home | O'Reilly's CD bookshelfs | FreeBSD | Linux | Cisco | Cisco Exam  

HTML: The Definitive Guide

Previous Chapter 13
Executable Content

13.4 JavaScript Style Sheets

Much of a browser's work is manipulating the display, and much of their display code already had been exposed for JavaScripting. So it seemed only natural, perhaps even relatively easy, for the developers at Netscape to implement JavaScript Style Sheets. Based on the W3C recommended Cascading Style Sheet model (CSS; see Chapter 9, Cascading Style Sheets), this alternative document style technology lets you prescribe display properties for all the various HTML elements, either inline as tag attributes, at the document level, or for an entire document collection.

JavaScript Style Sheets (JSS) are a Netscape invention. In fact, for a short time in the fall of 1996, Netscape appeared ready to eschew the CSS methodology, which Internet Explorer already had implemented, and use JSS exclusively for HTML document designers with their new browser, Netscape Navigator 4.0. Fortunately, the new version now supports both JSS and CSS technologies.

We are strong proponents of reasonable standards. The CSS model is a good one, and it is good that Netscape has decided to support it. Whether Internet Explorer will someday support JSS is not known, but it is clear that Microsoft intends continued support for the CSS standard and the promised HTML 4.0 standard (they haven't had good results bucking web standards in the past).

But standards aren't the whole story. We can't imagine that the HTML author, let alone the page layout designer, is going to abide the rigid programming syntax of JavaScript, starting with the importance of letter case in property names. Very un-HTML. Nonetheless, there are some advantages to JSS that some authors will find useful, even though it restricts their document's full potential to the select Netscape 4 user.

We believe style sheets are an important innovation for HTML, and JSS is a very powerful way to provide them. Nonetheless, we recommend using CSS for reasons of consistency and ease--unless you specifically need some feature of JSS.

We thoroughly discuss the concepts and ideas behind HTML style sheets--specifically, Cascading Style Sheets--in Chapter 9, Cascading Style Sheets, so we won't repeat ourselves here. Rather, we address only how to create and manipulate styles with JavaScript. Before forging ahead in this section, we recommend that you first absorb the information in Chapter 9, Cascading Style Sheets.

JavaScript Style Sheet Syntax

Netscape 4 implements JSS by extending several existing HTML tags and defining a few new objects that store your document's styles.

External, document-level, and inline JSS

As with CSS, you may reference and load external JSS files with the <link> tag. For example:

<link href="styles.js" rel=stylesheet type=text/JavaScript>

The only real difference between this one and the one for a CSS external style sheet is that the type attribute of the <link> tag is set to text/JavaScript instead of text/CSS. The referenced file, styles.js, contains JavaScript statements that define styles and classes that Netscape will then use to control display of the current document.

You define document-level JSS within a <style> tag in the <head> of the document, just like CSS. Again, there is only one real difference in that you set the type attribute of the <style> tag to text/JavaScript instead of text/CSS.

The contents of the <style> tag for JSS are quite different from those for CSS, however. For example:

<style type=text/JavaScript>
    tags.BODY.marginLeft = "20px";
    tags.P.fontWeight = "bold";
  // -->

First, notice that we use the standard JavaScript and HTML comments to surround our JSS definitions, preventing non-compliant browsers from processing them as HTML content. Also notice that the syntax of the style definition is that of JavaScript, where letter case does make a difference, amongst other things.

You associate inline JavaScript-based style rules with a specific tag using the style attribute, just like CSS inline styles. The value of the attribute is a list of JSS assignments, separated by semicolons. For example,

<p style="color = 'green'; fontWeight = 'bold'">

creates a green, bold-faced text paragraph. Notice first that you need to enclose inline style values within single quotation marks, not double quotation marks as you might use for document-level and in external JSS styles. This is reasonable, since the style attribute value itself must be enclosed in double quotation marks.

Also note that inline JSS definitions use only the property name, not the containing tag object that owns the property. This makes sense, since inline JSS styles affect only the current tag, not all instances of the tag.

JSS values

In general, all of the values you may use for CSS may also be used in JSS definitions. For keyword, length, and percentage values, simply enclose the value in quotes and use it as you would any string value in JavaScript. Thus, the CSS value bold becomes "bold" or 'bold' for JSS document-level or inline styles, respectively; 12pt in CSS becomes '12pt' or "12pt" in JSS.

Specify color values as the color name or a hexadecimal color value, enclosed in single or double quotes. The CSS decimal rgb notation is not supported in JSS.

JSS URL values are strings containing the desired URL. Thus, the CSS URL value url(http://www.kumquat.com) becomes 'http://www.kumquat.com' for a JSS inline style; or "http://www.kumquat.com" at the document level.

One unique power of JSS is that any value can be computed dynamically when the document is processed by the browser. Instead of statically specifying the font size, for example, you can compute it on the fly:

tags.P.fontSize = favorite_font_size();

We assume that the JavaScript function favorite_font_size() somehow determines the desired font size and returns a string value containing that size. This, in turn, is assigned to the fontSize property for the <p> tag, defining the font size for all paragraphs in the document.

Defining styles for tags

JavaScript defines a new document property, tags, that contains the style properties for all HTML tags. To define a style for a tag, you simply set the appropriate property of the desired style property within the tag property of the document object. For example:

document.tags.P.fontSize = '12pt';
document.tags.H2.color = 'blue';

These two JSS definitions set the font size for the <p> tag to 12 points and render all <h2> tags in blue. The equivalent CSS definitions are:

P {font-size : 12pt}
H2 {color : blue}

Since the tags property always refers to the current document, you may omit document from any JSS tag style definition. We could have written the previous two styles as:

tags.P.fontSize = '12pt';
tags.H2.color = 'blue';

Moreover, as we mention above, you may omit the tag name, as well as the document and tags properties for inline JSS using the style attribute.

Capitalization and case are significant in JSS. The tag names within the tags property must always be fully capitalized. The embedded capital letters within the tag properties are significant: any deviation from the exact lettering produces an error, and Netscape won't honor your JSS declaration. All of the following JSS definitions are invalid, though the reason is not overly apparent:

tags.p.fontsize = '12pt';
tags.Body.Color = 'blue';
tags.P.COLOR = 'red';

The correct versions are:

tags.P.fontSize = '12pt';
tags.BODY.color = 'blue';
tags.P.color = 'red';

It can be very tedious to specify a number of properties for a single tag, so you can take advantage of the JavaScript with statement to reduce your typing burden. These styles:

tags.P.fontSize = '14pt';
tags.P.color = 'blue';
tags.P.fontWeight = 'bold';
tags.P.leftMargin = '20%';

can be more easily written as:

with (tags.P) {
  fontSize = '14pt';
  color = 'blue';
  fontWeight = 'bold';
  leftMargin = '20%';

You can apply similar styles to diverse tags just as easily:

with (tags.P, tags.LI, tags.H1) {
  fontSize = '14pt';
  color = 'blue';
  fontWeight = 'bold';
  leftMargin = '20%';

Defining style classes

Like CSS, JSS lets you target styles for specific ways in which a tag may be used in your document. JSS uses the classes property to define separate styles for the same tag. There are no predefined properties within the classes property; instead, any property you reference is defined as a class to be used by the current document. For example:

classes.bold.P.fontWeight = 'bold';
with (classes.abstract.P) {
   leftMargin = '20pt';
   rightMargin = '20pt';
   fontStyle = 'italic';
   textAlign = 'justify';

The first style defines a class of the <p> tag named bold whose font weight is set to bold. The next style uses the with statement to create a class of the <p> tag named abstract with the specified properties. The equivalent CSS rules would be:

P.bold {font-weight : bold}
P.abstract {left-margin : 20pt;
            right-margin : 20pt;
            font-style : italic;
            text-align : justify

Once defined, use a JSS class just like any CSS class: with the class attribute and the class name.

Like CSS, JSS also lets you define a class without defining the tag that will use the class. This lets you define generic classes that you can later apply to any tag. To create a generic style class in JSS, use the special tag property all:

classes.green.all.color = "green";

You can then add class="green" to any tag to have Netscape render its contents in green. The equivalent CSS is:

.green {color : green}

Using contextual styles

One of the most powerful aspects of CSS is its contextual style capability, wherein the browser applies a style to tags only if they appear in the document in a certain nesting. JSS supports contextual styles as well, through the special contextual() method within the tags property. The parameters to this method are the tags and classes that define the context in which Netscape will apply the style. For example,

tags.contextual(tags.UL, tags.UL, tags.LI).listStyleType = 'disc';

defines a context wherein the elements (tags.LI) of an unordered list nested within another unordered list (tags.UL, tags.UL) use the disc as their bullet symbol. The CSS equivalent is:

UL UL LI {list-style-type : disc}

You can mix tags and classes in the contextual() method. For instance:

tags.contextual(classes.abstract.P, tags.EM).color = 'red';

tells the browser to display in red <em> tags that appear within paragraphs that are of the abstract class. The CSS equivalent is:

P.abstract EM {color : red}

Since the tags object is unambiguously included within the contextual() method, you may omit them from the definition. Hence, our nested list example may be rewritten as:

tags.contextual(UL, UL, LI).listStyleType = 'disc';

JavaScript Style Sheet Properties

A subset of the CSS style properties are supported in JSS. The JSS style properties, their CSS equivalents, and the sections in which those properties are fully documented are shown in Table 13.2.

Table 13.2: JavaScript Style Sheet properties and their Cascading Style Sheet equivalents

JSS Property

CSS Property

See section





























































JSS also defines three methods that allow you to define margins, padding, and border widths within a single style property. The three methods, margins(), paddings(), and borderWidths(), accept four parameters, corresponding to the top, right, bottom, and left margin, padding or border width, respectively. Unlike their CSS counterparts (margin,, padding,, and border-width,, these JSS methods require that you always specify all four parameters. There is no shorthand way in JSS to set multiple margins, paddings, or border widths with a single value.

Previous Home Next
JavaScript Book Index Dynamic Documents

HTML: The Definitive Guide CGI Programming JavaScript: The Definitive Guide Programming Perl WebMaster in a Nutshell