open source pdf to image converter c# : Change pdf to fillable form control software platform web page windows html web browser 5236-part559

12.12.4 See Also 
Recipe 12.5
for how to process an RSS feed and transform it to HTML; PEAR's 
XML_RSS
class 
at http://pear.php.net/package-info.php?package=XML_RSS
; more information on RSS at 
http://groups.yahoo.com/group/rss-dev/files/specification.html
; O'Reilly Network's Meerkat at 
http://www.oreillynet.com/meerkat/
.  
Change pdf to fillable form - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
add photo to pdf form; change font size pdf fillable form
Change pdf to fillable form - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
best way to create pdf forms; adding form fields to pdf
Chapter 13. Regular Expressions 
Introduction
Switching From ereg to preg
Matching Words
Finding the nth Occurrence of a Match
Choosing Greedy or Nongreedy Matches
Matching a Valid Email Address
Finding All Lines in a File That Match a Pattern
Capturing Text Inside HTML Tags
Escaping Special Characters in a Regular Expression
Reading Records with a Pattern Separator
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Convert multiple pages Word to fillable and editable PDF documents. Ability to get word count of PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
pdf form creation; create a fillable pdf form from a pdf
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Create fillable and editable PDF documents from Excel in Visual Merge all Excel sheets to one PDF file in Change Excel hyperlink to PDF hyperlink and bookmark.
change font size in pdf form; edit pdf form
13.1 Introduction 
Regular expressions are a powerful tool for matching and manipulating text. While not as fast 
as plain-vanilla string matching, regular expressions are extremely flexible; they allow you to 
construct patterns to match almost any conceivable combination of characters with a simple, 
albeit terse and somewhat opaque syntax.  
In PHP, you can use regular expression functions to find text that matches certain criteria. 
Once located, you can choose to modify or replace all or part of the matching substrings. For 
example, this regular expression turns text email addresses into 
mailto
: hyperlinks:  
$html = preg_replace('/[^@\s]+@([-a-z0-9]+\.)+[a-z]{2,}/i', 
'<a href="mailto:$0">$0</a>', $text); 
As you can see, regular expressions are handy when transforming plain text into HTML and 
vice versa. Luckily, since these are such popular subjects, PHP has many built-in functions to 
handle these tasks. Recipe 9.9
tells how to escape HTML entities, Recipe 11.12
covers 
stripping HTML tags, and Recipe 11.10
and Recipe 11.11
show how to convert ASCII to HTML 
and HTML to ASCII, respectively. For more on matching and validating email addresses, see 
Recipe 13.7
.  
Over the years, the functionality of regular expressions has grown from its basic roots to 
incorporate increasingly useful features. As a result, PHP offers two different sets of regular-
expression functions. The first set includes the traditional (or POSIX) functions, all beginning 
with 
ereg
(for extended regular expressions; the 
ereg
functions themselves are already an 
extension of the original feature set). The other set includes the Perl family of functions, 
prefaced with 
preg
(for Perl-compatible regular expressions).  
The 
preg
functions use a library that mimics the regular expression functionality of the Perl 
programming language. This is a good thing because Perl allows you to do a variety of handy 
things with regular expressions, including nongreedy matching, forward and backward 
assertions, and even recursive patterns.  
In general, there's no longer any reason to use the 
ereg
functions. They offer fewer features, 
and they're slower than 
preg
functions. However, the 
ereg
functions existed in PHP for many 
years prior to the introduction of the 
preg
functions, so many programmers still use them 
because of legacy code or out of habit. Thankfully, the prototypes for the two sets of functions 
are identical, so it's easy to switch back and forth from one to another in your mind without 
too much confusion. (We list how to do this while avoiding the major gotchas in Recipe 13.2
.)  
The basics of regular expressions are simple to understand. You combine a sequence of 
characters to form a pattern. You then compare strings of text to this pattern and look for 
matches. In the pattern, most characters represent themselves. So, to find if a string of HTML 
contains an image tag, do this:  
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. Convert multiple pages PowerPoint to fillable and editable PDF documents.
allow saving of pdf form; allow users to save pdf form
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Convert multiple pages Word to fillable and editable PDF documents in Able to get word count in PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
add form fields to pdf without acrobat; chrome save pdf form
if (preg_match('/<img /', $html)) { 
// found an opening image tag 
The 
preg_match( )
function compares the pattern of 
"<img "
against the contents of 
$html
. If it finds a match, it returns 1; if it doesn't, it returns 0. The 
/
characters are called 
pattern delimiters ; they set off the start and end of the pattern.  
A few characters, however, are special. The special nature of these characters are what 
transforms regular expressions beyond the feature set of 
strstr( )
and 
strpos( )
. These 
characters are called metacharacters. The most frequently used metacharacters include the 
period (.), asterisk (
*
), plus (
+
), and question mark (
?
). To match an actual metacharacter, 
precede the character with a backslash(\).  
· 
The period matches any character, so the pattern 
/.at/
matches 
bat
cat
, and even 
rat
 
· 
The asterisk means match 0 or more of the preceding object. (Right now, the only 
objects we know about are characters.)  
· 
The plus is similar to asterisk, but it matches 1 or more instead of or more. So, 
/.+at/
matches 
brat
sprat
, and even 
catastrophe
, but not 
at
. To match 
at
replace the 
+
with a 
*
.  
· 
The question mark matches 0 or 1 objects. 
To apply 
*
and 
+
to objects greater than one character, place the sequence of characters 
inside parentheses. Parentheses allow you to group characters for more complicated matching 
and also capture the part of the pattern that falls inside them. A captured sequence can be 
referenced in 
preg_replace( )
to alter a string, and all captured matches can be stored in 
an array that's passed as a third parameter to 
preg_match( )
and 
preg_match_all( )
The 
preg_match_all( )
function is similar to 
preg_match( )
, but it finds all possible 
matches inside a string, instead of stopping at the first match. Here are some examples:  
if (preg_match('/<title>.+<\/title>/', $html)) { 
// page has a title 
if (preg_match_all('/<li>/', $html, $matches)) { 
print 'Page has ' . count($matches[0]) . " list items\n"; 
// turn bold into italic 
$italics = preg_replace('/(<\/?)b(>)/', '$1i$2', $bold); 
If you want to match strings with a specific set of letters, create a character class with the 
letters you want. A character class is a sequence of characters placed inside square brackets. 
The caret (
^
) and the dollar sign (
$
) anchor the pattern at the beginning and the end of the 
string, respectively. Without them, a match can occur anywhere in the string. So, to match 
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Convert multiple pages PowerPoint to fillable and editable PDF documents. Easy to create searchable and scanned PDF files from PowerPoint.
build pdf forms; create pdf form
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Create fillable and editable PDF documents from Excel in both .NET WinForms and ASP.NET. Create searchable and scanned PDF files from Excel.
pdf create fillable form; create a pdf form to fill out
only vowels, make a character class containing 
a
e
i
o
, and 
u
; start your pattern with 
^;
and end it with 
$
 
preg_match('/^[aeiou]+$/', $string); // only vowels 
If it's easier to define what you're looking for by its complement, use that. To make a 
character class match the complement of what's inside it, begin the class with a caret. A caret 
outside a character class anchors a pattern at the beginning of a string; a caret inside a 
character class means "match everything except what's listed in the square brackets":  
preg_match('/^[^aeiou]+$/', $string) // only non-vowels 
Note that the opposite of 
[aeiou]
isn't 
[bcdfghjklmnpqrstvwxyz]
. The character class 
[^aeiou]
also matches uppercase vowels such as 
AEIOU
, numbers such as 
123
, URLs such 
as 
http://www.cnpq.br/
, and even emoticons such as 
:)
.  
The vertical bar (
|
), also known as the pipe, specifies alternatives. For example:  
// find a gif or a jpeg 
preg_match('/(gif|jpeg)/', $images); 
Beside metacharacters, there are also metasymbols. Metasymbols are like metacharacters, 
but are longer than one character in length. Some useful metasymbols are 
\w
(match any 
word character, 
[a-zA-Z0-9_]
); 
\d
(match any digit, 
[0-9]
); 
\s
(match any whitespace 
character), and 
\b
(match a word boundary). Here's how to find all numbers that aren't part 
of another word:  
// find digits not touching other words 
preg_match_all('/\b\d+\b/', $html, $matches); 
This matches 
123
76!
, and 
38-years-old
, but not 
2nd
.  
Here's a pattern that is the regular expression equivalent of 
trim( )
:  
// delete leading whitespace or trailing whitespace 
$trimmed = preg_replace('/(^\s+)|(\s+$)/', '', $string); 
Finally, there are pattern modifiers. Modifiers effect the entire pattern, not just a character or 
group of characters. Pattern modifiers are placed after the trailing pattern delimiter. For 
example, the letter 
i
makes a regular expression pattern case-insensitive:  
// strict match lower-case image tags only (XHTML compliant) 
if (preg_match('/<img[^>]+>/', $html)) { 
... 
// match both upper and lower-case image tags 
if (preg_match('/<img[^>]+>/i', $html)) { 
C# Create PDF Library SDK to convert PDF from other file formats
Create fillable PDF document with fields. Load PDF from existing documents and image in SQL server. Load PDF from stream programmatically.
change font size in fillable pdf form; cannot save pdf form in reader
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
An advanced .NET control to change ODT, ODS, ODP forms to fillable PDF formats in Visual C# .NET. Online source code for C#.NET class.
create a pdf form from excel; add text field to pdf acrobat
... 
We've covered just a small subset of the world of regular expressions. We provide some 
additional details in later recipes, but the PHP web site also has some very useful information 
on POSIX regular expressions at http://www.php.net/regex
and on Perl-compatible regular 
expressions at http://www.php.net/pcre
. The links from this last page to "Pattern Modifiers" 
and "Pattern Syntax" are especially detailed and informative.  
The best books on this topic are Mastering Regular Expressions by Jeffrey Friedl, and 
Programming Perl by Larry Wall, Tom Christiansen, and Jon Orwant, both published by 
O'Reilly. (Since the Perl-compatible regular expressions are based on Perl's regular 
expressions, we don't feel too bad suggesting a book on Perl.) 
Recipe 13.2 Switching From ereg to preg 
13.2.1 Problem 
You want to convert from using 
ereg
functions to 
preg
functions.  
13.2.2 Solution 
First, you have to add delimiters to your patterns: 
preg_match('/pattern/', 'string') 
For 
eregi( )
case-insensitive matching, use the 
/i
modifier instead:  
preg_match('/pattern/i', 'string'); 
When using integers instead of strings as patterns or replacement values, convert the number 
to hexadecimal and specify it using an escape sequence:  
$hex = dechex($number); 
preg_match("/\x$hex/", 'string'); 
13.2.3 Discussion 
There are a few major differences between 
ereg
and 
preg
. First, when you use 
preg
functions, the pattern isn't just the string 
pattern
; it also needs delimiters, as in Perl, so it's 
/pattern/
instead.
[1]
So:  
[1]
Or 
{}
<>
||
##
, or whatever your favorite delimiters are. PHP 
supports them all. 
ereg('pattern', 'string'); 
becomes: 
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
Remove Password from PDF; Change PDF Permission Settings. Bookmark. Metadata: Edit, Delete Metadata. Form Process. ODT, ODS, ODP forms into fillable PDF formats.
changing font size in pdf form; pdf form creator
preg_match('/pattern/', 'string'); 
When choosing your pattern delimiters, don't put your delimiter character inside the regular-
expression pattern, or you'll close the pattern early. If you can't find a way to avoid this 
problem, you need to escape any instances of your delimiters using the backslash. Instead of 
doing this by hand, call 
addcslashes( )
 
For example, if you use 
/
as your delimiter: 
$ereg_pattern = '<b>.+</b>'; 
$preg_pattern = addcslashes($ereg_pattern, '/'); 
The value of 
$preg_pattern
is now 
<b>.+<\/b>
.  
The 
preg
functions don't have a parallel series of case-insensitive functions. They have a 
case-insensitive modifier instead. To convert, change:  
eregi('pattern', 'string'); 
to: 
preg_match('/pattern/i', 'string'); 
Adding the 
i
after the closing delimiter makes the change.  
Finally, there is one last obscure difference. If you use a number (not a string) as a pattern or 
replacement value in 
ereg_replace( )
, it's assumed you are referring to the ASCII value 
of a character. Therefore, since 9 is the ASCII representation of tab (i.e., 
\t
), this code inserts 
tabs at the beginning of each line:  
$tab = 9; 
$replaced = ereg_replace('^', $tab, $string); 
Here's how to convert linefeed endings:  
$converted = ereg_replace(10, 12, $text); 
To avoid this feature in 
ereg
functions, use this instead:  
$tab = '9'; 
On the other hand, 
preg_replace( )
treats the number 9 as the number 9, not as a tab 
substitute. To convert these character codes for use in 
preg_replace( )
, convert them to 
hexadecimal and prefix them with 
\x
. For example, 
9
becomes 
\x9
or 
\x09,
and 
12
becomes 
\x0c
. Alternatively, you can use 
\t
\r
, and 
\n
for tabs, carriage returns, and 
linefeeds, respectively.  
13.2.4 See Also 
Documentation on 
ereg( )
at http://www.php.net/ereg
preg_match( )
at 
http://www.php.net/preg-match
, and 
addcslashes( )
at http://www.php.net/addcslashes
Recipe 13.3 Matching Words 
13.3.1 Problem 
You want to pull out all words from a string.  
13.3.2 Solution 
The key to this is carefully defining what you mean by a word. Once you've created your 
definition, use the special character types to create your regular expression:  
/\S+/         // everything that isn't whitespace 
/[A-Z'-]+/i   // all upper and lowercase letters, apostrophes, and hyphens 
13.3.3 Discussion 
The simple question "what is a word?" is surprisingly complicated. While the Perl compatible 
regular expressions have a built-in word character type, specified by 
\w
, it's important to 
understand exactly how PHP defines a word. Otherwise, your results may not be what you 
expect.  
Normally, because it comes directly from Perl's definition of a word, 
\w
encompasses all 
letters, digits, and underscores; this means 
a_z
is a word, but the email address 
php@example.com
is not.  
In this recipe, we only consider English words, but other languages use different alphabets. 
Because Perl-compatible regular expressions use the current locale to define its settings, 
altering the locale can switch the definition of a letter, which then redefines the meaning of a 
word.  
To combat this, you may want to explicitly enumerate the characters belonging to your words 
inside a character class. To add a nonstandard character, use 
\ddd
, where 
ddd
is a 
character's octal code.  
13.3.4 See Also 
Recipe 16.3
for information about setting locales.  
Recipe 13.4 Finding the nth Occurrence of a Match 
13.4.1 Problem 
You want to find the nth word match instead of the first one.  
13.4.2 Solution 
Use 
preg_match_all( )
to pull all the matches into an array; then pick out the specific 
matches you're interested in:  
preg_match_all ("/$pattern/$modifiers", $string, $matches) 
foreach($matches[1] as $match) { 
print "$match\n"; 
13.4.3 Discussion 
Unlike in Perl, PHP's Perl-compatible regular expressions don't support the 
/g
modifier that 
allows you to loop through the string one match at a time. You need to use 
preg_match_all( )
instead of 
preg_match( )
.  
The 
preg_match_all( )
function returns a two-dimensional array. The first element holds 
an array of matches of the complete pattern. The second element also holds an array of 
matches, but of the parenthesized submatches within each complete match. So, to get the 
third 
potato
, you access the third element of the second element of the 
$matches
array:  
$potatoes = 'one potato two potato three potato four'; 
preg_match_all("/(\w+)\s+potato\b/", $potatoes, $matches); 
print $matches[1][2]; 
three 
Instead of returning an array divided into full matches and then submatches, 
preg_match_all( )
returns an array divided by matches, with each submatch inside. To 
trigger this, pass 
PREG_SET_ORDER
in as the fourth argument. Now, 
three
isn't in 
$matches[1][2]
, as previously, but in 
$matches[2][1]
.  
Check the return value of 
preg_match_all( )
to find the number of matches:  
print preg_match_all("/(\w+)\s+potato\b/", $potatoes, $matches); 
3 
Note that there are only three matches, not four, because there's no trailing 
potato
after the 
word 
four
in the string.  
13.4.4 See Also 
Documentation on 
preg_match_all( )
at http://www.php.net/preg-match-all
.  
Recipe 13.5 Choosing Greedy or Nongreedy Matches 
13.5.1 Problem 
You want your pattern to match the smallest possible string instead of the largest.  
13.5.2 Solution 
Place a 
?
after a quantifier to alter that portion of the pattern:  
// find all bolded sections 
preg_match_all('#<b>.+?</b>#', $html, $matches); 
Or, use the 
U
pattern modifier ending to invert all quantifiers from greedy to nongreedy:  
// find all bolded sections 
preg_match_all('#<b>.+</b>#U', $html, $matches); 
13.5.3 Discussion 
By default, all regular expressions in PHP are what's known as greedy. This means a quantifier 
always tries to match as many characters as possible.  
For example, take the pattern 
p.*
, which matches a 
p
and then 0 or more characters, and 
match it against the string 
php
. A greedy regular expression finds one match, because after it 
grabs the opening 
p
, it continues on and also matches the 
hp
. A nongreedy regular 
expression, on the other hand, finds a pair of matches. As before, it matches the 
p
and also 
the 
h
, but then instead of continuing on, it backs off and leaves the final 
p
uncaptured. A 
second match then goes ahead and takes the closing letter.  
The following code shows that the greedy match finds only one hit; the nongreedy ones find 
two:  
print preg_match_all('/p.*/', "php");  // greedy 
print preg_match_all('/p.*?/', "php"); // nongreedy 
print preg_match_all('/p.*/U', "php"); // nongreedy 
1 
2 
2 
Greedy matching is also known as maximal matching and nongreedy matching can be called 
minimal matching, because these options match either the maximum or minimum number of 
characters possible.  
Initially, all regular expressions were strictly greedy. Therefore, you can't use this syntax with 
ereg( )
or 
ereg_replace( )
. Greedy matching isn't supported by the older engine that 
powers these functions; instead, you must use Perl-compatible functions.  
Documents you may be interested
Documents you may be interested