display pdf in asp.net page : Rotate individual pages in pdf reader software application dll windows winforms azure web forms dmp15-part1822

F
i
xed-w
i
dth data
131
Mul
t
iple record 
t
ypes
One slight variation of the fixed-width data record has different sets of data fields for
different types of data within the same file. Consider a system that maintains a prod-
uct list and, at the end of each day, produces a file that lists all new products added
and old products deleted during the day. For a new product, you will need a lot of
data (perhaps product code, description, price, stock count and supplier identifier).
For the deleted product you only need the product code (but you might also list the
product description to make the report easier to follow). Each record will have some
kind of identifier and the start of the line denoting which kind of record it is. In our
example they will be the strings 
ADD
and 
DEL
. Here are some sample data:
ADD0101Super Widget
00999901000SUPP01
ADD0102Ultra Widget
01499900500SUPP01
DEL0050Basic Widget
DEL0051Cheap Widget
On the day covered by this data, we have added two new widgets to our product
catalogue. The Super Widget (product code 0101) costs $99.99 and we have 1000
in stock. The Ultra Widget (product code 0102) costs $149.99 and we have 500 in
stock. We purchase both new widgets from the same supplier. At the same time we
have discontinued two older products, the Basic Widget (Product Code 0050) and
the Cheap Widget (Product Code 0051).
Example
:
reading mul
t
iple fixed
-
wid
t
h record 
t
ypes
A program to read a file such as the previous example might look like this:
my %templates = (ADD => 'a4A14a6a5a6',
DEL => 'a4A14');
while (<STDIN>) {
my ($type, $data) = unpack('a3a*', $_);
my @rec = unpack($templates{$type}, $data);
print "$type - ", join('¦', @rec);
print "\n";
}
In this case we are storing the two possible templates in a hash and unpacking the
data in two stages. In the first stage we separate the record type from the main part
of the data. We then use the record type to choose the appropriate template to
unpack the rest of the data. One thing that we haven’t seen before is the use of 
*
as
a field length to mean “use all characters to the end of the string.” This is very use-
ful when we don’t know how long our string will be.
Rotate individual pages in pdf reader - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
pdf rotate pages and save; pdf page order reverse
Rotate individual pages in pdf reader - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
how to change page orientation in pdf document; rotate pdf pages individually
132
CHAPTER 
F
i
xed-w
i
dth and b
i
nary data
Da
t
a wi
t
h no end
-
of
-
record marker
Another difference that you may come across with fixed-width data is that some-
times it comes without a defined end-of-record marker. As both the size of each field
in a record and the number of fields in a record are well defined, we know how long
each record will be. It is, therefore, possible to send the data as a stream of bytes and
leave it up to the receiving program to split the data into individual records.
Perl, of course, has a number of ways to do this. You could read the whole file
into memory and split the data using 
substr
or 
unpack
, but for many tasks the
amount of data to process makes this unfeasible.
The most efficient way is to use a completely different method of reading your
data. In addition to the 
<FILE>
syntax that reads data from file handles one record
at a time, Perl supports a more traditional syntax using the 
read
and 
seek
func-
tions. The 
read
function takes three or four arguments. The first three are: a file
handle to read data from, a scalar variable to read the data into, and the maximum
number of bytes to read. The fourth, optional, argument is an offset into the vari-
able where you want to start writing the data (this is rarely used). 
read
returns the
number of bytes read (which can be less than the requested number if you are near
the end of a file) and zero when there is no more data to read. 
Each open file handle has a current position associated with it called a file pointer
and 
read
takes its data from the file pointer and moves the pointer to the end of the
data it has read. You can also reposition the file pointer explicitly using the 
seek
function. 
seek
takes three arguments: the file handle, the offset you wish to move
to, and a value that indicates how the offset should be interpreted. If this value is 
0
then the offset is calculated from the start of the file, if it is 
1
the offset is calculated
from the current position, and if it is 
2
the offset is calculated from the end of the
file. You can always find out the current position of the file pointer by using 
tell
,
which returns the offset from the start of the file in bytes. 
seek
and 
tell
are often
unnecessary when handling 
ASCII
fixed-width data files, as you usually just read the
file in sequential order.
Example
:
reading da
t
a wi
t
h no end
-
of
-
record markers using read
As an example, if our previous data file were written without newlines, we could use
code like this to read it (obviously we could use any of the previously discussed
techniques to split the record up once we have read it):
my $template = 'A5A20A8A6AA8';
my $data;
while (read STDIN, $data, 48) {
my @rec = unpack($template, $data);
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
doc.Save(outPutFilePath). How to VB.NET: Delete Consecutive Pages from PDF. doc.Save(outPutFilePath). How to VB.NET: Delete Specified Pages from PDF.
save pdf rotated pages; rotate pages in pdf and save
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Page: Insert PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Add and Insert Multiple PDF Pages to PDF Document Using VB.
pdf rotate page and save; how to reverse pages in pdf
F
i
xed-w
i
dth data
133
print join('¦', @rec);
print "\n";
}
Example
:
reading mul
t
iple record 
t
ypes wi
t
hou
t
end
-
of
-
record markers
It is also possible to handle variable length, fixed-width records using a method sim-
ilar to this. In this case we read 3 bytes first to get the record type and then use this
to decide how many more bytes to read on a further pass.
my %templates = (ADD => {len => 35,
tem => 'a4A14a6a5a6'},
DEL => {len => 18,
tem => 'a4A14'});
my $type;
while (read STDIN, $type, 3) {
read STDIN, $data, $templates{$type}->{len};
my @rec = unpack($templates{$type}->{tem}, $data);
print "$type - ", join('¦', @rec);
print "\n";
}
Defining record s
t
ruc
t
ure wi
t
hin 
t
he da
t
a file
I mentioned earlier that it is possible that the structure of the data could be defined
in the file. You could then write your script to be flexible enough that it handles
any changes in the structure (assuming that the definition of the structure remains
the same).
There are a number of ways to encode this metadata, most of them based around
putting the information in the first row of the file. In this case you would read the
first line separately and parse it to extract the data. You would then use this informa-
tion to build the format string that you pass to 
unpack
. Here are a couple of the
encoding methods that you might find—and how to deal with them.
Fixed-width number
s
indicating column width
s
In this case, the first line will be a string of numbers. You will be told how long each
number is (probably two or three digits). You can 
unpack
the record into an array
of numbers. Each of these numbers is the width of one field. You can, therefore,
build up an 
unpack
format to use on the rest of the file.
my $line = <STDIN>;
# The metadata line
my $width = 3;
# The width of each number in $line;
my $fields = length($line) / $width;
my $meta_fmt = 'a3' x $fields;
my @widths = unpack($meta_fmt, $line);
C# PDF Page Insert Library: insert pages into PDF file in C#.net
how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to reorganize PDF document pages and how
reverse page order pdf; rotate all pages in pdf file
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
doc.Save(outPutFilePath); Demo Code: How to Delete Consecutive Pages from PDF in C#.NET. Demo Code: How to Delete Specified Pages from PDF in C#.NET.
pdf save rotated pages; rotate a pdf page
134
CHAPTER 
F
i
xed-w
i
dth and b
i
nary data
my $fmt = join('', map { "A$_" } @widths);
while (<STDIN>) {
my @data = unpack($fmt, $_);
# Do something useful with the fields in @data
}
Notice that we can calculate the number of fields in each record by dividing the
length of the metadata record by the width of each number in it. It might be useful
to add a sanity check at that point to ensure that this calculation gives an integer
answer as it should.
Using this method our financial data file would look like this:
005020008006001008
00374Bloggs & Co
19991105100103+00015000
00375Smith Brothers
19991106001234-00004999
The first line contains the field widths (5, 20, 8, 6, 1, and 8), all padded out to
three digit numbers.
Field-end marker
s
In this method, the first row in the file is a blank row that contains a marker (per-
haps a 
|
character) wherever a field will end in the following rows. In other words,
our example file would look like this:
|
|
|
||
|
00374Bloggs & Co
19991105100103+00015000
00375Smith Brothers
19991106001234-00004999
To deal with this metadata, we can split the row on the marker character and use
the length of the various elements to calculate the lengths of the fields:
my $line = <STDIN>; # The metadata line
chomp $line;
my $mark = '|'; # The field marker
my @fields = split($mark, $line);
my @widths = map { length($_) + 1 } @fields;
my $fmt = join('', map { "A$_" } @widths);
while (<STDIN>) {
chomp;
my @data = unpack($fmt, $_);
# Do something useful with the fields in @data
}
Notice that we add one to the length of each element to get the width. This is
because the marker character is not included in the array returned by the split, but it
should be included in the width of the field. 
C# TIFF: How to Rotate TIFF Using C# Code in .NET Imaging
Individual Products. XDoc.SDK for .NET. XImage.SDK for .NET. Edit. Insert Pages into Tiff File. Delete Tiff Pages. Move Tiff Page Position. Rotate a Tiff Page. Extract
rotate pages in pdf; pdf rotate all pages
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Individual Products. XDoc.SDK for .NET. XImage.SDK for .NET. Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Pages. Page: Rotate a PDF
pdf rotate page; how to rotate all pages in pdf in preview
F
i
xed-w
i
dth data
135
These are just two common ways to encode field structures in a fixed-width data
file. You will come across others, but it is always a case of working out the best way
to extract the required information from the metadata record. Of course, if you
have any influence in the design of your input file, you might like to suggest that
the first line contains the format that you need to pass to 
unpack
—let your source
system do the hard work!
7.1.2 Wri
t
ing fixed
-
wid
t
h da
t
If you have to read fixed-width data there is, of course, a chance that eventually you
will need to write it. In this section we’ll look at some common ways to do this.
Wri
t
ing fixed
-
wid
t
h da
t
a using pack
Luckily, Perl has a function which is the opposite of 
unpack
and, logically enough,
it is called 
pack
pack
takes a template and a list of values and returns a string con-
taining the list packed according to the rules given by the template. Once again the
full power of 
pack
will be useful when we look at binary data, but for 
ASCII
data we
will just use the 
A
and 
a
template options. These options have slightly different
meanings in a 
pack
template than the ones they have in an 
unpack
template.
Table 7.1 summarizes these differences.
Therefore, if we have a number of strings and wish to pack them into a fixed-
width data record, we can do something like this:
my @strings = qw(Here are a number of strings);
my $template = 'A6A6A3A8A4A10';
print pack($template, @strings), "\n";
and our strings will all be space padded to the sizes given in the 
pack
template.
There is, however, a problem padding numbers using this method, as Perl doesn’t
know the difference between text fields and numerical fields, so you end up with
numbers postpadded with spaces (or nulls, depending on the template you use).
This may, of course, be fine for your data, but if you want to prepad numbers with
spaces then you should use the 
sprintf
or 
printf
functions.
Table 7.1 Meaning
s
of A and a in pack and unpack 
t
empla
t
e
s
A
a
pack
Pad 
s
tring with 
s
pace
s
Pad 
s
tring with null character
s
unpack
Strip trailing null
s
and 
s
pace
s
Leave trailing null
s
and 
s
pace
s
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
C#.NET PDF Library - Copy and Paste PDF Pages in C#.NET. Easy to C#.NET Sample Code: Copy and Paste PDF Pages Using C#.NET. C# programming
pdf rotate just one page; pdf rotate single page reader
C# PDF: PDF Document Viewer & Reader SDK for Windows Forms
Rotate270: Rotate the currently displayed PDF page 90 degrees counterclockwise. for you to create and add a PDF document viewer & reader in Windows
how to rotate all pages in pdf; rotate all pages in pdf
136
CHAPTER 
F
i
xed-w
i
dth and b
i
nary data
Wri
t
ing fixed
-
wid
t
h da
t
a using prin
t
f and sprin
t
f
These two functions do very similar things. The only difference is that 
sprintf
returns its results in a scalar variable, whereas 
printf
will write them directly to a
file handle. Both of the functions take a format description followed by a list of val-
ues which are substituted into the format string. The contents of the format string
control how the values appear in the final result. At each place in the format string
where you want a value to be substituted you place a format specifier in the format
%m.nx
, where 
m
and 
n
control the size of the field and 
x
controls how the value
should be interpreted. Full details of the syntax for format specifiers can be found in
your Perl documentation but, for our current purposes, a small subset will suffice.
To put integers into the string, use the format specifier 
%d
;2 to force the field to
be five characters wide, use the format specifier 
%5d
; and to prepad the field with
zeroes, use 
%05d
. Here is an example which demonstrates these options:
my @formats = qw(%d %5d %05d);
my $num = 123;
foreach (@formats) {
printf "¦$_¦\n", $num;
}
Running this code produces the following results:
¦123¦
¦
123¦
¦00123¦
You can do similar things with floating point numbers using 
%f
. In this case you can
control the total width of the field and also the number of characters after the deci-
mal point by using notation such as 
%6.2f
(for a 6 character field with two charac-
ters after the decimal point). Here is an example of this:
my @formats = qw(%f %6.2f %06.2f);
my $num = 12.3;
foreach (@formats) {
printf "¦$_¦\n", $num;
}
which gives the following results (notice that the default number of decimal places
is six):
¦12.300000¦
¦ 12.30¦
¦012.30¦
2
%d
is actually for a signed integer. If you need an unsigned value, use 
%u
.
F
i
xed-w
i
dth data
137
For strings we can use the format specifier 
%s
. Again, we can use a number within
the specifier to define the size of the field. You’ll notice from the previous examples
that when the data was smaller than the field it was to be used in, the data was right
justified within the field. With numbers, that is generally what you want (especially
when you are going to prepad the number with zeroes) but, as we’ve seen previ-
ously, text is often left justified and postpadded with spaces. In order to left justify
the text we can prepend a minus sign to the size specifier. Here are some examples:
my @formats = qw(%s %10s %010s %-10s %-010s);
my $str = 'Text';
foreach (@formats) {
printf "¦$_¦\n", $str;
}
which gives the following output:
¦Text¦
¦
Text¦
¦000000Text¦
¦Text
¦
¦Text
¦
Notice that we can prepad strings with zeroes just as we can for numbers, but it’s
difficult to think of a situation where that would be useful.
Example
:
wri
t
ing fixed
-
wid
t
h da
t
a wi
t
h sprin
t
f
Putting this all together, we can produce code which can output fixed-width finan-
cial transaction records like the ones we were reading earlier.
my %rec1 = ( txnref => 374,
cust
=> 'Bloggs & Co',
date
=> 19991105,
extref => 100103,
dir
=> '+',
amt
=> 15000 );
my %rec2 = ( txnref => 375,
cust
=> 'Smith Brothers',
date
=> 19991106,
extref => 1234,
dir
=> '-',
amt
=> 4999 );
my @cols = (
{ name
=> 'txnref',
width => 5,
num
=> 1 },
{ name
=> 'cust',
138
CHAPTER 
F
i
xed-w
i
dth and b
i
nary data
width => 20,
num
=> 0 },
{ name
=> 'date',
width => 8,
num
=> 1 },
{ name
=> 'extref',
width => 6,
num
=> 1 },
{ name
=> 'dir',
width => 1,
num
=> 0 },
{ name
=> 'amt',
width => 8,
num
=> 1 } );
my $format = build_fmt(\@cols);
print fixed_rec(\%rec1, \@cols, $format);
print fixed_rec(\%rec2, \@cols, $format);
sub build_fmt {
my $cols = shift;
my $fmt;
foreach (@$cols) {
if ($_->{num}) {
$fmt .= "%0$_->{width}s";
} else {
$fmt .= "%-$_->{width}s";
}
}
return $fmt;
}
sub fixed_rec {
my ($rec, $cols, $fmt) = @_;
my @vals = map { $rec->{$_->{name}} } @$cols;
sprintf("$fmt\n", @vals);
}
In this program, we use an array of hashes (
@cols
) to define the characteristics of
each data field in our record. These characteristics include the name of the column
together with the width that we want it to be in the output, and a flag indicating
whether or not it is a numeric field. We then use the data in this array to build a
suitable 
sprintf
format string in the function 
build_fmt
. The 
fixed_rec
func-
tion then extracts the relevant data from the record (which is stored in a hash) into
B
i
nary data
139
an array and feeds that array to 
sprintf
along with the format. This creates our
fixed-width record. As expected, the results of running this program are the records
that we started with at the beginning of this chapter.
7.2
Binary da
t
a
All of the data that we have looked at so far has been 
ASCII
data. That is, it has been
encoded using a system laid down by the American Standards Committee for Infor-
mation Interchange. In this code, 128 characters3 have been given a numerical
equivalent value from 0 to 127. For example, the space character is number 32, the
digits 0 to 9 have the numbers 48 to 57, and the letters of the alphabet appear from
65 to 90 in upper case and from 97 to 122 in lower case. Other numbers are taken
up by punctuation marks and various control characters. 
When an 
ASCII
character is written to a file, what is actually written is the binary
version of the 
ASCII
code for the given character. For example the number 123
would be written to the file as 00110001 00110010 00110011 (the binary equiva-
lents of 49, 50, and 51). The advantage of this type of data is that it is very easy to
write software that allows users to make sense of the data. All you need to do is con-
vert each byte of data into its equivalent 
ASCII
character. The major disadvantage is
the amount of space used. In the previous example we used 3 bytes of data to store
a number, but if we had stored the binary number 01111011 (the binary equivalent
of 123) we could have used a third of the space.
For this reason, there are a number of applications which store data in binary for-
mat. In many cases these are proprietary binary formats which are kept secret so
that one company has a competitive advantage over another. A good example of
this is spreadsheets. Microsoft and Lotus have their own spreadsheet file format
and, although Lotus 123 can read Microsoft Excel files, each time a new feature is
added to Excel, Lotus has to do more work to ensure that its Excel file converter
can handle the new feature. Other binary file formats are in the public domain and
can therefore be used easily by applications from many different sources. Probably
the best example of this is in graphics files, where any number of applications across
many different platforms can happily read and write each other’s files.
We’ll start by writing a script that can extract useful data from a graphics file. The
most ubiquitous graphics file format (especially across the Internet) is the CompuServe
Graphic
s
I
nterchange Format (or 
GIF
). Unfortunately for us, this file format uses a pat-
ented data compression technique and the owners of the patent (Unisys) are trying to
3
There are a number of extensions to the ASCII character set which define 256 characters, but the fact that
they are nonstandard can make dealing with them problematic.
140
CHAPTER 
F
i
xed-w
i
dth and b
i
nary data
ensure that only properly licensed software is used to create 
GIF
files.4 As Perl is Open
Source, it does not fall into this category, and you shouldn’t use it to create 
GIF
s. I
believe that using Perl to read 
GIF
s would not violate the licensing terms, but to be
sure we’ll look at the Portable 
N
etwork Graphic
s
(
PNG
) format instead.
7.2.1 Reading 
PNG
files
In order to read any binary file, you will need a definition of the format. I’m using
the definition in Programming Web Graphic
s
with Perl & 
G
N
U
Software by Shawn
P. Wallace (O’Reilly), but you can get the definitive version from the 
PNG
group
home page at http:
/
/
www.cdrom.com
/
pub
/
png
/
.
Reading 
t
he file forma
t
signa
t
ure
Most binary files start with a 
s
ignature, that is a few bytes that identify the format of
the file. This is so that applications that are reading the file can easily check that the
file is in a format that they can understand. In the case of 
PNG
files, the first 8 bytes
always contain the hex value 
0x89
followed by the string 
PNG\cM\cJ\cZ\cM
. In
order to check that a file is a valid 
PNG
file, you should do something like this:
my data;
read(PNG, $data, 8);
die "Not a valid PNG\n" unless $data eq '\x89PNG\cM\cJ\cZ\cM';
Note that we use 
\x89
to match the hex number 
0x89
and 
\cZ
to match 
Control-Z
Reading 
t
he da
t
a chunks
After this header sequence, a 
PNG
file is made up of a number of chunk
s
. Each
chunk contains an 8-byte header, some amount of data, and a 4-byte trailer. Each
header record contains the length in a 4-byte integer followed by four characters
indicating the type of the chunk. The length field gives you the number of bytes
that you should read from the file and the type tells you how to process it. There are
a number of different chunk types in the 
PNG
specification, but we will look only at
the 
IHDR
(header) chunk, which is always the first chunk in the file and defines cer-
tain global attributes of the image. 
Example
:
reading a 
PNG
file
A complete program to extract this data from a 
PNG
file (passed in via 
STDIN
) looks
like this:
4
You can read more about this dispute in Lincoln Stein’s excellent article at:
http:
/
/
www.webtechniques.com
/
archives
/
1999
/
12
/
webm
/
.
Documents you may be interested
Documents you may be interested