HTML & DHTML
HTML & DHTML
40 Statements ......................................................................................................................... 54 Functions........................................................................................................................... 65 CHAPTER 1: Introduction to HTML ............................................................................... 71 CHAPTER 2 :HTML's Role on the Web.......................................................................... 81 CHAPTER 3: What You Need for a Web Site ................................................................. 84 CHAPTER 4: Creating a Web Page and Entering Text ................................................... 91 CHAPTER 5: Changing and Customizing HTML Text................................................... 99 CHAPTER 6: Displaying Text in Lists .......................................................................... 108 CHAPTER 7: Adding Graphics to Your Web Pages...................................................... 117 CHAPTER 8: Hypertext and Creating Links.................................................................. 130 CHAPTER 9: Clickable Image Maps and Graphical Interfaces..................................... 142 CHAPTER 10: HTML Forms......................................................................................... 153 CHAPTER 11: Adding Tables to Your Documents ....................................................... 165 CHAPTER 12: Images, Multimedia Objects, and Background Graphics ...................... 171 CHAPTER 13: Netscape Frames.................................................................................... 175
Introduction to DHTML Web authors today face significant challenges when making their Web pages interactive. The static nature of HTML pages limits their creative choices, and interactive components can be difficult to build and reuse. In addition, using proprietary extensions means authoring browserspecific Web pages. Microsoft Dynamic HTML technology helps to remove these barriers for content providers and offers users more engaging and interactive Web pages. Dynamic HTML provides authors with enhanced creative control so they can manipulate any page element at any time. Dynamic HTML is also the easiest way to make Web pages interactive, using open, standards-based technologies. Microsoft is working with the World Wide Web Consortium (W3C) to help ensure interoperability and support for users on multiple systems with different browsers. Dynamic HTML builds upon existing HTML standards to expand the possibilities of Web page design, presentation, and interaction. Ultimately, mastering DHTML will allow you to build Web-based applications, rather than mere portraits of data. Because DHTML is essentially an "added value" technology, you should be rather familiar with basic Web page design using traditional HTML specifications. Experience with JavaScript programming is also necessary to employ the potential of DHTML. Total Creative Control for an Immediate User Experience
Page 1 of 187
HTML &DHTML
Making simple updates, such as changing the color of text after a Web page loads, traditionally has meant reloading the page. These limitations have slowed the user experience and have impeded interactivity on the Web. Microsoft's Dynamic HTML takes interactivity to the next level. Pages authored with Dynamic HTML come alive, with every element in the page being truly dynamic. Whether the page has loaded already, content providers can change any element of the page -- text or graphics -without a round-trip to the server. This increased control and flexibility result in more compelling sites. For users, the Web experience becomes more responsive. Key features of DHTML Key features of Dynamic HTML include these:
Document Object Model (DOM). Dynamic HTML provides a comprehensive object model for HTML. This model exposes all page elements as objects. These objects can easily be manipulated, by changing their attributes or applying methods to them at any time. Dynamic HTML also provides full support for keyboard and mouse events on all page elements. Support for the Document Object Model enables the following: Dynamic content. Text or graphics can be added, deleted, or modified on the fly. For example, a Web page can display an updated headline, without refreshing the page. The text surrounding the headline will reflow automatically. Dynamic styles. Internet Explorer 4.0 fully supports Cascading Style Sheets (CSS). As such, any CSS attribute, including color and font, can be updated without a server roundtrip. For instance, text can change color or size when a mouse pointer passes over it. Multimedia filters and transition effects can be applied to HTML elements simply by adding the filter CSS attribute. Absolute positioning. CSS positioning coordinates for existing page content can be updated at any time to create animated effects, without reloading the page. Data Binding. Data-driven application front ends can be built that present, manipulate (e.g., sort, filter), and update data on the client without numerous round-trips to the server. Scriptlets. A scriptlet is a Web page, authored with Dynamic HTML, which content providers can use as a component in their Web applications. With scriptlets, content providers can author content once, then easily reuse the content in other Web pages or applications.
The Easiest Way to Make Pages Interactive Adding dynamic behavior to Web pages formerly required writing complex applets or controls, and incorporating them in Web pages using scripts. Although these components perform useful tasks, many authors found them hard to develop compared with scripts or HTML.
Page 2 of 187
HTML &DHTML
Microsoft Dynamic HTML was designed so that Web builders can use the scripting languages they know today -- such as JavaScript and the Microsoft Visual Basic programming system, Visual Basic Scripting Edition (VBScript) -- to make their Web pages interactive. Developers can also write full-featured Web applications with controls and applets that use Dynamic HTML. Web builders can easily reuse Dynamic HTML-based content through support for scriptlets in Microsoft Internet Explorer 4.0, using just HTML and script. Dynamic HTML can be authored today using tools from third parties, including Bluestone Inc., ExperTelligence Inc., Pictorius Inc., and SoftQuad Inc., as well as Microsoft FrontPage 98. Dynamic Content with a Broad Reach A standards-based approach enables content providers to create interactive pages that reach a broad audience. At a base level, content providers can take advantage of standards-based features, such as CSS and CSS Positioning, that are implemented in today's popular browsers. This ensures that a majority of users, regardless of the browser they are using, have the same Web experience. Web authors can also create a single set of pages authored with Dynamic HTML for all users. Users with any browser supporting the Document Object Model, such as Microsoft Internet Explorer 4.0, can fully interact with these pages. Other browser users, such as those running Netscape Navigator, could view much of this content statically, because Dynamic HTML uses standard HTML tags to render content. For instance, an interactive table of contents could expand and contract using Microsoft Internet Explorer 4.0. In a non-dynamic browser, the table would display in a fully expanded state. In some cases, content providers may decide to author separate sets of pages and take advantage of specific browser capabilities to ensure a truly engaging, rich experience. Dynamic HTML will be featured in all versions of Microsoft Internet Explorer 4.0, including versions for the Windows operating system and for the Macintosh and UNIX platforms. Microsoft's implementation of Dynamic HTML will also be available free of charge as a component for thirdparty use.
Page 3 of 187
Style
Properties of STYLE Clearly, positioning your block of content depends upon the specified STYLE properties. Several documents on Web contain references to the positioning properties available for style sheets -two worth reviewing are Microsoft's CSS Attributes Reference (under "Positioning Properties") and Netscape's Defining Positioned Blocks of HTML Content. We've included a handy chart summarizing the common STYLE properties which you may want to use when using the CSS syntax to position blocks of content. Employing the various STYLE properties gives you powerful control over the position and look of the blocks of content on your page. Conceptually, then, when we think in DHTML we think of a page as made up of one or more blocks. Of course, this is not immediately evident to the viewer, who essentially sees a flat Web page, without realizing that several smaller blocks of content are positioned here and there to create the overall effect. Still, the question begs: how is this dynamic? Consider the fact that, now that the blocks have been put into place, you can -- at any time -change their properties. Position, background, clipping region, z-index -- it's all plastic, with the help of JavaScript, and that is the reason to be excited!
width
height
left
Page 4 of 187
top
clip
visibility
z-index
Page 5 of 187
Page 6 of 187
Page 7 of 187
Page 8 of 187
position position width height none none none left left Note: Accepts either an integer (assumed pixel units) or a percentage string. Examples: left=10 or left="20%" Note: read-only, cannot modify via script pixelWidth pixelHeight left or pixelLeft Note: pixelLeft accepts a string which specifies measurement units; e.g. pixelLeft="10px" whereas left accepts an integer and assumes pixel units; e.g. left=10.
Page 9 of 187
clip
Example: Each dimension of the clipping document.all.blockname.style.clip coordinates is its own property, as seen here. Changing any property immediately ="rect(0 25 25 0)" causes the on-screen clip to change. visibility visibility May contain any of "inherit", "show", or "hide" zIndex z-index Any non-negative integer. bgColor Accepts string containing pre-defined color name or hex RGB triplet. backgrou nd-color Examples: document.layers["blockname"].bgColor ="black" document.layers["blockname"].bgColor ="#000000" background.src MSIE allows negative integers, but you may as well stick with positive for the sake of Netscape. backgroundColor Accepts string containing pre-defined color name or hex RGB triplet. Examples: document.all.blockname.style.backgrou ndColor ="black" document.all.blockname.style.backgrou ndColor ="#000000" backgroundImage visibility May contain any of "inherit", "visible", or "hidden" zIndex
backgrou Example: Example: nd-image document.layers["blockname"].backgroun document.all.blockname.backgroundIm age ="images/tile.jpg" d.src ="images/tile.jpg"
Putting the D in DHTML Once you've positioned a content block on the page using <DIV> tags in your HTML, you can use JavaScript to modify its properties. This has many possible consequences: you can move the
Page 10 of 187
Page 11 of 187
Page 12 of 187
Page 13 of 187
position position width height none none none left left Note: Accepts either an integer (assumed pixel units) or a percentage string. Examples: left=10 or left="20%" Note: read-only, cannot modify via script pixelWidth pixelHeight left or pixelLeft Note: pixelLeft accepts a string which specifies measurement units; e.g. pixelLeft="10px" whereas left accepts an integer and assumes pixel units; e.g. left=10.
Page 14 of 187
clip
Example: Each dimension of the clipping document.all.blockname.style.clip coordinates is its own property, as seen here. Changing any property immediately ="rect(0 25 25 0)" causes the on-screen clip to change. visibility visibility May contain any of "inherit", "show", or "hide" zIndex z-index Any non-negative integer. bgColor Accepts string containing pre-defined color name or hex RGB triplet. backgrou nd-color Examples: document.layers["blockname"].bgColor ="black" document.layers["blockname"].bgColor ="#000000" background.src MSIE allows negative integers, but you may as well stick with positive for the sake of Netscape. backgroundColor Accepts string containing pre-defined color name or hex RGB triplet. Examples: document.all.blockname.style.backgrou ndColor ="black" document.all.blockname.style.backgrou ndColor ="#000000" backgroundImage visibility May contain any of "inherit", "visible", or "hidden" zIndex
backgrou Example: Example: nd-image document.layers["blockname"].backgroun document.all.blockname.backgroundIm age ="images/tile.jpg" d.src ="images/tile.jpg"
Page 15 of 187
The Event Connection Quite frequently, you want some type of trigger to cause your DHTML to kick in. Whether repositioning blocks or changing style properties, some event usually causes these changes. Many different types of event can occur on a Web page, most of them caused by the user. He or she might click on a button (click event), might move the mouse over an element (mouseover event), or move the mouse off of an element (mouseout event). The user may submit a form (submit event) or resize the browser window (resize event). Additionally, some events occur without direct user intervention -- the page may finish loading (load event), for example. Talking about events in this article is tricky because, like our previous discussions, working with events crosses a couple of authoring technologies. The Document Object Model also defines types of events and their characteristics, such as to which elements they apply. More exactly, though, you manipulate and control events using JavaScript syntax. Once again, then, the handling of events is not exactly the same between Microsoft and Netscape browsers, at least until a standardized DOM comes along. Managing events can be relatively simple or quite complex, depending on the ambitions of your project. Since this is an introduction, we'll focus mainly on event basics. Fortunately, basic events are handled most similarly between browsers. Event Handlers Events occur on a Web page whether you choose to act on them or not. When the user moves the mouse over an element, a mouseover event occurs. If you would like to leverage this event as a trigger for some dynamic action, you must construct an event handler. An event handler is created as an attribute for the tag which defines the element at which you wish to catch the event. Event handler attribute named follow the syntax onEventname, and they accept JavaScript statements as their action. For example, the following tag creates a hyperlink with a mouseover event handler specified. <A HREF="page.html" onMouseOver="changeStatus('Read this page'); return true"> Click here </A> The onMouseOver event handler catches a mouseover event. When this event occurs at this element, a JavaScript function is called named changeStatus(). This is a fictional function, you can imagine that it might exist to change the message on the browser's status bar. Any JavaScript statement is allowed in an event handler, so we could also execute direct statement rather than call a function. For example, suppose that a mouseover for this element in MSIE should modify a style sheet's color property: <A HREF="page.html" onMouseOver="document.styleSheets[0].rules[0].style.color='blue'" > Click here</A>
Page 16 of 187
abort OnAbort User stops an image loading using the stop button. The above table is a quick reference guide. There are some important caveats to keep in mind. For one, this is not a comprehensive list of all events, although these are by far the most commonly used. Both browser support additional events for detecting keypresses and other mouse actions, while MSIE supports additional events above and beyond Netscape's. Secondly, you must keep in mind that not every event is applicable to every element. This also varies between browsers. For example, within Netscape a mouseover event only applies to a hyperlink <A>, area <AREA> or layer <LAYER>. Yet, within MSIE, you can apply a mouseover event to almost any element, including images <IMG>, and paragraphs <P>. In general, the above rule holds between browsers: Netscape restricts each event to certain limited elements, while MSIE allows most events to be handled at most elements. Mastering event handling is most certainly a topic unto itself. At the surface, handling basic events is simple, as you've seen. The classic "rollover effect" is a perfect example of a simple event used in DHTML. A rollover occurs when the user moves the mouse over an element; while the mouse hovers over the element, its appearance changes to reflect that it is "active". When the mouse moves off the element is reverts to a more subdued state. Rollovers commonly use
Page 17 of 187
Page 18 of 187
Layering
Dynamic Layering Techniques The ability to create layers in HTML allows developers to place elements on top of each other to create intriguing effects with text and graphics. However, some confusion may arise from the term "layer." While it is true that there is an actual HTML element from Netscape, the <LAYER> tag, there are several ways to create layers for both Internet Explorer and Netscape Navigator. In this article we will learn the difference between IE and NN layers as well as how to develop a layers-enhanced site for both browsers. Since both IE and Netscape view layers differently, it's important that you recognize these differences so that you can work around them. You cannot design an effective and useful site without an understanding of the technical limitations of the user's applications or the limitations of the technology. First, let's look at what layers are, and see how they can help improve your Web site. Layering Documents Most graphic designers are familiar with layering; they are an integral part of the apps used by most designers, including Photoshop, Illustrator, Freehand, Fireworks and ImageReady. Layers allow the designer to create complex graphics that integrate images or illustrations, and text. For instance, a designer may begin with a photo of a house, then add some trees or shrubs in front on a top layer, and maybe some text that goes over the house and trees on another. It is through the use of layering -- determining an item's order in a stack of other items -- that makes this technique work. Now Web developers can enjoy a similar presentation control in their HTML documents. The basic technology for layering comes to us from the W3C via Cascading Style Sheets. A single property that, when assigned to an element, determines an element's stacking order; its layered position. The property is called z-index -- it gives us the ability to define the thirddimension on the Web page. Listing 16.1 shows the syntax for the z-index property as it would be assigned in a style sheet and inline. Listing 16. 1: The z-index property <STYLE TYPE="text/css"> .layer1 { z-index:1; visibility: visible; } .layer2 { z-index:2; visibility: hidden; } </STYLE> ... <BODY> <IMG CLASS="layer1" SRC="myimage.gif"> <P STYLE="z-index:3; ">Here is some text...</P> <IMG CLASS="layer2" SRC="myimage.gif"> </BODY> Rather than go into CSS-positioning, we will assume the images are the same height and width, and that they occupy the same space on the document. The layering of these elements is determined according to their z-index properties. In the example in Listing 16.1, the first image
Page 19 of 187
Page 20 of 187
Page 21 of 187
Page 22 of 187
Page 23 of 187
Page 24 of 187
Transition Filters
IE4 offers a type of filter called the Transitional Filter. This filter works in much the same way as the Visual Filter; however, this filter is used to transition an object from its current state to a future state (i.e., when changing the source of an image from one image to another). There are two types of Transitional Filters: Blend and Reveal. Transition Methods The Transitional Filters use methods to work. There are three of these methods: 1. The transition must be applied by using either blendTrans.Apply() or revealTrans.Apply(). 2. The transition must then be played by using either blendTrans.Play() or revealTrans.Play(). 3. If you want to stop the filter transition, you may use either blendTrans.Stop() or revealTrans.Stop(). Note: These methods may also be used in conditional statements. For instance, to check if the transition has completed you may go if(blendTrans.Stop()) Blend Transition Filter The Blend Transition Filter is used to perform a fade in or fade out effect. Syntax: filter:BlendTrans(Duration=duration)}
Duration: Length of time the transition should take to complete. Value, float. Value is expressed in seconds.milliseconds (0.000).
Reveal Transition Filter The Reveal Transition Filter allows you to show or hide visual objects, using any of the 23 predefined types of patterns. Syntax: filter:RevealTrans(Duration=seconds, Transition=0-23)
Duration: Number of seconds the transition should take to complete. Transition: Type of pre-defined pattern: 0 - Box in 1 - Box out 2 - Circle in 3 - Circle out 4 - Wipe up
Page 25 of 187
5 - Wipe down 6 - Wipe right 7 - Wipe left 8 - Vertical blinds 9 - Horizontal blinds 10 - Checkerboard across 11 - Checkerboard down 12 - Random dissolve 13 - Split vertical in 14 - Split vertical out 15 - Split horizontal in 16 - Split horizontal out 17 - Strips left down 18 - Strips left up 19 - Strips right down 20 - Strips right up 21 - Random bars horizontal 22 - Random bars vertical 23 - Any random pattern 0-22
Source:
Page 26 of 187
Page 27 of 187
Page 28 of 187
Page 29 of 187
Introduction to JavaScript
JavaScript is Netscape's cross-platform, object-oriented scripting language. JavaScript is a small, lightweight language; it is not useful as a standalone language, but is designed for easy embedding in other products and applications, such as web browsers. Inside a host environment, JavaScript can be connected to the objects of its environment to provide programmatic control over them. Core JavaScript contains a core set of objects, such as Array, Date, and Math, and a core set of language elements such as operators, control structures, and statements. Core JavaScript can be extended for a variety of purposes by supplementing it with additional objects; for example:
Client-side JavaScript extends the core language by supplying objects to control a browser (Navigator or another web browser) and its Document Object Model (DOM). For example, client-side extensions allow an application to place elements on an HTML form and respond to user events such as mouse clicks, form input, and page navigation.
Server-side JavaScript extends the core language by supplying objects relevant to running JavaScript on a server. For example, server-side extensions allow an application to communicate with a relational database, provide continuity of information from one invocation to another of the application, or perform file manipulations on a server. Through JavaScript's LiveConnect functionality, you can let Java and JavaScript code communicate with each other. From JavaScript, you can instantiate Java objects and access their public methods and fields. From Java, you can access JavaScript objects, properties, and methods. Netscape invented JavaScript, and JavaScript was first used in Netscape browsers. JavaScript and Java
JavaScript and Java are similar in some ways but fundamentally different in others. The JavaScript language resembles Java but does not have Java's static typing and strong type checking. JavaScript supports most Java expression syntax and basic control-flow constructs. In contrast to Java's compile-time system of classes built by declarations, JavaScript supports a runtime system based on a small number of data types representing numeric, Boolean, and string values. JavaScript has a prototype-based object model instead of the more common class-based object model. The prototype-based model provides dynamic inheritance; that is, what is inherited can vary for individual objects. JavaScript also supports functions without any special declarative requirements. Functions can be properties of objects, executing as loosely typed methods. JavaScript is a very free-form language compared to Java. You do not have to declare all variables, classes, and methods. You do not have to be concerned with whether methods are public, private, or protected, and you do not have to implement interfaces. Variables, parameters, and function return types are not explicitly typed. Java is a class-based programming language designed for fast execution and type safety. Type safety means, for instance, that you can't cast a Java integer into an object reference L&T Infotech Confidential Page 30 of 187
HTML &DHTML Introduction to Javascript or access private memory by corrupting Java bytecodes. Java's class-based model means that programs consist exclusively of classes and their methods. Java's class inheritance and strong typing generally require tightly coupled object hierarchies. These requirements make Java programming more complex than JavaScript authoring. In contrast, JavaScript descends in spirit from a line of smaller, dynamically typed languages such as HyperTalk and dBASE. These scripting languages offer programming tools to a much wider audience because of their easier syntax, specialized built-in functionality, and minimal requirements for object creation.
JavaScript Interpreted (not compiled) by client. Object-oriented. No distinction between types of objects. Inheritance is through the prototype mechanism, and properties and methods can be added to any object dynamically. Java Compiled bytecodes downloaded from server, executed on client. Class-based. Objects are divided into classes and instances with all inheritance through the class hierarchy. Classes and instances cannot have properties or methods added dynamically.
Variable data types not declared (dynamic Variable data types must be declared (static typing). typing). Cannot automatically write to hard disk. Cannot automatically write to hard disk.
Table 18.1 JavaScript compared to Java Values JavaScript recognizes the following types of values:
Numbers, such as 42 or 3.14159. Logical (Boolean) values, either true or false. Strings, such as "Howdy!". null, a special keyword denoting a null value; null is also a primitive value. Because JavaScript is case sensitive, null is not the same as Null, NULL, or any other variant. undefined, a top-level property whose value is undefined; undefined is also a primitive value.
This relatively small set of types of values, or data types, enables you to perform useful functions with your applications. There is no explicit distinction between integer and real-valued numbers. Nor is there an explicit date data type in JavaScript. However, you can use the Date object and its methods to handle dates. Objects and functions are the other fundamental elements in the language. You can think of objects as named containers for values, and functions as procedures that your application can perform. Data Type Conversion
Page 31 of 187
By simply assigning it a value. For example, x = 42 With the keyword var. For example, var x = 42
Evaluating Variables A variable or array element that has not been assigned a value has the value undefined. The result of evaluating an unassigned variable depends on how it was declared:
If the unassigned variable was declared without var, the evaluation results in a runtime error. If the unassigned variable was declared with var, the evaluation results in the undefined value, or NaN in numeric contexts.
The following code demonstrates evaluating unassigned variables. function f1() { return y - 2;
Page 32 of 187
Array Literals Boolean Literals Floating-Point Literals Integers Object Literals String Literals
Page 33 of 187
Extra Commas in Array Literals You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with spaces for the unspecified elements. The following example creates the fish array: fish = ["Lion", , "Angel"] This array has two elements with values and one empty element (fish[0] is "Lion", fish[1] is undefined, and fish[2] is "Angel"): If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no myList[3]. All other commas in the list indicate a new element. myList = ['home', , 'school', ]; In the following example, the length of the array is four, and myList[0] is missing. myList = [ , 'home', , 'school']; In the following example, the length of the array is four, and myList[3] is missing. Only the last comma is ignored. This trailing comma is optional. myList = ['home', , 'school', , ]; Boolean Literals The Boolean type has two literal values: true and false. Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. Floating-Point Literals
Page 34 of 187
A decimal integer A decimal point (".") A fraction (another decimal number) An exponent
The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E"). Some examples of floating-point literals are 3.1415, -3.1E12, .1e12, and 2E-12 Integers Integers can be expressed in decimal (base 10), hexadecimal (base 16), and octal (base 8). A decimal integer literal consists of a sequence of digits without a leading 0 (zero). A leading 0 (zero) on an integer literal indicates it is in octal; a leading 0x (or 0X) indicates hexadecimal. Hexadecimal integers can include digits (0-9) and the letters a-f and A-F. Octal integers can include only the digits 0-7. Some examples of integer literals are: 42, 0xFFF, and -345. Object Literals An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error. The following is an example of an object literal. The first element of the car object defines a property, myCar; the second element, the getCar property, invokes a function (Cars("honda")); the third element, the special property, uses an existing variable (Sales). var Sales = "Toyota"; function CarTypes(name) { if(name == "Honda") return name; else return "Sorry, we don't sell " + name + "."; } car = {myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales} document.write(car.myCar); // Saturn document.write(car.getCar); // Honda document.write(car.special); // Toyota Additionally, you can use an index for the object, the index property (for example, 7), or nest an object inside another. The following example uses these options. These features, however, may not be supported by other ECMA-compliant browsers. car = {manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda"} document.write(car.manyCars.b); // Jeep document.write(car[7]); // Mazda String Literals
Page 35 of 187
You can call any of the methods of the String object on a string literal value--JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal. You should use string literals unless you specifically need to use a String object. Using Special Characters in Strings In addition to ordinary characters, you can also include special characters in strings, as shown in the following example. "one line \n another line" The following table lists the special characters that you can use in JavaScript strings. Character Meaning \b \f \n \r \t \' \" \\ \XXX Backspace Form feed New line Carriage return Tab Apostrophe or single quote Double quote Backslash character (\) The character with the Latin-1 encoding specified by up to three octal digits XXX between 0 and 377. For example, \251 is the octal sequence for the copyright symbol. The character with the Latin-1 encoding specified by the two hexadecimal digits XX between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol. The Unicode character specified by the four hexadecimal digits XXXX. For example, \u00A9 is the Unicode sequence for the copyright symbol. Table 18.2 JavaScript special characters
\xXX
\uXXXX
Page 36 of 187
For characters not listed in Table 18.2, a preceding backslash is ignored, with the exception of a quotation mark and the backslash character itself.
You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example, var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service." document.write(quote) The result of this would be He read "The Cremation of Sam McGee" by R.W. Service. To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following: var home = "c:\\temp"
Unicode Unicode is a universal character-coding standard for the interchange and display of principal written languages. It covers the languages of Americas, Europe, Middle East, Africa, India, Asia, and Pacifica, as well as historic scripts and technical symbols. Unicode allows for the exchange, processing, and display of multilingual texts, as well as the use of common technical and mathematical symbols. It hopes to resolve internationalization problems of multilingual computing, such as different national character standards. Not all modern or archaic scripts, however, are currently supported. The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.
JavaScript versions prior to 1.3. Unicode is not supported in versions of JavaScript prior to 1.3. Unicode Compatibility with ASCII and ISO
Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses 7-bit character set, Unicode uses a 16-bit value for each character. It allows for tens of thousands of characters. Unicode version 2.0 contains 38,885 characters. It also supports an extension mechanism, Transformation Format (UTF), named UTF-16, that allows for L&T Infotech Confidential Page 37 of 187
HTML &DHTML Introduction to Javascript the encoding of one million more characters by using 16-bit character pairs. UTF turns the encoding to actual bits. Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646, and supports the ISO UCS-2 (Universal Character Set) that uses two-octets (two bytes or 16 bits). JavaScript and Navigator support for Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments and string literals of JavaScript.
Unicode Escape Sequences You can use the Unicode escape sequence in string literals. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.
The following code returns the copyright symbol and the string "Netscape Communications".
x="\u00A9 Netscape Communications" The following table lists frequently used special characters and their Unicode value. Category White space values Unicode value Name \u0009 \u000B \u000C \u0020 Line terminator values \u000A \u000D Additional Unicode escape sequence values \u000b \u0009 \u0022 \u0027 \u005C Tab Vertical Tab Form Feed Space Line Feed Format name <TAB> <VT> <FF> <SP> <LF>
Carriage Return <CR> Backspace Horizontal Tab Double Quote Single Quote Backslash <BS> <HT> " ' \
Page 38 of 187
HTML &DHTML Introduction to Javascript The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (\u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.
Displaying Characters with Unicode
You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Netscape Navigator 4.x needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide a partial support for Unicode.
To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Often, the only way to input Unicode characters is by using Unicode escape sequences. The Unicode specification, however, does not require the use of escape sequences. Unicode delineates a method for rendering special Unicode characters using a composite character. It specifies the order of characters that can be used to create a composite character, where the base character comes first, followed by one or more non-spacing marks. Common implementations of Unicode, including the JavaScript implementation, however, do not support this option. JavaScript does not attempt the representation of the Unicode combining sequences. In other words, an input of a and ' does not produce . JavaScript interprets a' as two distinct 16-bit Unicode characters. You must use a Unicode escape sequence or a literal Unicode character for .
Page 39 of 187
Expressions Operators
Expressions An expression is any valid set of literals, variables, operators, and expressions that evaluates to a single value; the value can be a number, a string, or a logical value. Conceptually, there are two types of expressions: those that assign a value to a variable, and those that simply have a value. For example, the expression x = 7 is an expression that assigns x the value seven. This expression itself evaluates to seven. Such expressions use assignment operators. On the other hand, the expression 3 + 4 simply evaluates to seven; it does not perform an assignment. The operators used in such expressions are referred to simply as operators. JavaScript has the following types of expressions:
Arithmetic: evaluates to a number, for example 3.14159 String: evaluates to a character string, for example, "Fred" or "234" Logical: evaluates to true or false
Operators JavaScript has the following types of operators. This section describes the operators and contains information about operator precedence.
Assignment Operators Comparison Operators Arithmetic Operators Bitwise Operators Logical Operators String Operators Special Operators
JavaScript has both binary and unary operators. A binary operator requires two operands, one before the operator and one after the operator: operand1 operator operand2 For example, 3+4 or x*y. A unary operator requires a single operand, either before or after the operator: operator operand or operand operator For example, x++ or ++x.
Page 40 of 187
Comparison Operators A comparison operator compares its operands and returns a logical value based on whether the comparison is true. The operands can be numerical or string values. Strings are compared based on standard lexicographical ordering, using Unicode values. The following table describes the comparison operators. Operator Description Examples returning true1 == var1
Equal (==)
Returns true if the operands are equal If the two operands are 3
Page 41 of 187
Returns true if the operands are not equal. If the two operands var1 != are not of the same type, JavaScript attempts to convert the var2 != "3" operands to an appropriate type for the comparison. 3 === var1
Strict (===)
equal Returns true if the operands are equal and of the same type.
Strict not Returns true if the operands are not equal and/or not of the var1 !== "3" equal (!==) same type. 3 !== '3' Greater (>) than Returns true if the left operand is greater than the right var2 > var1 operand.
Greater than Returns true if the left operand is greater than or equal to the var2 >= var1 or equal (>=) right operand. var1 >= 3 Less than (<) Returns true if the left operand is less than the right operand. var1 < var2
Less than or Returns true if the left operand is less than or equal to the var1 <= var2 equal (<=) right operand. var2 <= 5 These examples assume that var1 has been assigned the value 3 and var2 has been assigned the value 4. Table 19.2 Comparison operators Arithmetic Operators Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/). These operators work as they do in most other programming languages, except the / operator returns a floating-point division in JavaScript, not a truncated division as it does in languages such as C or Java. For example: 1/2 //returns 0.5 in JavaScript 1/2 //returns 0 in Java In addition, JavaScript provides the arithmetic operators listed in the following table. Operator % (Modulus) ++ (Increment) Description Example
1
Binary operator. Returns the integer remainder of 12 % 5 returns 2. dividing the two operands. Unary operator. Adds one to its operand. If used as a prefix operator (++x), returns the value of its operand after adding one; if used as a postfix operator (x++), returns the value of its operand before adding one. If x is 3, then ++x sets x to 4 and returns 4, whereas x++ sets x to 4 and returns 3.
--
Unary operator Subtracts one to its operand The If x is 3 then --x sets x
Page 42 of 187
(Unary negation)
Table 19.3 Arithmetic Operators Bitwise Operators Bitwise operators treat their operands as a set of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the decimal number nine has a binary representation of 1001. Bitwise operators perform their operations on such binary representations, but they return standard JavaScript numerical values. The following table summarizes JavaScript's bitwise operators. Operator Bitwise AND Bitwise OR Usage a&b a|b Description Returns a one in each bit position for which the corresponding bits of both operands are ones. Returns a one in each bit position for which the corresponding bits of either or both operands are ones. Returns a one in each bit position for which the corresponding bits of either but not both operands are ones. Inverts the bits of its operand. Shifts a in binary representation b bits to left, shifting in zeros from the right. Shifts a in binary representation b bits to right, discarding bits shifted off.
Bitwise XOR
a^b
Bitwise NOT Left shift Sign-propagating right shift Zero-fill right shift
~a a << b a >> b
a >>> Shifts a in binary representation b bits to the right, discarding bits shifted off, and shifting in b zeros from the left. Table19.4 Bitwise operators
Bitwise Logical Operators Conceptually, the bitwise logical operators work as follows:
The operands are converted to thirty-two-bit integers and expressed by a series of bits (zeros and ones).
Page 43 of 187
Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on. The operator is applied to each pair of bits, and the result is constructed bitwise.
For example, the binary representation of nine is 1001, and the binary representation of fifteen is 1111. So, when the bitwise operators are applied to these values, the results are as follows:
15 & 9 yields 9 (1111 & 1001 = 1001) 15 | 9 yields 15 (1111 | 1001 = 1111) 15 ^ 9 yields 6 (1111 ^ 1001 = 0110)
Bitwise Shift Operators The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used. Shift operators convert their operands to thirty-two-bit integers and return a result of the same type as the left operator. The shift operators are listed in the following table. Operator << (Left shift) Description This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right. This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. Example 9<<2 yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36. 9>>2 yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, 9>>2 yields -3, because the sign is preserved. 19>>>2 yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For nonnegative numbers, zero-fill right shift and sign-propagating right shift yield the same result.
This operator shifts the first operand the specified right number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left.
Page 44 of 187
||
Table 19.6 Logical operators Examples of expressions that can be converted to false are those that evaluate to null, 0, the empty string (""), or undefined. The following code shows examples of the && (logical AND) operator. a1=true && true // t && t returns true a2=true && false // t && f returns false a3=false && true // f && t returns false a4=false && (3 == 4) // f && f returns false a5="Cat" && "Dog" // t && t returns Dog a6=false && "Cat" // f && t returns false a7="Cat" && false // t && f returns false
Page 45 of 187
false && anything is short-circuit evaluated to false. true || anything is short-circuit evaluated to true.
The rules of logic guarantee that these evaluations are always correct. Note that the anything part of the above expressions is not evaluated, so any side effects of doing so do not take effect. String Operators In addition to the comparison operators, which can be used on string values, the concatenation operator (+) concatenates two string values together, returning another string that is the union of the two operand strings. For example, "my " + "string" returns the string "my string". The shorthand assignment operator += can also be used to concatenate strings. For example, if the variable mystring has the value "alpha," then the expression mystring += "bet" evaluates to "alphabet" and assigns this value to mystring. Special Operators JavaScript provides the following special operators:
conditional operator comma operator delete in instanceof new this typeof void
Page 46 of 187
conditional operator The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is: condition ? val1 : val2 If condition is true, the operator has the value of val1. Otherwise it has the value of val2. You can use the conditional operator anywhere you would use a standard operator. For example, status = (age >= 18) ? "adult" : "minor" This statement assigns the value "adult" to the variable status if age is eighteen or more. Otherwise, it assigns the value "minor" to status. comma operator The comma operator (,) simply evaluates both of its operands and returns the value of the second operand. This operator is primarily used inside a for loop, to allow multiple variables to be updated each time through the loop. For example, if a is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to increment two variables at once. The code prints the values of the diagonal elements in the array: for (var i=0, j=9; i <= 9; i++, j--) document.writeln("a["+i+","+j+"]= " + a[i,j]) delete The delete operator deletes an object, an object's property, or an element at a specified index in an array. Its syntax is: delete objectName delete objectName.property delete objectName[index] delete property // legal only within a with statement where objectName is the name of an object, property is an existing property, and index is an integer representing the location of an element in an array. The fourth form is legal only within a with statement, to delete a property from an object. You can use the delete operator to delete variables declared implicitly but not those declared with the var statement. If the delete operator succeeds, it sets the property or element to undefined. The delete operator returns true if the operation is possible; it returns false if the operation is not possible. x=42 var y= 43 myobj=new Number() myobj.h=4 // create property h delete x // returns true (can delete if declared implicitly) delete y // returns false (cannot delete if declared with var) delete Math.PI // returns false (cannot delete predefined properties)
Page 47 of 187
Page 48 of 187
Page 49 of 187
Page 50 of 187
Page 51 of 187
Page 52 of 187
addition/subtraction + multiply/divide negation/increment call create instance member */% ! ~ - + ++ -- typeof void delete () new . [] Table 19.7 Operator precedence
Page 53 of 187
Statements
JavaScript supports a compact set of statements that you can use to incorporate a great deal of interactivity in Web pages. This chapter provides an overview of these statements. This chapter contains the following sections, which provide a brief overview of each statement:
Conditional Statements: if...else and switch Loop Statements: for, while, do while, label, break, and continue (label is not itself a looping statement, but is frequently used with these statements) Object Manipulation Statements: for...in and with Comments Exception Handling Statements: try...catch and throw
Any expression is also a statement. Use the semicolon (;) character to separate statements in JavaScript code. Conditional Statements A conditional statement is a set of commands that executes if a specified condition is true. JavaScript supports two conditional statements: if...else and switch. if...else Statement Use the if statement to perform certain statements if a logical condition is true; use the optional else clause to perform other statements if the condition is false. An if statement looks as follows: if (condition) { statements1 } [else { statements2 }] The condition can be any JavaScript expression that evaluates to true or false. The statements to be executed can be any JavaScript statements, including further nested if statements. If you want to use more than one statement after an if or else statement, you must enclose the statements in curly braces, {}. Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. Any object whose value is not undefined or null, including a Boolean object whose value is false, evaluates to true when passed to a conditional statement. For example: var b = new Boolean(false); if (b) // this condition evaluates to true Example. In the following example, the function checkData returns true if the number of characters in a Text object is three; otherwise, it displays an alert and returns false. function checkData () { if (document.form1.threeChar.value.length == 3) { return true } else { alert("Enter exactly three characters. " + document.form1.threeChar.value + " is not valid.")
Page 54 of 187
Page 55 of 187
Page 56 of 187
Page 57 of 187
After the first pass: n = 1 and x = 1 After the second pass: n = 2 and x = 3 After the third pass: n = 3 and x = 6
After completing the third pass, the condition n < 3 is no longer true, so the loop terminates. Example 2: infinite loop. Make sure the condition in a loop eventually becomes false; otherwise, the loop will never terminate. The statements in the following while loop execute forever because the condition never becomes false: 7 while (true) { alert("Hello, world") } label Statement A label provides a statement with an identifier that lets you refer to it elsewhere in your program. For example, you can use a label to identify a loop, and then use the break or continue statements to indicate whether a program should interrupt the loop or continue its execution. The syntax of the label statement looks like the following: label : statement The value of label may be any JavaScript identifier that is not a reserved word. The statement that you identify with a label may be any type. Example. In this example, the label markLoop identifies a while loop. markLoop: while (theMark == true) doSomething(); } break Statement Use the break statement to terminate a loop, switch, or label statement.
When you use break with a while, do-while, for, or switch statement, break terminates the innermost enclosing loop or switch immediately and transfers control to the following statement. When you use break within an enclosing label statement, it terminates the statement and transfers control to the following statement. If you specify a label when you issue the break, the break statement terminates the specified statement.
The syntax of the break statement looks like the following: 1. break 2. break [label] The first form of the syntax terminates the innermost enclosing loop, switch, or label; the second form of the syntax terminates the specified enclosing label statement. Example. The following example iterates through the elements in an array until it finds the index of an element whose value is theValue:
Page 58 of 187
In a while or for statement, continue terminates the current loop and continues execution of the loop with the next iteration. In contrast to the break statement, continue does not terminate the execution of the loop entirely. In a while loop, it jumps back to the condition. In a for loop, it jumps to the increment-expression. In a label statement, continue is followed by a label that identifies a label statement. This type of continue restarts a label statement or continues execution of a labelled loop with the next iteration. continue must be in a looping statement identified by the label used by continue.
The syntax of the continue statement looks like the following: 1. continue 2. continue [label] Example 1. The following example shows a while loop with a continue statement that executes when the value of i is three. Thus, n takes on the values one, three, seven, and twelve. i=0 n=0 while (i < 5) { i++ if (i == 3) continue n += i } Example 2. A statement labeled checkiandj contains a statement labeled checkj. If continue is encountered, the program terminates the current iteration of checkj and begins the next iteration. Each time continue is encountered, checkj reiterates until its condition returns false. When false is returned, the remainder of the checkiandj statement is completed, and checkiandj reiterates until its condition returns false. When false is returned, the program continues at the statement following checkiandj. If continue had a label of checkiandj, the program would continue at the top of the checkiandj statement. checkiandj : while (i<4) { document.write(i + "<BR>"); i+=1; checkj : while (j>4) { document.write(j + "<BR>"); j-=1; if ((j%2)==0);
Page 59 of 187
Page 60 of 187
Comments on a single line are preceded by a double-slash (//). Comments that span multiple lines are preceded by /* and followed by */:
Example. The following example shows two comments: // This is a single-line comment. /* This is a multiple-line comment. It can be of any length, and you can put whatever you want here. */
Page 61 of 187
Page 62 of 187
Page 63 of 187
Page 64 of 187
Functions
Functions are one of the fundamental building blocks in JavaScript. A function is a JavaScript procedure--a set of statements that performs a specific task. To use a function, you must first define it; then your script can call it. This chapter contains the following sections:
Defining Functions Calling Functions Using the arguments Array Predefined Functions
The name of the function. A list of arguments to the function, enclosed in parentheses and separated by commas. The JavaScript statements that define the function, enclosed in curly braces, { }. The statements in a function can include calls to other functions defined in the current application.
For example, the following code defines a simple function named square: function square(number) { return number * number; } The function square takes one argument, called number. The function consists of one statement that indicates to return the argument of the function multiplied by itself. The return statement specifies the value returned by the function. return number * number All parameters are passed to functions by value; the value is passed to the function, but if the function changes the value of the parameter, this change is not reflected globally or in the calling function. However, if you pass an object as a parameter to a function and the function changes the object's properties, that change is visible outside the function, as shown in the following example: function myFunc(theObject) { theObject.make="Toyota" } mycar = {make:"Honda", model:"Accord", year:1998} x=mycar.make // returns Honda myFunc(mycar) // pass object mycar to the function y=mycar.make // returns Toyota (prop was changed by the function) Calling Functions Defining a function does not execute it. Defining the function simply names the function and specifies what to do when the function is called. Calling the function actually performs the
Page 65 of 187
Page 66 of 187
eval isFinite isNaN parseInt and parseFloat Number and String escape and unescape
The following sections introduce these functions. eval Function The eval function evaluates a string of JavaScript code without reference to a particular object. The syntax of eval is: eval(expr) where expr is a string to be evaluated. If the string represents an expression, eval evaluates the expression. If the argument represents one or more JavaScript statements, eval performs the statements. Do not call eval to evaluate an arithmetic expression; JavaScript evaluates arithmetic expressions automatically. parseInt parses its first argument, the string str, and attempts to return an integer of the specified radix (base), indicated by the second, optional argument, radix. For example, a radix of ten indicates to convert to a decimal number, eight octal, sixteen hexadecimal, and so on. For radixes above ten, the letters of the alphabet indicate numerals greater than nine. For example, for hexadecimal numbers (base 16), A through F are used. If parseInt encounters a character that is not a numeral in the specified radix, it ignores it and all succeeding characters and returns the integer value parsed up to that point. If the first character
Page 67 of 187
Page 68 of 187
Page 69 of 187
Page 70 of 187
HTML
CHAPTER 1: Introduction to HTML
HTML is not a Programming Language Creating an HTML document is not much more difficult than using a ten-year-old copy of WordPerfect with the Reveal Codes setting engaged.Remember the definition of HTML: Hypertext Mark-up Language. In HTML itself, there is no programming-just the "marking up" of regular text for emphasis and organization. In fact, I prefer to call people who work with HTML "designers" or "developers," and not programmers. Actually, there's only limited design work that can be accomplished with HTML (especially the most basic standards of HTML), and anyone used to working with FrameMaker, QuarkXPress, or Adobe PageMaker will be more than a little frustrated. But the best pages are still those created by professional artists, writers, and others with a strong sense of design. As Web page development matures, we are starting to see more concessions to the professional designers, as well as an expansion into realms that do require a certain level of computer programming expertise. Creating scripts or applets (small programs) in the Java language, for instance, is an area where Web page development meets computer programming. It's also a relatively distinct arena from HTML, and you can easily be an expert in HTML without ever programming much of anything. The basics of HTML are not programming, and, for the uninitiated in both realms, HTML is much more easily grasped than are most programming languages. If you're familiar with the World Wide Web, you've used a Web browser like Netscape, Mosaic, or Lynx; and if you have any experience with a word processor or text editor like WordPad, Notepad, SimpleText, or Emacs, then you're familiar with the basic tools required for learning HTML. The World Wide Web and Web Servers Probably the most important thing to remember about the World Wide Web and the Internet in general is that they are global in scale and often a very cooperative venture. Information on the Web tends to be distributed around the world, and it's just as easy for you to access a site in New Zealand or Japan as it is to access Web information in your own state. The basic reason for learning HTML is to create pages for the World Wide Web. Before you start, though, you'll want to know a little about how this whole process works. We'll begin by taking a look at Web browsing programs, then we'll talk about how the World Wide Web works, and we'll discuss some of the terms associated with surfing the Web. Finally, we'll round out the discussion by talking about the Internet in general and the different services available on the Internet and how they interact with the Web. What's the World Wide Web? The World Wide Web is an Internet service, based on a common set of protocols, which allows a particularly configured server computer to distribute documents across the Internet in a standard way. This Web standard allows programs on many different computer platforms (such as UNIX,
Page 71 of 187
Figure 1.1 : Here's a Gopher site as displayed through Netscape Navigalor This flexibility is part of what has fueled the success and popularity of the Web. Not only do the Web protocols allow more interactive, multimedia presentations of information, but the typical Web browser can also offer its user access to other Internet resources, making a Web browser perhaps a user's most valuable Internet application. The Web Page The World Wide Web is composed of millions of Web pages, each of which is served to a browser (when requested) one page at a time. A Web page is generally a single HTML document, which might include text, graphics, sound files, and hypertext links. Each HTML document you create is a single Web page, regardless of the length of the document or the amount of information included. The Web Site
Page 72 of 187
Page 73 of 187
Figure 1.2: Examples of Web browser helper applications. Most of these helper applications will be add-on programs that are available as commercial or shareware applications. The browser will generally need to be configured to recognize particular types of multimedia files, which, in turn, will cause the browser to load the appropriate helper application. Once loaded, the downloaded multimedia file will be fed to the helper applications, which can then play or display the multimedia file Common Multimedia Formats Although it seems that multimedia formats are constantly being added and improved for the Web, some of the more common types of multimedia files are listed in Table 1.1 with their associated file extensions. This list isn't exhaustive, but it should give you an idea of the types of files that can be distributed on the Web. File Format Sun Systems sound Windows sound Audio Interchange MPEG audio SoundBlaster VOiCe RealAudio CompuServe GIF Type of File audio audio audio audio audio audio graphics Extension .au .wav .aiff, .aifc .mpg, .mpeg .voc .ra, .ram .gif
Page 74 of 187
Table 1.1 Multimedia Formats Common to the Web Not all of these different file formats necessarily require a special helper application. Many sound helpers will play the majority of different sound files, for instance, and some graphics programs can handle multiple file types. For the most part, you will need different helper applications for the various video, animation, and formatted text file types.
Page 75 of 187
Page 76 of 187
Page 77 of 187
Page 78 of 187
Page 79 of 187
Page 80 of 187
Multimedia presentation-A Web site allows you to do things that are simply not possible in any other medium. With some of the visual impact of television, the informational utility of print, and the personal appeal of radio, the Web is an effective tool for taking marketing information to another level. Products can be explained and offered in depth, along with pictures, video, sound, and even animation. Interactivity-There are a number of different areas where the fact that your user can interactively determine what to view or hear can really make the difference for a business. Especially important is the added value the Web gives you for customer service, technical or product support, and immediate feedback. While most of any Web site is automated, it gives you an opportunity to answer frequently asked questions and point customers to resources that may help them solve problems on their own. While this may seem like an advantage reserved for computer companies, consider the implications for service-oriented industries like travel, consulting, catalog sales, and business-tobusiness sales. Flexibility-If your business relies on printing or publishing as a medium, you may immediately see the advantage of the Web. Changes on the Web are relatively instantaneous, and the speed with which an update can be made is measured in minutes, not weeks. Consider the financial planner's or real estate agent's sales newsletter. Instant changes on the World Wide Web give their Net-savvy clients a time-based edge. Incorporating the Web into the services you offer a client gives you an added value in their eyes, especially in time-sensitive industries.
Page 81 of 187
Easy High-Tech-Whether you're a small or large business, it's important to keep up with technology in order to satisfy customers and be up on the "latest." Web pages are moving toward a point where they'll be expected of large businesses and not unusual from small ones. Like e-mail a couple years ago, and fax machines before that, it's become important to keep up with the Web. Fortunately, it's also rather easy to get started with HTML and quickly develop a Web site.
Disadvantages It's difficult to say that there are disadvantages in having a Web site, since most people and companies will use a Web site to enhance their marketing and customer service efforts, not supplant them. That said, there are a few hurdles to leap, and they should definitely be considered before your Web project takes off:
Learning Curve-It will take a while for folks to learn HTML, figure out how to upload pages, create appropriate graphics, and design effective Web sites. You'll also need to find an effective and helpful Internet service provider (or a similar in-house IS employee at a larger corporation) who can help you get online. Appearance-To be truly effective, a Web site also needs to be attractive and easy to use. For many companies, especially larger ones, that will mean using professional artists, writers, and designers. Beginning this task can be daunting, and will require a reasonable budget-which may be intimidating when management isn't sure what the benefits will be. Maintenance and Timeliness-One of the worst things that can happen to a Web site is for it to sit dormant for weeks or months because it's the pet project of an interested employee who has less time for it than she originally anticipated, or because every change to the Web site must first be approved by a committee. It's important that a Web developer be relatively free to spend time on the project, and that someone be available to make timely decisions. Without this, the Web site loses some of its inherent advantages. Security-Transmitting data via Internet technology, including the Web, is inherently a rather unsecure process. For data to be transmitted over the Web, it has to pass through a number of different servers and hosts-and any of the information you offer could potentially be read or held by any of these people. This has been a strong argument against commerce on the Web, as people recognize the dangers in revealing personal information (for instance, credit card numbers). Currently, it's difficult to create completely secure Web sites that offer access only to password-bearing users, and those passwords are often not impossible to intercept. Copyright Issues-The lack of security holds true for the Web designer-nearly anything you create on the Web can easily be read or copied by anyone with Web access. This is intimidating both to artists and publishers who want to make sure that Internet access doesn't, in some way, devalue their published (and profitable) efforts. Cost-Depending on the size of your organization and the expertise of its people, a Web site can quickly become expensive. Learning HTML and creating a reasonable site isn't that difficult (as you'll see in this book), but maintaining the appropriate equipment, paying the dedicated staffers, and bringing in consultants, designers, programmers, and IS technicians as the site grows can quickly expand the budget. The advantages will often outweigh these costs, but any Web developer should be aware that Web sites tend to get bigger and more time-consuming as time goes on.
Page 82 of 187
Page 83 of 187
Page 84 of 187
Figure 3.1: WebSTAR Web server software running on a Macintosh computer. Web server software generally requires a fairly robust operating system (like UNIX, Windows NT, or OS/2), although software is available for other versions of Microsoft Windows, and the Macintosh OS is a very popular choice for Web server computers. The software you use depends on your level of experience with Internet connections and various operating systems. Speed of the Server The other major consideration is how popular your Web site will be. The more hits, or connections, your Web server receives at one time, the more powerful the computer should beand the faster your connection to the Internet. Most Internet connections are measured in terms of bits per second (bps), which translates loosely as "how many bits of data can be transmitted across the Internet in a second." In computerese, it takes eight bits to make up one byte of computer information-and a byte is what is required to create a character of text. The typical modem connection is 14,400 bps, which translates to roughly 1,800 characters (bytes) transferred every second. If a typical page of text contains 300 words then, and each word averages six characters per word, this connection would yield roughly a page-per-second transmission rate. A 25-kilobyte (KB) file (such as a very small GIF file) would take about 14 seconds to transmit over this connection. This doesn't sound terribly slow, until you start to take into account the idea that more than one connection might occur with the Web server. If ten people connect to our server over this
Page 85 of 187
Page 86 of 187
Site's default URL-This should be something like the ISP's host address and a directory for your username. For instance, if my username is tstauffer and my ISP's Web server is www.webco.net, then the default URL for my site might be http://www.webcom.net/tstauffer/. Different ISPs will organize this in different ways, so you'll need to make sure you get this right. Uploading files to the site's directory-You should get instructions for accessing your Web site's directory on the Web server computer using either FTP or a UNIX shell account. Limitations to the names you can give to your files-The operating system in use by the Web server may not be instantly obvious to you. If this is the case, you'll want to ask if there is a certain filename length or a certain format for naming files you need to follow. Creating subdirectories within your main Web site directory-Most Web servers will give you this capability, but some will not allow you to create new subdirectories. Support offered for CGI programming Some servers won't allow you to add CGI scripts to your Web site for processing forms or adding other interactive features. At the same time, some will, but require you to pay extra or pay to have the provider write those scripts (regardless of your ability). If you plan a highly interactive site, then you should ask about CGI support.
Organizing a Web Site The most important thing to remember when organizing a Web site is how the server computer you're using will differ from the computer you use to create Web pages. This is because you'll need to know the exact path to HTML pages and multimedia files you use in creating your Web page. As we've seen before, an URL requires both a server name and a path statement to the file. This includes files that you've placed on your own Web server-so while you're creating your Web pages, you'll need to know where your files will eventually be.
Page 87 of 187
Single-directory sites-Smaller sites (with just a few HTML pages and graphics) can often get by with a single directory on the Web server. All your graphics and HTML pages are in this one directory. One of the biggest advantages of this system is that links to local files and graphics require no special path statements. Directory by function-One way to organize more complicated sites is to put each section of related Web pages in the same directory. For instance, in your main directory you might offer only your first (index) page and its associated graphics. For a business site then, you'd have subdirectories for About the Business, Product Information, Technical Support, and so on. In each of these subdirectories, you'd include all the related HTML files and the graphics for those pages. Directory by file type-Some people prefer to create subdirectories according to the type of file as opposed to the content of the page. Your main directory may have only the index page of your site. Other subdirectories might be Graphics, Web Pages, Downloadable Files, and so on. The main advantage in organizing this way is that files generally have to be replaced only once. If you use a graphic on a number of different pages, for instance, you replace it once in the Graphics subdirectory, and all the HTML pages that access this graphic will use the new one. Hybrid-The best way to organize a large site might be a hybrid of the last two methods above. Creating separate subdirectories for nonrecurring items (such as individual Web pages in each category) while creating other subdirectories for items used multiple times (such as graphics) lets you get to all the files in an efficient way.
Naming Your Files We've already mentioned that file extensions are an important part of all the filenames you use for your Web site. Because other Web browsers may rely on the file extension to know what sort of document or file it is, you'll need to include the appropriate extensions with all your Web site files. Your Web site will almost always begin with a file called index.html. Most Web server software programs will automatically load this page if the URL of your site is accessed without a specific path and file reference. For example, entering http://www.sun.com/ in your browser actually results in the URL http://www.sun.com/index.html being loaded in your browser. Your Web site's first page (whether it's a "front door" page or the first page of your site) should be designed with this in mind. If you plan to offer only Netscape-enhanced pages, for instance, you'll want to let your users know this on the index.html page. The other consideration for naming your files is the organization you plan to use for your site. If you're using a single-directory organization, your filenames should be as unique as possible, and graphics and other files should probably have names that relate to associated Web pages. For instance:
Page 88 of 187
Figure 3.2: The directory organization for my site. The directory names, then, will be as follows: about_pages service_pages sample_pages graphics sample_files Files and graphics are named for where they appear, unless they show up in multiple Web pages. For this site, the prefixes I'm using are as follows:
Page 89 of 187
Page 90 of 187
Figure 4.1 : In Microsoft Internet Explorer for Windows 95, the File, Open command opens the the Open Internet Address dialog box which contains an Open File command button to open a file from a drive. You may have heard of some dedicated HTML editing programs that are designed to make your work in HTML easier. They do indeed exist, and they can be very useful. Unfortunately, many of them also hide the HTML codes from the designer, so they would be difficult for us to use as you learn how HTML works. Once you understand HTML, though, it can be a great benefit to use one of these browsers.
Page 91 of 187
Page 92 of 187
<HTML> <HEAD> <TITLE>Enter Title Here</TITLE> </HEAD> <BODY> </BODY> </HTML> And that's it. Now save this as an ASCII text file called template.html (or template.htm if you're using DOS or Windows 3.1). Now, whenever you're ready to create a new HTML document, simply load template.html into your text editor and use the Save As command to rename it. Example: Hello World When learning a new programming language, it's traditional that the first program you create is designed to say "Hello World." Well, HTML isn't a programming language-but I can use the Hello World example to prove that your template is a complete Web document. Load the template.html file into your text editor, and use the Save As command to rename it hello_world.html or something similar. Now, edit the document so that it looks like this: <HTML> <HEAD> <TITLE>Hello World Page</TITLE> </HEAD> <BODY> Hello World! </BODY> </HTML> Select the File, Save command from your text editor. Now load your Web browser and select the Open File (or similar) command from the File menu. In the dialog box, find the document hello_world.html and select OK to load it into your Web browser. If everything goes as planned, your browser should display something similar to figure 4.2.
Figure 4.2 : The Hello World page as viewed in Microsoft Internet Explorer. And that's a Web page!
Page 93 of 187
Page 94 of 187
Figure 4.3 : Here are your two sentences, separated by a horizontal line. Entering Paragraph Text on Your Web Page With your template prepared, and with an understanding of the two types of tags in HTML, you're ready to enter text on a Web page. As mentioned earlier, all the text that you enter on a page should come between the <BODY> and </BODY> tags. Like <EM>, the body tags are container tags that tell a Web browser what parts of the HTML document should be displayed in the browser window. You've seen that you can just type text into an HTML document and it will be displayed in the browser. Technically, though, most of the text you type should be in another container tag: the <P> (paragraph) tag. This tag is used to show a Web browser what text in your document constitutes a paragraph. For the most part, Web browsers ignore more than one space between words and will ignore returns that you add to your HTML file while you're creating it. In order to give the appearance of paragraphs, then, you have to use the paragraph container tag. The paragraph tag uses the following format: <P>Here is the text for my paragraph. It doesn't matter how long it is, how many spaces are between the words or when I decide to hit the return key. It will create a new paragraph only when I end the tag and begin with another one. </P>
Page 95 of 187
Figure 4.4 : The Post Office would never deliver this. We already know what the problem is: Web browsers ignore extra spaces and returns! But if you put each of those lines in a paragraph container, you'd end up with a space between each line-and that would look wrong, too.
Page 96 of 187
Figure 4.5 : This address looks much better. The Comment Tag There's one other tag I'd like to discuss in this chapter, called the comment tag. This tag is fairly unique, in that it's actually used to make the Web browser ignore anything the tag contains. That can be text, hypertext links, image links, even small scripts and programs. For now, you'll use the comment tag to hide text. The point in hiding the text is that it allows you to create a private message that is intended to remind you of something or to help those who view the raw HTML document to understand what you're doing. That's why it's called the comment tag. For instance: <!--This is a comment that won't display in a browser--> The comment tag isn't the most elegant in HTML, but it usually works. Anything you type between <!-- and --> should be ignored by the browser. Even multiple lines are ignored-as with most tags, the comment tag ignores returns. Generally, you'll use the comment tag for your own benefit-perhaps to mark a point in a particular HTML document where you need to remember to update some text, or perhaps to explain a particularly confusing part of your page. Since it's fairly easy for anyone to view your raw HTML document, you might also use the comment tag to create a copyright message or give information about yourself. Viewing the Source of Web Pages: Ever been out on the Web looking at a particularly welldesigned HTML document-and wondering how they did it?
Page 97 of 187
If you'd like to, most browsers will let you view the document source for any Web page they can load. This allows you to download the raw HTML codes and ASCII text, just as if you'd created the page yourself. To do this, select the View Document command in the Edit menu of your Web browser (the command may differ slightly, so look for a similar name if you can't find View Document). What results is the plain ASCII text file that was used to create that Web page. Depending on your browser, this source file will either be displayed in the browser window, or saved to your hard drive and displayed in the default text editor. If the source is displayed in the browser window, then select File, Save As to save the source to your hard drive. Now you might be able to imagine how comments can come in handy. If you would rather not have people copy and use the source from your Web pages (or if your pages contain otherwise copyrighted material that you want to protect), you can use the comment tag to let others know that you consider the page your property. For instance: <!--Contents of this document Copyright 1996 Todd Stauffer. Please do not copy or otherwise reproduce the source HTML code of this document without permission.--> Of course, that's not to say that you shouldn't also offer a visible copyright notice or other legal disclaimers. But comments within the code tend to talk directly to folks a little more HTMLsavvy. Using a comment tag like this is a great way to encourage other Web designers to ask you before using your HTML pages for their own private use.
Page 98 of 187
Figure 5.1: HTML header tags at work. Notice that the fourth entry is regular text between <P> and </P>tags. <H1>Header Level One is the largest for headlines or page titles</H1> <H2>Level Two is a little smaller for major subheads</H2> <H3>Level Three is again smaller, for minor subheads</H3> <P>This is regular text.</P> <H4>Level Four is about the same size as regular text, but emphasized</H4> <H5>Level Five: again emphasized, but smaller than regular text</H5> <H6>Level Six is generally the smallest header</H6>
Page 99 of 187
Figure 5.2 : Most browsers can render two physical tags applied to the same selection of text. <H1><I>Welcome Home!</I></H1> <B><I>This is bold and italic</I></B> Implicit HTML Tags Implicit styles are often called logical styles, since they allow the browser some freedom in how it will display the text. These tags, like the header tags, are generally relative to one another, depending on the browser being used to view them. See Table 5.2 for some of the common implicit (logical) tags
Tags
Table 5.2 Some Basic Logical HTML Tags Table 5.2 includes a section that tells you how these tags are often rendered in graphical Web browsers. There's no rule for this, though, and the tags don't necessarily have to be rendered in that way. There are two other distinctions between these tags and the physical tags (such as bold and italic) that you've already discussed. First, these logical tags will always be rendered by any Web browser that views them. Even text browsers (which are unable to show italic text) will display the <EM> or <STRONG> tags by underlining, boldfacing, or highlighting the text. Second, these tags are generally not effective when used together. Where <B><I>text</I></B> will sometimes offer useful results, <EM><STRONG>text</STRONG></EM> rarely will. Combining these tags with other tags (such as header tags or physical tags) is often either ineffective or redundant. Other Implicits: Programming, Quoting, and Citing At the beginning of this chapter, I mentioned that the creation of HTML tags took place before the standard was ever conceived of-which might explain some of the tags that we discuss in this section. For the most part, these tags are implicit (logical) and aimed directly at certain areas of expertise. At the same time, however, the bulk of these tags will look exactly the same in a Web browser. Programmer's HTML Tags One of the early, more common uses for HTML was for documenting computer programs and offering tips or advice to computer programmers. Part of the HTML 3.0 standard, then, offers some implicit (logical) HTML tags that allow HTML designers to mark text in a way that makes it easier to present computer programming codes. Those tags are in Table 5.3.
Tags
Table 5.3 HTML Tags for Computer Programming Notice that the majority of these tags are often displayed in exactly the same way-in the default monospaced font for the browser. Then why use them?
Table 5.4 HTML Publisher-Style Tags Again, notice that the <CITE> tag isn't going to be rendered any differently from the italics, emphasis, or variable tags you've seen previously. The <DFN> tag is often not rendered as any special sort of text at all, whereas the <ADDRESS> tag is identical in function to the italics tag. So the best use for these tags (with the exception of the <BLOCKQUOTE> tag) is as internal documentation of your HTML documents. Remember, of course, that some browsers may render them slightly differently from what is suggested in Table 5.4. Example: Using the <BLOCKQUOTE> and <ADDRESS> Tags The only really new tag in the Table 5.4 is the <BLOCKQUOTE> tag. This tag usually indents the left margin of regular text in the browser window, just as you might find a blocked quotation formatted in a printed document. Also as part of the tag, <BLOCKQUOTE> generally adds a return or one extra line on either side of the tag, so no paragraph tags are needed. Paragraph tags should, however, be used to contain text on either side of the blockquote. Although the <ADDRESS> tag is similar to italics or emphasis, I've thrown in an example of using it correctly. Remember to include a line break after each line of the address. Enter Listing 5.1 between the body tags.
Notice that an off paragraph tag isn't required before you get into the address tag-remember, <ADDRESS> works very much as italics does, and the <BR> tag is designed to work as well inside a paragraph container as it does outside one. So you can put the paragraph tag after the address, to contain both address listing and the text in the same paragraph. Take a look at figure 5.3 <BLOCKQUOTE>, unlike some of the tags you've looked at, really does offer unique abilities that make it worth using in your documents.
You may have noticed that the preformatted text is in a monospaced font-it will always be that way. Otherwise, the <PRE> tag works pretty much like the paragraph font, except that it lets you decide where the line breaks and spaces will appear. Look at the following example: <PRE>I you. </PRE> With the above code, the browser will display this line in nearly exactly the same way as it would using the <P> tag, except that it will be in a monospaced font, and the extra spaces and extra return will appear as well. In fact, there will be two blank lines below the line of text-one for the return, and one for the </PRE> tag itself. You can even use the <PRE> tags to create extra lines in a document without typing any text between them. This example adds two blank lines to a document: <PRE> </PRE> For each additional blank line you want to add, just press Enter after the first tag one time. Note: There is one potential drawback to the <PRE> tag. It doesn't allow the browser screen to wrap text automatically-instead, users need to expand their browser window if you use particular long lines within a <PRE> container. Just keep this in mind, and make sure your lines of text are reasonably short so that all browsers can view them without scrolling. Example: Using <PRE> for Spaces and Tables In the same way that you created the film script using the <PRE> tag, you can also format a primitive table using the <PRE> tag along with some others. The key to making this work correctly is alignment. Realize that each space taken up by a character of an invisible tag (like <B>) will not appear in the browser's display, so you'll need to compensate. Tip : One way to keep the columns in a table straight is to type your table first, and then add emphasis tags afterward. Load your template and save it as pre_tbl.html. Now enter Listing 5.2 between the body tags. simply want to make this <B>really</B> clear to
You may need to play with the spacing a bit to line everything up. Save the HTML document, then choose the Open File command in your browser to proof it. Keep playing with it until it looks right. Once you have everything aligned correctly, it's actually a fairly attractive and orderly little table (see fig. 5.5).
Figure 6.1 : The subtle differences between ordered and unordered lists. As I've already mentioned, both ordered and unordered lists can take different types of internal HTML tags. It's even possible to include paragraph, line break, and header tags in lists. While you may see the potential in creating ordered lists that conform to standard outlining conventions (for instance, Roman numerals and letters), HTML 3.0 doesn't really help much. There is no way to change the <LI> number from Arabic numbers, and there's no way in HTML 3.0 to create a list that starts with something other than 1. Netscape, however, has added both of these abilities, and you can be much freer in your outline, as long as you warn your users ahead of time to view your page with Netscape Navigator (or a Netscape-compatible browser). Directories, Definitions, and Menus Your other lists have something in common with one another that they don't share with ordered and unordered lists: all of them use some permutation of the previous line-item system, but none of them consistently use numbers or bullets. Directories and menus are basically just plain lists. Definitions are unique among all lists because they offer two levels of line items within the list structure-one for the definition item and one for the definition itself. Directory and Menu Lists To create a directory or menu list, you start with its respective container tag: <DIR> or <MENU>. Of these two, the directory list is probably more useful. Most browsers don't currently render the <MENU> command consistently-some use a bulleted list, others use no bullets. The following is an example of <MENU>:
Figure 6.2 : Menu and directory lists in MS Internet Explorer. Definition Lists The final list tag is the definition list, which is designed to allow for two levels of list items, originally conceived to be the defined term and its definition. This is useful in many different ways, though, and is also nice for its consistent lack of bullet points or numbering items (as opposed to the menu and directory listings, which are often rendered haphazardly by browsers). The tags for this list are the container tag <DL> (definition list) and two empty tags, <DT> (definition term) and <DD> (definition). The <DT> tag is designed (ideally) to fit on a single line of your Web page, although it will wrap to the beginning of the next line if necessary. The <DD> tag will accept a full paragraph of text, continuously indented beneath the <DT> term. The following is an example of all three tags: <DL> <DT><B>hero</B> <I>(n.)</I> <DD>A person admired for his or her brave or noble deeds. <DT><B>hertz</B> <I>(n.)</I> <DD>A unit used in the measurement of the frequency of electromagnetic waves <DT><B>hex</B> <I>(n.)</I> <DD>An evil spell or magical curse, generally cast by a witch. </DL> Notice that standard HTML mark-up is permissible within the boundaries of a definition list, and that using bold and italics for the defined terms adds a certain dictionary-like quality (see fig. 6.3).
Figure 6.3: A basic definition list. Tip : Not all browsers will display definition lists in the same way, so adding spaces to <DT> items (to get them to line up with the <DD> text) is often a waste of time. It should also be pointed out that just because definition lists allow for two different types of list items, you needn't necessarily use both. Using just the <DT> tag in your list, for instance, will result in a list not unlike an unordered list-except that nearly all browsers will display it without bullets: <DL> <DT>Milk <DT>Honey <DT>Eggs <DT>Cereal </DL> And, although more difficult to find a use for, the <DD> item could be used on its own to indent paragraphs repeatedly. This book occasionally uses a similar device. <P>I must say that I was shocked at his behavior. He was: <DL> <DD><I>Rude.</I> Not rude in your standard sort of affable way, or even in a way that would be justifiable were he immensely weathly or critically wounded. It was just a rudeness spilling over with contempt. <DD><I>Unjust.</I> If there was something he could accuse you of falsely, he would do it. I could almost see him skulking around his apartment after a particularly unsucessful party, doing his best to find things stolen, which he could blame on people who hadn't actually bothered to show up. </DL> </P> The definition list offers some additional flexibility over the standard lists, giving you more choices in the way you layout the list items (see fig. 6.4).
Figure 6.4: Definition lists using only one of the two elements. Nesting Tags and Combining List Types Since most of your HTML lists can accept HTML tags within their list items, it stands to reason that you could potentially create lists within lists. In fact, creating a list, then creating another list as part of an item in that first list is how you can create an outline in HTML. Nesting Tags The idea of nesting comes to us from computer programming. Nesting is essentially completing an entire task within the confines of another task. For HTML, that means completing an HTML tag within the confines of another container tag. This could be something like the following: <P>She was easily the most <EM>beautiful</EM> girl in the room.</P> This is an example of correctly nesting the <EM> tag within a paragraph container. On the other hand, many browsers would still manage to display this next code: <P>She was easily the most <EM>beautiful</P> girl in the room.</EM> But this second example is really poorly constructed HTML. It often works, but the <EM> tag isn't properly nested inside the <P>. In this example, that doesn't matter too much, since you can still reason out what this statement is trying to do. With lists, however, things can get complicated. So it's best to remember the "nesting" concept when you begin to add lists within lists. As far as HTML is concerned, a nested list works as marked-up text within the previous list item. When the next list item is called for, HTML moves on. Lists Within Lists Let's look at an example of a simple nested list:
Figure 6.5: In both of the examples, the HTML container is simply part of the list. Combining List Types When nesting lists, it's also possible to nest different types of lists within one another. This is useful when you'd like to vary the types of bullets or numbers used in an outline form. For instance: <OL> <LI>Introdution <LI>Company Financial Update <UL> <LI>First Quarter <LI>Second Quarter <LI>Third Quarter <LI>Fourth Quarter </UL> <LI>Advertising Update <UL> <LI>Results of Newspaper Campaign <LI>Additions to Staff <LI>New Thoughts on Television </UL> <LI>Human Resources Update </OL> There's nothing terribly difficult to learn here-just the added benefit of being able to nest different types of lists within others. You're still simply adding HTML markup code to items in the original list. This time, however, you have more choice over how your outline looks (see fig. 6.6).
Create graphics in a graphics application. Many programs for both professional and amateur artists can output GIF- or JPEG-format files for use on the Web. Among these programs are Adobe Photoshop, CorelDRAW!, Fractal Painter, and Fractal Dabbler.
Tip: Any graphics program, even Microsoft Paint, can create Web graphics, although you may need to use another program to change the graphic to an acceptable file format.
Download public-domain graphics. Tons of sites on the Internet allow you to download icons, interface elements, and other graphics for your Web site. At the same time, public-domain clipart collections (such as those available on CD-ROM) can be useful for Web pages.
Use scanned photographs. Using scanned photographs (especially those that you've taken yourself) is a great way to come up with graphics for your Web pages. Unless you have access to scanning hardware, though, you may need to pay someone to scan the photos. Digital cameras. Cameras are available that allow you to take photos that can be downloaded directly from the camera to your computer. While some of this equipment can be very expensive, cameras under $500 do exist, and those photos can easily be converted for use on the Web. Use PhotoCDs. Many photo development shops can create digital files of your photographs (from standard 35mm film or negatives) and save those files in PhotoCD format. Most CD-ROM drives allow you to access these photos, which you can then change to GIF or JPEG format and display on your Web pages.
Manipulating Web Graphics After you decide what graphics to use, the next step is to manipulate and edit those graphics for best use on the Web. The preceding section discussed some of this manipulation (cropping and saving a graphic to make it as small as possible). Following are some other ways to use graphics applications to make your images lean, attractive, and useful:
Keep graphics small. Creating smaller graphics in the first place, and using the cropping tool to take out backgrounds and extra space, are great ways to keep graphics to a manageable size. Use fewer colors. Many graphics applications allow you to decide how much color information should be included in the file. Do you want to use a possible 256 colors or millions of colors? The fewer colors you choose, the smaller your image file will be (see fig. 7.2).
Figure 7.2: Adobe Photoshop allows you to choose the color bit-depth for a particular graphic.
Create thumbnail graphics. At times, displaying a large graphic may be necessary, especially if your user chooses to view it. You can give users this option by creating thumbnail graphics in your graphics programs and then using the thumbnails as links to identical (but much larger) graphics files. This method allows you to create pages that contain many images, all of which are scaled down considerably (and, therefore, download more quickly). If a user wants to view one of the graphics at full size, he or she can simply click the thumbnail graphic.
Note: Some browsers (notably, Netscape) can be used to resize the graphics on-the-fly. Although this is convenient for the designer, the entire file still must be transferred across the Internet, thereby negating the benefits that smaller thumbnail graphics offer in terms of downloading speed. Example: Creating Thumbnails with LView Pro Another must-have program for most Windows-based Web designers is LView Pro, a shareware graphics-manipulation program. Although the program has some of the same features as Paint Shop Pro, LView is designed less for creating images and more for changing them from one size to another or from one file format to another. You can download LView by accessing the Web URL http://world.std.com/~mmedia/lviewp.html. Choose the version for your flavor of Windows, down-load it to your computer, extract it from its Zip archive, install it in Windows, and start it.
Figure 7.3: Resizing graphics in LView Pro for Windows. Tip: If you plan to offer many thumbnails on one page, it's a good idea to make them a uniform width (or height) to keep the page orderly. When you create thumbnails, you'll probably want to maintain the aspect ratio of the current graphic in resizing, so that LView keeps the height and width of the new graphic at the same ratio as the original graphic, making the thumbnail smaller but similarly proportioned. Don't forget to save the new file with a slightly different name, using the appropriate file extension (GIF or JPG). Tip: Whenever an application gives you the choice, you should save GIF files as interlaced GIFs and JPEGs as progressive JPEGs. This lets the graphics display faster in many browsers. Embedding Graphics in Web Pages When your graphics are created, cropped, resized, and saved in the appropriate formats, you're ready to add them to your Web pages. To add graphics, you use an empty tag called the <IMG> (image) tag, which you insert into the body section of your HTML document as follows:
An absolute URL is essential, however, if you were accessing an image on a remote site, as in the following example:
Figure 7.5: Graphics within paragraph containers. Another popular use for graphics is including them in HTML lists. Best suited for this task is the <DL> (definition) list, which allows you to use your own graphics as bullet points. (Ordered and unordered lists display their numbers or bullets in addition to the graphic.) A <DT> (definition term) tag can accept more than one <DD> (definition) element, so you can create a bulleted list as follows: <DL> <DT> <DD><IMG SRC="bullet.gif"> This is the first point <DD><IMG SRC="bullet.gif"> This is the second point <DD><IMG SRC="bullet.gif"> Here's the third point
Figure 7.6: Use a <DL> tag to create custom bulleted lists and thumbnail lists. <DL> <DT><IMG SRC="Small_House14101.GIF"> <DD><EM>14101 Avondale</EM> This executive 3/2/2 is nestled among the live oak, with a beautiful view of the foothills. $139,900. <DT><IMG SRC="Small_House3405.GIF"> <DD><EM>3405 Main</EM> This timeless beauty is a cottage made for a prince (and/or princess!) Spacious 2/1/1 is cozy and functional at the same time, with all-new updates to this 1880s masterpiece. $89,995. </DL> The ALT Attribute None of the HTML tags that you've encountered so far offer the option of a tag attribute-an option that somehow affects or enhances the way the tag is displayed on-screen.
Figure 7.7: The ALIGN attribute for the <IMG> tag. <IMG SRC="image1.gif" aligned to middle. ALIGN="MIDDLE"> Descriptive text
Order among the attributes that you assign to an image tag is unimportant. In fact, because SRC="URL" is technically an attribute (although a required one), you can place the ALIGN or ALT attribute before the SRC information. Anywhere you put attributes, as long as they appear between the brackets of the <IMG> tag, is acceptable. Example: Adding Graphics to Your Web Site Now that you've learned how to add images to your Web pages, you have almost doubled the things that you can do on the Web. In this example, you add graphics to a typical corporate Web page, using a couple of methods that you've learned. To start, you need to create some graphics for your home page. If you have a corporate logo and a scanner handy, go ahead and scan in some graphics. Alternatively, you can use a graphics program to create, crop, and save your graphics as GIF or JPEG files. While you're at it, you may want to create some of your GIFs as transparent GIFs. Create a logo, a special bullet, and a photo for use on the page. Name your GIFs LOGO.GIF >, BULLET.GIF, and PHOTO.GIF, or something similar. (If you have already created a Web site, feel free to name the files according to the organizational system that you're using for the site. You can also use JPEG graphics if you so desire.) Then load your HTML template, and save it as a new HTML document. Between the body tags, type something like Listing 7.1.
Listing 7.1 images.html Using <IMG> to Create Images <BODY> <IMG SRC="logo.gif" ALT="RealCorp Logo"> <H1>Welcome to RealCorp's Web Site</H1> <H2><IMG SRC="photo.gif" ALT="Photo of CEO Bob MacFay" ALIGN=MIDDLE><EM>I'm Bob MacFay, CEO of RealCorp...</EM></H2> <P>We at RealCorp make it our business to be as productive and hard working as you are. That's why we've set up this Web site...to work a little harder, so you don't have to. Take a look at the various services our company offers, and maybe you'll see why we like to say, "We're the hardest working corporation all week, every week."</P> <DL> <DT> <DD><IMG SRC="bullet.gif" ALT="-" ALIGN=MIDDLE> Full service plans for any size of customers <DD><IMG SRC="bullet.gif" ALT="-" ALIGN=MIDDLE> On-time service calls, any time, any day of the week <DD><IMG SRC="bullet.gif" ALT="-" ALIGN=MIDDLE> Fullyequipped mobile troublshooting vans <DD><IMG SRC="bullet.gif" ALT="-" ALIGN=MIDDLE> Time honored appreciate for quality over expediency </DL> </BODY>
Although the ALT attribute is optional and the bulleted list may survive without it, the example uses ASCII to substitute hyphens for the bullet graphics if the browser can't display images. In most cases, you'll want to describe an image that a user can't view. For an element such as a bullet, though, you can use the ALT attribute to substitute an ASCII character for the graphic. For the photo of the CEO, the <IMG> tag is called within the <H2> tag, because the <H2> container (like a paragraph) otherwise would insert a carriage return and force the words I'm Bob MacFay... to appear below the photo. Including the <IMG> tag inside the <H2> tag allows the text to appear next to the photo (see fig. 7.8).
Figure 7.8: Sample Web page, including some different attributes for the <IMG> tag. Play with this example a little bit to get a feel for when you should place the <IMG> tag within another HTML container and when you can leave the tag out on its own. A page sometimes looks completely different, based only on where you place your image tags.
Figure 8.1: These are the hypertext links that you've created.
Listing 8.1 listlink.html Creating a Definition List <BODY> <H2>The Definition List</H2> <P>Click one of the following words to move to its definition in the list: <BR> <A HREF="#EPITHET">epithet</A><BR> <A HREF="#EPITOME">epitome</A><BR> <A HREF="#EPOCH">epoch</A><BR> <A HREF="#EPOXY">epoxy</A><BR> <A HREF="#EQUAL">equal</A><BR> </P>
In the example, clicking one of the words that appears as a hyperlink in the first section of the paragraph moves the browser window down to that link's associated NAME anchor, so that the definition becomes the focal point of the user's attention. Obviously, using section links would be of greater use in a larger list. Consider the implications for turning an entire dictionary into HTML documents. Also notice that anchors can be placed within the confines other HTML tags, as in the first paragraph container and in the definition lists of the example. In general, anchor tags can be acted on by other HTML tags as though they were regular text. In the case of hyperlinked text, the underlining and change in color in graphical browsers take precedence, but the hyperlinked text also has any other qualities of the surrounding text (for example, indenting with the rest of the definition text). In figure 8.2, notice which anchors cause the text to become a hyperlink and how the anchor tags respond within other container tags.
Figure 8.2 : Anchor tags are used to define and move between sections of an HTML document. Using Relative URLs In most cases, the URL referenced by the HREF attribute within the anchor tag needs to be an absolute URL, unless it references a file located in the same directory as the current HTML document. But consider the case of a well-organized Web site, as set out in Chapter 5, "What You Need for a Web Site." That chapter discussed the fact that it's not always the best idea to drop all your Web site's files into the same directory, especially for large sites that contain many graphics or pages. How do you create links to files that may be on the same server but not in the same directory? One obvious way is to use an absolute URL for every link in your Web site. If the current page is http://www.fakecorp.com/index.html, and you want to access a specific page that you organized into your products directory, you could simply create a link like the following, using an absolute URL: <A HREF="http://www.fakecorp.com/products/new_prods.html> Our new products</A> These absolute URLs can get rather tedious, not to mention the fact that if you happen to change the name of your Web server or move your site to another basic URL, you'll probably have to edit every page in your site to reflect the new URLs.
Figure 8.3 : Graphical look at your fictitious Web site's organization. For this example, you create only one Web page. To test the page, however, you want to create a directory structure similar to the previously outlined directory structure and include all the files mentioned. Begin by saving your template file as products.html. Then, in your text editor, enter Listing 8.2.
Listing 8.2 basetag.html Creating a Directory Structure <HTML> <HEAD> <TITLE>Our Products</TITLE>
Figure 8.4 : Your Products page, complete with relative links to other parts of the Web site. Note: Notice that the <BASE> HREF also affects graphics placed with the <IMG> tag. Remember to use relative addresses for images that take the <BASE> address into account. Only HTTP documents and images are affected by <BASE>, though, and not other URL types (like ftp:// and gopher://). Creating Links to Other Internet Services Here's where the real power of URLs comes into play. Remember that an URL can be used to describe almost any document or function that's available on the Internet? If something can be described in an URL, a hyperlink can be created for it. In the following section, you start with email. Hyperlinks for E-Mail Messages Creating a hyperlinked e-mail address is simple. Using the mailto: type of URL, you can create the following link: <A HREF="mailto:[email protected]">Send me e-mail</A>
Figure 8.5 : Clicking a mailto : link bring up an e-mail message window in Netscape. Not all Web browsers accept the mailto: style of URL, however, and most of those don't return an error message. If you use this type of link, you may want to warn users. Something like the following text should work well for users of nongraphical browsers: <P>If your browser supports the mailto: command, click <A HREF="mailto:[email protected]">here</A> to send me an e-mail message. </P> Other Internet Services Using the various types of URLs discussed in Chapter 3, you can create links to nearly all other types of Internet services as well. For Gopher sites, for example, a hypertext link might look like the following example: <A HREF="gopher://marvel.loc.gov/">the Congress Gopher</A> Library of
Most Web browsers can display Gopher menus. In most cases, clicking a gopher link points the browser at the Gopher site, and the Gopher menu appears in the browser window.
Figure 8.6 : Netscape is downloading a file from an FTP server. Note: Most browsers can accept hyperlinks only to anonymous FTP servers. You generally should not include in your HTML documents links to FTP servers that require usernames and passwords. Again, most browsers have some mechanism (sometimes built into the browser window) for reading UseNet newsgroups. Some browsers launch a separate program to read UseNet groups. In either case, you can create a link like the following: <A HREF="news:news.answers">UseNet Help Newsgroup</A> This link loads whatever UseNet reading features the browser employs and displays the specified newsgroup (see fig. 8.7). The news: URL type does not require a particular Internet server address to function. Each browser should be set up with its own links to the user's news server.
Figure 8.7 : MS Internet Explorer after clicking a link to the newsgroup news.answers. Other Links for the <HEAD> Tag You can create a couple more tags in the <HEAD> section of your HTML documents. These tags are of varying levels of real-world usefulness, so you may want to read this section quickly and refer to it again later if you have a question. The two tags discussed in the following sections are <LINK> and <ISINDEX>. The <LINK> Tag The <LINK> tag is designed to establish a hypertext relationship between the current document and another URL. Most of the time, the <LINK> tag does not create a clickable hypertext link in the user's Web viewer window. It's a little beyond the scope of this book, but programs can be written to take advantage of the <LINK> tag, such as a program that creates a toolbar that makes use of the relationship defined. The <LINK> tag generally has either of the following formats: <LINK HREF="URL" REL="relationship"> or <LINK HREF="URL" REV="relationship"> For the most part, <LINK> is used to create an author-defined structure to other HTML documents on a Web site. The attribute REL, for example, defines the relationship of the HREF
You also should include a mailto: anchor tag in the body of your document to allow people to respond to your Web page. Using both is encouraged, but it's ultimately up to you. The <ISINDEX> Tag Adding the <ISINDEX> tag to the <HEAD> of your document allows some Web-server search engines to search your Web pages for keywords. If your Web server offers such a search engine and the user's browser supports these searches, the user will be presented with a simple search box when this page is loaded. The user can then enter the text he or she wants to search for on your page. The tag itself is very straightforward and requires no further attributes, as the following example shows: <HEAD> <ISINDEX> </HEAD> Note: If someone else runs your Web server, you may want to ask that person whether you should include the <ISINDEX> tag. If the administrator offers a server-based search engine, he or she may have you use the <ISINDEX> tag, or he or she may insert it into your document himself or herself.
Figure 9.1 : The image map interface at Apple Computer's Web site. Check out one more thing. If the image map fills your screen, scroll down in your browser window so that you can see what's below the interface on Apple's Web page. The text directly below the interface almost exactly mirrors the hyperlink options you have with the image map, because image maps, unlike clickable graphics, don't offer an ALT statement for the various hot zones. So you have to include additional links to cater to your users of nongraphical browsers. Understanding How Image Maps Work Creating an image map involves three steps: creating the graphic, mapping the graphic for hot zones, and placing the correct information (along with the correct programs) on the Web server itself. This section discusses the Web server; the next section talks about defining hot zones. To offer your users the option of using image maps, you must have a special map server program running on your Web server. For UNIX-based servers, this program will most often be NCSA Imagemap; other platforms have their own map server programs. The Map Server Program When a user clicks an image map on a Web page, the browser determines the coordinates of the graphic (in pixels) that describe where the user clicked. The browser then passes these numbers to the map server program, along with the name of the file that contains the URLs that correspond to these coordinates.
Figure 9.2 : A map definition file. You can define different shapes in the file; these shapes correspond to the shapes of the hot zones that overlay the graphic that you want to use for your image. Each set of coordinates creates a point on the graphic. The coordinates are expressed in pixels, with each pair of numbers representing the number of pixels to the right and down, respectively, from the top left corner of your graphic. The shapes require a different number of points to define them. Rectangles require two points, for example, and polygons require as many points as necessary. Luckily, the number of points involved isn't something that you'll have to worry about. Simply by using a map editing program for Windows or Macintosh (discussed later in this chapter in the sections, "MapEdit for Microsoft
rect (rectangle)-This shape requires two points: the upper left coordinates and the lower right coordinates. circle-To create a circular region, you need coordinates for a center point and an edge point. The circle is then computed with that radius. point-A point requires only one coordinate. The map server software decides which point the mouse pointer was closest to when the shape was clicked (provided that the click didn't occur in another hot zone). poly (polygon)-You can use up to 100 sets of coordinates to determine all the vertices for the polygon region. default-Any part of the graphic that is not included in another hot zone is considered to be part of the default region, as long as no point zones are defined. If a point is defined, then default is redundant, since the map server will evaluate any click (outside of a hot zone) and choose the nearest point.
Defining Your Image Map Hot Zones As a designer, you are responsible for doing two things in the hot zone definition process. First, you need to define the hot zones to create the image map-that is, you need to decide what URL the coordinates will correspond to when the image map is clicked. Second, you need to create the map definition file that makes the hot zone information available to the Web server. For Windows and Macintosh users, luckily, programs that do both are available. MapEdit for Microsoft Windows and X-Windows Available for all flavors of Windows (Windows 95, Windows 3.1, and Windows NT) and for most types of UNIX, MapEdit is a powerful program that allows you to graphically define the hot zones for your image maps. You can access and download the latest version of this program via the MapEdit Web site (http://www.boutell.com/mapedit/). When you have the program installed and you double-click its icon to start it, follow these steps to define your map: 1. Choose File, Open/Create from the MapEdit menu. The Open/Create Map dialog box appears. 2. In the Open/Create Map dialog box, enter the name of the map definition file you want to create and the name of the graphic file you want to use for your map. You should also use the radio buttons to determine whether you'll use CERN or NCSA map definitions. (Consult your map server software or ISP if you're not sure whether to use CERN or NCSA.) 3. Click the OK button. The Creating New Map File dialog box appears. In this dialog box, click Yes. After a moment, MapEdit displays your image file.
Figure 9.3 : Associating an URL with the hot zone. Tip: By choosing File, Edit Default URL, you can determine whether your image map includes a default URL for clicks outside your hot zones. Example: MapEdit and a Simple Button Bar In this example, you use MapEdit to create a simple button bar-a little like the menu bar that you created with clickable graphics in Chapter 11, except for the fact that this one is an image map. Start by drawing an appropriate graphic in a graphics application and saving it as a GIF file. For this example, name the file testbar.gif. Then follow these steps: 1. Open MapEdit, and choose File, Open/Create. The Open/Create Map dialog box appears.
Figure 9.4 : A successful map definition file created in MapEdit. WebMap for Macintosh If you're a Macintosh user, you can use a program called WebMap, which is similar to MapEdit. You can download WebMap from http://www.city.net/cnx/software/webmap.html. Install the program; then double-click its icon to start it. To create an image map in WebMap, follow these steps: 1. Choose File, Open. 2. In the Open dialog box, select the graphic that you want to use for your map and the name of the map definition file that you want to create.
Figure 9.5 : Using WebMap to create hot zones. To create your map definition file, pull down the File menu and choose Export As Text. In the resulting dialog box, you can name your map file and save it in CERN or NCSA format. Now you're free to save the graphic and quit the program. Adding Image Maps to Your Web Page After you create your image map and your map definition file, you're ready to add a link for your image map to your HTML page. You can accomplish this task in a couple of ways, depending on your Web server. In essence, though, the only major difference between an image map and a clickable image is a new attribute for the <IMG> tag: ISMAP.
Listing 9.1 img_map.html Adding Image Maps in HTML <BODY> <A HREF="http://www.server.com/mymap.map><IMG SRC="mymap.gif" ISMAP ALT= "My Image Map"></A> <H2>Welcome to my page!</H2> </BODY> Note: If you're going to test this example on an actual Web server, you need to replace the URL with the appropriate one for your Web site (and add the type of link to your map info file that's required for your server). Also, use the real name of the mapped GIF file in the <IMG> tag. Save the HTML file and then load it in a graphical browser. If your graphic came up, chances are that you set the <IMG> tag correctly. Notice that many browsers do not display a colored link border around the graphic, because the graphic is now considered to be an image map. Before clicking any of the hot zones, move your mouse pointer around on the image map graphic. If you have a status bar at the bottom of your browser window, you may notice that the link keeps changing (see fig. 9.6). Along with the URL of your map definition file, you should be seeing the current coordinates of your pointer. All this information is sent to the map server to help it figure out what region you clicked. (If you're testing this image map from your local drive, the status bar test is the only part of the example that will work.)
Figure 9.6 : An example image map, showing the URL and the coordinates that it will access if clicked Now, if you are testing your image map on the Web server, go ahead and click the map to make sure that all the links work. If you're viewing the image map locally, turn off the graphics-loading option in your browser, and reload the page. You should notice that there's now no way to access the hyperlinks in the image map-that's why you also need text links for your image map pages. Image Map Design Tips This chapter has covered creating and linking an image map to your Web page fairly thoroughly. Image maps are a bit of a departure from standard text-markup HTML, however, so you should learn a little bit of design theory and Web-related netiquette before you leave this chapter. Please try to keep some of the following suggestions in mind when you add image maps to your Web pages:
Use image maps sparingly. The best way to use an image map is as a clickable menu bar or some other easy-to-recognize interface element. The point isn't really to see how graphical you can make your Web pages-just how intuitive. Remember that image maps are usually little more than big graphics files. Ultimately, the key to graphics on the Web is keeping them small. Even if your image map is incredibly attractive, users will be annoyed if they have to wait many minutes for their four possible choices to download to their browsers. Use all the tips in Chapter 9 to keep your graphic as small as possible, and use image maps only to enhance usability. Image maps require redundant text links. Unless you plan to leave out everyone who can't view your graphics, you need to create text links that do everything that your image map does. Remember that with clickable graphics, the ALT attribute takes care of the problem. The ALT attribute doesn't work for image maps, because a single image map graphic can have many links, so you need to create an identical text link on your page for every hot zone link in your image map. Stick to normal shapes whenever possible. You should try to be conservative with your image maps (see fig. 9.7). A graphic that looks as though it has rectangular buttons
Figure 9.7 : Some sites make it their business to use image maps that break the rules. This one doesn't.
Figure 10.1 : Example of an HTML form available on theWeb. Note: Nearly all graphical browsers have a View Source command. Look in the Edit menu for this command or a command with a similar name. The HTML source of the current Web document will then be displayed or saved as a text file. Notice a couple of things here. The <FORM> tag at WebCrawler is using the ACTION and METHOD attributes that were discussed. ACTION is accessing a script called WebQuery found in the cgi-bin/ directory of the Web server. The METHOD used is SEND. Text Fields and Attributes One of the more common uses for forms is to accept multiple lines of text from a user, perhaps for feedback, bug reports, or other uses. To do this, use the <TEXTAREA> tag within your form. You can set this tag to control the number of rows and columns it displays, although it will generally accept as many characters as the user desires to enter. It takes the following form: <TEXTAREA NAME="variable_name" ROWS="number" COLS="number"> default text </TEXTAREA>
Figure 10.2 : The <TEXTAREA> tag in action. The NAME attribute is a variable name for this string of text. It gets passed on to your processing script on the Web server. ROWS and COLS can accept different numbers to change the size of the textarea box, but you should take care that the majority of browsers can see the entire box onscreen. It's best to limit COLS to 80, and ROWS to something like 24 (the typical size for a textbased computer screen). But it's up to you. <TEXTAREA> will also accept one other attribute: WRAP. WRAP can be set to OFF (which is the default if WRAP is not included), VIRTUAL, or PHYSICAL. Setting wrap to PHYSICAL forces the browser to include actual line breaks in the text when sending it to the Web server. VIRTUAL makes the textbox seem to offer line wrap, but sends a continuous stream of words to the Web server (unless the user has entered returns on his or her own). Example: Web-based Feedback Form I mentioned before that <TEXTAREA> is commonly used to gather feedback from your Web users. To create a small form to do just that, save your default template as a new HTML document and enter the following: <BODY> <H3>Feedback Form</H3> <P>Please take a moment to tell us what you thought of the Web site.<BR> Your Feedback is appreciated!</P> <FORM METHOD="POST" ACTION="cgi-bin/feedback"> Enter your comments below:<BR>
Figure 10.3 : Sample textarea HTML form. You may have realized that there's something lacking in this sample form. There's no way to submit the user's entry! You'll get to that in the next section, when I discuss this next tag for form entry. The <INPUT> Tag Our next tag for HTML forms give you the opportunity to be a bit more picky about the type of input you're going to accept from the user. The <INPUT> tag follows the following format: <INPUT TYPE="type_of_box" NAME="variable" SIZE="number" MAXLENGTH="number"> Now, technically, the only required attributes are TYPE and NAME. Some other "types" of the input tag will also accept the attribute VALUE. But first, let's look at the different types of <INPUT>. Note: By the way, notice that <INPUT> is an empty tag. There's no </INPUT> element.
The first possible value for the TYPE attribute is TEXT, which creates a single-line textbox of a length you choose. Notice that the length of the box and the maximum length entered by the user can be set separately. It's possible to have a box longer (or, more often, shorter) than the maximum number of characters you allow to be entered. Here's an example of a textbox: Last name: <INPUT TYPE="TEXT" NAME="last_name" SIZE="40" MAXLENGTH="40"> When appropriately entered between <FORM> tags, this <INPUT> yields a box similar to figure 10.4. If desired, the attribute VALUE can be used to give the textbox a default entry, as in the following example:
Figure 10.4 : Using the TEXT option with the TYPE attribute. Type of Computer: <INPUT TYPE="TEXT" NAME="computer" SIZE="50" MAXLENGTH="50" VALUE="Pentium">
PASSWORD
The PASSWORD option is nearly identical to the TEXT option except that it responds to typed letters with bullet points or a similar scheme (chosen by the browser) to keep the words from being read. A sample password box could be the following: Enter Password: <INPUT TYPE="PASSWORD" NAME="password" SIZE="25" MAXLENGTH="25"> When characters are typed into this textbox, they are shown on the screen as in figure 10.5.
Figure 10.5 : PASSWORD hides text from people looking over your user's shoulder. Recognize that the text is still stored as the text typed by the user-not as bullet points or similar characters.
This value for TYPE allows you to create a checkbox-style interface for your form. This is best used when there are two possible values for a given choice-and no others. You can also determine whether or not a checkbox will already be checked (so that it must be unchecked by the user, if desired), by using the attribute CHECKED. Here's an example of adding checkboxes to a form: Type of computer(s) you own:<BR> <INPUT TYPE="CHECKBOX" NAME="Pentium" CHECKED> Pentium <INPUT TYPE="CHECKBOX" NAME="486"> 486-Series PC <INPUT TYPE="CHECKBOX" NAME="Macintosh"> Macintosh In this example, it's possible to check as many of the options as are presented. CHECKBOX evaluates each item separately from any others. Figure 10.6 illustrates how CHECKBOX is displayed in a browser.
Like CHECKBOX, RADIO is designed to offer your user a choice from pre-determined options. Unlike CHECKBOX, however, RADIO is also designed to accept only one response from among its options. RADIO uses the same attributes and basic format as CHECKBOX. RADIO requires that you use the VALUE attribute, and that the NAME attribute be the same for all of <INPUT> tags that are intended for the same group. VALUE, on the other hand, should be different for each choice. For instance, look at the following example: Choose the computer <INPUT TYPE="RADIO" Pentium <INPUT TYPE="RADIO" Series PC <INPUT TYPE="RADIO" Macintosh <INPUT TYPE="RADIO" type you use most often:<BR> NAME="Computer" VALUE="P" CHECKED> NAME="Computer" VALUE="4"> 486NAME="Computer" VALUE="M"> NAME="Computer" VALUE="O"> Other
With RADIO, it's important to assign a default value, since it's possible that the user will simply skip the entry altogether. While the user can't check more than one, he or she can check none. So choose the most common value and set it as CHECKED, just so that the form-processing script doesn't have trouble. Note: Of course, if you want to give your user the option of choosing none, then you can leave off the CHECKED attribute. It's more complete and obvious for the user, however, to include another radio button with a VALUE of none, and make it the CHECKED choice.
This <INPUT> type technically isn't "input" at all. Rather, it's designed to pass some sort of value along to the Web server and script. It's generally used to send a keyword, validation number, or some other kind of string to the script so that the script knows it's being accessed by a valid (or just a particular) Web page. The <INPUT TYPE="Hidden"> tag takes the attributes NAME and VALUE. Note: This isn't really terribly covert, since an intrepid user could simply choose View Source to see the value of the hidden field. It's more useful from a programmer's standpoint. For instance, on a large Web site, the hidden value might tell a multi-purpose script which particular form (among many) is sending the data, so the script knows how to process the data.
RESET
The <INPUT> tag has built into it the ability to clear an HTML form. RESET simply creates a push button (named with the VALUE string) that resets all of the elements in that particular FORM to their default values (erasing anything that the user has entered). An example would be the following: <INPUT TYPE="RESET"> With a VALUE statement, you could enter the following: <INPUT TYPE="RESET" VALUE="Reset the Form"> The results are shown in figure 10.7.
The <INPUT> tag also has a type that automatically submits the data that's been entered into the HTML form. The SUBMIT type accepts only the attribute VALUE, which can be used to rename the button. Otherwise, the only purpose of the Submit button is to send off all the other form information that's been entered by your user. See the following two examples (see fig. 10.8):
Listing 10.1 scrp_frm.html Creating a Complete Form <BODY> <H2>Subscribe to CorpWorld</H2> <P>Interested in receiving daily email updates of all the latest exploits of BigCorp? Well, now you can. And, best of all, it's free! Just fill out this form and submit it by clicking the "Send it In" button. We'll put you on our mailing list, and you'll receive your first email in 3-5 days.</P> <FORM METHOD="Send" ACTION="http://www.fakecorp.com/cgi-bin/subscribe"> Please complete all of the following:<BR> First Name: <INPUT TYPE="Text" Name="first" SIZE="25" MAXLENGTH="24"><BR> Last Name: <INPUT TYPE="Text" Name="last" SIZE="35" MAXLENGTH="34"><BR> Business: <INPUT TYPE="Text" Name="business" SIZE="50" MAXLENGTH="49"><BR> We must have a correct email address to send you the newsletter:<BR> Email: <INPUT TYPE="Text" Name="email" SIZE="50" MAXLENGTH="49"><BR> How did you hear about BigCorp's email letter?<BR> <INPUT TYPE="RADIO" NAME="hear" VALUE="web" CHECKED>Here on the Web <INPUT TYPE="RADIO" NAME="hear" VALUE="mag">In a magazine <INPUT TYPE="RADIO" NAME="hear"
Notice that, for text type <INPUT> boxes, the MAXLENGTH is one less than the size of the box. This tends to look a little better, but choosing the size is up to you. Figure 10.9 shows how it looks on a Web page.
Figure 10.9 : The complete form in MS Internet Explorer. Creating Pop-Up and Scrolling Menus
The last types of input that you can offer to users of your Web page revolve around the <SELECT> tag, which can be used to create different L&T Infotech Confidential Page 162 of 187
HTML &DHTML HTML Forms types of pop-up and scrolling menus. This is another element designed specifically for allowing users to make a choice-they can't enter their own text. The <SELECT> tag requires a NAME attribute and allows you to decide how many options to display at once with the SIZE attribute.
Using <SELECT> Also notice that, like <TEXTAREA>, <SELECT> is a container tag. Options are placeed between the two <SELECT> tags, each with a particular VALUE that gets associated with <SELECT>'s NAME attribute when chosen. The following is the basic format: <SELECT NAME="variable"> <OPTION SELECTED VALUE="value"> Menu text <OPTION VALUE="value"> Menu text ... </SELECT> The attribute SELECTED is simply designed to show which value will be the default in the menu listing. value can be anything you want to pass on to the Web server and associated script for processing. An example might be: Choose your favorite food: <SELECT NAME="food"> <OPTION SELECTED VALUE="ital"> Italian <OPTION VALUE="texm"> TexMex <OPTION VALUE="stek"> SteakHouse <OPTION VALUE="chin"> Chinese </SELECT> You can also use the SIZE attribute to decide to display the menu in its entirety, by simply changing the first line of the example to the following: <SELECT NAME="food" SIZE="4"> Both examples are shown in figure 10.10.
Figure 10.11 : A <SELECT> menu can allow multiple choices. What type of cars does your family own (select as many as apply)? <SELECT NAME="cars" MULTIPLE> <OPTION VALUE="sedan"> Sedan <OPTION VALUE="coupe"> Coupe <OPTION VALUE="mivan"> Minivan <OPTION VALUE="covan"> Conversion Van <OPTION VALUE="statn"> Stationwagon <OPTION VALUE="sport"> SUV (4x4) <OPTION VALUE="truck"> Other Truck </SELECT>
ALIGN. The ALIGN attribute is used to determine where the chart will appear relative to the browser window. Valid values are ALIGN=LEFT and ALIGN=RIGHT. As an added bonus, text will wrap around the table (if it's narrow enough) when the ALIGN=LEFT or ALIGN=RIGHT attributes are used. WIDTH. The WIDTH attribute sets the relative or absolute width of your table in the browser window. Values can be either percentages, as in WIDTH="50%", or absolute values. With absolute values, you must also include a suffix that defines the units used, as in px for pixels or in for inches (e.g., WIDTH="3.5in"). Absolute values for table widths are discouraged, though. COLS. The COLS attribute specifies the number of columns in your table, allowing the browser to draw the table as it downloads. BORDER. The BORDER attribute defines the width of the border surrounding the table. Default value is 1 (pixel). CELLSPACING. The CELLSPACING attribute tells the browser how much space to include between the walls of the table and between individual cells. (Value is a number in pixels.) CELLPADDING. The CELLPADDING attribute tells the browser how much space to give data elements away from the walls of the cell. (Value is a number in pixels.)
It is definitely not necessary to use all of these attributes for your table-in fact, the simple table example earlier didn't use any of them. Often, ho wever, they will come in handy. Example: Playing with Table Attributes This is another fairly freeform example. Let's look at the difference between a plain table and a table embellished with a few attributes. Insert Listing 11.1 in a new HTML document. Listing 11.1 badtable.html Creating a Plain Table <BODY> <H2> BigCorp's Computer Systems </H2> <P>We use only the highest quality components and software for all of our Wintel computer systems. Plus, if you don't see a configuration you like, call (or email) and let us know. We'll custom build to please!</P> <TABLE> <CAPTION>BigCorp's Computer Systems and Specifications</CAPTION> <TR><TH>System 486</TH><TH>System 586</TH><TH>System 686</TH>
Last time we tried a simple table, it communicated its data well. But this one is fairly ineffective, with everything lined up so poorly. Using just the attributes only mentioned, though, you can change this table so that it looks better to the user and is easier to read. All that needs to change is the first <TABLE> tag: <TABLE BORDER ALIGN="LEFT" CELLSPACING="3" CELLPADDING="3"> That makes for a much nicer looking table, complete with borders and lines for cells, and a comfortable amount of spacing to separate cell data elements from one another (see fig. 11.2).
Figure 11.2: Look how nice the table looks with spacing and borders.
The <CAPTION> tag is a container for reasons that may be obvious-it allows you to nest other HTML tags within the description. For instance: <CAPTION><B>Table 3.1 from the book <I>Life in El Salvador</I></B></CAPTION> Just about any sort of markup tags are possible inside the <CAPTION> tags, although some-like list tags-wouldn't make much sense. The <CAPTION> tag has one attribute, ALIGN. ALIGN="TOP" and ALIGN="BOTTOM" are encouraged. By default, text is also aligned to center (horizontally). By TOP and BOTTOM, I'm referring to the entire table; the caption will default to the top of the table if not otherwise specified. To align the caption to BOTTOM, for instance, enter the following: <CAPTION ALIGN="BOTTOM">Table of Common Foods</CAPTION> The <CAPTION> tag is commonly the first tag just inside the <TABLE> tag (although this placement is not required). Regardless of where you place the <CAPTION> tag, however, you must use ALIGN to force it to the bottom of the table. Otherwise, it will appear at the top, according to its default. Let's create an entire table and use the ALIGN attribute to the <CAPTION> tag to force the caption to the bottom, like this: <BODY> <H3>Favorite Ice Cream Flavors</H2> <TABLE BORDER> <CAPTION ALIGN="BOTTOM">Data from the <I>New Jersey Times</I></CAPTION> <TR><TH>Date</TH><TH>Chocolate</TH><TH>Vanilla</TH> <TR><TH>1970</TH><TD>50%</TD><TD>50%</TD> <TR><TH>1980</TH><TD>76%</TD><TD>24%</TD> <TR><TH>1990</TH><TD>40%</TD><TD>60%</TD> </TABLE> </BODY> When the browser interprets this table, it should place the caption at the bottom of the table, centered horizontally (see fig. 11.3).
Figure 11.3: You can align the caption to BOTTOM. Table Rows Table rows (<TR>) can accept one attribute you should concern yourself with-ALIGN. The ALIGN attribute is used to determine how text will appear (horizontally) in each of the rows data cells. For instance: <TR ALIGN="CENTER"><TH>Date</TH><TH>Chocolate</TH><TH>Vani lla</TH> <TR ALIGN="CENTER"><TH>1970</TH><TD>50%</TD><TD>50%</TD> <TR ALIGN="CENTER"><TH>1980</TH><TD>76%</TD><TD>24%</TD> <TR ALIGN="CENTER"><TH>1990</TH><TD>40%</TD><TD>60%</TD> Here, I've added the ALIGN attribute (with a value of CENTER) to the rows in the previous example. Notice now that all cells center data horizontally (see fig. 11.4). This ALIGN attribute can also accept LEFT and RIGHT.
Figure 11.4: This uses the ALIGN attribute with <TR>. (Compare this to figure 11.3) Note: HTML 4.0 also supports another useful attribute, VALIGN, which accepts the values TOP, BOTTOM, and CENTER. Using this attribute, you can choose to align cells vertically as well as horizontally. Until they support VALIGN, non-HTML 4.0 browsers should ignore VALIGN. Unfortunately, those are currently the most popular browsers!
application/x-oleobject OLE object Table 12.1 Some MIME-Style Data Types for the <INSERT> Tag MIME-style data types for newer multimedia formats (especially vendor-specific ones like Macromedia Director) will generally be in the form of application/x-datatype. More often than not, these are the types you'll use for the <INSERT> tag, since these are the data types used for browser plug-ins. <INSERT>'s Attributes Aside from DATA and TYPE, <INSERT> can also accept the attributes ALIGN, WIDTH, HEIGHT, and BORDER. Its format is as follows: <INSERT ALIGN="direction"> ALIGN works much as it does with <IMG>. The values possible for ALIGN are shown in Table 12.2. Notice that some of these values (LEFT, CENTER, MIDDLE) cause <INSERT> to act as a separate object, while the others assume the inserted multimedia object is supposed to be inline with the text of the document. You may recall that this is almost identical to what you learned about <IMG> at the beginning of this chapter. Value LEFT RIGHT CENTER TEXTTOP MIDDLE Acts as Object Object Object Inline Inline How Object is Aligned With left border and allows text wrap With right border and allows text wrap Between browser allows text wrap borders and
Top vertically aligned with top of text's font Middle vertically aligned with
Table 12.2 Values for the <INSERT ALIGN> Attribute WIDTH and HEIGHT accept numbers and unit suffixes (like px for pixels and in for inches). These two attributes are used to define the size of the object for faster downloading. Some browsers will also resize objects according to these attributes, so that you might expand a smaller inline movie's object with WIDTH and HEIGHT, for instance, to save on downloading time. WIDTH and HEIGHT take the following format: <INSERT WIDTH="#units" WIDTH="#units"> The last parameter is BORDER, which has a default value of 1. The border will generally only appear when the entire <INSERT> object in enclosed in an anchor tag, as in the following example: <A HREF="intro.html"><INSERT DATA="intro.moov" TYPE="video/quicktime" ALIGN="LEFT" WIDTH="3in" HEIGHT="2in" BORDER="2"> </INSERT></A> Using <PARAM> and <IMG> with <INSERT> Two of the most common tags you'll want to use with the <INSERT> tag are the <PARAM> and <IMG> tags. The <IMG> tag is used just as it has been elsewhere except it's only displayed when the browser isn't able to deal with the type of multimedia file that the <INSERT> tag is trying to send. For instance, if you were sending a Macromedia Director multimedia file from your Web pages, but the receiving browser wasn't able to deal with it, the <INSERT> tag would substitute the <IMG> you'd specified instead. The <PARAM> tag is used to offer additional parameters to the <INSERT> tag information like how many times to play a movie clip. The <PARAM> tag takes elements NAME and VALUE, which work a little like they do for certain table tags. Unfortunately, each different type of multimedia file will require different NAME and VALUE values, so you'll have to seek those out from the creator of the particular object type you're wanting to send. Here's an example of the <PARAM> tag: <INSERT DATA="ship.avi" TYPE="application/avi"> <PARAM NAME="loop" VALUE="infinite"> </INSERT> The <IMG> tag is used within an <INSERT> definition in the same way that it is used elsewhere, except that the ALIGN attribute isn't really necessary since the <IMG> will only be used to directly replace the inserted multimedia object. You can add the <IMG> like this:
Figure 13.1 : A simple frames interface Using frames in this way takes you one step closer to the ideal Web interface, because it makes it as intuitive and universal as possible.
Table of Contents (TOC). By placing the TOC in a "column" on your Web page, people can click around your site or your documentation pages without being forced to constantly move "back" to the contents page. Instead, users simply click a new content level in the static frame. Fixed interface elements. As mentioned previously, you can force clickable graphics, logos, and other information to stay in one fixed portion of the screen, while the rest of your document scrolls in another frame. Better forms and results. Frames also enable you to create a form in one frame and offer results in another frame. This is something we're beginning to see extensively with Web search pages (look to fig. 13.2). With the search text box always available, you're free to change search phrases or pinpoint your search more quickly, without moving back in the hierarchy of the Web pages.
Creating Frames Probably most unique among the HTML-style tags so far is the <FRAMESET> tag. This container is required for frames-style pages-but it also replaces the <BODY> tag completely on these pages. When you use frames then, you're committed to using them completely-you can't just add frames to part of your page. On a typical page, <FRAMESET> is added like this: <HTML> <HEAD> ...HEAD markup... </HEAD> <FRAMESET> ...Frames and other HTML markup... </FRAMESET> </HTML> The <FRAMESET> tag can accept two attributes: ROWS and COLS. Both attributes accept either numerical values (size in pixels), percentages, or a combination of both. The value * can also be used to suggest that a particular row or column should take up the rest of the page. The number of rows or columns is suggested by the number of values you give the attribute. These attributes take the following format: <FRAMESET ROWS="numbers,percentages,*" COLS="numbers,percentages, *"> An example like the following would create two rows: one 50 pixels long and another row that took up the rest of the page: <FRAMESET ROWS="50,*"> (This would be useful for a page that displays a fixed map or graphic at the top.) The following example would create a Web interface with two columns: one on the leftmost 25 percent of the screen and one on the other 75 percent:
Figure 13.3 : The logical breaks created by nested <FRAMESET> tags. The <FRAME> Tag The <FRAME> tag is used within the <FRAMESET> container to determine what will actually appear in a particular frame. Each <FRAME> tag is an empty tag-and it's not unlike the <LI> tags
Figure 13.4 : The <FRAME> tag assigns URLs to each frame window. <FRAMESET ROWS="50%,50%"> <FRAME SRC="index.html"> <FRAME SRC="help.html"> </FRAMESET> By using the <FRAME> tag, you create what's known as a frame window. Each window corresponds to a "row" or "column" definition in the <FRAMESET> tag, but nothing is drawn or displayed until an appropriate <FRAME> tag is used to define each individual window.
Figure 13.6 : The <NOFRAME> HTML message Targeting Frame Windows So far, you've seen that frame windows offer you the ability to load URLs independent of one another, so that you can present two (or more) different HTML pages in the same browser window. But what good is this to you? In many cases, it may be useful to offer multiple documents at once. For instance, with what you know now, you could use frames to add a button bar image map to the top of every HTML page you create. But that would get tedious-each link would have to point to a new frame document that would then load the button bar and the next document. But what if you could just leave the button bar in the top frame window and load a new document in the other window? You can do just that, if you know a little about targeting. The NAME Attribute First, you need to name your frame windows-at least, you have to name the windows you might want to change. This is accomplished with the NAME attribute to the <FRAME> tag, which takes the following format: <FRAME SRC="original URL" NAME="window_name"> This shouldn't look too foreign to you, as it's a little like the way that the NAME attribute works for <A NAME> links. Once the frame window has a distinct name, you can access it directly from other frame windows. An example of this is the following: <FRAME SRC="index.html" NAME="main_viewer"> Although you can pretty much name your frame window anything you want, there is one restriction: you can't start the name with an underscore character (_). If you do, the name will be ignored. But, there's a good reason for that.
Likewise, you can add a TARGET attribute to the <FORM> tag. Remember that it's the <FORM> container tag that tells the browser the URL for the script that is required to process the form data. In that same tag, you can also specify a target window for the results that are received from the server. If you want users to be able to use your form repeatedly (to allow them to generate different results), you can leave both the form and the results in separate frames. This attribute takes the following format: <FORM ACTION="Script_URL" TARGET="window_name">
<BASE> Targets
The last example you went through (Listing 20.4) would have been a great candidate for this one type of target. What if you want the majority of your links to point to a particular frame window? In the early example, you created a file called control2.html that had nothing but hypertext links. Each one of those links required a TARGET attribute that pointed to the big_window. You could have made that easier with a <BASE> tag in the head of your document. Use this format: <HEAD> <BASE TARGET="window_name"> </HEAD> A good example of this for the previous example would be:
TARGET="_blank"-The URL specified in this link will always be loaded in a new blank browser window. TARGET="_self"-This is used for overriding a <BASE> tag, and forcing a link to load in the same window that it's clicked in. TARGET="_parent"-This causes the document to load in the current window's parentgenerally, the frame window immediately preceding in the <FRAMESET> definition. If no parent exists, it acts like "_self". TARGET="_top"-The document is loaded in the topmost frame of the current browser window.
Basically, these magic targets are designed to let you break out of the current <FRAMESET> structure in some way. Experiment with them to see how you can move around to different windows. The Elegant Frame Interface Let's use three different frame windows. One will hold a client-side graphic for your site, one will offer a "table of contents" page, and one will display the actual information for your site. You'll need a fixed window for the client-side map and two dynamic windows. One will load the parts of the table of contents, and one will load the information pages. Use Listing 13.2 for the client-side map. Listing 13.2 control3.html HTML for a Client-Side Map <HTML> <HEAD> <TITLE>Control Map</TITLE> <BASE TARGET="toc_window"> </HEAD> <BODY> <DIV ALIGN="CENTER"> <IMG SRC="control.gif" USEMAP="#control"> </DIV>
Figure 13.3: A three way interface is attractive, but it can be tough to manage. Note : For this example to work well, you may need to create some other files like index_toc.html, or rename files to work in your main window.