display pdf in asp.net page : How to rotate a single page in a pdf document Library software class asp.net winforms html ajax dmp19-part1826

Prebu
i
lt HTML par
s
er
s
171
my $p = HTML::TokeParser->new($file);
my $tag;
while ($tag = $p->get_tag()) {
next unless $tag->[0] =~ /^h(\d)/;
my $level = $1;
print ' ' x $level, "Head $level: ", $p->get_text(), "\n";
}
Notice that we only process tags where the name matches the regular expression
/^h(\d)/
. This ensures that we only see 
HTML
header tags. We put brackets
around the 
\d
to capture this value in 
$1
. This value indicates the level of the header
we have found and we can use it to calculate how far to indent the output. Running
this program on our previous sample 
HTML
file gives the following output:
Head 1: The first major item
Head 2: Section 1.1
Head 2: Section 1.2
Head 3: Section 1.2.1
Head 3: Section 1.2.2
Head 1: Another major header
Head 2: Section 2.1
Head 3: Section 2.1.1
Head 3: Section 2.1.2
Head 2: Section 2.2
which is a very useful outline of the structure of the document.
9.3.3
HTML
:
:
TreeBuilder and 
HTML
:
:
Elemen
t
Another very useful subclass of 
HTML::Parser
is 
HTML::TreeBuilder
. As you can
probably guess from its name, this class builds a parse tree that represents an 
HTML
document. Each node in the tree is an 
HTML::Element
object. 
Example
:
parsing 
HTML
wi
t
HTML
:
:
Treebuilder
Here is a simple script which uses 
HTML::TreeBuilder
to parse an 
HTML
document.
#!/usr/bin/perl -w
use strict;
use HTML::TreeBuilder;
my $h = HTML::TreeBuilder->new;
$h->parse_file(shift);
$h->dump;
print $h->as_HTML;
How to rotate a single page in a pdf document - 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#
reverse pdf page order online; how to save a pdf after rotating pages
How to rotate a single page in a pdf document - 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 pdf page few degrees; how to rotate a page in pdf and save it
172
CHAPTER 
HTML
In this example we create a new parser object using the 
HTML::Treebuilder->new
method. We then parse our file using the new object’s 
parse_file
method.3
Notice that, unlike some other tree-based parsers, this function doesn’t return a
new tree object, rather the parse tree is built within the parser object itself.
As the example demonstrates, this class has a couple of ways to display the parse
tree. Both of these are, in fact, inherited from the 
HTML::Element
class. The 
dump
method prints a simple representation of the element and its descendents and the
as_HTML
method prints the element and its descendents as 
HTML
. This might seem
a little less than useful given that we have just created the parse tree from  an 
HTML
file, but there are at least three reasons why this might be useful. First, a great many
HTML
files aren’t strictly valid 
HTML.
HTML::TreeBuilder
does a good job of
parsing invalid 
HTML
and the 
as_HTML
method can then be used to output valid
HTML
. Second, the 
HTML::Element
has a number of methods for changing the
parse tree, so you can alter your page and then use the 
as_HTML
method to produce
the altered page. And third, the tree can be scanned in ways that would be inconve-
nient or impossible with just a token stream.
Notice that I’ve been saying that you can call 
HTML::Element
methods on an
HTML::TreeBuilder
object. This is because 
HTML::TreeBuilder
inherits from
both 
HTML::Parser
and 
HTML::Element
. An 
HTML
document should always start
with an 
<HTML>
and end with a 
</HTML>
tag and therefore the whole document can
be viewed as an 
HTML
element, with all of the other elements contained within it. It is,
therefore, valid to call 
HTML::Element
methods on our 
HTML::TreeBuilder
object.
Both 
HTML::TreeBuilder
and 
HTML::Element
are part of the 
HTML
-Tree
bundle of modules which can be found on the 
CPAN
.
9.4
Ex
t
ended example
:
ge
t
t
ing wea
t
her forecas
t
s
To finish this section, here is an example demonstrating the extraction of useful data
from web pages. We will get a weather forecast for the Central London area from
Yahoo! The front page to Yahoo!’s U.K. weather service is at weather.yahoo.co.uk
and by following a couple of links we can find that the address of the page contain-
ing the weather forecast for London is at http:
/
/
uk.weather.yahoo.com
/
1208
/
index_c.html. In order to extract the relevant data from the file we need to examine
the 
HTML
source for the page. You can either use the View Source menu option of
your browser or write a quick Perl script using LWP and 
getstore
to store the
page in a file.
3
Note that 
HTML::Treebuilder
supports the same parsing interface as 
HTML::Parser
, so you could just as
easily call 
$h->parse
, passing it a variable containing HTML to parse.
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Able to remove a single page from adobe PDF document in VB.NET. This is a VB .NET example for how to delete a single page from a PDF document.
rotate pdf pages by degrees; pdf reverse page order preview
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Able to remove a single page from PDF document. Ability to remove a range of pages from PDF file. How to delete a single page from a PDF document.
how to rotate all pages in pdf at once; save pdf rotated pages
Extended example
:
gett
i
ng weather foreca
s
t
s
173
Having retrieved a copy of the page we can examine it to find out where in the
page we can find the data that we want. Looking at the Yahoo! page I found that
the description of the weather outlook was within the first 
<font>
tag after the sixth
<table>
tag. The high and low temperature measurements were within the follow-
ing two 
<b>
tags.4 Armed with this knowledge, we can write a program which will
extract the weather forecast and display it to the user. The program looks like this:
use HTML::TokeParser;
use LWP::Simple;
my $addr = 'http://uk.weather.yahoo.com/1208/index_c.html';
my $page = get $addr;
my $p = HTML::TokeParser->new(\$page)
|| die "Parse error\n";
$p->get_tag('table') !! die "Not enough table tags!" foreach (1 .. 6);
$p->get_tag('font');
my $desc = $p->get_text, "\n";
$p->get_tag('b');
my $high = $p->get_text;
$p->get_tag('b');
my $low = $p->get_text;
print "$desc\nHigh: $high, Low: $low\n";
You will notice that I’ve used 
HTML::TokeParser
in this example. I could have also
chosen another 
HTML::Parser
subclass or even written my own, but 
HTML::
TokeParser
is a good choice for this task as it is very easy to target specific ele-
ments, such as the sixth 
<table>
tag, and then move to the next 
<font>
tag.
In the program we use 
LWP::Simple
to retrieve the required page from the web
site and then parse it using 
HTML::TokeParser
. We then step through the parsed
document looking for 
<table>
tags, until we find the sixth one. At this point we
find the next 
<font>
tag and extract the text within it using the 
get_text
method.
This gives us the brief weather outlook. We then move in turn to each of the next
two 
<b>
tags and for each one extract the text from it. This gives us the forecast
high and low temperatures. We can then format all of this information in a nice way
and present it to the user.
This has been a particularly simple example, but similar techniques can be used
to extract just about any information that you can find on the World Wide Web.
4
You should, of course, bear in mind that web pages change very frequently. By the time you read this,
Yahoo! may well have changed the design of this page which will render this program useless.
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C# Users can view PDF document in single page or continue pages.
rotate all pages in pdf and save; save pdf after rotating pages
How to C#: Basic SDK Concept of XDoc.PDF for .NET
insert, delete, re-order, copy, paste, cut, rotate, and save from file or query data and save the PDF document. The PDFPage class presents a single page in a
rotate individual pdf pages reader; rotate all pages in pdf file
176
CHAPTER 
XML
Over the next few years, it looks as though 
XML
will become the data exchange for-
mat of choice for a vast number of computer systems. In this chapter we will take a
look at some of the tools available for parsing 
XML
with Perl. 
10.1
XML overview
One of the problems we had when extracting the weather information from the web
page in the previous chapter was that it was difficult to know where in the page to
find the data we needed. The only way to do it was to closely examine the 
HTML
file
and work out which tags surrounded our required data. This also meant that each
time the design of the page was changed, we would have to rework our program. 
10.1.1 Wha
t
’s wrong wi
t
HTML
?
The reason this was so difficult was that 
HTML
was designed to model the logical
structure of a document, not the meaning of the various elements. For example, an
HTML
document makes it easy to recognize headings at various levels, paragraphs,
lists, and various other publishing elements. You can tell when an element should
be printed in bold, but the problem is that you don’t know why that particular ele-
ment was bold. It could be purely for emphasis, it could be because it is a row head-
ing in a table, or it could be because it is the temperature on a weather page.
Our task would be a lot easier if the mark-up in a document told us more about
the actual meaning of the data. In our weather example, it would be nice if there was
<FORECAST>
</FORECAST>
element that surrounded the actual forecast descrip-
tion and perhaps a 
<TEMPERATURE>
</TEMPERATURE>
element which surrounded
each of the temperature figures in which we were interested. Even better, the
<TEMPERATURE>
element could have attributes which told us whether it was a maxi-
mum or minimum temperature and whether it was in degrees Fahrenheit or Celsius.
10.1.2 Wha
t
is 
XML
?
This is exactly the kind of problem that 
XML
was designed to solve. 
XML
is the
Exten
s
ible Mark-up Language. In fact it isn’t really a mark-up language at all, it is a
method to define new mark-up languages which are better suited to particular tasks.
The way it works is by defining a syntax for Document Type Definition
s
(
DTD
s). A
DTD
defines the set of elements that are allowed in a document, together with their
attributes and relationships to each other. It will define which elements are manda-
tory or optional, whether there is any defined order, and which elements can (or
must) contain other elements. The exact syntax of 
DTD
s is beyond the scope of this
book, but there are a number of specialized books which cover it in some detail (for
example 
XML
Pocket 
R
eference by Robert Eckstein and published by O’Reilly).
178
CHAPTER 
XML
document to conform with that 
DTD
then we could call it valid. Currently, we
don’t have such a 
DTD
so there is no way that our document can be valid.
XML
parsers fall into two types. Validating parsers will check the document’s
structure against its 
DTD
and nonvalidating parsers only check that the document is
well-formed.
10.2
Parsing XML wi
t
h XML
:
:
Parser
Of course there are Perl 
XML
parsers available. The most generalized one is the
CPAN
module 
XML::Parser
. This module is based on an 
XML
parser called Expat.
Expat is a nonvalidating parser, so in Perl you will generally only be interested in the
well-formedness of documents.2
XML::Parser
works in a similar way to 
HTML::Parser
, but as 
XML
is more com-
plex than 
HTML
XML::Parser
needs to be more complex than 
HTML::Parser
10.2.1 Example
:
parsing wea
t
her.xml
As an example of using 
XML::Parser
, here is a simple script to parse our weather
XML
file:
use strict;
use XML::Parser;
my %forecast;
my @curr;
my $type;
my $p = XML::Parser->new(Style => 'Stream');
$p->parsefile(shift);
print "Outlook: $forecast{outlook}\n";
foreach (keys %forecast) {
next if /outlook/;
print "$_: $forecast{$_}->{val} $forecast{$_}->{deg}\n";
}
sub StartTag {
my ($p, $tag) = @_;
push @curr, $tag;
if ($tag eq 'TEMPERATURE') {
$type = $_{TYPE};
$forecast{$type}->{deg} = $_{DEGREES};
2
I hope this explains my reluctance to go into the details of DTDs—
XML::Parser
makes no use of them.
There is, however, an experimental subclass of 
XML::Parser
, called 
XML::Checker::Parser
, which does
validate an XML document against a DTD. 
Par
s
i
ng XML w
i
th XML
:
:
Par
s
er
179
}
}
sub EndTag {
pop @curr;
};
sub Text {
my ($p) = shift;
return unless /\S/;
s/^\s+//;
s/\s+$//;
if ($curr[-1] eq 'OUTLOOK') {
$forecast{outlook} .= $_;
} elsif ( $curr[-1] eq 'TEMPERATURE') {
$forecast{$type}->{val} = $_;
}
}
Running this script against our sample weather 
XML
document gives the follow-
ing result:
Outlook: Partly Cloudy
MAX: 12 C
MIN: 6 C
10.2.2 Using 
XML
:
:
Parser
There are a number of different ways to use 
XML::Parser
. In this example we are
using it in a very similar manner to 
HTML::Parser
. When we create the parser
object we pass it a hash containing various configuration options. In this case, the
hash consists of one key (
Style
) and an associated value, which is the string
Stream
. The 
Style
parameter tells 
XML::Parser
that we want to use one of a
number of built-in parsing methods. The one that we want to use in this example is
called 
Stream
. In this mode 
XML::Parser
works very similarly to 
HTML::Parser
.
There are a number of predefined methods which the parser will call when encoun-
tering various parts of the 
XML
document. For this example we need to define three
of these methods. 
StartTag
is called when the start of an 
XML
tag is found,
EndTag
is called when the end of a tag is seen, and 
Text
is called when text data is
encountered. In each case the first parameter to the function will be a reference to
the underlying Expat object which is doing the parsing. In the 
StartTag
and
EndTag
functions the second parameter is the name of the tag which is being
started or ended. The complete original tag is stored in 
$_
. Additionally, in the
180
CHAPTER 
XML
StartTag
function, the list of attributes is stored in 
%_
. In the 
Text
function, the
text that has been found is stored in 
$_
.
This may all make a bit more sense if we look at the example code in more detail.
The main part of the program defines some global variables, creates the parser,
parses the file, and displays the information which has been extracted. The global
variables which it defines are: 
%forecast
, which will store the forecast data that we
want to display, 
@curr
which is a list of all of the current elements that we are in,
and 
$type
which stores the current temperature type. All of the real work goes on
in the parsing functions which are called by the parser as it processes the file.
The 
StartTag
function pushes the new tag on to the end of the 
@curr
array,
and if the tag starts a 
TEMPERATURE
element, it stores the values of the 
TYPE
and
DEGREES
attributes (which it finds in 
%_
).
The 
EndTag
function simply pops the last element from the 
@curr
array. You
might think that we should check whether the tag that we are ending is of the same
type as the current end of this list but, if it wasn’t the case, the document wouldn’t
be well-formed and would, therefore, fail the parsing process.3
The 
Text
function checks whether there is useful data in the text string (which is
stored in 
$_
) and returns if it can’t find at least one nonspace character. It then
strips leading and trailing spaces from the data. If the current element we are pro-
cessing (given by 
$curr[-1]
) is the 
OUTLOOK
element, then the text must be the
outlook description and we store it in the appropriate place in the 
%forecast
vari-
able. If the current element is a 
TEMPERATURE
element, then the text will be the
temperature data and that is also stored in the 
%forecast
hash (making use of the
current temperature type which is stored in the global 
$type
variable).
Once the parsing is complete the data is all stored in the 
%forecast
hash and we
can traverse the hash to display the required data. Notice that the method that we
use for this makes no assumptions about the list of temperature types used. If we
were to add average temperature data to the weather document, our program
would still display this.
Parsing failures
XML::Parser
(and the other parsers which are based on it) have a somewhat harsh
approach to non-well-formed 
XML
documents. They will always throw a fatal
exception when they encounter non-well-formed 
XML
. Unfortunately, this behav-
ior is defined in the 
XML
specifications, so they have no choice about this, but it can
still take beginners by surprise as they often expect the 
parse
or 
parsefile
method to return an error code, but instead their entire program is halted.
3
This always throws a fatal exception, but there are ways to prevent your program from dying if you give it
non-well-formed XML, as we will see later.
Documents you may be interested
Documents you may be interested