open pdf and draw c# : Add hyperlink pdf control application platform web page azure winforms web browser %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D49-part1580

// Put the frame in the document and move the content elt into the frame.
content.parentNode.insertBefore(frame, content);
frame.appendChild(content);
// Position the element relative to the frame
content.style.position = "relative";
content.style.left = contentX + "px";
content.style.top = contentY + "px";
// We'll need to work around some browser-specific quirks below
var isMacWebkit = (navigator.userAgent.indexOf("Macintosh") !== -1 &&
navigator.userAgent.indexOf("WebKit") !== -1);
var isFirefox = (navigator.userAgent.indexOf("Gecko") !== -1);
// Register mousewheel event handlers.
frame.onwheel = wheelHandler;       // Future browsers
frame.onmousewheel = wheelHandler;  // Most current browsers
if (isFirefox)                      // Firefox only
frame.addEventListener("DOMMouseScroll", wheelHandler, false);
function wheelHandler(event) {
var e = event || window.event;  // Standard or IE event object
// Extract the amount of rotation from the event object, looking
// for properties of a wheel event object, a mousewheel event object 
// (in both its 2D and 1D forms), and the Firefox DOMMouseScroll event.
// Scale the deltas so that one "click" toward the screen is 30 pixels.
// If future browsers fire both "wheel" and "mousewheel" for the same
// event, we'll end up double-counting it here. Hopefully, however,
// cancelling the wheel event will prevent generation of mousewheel.
var deltaX = e.deltaX*-30 ||  // wheel event
e.wheelDeltaX/4 ||  // mousewheel
0;    // property not defined
var deltaY = e.deltaY*-30 ||  // wheel event
e.wheelDeltaY/4 ||  // mousewheel event in Webkit
(e.wheelDeltaY===undefined &&      // if there is no 2D property then 
e.wheelDelta/4) ||  // use the 1D wheel property
e.detail*-10 ||  // Firefox DOMMouseScroll event
0;     // property not defined
// Most browsers generate one event with delta 120 per mousewheel click.
// On Macs, however, the mousewheels seem to be velocity-sensitive and
// the delta values are often larger multiples of 120, at 
// least with the Apple Mouse. Use browser-testing to defeat this.
if (isMacWebkit) {
deltaX /= 30;
deltaY /= 30;
}
// If we ever get a mousewheel or wheel event in (a future version of)
// Firefox, then we don't need DOMMouseScroll anymore.
if (isFirefox && e.type !== "DOMMouseScroll")
frame.removeEventListener("DOMMouseScroll", wheelHandler, false);
// Get the current dimensions of the content element
var contentbox = content.getBoundingClientRect();
17.6  Mousewheel Events | 473
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
Add hyperlink pdf - 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
pdf link to specific page; add link to pdf acrobat
Add hyperlink pdf - 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
chrome pdf from link; clickable links in pdf
var contentwidth = contentbox.right - contentbox.left;
var contentheight = contentbox.bottom - contentbox.top;
if (e.altKey) {  // If Alt key is held down, resize the frame
if (deltaX) {
framewidth -= deltaX; // New width, but not bigger than the
framewidth = Math.min(framwidth, contentwidth);  // content
framewidth = Math.max(framewidth,50);   // and no less than 50.
frame.style.width = framewidth + "px";  // Set it on frame
}
if (deltaY) {
frameheight -= deltaY;  // Do the same for the frame height
frameheight = Math.min(frameheight, contentheight);
frameheight = Math.max(frameheight-deltaY, 50);
frame.style.height = frameheight + "px";
}
}
else { // Without the Alt modifier, pan the content within the frame
if (deltaX) {
// Don't scroll more than this
var minoffset = Math.min(framewidth-contentwidth, 0);
// Add deltaX to contentX, but don't go lower than minoffset
contentX = Math.max(contentX + deltaX, minoffset);
contentX = Math.min(contentX, 0);     // or higher than 0
content.style.left = contentX + "px"; // Set new offset
}
if (deltaY) {
var minoffset = Math.min(frameheight - contentheight, 0);
// Add deltaY to contentY, but don't go lower than minoffset
contentY = Math.max(contentY + deltaY, minoffset);
contentY = Math.min(contentY, 0);     // Or higher than 0
content.style.top = contentY + "px";  // Set the new offset.
}
}
// Don't let this event bubble. Prevent any default action.
// This stops the browser from using the mousewheel event to scroll
// the document. Hopefully calling preventDefault() on a wheel event
// will also prevent the generation of a mousewheel event for the
// same rotation.
if (e.preventDefault) e.preventDefault();
if (e.stopPropagation) e.stopPropagation();
e.cancelBubble = true;  // IE events
e.returnValue = false;  // IE events
return false;
}
}
17.7  Drag and Drop Events
Example 17-2 showed how to respond to mouse drags within an application. It is pos-
sible to use techniques like that to allow elements to be dragged and “dropped” within
a web page, but true “drag-and-drop” is something else. Drag-and-drop (or DnD) is a
user interface for transferring data between a “drag source” and “drop target” that may
474 | Chapter 17: Handling Events
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. Hyperlink Edit. XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document
add a link to a pdf file; convert excel to pdf with hyperlinks
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. Hyperlink Edit. XDoc.PDF for .NET allows VB.NET developers to edit hyperlink of PDF
add a link to a pdf; add links pdf document
be in the same application or in different applications. DnD is a complex human/
computer interaction, and APIs for implementing DnD are always complicated:
• They have to tie into the underlying OS so that they can work between unrelated
applications.
• They must accommodate “move”, “copy”, and “link” data-transfer operations,
allow the drag source and drop target to restrict the set of allowed operations, and
then allow the user to choose (usually using keyboard modifiers) among the per-
mitted set.
• They must provide a way for a drag source to specify the icon or image to be
dragged.
• They must provide event-based notification to both the drag source and the drop
target of the progress of the DnD interaction.
Microsoft introduced a DnD API into early versions of IE. It was not a well-designed
or well-documented API, but other browsers have attempted to replicate it, and
HTML5 standardizes something like the IE API and then adds new features that make
the API much easier to use. This new easy-to-use DnD API is not implemented at the
time of this writing, so this section covers the IE API, as blessed by the HTML5 standard.
The IE DnD API is tricky to use and implementation differences in current browsers
make it impossible to use some of the more sophisticated parts of the API interoperably,
but it does allow web applications to participate in interapplication DnD like regular
desktop applications can. Browsers have always been able to perform simple DnD. If
you select text in a web browser, it is easy to drag that text into a word processor. And
if you select a URL in a word processor, you can drag it to the browser to make the
browser visit the URL. What this section demonstrates is how to create custom drag
sources that transfer data other than their textual content and custom drop targets that
respond to dropped data in some way other than simply displaying it.
DnD is always event-based and the JavaScript API involves two sets of events: one set
that is fired on the drag source and another set that is fired on the drop target. All DnD
event handlers are passed an event object that is like a mouse event object, with the
addition of a 
dataTransfer
property. This property refers to a DataTransfer object that
defines the methods and properties of the DnD API.
Drag source events are relatively simple and we’ll begin with them. Any document
element that has the HTML 
draggable
attribute is a drag source. When the user begins
a mouse drag over a drag source, the browser does not select the element content:
instead, it fires a 
dragstart
event on the element. Your handler for that event should
call 
dataTransfer.setData()
to specify the data (and the type of that data) that the drag
source is making available. (When the new HTML5 API is implemented, you might
call 
dataTransfer.items.add()
instead.)  Your  handler  may  also  want  to  set
dataTransfer.effectAllowed
to specify which of the “move”, “copy”, and “link” trans-
fer operations are supported and it might want to call 
dataTransfer.setDragImage()
or
17.7  Drag and Drop Events | 475
Client-Side
JavaScript
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Change Word hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Word to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
clickable links in pdf from word; adding links to pdf document
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Change Excel hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Excel to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
pdf links; add url pdf
dataTransfer.addElement()
(in browsers that support those methods) to specify an im-
age or document element to be used as the visual representation of the drag.
While the drag progresses, the browser fires drag events on the drag source. You can
listen for these events if you want to update the drag image or alter the data being
offered, but it is not generally necessary to register “drag” handlers.
When a drop occurs, the dragend event is fired. If your drag source supports a “move”
operation, it should check 
dataTransfer.dropEffect
to see if a move operation was
actually performed. If so, the data has been transferred elsewhere, and you should delete
it from the drag source.
The dragstart event is the only one you need to implement simple custom drag sources.
Example 17-4 is an example. It displays the current time in “hh:mm” format in a
<span>
element and updates the time once a minute. If this was all the example did, the
user could select the text displayed in the clock and then drag the time. But the Java-
Script code in this example makes the clock into a custom drag source by setting the
draggable
property of this clock element to 
true
and defining an 
ondragstart
event
handler function. The event handler uses 
dataTransfer.setData()
to specify a complete
timestamp string (including the date, seconds, and timezone information) as the data
to be dragged. It also calls 
dataTransfer.setDragIcon()
to specify an image (a clock
icon) to be dragged.
Example 17-4. A custom drag source
<script src="whenReady.js"></script>
<script>
whenReady(function() {
var clock = document.getElementById("clock");  // The clock element
var icon = new Image();                        // An image to drag
icon.src = "clock-icon.png";                   // Image URL
// Display the time once every minute
function displayTime() {
var now = new Date();               // Get current time
var hrs = now.getHours(), mins = now.getMinutes();
if (mins < 10) mins = "0" + mins;
clock.innerHTML = hrs + ":" + mins; // Display current time
setTimeout(displayTime, 60000);     // Run again in 1 minute
}
displayTime();
// Make the clock draggable
// We can also do this with an HTML attribute: <span draggable="true">...
clock.draggable = true;
// Set up drag event handlers
clock.ondragstart = function(event) {
var event = event || window.event; // For IE compatability
// The dataTransfer property is key to the drag-and-drop API
var dt = event.dataTransfer;
476 | Chapter 17: Handling Events
C# PDF Library SDK to view, edit, convert, process PDF file for C#
editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update
adding an email link to a pdf; adding a link to a pdf in preview
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Please click to see details. PDF Hyperlink Edit. RasterEdge PDF SDK for .NET package offers robust APIs for editing PDF document
add hyperlinks to pdf; clickable pdf links
// Tell the browser what is being dragged.
// The Date() constructor used as a function returns a timestamp string
dt.setData("Text", Date() + "\n");
// Tell the browser to drag our icon to represent the timestamp, in
// browsers that support that. Without this line, the browser may
// use an image of the clock text as the value to drag.
if (dt.setDragImage) dt.setDragImage(icon, 0, 0);
};
});
</script>
<style> 
#clock { /* Make the clock look nice */
font: bold 24pt sans; background: #ddf; padding: 10px;
border: solid black 2px; border-radius: 10px;
}
</style>
<h1>Drag timestamps from the clock</h1>
<span id="clock"></span>  <!-- The time is displayed here -->
<textarea cols=60 rows=20></textarea> <!-- You can drop timestamps here -->
Drop targets are trickier than drag sources. Any document element can be a drop target:
there is no need to set an HTML attribute as there is for drag sources; you simply need
to define appropriate event listeners. (With the new HTML5 DnD API, however, you
will be able to define a 
dropzone
attribute on the drop target instead of defining some
of the event handlers described below.) There are four events that are fired at drop
targets. When a dragged object enters a document element, the browser fires a
dragenter event on that element. Your drop target should use the 
dataTransfer.types
property to determine whether the dragged object has data available in a format that
it can understand. (You might also want to check 
dataTransfer.effectAllowed
to en-
sure that the drag source and your drop target can agree on one of the move, copy, and
link operations.) If these checks succeed, your drop target must let both the user and
the browser know that it is interested in a drop. You can give this feedback to the user
by changing its border or background color. Surprisingly, a drop target tells the browser
that it is interested in a drop by canceling the event.
If an element does not cancel the dragenter event the browser sends it, the browser will
not treat it as a drop target for this drag and will not send it any more events. But if a
drop target does cancel the dragenter event, the browser will send dragover events as
the user continues to drag the object over that target. Surprisingly (again) a drop target
must listen for and cancel all of these events to indicate its continued interest in the
drop. If the drop target wants to specify that it only allows move, copy, or link opera-
tions, it should use this dragover event handler to set 
dataTransfer.dropEffect
.
If the user moves the dragged object off of a drop target that has indicated interest by
canceling events, then the dragleave event will be fired on the drop target. The handler
for this event should restore the element’s border or background color or undo any
other visual feedback performed in response to the dragenter event. Unfortunately,
both the dragenter and dragleave events bubble and if a drop target has elements nested
17.7  Drag and Drop Events | 477
Client-Side
JavaScript
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Change Word hyperlink to PDF hyperlink and bookmark. C#.NET Sample Code: Convert Word to PDF in C#.NET Project. Add necessary references:
check links in pdf; add hyperlink pdf
.NET PDF SDK - Description of All PDF Processing Control Feastures
Create signatures in existing PDF signature fields; Create signatures in new fields which hold the signature; Add signature image to PDF file. PDF Hyperlink Edit
pdf hyperlinks; add page number to pdf hyperlink
within it, it is difficult to know whether a dragleave event means that the drag has left
the drop target for an event outside of the target or for an event inside the target.
Finally, if the user drops an object on a drop target, the drop event is fired on the drop
target. The handler for this event should use the 
dataTransfer.getData()
to obtain the
data that was transferred and do something appropriate with it. Alternatively, if the
user dropped one or more files on the drop target, the 
dataTransfer.files
property
will be an array-like object of File objects. (See Example 18-11 for a demonstration.)
With the new HTML5 API, drop event handlers will be able to loop through the ele-
ments of 
dataTransfer.items[]
to examine both files and nonfile data.
Example 17-5 demonstrates how to make 
<ul>
elements into drop targets and how to
make the 
<li>
elements within them into drag sources. The example is a piece of un-
obtrusive JavaScript that looks for 
<ul>
elements with a 
class
attribute that includes
“dnd” and registers DnD event handlers on any such lists it finds. The event handlers
make the list itself into a drop target: any text you drop onto the list is turned into a
new list item and is inserted at the end of the list. The event handlers also listen for
drags on the items within the list and make the text of each list item available for
transfer. The drag source handlers allow “copy” and “move” operations and delete list
items that are dropped in move operations. (Note, however, that not all browsers sup-
port move operations interoperably.)
Example 17-5. A list as drop target and drag source
/*
* The DnD API is quite complicated, and browsers are not fully interoperable.
* This example gets the basics right, but each browser is a little different
* and each one seems to have its own unique bugs. This code does not attempt
* browser-specific workarounds.
*/
whenReady(function() {  // Run this function when the document is ready
// Find all <ul class='dnd'> elements and call the dnd() function on them
var lists = document.getElementsByTagName("ul");
var regexp = /\bdnd\b/;
for(var i = 0; i < lists.length; i++)
if (regexp.test(lists[i].className)) dnd(lists[i]);
// Add drag-and-drop handlers to a list element
function dnd(list) {
var original_class = list.className;  // Remember original CSS class
var entered = 0;                      // Track enters and leaves
// This handler is invoked when a drag first enters the list. It checks
// that the drag contains data in a format it can process and, if so,
// returns false to indicate interest in a drop. In that case, it also
// highlights the drop target to let the user know of that interest.
list.ondragenter = function(e) {
e = e || window.event;  // Standard or IE event
var from = e.relatedTarget; 
// dragenter and dragleave events bubble, which makes it tricky to
478 | Chapter 17: Handling Events
// know when to highlight or unhighlight the element in a case like
// this where the <ul> element has <li> children. In browsers that
// define relatedTarget we can track that.
// Otherwise, we count enter/leave pairs
// If we entered from outside the list or if
// this is the first entrance then we need to do some stuff
entered++;
if ((from && !ischild(from, list)) || entered == 1) {
// All the DnD info is in this dataTransfer object
var dt = e.dataTransfer; 
// The dt.types object lists the types or formats that the data
// being dragged is available in. HTML5 says the type has a
// contains() method. In some browsers it is an array with an
// indexOf method. In IE8 and before, it simply doesn't exist.
var types = dt.types;    // What formats data is available in
// If we don't have any type data or if data is
// available in plain text format, then highlight the
// list to let the user know we're listening for drop
// and return false to let the browser know.
if (!types ||                                           // IE
(types.contains && types.contains("text/plain")) || //HTML5
(types.indexOf && types.indexOf("text/plain")!=-1)) //Webkit 
{
list.className = original_class + " droppable";
return false;
}
// If we don't recognize the data type, we don't want a drop
return;   // without canceling
}
return false; // If not the first enter, we're still interested
};
// This handler is invoked as the mouse moves over the list.
// We have to define this handler and return false or the drag
// will be canceled.
list.ondragover = function(e) { return false; };
// This handler is invoked when the drag moves out of the list
// or out of one of its children. If we are actually leaving the list
// (not just going from one list item to another), then unhighlight it.
list.ondragleave = function(e) {
e = e || window.event;
var to = e.relatedTarget;
// If we're leaving for something outside the list or if this leave
// balances out the enters, then unhighlight the list
entered--;
if ((to && !ischild(to,list)) || entered <= 0) {
list.className = original_class;
entered = 0;
}
return false;
17.7  Drag and Drop Events | 479
Client-Side
JavaScript
};
// This handler is invoked when a drop actually happens.
// We take the dropped text and make it into a new <li> element
list.ondrop = function(e) {
e = e || window.event;       // Get the event
// Get the data that was dropped in plain text format.
// "Text" is a nickname for "text/plain".  
// IE does not support "text/plain", so we use "Text" here.
var dt = e.dataTransfer;       // dataTransfer object
var text = dt.getData("Text"); // Get dropped data as plain text.
// If we got some text, turn it into a new item at list end.
if (text) {
var item = document.createElement("li"); // Create new <li>
item.draggable = true;                   // Make it draggable
item.appendChild(document.createTextNode(text)); // Add text
list.appendChild(item);                  // Add it to the list
// Restore the list's original style and reset the entered count
list.className = original_class;
entered = 0;
return false;
}
};
// Make all items that were originally in the list draggable
var items = list.getElementsByTagName("li");
for(var i = 0; i < items.length; i++)
items[i].draggable = true;
// And register event handlers for dragging list items.
// Note that we put these handlers on the list and let events
// bubble up from the items.
// This handler is invoked when a drag is initiated within the list.
list.ondragstart = function(e) {
var e = e || window.event;
var target = e.target || e.srcElement;
// If it bubbled up from something other than a <li>, ignore it
if (target.tagName !== "LI") return false;
// Get the all-important dataTransfer object
var dt = e.dataTransfer;
// Tell it what data we have to drag and what format it is in
dt.setData("Text", target.innerText || target.textContent);
// Tell it we know how to allow copies or moves of the data
dt.effectAllowed = "copyMove";
};
// This handler is invoked after a successful drop occurs
list.ondragend = function(e) {
e = e || window.event;
var target = e.target || e.srcElement;
480 | Chapter 17: Handling Events
// If the drop was a move, then delete the list item.
// In IE8, this will be "none" unless you explicitly set it to 
// move in the ondrop handler above.  But forcing it to "move" for
// IE prevents other browsers from giving the user a choice of a
// copy or move operation.
if (e.dataTransfer.dropEffect === "move")
target.parentNode.removeChild(target);
}
// This is the utility function we used in ondragenter and ondragleave.
// Return true if a is a child of b.
function ischild(a,b) {
for(; a; a = a.parentNode) if (a === b) return true;
return false;
}
}
});
17.8  Text Events
Browsers have three legacy events for keyboard input. The keydown and keyup events
are low-level events that are covered in the next section. The keypress event, however,
is a higher-level event that signals that a printable character has been generated. The
DOM Level 3 Events draft specification defines a more general textinput event triggered
whenever the user inputs text regardless of the source (a keyboard, data transfer in the
form of a paste or a drop, an Asian-language input method, or a voice or handwriting
recognition system, for example). The textinput event is not supported at the time of
this writing, but Webkit browsers support a very similar “textInput” (with a capital
letter I) event.
The proposed textinput event and the currently implemented textInput event are
passed a simple event object with a 
data
property that holds the input text. (Another
property, 
inputMethod
, is proposed to specify the source of the input, but it has not yet
been implemented.) For keyboard input, the 
data
property will usually hold only a
single character, but input from other sources may often include multiple characters.
The event object passed with keypress events is more confusing. A keypress event rep-
resents a single character of input. The event object specifies that character as a numeric
Unicode codepoint, and you must use 
String.fromCharCode()
to convert it to a string.
In most browsers, the 
keyCode
property of the event object specifies the codepoint of
the input character. For historical reasons, however, Firefox uses the 
charCode
property
instead. Most browser only fire keypress events when a printable character is generated.
Firefox, however, also fires “keypress” for nonprinting characters. To detect this case
(so you can ignore the nonprinting characters), you can look for an event object with
charCode
property that is defined but set to 0.
The textinput, textInput, and keypress events can be canceled to prevent the character
from being input. This means you can use these events to filter input. You might want
to prevent a user from entering letters into a field intended for numeric data, for ex-
17.8  Text Events | 481
Client-Side
JavaScript
ample. Example 17-6 is an unobtrusive module of JavaScript code that allows exactly
this sort of filtering. It looks for 
<input type=text>
elements that have an additional
(nonstandard) attribute named 
data-allowed-chars
. The module registers handlers for
textinput, textInput, and keypress events on any such text field to restrict input to
characters that appear in the value of the allowed attribute. The initial comment at the
top of Example 17-6 includes some sample HTML that uses the module.
Example 17-6. Filtering user input
/**
* InputFilter.js: unobtrusive filtering of keystrokes for <input> elements
*
* This module finds all <input type="text"> elements in the document that
* have an "data-allowed-chars" attribute. It registers keypress, textInput, and
* textinput event handlers for any such element to restrict the user's input
* so that only characters that appear in the value of the attribute may be
* entered. If the <input> element also has an attribute named "data-messageid",
* the value of that attribute is taken to be the id of another document
* element. If the user types a character that is not allowed, the message
* element is made visible. If the user types a character that is allowed, the
* message element is hidden. This message id element is intended to offer
* an explanation to the user of why her keystroke was rejected. It should
* typically be styled with CSS so that it is initially invisible.
*
* Here is sample HTML that uses this module.
*   Zipcode: <input id="zip" type="text"
*                   data-allowed-chars="0123456789" data-messageid="zipwarn">
*   <span id="zipwarn" style="color:red;visibility:hidden">Digits only</span>
*
* This module is purely unobtrusive: it does not define any symbols in
* the global namespace.
*/
whenReady(function () {  // Run this function when the document is loaded
// Find all <input> elements
var inputelts = document.getElementsByTagName("input");
// Loop through them all
for(var i = 0 ; i < inputelts.length; i++) {
var elt = inputelts[i];
// Skip those that aren't text fields or that don't have
// a data-allowed-chars attribute.
if (elt.type != "text" || !elt.getAttribute("data-allowed-chars"))
continue;
// Register our event handler function on this input element
// keypress is a legacy event handler that works everywhere.
// textInput (mixed-case) is supported by Safari and Chrome in 2010.
// textinput (lowercase) is the version in the DOM Level 3 Events draft.
if (elt.addEventListener) {
elt.addEventListener("keypress", filter, false);
elt.addEventListener("textInput", filter, false);
elt.addEventListener("textinput", filter, false);
}
else { // textinput not supported versions of IE w/o addEventListener()
elt.attachEvent("onkeypress", filter); 
}
482 | Chapter 17: Handling Events
Documents you may be interested
Documents you may be interested