c# .net pdf reader : Adding page numbers to pdf in preview software application dll winforms html wpf web forms Pro_Silverlight_5_in_CSharp_4th_edition6-part126

CHAPTER 2  XAML 
47 
BROWSING NESTED ELEMENTS WITH VISUALTREEHELPER 
e hierarchy elements. The 
VisualTreeHelper class provides three static methods for this purpose: GetParent(), which returns the 
element that contains a specified element; GetChildrenCount(), which indicates how many elements are 
nested inside the specified element; and GetChild(),which retrieves one of the nested elements, by its index 
number position. 
The advantage of VisualTreeHelper is that it works in a generic way that supports all Silverlight elements, 
no matter what content model they use. For example, you may know that list controls expose items 
through an Items property, layout containers provide their children through a Children property, and 
content controls expose the nested content element through a Content property, but only the 
VisualTreeHelper can dig through all three with the same seamless code. 
The disadvantage to using the VisualTreeHelper is that it gets every detail of an element’s visual 
composition, including some that aren’t important to its function. For example, when you use 
VisualTreeHelper to browse through a ListBox, you’ll come across a few low-level details that probably 
don’t interest yo
Grid that lays out items in discrete rows. For this reason, the only practical way to use the VisualTreeHelper 
is with recursive code—in essence, you keep digging through the tree until you find the type of element 
you’re interested in, and then you act on it. The following example uses this technique to clear all the text 
boxes in a hierarchy of elements: 
private void Clear(DependencyObject element) 
// If this is a text box, clear the text. 
TextBox txt = element as TextBox
if (txt != null) txt.Text = ""
// Check for nested children. 
int children = VisualTreeHelper.GetChildrenCount(element); 
for (int i = 0; i < children; i++) 
DependencyObject child = VisualTreeHelper.GetChild(element, i); 
Clear(child); 
To set it in motion, call the Clear() method with the topmost object you want to examine. Here’s how to 
dissect the entire current page: 
Clear(this); 
Events 
So far, all the attributes you’ve seen map to properties. However, attributes can also be used to attach 
event handlers. The syntax for this is EventName="EventHandlerMethodName". 
For example, the Button control provides a Click event. You can attach an event handler like this: 
www.it-ebooks.info
Adding page numbers to pdf in preview - 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
adding page numbers to a pdf document; add or remove pages from pdf
Adding page numbers to pdf in preview - 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 numbers to pdf online; add page numbers to pdf using preview
CHAPTER 2  XAML 
48 
<Button ... Click="cmdAnswer_Click"> 
This assumes that there is a method with the name cmdAnswer_Click in the code-behind class. The 
event handler must have the correct signature (that is, it must match the delegate for the Click event). 
Here’s the method that does the trick: 
private void cmdAnswer_Click(object sender, RoutedEventArgs e) 
{  
AnswerGenerator generator = new AnswerGenerator(); 
txtAnswer.Text = generator.GetRandomAnswer(txtQuestion.Text); 
In many situations, you’ll use attributes to set properties and attach event handlers on the same 
element. Silverlight always follows the same sequence: first it sets the Name property (if set), then it 
attaches any event handlers, and lastly it sets the properties. This means that any event handlers that 
respond to property changes will fire when the property is set for the first time. 
The Full Eight Ball Example 
Now that you’ve considered the fundamentals of XAML, you know enough to walk through the 
definition for the page in Figure 2-1. Here’s the complete XAML markup: 
<UserControl x:Class="EightBall.MainPage" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
<Grid x:Name="grid1"> 
<Grid.RowDefinitions
<RowDefinition Height="*" /> 
<RowDefinition Height="Auto" /> 
<RowDefinition Height="*" /> 
</Grid.RowDefinitions
<TextBox VerticalAlignment="Stretch" HorizontalAlignment="Stretch" 
Margin="10,10,13,10" x:Name="txtQuestion"  
TextWrapping="Wrap" FontFamily="Verdana" FontSize="24" 
Grid.Row="0" Text="[Place question here.]"> 
</TextBox
<Button VerticalAlignment="Top" HorizontalAlignment="Left" 
Margin="10,0,0,20" Width="127" Height="23" x:Name="cmdAnswer" 
Click="cmdAnswer_Click" Grid.Row="1" Content="Ask the Eight Ball"> 
</Button
<TextBox VerticalAlignment="Stretch" HorizontalAlignment="Stretch" 
Margin="10,10,13,10" x:Name="txtAnswer" TextWrapping="Wrap" 
IsReadOnly="True" FontFamily="Verdana" FontSize="24" Foreground="Green" 
Grid.Row="2" Text="[Answer will appear here.]"> 
</TextBox
<Grid.Background
<LinearGradientBrush
<LinearGradientBrush.GradientStops
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
www.it-ebooks.info
C# Create PDF Library SDK to convert PDF from other file formats
PDF document file but also offer them the ability to count the page numbers of generated Besides, using this PDF document metadata adding control, you
adding pages to a pdf document in preview; add page numbers to a pdf
C# Word - Word Create or Build in C#.NET
but also offer them the ability to count the page numbers of generated Besides, using this Word document adding control, you can add some Create Word From PDF.
add page pdf; add page number to pdf in preview
CHAPTER 2  XAML 
49 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</Grid.Background> 
</Grid> 
</Window> 
Remember, you probably won’t write the XAML for a graphically rich user interface by hand—doing 
so would be unbearably tedious. However, you might have good reason to edit the XAML code to make a 
change that would be awkward to accomplish in the designer. You might also find yourself reviewing 
XAML to get a better idea of how a page works. 
XAML Resources 
Silverlight includes a resource system that integrates closely with XAML. Using resources, you can do the 
following: 
• Create nonvisual objects: This is useful if other elements use these objects. For 
example, you could create a data object as a resource and then use data binding to 
display its information in several elements. 
• Reuse objects: Once you define a resource, several elements can draw on it. For 
example, you can define a single brush that’s used to color in several shapes. Later 
in this book, you’ll use resources to define styles and templates that are reused 
among elements. 
• Centralize details: Sometimes, it’s easier to pull frequently changed information 
into one place (a resources section) rather than scatter it through a complex 
markup file, where it’s more difficult to track down and change. 
The resource system shouldn’t be confused with assembly resources, which are blocks of data that 
you can embed in your compiled Silverlight assembly. For example, the XAML files you add to your 
project are embedded as assembly resources. You’ll learn more about assembly resources in Chapter 6. 
The Resources Collection 
Every element includes a Resources property, which stores a dictionary collection of resources. The 
resources collection can hold any type of object, indexed by string. 
Although every element includes the Resources property, the most common way to define resources 
is at the page level. That’s because every element has access to the resources in its own resource 
collection and the resources in all of its parents’ resource collections. So if you define a resource in the 
page, all the elements on the page can use it. 
For example, consider the eight ball example. Currently, the GradientBrush that paints the 
background of the Grid is defined inline (in other words, it’s defined and set in the same place). 
However, you might choose to pull the brush out of the Grid markup and place it in the resources 
collection instead: 
<UserControl x:Class="EightBall.MainPage" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
<UserControl.Resources> 
<LinearGradientBrush x:Key="BackgroundBrush"> 
<LinearGradientBrush.GradientStops> 
www.it-ebooks.info
CHAPTER 2  XAML 
50 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</UserControl.Resources> 
... 
</UserControl> 
The only important new detail is the Key attribute that’s been added to the brush (and preceded by 
the x: namespace prefix, which puts it in the XAML namespace rather than the Silverlight namespace). 
The Key attribute assigns the name under which the brush will be indexed in the resources collection. 
You can use whatever you want, so long as you use the same name when you need to retrieve the 
resource. It’s a good idea to name resources based on their functions (which won’t change) rather than 
the specific details of their implementations (which might). For that reason, BackgroundBrush is a better 
name than LinearGradientBrush or ThreeColorBrush. 
 Note  You can instantiate any .NET class in the resources section (including your own custom classes), as long 
as it’s XAML
constructor and writeable properties. 
To use a resource in your XAML markup, you need a way to refer to it. This is accomplished using a 
markup extension—a specialized type of syntax that sets a property in a nonstandard way. Markup 
extensions extend the XAML language and can be recognized by their curly braces. To use a resource, 
you use a markup extension named StaticResource: 
<Grid x:Name="grid1" Background="{StaticResource BackgroundBrush}"> 
This refactoring doesn’t shorten the markup you need for the eight ball example. However, if you 
need to use the same brush in multiple elements, the resource approach is the best way to avoid 
duplicating the same details. And even if you don’t use the brush more than once, you might still prefer 
this approach if your user interface includes a number of graphical details that are likely to change. For 
example, by placing all the brushes front and center in the resources collection, you’ll have an easier 
time finding them and changing them. Some developers use the resources collection for virtually every 
complex object they create to set a property in XAML. 
 Note  The word static stems from the fact that WPF has two types of resources, static and dynamic. However, 
Silverlight includes only static resources. 
www.it-ebooks.info
CHAPTER 2  XAML 
51 
CUSTOM MARKUP EXTENSIONS 
Silverlight 5 opens the door to custom markup extensions, which can extend the XAML language with your 
custom shortcuts. Custom markup extensions are particularly useful for people building add-on 
frameworks that extend Silverlight. 
To make a custom markup extension, you create a class that derives from MarkupExtension (in the 
System.Windows.Markup namespace). This class will consist of two things. First, it can include properties, 
which the XAML parser sets based on your markup. Second, it includes the ProvideValue() method, which 
you override to return the final object to the XAML parser. For example, consider the StaticResource 
markup extension. It includes a ResourceKey property that accepts the text for a key name (like 
“BackgroundBrush”). When the XAML parser chews through this piece of markup, it creates the 
StaticResourceExtension object, sets its ResourceKey property accordingly, and then calls ProvideValue(). 
The ProvideValue() method then searches for the matching object and returns it to the XAML parser. 
Although you’ll use plenty of markup extensions in this book, you won’t create your own. If you’re curious 
about some of the specialized scenarios where custom markup extensions make sense, you can find a few 
good examples online. For an example of a custom markup extension that supports localization, see 
http://tinyurl.com/6xwv3se
. For a markup extension that simplifies the Managed Extensibility 
Framework, see 
http://tinyurl.com/6xm2sv5
. And for a markup extension that can create pack URIs, 
which are explained in Chapter 6, see 
http://tinyurl.com/6djjnyd
(although this extension is designed 
for WPF and needs minor tweaking to work in Silverlight). 
The Hierarchy of Resources 
Every element has its own resource collection, and Silverlight performs a recursive search up your 
element tree to find the resource you want. For example, imagine you have the following markup: 
<UserControl x:Class="Resources.ResourceHierarchy" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
Width="400" Height="300"> 
<Grid x:Name="LayoutRoot" Background="White"> 
<StackPanel> 
<StackPanel.Resources> 
<LinearGradientBrush x:Key="ButtonFace"> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</LinearGradientBrush> 
</StackPanel.Resources> 
<Button Content="Click Me First" Margin="5" 
Background="{StaticResource ButtonFace}"></Button> 
<Button Content="Click Me Next" Margin="5" 
Background="{StaticResource ButtonFace}"></Button> 
</StackPanel> 
</Grid> 
www.it-ebooks.info
CHAPTER 2  XAML 
52 
</UserControl> 
Figure 2-2 shows the page this markup creates. 
Figure 2-2. Using one brush to color two buttons 
Here, both buttons set their backgrounds to the same resource. When encountering this markup, 
Silverlight will check the resources collection of the button itself and then the StackPanel (where it’s 
defined). If the StackPanel didn’t include the right resource, Silverlight would continue its search with 
the resources collection of the Grid and then the UserControl. If it still hasn’t found a resource with the 
right name, Silverlight will end by checking the application resources that are defined in the 
<Application.Resources> section of the App.xaml file:  
<Application xmlns="http://schemas.microsoft.com/client/2007" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
x:Class="SilverlightApplication1.App"> 
<Application.Resources> 
<LinearGradientBrush x:Key="ButtonFace"> 
<LinearGradientBrush.GradientStops> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</Application.Resources> 
</Application> 
The advantage of placing resources in the application collection is that they’re completely removed 
from the markup in your page, and they can be reused across an entire application. In this example, it’s a 
good choice if you plan to use the brush in more than one page. 
www.it-ebooks.info
CHAPTER 2  XAML 
53 
 Note  Before creating an application resource, consider the trade-off between complexity and reuse. Adding an 
application resource gives you better reuse, but it adds complexity because it’s not immediately clear which pages 
use a given resource. (It’s conceptually the same as an old-style C++ program with too many global variables.) A 
good guideline is to use application resources if your object is reused widely. If it’s used in just two or three pages, 
consider defining the resource in each page. 
Order is important when defining a resource in markup. The rule of thumb is that a resource must 
appear before you refer to it in your markup. That means that even though it’s perfectly valid (from a 
markup perspective) to put the <StackPanel.Resources> section after the markup that declares the 
buttons, this change will break the current example. When the XAML parser encounters a reference to a 
resource it doesn’t know, it throws an exception. 
Interestingly, resource names can be reused as long as you don’t use the same resource name more 
than once in the same collection. In this case, Silverlight uses the resource it finds first. This allows you 
to define a resource in your application resources collection and then selectively override it with a 
replacement in some pages with a replacement. 
Accessing Resources in Code 
Usually, you’ll define and use resources in your markup. However, if the need arises, you can work with 
the resources collection in code. The most straightforward approach is to look up the resource you need 
in the appropriate collection by name. For example, if you store a LinearGradientBrush in the 
<UserControl.Resources> section with the key name ButtonFace, you could use code like this: 
LinearGradientBrush brush = (LinearGradientBrush)this.Resources["ButtonFace"]; 
// Swap the color order. 
Color color = brush.GradientStops[0].Color; 
brush.GradientStops[0].Color = brush.GradientStops[2].Color; 
brush.GradientStops[2].Color = color; 
When you change a resource in this way, every element that uses the resource updates itself 
automatically (see Figure 2-3). In other words, if you have four buttons using the ButtonFace brush, they 
will all get the reversed colors when this code runs. 
www.it-ebooks.info
CHAPTER 2  XAML 
54 
Figure 2-3. Altering a resource 
However, there’s one limitation. Because Silverlight doesn’t support dynamic resources, you aren’t 
allowed to change the resource reference. That means you can’t replace a resource with a new object. 
Here’s an example of code that breaks this rule and will generate a runtime error: 
SolidColorBrush brush = new SolidColorBrush(Colors.Yellow); 
this.Resources["ButtonFace"] = brush; 
Rather than dig through the Resources collection to find the object you want, you can give your 
resource a name by adding the Name attribute. You can then access it directly by name in your code. 
However, you can’t set both a name and a key on the same object, and the StaticResource markup 
extension recognizes keys only. Thus, if you create a named resource, you won’t be able to use it in your 
markup with a StaticResource reference. For that reason, it’s more common to use keys. 
Organizing Resources with Resource Dictionaries 
If you want to share resources between multiple projects or just improve the organization of a complex, 
resource-laden project, you can create a resource dictionary. A resource dictionary is simply a XAML 
document that does nothing but store a set of resources. To create a resource dictionary in Visual Studio, 
right-click your project in the Solution Explorer, choose Add 
New Item, pick the Silverlight Resource 
Dictionary template, supply any name you like, and click Add. 
Here’s an example of a resource dictionary named ElementBrushes.xaml that defines one resource: 
<ResourceDictionary 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
<LinearGradientBrush x:Key="ButtonFace"> 
<LinearGradientBrush.GradientStops> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
www.it-ebooks.info
CHAPTER 2  XAML 
55 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</ResourceDictionary> 
To use a resource dictionary, you need to merge it into a resource collection somewhere in your 
application. You could do this in a specific page, but it’s more common to merge it into the resources 
collection for the application, as shown here: 
<Application xmlns="http://schemas.microsoft.com/client/2007" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
x:Class="SilverlightApplication1.App"> 
<Application.Resources> 
<ResourceDictionary> 
<ResourceDictionary.MergedDictionaries> 
<ResourceDictionary Source="ElementBrushes.xaml" /> 
</ResourceDictionary.MergedDictionaries> 
</ResourceDictionary> 
</Application.Resources> 
</Application> 
The MergedDictionaries collection is a collection of ResourceDictionary objects that you want to 
use to supplement your resource collection. In this example, there’s just one, but you can combine as 
many as you want. And if you want to add your own resources and merge in resource dictionaries, you 
simply need to place your resources before or after the MergedProperties section, as shown here: 
<Application.Resources> 
<ResourceDictionary> 
<ResourceDictionary.MergedDictionaries> 
<ResourceDictionary Source="BasicBrushes.xaml" /> 
<ResourceDictionary Source="ButtonBrushes.xaml" /> 
</ResourceDictionary.MergedDictionaries> 
<LinearGradientBrush x:Key="GraphicalBrush1" ... ></LinearGradientBrush> 
<LinearGradientBrush x:Key="GraphicalBrush2" ... ></LinearGradientBrush> 
</ResourceDictionary> 
</Application.Resources> 
 Note  As you learned earlier, it’s perfectly reasonable to have resources with the same name stored in different 
but overlapping resource collections. However, it’s not acceptable to merge resource dictionaries that use the 
One reason to use resource dictionaries is to define the styles for application skins that you can 
apply dynamically to your controls. (You’ll learn how to develop this technique in Chapter 14.) Another 
reason is to store content that needs to be localized (such as error message strings). 
www.it-ebooks.info
CHAPTER 2  XAML 
56 
Element-to-Element Binding 
In the previous section, you saw how to use the StaticResource markup extension, which gives XAML 
additional capabilities (in this case, the ability to easily refer to a resource that’s defined elsewhere in 
your markup). You’ll see the StaticResource at work throughout the examples in this book. Another 
markup extension that gets heavy use is the Binding expression, which sets up a relationship that 
funnels information from a source object to a target control. 
In Chapter 20, you’ll use binding expressions to create data-bound pages that allow the user to 
review and edit the information in a linked data object. But in this chapter, you’ll take a quick look at a 
more basic skill—the ability to connect two elements together with a binding expression. 
One-Way Binding 
To understand how you can bind an element to another element, consider the simple window shown in 
Figure 2-4. It contains two controls: a Slider and a TextBlock with a single line of text. If you pull the 
thumb in the slider to the right, the font size of the text is increased immediately. If you pull it to the left, 
the font size is reduced. 
Figure 2-4. Linked controls through data binding 
Clearly, it wouldn’t be difficult to create this behavior using code. You would simply react to the 
Slider.ValueChanged event and copy the current value from the slider to the TextBlock. However, data 
binding makes it even easier. 
When using data binding, you don’t need to make any change to your source object (which is the 
Slider in this example). Just configure it to take the right range of values, as you would ordinarily. 
<Slider x:Name="sliderFontSize" Margin="3" 
Minimum="1" Maximum="40" Value="10"> 
</Slider> 
The binding is defined in the TextBlock element. Instead of setting the FontSize using a literal value, 
you use a binding expression, as shown here: 
<TextBlock Margin="10" Text="Simple Text" x:Name="lblSampleText" 
FontSize="{Binding ElementName=sliderFontSize, Path=Value}" > 
</TextBlock> 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested