open pdf and draw c# : Add links to pdf in preview application SDK cloud windows winforms wpf class %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D42-part1573

A text field’s 
onchange
event handler is triggered when the user enters new text or edits
existing text and then indicates that he is finished editing by moving input focus out of
the text field.
The Textarea element is like a text input field element, except that it allows the user to
input (and your JavaScript programs to display) multiline text. Textarea elements are
created with a 
<textarea>
tag using a syntax significantly different from the 
<input>
tag
that creates a text field. (See 
TextArea
in Part IV.) Nevertheless, the two types of ele-
ments behave quite similarly. You can use the 
value
property and 
onchange
event han-
dler of a Textarea element just as you can for a Text element.
An 
<input type="password">
element is a modified input field that displays asterisks as
the user types into it. As the name indicates, this is useful to allow a user to enter
passwords without worrying about others reading over his shoulder. Note that the
Password element protects the user’s input from prying eyes, but when the form is
submitted, that input is not encrypted in any way (unless it is submitted over a secure
HTTPS connection), and it may be visible as it is transmitted over the network.
Finally, an 
<input type="file">
element allows the user to enter the name of a file to
be uploaded to the web server. It is a text field combined with a button that opens a
file-chooser dialog box. This file selection element has an 
onchange
event handler, like
a regular input field. Unlike an input field, however, the 
value
property of a file selection
element is read-only. This prevents malicious JavaScript programs from tricking the
user into uploading a file that should not be shared.
The various text input elements define 
onkeypress
onkeydown
, and 
onkeyup
event han-
dlers. You can return 
false
from the 
onkeypress
or 
onkeydown
event handlers to prevent
the user’s keystroke from being recorded. This can be useful, for example, if you want
to force the user to enter only digits into a particular text input field. See Exam-
ple 17-6 for a demonstration of this technique.
15.9.7  Select and Option Elements
The Select element represents a set of options (represented by Option elements) from
which the user can select. Browsers typically render Select elements in drop-down me-
nus, but if you specify a 
size
attribute with a value greater than 1, they will display the
options in a (possibly scrollable) list instead. The Select element can operate in two
very distinct ways, and the value of the 
type
property depends on how it is configured.
If the 
<select>
element has the 
multiple
attribute, the user is allowed to select multiple
options, and the 
type
property of the Select object is “select-multiple”. Otherwise, if
the 
multiple
attribute is not present, only a single item can be selected, and the 
type
property is “select-one”.
In some ways, a select-multiple element is like a set of checkbox elements, and a select-
one element is like a set of radio elements. The options displayed by a Select element
are not toggle buttons, however: they are defined by 
<option>
elements instead. A Select
15.9  HTML Forms | 403
Client-Side
JavaScript
Add links to pdf in preview - 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 link to pdf acrobat; pdf link open in new window
Add links to pdf in preview - 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
add a link to a pdf in preview; add url to pdf
element defines an 
options
property which is an array-like object that contains Option
elements.
When the user selects or deselects an option, the Select element triggers its 
onchange
event handler. For select-one Select elements, the read/write 
selectedIndex
property
specifies which one of the options is currently selected. For select-multiple elements,
the single 
selectedIndex
property is not sufficient to represent the complete set of se-
lected options. In this case, to determine which options are selected, you must loop
through the elements of the 
options[]
array and check the value of the 
selected
prop-
erty for each Option object.
In addition to its 
selected
property, each Option object has a 
text
property that speci-
fies the string of plain text that appears in the Select element for that option. You can
set this property to change the text that is displayed to the user. The 
value
property is
also a read/write string that specifies the text to be sent to the web server when the form
is submitted. Even if you are writing a pure client-side program and your form never
gets submitted, the 
value
property (or its corresponding HTML 
value
attribute) can be
a useful place to store any data that you’ll need if the user selects a particular option.
Note that Option elements do not have form-related event handlers: use the 
onchange
handler of the containing Select element instead.
In addition to setting the 
text
property of Option objects, you can dynamically change
the options displayed in a Select element using special features of the 
options
property
that date to the early days of client-side scripting. You can truncate the array of Option
elements by setting 
options.length
to the desired number of options, and you can
remove all Option objects by setting 
options.length
to 0. You can remove an individual
Option object from the Select element by setting its spot in the 
options[]
array to
null
. This deletes the Option object, and any higher elements in the 
options[]
array
automatically get moved down to fill the empty spot.
To add new options to a Select element, create an Option object with the 
Option()
constructor and append it to the 
options[]
property with code like this:
// Create a new Option object
var zaire = new Option("Zaire",  // The text property
"zaire",  // The value property
false,    // The defaultSelected property
false);   // The selected property
// Display it in a Select element by appending it to the options array:
var countries = document.address.country;  // Get the Select object
countries.options[countries.options.length] = zaire;
Keep in mind that these special-purpose Select element APIs are very old. You can
more  clearly  insert  and  remove  option  elements  with  standard  calls  to
Document.createElement()
Node.insertBefore()
Node.removeChild()
, and so on.
404 | Chapter 15: Scripting Documents
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
add links in pdf; add hyperlink to pdf
C# Image: Tutorial for Document Management Using C#.NET Imaging
navigate viewing document by generating a thumbnail preview. on each part by following the links respectively & profession imaging controls, PDF document, image
add a link to a pdf file; add url link to pdf
15.10  Other Document Features
This chapter began with the assertion that it is one of the most important in the book.
It is also, by necessity, one of the longest. This final section rounds out the chapter by
covering a number of miscellaneous features of the Document object.
15.10.1  Document Properties
This  chapter  has  already  introduced  Document  properties  such  as 
body
,
documentElement
, and 
forms
that refer to special elements of the document. Documents
also define a few other properties of interest:
cookie
A special property that allows JavaScript programs to read and write HTTP cook-
ies. This property is covered in Chapter 20.
domain
A property that allows mutually trusted web servers within the same Internet
domain to collaboratively relax same-origin policy security restrictions on inter-
actions between their web pages (see §13.6.2.1).
lastModified
A string that contains the modification date of the document.
location
This property refers to the same Location object as the 
location
property of the
Window object.
referrer
The URL of the document containing the link, if any, that brought the browser to
the current document. This property has the same content as the HTTP 
Referer
header, but it is spelled with a double r.
title
The text between the 
<title>
and 
<title>
tags for this document.
URL
The URL of the document as a read-only String rather than as a Location object.
The value of this property is the same as the initial value of 
location.href
, but it
is not dynamic like the Location object is. If the user navigates to a new fragment
identifier within the document, for example, 
location.href
will change, but
document.URL
will not.
referrer
is one of the most interesting of these properties: it contains the URL of the
document from which the user linked to the current document. You might use this
property with code like this:
if (document.referrer.indexOf("http://www.google.com/search?") == 0) {
var args = document.referrer.substring(ref.indexOf("?")+1).split("&");
for(var i = 0; i < args.length; i++) {
if (args[i].substring(0,2) == "q=") {
15.10  Other Document Features | 405
Client-Side
JavaScript
C# Word - Convert Word to PDF in C#.NET
of original Word file and maintains the original text style (including font, size, color, links and boldness C# Demo: Convert Word to PDF Document. Add references
clickable links in pdf; adding hyperlinks to pdf files
C# powerpoint - Convert PowerPoint to PDF in C#.NET
PowerPoint file and maintains the original text style (including font, size, color, links and boldness C# Demo: Convert PowerPoint to PDF Document. Add references
add hyperlink pdf file; pdf link to specific page
document.write("<p>Welcome Google User. ");
document.write("You searched for: " +
unescape(args[i].substring(2)).replace('+', ' ');
break;
}
}
}
The 
document.write()
method used in the code above is the subject of the next section.
15.10.2  The document.write() Method
The 
document.write()
method was one of the very first scriptable APIs implemented
by the Netscape 2 web browser. It was introduced well before the DOM and was the
only way to display computed text in a document. It is no longer needed in new code,
but you are likely to see it in existing code.
document.write()
concatenates its string arguments and inserts the resulting string into
the document at the location of the script element that invoked it. When the script
finishes running, the browser parses the generated output and displays it. The following
code, for example, uses 
write()
to dynamically output information into an otherwise
static HTML document:
<script>
document.write("<p>Document title: " + document.title);
document.write("<br>URL: " + document.URL);
document.write("<br>Referred by: " + document.referrer);
document.write("<br>Modified on: " + document.lastModified);
document.write("<br>Accessed on: " + new Date());
</script>
It is important to understand that you can use the 
write()
method to output HTML to
the current document only while that document is being parsed. That is, you can call
document.write()
from within top-level code in 
<script>
elements only because these
scripts are executed as part of the document parsing process. If you place a
document.write() 
call within a function definition and then call that function from an
event handler, it will not work as you expect—in fact, it will erase the current document
and the scripts it contains! (You’ll see why shortly.) For similar reasons, you should
not use 
document.write()
in scripts that have the 
defer
or 
async
attributes set.
Example 13-3 in Chapter 13 used 
document.write()
in this way to generate more com-
plicated output.
You can also use the 
write()
method to create entirely new documents in other win-
dows or frames. (When working with multiple windows or frames, however, you must
be careful not to violate the same-origin policy.) Your first call to the 
write()
method
of another document will erase all content in that document. You can call 
write()
more
than once to build up the new content of the document. The content you pass to
write()
may be buffered (and not displayed) until you terminate the sequence of writes
by calling the 
close()
method of the document object. This, in essence, tells the HTML
406 | Chapter 15: Scripting Documents
C# PDF: C# Code to Create Mobile PDF Viewer; C#.NET Mobile PDF
In Default.aspx, add a reference to the path in for Windows Forms application, please follow above links respectively. More Tutorials on .NET PDF Document SDK.
add links to pdf in preview; c# read pdf from url
C# powerpoint - Convert PowerPoint to HTML in C#.NET
The HTML document file, converted by C#.NET PowerPoint to HTML converter toolkit SDK, preserves all the original anchors, links, bookmarks and Add references:
add a link to a pdf; chrome pdf from link
parser that it has reached the end-of-file for the document and that it should finish
parsing and display the new document.
It is worth noting that the Document object also supports a 
writeln()
method, which
is identical to the 
write()
method in every way except that it appends a newline after
outputting its arguments. This can be useful if you are outputting preformatted text
within a 
<pre>
element, for example.
The 
document.write()
method is not commonly used in modern code: the 
innerHTML
property and other DOM techniques provide a better way of adding content to a docu-
ment. On the other hand, some algorithms do lend themselves nicely to a stream-style
I/O API like that provided by the 
write()
method. If you are writing code that computes
and outputs text while it runs, you might be interested in Example 15-10, which wraps
simple 
write()
and 
close()
methods around the 
innerHTML
property of a specified
element.
Example 15-10. A streaming API for the innerHTML property
// Define a simple "streaming" API for setting the innerHTML of an element.
function ElementStream(elt) {
if (typeof elt === "string") elt = document.getElementById(elt);
this.elt = elt;
this.buffer = "";
}
// Concatenate all arguments and append to the buffer
ElementStream.prototype.write = function() {
this.buffer += Array.prototype.join.call(arguments, "");
};
// Just like write(), but add a newline
ElementStream.prototype.writeln = function() {
this.buffer += Array.prototype.join.call(arguments, "") + "\n";
};
// Set element content from buffer and empty the buffer.
ElementStream.prototype.close = function() {
this.elt.innerHTML = this.buffer;
this.buffer = "";
};
15.10.3  Querying Selected Text
It is sometimes useful to be able to determine what text the user has selected within a
document. You can do that with a function like this:
function getSelectedText() {
if (window.getSelection)       // The HTML5 standard API
return window.getSelection().toString();
else if (document.selection)   // This is the IE-specific technique.
return document.selection.createRange().text;
}
15.10  Other Document Features | 407
Client-Side
JavaScript
C# Word - Convert Word to HTML in C#.NET
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB to HTML converter toolkit SDK, preserves all the original anchors, links, bookmarks and Add references:
add link to pdf file; adding links to pdf
How to C#: Basic SDK Concept of XDoc.PowerPoint
Conversely, conversion from PDF to PowerPoint (.PPTX) is also split PowerPoint file(s), and add, create, insert including editing PowerPoint url links and quick
active links in pdf; adding a link to a pdf in preview
The standard 
window.getSelection()
method returns a Selection object that describes
the current selection as a sequence of one or more Range objects. Selection and Range
define a fairly complex API that is not commonly used and is not documented in this
book. The most important and widely implemented (except in IE) feature of the Se-
lection object is that it has a 
toString()
method that returns the plain text content of
the selection.
IE  defines  a  different  API  that  is  also  left  undocumented  in  this  book.
document.selection
returns  an  object  that  represents  the  selection.  The
createRange()
method of that object returns an IE-specific TextRange object, and the
text
property of that object contains the selected text.
Code like the above can be particularly useful in bookmarklets (§13.2.5.1) that operate
on the selected text by looking up a word with a search engine or reference site. The
following HTML link, for example, looks up the currently selected text in Wikipedia.
When bookmarked, this link and the JavaScript URL it contains become a
bookmarklet:
<a href="javascript: var q;
if (window.getSelection) q = window.getSelection().toString();
else if (document.selection) q = document.selection.createRange().text;
void window.open('http://en.wikipedia.org/wiki/' + q);">
Look Up Selected Text In Wikipedia
</a>
There is an incompatibility in the selection querying code shown above: the
getSelection()
method of the Window object does not return selected text if it is within
an 
<input>
or 
<textarea>
form element: it only returns text selected from the body of
the document itself. The IE 
document.selection
property, on the other hand, returns
selected text from anywhere in the document.
To obtain the selected text from a text input field or 
<textarea>
element, use this code:
elt.value.substring(elt.selectionStart, elt.selectionEnd);
The 
selectionStart
and 
selectionEnd
properties are not supported in IE8 or earlier.
15.10.4  Editable Content
We’ve seen that HTML form elements include text fields and textarea elements that
allow the user to enter and edit plain text. Following the lead of IE, all current web
browsers also support simple HTML editing functionality: you may have seen this in
use on pages (such as blog comment pages) that embed a rich-text editor that includes
a toolbar of buttons for setting typographic styles (bold, italic), setting justification,
and inserting images and links.
There are two ways to enable this editing functionality. Set the 
contenteditable
HTML
attribute of any tag or set the 
contenteditable
JavaScript property on the corresponding
Element to make the content of that element editable. When the user clicks on the
408 | Chapter 15: Scripting Documents
How to C#: Basic SDK Concept of XDoc.Word
Conversely, conversion from PDF to Word (.docx) is also and split Word file(s), and add, create, insert document, including editing Word url links and quick
clickable links in pdf files; add hyperlinks to pdf online
content inside that element, an insertion cursor will appear and the user’s keystrokes
will be inserted. Here is an HTML element that creates an editable region:
<div id="editor" contenteditable>
Click to edit
</div>
Browsers may support automatic spell-checking for form fields and 
contenteditable
elements. In browsers that support this, checking may be on by default or off by default.
Add the 
spellcheck
attribute to explicitly turn checking on in browsers that support it.
And use 
spellcheck=false
to explicitly disable checking (when, for example, a
<textarea>
will display source code or other content with identifiers that do not appear
in dictionaries).
You can also make an entire document editable by setting the 
designMode
property of
the Document object to the string “on”. (Set it to “off” to revert to a read-only docu-
ment.) The 
designMode
property does not have a corresponding HTML attribute. You
might make the document within an 
<iframe>
editable like this (note the use of the
onLoad()
function from Example 13-5):
<iframe id="editor" src="about:blank"></iframe>     // Empty iframe
<script>
onLoad(function() {                                 // When document loads,
var editor = document.getElementById("editor"); // get the iframe document
editor.contentDocument.designMode = "on";       // and turn editing on.
});
</script>
All current browsers support 
contenteditable
and 
designMode
. They are less compati-
ble, however, when it comes to their actual editing behavior. All browsers allow you
to insert and delete text and move the cursor using the mouse and keyboard. In all
browsers, the Enter key begins a new line, but different browsers produce different
markup. Some begin a new paragraph and others simply insert a 
<br/>
element.
Some browsers allow keyboard shortcuts such as Ctrl-B to convert the currently selec-
ted text to bold. In other browsers (such as Firefox), standard word processor shortcuts
such as Ctrl-B and Ctrl-I are bound to other, browser-related functions and are not
available to the text editor.
Browsers define a number of text-editing commands, most of which do not have key-
board shortcuts. To execute these commands, you instead use the 
execCommand()
meth-
od of the Document object. (Note that this is a method of the Document, not of the
element on which the 
contenteditable
attribute is set. If a document contains more
than one editable element, the command applies to whichever one holds the selection
or the insertion cursor.) Commands executed by 
execCommand()
are named by strings
such as “bold”, “subscript”, “justifycenter,” or “insertimage”. The command name is
the first argument to 
execCommand()
. Some commands require a value argument—
“createlink”, for example, requires the hyperlink URL. In theory, if the second argu-
ment to 
execCommand()
is 
true
, the browser will automatically prompt the user for
whatever value is required. For portability, however, you should prompt the user
15.10  Other Document Features | 409
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
yourself, pass 
false
as the second argument, and pass the value as the third argument.
Here are two example functions that perform edits using 
execCommand():
function bold() { document.execCommand("bold", false, null); }
function link() {
var url = prompt("Enter link destination");
if (url) document.execCommand("createlink", false, url);
}
The commands supported by 
execCommand()
are typically triggered by buttons in a
toolbar. A good UI will disable buttons when the command they trigger is not available.
Pass a command name to 
document.queryCommandSupported()
to find out if it is sup-
ported by the browser. Call 
document.queryCommandEnabled()
to find out if the com-
mand can currently be used. (A command that expects a selected range of text, for
example, might be disabled when there is no selection.) Some commands, such as the
“bold” and “italic” commands, have a boolean state and can be on or off depending
on the current selection or cursor location. These commands are typically represented
with a toggle button in a toolbar. Use 
document.queryCommandState()
to determine the
current state of such a command. Finally, some commands, such as “fontname,” have
an associated value (a font family name). Query this value with 
document.queryCommand
Value()
. If the current selection includes text using two different font families, the value
of “fontname” will be indeterminate. Use 
document.queryCommandIndeterm()
to check
for this case.
Different browsers implement different sets of editing commands. A few, such as
“bold”, “italic”, “createlink”, “undo,” and “redo”, are well supported.
6
The HTML5
draft current at the time of this writing defines the following commands. Because they
are not universally supported, however, they are not documented here in any detail:
bold              insertLineBreak          selectAll
createLink        insertOrderedList        subscript
delete            insertUnorderedList      superscript
formatBlock       insertParagraph          undo
forwardDelete     insertText               unlink
insertImage       italic                   unselect
insertHTML        redo
If you need rich-text editing functionality for your web application, you will probably
want to adopt a prebuilt solution that addresses the various differences between brows-
ers. A number of such editor components can be found online.
7
It is worth noting that
the editing functionality built into browsers is powerful enough to allow a user to enter
small amounts of rich text, but it is too simple for any kind of serious document editing.
In particular, note that the HTML markup generated by these editors is likely to be
quite messy.
6.See http://www.quirksmode.org/dom/execCommand.html for a list of interoperable commands.
7.The YUI and Dojo frameworks include editor components. A list of other choices can be found at http:
//en.wikipedia.org/wiki/Online_rich-text_editor.
410 | Chapter 15: Scripting Documents
Once the user has edited the content of an element that has the 
contenteditable
at-
tribute set, you can use the 
innerHTML
property to obtain the HTML markup of the
edited content. What you do with that rich text is up to you. You might store it in a
hidden form field and send it to a server by submitting the form. You might use the
techniques described in Chapter 18 to send the edited text directly to a server. Or you
might use the techniques shown in Chapter 20 to save the user’s edits locally.
15.10  Other Document Features | 411
Client-Side
JavaScript
Documents you may be interested
Documents you may be interested