c# free pdf viewer component : Add page numbers to pdf files Library software component asp.net windows html mvc Pro_Silverlight_5_in_CSharp_4th_edition25-part88

CHAPTER 7  NAVIGATION 
240 
Figure 7-3. Showing a child window 
The child window pops into view with a subtle but attractive expansion effect. It also behaves like a 
real window, allowing you to click its title bar and drag it around the page (but not out of the browser 
display area). 
Although the ChildWindow control provides the illusion of a separate pop-up window that appears 
on top of your application, it’s actually just another element that’s added to your existing page. However, 
the ChildWindow control is clever enough to disable the rest of the content in the root visual of your 
application and position itself appropriately, making it look and behave like a traditional pop-up 
window. Finally, it’s worth noting that when you show a child window, the user interface underneath 
remains active, even though the user can’t interact with it. For example, if you have an animation 
www.it-ebooks.info
Add page numbers to 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
add page to a pdf; add page to existing pdf file
Add page numbers to 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 document; add a page to a pdf document
CHAPTER 7  NAVIGATION 
241 
running or a video playing, it continues in the background while the child window is visible (unless you 
explicitly stop it). 
OTHER OPTIONS FOR SECONDARY WINDOWS 
There are two alternatives to the ChildWindow class, which are appropriate in specialized scenarios. 
The first alternative is the FloatableWindow control. It isn’t available as part of the main Silverlight runtime, 
but you can download it from 
http://floatablewindow.codeplex.com
. Unlike the ChildWindow control, 
which always blocks the main user interface, the FloatableWindow lets the main window remain 
responsive. That means you can use the FloatableWindow to display one or more pop-up windows over 
your main Silverlight page and keep them there while the user interacts with the rest of the application. 
You can use this design to implement a notification window, separate task area, or floating tool panel, but 
tread with caution. If not handled carefully, floating windows can be confusing for the end user. 
The second alternative is a native window. This is a distinct, truly independent window that’s created by 
the operating system. However, the native window feature is available only to out-of-browser applications 
that are running with elevated trust. You’ll learn how to create native window in Chapter 18. 
Designing a ChildWindow 
Before you can show a child window, you need to create one with a XAML template, in the same way you 
design a user control. To add a bare-bones starter in Visual Studio, right-click the project name in the 
Solution Explorer, and choose Add 
New Item. Then, pick the Silverlight Child Window template, enter 
a name, and click Add. Visual Studio creates the new XAML template and a code-behind file, and it adds 
a reference to the System.Windows.Controls.dll assembly where the ChildWindow control is defined. 
 Note  ChildWindow is a control that derives from ContentControl. It adds two new properties (Title and 
DialogResult), two methods (Show and Close), and two events (Closing and Closed). 
After you’ve added a child window, you can design it in exactly the same way you design an ordinary 
user control. To make your life easier, Visual Studio automatically creates a two-row Grid in the new 
child window template and places OK and Cancel buttons in the bottom row, complete with event 
handlers that close the window. (Of course, you can remove or reconfigure these buttons to suit your 
application design.) 
Here’s the markup for the child window shown in Figure 7-3. It provides two text boxes for user 
information and adds the standard OK and Cancel buttons underneath: 
<controls:ChildWindow x:Class="Navigation.UserInformation" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
xmlns:controls
"clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls" 
Title="UserInformation"> 
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 or remove pages from pdf; add page numbers to pdf using preview
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.
add page numbers to pdf in reader; add contents page to pdf
CHAPTER 7  NAVIGATION 
242 
<Grid x:Name="LayoutRoot" Margin="2"> 
<Grid.RowDefinitions> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
</Grid.RowDefinitions> 
<Grid.ColumnDefinitions> 
<ColumnDefinition></ColumnDefinition> 
<ColumnDefinition></ColumnDefinition> 
</Grid.ColumnDefinitions> 
 
<TextBlock>First Name:</TextBlock> 
<TextBox x:Name="txtFirstName" Grid.Column="1" Margin="3" Width="150"></TextBox> 
<TextBlock Grid.Row="1">Last Name:</TextBlock> 
<TextBox x:Name="txtLastName" Grid.Row="1" Grid.Column="1" Margin="3"></TextBox> 
 
<Button Grid.Row="2" Margin="3" Width="75" Height="23" 
HorizontalAlignment="Right" Content="OK" Click="cmdOK_Click"></Button> 
<Button Grid.Row="2" Grid.Column="1" Margin="3" Width="75" Height="23"  
HorizontalAlignment="Left" Content="Cancel" Click="cmdCancel_Click"></Button> 
</Grid> 
</controls:ChildWindow> 
The event handlers for the two buttons set the ChildWindow.DialogResult property. This property is 
a nullable Boolean value that indicates whether the user accepted the action represented by this window 
(true), cancelled it (false), or did neither (null). 
private void cmdOK_Click(object sender, RoutedEventArgs e) 
this.DialogResult = true
private void cmdCancel_Click(object sender, RoutedEventArgs e) 
this.DialogResult = false
Setting the DialogResult property also closes the window, returning control to the root visual. In 
some cases, the DialogResult property may not be relevant to your application (for example, if you’re 
showing an About window that includes a single Close button). In this case, you can close the window by 
using the ChildWindow.Close() method rather than setting the DialogResult property. 
Showing a ChildWindow 
Showing a child window is easy. You need to create an instance of your custom ChildWindow class and 
call the Show() method: 
UserInformation childWindow = new UserInformation(); 
childWindow.Show(); 
It’s important to realize that although the child window blocks the main user interface, the Show() 
method doesn’t block the execution of your code. Thus, if you put code after the call to the Show() 
method, that code runs immediately. 
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 a page to a pdf file; add page number to pdf online
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 pdf pages to word document; add blank page to pdf
CHAPTER 7  NAVIGATION 
243 
This presents a problem if you need to react when the user closes the child window, which is usually 
the case. In the example shown in Figure 7-3, the application needs to gather the entered user name and 
use it to update the display in the main page. To perform this task, your code must respond to the 
ChildWindow.Closed event. (The ChildWindow class also provides a Closing event that fires when the 
window begins to close, but this is intended for scenarios when you need to cancel the close operation—
for example, if necessary information hasn’t been entered.) 
Remember to attach an event handler to the Closed event before you show the child window: 
UserInformation childWindow = new UserInformation(); 
childWindow.Closed += childWindow_Closed; 
childWindow.Show(); 
There’s still more to think about. If your child window is anything more than a simple confirmation 
box, you’ll probably need to return additional information to the rest of your application. In the current 
example, that information consists of the user’s first and last names. In theory, your application code 
could grab the ChildWindow object and directly extract this information from the appropriate controls. 
However, this sort of interaction is fragile. It creates tight dependencies between the main page and the 
child window, and these dependencies aren’t always obvious. If you change the design of your 
application—for example, swapping the first name and last name text boxes for different controls—the 
code breaks. A far better approach is to create an extra layer of public properties and methods in your 
child window. Your main application page can call on these members to get the information it needs. 
Because these methods are stored in the custom ChildWindow class, you’ll know to tweak them so they 
continue to work if you revamp the child window’s user interface. 
For example, in the current example, you can add this property to the UserInformation class to 
expose the full name information: 
public string UserName 
get { return txtFirstName.Text + " " + txtLastName.Text; } 
Now, you can access this detail when you respond to the Closed event: 
private void childWindow_Closed(object sender, EventArgs e) 
UserInformation childWindow = (UserInformation)sender; 
if (childWindow.DialogResult == true
{  
lblInfo.Text = "Welcome to this application, " + childWindow.UserName + "."
One final improvement is worth making. Currently, the child window is created each time the user 
clicks the Enter User Information button. As a result, the first name and last name text boxes always 
remain empty, even if the user has entered name information previously. To correct this, you can add a 
property setter for the UserName property or, even better, you can keep the lightweight 
UserInformation object in memory. In this example, the ChildWindow object is created it once, as a 
member variable of the main page: 
private UserInformation childWindow = new UserInformation(); 
You must now attach the ChildWindow.Closed event handler in the page constructor: 
public ShowChildWindow() 
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
add page number to pdf; add and delete pages in pdf
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 pdf preview; add page numbers to pdf reader
CHAPTER 7  NAVIGATION 
244 
InitializeComponent(); 
childWindow.Closed += childWindow_Closed; 
The UserInformation object will keep its state, meaning that every time you show it, the previously 
entered name information will remain in place. 
 Tip  Here’s a neat way to use ChildWindow: to pop up rich error messages that have more polish than the basic 
MessageBox. In fact, if you create a new project in Visual Studio using the Silverlight Navigation Application 
template, you’ll find that it uses this design. The navigation template includes markup and code for a custom 
ChildWindow called ErrorWindow. When the Application.UnhandledException event occurs, the application uses the 
ErrorWindow to politely explain the problem. 
The Frame and Page 
Changing the user interface by hand is a good approach if your application has very few pages (like an 
animated game that revolves around a main screen and a configuration window). It also makes sense if 
you need complete control over the navigation process (perhaps so you can implement page-transition 
effects, like the ones you’ll see in Chapter 10). But if you’re building a more traditional application and 
you expect the user to travel back and forth through a long sequence of pages, Silverlight’s navigation 
system can save you some significant work. 
The navigation system is built into two controls: Frame and Page. Of the two, the Frame control is 
the more essential, because it’s responsible for creating the container in which navigation takes place. 
The Page control is an optional sidekick—it gives you a convenient way to show different units of 
content in a frame. Both classes have members that expose the navigation features to your code. 
Frames 
The Frame is a content control—a control that derives from ContentControl and contains a single child 
element. This child is exposed through the Content property. 
Other content controls include Button, ListBoxItem, ToolTip, and ScrollViewer. However, the Frame 
control has a notable difference: if you’re using it right, you’ll almost never touch the Content property 
directly. Instead, you’ll change the content using the higher-level Navigate() method. The Navigate() 
method changes the Content property, but it also triggers the navigation services that are responsible for 
tracking the user’s page history and updating the browser’s URI. 
For example, consider the following page markup. It defines a Grid that has two rows. In the top row 
is a Border that holds a Frame. (Although the Frame class has the BorderBrush and BorderThickness 
properties, it lacks the CornerRadius property, so you need to use a Border element if you want a 
rounded border around your content.) In the bottom row is a button that triggers navigation. Figure 7-4 
shows the page. 
<UserControl x:Class="Navigation.MainPage" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:navigation= 
> 
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 remove pages from pdf; adding pages to a pdf document
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
add and delete pages from pdf; add page pdf
CHAPTER 7  NAVIGATION 
245 
<Grid> 
<Grid.RowDefinitions> 
<RowDefinition></RowDefinition> 
<RowDefinition Height="Auto"></RowDefinition> 
</Grid.RowDefinitions> 
 
<Border Margin="10" Padding="10" BorderBrush="DarkOrange" BorderThickness="2" 
CornerRadius="4"> 
<navigation:Frame x:Name="mainFrame"></navigation:Frame> 
</Border> 
<Button Grid.Row="1" Margin="5" Padding="5" HorizontalAlignment="Center" 
Content="Navigate to a New Page" Click="cmdNavigate_Click"></Button> 
</Grid> 
</UserControl> 
To use the Frame class, you must map the System.Windows.Controls namespace from the 
System.Windows.Controls.Navigation.dll assembly to an XML namespace prefix. This example uses the 
prefix navigation
Figure 7-4. An empty frame 
Currently, the frame is empty. But if the user clicks the button, an event handler runs and calls the 
Navigate() method. The Navigate() method takes a single argument—a URI pointing to a compiled 
XAML file in your application: 
private void cmdNavigate_Click(object sender, RoutedEventArgs e) 
mainFrame.Navigate(new Uri("/Page1.xaml"UriKind.Relative)); 
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
adding page numbers to a pdf file; add pages to pdf document
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
adding page numbers in pdf; add page to pdf without acrobat
CHAPTER 7  NAVIGATION 
246 
This code works because the application includes a user control named Page1.xaml. Note that the 
URI always begins with a forward slash, which represents the application root. 
 Notees of content or to pages outside 
your application (for example, external websites). 
Here’s the markup for the Page1.xaml user control: 
<UserControl x:Class="Navigation.Page1"  
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"> 
<Grid x:Name="LayoutRoot" Background="White"> 
<TextBlock TextWrapping="Wrap">This is the unremarkable content in 
Page1.xaml.</TextBlock> 
</Grid> 
</UserControl> 
When you call the Navigate() method, Silverlight creates an instance of the Page1 class and uses it to 
set the frame content, as shown in Figure 7-5. 
Figure 7-5. Filling a frame with content through navigation 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
247 
If you were performing navigation by hand, you could replace the call to Navigate() with this code: 
// Create the user control. 
Page1 newPage = new Page1(); 
mainFrame.Content = newPage; 
However, this code changes only the content, whereas the Navigate() method treats the action as a 
higher-level navigation event that hooks into some additional features. When you call Navigate(), you’ll 
notice two significant differences—browser URI integration and history support—which are described 
in the following sections. 
 Tip  You can get the URI of the current page at any time using the Frame.Source property. You can also set the 
Source property as an alternative to calling Navigate(). 
Browser URI Integration 
When you change the content of a Frame control through the Navigate() method, the name of the XAML 
resource is appended to the current URI, after the fragment marker (#). So if your application lives at this 
URI: 
localhost://Navigation/TestPage.html 
and you perform navigation with code like this: 
mainFrame.Navigate(new Uri("/Page1.xaml"UriKind.Relative)); 
you’ll now see this URI in your browser: 
localhost://Navigation/TestPage.html#/Page1.xaml 
This system has many implications—some good, some potentially bad (or at least complicating). 
Essentially, when you use Silverlight’s frame-based navigation system, each page you load into the frame 
has a distinct URI, which also means it’s a separate history item and a new entry point into your 
application. 
For example, if you close the browser and reopen it later, you can type in the newly constructed 
navigation URI with #/Page1.xaml at the end to request TestPage.html, load the Silverlight application, 
and insert the content from Page1.xaml into the frame, all in one step. Similarly, users can create a 
bookmark with this URI that lets them return to the application with the correct page loaded in the 
frame. This feature is sometimes called deep linking, because it allows you to use links that link not just 
to the entry point of an application but also to some record or state inside that application. 
 Tip  
search engine optimization (SEO). 
The basic idea is to create multiple HTML or ASP.NET pages that lead to different parts of your Silverlight 
application. Each page will point to the same XAP file, but the URI will link to a different page inside that 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
248 
application. Web search engines can then add multiple index entries for your application, one for each HTML or 
ASP.NET page that leads into it. 
URI integration is obviously a convenient feature, but it also raises a few questions, which are 
outlined in the following sections. 
What Happens If the Page Has More Than One Frame? 
The URI fragment indicates the page that should appear in the frame, but it doesn’t include the frame 
name. It turns out that this system really works only for Silverlight applications that have a single frame. 
(Applications that contain two or more frames are considered to be a relatively rare occurrence.) 
If you have more than one frame, they will all share the same navigation path. As a result, when your 
code calls Navigate() in one frame or when the user enters a URI that includes a page name as a 
fragment, the same content will be loaded into every frame. To avoid this problem, you must pick a 
single frame that represents the main application content. This frame will control the URI and the 
browser history list. Every other frame will be responsible for tracking its navigation privately, with no 
browser interaction. To implement this design, set the JournalOwnership property of each additional 
frame to OwnJournal. From that point on, the only way to perform navigation in these frames is with 
code that calls the Navigate() method. 
What Happens If the Startup Page Doesn’t Include a Frame Control? 
Pages with multiple frames aren’t the only potential problem with the navigation system’s use of URIs. 
Another issue occurs if the application can’t load the requested content because there’s no frame in the 
application’s root visual. This situation can occur if you’re using one of the dynamic user interface tricks 
described earlier—for example, using code to create the Frame object or swap in another page that 
contains a frame. In this situation, the application starts normally; but because no frame is available, the 
fragment part of the URI is ignored. 
To remedy this problem, you need to either simplify your application so the frame is available in the 
root visual at startup or add code that responds to the Application.Startup event (see Chapter 6) and 
checks the document fragment portion of the URI, using code like this: 
string fragment = System.Windows.Browser.HtmlPage.Document.DocumentUri.Fragment; 
If you find that the URI contains fragment information, you can then add code by hand to restore 
the application to its previous state. Although this is a relatively rare design, take the time to make sure it 
works properly. After all, when a fragment URI appears in the browser’s address bar, the user naturally 
assumes it’s a suitable bookmark point. And if you don’t want to provide this service, consider disabling 
the URI system altogether by setting the JournalOwnership property to OwnJournal. 
What About Security? 
In a very real sense, the URI system is like a giant back door into your application. For example, a user 
can enter a URI that points to a page you don’t want that user to access—even one that you never load 
with the Navigate() method. Silverlight doesn’t attempt to impose any measure of security to restrict this 
scenario. In other words, adding a Frame control to your application provides a potential path of access 
to any other page in your application. 
www.it-ebooks.info
CHAPTER 7  NAVIGATION 
249 
Fortunately, you can use several techniques to clamp down on this ability. First, you can detach the 
frame from the URI system by setting the JournalOwnership property to OwnJournal, as described 
earlier. However, this gives up the ability to use descriptive URIs for any of the pages in your application, 
and it also removes the integration with the browser history list that’s described in the next section. A 
better approach is to impose selective restriction by handling the Frame.Navigating event. At this point, 
you can examine the URI (through the NavigatingCancelEventArgs object) and, optionally, cancel 
navigation: 
private void mainFrame_Navigating(object sender, NavigatingCancelEventArgs e) 
if (e.Uri.ToString().ToLower().Contains("RestrictedPage.xaml")) 
e.Cancel = true
You’ll notice that this code doesn’t match the entire URI but simply checks for the presence of a 
restricted page name. This is to avoid potential canonicalization problems—in other words, allowing 
access to restricted pages by failing to account for the many different ways the same URI can be written. 
Here’s an example of functionally equivalent but differently written URIs: 
localhost://Navigation/TestPage.html#/Page1.xaml 
localhost://Navigation/TestPage.html#/FakeFolder/.../Page1.xaml 
This example assumes that you never want to perform navigation to RestrictedPage.xaml. The 
Navigating event does not distinguish whether the user has edited the URI or whether the navigation 
attempt is the result of the user clicking the link or your code calling the Navigate() method. Presumably, 
the application will use RestrictedPage.xaml in some other way—for example, with code that manually 
instantiates the user control and loads it into another container. 
Finally, it’s worth noting that there’s one other way to deal with restricted pages. You could create a 
custom content loader (as described in the “Custom Content Loaders” section at the end of this 
chapter), which would check the requested URI against a collection of allowed pages. This approach is 
similar to handling the Frame.Navigating event, but it’s a bit more general (and a bit more complex). If 
you get your design right, you can use it in any application that needs it—all you need to do is add the 
custom content loader to the appropriate frame and configure the collection of allowed pages. The 
disadvantage is that it will take you significantly more coding to arrive at a workable solution. 
History Support 
The navigation features of the Frame control also integrate with the browser. Each time you call the 
Navigate() method, Silverlight adds a new entry in the history list (see Figure 7-6). The first page of your 
application appears in the history list first, with the title of the HTML entry page. Each subsequent page 
appears under that in the history list, using the user-control file name for the display text (such as 
Page1.xaml). In the “Pages” section later in this chapter, you’ll learn how you can supply your own, more 
descriptive title text using a custom page. 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested