c# open pdf adobe reader : Delete a page from a pdf file application software tool html windows azure online theword18-part1318

178
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
it takes a long time before reporting failure. This is because the string can be divided between the
internal \D+ repeat and the external * repeat in a large number of ways, and all have to be tried. (The
example uses [!?] rather than a single character at the end, because both PCRE and Perl have an
optimization that allows for fast failure when a single character is used. They remember the last single
character that is required for a match, and fail early if it is not present in the string.) If the pattern is
changed so that it uses an atomic group, like this:
((?>\D+)|<\d+>)*[!?]
sequences of non-digits cannot be broken, and failure happens quickly.
BACK REFERENCES
Outside a character class, a backslash followed by a digit greater than 0 (and possibly further digits) is a
back reference to a capturing subpattern earlier (that is, to its left) in the pattern, provided there have
been that many previous capturing left parentheses.
However, if the decimal number following the backslash is less than 10, it is always taken as a back
reference, and causes an error only if there are not that many capturing left parentheses in the entire
pattern. In other words, the parentheses that are referenced need not be to the left of the reference for
numbers less than 10. See the subsection entitled "Non-printing characters" above
for further details of
the handling of digits following a backslash.
A back reference matches whatever actually matched the capturing subpattern in the current subject
string, rather than anything matching the subpattern itself (see "Subpatterns as subroutines"
below for a
way of doing that). So the pattern
(sens|respons)e and \1ibility
matches "sense and sensibility" and "response and responsibility", but not "sense and responsibility". If
caseful matching is in force at the time of the back reference, the case of letters is relevant. For example,
((?i)rah)\s+\1
matches "rah rah" and "RAH RAH", but not "RAH rah", even though the original capturing subpattern is
matched caselessly.
Back references to named subpatterns use the Python syntax (?P=name). We could rewrite the above
example as follows:
(?<p1>(?i)rah)\s+(?P=p1)
There may be more than one back reference to the same subpattern. If a subpattern has not actually
been used in a particular match, any back references to it always fail. For example, the pattern
(a|(bc))\2
always fails if it starts to match "a" rather than "bc". Because there may be many capturing parentheses in
a pattern, all digits following the backslash are taken as part of a potential back reference number. If the
pattern continues with a digit character, some delimiter must be used to terminate the back reference. If
the PCRE_EXTENDED option is set, this can be whitespace. Otherwise an empty comment (see 
"Comments"
below) can be used.
A back reference that occurs inside the parentheses to which it refers fails when the subpattern is first
Delete a page from a pdf file - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
delete pages from pdf file online; delete a page in a pdf file
Delete a page from a pdf file - VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Visual Basic Sample Codes to Delete PDF Document Page in .NET
delete a page from a pdf; delete blank pages in pdf online
179
used, so, for example, (a\1) never matches. However, such references can be useful inside repeated
subpatterns. For example, the pattern
(a|b\1)+
matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration of the subpattern, the back
reference matches the character string corresponding to the previous iteration. In order for this to work,
the pattern must be such that the first iteration does not need to match the back reference. This can be
done using alternation, as in the example above, or by a quantifier with a minimum of zero.
ASSERTIONS
An assertion is a test on the characters following or preceding the current matching point that does not
actually consume any characters. The simple assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are
described above.
More complicated assertions are coded as subpatterns. There are two kinds: those that look ahead of the
current position in the subject string, and those that look behind it. An assertion subpattern is matched in
the normal way, except that it does not cause the current matching position to be changed.
Assertion subpatterns are not capturing subpatterns, and may not be repeated, because it makes no
sense to assert the same thing several times. If any kind of assertion contains capturing subpatterns within
it, these are counted for the purposes of numbering the capturing subpatterns in the whole pattern.
However, substring capturing is carried out only for positive assertions, because it does not make sense
for negative assertions.
Lookahead assertions
Lookahead assertions start with (?= for positive assertions and (?! for negative assertions. For example,
\w+(?=;)
matches a word followed by a semicolon, but does not include the semicolon in the match, and
foo(?!bar)
matches any occurrence of "foo" that is not followed by "bar". Note that the apparently similar pattern
(?!foo)bar
does not find an occurrence of "bar" that is preceded by something other than "foo"; it finds any
occurrence of "bar" whatsoever, because the assertion (?!foo) is always true when the next three
characters are "bar". A lookbehind assertion is needed to achieve the other effect.
If you want to force a matching failure at some point in a pattern, the most convenient way to do it is with
(?!) because an empty string always matches, so an assertion that requires there not to be an empty
string must always fail.
Lookbehind assertions
Lookbehind assertions start with (?<= for positive assertions and (?<! for negative assertions. For
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Merge PDF; C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF
delete pages of pdf preview; delete pages from pdf without acrobat
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
your PDF document is unnecessary, you may want to delete this page adding a page into PDF document, deleting unnecessary page from PDF file and changing
delete page from pdf file online; delete pages from pdf in reader
180
example,
(?<!foo)bar
does find an occurrence of "bar" that is not preceded by "foo". The contents of a lookbehind assertion
are restricted such that all the strings it matches must have a fixed length. However, if there are several
alternatives, they do not all have to have the same fixed length. Thus
(?<=bullock|donkey)
is permitted, but
(?<!dogs?|cats?)
causes an error at compile time. Branches that match different length strings are permitted only at the top
level of a lookbehind assertion. This is an extension compared with Perl (at least for 5.8), which requires
all branches to match the same length of string. An assertion such as
(?<=ab(c|de))
is not permitted, because its single top-level branch can match two different lengths, but it is acceptable if
rewritten to use two top-level branches:
(?<=abc|abde)
The implementation of lookbehind assertions is, for each alternative, to temporarily move the current
position back by the fixed width and then try to match. If there are insufficient characters before the
current position, the match is deemed to fail.
PCRE does not allow the \C escape (which matches a single byte in UTF-8 mode) to appear in lookbehind
assertions, because it makes it impossible to calculate the length of the lookbehind. The \X escape, which
can match different numbers of bytes, is also not permitted.
Atomic groups can be used in conjunction with lookbehind assertions to specify efficient matching at the
end of the subject string. Consider a simple pattern such as
abcd$
when applied to a long string that does not match. Because matching proceeds from left to right, PCRE
will look for each "a" in the subject and then see if what follows matches the rest of the pattern. If the
pattern is specified as
^.*abcd$
the initial .* matches the entire string at first, but when this fails (because there is no following "a"), it
backtracks to match all but the last character, then all but the last two characters, and so on. Once again
the search for "a" covers the entire string, from right to left, so we are no better off. However, if the
pattern is written as
^(?>.*)(?<=abcd)
or, equivalently, using the possessive quantifier syntax,
^.*+(?<=abcd)
there can be no backtracking for the .* item; it can match only the entire string. The subsequent
lookbehind assertion does a single test on the last four characters. If it fails, the match fails immediately.
For long strings, this approach makes a significant difference to the processing time.
Using multiple assertions
C# PDF Page Insert Library: insert pages into PDF file in C#.net
page processing functions, such as how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C#
delete page in pdf file; cut pages from pdf reader
C# PDF File Split Library: Split, seperate PDF into multiple files
Besides, in the process of splitting PDF document, developers can also remove certain PDF page from target PDF file using C#.NET PDF page deletion API.
delete page pdf; delete pdf pages reader
181
Several assertions (of any sort) may occur in succession. For example,
(?<=\d{3})(?<!999)foo
matches "foo" preceded by three digits that are not "999". Notice that each of the assertions is applied
independently at the same point in the subject string. First there is a check that the previous three
characters are all digits, and then there is a check that the same three characters are not "999". This
pattern does not match "foo" preceded by six characters, the first of which are digits and the last three of
which are not "999". For example, it doesn't match "123abcfoo". A pattern to do that is
(?<=\d{3}...)(?<!999)foo
This time the first assertion looks at the preceding six characters, checking that the first three are digits,
and then the second assertion checks that the preceding three characters are not "999".
Assertions can be nested in any combination. For example,
(?<=(?<!foo)bar)baz
matches an occurrence of "baz" that is preceded by "bar" which in turn is not preceded by "foo", while
(?<=\d{3}(?!999)...)foo
is another pattern that matches "foo" preceded by three digits and any three characters that are not
"999".
CONDITIONAL SUBPATTERNS
It is possible to cause the matching process to obey a subpattern conditionally or to choose between two
alternative subpatterns, depending on the result of an assertion, or whether a previous capturing
subpattern matched or not. The two possible forms of conditional subpattern are
(?(condition)yes-pattern)
(?(condition)yes-pattern|no-pattern)
If the condition is satisfied, the yes-pattern is used; otherwise the no-pattern (if present) is used. If there
are more than two alternatives in the subpattern, a compile-time error occurs.
There are three kinds of condition. If the text between the parentheses consists of a sequence of digits,
the condition is satisfied if the capturing subpattern of that number has previously matched. The number
must be greater than zero. Consider the following pattern, which contains non-significant white space to
make it more readable (assume the PCRE_EXTENDED option) and to divide it into three parts for ease of
discussion:
( \( )?    [^()]+    (?(1) \) )
The first part matches an optional opening parenthesis, and if that character is present, sets it as the first
captured substring. The second part matches one or more characters that are not parentheses. The third
part is a conditional subpattern that tests whether the first set of parentheses matched or not. If they did,
that is, if subject started with an opening parenthesis, the condition is true, and so the yes-pattern is
executed and a closing parenthesis is required. Otherwise, since no-pattern is not present, the subpattern
matches nothing. In other words, this pattern matches a sequence of non-parentheses, optionally
enclosed in parentheses.
If the condition is the string (R), it is satisfied if a recursive call to the pattern or subpattern has been
made. At "top level", the condition is false. This is a PCRE extension. Recursive patterns are described in
the next section.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
delete a page from a pdf without acrobat; delete pages of pdf online
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
using RasterEdge.XDoc.PDF; Add and Insert a Page to PDF File Using VB. doc2.Save( outPutFilePath). Add and Insert Blank Page to PDF File Using VB.
add and remove pages from pdf file online; acrobat export pages from pdf
182
If the condition is not a sequence of digits or (R), it must be an assertion. This may be a positive or
negative lookahead or lookbehind assertion. Consider this pattern, again containing non-significant white
space, and with the two alternatives on the second line:
(?(?=[^a-z]*[a-z])
\d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} )
The condition is a positive lookahead assertion that matches an optional sequence of non-letters followed
by a letter. In other words, it tests for the presence of at least one letter in the subject. If a letter is found,
the subject is matched against the first alternative; otherwise it is matched against the second. This
pattern matches strings in one of the two forms dd-aaa-dd or dd-dd-dd, where aaa are letters and dd
are digits.
COMMENTS
The sequence (?# marks the start of a comment that continues up to the next closing parenthesis. Nested
parentheses are not permitted. The characters that make up a comment play no part in the pattern
matching at all.
If the PCRE_EXTENDED option is set, an unescaped # character outside a character class introduces a
comment that continues up to the next newline character in the pattern.
RECURSIVE PATTERNS
Consider the problem of matching a string in parentheses, allowing for unlimited nested parentheses.
Without the use of recursion, the best that can be done is to use a pattern that matches up to some fixed
depth of nesting. It is not possible to handle an arbitrary nesting depth. Perl provides a facility that allows
regular expressions to recurse (amongst other things). It does this by interpolating Perl code in the
expression at run time, and the code can refer to the expression itself. A Perl pattern to solve the
parentheses problem can be created like this:
$re = qr{\( (?: (?>[^()]+) | (?p{$re}) )* \)}x;
The (?p{...}) item interpolates Perl code at run time, and in this case refers recursively to the pattern in
which it appears. Obviously, PCRE cannot support the interpolation of Perl code. Instead, it supports
some special syntax for recursion of the entire pattern, and also for individual subpattern recursion.
The special item that consists of (? followed by a number greater than zero and a closing parenthesis is a
recursive call of the subpattern of the given number, provided that it occurs inside that subpattern. (If not,
it is a "subroutine" call, which is described in the next section.) The special item (?R) is a recursive call of
the entire regular expression.
For example, this PCRE pattern solves the nested parentheses problem (assume the PCRE_EXTENDED
option is set so that white space is ignored):
\( ( (?>[^()]+) | (?R) )* \)
First it matches an opening parenthesis. Then it matches any number of substrings which can either be a
sequence of non-parentheses, or a recursive match of the pattern itself (that is a correctly parenthesized
substring). Finally there is a closing parenthesis.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
cut pages from pdf online; delete pdf pages online
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
document file, and choose to create a new PDF file in .NET NET document imaging toolkit, also offers other advanced PDF document page processing and
delete a page in a pdf file; delete blank page in pdf
183
If this were part of a larger pattern, you would not want to recurse the entire pattern, so instead you
could use this:
( \( ( (?>[^()]+) | (?1) )* \) )
We have put the pattern into parentheses, and caused the recursion to refer to them instead of the whole
pattern. In a larger pattern, keeping track of parenthesis numbers can be tricky. It may be more
convenient to use named parentheses instead. For this, PCRE uses (?P>name), which is an extension to the
Python syntax that PCRE uses for named parentheses (Perl does not provide named parentheses). We
could rewrite the above example as follows:
(?P<pn> \( ( (?>[^()]+) | (?P>pn) )* \) )
This particular example pattern contains nested unlimited repeats, and so the use of atomic grouping for
matching strings of non-parentheses is important when applying the pattern to strings that do not match.
For example, when this pattern is applied to
(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
it yields "no match" quickly. However, if atomic grouping is not used, the match runs for a very long time
indeed because there are so many different ways the + and * repeats can carve up the subject, and all
have to be tested before failure can be reported.
At the end of a match, the values set for any capturing subpatterns are those from the outermost level of
the recursion at which the subpattern value is set. If you want to obtain intermediate values, a callout
function can be used (see the next section and the pcrecallout documentation). If the pattern above is
matched against
(ab(cd)ef)
the value for the capturing parentheses is "ef", which is the last value taken on at the top level. If
additional parentheses are added, giving
\( ( ( (?>[^()]+) | (?R) )* ) \)
^                        ^
^                        ^
the string they capture is "ab(cd)ef", the contents of the top level parentheses. If there are more than 15
capturing parentheses in a pattern, PCRE has to obtain extra memory to store data during a recursion,
which it does by using pcre_malloc, freeing it via pcre_free afterwards. If no memory can be obtained, the
match fails with the PCRE_ERROR_NOMEMORY error.
Do not confuse the (?R) item with the condition (R), which tests for recursion. Consider this pattern, which
matches text in angle brackets, allowing for arbitrary nesting. Only digits are allowed in nested brackets
(that is, when recursing), whereas any characters are permitted at the outer level.
< (?: (?(R) \d++  | [^<>]*+) | (?R)) * >
In this pattern, (?(R) is the start of a conditional subpattern, with two different alternatives for the recursive
and non-recursive cases. The (?R) item is the actual recursive call.
SUBPATTERNS AS SUBROUTINES
If the syntax for a recursive subpattern reference (either by number or by name) is used outside the
parentheses to which it refers, it operates like a subroutine in a programming language. An earlier
184
example pointed out that the pattern
(sens|respons)e and \1ibility
matches "sense and sensibility" and "response and responsibility", but not "sense and responsibility". If
instead the pattern
(sens|respons)e and (?1)ibility
is used, it does match "sense and responsibility" as well as the other two strings. Such references must,
however, follow the subpattern to which they refer.
CALLOUTS
Perl has a feature whereby using the sequence (?{...}) causes arbitrary Perl code to be obeyed in the
middle of matching a regular expression. This makes it possible, amongst other things, to extract
different substrings that match the same pair of parentheses when there is a repetition.
PCRE provides a similar feature, but of course it cannot obey arbitrary Perl code. The feature is called
"callout". The caller of PCRE provides an external function by putting its entry point in the global variable 
pcre_callout. By default, this variable contains NULL, which disables all calling out.
Within a regular expression, (?C) indicates the points at which the external function is to be called. If you
want to identify different callout points, you can put a number less than 256 after the letter C. The default
value is zero. For example, this pattern has two callout points:
(?C1)\dabc(?C2)def
If the PCRE_AUTO_CALLOUT flag is passed to pcre_compile(), callouts are automatically installed before
each item in the pattern. They are all numbered 255.
During matching, when PCRE reaches a callout point (and pcre_callout is set), the external function is
called. It is provided with the number of the callout, the position in the pattern, and, optionally, one item
of data originally supplied by the caller of pcre_exec(). The callout function may cause matching to
proceed, to backtrack, or to fail altogether. A complete description of the interface to the callout function
is given in the pcrecallout documentation.
Misc & Hidden functions
Overview
There are some functions that are 'hidden' within theWord and are only useful in very specific situations.
Finding the line in an .ont file that corresponds to a verse
If you are editing an .ont file, it is useful to be able to find the line number in the .ont that a specific verse
is. To do this, you can press CTRL+ALT+INSERT in any Bible view and a popup dialog will give you the
info you need:
185
Locating errors
theWord logs any errors that happen in a file called errors.log. This file can be found in the Cache folder
of your installation. If you need to manually submit a bug report, then you should attach this file also.
186
Copyrights and License information
Overview
The copyright and license for theWord and paid modules is included here.
Notice that modules that are distributed for free may also be copyrighted by their respective publishers.
Please, read carefully the license and copyright restrictions before using the software or any
accompanying modules.
theWord license
This is the standard license of theWord. It is also included in the software and appears when you click on 
Help-> About.
This Software ("In the beginning was theWord", abbreviated theWord) is
copyrighted.
© 2003-2012 - Costas Stergiou
Please read this license agreement carefully. You may only use theWord if you
agree to the entire license agreement. 
The Author of this Software (referenced throughout this license agreement) is
Costas Stergiou.
The copyright applies to all the program files (e.g. the theword.exe file, language
translation files etc), all documentation accompanying this program, and all add-
ons (Bible and Book module add-ons). In general, all files that can be
downloaded from the official website (http://www.theword.net
) are under this
license agreement, unless otherwise stated in individual licenses of add-on
modules (this applies particularly to add-on modules that are copyrighted by
their authors and/or publishers).
theWord is free software (free to use). This means that the Software is available
for use without any charge attached to it. theWord is not open source software.
The source code is not free or available to download or view.
This license is designed to ensure that theWord remains free for everyone and is
not used in any way to promote any profit generating activities that are outside
the scope of the Software. Exceptions to this rule apply only if there is a written
agreement with the Author of the Software. 
You can copy theWord freely for personal use and give it away to friends,
relatives, etc., as long as you do not charge for it in any way. You may not
charge for duplication costs, media costs, or even postage costs. If you
undertake the task of giving copies of theWord to others, you must do it for
free. You may not sell or resell this program or distribute it as a part of a
commercial package or any other profit generating activity, even if the
distribution is free. You may not bundle the Software (even if the media is free)
with any other product (e.g. enclose in a book, distribute with tracts) or make it
appear that the Software is an add-on, bonus pack, extra-service, etc., that the
end-user gets as a bonus for any service, product, activity of yours.
You may not host theWord software executable files, installation files, or any
other official files that can be found at the official website (http://www.theword.
net
) on your website. You may not post any files or archives containing the
Software itself or any other files related to the Software in any software
187
repository, peer-to-peer network, or other file-sharing website or program.
theWord is designed in a way so that it can be extended with add-on modules.
The structure of add-on files (Bibles, Books, language files, etc) is open and
documented in order to allow you to compile your own modules or build utilities
and auxiliary programs to enhance the functionality of the Software. You may not
charge for add-on modules or auxiliary utilities without written permission from
the Author. Under the spirit of this clause, you may examine and/or reverse
engineer the structure of add-on modules in order to create your own modules.
You may not reverse-engineer the program binary file (theword.exe) or any
encrypted module. Some modules are encrypted to protect their copyrighted
content from unauthorized duplication. You must respect this protection and not
attempt to copy, extract, modify, and/or reuse such content. If you are unsure
about copyrights and/or this protection, please contact the Author (
root@theword.net
).
The origin of this Software must not be misrepresented. You must not claim that
you wrote this Software. If you choose to redistribute the Software as part of an
"official" package (e.g. your own CD compilation with a custom CD cover or
label) you must:
1. State clearly on the CD itself (and the cover if applicable) that the Software is
not written by you 
2. Place a link to http://www.theword.net
in a noticeable area on the CD label
and cover
3. Contact the Author (root@theword.net
) to obtain written permission. All valid
electronic media distributions of the Software (e.g. CD, DVD, USB flash drive,
etc.) will be listed, along with a picture of the actual media, on a noticeable
area on the official website (http://www.theword.gr/license
)  so users will know
whether or not the distribution is legal.
This Software is provided by the Author "as is". Any express or implied
warranties, including, but not limited to, the implied warranties of merchantability
and fitness for a particular purpose are disclaimed. In no event shall the Author
or contributors be liable for any direct, indirect, incidental, special, exemplary, or
consequential damages (including, but not limited to, procurement of substitute
goods or services; loss of use, data, or profits; or business interruption)
however caused and on any theory of liability, whether in contract, strict liability,
or tort (including negligence or otherwise) arising in any way out of the use of,
or inability to use, this Software, even if advised of the possibility of such
damage.
I, Costas Stergiou (the Author), reserve the right to make exceptions to any of
these conditions, or alter these conditions, at any time. For every exception to
the above rules, a notice will be available at the official website at http://www.
theword.gr/license
. If you are aware that any of these terms have been violated,
please refer to the previous link and report it. 
Costas Stergiou
Greece
root@theword.net
http://www.theword.net
Documents you may be interested
Documents you may be interested