display pdf in asp.net page : Rotate pdf pages control software system web page winforms html console dmp20-part1828

Par
s
i
ng XML w
i
th XML
:
:
Par
s
er
181
It’s difficult to see what processing you might want to proceed with if your 
XML
document is incorrect, so in many cases dying is the correct approach for a program
to take. If, however, you have a case where you want to recover a little more grace-
fully you can catch the fatal exception. You do this using 
eval
. If the code that is
passed to 
eval
causes an exception, the program does not die, but the error mes-
sage is put in the variable 
$@
. You can therefore parse your 
XML
documents using
code like this:
eval { $p->parsefile($file) };
if ($@) {
die "Bad XML Document: $file\n";
} else {
print "Good XML!\n";
}
10.2.3 O
t
her 
XML
:
:
Parser s
t
yles
The Stream style is only one of a number of styles which 
XML::Parser
supports.
Depending on your requirements, another style might be better suited to the task.
Debug
The Debug style simply prints out a stylized version of your 
XML
document. Pars-
ing our weather example file using the Debug style gives us the following output:
\\ ()
FORECAST || #10;
FORECAST ||
FORECAST \\ ()
FORECAST OUTLOOK || #10;
FORECAST OUTLOOK ||
Partly Cloudy
FORECAST OUTLOOK || #10;
FORECAST OUTLOOK ||
FORECAST //
FORECAST || #10;
FORECAST ||
FORECAST \\ (TYPE MAX DEGREES C)
FORECAST TEMPERATURE || 12
FORECAST //
FORECAST || #10;
FORECAST ||
FORECAST \\ (TYPE MIN DEGREES C)
FORECAST TEMPERATURE || 6
FORECAST //
FORECAST || #10;
//
Rotate pdf pages - 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#
how to rotate page in pdf and save; rotate individual pages in pdf
Rotate pdf pages - 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
rotate single page in pdf; pdf rotate one page
182
CHAPTER 
XML
If you look closely, you will see the structure of our weather document in this dis-
play. A line containing the opening tag of a new element contains the character
sequence 
\
\
and the attributes of the element appear in brackets. A line containing
the character sequence 
//
denotes an element’s closing tag, and a line containing
the character sequence 
||
denotes the text contained within an element. The 
#10
sequences denote the end of each line of text in the original document.
Subs
The Subs style works in a very similar manner to the Stream style, except that
instead of the same functions being called for the start and end tags of each ele-
ment, a different pair of functions is called for each element type. For example, in
our weather document, the parser would expect to find functions called 
FORECAST
and 
OUTLOOK
that it would call when it found 
<FORECAST>
and 
<OUTLOOK>
tags.
For the closing tags, it would look for functions called 
_FORECAST
and 
_OUTLOOK
.
This method prevents the program from having to check which element type is
being processed (although this information is still passed to the function as the sec-
ond parameter).
Tree
All of the styles that we have seen so far have been 
s
tream-ba
s
ed. That is, they move
through the document and call certain functions in your code when they come
across particular events in the document. The Tree style does things differently. It
parses the document and builds a data structure containing a logical model of the
document. It then returns a reference to this data structure.
The data structure generated by our weather document looks like this:
[ 'FORECAST', [ {}, 0, "\n
",
'OUTLOOK', [ {}, 0, "\n
Partly Cloudy\n
"], 0, "\n
",
'TEMPERATURE', [ ( 'DEGREES' => 'C', 'TYPE' => 'MAX' }, 0, '12' ], 0, "\n ",
'TEMPERATURE', [ ( 'DEGREES' => 'C', 'TYPE' => 'MAX' }, 0, '6'
], 0, "\n"
] ]
It’s probably a little difficult to follow, so let’s look at it in detail.
Each element is represented by a list. The first item is the element type and the
second item is a reference to another list which represents the contents of the ele-
ment. The first element of this second level list is a reference to a hash which con-
tains the attributes for the element. If the element has no attributes then the
reference to the hash still exists, but the hash itself is empty. The rest of the list is a
series of pairs of items, which represent the text, and elements that are contained
within the element. These pairs of items have the same structure as the original two-
item list, with the exception that a text item has a special element type of 
0
.
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Page: Delete Existing PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Delete PDF Page. How to VB.NET: Delete Consecutive Pages from PDF.
rotate pages in pdf online; rotate pages in pdf and save
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Page: Delete Existing PDF Pages. Provide C# Users with Mature .NET PDF Document Manipulating Library for Deleting PDF Pages in C#.
rotate pdf pages; pdf rotate single page
Par
s
i
ng XML w
i
th XML
:
:
Par
s
er
183
If you’re the sort of person who thinks that a picture is worth a thousand words,
then figure 10.1 might have saved me a lot of typing.
In the figure the variable 
$doc
is returned from the parser. You can also see the
arrays which contain the definitions of the 
XML
content and the hashes which con-
tain the attributes.
Example
:
using 
XML
:
:
Parser in Tree s
t
yle
This may become clearer still if we look at some sample code for dealing with one of
these structures. The following program will print out the structure of an 
XML
doc-
ument. Using it to process our weather document will give us the following output:
FORECAST []
OUTLOOK []
Partly Cloudy
TEMPERATURE [DEGREES: C, TYPE: MAX]
12
TEMPERATURE [DEGREES: C, TYPE: MIN]
6
Here is the code:
use strict;
use XML::Parser;
0
1
2
3
4
5
h
a
s
h
r
e
f
'
0
'
"\n"
'
OUTLOOK
'
l
i
s
t
r
e
f
'
0
'
e
mpty
6
7
8
9
10
11
12
13
14
"\n"
'
TEMPERATURE
'
l
i
s
t
r
e
f
'
0
'
"\n"
'
TEMPERATURE
'
l
i
s
t
r
e
f
'
0
'
"\n"
0
1
2
h
a
s
h
r
e
f
'
0
'
"\nP
a
rtly Cloudy\n"
0
1
2
h
a
s
h
r
e
f
'
0
'
0
1
2
h
a
s
h
r
e
f
'
0
'
'
12
'
'
12
'
e
mpty
'
C
'
d
e
gr
e
e
s
typ
e
'
MAX
'
'
C
'
d
e
gr
e
e
s
typ
e
'
MIN
'
0
1
'
FORECAST
'
l
i
s
t
r
e
f
$doc
Figur
e
10.1 Output from XML::Parser Tr
e
e
s
tyl
e
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 save rotated pages; rotate pages in pdf
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
rotate pages in pdf and save; how to save a pdf after rotating pages
184
CHAPTER 
XML
my $p = XML::Parser->new(Style => 'Tree');
my $doc = $p->parsefile(shift);
my $level = 0;
process_node(@$doc);
sub process_node {
my ($type, $content) = @_;
my $ind = ' ' x $level;
if ($type) { # element
my $attrs = shift @$content;
print $ind, $type, ' [';
print join(', ', map { "$_: $attrs->{$_}" } keys %{$attrs});
print "]\n";
++$level;
while (my @node = splice(@$content, 0, 2)) {
process_node(@node); # Recursively call this subroutine
}
--$level;
} else { # text
$content =~ s/\n/ /g;
$content =~ s/^\s+//;
$content =~ s/\s+$//;
print $ind, $content, "\n";
}
}
Let’s look at the code in more detail.
The start of the program looks similar to any number of other parsing programs
that we’ve seen in this chapter. The only difference is that we create our 
XML:Parser
object with the Tree style. This means that the 
parsefile
method returns us a ref-
erence to our tree structure.
As we’ve seen above, this is a reference to a list with two items in it. We’ll call one
of these two-item lists a node and write a function called 
process_node
which will
handle one of these lists. Before calling 
process_node
, we initialize a global vari-
able to keep track of the current element nesting level.
In the 
process_node
function, the first thing that we do is determine the type of
node we are dealing with. If it is an element, then the first item in the node list will
have a 
true
value. Text nodes have the value 
0
in this position, which will evaluate
as 
false
.
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 page; reverse page order pdf
VB.NET PDF Page Replace Library: replace PDF pages in C#.net, ASP.
C#.NET convert PDF to text, C#.NET convert PDF to images, C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET
how to rotate all pages in pdf at once; rotate pdf pages by degrees
Par
s
i
ng XML w
i
th XML
:
:
Par
s
er
185
If we are dealing with an element, then 
shift
ing the first element off of the con-
tent list will give us a reference to the attribute hash. We can then print out the ele-
ment type and attribute list indented to the correct level.
Having dealt with the element and its attributes we can process its contents. One
advantage of using 
shift
to get the attribute hash reference is that it now leaves
the content list with an even number of items in it. Each pair of items is another
node. We can simply use 
splice
to pull the nodes off the array one at a time and
pass them recursively to 
process_node
, pausing only to increment the level before
processing the content and decrementing it again when finished.
If the node is text, then the second item in the node list will be the actual text. In
this case we just clean it up a bit and print it out.
Example
:
parsing wea
t
her.xml using 
t
he Tree s
t
yle
This program will work with any tree structure that is generated by 
XML::Parser
using the Tree style. However, more often you will want to do something a little
more specific to the document with which you are dealing. In our case, this will be
printing out a weather forecast. Here is a Tree-based program for printing the fore-
cast in our usual format.
use strict;
use XML::Parser;
my $p = XML::Parser->new(Style => 'Tree');
my $doc = $p->parsefile(shift);
process_node(@$doc);
sub process_node {
my ($type, $content) = @_;
if ($type eq 'OUTLOOK') {
print 'Outlook: ', trim($content->[2]), "\n";
} elsif ($type eq 'TEMPERATURE') {
my $attrs = $content->[0];
my $temp = trim($content->[2]);
print "$attrs->{TYPE}: $temp $attrs->{DEGREES}\n";
}
if ($type) {
while (my @node = splice @$content, 1, 2) {
process_node(@node)
}
}
}
sub trim {
C# PDF Page Replace Library: replace PDF pages in C#.net, ASP.NET
Page: Replace PDF Pages. |. Home ›› XDoc.PDF ›› C# PDF: Replace PDF Pages. C#.NET PDF Library - Replace PDF Pages in C#.NET.
how to rotate one pdf page; pdf save rotated pages
VB.NET PDF - WPF PDF Viewer for VB.NET Program
C#.NET convert PDF to text, C#.NET convert PDF to images, C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET
pdf rotate page and save; rotate pdf pages
186
CHAPTER 
XML
local $_ = shift;
s/\n/ /g;
s/^\s+//;
s/\s+$//;
return $_;
}
The basic structure of this program is quite similar to the previous one. All of the
work is still done in the 
process_node
function. In this version, however, we are
on the lookout for particular element types which we know we want to process.
When we find an 
OUTLOOK
element or a 
TEMPERATURE
element we know exactly
what we need to do. All other elements are simply ignored. In the case of an
OUTLOOK
element we simply extract the text from the element and print it out.
Notice that the text contained within the element is found at 
$content->[2]
, the
third item in the content array. This is true for any element that only contains text,
as the first two items in the content list will always be a reference to the attribute
hash and the character 
0
.
The processing for the 
TEMPERATURE
element type is only slightly more complex
as we need to access the attribute hash to find out the type of the temperature (min-
imum or maximum) and the kind of degrees in which is it measured.
Notice that we still need to process any child elements and that this is still done in
the same way as in the previous program—by removing nodes from the 
@$content
list. In this case we haven’t removed the attribute hash from the front of the list, so we
start the 
splice
from the second item in the list (the second item has the index 
0
).
Objec
t
s
The Objects style works very much like the Tree style, except that instead of arrays
and hashes, the document tree is presented as a collection of objects. Each element
type becomes a different object class. The name of the class is created by appending
main::
to the front of the element’s name.4 Text data is turned into an object of
class 
main::Characters
. The value that is returned by the 
parse
method is a ref-
erence to an array of such objects. As a well-formed 
XML
object can only have one
top-level element, this array will only have one element. 
4
This is the default behavior. You can create your objects within other packages by using the Pkg option
to 
XML::Parser->new
. For example:
my $p = XML::Parser->new(Style => 'Objects', Pkg => 'Some_Other_Package');
Par
s
i
ng XML w
i
th XML
:
:
Par
s
er
187
Attributes of the element are stored in the element hash. This hash also contains
a special key, 
Kids
. The value associated with this key is a reference to an array
which contains all of the children of the element.
Example
:
parsing 
XML
wi
t
XML
:
:
Parser using 
t
he Objec
t
s s
t
yle
Here is a program that displays the structure of any given 
XML
document using the
Objects style:
use strict;
use XML::Parser;
my $p = XML::Parser->new(Style => 'Objects');
my $doc = $p->parsefile(shift);
my $level = 0;
process_node($doc->[0]);
sub process_node {
my ($node) = @_;
my $ind = ' ' x $level;
my $type = ref $node;
$type =~ s/^.*:://;
if ($type ne 'Characters') {
my $attrs = {%$node};
delete $attrs->{Kids};
print $ind, $type, ' [';
print join(', ', map { "$_: $attrs->{$_}" } keys %{$attrs});
print "]\n";
++$level;
foreach my $node (@{$node->{Kids}}) {
process_node($node);
}
--$level;
} else {
my $content = $node->{Text};
$content =~ s/\n/ /g;
$content =~ s/^\s+//;
$content =~ s/\s+$//;
print $ind, $content, "\n" if $content =~ /\S/;
}
}
This program is very similar to the example that we wrote using the Tree style.
Once again, most of the processing is carried out in the 
process_node
function. In
188
CHAPTER 
XML
this case each node is represented by a single reference rather than a two-item list.
The first thing that we do in 
process_node
is to work out the type of element with
which we are dealing. We do this by using the standard Perl function 
ref
. This
function takes one parameter, which is a reference, and returns a string containing
the type of object that the reference refers to. For example, if you pass it a reference
to an array, it will return the string 
ARRAY
. This is a good way to determine the
object type a reference has been 
bless
ed into. In our case, each reference that we
pass to it will be of type 
main::Element
, where 
Element
is the name of one of our
element types. We remove the 
main::
from the front of the string to leave us with
the specific element with which we are dealing.
If we are dealing with an element (rather than character data) we then take a
copy of the object hash which we will use to get the list of attributes. Notice that
we don’t use the more obvious 
$attrs
=
$node
as this only copies the reference
and still leaves it pointing to the same original hash. As the next line of the code
deletes the 
Kids
array reference from this hash, we use the slightly more complex
$attrs = {%$node}
as this takes a copy of the original hash and returns a refer-
ence to the new copy. We can then delete the 
Kids
reference without doing any
lasting damage to the original object.
Having retrieved the attribute hash, we display the element type along with its
attributes. We then need to process all of the element’s children. We do this by iter-
ating across the 
Kids
array (which is why it’s a good idea that we didn’t delete the
original earlier), passing each object in turn to 
process_node
.
If the object with which we are dealing is of the class Characters then it contains
character data and we can access the actual text by using the special 
Text
key.
Choosing be
t
ween Tree and Objec
t
s
t
yles
The Tree and Object styles can both be used to address the same set of problems.
You would usually use one of these two styles when your document processing
requires multiple passes over the document structure. Whether you choose the Tree
or Objects style for your tree-based parsing requirements is simply a matter of per-
sonal taste.
10.2.4
XML
:
:
Parser handlers
The 
XML::Parser
styles that we have been discussing are a series of prebuilt meth-
ods for parsing 
XML
documents in a number of popular ways. If none of these
styles meet your requirements, there is another way that you can use 
XML::Parser
which gives even more control over the way it works. This is accomplished by set-
ting up a series of handler
s
which can respond to various events that are triggered
while parsing a document. This is very similar to the way we used 
HTML::Parser
or the Stream style of 
XML::Parser
.
190
CHAPTER 
XML
my $text;
$p->parsefile(shift);
sub init {
$level = 0;
$text = '';
}
sub start {
my ($p, $tag) = (shift, shift);
my %attrs = @_ if @_;
print $ind, $tag, ' [';
print join ', ', map { "$_: $attrs{$_}" } keys %attrs;
print "]\n";
$level++;
$ind = ' ' x $level;
}
sub end {
print $ind, $text, "\n";
$level--;
$ind = ' ' x $level;
$text = '';
}
sub char {
my ($p, $str) = (shift, shift);
return unless $str =~ /\S/;
$str =~ s/^\s+//;
$str =~ s/\s+$//;
$text .= $str;
}
In this case we only need to define four handlers for 
Init
Start
End
, and 
Char
.
The 
Init
handler only exists to allow us to set 
$level
and 
$text
to initial values.
In the 
Start
handler we do very similar processing to the previous examples.
That is, we print the element’s name and attributes. In this case it is very easy to get
these values as they are passed to us as parameters. We also increment 
$level
and
use the new value to calculate an indent string which we will print before any output.
In the 
End
handler we print out any text that has been built up in 
$text
, decre-
ment 
$level
, recalculate 
$ind
, and reset 
$text
to an empty string.
In the 
Char
handler we do the usual cleaning that strips any leading and trailing
white space and appends the string to 
$text
. Notice that it is possible that because
Documents you may be interested
Documents you may be interested