c# free pdf viewer component : Add page number to pdf file control SDK platform web page wpf asp.net web browser Pro_Silverlight_5_in_CSharp_4th_edition24-part87

CHAPTER 6  THE APPLICATION MODEL 
229 
Figure 6-9. The .extmap.xml file for CacheableAssembly.dll 
The easiest way to create an .extmap.xml file is to take a sample (like the one shown next), and 
modify it for your assembly. In the following listing, the details you need to change are in bold: 
<?xml version="1.0"?> 
<manifest xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
<assembly> 
<name>CacheableAssembly</name> 
<version>1.0.0.0</version> 
<publickeytoken>e6a351dca87c1032</publickeytoken> 
<relpath>CacheableAssembly.dll</relpath> 
<extension downloadUri="CacheableAssembly.zip" /> 
</assembly> 
</manifest> 
The name and version details are obvious, and they should match your assembly. The public key 
token is the identifying fingerprint of the strong key that was used to sign your assembly, and you 
collected it with the sn.exe tool in the previous section. The relative path (relpath) is the exact file name 
of the assembly. Finally, the downloadUri attribute provides the most important piece of information—
it tells the application where to find the packaged, downloadable assembly. 
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 remove pages from pdf; add page number to pdf hyperlink
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
adding page numbers pdf file; add pages to pdf without acrobat
CHAPTER 6  THE APPLICATION MODEL 
230 
You have two options for setting downloadUri. The easiest approach is the one that’s used in the 
previous example—simply supply a file name. When you switch on assembly caching in your 
application, Visual Studio will take your class library assembly (in this case, CacheableAssembly.dll), 
compress it, and place the compressed file (in this case, CacheableAssembly.zip) alongside the compiled 
XAP file. As you saw in Chapter 1, this is the approach that Silverlight’s add-on assemblies use. 
 Note  Although Visual Studio compresses your assembly using ZIP compression, it’s not necessary to use a file 
name that ends with the extension .zip. If your web server requires a different extension, feel free to use that for 
the downloadUri. And if you have use the same downloadUri file name for more than one assembly, Visual Studio 
compresses all the assemblies into a single ZIP file. 
Your other option is to use an absolute URI for the downloadUri: 
<extension 
downloadUri="http://www.mysite.com/assemblies/v1.0/CacheableAssembly.zip" /> 
In this case, Visual Studio won’t package up the assembly when you compile the application. 
Instead, it expects you to have already placed the assembly at the web location you’ve specified. This 
gives you a powerful way to share libraries between multiple applications. However, the download 
location must be on the same domain as the Silverlight application, or it must explicitly allow cross-
domain access, as described in Chapter 19. 
With the .extmap.xml file shown earlier, you’re ready to use assembly caching. To try it, create an 
application that uses your class library. Turn on assembly caching for your application by opening the 
project properties and selecting the “Reduce XAP size by using application library caching” option. 
Finally, build your application. If you check out the contents of your Debug folder, you’ll find the 
packaged up ZIP file for your assembly (as shown in Figure 6-10). 
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 pages to pdf in preview; add page numbers to a pdf document
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
adding page to pdf; adding a page to a pdf in preview
CHAPTER 6  THE APPLICATION MODEL 
231 
Figure 6-10. The compressed assembly, ready for caching 
The Last Word 
In this chapter, you explored the Silverlight application model in detail. You reexamined the application 
object and the events it fires. You learned how to pass initialization parameters from different web pages 
and how to display a custom splash screen while your application is being downloaded. Finally, you 
explored the resource system that Silverlight uses and considered the many options for deploying 
resources and class libraries, from placing them alongside your assembly to downloading them only 
when needed. 
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
add page to pdf without acrobat; adding page to pdf in preview
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 to a pdf; add page to pdf online
C H A P T E R  7 
233 
Navigation 
With the know-how you’ve picked up so far, you’re ready to create applications that use a variety of 
different controls and layouts. However, there’s still something missing: the ability to transition from 
one page to another. After all, traditional rich-client applications are usually built around different 
windows that encapsulate distinct tasks. To create this sort of application in Silverlight, you need a way 
to move beyond the single-page displays you’ve seen so far. 
You can use two basic strategies to perform page changes in a Silverlight application, and each one 
has its proper place. The first option is to do it yourself by directly manipulating the user interface. For 
example, you can use code to access the root visual, remove the user control that represents the first 
page, and add another user control that represents a different page. This technique is straightforward, 
simple, and requires relatively little code. It also gives you the ability to micromanage details such as 
state management and to apply animated transition effects.  
The second option is to use Silverlight’s navigation system, which revolves around two new 
controls: Frame and Page. The basic idea is that a single frame container can switch between multiple 
pages. Although this approach to navigation is really no easier than managing the user interface 
manually, it provides a number of value-added features that would be extremely tedious to implement 
on your own. These include meaningful URIs, page tracking, and integration with the browser’s history 
list. 
In this chapter, you’ll start by learning the basic do-it-yourself method of navigation. Next, you’ll 
take a quick detour to consider the ChildWindow class, which gives you a straightforward way to 
simulate a modal dialog box (a window that temporary blocks the current page but doesn’t replace it). 
Finally, you’ll step up to the Frame and Page controls and see how they plug into Silverlight’s built-in 
navigation system. 
Loading User Controls 
The basic idea of do-it-yourself navigation is to programmatically change the content that’s shown in 
the Silverlight page, usually by manipulating layout containers or content controls. Of course, you don’t 
want to be forced to create and configure huge batches of controls in code—that task is easier to 
complete using XAML. Instead, you need a way to create and load distinct user controls, each of which 
represents a page, and each of which is prepared at design time as a separate XAML file. 
In the following sections, you’ll see two related variations of this technique. First, you’ll see an 
example that loads user controls into an existing page. This approach is best suited to user interfaces 
that need to keep some common elements (for example, a toolbar at the top or information panel at the 
side) as they load new content. Next, you’ll see how to swap out the entire content of the current page. 
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
add pages to pdf file; add a blank page to a pdf
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 pdf reader; adding page numbers to pdf files
CHAPTER 7  NAVIGATION 
234 
Embedding User Controls in a Page 
Many Silverlight applications are based around a single central page that acts as the main window for 
the entire application. You can change part of this page to load new content and simulate navigation. 
One example of this design is the menu page that’s used for most of the sample projects that 
accompany this book. This page uses the Grid control to divide itself into two main sections (separated 
by a horizontal GridSplitter). At the top is a list of all the pages you can visit. When you select one of the 
items from this list, it’s loaded into the larger content region underneath, as shown in Figure 7-1. 
Figure 7-1. A window that loads user controls dynamically 
Dynamically loading a user control is easy—you simply need to create an instance of the 
appropriate class and then add it to a suitable container. Good choices include the Border, ScrollViewer, 
StackPanel, or Grid control. The example shown previously uses the Border element, which is a content 
control that adds the ability to paint a border around its edges using the BorderBrush and 
BorderThickness properties. 
Here’s the markup (without the list of items in the list box): 
<UserControl x:Class="Navigation.MenuPage" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:basics= 
<Grid x:Name="LayoutRoot" Background="White" Margin="5"> 
<Grid.RowDefinitions> 
<RowDefinition Height="*"></RowDefinition> 
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
add a page to a pdf in reader; add and delete pages in 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 numbers pdf file; add pages to pdf preview
CHAPTER 7  NAVIGATION 
235 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="3*"></RowDefinition> 
</Grid.RowDefinitions> 
<ListBox Grid.Row="0" SelectionChanged="lstPages_SelectionChanged"> 
... 
</ListBox> 
<basics:GridSplitter Grid.Row="1" Margin="0 3" HorizontalAlignment="Stretch" 
Height="2"></basics:GridSplitter> 
<Border Grid.Row="2" BorderBrush="SlateGray" BorderThickness="1" 
x:Name="borderPlaceholder" Background="AliceBlue"></Border> 
</Grid> 
</UserControl> 
In this example, the Border is named borderPlaceholder. Here’s how you might display a new 
custom user control named Page2 in the borderPlaceholder region: 
Page2 newPage = new Page2(); 
borderPlaceholder.Child = newPage; 
If you’re using a different container, you may need to set a different property instead. For example, 
Silverlight’s layout panels can hold multiple controls and so provide a Children collection instead of a 
Child property. You need to clear this collection and then add the new control to it. Here’s an example 
that duplicates the previous code, assuming you’ve replaced the Border with a single-celled Grid: 
Page2 newPage = new Page2(); 
gridPlaceholder.Children.Clear(); 
gridPlaceholder.Children.Add(newPage); 
If you create a Grid without declaring any rows or columns, the Grid has a single proportionately 
sized cell that fits all the available space. Thus, adding a control to that Grid produces the same result as 
adding it to a Border. 
The actual code that’s used in the examples is a bit different because it needs to work for different 
types of controls. To determine which type of user control to create, the code examines the ListBoxItem 
object that was just clicked. It then uses reflection to create the corresponding user-control object: 
private void lstPages_SelectionChanged(object sender, SelectionChangedEventArgs e) 
// Get the selected item. 
string newPageName = ((ListBoxItem)e.AddedItems[0]).Content.ToString(); 
// Create an instance of the page named 
// by the current button. 
Type type = this.GetType(); 
Assembly assembly = type.Assembly; 
UserControl newPage = (UserControl)assembly.CreateInstance( 
type.Namespace + "." + newPageName); 
// Show the page. 
borderPlaceholder.Child = newPage; 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
236 
Despite the reflection code, the process of showing the newly created user control—that is, setting 
the Border.Child property—is exactly the same. 
Hiding Elements 
If you decide to create a dynamic page like the one shown in the previous example, you aren’t limited to 
adding and removing content. You can also temporarily hide it. The trick is to set the Visibility property, 
which is defined in the base UIElement class and inherited by all elements: 
panel.Visibility = Visibility.Collapsed; 
The Visibility property uses an enumeration that provides just two values: Visible and Collapsed. 
(WPF included a third value, Hidden, which hides an element but keeps a blank space where it should 
be. However, this value isn’t supported in Silverlight.) Although you can set the Visibility property of 
individual elements, usually you’ll show and hide entire containers (for example, Border, StackPanel, or 
Grid objects) at once. 
When an element is hidden, it takes no space in the page and doesn’t receive any input events. The 
rest of your interface resizes itself to fill the available space, unless you’ve positioned your other 
elements with fixed coordinates using a layout container such as the Canvas. 
 Tip  Many apyou can combine 
this code with a dash of Silverlight animation. The animation changes the element you want to hide—for example, 
shrinking, compressing, or moving it. When the animation ends, you can set the Visibility property to hide the 
element permanently. You’ll see how to use this technique in Chapter 10. 
Managing the Root Visual 
The page-changing technique shown in the previous example is common, but it’s not suited for all 
scenarios. Its key drawback is that it slots new content into an existing layout. In the previous example, 
that means the list box remains fixed at the top of the page. This is handy if you need to make sure a 
toolbar or panel always remains accessible, but it isn’t as convenient if you want to switch to a 
completely new display for a different task. 
An alternative approach is to change the entire page from one control to another. The basic 
technique is to use a simple layout container as your application’s root visual. You can then load user 
controls into the root visual when required and unload them afterward. (The root visual itself can never 
be replaced after the application has started.) 
As you learned in Chapter 6, the startup logic for a Silverlight application usually creates an instance 
of a user control, as shown here: 
private void Application_Startup(object sender, StartupEventArgs e) 
this.RootVisual = new MainPage(); 
The trick is to use something more flexible—a simple container like the Border or a layout panel like 
the Grid. Here’s an example of the latter approach: 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
237 
// This Grid will host your pages. 
private Grid rootGrid = new Grid(); 
private void Application_Startup(object sender, StartupEventArgs e) 
// Load the first page. 
this.RootVisual = rootGrid; 
rootGrid.Children.Add(new MainPage()); 
Now, you can switch to another page by removing the first page from the Grid and adding a 
different one. To make this process relatively straightforward, you can add a static method like this to the 
App class: 
public static void Navigate(UserControl newPage) 
// Get the current application object and cast it to 
// an instance of the custom (derived) App class. 
App currentApp = (App)Application.Current; 
// Change the currently displayed page. 
currentApp.rootGrid.Children.Clear(); 
currentApp.rootGrid.Children.Add(newPage); 
You can navigate at any point using code like this: 
App.Navigate(new Page2()); 
 Tip  You can add a dash of Silverlight animation and graphics to create a more pleasing transition between 
pages, such as a gentle fade or wipe. You’ll learn how to use this technique in Chapter 10. 
Retaining Page State 
If you plan to allow the user to navigate frequently between complex pages, it makes sense to create each 
page once and keep the page instance in memory until later. This approach also has the sometimes-
important side effect of maintaining that page’s current state, including all the values in any input 
controls. 
To implement this pattern, you first need a system to identify pages. You could fall back on string 
names, but an enumeration gives you better error prevention. Here’s an enumeration that distinguished 
between three pages: 
public enum Pages 
MainWindow, 
ReviewPage, 
AboutPage 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
238 
You can then store the pages of your application in private fields in your custom application class. 
Here’s a simple dictionary that does the trick: 
private static Dictionary<PagesUserControl> pageCache = 
new Dictionary<Pages,UserControl>(); 
In your Navigate() method, create the page only if it needs to be created—in other words, the 
corresponding object doesn’t exist in the collection of cached pages: 
public static void Navigate(Pages newPage) 
// Get the current application object and cast it to 
// an instance of the custom (derived) App class. 
App currentApp = (App)Application.Current; 
// Check if the page has been created before. 
if (!pageCache.ContainsKey(newPage)) 
// Create the first instance of the page, 
// and cache it for future use. 
Type type = currentApp.GetType(); 
Assembly assembly = type.Assembly; 
pageCache[newPage] = (UserControl)assembly.CreateInstance( 
type.Namespace + "." + newPage.ToString()); 
// Change the currently displayed page. 
currentApp.rootGrid.Children.Clear(); 
currentApp.rootGrid.Children.Add(pageCache[newPage]); 
Now, you can navigate by indicating the page you want with the Pages enumeration: 
App.Navigate(Pages.MainWindow); 
Because only one version of the page is ever created and it’s kept in memory over the lifetime of the 
application, all of the page’s state remains intact when you navigate away and back again (see Figure 7-
2). 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
239 
Figure 7-2. Moving from one page to another 
Browser History 
The only limitation with the navigation methods described in this section is that the browser has no idea 
you’ve changed from one page to another. If you want to let the user go back, it’s up to you to add the 
controls that do it. The browser’s Back button will only send you to the previous HTML page (thereby 
exiting your Silverlight application). 
If you want to create an application that integrates more effectively with the browser and supports 
the Back button, you’ll need to use the Frame and Page classes discussed later in this chapter. 
Child Windows 
In many situations, you don’t need a way to change the page—you just need to temporarily show some 
sort of content before allowing the user to return to the main application page. The obvious example is a 
confirmation dialog box, but Windows and web applications use pop-up windows to collect 
information, show basic program information, and provide access to configuration settings. 
In Silverlight, you can create this sort of design using a handy content control called ChildWindow. 
Essentially, ChildWindow mimics the modal dialog boxes you’ve seen on the Windows platform. When 
you show a child window, the rest of the application information is disabled (and a gray shaded overlay 
is displayed over of it as a user cue). Then, the child window appears centered on top of the page. After 
the user completes a task in the child window, your code closes it, and the rest of the application 
becomes responsive again. 
Figure 7-3 shows an example. Here, the page includes a single button that, when clicked, pops open 
a child window requesting more information. When the user clicks a button (or clicks the X in the top-
right corner), the window vanishes. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested