pdf viewer c# : Add an image to a pdf form application Library tool html asp.net winforms online OReilly_-_POSIX_Programmers_Guide11-part1944

the high-level routines in the application.
There are times when you do need to use the primitive routines in your applications: they often
provide functions that are not available in the C library as well as more precise control over
the behavior of your program.
CAUTION
Since many of the systems you will use have the traditional layering of library functions and
system calls, mixing high-level functions (
fprintf(),fgets(),fputs()
, etc.) and the
low-level functions (
read()
,
write(),lseek()
, etc.) requires care. The section 
called
"Mixing the Levels" later in this chapter talks about the rules for mixing low- and high-level
functions.
Primitive File Operations
The primitive (or low-level) file operations can be thought of as the building blocks for more
complex functions, such as 
fprintf()
and 
fscanf()
.
P
age 87
File Descriptors
The primitive file operations all operate 
on file descriptors. 
A file descriptor is a small,
non-negative integer used to identify an open file. File descriptors are assigned in order (0, 1,
2, 3, ...) on a per-process basis. The number of open file descri
ptors is limited; however, the
limit is 16 or larger. The exact number is given by the symbol 
OPEN_MAX
in the header file
<limits.h>
.
Opening afile
The connection between a file descriptor and a file is established by the 
open()
and
creat()
functions. The 
open()
function is used to assign a file descriptor for a new or
existing file. The function is defined as:
int open(const char *path, int oflag, ...);
The 
...
indicates an unspecified number of additional arguments. It allows for an optional
third argument, a 
mode_t
called 
mode
that can be used to set the file permission bits when a
file is created.
The 
path
argument is a string that names the file to be opened. It can be either an absolute
path (starting with a /) or a relative path.
The 
oflag
argument is the bitwise inclusive OR of the values of symbolic constants. The
programmer must specify exactly one of the following three symbols:
O_RDONLY
Open for reading only.
O_WRONLY
Open for writing only.
O_RDWR
Open for reading and writing.
Add an image to a pdf form - 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
adding images to pdf files; how to add image to pdf acrobat
Add an image to a pdf form - 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; add image to pdf in preview
Any combination of the following symbols can also be used:
O_APPEND
Set the file offset to the end-of-file prior to each write.
O_CREAT
If the file does not exist, allow it to be created. This flag indicates that the mode
argument is present in the call to 
open()
.
O_EXCL
This flag may be used only if 
O_CREAT
is al
so set. It causes the call to 
open()
to fail if the file already exists.
O_NOCTTY
If 
path
identifies a terminal, this flag prevents that terminal from becoming the
controlling terminal for this process. It prevents an application from
unintentionally acqui
ring a controlling terminal as a side-effect of 
open()
. It is
always safe to set this flag for data files. 
O_NOCTTY
has no effect if the file
being opened is not a terminal. See Chapter 8 for a description of terminal I/O.
P
age 88
O_NONBLOCK
Do not wait for the device or file to be ready or available. After the file is open,
the 
read()
and 
write()
calls always return immediately. If the process
would be delayed in the read or write operation, 
-1
is returned and 
errno
is
set to 
EAGAI
N
instead of blocking the caller.
System V provides a flag called 
O_NDELAY
that is similar to 
O
_
NONBLOCK
The 
O
_
NDELAY
flag causes 
read()
or 
write()
to return zero instead of
blocking. Since 
read()
also returns zero on end-of-file, it is difficult to
dist
inguish the two cases. BSD also has an 
O
_
NDELAY
flag that causes the error
EWOULDBLOCK
to be returned if the process would block. POSIX resolved this
incompat ibility by inventing the 
O
_
NONBLOCK
flag. Port with care!
O_TRUNC
This flag should be used only o
n ordinary files opened for writing. It causes the
file to be truncated to zero length.
Traditional UNIX systems used the values 0, 1, and 2 for 
O_RDONLY,O_WRONLY
, and
O_RDWR
. These values should be changed to macros. To allow your code to continue to work
on old systems, include the following:
#ifndef 0_RDONLY 
#define O_RDONLY 0 
#endif 
#ifndef 0_WRONLY 
#define 0_WRONLY 1 
#endif 
#ifndef 0_RDWR 
#define O_RDWR   2 
#endif 
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Scan image to PDF, tiff and various image formats. Get image information, such as its location, zonal information Able to edit, add, delete, move, and output PDF
adding an image to a pdf file; adding images to a pdf document
C# PDF Form Data Read Library: extract form data from PDF in C#.
featured PDF software, it should have functions for processing text, image as well can help you have a quick evaluation of our PDF SDK. Add necessary references
adding image to pdf in preview; add image to pdf acrobat reader
The call:
creat(path,mode);
is equivalent to:
open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
and has the same portability issues.
P
age 89
Reading from a File
The only low-level function for reading from a file is the 
read()
function. It is defined as:
*
ssize_t read(int fildes, void *buf, size_t nbyte);
and reads 
nbyte
bytes from the file open on 
fildes
into buffer 
buf
. The 
read()
function
returns the number of bytes placed in the buffer. This value will never be greater than 
nbyte
.
The value will be smaller than 
nbyte
if the file has fewer bytes immediat
ely available for
reading. If there is an error, a value of 
-1
is returned and 
errno
is set.
That seems easy enough. What portability problems can it have? Here are a few:
·
The standard does not specify exactly what happens on an error. It is almost impossible to
do portable error recovery if 
read()
returns 
EIO
.
·
Section 6.4.1.2 of POSIX states, "If a 
read()
is interrupted by a signal after it has
successfully read some data, either it shall return 
-1
with 
errno
set to 
EINTR
, or it shall
return the number of bytes read." Therefore, applications must treat 
EINTR
a
s a fatal error
because they cannot tell if any data were lost.
The U.S. Government (in FIPS 151-1) requires that 
read()
return the number of bytes
read. Since the Federal Government is the world's largest buyer of POSIX systems, it is a
good bet that most POSIX systems will return the number of bytes read.
·
The 
nbyte
argument has type 
size_t
in IEEE Std 1003.1-1990, but has type
unsigned int
in the 1988 standard and in most UNIX systems. It was changed because
the largest block that can be read in a single call is 
UINT_MAX
bytes (65,535 on 16-bit
systems). 
Programs that need to operate using both the 1988 and 1990 standard should limit
reads to 65,535 or fewer bytes.
Writing to a File
The 
write()
function writes to a file. This is defined as:
ssize_t write(int fildes, const void *buf, size_t nbyte);
and attempts to write 
nbyte
bytes from the buffer pointed to by 
buf
to the file open on
fildes
. The 
write()
function returns the number of bytes written to the file. This may be
less than 
nbyte
if an error occurred during the write operation. If an error
VB.NET PDF Form Data Read library: extract form data from PDF in
featured PDF software, it should have functions for processing text, image as well can help you have a quick evaluation of our PDF SDK. Add necessary references
add a jpg to a pdf; add image pdf acrobat
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
multiple types of image from PDF file in VB.NET, like XObject Image, XObject Form, Inline Image DLLs for PDF Image Extraction in VB.NET. Add necessary references
add image to pdf java; adding a jpeg to a pdf
* The definition of 
read()
uses two POSIX types: 
ssize_t
and 
size_t
. There are 
typdefs
for
these in 
<sys/types.h>
. A 
size_t 
is a type that can hold a number of bytes, for example,
unsigned long
. A 
ssize_t
is a signed 
size_t
and is used because 
read()
retur
ns 
-1
if there
is an error. Unfortunately, this is one of the conflicts between IEEE Std 1003.1-1990 and IEEE Std
1003.1-1988. The 1988 standard defines read( ) as:
int read(int fildes, char *buf, unsigned int nbyte);
P
age 90
condition prevented any bytes from being written, 
-1
is returned and 
errno
is set to indicate
the error.
The 
write()
function has the same portability issues as 
read()
Fast File Copy Example
At this point, it is helpful to look at a simple example showing the use of 
read()
and
write()
. The following simple file copy program asks for an input path and an output path
and then copies the input to the output. We assume that both input and output f
iles are ordinary
files. To make our copy program fast, the file is read in one large hunk and then written out.
The program that fills the bill is shown in Example 5-1.
EXAMPLE 5-1 
ffcopy.c
#define _POSIX_SOURCE 1 
#include <unistd.h> 
#include <stdio.h> 
#include <limits.h> 
#include <sys/types.h> 
#include <stdlib.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include "panic.h'             /* Defines the PANIC macro */ 
#de
fine HUNK_MAX INT_MAX 
#define MAX_PATH 2048          /* It would be nice if POSIX 
* provided some way to determine 
* the longest path name a user 
* may need
to type. Since there 
* is no way to get that number, 
* I am picking something large. 
*/ 
int main() 
char ifpat
h[MAX_PATH+1];       /* name of input file */ 
char ofpath[MAX_PATH+1];       /* name of output file */ 
char scanf_string[10];         /* argument string for 
scanf() */ 
struct stat ifstat;            /* result of stat(
) call */ 
char *bigbuf;                  /* pointer to buffer */ 
int ifdes,ofdes;               /* input/output file 
VB.NET PDF Password Library: add, remove, edit PDF file password
passwordSetting.IsAnnot = True ' Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = True ' Add password to PDF file. PDFDocument
how to add image to pdf reader; add photo to pdf for
C# PDF Password Library: add, remove, edit PDF file password in C#
passwordSetting.IsAnnot = true; // Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = true; // Add password to PDF file. PDFDocument
add photo to pdf preview; how to add photo to pdf in preview
descriptors */ 
size_t hunk;                   /* number of bytes to 
transfer in one piece */ 
size_t left;                   /* number of bytes left to 
transfer */ 
/* Build the string "%2048s" */ 
(void)sprintf(scanf_string,"%%%ds
",MAX_PATH); 
/* Get the input path */ 
(void)printf("Input file: "); 
if (scanf(scanf_string,ifpath)  != 1) PANIC; 
/* See if the file exists and how big it is */ 
P
age 91
if (stat(ifpath,&ifstat)  != 0) 
{
(void)perror("? Can not stat file"); 
exit(EXIT_FAILURE); 
left = hunk = ifstat.stsize; /* left is the amount left 
* to copy.  Start
it out 
* with the size of the 
* whole file. 
*/ 
if (hunk > HUNK_MAX) hunk = HUNK_MAX; 
/* Get a buffer for the whole file (or 1 hunk if t
he file 
* is too big. 
*/ 
if((bigbuf = (char *)malloc(hunk)) == NULL) 
(void)fprintf(stderr, 
"? File is too big for fast copy\n"); 
exit(EXITFAILURE); 
/* Open the input 
file */ 
if ((ifdes = open(ifpath,O_RDONLY)) == -1) PANIC; 
/* Now that we have the input file open, ask for the 
* path for the output file 
*/ 
(void)printf("Output file: "); 
if (scanf(scanf_string,ofpath) != 1) PANIC; 
/* Open the output file */ 
if ((ofdes = open(ofpath,O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR)) 
== -1) PANIC; 
while (left > 0) 
/* Read the file in one big bite */ 
if (read(ifdes,bigbuf,hunk) != 
hunk) 
(void)fprintf(stderr, 
"? Error reading file %s\n",ifpath); 
exit(EXIT_FAILURE); 
/* Write out the copy */ 
if(write(ofdes,bigbuf,hunk) != hunk
C# Create PDF from images Library to convert Jpeg, png images to
List<Bitmap> images = new List<Bitmap>(); images.Add(new Bitmap(Program.RootPath + "\\" 1.gif")); / Build a PDF document with GIF image.
add image field to pdf form; add image to pdf form
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
C#.NET PDF SDK - Add Sticky Note to PDF Page in C#.NET. Able to add notes to PDF using C# source code in Visual Studio .NET framework.
add picture to pdf form; add picture to pdf document
(void)fprintf(stderr, " Error writing file %s\n",ofpath); 
exit(EXIT_FAILURE); 
left -= hunk; 
if (left < hunk) hunk = left; 
/* Close the files */ 
if (close(ifdes) != 0) PANIC; 
if (close(ofdes) != 0) PANIC; 
/* Print out a status message */ 
(void)printf("%s copied to %s (%d bytes)\n", 
ifpath,ofpath,ifstat.st_size); 
return(0); 
There is an interesting portability sidelight here. On systems where an 
int
is 32-bits, the file
will be copied using a single call to 
read()
and a single call to 
write()
. It is
P
age 92
possible that a system has a 16-bit int and a 32-bit 
st_size
. The 
read()
and 
write()
functions use a 
size_t
*
for the number of bytes to transfer. It is possible that there are
systems that cannot read a large file with a single 
read()
call. On these system
s, large files
are broken up into multiple hunks.
Control Operations on a File
One of the reasons for using the low-level I/O functions is to get better control. The file control
function 
fcntl()
is a multi-purpose function that performs various operations on open file
descriptors. The definition is:
int fcntl(int fildes, int cmd, ...);
The exact arguments depend on the command, 
cmd
, given. The commands are:
cmd
Value
Description
F_DUPFD
Duplicate a file descriptor.
F_GETFD
Get file descriptor flags.
F_GETLK
Get record locking information.
F_SETFD
Set file descriptor flags.
F_GETFL
Get file status flags.
F_SETFL
Set file status flags.
F_SETLK
Set record lockin
g information.
F_SETLKW
Set record locking information; wait if blocked.
F_GETFD/F_SETFD
Every file descriptor has a close-on-exec flag. In the default case, the 
fork()
and 
exec()
**
function calls allow one process to inherit the open files from the parent process that created it.
That is how the shell passes 
stdin, stdout
, and 
stderr
to progr
ams it runs.
Sometimes you do not want to pass an open file. If the file is not useful to the new program, it
not only uses up valuable open file slots, but also allows the child to interfere with the parent.
One way to prevent this is to set the close-on-exec flag for
a file descriptor. The 
exec()
function will close that descriptor prior to starting the new program.
* The 1990 revision of 1003.1 quietly changed the type of this argument from 
unsigned int
to
size_t
** These are described in detail in the next chapter.
P
age 93
There may be 
fcntl()
flags that are specific to a system but are not defined by POSIX. If we
want our code to be portable, we need to preserve those implementation-defined bits. You
set/unset only what you want and avoid the rest. The sequence:
flags = fcntl(fildes,F_GETFD); 
fcntl(fildes,F_SETFD,flags | FD_CLOEXEC); 
will set the close-on-exec bit. The sequence:
flags = fcntl(fildes,F_GETFD); 
fcntl(fildes,F_SETFD,flags & -FD_CLOEXEC); 
will clear the close-on-exec bit. All other bits are preserved.
F_GETFL/F_SETFL
Two of the flags that can be set in the 
open()
call may be modified by the 
fcntl()
function. The 
O_APPEND
and 
O_NONBLOCK
flags may be changed while the file is open. The
most portable way to modify them is first to read the flags with:
flags = fcntl(fildes,F_GETFD);
Then set any desired bits with a statement such as:
flags |= O_NONBLOCK;
Next, clear any flags no longer desired:
flags &= -(O_APPEND);
Finally, reset the flags with:
fcntl(fildes,F_SETFD,flags);
This preserves any implementation-defined flags. The normal open flags, such as 
O_CREAT
,
are also preserved by this technique. The POSIX standard does not specify what happens if you
attempt to modify these flags with 
fcntl()
, and it is best not to try it.
You may wonder why POSIX defines both 
F_SETFD
and 
F_SETFL
. Can't we get away with
only one? Well, 
F_SETFD
applies only to a single file descriptor. 
F_SETFL
applies to all
file descriptors that share a common open file description, either by inheritance thr
ough
fork()
or as the result of an 
F_DUPFD
operation with 
fcntl()
; for example:
fd1 = open(path,oflags); 
fd2 = dup(fdl); 
fd3 = open(path,oflags); 
An 
F_SETFD
on 
fd1
applies only to 
fd1
. An 
F_SETFL
on 
fd1
applies to 
fd1
and 
fd2
but not to 
fd3
.
P
age 94
F_SETLK/F_SETLKW/FGETLK
POSIX supports a form of interprocess communication called "advisory record locking." This
feature is found in POSIX and System V Release 3 and later, but not in BSD. Record locking
lets one process indicate its intent to read or write part of a file. Othe
r processes may observe
these intents. This is called advisory locking because the system does not supervise programs
that read or write locked files. The scheme depends on the good will and proper coding of
each application program.
Record locking is controlled by the 
flock
structure. The flock structure contains the
following members:
Member
Type
Member
Type
Description
short
l_type
One of the symbolic constants:
F_RDLCK
: to indicate a read (shared) lock
F_WRLCK
: to indicate a write (exclusive) lock
F
_
UNLCK
: to remove a lock
short
l_whence
One of the symbolic constants: 
SEEK
_
SET
SEEK
_
CUR
, or 
SEEK
_
END
to indicate that 
l_start
is measured from the start of the file, the current
position, or the end of the file.
off_t
l_start
Relative offset in bytes.
off_t
l_len
The number of bytes to lock. This value should not be negative. If it is
zer
o, it indicates "until EOF."
pid_t
l_pid
Process ID of the process holding the lock; used only by the 
F_GETLK
function.
The 
F_SETLKW
function sets and clears locks for a record. A call looks like:
fcntl(fildes,F_SETLKW,flock_ptr);
where 
fildes
is the file to lock and 
flock_ptr
points to a 
struct flock
. This call
can establish or remove shared or exclusive locks. If the lock is not available, the 
F_SETLKW
call will wait for some other process to unlock the lock.
The 
F_SETLK
call is identical to the 
F_SETLKW
call except when the lock is not available.
Instead of waiting, 
F_SETLK
returns 
-1
and sets 
errno
to 
EAGAIN
.
The 
F_GETLK
function is called with:
fcntl(fildes,F_GETLKW,flock_ptr);
and searches for a lock that would block the one in the 
struct flock
pointed to by
flock_ptr
. If no lock is found that would prevent this lock from being created, the lock type
is set to 
F_UNLCK
. Otherwise, the structure is overwritten with lock informatio
n for an
arbitrarily chosen lock.
P
age 95
You can build a simple semaphore system using advisory record locking. A file can be used as
an array of locks. You do not need to read or write the file to use record locking.
F_DUPFD
The final use for 
fcntl()
is to duplicate an open file descriptor. The call:
fcntl(fildes,F_DUPFD,minfd)
returns a new file descriptor which is associated with the same open file as 
fildes
and is
greater than or equal to 
minfd
. If 
minfd
is unused then that is the file descriptor that will be
used. Otherwise, the lowest numbered unused file descriptor greater 
than 
minfd
is returned.
The new file descriptor shares any locks with the original file. The close-on-exec flag for the
new descriptor is clear.
Setting the File Position
I covered the 
fseek()
function in Chapter 3, 
Standard File and Terminal I/O. 
The
lseek()
function does exactly the same thing (sets the position of the file), except that it
operates on file descriptors instead of on streams. The function is defined as:
off_t lseek(int fildes, off_t offset, int whence);
The 
whence
argument is either:
Argument
Meaning
SEEK_SET
To set the file position to 
offset
.
SEEK_CUR
To set the file position to be the current position plus 
offset
.
SEEK_EOF
To set the file position to be the end-of-file plus 
offset
.
The file position may be set beyond the current end-of-file. If data is written at this point, the
gap is filled with zeros.
*
The 
lseek()
function returns the resulting offset measured as the number of bytes from the
beginning of the file. In case of error, it returns 
((off_t) -1)
and sets 
errno
to indicate
the error.
Seeking is portable only for disk files. The effect of 
lseek()
on pipes, FIFOs, terminals, and
other non-disk devices is undefined. In System V and BSD, an 
lseek()
on a device
incapable of seeking has no effect. You should not count on all systems providin
g such benign
results.
* The standard does not actually specify that zeros are written into the file, only that an attempt to
read the gap shall return zeros. It is possible to implement a system with ''sparse'' files where no disk
space is used for the holes.
P
age 96
In historical UNIX implementations, 
seek()
used an offset of type 
int
and 
lseek()
(which was added later) used an offset of type 
long
. Today, 
seek()
is obsolete. POSIX
defined the offset for 
lseek()
as an 
off_t
. All useful POSIX systems will define 
off_t
a
s a long or larger. You can safely assume that 
lseek()
will work on  files of a billion bytes.
The dup() and dup2() Functions
The function 
dup(fildes)
is equivalent to:
fcntl(fildes,F_DUPFD,0)
and saves some typing.
The function 
dup2(fildes,fildes2)
is more or less equivalent to:
close(fildes2); 
fcntl(fildes, F_DUPFD, fildes2); 
but 
dup2()
is considered outdated and should not be used in new programs. Use the
close()/fcntl()
combination instead because it does a better job of error reporting.
Closing a File
When you are done with a file, the 
close()
function should be used to deallocate the file
descriptor and clean up the file. When our program terminates, all of the open files are closed.
There are still good reasons for explicitly calling 
close()
for each 
file:
·
Open files are a limited resource. It is a good idea to give them back as soon as possible.
·
It is always a good idea to check for errors. If you let 
exit()
close your open files,
errors will be ignored.
The 
close()
function is about as portable as you can get.
FIFOs and Pipes
Documents you may be interested
Documents you may be interested