c# free pdf viewer : Add page number pdf control application system web page html winforms console Pro_Silverlight_5_in_CSharp_4th_edition10-part72

CHAPTER 3  LAYOUT 
88 
Layering with ZIndex 
If you have more than one overlapping element, you can set the attached Canvas.ZIndex property to 
control how they are layered. 
Ordinarily, all the elements you add have the same ZIndex—0. When elements have the same 
ZIndex, they’re displayed in the same order that they exist in the Canvas.Children collection, which is 
based on the order that they’re defined in the XAML markup. Elements declared later in the markup—
such as button (70,120)—are displayed overtop of elements that are declared earlier—such as button 
(60,80). 
However, you can promote any element to a higher level by increasing its ZIndex. That’s because 
higher ZIndex elements always appear over lower ZIndex elements. Using this technique, you could 
reverse the layering in the previous example: 
<Button Canvas.Left="60" Canvas.Top="80" Canvas.ZIndex="1" Width="50" Height="50" 
Content="(60,80)"></Button> 
<Button Canvas.Left="70" Canvas.Top="120" Width="100" Height="50" 
Content="(70,120)"</Button> 
 Note  The actual values you use for the Canvas.ZIndex property have no meaning. The important detail is how 
n set the ZIndex using any 
positive or negative integer. 
The ZIndex property is particularly useful if you need to change the position of an element 
programmatically. Just call Canvas.SetZIndex() and pass in the element you want to modify and the new 
ZIndex you want to apply. Unfortunately, there is no BringToFront() or SendToBack() method—it’s up 
to you to keep track of the highest and lowest ZIndex values if you want to implement this behavior. 
Clipping 
There’s one aspect of the Canvas that’s counterintuitive. In most layout containers, the contents are 
limited to the space that’s available in that container. For example, if you create a StackPanel with a 
height of 100 pixels and place a tall column of buttons inside, those that don’t fit will be chopped off the 
bottom. However, the Canvas doesn’t follow this common-sense rule. Instead, it draws all its children, 
even if they fall outside its bounds. That means you could replace the earlier example with a Canvas that 
has a 0-pixel height and a 0-pixel width, and the result wouldn’t change. 
The Canvas works this way for performance reasons—quite simply, it’s more efficient for the Canvas 
to draw all its children and then check whether each one falls insides its bounds. However, this isn’t 
always the behavior you want. For example, Chapter 11 includes an animated game that sends bombs 
flying off the edge of the playing area, which is a Canvas. In this situation, the bombs must be visible 
only inside the Canvas—when they leave, they should disappear under the Canvas border, not drift 
overtop other elements. 
Fortunately, the Canvas has support for clipping, which ensures that elements (or the portions of an 
element) that aren’t inside a specified area are cut off, in much the same way as elements that extend 
beyond the edges of a StackPanel or Grid. The only inconvenience is that you need to set the shape of the 
clipping area manually using the Canvas.Clip property. 
www.it-ebooks.info
Add page number pdf - 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 number to pdf hyperlink; add page number pdf
Add page number pdf - 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 pages to pdf file; add page numbers to pdf using preview
CHAPTER 3  LAYOUT 
89 
Technically, the Clip property takes a Geometry object, which is a useful object you’ll consider in 
more detail when you tackle drawing in Chapter 8. Silverlight has different Geometry-derived classes for 
different types of shapes, including squares and rectangles (RectangleGeometry), circles and ellipses 
(EllipseGeometry), and more complex shapes (PathGeometry). Here’s an example that sets the clipping 
region to a rectangular area that matches the bounds of the Canvas: 
<Canvas x:Name="canvasBackground" Width="200" Height="500" Background="AliceBlue"> 
<Canvas.Clip
<RectangleGeometry Rect="0,0 200,500"></RectangleGeometry
</Canvas.Clip
... 
<Canvas
In this example, the clipping region can be described as a rectangle with its top-left corner at point 
(0, 0), a width of 200 pixels, and a height of 500 pixels. The coordinate for the top-left corner is relative to 
the Canvas itself, so you must always have a top-left corner of (0,0) unless you want to leave out some of 
the content in the upper or left region of the Canvas. 
Setting the clipping region in markup isn’t always the best approach. It’s particularly problematic if 
your Canvas is sized dynamically to fit a resizable container or the browser window. In this situation, it’s 
far more effective to set the clipping region programmatically. Fortunately, all you need is a simple event 
handler that changes the clipping region when the Canvas is resized by reaching the 
Canvas.SizeChanged event. (This event also fires when the Canvas is first created, so it also takes care of 
the initial clipping region setup.) 
private void canvasBackground_SizeChanged(object sender, SizeChangedEventArgs e) 
RectangleGeometry rect = new RectangleGeometry(); 
rect.Rect = new Rect(0, 0, canvasBackground.ActualWidth, 
canvasBackground.ActualHeight); 
canvasBackground.Clip = rect; 
You can attach that event handler like so: 
<Canvas x:Name="canvasBackground" SizeChanged="canvasBackground_SizeChanged" 
Background="AliceBlue"> 
You’ll see this technique in action with the bomb-dropping game in Chapter 11. 
CHOOSING THE RIGHT LAYOUT CONTAINER 
As a general rule of thumb, the Grid and StackPanel are best when dealing with business-style 
applications (for example, when displaying data entry forms or documents). They deal well with changing 
window sizes and dynamic content (for example, blocks of text that can grow or shrink depending on the 
information at hand). They also make it easier to modify, localize, and reskin the application, because 
adjacent elements will bump each other out of the way as they change size. The Grid and StackPanel are 
also closest to the way ordinary HTML pages work. 
The Canvas is dramatically different. Because all of its children are arranged using fixed coordinates, you 
need to go to more work to position them (and even more work if you want to tweak the layout later on in 
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 pdf; add page to pdf without acrobat
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 a page to pdf file; add pages to pdf reader
CHAPTER 3  LAYOUT 
90 
response to new elements or new formatting.) However, the Canvas makes sense in certain types of 
graphically rich applications, such as games. In these applications, you need fine-grained control, text and 
graphics often overlap, and you often change coordinates programmatically. Here, the emphasis isn’t on 
flexibility but on achieving a specific visual appearance, and the Canvas makes more sense. 
Custom Layout Containers 
Although Silverlight has a solid collection of layout containers, it can’t offer everything. The developers 
of Silverlight left out many more specialized layout containers to keep the Silverlight download as lean as 
possible. 
However, there’s no reason you can’t create some layout containers of your own. You simply need 
to derive a custom class from Panel and supply the appropriate layout logic. And if you’re ambitious, you 
can combine the layout logic of a panel with other Silverlight features. For example, you can create a 
panel that handles mouse-over events to provide automatic drag support for the elements inside (like 
the dragging example shown in Chapter 4), or you can create a panel that displays its children with an 
animated effect. 
In the following sections, you’ll learn how the layout process works, and then you’ll see how to build 
a custom layout container. The example you’ll consider is the UniformGrid—a stripped-down grid 
control that tiles elements into a table of identically sized cells.  
The Two-Step Layout Process 
Every panel uses the same plumbing: a two-step process that’s responsible for sizing and arranging 
children. The first stage is the measure pass, and it’s at this point that the panel determines how large its 
children want to be. The second stage is the layout pass, and it’s at this point that each control is 
assigned its bounds. Two steps are required, because the panel might need to take into account the 
desires of all its children before it decides how to partition the available space. 
You add the logic for these two steps by overriding the oddly named MeasureOverride() and 
ArrangeOverride() methods, which are defined in the FrameworkElement class as part of the Silverlight 
layout system. The odd names represent that the MeasureOverride() and ArrangeOverride() methods 
replace the logic that’s defined in the MeasureCore() and ArrangeCore() methods that are defined in the 
UIElement class. These methods are not overridable. 
MeasureOverride() 
The first step is to determine how much space each child wants using the MeasureOverride() method. 
However, even in the MeasureOverride() method, children aren’t given unlimited room. At a bare 
minimum, children are confined to fit in the space that’s available to the panel. Optionally, you might 
want to limit them more stringently. For example, a Grid with two proportionally sized rows will give 
children half the available height. A StackPanel will offer the first element all the space that’s available 
and then offer the second element whatever’s left, and so on. 
Every MeasureOverride() implementation is responsible for looping through the collection of 
children and calling the Measure() method of each one. When you call the Measure() method, you 
supply the bounding box—a Size object that determines the maximum available space for the child 
control. At the end of the MeasureOverride() method, the panel returns the space it needs to display all 
its children and their desired sizes. 
Here’s the basic structure of the MeasureOverride() method, without the specific sizing details: 
www.it-ebooks.info
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 number to pdf preview; add page numbers to pdf in preview
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 in pdf; adding page numbers to a pdf in preview
CHAPTER 3  LAYOUT 
91 
protected override Size MeasureOverride(Size panelSpace) 
// Examine all the children. 
foreach (UIElement element in this.Children) 
// Ask each child how much space it would like, given the 
// availableElementSize constraint. 
Size availableElementSize = new Size(...); 
element.Measure(availableElementSize); 
// Indicate how much space this panel requires. 
// This will be used to set the DesiredSize property of the panel. 
return new Size(...); 
The Measure() method doesn’t return a value. After you call Measure() on a child, that child’s 
DesiredSize property provides the requested size. You can use this information in your calculations for 
future children (and to determine the total space required for the panel). 
You must call Measure() on each child, even if you don’t want to constrain the child’s size or use the 
DesiredSize property. Many elements will not render themselves until you’ve called Measure(). If you 
want to give a child free rein to take all the space it wants, pass a Size object with a value of 
Double.PositiveInfinity for both dimensions. (The ScrollViewer is one element that uses this strategy, 
because it can handle any amount of content.) The child will then return the space it needs for all its 
content. Otherwise, the child will normally return the space it needs for its content or the space that’s 
available—whichever is smaller. 
At the end of the measuring process, the layout container must return its desired size. In a simple 
panel, you might calculate the panel’s desired size by combining the desired size of every child. 
 Note  You can’t simply return the constraint that’s passed to the MeasureOverride() method for the desired size 
of your panel. Although this seems like a good way to take all the available size, it runs into trouble if the container 
passes in a Size object with Double.PositiveInfinity for one or both dimensions (which means “take all the space 
you want”). Although an infinite size is allowed as a sizing constraint, it’s not allowed as a sizing result, because 
Silverlight won’t be able to figure out how large your element should be. Furthermore, you really shouldn’t take 
ments that occur after your layout 
panel to be bumped farther down the window. 
If you’re an attentive reader, you may have noticed that there’s a close similarity between the 
Measure() method that’s called on each child and the MeasureOverride() method that defines the first 
step of the panel’s layout logic. In fact, the Measure() method triggers the MeasureOverride() method. 
Thus, if you place one layout container inside another, when you call Measure(), you’ll get the total size 
required for the layout container and all its children. 
One reason the measuring process goes through two steps (a Measure() method that triggers the 
MeasureOverride() method) is to deal with margins. When you call Measure(), you pass in the total 
www.it-ebooks.info
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 page number to pdf print; adding page numbers in pdf file
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
add pdf pages to word; add a page to a pdf in reader
CHAPTER 3  LAYOUT 
92 
available space. When Silverlight calls the MeasureOverride() method, it automatically reduces the 
available space to take margin space into account (unless you’ve passed in an infinite size). 
ArrangeOverride() 
Once every element has been measured, it’s time to lay them out in the space that’s available. The layout 
system calls the ArrangeOverride() method of your panel, and the panel calls the Arrange() method of 
each child to tell it how much space it’s been allotted. (As you can probably guess, the Arrange() method 
triggers the ArrangeOverride() method, much as the Measure() method triggers the MeasureOverride() 
method.) 
When measuring items with the Measure() method, you pass in a Size object that defines the 
bounds of the available space. When placing an item with the Arrange() method, you pass in a 
System.Windows.Rect object that defines the size and position of the item. At this point, it’s as though 
every element is placed with Canvas-style X and Y coordinates that determine the distance between the 
top-left corner of your layout container and the element. 
Here’s the basic structure of the ArrangeOverride() method, without the specific sizing details: 
protected override Size ArrangeOverride(Size panelSize) 
// Examine all the children. 
foreach (UIElement element in this.Children) 
// Assign the child its bounds. 
Rect elementBounds = new Rect(...); 
element.Arrange(elementBounds); 
//  to find out the size it used.) 
// Indicate how much space this panel occupies. 
// of the panel. 
return arrangeSize; 
When arranging elements, you can’t pass infinite sizes. However, you can give an element its 
desired size by passing in the value from its DesiredSize property. You can also give an element more 
space than it requires. In fact, this happens frequently. For example, a vertical StackPanel gives a child as 
much height as it requests but gives it the full width of the panel itself. Similarly, a Grid might use fixed 
or proportionally sized rows that are larger than the desired size of the element inside. And even if 
you’ve placed an element in a size-to-content container, that element can still be enlarged if an explicit 
size has been set using the Height and Width properties. 
When an element is made larger than its desired size, the HorizontalAlignment and 
VerticalAlignment properties come into play. The element content is placed somewhere inside the 
bounds that it has been given. 
Because the ArrangeOverride() method always receives a defined size (not an infinite size), you can 
return the Size object that’s passed in to set the final size of your panel. In fact, many layout containers 
take this step to occupy all the space that’s been given. You aren’t in danger of taking up space that could 
be needed for another control, because the measure step of the layout system ensures that you won’t be 
given more space than you need unless that space is available. 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Highlight Text. Add Text. Add Text Box. Drawing Markups. PDF Print. Work with Other SDKs. Please note that, PDF page number starts from 0.
add page numbers to a pdf; add pages to pdf preview
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Add necessary references: RasterEdge.Imaging.Basic.dll. 0
add pages to pdf online; add page to pdf online
CHAPTER 3  LAYOUT 
93 
The UniformGrid 
Now that you’ve examined the layout system in a fair bit of detail, it’s worth creating your own layout 
container that adds something you can’t get with the basic set of Silverlight panels. In this section, you’ll 
see an example straight from the WPF world: a UniformGrid that arranges its children into automatically 
generated, equally sized cells. 
 Note  The UniformGrid is useful as a lightweight alternative to the regular Grid, because it doesn’t require 
explicitly defined rows and columns, and it doesn’t force you to manually place each child in the right cell. It 
y more ambitious 
version of this control as part of the .NET Framework. 
Like all custom panels, the UniformGrid starts with a simple class declaration that inherits from the 
base Panel control: 
public class UniformGrid System.Windows.Controls.Panel 
{ ... } 
 Note  You can build the UniformGrid directly inside any Silverlight application. But if you want to reuse your 
custom layout container in multiple applications, it’s a better idea to place it in a new Silverlight class library for it. 
When you want to use your custom layout container in an application, simply add a reference to the compiled 
class library.  
Conceptually, the UniformGrid is quite simple. It examines the available space, calculates how 
many cells are needed (and how big each cell will be), and then lays out its children one after the other. 
The UniformGrid allows you to customize its behavior with two properties, Rows and Columns, which 
can be set independently or in conjunction: 
public int Columns { getset; } 
public int Rows { getset; } 
Here’s how the Rows and Columns properties affect the layout logic: 
• If both the Rows and Columns properties are set, the UniformGrid knows how big 
to make the grid. It simply needs to divide the available space proportionately to 
find the size of each cell. If there are more elements than cells, the extra elements 
aren’t displayed. 
• If only one of these properties is set, the UniformGrid calculates the other, 
assuming that you want to display all the elements inside. For example, if you set 
Columns to 3 and place eight elements inside, the UniformGrid will divide the 
available space into three rows. 
www.it-ebooks.info
CHAPTER 3  LAYOUT 
94 
• If neither of these properties is set, the UniformGrid will calculate both of them, 
assuming that you want to display all the elements and you want an equal number 
of rows and columns. (However, the UniformGrid won’t create an entirely blank 
row or column. Instead, if it can’t match the number of rows and columns exactly, 
the UniformGrid will add an extra column.) 
To implement this system, the UniformGrid keeps track of the real number of columns and rows. 
This holds the value in the Columns and Rows properties, if they’re set. If they aren’t, the Grid uses a 
custom method called CalculateColumns() to count the child elements and determine the dimensions of 
the grid. This method can then be called during the first stage of layout. 
private int realColumns; 
private int realRows; 
private void CalculateColumns() 
// Count the elements, and don't do anything 
// if the panel is empty. 
double elementCount = this.Children.Count; 
if (elementCount == 0) return
realRows = Rows; 
realColumns = Columns; 
// If the Rows and Columns properties were set, use them. 
if ((realRows != 0) && (realColumns != 0)) 
return
// If neither property was set, start by calculating the columns. 
if ((realColumns == 0) && realRows == 0) 
realColumns = (int)Math.Ceiling(Math.Sqrt(elementCount)); 
// If only Rows is set, calculate Columns. 
if (realColumns == 0) 
realColumns = (int)Math.Ceiling(elementCount / realRows); 
// If only Columns is set, calculate Rows. 
if (realRows == 0) 
realRows = (int)Math.Ceiling(elementCount / realColumns); 
The Silverlight layout system starts the layout process by calling the MeasureOverride() method in 
the UniformGrid. It needs to call the column calculation method (ensuring the number of rows and 
columns are set) and then divide the available space into equally sized cells. 
protected override Size MeasureOverride(Size constraint) 
CalculateColumns(); 
// Share out the available space equally. 
Size childConstraint = new Size
constraint.Width / realColumns, constraint.Height / realRows); 
... 
www.it-ebooks.info
CHAPTER 3  LAYOUT 
95 
Now the elements inside the UniformGrid need to be measured. However, there’s a trick—an 
element may return a larger value when its Measure() method is called, indicating that it’s minimum size 
is greater than the allocated space. The UniformGrid keeps track of the largest requested width and 
height values. Finally, when the entire measuring process is finished, the UniformGrid calculates the size 
required to make every cell big enough to accommodate the maximum width and height. It then returns 
that information as its requested size.     
... 
// Keep track of the largest requested dimensions for any element. 
Size largestCell = new Size(); 
// Examine all the elements in this panel. 
foreach (UIElement child in this.Children) 
// Get the desired size of the child. 
child.Measure(childConstraint); 
// Record the largest requested dimensions. 
largestCell.Height = Math.Max(largestCell.Height, child.DesiredSize.Height); 
largestCell.Width = Math.Max(largestCell.Width, child.DesiredSize.Width); 
// Take the largest requested element width and height, and use 
// those to calculate the maximum size of the grid. 
return new Size(largestCell.Width * realColumns, largestCell.Height * realRows); 
}  
The ArrangeOverride() code has a similar task. However, it’s no longer measuring the children. 
Instead, it takes note of the final space measurement, calculates the cell size, and positions each child 
inside the appropriate bounds. If it reaches the end of the grid but there are still extra elements (which 
only occurs if the control consumer sets limiting values for Columns and Rows), these extra items are 
given a 0
0 layout box, which hides them. 
protected override Size ArrangeOverride(Size arrangeSize) 
// Calculate the size of each cell. 
double cellWidth = arrangeSize.Width / realColumns; 
double cellHeight = arrangeSize.Height / realRows; 
// Determine the placement for each child. 
Rect childBounds = new Rect(0, 0, cellWidth, cellHeight); 
// Examine all the elements in this panel. 
foreach (UIElement child in this.Children) 
// Position the child. 
child.Arrange(childBounds); 
// Move the bounds to the next position.                 
childBounds.X += cellWidth; 
if (childBounds.X >= cellWidth * realColumns) 
// Move to the next row. 
www.it-ebooks.info
CHAPTER 3  LAYOUT 
96 
childBounds.Y += cellHeight; 
childBounds.X = 0; 
// If there are more elements than cells, 
// hide extra elements. 
if (childBounds.Y >= cellHeight * realRows) 
childBounds = new Rect(0, 0, 0, 0); 
return arrangeSize; 
Using the UniformGrid is easy. You simply need to map the namespace in your XAML markup and 
then define the UniformGrid in the same way you define any other layout container. Here’s an example 
that places the UniformGrid in a StackPanel with some text content. This allows you to verify that the 
size of the UniformGrid is correctly calculated and make sure that the content that follows it is bumped 
out of the way: 
<UserControl x:Class="Layout.UniformGridTest" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:local="clr-namespace:Layout" > 
<StackPanel Background="White"> 
<TextBlock Margin="5" Text="Content above the WrapPanel."></TextBlock> 
<local:UniformGrid Margin="5" Background="LawnGreen"> 
<Button Height="20" Content="Short Button"></Button> 
<Button Width="150" Content="Wide Button"></Button> 
<Button Width="80" Height="40" Content="Fixed Button"></Button> 
<TextBlock Margin="5" Text="Text in the UniformGrid cell goes here" 
TextWrapping="Wrap" Width="100"></TextBlock>             
<Button Width="80" Height="20" Content="Short Button"></Button> 
<TextBlock Margin="5" Text="More text goes in here" 
VerticalAlignment="Center"></TextBlock> 
<Button Content="Unsized Button"></Button> 
<Button Content="Unsized Button"></Button> 
 </local:UniformGrid> 
<TextBlock Margin="5" Text="Content below the WrapPanel."></TextBlock> 
</StackPanel> 
</UserControl> 
Figure 3-17 shows how this markup is displayed. By examining the different sizing characteristics of 
the children inside the UniformGrid, you can set how its layout works in practice. For example, the first 
button (named Short Button) has a hard-coded Height property. As a result, its height is limited, but it 
automatically takes the full width of the cell. The second button (Wide Button) has a hard-coded Width 
property. However, it’s the widest element in the UniformGrid, which means its width determines the 
cell width for the entire table. As a result, its dimensions match the unsized buttons exactly—both fill all 
the available cell space. Similarly, it’s the three lines of wrapped text in the TextBlock that requires the 
most vertical headroom and so determines the height of all the cells in the grid. 
www.it-ebooks.info
CHAPTER 3  LAYOUT 
97 
Figure 3-17. The UniformGrid 
 Note 
out the radial panel at 
http://tinyurl.com/cwk6nz
, which arranges elements around the edge of an invisible 
circle. 
Sizing Pages 
So far, you’ve taken an extensive look at the different layout containers Silverlight offers and how you 
can use them to arrange groups of elements. However, there’s one important part of the equation that 
you haven’t considered yet—the top-level page that holds your entire user interface. 
As you’ve already seen, the top-level container for each Silverlight page is a custom class that derives 
from UserControl. The UserControl class adds a single property, named Content, to Silverlight’s basic 
element infrastructure. The Content property accepts a single element, which becomes the content of 
that user control. 
User controls don’t include any special functionality—they’re simply a convenient way to group 
together a block of related elements. However, the way you size your user control can affect the 
appearance of your entire user interface, so it’s worth taking a closer look. 
You’ve already seen how you can use different layout containers with a variety of layout properties 
to control whether your elements size to fit their content, the available space, or hard-coded 
dimensions. Many of the same options are available when you’re sizing a page, including the following: 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested