c# .net pdf viewer : Adding pages to a pdf Library SDK component .net wpf azure mvc Pro_Silverlight_5_in_CSharp_4th_edition61-part128

CHAPTER 16  MULTITHREADING 
606 
lstPrimes.Items.Add(prime); 
cmdFind.IsEnabled = true
cmdCancel.IsEnabled = false
progressBar.Value = 0; 
Now, the BackgroundWorker component allows you to start a search and end it prematurely. 
The Last Word 
In this chapter, you saw two powerful ways to incorporate multithreading into a Silverlight application. 
Of course, just because you can write a multithreaded Silverlight application doesn’t mean you should. 
Before you delve too deeply into the intricacies of multithreaded programming, it’s worth considering 
the advice of Microsoft architects. Because of the inherent complexity of deeply multithreaded code, 
especially when combined with dramatically different operating systems and hardware, Microsoft’s 
official guidance is to use multithreading sparingly. Certainly, you should use it to move work to the 
background, avoid long delays, and create more responsive applications. However, when possible, it’s 
better to use the straightforward BackgroundWorker component than the lower-level Thread class. And 
when you need to use the Thread class, it’s better to stick to just one or two background threads. It’s also 
a good idea to set up your threads to work with distinct islands of information and thereby avoid locking 
complications and synchronization headaches. 
www.it-ebooks.info
Adding pages to a 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 numbers to pdf files; add pdf pages together
Adding pages to a 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 blank page to pdf preview; add page to pdf in preview
C H A P T E R  17 
607 
Browser Integration 
Because Silverlight applications run in their own carefully designed environment, you’re insulated from 
the quirks and cross-platform headaches that traditionally confront developers when they attempt to 
build rich browser-based applications. This is a tremendous advantage. It means you can work with an 
efficient mix of C# code and XAML markup rather than struggle through a quagmire of HTML, 
JavaScript, and browser-compatibility issues. 
However, in some cases you’ll need to create a web page that isn’t just a thin shell around a 
Silverlight application. Instead, you may want to add Silverlight content to an existing page and allow the 
HTML and Silverlight portions of your page to interact. 
There are several reasons you may choose to blend the classic browser world with the managed 
Silverlight environment. Here are some possibilities: 
Compatibility: You can’t be sure your visitors will have the Silverlight plug-in 
installed. If you’re building a core part of your website, your need to ensure broad 
compatibility (with HTML) may trump your desire to use the latest and greatest 
user interface frills (with Silverlight). In this situation, you may decide to include a 
Silverlight content region to show nonessential extras alongside the critical HTML 
content. 
Legacy web pages: If you have an existing web page that does exactly what you 
want, it may make more sense to extend it with a bit of Silverlight pizzazz than to 
replace it outright. Once again, the solution is to create a page that includes both 
HTML and Silverlight content. 
Server-side features: Some types of tasks require server-side code. For example, 
Silverlight is a poor fit for tasks that need to access server resources or require high 
security, which is why it makes far more sense to build a secure checkout process 
with a server-side programming framework like ASP.NET. But you can still use 
Silverlight to display advertisements, video content, product visualizations, and 
other value-added features in the same pages. 
In this chapter, you’ll consider how you can bridge the gap between Silverlight and the ordinary 
world of HTML. First, you’ll see how Silverlight can reach out to other HTML elements on the page and 
manipulate them. Next, you’ll learn how Silverlight can fire off JavaScript code and how JavaScript code 
can trigger a method in your Silverlight application. Finally, you’ll look at a few more options for 
overlapping Silverlight content and ordinary HTML elements. 
www.it-ebooks.info
VB.NET PDF Library SDK to view, edit, convert, process PDF file
PDF document (pages) creation and edit methods in VB.NET. Feel free to define text or images on PDF document and extract accordingly. Capable of adding PDF file
add page numbers to a pdf in preview; add page numbers to pdf
C# PDF insert image Library: insert images into PDF in C#.net, ASP
application? To help you solve this technical problem, we provide this C#.NET PDF image adding control, XDoc.PDF for .NET. Similar
add page numbers to pdf reader; add page to pdf online
CHAPTER 17  BROWSER INTEGRATION 
608 
 Note  Thinking of building an out-of-browser application (as described in Chapter 18)? If so, you won’t be able 
control to interact 
with HTML content (which is also described in Chapter 18). 
Interacting with HTML Elements 
Silverlight includes a set of managed classes that replicate the HTML document object model (DOM) in 
managed code. These classes let your Silverlight code interact with the HTML content on the same page. 
Depending on the scenario, this interaction may involve reading a control value, updating text, or 
adding new HTML elements to the page. 
The classes you need to perform these feats are found in the System.Windows.Browser namespace 
and are listed in Table 17-1. You’ll learn about them in the following sections. 
Table 17-1. The Key Classes in the System.Windows.Browser Namespace 
Class 
Description 
HtmlPage 
Represents the current HTML page (where the Silverlight control is 
placed). The HtmlPage class is a jumping-off point for most of the 
HTML interaction features. It provides members for exploring the 
HTML elements on the page (the Document property), retrieving 
browser information (the BrowserInformation property), interacting 
with the current browser window (the Window property), and 
registering Silverlight methods that you want to make available to 
JavaScript (the RegisterCreatableType() and RegisterScriptableType() 
methods). 
BrowserInformation 
Provides some basic information about the browser that’s being used to 
run your application, including the browser name, version, and 
operating system. You can retrieve an instance of the 
BrowserInformation class from the HtmlPage.BrowserInformation 
property. 
HtmlDocument 
Represents a complete HTML document. You can get an instance of 
HtmlDocument that represents the current HTML page from the 
HtmlPage.Document property. You can then use the HtmlDocument 
object to explore the structure and content of the page (as nested levels 
of HtmlElement objects). 
HtmlElement 
Represents any HTML element on the page. You can use methods like 
SetAttribute() and SetProperty() to manipulate that element. Usually, 
you look up HtmlElement objects in an HtmlDocument object. 
www.it-ebooks.info
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Provides you with examples for adding an (empty) page to a PDF and adding empty pages to a PDF from a supported file format, with customized options.
add page numbers to pdf preview; add page numbers to pdf online
C# PDF insert text Library: insert text into PDF content in C#.net
Supports adding text to PDF in preview without adobe reader installed in ASP.NET. Powerful .NET PDF edit control allows modify existing scanned PDF text.
add page number to pdf print; add pages to pdf
CHAPTER 17  BROWSER INTEGRATION 
609 
Class 
Description 
HtmlWindow 
Represents the browser window and provides methods for navigating to 
a new page or to a different anchor in the current page. You can get an 
instance of HtmlWindow that holds the current page from the 
HtmlPage.Window property. 
HttpUtility 
Provides static methods for a few common HTML-related tasks, 
including HTML encoding and decoding (making text safe for display in 
a web page) and URL encoding and decoding (making text safe for use 
in a URL—for example, as a query string argument). 
ScriptableTypeAttribute and 
ScriptableMemberAttribute 
Allows you to expose the classes and methods in your Silverlight 
application so they can be called from JavaScript code in the HTML 
page. 
ScriptObject 
Represents a JavaScript function that’s defined in the page and allows 
you to invoke the function from your Silverlight application. 
Getting Browser Information 
Most of the time, you shouldn’t worry about the specific browser that’s being used to access your 
application. After all, one of the key advantages of Silverlight is that it saves you from the browser-
compatibility hassles of ordinary web programming and lets you write code that behaves in the same 
way in every supported environment. However, in some scenarios you may choose to take a closer look 
at the browser—for example, when diagnosing an unusual error that can be browser related. 
The browser information that’s available in the BrowserInformation class is fairly modest. You’re 
given four string properties that indicate the browser name, version, operating system, and user agent—
a long string that includes technical details about the browser (for example, in Internet Explorer, it lists 
all the currently installed versions of the .NET Framework). You can also use the Boolean 
CookiesEnabled property to determine whether the current browser supports cookies and has them 
enabled (in which case it’s true). You can then read or change cookies through the HtmlPage class. 
 Noteer represents itself 
to the world, but it may not reflect the browser’s true identity. Browsers can be configured to impersonate other 
browsers, and some browsers use this technique to ensure broader compatibility. If you write any browser-specific 
code, make sure you test it with a range of browsers to verify that you’re detecting the correct conditions. 
Here’s some straightforward code that displays all the available browser information: 
BrowserInformation b = HtmlPage.BrowserInformation; 
lblInfo.Text = "Name: " + b.Name; 
lblInfo.Text += "\nBrowser Version: " + b.BrowserVersion.ToString(); 
lblInfo.Text += "\nPlatform: " + b.Platform; 
www.it-ebooks.info
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
Provides you with examples for adding an (empty) page to a PDF and adding empty pages to a PDF from a supported file format, with customized options in VB.NET.
add pages to pdf reader; add a page to a pdf online
VB.NET PDF insert text library: insert text into PDF content in vb
VB.NET PDF - Insert Text to PDF Document in VB.NET. Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program.
add multi page pdf to word document; adding page numbers to pdf in preview
CHAPTER 17  BROWSER INTEGRATION 
610 
lblInfo.Text += "\nCookies Enabled: " + b.CookiesEnabled; 
lblInfo.Text += "\nUser Agent: " + b.UserAgent; 
Figure 17-1 shows the result. 
Figure 17-1. Profiling the browser 
The HTML Window 
Silverlight also gives you a limited ability to control the browser through the HtmlWindow class. It 
provides two methods that allow you to trigger navigation: Navigate() and NavigateToBookmark(). 
Navigate() sends the browser to another page. You can use an overloaded version of the Navigate() 
method to specify a target frame. When you use Navigate(), you abandon the current Silverlight 
application. It’s the same as if the user had typed a new URL in the browser’s address bar. 
NavigateToBookmark() scrolls to a specific bookmark in the current page. A bookmark is an <a> 
element with an ID (or name) but no target: 
<a id="myBookmark">...</a> 
To navigate to a bookmark, you add the number sign (#) and bookmark name to the end of your 
URL: 
<a href="page.html#myBookmark">Jump to bookmark</a> 
You can retrieve the bookmark from the current browser URL at any time using the 
HtmlWindow.CurrentBookmark property, which is the only property the HtmlWindow class includes. 
The NavigateToBookmark() method and CurrentBookmark property raise an interesting possibility. 
You can use a bookmark to store some state information. Because this state information is part of the 
URL, it’s preserved in the browser history and (if you bookmark a page with Silverlight content) the 
browser’s favorites list. This technique is the basis for the higher-level navigation framework you 
explored in Chapter 7. 
www.it-ebooks.info
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
TIFF Pages Modifier. Opposite to page adding & inserting &ltsummary> ''' Sort TIFF document pages in designed & profession imaging controls, PDF document, image
add page numbers to pdf document; add pages to pdf preview
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Rapidly load, create, convert and edit PDF document (pages) in C# class with .NET PDF library. Support protecting PDF file by adding password and digital
add pages to pdf without acrobat; add page number to pdf
CHAPTER 17  BROWSER INTEGRATION 
611 
Popup Windows 
The HtmlPage class also provides a PopupWindow() method that allows you to open a pop-up window 
to show a new web page. The PopupWindow() method is intended for showing advertisements and 
content from other websites. It’s not intended as a way to show different parts of the current Silverlight 
application. (If you want the ability to show a pop-up window inside a Silverlight application, you need 
the ChildWindow control described in Chapter 7.) 
The PopupWindow() method is fairly reliable and dodges most pop-up blockers (depending on the 
user’s settings). However, it also has a few quirks and should never be relied on for creating an integral 
part of your application. Instead, the pop-up window content should be an optional extra. Technically, 
the PopupWindow() method works by triggering a JavaScript window.open() call. 
Here’s an example that uses the PopupWindow() method. Note that this codes tests the 
IsPopupWindowAllowed property to avoid potential errors, because popup window are not supported 
in all scenarios: 
if (HtmlPage.IsPopupWindowAllowed) 
// Configure the popup window options. 
HtmlPopupWindowOptions options = new HtmlPopupWindowOptions(); 
options.Resizeable = true
// Show the popup window. 
// You pass in an absolute URI, an optional target frame, and the 
// HtmlPopupWindowOptions. 
HtmlPage.PopupWindow(new Uri(uriForAdvertisement), 
null, options); 
Here are the rules and restrictions of Silverlight popup windows: 
• They don’t work if the allowHtmlPopupWindow parameter is set to false in the 
HTML entry page. (See the “Securing HTML Interoperability” section at the end of 
this chapter.) 
• If your HTML entry page and Silverlight application are deployed on different 
domains, popup windows are not allowed unless the HTML entry page includes 
the allowHtmlPopupWindow parameter and explicitly sets it to true. 
• The PopupWindow() can be called only in response to a user-initiated click on a 
visible area of the Silverlight application. 
• The PopupWindow() method can be called only once per event. This means you 
can’t show more than one pop-up window at once. 
• Popup window work with the default security settings in Internet Explorer and 
Firefox. However, they won’t appear in Safari. 
• You can configure the HtmlPopupWindowOptions object to determine whether 
the pop-up window should be resizable, how big it should be, where it should be 
placed, and so on, just as you can in JavaScript. However, these properties won’t 
always be respected. For example, browsers refuse to show popup windows that 
are smaller than a certain size and, depending on settings, may show pop-up 
windows as separate tabs in the current window. 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
612 
• When calling PopupWindow(), you must supply an absolute URI. 
Inspecting the HTML Document 
Retrieving browser information and performing navigation are two relatively straightforward tasks. Life 
gets a whole lot more interesting when you start peering into the structure of the page that hosts your 
Silverlight content. 
To start your exploration, you use one of two static properties from the HtmlPage class. The Plugin 
property provides a reference to the <object> element that represents the Silverlight control, as an 
HtmlElement object. The Document property provides something more interesting: an HtmlDocument 
object that represents the entire page, with the members set out in Table 17-2. 
Table 17-2. Members of the HtmlDocument Class 
Member 
Description 
DocumentUri 
Returns the URL of the current document as a Uri object. 
QueryString 
Returns the query string portion of the URL as a single long string that you 
must parse. 
DocumentElement 
Provides an HtmlElement object that represents the top-level <html> element 
in the HTML page. 
Body 
Provides an HtmlElement object that represents the <body> element in the 
HTML page. 
Cookies 
Provides a collection of all the current HTTP cookies. You can read or set the 
values in these cookies. Cookies provide one easy, low-cost way to transfer 
information from server-side ASP.NET code to client-side Silverlight code. 
However, cookies aren’t the best approach for storing small amounts of data 
on the client’s computer—isolated storage, which is discussed in Chapter 22, 
provides a similar feature with better compatibility and programming support.
IsReady 
Returns true if the browser is idle or false if it’s still downloading the page. 
CreateElement() 
Creates a new HtmlElement object to represent a dynamically created HTML 
element, which you can then insert into the page. 
AttachEvent() and 
DetachEvent() 
Connect an event handler in your Silverlight application to a JavaScript event 
that’s raised by the document. 
Submit() 
Submits the page by posting a form and its data back to the server. This is 
useful if you’re hosting your Silverlight control in an ASP.NET page, because it 
triggers a postback that allows server-side code to run. 
When you have the HtmlDocument object that represents the page, you can browse down through 
the element tree, starting at HtmlDocument.DocumentElement or HtmlDocument.Body. To step from 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
613 
one element to another, you use the Children property (to see the elements nested inside the current 
element) and the Parent property (to get the element that contains the current element). 
Figure 17-2 shows an example—a Silverlight application that starts at the top-level <html> element 
and uses a recursive method to drill through the entire page. It displays the name and ID of each 
element. 
Figure 17-2. Dissecting the current page 
Here’s the code that creates this display when the page first loads: 
private void Page_Loaded(object sender, RoutedEventArgs e) 
// Start processing the top-level <html> element. 
HtmlElement element = HtmlPage.Document.DocumentElement; 
ProcessElement(element, 0); 
private void ProcessElement(HtmlElement element, int indent) 
// Ignore comments. 
if (element.TagName == "!"return
// Indent the element to help show different levels of nesting. 
lblElementTree.Text += new String(' ', indent * 4); 
// Display the tag name. 
lblElementTree.Text += "<" + element.TagName; 
// Only show the id attribute if it's set. 
if (element.Id != "") lblElementTree.Text += " id=\"" + element.Id + "\""
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
614 
lblElementTree.Text += ">\n"
// Process all the elements nested inside the current element. 
foreach (HtmlElement childElement in element.Children) 
ProcessElement(childElement, indent + 1); 
The HtmlElement provides relatively few properties. Aside from the Children and Parent properties 
that allow you to navigate between elements, it also includes the TagName and Id demonstrated shown 
here, as well as a CssClass property that indicates the name of the Cascading Style Sheets (CSS) style 
that’s set through the class attribute and used to configure the appearance of the current element. To get 
more information out of an element, you need to use one of the HtmlElement methods you’ll learn 
about in the next section. 
Manipulating an HTML Element 
The Parent and Children properties aren’t the only way to travel through an HtmlDocument object. You 
can also search for an element with a specific name using the GetElementByID() or 
GetElementsByTagName() method. When you have the element you want, you can manipulate it using 
one of the methods described in Table 17-3.  
Table 17-3. Methods of the HtmlElement Class 
Method 
Description 
AppendChild() 
Inserts a new HTML element as the last nested element inside the current 
element. To create the element, you must first use the 
HtmlDocument.CreateElement() method. 
RemoveChild() 
Removes the specified HtmlElement object (which you supply as an 
argument). This HtmlElement must be one of the children that’s nested in 
the current HtmlElement. 
Focus() 
Gives focus to the current element so it receives keyboard events. 
GetAttribute(), 
SetAttribute(), and 
RemoveAttribute() 
Let you retrieve the value of any attribute in the element, set the value (in 
which case the attribute is added if it doesn’t already exist), or remove the 
attribute altogether, respectively. 
GetStyleAttribute(), 
SetStyleAttribute(), 
RemoveStyleAttribute() 
Let you retrieve a value of a CSS style property, set the value, or remove the 
style attribute altogether, respectively. (As you no doubt know, CSS 
properties are the modern way to format HTML elements, and they let you 
control details such as font, foreground and background color, spacing and 
positioning, and borders.) 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
615 
Method 
Description 
GetProperty() and 
SetProperty() 
Allow you to retrieve or set values that are defined as part of the HTML 
DOM. These are the values that are commonly manipulated in JavaScript 
code. For example, you can extract the text content from an element using 
the innerHTML property. 
AttachEvent() and 
DetachEvent() 
Connect and disconnect an event handler in your Silverlight application to a 
JavaScript event that’s raised by an HTML element. 
For example, imagine that you have a <p> element just underneath your Silverlight content region 
(and your Silverlight content region doesn’t fill the entire browser window). You want to manipulate the 
paragraph with your Silverlight application, so you assign it a unique ID like this: 
<p id="paragraph">...</p> 
You can retrieve an HtmlElement object that represents this paragraph in any Silverlight event 
handler. The following code retrieves the paragraph and changes the text inside: 
HtmlElement element = HtmlPage.Document.GetElementById("paragraph"); 
element.SetProperty("innerHTML"
"This HTML paragraph has been updated by Silverlight."); 
This code works by calling the HtmlElement.SetProperty() method and setting the innerHTML 
property. Long-time JavaScript developers will recognize innerHTML as one of the fundamental 
ingredients in the DOM. 
 Note  When you use methods like SetProperty() and SetStyleAttribute(), you leave the predictable Silverlight 
environment and enter the quirkme into 
play. For example, if you use the innerText property (which is similar to innerHTML but performs automatic HTML 
escaping to ensure that special characters aren’t interpreted as tags), you’ll find that your code no longer works in 
Firefox, because Firefox doesn’t support innerText. 
Figure 17-3 shows a test page that demonstrates this code. At the top of the page is a Silverlight 
content region with a single button. When the button is clicked, the text is changed in the HTML 
element underneath (which is wrapped in a solid border to make it easy to spot). 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested