c# .net pdf reader : Add page number to pdf file application Library cloud windows asp.net azure class Pro_Silverlight_5_in_CSharp_4th_edition5-part115

CHAPTER 2  XAML 
37 
• The XML namespace prefix: You’ll use the namespace prefix to refer to the 
namespace in your XAML page. In this example, that’s w, although you can 
choose anything you want that doesn’t conflict with another namespace prefix. 
• The .NET namespace: In this case, the classes are located in the Widgets 
namespace. If you have classes that you want to use in multiple namespaces, you 
can map them to different XML namespaces or to the same XML namespace (as 
long as there aren’t any conflicting class names). 
• The assembly: In this case, the classes are part of the WidgetLibrary.dll assembly. 
(You don’t include the .dll extension when naming the assembly.) Silverlight will 
look for that assembly in the same XAP package where your project assembly is 
placed. 
 Note  Re Silverlight 
application can’t use a full .NET class library assembly. Instead, it needs to use a Silverlight class library. You can 
easily create a Silverlight class library in Visual Studio by choosing the Silverlight Class Library project template. 
If you want to use a custom control that’s located in the current application, you can omit the 
assembly part of the namespace mapping, as shown here: 
xmlns:w="clr-namespace:Widgets" 
Once you’ve mapped your .NET namespace to an XML namespace, you can use it anywhere in your 
XAML document. For example, if the Widgets namespace contains a control named HotButton, you 
could create an instance like this: 
<w:HotButton Content="Click Me!" Click="DoSomething"></w:HotButton> 
You’ll use this technique throughout this book to access controls in the Silverlight add-on 
assemblies and the Silverlight Toolkit. 
The Code-Behind Class 
XAML allows you to construct a user interface, but in order to make a functioning application, you need 
a way to connect the event handlers that contain your application code. XAML makes this easy using the 
Class attribute that’s shown here: 
1  <UserControl x:Class="SilverlightApplication1.MainPage" 
The x namespace prefix places the Class attribute in the XAML namespace, which means this is a 
more general part of the XAML language, not a specific Silverlight ingredient. 
In fact, the Class attribute tells the Silverlight parser to generate a new class with the specified name. 
That class derives from the class that’s named by the XML element. In other words, this example creates 
a new class named SilverlightProject1.MainPage, which derives from the UserControl class. The 
automatically generated portion of this class is merged with the code you’ve supplied in the code-
behind file. 
www.it-ebooks.info
Add page number to 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 a page to a pdf in reader; add page number to pdf in preview
Add page number to 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 numbers pdf files; adding page numbers to pdf in preview
CHAPTER 2  XAML 
38 
Usually, every XAML file will have a corresponding code-behind class with client-side C# code. 
Visual Studio creates a code-behind class for the MainPage.xaml file named MainPage.xaml.cs. Here’s 
what you’ll see in the MainPage.xaml.cs file: 
using System
using System.Collections.Generic
using System.Linq
using System.Net
using System.Windows
using System.Windows.Controls
using System.Windows.Documents
using System.Windows.Input
using System.Windows.Media
using System.Windows.Media.Animation
using System.Windows.Shapes
namespace SilverlightApplication1 
public partial class MainPage UserControl 
public MainPage() 
InitializeComponent(); 
Currently, the MainPage class code doesn’t include any real functionality. However, it does include 
one important detail—the default constructor, which calls InitializeComponent() when you create an 
instance of the class. This parses your markup, creates the corresponding objects, sets their properties, 
and attaches any event handlers you’ve defined. 
 Note  The InitializeComponent() method plays a key role in Silverlight content. For that reason, you should never 
delete the InitializeComponent() call from the constructor. Similarly, if you add another constructor to your page, 
make sure it also calls InitializeComponent(). 
Naming Elements 
There’s one more detail to consider. In your code-behind class, you’ll often want to manipulate 
elements programmatically. For example, you might want to read or change properties or attach and 
detach event handlers on the fly. To make this possible, the control must include a XAML Name 
attribute. In the previous example, the Grid control already includes the Name attribute, so you can 
manipulate it in your code-behind file. 
6      <Grid x:Name="LayoutRoot"> 
7      </Grid
www.it-ebooks.info
C# PDF File Split Library: Split, seperate PDF into multiple files
If your page number is set as 1, then the two output PDF files will contains the first page and the later three pages Add necessary references:
add pdf pages together; add a page to pdf file
VB.NET PDF File Split Library: Split, seperate PDF into multiple
can split target multi-page PDF document file to one-page PDF files or PDF file to smaller PDF documents by every given number of pages Add necessary references
add page numbers to pdf; add blank page to pdf
CHAPTER 2  XAML 
39 
The Name attribute tells the XAML parser to add a field like this to the automatically generated 
portion of the MainPage class: 
private System.Windows.Controls.Grid LayoutRoot; 
Now you can interact with the grid in your page class code by using the name LayoutRoot. 
 Tip  In a traditional Windows Forms application, every control has a name. In a Silverlight application, there’s no 
such requirement. If you don’t want to interact with an element in your code, you’re free to remove its Name 
attribute from the markup. The examples in this book usually omit element names when they aren’t needed, which 
makes the markup more concise. 
Properties and Events in XAML 
So far, you’ve considered a relatively unexciting example—a blank page that hosts an empty Grid 
control. Before going any further, it’s worth introducing a more realistic page that includes several 
elements. Figure 2-1 shows an example with an automatic question answerer. 
Figure 2-1. Ask the eight ball, and all will be revealed. 
The eight ball page includes four elements: a Grid (the most common tool for arranging layout in 
Silverlight), two TextBox objects, and a Button. The markup that’s required to arrange and configure 
these elements is significantly longer than the previous examples. Here’s an abbreviated listing that 
replaces some of the details with an ellipsis (. . .) to expose the overall structure: 
www.it-ebooks.info
C# PDF insert text Library: insert text into PDF content in C#.net
pageIndex, The page index of the PDF page that will be 0
adding page numbers to pdf files; add page to a pdf
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Highlight Text. Add Text. Add Text Box. Drawing Markups. PDF users to do multiple manipulations on PDF file and page Please note that, PDF page number starts from
add page number to pdf hyperlink; add page to pdf
CHAPTER 2  XAML 
40 
<UserControl x:Class="EightBall.MainPage" 
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="grid1"> 
<Grid.Background> 
...    
</Grid.Background> 
<Grid.RowDefinitions> 
... 
</Grid.RowDefinitions> 
<TextBox x:Name="txtQuestion" ... > 
</TextBox> 
<Button x:Name="cmdAnswer" ... > 
</Button> 
<TextBox x:Name="txtAnswer" ... > 
</TextBox> 
</Grid> 
</UserControl> 
In the following sections, you’ll explore the parts of this document—and learn the syntax of XAML 
along the way. 
Simple Properties and Type Converters 
As you’ve already seen, the attributes of an XML element set the properties of the corresponding 
Silverlight object. For example, the text boxes in the eight ball example configure the alignment, margin, 
and font: 
<TextBox x:Name="txtQuestion" 
VerticalAlignment="Stretch" HorizontalAlignment="Stretch"  
FontFamily="Verdana" FontSize="24" Foreground="Green" ... > 
For this to work, the System.Windows.Controls.TextBox class must provide the following properties: 
VerticalAlignment, HorizontalAlignment, FontFamily, FontSize, and Foreground. You’ll learn the 
specific meaning for each of these properties in the following chapters. 
 Tip  Several special characters can’t be entered directly into an attribute string, including the quotation mark, 
the ampersand (&), and the two angle brackets. To use these values, you must replace them with the equivalent 
XML character entity. That’s 
&quot;
for a quotation mark, 
&amp;
for the ampersand, 
&lt;
for the < (less than) 
character, and 
&gt;
for the > (greater than) character. Of course, this limitation is an XML detail, and it won’t 
affect you if you set a property in code. 
www.it-ebooks.info
C# PDF Text Search Library: search text inside PDF file in C#.net
Add necessary references: Description: Search specified string from all the PDF pages. eg: The first page is 0. 0
adding page numbers to pdf in reader; add pdf pages to word
C# PDF delete text Library: delete, remove text from PDF file in
Add necessary references: RasterEdge.Imaging.Basic.dll. matchString, The string wil be deleted from PDF file, -. 0
add multi page pdf to word document; adding pages to a pdf document in preview
CHAPTER 2  XAML 
41 
To make the property system work, the XAML parser needs to perform a bit more work than you 
might initially realize. The value in an XML attribute is always a plain-text string. However, object 
properties can be any .NET type. In the previous example, there are two properties that use 
enumerations (VerticalAlignment and HorizontalAlignment), one string (FontFamily), one integer 
(FontSize), and one Brush object (Foreground). 
To bridge the gap between string values and nonstring properties, the XAML parser needs to 
perform a conversion. The conversion is performed by type converters, a basic piece of infrastructure 
that’s borrowed from the full .NET Framework. 
Essentially, a type converter has one role in life—it provides utility methods that can convert a 
specific .NET data type to and from any other .NET type, such as a string representation in this case. The 
XAML parser follows two steps to find a type converter: 
1. It examines the property declaration, looking for a TypeConverter attribute. (If 
present, the TypeConverter attribute indicates what class can perform the 
conversion.) For example, when you use a property such as Foreground, .NET 
checks the declaration of the Foreground property. 
2. If there’s no TypeConverter attribute on the property declaration, the XAML 
parser checks the class declaration of the corresponding data type. For 
example, the Foreground property uses a Brush object. The Brush class (and 
its derivatives) uses the BrushConverter because the Brush class is decorated 
with the TypeConverter(typeof(BrushConverter)) attribute declaration. 
If there’s no associated type converter on the property declaration or the class declaration, the 
XAML parser generates an error. 
This system is simple but flexible. If you set a type converter at the class level, that converter applies 
to every property that uses that class. On the other hand, if you want to fine-tune the way type 
conversion works for a particular property, you can use the TypeConverter attribute on the property 
declaration instead. 
It’s technically possible to use type converters in code, but the syntax is a bit convoluted. It’s almost 
always better to set a property directly—not only is it faster, but it also avoids potential errors from 
mistyping strings, which won’t be caught until runtime. This problem doesn’t affect XAML, because the 
XAML is parsed and validated at compile time. 
 Note  XAML, like all XML-based languages, is case-sensitive. That means you can’t substitute <button> for 
<Button>. However, type converters usually aren’t case-sensitive, which means both 
Foreground="White"
and 
Foreground="white"
have the same result. 
Some classes define a content property, which allows you to provide the property value between the 
start and end tags. For example, the Button class designates Content as its content property, meaning 
this markup: 
<Button>Click Me!</Button
is equivalent to this: 
<Button Content="Click Me!"></Button> 
www.it-ebooks.info
C# PDF Text Highlight Library: add, delete, update PDF text
200F); annot.EndPoint = new PointF(300F, 400F); // add annotation to The string wil be highlighted from PDF file, 0
adding a page to a pdf in reader; add page numbers to a pdf
C# Word - Split Word Document in C#.NET
your page number is set as 1, then the two output Word files will contains the first page and the later three pages respectively. C# DLLs: Split Word File. Add
add page pdf; adding a page to a pdf in preview
CHAPTER 2  XAML 
42 
Despite this convenience, you’re more likely to see the second approach in markup. Not only is it 
the standard Visual Studio uses when you configure elements with the Properties window, it was also the 
only supported option for many controls in older versions of Silverlight (up until Silverlight 4). 
Complex Properties 
As handy as type converters are, they aren’t practical for all scenarios. For example, some properties are 
full-fledged objects with their own set of properties. Although it’s possible to create a string 
representation that the type converter could use, that syntax might be difficult to use and prone to error. 
Fortunately, XAML provides another option: property-element syntax. With property-element 
syntax, you add a child element with a name in the form Parent.PropertyName. For example, the Grid 
has a Background property that allows you to supply a brush that’s used to paint the area behind the 
elements. If you want to use a complex brush—one more advanced than a solid color fill—you’ll need to 
add a child tag named Grid.Background, as shown here: 
<Grid x:Name="grid1"> 
<Grid.Background> 
...    
</Grid.Background> 
... 
</Grid> 
The key detail that makes this work is the period (.) in the element name. This distinguishes 
properties from other types of nested content. 
This still leaves one detail—namely, once you’ve identified the complex property you want to 
configure, how do you set it? Here’s the trick. Inside the nested element, you can add another tag to 
instantiate a specific class. In the eight ball example (shown in Figure 2-1), the background is filled with 
a gradient. To define the gradient you want, you need to create a LinearGradientBrush object. 
Using the rules of XAML, you can create the LinearGradientBrush object using an element with the 
name LinearGradientBrush: 
<Grid x:Name="grid1"> 
<Grid.Background> 
<LinearGradientBrush> 
</LinearGradientBrush> 
</Grid.Background> 
... 
</Grid> 
The LinearGradientBrush is part of the Silverlight set of namespaces, so you can keep using the 
default XML namespace for your tags. 
However, it’s not enough to simply create the LinearGradientBrush—you also need to specify the 
colors in that gradient. You do this by filling the LinearGradientBrush.GradientStops property with a 
collection of GradientStop objects. Once again, the GradientStops property is too complex to be set with 
an attribute value alone. Instead, you need to rely on the property-element syntax: 
<Grid x:Name="grid1"> 
<Grid.Background> 
<LinearGradientBrush> 
<LinearGradientBrush.GradientStops> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</Grid.Background> 
www.it-ebooks.info
CHAPTER 2  XAML 
43 
... 
</Grid> 
Finally, you can fill the GradientStops collection with a series of GradientStop objects. Each 
GradientStop object has an Offset and Color property. You can supply these two values using the 
ordinary property-attribute syntax: 
<Grid x:Name="grid1"> 
<Grid.Background> 
<LinearGradientBrush> 
<LinearGradientBrush.GradientStops> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
</Grid.Background> 
... 
</Grid> 
 Note  You can use property-element syntax for any property. But usually you’ll use the simpler property-
attribute approach if the property has a suitable type converter. Doing so results in more compact code. 
Any set of XAML tags can be replaced with a set of code statements that performs the same task. The 
tags shown previously, which fill the background with a gradient of your choice, are equivalent to the 
following code: 
LinearGradientBrush brush = new LinearGradientBrush(); 
GradientStop gradientStop1 = new GradientStop(); 
gradientStop1.Offset = 0; 
gradientStop1.Color = Colors.Yellow; 
brush.GradientStops.Add(gradientStop1); 
GradientStop gradientStop2 = new GradientStop(); 
gradientStop2.Offset = 0.5; 
gradientStop2.Color = Colors.White; 
brush.GradientStops.Add(gradientStop2); 
GradientStop gradientStop3 = new GradientStop(); 
gradientStop3.Offset = 1; 
gradientStop3.Color = Colors.Purple; 
brush.GradientStops.Add(gradientStop3); 
grid1.Background = brush; 
www.it-ebooks.info
CHAPTER 2  XAML 
44 
Attached Properties 
Along with ordinary properties, XAML also includes the concept of attached properties—properties that 
may apply to several elements but are defined in a different class. In Silverlight, attached properties are 
frequently used to control layout. 
Here’s how it works. Every control has its own set of intrinsic properties. For example, a text box has 
a specific font, text color, and text content as dictated by properties such as FontFamily, Foreground, 
and Text. When you place a control inside a container, it gains additional features, depending on the 
type of container. For example, if you place a text box inside a grid, you need to be able to choose the 
grid cell where it’s positioned. These additional details are set using attached properties. 
Attached properties always use a two-part name in this form: DefiningType.PropertyName. This 
two-part naming syntax allows the XAML parser to distinguish between a normal property and an 
attached property. 
In the eight ball example, attached properties allow the individual elements to place themselves on 
separate rows in the (invisible) grid: 
<TextBox ... Grid.Row="0"> 
</TextBox> 
<Button ... Grid.Row="1"> 
</Button> 
<TextBox ... Grid.Row="2"> 
</TextBox> 
Attached properties aren’t really properties at all. They’re actually translated into method calls. The 
XAML parser calls the static method that has this form: DefiningType.SetPropertyName(). For example, 
in the previous XAML snippet, the defining type is the Grid class, and the property is Row, so the parser 
calls Grid.SetRow(). 
When calling SetPropertyName(), the parser passes two parameters: the object that’s being 
modified and the property value that’s specified. For example, when you set the Grid.Row property on 
the TextBox control, the XAML parser executes this code: 
Grid.SetRow(txtQuestion, 0); 
This pattern (calling a static method of the defining type) is a convenience that conceals what’s 
really taking place. To the casual eye, this code implies that the row number is stored in the Grid object. 
However, the row number is actually stored in the object that it applies to—in this case, the TextBox 
object. 
This sleight of hand works because the TextBox derives from the DependencyObject base class, as 
do all Silverlight elements. The DependencyObject is designed to store a virtually unlimited collection of 
dependency properties (and attached properties are one type of dependency property). 
In fact, the Grid.SetRow() method is actually a shortcut that’s equivalent to calling the 
DependencyObject.SetValue() method, as shown here: 
txtQuestion.SetValue(Grid.RowProperty, 0); 
Attached properties are a core ingredient of Silverlight. They act as an all-purpose extensibility 
system. For example, by defining the Row property as an attached property, you guarantee that it’s 
usable with any control. The other option, making it part of a base class such as FrameworkElement, 
complicates life. Not only would it clutter the public interface with properties that have meaning only in 
certain circumstances (in this case, when an element is being used inside a Grid), it also makes it 
impossible to add new types of containers that require new properties. 
www.it-ebooks.info
CHAPTER 2  XAML 
45 
Nesting Elements 
As you’ve seen, XAML documents are arranged as a heavily nested tree of elements. In the current 
example, a UserControl element contains a Grid element, which contains TextBox and Button elements. 
XAML allows each element to decide how it deals with nested elements. This interaction is mediated 
through one of three mechanisms that are evaluated in this order: 
• If the parent implements IList<T>, the parser calls the IList<T>.Add() method and 
passes in the child. 
• If the parent implements IDictionary<T>, the parser calls IDictionary<T>.Add() 
and passes in the child. When using a dictionary collection, you must also set the 
x:Key attribute to give a key name to each item. 
• If the parent is decorated with the ContentProperty attribute, the parser uses the 
child to set that property. 
For example, earlier in this chapter you saw how a LinearGradientBrush can hold a collection of 
GradientStop objects using syntax like this: 
<LinearGradientBrush> 
<LinearGradientBrush.GradientStops> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
The XAML parser recognizes the LinearGradientBrush.GradientStops element is a complex property 
because it includes a period. However, it needs to process the tags inside (the three GradientStop 
elements) a little differently. In this case, the parser recognizes that the GradientStops property returns a 
GradientStopCollection object, and the GradientStopCollection implements the IList interface. Thus, it 
assumes (quite rightly) that each GradientStop should be added to the collection using the IList.Add() 
method: 
GradientStop gradientStop1 = new GradientStop(); 
gradientStop1.Offset = 0; 
gradientStop1.Color = Colors.Yellow; 
IList list = brush.GradientStops; 
list.Add(gradientStop1); 
Some properties might support more than one type of collection. In this case, you need to add a tag 
that specifies the collection class, like this: 
<LinearGradientBrush> 
<LinearGradientBrush.GradientStops> 
<GradientStopCollection> 
<GradientStop Offset="0.00" Color="Yellow" /> 
<GradientStop Offset="0.50" Color="White" /> 
<GradientStop Offset="1.00" Color="Purple" /> 
</GradientStopCollection> 
</LinearGradientBrush.GradientStops> 
</LinearGradientBrush> 
www.it-ebooks.info
CHAPTER 2  XAML 
46 
 Note  If the collection defaults to null, you need to include the tag that specifies the collection class, thereby 
creating the collection object. If there’s a default instance of the collection and you simply need to fill it, you can 
omit that part. 
Nested content doesn’t always indicate a collection. For example, consider the Grid element, which 
contains several other elements: 
<Grid x:Name="grid1"> 
... 
<TextBox x:Name="txtQuestion" ... > 
</TextBox
<Button x:Name="cmdAnswer" ... > 
</Button
<TextBox x:Name="txtAnswer" ... > 
</TextBox> 
</Grid> 
These nested tags don’t correspond to complex properties, because they don’t include the period. 
Furthermore, the Grid control isn’t a collection and so it doesn’t implement IList or IDictionary. What 
the Grid does support is the ContentProperty attribute, which indicates the property that should receive 
any nested content. Technically, the ContentProperty attribute is applied to the Panel class, from which 
the Grid derives, and looks like this: 
[ContentPropertyAttribute("Children")]  
public abstract class Panel : FrameworkElement 
This indicates that any nested elements should be used to set the Children property. The XAML 
parser treats the content property differently depending on whether it’s a collection property (in which 
case it implements the IList or IDictionary interface). Because the Panel.Children property returns a 
UIElementCollection and because UIElementCollection implements IList, the parser uses the IList.Add() 
method to add nested content to the grid. 
In other words, when the XAML parser meets the previous markup, it creates an instance of each 
nested element and passes it to the Grid using the Grid.Children.Add() method: 
txtQuestion = new TextBox(); 
... 
grid1.Children.Add(txtQuestion); 
cmdAnswer = new Button(); 
... 
grid1.Children.Add(cmdAnswer); 
txtAnswer = new TextBox(); 
... 
grid1.Children.Add(txtAnswer); 
What happens next depends entirely on how the control implements the content property. The Grid 
displays all the elements it holds in an invisible layout of rows and columns, as you’ll see in Chapter 3. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested