open pdf and draw c# : Add links pdf document SDK application project winforms windows web page UWP %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D45-part1576

e.style.marginBottom = bottomMargin + "px";
e.style.marginLeft = leftMargin + "px";
The 
style
attribute of an HTML element is its inline style, and it overrides any style
specifications in a stylesheet. Inline styles are generally useful for setting style values,
and that is what the examples above have all done. You can read the properties of a
CSSStyleDeclaration object that represents inline styles, but they return meaningful
values only if they’ve previously been set by your JavaScript code or if the HTML ele-
ment with which you are working has an inline 
style
attribute that sets the desired
properties. For example, your document may include a stylesheet that sets the left
margin for all paragraphs to 30 pixels, but if you read the 
marginLeft
property of one
of your paragraph elements, you’ll get the empty string unless that paragraph has a
style
attribute that overrides the stylesheet setting.
Reading the inline style of an element is particularly difficult for style properties that
require units and for shortcut properties: your code has to include nontrivial CSS pars-
ing capabilities to really make use of those values. In general, the inline style of an
element is only useful for setting styles. If you need to query the style of an element,
use the computed style, which is discussed in §16.4.
Sometimes, you may find it easier to set or query the inline style of an element as a
single string value rather than as a CSSStyleDeclaration object. To do that, you can use
the Element 
getAttribute()
and 
setAttribute()
methods, or you can use the 
cssText
property of the CSSStyleDeclaration object:
// Set the style attribute of e to the string s with either of these lines:
e.setAttribute("style", s);  
e.style.cssText = s;
// Query the inline style string of the element e with either of these:
s = e.getAttribute("style");
s = e.style.cssText;
16.3.1  CSS Animations
One of the most common uses of scripted CSS is to produce animated visual effects.
This can be achieved by using 
setTimeout()
or 
setInterval()
(see §14.1) to repeatedly
invoke a function that alters the inline style of an element. Example 16-3 demonstrates
with two functions 
shake()
and 
fadeOut()
shake()
quickly moves or “shakes” an ele-
ment side to side. It might be used to grab the user’s attention if he enters invalid data,
for example. 
fadeOut()
decreases the opacity of an element over a specified amount of
time (500 milliseconds, by default), causing it to fade out and vanish.
Example 16-3. CSS animations
// Convert element e to relative positioning and "shake" it left and right.
// The first argument can be an element object or the id of an element.
// If a function is passed as the second argument, it will be invoked 
// with e as an argument when the animation is complete.
// The 3rd argument specifies how far to shake e. The default is 5 pixels.
// The 4th argument specifies how long to shake for. The default is 500 ms.
16.3  Scripting Inline Styles | 433
Client-Side
JavaScript
Add links pdf document - 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 edit hyperlink; add hyperlinks to pdf
Add links pdf document - 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 links; convert excel to pdf with hyperlinks
function shake(e, oncomplete, distance, time) {
// Handle arguments
if (typeof e === "string") e = document.getElementById(e);
if (!time) time = 500;
if (!distance) distance = 5;
var originalStyle = e.style.cssText;      // Save the original style of e
e.style.position = "relative";            // Make e relatively positioned
var start = (new Date()).getTime();       // Note the animation start time
animate();                                // Start the animation
// This function checks the elapsed time and updates the position of e.
// If the animation is complete, it restores e to its original state.
// Otherwise, it updates e's position and schedules itself to run again.
function animate() {
var now = (new Date()).getTime();     // Get current time
var elapsed = now-start;              // How long since we started
var fraction = elapsed/time;          // What fraction of total time?
if (fraction < 1) {     // If the animation is not yet complete
// Compute the x position of e as a function of animation
// completion fraction. We use a sinusoidal function, and multiply
// the completion fraction by 4pi, so that it shakes back and
// forth twice.
var x = distance * Math.sin(fraction*4*Math.PI);
e.style.left = x + "px";
// Try to run again in 25ms or at the end of the total time.
// We're aiming for a smooth 40 frames/second animation.
setTimeout(animate, Math.min(25, time-elapsed));
}
else {                  // Otherwise, the animation is complete
e.style.cssText = originalStyle  // Restore the original style
if (oncomplete) oncomplete(e);   // Invoke completion callback
}
}
}
// Fade e from fully opaque to fully transparent over time milliseconds.
// Assume that e is fully opaque when this function is invoked.
// oncomplete is an optional function that will be invoked with e as its
// argument when the animation is done. If time is omitted, use 500ms.
// This function does not work in IE, but could be modified to animate
// IE's nonstandard filter property in addition to opacity.
function fadeOut(e, oncomplete, time) {
if (typeof e === "string") e = document.getElementById(e);
if (!time) time = 500;
// We use Math.sqrt as a simple "easing function" to make the animation
// subtly nonlinear: it fades quickly at first and then slows down some.
var ease = Math.sqrt;
var start = (new Date()).getTime();    // Note the animation start time
animate();                             // And start animating
function animate() {
434 | Chapter 16: Scripting CSS
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
converter toolkit SDK, preserves all the original anchors, links, bookmarks and Use C#.NET Demo Code to Convert PDF Document to HTML5 Add necessary references:
adding links to pdf in preview; change link in pdf
.NET PDF Document Viewing, Annotation, Conversion & Processing
edit, delete links. Form Process. Fill in form data programmatically. Read form data from PDF form file. Add, Update, Delete form fields programmatically. Document
adding hyperlinks to pdf documents; check links in pdf
var elapsed = (new Date()).getTime()-start; // elapsed time
var fraction = elapsed/time;                // As a fraction of total
if (fraction < 1) {     // If the animation is not yet complete
var opacity = 1 - ease(fraction);  // Compute element opacity
e.style.opacity = String(opacity); // Set it on e  
setTimeout(animate,                // Schedule another frame
Math.min(25, time-elapsed));
}
else {                  // Otherwise, we're done
e.style.opacity = "0";          // Make e fully transparent
if (oncomplete) oncomplete(e);  // Invoke completion callback
}
}
}
Both 
shake()
and 
fadeOut()
accept an optional callback function as their second argu-
ment. If specified, this function will be invoked when the animation is complete. The
element that was animated is passed as an argument to the callback. The following
HTML creates a button that, when clicked, shakes from side to side and then fades
away:
<button onclick="shake(this, fadeOut);">Shake and Fade</button>
Note that the 
shake()
and 
fadeOut()
example functions are quite similar to each other,
and both can serve as templates for similar animations of other CSS properties. Client-
side libraries, such as jQuery usually support pre-defined visual effects, however, so
you may never actually need to write an animation function like 
shake()
, unless you
want to create a particularly complex visual effect. One early and noteworthy effects
library is Scriptaculous, which is designed for use with the Prototype framework. Visit
http://script.aculo.us/ and http://scripty2.com/ to learn more.
The CSS3 Transitions module defines a way to specify animated effects in stylesheets,
obviating the need for any scripting. Instead of defining a function like 
fadeOut()
, for
example, you might use CSS like this:
.fadeable { transition: opacity .5s ease-in }
This specifies that any time the opacity of a “fadeable” element changed, that change
will be animated (from the current value to the new value) over a period of half a second,
using a nonlinear easing function. CSS Transitions is not yet standard but has been
implemented for some time in Safari and Chrome using the 
-webkit-transition
prop-
erty. At the time of this writing, Firefox 4 has added support using 
-moz-transition
.
16.4  Querying Computed Styles
The 
style
property of an element is that element’s inline style. It overrides all style-
sheets, and it is the perfect place to set CSS properties to change the visual appearance
of an element. It is not, however, generally useful for querying the styles that actually
apply to an element. For that, you want the computed style. The computed style for an
element is the set of property values that the browser derives (or computes) from the
16.4  Querying Computed Styles | 435
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:
convert a word document to pdf with hyperlinks; pdf reader link
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
pdf hyperlinks; add hyperlinks pdf file
inline style plus all applicable style rules in all linked stylesheets: it is the set of properties
actually used to display the element. Like inline styles, computed styles are represented
with a CSSStyleDeclaration object. Unlike inline styles, however, computed styles are
read-only. You can’t set these styles, but the computed CSSStyleDeclaration object for
an element lets you determine exactly what style property values the browser used when
rendering that element.
Obtain the computed style for an element with the 
getComputedStyle()
method of the
Window object. The first argument to this method is the element whose computed
style is desired. The second argument is required and is usually 
null
or the empty string,
but it can also be a string that names a CSS pseudoelement, such as “:before”, “:after”,
“:first-line”, or “:first-letter”:
var title = document.getElementById("section1title");
var titlestyles = window.getComputedStyle(element, null);
The return value of 
getComputedStyle()
is a CSSStyleDeclaration object that represents
all the styles that apply to the specified element (or pseudoelement). There are a number
of important differences between a CSSStyleDeclaration object that represents inline
styles and one that represents computed styles:
• Computed style properties are read-only.
• Computed style properties are absolute: relative units like percentages and points
are converted to absolute values. Any property that specifies a size (such as a margin
size or a font size) will have a value measured in pixels. This value will be a string
with a “px” suffix, so you’ll still need to parse it, but you won’t have to worry about
parsing or converting units. Properties whose values are colors will be returned in
“rgb(#,#,#)” or “rgba(#,#,#,#)” format.
• Shortcut properties are not computed, only the fundamental properties that they
are based on. Don’t query the 
margin
property, for example, but use 
marginLeft
,
marginTop
, and so on.
• The 
cssText
property of the computed style is undefined.
Computed styles and inline styles can be used together. Example 16-4 defines functions
scale()
and 
scaleColor()
. One queries and parses the computed text size of a specified
element; the other queries and parses the computed background color of an element.
Both functions then scale the resulting value and set the scaled value as an inline style
of the element. (These functions do not work in IE8 and earlier: as we’ll discuss below,
those versions of IE do not support 
getComputedStyle()
.)
Example 16-4. Querying computed styles and setting inline styles
// Scale the text size of element e by the specified factor
function scale(e, factor) {
// Use the computed style to query the current size of the text
var size = parseInt(window.getComputedStyle(e,"").fontSize);
// And use the inline style to enlarge that size
e.style.fontSize = factor*size + "px";
}
436 | Chapter 16: Scripting CSS
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
change link in pdf file; c# read pdf from url
C# Create PDF Library SDK to convert PDF from other file formats
PDF with a blank page, bookmarks, links, signatures, etc. a PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
pdf link to email; chrome pdf from link
// Alter the background color of element e by the specified amount.
// Factors > 1 lighten the color and factors < 1 darken it.  
function scaleColor(e, factor) {
var color = window.getComputedStyle(e, "").backgroundColor;  // Query
var components = color.match(/[\d\.]+/g);   // Parse r,g,b, and a components
for(var i = 0; i < 3; i++) {                // Loop through r, g and b
var x = Number(components[i]) * factor;         // Scale each one
x = Math.round(Math.min(Math.max(x, 0), 255));  // Round and set bounds
components[i] = String(x);                      
}
if (components.length == 3)  // A rgb() color
e.style.backgroundColor = "rgb(" + components.join() + ")";
else                         // A rgba() color
e.style.backgroundColor = "rgba(" + components.join() + ")";
}
Computed styles can be tricky, and querying them does not always provide the infor-
mation you might expect. Consider the 
font-family
property: it accepts a comma-
separated list of desired font families for cross-platform portability. When you query
the 
fontFamily
property of a computed style, you’re simply getting the value of the most
specific 
font-family
style that applies to the element. This may return a value such as
“arial,helvetica,sans-serif”, which does not tell you which typeface is actually in use.
Similarly, if an element is not absolutely positioned, attempting to query its position
and size through the 
top
and 
left
properties of its computed style often returns the
value “auto”. This is a perfectly legal CSS value, but it is probably not what you were
looking for.
getComputedStyle()
is not implemented by IE8 and earlier, but it is expected in IE9. In
IE,  every  HTML  element  has  a 
currentStyle
property  whose  value  is  a
CSSStyleDeclaration. IE’s 
currentStyle
combines inline styles with stylesheets, but it
is not a true computed style because relative values are not converted to absolute values.
Querying the properties of IE’s current style can return sizes with relative units like
“%” or “em” or colors with imprecise names like “red”.
Although CSS can be used to precisely specify the position and size of document ele-
ments, querying the computed style of an element is not the preferred way to determine
the element’s size and position. See §15.8.2 for a simpler, portable alternative.
16.5  Scripting CSS Classes
An alternative to scripting individual CSS styles through the inline 
style
property is to
script the value of the HTML 
class
attribute. Changing an element’s 
class
changes the
set of stylesheet selectors that apply to the element and can cause multiple CSS prop-
erties to change at the same time. Suppose, for example, that you want a way to draw
the user’s attention to individual paragraphs (or other elements) of a document. You
might start by defining attention-grabbing styles for any elements that have a class name
of “attention”:
16.5  Scripting CSS Classes | 437
Client-Side
JavaScript
Download from Wow! eBook <www.wowebook.com>
C# Image: Tutorial for Document Management Using C#.NET Imaging
detailed C# tutorials on each part by following the links respectively. are dedicated to provide powerful & profession imaging controls, PDF document, image to
add hyperlink in pdf; add hyperlink pdf
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
pdf edit hyperlink; add links to pdf acrobat
.attention {  /* Styles to grab the user's attention */
background-color: yellow;    /* Yellow highlight background */
font-weight: bold;           /* Bold text */
border: solid black 2px;     /* Black box */
}
The identifier 
class
is a reserved word in JavaScript, so the HTML 
class
attribute is
available to JavaScript code using the name 
className
. Here is code that sets and clears
the 
className
property of an element to add and remove the “attention” class for that
element:
function grabAttention(e) { e.className = "attention"; }
function releaseAttention(e) { e.className = ""; }
HTML elements can be members of more than one CSS class and the 
class
attribute
holds a space-separated list of class names. The 
className
property has a misleading
name: 
classNames
would have been a much better choice. The functions above assume
that the 
className
property will specify zero or one class name and do not work when
more than one class is in use. If an element already has a class assigned, calling the
grabAttention()
function for that element will overwrite the existing class.
HTML5 addresses this issue by defining a 
classList
property for every element. The
value of this property is known as a DOMTokenList: a read-only array-like object
(§7.11) whose elements contain the individual classnames for the element. More im-
portant than its array elements, however, are the methods defined by DOMTokenList.
add()
and 
remove()
add and remove individual class names from the element’s 
class
attribute. 
toggle()
adds a classname if it is not already present and removes it otherwise.
Finally, the 
contains()
method tests whether the 
class
attribute contains a specified
classname.
Like other DOM collection types, a DOMTokenList is a “live” representation of the
element’s set of classes, not a static snapshot of the classes at the time the 
classList
property is queried. If you obtain a DOMTokenList from the 
classList
property of an
element and then change the 
className
property of that element, those changes are
immediately visible through the token list. Similarly, any changes you make through
the token list are immediately visible through the 
className
property.
At the time of this writing, the 
classList
property is not supported by all current
browsers. This important functionality is easy to approximate, however, with code like
that of Example 16-5. Using code like this that allows an element’s 
class
attribute to
be treated as a set of classnames makes many CSS scripting tasks much easier.
Example 16-5. classList(): treat className as a set of CSS classes
/*
* Return the classList property of e, if it has one.
* Otherwise, return an object that simulates the DOMTokenList API for e.
* The returned object has contains(), add(), remove(), toggle() and toString()
* methods for testing and altering the set of classes of the element e.
* If the classList property is natively supported, the returned object is
* array-like and has length and array index properties. The simulated
438 | Chapter 16: Scripting CSS
* DOMTokenList is not array-like, but has a toArray() method that returns
* a true-array snapshot of the element's class names.
*/
function classList(e) {
if (e.classList) return e.classList;   // Return e.classList if it exists
else return new CSSClassList(e);       // Otherwise try to fake it
}
// CSSClassList is a JavaScript class that simulates DOMTokenList
function CSSClassList(e) { this.e = e; }
// Return true if e.className contains the class c, false otherwise
CSSClassList.prototype.contains = function(c) {
// Check that c is a valid class name
if (c.length === 0 || c.indexOf(" ") != -1) 
throw new Error("Invalid class name: '" + c + "'");
// Check common cases first
var classes = this.e.className;
if (!classes) return false;       // e has no classes at all
if (classes === c) return true;   // e has one class that matches exactly
// Otherwise, use a RegExp to search for c as a word by itself
// \b in a regular expression requires a match at a word boundary.
return classes.search("\\b" + c + "\\b") != -1;
};
// Add c to the e.className if it is not already present
CSSClassList.prototype.add = function(c) {
if (this.contains(c)) return;            // Do nothing if already present
var classes = this.e.className;
if (classes && classes[classes.length-1] != " ")
c = " " + c;                         // Add a space if we need one
this.e.className += c;                   // Add c to the className
};
// Remove all occurrences of c from e.className
CSSClassList.prototype.remove = function(c) {
// Make sure c is a valid class name
if (c.length === 0 || c.indexOf(" ") != -1) 
throw new Error("Invalid class name: '" + c + "'");
// Remove all occurances of c as a word, plus any trailing space
var pattern = new RegExp("\\b" + c + "\\b\\s*", "g");
this.e.className = this.e.className.replace(pattern, "");
};
// Add c to e.className if it is not already present and return true.
// Otherwise, remove all occurrences of c from e.className and return false.
CSSClassList.prototype.toggle = function(c) {
if (this.contains(c)) {  // If e.className contains c
this.remove(c);      // then remove it.
return false;
}
else {                   // Otherwise:
this.add(c);         // add it.
return true;
}
16.5  Scripting CSS Classes | 439
Client-Side
JavaScript
};
// Return e.className itself
CSSClassList.prototype.toString = function() { return this.e.className; };
// Return of the names in e.className
CSSClassList.prototype.toArray = function() {
return this.e.className.match(/\b\w+\b/g) || [];
};
16.6  Scripting Stylesheets
So far, we’ve seen how to set and query the CSS styles and classes of individual elements.
It is also possible to script CSS stylesheets themselves. This is not commonly done, but
it can occasionally be useful and this section sketches out the technique.
When scripting stylesheets, there are two kinds of objects you may need to work with.
The first kind are the Element objects that represent 
<style>
and 
<link>
elements that
contain or reference your stylesheets. These are regular document elements and if you
give them 
id
attributes, you can select them with 
document.getElementById()
. The sec-
ond kind of object is a CSSStyleSheet object that represents the stylesheet itself. The
document.styleSheets
property is a read-only array-like object containing CSSStyle-
Sheet objects that represent the stylesheets associated with the document. If you set
the 
title
attribute of the 
<style>
or 
<link>
element that defines or references the style-
sheet, that title will be available as the 
title
property of the corresponding CSSStyle-
Sheet object.
The subsections that follow explain what you can do with these style and link elements
and stylesheet objects.
16.6.1  Enabling and Disabling Stylesheets
The simplest stylesheet scripting technique is also the most portable and robust.
<style>
elements, 
<link>
elements, and CSSStyleSheet objects all define a 
disabled
property that you can query and set in JavaScript. As its name implies, if the 
disabled
property is 
true
, then the stylesheet is disabled and is ignored by the browser.
The 
disableStylesheet()
function below demonstrates this. If passed a number, it
treats it as an index into the 
document.styleSheets
array. If passed a string, it treats it
as a CSS selector and passes it to 
document.querySelectorAll()
(see §15.2.5), then sets
the 
disabled
property of all returned elements:
function disableStylesheet(ss) {
if (typeof ss === "number") 
document.styleSheets[ss].disabled = true;
else {
var sheets = document.querySelectorAll(ss);
for(var i = 0; i < sheets.length; i++)
440 | Chapter 16: Scripting CSS
sheets[i].disabled = true;
}
}
16.6.2  Querying, Inserting and Deleting Stylesheet Rules
In addition to disabling and enabling stylesheets, the CSSStyleSheet object also defines
an API for querying, inserting, and deleting the style rules of a stylesheet. IE8 and before
implement a slightly different API than the standard API implemented by other
browsers.
Manipulating stylesheets directly is not normally a useful thing to do. Instead of editing
or adding new rules to a stylesheet, it is typically better to leave your stylesheets static
and script the 
className
property of your elements. On the other hand, if you want to
allow the user complete control over the styles used on your pages, you might need to
dynamically manipulate a stylesheet.
The elements  of the 
document.styleSheets[]
array are  CSSStyleSheet objects. A
CSSStyleSheet object has a 
cssRules[]
array that contains the rules of the stylesheet:
var firstRule = document.styleSheets[0].cssRules[0];
IE uses the property name 
rules
instead of 
cssRules
.
The elements of the 
cssRules[]
or 
rules[]
arrays are CSSRule objects. In the standard
API, a CSSRule object may represent any kind of CSS rule, including at-rules such as
@import
and 
@page
directives. In IE, however, the 
rules[]
array contains only the actual
style rules of the stylesheet.
CSSRule objects have two properties that can be used portably. (In the standard API,
a rule that is not a style rule will not have these properties defined, and you probably
want to skip over it when traversing the stylesheet.) 
selectorText
is the CSS selector
for the rule, and 
style
refers to a writable CSSStyleDeclaration object that describes
the styles associated with that selector. Recall that CSSStyleDeclaration is the same type
used to represent inline and computed styles. You can use this 
CSSStyleDeclaration
object to query the style values or to set new styles for the rule. Often, when traversing
a stylesheet, you are interested in the text of the rule rather than a parsed representation
of the rule. In this case, use the 
cssText
property of the CSSStyleDeclaration object to
obtain the text representation of the rules.
In addition to querying and altering the existing rules of a stylesheet, you can also add
rules to and remove rules from a stylesheet. The standard API interface defines
insertRule()
and 
deleteRule()
methods for adding and removing rules:
document.styleSheets[0].insertRule("H1 { text-weight: bold; }", 0);
IE does not support 
insertRule()
and 
deleteRule()
but defines largely equivalent
addRule()
and 
removeRule()
functions. The only real difference (aside from the different
names) is that 
addRule()
expects the selector text and styles text as two separate
arguments.
16.6  Scripting Stylesheets | 441
Client-Side
JavaScript
The following code loops through the rules of a stylesheet, demonstrating the API by
making some dubious changes to the stylesheet:
var ss = document.styleSheets[0];              // Get the first stylesheet 
var rules = ss.cssRules?ss.cssRules:ss.rules;  // Get the stylesheet rules
for(var i = 0; i < rules.length; i++) {        // Loop through those rules
var rule = rules[i];
if (!rule.selectorText) continue;  // Skip @import and other nonstyle rules
var selector = rule.selectorText;  // The selector
var ruleText = rule.style.cssText; // The styles, in text form
// If the rule applies to h1 elements, apply it to h2 elements as well
// Note this only works if the selector is literally "h1"
if (selector == "h1") {
if (ss.insertRule) ss.insertRule("h2 {" + ruleText + "}", rules.length);
else if (ss.addRule) ss.addRule("h2", ruleText, rules.length);
}
// If the rule sets the text-decoration property, delete it.
if (rule.style.textDecoration) {
if (ss.deleteRule) ss.deleteRule(i);
else if (ss.removeRule) ss.removeRule(i);
i--; // Adjust the loop index since the former rule i+1 is now rule i
}
}
16.6.3  Creating New Stylesheets
Finally, it is possible to create entirely new stylesheets and add them to your document.
In most browsers, this is done with standard DOM techniques: just create a new
<style>
element and insert it into the document head, then use its 
innerHTML
property
to set stylesheet content. In IE8 and before, however, a new CSSStyleSheet object is
created with the nonstandard method 
document.createStyleSheet()
, and stylesheet
text is specified using the 
cssText
property. Example 16-6 demonstrates.
Example 16-6. Creating a new stylesheet
// Add a stylesheet to the document and populate it with the specified styles.
// The styles argument can be a string or an object. If it is a string, it
// is treated as the text of the stylesheet. If it is an object, then each
// property defines a style rule to be added to the stylesheet. Property 
// names are selectors and their values are the corresponding styles
function addStyles(styles) {
// First, create a new stylesheet
var styleElt, styleSheet;
if (document.createStyleSheet) { // If the IE API is defined, use it
styleSheet = document.createStyleSheet();
}
else {
var head = document.getElementsByTagName("head")[0]
styleElt = document.createElement("style"); // New <style> element
head.appendChild(styleElt);                 // Insert it into <head>
442 | Chapter 16: Scripting CSS
Documents you may be interested
Documents you may be interested