c# free pdf viewer : Add page to existing pdf file software Library cloud windows .net html class Pro_Silverlight_5_in_CSharp_4th_edition19-part81

CHAPTER 5  ELEMENTS 
179 
Table 5-4. Values for the AutoCompleteFilterMode Enumeration 
Name 
Description 
None 
No filtering will be performed, and all the items will appear in the list of 
suggestions. This is also the option you’ll use if you need to fetch the 
collection of items yourself—for example, if you need to query them from a 
database or request them from a web service. 
StartsWith 
All the items that start with the typed-in text will appear. This is the default. 
StartsWithCaseSensitive All the items that start with the typed-in text will appear provided the 
capitalization also matches. 
Contains 
All the items that contain the typed-in text will appear. For example, typing 
ember would match SeptemberNovember, and December. 
ContainsCaseSensitive All the items that contain the typed-in text will appear provided the 
capitalization also matches. 
Custom 
You must perform the filtering by applying a delegate that does the work to 
the TextFilter or ItemFilter property. In fact, if you set TextFilter or ItemFilter 
the FilterMode property is automatically switched to Custom. 
Custom Filtering 
To perform any sort of custom filtering, you must set the TextFilter or ItemFilter property. Use TextFilter 
if your ItemsSource is a collection or strings, and use ItemFilter if your ItemsSource is a collection with 
some other sort of object. Either way, the TextFilter or ItemFilter property takes a delegate that points to 
a method that performs the custom filtering. This method takes two arguments: the text that the user has 
entered so far and the item that you’re currently testing for a match. 
public bool ItemFilter(string text, object item) 
{ ... } 
The code in the filtering method should perform whatever comparison logic you need and return 
true if the item should be included as a drop-down suggestion based on the current text or false if it 
should be omitted. 
Custom filtering is particularly useful if you’re comparing text against a list of complex objects. 
That’s because it allows you to incorporate the information that’s stored in different properties. 
For example, imagine you have this simple Product class: 
public class Product 
public string ProductName { getset; } 
public string ProductCode { getset; } 
public Product(string productName, string productCode) 
www.it-ebooks.info
Add page to existing pdf file - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
add page numbers to pdf using preview; add a page to pdf file
Add page to existing pdf file - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page number pdf file; adding page numbers to pdf document
CHAPTER 5  ELEMENTS 
180 
ProductName = productName; 
ProductCode = productCode; 
public override string ToString() 
return ProductName; 
You then decide to build an AutoCompleteBox that attempts to match the user’s text with a Product 
object. In preparation for this step, you fill the AutoComplexBox.ItemsSource collection with product 
objects: 
Product[] products = new []{ 
new Product("Peanut Butter Applicator""C_PBA-01"), 
new Product("Pelvic Strengthener""C_PVS-309"), ...}; 
acbProduct.ItemsSource = products; 
If you take no further steps, the AutoCompleteBox will use its standard behavior. As the user types, it 
will call ToString() on each Product object. It will then use that text to perform its suggestion filtering. 
Because the Product class overrides the ToString() method to return the product name, the 
AutoCompleteBox will attempt to match the user’s text with a product name, which is perfectly 
reasonable. 
However, if you perform custom filtering, you can get a bit more sophisticated. For example, you 
can check whether the user’s text matches the ProductName property or the ProductCode property and 
deem the Product object as a match either way. Here’s an example of the custom filtering logic that does 
the trick: 
public bool ProductItemFilter(string text, object item) 
Product product = (Product)item; 
// Call it a match if the typed-in text appears in the product code 
// or at the beginning of the product name. 
return ((product.ProductName.StartsWith(text)) || 
(product.ProductCode.Contains(text))); 
You simply need to connect this method to your AutoComplexBox when it’s first initialized: 
acbProduct.ItemFilter = ProductItemFilter; 
Now if the user types the text PBA, it matches the product code C_PBA-01 and shows the matching 
item Peanut Butter Applicator in the list of suggestions, as shown in Figure 5-15. 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages. Copy, Paste, Cut Image in Page. Link: Edit Redact Pages. Annotation & Drawing. Add Sticky Note
add page to pdf without acrobat; add and delete pages from pdf
C# PDF File Compress Library: Compress reduce PDF size in C#.net
this PDF document compressing control is designed to offer C# developers to compress existing PDF documents in Embedded page thumbnails. Add necessary references
adding a page to a pdf in preview; add pages to pdf
CHAPTER 5  ELEMENTS 
181 
Figure 5-15. A custom search that matches product codes 
Dynamic Item Lists 
So far, you’ve used the ItemsSource property to fill the AutoCompleteBox with a collection of 
suggestions. For this to work, you must have the complete list, and it must be a manageable size. If you 
need to pull the information from somewhere else or the list is large enough that it isn’t practical to load 
the whole thing at once, you’ll need to take a different approach to filling the AutoCompleteBox. Instead 
of setting the ItemsSource property when the page is first created, you’ll need to set it in real time, as the 
user types. 
To do so, set the FilterMode property to None, and handle the Populating event. The Populating 
event fires whenever the AutoCompleteBox is ready to search for results. By default, this happens every 
time the user presses a key and changes the current text entry. You can make the AutoCompleteBox 
somewhat more relaxed using the MinimumPrefixLength and MinimumPopupDelay properties that are 
discussed at the end of this section. 
<input:AutoCompleteBox x:Name="acbProducts" FilterMode="None" 
Populating="acbProducts_Populating" ></input:AutoCompleteBox> 
When the Populating event fires, you have two choices: set the ItemsSource property immediately 
or launch an asynchronous process to do it. Setting the ItemsSource property immediately makes sense 
if you have the list of suggestions on hand or you can generate them quickly. The list of suggestions will 
then appear in the drop-down list right away. 
But in many situations, you’ll need a potentially time-consuming step to get the list of suggestions, 
such as performing a series of calculations or querying a web service. In this situation, you need to 
launch an asynchronous process. Although you can accomplish this with the multithreading support 
that’s described in Chapter 16, you won’t necessarily need to. Some Silverlight features have built-in 
asynchronous support. This is the case with Silverlight’s implementation of web services, which is 
hardwired to use asynchronous calls exclusively. 
When using an asynchronous operation, you need to explicitly cancel the normal processing in the 
Populating event handler, by setting PopulatingEventArgs.Cancel to true. You can then launch the 
asynchronous operation. The following example gets the suggestion list asynchronously from a web 
service. (You’ll learn much more about coding and consuming web services in Chapter 19. For now, you 
can review the example code and the downloadable project with this chapter.) 
www.it-ebooks.info
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Add multiple images to multipage PDF document in .NET WinForms. Ability to put image into specified PDF page position and save existing PDF file or output a
add page number to pdf in preview; add page to pdf in preview
VB.NET PDF insert image library: insert images into PDF in vb.net
Add images to any selected PDF page in VB.NET. Ability to put image into defined location on PDF page. Save changes to existing PDF file or output a new PDF file
add pages to pdf reader; adding page numbers to pdf documents
CHAPTER 5  ELEMENTS 
182 
private void acbProducts_Populating(object sender, PopulatingEventArgs e) 
// Signal that the task is being performed asynchronously. 
e.Cancel = true
// Create the web service object. 
ProductAutoCompleteClient service = new ProductAutoCompleteClient(); 
// Attach an event handler to the completion event. 
service.GetProductMatchesCompleted += GetProductMatchesCompleted; 
// Call the web service (asynchronously). 
service.GetProductMatchesAsync(e.Parameter); 
On the web server, the code in a GetProductMathes() web method runs and retrieves the matches: 
public string[] GetProductMatches(string inputText) 
{      
// Get the products (for example, from a server-side database). 
Product[] products = GetProducts(); 
// Create a collection of matches. 
List<string> productMatches = new List<string>(); 
foreach (Product product in products) 
// See if this is a match. 
if ((product.ProductName.StartsWith(inputText)) || 
(product.ProductCode.Contains(inputText))) 
productMatches.Add(product.ProductName); 
// Return the list of matches. 
return productMatches.ToArray(); 
When the asynchronous operation finishes and you receive the result in your Silverlight application, 
you fill the ItemsSource property with the list of suggestions. Then, you must call the 
PopulateComplete() method to notify the AutoCompleteBox that the new data has arrived. Here’s the 
callback handler that does the job in the current example: 
private void GetProductMatchesCompleted(object sender, 
GetProductMatchesCompletedEventArgs e) 
// Check for a web service error. 
if (e.Error != null
lblStatus.Text = e.Error.Message; 
return
www.it-ebooks.info
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
applications to delete any unnecessary page from target existing PDF document file. C#.NET Project DLLs for Deleting PDF Document Page. Add necessary references
add pages to an existing pdf; add a page to a pdf online
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Existing PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Delete PDF Page. DLLs for Deleting Page from PDF Document in VB.NET Class. Add necessary references:
add page number to pdf preview; add page numbers to a pdf in preview
CHAPTER 5  ELEMENTS 
183 
// Set the suggestions. 
acbProducts.ItemsSource = e.Result; 
// Notify the control that the data has arrived. 
acbProducts.PopulateComplete();  
When filling the AutoCompleteBox with a time-consuming or asynchronous step, there are two 
properties you may want to adjust: MinimumPrefixLength and MinimumPopupDelay. 
MinimumPrefixLength determines how much text must be typed in before the AutoCompleteBox gives 
its suggestions. Ordinarily, the AutoCompleteBox offers suggestions after the first letter is entered. If you 
want it to wait for three letters (the standard used by many of the Ajax-powered autocompletion text 
boxes that you’ll find on the Web), set MinimumPrefixLength to 3. Similarly, you can force the 
AutoCompleteBox to hold off until a certain interval of time has passed since the user’s last keystroke 
using the MinimumPopulateDelay property. This way, you won’t waste time with a flurry of overlapping 
calls to a slow web service. Of course, this doesn’t necessarily determine how long it takes for the 
suggestions to appear—that depends on the wait before initiating the query and then the time needed to 
contact the web server and receive a response. 
The RichTextBox 
If you’ve programmed with WPF before, you are probably familiar with its flow document model—a 
flexible system for displaying richly formatted, read-only content. Compared to ordinary text display 
(say, with the TextBlock element), flow documents support advanced features such as balanced 
columns, text wrapping around floating figures, and intelligent algorithms for letter spacing, word 
wrapping, and hyphenation. Silverlight doesn’t include the flow document feature, but it does borrow 
part of the same model to support one of its most impressive controls: the RichTextBox. 
The RichTextBox is an editable text box control that supports rich formatting. Unlike the ordinary 
TextBox control, the RichTextBox allows individual sections (say, a single word or an entire paragraph) 
to be formatted with a different font and color. The RichTextBox also supports images, links, and inline 
elements (like drop-down lists and buttons). Best of all, the RichTextBox is easy to use in any 
application. 
Text Elements 
Before you can understand the RichTextBox, you need to know a bit about the model it uses. While an 
ordinary text box shows holds a string of text, the RichTextBox holds an entire document, which is 
represented by a collection of text elements (sometimes called flow elements, because they are used to 
create flow documents). 
Text elements have an important difference from the elements you’ve seen so far. They don’t inherit 
from the familiar UIElement and FrameworkElement classes. Instead, they form an entirely separate 
branch of classes that derive first from DependencyObject and then from TextElement. As you might 
expect, they are also far simpler, supporting no events and providing a small set of mostly formatting-
related properties. Figure 5-16 shows the inheritance hierarchy for text elements. 
www.it-ebooks.info
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Add necessary references Visual Basic coding example will help you open an encrypted PDF file.
add blank page to pdf; add page numbers pdf file
C# PDF Password Library: add, remove, edit PDF file password in C#
your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via Add necessary references
add pages to pdf preview; add and remove pages from pdf file online
CHAPTER 5  ELEMENTS 
184 
Figure 5-16. Text elements 
There are two key branches of text elements: 
• Block elements: There are two block element classes: Paragraph and Section. 
Paragraphs can hold text and a combination on inline elements. Sections can hold 
a group of paragraphs (or a group of sections), but they must be created 
programmatically, as they aren’t usable in XAML. 
• Inline elements: These elements are nested inside a block element (or another 
inline element). They include elements for formatting text (Bold, Italic, Underline, 
Run), making hard line breaks (LineBreak), adding hyperlinks (Hyperlink), and 
embedding other controls (InlineUIContainer). Finally, the Span container gives 
you the ability to group together multiple inline elements in one container. 
www.it-ebooks.info
CHAPTER 5  ELEMENTS 
185 
This text element model allows multiple layers of nesting. For example, you can place a Bold 
element inside an Underline element to create text that’s both bold and underlined. Similarly, you might 
create a Section element that wraps together multiple Paragraph elements, each of which contains a 
variety of inline elements with the actual text content. All of these elements are defined in the 
System.Windows.Documents namespace. 
 Note  You may remember the inline elements from the TextBlock discussion earlier in this chapter. In fact, the 
ally, it’s a container that holds a 
The following example shows a RichTextBox with some hard-coded document content already filled 
in: 
<RichTextBox Margin="5" x:Name="richText">  
<Paragraph Foreground="DarkRed" FontFamily="Trebuchet MS" FontSize="22" 
FontWeight="Bold" TextAlignment="Center">Chapter I</Paragraph> 
<Paragraph> 
<Bold><Italic><Run FontSize="12">The Period</Run></Italic></Bold> 
</Paragraph> 
<Paragraph> 
<LineBreak></LineBreak> 
</Paragraph>  
<Paragraph> 
</Paragraph>  
</RichTextBox> 
Figure 5-17 shows how this markup is rendered. 
www.it-ebooks.info
CHAPTER 5  ELEMENTS 
186 
Figure 5-17. A simple document 
This example is enough to illustrate the key details of the text element model. First, every 
RichTextBox holds a collection of block elements. In this case, the RichTextBox holds four Paragraph 
objects, which hold still more objects nested inside, such as Bold, Italic, and Run to apply formatting, 
and LineBreak to add some empty space between paragraph. (Ordinarily, there is none.) 
Formatting Text Elements 
You can use two broad approaches to applying formatting. The first is to use the properties of the 
appropriate text element class, most of which are inherited from the base class TextElement. The 
previous example used this approach to set the formatting for the chapter title in the first paragraph and 
to apply formatting to a Run in the second paragraph. Table 5-5 lists all the properties you can set. 
Table 5-5. Properties for Content Elements 
Name 
Description 
Foreground  
Accept brushes that will be used to paint the foreground text. You 
can’t set a background for individual text elements, although you can 
set a background for the entire document using the 
RichTextBox.Background property. 
www.it-ebooks.info
CHAPTER 5  ELEMENTS 
187 
Name 
Description 
FontFamily, FontSize, 
FontStretch, FontStyle, and 
FontWeight 
Allow you to configure the font that’s used to display text. 
TextAlignment 
Sets the horizontal alignment of nested text content (which can be 
Left, Right, Center, or Justify). Ordinarily, content is justified. 
TextDecorations 
Allows you to add a line underneath the text. This property is provided 
only for inline objects. 
The second approach is to use a nested element that applies formatting automatically, such as Bold, 
Italic, or Underline. The previous example used this approach to apply bold and italic formatting to the 
title in the second paragraph. 
Truthfully, the second approach (using formatting elements) is a subset of the first (using formatting 
properties). That’s because using a formatting element is just a convenient shortcut to using a Run or 
Span with the same formatting. For example, using the Bold element is the same as setting the 
FontWeight property to Bold, using the Italic element is the same as setting the FontStyles property to 
Italic, and using the Underline element is the same as setting the TextDecorations property to 
Underline. 
Compared to WPF flow documents, the Silverlight text elements lack several features. For example, 
there is no way add extra spacing above or below paragraphs, there is no support for advanced text 
justification and letter-spacing algorithms, and there is no ability to float content or wrap text around 
the sides of figures. 
Manipulating Text Elements in Code 
Documents can also be explored and even created programmatically. The entry point to the content in 
the RichTextBox is the Blocks property, which holds a collection of block elements. It’s analogous to the 
Inlines property of the TextBlock, which holds a collection of inline elements. 
Creating a document programmatically is fairly tedious because of a number of disparate elements 
that need to be created. As with all XAML elements, you must create each element and then set all its 
properties, because there are no constructors to help you. You also need to create a Run object to wrap 
every piece of text and then add your Run objects to a suitable container (like a Paragraph object). This 
step isn’t required when you create a document with markup, because Silverlight automatically creates a 
Run object to wrap the text you place inside each Paragraph object. 
Here’s a snippet of code that creates a document with a single paragraph and some bolded text: 
// Create the first part of the sentence. 
Run runFirst = new Run(); 
runFirst.Text = "Hello world of "
// Create bolded text. 
Bold bold = new Bold(); 
Run runBold = new Run(); 
runBold.Text = "dynamically generated"
bold.Inlines.Add(runBold); 
www.it-ebooks.info
CHAPTER 5  ELEMENTS 
188 
// Create last part of sentence. 
Run runLast = new Run(); 
runLast.Text = " documents"
// Add three parts of sentence to a paragraph, in order. 
Paragraph paragraph = new Paragraph(); 
paragraph.Inlines.Add(runFirst); 
paragraph.Inlines.Add(bold); 
paragraph.Inlines.Add(runLast); 
// Add this paragraph to the RichTextBox. 
richText.Blocks.Clear(); 
richText.Blocks.Add(paragraph); 
The result is the sentence “Hello world of dynamically generated documents.” 
Most of the time, you won’t create flow documents programmatically. However, you might want to 
create an application that browses through portions of a flow document and modifies them dynamically. 
You can do this in the same way that you interact with any other WPF elements: by responding to 
element events and by attaching a name to the elements that you want to change. However, because 
flow documents use deeply nested content with a free-flowing structure, you may need to dig through 
several layers to find the actual content you want to modify. (Remember, this content is always stored in 
a Run object, even if the run isn’t declared explicitly.) 
 Tip  The previous example de
However, more complex scenarios are possible—for example, if you want to move through user-supplied content, 
find individual words, and tweak their formatting. This sort of task works better using the lower-level TextPointer 
class, which lets you find logical insertion points in the RichTextBox content. For a demonstration of this more 
advanced but less common technique, see 
http://tinyurl.com/26352z2
Creating a Text Editor 
Although you can create documents with handwritten XAML or build and manipulate them in code, the 
real goal of the RichTextBox is to provide a place where users can edit rich content. 
On its own, the RichTextBox works just like the TextBox control. The user can type text into it, edit 
that text, cut and paste a selection, and so on. However, there’s no built-in way for the user to apply 
formatting. To allow this, it’s up for you to add the appropriate controls, like a button for toggling bold 
formatting or a list for changing the font. Figure 5-18 shows an example. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested