<p>This is a paragraph that includes an instance of the <code>happy</code> tag (<happy>Joe</happy>).</p>
Because render_contents is set to "false" in the tag specification, the contents of the happy tag (the word Joe) are not rendered. Instead, the start and end tags and their contents appear as a single icon. For nonempty tags that have a render_contents value of "true", the icon does not appear in the Design view; instead, the content between the opening and closing tags (such as the text between the tags in <mytag>This is the content between the opening and closing tags</mytag>) appears. If View > Invisible Elements is enabled, the content is highlighted using the third-party tag color specified in Highlighting preferences. (Highlighting applies only to tags defined in tag database files.)
To change the highlighting color of third-party tags:
Select Edit > Preferences, and select the Highlighting category. Click the Third-Party Tags color box to display the color picker. Select a color, and click OK to close the Preferences dialog box. For information about selecting a color, see Using Dreamweaver.
Avoiding rewriting third-party tags
Dreamweaver corrects certain kinds of errors in HTML code. For details, see Using Dreamweaver. By default, Dreamweaver refrains from changing HTML in files with certain filename extensions, including.asp (ASP),.cfm (ColdFusion),.jsp (JSP), and.php (PHP). This default is set so that Dreamweaver does not accidentally modify the code contained in any such non-HTML tags. You can change the Dreamweaver default rewriting behavior so that it rewrites HTML when it opens such files, and you can add other file types to the list of types that Dreamweaver does not rewrite. Dreamweaver encodes certain special characters by replacing them with numerical values when you enter them in the Property inspector. Its usually best to let Dreamweaver perform this encoding because the special characters are more likely to display correctly across platforms and browsers. However, because such encoding can interfere with third-party tags, you may want to change the Dreamweaver encoding behavior when youre working with files that contain third-party tags.
To allow Dreamweaver to rewrite HTML in more kinds of files:
Select Edit > Preferences, and select the Code Rewriting category. Select either of the following options:

<ignoreMMTParams>No</ignoreMMTParams>

<ignoreTags>

Specifies whether markup tags should be ignored. Values are Yes and No; the default is Yes. Set to No when syntax is for tag markup language that is delimited by < and >. Set to Yes when syntax is for a programming language.
<ignoreTags>No</ignoreTags>

<isLocked>

Specifies whether the text that is matched by this scheme is locked from being edited in the Code view. Values are Yes and No. Default is No.
<isLocked>Yes</isLocked>

<keyword>

A string of text that defines a keyword. Multiple keyword tags are allowed. A keyword may start with any character, but subsequent characters may only be a-z, A-Z, 0-9, _, $, or @. The code color is specified by the containing keyword tags.
<keyword>.getdate</keyword>

<keywords>

List of keywords for type specified in category attribute. Multiple keywords tags are allowed.
name="keywords_name" id="id_string"
A string that assigns a name to the list of keywords.
<keyword></keyword>
<keywords name="Reserved Keywords" id="CodeColor_JavascriptReserved"> <keyword>break</keyword> <keyword>case</keyword> </keywords>

<numbers/>

An empty tag that specifies numbers that should be recognized and also holds color attributes.
name="number_name" id="id_string"
A string that assigns a name to the numbers tag.
<numbers name="Number" id="CodeColor_CFScriptNumber" />

<operators>

A list of characters to be recognized as operators.
name="operator_name" id="id_string"
A string that assigns a name to the list of operator characters.
<operators name="Operator" id="CodeColor_JavaOperator"><![CDATA[+-*/ %<>!?:=&|^~]]></operators>

<regexp>

Specifies a list of searchPattern tags.
name, id, delimiter, escape
name="stringStart_name"
A string that assigns a name to the list of search pattern

strings.

delimiter
The character or string that starts and ends a regular expression.
escape The character or string that signals special character processing, known as the escape character or string.

Designing an extension user interface
Typically, you create an extension to perform a task that users encounter frequently. Certain parts of the task are repetitive; by creating an extension, you can automate the repetitive actions. Some steps in the task can change, or specific attributes of the code that the extension processes can change. To receive user inputs for these variable values, you build a UI. For example, you might create an extension to update a web catalog. Users periodically need to change values for image sources, item descriptions, and prices. Although the values change, the procedures for getting these values and formatting the information for display on the website remain the same. A simple extension can automate the formatting while letting users manually input the new, updated values for image sources, item descriptions, and prices. A more robust extension can retrieve these values periodically from a database. The purpose of your extension UI is to receive information that the user inputs. This information handles the variable aspects of a repetitive task that the extension performs. Dreamweaver supports HTML and JavaScript form elements as the basic building blocks for creating extension UI controls and displays the UI using its own HTML renderer. Therefore, an extension UI can be as simple as an HTML file that contains a two-column table with text descriptions and form input fields.
When you design an extension, you should determine what variables are necessary and what form elements can best handle them. Consider the following basic guidelines when you design an extension UI:
To name your extension, place the name in the title tag of your HTML file. Dreamweaver displays the name in the extension title bar. Keep text labels on the left side of your UI, aligned right, with text boxes on the right side, aligned left. This arrangement lets the users eyes easily locate the beginning of any text box. Minimal text can follow the text box as explanation or units of measure. Keep checkbox and radio button labels on the right side of your UI, aligned left. For readable code, assign logical names to your text boxes. If you use Dreamweaver to create your extension UI, you can use the Property inspector or the Quick Tag Editor to assign names to the fields.
In a typical scenario, after you create the UI, you test the extension code to see that it properly performs the following UI-related tasks:
Getting the values from the text boxes Setting default values for the text boxes or gathering values from the selection Applying changes to the user document

<html> <head> <title>Editable Dropdown Test</title> <script language="javascript"> function getAlert() { var i=document.myForm.mySelect.selectedIndex; if (i>=0) { alert("Selected index: " + i + "\n" + "Selected text " + document.myForm.mySelect.options[i].text); } else { alert("Nothing is selected" + "\n" + "or you entered a value"); } } function commandButtons() { return new Array("OK", "getAlert()", "Cancel", "window.close()"); } </script> </head> <body> <div name="test"> <form name="myForm"> <table> <tr> <td colspan="2"> <h4>Select your favorite</h4> </td> </tr> <tr> <td>Sport:</td> <td> <select name="mySelect" editable="true" style="width:150px" editText="Editable Text"> <option> Baseball</option> <option> Football </option> <option> Soccer </option>
</select> </td> </tr> </table> </form> </div> </body> </html> 3.
Save the file as EditableSelectTest.htm in the Dreamweaver Configuration/Commands folder.

To test the example:

Restart Dreamweaver. Select Commands > EditableSelectTest. When you select a value from the list, an alert message displays the index of the value and the text. If you enter a value, an alert message indicates that nothing is selected.

Database controls

Using Dreamweaver, you can extend the HTML select tag to create a database tree control. You can also add a variable grid control. The database tree control displays database schema, and the variable grid control displays tabular information.
The following figure shows an advanced Recordset dialog box that uses a database tree control and a variable grid control:
Adding a database tree control
The database tree control has the following attributes:
name control.style type connection

function canAcceptCommand() { var selarray; if (arguments.length != 1) return false; var bResult = false; var whatToDo = arguments[0]; if (whatToDo == "undo") { bResult = dw.canUndo(); } else if (whatToDo == "redo") { bResult = dw.canRedo(); } return bResult; }
Dreamweaver calls the receiveArguments() function to process any arguments that you defined for the menuitem tag. For the Undo and Redo menu items, the receiveArguments() function calls either the dw.undo() function or the dw.redo() function, depending on whether the value of the argument, arguments[0], is "undo" or "redo". The dw.undo() function undoes the previous step that the user performed in the document window, dialog box, or panel that has focus. The dw.redo() function redoes the last operation that was undone. The receiveArguments() function looks like the following example code:
function receiveArguments() { if (arguments.length != 1) return; var whatToDo = arguments[0]; if (whatToDo == "undo") { dw.undo(); } else if (whatToDo == "redo") { dw.redo(); } }
In this command, the receiveArguments() function processes the arguments and executes the command. More complex menu commands might call different functions to execute the command. For example, the following code checks whether the first argument is "foo"; if it is, it calls the doOperationX() function and passes it the second argument. If the first argument is "bar", it calls the doOperationY() function and passes it the second argument. The doOperationX() or doOperationY() function is responsible for executing the command.
function receiveArguments(){ if (arguments.length != 2) return; var whatToDo = arguments[0]; if (whatToDo == "foo"){ doOperationX(arguments[1]); }else if (whatToDo == "bar"){ doOperationX(arguments[1]); } }

setMenuText()

Dreamweaver calls the setMenuText() function to determine what text appears for the menu item. If you do not define the setMenuText() function, Dreamweaver uses the text that you specified in the name attribute of the menuitem tag. The setMenuText() function checks the value of the argument that Dreamweaver passes, arguments[0]. If the value of the argument is "undo", Dreamweaver calls the dw.getUndoText() function; if it is "redo", Dreamweaver calls dw.getRedoText(). The dw.getUndoText() function returns text that specifies the operation that Dreamweaver will undo. For example, if the user executes multiple Redo operations, dw.getUndoText() could return the menu text Undo Edit Source. Likewise, the dw.getRedoText() function returns text that specifies the operation that Dreamweaver will redo. If the user executes multiple Undo operations, the dw.RedoText() function could return the menu text Redo Edit Source.

<?xml version="1.0"?> <!DOCTYPE toolbarset SYSTEM "-//Macromedia//DWExtension toolbar 5.0"> <toolbarset>
<!-- main toolbar --> <toolbar id="DW_Toolbar_Main" label="Document"> <radiobutton id="DW_CodeView"./> <radiobutton id="DW_SplitView"./> <radiobutton id="DW_DesignView"./> <separator/> <checkbutton id="DW_LiveDebug"./> <checkbutton id="DW_LiveDataView"./> <separator/> <editcontrol id="DW_SetTitle"./> <menubutton id="DW_FileTransfer"./> <menubutton id="DW_Preview"./> <separator/> <button id="DW_DocRefresh"./> <button id="DW_Reference"./> <menubutton id="DW_CodeNav"./> <menubutton id="DW_ViewOptions"./> </toolbar> </toolbarset>
The following section describes each of the toolbar tags.

<toolbar>

Defines a toolbar. Dreamweaver displays the items and separators from left to right in the specified order, laying out the items automatically. The toolbar file does not specify control over the spacing between the items, but you can specify the widths of certain kinds of items.
id, label, {container}, {initiallyVisible}, {initialPosition}, {relativeTo}

id="unique_id"

Required. An identifier string must be unique within a file and within all files that the file includes. The JavaScript API functions that manipulate a toolbar refer to it by its ID. For more information on these functions, see the Dreamweaver API Reference. If two toolbars that are included in the same file have the same ID, Dreamweaver displays an error.
label="string" Required. The label attribute specifies the label, which is a character string, that Dreamweaver displays to the user. The label appears in the View >Toolbars menu and in the title bar of the toolbar when its floating.
or "document" Defaults to "mainframe". Specifies where the toolbar should dock in the Dreamweaver workspace on Windows. If the container is set to "mainframe", the toolbar appears in the outer workspace frame and operates on the front document. If the container is set to "document", the toolbar appears in each document window. On the Macintosh, all toolbars appear in each document window.

The toolbar command API

In many cases where you specify a script for an attribute, you can also implement the attribute through a JavaScript function in a command file. This action is necessary when the functions need to take arguments, as in the command handler for a text box. It is required for pop-up menus and combo boxes. The command file API for toolbar items is an extension of the menu command file API, so you can reuse menu command files directly as toolbar command files, perhaps with some additional functions that are specific to toolbars.
Determines whether the toolbar item is enabled. The enabled state is the default condition for an item, so you should not define this function unless it returns a false value in at least one case.
For pop-up menus, combo boxes, text boxes, and color pickers, the first argument is the current value within the control. The getDynamicContent() function can optionally attach individual IDs to items within a pop-up menu. If the selected item in the pop-up menu has an ID attached, Dreamweaver passes that ID to canAcceptCommand() instead of the value. For combo boxes, if the current contents of the text box do not match an entry in the pop-up menu, Dreamweaver passes the contents of the text box. Dreamweaver compares against the pop-up menu without case-sensitivity to determine whether the contents of the text box match an entry in the list. If you specify the arguments attribute for this toolbar item in the toolbars.xml file, those arguments are passed next. If you did not specify the arguments attribute, Dreamweaver passes the ID of the item.
Dreamweaver expects a Boolean value; true if the item is enabled; false otherwise.
function canAcceptCommand() { return (dw.getDocumentDOM() != null); }

getCurrentValue()

Returns the current value to display in the item. Dreamweaver calls the getCurrentValue() function for pop-up menus, combo boxes, text boxes, and color pickers. For pop-up menus, the current value should be one of the items in the menu. If the value is not in the pop-up menu, Dreamweaver selects the first item. For combo boxes and text boxes, this value can be any string that the function returns. For color pickers, the value should be a valid color, but Dreamweaver does not enforce this. This function is equivalent to the value attribute.
Dreamweaver expects a string that contains the current value to display. For the color picker, the string contains the RGB form of the selected color (for example #FFFFFF for the color white).
This function is required for pop-up menus and combo boxes. As with menus, this function returns an array of strings that populate the pop-up menu. Each string can optionally end with ";id=id". If an ID is specified, Dreamweaver passes the ID to the receiveArguments() function instead of the actual string to appear in the menu.

commandname.js

How stand-alone reports work
The custom command, which is the command you create to generate the report, opens a new results window by calling the dw.createResultsWindow() function and storing the returned results object in a window variable. The remaining functions in this process should be called as methods of this object. The custom command initializes the title and format of the Results window by calling the setTitle() and SetColumnWidths() functions as methods of the Results window object. The command can either start adding items to the Results window immediately by calling the addItem() function, or it can begin iterating through a list of files by calling the setFileList() and startProcessing() functions as methods of the Results window object. When the command calls resWin.startProcessing(), Dreamweaver calls the processFile() function for each file URL in the list. Define the processFile() function in the stand-alone command. It receives the file URL as its only argument. Use the setCallbackCommands() function of the Results window object if you want Dreamweaver to call the processFile() function in some other command.
To call the addItem() function, the processFile() function needs to have access to the Results window that was created by the stand-alone command. The processFile() function can also call the stopProcessing() function of the Results window object to stop processing the list of files.
A simple stand-alone report example
The simple stand-alone report extension lists all the images referenced in a particular file and displays the report in the Results window. You create this extension by performing the following steps:
Creating the dialog box UI Writing the JavaScript code
This example creates two files in the Configuration/Commands folder: List images.htm which defines the UI of the dialog box that appears when the user selects the custom command, and Listimages.js, which contains the JavaScript code specific to this report.
Creating the dialog box UI
The BODY of the HTML file specifies the contents of the dialog box that appears when the user selects the custom command and calls any JavaScript files required.
Create the Configuration/Commands/Listimages.htm file. Enter the following in the Listimages.htm file:
<html> <head> <title>Standalone report example</title> <script src=Listimages.js> </script> </head> <body> <div name="test"> <form name="myForm"> <table> <tr> <td>Click OK to display the standalone report.</td> </tr> </table> </form> </div> </body>

Defining the new server behavior
Next, you define the new server behavior.
To use the Server Behavior Builder to define your new server behavior:
If the Server Behaviors panel is not open and visible, select the Window > Server Behaviors menu option.
In the Server Behaviors panel, select the Plus (+) button, and then select the New Server Behavior menu option. In the New Server Behavior dialog box, select Document Type: ASP JavaScript and Name: Hello World (Leave the Copy existing server behavior checkbox unchecked.) Click OK.
Defining the code to insert
Finally, you define the code to insert.
To define the code to insert:
Select the Plus (+) button for Code Blocks to Insert. In the Create a New Code Block dialog box, enter Hello_World_block1 (Dreamweaver might automatically enter this information for you). Click OK. In the Code Block text field, enter <% Response.Write(Hello World) %>. In the Insert Code pop-up menu, select Relative to the Selection so the user can control where this code goes in the document.
In the Relative Position pop-up menu, select After the Selection. Click OK.
In the Server Behaviors panel, you can see that the Plus (+) menu contains the new server behavior in the pop-up list. Also, in the installation folder for your Dreamweaver files, the Configuration/ServerBehaviors/ASP_Js folder now contains the following three files:
The group file: Hello World.edml The participant file: Hello World_block1.edml A script file: Hello World.htm
If you are working in a multiuser configuration, these files appear in your Application Data folder.
How the Server Behavior API functions are called
The Server Behavior API functions are called in the following scenarios:
The findServerBehaviors() function is called when the document opens and again when the participant is edited. It searches the users document for instances of the server behavior. For each instance it finds, the findServerBehaviors() function creates a JavaScript object, and uses JavaScript properties to attach state information to the object. If it is implemented, Dreamweaver calls the analyzeServerBehavior() function for each behavior instance that is found in the users document after all the findServerBehaviors() functions are called. When the findServerBehaviors() function creates a behavior object, it usually sets the four properties (incomplete, participants, selectedNode, and title). However, it is sometimes easier to delay setting some of the properties until all the other server behaviors find instances of themselves. For example, the Move To Next Record behavior has two participants; a link object and a recordset object. Rather than finding the recordset object in its findServerBehaviors() function, wait until the recordset behaviors findServerBehaviors() function runs because the recordset finds all instances of itself. When the Move To Next Record behaviors analyzeServerBehavior() function is called, it gets an array that contains all the server behavior objects in the document. The function can look through the array for its recordset object.

Participant EDML files 355
The parameter names should match the ones that are specified in the insertion text and the update parameters.

searchPattern

paramName1, paramName2,
Each parameter name should be the exact name of a parameter that is used in the insertion text. For example, if the insertion text contains @@p1@@, you should define exactly one parameter with that name:
<searchPattern paramNames="p1">patterns</searchPattern>
To extract multiple parameters using a single pattern, use a comma-separated list of parameter names, in the order that the subexpressions appear in the pattern. Suppose the following example shows your search pattern:
<searchPattern paramName="p1,,p2">/(\w+)_(BIG|SMALL)_(\w+)/ </searchPattern>
There are two parameters (with some text in between them) to extract. Given the text: <%= a_BIG_b %>, the first subexpression in the search pattern matches "a", so p1="a". The second subexpression is ignored (note the ,, in the paramName value). The third subexpression matches "b", so p2="b".

limitSearch

This attribute limits the search to some part of the whereToSearch tag.
all, attribute+attribName, tagOnly, innerOnly
The all value (default) searches the entire tag that is specified in the whereToSearch attribute. The attribute+attribName value searches only within the value of the specified attribute, as shown in the following example:
<searchPatterns whereToSearch="tag+FORM"> <searchPattern limitSearch="attribute+ACTION"> /MY_PATTERN/ </searchPattern> </searchPatterns>
This example indicates that only the value of the ACTION attribute of FORM tags should be searched. If that attribute is not defined, the tag is ignored.
The tagOnly value searches only the outer tag and ignores the innerHTML tag. This value is valid only if whereToSearch is a tag. The innerOnly value searches only the innerHTML tag and ignores the outer tag. This value is valid only if whereToSearch is a tag.

isOptional

This attribute is a flag that indicates that the search pattern is not required to find the participant. This is useful for complex participants that might have non-critical parameters to extract. You can create some patterns for distinctly identifying a participant and have some optional patterns for extracting non-critical parameters.

string

The string argument is the dynamic data object.
Dreamweaver expects an array of two elements (parent name and child name) for the matched node; it returns a null value if no matches are found.

CHAPTER 17

Server Formats
Chapter 16, Data Sources, on page 379, discusses how Macromedia Dreamweaver 8 inserts dynamic data into a users document by adding a server expression at the appropriate location. When a visitor requests the document from the web server, that server expression is converted to a value from a database, the contents of a request variable, or some other dynamic value. The Dreamweaver server formats let you format how this dynamic value is presented to the visitor. This chapter discusses the API that formats the dynamic data that is returned by the functions described in Chapter 16, Data Sources, on page 379. The functions that are described in both chapters work together to format dynamic data. If the user selects a format for the dynamic data, Dreamweaver calls the data source function generateDynamicDataRef(), see generateDynamicDataRef() on page 394, to get the string to insert into the users document. Before inserting the string into the users document, Dreamweaver passes that string to the formatDynamicDataRef() function, which is described in this chapter. The string that the formatDynamicDataRef() function returns is the formatted dynamic data that is finally inserted in the users document. Dreamweaver users can format data with built-in formats, create new formats that are based on built-in format types, or create new formats that are based on custom format types. The user can format dynamic data in several ways. By using the Format menu in the Dynamic Data or the Dynamic Text dialog box or in the Bindings panel, the user can format the data before inserting it into an HTML document. If the user wants to create a format, he or she can select the Edit Format List command from the Format menu and select a format type from the Plus (+) menu. The Plus (+) menu contains a list of format types. Format types are basic format categories, such as Currency, DateTime, or AlphaCase. Format types collect all the common parameters for a category of format, letting you streamline the work to create a new format.
One example might be to create a new currency format. Essentially, all currency formatting consists of converting a number to a string, inserting commas and decimal points, and inserting a currency symbol, such as a dollar ($) sign. The Currency format data type collects all the common parameters and prompts you for the required values.
How data formatting works
All format files reside in the Configuration/ServerFormats/currentServerModel folder. Each subfolder contains one XML file and multiple HTML files. The Formats.xml file describes all the choices in the Format menu. Dreamweaver automatically adds the Edit Format List and None options. The folder also contains one HTML file for each currently installed format type, which includes AlphaCase, Currency, DateTime, Math, Number, Percent, Simple, and Trim.

Later, if the user edits the format by selecting it in the Edit Format List dialog box and clicking the Edit button, Dreamweaver calls the inspectFormatDefinition() function before the Parameters dialog box appears, so the form controls can be initialized to the correct values.

The Server Formats API

The server formats API consists of the following data formatting functions.

applyFormat()

This function can edit a users document by adding a format function declaration to it. When a user selects a format from the Format text field in the Dynamic Data or the Dynamic Text dialog box or in the Bindings panel, Dreamweaver makes two changes to the users document: It adds the appropriate format function before the HTML tag (if its not already there), and it changes the dynamic data object to call the appropriate format function. Dreamweaver adds the function declaration by calling the applyFormat() JavaScript function in the data format file. It changes the dynamic data object by calling the formatDynamicDataRef() function. The applyFormat() function should use the DOM to add function declarations to the top of the users document. For example, if the user selects Currency - Default, the function adds the Currency function declaration.

format

The format argument is a JavaScript object that describes the format to apply. The JavaScript object is the node that corresponds to the format tag in the Formats.xml file. The object has a JavaScript property for each attribute of the corresponding format tag.

applyFormatDefinition()

Commits the changes to a format that was created using the Edit Format dialog box. Users can create, edit, or delete formats with the Edit Format List dialog box. This function is called to commit any modifications that are made to a format. It can also set other, arbitrarily named properties on the object. Each property is stored as an attribute of the format tag in the Formats.xml file.

ImageButtonClass.js

ListControlClass.js
PageSettingsASPNet.js RadioGroupClass.js

SBDatabaseCallClass.js

ServerBehaviorClass.js
ServerSettingsASPNet.js SQLStatementClass.js

tagDialogsCmn.js

TagEditClass.js

TreeControlClass.js

Contains functions that manage a tree control within Dreamweaver. The methods of the TreeControl object defined in this file get, set, and arrange values in a tree. You attach this class to a special MM:TREECONTROL tag in your HTML to manage the tree control functionality. Contains functions that manage the location and values of a XML property sheet.

XMLPropSheetClass.js

The MM folder
The MM folder contains the shared scripts, images, and classes used by the extensions that come with Dreamweaver, including the scripts for building a navigation bar, specifying preload calls, and the shortcut key definitions.

The Scripts folder

The Scripts subfolder contains the following utility functions:
CFCutilities.js Contains utility functions related to Macromedia ColdFusion components. Functions parse attributes from within the opening tag of a given node, parse a CFC tree, get the current URL DOM, get the CFC DOM, and more. Contains functions to register events, notify parties of events from the menus.xml file, and add event notifiers to the menus.xml file. Contains functions that update a color picker, check for hex color, check for an absolute link, add an extension to a filename, generate error messages, set Flash attributes, check a link for Flash object, and so on. Contains functions to insert Fireworks HTML code into Dreamweaver documents. Functions check whether current document is a Fireworks document, insert Fireworks HTML at insertion point, update Macromedia Fireworks style block to Dreamweaver, and more. Also contains related utility functions. Contains functions for use with the Jump Menu object and Jump Menu behavior. Functions populate menu options, create an option label, add an option, delete an option, and so on. Contains an array of keyboard key codes.

event.js

FlashObjects.js

insertFireworksHTML.js

jumpMenuUI.js

keyCodes.js

navBar.js
Contains classes and functions for working with a navigation bar and navigation bar elements. Includes functions to add, remove, and manipulate navigation bar elements. Contains functions related to navigation bar image behaviors. Defines various language codes. Contains functions for adding and deleting preload-image calls to the BODY/onLoad MM_preloadImages handler. Contains the static class and functions to display the recordset server behaviors UI. Functions determine which interface, simple or advanced, to display. Also, houses functionality shared between the UI implementations and mediates switches between the UIs. Contains shared functions for use within Macromedia server behaviors. The dwscripts class in the Configuration/Shared/ Common/Scripts folder contains more general purpose utilities. Contains functions to escape an expression string, unescape an expression string, and extract an expression string. Contains functions to initialize and sort a table as well as functions to sort an array, set the mouse pointer to a hand icon or pointer, and check the type and version of the browser.