open pdf and draw c# : Add links to pdf online application Library cloud html .net winforms class %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D48-part1579

• Handlers registered with 
addEventListener()
are invoked in the order in which
they were registered.
4
• Handlers registered with 
attachEvent()
may be invoked in any order and your code
should not depend on sequential invocation.
17.3.6  Event Propagation
When the target of an event is the Window object, or some other standalone object
(such as an XMLHttpRequest), the browser responds to an event simply by invoking
the appropriate handlers on that one object. When the event target is a Document or
document Element, however, the situation is more complicated.
After the event handlers registered on the target element are invoked, most events
“bubble” up the DOM tree. The event handlers of the target’s parent are invoked. Then
the handlers registered on the target’s grandparent are invoked. This continues up to
the Document object, and then beyond to the Window object. Event bubbling provides
an alternative to registering handlers on lots of individual document elements: instead
you can register a single handler on a common ancestor element and handle events
there. You might register an “change” handler on a 
<form>
element, for example, instead
of registering a “change” handler for every element in the form.
Most events that occur on document elements bubble. Notable exceptions are the fo-
cus, blur, and scroll events. The load event on document elements bubbles, but it stops
bubbling at the Document object and does not propagate on to the Window object.
The load event of the Window object is triggered only when the entire document has
loaded.
Event bubbling is the third “phase” of event propagation. The invocation of the event
handlers of the target object itself is the second phase. The first phase, which occurs
even before the target handlers are invoked, is called the “capturing” phase. Recall that
addEventListener()
takes a boolean value as its third argument. If that argument is
true
, the event handler is registered as a capturing event handler for invocation during
this first phase of event propagation. Event bubbling is universally supported: it works
in all browsers including IE, and it works for all handlers, regardless of how they are
registered (unless they are registered as capturing event handlers). Event capturing, by
contrast, only works with event handlers registered with 
addEventListener()
when the
third argument is 
true
. This means that event capturing is not available in IE prior to
IE9, and is not, at the time of this writing, a commonly used technique.
The capturing phase of event propagation is like the bubbling phase in reverse. The
capturing handlers of the Window object are invoked first, then the capturing handlers
of the Document object, then of the body object, and so on down the DOM tree until
4.The DOM Level 2 standard leaves the invocation order undefined, but current browsers all invoke the
handlers in registration order and the current DOM Level 3 draft standardizes this behavior.
17.3  Event Handler Invocation | 463
Client-Side
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 a link to a pdf file; adding a link to a pdf
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
add link to pdf; add hyperlink pdf document
the capturing event handlers of the parent of the event target are invoked. Capturing
event handlers registered on the event target itself are not invoked.
Event capturing provides an opportunity to peek at events before they are delivered to
their target. A capturing event handler can be used for debugging, or it can be used
along with the event cancellation technique described below to filter events so that the
target event handlers are never actually invoked. One common use for event capturing
is handling mouse drags, where mouse motion events need to be handled by the object
being dragged, not the document elements over which it is dragged. See Exam-
ple 17-2 for an example.
17.3.7  Event Cancellation
§17.3.4 explained that the return value of event handlers registered as properties can
be used to cancel the browser’s default action for the event. In browsers that support
addEventListener()
, you can also cancel the default action for an event by invoking the
preventDefault()
method of the event object. In IE prior to IE9, however, you do the
same by setting the 
returnValue
property of the event object to 
false
. The following
code shows a dummy event handler that uses all three cancellation techniques:
function cancelHandler(event) {
var event = event || window.event;  // For IE
/* Do something to handle the event here */
// Now cancel the default action associated with the event
if (event.preventDefault) event.preventDefault();  // Standard technique
if (event.returnValue) event.returnValue = false;  // IE
return false;        // For handlers registered as object properties
}
The current DOM Events module draft defines a property of the Event object named
defaultPrevented
. It is not yet widely supported, but the intent is that this property will
normally be 
false
but will become 
true
if 
preventDefault()
is called.
5
Canceling the default action associated with an event is only one kind of event cancel-
lation. We can also cancel the propagation of events. In browsers that support
addEventListener()
, the event object has a 
stopPropagation()
method that you can
invoke to prevent the continued propagation of the event. If there are other handlers
defined on the same object, the rest of those handlers will still be invoked, but no event
handlers on any other object will be invoked after 
stopPropagation()
is called. The
stopPropagation()
method can be called at any time during event propagation. It works
during the capturing phase, at the event target itself, and during the bubbling phase.
Prior to IE9, IE does not support the 
stopPropagation()
method. Instead, the IE event
object has a property named 
cancelBubble
. Set this property to 
true
to prevent any
5.The jQuery (see Chapter 19) event object has a 
defaultPrevented()
method instead of a property.
464 | Chapter 17: Handling Events
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
clickable links in pdf; add page number to pdf hyperlink
.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.
adding an email link to a pdf; add hyperlinks to pdf online
further propagation. (IE8 and before do not support the capturing phase of event prop-
agation, so bubbling is the only kind of propagation to be canceled.)
The current draft DOM Events specification defines another method on the Event ob-
ject, named 
stopImmediatePropagation()
. Like 
stopPropagation()
, this method pre-
vents the propagation of the event to any other objects. But it also prevents the invo-
cation of any other event handlers registered on the same object. At the time of this
writing, some browsers support 
stopImmediatePropagation()
and some do not. Some
utility libraries, like jQuery and YUI, define 
stopImmediatePropagation()
in a cross-
platform way.
17.4  Document Load Events
Now that we’ve covered the fundamentals of JavaScript event handling, we’ll start
looking in more detail at specific categories of events. We begin, in this section, with
document load events.
Most web applications need notification from the web browser to tell them when the
document has been loaded and is ready to be manipulated. The load event on the
Window object serves this purpose and was discussed in detail in Chapter 13, which
included an 
onLoad()
utility function in Example 13-5. The load event does not fire
until a document and all of its images are fully loaded. It is usually safe, however, to
start running your scripts after the document is fully parsed but before images are
downloaded. You can improve the startup time of your web applications if you trigger
your scripts on events other than “load”.
The DOMContentLoaded event is fired when the document has been loaded and
parsed and any deferred scripts have been executed. Images and 
async
scripts may still
be loading, but the document is ready to be manipulated. (Deferred and async scripts
are explained in §13.3.1.) This event was introduced by Firefox, and it has been adopted
by all other browser vendors, including Microsoft in IE9. Despite the “DOM” in its
name, it is not part of the DOM Level 3 event standard, but it is standardized by
HTML5.
As described in §13.3.4, the 
document.readyState
property changes as the document
loads. In IE, each change in state is accompanied by a readystatechange event on the
Document object, and it is possible to use this event to determine when IE reaches the
“complete” state. HTML5 standardizes the readystatechange event, but fires it imme-
diately before the load event, so it is not clear that much advantage is gained by listening
for “readystatechange” instead of “load”.
Example 17-1 defines a 
whenReady()
function that is much like the 
onLoad()
function
of Example 13-5. Functions passed to 
whenReady()
will be invoked (as methods of the
Document object) when the document is ready to be manipulated. Unlike the earlier
onLoad()
function, 
whenReady()
listens for DOMContentLoaded and readystatechange
events, and uses load events only as backup for older browsers that do not support the
17.4  Document Load Events | 465
Client-Side
JavaScript
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 a link to a pdf in preview; add email link to pdf
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 links in pdf; pdf links
earlier events. Some of the examples that follow (in this and subsequent chapters) use
this 
whenReady()
function.
Example 17-1. Invoking functions when the document is ready
/*
* Pass a function to whenReady() and it will be invoked (as a method of the
* document) when the document is parsed and ready for manipulation. Registered
* functions are triggered by the first DOMContentLoaded, readystatechange, or
* load event that occurs. Once the document is ready and all functions have
* been invoked, any functions passed to whenReady() will be invoked 
* immediately.
*/
var whenReady = (function() { // This function returns the whenReady() function
var funcs = [];    // The functions to run when we get an event
var ready = false; // Switches to true when the handler is triggered
// The event handler invoked when the document becomes ready
function handler(e) {
// If we've already run once, just return
if (ready) return;
// If this was a readystatechange event where the state changed to
// something other than "complete", then we're not ready yet
if (e.type === "readystatechange" && document.readyState !== "complete")
return;
// Run all registered functions.
// Note that we look up funcs.length each time, in case calling
// one of these functions causes more functions to be registered.
for(var i = 0; i < funcs.length; i++) 
funcs[i].call(document);
// Now set the ready flag to true and forget the functions
ready = true;
funcs = null;
}
// Register the handler for any event we might receive
if (document.addEventListener) {
document.addEventListener("DOMContentLoaded", handler, false);
document.addEventListener("readystatechange", handler, false);
window.addEventListener("load", handler, false);
}
else if (document.attachEvent) {
document.attachEvent("onreadystatechange", handler);
window.attachEvent("onload", handler);
}
// Return the whenReady function
return function whenReady(f) {
if (ready) f.call(document); // If already ready, just run it
else funcs.push(f);          // Otherwise, queue it for later.
}
}());
466 | Chapter 17: Handling Events
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
convert a word document to pdf with hyperlinks; add links to pdf online
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
add link to pdf; add links to pdf file
17.5  Mouse Events
There are quite a few mouse-related events. Table 17-1 lists them all. All mouse events
except “mouseenter” and “mouseleave” bubble. Click events on links and Submit but-
tons have default actions that can be prevented. You may be able to cancel a context
menu event to prevent the display of a context menu, but some browsers have config-
uration options that make context menus noncancelable.
Table 17-1. Mouse events
Type
Description
click
A higher-level event fired when the user presses and releases a mouse button or otherwise “activates” an
element.
contextmenu A cancelable event fired when a contextmenu is about to be popped up. Current browsers display context
menus on right mouse clicks, so this event can also be used like the click event.
dblclick
Fired when the user double-clicks the mouse
mousedown
Fired when the user presses a mouse button
mouseup
Fired when the user releases a mouse button
mousemove
Fired when the user moves the mouse.
mouseover
Fired when the mouse enters an element. 
relatedTarget
(or 
fromElement
in IE); specifies what element
the mouse is coming from.
mouseout
Fired when the mouse leaves an element. 
relatedTarget
(or 
toElement
in IE); specifies what element
the mouse is going to.
mouseenter
Like “mouseover”, but does not bubble. Introduced by IE and standardized in HTML5 but not yet widely
implemented.
mouseleave
Like “mouseout”, but does not bubble. Introduced by IE and standardized in HTML5 but not yet widely
implemented.
The object passed to mouse event handlers has 
clientX
and 
clientY
properties that
specify the coordinates of the mouse pointer relative to the containing window. Add
the window’s scroll offsets (see Example 15-8) to convert this position to document
coordinates.
The 
altKey
ctrlKey
metaKey
, and 
shiftKey
properties specify whether various key-
board modifier keys were held down when the event occurred: this allows you to dis-
tinguish an ordinary click from a Shift-click, for example.
The 
button
property specifies which mouse button, if any, was held down when the
event occurred. Different browsers assign different values to this property, however, so
it is difficult to use portably. See the Event reference page for details. Some browsers
only fire click events for left button clicks. You should use mousedown and mouseup
if you need to detect clicks of other buttons. The contextmenu event usually signals a
right-button click, but as noted above, it may be impossible to prevent the appearance
of a context menu when this event occurs.
17.5  Mouse Events | 467
Client-Side
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
adding a link to a pdf; add links to pdf acrobat
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
add hyperlink to pdf online; adding hyperlinks to pdf documents
The event object for mouse events has a few other mouse-specific properties, but they
are not as commonly used as these. See the Event reference page for a list.
Example 17-2 shows a JavaScript function, 
drag()
, that, when invoked from a 
mouse
down
event handler, allows an absolutely positioned document element to be dragged
by the user. 
drag()
works with both the DOM and IE event models.
drag()
takes two arguments. The first is the element that is to be dragged. This may be
the element on which the mousedown event occurred or a containing element (e.g.,
you might allow the user to drag on an element that looks like a titlebar to move the
containing element that looks like a window). In either case, however, it must be a
document element that is absolutely positioned using the CSS 
position
attribute. The
second argument is the event object from the triggering mousedown event. Here’s a
simple example that uses 
drag()
. It defines an 
<img>
that the user can drag if the Shift
key is held down:
<img src="draggable.gif"
style="position:absolute; left:100px; top:100px;"
onmousedown="if (event.shiftKey) drag(this, event);">
The 
drag()
function converts the position of the mousedown event to document co-
ordinates in order to compute the distance between the mouse pointer and the upper-
left corner of the element being moved. It uses 
getScrollOffsets()
from Exam-
ple 15-8 to help with the coordinate conversion. Next, 
drag()
registers event handlers
for the mousemove and mouseup events that follow the mousedown event. The mouse-
move handler is responsible for moving the document element, and the mouseup han-
dler is responsible for deregistering itself and the mousemove handler.
It is important to note that the mousemove and mouseup handlers are registered as
capturing event handlers. This is because the user may move the mouse faster than the
document element can follow it, and if that happens, some of the mousemove events
occur outside the original target element. Without capturing, those events will not be
dispatched to the correct handlers. The IE event model does not support event cap-
turing the way the standard event model does, but it does have a special-purpose
setCapture()
method for capturing mouse events in cases just like this. The example
code shows how it works.
Finally, note that the 
moveHandler()
and 
upHandler()
functions are defined within
drag()
. Because they are defined in this nested scope, they can use the arguments and
local variables of 
drag()
, which considerably simplifies their implementation.
Example 17-2. Dragging document elements
/**
* Drag.js: drag absolutely positioned HTML elements.
*
* This module defines a single drag() function that is designed to be called
* from an onmousedown event handler. Subsequent mousemove events will
* move the specified element. A mouseup event will terminate the drag.
* This implementation works with both the standard and IE event models.
468 | Chapter 17: Handling Events
* It requires the getScrollOffsets() function from elsewhere in this book.
*
* Arguments:
*
*   elementToDrag: the element that received the mousedown event or
*     some containing element. It must be absolutely positioned. Its
*     style.left and style.top values will be changed based on the user's
*     drag.
*
*   event: the Event object for the mousedown event.
**/
function drag(elementToDrag, event) {
// The initial mouse position, converted to document coordinates
var scroll = getScrollOffsets();  // A utility function from elsewhere
var startX = event.clientX + scroll.x;
var startY = event.clientY + scroll.y;
// The original position (in document coordinates) of the element
// that is going to be dragged.  Since elementToDrag is absolutely
// positioned, we assume that its offsetParent is the document body.
var origX = elementToDrag.offsetLeft;
var origY = elementToDrag.offsetTop;
// Compute the distance between the mouse down event and the upper-left
// corner of the element. We'll maintain this distance as the mouse moves.
var deltaX = startX - origX;
var deltaY = startY - origY;
// Register the event handlers that will respond to the mousemove events
// and the mouseup event that follow this mousedown event.
if (document.addEventListener) {  // Standard event model
// Register capturing event handlers on the document
document.addEventListener("mousemove", moveHandler, true);
document.addEventListener("mouseup", upHandler, true);
}
else if (document.attachEvent) {  // IE Event Model for IE5-8
// In the IE event model, we capture events by calling
// setCapture() on the element to capture them.
elementToDrag.setCapture();
elementToDrag.attachEvent("onmousemove", moveHandler);
elementToDrag.attachEvent("onmouseup", upHandler);
// Treat loss of mouse capture as a mouseup event.
elementToDrag.attachEvent("onlosecapture", upHandler);
}
// We've handled this event. Don't let anybody else see it.
if (event.stopPropagation) event.stopPropagation();  // Standard model
else event.cancelBubble = true;                      // IE
// Now prevent any default action.
if (event.preventDefault) event.preventDefault();   // Standard model
else event.returnValue = false;                     // IE
/**
* This is the handler that captures mousemove events when an element
* is being dragged. It is responsible for moving the element.
17.5  Mouse Events | 469
Client-Side
JavaScript
**/
function moveHandler(e) {
if (!e) e = window.event;  // IE event Model
// Move the element to the current mouse position, adjusted by the
// position of the scrollbars and the offset of the initial click.
var scroll = getScrollOffsets();
elementToDrag.style.left = (e.clientX + scroll.x - deltaX) + "px";
elementToDrag.style.top = (e.clientY + scroll.y - deltaY) + "px";
// And don't let anyone else see this event.
if (e.stopPropagation) e.stopPropagation();  // Standard
else e.cancelBubble = true;                  // IE
}
/**
* This is the handler that captures the final mouseup event that
* occurs at the end of a drag.
**/
function upHandler(e) {
if (!e) e = window.event;  // IE Event Model
// Unregister the capturing event handlers.
if (document.removeEventListener) {  // DOM event model
document.removeEventListener("mouseup", upHandler, true);
document.removeEventListener("mousemove", moveHandler, true);
}
else if (document.detachEvent) {  // IE 5+ Event Model
elementToDrag.detachEvent("onlosecapture", upHandler);
elementToDrag.detachEvent("onmouseup", upHandler);
elementToDrag.detachEvent("onmousemove", moveHandler);
elementToDrag.releaseCapture();
}
// And don't let the event propagate any further.
if (e.stopPropagation) e.stopPropagation();  // Standard model
else e.cancelBubble = true;                  // IE
}
}
The following code shows how you can use 
drag()
in an HTML file (it’s a simplified
version of Example 16-2, with the addition of dragging):
<script src="getScrollOffsets.js"></script> <!-- drag() requires this -->
<script src="Drag.js"></script>             <!-- defines drag() -->
<!-- The element to be dragged -->
<div style="position:absolute; left:100px; top:100px; width:250px;
background-color: white; border: solid black;">
<!-- The "titlebar" to drag it with. Note the onmousedown attribute. -->
<div style="background-color: gray; border-bottom: dotted black;
padding: 3px; font-family: sans-serif; font-weight: bold;"
onmousedown="drag(this.parentNode, event);">
Drag Me  <!-- The content of the titlebar -->
</div>
<!-- Content of the draggable element -->
470 | Chapter 17: Handling Events
<p>This is a test. Testing, testing, testing.</p><p>Test</p><p>Test</p>
</div>
The key here is the 
onmousedown
attribute of the inner 
<div>
element. Note that it uses
this.parentNode
to specify that the entire container element is to be dragged.
17.6  Mousewheel Events
All modern browsers support mouse wheels and fire events when the user rotates the
mousewheel. Browsers often use the mousewheel to scroll the document or to zoom
in or out, but you can cancel the mousewheel event to prevent those default actions.
There are a number of interoperability issues that affect mousewheel events, but it is
possible to write code that works on all platforms. At the time of this writing, all
browsers but Firefox support an event named “mousewheel”. Firefox uses “DOM-
MouseScroll” instead. And the DOM Level 3 Events draft proposes an event named
“wheel” instead of “mousewheel”. In addition to the differences in event names, the
objects passed to these various events use different property names to specify the
amount of wheel rotation that occurred. Finally, note that there are fundamental hard-
ware distinctions between mouse wheels as well. Some allow 1-dimensional rotation
forward and back and some (particularly on Macs) also allow rotation left and right
(on these mice the “wheel” is really a trackball). The DOM Level 3 standard even
includes support for 3-dimensional mouse “wheels” that can report clockwise or
counter-clockwise rotation in addition to forward/back and left/right.
The event object passed to a “mousewheel” handler has a 
wheelDelta
property that
specifies how far the user turned the wheel. One mousewheel “click” away from the
user is generally a delta of 120 and one click toward the user is -120. In Safari and
Chrome, to support Apple’s mice that include a two-dimensional trackball instead of
a one-dimensional mousewheel, the event object has 
wheelDeltaX
and 
wheelDeltaY
properties in addition to 
wheelDelta
, and 
wheelDelta
and 
wheelDeltaY
are always the
same value.
In Firefox you can the nonstandard DOMMouseScroll event instead of mousewheel
and use the 
detail
property of the event object instead of 
wheelDelta
. The scaling and
sign of this 
detail
property is different than 
wheelDelta
, however: multiply 
detail
by
-40 to compute the equivalent 
wheelDelta
value.
At the time of this writing, the DOM Level 3 Events draft standard defines a wheel
event as the standardized version of mousewheel and DOMMouseScroll. The object
passed to a wheel event handler will have 
deltaX
deltaY
, and 
deltaZ
properties to
specify rotation in three dimensions. You must multiply these values by -120 to match
the value and sign of a mousewheel event.
For all of these event types, the event object is like a mouse event object: it includes
mouse pointer coordinates and the state of the keyboard modifier keys.
17.6  Mousewheel Events | 471
Client-Side
JavaScript
Example 17-3 demonstrates how to work with mouse wheel events and how to do so
interoperably across platforms. It defines a function named 
enclose()
that wraps a
“frame” or “viewport” of the specified size around a larger content element (such as an
image) and defines a mouse wheel event handler that allows the user to pan the content
element within the viewport and also to resize the viewport. You might use this
enclose()
function with code like this:
<script src="whenReady.js"></script>
<script src="Enclose.js"></script>
<script>
whenReady(function() {
enclose(document.getElementById("content"),400,200,-200,-300);
});
</script>
<style>div.enclosure {  border: solid black 10px; margin: 10px; }</style>
<img id="content" src="testimage.jpg"/>
In order to work correctly in all common browsers, Example 17-3 must perform some
browser testing (§13.4.5). The example anticipates the DOM Level 3 Events specifi-
cation and includes code to use the wheel event when browsers implement it.
6
It also
includes some future-proofing to stop using the DOMMouseScroll event when Firefox
starts firing wheel or mousewheel. Note that Example 17-3 is also a practical example
of the element geometry and CSS positioning techniques explained in §15.8 and
§16.2.1.
Example 17-3. Handling mousewheel events
// Enclose the content element in a frame or viewport of the specified width
// and height (minimum 50x50). The optional contentX and contentY arguments
// specify the initial offset of the content relative to the frame. (If
// specified, they must be <= 0.) The frame has mousewheel event handlers that
// allow the user to pan the element, and to shrink or enlarge the frame.
function enclose(content, framewidth, frameheight, contentX, contentY) {
// These arguments aren't just the initial values: they maintain the
// current state and are used and modified by the mousewheel handler.
framewidth = Math.max(framewidth, 50);
frameheight = Math.max(frameheight, 50);
contentX = Math.min(contentX, 0) || 0;
contentY = Math.min(contentY, 0) || 0;
// Create the frame element and set a CSS classname and styles
var frame = document.createElement("div");
frame.className = "enclosure"; // So we can define styles in a stylesheet
frame.style.width = framewidth + "px";       // Set the frame size.
frame.style.height = frameheight + "px";
frame.style.overflow = "hidden";             // No scrollbars, no overflow
frame.style.boxSizing = "border-box";        // Border-box simplifies the 
frame.style.webkitBoxSizing = "border-box";  // calculations for resizing
frame.style.MozBoxSizing = "border-box";     // the frame.
6.This is risky: if future implementations do not match the draft specification current as I write this, this
will backfire and the example will break.
472 | Chapter 17: Handling Events
Documents you may be interested
Documents you may be interested