{DOCUMENT$
{PARA$ STYLE$ STYLE.FORMAT=root PROPERTIES$ PROPERTIES.Postfix=<(firstHeadersAfterPage) {1} .cvx .def (firstPageNumber) {1} .cvx .def (oneSidedFormat) {.false} .cvx .def> PROPERTIES.StyleDef=<BeginStyle
(Cedar) AttachStyle
(Nest) "display nesting level"  { BasicSize bigger leftIndent  } PrintRule
EndStyle> PROPERTIES.FromTiogaFile=<> 
{CHARS$ <
>}
{PARA$ PROPERTIES$ PROPERTIES.Mark=<LastEdited> 
{CHARS$ <TiogaDoc.Tioga
>}
{PARA$ PROPERTIES$ PROPERTIES.Mark=<LastEdited> 
{CHARS$ <Bill Paxton on March 14, 1983
>}}
{PARA$ PROPERTIES$ PROPERTIES.Mark=<LastEdited> 
{CHARS$ <Doug Wyatt on February 13, 1984
>}}
{PARA$ PROPERTIES$ PROPERTIES.Mark=<LastEdited> 
{CHARS$ <Rick Beach on May 9, 1984
>}}
{PARA$ PROPERTIES$ PROPERTIES.Mark=<LastEdited> 
{CHARS$ <Subhana, May 30, 1984 11:02:13 am PDT
>}}
{PARA$ STYLE$ STYLE.FORMAT=code PROPERTIES$ PROPERTIES.Mark=<centerVersoHeader> 
{CHARS$ <Rick Beach, May 30, 1985 3:00:19 pm PDT (Cedar6.0)
>}}
{PARA$ STYLE$ STYLE.FORMAT=code 
{CHARS$ <Michael Plass, August 7, 1985 4:44:34 pm PDT
>}}}
{PARA$ STYLE$ STYLE.FORMAT=unleaded 
{CHARS$ <T>}
{CHARS$ LOOKS$ LOOK.s=TRUE <IOGA>}
{CHARS$ < E>}
{CHARS$ LOOKS$ LOOK.s=TRUE <DITOR>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=unleaded PROPERTIES$ PROPERTIES.Mark=<centerRectoHeader> 
{CHARS$ <T>}
{CHARS$ LOOKS$ LOOK.s=TRUE <IOGA>}
{CHARS$ < E>}
{CHARS$ LOOKS$ LOOK.s=TRUE <DITOR>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=unleaded PROPERTIES$ PROPERTIES.Mark=<centerVersoFooter> 
{CHARS$ LOOKS$ LOOK.s=TRUE <CEDAR 6.0  FOR INTERNAL XEROX USE ONLY>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=unleaded PROPERTIES$ PROPERTIES.Mark=<centerRectoFooter> 
{CHARS$ LOOKS$ LOOK.s=TRUE <CEDAR 6.0  FOR INTERNAL XEROX USE ONLY>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=title 
{CHARS$ <The Tioga Editor
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.m=TRUE LOOK.s=TRUE <c>}
{CHARS$ LOOKS$ LOOK.s=TRUE <  Copyright 1984, 1985 Xerox Corporation.  All rights reserved.
>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ LOOKS$ LOOK.b=TRUE <Abstract: >}
{CHARS$ < Tioga is a system to help you prepare documents.  Its two main components are an editor and a typesetter.  The editor lets you prepare the textual content of a document.  The typesetter composes the document into pages for printing.  Tioga is capable of dealing with simple technical papers and memos, and is well integrated within Cedar to support more mundane tasks such as writing programs.  In future versions, it will be suitable for complex technical documents and books and will support tables, math formulas, and illustrations containing synthetic graphics and scanned images.
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ <When viewing this document on-line, use the level-clipping functions to see the overall structure rather than simply plowing straight through.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click the "Levels" button in the top menu, then >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click "FirstLevelOnly" in the new menu that appears.  This will show you the major section headings.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click "MoreLevels" to see the subsections, or "AllLevels" to read the details.
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ LOOKS$ LOOK.b=TRUE <Created by:>}
{CHARS$ < Bill Paxton
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ LOOKS$ LOOK.b=TRUE <Maintained by:>}
{CHARS$ < TiogaImplementors^.pa
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ LOOKS$ LOOK.b=TRUE <Keywords:>}
{CHARS$ < Tioga, editor, formatter, WYSIWYG, document model, style, EditTool
>}}
{PARA$ STYLE$ STYLE.FORMAT=abstract 
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=boilerplate 
{CHARS$ LOOKS$ LOOK.q=TRUE <XEROX>}
{CHARS$ <			>}
{CHARS$ LOOKS$ LOOK.o=TRUE <Xerox Corporation>}
{CHARS$ <
				>}
{CHARS$ LOOKS$ LOOK.o=TRUE <Palo Alto Research Center>}
{CHARS$ <
				>}
{CHARS$ LOOKS$ LOOK.o=TRUE <3333 Coyote Hill Road>}
{CHARS$ <
				>}
{CHARS$ LOOKS$ LOOK.o=TRUE <Palo Alto, California 94304
>}
{CHARS$ LOOKS$ LOOK.b=TRUE LOOK.o=TRUE LOOK.x=TRUE <
For Internal Xerox Use Only>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Overview
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Some editors represent a document as a list of paragraphs.  In Tioga, a document is a tree structure rather than a list so that you can explicitly represent its hierarchical structure.  In discussing the document tree we use Computer Science terminology in which a branch is recursively defined to be a node having zero or more children branches.  The root node of the document tree is not displayed  although it can be modified by a few special commands  so the document basically appears to be a list of top-level branches.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Each node in the tree contains text.  The characters of the text can have >}
{CHARS$ LOOKS$ LOOK.e=TRUE <looks>}
{CHARS$ < which control various aspects of their appearance such as font and size.  Appearance is also influenced by the >}
{CHARS$ LOOKS$ LOOK.e=TRUE <format>}
{CHARS$ < of the node which determines things such as vertical and horizontal spacing.  The document refers to the names>}
{CHARS$ LOOKS$ LOOK.e=TRUE < >}
{CHARS$ <of looks and formats, but not to any specific interpretation of them.  The interpretations are instead collected in a >}
{CHARS$ LOOKS$ LOOK.e=TRUE <style>}
{CHARS$ < which can be shared by many documents.  For example, in the style for this document there are definitions of formats for titles, headings, and standard paragraphs, and there are definitions of looks for emphasis and for small caps.  Rather than specifying all the details for the formats and looks, the document refers to them by name so it is easy to change the definitions in the style and modify the appearance uniformly throughout the document.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <User Categories
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The Tioga user-interface is `layered' so that beginning users can protect themselves from the confusion that results from mistakenly giving a command.  In ways described below, you can tell the system that you are either a beginner, an intermediate, or an advanced user.  In the current Cedar environment, the default is advanced, so beware.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <As far as the Tioga user-interface is concerned, the user category determines which keyboard commands are currently enabled.  As a beginner, you get the commands that use the special keys at the left and right of the keyboard, plus >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ < for backspace character and word, respectively.  As an intermediate user, you add a large number of commands that use print keys in combination with the various shift keys.  As an advanced user, you add the keyboard commands for manipulating the document tree structure.  Any category of user can get at any of the commands by using the EditTool.  The user category mechanism is meant to let you protect yourself, not to limit you.  The default user category in the user profile distributed with Cedar is Advanced.   You are free to change your own category at any time you feel like it.  For example, to declare yourself to be an intermediate user, edit your user profile file to say >}
{CHARS$ LOOKS$ LOOK.o=TRUE <UserCategory: Intermediate>}
{CHARS$ <.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Input Devices
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Mouse
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The mouse has three buttons named >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <, and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ < corresponding to their physical layout.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Keyboard
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The keyboard is used for commands as well as text input.   Here are the names for the special keys:
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <	top right blank key.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ <	middle right blank key.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ LOOKS$ LOOK.s=TRUE <REPEAT>}
{CHARS$ <	key labelled >}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ LOOKS$ LOOK.s=TRUE <DELETE>}
{CHARS$ <	key labelled >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOAD FILE>}
{CHARS$ <	key labelled >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ <.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <The bottom right blank key is an alternative >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key.  You can use either >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key and either >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key interchangeably.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Scrolling and Thumbing
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To move a viewer to look at a different part of the document, move the cursor into the left margin until it becomes a double arrow pointing both up and down.  The part of the margin that becomes gray is called the >}
{CHARS$ LOOKS$ LOOK.i=TRUE <scroll bar>}
{CHARS$ <.  The dark gray part shows the relative size and location of the currently visible portion of the document.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click to move the text adjacent to the arrow to the top of the viewer.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to move the text from the top of the viewer down to the arrow.  These operations are called >}
{CHARS$ LOOKS$ LOOK.i=TRUE <scrolling>}
{CHARS$ < the document.  
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you hold down >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ < in the scroll bar, the cursor becomes a right-pointing arrow.  If you move the cursor to >}
{CHARS$ LOOKS$ LOOK.i=TRUE <x>}
{CHARS$ <% down from the top of the viewer and let up, the viewer will change to start about >}
{CHARS$ LOOKS$ LOOK.i=TRUE <x>}
{CHARS$ <% of the way through the document.  This operation is called >}
{CHARS$ LOOKS$ LOOK.i=TRUE <thumbing>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Changing levels when you scroll 
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In a document such as this one that uses levels to reflect its logical structure, it is often useful to start with a view of the first level only and then progressively scroll the document and show more levels as you zoom in on a particular topic.  This process is slowed when you have to move the mouse between the scroll bar and the levels menu, so we have made it possible to scroll and change levels in a single operation.  This works by using the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < keys as modifiers of the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click that causes scrolling up.
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Scroll up and show more levels  >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click (hold the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key (either one) down when >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking to scroll)
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Scroll up and show all levels  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click >}
{CHARS$ LOOKS$ LOOK.s=TRUE <(>}
{CHARS$ <hold >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < down when >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking to scroll)
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Scroll up and show minimum levels  >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click (hold both the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < keys down when >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking to scroll).
>}}
{PARA$ STYLE$ STYLE.FORMAT=pagebreak 
{CHARS$ <
>}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The details of making selections will be covered later on.  For now, you simply need to know that there is a single primary selection on the screen.  The viewer containing the selection is referred to as the >}
{CHARS$ LOOKS$ LOOK.i=TRUE <selected viewer>}
{CHARS$ <.  Many of the following commands deal with the selection or the selected viewer. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Undo
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <While undo is described later in more detail, hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT-ESC>}
{CHARS$ < undoes the most recent edit sequence and restores the selection to its prior state.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Naming Files
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Tioga traffics in full FNames (see the >}
{CHARS$ LOOKS$ LOOK.i=TRUE <Naming Files>}
{CHARS$ < section of FSDoc.tioga).  When a file has been loaded into a Tioga viewer, the viewer's caption displays the file's full FName.  A Tioga viewer without a backing file displays just a working directory, ending in `>>'.  In either case, the working directory associated with a Tioga viewer is the part of the viewer's name up to the last `>>'.  For most Tioga operations that deal with files, you can specify just a short name, letting the viewer supply the working directory.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Typically you will want to view the most recent version of a file.  If you omit the version part when specifying a file name, Tioga will find the most recent (!H) version.  The viewer's caption will display the actual version number in parentheses.  Furthermore, if another version of that file is created, Tioga will automatically reload the viewer with the newer version.  (Exception: if a newer version is created while you are editing the older version, Tioga will flash a warning instead of reloading the viewer.)  If you name a file with an explicit version number, Tioga will display the version number as part of the file name, and will never automatically reload the viewer. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Emergency Save All Edits
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If your machine hangs up, and you have some unsaved documents, hold down >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.k=TRUE <SWAT>}
{CHARS$ < (i.e., both shift keys and the bottommost blank key) for about a second.  This will save all of your edits, if possible.  The cursor changes to a square while the save is taking place.  Documents in unnamed viewers will be stored with names like "[]<>>SaveAllEdits-*.tioga".
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Menus
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Top level menu
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Clear  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <creates an empty viewer.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <LEFT>}
{CHARS$ <-click the Clear button, the `clicked' viewer is cleared.  If you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <MIDDLE>}
{CHARS$ <-click the Clear button, a new >}
{CHARS$ LOOKS$ LOOK.r=TRUE <empty >}
{CHARS$ <viewer is created below the clicked one.  Finally, if you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <RIGHT>}
{CHARS$ <-click the Clear button, the clicked viewer is closed and a new >}
{CHARS$ LOOKS$ LOOK.r=TRUE <empty >}
{CHARS$ <viewer appears in its place.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In the viewer's caption (at the top, where the file name would normally appear), an empty viewer will display just a working directory, ending in `>>'.  An empty viewer produced by Clear inherits its working directory from the `clicked' viewer.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Naturally the most common thing to do with an empty viewer is to load a file.  If you type a file name into an empty viewer and then hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ <, it is as if you selected the name and hit Get but no confirmation is required.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ < provides a similar function for GetImpl.  You can also type a working directory name (ending in `>>' or `/') and hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ <; this will simply change the working directory for the empty viewer.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Reset  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <discards edits by reloading the filed version of the document.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.r=TRUE <Reset is a guarded menu command to prevent accidental loss of edits.  The line through the menu item represents the guard.  The first click removes the guard for a short time interval and posts a confirmation message in the window at the top of the screen.  A second click >}
{CHARS$ LOOKS$ LOOK.e=TRUE <while the guard has been removed>}
{CHARS$ < executes the command. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Get>}
{CHARS$ LOOKS$ LOOK.r=TRUE <  loads the file named by the selection into a viewer.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <LEFT>}
{CHARS$ <-click the Get button, the file is loaded into the `clicked' viewer and replaces the previous contents.  If you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <MIDDLE>}
{CHARS$ <-click the Get button, a new viewer is created below the clicked one in the same viewer column.  Finally, if you >}
{CHARS$ LOOKS$ LOOK.k=TRUE <RIGHT>}
{CHARS$ <-click the Get button, the clicked viewer is closed to make it iconic and a new viewer appears in its place.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If the selected name is a partial name (not beginning with `[' or `/'), Tioga interprets the name in the `clicked' viewer's working directory.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If the selected name does not include an explicit extension, Tioga will search for the file using a set of standard extensions.  The default extensions are mesa, tioga, df, cm, config, and style.  You can specify your own list of extensions with a user profile entry for >}
{CHARS$ LOOKS$ LOOK.o=TRUE <SourceFileExtensions>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If the selected name is of the form <alpha>>.<beta>> and such a file exists, it is opened.  Otherwise, if <beta>> is one of the standard set of extensions, you will be informed that the file doesn't exist.  However, if <beta>> is not a standard extension, the system tries to open the file as if you had simply selected <alpha>>.  If this succeeds, it searches in the file for a definition of <beta>> (see Def in the Places menu).  This convention is intended for use with programs that have many instances of <Interface>>.<Item>> in which <Interface>>.mesa is a file containing a definition for <Item>>.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <GetImpl  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <like >}
{CHARS$ <Get>}
{CHARS$ LOOKS$ LOOK.r=TRUE < but loads the file that implements the selected interface name.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If the selected name does not include an explicit extension (i.e., there is no period in the selected text), Tioga will use a set of standard implementation extensions.  Currently, mesa is the only default implementation extension.  You can specify your own list of implementation extensions with a user profile entry for >}
{CHARS$ LOOKS$ LOOK.o=TRUE <ImplFileExtensions>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If the selected name is of the form <Interface>>.<Item>> and an implementation for the item is currently loaded, the system will find the name of the file holding the implementation (our thanks to the Cedar runtime model for providing this information).  Otherwise, the system tries to open the file as if you had selected <Interface>>Impl, and, if this succeeds, searches in the file for a definition of <Item>>.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <PrevFile  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <like >}
{CHARS$ <Get>}
{CHARS$ LOOKS$ LOOK.r=TRUE < but reloads the file that was previously in this viewer.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Store  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <like >}
{CHARS$ <Save>}
{CHARS$ LOOKS$ LOOK.r=TRUE < but writes to the file named by the current selection.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Store is also a guarded menu command like Reset.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Save  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <writes a new version of the file>}
{CHARS$ <.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Tioga keeps 2 versions by default when it stores files, so you can retrieve the previous version if necessary.  If the file has a keep property, then Tioga keeps that number of versions.  Use the SetKeep command to change the keep property on a file.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <A Comment Regarding `Unsaved' Documents
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <It is not uncommon to forget to save the contents of a viewer before destroying it or loading something else into it.  However this is not a disaster since Tioga holds onto `unsaved' documents so you can reload them with edits preserved.  The number of such documents that Tioga will remember is set by a profile entry (UnsavedDocumentsCacheSize); the default is four.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Whenever there are unsaved documents, Tioga creates a special viewer named `Unsaved Documents List' containing the names of the unsaved documents.  To retrieve a document with all the unsaved edits, select the entire filename, including a version number if one, and click Open in the system menu area at the top right of the screen.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Unsaved documents are put into the cache by Destroy, Clear, Get, GetImpl, and PrevFile.  They are >}
{CHARS$ LOOKS$ LOOK.e=TRUE <not>}
{CHARS$ < put in by Reset.  If the cache is already full when a new entry arrives, the oldest entry is discarded.  Whenever a file is needed for Get, GetImpl, or PrevFile, the cache is checked to see if an unsaved version is available.  Unnamed documents are not put into the cache.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Time  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <inserts the current time at the caret.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Split  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <creates a new viewer looking at the same document.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The selection is highlighted in one viewer only, however edits will be reflected in all viewers for the document.  Note that the split viewers can be independently closed, opened, or moved on the screen, and may be displayed at different levels of detail (see the Levels menu section).
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Places, Levels  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <show/remove these submenus.>}
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Places
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The Places menu contains commands that cause the viewer to begin displaying at a new place in the document.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <For the first three of the commands (Find, Word, and Def) commands, the button used in clicking the menu item determines how the search is carried out  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click to search towards the end of the document, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to search towards the start of the document, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-click to search first towards the end and, if that fails, then from the start of the document towards the selection.  If the selection is visible in the viewer, the search starts there.  Otherwise, it starts from the top of the viewer.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Find  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <find another instance of the selected text.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In this command and the following two, the direction of search and capitalization are determined by the mouse buttons and >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ < keys.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking searches forward from the current selection point; >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-clicking searches backwards; >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-clicking does a wrap-around search by first searching forward to the end of the document then searching from the beginning until the entire document has been searched.  By default, the search matches capitalization.  Clicking with the >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ < key down invokes a `caseless' search in which capitalization does not matter.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Word  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <find an instance of the selected text that is a `word'.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A word is defined to not have adjacent letters or digits.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Def  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <find a `definition' of the selected text.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A definition is an instance of the selected text that is immediately followed by a colon and isn't  immediately preceded by an alphanumeric.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Position  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <scroll to and select the character position indicated by the selected number.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This is useful with compiler error messages that give locations as character counts.  The command scrolls to the selected character number and then selects it  e.g., if `183' is selected, scroll to and select character number 183 in the document.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Compiler error messages give locations that exclude comment nodes.  For error messages that include comment nodes, such as those from the TSetter, select the number and >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <-click Position to include comment nodes.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Normalize>}
{CHARS$ LOOKS$ LOOK.r=TRUE <  scroll to make the selection visible.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click to scroll to the start of the selection, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to scroll to the end, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-click to scroll to the caret.  If the document in this viewer does not contain the selection, scrolls to the start of the document.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <PrevPlace>}
{CHARS$ LOOKS$ LOOK.r=TRUE <  scroll to place that was previously visible.>}
{CHARS$ <
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Go back to the place that was previously visible in this viewer discounting manual scrolling that may have taken place since.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Reselect  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <restore the most recent selection in this viewer and scroll to it.>}
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Levels
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <These commands in the Levels menu let you control how deep the display goes in the document tree structure.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <FirstLevelOnly  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <show only the top level nodes.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <MoreLevels  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <show one more level than currently.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <FewerLevels  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <show one fewer level than currently.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <AllLevels  >}
{CHARS$ LOOKS$ LOOK.r=TRUE <show all levels of the tree.>}
{CHARS$ <
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Tioga performs its editing operations on selected portions of the document.  The normal method of editing in Tioga is to make a selection and then request an operation.  The selection may be changed at any time prior to requesting the operation be completed.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Two kinds of selections are most frequently used: >}
{CHARS$ LOOKS$ LOOK.i=TRUE <primary>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.i=TRUE <secondary>}
{CHARS$ <.  A third kind of >}
{CHARS$ LOOKS$ LOOK.i=TRUE <feedback>}
{CHARS$ < selection provides feedback for tools that manipulate Tioga documents, such as the debugger identifying the point in a source file corresponding to the current execution stack position by scrolling the source file document and posting a feedback selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Primary selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The primary selection is the one that's around most of the time and is the usual site for edits.  It is displayed with a solid underline or with video reverse.  Make a primary selection with the mouse in ways described below.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Insertion point
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The insertion point goes with primary selection.  It is shown by a blinking `caret' at one end or the other of the selection  the end closer to the cursor when the selection was made or the end most recently extended.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Secondary selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The secondary selection is a selection made with the >}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ < key held down.  It is displayed with a gray underline or with a gray background.  Secondary seletions are often involved in Copy and Move operations.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Making selections
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <The selection hierarchy
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The selection hierarchy consists of the following granularities: point, character, word, node, branch, and document.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Point selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The primary selection has a blinking caret at one end.  Some operations, such as delete and type-in, reduce the selection to just the caret.  This is called a point selection.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Character selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click with the cursor over the desired character.  You can hold the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ < button down and move to the correct place before letting the button up.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You can cancel the new selection by hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ < while the mouse button is still down.  Tioga will restore the previous selection.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Word selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A `word' is defined as a sequence of letters and digits or a sequence of identical characters that are not letters or digits.  Use the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ < mouse button to make word selections.  As with character selection, you can hold >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ < down and move to the correct word before letting up.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Node selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-double-click to select a node.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Branch selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A branch is a node and any children branches it might have.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-double-click to select a branch.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Document selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <D>}
{CHARS$ < extends the selection to include the entire document.  `D' stands for for `Document'.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selection extension
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Extend an existing selection by pointing at a new endpoint either before or after the selection and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-clicking.  The system will extend the end of the selection closer to the cursor when >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ < goes down.  You can hold >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ < down and move the endpoint to a new position.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you just >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click, the selection is extended at the same level in the selection hierarchy.  For example, a selection at the word level will be extended a word at a time.  Double->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to extend at a lower level in selection hierarchy.  Triple->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to extend at a higher level in selection hierarchy.  Thus, if you have a node-level selection and wish to extend it to a word position within a node, double->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to reduce the level to words and then do the extension.  If necessary, you can then double->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click again to reduce to character level.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Editing by making selections
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Delete selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A >}
{CHARS$ LOOKS$ LOOK.e=TRUE <delete selection>}
{CHARS$ < is deleted as soon as the selection is completed.  It is shown as video reverse.  Hold down >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < to make a delete selection.  The selection is complete when you let up on both the mouse button and the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Pending-delete selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <`Pending-delete' selections are automatically deleted by subsequent insertions.  They are shown with video reverse rather than solid underline.  Whenever you extend a selection by >}
{CHARS$ LOOKS$ LOOK.k=TRUE <RIGHT>}
{CHARS$ <-clicking, the selection is automatically made pending-delete.  Notice that you don't have to actually point to a new place in the text to `extend' a selection.  For example, you can >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-click to select a word and then >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click without moving the mouse to make it pending-delete.  Or you can combine these actions by `rolling' from the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ < or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ < mouse button to the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ < button to make a char or word selection pending-delete.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Copy and Move
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Copy and Move operations require two selections, one for the source of the operation and the other for the destination.  The Primary and Secondary selections are used for these.  Secondary selections are made with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key held down and are shown with a gray underline.  
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Copy secondary to primary
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you hold down the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key and select, the source selection will be copied.  If the primary selection is currently pending-delete, it will be replaced by the copy of the source.  Otherwise, the copy will be inserted at the caret.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Move secondary to primary
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you hold down both the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key and the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key, the source selection will be moved.  As before, if the primary selection is pending-delete, it will be replaced by the source.  Otherwise, the source will be moved to the caret.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Destination selections for Copy and Move
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The operations described above work by copying or moving a secondary selection to the primary selection.  However, sometimes the primary selection is itself the thing you want to copy or move.  The following two commands take care of these situations.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Copy primary to secondary
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To copy the primary selection, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-S>}
{CHARS$ <, and with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key still held down, select a destination.  The copy takes place as soon as you let the keys up.  The primary selection is made not-pending-delete as soon as you hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-S>}
{CHARS$ < to indicate that it will be copied rather than moved.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Move primary to secondary
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To move the primary selection, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-Z>}
{CHARS$ <, and with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key still held down, select a destination.  The move takes place as soon as you let the keys up.  The primary selection is made pending-delete as soon as you hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-Z>}
{CHARS$ < to indicate that it will be moved rather than copied.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Transpose selections
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <We now have covered commands to copy or move either the primary or the source selections.  A final option is to transpose the primary and the source.  To do this, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-X>}
{CHARS$ <, and with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key still held down, select a source.  The primary selection is made pending-delete as soon as you hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-X>}
{CHARS$ < to indicate that it will be moved rather than copied.  The transpose takes place as soon as you let the keys and mouse buttons up.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Miscellaneous
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Cancelling a selection
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ < before finishing the selection and the previous selection will be restored.  This works during either primary, source, destination, or transpose selections.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Placeholders
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A `placeholder' is all the text between a matching pair of placeholder brackets,>}
{CHARS$ LOOKS$ LOOK.t=TRUE < 
 >}
{CHARS$ <.  Hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < to find and select the next placeholder beyond the current selection.  Hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < to find the previous one.  Recall that >}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < is the blank key to the right of >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RETURN>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If there isn't another placeholder, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < will move the selection to the end of the document.  If the selection is already at the end, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < will try to find the next nested text viewer.  Similarly, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < will move the selection to the start of the document if it doesn't find a previous placeholder and will try to find the previous nested text viewer if it is already at the start.  This allows you to use >}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ < both when filling in placeholders within a document and when filling in text viewers in tools.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Select visible  expand selection to blanks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <V>}
{CHARS$ < expands the selection to include the `visible' characters on the left and right ends.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This is useful for selecting things like full file names.  For example, in the following you could make a character selection anywhere in the name and then extend the selection with >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <V>}
{CHARS$ <.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Filed on:  [Cedar]<Cedar6.0>>Documentation>>TiogaDoc.tioga
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Select matching brackets
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-] extends the selection to the left and right to find a matching pair of [..]'s.  Similarly for >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-}, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-), and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->>.  Note that you hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < with the right bracket to extend the selection.  In addition, you can hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < with the left bracket to insert matching brackets around the selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <Unfortunately, our keyboards don't have both left and right quote keys.  However most of the fonts, including TimesRoman and Helvetica, do provide a left and right single quote.  The keyboard quote key inserts a right single quote (code 047); the left single quote (code 140) can be inserted using the MakeOctalCharacter command in the EditTool or with the Insert Matching Single Quotes command (CTRL-').  The EditTool also has a command which extends the selection to find a matching pair of left and right single quotes.  The situation for double quotes is even less uniform.  Some fonts, such as Classic, have a left double quote (code 264) in addition to a right double quote (code 042).  However, most fonts have only the 042 double quote, so the Tioga commands for inserting and matching double quotes use that code exclusively.
>}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Editing
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Text input
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Typed-in characters are inserted at the caret.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To insert the current time use >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <T>}
{CHARS$ <  `T' for >}
{CHARS$ LOOKS$ LOOK.e=TRUE <Time>}
{CHARS$ <.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you insert a carriage return by hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RETURN>}
{CHARS$ <, the system will automatically copy the blank characters (tabs and spaces) from the start of the previous line.  To suppress this, type >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RETURN>}
{CHARS$ < and only the carriage return will be inserted.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To insert control characters or characters with a specific octal code, use >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-K>}
{CHARS$ < or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-O>}
{CHARS$ <.  The former will change the character before the caret to a control character, while the latter will convert the three digits before the caret to the corresponding octal character.  The inverse operations are also available as >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-SHIFT-K>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-SHIFT-O>}
{CHARS$ <.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Abbreviation Expansion
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <E>}
{CHARS$ <  `E' for >}
{CHARS$ LOOKS$ LOOK.e=TRUE <Expand abbreviation>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <E>}
{CHARS$ <, the caret is moved to the right of the selection if necessary and the keyname to the left of the caret is then replaced by the expansion text (according to the definition which is linked to the style in a manner described below).  If the keyname had looks, they are added to the expansion.  If the keyname was all caps, the expansion is made all caps too.  If the keyname had an initial cap, the first character of the expansion is made uppercase (useful at the start of sentences, for example).  If the definition node has a non-null format, the format of the caret node is changed to be the same as the definition node.  If the expansion contains a placeholder, the first placeholder is selected.  Otherwise the entire expansion is selected.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Definitions for abbreviations come from Tioga documents which are automatically read by the system when needed.  The name of the appropriate abbreviations file is determined by the style>}
{CHARS$ LOOKS$ LOOK.e=TRUE < >}
{CHARS$ <that is in effect at the caret when the expansion takes place.  For example, if the style is `Report', the abbreviations will come from the file `Report.Abbreviations'.  You can override this by explicitly naming the abbreviations file along with the keyname.  For example, `Mesa.proc' will expand the abbreviation for `proc' from the file `Mesa.Abbreviations' independent of the style in effect at the caret.  (>}
{CHARS$ LOOKS$ LOOK.s=TRUE <Fine point: Since the system interprets a period before the keyname to mean that you're specifying a particular abbreviations file, you cannot type a vanilla abbreviation after a period.>}
{CHARS$ <)
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Each definition in an abbreviations file consists of a separate branch. The top node of the branch holds the keyname followed by an equals sign and then the text expansion.  The rest of the branch, if any, is copied after the caret node as part of expanding the abbreviation; if the text expansion following the keyname is empty, then the rest of the branch will be at the same level as the caret node, otherwise, the rest of the branch is nested underneath the caret node.  Any text following the keyname is moved to the end of the last child node in the branch.  The definition may also include a list of operations to be performed after the expansion has been inserted.  These operations have the same format as those in EditTool and are placed in parentheses after the keyname and before the equals sign. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Delete Character or Word
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <BackSpace: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ <, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H>}
{CHARS$ <, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <.  Deletes the character to the left of the caret.
>}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <If the caret is at the start of a node, this does a Join command (q.v.).
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <BackWord: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ <, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <.  Deletes the word to the left of the caret.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <DeleteNextChar: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ <, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H>}
{CHARS$ <, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <.  Deletes the character to the right of the caret up to the end of a node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <DeleteNextWord: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ <, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <.  Deletes the word to the right of the caret up to the end of a node.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Delete
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <As mentioned above, you can delete something by selecting it with >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < held down.  In addition, you can delete the current selection by hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ <. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Paste
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Paste: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <P>}
{CHARS$ <.  The most recently deleted text is copied to the caret.  You can also use the EditTool to save the current selection to be pasted later.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Copy, Move, Replace, and Transpose
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <These operations are all carried out by making selections.  They are described in detail in the previous section.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Insert matching brackets
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-[ adds a matching pair of [..]'s to the ends of the selection.  Similar >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < commands exist for {, (, <, -, ', and ".  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <B>}
{CHARS$ < inserts matching placeholder brackets >}
{CHARS$ LOOKS$ LOOK.t=TRUE <
.>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.t=TRUE <Note: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-'>}
{CHARS$ LOOKS$ LOOK.t=TRUE < inserts a left single quote (code 140) and a right single quote (code 047); >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-">}
{CHARS$ LOOKS$ LOOK.t=TRUE < inserts the same character (code 042) at each end of the selection. >}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=pagebreak 
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Case
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <All lower: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C.  >}
{CHARS$ <Makes the selection all lower case.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <All caps: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C>}
{CHARS$ <.  Makes the selection all upper case.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <First cap: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-double >}
{CHARS$ LOOKS$ LOOK.s=TRUE <C.  >}
{CHARS$ < Capitalizes the first word of the selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Initial caps: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-double >}
{CHARS$ LOOKS$ LOOK.s=TRUE <C.  >}
{CHARS$ < Capitalizes each word in the selection.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Repeat
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ < will repeat the most recent non-empty edit sequence starting with the current selection.  Edit sequences are separated by user-made selections.  For example, if you select a word, delete it, type a new one, and then select something else, the edit sequence is delete followed by text entry.  If you hit Repeat, the system will do a delete and retype the new word.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Auto-repeat is done by >}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ <-select: if you hold down the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ < key while making a selection, a Repeat will automatically be done as soon as the selection is completed.  This is useful when you're doing a large number of repeats.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Undo
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT-ESC>}
{CHARS$ < undoes the most recent edit sequence and restores the selection to its prior state.  If you want to undo more than just the most recent sequence, use the EditHistory tool which is described later.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Tree structure editing
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <As explained in the introduction, Tioga documents consist of a tree of nodes.  The following commands let you break, join, and nest nodes in the tree.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Break: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <RETURN>}
{CHARS$ <  break node at insertion point to create a new node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Join: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <J>}
{CHARS$ <  join node at insertion point with previous node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Nest: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <N>}
{CHARS$ <  move selected nodes to deeper nesting level in tree.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <UnNest: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <N>}
{CHARS$ <  move selected nodes to shallower nesting level in tree.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Break & Nest: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <I>}
{CHARS$ <  simultaneously insert a new node and nest it.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Break & UnNest: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <I>}
{CHARS$ <  simultaneously insert and unnest.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Looks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Characters have looks which are named by the lower case letters `a' to `z'.  Looks are interpreted by the style to change the appearance of the text.  For example, look `e' might stand for >}
{CHARS$ LOOKS$ LOOK.e=TRUE <`emphasis'>}
{CHARS$ < and might result in italic face in one style and bold face in another.  Each character has a set of looks  thus it may have several looks simultaneously, but each look occurs only once.  You can use the EditTool to read or change the set of looks for selected characters.  The following keyboard commands are also available for dealing with looks. 
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selection Looks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You can change the selection looks with the following commands.  (Recall that the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ < shift is the top blank key to the right of >}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <.)
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-char to add to selection looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-char to remove from selection looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-space to remove all selection looks.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Caret Looks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Caret looks determine the looks of typed-in text.  The caret picks up the looks of the adjacent selected text whenever a selection is made.  Changing the selection looks also changes the caret looks.  However, if you wish to change the looks of the caret without changing the selection looks, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click the character key twice in quick succession.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-char-char to add to caret looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-char-char to remove from caret looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-space-space to remove all caret looks.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Using Selections To Copy Looks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To copy the looks of some existing text to the primary selection, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <Q>}
{CHARS$ <, and then with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key still held down, select the text with the looks you want to copy.  The source looks replace any looks the selection previously had. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Automatic Mesa formatting
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <M>}
{CHARS$ < command scans the selection for Mesa keywords, comments, and procedure names and gives them looks k, c, and n respectively.  (As a convenience during typein, the entire caret node is reformatted if the selection is a single character or less.)  With the standard Cedar style, the keywords will then be displayed in small caps, the comments will be italic, and the procedure names will be boldface.  We expect to provide more extensive reformatting capabilities in the future.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Formats
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Just as characters have looks, nodes have formats.  The `format' is the name of a rule in the style that tells how to modify various parameters when displaying the node.  For example, a style for documents might contain formats for titles, headings, quotations, standard paragraphs, etc.  The EditTool has facilities for reading and changing the format of a node, or you can use the commands described below.  (By convention, the null format name is equivalent to `default'.)
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Setting and inserting caret node format
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <_>}
{CHARS$ < will delete the word to the left of the caret and make it the format of the caret node.
>}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <In most cases you will give this command immediately after typing the format name, so the caret will naturally be in the correct place.  However, to handle cases in which you select the name before hitting CTRL->}
{CHARS$ LOOKS$ LOOK.s=TRUE <_>}
{CHARS$ <, the caret will automatically be forced to the right of the selection at the start of this command.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <_>}
{CHARS$ < inserts the format name at the caret.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This gives you a simple way to find out the format of a selected node.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Using selections to copy formats
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To copy the format of some exisiting node to the selection nodes, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <F>}
{CHARS$ <, and then with the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key still held down, select the node with the format you want to copy. 
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <The EditTool
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The EditTool provides a variety of operations on Tioga documents.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The text fields in the EditTool follow the convention that clicking the field name with >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ < causes the contents of the field to be selected pending-delete while clicking with >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ < causes the field to be cleared and selected.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Search and Substitute
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Search
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To do a search, enter the text you're looking for in the `Target' field, select where you want the search to start, and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click `Search' to search forward, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to search backwards, or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MIDDLE>}
{CHARS$ <-click to search first forward then backwards.  The system searches from the current selection and updates the selected viewer if the search succeeds.  (Fine point: in both searches and substitutes, the match is limited to a single node  we do not yet have mechanisms for doing matches across node boundaries.)
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The multiple choices below the `Replacement' field control what is matched in searches and replaced in substitutes.  You can select or deselect an item by clicking it with the mouse.  White text on black background means that the item is selected; black text on white means it is not selected.
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Text  if this option is selected, match characters of target text when searching.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Looks  if selected, match looks of target text when searching.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Format  match format of target node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Style  match style of target node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Comment  match comment property of target node.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <For example, if you pick the Looks option and deselect the Text option, you can search for any text that has a particular set of looks.  If you pick only Text, the matching will ignore the looks of the target.  If you pick Text and Looks, the matching text must match both the characters and the looks of the target text.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The other options deal with node properties.  If you pick Format, the matching will be limited to nodes with the same format as the target node.  Similarly, if you pick Style, the matching will only look at nodes whose style is the same as the target node's.  Finally, if you pick Comment, the match will consider only nodes with the same value of the Comment property (>}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ < or >}
{CHARS$ LOOKS$ LOOK.s=TRUE <FALSE>}
{CHARS$ <) as the target.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The first two rows of boxes below the multiple choices give you control over how matching is performed.  >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click with the cursor over a box to change the choice next to it.  The various choices are as follows:
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <1.  Case of matching text
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match Case  matching text must have same case as target text.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Ignore Case  matching text does not have to have same case as target text.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <2.  Interpretation of target text
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match Literally  don't treat target text as a pattern.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match as Pattern  do treat target as pattern.  (Patterns are described below.)
>}}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <3.  Context of target text
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match Anywhere  ignore context of matching text.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match Words Only  matching text must not have adjacent letters or digits.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Match Entire Nodes Only  matching text must span entire node.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <4.  Matching target looks
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Subset as Looks Test  looks of matching text must include target looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Equal as Looks Test  looks of matching text must be identical to target looks.
>}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Substitute
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To do a substitution, enter the new text in the `Replacement' field, enter the text to be replaced in the `Target' field, and hit `Substitute' in the menu at the top of the EditTool.  The Text/Looks/Format/... options guide the search in the usual manner and also control what is replaced.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you pick Text and Looks, the matching text will be replaced just as if you had selected it with pending delete and made a source secondary selection of the replacement text.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you pick only the Looks option, the matching text will have the target looks removed and the replacement looks added.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you pick only Text, the replacement text will have the looks of the replaced text added to it.  (Fine point: if the looks of the replaced text are not uniform, the looks of the first character will be used throughout.)
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If you pick Format, the matching node will get the format of the replacement node.  Similarly, picking Style causes the matching node to get the style of the replacement node, and picking Comment causes the matching node to get the same value of the Comment property as the replacement node. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The final three boxes in the Search&Substitute section give you further control over this operation.
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <1.  First character capitalization of the replacement text
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <First cap like replaced  if the replaced text starts with a capital letter, force the first letter of the replacement to be a capital too.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Don't change caps  leave the replacement capitalization alone.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <2.  What is done to the matching text
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Do Replace  do the usual substitute or replace.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Do Operations  instead of doing a replace, select the matching text and then do the operations currently in the `Operations' field of the EditTool.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <3.  Where the substitutions will take place
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Within Selection Only  substitute is limited to current selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <After Selection Only  substitute after selection to end of document.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <In Entire Document  substitute in the entire selected document.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Case-by-Case Substitutes
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In addition to doing global substitutes, you can decide on a case-by-case basis whether or not to replace the matching text by the new text.  Use the search commands to find the first matching text.  Then if you hit `Yes', the system will do a `Replace' followed by a search forward.  If you hit `No', it will skip the `Replace' and simply do another search.   Thus to selectively substitute, start with a search, then do `Yes' for the cases you want to change and `No' for the others.  The `Replace' command simply does for the current selection what a substitute would do for a match.  Finally, the `Count' command is available to tell you how many substitutions would take place without actually changing the document. 
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In order to do a search or substitute, you will typically need to fill in the Target or Replacement fields in the EditTool.  Naturally, this changes the selection, and before you can do the operation, you must restore the selection to the place where you actually want it to take place.  The system helps you with this by saving the primary selection if it is not in the EditTool when you >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click either the Target or the Replacement button.  The commands along the top of the EditTool  Search, Substitute, Yes, No, Replace, and Count  restore the saved selection if the primary selection is in the EditTool when they are clicked.  The net effect is that if you start out with the selection in the right place, you can >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click the Target or Replacement buttons, fill in the needed information, and then directly click one of the commands without needing to reselect since the system will do it for you.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Patterns for Search and Substitute
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you specify that the target be matched as a pattern rather than literally, the following symbols in the target text are interpreted specially.  A short summary of these symbols appears at the bottom of the Search&Substitute section of the EditTool.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Characters
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	#		Match any single character.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	*		Match shortest possible sequence of characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	**		Match longest possible sequence of characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	'		Match the next character in the pattern exactly.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~		Match any character except the next one in the pattern.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Alphanumeric characters
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	@		Match any single alphanumeric character (letter or digit).
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	&		Match shortest possible sequence of alphanumeric characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	&&	Match longest possible sequence of alphanumeric characters.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Non-alphanumeric characters
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~@	Match any single non-alphanumeric character.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~&	Match shortest possible sequence of non-alphanumeric characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~&~& Match longest possible sequence of non-alphanumeric characters.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Blank characters
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	%		Match any single blank character.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	$		Match shortest possible sequence of blank characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	$$		Match longest possible sequence of blank characters.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Non-blank characters
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~%	Match any single non-blank character.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~$	Match shortest possible sequence of non-blank characters.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	~$~$	Match longest possible sequence of non-blank characters.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Miscellaneous
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	|		Match start or end of node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	{		Mark start of resulting selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	}		Mark end of resulting selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	<		Mark start of named subpattern.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <	>>		Mark end of named subpattern.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The named subpatterns are of use in substitutes that reorder or duplicate parts of the matching text.  The full syntax for a named subpattern is <name:subpattern>>.   The special case of `match any sequence of characters' is provided as a default  i.e., <name>> is equivalent to <name:*>>.  As far as the matching is concerned, the occurrence of <name:subpattern>> is the same as if the subpattern had appeared without a name, but it has the side-effect of remembering the subsection it matched.  The `Replacement' field can contain <name>>'s corresponding to named subpatterns in the target.  The replacement text is constructed by replacing the <name>>'s with the section of replaced text that matched the subpattern.  The replacement is automatically considered to be a pattern whenever the target is  you don't need to do anything special to get the <name>>'s in the replacement interpreted as subpatterns.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <For example, if the target is
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Target: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <WHILE>}
{CHARS$ < <pred>>[<arg>>] >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DO>}
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <and the replacement is
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Replacement: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <WHILE>}
{CHARS$ < <arg>> >}
{CHARS$ LOOKS$ LOOK.s=TRUE <IS>}
{CHARS$ < <pred>> >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DO>}
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <then `>}
{CHARS$ LOOKS$ LOOK.s=TRUE <WHILE>}
{CHARS$ < blue[moon] >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DO>}
{CHARS$ <' will be converted to `>}
{CHARS$ LOOKS$ LOOK.s=TRUE <WHILE>}
{CHARS$ < moon >}
{CHARS$ LOOKS$ LOOK.s=TRUE <IS>}
{CHARS$ < blue >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DO>}
{CHARS$ <'. 
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Looks, Formats, Styles, and Properties
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Looks
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The Looks commands let you read and modify the looks of the caret or the selection.  The looks are shown as a series of letters in the `Looks characters' field.  The box lets you pick whether you want the looks for the selection or the looks for the caret.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Get  fills the `Looks characters' field with the letters for the caret/selection looks.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Set  reads the `Looks characters' field and sets the looks of the caret/selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Clear  removes all looks from the caret/selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add  adds the specified looks to the caret/selection.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Sub  removes the specified looks from the caret/selection. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Formats
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The Format commands let you read and modify the format for the root node or the selected nodes.  The box at the right lets you pick the case you want.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Get  fills the `Format name' field.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Set  reads the `Format name' field and sets the node's format.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Clear  removes the node's format name.  This is the same as specifying `default' format.
>}}
{PARA$ STYLE$ STYLE.FORMAT=pagebreak 
{CHARS$ <
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Styles
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A style is a collection of interpretations for looks and formats.  The definition of style rules are described later in their own section.  The Style commands in the EditTool let you read and modify the name of the style for the root node or the selected nodes.  The new style applies to the specified node and all the nodes within its sub-branches that do not themselves have explicit styles.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Get  fills the `Style name' field.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Set  reads the `Style name' field and sets the node's style.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Clear  removes any style specification from the node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <LoadStyleDefinition  reads the `Style name' field and reloads the style definition from that file with extension `Style'.  (Don't put the extension in the field  just put the style name and let the system add the extension.)  Do this operation after you have edited (and saved) the style definition and want to load the new version.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <LoadAbbreviations  reads the `Style name' field and reloads the abbreviation definitions from that file with extension `Abbreviations'.  Do this after you have edited the abbreviations and want to load the new version.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Properties
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A node can have an arbitrary set of `properties'.  Each property consists of a name and a value.  Certain properties are used by the system, but you (and your programs) are free to add others.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The `Property name' field specifies the name of a property.  (Incidentally, case distinctions do matter in property names  `foo' is a different property than `Foo'.)  The `Property value' field specifies a value.  The box lets you pick whether you are talking about properties of the root node or the selected nodes.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Get  fills the `Property value' field with the current value of the named property.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Set  reads the `Property value' field and sets the property value.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Remove  removes the named property from the node.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <List  fills the `Property name' field with the names of the node's properties.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Properties may also be applied at the character level; click the box until it says "For selected characters".  Character properties are not always interpreted the same way as the node properties, but the Postfix property (see below) works for both.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In addition to setting and reading properties, there is a mechanism that lets you find nodes with a certain property value.  For example, if you have annotated a document with comments under the property name `MyOpinion', and you want to find nodes in which your comment included the word `good', enter the name in the `Property name' field and the text in the `Value pattern' field.  Then use the `Find' command to search forward or backwards from the caret node for a node with a value of the property that matches the pattern.  (>}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click to search forward, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to search backwards.)  Value patterns can use the standard set of special characters for searches.  If a match is found, the node is selected and the property value is displayed.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Comment Property
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <All nodes have a `Comment' property which is either `>}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ <' or `>}
{CHARS$ LOOKS$ LOOK.s=TRUE <FALSE>}
{CHARS$ <'.  If its value is >}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ <, the text of the node is not seen by programs such as the compiler that are only interested in the basic text contents.  This makes it possible to intermix documentation and program text without requiring special escape characters to mark the start and end of comments.  You can set the Comment property by using the EditTool or with the following commands.
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-\  set comment property of all selected nodes to >}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-\  set comment property of all selected nodes to >}
{CHARS$ LOOKS$ LOOK.s=TRUE <FALSE>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <If you are worried about not knowing at a glance what is a comment node and what is not, find a StyleRule  in the style that applies to all the formats you are interested in (e.g., `standard' in Cedar.style), and insert the line
>}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <isComment {visible underlining} {none underlining} .ifelse .cvx .exec
>}}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <This will cause the contents of all comment nodes to be underlined.  (You might want to say `strikeout' instead of `underlining' if the style already uses underlining to mean something else, and legibility is not your main concern.)
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Miscellaneous
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Sort and Reverse
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <These commands let you sort or reverse lists of things.  The `Sort' command sorts things in alphabetical order, ignoring case.  `Sort-and-remove-duplicates' is useful when you are merging sets of things.  The box below the Sort button lets you pick whether you want increasing or decreasing order in the result.  The right box lets you pick what will be sorted: text delimited by blanks, lines delimited by carriage returns, or branches of the document tree.  Leading blanks are ignored when sorting lines or branches.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Operations
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <These commands let you construct simple edit macros.  The `Operations' field holds a text description of a command sequence.  The `GetLast' command fills in the Operations with the description of the most recent sequence, i.e., the one a Cancel would cancel or a Repeat would repeat.  `Do' executes the description in the operations field.  `Begin' marks the start of a command sequence.  `End' fills the Operations with the description of the commands since the most recent `Begin'.  `SetCom' stores the operations under the >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-number key for the number in the `Command [0..9]' field.  Conversely, `GetCom' fills the `Operations' field with the current >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-number definition.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To see how this works, select the following word: `hello'.  Hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ < and type in `howdy'.  Now hit the `GetLast' button.  The Operations field should now contain: Delete `howdy'.   Edit the Operations field contents to replace `howdy' by `goodbye', then hit the `SetCom' button (first put 1 in the Command field if it's not already there).  Now select the `howdy' you typed earlier and hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-1.  If all went well, the `howdy' will have been deleted and `goodbye' inserted in its place.  More examples of edit macros will be given later.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Searches and Operations on Files
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You can use the EditTool to look through a list of files for one in which the current search specifications are satisfied.  This can be accomplished by clicking the `SearchEachFile' button after filling in the `Files' field with the file names (or `@' followed by the name of a file that holds the list of file names).  You can also specify a working directory for file lookup by filling in the `Working Directory' field.  When you >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click SearchEachFile, a new viewer is created, and one-by-one the files will be loaded and searched until a match is found.  The list of files will be updated when a match is found, so that when you are finished with one file you can >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-click SearchEachFile again to look for the next one.  You can hit the `Stop' button at the top of the EditTool to interrupt the search, but you should not try doing other operations while the search is in progress since it resets the selection each time it loads a file.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Occasionally you will want to apply certain operations to an entire set of files.  You can do this by filling in the `Operations' field and the `Files' field, and then clicking `DoForEachFile'.  A new viewer will be created, and one-by-one the files will be loaded, selected, edited, and saved.  No confirmation is required for the saves, so the entire process can go on without you.  In fact, you should not try to do anything else while this is going on since the operations use the primary selection.  The one exeception is the `Stop' button which you can hit to terminate the process.  
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Operations via the Command Tool
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You can invoke a set of operations from a command tool as well as directly from the EditTool.  When you run TiogaExecCommands, one of the commands it registers is DoTiogaOps which expects a command line containing operations in the same format as in the operations field.  One possible application of this is to create a command file that initializes various EditTool switches to your favorite settings.  For example, you could use the following command to set up some of the search parameters: DoTiogaOps IgnoreCase MatchWords MatchPattern.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Edit Commands
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This section of the EditTool contains buttons for all the basic edit commands.  These are useful if you can't remember what keys to hit for an infrequent command or if you've set your user category to beginner or intermediate to filter out certain commands.  Many of the buttons correspond to commands that have been documented above.  However, a few of them are primarily of use in constructing edit macros and have not been mentioned before.  For completeness, all the buttons will be given a brief description.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Modifying selections
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CaretBefore  move caret to front of selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CaretAfter  move caret to end of selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CaretOnly  reduce selection to a caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Grow  selection grows in hierarchy of point, character, word, node, branch
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Document  select entire document
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <PendingDelete  make primary selection pending delete
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <NotPendingDelete  make primary selection not pending delete
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <MakeSecondary  make the primary selection become the secondary selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <MakePrimary  make the secondary selection become the primary selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CancelSecondary  remove the secondary selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CancelPrimary  remove the primary selection
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Copy, Move, and Translate
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <ToPrimary  copy/move secondary to primary
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <ToSecondary  copy/move primary to secondary
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Transpose  transpose the primary and the secondary
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Moving the caret
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <GoToNextChar  make primary caret only and move one character toward end of document or one toward start if you >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click instead of >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <GoToNextWord  like GoToNextChar, but move toward end by `words' or one toward start if you >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click instead of >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <GoToNextNode  move caret one node toward end or one toward start if you >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click instead of >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LEFT>}
{CHARS$ <-clicking
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Saving and Restoring the selection
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <SaveSel-A  save primary selection to restore later
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <RestoreSel-A  restore the selection previously saved by SaveSel-A
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <SaveSel-B  save primary selection to restore later
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <RestoreSel-B  restore the selection previously saved by SaveSel-B
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Extend the selection to matching brackets
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <(...)  extend primary selection to matching parens
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <<...>>  extend to matching angle brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <{...}  extend to matching curly brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <[...]  extend to matching square brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <"..."  extend to matching double quotes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <`...'  extend to matching single quotes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <-...-  extend to matching dashes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ LOOKS$ LOOK.t=TRUE <
>}
{CHARS$ <...>}
{CHARS$ LOOKS$ LOOK.t=TRUE <>}
{CHARS$ <  extend to matching placeholder brackets
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Find placeholders
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Next>}
{CHARS$ LOOKS$ LOOK.t=TRUE <
>}
{CHARS$ <...>}
{CHARS$ LOOKS$ LOOK.t=TRUE <>}
{CHARS$ <  move primary selection to next placeholder
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Prev>}
{CHARS$ LOOKS$ LOOK.t=TRUE <
>}
{CHARS$ <...>}
{CHARS$ LOOKS$ LOOK.t=TRUE <>}
{CHARS$ <  move to previous placeholder
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Delete and Paste
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Delete  delete the primary selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Paste  insert saved text at caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <SaveForPaste  save text for later pasting; overwrites text saved by Delete
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Repeat and Undo
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Repeat  repeat the last command sequence
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Undo  undo the last command sequence
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Deleting character/word next to caret
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <BackSpace  delete the character to the left of the caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <BackWord  delete the word to the left of the caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <DeleteNextChar  delete the character to the right of the caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <DeleteNextWord  delete the word to the right of the caret
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Inserting matching brackets around the selection
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add( )  insert parens around the selection
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add< >>  insert angle brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add{ }  insert curly brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add[ ]  insert square brackets
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add" "  insert double quotes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add` '  insert single quotes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add- -  insert dashes
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Add>}
{CHARS$ LOOKS$ LOOK.t=TRUE <
>}
{CHARS$ < >}
{CHARS$ LOOKS$ LOOK.t=TRUE <>}
{CHARS$ <  insert placeholder brackets
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Capitalization
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <AllCaps  make the selection upper case
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <AllLower  make the selection lower case
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <FirstCap  capitalize each word in the selection and make the other letters lower case
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <InitialCaps  capitalize the first word in the selection and make the other letters lower case
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Special characters
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <MakeOctalCharacter  convert the 3 digits before the caret to the corresponding character
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <MakeControlCharacter  convert the character before the caret to a control character
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <UnMakeOctalCharacter  convert the character before the caret to 3 digit representing its character code
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <UnMakeControlCharacter  convert the control character before the caret to a normal character
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Tree structure commands
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Break  break node at caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Join  join caret node to one before it
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Nest  move selection deeper in tree
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <UnNest  move selection higher in tree
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Miscellaneous commands
>}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <CommentNode  set Comment property of all selected nodes to >}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <NotCommentNode  set Comment property of all selected nodes to >}
{CHARS$ LOOKS$ LOOK.s=TRUE <FALSE>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <ExpandAbbreviation  expand the abbreviation to the left of the caret
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <MesaFormatting  add Mesa looks, formats, and style to selection 
>}}
{PARA$ STYLE$ STYLE.FORMAT=item 
{CHARS$ <Command 0 1 2 3 4 5 6 7 8 9  do saved command macro
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Writing Edit Macros
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A few examples should get you started writing your own edit macros.  First, assume you find yourself doing a lot of edits of the form <stuff>> becomes <pred>>[<stuff>>] for various values of <stuff>> and <pred>>.  You might like a single command to insert the brackets and move the caret to the place where you will insert the <pred>>.  To construct such a command, first select a particular <stuff>>, hit the Add[ ] button in the EditTool, the CaretBefore button, and the GoToNextChar button using the right mouse button.  Then hit GetLast to fill the Operations field, enter `1' in the `Command [0..9]' field, and hit SetCom to save the macro definition.  Now you can select <stuff>>, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-1, and be ready to insert before the left bracket.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A macro to delete matching parentheses will show the use of the SaveSel and RestoreSel commands.  Make a selection anywhere inside a pair of matching parens.  Give the following sequence of commands: (...) to extend the selection, CaretAfter to position the caret at the right, SaveSel-A so we can restore the selection later, BackSpace to delete the right paren, RestoreSel-A to get the selection back, CaretBefore to move the caret to the front, and finally DeleteNextChar to delete the left paren.  Now you can hit GetLast and SetCom to save this macro.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Other operations on the EditTool can also be programmed using edit macros.  For example, assume you want a macro to substitute `which' for `that'.   The following set of commands will load the target and replacement fields and do the substitute: >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to select and clear the target field, type `that' as the target text, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <RIGHT>}
{CHARS$ <-click to select and clear the replacement field, type `which' as the replacement text, and finally hit the Substitute button.  This macro will only change the target and replacement fields.  The other parameters of the substitute are not changed and thus behave like `free variables' of the macro.  If you want to bind more of the choices, such as Match Case or Ignore Case, you simply include those commands as part of the macro.  For example, you could select Ignore Case just before restoring the selection, and the macro would always set the ignore case flag when it was executed.  Note that you must hit the `Target' and `Replacement' buttons to enter the target and replacement text.  Directly selecting in those fields would not produce a correct macro because it would terminate the edit sequence and would also fail to identify which field was being filled in.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you save an edit macro under a >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-number key, it only stays around for the rest of the session.  If you want to save one for tomorrow, you can of course copy the operations to a file and redefine it another time.  But if you really want to make a macro a permanent part of your user interface, you can add it to your `TIP table' which describes the translation from keyboard and mouse actions into executable tokens such as those in edit macros.  The details of how to do this are given in a later section. 
>}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <The EditHistory Tool
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The EditHistory tool lets you undo edits in the same way that Undo does, but it lets you go back farther in history than just the most recent sequence.  To create an EditHistory tool, type `EditHistory' to the CommandTool.  At the top of the tool are two fields and four commands.  The bottom part of the tool is a text field to hold descriptions of previous edit events.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The system keeps a history of a certain number of the most recent edit events.  You can find out how large this history is by the `Get' command which will enter a number in the `history size' field.  The `Set' command will change the history size to whatever value you've entered in the size field.  The default size is 20; you can change this by making an entry in your User.Profile of the form `EditHistory: <history-size>>'. 
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The `Show' command will display the events starting with the number in the `since event number' field.  If that field is empty it will show as many as are still remembered.   The format of the entries is <event-number>>, >}
{CHARS$ LOOKS$ LOOK.s=TRUE <TAB>}
{CHARS$ <, and then a list of operations.  The `Undo' command undoes the edits since the specified event number. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Printing and the TypeSetter Tool
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In the glorious future, Tioga will have an interactive typesetter that will let you make incremental revisions to a typeset document to adjust pagination, page layout, and other details before actually printing it.  Only preliminary work has started on this, but until it's available, the current typesetter will do a more than adequate job of letting you print your files.   Documentation for the TSetter tool may be found in TSetterDoc.tioga.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <TIP Tables for Tioga
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The acronym `TIP' stands for `terminal interface package'.  TIP tables describe the translation from keyboard and mouse actions into executable tokens.  The standard TIP table for Tioga is found in the file `Tioga.TIP' and contains all the gory details about things such as multi-clicks of mouse buttons with various combinations of shift keys.  It's unlikely that you want to try changing anything in Tioga.TIP, but you can consider adding commands to your own TIP table for things such as your favorite set of edit macros.  Your TIP table can be `layered' on top of the Tioga table so that the system will try to interpret actions according to your table before looking at the standard one.  The User.Profile contains an entry named `TiogaTIP' in which you can enter the file name of your TIP table to be layered over the standard Tioga table.  The entry should look like something like this
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <TiogaTIP: MyOwn.tip Default
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <where `MyOwn.tip' is the file name for your table.  Notice that your table goes first in the list; definitions in tables occurring early in the list take precedence over those that appear later.  The special name `Default' refers to Tioga's default TIP table and will typically be the last entry in the list.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The file `MyOwn.tip' contains a sample table that you can edit to produce your own.  It also contains documentation about the syntax of TIP tables and the macro package which is used with them.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Use the command ReadTiogaTipTables to reload a TIP table after you've changed it, or, if your user category is advanced, hit >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-! (really >}
{CHARS$ LOOKS$ LOOK.k=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.k=TRUE <SHIFT>}
{CHARS$ <-1) to reload the Tioga profile information.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Styles
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A style is a collection of interpretations for looks and formats.  The interpretations are represented as procedures written in a simple language that uses the JaM interpreter.  The procedures set various formatting parameters such as font size and line spacing.
>}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <Note: If a document doesn't specify a style, the system will use a default.  You can say what the default will be by adding user profile entries for DefaultStyle or ExtensionStyles (described below).
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <To determine the formatting parameters for a particular node, the system first gets the parameters for its parent and then executes the appropriate formatting procedure from the style.  If the node doesn't have an explicit format, or if the format it has is not defined in the style, the system will execute the default formatting procedure instead.   For root nodes, the default is the rule named `root'; for other nodes, it is the rule named `default'.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Formatting parameters for the text within a node are determined in a similar manner.  The system first gets the parameters for the node and then executes the formatting procedures for the looks of the text.  For look `a', it executes the rule named `look.a', for look `b', the rule named `look.b', etc.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Properties related to styles
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Prefix and Postfix properties
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The values of these properties are command sequences that might be part of a formatting procedure.  The Prefix commands are executed just before the standard formatting procedure for the node, and the Postfix commands are executed just after it.  This makes it possible to modify the values of the formatting parameters that are the input and output of the format.  You may want to use this to make local formatting changes, such as modifying tab stops for a particular table.  However, don't abuse this facility.  If you find you are making many local changes, you should probably modify the style instead. 
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <StyleDef property
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In typical use, a style lives in its own file and is referred to by the various documents that use it.  However, in some cases you may have a style that is only used in one document, and you'd like to include it as part of the document to avoid the trouble of maintaining the style as a separate file.  You can do this by using the StyleDef property.  The value of this property is a style definition without any node structure or formatting looks.  The style is automatically saved and loaded as part of the file and applies to the node and its children just as if you had set the node style in the usual manner with the EditTool.
>}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <[Note: If you use a StyleDef and it doesn't seem to do anything, do a Clear of the style name using the EditTool.]
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Style definitions
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <A style definition begins with the command `BeginStyle' and ends with `EndStyle'.  Between these come any number of commands and definitions.  The style is parsed and interpreted using JaM, so you will want to read the JaM documentation if you're going to spend much time writing styles.
>}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Attached styles
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You may want to define a new style that is only slightly different than an existing one.  One approach would be to copy the existing style and edit it to make the changes.  However, it may be preferable to track whatever modifications to the other style that may happen in the future.  This can be done by `attaching' the old style to the new one.  For example, if your new style includes a command of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <(Cedar) AttachStyle
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <then the new style will automatically include everything from the current version of Cedar style.  Thus, if a format is not defined in the new style, it will be taken from Cedar style instead.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <ScreenRules, PrintRules, and StyleRules
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The basic form for a rule definition in a style is
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <(name) "comment string" { commands } StyleRule
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <In many cases it will be desirable for a rule definition to be different depending on whether the output is for printing or for display.  To simplify this, you may define a format both as a ScreenRule and as a PrintRule.  The ScreenRule definition will be used for display, while the PrintRule will be used for printing.  If there is only a StyleRule definition, it will be used for both printing and display.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Formatting Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This section lists some of the formatting parameters currently supported.  Typically, the name of the parameter is a command defined in JaM that pops an item from the stack and makes it the new parameter value.  However if the item on the top of the stack is the word `the', the commands push the current parameter value so procedures can read parameters as well as write them.  For numeric parameters, the following mechanisms are provided to simplify making incremental changes to the current parameter value:
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <<amount>> bigger	adds the amount to the current para-
	meter value
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <<amount>> smaller	substracts the amount from the para-
	meter value
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <<amount>> percent	multiplies the parameter value by the
	specified percentage, i.e.,
	value _ (amount/100)*value
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <<amount>> percent bigger	increases value by specified percentage
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <<amount>> percent smaller	decreases value by specified percentage
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Font Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <family	the name of current font family, such
	as `TimesRoman'
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <size	value is the font size in points
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <face	one of regular, bold, italic, or bold+
	italic
>}}
{PARA$ STYLE$ STYLE.FORMAT=block 
{CHARS$ <You can also add or remove italic or bold by means of the following commands:
>}
{PARA$ STYLE$ STYLE.FORMAT=center 
{CHARS$ <+bold face, -bold face, +italic face, or -italic face
>}}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <underlining	one of all, visible, letters+digits, or 
	none
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <strikeout	one of all, visible, letters+digits, or 
	none
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Indent Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leftIndent	left indent for start of lines
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <rightIndent	right indent for end of lines
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <firstIndent	added to leftIndent for first line of 
	paragraph
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <restIndent	added to leftIndent for remaining lines
	of paragraph
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topIndent	distance from top of viewer/column to
	first baseline
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Leading Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Leading parameters are stored as triples of <size, stretch, and shrink>> which, following Knuth, we refer to as `glue'.  You can set the separate components individually, or you can push three values on the stack and use one of the leading glue commands to set them all at once.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <There are three kinds of leading corresponding to the spaces between lines in a node, the space above a node, and the space below it.  The actual space between two adjacent nodes is the maximum of the `below' leading of the first node and the `above' leading of the second.
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leading	distance between baselines within a
	node
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leadingStretch	how much leading can increase
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leadingShrink	how much leading can decrease
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leadingGlue	size, stretch, and shrink for leading
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topLeading	distance between baselines above a
	node
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topLeadingStretch	how much top leading can increase
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topLeadingShrink	how much top leading can decrease
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topLeadingGlue	size, stretch, and shrink for top leading
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomLeading	distance between baselines below a
	node
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomLeadingStretch	how much bottom leading can increase
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomLeadingShrink	how much bottom leading can decrease
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomLeadingGlue	size, stretch, and shrink for bottom
	leading
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Layout Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <lineFormatting	FlushLeft, FlushRight, Justified,
	Centered
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <minLineGap	min distance between line top and
	previous bottom (can be negative)
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leftIndent	all lines indent this much on left
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <rightIndent	all lines indent this much on right
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <firstIndent	first line indent this much more on left
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <restIndent	other lines indent this much more on
	left
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topIndent	top line at least this much down from
	top of viewer/page
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomIndent	bottom baseline at least this up from
	bottom of page
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Page Layout Parameters
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <pageWidth	width of the paper
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <pageLength	height of the paper
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <leftMargin	whitespace at left of the page
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <rightMargin	whitespace at right of the page
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <topMargin	whitespace at top of the page
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bottomMargin	whitespace at bottom of the page
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <headerMargin	height of area below topMargin for
	headers
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <footerMargin	height of area above bottomMargin for
	footers
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <bindingMargin	not used at present
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <lineLength	width of lines of text
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Dimensions
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <pt	point
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <pc	pica
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <in	inches
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <cm	centimeters
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <mm	millimeters
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <fil	10^4 points
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <fill	10^8 points
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Miscellaneous
>}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <style	the name of the current style
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <isComment	pushes .true or .false according to
	comment property of node
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <isPrint	pushes .true if executing print rules, else .false	
>}}
{PARA$ STYLE$ STYLE.FORMAT=table 
{CHARS$ <nestingLevel	pushes integer; 0 for root, 1 for top
	level, etc.
>}}
{PARA$ STYLE$ STYLE.FORMAT=pagebreak 
{CHARS$ <
>}}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Tioga Commands
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <ReadTiogaTipTables
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Causes Tioga to read its TIP tables again.  If your user category is advanced, you can also invoke this operation by selecting in any Tioga document and hitting >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-!.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <WritePlain
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Make Tioga files unformatted by eliminating everything except the plain text.  Inserts leading tabs before each node according to its nesting in the tree and terminates each node with a carriage return.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <WriteMesaPlain
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Same as WritePlain, except inserts double dashes at start of comment nodes.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <ReadIndent
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Build Tioga files with one node per line of source with indenting based on white space at the start of lines.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <TiogaMesa
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Convert Mesa files to Tioga format by combining a ReadIndent with a >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-M>}
{CHARS$ < over the entire file.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <DoTiogaOps
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Expects a command line containing operations in the same format as in the EditTool operations field.  Among other things, you can use this to initialize various EditTool choices such as IgnoreCase or MatchWords.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <AnnotateProperties
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Creates a system button, TiogaProps, to annotate Tioga documents with comments describing the node properties and the document nesting structure.  >}
{CHARS$ LOOKS$ LOOK.k=TRUE <LEFT>}
{CHARS$ <-click TiogaProps with the selection in a document and the annotations are added; >}
{CHARS$ LOOKS$ LOOK.k=TRUE <RIGHT>}
{CHARS$ <-click TiogaProps and the annotations are removed from the selected document.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When a list of file names is given as command arguments, AnnotateProperties writes new versions of the files with the annotations in place.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <PruneAnnotations
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <PruneAnnotations takes a list of files and writes new versions of the files with the annotations removed.
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Tioga User Profile Entries
>}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Default file extensions
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This determines what extensions Tioga should look for in opening files.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <SourceFileExtensions: mesa tioga df cm config style
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You may also have an entry for implementation extensions to be used with the `load impl' commands.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <ImplFileExtensions: cedar mesa
>}}
{PARA$ STYLE$ STYLE.FORMAT=pagebreak 
{CHARS$ <
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Open First Level Only
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If set to true, documents will be opened with only their first level showing.  Default is false.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <OpenFirstLevelOnly: TRUE
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Default Styles Determined by File Extensions
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This entry specifies the default style to be used with documents that do not explicitly name a style.  The style is determined by the extension in the file name.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <ExtensionStyles: <extension1>> <stylename1>> <extension2>> <stylename2>> ...
>}}}
{PARA$ STYLE$ STYLE.FORMAT=note 
{CHARS$ <To specify a default style for files with no extension in their name, use the fake extension name `null' in this list.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Default Style
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This entry specifies the default style to be used with documents that do not explicitly name a style and do not have an extension given in the ExtensionStyles list.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <DefaultStyle: Cedar
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Default submenus
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This entry specifies which menus, if any, should automatically be displayed when you create a new Tioga viewer by clicking one of the buttons in the upper right corner or by using the Open or New commands.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <DefaultTiogaMenus: places levels
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <or
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <DefaultTiogaMenus: none
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <You may delete or reorder the menu names to suit your tastes.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Scroll bottom offset
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you are typing and the caret goes to a new line just off the bottom of the viewer, Tioga will automatically scroll the viewer up a little to make the caret visible again.  This parameter controls how far up to scroll; a big number causes larger but less frequent glitches.
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <ScrollBottomOffset: 3
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Scroll top offset
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <When you do a Find command you may want to see a few lines in front of the match to give you more context.  This parameter tells Tioga how many extra lines to want in such situations.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <ScrollTopOffset: 1
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selection Caret
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The default behaviour for Tioga is to place the caret at the end nearer the cursor when the selection is made.  Some people have requested to have the caret always placed at one end or the other, hence this profile entry.  The choices are before, after, and balance.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <SelectionCaret: before
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Selection Displacement
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This lets you specify a vertical displacement for making selections.  Tioga behaves as if you had pointed this number of points higher up the screen so that you can point at things from slightly below them.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <YSelectFudge: 2
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <TIP Table
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This entry specifies the TIP tables to use with Tioga documents.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <TiogaTIP: MyOwnTip.tip Default
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <See the section on TIP tables for more information.
>}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Unsaved Documents Cache Size
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This controls the number of unsaved documents the system will remember.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <UnsavedDocumentsCacheSize: 4
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Show Unsaved Documents List
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If this is true, a viewer will be created holding an up-to-date list of the unsaved documents that can still be reloaded.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <ShowUnsavedDocumentsList: TRUE
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <User category
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <As described above, this entry lets you control your user category.  The alternatives are Beginner, Intermediate, and Advanced.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <UserCategory: Intermediate
>}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Version Map lookup
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <If this is true, Get, GetImpl, Open, and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ < will look for the requested file in the Cedar version map if their earlier attempts to open a file fail.  The entry is of the form
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Tioga.TryVersionMap: FALSE
>}}}}}
{PARA$ STYLE$ STYLE.FORMAT=head 
{CHARS$ <Command Summary
>}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <This is a short summary of the Tioga commands available using the keyboard and mouse.  Other commands are available through the EditTool, the EditHistory Tool, and various command operations.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The extra keys on the keyboard are used for common editing actions.   Recall that the bottom right blank key can be used as another >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key, and you can use either >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ < key and either >}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ < key interchangeably.
>}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <The word >}
{CHARS$ LOOKS$ LOOK.k=TRUE <CLICK>}
{CHARS$ < refers to the action of rapidly pressing, releasing, and repressing a key.
>}
{PARA$ STYLE$ STYLE.FORMAT=table1 
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ <	Repeat last action
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC>}
{CHARS$ <	Undo last action
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <ESC->}
{CHARS$ <select	Automatic repeat of last action when finish selection
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <DEL>}
{CHARS$ <	Delete
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ <	Load file in `No Name' viewer
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <LF>}
{CHARS$ <	Load Impl file in `No Name' viewer
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <	Backspace character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <	Delete next character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <	Backspace word
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <BS>}
{CHARS$ <	Delete next word
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ <	Find next placeholder (middle blank key)
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <NEXT>}
{CHARS$ <	Find previous placeholder
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <RETURN>}
{CHARS$ <	Insert carriage return with leading spaces copied
	from previous line
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT-RETURN>}
{CHARS$ <	Insert carriage return
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL-RETURN>}
{CHARS$ <	Break node
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Mouse button clicks are used for making selections.  Selection granularities are point, character, word, node, branch, document.
>}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ LOOKS$ LOOK.s=TRUE <CLICKS	LEFT			MIDDLE			RIGHT>}
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ <
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ LOOKS$ LOOK.s=TRUE <SINGLE>}
{CHARS$ <	Select letter	Select word		Extend selection at current granularity
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ LOOKS$ LOOK.s=TRUE <DOUBLE>}
{CHARS$ <	Select node	Select branch	Reduce selection granularity & extend
>}}
{PARA$ STYLE$ STYLE.FORMAT=table4 
{CHARS$ LOOKS$ LOOK.s=TRUE <TRIPLE>}
{CHARS$ <										Increase selection granularity & extend
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Selections are used for delete, copy, and move.
>}
{PARA$ STYLE$ STYLE.FORMAT=table1 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-select	Delete when finish selection
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-select	Copy to primary
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-select	Move to primary
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ < commands are used for editing looks.>}
{CHARS$ LOOKS$ LOOK.s=TRUE <  >}
{CHARS$ <(The >}
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ < shift is the top blank key.)
>}
{PARA$ STYLE$ STYLE.FORMAT=table1 
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-char	Add look to selection
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <-char	Remove from selection
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <LOOK>}
{CHARS$ <-space	Remove all from selection
>}}}
{PARA$ STYLE$ STYLE.FORMAT=body 
{CHARS$ <Except for >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A, CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H,>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ <, the following commands are not enabled for beginning users.  We provide both >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ < and >}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H>}
{CHARS$ < as a convenience to users with strong habits from previous systems.  A `>}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <' indicates a command enabled for advanced users only.
>}
{PARA$ STYLE$ STYLE.FORMAT=table1 
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ <	Backspace character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <A>}
{CHARS$ <	Delete next character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <B>}
{CHARS$ <	Insert matching placeholder brackets
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C>}
{CHARS$ <	Lower case
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C>}
{CHARS$ <	Upper case
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <CLICK>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C>}
{CHARS$ <	First cap
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <CLICK>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <C>}
{CHARS$ <	Initial caps
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <D>}
{CHARS$ <	Select document
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <E>}
{CHARS$ <	Expand abbreviation
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <F>}
{CHARS$ <-select	Copy format to primary >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H>}
{CHARS$ <	Backspace character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <H>}
{CHARS$ <	Delete next character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <I>}
{CHARS$ <	Indent (does Break and Nest) >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <I>}
{CHARS$ <	Unindent (does Break and UnNest) >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <J>}
{CHARS$ <	Join nodes >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <K>}
{CHARS$ <	Make control character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <K>}
{CHARS$ <	Unmake control character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <M>}
{CHARS$ <	Automatic >}
{CHARS$ LOOKS$ LOOK.s=TRUE <MESA>}
{CHARS$ < formatting
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <N>}
{CHARS$ <	Nest >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <N>}
{CHARS$ <	UnNest >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <O>}
{CHARS$ <	Make octal character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <O>}
{CHARS$ <	Unmake octal character
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <P>}
{CHARS$ <	Paste
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <Q>}
{CHARS$ <-select	Copy looks to primary
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <S>}
{CHARS$ <-select	Copy primary to selected destination
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <T>}
{CHARS$ <	Time
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <V>}
{CHARS$ <	Select visible (expand to selection to blanks)
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ <	Backspace word
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <W>}
{CHARS$ <	Delete next word
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <X>}
{CHARS$ <-select	Select for transpose with primary
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <Z>}
{CHARS$ <-select	Move primary to selected destination
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <]>}
{CHARS$ <	Select matching [..]'s  (same for }, ), and >>)
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <[>}
{CHARS$ <	Add matching [..]'s  (same for ", ', -, {, (, and <)
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <-!	Have Tioga read its TIP tables again>}
{CHARS$ LOOKS$ LOOK.t=TRUE < >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <_>}
{CHARS$ <	Se>}
{CHARS$ LOOKS$ LOOK.t=TRUE <t format to word before caret >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <_>}
{CHARS$ <	Insert format name>}
{CHARS$ LOOKS$ LOOK.s=TRUE < *>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <\>}
{CHARS$ <	Set comment property >}
{CHARS$ LOOKS$ LOOK.s=TRUE <TRUE>}
{CHARS$ < >}
{CHARS$ LOOKS$ LOOK.s=TRUE <*>}
{CHARS$ <
>}
{CHARS$ LOOKS$ LOOK.s=TRUE <CTRL>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <SHIFT>}
{CHARS$ <->}
{CHARS$ LOOKS$ LOOK.s=TRUE <\>}
{CHARS$ <	Set comment property >}
{CHARS$ LOOKS$ LOOK.s=TRUE <FALSE *>}
{CHARS$ <
>}}}}}
}