1	File Format .aw

Anyware shares the same Applixware file formats.

This chapter describes the generic ASCII file format of all Version 4.3, 4.4 and 5.0 Applixware documents and the Applixware Words internal ASCII file format. These formats consist of statements and properties that define all of the text, graphics, formatting, and layout constructs of an Applixware document.

The following topics are described:

· An explanation of the document conventions used in this chapter.

· A description of the Version 4.3/4.4/5.0 file format for Applixware Words.

· A description of the supported Applixware Words statements and their properties.

Statement Syntax

In the following listing of statements, these conventions apply:

UPPERCASE Courier uppercase indicates an actual statement. At this point, turn to the "Statements Reference" later in this chapter to look up the exact syntax of the statement.

Example: DOCUMENT_BEGIN is a self-contained statement and may be found in the "Statements Reference."

italic Courier italic indicates a statement group.

When you reach an italic entry, look further down the list to see the statements that make up the group.

Example:

The document group outlines the overall structure of the document file. Within the document structure, the definitions entry indicates a group of statements that defines items for the entire document. Look under definitions in the left column for the statements that make up the definitions group.

{ braces } Braces indicate a required entry; that is, you must choose one of the indicated elements.

[ brackets ] Brackets indicate an optional entry, which may or may not appear in the document.

Example:

[ object_definition ]

This entry appears in the file only if one or more objects are included in the document.

... (ellipse) Any entry followed by an ellipse (...) indicates that the statement or group may be repeated any number of times.

Example:

paragraph...

This shows that the statement group can contain any number of paragraphs.

vertical | bar A vertical bar between items indicates that the document entry includes one of the options.

Example:

object_definition = OBJECT | GRAPHICS

This indicates that the object_definition section can include one of the keywords OBJECT or GRAPHICS.

File Header

The first line of the file is a header line that identifies the file as an Applixware file, specifies the encoding method and gives the Applixware version number.

The file header is:

*BEGIN¹ datatype VERSION=version [ ENCODING=encoding] [C=content] [future data elements]

The last line of the file is

*END datatype

The following defines these elements:

content = This field depends on the datatype field. It gives further information about the content of the file.

The significance of datatype is that you know how to process each of these types of contents. The data in the Applixware file is encoded to prevent accidental asterisk (*) lines from occurring. Datatype sections that are unknown to this version are skipped.

ASCII and BINARY are two different encodings for arbitrary data, such as local foreign insets in an Applixware Words application. This is used for foreign insets. ASCII provides a base level of readability in the Applixware file; however, it does not provide any more or less information than BINARY.

version = Should be 430 for a file in Release 4.3 format, 440 for a file in Release 4.4 format, or 500 (documented here). 311 was used for a file in Release 3 format.

Embedded Data

For embedded data, use *BEGIN and *END to delimit the data.

Links

For each external link in the file, a LINK statement must appear somewhere in the file to permit a simple scan for links.

*LINK pathname

Maximum Line Length

Programs that write files should write short lines (at most 80 characters) for the convenience of people using text editors. Programs that read files should be able to handle lines as long as 4090 characters. If a statement needs to be longer than the desired line length, the continuation line format is used.

Continuation Lines

An application is free to define how continuation lines are handled within its data segment. The one restriction is that the first character of a line is never an asterisk.

In Words, if a statement is longer than the standard line length (80 characters for files written by Words), it is broken into multiple lines. A backslash is added to the end of each line (except for the last line). A space is added to the start of each line after the first line. The lines are rejoined and these backslashes and spaces are discarded when Words reads the file.

NOTE: If a Words document contains embedded Applixware objects, the application that owns the object determines the continuation line format for that object.

Wide and Multi-Byte Characters

8-bit and 16-bit characters should, be default, be encoded in the output file so that the files are 8-bit clean (that is, the file contains only 7-bit characters). Such files will have the token "ENCODING=7BIT" in their *BEGIN header lines (as would Applixware objects embedded within Applixware files).

Here are the algorithms for folding 8- and 16-bit characters into 7 bits.

For both algorithms, the carat character '^' is used as an escape character to signal the start of an 8- or 16-bit character. To output a real carat character, escape it with another carat (i.e. double it). For example, given the following string in a Words document:

Here is a single carat: ^

The following line would appear in the Words file:

<Text "Here is a single carat: ^^">

8-bit characters

Assume a hexadecimal system where 'a' represents 0, 'b' is 1, ... 'p' is 15. An 8-bit character is represented as a carat character followed by a pair of these "hex letters". For example, the tab character (character code 9) is represented as "^aj", where a=0, j=9, and thus (0 * 16) + 9 = 9. The (US) cents character ("¢"), which is code 162, is represented as "^kc", where k=10, c=2, and thus (10 * 16) + 2 = 162.

Any 8-bit character larger or equal to 128, or smaller than 32 (but excluding character 10, the line break) is output in this format. Character code 10 is output as "\n". Any other character is output in its ASCII representation.

16-bit characters

For character codes less than 256, the 8-bit system is used as described above. For character codes greater than 256, a system is used where space is 0, '!' is 1, ... underscore is 63. However, the backquote (code 96) is used to represent 2 instead of the double quote. The overall representation is of the form ^XYY, where X is a 6-bit value in this system, and Y is a 5-bit value. Thus the largest possible 16-bit code (65535) would be represented as "^_??", where _=63, ?=31, and thus (63 * 1024) + (31 * 32) + 31 = 65535. The character code 256 is not used in this system.

Note there is no intersection between the codes used to represent 8-bit values (a-p) and the codes used to represent 16-bit values (space to underscore, plus back quote). Following an unescaped carat you should either see a pair of 8-bit codes or a triple of 16-bit codes.

Escape characters

An application is free to support escape characters, in addition to the carat as described above.

In a Words file, the backslash character '\' is used as an escape character within quoted strings. Backslashes and double quotes must be escaped. "\n" represents a line break.

The following table describes the supported escape sequences in quoted strings within a Words file:

Table 1-1 Escape Sequences in Quoted Strings

Appearance in File	Meaning
\\	Backslash within string
\"	Double quote within string
\n	Newline within string

Comment Lines

Lines that start with ** are comments; they have no inherent semantics. However, they are treated as significant in that applications will preserve them.

A comment line can contain any legal Applixware character. The comment cannot be longer than one line.

Comments can be inserted at the beginning of any line within a document. When a document is stored by an Applixware application, all Applixware comments are written to the stored image immediately following the *BEGIN line of the document. Comments within embedded data remain within that data and are not moved to the start of the file.

Third party developers and users can attach their own semantics and additional syntax to comments. VistaSource strongly suggests that developers adhere to the following conventions:

· A structured comment will consist of the following sequence:

** "keyword"string

keyword is an agreed upon sequence of case sensitive characters enclosed in quotes and string is any sequence of legal characters terminated by the end of the line.

· All Applixware keywords begin with one of the following strings: ax, Ax, or AX. These strings are reserved for Applix's use.

Applixware Words Statements

This section describes Applixware Words statements. Most statements consist of:

1. A left angle bracket

2. A keyword

3. A sequence of items

4. A terminating right angle bracket

When an item appears, it must appear in the order specified. For example:

< keyword

item1

item2

>

Items

There are three types of items that can be used in statement syntax:

Literal text Literal text is indicated by Courier text. It is to be specified exactly as shown.

Variables Variables are represented by Courier italic text, followed by the type of the variable in parenthesis. A number or string of the appropriate type should be provided.

Property

reference

A property reference is represented by mixed-case Courier italic. The property is either described immediately below the statement syntax description or in the "Supported Properties" section later in this chapter.

Unless otherwise indicated, the items within the statements are optional and have a default value when not specified.

Example Statement Definition

< ice_cream /* abbrev: i_c */

jimmies | nuts

scoops:numscoops(int)

flavor:flavorName

>

flavorName = "Vanilla" | "Chocolate"

The following table describes each of the components of the statements:

Table 1-2 Statement Elements (cont.)
Element	Meaning
`<`	Opening bracket
`ice_cream`	May substitute a short form here: for example, `i_c`
`jimmies \| nuts`	Can specify either of these literals
`scoops:``numscoops(int)`	Literal followed by variable
`flavor:``flavorName`	Mixed case, no type: must be a property
`>`	Closing bracket
`flavorName = "Vanilla" \| "Chocolate"`	The property definition. If the property definition is not included immediately below the statement definition, look up the property in the "Supported Properties" section later in this chapter.

Using this definition, we can derive the following legal statements:

<ice_cream>

Uses all defaults.

<i_c scoops:1>

Uses the keyword abbreviation.

<ice_cream jimmies scoops:2 flavor:"Vanilla">

Includes a literal (jimmies), a variable (scoops), and a property (flavor). Spaces around the colons are optional.

If an item is omitted, default values are used. The default is either described in a comment or can be assumed to be one of the following:

· Zero

· Not present

· FALSE

Variable Types

The following variable types are used in this chapter:

Table 1-3 Variable Types (cont.)
Type	Meaning
float	Floating point number. This is a number greater than or equal to zero unless otherwise indicated.
int	An integer. This is a number greater than or equal to zero unless otherwise indicated.
mils	Units of 1/1000th of an inch. This is a positive integer unless otherwise indicated.
points	Text size (72 points to the inch). This should be a positive integer.
string	A text string in double quotes; for example, `"Vanilla"`. The backslash (\) is used as an escape character in quoted strings in a Words file. Double quotes (") must be escaped, as are backslashes used in the text. The newline character (code 10) is represented as "`\n`". See "Wide and Multi-byte Characters" earlier in this chapter for a discussion of the treatment of other 8-bit and special characters. As an example, given the following string in a Words document: `The character "\" is a backslash` The following line would appear in the Words file: `<Text "The character \"\\\" is a backslash">`

All other units are described in context.

Sequence of Statements in Words

The following example displays the sequence of statements in a Words document. These statements are explained in detail in the sections following this example, listed in alphabetical order:

document = DOCUMENT_BEGIN

definitions

FLOW_BEGIN

[ contents ]...

paragraph /* Minimum flow contents is one

PARA */

SECTION

FLOW_END

[ secondary_flow ]...

[ object_definition ]...

variables

DOCUMENT_END

definitions = STYLES_BEGIN

STYLE /* Top-level style */

[ STYLE | SERIES | COLOR | glossary ]...

STYLES_END

glossary = GLOSSARY_BEGIN

[ contents | material ]...

GLOSSARY_END

contents = paragraph | row

paragraph = [ material ]...

PARA

row = ROW_START

cell... /* Last cell specially

marked as such */

cell = paragraph... /* No frames or

section/column/page breaks

allowed */

/* Cell must end with PARA */

CELL_END

field = FIELD_BEGIN

material /* Field method - defines field;

see Chapter 3, "Field Method

Syntax." */

LINK /* Required for linked objects;

omit for others */

FIELD_VALUE

/* Field value - contents of

field */

[ contents | material ]...

FIELD_END

break = LINE_BREAK | COLUMN_BREAK | SECTION | PAGE_BREAK

secondary_flow = hdr_ftr | footnote

object_definition = OBJECT | GRAPHICS

variables = VARS_BEGIN

[ DOC_VARIABLE ]...

VARS_END

hdr_ftr = HDRFTR_BEGIN

[ contents ]...

paragraph /* Must end with PARA */

HDRFTR_END

footnote = FOOTNOTE_BEGIN

field /* ...of type Footnote

Numbering */

[ contents ]...

paragraph /* Must end with PARA */

FOOTNOTE_END

NOTE: The TEXT statements that make up a field method must contain specific strings. Field methods are described in Chapter 3.

CELL_END

< cell_end /* abbrev: CE */

width:width(mils)

[ center | bottom ]

[ leftCellMargin:margin(mils) ] /* abbrev: lm */

[ rightCellMargin:margin(mils) ] /* abbrev: rm */

[ topCellMargin:margin(mils) ] /* abbrev: tm */

[ bottomCellMargin:margin(mils) ] /* abbrev: bm */

[ borderAttributes ]

[ locked ]

[ id:cell_id(string) ]

[ nextId:cell_id(string) ]

[ doubleClickMacro:macro(string) ]

[ enterMacro:macro(string) ]

[ exitMacro:macro(string) ]

[ maxChars:maxChars(int) ]

[ nextIfFull ]

[ case:caseCode(int) ]

[ promptText:promptText(string) ]

lastCellInRow /* abbrev: last */

>

The following table describes the items in the CELL_END statement:

Table 1-4 CELL_END Comments (cont.)
Element	Notes
`borderAttributes`	Border and shading properties of the cell. See "Supported Statements"
`case:` `caseCode(int)`	Causes the case of text typed into the cell in Forms mode to be altered as follows: 0 = No change (the default) 1 = Force lowercase 2 = Force uppercase This item did not exist in releases prior to release 4.1, and is meaningful only in Forms mode.
`center` \| `bottom`	Vertical alignment of material in cell; omit for default (top)
`doubleClickMacro:` `macro (string)`	The name of an ELF macro that will be executed when a user double clicks upon a cell in Forms mode This item did not exist in releases prior to release 4, and is meaningful only in Forms mode.
`enterMacro:` `macro (string)`	The name of an ELF macro that will be executed when the cursor moves into a cell in Forms mode This item did not exist in releases prior to release 4, and is meaningful only in Forms mode.
`exitMacro:` `macro (string)`	The name of an ELF macro that will be executed when the cursor leaves a cell while in Forms mode This item did not exist in releases prior to release 4, and is meaningful only in Forms mode.
`id:` `cell_id (string)`	An arbitrary string identifying a cell This item did not exist in releases prior to release 4.
`lastCellInRow`	This must be specified for the last cell (and only the last cell) in each row
`leftCellMargin, rightCellMargin, topCellMargin, bottomCellMargin:``margin (mils)`	Space between left/right/top/bottom border of the cell and material within the cell
`locked`	This only exists if a cell is locked (which means the cell cannot be selected, entered, or edited in Forms mode) This item did not exist in releases prior to release 4, and is meaningful only in Forms mode.
`maxChars:` `maxChars(int)`	Maximum number of characters allowed to be typed into the cell in Forms mode. This item did not exist in releases prior to release 4.1, and is meaningful only in Forms mode.
`nextID:` `cell_id (string)`	The id of a cell to which the "Go To Next Cell" command will move the cursor when in Forms mode This item did not exist in releases prior to release 4, and is meaningful only in Forms mode.
`nextIfFull`	If present, and if a `maxChars` value is specified, when the cursor is in the cell in Forms mode and the cell becomes "full" (as defined by `maxChars`), the cursor is moved to the cell with the nextID cell id. This item did not exist in releases prior to release 4.1, and is meaningful only in Forms mode.
`promptText:` `promptText(string)`	When the cursor enters the cell, this text will be displayed on the status line at the bottom of the Words window. This item did not exist in releases prior to release 4.1, and is meaningful only in Forms mode.
`width (mils)`	Overall width of cell, in mils

COLOR

< color

name(string):C:M:Y:K

>

Table 1-5 COLOR Comments (cont.)

Element

Meaning

C:M:Y:K

Required. The C, M, Y, and K values are integers between 0 and 255 representing the cyan, magenta, yellow, and black values respectively of the color

COLUMN_BREAK

< column_break >

DOC_VARIABLE

< variable

name(string) /* Required */

elfData

>

DOCUMENT_BEGIN

*BEGIN WORDS VERSION=vnum ENCODING=encoding

<Applix Words>

< Globals

levelIndent:indent(mils)

hyphMethod: hyphCode

headerMargins:header(mils)

footerMargins:footer(mils)

changeBarPos:barPos

[ facingPages ]

>

If the beads were contained in a formatted Macro Editor document, the first statement would be as follows:

*BEGIN MACROS VERSION=vnum ENCODING=encoding

The following table describes items in the DOCUMENT_BEGIN statement:

Table 1-6 DOCUMENT_BEGIN Comments (cont.)
Element	Notes
`changeBarPos:``barPos`	`barPos` is an integer controlling the placement of change bars in the document. The code numbers corresponding to the `WP#CB#POS#` defines in wp_.am are as follows: 0 = left margin 1 = right margin 2 = outer margin
`facingPages`	If present, the document is in "facing pages" mode; the main effect is the treatment of the left and right page margins (see the Section bead, below). Note this does not imply the document will be printed in double-sided mode.
`footerMargins:``footer(mils)`	Distance between the bottom of the page and the bottom of the footer, if any
`headerMargins:``header(mils)`	Distance between the top of the page and the top of the header, if any
`hyphMethod:``hyphcode`	`hyphCode` is an integer indicating the method used to hyphenate words in the dictionary. The code numbers corresponding to the `WP#HYPHENATE#` defines in wp_.am are as follows: 0 = use rules for hyphenation 1 = look in dictionary; if not found, use the rules 2 = don't hyphenate. 3 = look in dictionary only 4 = use profiled value (wpSpellEnglishOpts for English; wpSpellFrenchOpts for French, etc.; profiles use the HYPH_ defines in wp_.am). This option is supported as of release 4.4.
`levelIndent`:`indent(mils)`	Extra indent per para level.

DOCUMENT_END

< end_document >

*END WORDS

If the beads were contained in a formatted Macro Editor document, the last statement would be:

*END MACROS

EQUATION

See "Equation Statements" later in this chapter for more information.

ERROR

Contains compilation error message for an ELF macro document. This information is not written to or read from a file.

FIELD_BEGIN

< start_field /* abbrev: S_F */

[ { botPage | endDoc } footnote footNoteId(string) ]

[ date:dateStamp ]

[ docType:docTypeCode ]

[ appType:appTypeCode ]

[ editable ]

[ outDated ]

>

Table 1-7 FIELD_BEGIN Comments (cont.)
Element	Meaning
`appType`:`appTypeCode`	Only used for linked or embedded object fields; `appTypeCode` is described in the `OBJECT` statement
`{ botPage` \| `endDoc } footnote` `footNoteId(string)`	Only used for footnote reference fields. `footNoteId` is a string that identifies the matching footnote body. `botPage` is used for footnotes that are to be placed at the bottom of the page; `endDoc` for footnotes that are to be placed at the end of the document.
`date:``dateStamp`	Only used for linked object fields; `dateStamp`is the time the linked file was last modified This is the same format as the time returned by DATE_LAST_MODIFIED@
`docType`:`docTypeCode`	Only used for linked or embedded object fields; `docTypeCode` is described in the `OBJECT` statement
`editable`	If present, the field value can be edited; that is, it is unprotected
`endDoc footnote` `name(string)`	Only used for end-of-document footnote reference field
`outDated`	If present, the field value is reevaluated when the document is read

The FIELD_BEGIN statement is followed by the field method. See Chapter 3 for information.

FIELD_END

< end_field > /* abbrev: < E_F > */

FIELD_VALUE

< field_value > /* abbrev: < FV > */

FLOW_BEGIN

< start_flow >

FLOW_END

< end_flow >

FOOTNOTE_BEGIN

< start_footnote

footNoteId

>

Table 1-8 FOOTNOTE_BEGIN Comments (cont.)
Element	Meaning
`footNoteId`	A string that identifies the matching footnote reference field

FOOTNOTE_END

< end_footnote >

GLOSSARY_BEGIN

< start_glossary /* abbrev: < S_G */

name(string)

[ live ]

>

Table 1-9 GLOSSARY_BEGIN Comments (cont.)
Element	Meaning
`live`	If specified, matching references change when the glossary's contents change
`name(string)`	Required; name of glossary

GLOSSARY_END

< end_glossary > /* abbrev: < E_G > */

GRAPHICS

< graphics

name(string)

[ changedFlag ]

>

asciiData

The graphics bead is used as a temporary container for the actual graphics data in a linked graphics file. This information is discarded on save and recreated when the document is read back in. Thus the Graphics bead does not usually appear in the Words file.

Table 1-10 GRAPHICS Comments (cont.)
Element	Meaning
`asciiData`	Contents of graphics
`name(string)`	Unique name for this data

HDRFTR_BEGIN

< start_hdrftr

hdrftrname(string)

>

Table 1-11 HDRFTR_BEGIN Comments (cont.)

Element

Meaning

hdrftrname(string)

This name matches the name in the hdrFtrReference statement. The name should be of the format "_AX_HF_#", where "#" is a number; e.g. "_AX_HF_1".

HDRFTR_END

< end_hdrftr>

LINE_BREAK

\n

The line break is represented by a backslash-n in the file.

LINK

*LINK pathname

Table 1-12 LINK Comments (cont.)

Element

Meaning

pathname

The name of the external file to which you are linking

MARKER

<marker

markername(string)

>

Creates a named location in a file. This bead was not written to file during a Save operation in releases prior to release 4.

OBJECT

< object

name(string)

docType:docTypeCode

appType:appTypeCode

[ cvtMacro:macro(string) ]

[ appMacro:macro(string) ]

[ allowUnreferenced ]

[ changedFlag ]

asciiData | binaryData /* Contents of object */

Table 1-13 OBJECT Comments (cont.)
Element	Meaning
`allowUnreferenced`	If present, this object will be preserved at save time even if not referenced in the document. If absent, this object will not be written to the output file if it is not referenced within the document (default behavior).
`appMacro:` `macro(string)`	The name of the ELF macro to execute when the object is double-clicked upon (not needed for an Applixware object). Note this value will be overridden by a similar specification in the object field that references this object, if the field has such a specification.
`appType:``appTypeCode`	An integer representing the Applixware application matching the object. For example, if the object is a graphics object of any type (e.g. GIF, JPEG, Applixware Graphics), the value will be 2, representing "Applixware Graphics". See the `appTypeCode`section below for more information. Note this value will be overridden by a similar specification in the object field that references this object, if the field has such a specification.
`docMacro:` `macro(string)`	The name of the ELF macro to be used when converting the object into Applixware format (not needed for an Applixware object). Note this value will be overridden by a similar specification in the object field that references this object, if the field has such a specification.
`docType:``docTypeCode`	Is an integer representing the origin of the object. The same coding system is used by the RECOGNIZE_FILE@ macro Some of the common codes are: 0 = ASCII 1 = DCA 35 = HTML 66 = GIF 108 = Excel XLS 4.0 200 = Applixware Words 201 = Applixware Graphics 203 = Applixware Spreadsheets 211 = Applixware Data See recgfil_.am for more codes. Note this value will be overridden by a similar specification in the object field that references this object, if the field has such a specification.
`name(string)`	This required field matches the name in an object field method

PAGE_BREAK

< page_break

[ odd_page | even_page ]

>

Table 1-14 PAGE_BREAK Comments (cont.)

Element

Meaning

odd_page | even_page

If odd_page is specified, the material following the page break will begin on the next odd page. If even_page is specified, it will begin on the next even page. If nothing is specified, the material will begin on the next page, regardless of whether it is an odd or even page (default behavior).

PARA

< para /* abbrev: < P */

styleName(string)

[ borderAttributes ]

[ paraAttributes ]

[ tabDefinitions ]

[ frameAttributes ]

[ textAttributes ]

[ changedFlag ]

>

Table 1-15 PARA Comments (cont.)

Element

Meaning

changedFlag

For change bar operations only, If this attribute is used, it always occurs just before the bead's concluding ">"

styleName

The name of the style controlling the inherited attributes of this paragraph

PICTURE

< picture

name(string)

[ builtIn ]

appId:appTypeCode

[ proportional ]

[ clipMode:clipModeCode(int)

[ xScale:xscale(float) ]

[ yScale:yscale(float) ]

[ xOffset:xoffset(mils) ]

[ yOffset:yoffset(mils) ]

[ srcWidth:srcWidth(mils) ]

[ srcHeight:srcHeight(mils) ]

[ picSource:"elfStringArray" ]

[ width:displayWidth(mils)/ ]

[ height:displayHeight(mils) ]

[ changedFlag ]

>

Table 1-16 PICTURE Comments (cont.)
Element	Meaning
`builtIn`	Obsolete as of 4.3.
`appId:``appTypeCode`	An integer representing the Applixware application matching the inset. For example, if the inset is a graphics object of any type (e.g. GIF, JPEG, Applixware Graphics), the value will be 2, representing "Applixware Graphics". See the `appTypeCode`section below for more information. Note this value will be overridden by a similar specification in the inset field that references this object, if the field has such a specification.
`clipMode:` `clipModeCode`	This controls how the picture is scaled or clipped. Possible values are: 0: This is the default if "clipMode" is not specified. If the picture is in a frame, the picture is scaled to the size of the frame. If the frame has auto width or height or both, the corresponding width/height of the picture is not scaled, i.e., it is displayed at full size. In release 4.3 and before, if the picture is not in a frame, the picture is not scaled, but may be clipped if it is larger than the margins. As of release 4.4, the picture will be sized so its width exactly fits the column or cell it falls within³, and its height adjusted proportinately, even if the `proportional` flag is absent. However, the 4.3 behavior can be preserved (i.e. the picture only resizes if it is in a frame) by setting the `wpNoInsetScaleToFit` profile to 1. 1: The picture is clipped if it is larger than the frame (if the picture is within a frame) or the margins (if the picture is not in a frame).
	Note in release 4.2, a graphics inset in a cell was not clipped to the cell margins. As of release 4.3, any picture inset in a cell is clipped to the cell margins. As of release 4.4, the release 4.2 behavior can be recovered (i.e. an inset will not be clipped to the cell margins) by setting the wpNoClip profile to 1. The picture is scaled using the "xScale" and "yScale" attributes of the `PICTURE` bead, if any.
`height:``displayHeight (mils)`	Only used for filters. `height` and `width` define the display size of the picture, taking into account the source specification (or offsets and source size) and the scale factor. `height` and `width` are included only to provide conversion compatibility with foreign formats that require this information. Words will recalculate these values when the file is read and the object first displayed.
`name(string)`	This is a required field. For an embedded object, `name` matches the name in an object or graphic bead containing the data being displayed. For a linked inset, `name` represents the (absolute or relative) filename of the entity. As of release 4.3, name can be a URL.
`proportional`	If omitted, `xScale` and `yScale` can differ
`picSource:"``elfStringArray"`	As of release 4.3, this format is used to indicate what portion of the inset to display. For a Graphics inset, this might describe a rectangular area within the object; for a Spreadsheet, a cell range, etc. This format represents an ELF array which will be different for each object type. For a Graphics inset, see gr_inset_source@ in graphic_.am. For a Spreadsheet inset, see ss_inset_source@ in spsheet_.am. For a Words inset, see wp_inset_source@ in wp_.am. For a Graphics inset only, if no`picSource`is specified, and any combination of `xOffset, yOffset,` `srcWidth`, and `srcHeight` are specified, these values are used to manufacture a `picSource.`
`srcHeight:` `srcHeight(mils)`	For a graphics inset only. If omitted, the entire height of the source object is used `xOffset, yOffset, srcWidth`, and `srcHeight` define the area of the source material used by the picture. As of 4.3, all insets will write their source specification data in `picSource:"``elfStringArray"`format.
`srcWidth:` `srcWidth(mils)`	For a graphics inset only. If omitted, the entire width of the source object is used. See `srcHeight` for more information.
`width:` `displayWidth (mils)`	Only used for filters; see `height` for more information
`xOffset:` `xoffset(mils)`	For a graphics inset only. See `srcHeight` for more information
`xScale:` `xscale(float)`	If omitted, a default value of 1 is used `xScale` is the horizontal scale factor by which the source material will be scaled
`yOffset:` `yoffset(mils)`	For a graphics inset only. See `srcHeight` for more information
`yScale:` `yscale(float)`	If omitted, a default value of 1 is used `yScale` is the vertical scale factor by which the source material will be scaled

ROW_START

< row_start /* abbrev: < RS */

[ justifyLeft | justifyRight | justifyCenter ]

[ leftIndent:indent(mils) ]

[ topRowMargin:margin(mils) ]

[ bottomRowMargin:margin(mils) ]

[ height:height(mils) | minHeight: height(mils) | maxHeight:height(mils) ]

[ heading ]

>

Table 1-17 ROW_START Comments (cont.)
Element	Meaning
`bottomRowMargin:` `margin(mils)`	Amount of whitespace below the row (before the next row or paragraph). Assumed to be zero if omitted.
`heading`	If present and this is the first row in the table, this row will be repeated as the first row on subsequent pages which contain rows of the same table This is a Release 4 feature
`height:``height(mils)` \| `minHeight:``height(mils)` \| `maxHeight:``height(mils)`	If omitted, `row`is as high as the tallest cell; otherwise, the heights are as follows: `height` exactly this tall `minHeight` at least this tall `maxHeight` at most this tall
`justifyLeft` \| `justifyRight` \| `justifyCenter`	The default is left justified
`leftIndent`	If omitted, the row begins at the left column or margin
`topRowMargin:` `margin(mils)`	Amount of whitespace above the row (after the preceding row or paragraph). Assumed to be zero if omitted.

SECTION

< section

[ next_column | next_page | even_page | odd_page ]

[ landscape ]

pageWidth:width(mils)

pageHeight: height(mils)

[ paperSize:paperCode(int) ]

[ leftMargin:margin(mils) ]

[ rightMargin:margin(mils) ]

[ topMargin:margin(mils) ]

[ bottomMargin:margin(mils) ]

[ bindingMargin:margin(mils) ]

[ columns:columns(1-19) ]

[ gutterWidth:gutter(mils) ]

[ oddHeader:hdrFtrReference ]

[ evenHeader:hdrFtrReference ]

[ firstHeader:hdrFtrReference ]

[ lastHeader:hdrFtrReference ]

[ oddFooter:hdrFtrReference ]

[ evenFooter:hdrFtrReference ]

[ firstFooter:hdrFtrReference ]

[ lastFooter:hdrFtrReference ]

[ sectNumFmt:numstyle ]

[ sectNumCtl:sectnumctl ]

[ sectNumVal:sectnum(int) ]

[ sectPageSep:separator(string)]

[ pageNumFmt:numstyle ]

[ pageNumCtl:pagenumctl ]

[ pageNumVal:pagenum(int) ]

[ printSourceTray:sourceTray(int) ]

[ printDestTray:destTray(int) ]

[ duplex:duplex(int) ]

>

The section and page numbering properties control the appearance of the page number fields that fall into the section (that is, before this section bead but after any preceding section beads). Page numbering consists of a page number, optionally preceded by a section number. Within the section, the page numbers increment, but the section number does not.

Table 1-18 SECTION Comments (cont.)
Element	Meaning
`bindingMargin:``margin(mils)`	If the document is in "facing pages" mode, this margin is added to the inner margin of each page. If the document is not in "facing pages" mode, this margin is added to the left margin of each page.
`columns:``columns(1-19)`	Single column if omitted
`duplex:``duplex(int)`	Indication of whether the physical printing should occur on one or both sides of the paper. Note this is not related to the "facing pages" mode. The codes are: 0 = simplex (single-sided) print (the default) 1 = duplex (double-sided), long edge 2 = duplex (double-sided), short edge On a sheet of paper printed in duplex-long, the paper must be rotated about the long (vertical) axis in order to view the back right side up. In duplex-short, the paper must be rotated about the short (horizontal) axis to view the back right side up. This item did not exist in releases prior to release 4.2.
`gutterWidth:``gutter(mils)`	The space left between columns, if the section has more than one column.
`landscape`	If omitted, the pages in the section are printed in normal (portrait) mode. If present, pages are printed in landscape mode. In landscape mode, all text and graphics is rotated 90 degrees with respect to the physical paper.
`leftMargin:``margin(mils)` `rightMargin:``margin(mils)` `topMargin:``margin(mils)` `bottomMargin:``margin(mils)`	The left, right, top, and bottom margins; that is, the whitespace between the main flow rectangle and the edge of the paper. Note the header and footer ignore the top and bottom margins. The margins are place relative to the direction of the text. In a portrait (normal) section of US Letter size, the top and bottom margins run along the short (8.5 inch) sides of the paper. In a landscape section of the same page size, the top and bottom margins run along the long (11 inch) sides of the paper. If the document is in "facing pages" mode, `leftMargin` represents the inner margin (i.e. the left margin of an odd page and the right margin of an even page) and `rightMargin` represents the outer margin.
`next_column` \| `next_page` \| `even_page` \| `odd_page` \| `Continuous`	If omitted, the default is `Continuous`
`oddHeader:hdrFtrReference...` `lastFooter:``hdrFtrReference`	The status of the headers and footers on the first, odd, even, and last pages of the section. See `hdrFtrReference` for more information.
`pageWidth:width(mils),` `pageHeight:``height(mils)`	Actual paper (page) size for pages that fall into this section. Will override `paperSize` (see below) if a mismatch occurs. Note that these values are not swapped when the document moves between portrait and landscape mode
`pageNumCtl:``pagenumctl`	If omitted, increment last page in previous section `pagenumctl` is a Boolean controlling the value of the first page in the section. The code is as follows: 0 = increment last page in previous section 1 = use `pagenum` value
`pageNumFmt:``numstyle`	If omitted, Arabic numbering is used
`pageNumVal`:`pagenum(int)`	If this is used, the page number to a specific value `pagenum` is an integer used as the value of the first page number in the section only when `pagenumctl` is set to 1
`paperSize:``paperCode(int)`	Code indicating desired paper size, as displayed in the Page Setup dialog box. Must be kept in synch with `pageWidth` and `pageHeight` (see above) as they control the actual values used for the page size. The code values are as follows: 1 = US Letter 2 = US Tabloid 3 = US Ledger 4 = US Legal 5 = US Statement 6 = US Executive 7 = US Envelope 10 8 = US Envelope 9 9 = US Envelope 6 10 = A3 11 = A4 12 = A5 13 = B4 14 = B5 15 = Envelope C4 16 = Envelope C5 17 = Envelope DIN
`printDestTray:``destTray(int)`	Printer tray number into which printed paper is put during a print. Zero represents the default destination tray. This item did not exist in releases prior to release 4.2.
`printSourceTray:``sourceTray(int)`	Printer tray number from which paper is drawn during a print. Zero represents the default source tray. This item did not exist in releases prior to release 4.2.
`sectNumCtl`:`sectnumctl`	If omitted, section numbering is the same as the previous section `sectnumctl` is an integer indicating the method of determining the value of the section numbering. The code numbers, corresponding to the `WP#SECT#NUM#`defines in wp_.am, are as follows: 0 = same value as previous section 1 = increment previous section's value 2 = use `sectnum` value.
`sectNumFmt`:`numstyle`	If omitted, no section numbering `numstyle` is an integer representing the section or page numbering format The code numbers, corresponding to the `WP#NUMBERING#` defines in wp_.am, are as follows: -1 = no numbering 0 = Arabic 1 = uppercase letters 2 = lowercase letters 3 = uppercase Roman 4 = lowercase Roman Numbers larger than 1000 indicate document variables that define a macro for a custom series format (1000+N corresponds to document variable `UserSeriesN`) Refer to the UtilitiesÝ Edit Numbered Series Ý Custom Series dialog box for more information
`sectNumVal`:`sectnum(int)`	If used, the section number is forced to this value `sectnum` is the section numbering value when `sectnumctl` is set to 2
`sectPageSep`:`separator(string)`	If omitted, the page separator is a hyphen `separator` is the string separating the section and page numbering; it is only displayed if both section and page numbering are displayed (that is, both `numstyles` are not -1)

SERIES

< series

name(string)

n0 n1 n2 n3 n4 n5 n6 n7 n8 n9

[ leader:leader(string) ]

[ trailer:trailer(string) ]

[ leaders0:leader (string) ]

[ leaders1:leader (string) ]

[ leaders2:leader (string) ]

[ leaders3:leader (string) ]

[ leaders4:leader (string) ]

[ leaders5:leader (string) ]

[ leaders6:leader (string) ]

[ leaders7:leader (string) ]

[ leaders8:leader (string) ]

[ leaders9:leader (string) ]

[ trailers0:trailer (string) ]

[ trailers1:trailer (string) ]

[ trailers2:trailer (string) ]

[ trailers3:trailer (string) ]

[ trailers4:trailer (string) ]

[ trailers5:trailer (string) ]

[ trailers6:trailer (string) ]

[ trailers7:trailer (string) ]

[ trailers8:trailer (string) ]

[ trailers9:trailer (string) ]

[ multiLevel ] /* Display single level only if omitted */

[ sep1:separator (string) ]

[ sep2:separator (string) ]

[ sep3:separator (string) ]

[ sep4:separator (string) ]

[ sep5:separator (string) ]

[ sep6:separator (string) ]

[ sep7:separator (string) ]

[ sep8:separator (string) ]

[ sep9:separator (string) ]

[ from1:level to show from(0-1) ]

[ from2:level to show from(0-2) ]

[ from3:level to show from(0-3) ]

[ from4:level to show from(0-4) ]

[ from5:level to show from(0-5) ]

[ from6:level to show from(0-6) ]

[ from7:level to show from(0-7) ]

[ from8:level to show from(0-8) ]

[ from9:level to show from(0-9) ]

>

Table 1-19 SERIES Comments (cont.)
Element	Meaning
`name(string)`	Name of the series.
`n0...n9 (int)`	Integers representing the format of the levels of the series. The level of an instance of the series is, by default, determined by the level of the paragraph the series field falls within. The code numbers, corresponding to the `WP#NUMBERING#`defines in wp_.am, are as follows: -1 = no numbering 0 = Arabic 1 = uppercase letters 2 = lowercase letters 3 = uppercase Roman 4 = lowercase Roman Numbers larger than 1000 indicate document variables which define a macro for a custom series format (1000+N corresponds to document variable `UserSeriesN`); refer to the Utilities Ý Edit Numbered Series Ý Custom Series dialog box for more information
`leader:``leader (string)`	If present, the string to be displayed before the series number(s) or letter(s).
`trailer:``trailer (string)`	If present, the string to be displayed after the series number(s) or letter(s).
`leaders0...leaders9:``leader (string)`	Strings representing individual leaders for particular levels of the series. These can be used as an alternative to, or in addition to, the global leader. If a series at a particular level has a level-dependent leader as well as a global leader, the global leader precedes the level-dependent leader. This feature was implemented in release 4.0
`trailers0...trailers9:``trailer (string)`	Strings representing individual trailers for particular levels of the series. These can be used as an alternative to, or in addition to, the global trailer. If a series at a particular level has a level-dependent trailer as well as a global trailer, the global trailer follows the level-dependent trailer. This feature was implemented in release 4.0
`multilevel`	If omitted, only display single level
`from1...from9:``level to show from (int)`	Numbers representing, for a particular level, which higher levels to display. For example, if the formats for levels 0, 1, and 2 are "A", "a", and "i" respectively, the following would be displayed at level 2: Flag displayed from2:2 i from2:1 a.i from2:0 A.a.i These flags are only serviced when the `multilevel` flag is set.
`sep1...sep9:``separator (string)`	Strings representing individual separators between particular levels of the series. These separators are only displayed when the `multilevel` flag is set, and the `from` flag for the given level specifies the display of higher levels. The separator for a given level precedes the string for that level, if the next-higher level is also being displayed.

STYLE

< style

name(string)

parent name(string)

[ nextStyle name(string) ]

[ borderAttributes ]

[ frameAttributes ]

[ glossary name(string)] /* Style has no leading glossary if omitted*/

[ paraAttributes ]

[ tabDefinitions ]

[ textAttributes ]

>

Table 1-20 STYLE Comments (cont.)
Element	Meaning
`glossary` `name(string)`	If present, name of glossary to be inserted before each instance of a paragraph that uses this style (e.g. a glossary containing a bullet, or a numbered series field).
`name(string)`	Name of current style. All styles in a document must have unique names. The first style in a document should be the top-level style, from which all other styles should be directly or indirectly descended.
`nextStyle` `name(string)`	Name of style to be used when user puts cursor at the end of a paragraph of current style and hits return, thus creating a new, empty paragraph. If omitted, the current style will be used.
`parent` `name(string)`	This is required except for the top-level style where it is omitted The top-level style does not have itself for a parent

STYLES_BEGIN

< start_styles >

STYLES_END

< end_styles >

TEXT

< text /* abbrev: < T */

text(string)

[ textAttributes ]

[ changedFlag ]

>

Table 1-21 TEXT Comments (cont.)
Element	Meaning
`text(string)`	This cannot be empty; if it is, the bead is discarded
`changedFlag`	(Change bar operations only) If present, it always occurs just before the ">"

VARS_BEGIN

< start_vars >

VARS_END

< end_vars >

Supported Properties

This section describes the properties of the supported statements. The properties are listed in alphabetical order. Generally, properties are optional and have a default value when they are omitted. The formatting conventions from the "Supported Statements" section are also used here.

appTypeCode

appTypeCode is an integer representing an Applixware application type. The same coding system is used by the AX_APP_TYPE_FROM_DOC_TYPE@ macro; some of the common codes are:

1= Words
2= Graphics
3= Spreadsheets
4= Macros
5= Audio
6= Bitmap
10= Data
12 = Equations
14 = HTML Author

See app_ids_.am for more codes.

asciiData

<start_data ascii >

asciiData

<end_data>

asciiData is printable ASCII characters. Newlines are ignored. To make a newline in the data, use \n. The maximum line length is 1000 characters. The following are the other escape sequences:

\t tab\< left angle bracket\> right angle bracket\\ backslash\* asterisk

See the section on Wide and Multi-byte Characters earlier in this chapter for a discussion of the treatment of other 8-bit and special characters.

In Release 4.0 and beyond, ASCII data that extends across multiple lines should be in continuation line format, with a backslash at the end of each line (except for the last line), and a space at the beginning of each line (except the first line). For example:

<start_data ascii >

Here is the first line.\nHere is the second line; no\

te the backslash and leading space. Here is the las\

t line which has no final backslash.

<end_data>

Prior to Release 4.0, continuation line format was not used for ASCII data. For example:

<start_data ascii >

Here is the first line in 3.11 format.\nHere is th

e second line; note there are no trailing backslas

hes or leading spaces in this version.

<end_data>

It is important that the format of the ASCII data be appropriate for the version number in the document header (use continuation lines when the version number is 400 or larger).

binaryData

<start_data binary >

hexData

<end_data>

hexData is any binary data where bytes are represented by two hexadecimal digits. New lines are ignored. The maximum line length is 1000 characters.

borderAttributes

See the sections CELL_END, PARA, and STYLE.

bottomBorder:thickness(mils):double(bool):color(string) /* or bB:*/

dropShadow:shadingStyle

horizontal:thickness(mils):double(bool):color(string) /* or hB:*/

horizontalMargin:margin(mils)

leftBorder:thickness(mils):double(bool):color(string) /* or lB :*/

rightBorder:thickness(mils):double(bool):color(string) /* or rB :*/

shading:shadingStyle:foregroundcolor(string):backgroundcolor(string)

topBorder:thickness(mils):double(bool):color(string) /* or tB :*/

verticalBorder:thickness(mils):double(bool):color(string) /* or vB:*/

verticalMargin:margin(mils)

shadingStyle is an integer representing the desired shading pattern, as defined by the WP#SHADING#defines in wp_.am. WP#SHADING#NONE, or integer value 18, is the default.

changedFlag

See the sections PARA and TEXT.

Changes:added | deleted | changed

This property controls the type of change bar to be displayed adjacent to the line containing the statement. If omitted, no change bar is displayed.

docTypeCode

See OBJECT for information on docTypeCodes.

elfData

See DOC_VARIABLE and elfDataArray.

value(int) | value(float) | value(string) | binaryData | elfDataArray

elfDataArray

See elfData in the previous section.

<

elfData...

>

elfString

See PICTURE and elfStringArray.

value(int) | value(float) | value(string) | ~ | elfDataArray

Table 1-22 elfString Comments (cont.)
Element	Meaning
`~`	The tilde character '~' represents a NULL element in an array.

elfStringArray

See elfString in the previous section.

<

elfString...

>

frameAttributes

See the PARA and STYLE sections.

bottomFrameMargin: margin(mils)

frameMargin: margin(mils) */

height:height(mils) | minHeight:height(mils) | maxHeight: height(mils)

jumpOver | background /* Frame type; omit for default (flow around) */

leftFrameMargin: margin(mils)

noFrame /* If present, para has no frame */

rightFrameMargin: margin(mils)

topFrameMargin: margin(mils)

width:framewidth(mils)

xpos:position(mils)

xposMarginRelative | xposColumnRelative

xposTypeCenter | xposTypeRight | xposTypeOutside | xposTypeInside

ypos:position(mils)

yposMarginRelative | yposParaRelative

yposTypeCenter | yposTypeBottom

Table 1-23 frameAttributes Comments (cont.)
Element	Meaning
`frameMargin:` `margin(mils)`	If present, it is the value to which all four margins are set
`height:``height(mils)` \| `minHeight`:`height(mils)`	If omitted, the height will be autosized
`jumpOver` \| `background`	Frame type; omit for the default, which is flow around
`noFrame`	If present, the paragraph does not have a frame
`width`:`framewidth(mils)`	If omitted, the width will be autosized
`xposMarginRelative` \| `xposColumnRelative`	Relative to (horizontally); omit for default, which is page
`xposTypeCenter` \| `xposTypeRight` \| `xposTypeOutside` \| `xposTypeInside`	Horizontal alignment; omit for the default, which is left align
`yposMarginRelative` \| `yposParaRelative`	If omitted, the height is autosized
`yposTypeCenter` \| `yposTypeBottom`	Vertical alignment; omit for default, which is top align

hdrFtrReference

inherit | none | Normal:hdrftrName(string) | UseGlossary:glossaryName(string)

Table 1-24 hdrFtrReference Comments
Element	Meaning
`glossaryName`	Match the name in a `GLOSSARY_BEGIN` statement
`hdrftrName`	Match the name in a `HDRFTR_BEGIN` statement. The name should be of the format "`_AX_HF_#`", where `#` is a number; For example: `"_AX_HF_1"`
`inherit`	Inherit from the previous section
`none`	Do not use a header or footer of this type in this section

paraAttributes

Note that if properties are missing, then the values are inherited.

firstIndent:indent(mils)

hyphMinFrag:frag(# of chars)

hyphZone:zone(mils)

indentToLevel | no-indentToLevel

justifyLeft | justifyRight | justifyCenter | justifyFull

leftIndent:indent(mils)

level:level(0-10)

lineSpacing:spacing(mils)

lineSpacingMode:mode

lineSpacingCountHeight:value (number, mils)

lineSpacingSep:value(mils)

no-keepWith | keepWith

postParaSpacing:spacing(mils)

preParaSpacing:spacing(mils)

rightIndent:indent(mils)

spellcheck | no-spellcheck

Table 1-25 paraAttributes Comments (cont.)
Element	Meaning
`indentToLevel`	If indenting, add an extra indent of `level * indent-per-level-amount`; See DOCUMENT_BEGIN for more information
`level`	Levels are 1-based in the user interface; however, they are zero-based in the file
`lineSpacing`	Spacing is a number specifying leading. Retained for compatibility with versions earlier than 4.4.2.
`lineSpacingMode`	Mode is a number specifying "multiple-line", "exact", or "at least" line spacing mode.
`lineSpacingCountHeight`	"Multiple-line" mode: Value is number of lines, in 1000ths of lines (1000 = single). "Exact" mode: Value is line height, mils. "At Least" mode: Value is minimum line height, mils.
`lineSpacingSep`	"Multiple-line" mode only. Value is added to space between bottom and top of consecutive lines.

tabDefinitions

See PARA, STYLE

localTabs

[tabStop]...

Table 1-26 tabDefinitions Comments (cont.)
Element	Meaning
`localTabs`	If omitted, all tabs are inherited; otherwise, no tabs are inherited
`tabStop`	Set of tabs if tabs are not inherited

tabStop

See tabDefinitions

A tabstop definition consists of one of the following:

centerTab:position(mils)) [:leaders(string) ] /* abbrev cT */

/* abbrev dT */

decimalTab:position:alignChar(string) [:leaders(string) ]

leftTab:position(mils) [:leaders(string) ]

/* abbrev: lT */

rightTab:position(mils) [:leaders(string) ]

/* abbrev rT */

Table 1-27 tabStop Comments (cont.)

Element

Meaning

alignChar

A string containing a single character; the matching character in the text following a tab will align at this tab stop

An alignCharis required in a decimal tab

leaders

The string that is replicated along the length of the tab up to the tabbed text; if omitted, the tab has no leader

textAttributes

See PARA, STYLE

Note that if properties are missing, values are inherited.

bold | no-bold

color:name(string)

face: name(string)

hyphenate | no-hyphenate

italic | no-italic

position:offset (points)

size: size(points)

strikethru | no-strikethru

Table 1-28 textAttributes Comments (cont.)
Element	Meaning
`offset`	A positive number is a superscript; a negative number is a subscript

Equation File Format

Equations uses two different formats. One format is used when the equation is contained as an embedded object; the second is used when the object is localized.

The following is the sequence of statements used when Equation information is stored as an embedded object.

document = DOCUMENT_BEGIN

[ EQUATION-SETTINGS ]

equation

DOCUMENT_END

equation = EQUATION_BEGIN

[ TEMPLATE ]

EQUATION_END

subequations = [ equation ] ...

The following format is used when an Equation object is localized:

equationBead = EQUATION_BEAD_BEGIN

[ EQUATION-SETTINGS ]

equation

EQUATION_BEAD_END

Equation Statements

DOCUMENT_BEGIN

*BEGIN⁴ EQUATIONS VERSION=vnum ENCODING=encoding <APPLIX EQUATIONS>

DOCUMENT_END

<end_document> *END EQUATIONS

EQUATION_BEAD_END

>

EQUATION_BEAD_START

<equation

EQUATION_BEGIN

<eqn_begin

[ pileAlign ]

[ matrixRowAlign ]

[ matrixColAlign ]

>

EQUATION_END

<eqn_end>

EQUATION_SETTINGS

fullSize: fontSize(points)

subSize: fontSize(points)

subSubSize: fontSize(points)

symbolSize: fontSize(points)

subSymbolSize:fontSize(points)

lineSpace: percent | amount(points)

matrixRowSpace: percent | amount(points)

matrixColSpace: percent | amount(points)

subscriptDepth: percent | amount(points)

superscriptHeight: percent | amount(points)

limitHeight: percent | amount(points)

Only amounts that differ from their default values are stored in a file. A negative spacing attribute value represents a relative value in percent of the fontHeight of the font with a size=fullSize.

The following are the default value for each of these equation settings:

Table 1-29 Equation Setting Defaults (cont.)
Element	Default Value
`fullSize`	12 points
`subSize`	8 points
`subSubSize`	6 points
`symbolSize`	24 points
`subSymbolSize`	18 points
`lineSpace`	-150
`matrixRowSpace`	-150
`matrixColSpace`	-100
`subscriptDepth`	-40
`superscriptHeight`	-20
`limitHeight`	-20

TEMPLATE

<tmpl

template-type

[ xnudge: amount(mils) ]

[ ynudge: amount(mils) ]

>

subequations...

The number of subequations depends on the type of template.

Equation Properties

matrixColAlign

Only a matrixColAlign attribute that differs from the default is saved in a file. The default value is leftAlign.

matrixRowAlign

topAlign | centerAlign | bottomAlgin | baselineAlign

Only a matrixRowAlign attribute that differs from the default is saved in a file. The default value is topAlign.

pileAlign

Only a pileAlign attribute that differs from the default is saved in a file. The default value is leftAlign.

symbol

symbol { string | char:asciiCode(num) | space:amount(mils) | alignMarker } | relSymbol { string | char:asciiCode(num) } | greekSymbol {string | char:asciiCode(num) }

A symbol template is a simple template. That is, it is a template whose contents do not contain any subequations. All adjacent symbol templates with similar properties are normally combined to form string.

Automatic mathematical function recognition is performed upon symbols.

To qualify for a function name, all the letters in the function should exist as symbol templates with no attribute exceptions. In addition, they must all be adjacent.

Non-printable characters are stored with a char:asciiCode description.

AlignMarker and spaces (which are also simple templates) are treated as symbol templates.

greekSymbol and relSymbol are derived from symbol templates; however, their default font is Symbol.

symbolAttributes

no-bold | bold no-italic | italic face: fontName(name) size:fontSize(pts)

Only attributes which differ from their default values are stored in a file. The default values for these properties are:

Table 1-30 symbolAttribute Defaults (cont.)
Element	Default Value
`no-bold` \| `bold`	`no-bold`
`no-italic` \| `italic`	`italic`
`face:` `fontName(name)`	`Times`
`size:` `fontSize(pts)`	`fullSize`

templateType

symbol [ symbol-attributes ] |

paren | ltparen | rtparen |

brace | ltbrace | rtbrace |

bracket | ltbracket | rtbracket |

vert | ltvert | rtvert |

dblvert | ltdblvert | rtdblvert |

floor | ltfloor | rtfloor |

ceil | ltceil | rtceil|

ltltbracket | rtrtbracket | oppBracket |

parenBracket | bracketParen |

underbar | dblunderbar |

overbar | dbloverbar |

sqrt | nroot |

sub | sup | subsup | ltsub | ltsup | ltsubsup |

script | scriptup | scriptdn| scriptupdn |

ltarrowup | rtarrowup | ltrtarrowup |

ltarrowdn | rtarrowdn | ltrtarrowdn |

matrix matrixRows:number MatrixCols: number

[matrixRowAlign: topAlign | centerAlign | bottomAlign | baselineAlign ]

[equalRowHeights] [equalColWidths] |

eqn_break

More Information on Templates

The following table describes various template types and the number of subequations they contain.

Table 1-31 Template Descriptions (cont.)
Types	#	Description
symbol	0	symbol, relSymbol, greekSymbol, space, alignMarker are members of this template, which are simple templates
eqn_break	1	Piles of equations are built with eqn_break template as the separator between equations
fences	1	paren, ltparen, rtparen, brace, ltbrace, rtbrace, bracket, ltbracket, rtbracket, vert, ltvert, rtvert, dblvert, ltdblvert, rtdblvert, underbar, dblunderbar, overbar, dbloverbar, floor, ltfloor, rtfloor, ceil, ltceil, rtceil, ltltbracket, rtrtbracket, and oppBracket are members of the fences template The size of the subequation is fullsize
fraction	2	over, divide, slash, by and vertslash are members of the fraction template The order of equations stored in files is: [numerator][denominator] The size of both subequations is fullSize
sqrt	*	sqrt(1), nroot(2) are members of the sqrt template The number in parentheses indicates the number of subequations these templates contain. The order of equations stored in files is: [body][nroot] Size of `body' equation is fullSize The size of `nroot' equation is subSize
script	*	script(1), scriptup(2), scriptdn(2) and scriptupdn(3) are members of the script templates. The number in parenthesis indicates the number of subequations these templates contain The order of equations stored in files is : [body][up limit][down limit] The size of `body' equation is fullSize The size of both the limit equations is subSize
summation	*	sum(1), sumup(2), sumdn(2), sumupdn(3), sumsup(2), sumsub(2), sumsubsup(3) prod(1), produp(2), proddn(2), produpdn(3), prodsup(2), prodsub(2), prodsubsup(3) cup(1), cupup(2), cupdn(2), cupupdn(3), cupsup(2), cupsub(2), cupsubsup(3) cap(1), capup(2), capdn(2), capupdn(3), capsup(2), capsub(2), capsubsup(3) int(1), intup(2), intdn(2), intupdn(3), intsup(2), intsub(2), intsubsup(3) tint(1), tintup(2), tintdn(2), tintupdn(3), tintsup(2), tintsub(2), tintsubsup(3) thint(1), thintup(2), thintdn(2), thintupdn(3), thintsup(2), thintsub(2), thintsubsup(3) oint(1), ointup(2), ointdn(2), ointupdn(3), ointsup(2), ointsub(2), ointsubsup(3) are the members of the summation template The order of equations stored is: [body][up/sup limit][down/sub limit] The size of `body' equation is fullSize and size of both the limit equations is subSize
subscript/ superscript	*	sub(1), sup(1), subsup(2), ltsub(1), ltsup(1) , and ltsubsup(2) are members of the subscript/superscript template The order of equations stored is: [superscript][subscript] The size of both the script equations is subSize
label-arrows	1	ltarrowup, rtarrowup, ltrtarrowup, ltarrowdn, rtarrowdn, ltrtarrowdn are members of the label-arrows template Size of the subequation is subSize
matrix	*	Total number of subequations inside a matrix of m rows and n cols is m x n The order of equations stored in files is row major ; that is, elements in the top row are stored first from left-column to right-column and then the second row and then the third row and so on All subequations are created with fullSize

* An asterisk in the second column indicates the number of subequations is variable and is described in 'description' column.