c# free pdf viewer component : Add page numbers pdf files SDK application service wpf html web page dnn Pro_Silverlight_5_in_CSharp_4th_edition26-part89

CHAPTER 7  NAVIGATION 
250 
Figure 7-6. The navigation history of the frame 
The browser’s history list works exactly the way you’d expect. The user can click the Back or 
Forward button or pick an entry in the history list to load a previous page into the frame. Best of all, this 
doesn’t cause your application to restart. As long as the rest of the URI stays the same (everything except 
the fragment), Silverlight simply loads the appropriate page into the frame. On the other hand, if the 
user travels to another website and then uses the Back button to return, the Silverlight application is 
reloaded, the Application.Startup event fires, and then Silverlight attempts to load the requested page 
into the frame. 
Incidentally, you can call the Frame.Navigate() method multiple times in succession with different 
pages. The user ends up on the last page, but all the others are added to the history list in between. 
Finally, the Navigate() method does nothing if the page is already loaded—it doesn’t add a duplicate 
entry to the history list. 
Navigation Failure 
Silverlight has a quirk that affects how it deals with the Back button when using navigation. The problem 
occurs if you use the browser history list to return to a page that doesn’t include the fragment portion of 
the URI. For example, you will encounter this problem in the previous example if you launch the 
application, surf to a new page, and then press the browser’s Back button to return to the initial page. 
When you do, you’ll receive an ArgumentException that explains “Content for the URI cannot be 
loaded.” In other words, the URI did not specify the content for the frame, and Silverlight didn’t know 
what to put there. 
There are two easy ways to deal with this problem. The first approach is to handle the 
Frame.NavigationFailed event. You can then examine the exception object (provided through the 
NavigationFailedEventArgs.Exception property) and set the NavigationFailedEventArgs.Handled 
property to true to gracefully ignore this nonissue and carry on. 
www.it-ebooks.info
Add page numbers pdf files - 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 pages to a pdf; add page numbers pdf files
Add page numbers pdf files - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page number to pdf hyperlink; adding pages to a pdf document in preview
CHAPTER 7  NAVIGATION 
251 
Your other option is to use the UriMapper to set the initial content of the frame. With this 
technique, you map the ordinary, empty URI to a valid page, which will then be shown in the frame 
(although that page can be blank). You’ll see how to use this technique in the next section. 
URI Mapping 
As you’ve seen, the fragment URI system puts the page name in the URI. In some situations, you’d prefer 
not to make this detail as glaring. Perhaps you don’t want to expose the real page name, you don’t want 
to tack on the potentially confusing .xaml extension, or you want to use a URI that’s easier to remember 
and type in by hand. In all these situations, you can use URI mapping to define different, simpler URIs 
that map to the standard versions you’ve seen so far. 
To use URI mapping, you first need to add a UriMapper object as a XAML resource. Typically, you’ll 
define the UriMapper in the resources collection of the main page or the App.xaml file, as shown here: 
<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
x:Class="Navigation.App" xmlns:navigation
"clr-namespace:System.Windows.Navigation;assembly=System.Windows.Controls.Navigation"> 
<Application.Resources
<navigation:UriMapper x:Key="PageMapper"> 
</navigation:UriMapper
</Application.Resources
</Application
You then need to link your UriMapper to your frame by setting the Frame.UriMapper property: 
<navigation:Frame x:Name="mainFrame" UriMapper="{StaticResource PageMapper}"> 
</navigation:Frame
Now, you can add your URI mappings inside the UriMapper. Here’s an example: 
<navigation:UriMapper x:Key="PageMapper"> 
<navigation:UriMapping Uri="Home" MappedUri="/Views/HomePage.xaml" /> 
</navigation:UriMapper
If your application is located here 
localhost://Navigation/TestPage.html 
you can use this simplified URI 
localhost://Navigation/TestPage.html#Home 
which is mapped to this URI: 
localhost://Navigation/TestPage.html#/Views/HomePage.xaml 
The only catch is that it’s up to you to use the simplified URI when you call the Navigate() method, 
as shown here: 
mainFrame.Navigate(new Uri("Home"UriKind.Relative)); 
Note that you don’t need to include a forward slash at the beginning of a mapped URI. 
After mapping, both the original and the new URI will work, allowing you to reach the same page. If 
you use the original URI format when calling the Navigate() method (or in a link or in a bookmark), 
that’s what the user sees in the browser’s address bar. 
www.it-ebooks.info
C# Create PDF Library SDK to convert PDF from other file formats
them the ability to count the page numbers of generated metadata adding control, you can add some additional Create PDF Document from Existing Files Using C#.
add page numbers to pdf in preview; add page number to pdf print
C# Word - Word Create or Build in C#.NET
also offer them the ability to count the page numbers of generated using this Word document adding control, you can add some additional Create Word From PDF.
adding page numbers in pdf file; adding page numbers to pdf in reader
CHAPTER 7  NAVIGATION 
252 
You can also use the UriMapper to set the initial content in a frame. The trick is to map a Uri that’s 
just an empty string, as shown here: 
<navigation:UriMapper x:Key="PageMapper"> 
<navigation:UriMapping Uri="" MappedUri="/InitialPage.xaml" /> 
<navigation:UriMapping Uri="Home" MappedUri="/Views/HomePage.xaml" /> 
</navigation:UriMapper> 
Now, when the page first appears, the frame will show the content from InitialPage.xaml. 
 Note  Remember, if you don’t use the UriMapper to set the initial page, you must handle the 
Frame.NavigationFailed event. Otherwise, users may receive an error when they step back to the first page using 
the browser’s Back button. 
The UriMapper object also supports URIs that take query-string arguments. For example, consider 
the following mapping: 
<navigation:UriMapping Uri="Products/{id}"  
MappedUri="/Views/ProductPage.xaml?id={id}"></navigation:UriMapping> 
In this example, the {id} portion in curly brackets is a placeholder. You can use any URI that has this 
basic form but supplies an arbitrary value for the id. For example, this URI 
localhost://Navigation/TestPage.html#Products/324 
will be mapped to this: 
localhost://Navigation/TestPage.html#/Views/ProductPage.xaml?id=324 
The easiest way to retrieve the id query-string argument in the ProductPage.xaml code is to use the 
NavigationContext object described later in the “Pages” section. 
Forward and Backward Navigation 
As you’ve learned, you can set the Frame.JournalOwnership property to determine whether the frame 
uses the browser’s history-tracking system (the default) or is responsible for keeping the record of visited 
pages on its own (which is called the journal). If you opt for the latter by setting the JournalOwnership 
property to OwnJournal, your frame won’t integrate with the browser history or use the URI system 
described earlier. You’ll need to provide a way for the user to navigate through the page history. The 
most common way to add this sort of support is to create your own Forward and Backward buttons. 
Custom Forward and Backward buttons are also necessary if you’re building an out-of-browser 
application, like the sort described in Chapter 18. That’s because an application running in a stand-
alone window doesn’t have access to any browser features and doesn’t include any browser user 
interface (including the Back and Forward buttons). In this situation, you’re forced to supply your own 
navigation buttons for programmatic navigation, even if you haven’t changed the JournalOwnership 
property. 
If you’re not sure whether your application is running in a browser or in a stand-alone window, 
check the Application.IsRunningOutOfBrowser property. For example, the following code shows a panel 
www.it-ebooks.info
C# PowerPoint - PowerPoint Creating in C#.NET
New PowerPoint File and Load PowerPoint from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add pages to pdf file; add page numbers pdf file
C# Word - Word Creating in C#.NET
to Create New Word File and Load Word from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
add and remove pages from a pdf; adding page numbers to pdf files
CHAPTER 7  NAVIGATION 
253 
with navigation buttons when the application is hosted in a stand-alone window. You can use this in the 
Loaded event handler for your root visual. 
if (App.Current.IsRunningOutOfBrowser) 
pnlNavigationButtons.Visibility = Visibility.Visible; 
Designing Forward and Backward buttons is easy. You can use any element you like—the trick is 
simply to step forward or backward through the page history by calling the GoBack() and GoForward() 
methods of the Frame class. You can also check the CanGoBack property (which is true if there are pages 
in the backward history) and the CanGoForward property (which is true if there are pages in the forward 
history) and use that information to selectively enable and disable your custom navigation buttons. 
Typically, you’ll do this when responding to the Frame.Navigated event: 
private void mainFrame_Navigated(object sender, NavigationEventArgs e) 
if (mainFrame.CanGoBack) 
cmdBack.Visibility = Visibility.Visible; 
else 
cmdBack.Visibility = Visibility.Collapsed; 
if (mainFrame.CanGoForward) 
cmdForward.Visibility = Visibility.Visible; 
else 
cmdForwawrd.Visibility = Visibility.Collapsed; 
Rather than hide the buttons (as done here), you may choose to disable them and change their 
visual appearance (for example, changing the color, opacity, or picture, or adding an animated effect). 
Unfortunately, there’s no way to get a list of page names from the journal, which means you can’t 
display a history list like the one shown in the browser. 
Hyperlinks 
In the previous example, navigation was performed through an ordinary button. However, it’s a 
common Silverlight design to use a set of HyperlinkButton elements for navigation. Thanks to the URI 
system, it’s even easier to use the HyperlinkButton than an ordinary button. You simply need to set the 
NavigateUri property to the appropriate URI. You can use URIs that point directly to XAML pages, or you 
can use mapped URIs that go through the UriMapper. 
Here’s a StackPanel that creates a strip of three navigation links: 
<StackPanel Margin="5" HorizontalAlignment="Center" Orientation="Horizontal"> 
<HyperlinkButton NavigateUri="/Page1.xaml" Content="Page 1" Margin="3" /> 
<HyperlinkButton NavigateUri="/Page2.xaml" Content="Page 2" Margin="3" /> 
<HyperlinkButton NavigateUri="Home" Content="Home" Margin="3" /> 
</StackPanel> 
Although the concept hasn’t changed, this approach allows you to keep the URIs in the XAML 
markup and leave your code simple and uncluttered by extraneous details. 
Pages 
The previous examples all used navigation to load user controls into a frame. Although this design 
works, it’s far more common to use a custom class that derives from Page instead of a user control, 
www.it-ebooks.info
C# Excel - Excel Creating in C#.NET
to Create New Excel File and Load Excel from Other Files. them the ability to count the page numbers of generated creating toolkit, if you need to add some text
adding page numbers to a pdf in preview; add a page to a pdf file
VB.NET TIFF: VB.NET Sample Codes to Sort TIFF File with .NET
to sort a multi-page TIFF file with page numbers using VB define the orders for the TIFF file page sorting by pageCount - 1 To 0 Step -1 newOrders.Add(i) Next
add page numbers to a pdf in preview; add page numbers to a pdf document
CHAPTER 7  NAVIGATION 
254 
because the Page class provides convenient hooks into the navigation system and (optionally) automatic 
state management. 
To add a page to a Visual Studio project, right-click the project name in the Solution Explorer, and 
choose Add 
New Item. Then, select the Silverlight Page template, enter a page name, and click Add. 
Aside from the root element, the markup you place in a page is the same as the markup you put in a user 
control. Here’s a reworked example that changes Page1.xaml from a user control into a page by 
modifying the root element and setting the Title property: 
<navigation:Page x:Class="Navigation.Page1"  
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
xmlns:navigation
Title="Sample Page"> 
<Grid x:Name="LayoutRoot" Background="White"> 
<TextBlock TextWrapping="Wrap">This is the unremarkable content in 
Page1.xaml.</TextBlock> 
</Grid> 
</navigation:Page> 
 Tip  It’s a common design convention to place pages in a separate project folder from your user controls. For 
example, you can place all your pages in a folder named Views and use navigation URIs like 
/Views/Page1.xaml
Technically, Page is a class that derives from UserControl and adds a small set of members. These 
include a set of methods you can override to react to navigation actions and four properties: Title, 
NavigationService, NavigationContext, and NavigationCacheMode. The Title property is the simplest. It 
sets the text that’s used for the browser history list, as shown in the previous example. The other 
members are described in the following sections. 
Navigation Properties 
Every page provides a NavigationService property that offers an entry point into Silverlight’s navigation 
system. The NavigationService property provides a NavigationService object, which supplies the same 
navigational methods as the Frame class, including Navigate(), GoBack(), and GoForward(), and 
properties such as CanGoBack, CanGoForward, and CurrentSource. That means you can trigger page 
navigation from inside a page by adding code like this: 
this.NavigationService.Navigate(new Uri("/Page2.xaml"UriKind.Relative)); 
The Page class also includes a NavigationContext property that provides a NavigationContext 
object. This object exposes two properties: Uri gets the current URI, which was used to reach the current 
page, and QueryString gets a collection that contains any query-string arguments that were tacked on to 
the end of the URI. This way, the code that triggers the navigation can pass information to the 
destination page. For example, consider the following code, which embeds two numbers into a URI as 
query-string arguments: 
string uriText = String.Format("/Product.xaml?productID={0}&type={1}"
www.it-ebooks.info
C#: Use XImage.OCR to Recognize MICR E-13B, OCR-A, OCR-B Fonts
may need to scan and get check characters like numbers and codes. page.RecSettings. LanguagesEnabled.Add(Language.Other); page.RecSettings.OtherLanguage
add page to existing pdf file; add page to pdf reader
VB.NET Excel: VB Methods to Set and Customize Excel Rendering
treat every single Excel spreadsheet as a page in our An image consists of large numbers of dots, and the Our Excel converting add-on for VB.NET still supports
adding page numbers to pdf in; adding page numbers to a pdf in reader
CHAPTER 7  NAVIGATION 
255 
productID, productType); 
mainFrame.Navigate(new Uri(uriText), UriKind.Relative); 
A typical completed URI might look something like this: 
/Product.xaml?productID=402&type=12 
You can retrieve the product ID information in the destination page with code like this: 
int productID, type; 
if (this.NavigationContext.QueryString.ContainsKey("productID")) 
productID = Int32.Parse(this.NavigationContext.QueryString["productID"]); 
if (this.NavigationContext.QueryString.ContainsKey("type")) 
type = Int32.Parse(this.NavigationContext.QueryString["type"]); 
Of course, there are other ways to share information between pages, such as storing it in the 
application object. The difference is that query-string arguments are preserved in the URI, so users who 
bookmark the link can reuse it later to return to an exact point in the application (for example, the query 
string allows you to create links that point to particular items in a catalog of data). On the downside, 
query-string arguments are visible to any user who takes the time to look at the URI, and they can be 
tampered with. 
State Storage 
Ordinarily, when the user travels to a page using the Forward and Backward buttons or the history list, 
the page is re-created from scratch. When the user leaves the page, the page object is discarded from 
memory. One consequence of this design is that if a page has user input controls (for example, a text 
box), they’re reset to their default values on a return visit. Similarly, any member variables in the page 
class are reset to their initial values. 
The do-it-yourself state-management approach described earlier lets you avoid this issue by 
caching the entire page object in memory. Silverlight allows a similar trick with its own navigation 
system using the Page.NavigationCacheMode property. 
The default value of NavigationCacheMode is Disabled, which means no caching is performed. 
Switch this to Required, and the Frame will keep the page object in memory after the user navigates 
away. If the user returns, the already instantiated object is used instead of a newly created instance. The 
page constructor will not run, but the Loaded event will still fire.  
There’s one other option for NavigationCacheMode. Set it to Enabled, and pages will be cached—up 
to a point. The key detail is the Frame.CacheSize property, which sets the maximum number of optional 
pages that can be cached. For example, when this value is 10 (the default), the Frame will cache the ten 
most recent pages that have a NavigationCacheMode of Enabled. When an eleventh page is added to the 
cache, the first (oldest) page object will be discarded from the cache. Pages with NavigationCacheMode 
set to Required don’t count against the CacheSize total. 
Typically, you’ll set NavigationCacheMode to Required when you want to cache a page to preserve 
its current state. You’ll set NavigationCacheMode to Enabled if you want the option of caching a page to 
save time and improve performance—for example, if your page includes time-consuming initialization 
logic that performs detailed calculations or calls a web service. In this case, make sure you place this 
logic in the constructor, not in an event handler for the Loaded event (which still fires when a page is 
served from the cache). 
www.it-ebooks.info
C# Excel: Create and Draw Linear and 2D Barcodes on Excel Page
barcode image to the first page page.AddImage(barcodeImage C#.NET Excel Barcode Creating Add-on imaging controls, PDF document, image to pdf files and components
add page number to pdf document; adding page to pdf
VB.NET Image: Guide to Convert Images to Stream with DocImage SDK
Follow this guiding page to learn how to easily convert a single image or numbers of it an image processing component which can enable developers to add a wide
add pdf pages to word; add page to pdf
CHAPTER 7  NAVIGATION 
256 
Navigation Methods 
The Page class also includes a small set of methods that are triggered during different navigation actions. 
They include the following: 
• OnNavigatedTo(): This method is called when the frame navigates to the page 
(either for the first time or on a return trip through the history).  
• OnNavigatingFrom(): This method is called when the user is about to leave the 
page; it allows you to cancel the navigation action.  
• OnNavigatedFrom(): This method is called when the user has left the page, just 
before the next page appears. 
You could use these methods to perform various actions when a page is being left or visited, such as 
tracking and initialization. For example, you could use them to implement a more selective form of state 
management that stores just a few details from the current page in memory, rather than caching the 
entire page object. Simply store page state when OnNavigatedFrom() is called and retrieve it when 
OnNavigatedTo() is called. Where you store the state is up to you—you can store it in the App class, or 
you can use static members in your custom page class, as done here with a single string: 
public partial class CustomCachedPage Page 
... 
public static string TextBoxState { getset; } 
Here’s the page code that uses this property to store the data from a single text box and retrieve it 
when the user returns to the page later: 
protected override void OnNavigatedFrom(NavigationEventArgs e) 
// Store the text box data. 
CustomCachedPage.TextBoxState = txtCached.Text; 
base.OnNavigatedFrom(e); 
protected override void OnNavigatedTo(NavigationEventArgs e) 
// Retrieve the text box data. 
if (CustomCachedPage.TextBoxState != null
txtCached.Text = CustomCachedPage.TextBoxState; 
base.OnNavigatedTo(e); 
Navigation Templates 
You now know everything you need to use Silverlight’s Frame and Page classes to create a navigable 
application. However, there’s no small gap between simply using these features and actually making 
them look good, with a slick, visually consistent display. There are two ways to bridge this gap. One 
option is to gradually build your design skills, review other people’s example, experiment, and 
eventually end up with the perfectly customized user interface you want. The other option is to use a 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
257 
ready-made navigation template as a starting point. These are starter project templates that you can use 
in Visual Studio, and they give you basic project structure and a few finer points of style. 
Figure 7-7 shows what you start with if you create a new project using the Silverlight Navigation 
Application project template instead of the general-purpose Silverlight Application template. 
Figure 7-7. An application created with a navigation template 
The basic structure of this application is simple enough—there’s a page header at the top of a page 
with a group of link buttons on the left for navigation. Underneath is the Frame that performs the 
navigation. Pages are mapped through the UriMapper and placed in a project subfolder named Views. 
Silverlight ships with just one navigation template, which is shown in Figure 7-7. However, the 
Silverlight team posted several alternative templates when Silverlight 3 was released, and you can get 
them at http://tinyurl.com/ktv4vu. These templates use the same basic structure, but they tweak the 
visual styles and the placement of the link buttons. 
Custom Content Loaders 
As you’ve seen, Silverlight’s navigation system is powerful but not overly flexible. It makes certain 
assumptions about the way URIs will be handled. (Essentially, every URI provides the name of a XAML 
page that will be loaded in a frame.) This system works well for applications that use straightforward 
navigation, but it doesn’t give you the opening to explore more interesting extensions, like URIs that 
prompt your application to contact remote services or start a download. It also doesn’t let you plug 
additional features into the navigation system, like user authentication and authorization. 
Some of these features may appear in future versions of Silverlight. Many of them will be provided 
in separate libraries (some free, some not) by third-party developers. But now, you can begin to extend 
the navigation on your own, using a feature called custom content loaders. 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
258 
The idea of custom content loaders is simple. You create a class that implements the 
INavigationContentLoader interface. This class receives a URI and then handles it appropriately (for 
example, by providing the page content or starting an entirely different task). You can then attach your 
custom content loader to a frame in any application. You can even chain content loaders together so 
that one content loader can pass a requested URI to the next content loader in a sequence. 
Although the idea of content loaders is fairly simple, programming them is not. Here, there are two 
issues. First, the INavigationContentLoader is designed around an asynchronous model. That means 
you need to implement methods like BeginLoad(),EndLoad(), and CancelLoad() and use an IAsyncResult 
object to coordinate the interaction between the content loading code and your frame. Second, there are 
subtle issues that can cause exceptions or cancellations. (This is particularly true if your navigation takes 
more than a few milliseconds. If users don’t get an instant response, they may click a link several times 
in a row, launching several requests, all of which will be subsequently cancelled.) In short, building a 
custom content loader isn’t difficult. But building one that’s as robust and reliable as it should be often 
is. 
So with these complications in mind, how should you approach custom content loaders? You have 
three options: 
• Leave infrastructure programming to the experts: You can still benefit from the 
custom content loader feature, but not by building your own implementations. 
Instead, you’ll download and use the custom content loaders that are created by 
other developers—those who live to write low-level plumbing code. 
• Create simple implementations: You can handle several simple scenarios by 
building a custom content loader that offloads most of the real work to the 
PageResourceContentLoader class. (PageResourceContentLoader is the built-in 
content loader that loads XAML documents into a frame.) This is the approach 
you’ll use in the example in this chapter. 
• Use someone else’s higher-level class: The race is on to create a simple content 
loading model overtop of the low-level INavigationContentLoader interface. 
Ideally, you’ll simply need to derive from a straightforward synchronous base class 
to create your custom content loader. David Hill has a solid first step at 
http://tinyurl.com/37rqc7x. 
In the following sections, you’ll see how to build a simple content loader that implements user 
authentication. 
Authentication and Navigation 
If you’ve ever programmed an ASP.NET application, you’re already familiar with the way authentication, 
authorization, and navigation fit together. 
In a traditional web application, some pages are accessible to everybody, while others are protected. 
The authorization rules describe these differences, marking certain pages as public and others as 
restricted (which means they are available only to logged-in users or only to specific users or groups). If 
an anonymous user attempts to request a restricted page, that user is redirected to a login page for 
authentication. Usually, this step involves entering a valid user name and password, after which the user 
is sent back to the originally requested page.  
Using a custom content loader, you can create exactly this sort of system. Your custom content 
loader will intercept each page request, check whether the user is authenticated, and then take 
appropriate action. To do this, the application needs to distinguish between public pages and those that 
require authentication. In this example, the pages that require authentication are placed in a project 
subfolder named SecurePages (Figure 7-8). 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
259 
Figure 7-8. Pages that need authentication 
Figure 7-9 shows a simple application that tests the finished authentication system. The first page 
shown in the frame is InitialPage.xaml (Figure 7-9, left). The user can travel to another page by clicking a 
button (which triggers the Navigate() method) or a link. However, if the application attempts to navigate 
to a page in the SecurePages folder, the custom content loader redirects the user to the login page 
(Figure 7-9, right). 
Figure 7-9. Requesting a secured page 
While at the login page, the user has several choices. The user can enter a valid user name and 
password combination and click Login. The login page will then redirect the user to the originally 
requested page. Or, the user can navigate to a page that isn’t secured (which works as it normally does) 
or to a page that is secured (in which case the user returns immediately to the login page). 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested