pdf viewer c# : Add photo to pdf reader Library software class asp.net windows azure ajax OReilly_-_POSIX_Programmers_Guide7-part1995

Before Standard C, there were several solutions that have various problems. None of the
solutions is very good. Some of the possibilities are:
1.
Avoid the problem. Use 
sprintf()
to format a string and pass the string to the function.
2.
Pick some maximum number of parameters and write the function like this:
errmsg(fmt, al, a2, a3, a4, a5) 
char *fmt; 
int al, a2, a3, a4, a5; 
}
printf(fmt,a1,a2,a3,a4,a5); 
fprintf (log,fmt, al, a2, a3, a4, a5); 
return; 
If 
errmsg()
is called with fewer than five arguments, this will work and is fairly
portable. It will not work if the caller needs to write more than five values.
* The command "!a%888888f will crash many versions of csh when it tries to print out an error
message.
P
age 44
We also have a problem with some modem compilers. They will optimize the generated
code for the number of parameters expected. If we write:
errmsg("hello, world\n");
it might not work because 
a1
to 
a5
are missing.
3.
We can look at the 
FILE
structure and copy the data to another file. This is not portable.
As an example of non-portable programming, look at this program fragment that runs under
4.2BSD on a VAX:
#include <stdio.h> 
. . .
FILE   fake; 
char   buffer[132]; 
. . .
fake.flag = _IOWRT + _IOSTRG; 
fake.ptr = buffer; 
fake.cnt = 32767; 
_doprnt(format, & args,&fake); 
This code knows the internals of the 
printf()
function. It creates a 
struct FILE
and
fills it in. It also calls the documented, but highly non-portable, BSD 
_doprnt()
function.
Standard C solves this problem with three new functions: the functions 
vfprintf()
,
vprintf()
, and 
vsprintf()
are identical to 
fprintf(), printf()
, and
sprintf()
except that they use a pointer to an argument list. This is best seen with an
example:
#include <stdarg.h> 
Add photo to pdf reader - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add photo pdf; add photo to pdf form
Add photo to pdf reader - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
how to add an image to a pdf file; add picture to pdf reader
#include <stdio.h> 
/* 
* Write a message to stderr and to a log file 
*/ 
void errmsg(char *fmt, ...) 
va_list     ap; 
va_start(ap, fmt);    
/* Set ap to point to 
* the argument list. 
*/ 
vfprintf(stderr, fmt, ap); /* Write the message to 
* stderr. 
*/ 
va_end(ap);                /* Done */ 
/* Now, do the same thing except write the message 
* to logfile. 
*/ 
va_start(ap, fmt); 
vfprint
f(logfile, fmt, ap); 
va_end(ap); 
return;                    /* All done. */ 
}            
P
age 45
This code declares a function called 
errmsg()
with a variable number of arguments. The
vfprintf()
function works just like 
printf()
except it writes its data to both 
stderr
and 
logfile
instead of stdout. The call to 
va_start()
sets 
ap
to point to all of th
e
arguments that follow 
fmt
. The 
vfprintf()
function then takes 
fmt
and the variable
number of arguments that follow it and prints them.
This gives you a portable solution to a common problem. It lets you write functions that are
called the same way 
printf()
is called but do something extra.
Character Output Functions
In addition to the powerful 
fprintf()
function, there are five lighter-duty character output
functions.
The fputs() and puts() Functi
o
ns
fputs(str,stream);
does exactly the same thing as:
fprintf(stream,"%s",str);
That is, writes the string pointed to by the pointer 
str
into the output stream.
The function 
puts(str)
writes 
str
followed by a newline to the standard output stream
and is the same as 
fprintf(stdout, "%s\n", str)
.
VB.NET Image: Mark Photo, Image & Document with Polygon Annotation
What's more, if coupled with .NET PDF document imaging add-on, the VB.NET annotator SDK can easily generate polygon annotation on PDF file without using
add image to pdf form; add an image to a pdf
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
VB.NET image cropper control SDK; VB.NET image cropping method to crop picture / photo; you can adjust the size of created cropped image file, add antique effect
add image to pdf online; add picture to pdf online
These functions are extremely portable.
The fputc(), putc(), and putchar() Funct
ions
The 
fputc()
function writes a single character to a stream. The 
putchar()
function
writes a character to the standard output file. Thus, 
putchar(ch)
is the same as
fputc(ch,stdout)
.
The function 
putc()
is the same as 
fputc()
. In some systems, 
putc()
is a macro while
fputc()
is a real function. The macro may evaluate its arguments several times. This means
that 
putc(i,file++)
may not work as desired.
If you avoid cases like 
putc(i,file++)
, these functions are also extremely portable.
Reading Lines of Input
Here 
fscanf()
reads input from 
stream
and analyzes it according to 
format
using
subsequent arguments as pointers to objects to receive the converted input. The 
fscanf()
function is very similar to 
fprintf()
, however, not nearly as widely used.
P
age 46
Like 
printf()
, some directives are more portable than others. Here is the list defined by
Standard C:
Directive
Meaning
%c
Reads a byte—argument should be 
char *
.
%d
Reads a sequence of decimal digits—argument should be 
int *
.
%e
Reads a floating point number—argument should be 
float *.
%f
Same as 
%e
.
%g
Same as 
%e
.
%i
Reads a sequence of decimal digits—ar
gument should be 
int *
.
%n
Store the number of characters read so far into the argument. The argument should be 
int
*
. This does not read anything from the input stream.
%o
Reads a sequence of octal digits—argument should be 
unsigned 
int *
.
%p
Reads a poin
ter—argument should be 
void *
.
%s
Reads a string of non-white-space characters—argument should be a 
char *
.
%u
Reads a sequence of decimal digits—argument should be unsigned 
int *
.
%x
Reads a sequence of hex digits—argument should be unsigned 
int *
.
[
Read
s a set of expected characters—argument should be 
char *
.
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
To help you know more about this VB.NET image scaling control add-on, we scaling control SDK API, developer can only scale one image / picture / photo at a
add image to pdf file acrobat; how to add an image to a pdf in reader
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
VB.NET Image & Photo Resizing Overview. The practical this VB.NET image resizer control add-on, can powerful & profession imaging controls, PDF document, image
adding images to pdf; pdf insert image
%
Matches a single 
%
.
The 
[,%c,%d,%o,%s
, and 
%x
, directives work everywhere. The 
%e
and 
%f
work on all
systems that support floating point. The %g directive is not supported on BSD.
The 
%i,%n
and 
%p
directives are new to Standard C. They will work on all systems
supporting the standard, but not on many older systems.
The full details for format directives are given in the Functions Section under 
scanf()
.
P
age 47
Pitfalls
There are a few things to be careful about when you use 
fscanf()
. The important ones are:
·
A size should always be given on the 
%s
specifier. If there is no size specified, bad input
could overflow available storage and destroy data. The size should include the 
NULL
,
which is stored automatically.
*
·
The popular pattern of 
"[A-Za-z]"
will match a string of letters on many systems but is
not provided on all systems. Even on systems where it is supported, it may fail on strings
like 
"ÅLBË"
.
Additional Pitfall
·
Remember that 
scanf()
stores values into locations specified by 
pointers. 
To place a
value into the variable 
var
, use 
&var
in the 
scanf()
call. Forgetting the & is a common
mistake that can be very difficult to find.
Other Character Input Functions
There are a few input functions which are less complex than 
fscanf()
. In many cases, these
functions give better control than 
fscanf()
.
The fgetc(), getc() and getchar() Functio
n
s
The call 
fgetc(stream)
returns the next character from 
stream
. If 
stream
is at
end-of-file, 
EOF
is returned.
The 
getc()
function is the same as 
fgetc()
except it may be implemented as a macro.
The 
getchar()
function returns the next character from 
stdin
. It requires no arguments.
These functions are very portable. There is only one pitfall: the data must be read into a
variable of type 
int
and not of type 
char
EOF
is not a 
char
value.
* Unchecked 
fscanf()
and 
gets()
calls have been exploited to break computer security. For
details read: D. Seeley, "A Tour of the Worm," Proc. of the 1989 Winter USENIX Technical
Conference, pp. 287-304 (January 1989).
C# Image: How to Add Antique & Vintage Effect to Image, Photo
this C#.NET antique effect creating control add-on is widely used in modern photo editors, which powerful & profession imaging controls, PDF document, tiff
add image to pdf preview; add image pdf
VB.NET Image: How to Save Image & Print Image Using VB.NET
NET programmers save & print image / photo / picture from NET method and demo code to add image printing printing multi-page document files, like PDF and Word
add a picture to a pdf document; add picture to pdf in preview
P
age 48
The fgets() Function
The call:
char *fgets(char *s, int n, FILE *stream);
reads up to 
n-1
characters from 
stream
into the array pointed to by 
s
. A null character is
written immediately after the last byte. Reading stops when a newline or end-of-file is
encountered. If reading stops because a newline character is read, the newlin
e is stored in the
array.
This call is very portable.
The gets() Function
The call:
char *gets(char *s);
reads characters from 
stdin
into the array pointed to by 
s
.
Unlike 
fgets()
, the 
gets()
function does no limit checking. If the input line is too long for
the buffer pointed to by 
s
, the results may be disastrous and are certainly not portable. For this
reason, do not use 
gets()
. The 
scanf()
function may be used ins
tead, as in:
char  inbuf[82]; 
int status; 
status = scanf("%82s",inbuf); 
/* Check status for EOF */ 
/* If (strlen(inbuf) == 81) the input line may 
* have been truncated. 
*/ 
The POSIX.2 standard (Shell and Utilities) allows for lines of 2048 bytes. You should be aware
that such long lines may exist.
The ungetc() Function
The call:
int ungetc(int c, FILE *stream);
pushes one character back onto stream. The pushed back characters will be returned by
subsequent reads on that stream in the reverse order of their pushing.
Unfortunately, the maximum number of characters we can push back portably is one.
The
ungetc()
function returns 
c
on success and 
EOF
on failure.
VB.NET Image: Tutorial for Flipping Image Using Our .NET Image SDK
version of .NET imaging SDK and add the following becomes a mirror reflection of the photo on the powerful & profession imaging controls, PDF document, tiff
add image to pdf java; adding an image to a pdf form
C# PDF remove image library: remove, delete images from PDF in C#.
Support removing vector image, graphic picture, digital photo, scanned signature, logo, etc. Remove Image from PDF Page Using C#. Add necessary references:
adding image to pdf file; add picture pdf
P
age 49
Opening and Closing Files
We have been looking at using the files that the system already opened for us. Almost all
interesting programs need to use other files. The 
fopen()
function is used to connect a file
with a stream:
FILE *fopen(const char *path, const char *mode);
The  argument 
path
points to the file we want to open. For example,
"
/usr/don/book/ch3
" is the name of the file with this text in it. The next several chapters
discuss portable pathnames and files in greater detail.
The argument mode points to a string beginning with one of the following:
r
Open file for reading.
w
Create new file for writing. If a file with this name already exists, its contents are lost.
a
Append to existing file or create file if it does not exist.
r+
Open file for update (reading and writing). All existing data is prese
rved.
w+
Open new file for update (reading and writing). If the file already exists, it is truncated to
zero length.
a+
Open or create text file for update. If the file already exists, the first write will add new data
after the current end-of-file.
Some systems make a distinction between text files and binary files. While there is no such
distinction in POSIX, a 
'b'
may be appended to the mode string to indicate binary. The 
b
does not do anything but may be useful for compatibility with non-POSIX sys
tems. If you are
creating a binary file, include the 
b
to make your program more portable. Most systems that do
not support the 
b
option will just ignore it.
Upon success, the 
fopen()
function returns a pointer to a file descriptor. This pointer is used
only as an argument to other functions. Do not attempt to manipulate the object it points at. If the
open fails, 
fopen()
returns a null pointer.
When you are finished with a file, you should close it. The call 
fclose(stream)
will
complete any pending processing, release system resources, and end access to the file. If there
are no errors, 
fclose()
returns zero. It returns 
EOF
if any errors are dete
cted.
If you fail to close a file, it will be closed automatically when your program completes. There
are four reasons for closing the file explicitly:
1.
If there is other processing to be done, you will free up system resources and are less likely
to hit some implementation limit.
2.
Buffers are written out in a timely fashion.
P
age 50
3.
Closing the file yourself lets you check for errors. It is good practice to report any errors
that take place.
4.
If your program ends with a call to 
_exit()
, buffers may not be written out.
Direct Input/Output functions
The fwrite() and fread() Function
s
Often, you do not need to format your data for human consumption; you need only to save some
information in a file and get it back later. The 
fwrite()
function lets you dump data
structures to a file, and the 
fread()
function lets you get them back. The de
finition of
fwrite()
is:
size_t fwrite(const void *ptr, 
size_t size, 
size_t nmemb, 
FILE *stream); 
This is not as complex as it looks. The 
fwrite()
function writes, from the array pointed to
by 
ptr
, up to 
nmemb
elements whose size is specified by 
size
, to the stream pointed to by
stream
. It returns the number of elements written. This will equal 
nmemb
u
nless a write
error occurs.
For example:
fwrite(tbl,sizeof(int),(size_t)100,outfile);
will write 100 
int
elements from the array 
tbl 
into 
outfile
.
To get the data back, we use the 
fread()
function. The arguments to 
fread()
are exactly
the same as 
fwrite()
. The only difference is the direction of transfer.
Programs that use 
fwrite()
and 
fread()
can be completely portable. The data that is
written will not always be portable.
In some systems, 
fread()
and 
fwrite()
are very fast. On others, these functions result in
repeated calls to 
getc()
and 
putc()
; in this case 
printf()
is faster that 
fwrite()
. In
general, use 
fread()/fwrite()
for binary files and 
printf()
fputs()
, and
fgets
()
for text. This will give you maximum performance and program portability.
File Positioning Functions
So far, we have done all our reading and writing in order. Often, you need to select the place
where you are going to read or write. There are several functions that let you select your
position.
P
age 51
The fgetpos() and fsetpos() Functions
The call:
int fgetpos(FILE *stream, fpos_t *pos);
stores the current file position of 
stream
in the variable pointed to by 
pos
. The value stored
is used only by 
fsetpos()
. Your program should respect its privacy.
The 
fsetpos()
function has the same arguments as 
fgetpos()
and is used to restore the
file position. This function was introduced by Standard C and is not available on older
systems.
The ftell() and fseek() Funct
i
o
n
The function 
ftell(stream)
returns a 
long int
which is the number of characters from
the beginning of the file. In case of error, it returns 
-1L
.
int fseek(FILE *stream, long off, int whence);
The previous example sets the position of the file 
stream
. The new position is determined by
adding 
offset
to the position specified by 
whence
. The values for 
whence
are:
SEEK_SET
Indicates the beginning of the file. This can be used with the value returned by
ftell()
to restore a remembered position.
SEEK_END
Indicates the end of the file.
SEEK_CUR
Indicates the current position.
The 
fseek()
function returns nonzero if a request cannot be satisfied.
At this point you may be wondering why we have both the 
fgetpos/fsetpos
pair and the
ftell/fseek
pair. Can't we do everything we need with 
ftell/fseek
?
The answer is yes; however, 
fgetpos/fsetpos
have two potential advantages:
1.
Possibility of higher performance on some systems.
2.
Ability to support files that have more than 
LONG_MAX
bytes.
If there is no need to do anything other than remember a saved file position,
fgetpos/fsetpos
are a good bet.
The rewind() Function
The function rewind( stream) is the same as:
(void)fseek(stream, 0L, SEEK_SET);
except the error indication for the stream is cleared and no errors are reported.
P
age 52
Managing Buffers
If each call to 
fgetc()
were required to read a byte off the disk, programs would run very
slowly. Disks are mechanical devices and may take 100,000 times longer to access than main
memory. To avoid this penalty, data is transferred from disk to main memor
y in large hunks.
These hunks of data are stored in areas of memory called buffers and functions like 
fgetc()
and 
fscanf()
get their data from the buffer, accessing the disk only when the buffer is empty.
Functions like 
fputc()
and 
fprintf()
perform an analogous operation on output.
While the system's defaults for buffering usually work well, the 
setvbuf()
function is
provided to give the programmer some control over buffering.
The call to 
setvbuf()
must be made after the file is opened and before any other operation
is performed. The definition of 
setvbuf()
is:
int setvbuf(FILE *stream, char *buf, int mode, 
sizet size); 
stream
Identifies the I/O stream.
buf
Is a pointer to an array to be used as a buffer. If 
buf
is the null pointer, 
setvbuf()
will
allocate a buffer.
mode
Must be one of the following macros:
_IOFBF
Causes input/output to be fully buffered. Data will be tr
ansmitted only
when a buffer is full.
_IOLBF
Causes input/output to be line-buffered. Data will be transferred when a
newline character is encountered. This is useful for I/O to terminals.
_IONBF
Causes input/output to be unbuffered. This is useful for t
erminal and other
communications devices where we want something to happen on character
sequences that are shorter than a full line.
size
Is the size of the buffer.
The 
setvbuf()
function advises the system of your program's needs, but does not obligate
the system.
The function 
setbuf(FILE *stream, char *buf)
is equivalent to
(void)setvbuf(stream,buf,_IOFBF,BUFSIZ)
. The 
setbuf()
call is new with
Standard C. Of course, the most portable thing to do is to stick to the default buffering provided
by the system.
The function 
fflush(FILE *stream)
causes any buffered output data for 
stream
to be
written. The call 
fflush(NULL)
causes this action for all open streams.
P
age 53
Sample Program
We will now write a complete example. While the example we have chosen might seem a bit
simple-minded, the idea is to show off some of the input/output functions and the logistics of
building an application without getting bogged down in complex computatio
n. Here is a brief
specification for our program:
3.
Accept a filename for an output file from the user.
4.
Accept two integers from the user: a lower limit and an upper limit.
5.
For each integer between the lower limit and the upper limit, write the integer and its
square root to the output file. The output should be nicely formatted text.
The first design question is: How am I going to split the program into reusable modules? One
model that many programs can follow is three modules: one module accepts the input, another
that does the work, and a third that creates the output.
The basic design becomes:
1.
A module to ask the user for a filename as well as a starting and an ending value. These
tasks can be performed in 
main()
.
2.
A module, 
compute_square_root
,
*
to calculate the square roots.
3.
A module, 
format_output
, to take the square roots and print them.
Now that we know what the program should do, we can consider how to make portability an
element of its basic design. We begin by listing those tasks that require our program to depend
upon services provided by the system libraries. Here's a sequential list
of those tasks:
**
1.
Prompt the user for a filename.
2.
Accept the filename from the user.
* I have a strong preference for descriptive function names. I find the name
compute_square_root
much nicer than say 
csqrt
for instance. On some systems, longer
names may produce a portability problem. The linker may support only six-character external nam
es.
Instead of making my code more obscure for all machines in order to support a brain-damaged linker,
I use #define to work around the problem. In this case, I need an include file which contains:
#define compute_square_root  CS01
#define format_output        FO01
to map my names into something short and portable. This makes debugging harder, so I do my
development on a more friendly system.
** Some of the services are provided by the Standard C library, some by the math library, some by the
POSIX library, and some by the kernel of the operating system. From a programmer's point of view,
there is no need to make a distinction among the various
providers of a service. Application modules
are written by the programmer and everything else is provided by the system. The C and POSIX
standards call the part not provided by the programmer the implementation.
P
age 54
Documents you may be interested
Documents you may be interested