c# .net pdf viewer : Add page number to pdf file control SDK system web page wpf asp.net console Pro_Silverlight_5_in_CSharp_4th_edition62-part129

CHAPTER 17  BROWSER INTEGRATION 
616 
Figure 17-3. Changing HTML elements with Silverlight code 
You’ll notice that the transition between Silverlight and the HTML DOM isn’t perfect. Silverlight 
doesn’t include a full HTML DOM, just a lightweight version that standardizes on a basic HtmlElement 
class. To manipulate this element in a meaningful way, you often need to set an HTML DOM property 
(such as innerHTML in the previous example) using the SetProperty() method and supply the name of 
the property as a string. If you plan to do a lot of work with specific HTML elements, you may want to 
wrap them in higher-level custom classes (for example, by creating a custom Paragraph class) and 
replace their DOM properties or CSS style properties with strongly typed properties. Many developers 
use this approach to prevent minor typographic errors in property names that won’t be caught at 
compile time. 
ESCAPING SPECIAL CHARACTERS 
When you set the innerHTML property, your text is interpreted as raw HTML. That means you’re free to use 
nested elements, like this: 
element.SetProperty("innerHTML""This <b>word</b> is bold."); 
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 page number to pdf; add pages to pdf reader
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
add remove pages from pdf; add page numbers to pdf in preview
CHAPTER 17  BROWSER INTEGRATION 
617 
If you want to use angle brackets that would otherwise be interpreted as special characters, you need to 
replace them with the &lt; and &gt; character entities, as shown here: 
element.SetProperty("innerHTML""To get bold text use the &lt;b&gt; element."); 
If you have a string with many characters that need to be escaped or you don’t want reduce the readability 
of your code with character entities, you can use the static HttpUtility.HtmlEncode() method to do the work: 
element.SetProperty("innerHTML"
HttpUtility.HtmlEncode("My favorite elements are <b>, <i>, <u>, and <p>.")); 
If you want to add extra spaces (rather than allow them to be collapsed to a single space character), you 
need to use the &nbsp; character entity for a nonbreaking space. 
Inserting and Removing Elements 
The previous example modified an existing HTML element. It’s just as easy to add elements to or remove 
them from an HTML page, using three methods: HtmlDocument.CreateElement(), 
HtmlElement.AppendChild(), and HtmlElement.RemoveChild(). 
For example, the following code assumes that the paragraph doesn’t exist in the text page and 
creates it: 
HtmlElement element = HtmlPage.Document.CreateElement("p"); 
element.Id = "paragraph"
element.SetProperty("innerHTML"
"This is a new element. Click to change its background color."); 
HtmlPage.Document.Body.AppendChild(element); 
In this example, the element is inserted as the last child of the <body> element, which means it’s 
placed at the end of the document. If you have a place where you want to insert dynamic Silverlight 
content, it’s easiest to define an empty <div> container with a unique ID. You can then retrieve the 
HtmlElement for that <div> and use AppendChild() to insert your new content. 
 Note  You can execute this code more than once to add multiple paragraphs to the end of the HTML document. 
However, as it currently stands, each paragraph will be given the same ID, which isn’t strictly correct. If you use 
the GetElementById() method on a document like this, you get only the first matching element. 
Ordinarily, the AppendChild() method places the new element at the end of the collection of nested 
children. But it’s possible to position an element more precisely by using an overloaded version of 
AppendChild() that accepts another HtmlElement object to act as a reference. When you use this 
approach, the element is inserted just before the referenced element: 
// Get a reference to the first element in the <body>. 
HtmlElement referenceElement = HtmlPage.Document.Body.Children[0]; 
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:
adding page numbers to pdf documents; add pages to pdf online
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 numbers to pdf in preview; add pdf pages to word
CHAPTER 17  BROWSER INTEGRATION 
618 
// Make the new element the very first child in the <body> element, 
// before all other nested elements. 
HtmlPage.Document.Body.AppendChild(element, referenceElement); 
Incidentally, it’s even easier to remove an element. The only trick is that you need to use the 
RemoveChild() method of the parent, not the element you want to remove. 
Here’s the code that removes the paragraph element if it exists: 
HtmlElement element = HtmlPage.Document.GetElementById("paragraph"); 
if (element != null
element.Parent.RemoveChild(element); 
Changing Style Properties 
Setting style attributes is just as easy as setting DOM properties. You have essentially three options. 
First, you can set the element to use an existing style class. To do this, you set the 
HtmlElement.CssClass property: 
element.CssClass = "highlightedParagraph"
For this to work, the named style must be defined in the current HTML document or in a linked style 
sheet. Here’s an example that defines the highlightedParagraph style in the <head> of the HTML page: 
<html xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
<style type="text/css"> 
.highlightedParagraph 
color: White
border: solid 1px black
background-color: Lime
... 
</style> 
... 
</head> 
<body>...</body> 
</html> 
This approach requires the least code and keeps the formatting details in your HTML markup. 
However, it’s an all-or-nothing approach—if you want to fine-tune individual style properties, you must 
follow up with a different approach. 
Another option is to set the element’s style all at once. To do this, you use the 
HtmlElement.SetAttribute() method and set the style property. Here’s an example: 
element.SetAttribute("style"
"color: White; border: solid 1px black; background-color: Lime;"); 
But a neater approach is to set the style properties separately using the SetStyleAttribute() method 
several times: 
element.SetStyleAttribute("color""White"); 
element.SetStyleAttribute("border""solid 1px black"); 
element.SetStyleAttribute("background""Lime"); 
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 number to pdf in preview; adding pages to a pdf document
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 numbers to pdf reader; add a page to a pdf in acrobat
CHAPTER 17  BROWSER INTEGRATION 
619 
You can use the SetStyleAttribute() at any point to change a single style property, regardless of how 
you set the style initially (or even if you haven’t set any other style properties). 
 Tip  For a review of the CSS properties you can use to configure elements, refer to 
www.w3schools.com/css
Handling JavaScript Events 
Not only can you find, examine, and change HTML elements, you can also handle their events. Once 
again, you need to know the name of the HTML DOM event. In other words, you need to have your 
JavaScript skills handy in order to make the leap between Silverlight and HTML. Table 17-4 summarizes 
the most commonly used events. 
Table 17-4. Common HTML DOM Events  
Event 
Description 
onchange 
Occurs when the user changes the value in an inputcontrol. In text controls, this event 
fires after the user changes focus to another control. 
onclick 
Occurs when the user clicks a control. 
onmouseover 
Occurs when the user moves the mouse pointer over a control. 
onmouseout 
Occurs when the user moves the mouse pointer away from a control. 
onkeydown 
Occurs when the user presses a key. 
onkeyup 
Occurs when the user releases a pressed key. 
onselect 
Occurs when the user selects a portion of text in an input control. 
onfocus 
Occurs when a control receives focus. 
onblur 
Occurs when focus leaves a control. 
onabort 
Occurs when the user cancels an image download. 
onerror 
Occurs when an image can’t be downloaded (probably because of an incorrect URL). 
onload 
Occurs when a new page finishes downloading. 
onunload 
Occurs when a page is unloaded. (This typically occurs after a new URL has been 
entered or a link has been clicked. It fires just before the new page is downloaded.) 
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 page number to pdf reader; adding a page to a pdf document
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
adding page numbers to pdf in reader; add page to pdf
CHAPTER 17  BROWSER INTEGRATION 
620 
To attach your event handler, you use the HtmlElement.AttachEvent() method. You can call this 
method at any point and use it with existing or newly created elements. Here’s an example that watches 
for the onclick event in the paragraph: 
element.AttachEvent("onclick", paragraph_Click); 
 Tip  You can use HtmlElement.AttachEvent() to handle the events raised by any HTML element. You can also use 
HtmlWindow.AttachEvent() to deal with events raised by the browser window (the DOM window object) and 
HtmlDocument.AttachEvent() to handle the events raised by the top-level document (the DOM document object). 
The event handler receives an HtmlEventArgs object that provides a fair bit of additional 
information. For mouse events, you can check the exact coordinates of the mouse (relative to the 
element that raised the event) and the state of different mouse buttons. 
In this example, the event handler changes the paragraph’s text and background color: 
private void paragraph_Click(object sender, HtmlEventArgs e) 
HtmlElement element = (HtmlElement)sender; 
element.SetProperty("innerHTML"
"You clicked this HTML element, and Silverlight handled it."); 
element.SetStyleAttribute("background""#00ff00"); 
This technique achieves an impressive feat. Using Silverlight as an intermediary, you can script an 
HTML page with client-side C# code, instead of using the JavaScript that would normally be required. 
Figure 17-4 shows this code in action. 
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 pages to pdf without acrobat; adding page numbers pdf file
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 a page to pdf file; adding page numbers to pdf in
CHAPTER 17  BROWSER INTEGRATION 
621 
Figure 17-4. Silverlight and HTML interaction 
Code Interaction 
So far, you’ve seen how a Silverlight application can reach into the browser to perform navigation and 
manipulate HTML elements. The one weakness of this approach is that it creates tightly bound code—in 
other words, a Silverlight application that has hard-coded assumptions about the HTML elements on the 
current page and their unique IDs. Change these details in the HTML page, and the Silverlight code for 
interacting with them won’t work anymore. 
One alternative that addresses this issue is to allow interaction between code, not elements. For 
example, your Silverlight application can update the content of the HTML page by calling a JavaScript 
method that’s in the page. Essentially, the JavaScript code creates an extra layer of flexibility in between 
the Silverlight code and HTML content. This way, if the HTML elements on the page are ever changed, 
the JavaScript method can be updated to match at the same time, and the Silverlight application won’t 
need to be recompiled. The same interaction can work in the reverse direction—for example, you can 
create JavaScript code that calls a Silverlight method that’s written in managed C# code. In the following 
sections, you’ll see examples of both techniques. 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
622 
Calling Browser Script from Silverlight 
Using the Silverlight classes in the System.Windows.Browser namespace, you can invoke a JavaScript 
function that’s declared in a script block. This gives you a disciplined, carefully controlled way for 
Silverlight code to interact with a page. It’s particularly useful if you already have a self-sufficient page 
with a full complement of JavaScript functions. Rather than duplicate the code that manipulates the 
elements in that page, you can call one of the existing methods. 
For example, assume you have this function defined in the <head> section of your HTML page: 
<script type="text/javascript"> 
function changeParagraph(newText) { 
var element = document.getElementById("paragraph"); 
element.innerHTML = newText; 
</script> 
To call this method, you need to use the HtmlWindow.GetProperty() method and pass in the name 
of the function. You receive a ScriptObject, which you can execute at any time by calling InvokeSelf(). 
ScriptObject script = (ScriptObject)HtmlPage.Window.GetProperty("changeParagraph"); 
When you call InvokeSelf(), you pass in all the parameters. The changeParagraph() function requires 
a single string paragraph, so you can call it like this: 
script.InvokeSelf("Changed through JavaScript."); 
Calling Silverlight Methods from the Browser 
Interestingly, Silverlight also has the complementary ability to let JavaScript code call a method written 
in managed code. This process is a bit more involved. To make it work, you need to take the following 
steps: 
1. Create a public method in your Silverlight code that exposes the information 
or functionality you want the web page to use. You can place the method in 
your page class or in a separate class. You’ll need to stick to simple data types, 
such as strings, Boolean values, and numbers, unless you want to go through 
the additional work of serializing your objects to a simpler form. 
2. Add the ScriptableMember attribute to the declaration of the method that you 
want to call from JavaScript. 
3. Add the ScriptableType attribute to the declaration of the class that includes 
the scriptable method. 
4. To expose your Silverlight method to JavaScript, call the 
HtmlPage.RegisterScriptableObject() method. 
Provided you take all these steps, your JavaScript code will be able to call your Silverlight method 
through the <object> element that represents the Silverlight content region. However, to make this task 
easier, it’s important to give the <object> element a unique ID. By default, Visual Studio creates a test 
page that assigns a name to the <div> element that contains the <object> element 
(silverlightControlHost), but it doesn’t give a name to the <object> element inside. Before continuing, 
you should create a test page that adds this detail, as shown here: 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
623 
<div id="silverlightControlHost"> 
<object data="data:application/x-silverlight," 
type="application/x-silverlight-2-b1" width="400" height="300" 
id="silverlightControl"> 
... 
</object> 
<iframe style="visibility:hidden;height:0;width:0;border:0px"></iframe> 
</div> 
 Note  Remember, you can’t modify the test page in a stand-alone Silverlight application, because it will be 
replaced when you rebuild your project. Instead, you need to create a new test page as described in Chapter 1. If 
you’re using a solution that includes an ASP.NET test website, you can change the HTML test page directly. If 
you’re using the server-side .aspx test page, you can change the ID of the server-side Silverlight control, which 
will be used when creating the client-side Silverlight control. 
After you’ve named the Silverlight control, you’re ready to create the scriptable Silverlight method. 
Consider the example shown in Figure 17-5. Here, a Silverlight region (the area with the gradient 
background) includes a single text block (left). Underneath is an HTML paragraph. When the user clicks 
the paragraph, a JavaScript event handler springs into action and calls a method in the Silverlight 
application that updates the text block (right). 
Figure 17-5. Calling Silverlight code from JavaScript 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
624 
To create this example, you need the custom page class shown here. It includes a single scriptable 
method, which is registered when the page is first created: 
[ScriptableType()] 
public partial class ScriptableSilverlight: UserControl 
public ScriptableSilverlight() 
InitializeComponent(); 
HtmlPage.RegisterScriptableObject("Page"this); 
[ScriptableMember()] 
public void ChangeText(string newText) 
lbl.Text = newText; 
When registering a scriptable type, you need to specify a JavaScript object name and pass a 
reference to the appropriate object. Here, an instance of the ScriptableSilverlight class is registered with 
the name Page. This tells Silverlight to create a property named Page in the Silverlight control on the 
JavaScript page. Thus, to call this method, the JavaScript code needs to use the find the Silverlight 
control, get its content, and then call its Page.ChangeText() method. 
Here’s an example of a function that does exactly that: 
<script type="text/javascript"> 
function updateSilverlightText() 
var control = document.getElementById("silverlightControl"); 
control.content.Page.ChangeText( 
"This TextBlock has been updated through JavaScript."); 
</script> 
You can trigger this JavaScript method at any time. Here’s an example that fires it off when a 
paragraph is clicked: 
<p onclick="updateSilverlightText()">Click here to change the Silverlight 
TextBlock.</p> 
Now, clicking the paragraph triggers the updateSilverlight() JavaScript function, which in turn calls 
the ChangeText () method that’s part of your ScriptableSilverlight class. 
Instantiating Silverlight Objects in the Browser 
The previous example demonstrated how you can call a Silverlight method for JavaScript code. 
Silverlight has one more trick for code interaction: it allows JavaScript code to instantiate a Silverlight 
object. 
As before, you start with a scriptable type that includes scriptable methods. Here’s an example of a 
very basic Silverlight class that returns random numbers: 
[ScriptableType()] 
www.it-ebooks.info
CHAPTER 17  BROWSER INTEGRATION 
625 
public class RandomNumbers 
private Random random = new Random(); 
[ScriptableMember()] 
public int GetRandomNumberInRange(int from, int to) 
return random.Next(from, to+1); 
As with the previous example, you need to register this class to make it available to JavaScript code. 
However, instead of using the RegisterScriptableObject() method, you use the RegisterCreateableType() 
method, as shown here: 
HtmlPage.RegisterCreateableType("RandomNumbers"typeof(RandomNumbers)); 
To create an instance of a registered type, you need to find the Silverlight control and call its 
content.services.createObject() method. Here’s an example with a JavaScript function that displays a 
random number from 1 to 6 using an instance of the Silverlight RandomNumbers class: 
<script type="text/javascript"> 
function getRandom1To6() 
var control = document.getElementById("silverlightControl"); 
var random = control.content.services.createObject("RandomNumbers"); 
alert("Your number is: " + random.GetRandomNumberInRange(1, 6)); 
</script> 
The final detail is an HTML element that calls getRandom1To6(): 
<p onclick="getRandom1To6()">Click here to get a random number from 1 to 6.</p> 
Figure 17-6 shows this code in action. 
Figure 17-6. Creating a Silverlight object from JavaScript 
www.it-ebooks.info
Documents you may be interested
Documents you may be interested