open pdf and draw c# : Add links to pdf online SDK control service wpf web page winforms dnn %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D30-part1560

11.6  Multiple Catch Clauses
In JavaScript 1.5, the 
try/catch
statement has been extended to allow multiple catch
clauses. To use this feature, follow the name of the catch clause parameter with the
if
keyword and a conditional expression:
try { 
// multiple exception types can be thrown here 
throw 1;
}
catch(e if e instanceof ReferenceError) {
// Handle reference errors here
}
catch(e if e === "quit") {
// Handle the thrown string "quit"
}
catch(e if typeof e === "string") {
// Handle any other thrown strings here
}
catch(e) {
// Handle anything else here
}
finally {
// The finally clause works as normal
}
When an exception occurs, each catch clause is tried in turn. The exception is assigned
to the named catch clause parameter, and the conditional is evaluated. If true, the body
of that catch clause is evaluated, and all other catch clauses are skipped. If a catch clause
has no conditional, it behaves as if it has the conditional 
if true
, and it  is  always
triggered if no clause before it was triggered. If all catch clauses have a conditional, and
none of those conditionals are true, the exception propagates uncaught. Notice that
since the conditionals already appear within the parentheses of the catch clause, they
are not required to be directly enclosed in parentheses as they would be in a regular
if
statement.
11.7  E4X: ECMAScript for XML
ECMAScript for XML, better known as E4X, is a standard extension
4
to JavaScript that
defines a number of powerful features for processing XML documents. E4X is suppor-
ted by Spidermonkey 1.5 and Rhino 1.6. Because it is not widely supported by browser
vendors, E4X may perhaps be best considered a server-side technology for script en-
gines based on Spidermonkey or Rhino.
4. E4X is defined by the ECMA-357 standard. You can find the official specification at http://www.ecma
-international.org/publications/standards/Ecma-357.htm.
11.7  E4X: ECMAScript for XML | 283
Core JavaScript
Add links to pdf online - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add links to pdf document; add hyperlink to pdf in
Add links to pdf online - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
pdf link to attached file; adding hyperlinks to pdf documents
E4X represents an XML document (or an element or attribute of an XML document)
as an XML object and represents XML fragments (more than one XML element not
included in a common parent) with the closely related XMLList object. We’ll see a
number of ways to create and work with XML objects throughout this section. XML
objects are a fundamentally new kind of object, with (as we’ll see) much special-purpose
E4X syntax supporting them. As you know, the 
typeof
operator returns “object” for
all standard JavaScript objects other than functions. XML objects are as different from
ordinary JavaScript objects as functions are, and the 
typeof
operator returns “xml”. It
is important to understand that XML objects are unrelated to the DOM (Document
Object Model) objects used in client-side JavaScript (see Chapter 15). The E4X stand-
ard defines optional features for converting between the E4X and DOM representations
of XML documents and elements, but Firefox does not implement these. This is another
reason that E4X may be best considered a server-side technology.
This section presents a quick tutorial on E4X but does not attempt to document it
comprehensively. In particular, the XML and XMLList objects have a number of meth-
ods that are not mentioned here. Neither are they covered in the reference section.
Readers who want to use E4X will need to refer to the specification for definitive
documentation.
E4X defines quite a bit of new language syntax. The most striking bit of new syntax is
that XML markup becomes part of the JavaScript language, and you can include XML
literals like these directly in your JavaScript code:
// Create an XML object
var pt =
<periodictable>
<element id="1"><name>Hydrogen</name></element>
<element id="2"><name>Helium</name></element>
<element id="3"><name>Lithium</name></element>
</periodictable>;
// Add a new element to the table
pt.element += <element id="4"><name>Beryllium</name></element>;
The XML literal syntax of E4X uses curly braces as escape characters that allow you to
place JavaScript expressions within XML. This, for example, is another way to create
the XML element just shown:
pt = <periodictable></periodictable>;              // Start with empty table
var elements = ["Hydrogen", "Helium", "Lithium"];  // Elements to add
// Create XML tags using array contents
for(var n = 0; n < elements.length; n++) {
pt.element += <element id={n+1}><name>{elements[n]}</name></element>;
}
284 | Chapter 11: JavaScript Subsets and Extensions
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
HTML converter toolkit SDK, preserves all the original anchors, links, bookmarks and to Use C#.NET Demo Code to Convert PDF Document to Add necessary references
add hyperlink to pdf online; add links pdf document
.NET PDF Document Viewing, Annotation, Conversion & Processing
Edit, delete text from PDF. Insert images into PDF. Edit, remove images from PDF. Add, edit, delete links. Form Process. Fill in form data programmatically.
add hyperlink to pdf in preview; convert a word document to pdf with hyperlinks
In addition to this literal syntax, you can also work with XML parsed from strings. The
following code adds another element to your periodic table:
pt.element += new XML('<element id="5"><name>Boron</name></element>');
When working with XML fragments, use 
XMLList()
instead of 
XML()
:
pt.element += new XMLList('<element id="6"><name>Carbon</name></element>' +
'<element id="7"><name>Nitrogen</name></element>');
Once you have an XML document defined, E4X defines an intuitive syntax for accessing
its content:
var elements = pt.element;    // Evaluates to a list of all <element> tags
var names = pt.element.name;  // A list of all <name> tags
var n = names[0];             // "Hydrogen": content of <name> tag 0.
E4X also adds new syntax for working with XML objects. The 
..
operator is the de-
scendant operator; you can use it in place of the normal 
.
member-access operator:
// Here is another way to get a list of all <name> tags
var names2 = pt..name;
E4X even has a wildcard operator:
// Get all descendants of all <element> tags.
// This is yet another way to get a list of all <name> tags.  var
names3 = pt.element.*;
Attribute names are distinguished from tag names in E4X using the 
@
character (a syntax
borrowed from XPath). For example, you can query the value of an attribute like this:
// What is the atomic number of Helium?
var atomicNumber = pt.element[1].@id;
The wildcard operator for attribute names is 
@*
:
// A list of all attributes of all <element> tags 
var atomicNums = pt.element.@*;
E4X even includes a powerful and remarkably concise syntax for filtering a list using
an arbitrary predicate expression:
// Start with a list of all elements and filter it so
// it includes only those whose id attribute is < 3
var lightElements = pt.element.(@id < 3);
// Start with a list of all <element> tags and filter so it includes only
// those whose names begin with "B". Then make a list of the <name> tags
// of each of those remaining <element> tags.
var bElementNames = pt.element.(name.charAt(0) == 'B').name;
11.7  E4X: ECMAScript for XML | 285
Core JavaScript
Download from Wow! eBook <www.wowebook.com>
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
add links to pdf in acrobat; clickable links in pdf files
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
the original text style (including font, size, color, links and boldness). C#.NET DLLs and Demo Code: Convert PDF to Word Document in C# Add necessary references
add a link to a pdf in preview; add hyperlinks pdf file
The 
for/each
loop we saw earlier in this chapter (see §11.4.1) is generally useful, but
it was defined by the E4X standard for iterating through lists of XML tags and attributes.
Recall that 
for/each
is like the 
for/in
loop, except that instead of iterating through the
properties of an object, it iterates through the values of the properties of an object:
// Print the names of each element in the periodic table
for each (var e in pt.element)  {
console.log(e.name);
}
// Print the atomic numbers of the elements
for each (var n in pt.element.@*) console.log(n);
E4X expressions can appear on the left side of an assignment. This allows existing tags
and attributes to be changed and new tags and attributes to be added:
// Modify the <element> tag for Hydrogen to add a new attribute
// and a new child element so that it looks like this:
//
// <element id="1" symbol="H">
//   <name>Hydrogen</name>
//   <weight>1.00794</weight>
// </element>
//
pt.element[0].@symbol = "H";
pt.element[0].weight = 1.00794;
Removing attributes and tags is also easy with the standard 
delete
operator:
delete pt.element[0].@symbol; // delete an attribute
delete pt..weight;            // delete all <weight> tags
E4X is designed so that you can perform most common XML manipulations using
language syntax. E4X also defines methods you can invoke on XML objects. Here, for
example, is the 
insertChildBefore()
method:
pt.insertChildBefore(pt.element[1],
<element id="1"><name>Deuterium</name></element>);
E4X is fully namespace-aware and includes language syntax and APIs for working with
XML namespaces:
// Declare the default namespace using a "default xml namespace" statement:
default xml namespace = "http://www.w3.org/1999/xhtml";
// Here's an xhtml document that contains some svg tags, too:
d = <html>
<body>
This is a small red square:
<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10">
<rect x="0" y="0" width="10" height="10" fill="red"/>
</svg>
</body>
</html>
// The body element and its namespace uri and its local name
var tagname = d.body.name();
286 | Chapter 11: JavaScript Subsets and Extensions
C# Create PDF Library SDK to convert PDF from other file formats
PDF with a blank page, bookmarks, links, signatures, etc. PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
pdf email link; add links in pdf
C# Image: Tutorial for Document Management Using C#.NET Imaging
more detailed C# tutorials on each part by following the links respectively are dedicated to provide powerful & profession imaging controls, PDF document, image
pdf link open in new window; add hyperlink pdf file
var bodyns = tagname.uri;
var localname = tagname.localName;
// Selecting the <svg> element is trickier because it is not in the
// default namespace.  So create a Namespace object for svg, and use the
// :: operator to add a namespace to a tagname
var svg = new Namespace('http://www.w3.org/2000/svg');
var color = d..svg::rect.@fill  // "red"
11.7  E4X: ECMAScript for XML | 287
Core JavaScript
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. to edit hyperlink of PDF document, including editing PDF url links and quick
check links in pdf; adding a link to a pdf in preview
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. to edit hyperlink of PDF document, including editing PDF url links and quick
adding an email link to a pdf; adding links to pdf document
CHAPTER 12
Server-Side JavaScript
The previous chapters have covered the core JavaScript language in detail, and we’re
about to start Part II of the book, which explains how JavaScript is embedded in web
browsers and covers the sprawling client-side JavaScript API. JavaScript is the pro-
gramming language of the Web, and most JavaScript code is written for web browsers.
But JavaScript is a fast and capable general-purpose language, and there is no reason
that JavaScript cannot be used for other programming tasks. So before we transition
to client-side JavaScript, we’ll take a quick look at two other JavaScript embeddings.
Rhino is a Java-based JavaScript interpreter that gives JavaScript programs access to the
entire Java API. Rhino is covered in §12.1. Node is a version of Google’s V8 JavaScript
interpreter with low-level bindings for the POSIX (Unix) API—files, processes, streams,
sockets, and so on—and a particular emphasis on asynchronous I/O, networking, and
HTTP. Node is covered in §12.2.
The title of this chapter says that it is about “server-side” JavaScript, and Node and
Rhino are both commonly used to create or to script servers. But the phrase “server-
side” can also be taken to mean “anything outside of the web browser.” Rhino programs
can create graphical UIs with Java’s Swing framework. And Node can run JavaScript
programs that manipulate files the way shell scripts do.
This is a short chapter, intended only to highlight some of the ways that JavaScript can
be used outside of web browsers. It does not attempt to cover Rhino or Node compre-
hensively, and the APIs discussed here are not covered in the reference section. Obvi-
ously, this chapter cannot document the Java platform or the POSIX API, so the section
on Rhino assumes some familiarity with Java and the section on Node assumes some
familiarity with low-level Unix APIs.
12.1  Scripting Java with Rhino
Rhino is a JavaScript interpreter written in Java and designed to make it easy to write
JavaScript programs that leverage the power of the Java platform APIs. Rhino auto-
289
matically handles the conversion of JavaScript primitives to Java primitives, and vice
versa, so JavaScript scripts can set and query Java properties and invoke Java methods.
Obtaining Rhino
Rhino is free software from Mozilla. You can download a copy from http://www.mozilla
.org/rhino/. Rhino version 1.7r2 implements ECMAScript 3 plus a number of the lan-
guage extensions described in Chapter 11. Rhino is mature software and new versions
are not released often. At the time of this writing, a prerelease version of 1.7r3 is avail-
able  from  the  source  repository  and  includes  a  partial  implementation  of
ECMAScript 5.
Rhino is distributed as a JAR archive. Start it with a command line like this:
java -jar rhino1_7R2/js.jar program.js
If you omit 
program.js
, Rhino starts an interactive shell, which is useful for trying out
simple programs and one-liners.
Rhino defines a  handful of  important  global  functions that are not  part of  core
JavaScript:
// Embedding-specific globals: Type help() at the rhino prompt for more
print(x);           // Global print function prints to the console
version(170);       // Tell Rhino we want JS 1.7 language features
load(filename,...); // Load and execute one or more files of JavaScript code
readFile(file);     // Read a text file and return its contents as a string
readUrl(url);       // Read the textual contents of a URL and return as a string
spawn(f);           // Run f() or load and execute file f in a new thread
runCommand(cmd,     // Run a system command with zero or more command-line args
[args...]);
quit()              // Make Rhino exit
Notice the 
print()
function: we’ll use it in this section instead of 
console.log()
. Rhino
represents Java packages and classes as JavaScript objects:
// The global Packages is the root of the Java package hierarchy
Packages.any.package.name // Any package from the Java CLASSPATH
java.lang                 // The global java is a shortcut for Packages.java
javax.swing               // And javax is a shortcut for Packages.javax
// Classes: accessed as properties of packages
var System = java.lang.System;
var JFrame = javax.swing.JFrame;
Because packages and classes are represented as JavaScript objects, you can assign them
to variables to give them shorter names. But you can also more formally import them,
if you want to:
var ArrayList = java.util.ArrayList; // Create a shorter name for a class
importClass(java.util.HashMap);      // Same as: var HashMap = java.util.HashMap
// Import a package (lazily) with importPackage(). 
// Don't import java.lang: too many name conflicts with JavaScript globals.
290 | Chapter 12: Server-Side JavaScript
importPackage(java.util);
importPackage(java.net);
// Another technique: pass any number of classes and packages to JavaImporter()
// and use the object it returns in a with statement
var guipkgs = JavaImporter(java.awt, java.awt.event, Packages.javax.swing);
with (guipkgs) {
/* Classes like Font, ActionListener and JFrame defined here */
}
Java classes can be instantiated using 
new
, just like JavaScript classes can:
// Objects: instantiate Java classes with new
var f = new java.io.File("/tmp/test"); // We'll use these objects below
var out = new java.io.FileWriter(f);
Rhino allows the JavaScript 
instanceof
operator to work with Java objects and classes:
f instanceof java.io.File        // => true
out instanceof java.io.Reader    // => false: it is a Writer, not a Reader
out instanceof java.io.Closeable // => true: Writer implements Closeable
As you can see, in the object instantiation examples above, Rhino allows values to be
passed to Java constructors and the return value of those constructors to be assigned
to JavaScript variables. (Note the implicit type conversion that Rhino performs in this
example: the JavaScript string  “/type/test” is automatically converted into  a Java
java.lang.String value.) Java methods are much like Java constructors, and Rhino allows
JavaScript programs to invoke Java methods:
// Static Java methods work like JavaScript functions
java.lang.System.getProperty("java.version") // Return Java version
var isDigit = java.lang.Character.isDigit;   // Assign static method to variable
isDigit("٢")                                 // => true: Arabic digit 2
// Invoke instance methods of the Java objects f and out created above
out.write("Hello World\n");     
out.close();                    
var len = f.length();
Rhino also allows JavaScript code to query and set the static fields of Java classes and
the instance fields of Java objects. Java classes often avoid defining public fields in favor
of getter and setter methods. When getter and setter methods exist, Rhino exposes
them as JavaScript properties:
// Read a static field of a Java class
var stdout = java.lang.System.out;
// Rhino maps getter and setter methods to single JavaScript properties
f.name          // => "/tmp/test": calls f.getName()
f.directory     // => false: calls f.isDirectory()
Java allows overloaded methods that have the same name but different signatures.
Rhino can usually figure out which version of a method you mean to invoke based on
the type of the arguments you pass. Occasionally, you need to specifically identify a
method by name and signature:
12.1  Scripting Java with Rhino | 291
Core JavaScript
// Suppose the Java object o has a method named f that expects an int or
// a float. In JavaScript, you must specify the signature explicitly:
o['f(int)'](3);            // Call the int method
o['f(float)'](Math.PI);    // Call the float method
You can use a 
for/in
loop to iterate through the methods, fields, and properties of Java
classes and objects:
importClass(java.lang.System);
for(var m in System) print(m); // Print static members of the java.lang.System
for(m in f) print(m);          // Print instance members of java.io.File
// Note that you cannot enumerate the classes in a package this way
for (c in java.lang) print(c); // This does not work
Rhino allows JavaScript programs to get and set the elements of Java arrays as if they
were JavaScript arrays. Java arrays are not the same as JavaScript arrays, of course: they
are fixed length, their elements are typed, and they don’t have JavaScript methods
like 
slice()
. There is no natural JavaScript syntax that Rhino can extend to allow
JavaScript programs to create new Java arrays, so you have to do that using the
java.lang.reflect.Array class:
// Create an array of 10 strings and an array of 128 bytes
var words = java.lang.reflect.Array.newInstance(java.lang.String, 10);
var bytes = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 128);
// Once arrays are created, you can use them much like JavaScript arrays:
for(var i = 0; i < bytes.length; i++)  bytes[i] = i;
Java programming often involves implementing interfaces. This is particularly common
in GUI programing, where each event handler must implement an event listener inter-
face, and the following examples demonstrate how to implement Java event listeners:
// Interfaces: Implement interfaces like this:
var handler = new java.awt.event.FocusListener({
focusGained: function(e) { print("got focus"); },
focusLost: function(e) { print("lost focus"); }
});
// Extend abstract classes in the same way
var handler = new java.awt.event.WindowAdapter({
windowClosing: function(e) { java.lang.System.exit(0); }
});
// When an interface has just one method, you can just use a function instead
button.addActionListener(function(e) { print("button clicked"); });
// If all methods of an interface or abstract class have the same signature,
// then you can use a single function as the implementation, and Rhino will
// pass the method name as the last argument
frame.addWindowListener(function(e, name) {
if (name === "windowClosing") java.lang.System.exit(0);
});
// If you need one object that implements multiple interfaces, use JavaAdapter:
292 | Chapter 12: Server-Side JavaScript
Documents you may be interested
Documents you may be interested