Dalsoft Development Environment

Reference Manual

Text Editor, Word Processor and Outliner, Tree Presentation
version 1.6

for the Linux/UNIX operating system

for Windows

Windows is a trademark of Microsoft Corporation.

UNIX is a trademark of AT&T.

1. Introduction
2. General Information
3. Windows
4. Commands
5. Suggestions for using dde
Appendix A Terminal support
Appendix B Execution File Format
Appendix C Text Editors Function Summary and Default Binding
Appendix D Word Processors Command Summary
Appendix E Command Summary for Tree Presentation Utility
Appendix F Using dde under X window system
Appendix G Using dde under Windows

1. Introduction

1.1 General Overview

Dalsoft Development Environment ( referred later as dde ) is a tool that may be incorporated into all stages of software development - from general design, through coding and documentation, to the creation of demos and help systems. dde combines a versatile, multi-window text editor, a general purpose word processor/outliner and an interactive tree-presentation utility.

1.1.1 Text Editor

dde offers an extensive display editor featuring true multi-windowing. dde doesn't just split the screen vertically or horizontally. Rather, it enables the creation of any number of any sized, overlapping windows, which can be located in any position on or outside of the screen. In addition, dde has a command set and general approach derived from the EMACS editor. dde has a fully configurable keyboard and its extensive command set allows editing of any number of files, supports very powerful macros, provides incremental and regular-expression search, offers a full and complete undo facility and much more.

1.1.2 Word Processor - Outliner

The word processor within dde includes a comprehensive array of word processing features. It supports complete paragraph and character formatting, text search, file operations, cut and paste, an interactive spell-checker, etc. The built-in outliner enables the development and maintenance of multilevel outlined documents by supplying commands which control outline levels, visually distinguish the levels, print level of the current paragraph, etc.

1.1.3 Tree Presentation

The tree presentation utility allows interactive display of the outlined document. At each interaction it displays all the paragraphs of the current level as menu entries. The choice of the particular entry continues with all outlines under this entry until the text is reached. The utility provides an easy method for changing the outline levels that are displayed, and complete cursor control when the text is reached.

1.1.4 Features and Description

* True multi-windowing

dde supports covered rectangular windows, i.e. windows that can overlap arbitrarily ( just like pieces of paper on a desk ). It allows the creation of any number of any sized windows and locates them in any position on or outside of the screen. dde provides commands to create, resize and move windows, to change window attributes ( e.g. user definable tabs ) and window appearance, etc.

* Multiple file editing

dde allows editing of any number of any sized files that will fit into available memory. It allows editing of the same file in different windows.

* Completely reconfigurable keyboard

dde allows the association of a key or key combination with its internal commands. In addition to this it enables assignment of user created macros to keys.

* Powerful macros

dde supports default and named macros. The macros may be nested and a command is available allowing macros to be paused to accept input from the keyboard. Macros may be assigned to keys.

* Search and replace

dde supports incremental forward and backward search and conditional replacement. It allows repetition of the last search and editing of the search string. dde also supports regular-expression search and replacement.

* Complete and full undo

dde allows to undo any command that affects the cursor and the text. The undo command, supported by dde doesn't just restore buffer and cursor position but recreates the exact screen image.

* On-line help

dde provides full on-line descriptions of all of its features and commands.

* Flexible initialization

dde, under invocation, tries to execute commands from a specially named file, thus allowing the set up of a proper environment.

* Data transfer between text-editor and word-processor

dde allows cut and paste between all of its buffers thus allowing to incorporate documentation into the source, access to the outline of the design while coding, etc.

* Tree Presentation Utility

dde provides a tree presentation utility which allows a menu-driven interactive display of the outlined document. This is ideal for building help systems, demos and as a general interface to the data base.

1.1.5 Technical Specifications

Current version:
Maximum number of windows:
Minimum size of window:
Maximum size of window:
Maximum number of buffers:
Maximum windows per buffer:
Maximum text buffer size:
Maximum line length:
Maximum lines in buffer:
Maximum number of files:
File name expansion:
Maximum number of macros:
Maximum macro size:
Maximum nesting depth of macro:
Maximum level of outline:
Customization:
Source code in:
Operating system supported:
Documentation:
Support:

1.6
unlimited
1x2
65534x65534
unlimited
unlimited
unlimited
unlimited
unlimited
unlimited
supported
unlimited
unlimited
16
16
provided
C/C++
Linux/UNIX, Windows
manual
on-line

`unlimited' should be understood as `determined by
the amount of the available memory'

The currently released version of the tool supports only text editing; word processor/outliner and tree presentation are included but not supported.

Currently the tool is provided only as a 64-bit executable for a x86 Linux OS and a 32-bit executable for the Windows OS.

WE ASSUME NO LIABILITY WHATSOEVER, AND DISCLAIM ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF OUR PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Our products are not intended for use in medical, life saving, life sustaining, critical control or safety systems, or in nuclear facility applications.

The software described in this document may contain software defects which may cause it to deviate from expected behavior.

1.2 Conventions used in this document

The following notations are used in this document:

<SPACE> stands for the SPACE bar

<RETURN> stands for the ENTER or the RETURN key

<ESC> stands for the ESCAPE key

<TAB> stands for the horizontal tab

^A stands for Control character ( here - control A )

<F#> stands for a function key ( e.g., <F6> )

<CF#> stands for a Control function key ( e.g., <CF6> )

<SF#> stands for a Shift function key ( e.g., <SF6> )

<AF#> stands for a Alt function key ( e.g., <AF6> )

<'name'> reference to key by name ( e.g., <PgUp> )

1.3 Installation and Setup

To install dde, copy the executable image of the product
( the file named `dde' ) into the appropriate working directory ( e.g., `/usr/bin' ).

If the dictionary will be used, copy the dictionary file, `diction' into the appropriate directory ( e.g., `/usr/local/dde' ) and set the environment variable `DDEDICTION' to contain the full pathname of this file ( e.g., `/usr/local/dde/diction' ).

If use of the on line help system is desired, copy the help file `help' into an appropriate directory ( e.g., `/usr/local/dde' ) and set the environment variable `DDEHELP' to contain the full pathname of this file ( e.g., `/usr/local/dde/help' ).

2. General Information

2.1 The screen

The screen ( or monitor, or console ) is the area where dde displays its data. Note that the monitor should not necessarily be a computers physical display. When running in a multi-windowing environment, the physical display may contain many windows and dde can be run in one of them. In such an environment you may resize your screen. If the window it is running in is resized, dde will attempt to detect the change and update the window appropriately.

When running under the LINUX operating system, dde relies on the termcap or terminfo package to obtain information about the screen and manipulate it ( see Appendix A ). The type of screen is determined by the environment variable `TERM'. It is the user's responsibility to make this data available within the environment and ensure that it accurately represents the monitor which is being used.

Some of the commands provided by the word processor make use of the shifted function keys ( see 4.2.2 ). On some terminals shifted function keys are user defined ( e.g., VT100 family of terminals ). In this case, dde expects the settings for the shifted function keys as defined in the Appendix A.

2.2 Layout of the Screen

The line at the bottom of the screen is called the Information Line. dde uses the Information Line for displaying messages, and for accepting input for certain commands. The rest of the screen may be occupied by windows. See 3.1, 3.2 for an explanation of the layout of the window.

2.3 The Information Line

Each position on the Information Line may contain an Information line indicator of some special state within dde. The meaning of each position is described below:

The rightmost position is where the cursor is placed if it is actually off the screen and therefore ( e.g., the current window moved off the screen ).

The next leftmost location indicates if the cursor belongs to an icon or if the cursor is .

If the cursor belongs to an icon, the high-density `*' will appear in this location.

If the cursor doesn't belong to an icon and is obscured, the high-density blinking `*' will appear in this location. Note that a cursor will still be visible at the correct screen location or on the information line to the right of the `*'.

The next leftmost position indicates if dde executes a .

This position contains a hexadecimal number if dde is executing a macro. The number represents the executed macro depth ( 1, 2, ..., f ) and appears in high-density. If dde accepts keyboard input during macro execution, the printed number will blink. If dde does accept keyboard input during macro creation, a blinking `0' will appear in this location.

The next leftmost location indicates if a is being created.

This location contains a blinking, high density `M' if a macro is being created.

The next position to the left of this indicates whether dde is in window mode.

If dde is in window mode, a blinking, high density `W' appears in this location.

The next leftmost position indicates the state of the word processor.

If there is no word processing window, this location is empty. A digit will appear here if the word processor is in outline mode. This digit represents the outline level of the paragraph in which the cursor is currently positioned. If the word processor is not in outline mode, `W' is displayed here. If the word processing window is the current window, the data in this location ( `W' or digit ) is printed in high density.

The next leftmost position contains the Busy/Idle/Delay indicator.

Whenever dde is busy executing a command, a blinking, high density `B' appears in this location. If `<ESC>' or `^X' was entered, a reverse video `E' or `X' ( the `E' for `<ESC>', the `X' for `^X' ) appears in this location indicating that dde is waiting for the second keystroke of the command to be entered. If dde is delayed, a reverse video `D' appears here. Otherwise, a reverse video `I' appears to indicate that dde is waiting for input, or `Idle'.

The remaining space of the information line is used by some commands to prompt for input and to print messages.

2.4 Entering Data on the Information Line

Some of the dde commands accept keyboard input during their execution ( file names, window numbers, etc. ). The input data is not accepted by dde until `<RETURN>' is entered ( see 4.1.2.1, 4.1.2.2, 4.1.8 and 4.1.9.1 for deviations from this rule; see also 2.12.2 ).

The following editing capabilities are supported while entering data on the Information Line:

^F, <RightArrow> - moves the cursor
one character forward

^B, <LeftArrow> - moves the cursor
one character backward

^A, <Home> - moves the cursor to the
beginning of the entry

^E, <End> - moves the cursor to the
end of the entry

^D, <Del> - deletes the character that
the cursor is on

^H, <BackSpace> - deletes the character immediately
preceding the cursor
^K - deletes characters from the cursor
to the end of the line
^U - deletes all characters

^L - refreshes the screen

^G - quits without accepting the entry

<RETURN> - accepts the entry as input

2.5 The cursor

For the purposes of this document, the logical cursor ( or just `cursor' ) will be considered to be a location on the window which currently may be affected by the available commands. Because dde supports overlapping windows which may be "positioned" anywhere relative to the actual screen, the cursor may not always be visible. There are at least two reasons for this:

1. the real location of the cursor is not on the screen.

2. the real location of the cursor is obscured by another

window(s).

If the cursor is located on the screen, its location is indicated by the "hardware cursor". If it is not obscured, the hardware cursor is displayed as a blinking bloc on PC's or made specially visible on terminals that support this. If the logical cursor is obscured, the hardware cursor is displayed as a blinking line on PC's or made normally visible on other terminals ( also see 2.3 ).

2.6 Buffers and Windows

dde keeps all available data in a "buffer", which is an internal representation of the treated information. A "window" is an area that displays a buffer. A buffer may be viewed only through a window, and the visible part of the buffer is the part within the screen which is not obscured by another window ( see 3.1 ). The window's geometry and attributes determine what part of the buffer is visible and how it is displayed. Note, that the same buffer may be viewed in more than one window but every window has only one buffer. Also note that not every buffer may be visible; for example, macros ( see 4.1.7 ) are stored in buffers, but these buffers are not made visible; the kill buffer ( see 2.7 ) is also not visible.

A visible buffer may be associated with a file by creating it with one of the file handling functions ( see 2.17.8, 4.1.5 ). This association makes file operations easier and provides control of text processing.

To obtain a complete list of buffers and windows currently in use by dde, execute `b_inf - the information about buffers and windows' function ( see 4.1.9.4 ). This function prints out information about buffers and windows that includes:

- size of the buffer ( i.e., the size of the data
within it)

- current state of the buffer ( changed/unchanged )

- type of buffer ( file buffer, macro body, etc. )

- name of the file/macro associated with the buffer
(if any)

- list of windows that are attached to buffer (if any)

2.7 Kill buffer

The kill buffer is a special buffer which is used to store data that was killed with `k_eol - kill to the end of the line' ( see 4.1.3.3 ), `k_buf - delete a region' ( see 4.1.3.4 ) functions and the word processing `delete a region' ( see 4.2.1.2 ) command. Its contents may be inserted into the text by yank - either `yank - yank from the kill buffer' ( see 4.1.4.4 ) function or word processing `yank' ( see 4.2.1.3 ) command.

The kill buffer may be used to:

- cut and paste data within the editing buffer
- to transfer data between buffers
- to transfer data between text editor and word
processor

Note that there are no limitations imposed on the size and format of the kill buffer.

2.8 Functions and Commands

dde provides a complete set of functions and commands that perform many different text processing tasks.

2.8.1 Text editor functions

Every function may be called explicitly ( see 4.1.7.6 ). However, there is a way to associate certain keystroke(s) with dde functions, thus creating dde commands. When the keystroke is entered, the associated function is executed. See 4.1.8 for more details.

2.8.2 Word processor commands

Most of the commands supported by the word processor are executed through the word processing menu, by entering some control characters or by entering function keys.

2.9 Errors

dde prints out its error messages on the Information Line ( see 2.3 ). All error messages are self-explanatory and are usually followed by a beep. Most of the errors are recoverable and dde continues execution after reporting them. In the case of a fatal error ( e.g., failure to allocate a sufficient amount of memory ), dde terminates editing in the following manner: it checks if there are updated buffers and, if so, it asks if they should be saved. If confirmed, all updated buffers are copied into files in the current directory named "dde0.sav", "dde1.sav", etc.

2.10 Non ASCII characters and long lines

dde processes all characters in its buffers and imposes no restriction on the length of a line. The way nonprintable characters are actually printed by dde depends upon whether it is executing the text editor or word processor.

If the text editor is active, dde prints these characters as hexadecimal numbers preceded by `\'; e.g, `\01'. ( see 4.1.4.3 about how to enter special characters ).

If the word processor is active, nonprintable characters are printed as `?'. The only exception is the character with the decimal value 12; this character is interpreted as a form feed and displayed as ( see 4.2.3.9 ).

If the text editor is running, dde displays lines that are longer than the width of the window by their continuation onto the next line(s). A `\' is displayed at the end of any line which is continued on the next line. dde always tries to display as much information as possible. Lines that cannot fit into the window are displayed with an attempt to locate the cursor as close to the end of the window as possible.

2.11 Special keys

dde attempts to interpret special keys in a way that corresponds to their "intuitive" meaning ( e.g., arrow keys are used for cursor and window movement ).

If the text editor is active, pressing function key F# causes macro `F#_macro' to be executed. For example, pressing function key `F6' causes macro `F6_macro' to be executed ( if it exists ).

2.12 Files

2.12.1 File name

dde always displays the full path name of the file(s) that it deals with. However, when specifying the file name you may specify any pathname of the file, relative to the current working directory, in addition to specifying the full pathname.

2.12.2 File name completion

When specifying the name of a file, you enter data on the information line as described in 2.4. If at the end of the entry a blank character is typed while entering a pathname, dde will try to extend the typed portion of the pathname using the files available within the file system as following:

1.It will create a directory window and display there all directories on the selected drive with the pass of the currently chosen directory being highlighted and the last element of the currently chosen directory being located in the center of directory window. Directory tree is calculated in background upon invocation of the dde and display window would not be created before this calculation is completed.

2.It will create a file window and display there all files in the currently chosen directory with names which have the same prefix as that entered so far on the information line.

3.The file name portion on the information line will be extended by adding to the already entered name prefix zero or more characters that will create a new prefix, which matches all files in the file window.

You may continue to enter characters and/or blanks. When the pathname is completed by typing `<RETURN>', the file window is deleted.

For example, assume that current working directory consists of the files:

file1a file2 file1a1 file1a2 data1 data2

Then when an `f' and ` ' are typed the file window will be created and the following data will be displayed in it:

file1a file2 file1a1 file1a2

The input portion of the file name on the information line will be extended to `file'. If a `1' is now typed followed by ` ' the file window will be updated to contain the following data:

file1a file1a1 file1a2

and the input portion of the file name on the information line will be extended to `file1a'. If a `2' is now typed followed by <RETURN>, dde will delete the file window and proceed with the pathname `file1a2'.

If mouse is installed, you can choose a directory by clicking on any item in the directory window and you can choose file ( plain or directory ) by clicking on any item in the file window.

Note that if the name indicates a directory, it is displayed in the file window followed by `/' on LINUX systems and `\' on WINDOWS.

2.12.3 Execution file format

dde allows you to create a file whose contents are commands which it will execute ( see 4.1.5.4 ). To enable the specification of special keys in the command file, dde uses input conversions specified in Appendix B.

For example, the following file context:

\kl\a\\\kn

will be interpreted as <LeftArrow> followed by '\' followed by 'a' followed by '\' followed by <PgDn>.

See 5.6 for more examples.

2.13 Regular Expressions

Regular expressions are strings that are interpreted according to special rules. These rules allow the description of very complex search/replace patterns, which can then be used for text editing.

2.13.1 Regular Expression Definition

dde supports regular expressions constructed according to the following rules:

Any character except a special character matches itself ( the special characters are listed below ).

`.' - matches any character except new line.

`\' - followed by any character except `t', `x'
or a digit, matches the character
after `\'.

`\t' - matches horizontal tab.

`\xhh' - matches the character that has
hexadecimal value `hh'
( e.g., `\x7a' matches `z' ).

`^' - matches the beginning of the line.

`$' - matches the end of the line.

`*' - matches zero or more occurrences of the
previously matched one character regular
expression.

`[s]' - matches any character in the set `s'.
In the set `s' none of the special
characters described above has a special
meaning. A substring `a-b' with `a' and
`b' in ascending ASCII order stands for
a range of characters from `a' to `b'.

`[^s]' - matches any character not in the set `s',
where the set `s' is defined as above.

`ab' - matches an occurrence of regular
expression `a' followed by regular
expression `b', with the occurrence
of `a' being as long as possible.

`r\{m,n\}' - matches any number of `m' through `n'
successive occurrences of
regular expression `r'.

`r\{m\}' - matches exactly `m' occurrences of
regular expression `r'.

`r\{m,\}' - matches at least `m' ( `m' or more )
occurrences of regular expression `r'.

`$r$' - matches regular expression `r'.

`\n' - ( where `n' is a number greater than zero)
matches the same string of characters,
that was matched by the n'th regular
expression enclosed between `$' and `$'
earlier in the same regular expression.

`a|b' - matches regular expression `a' or regular
expression `b'.

The described regular expressions are used in the regular expression search function ( see 4.1.2.3 ), when specifying the string to search for, and the regular expression replace function ( see 4.1.2.5 ), when specifying the string to be replaced. The characters in the replacing string for the regular expression replace function are treated as usual ASCII characters, except for those preceded by `\' in the following list:

`\xhh' - stands for a character that has
value `hh'.

`\n' - ( where `n' is a number greater than zero )
stands for the n'th expression enclosed
between `$' and `$' in the replaced string.

`\0' - stands for the entire replaced string.

`\t' - stands for horizontal tab.

`\c' - stands for the character `c', where `c' is any
character except digit, `x' and `t'.

The following examples will clarify the above definitions and may suggest situations were regular expressions can be particularly useful.

`[abcd]' match `a', `b', `c' or `d'.

`[a-z]' match any lower case letter.

`ab\{2,4\}' match `abab', `ababab' or `abababab'.

`ab\{2,}' match `abab', `ababab', `abababab' ... .

`$[ab]$c\1' match `aca' or `bcb'.

replacing `$a$$b$' by `\2\1' will replace `ab' by `ba'.

The following is a regular expression, used by dde to verify that paragraph margins ( see 2.14.2.1, 4.2.1.4.2.2, 4.2.1.4.2.3 ) are decimal numbers in the range from 1 to 132:

"[1-9]|[1-9][0-9]|1[0-2][0-9]|13[0-2]"

2.14 Word Processor-Outliner Definitions

2.14.1 Character attributes

The word processor allows you to assign an attribute to every character in the document, thus controlling the way characters appear. The character attributes, supported by dde, are normal, bold, underlined, italic, reverse video, or any combination of these. Thus, the document may contain an underlined, bold character, etc. Note that on terminals that don't support italic characters, characters with an italic attribute are made blinking. Note also that characters with the reverse video attribute, when printed out, will appear without the reverse video attribute.

The assignment of a character attribute may be done by applying it to every character to be typed ( see 4.2.1.4.1 ) or by controlling attributes of a region of already typed text ( see 4.2.2.18 - 4.2.2.26 ).

2.14.2 Paragraphs

The word processor controls the appearance of the document by applying its commands to paragraphs. A paragraph is a portion of text terminated by pressing `<RETURN>' ( see 4.2.3.2 ). While typing within a paragraph, dde automatically wraps words too long to fit onto a single line onto the next. The appearance of the line is determined by the left and right margins and by the alignment of the paragraph it belongs to.

2.14.2.1 Left and Right margins

Every paragraph has left and right margins which determine the extent of the text in a paragraph. The Left margin determines the position before which no character from the paragraph may be printed. The Right margin determines the position after which no non-blank character from the paragraph may be printed.

2.14.2.2 Alignment

The alignment of the paragraph determines the appearance of the lines in the paragraph. The alignment applies to the aligned text which is the portion of line typed after the last tab stop or, if there are no tab stops, the entire line. The area in which the text will be aligned is an alignment area - it begins at the last tab stop or the left margin ( if there are no tabs ) and extends to the right margin.

Alignment may be Left, Right, Centered or Justified.

Left alignment will cause the aligned text to be printed at the start of the alignment area. For example, the following line is left aligned:

This line is left aligned.

Right alignment will cause the aligned text to be printed so that its last non-blank character is located at the end of the alignment area. For example, the following line is right aligned:

This line is right aligned.

Centered alignment will cause the aligned text to be centered between the start and end of the alignment area. dde will attempt to make the distance between the start of the alignment area and the beginning of the aligned text to be equal to the distance between the final character of the aligned text and the end of the alignment area. For example, the following line is centered:

This line is centered.

When alignment is justified, dde prints the aligned text starting at the beginning of the alignment area. The last non blank character of the aligned text is always printed at the end of the alignment area. To achieve this, dde may insert blanks between words of the aligned text. An attempt is made to keep the number of inserted blanks between words in the aligned text equal. For example, the following line is Justified:

This line is Justified.

2.14.3 Outlines

2.14.3.1 Definition of outliner

The Outliner is a part of the word processor that attaches a level to each paragraph. The levels are numbered using positive integers. The highest level is 1 and each integer after 1 represents one lower level. Each paragraph with a non-zero outline level will have included under it all paragraphs of lower levels, until a paragraph with the same or a higher level appears. An outline level of 0 is considered to be special and interpreted as a text of the preceding it paragraph of non-zero level.

The Outliner can organize your document into a series of levels, each of which then may have a number of lower levels, which gradually introduce more subtle and detailed description. For example, this section of the document is built as the following outline:

Word Processor-Outliner Definitions - level 1

Character attributes - level 2

<text for `Character attributes'> - level 0

Paragraphs - level 2

<text for `Paragraphs'> - level 0

Left and Right margins - level 3

<text for `Left and Right margins'> - level 0

Alignment - level 3

<text for `Alignment'> - level 0

Outlines - level 1

Definition of outliner level 2

<text for `Definition of outliner'> - level 0

Displaying outlines - level 2

<text for `Displaying outlines'> - level 0

Spelling Checking dictionary - level 1

<text for `Spelling Checking dictionary'> - level 0

2.14.3.2 Displaying outlines

When the word processor uses the Outliner ( is in the outline mode - see 4.2.4 ) the screen looks quite different from the regular word processing mode. First of all, a high density digit, representing the outline level of the paragraph in which the cursor is located, appears on the information line ( see 2.3 ). Every paragraph is printed, regardless of its alignment or margins. The only factor used in determining the display of the paragraph on the screen is its outline level. Each outline level causes indentation of the paragraph by an additional two spaces. Therefore, all level 1 paragraphs are printed starting at column 2, all level 2 paragraphs are printed starting at column 4, etc. Note that all text paragraphs are printed starting at
column 0.

2.14.4 Spelling Checking dictionary

The word processor supports a powerful, interactive spelling checking facility ( see 4.2.1.6 ). The spelling checker uses a dictionary of predefined words that are assumed to be correct. dde provides the dictionary, but you may build your own by obeying the following rules:

1. each line in the dictionary must contain
exactly one word
2. each word must consist of only lowercase
letters
3. the lines in the dictionary must be
lexicographically sorted

A number of spelling dictionaries may be created. The one to be used for a particular session may be indicated by setting the environment variable `DDEDICTION' to contain its full file name ( see 1.3 ).

2.15 Execution interruption

dde allows you to interrupt execution of many of its commands by typing `^G' ( control-G ). After `^G' is typed, dde will immediately suspend execution of the current command ( if it is interruptible ) and discard all characters in the input key buffer that were typed before the `^G' was received, but not yet processed ( if any ). Note that changes that took place before `^G' was entered, will remain in effect.

Interrupting execution in this manner might be desirable when executing a command which is consuming too much time or executing an unintended command. Another case where such an interruption may be useful is when partial execution of a command is desired. For example, you may perform global replacement and interrupt it when reaching a certain location in the buffer ( see 4.1.2.4, 4.1.2.5 ).

2.16 Invocation and Initialization

2.16.1 Invocation

.invocation;

dde may be invoked with one file name argument preceded by zero or more parameters ( both the filename and parameters are optional ). The invocation of dde has the form:

dde [parameter list] [file-name]

If `file-name' is specified, dde loads this file as the initial contents of its buffer and sets buffers type to be `file' ( see 2.6 ).

The following is a list of the parameters and descriptions of their functionality ( also see Appendix F ):

-nobak

By default dde creates a backup of an updated file before overwriting the original file. If `-nobak' is specified, dde will not create a backup of an updated file. If `-nobak' is NOT specified, the backup filename is created in the following way:

In a WINDOWS environment the original filename will be used, but will be preceded by the `~' character ( e.g., the file `dde' would have a backup named `~dde'). In a LINUX environment, the original filename will be used, but an extension of `.bak' will be added ( e.g., the file `dde' would have a backup named `dde.bak' ).

-c [file_name]

This flag allows to specify a file to be used for initialization, instead of the expected initialization file ( see 2.16.2 ). If the `file_name' is not specified, dde does not perform initialization when invoked.

-wp

By default, dde activates the text editor, when invoked. When this flag is specified, dde enters the word processor when invoked.

-h [filename]

If this flag is specified, dde enters the tree-presentation utility with the file `filename' as an outline ( see 4.3 ). If `filename' is not specified, the help file ( see 1.3 ) is used instead. This command option allows dde to be used as a stand alone tree presentation utility to display demos, help systems, etc.

This is a dummy option. It does nothing and may be used as a separator between options. For example, suppose you wish to edit the file `foo' and want no initialization to be performed. If dde is invoked using:

dde -c foo

dde will use `foo' as the name of the initialization file, which was not the intention. The right invocation in this case would be:

dde -c -- foo

2.16.2 Initialization

If the command option `-c' was not specified, then when started, dde attempts to read the file `dde.ini' from the directory in which it was invoked ( the current directory ). If this attempt failed, dde attempts to read the file `dde.ini' from the directory specified by the environment variable `HOME'. If it succeeds, the contents of this file are interpreted as dde command(s) which are executed immediately. This allows the setting of the proper working environment ( creation of the macros to be used, changing window layout, etc. ).

2.17 Basic commands and operations

This section provides a general introduction to the basic functions and commands, supported by dde. It may be particularly helpful if you wish to start using dde quickly or to get help quickly after having already used the product. By reading this section, you should be able to use dde efficiently and be fully prepared to read and understand chapters describing advanced features and/or giving in depth explanation of the functionality provided by dde.

2.17.1 Invoking dde

The simplest way to invoke the text editor is just by typing

dde

at the shell level. To invoke the word processor from the shell level, type

dde -wp

dde will display the copyright message, clear the screen and create an appropriate text editor or word processor window. dde will then attempt to load the initialization file ( see 2.16.2 ). At this point, you may start to enter dde commands.

The invocations of dde above may be followed by the name of a file which dde should load before starting editing/word processing. For example, to start editing the file `prog.c', just type:

dde prog.c

2.17.2 Exiting dde

The command(s) to exit dde depend on whether the text editor or word processor is being used.

2.17.2.1 Exiting the text editor

The command sequence that exits the text editor depends on its current state. The following commands should be executed in the sequence in which they are presented and will exit the text editor ( in most cases ):

If there is a blinking high density `W' on the information line ( which indicates window mode ) type `<ESC>'. If the blinking high density `W' on the information line does not disappear, type `<ESC><UpArrow><ESC>'.

If there is a blinking high density `M' on the information line ( which indicates that a macro is being created ) type `^X' followed by `]'.

Type `^C' to exit dde. If dde asks for confirmation, type `yes' followed by `<RETURN>'.

2.17.2.2 Exiting the word processor

Typing `<ESC><ESC>e' will exit the word processor ( in most cases ). If dde asks for confirmation, type `yes' followed by `<RETURN>'.

2.17.3 Getting help

To obtain interactive help from dde, type `<ESC>h'. dde will display a menu of choices. Use `<LeftArrow>' or `<RightArrow>' to navigate inside the menu. Use `<DownArrow>' to make a choice. Use `<UpArrow>' to go to the previously displayed menu or to exit the help system ( only if currently in the first menu ). When inside an explanation window ( a window that doesn't have any menu choices ), use the directional keys for navigation and `<ESC>' to return to the last menu.

2.17.4 Inserting Text

dde will automatically insert every printable character typed into the text being processed. The character is inserted at the location of the cursor and the cursor is moved forward. If there is text past the cursor, this text will be shifted forward. As the line of text passes the margin, dde will automatically split the line, in the text editor, or display the word that reached the margin on the next line, in the word processor. Type `<RETURN>' to end the current line. The current line will be split and the cursor will be placed at the beginning of the next line. The new line will consist of text from the old line that was located at and after the cursor.

2.17.5 Deleting Text

dde allows you to delete text by character, by line and by region.

2.17.5.1 Deleting a character

To delete the character on which the cursor is located, use `^D' or `<Del>'. If there is text past the cursor, this text will be shifted backward. If `^D' or `<Del>' is typed at the end of the line, the line that the cursor is on and the next line will be merged.

To delete a character immediately preceding the cursor use `^H' or `<BackSpace>'. If there is text past the cursor, this text will be shifted backward. If `^H' or `<BackSpace>' is typed at the beginning of the line, the line on which the cursor is located will be merged with the previous line.

Note, that because the word processor automatically wraps words too long to fit onto a single line onto the next, deletion commands have more subtle behavior when used in the word processor.

2.17.5.2 Deleting a region

A region is defined as an area of text between a mark and the cursor ( note that the region may be empty ). Therefore, before deleting a region, a mark should be set. To set a mark, use `^@'. After the mark is set ( and therefore the region is defined ), use `^W' in the text editor or `<ESC>d' in the word processor to delete the region. After issuing this command, all characters are deleted from the region to the kill buffer ( see 2.7 ).

2.17.5.3 Deleting a line ( text editor only )

Typing `^K' will delete the contents of the line from the cursor position to the last character on the line. Note that if the cursor is located at the end of a line, the next line will be merged with the line that the cursor is on. If the cursor is not at the end of a line, issuing this command will not merge lines. Text deleted by this command is placed into the kill buffer ( see 2.7 ). A sequence of consecutive ^K's will append to the kill buffer, with the first `^K' erasing it, prior to inserting deleted text.

2.17.6 Movement Commands

dde provides a wide range of commands for moving the cursor a character, a line or a screen at a time. Directional keys perform the commands that are intuitively associated with them. Namely:

<RightArrow> - moves the cursor one character
forward. An end of line or tab
counts as one character. If the
cursor is located at the end of
the line, it is moved to the
beginning of the next line.

<LeftArrow> - moves the cursor one character
backward. An end of line or tab
counts as one character. If the
cursor is located at the beginning
of the line, it is moved to the
end of the previous line.

<UpArrow> - moves the cursor up one line;
attempts to keep the cursor at the
same horizontal position.

<DownArrow> - moves the cursor down one line;
attempts to keep the cursor at the
same horizontal position.

<PgUp> - moves the cursor up by the number
of the lines in the window;
attempts to keep the cursor at the
same horizontal position.

<PgDn> - moves the cursor down by the
number of the lines in the window;
attempts to keep the cursor at
the same horizontal position.

<Home> - locates the cursor at the first
character in the buffer and
updates the screen appropriately.

<End> - locates the cursor immediately
after the last character in the
buffer and updates the screen
appropriately.

In the text editor, these commands may be also performed by

pressing control keys or escape sequences as follows:

^F - identical to `<RightArrow>' and moves the
cursor one character forward.

^B - identical to `<LeftArrow>' and moves the
cursor one character backward.

^P - identical to `<UpArrow>' and moves the
cursor up one line.

^N - identical to `<DownArrow>' and moves the
cursor down one line.

<ESC>v - identical to `<PgUp>' and moves the
cursor up by the number of the lines in
the window.

^V - identical to `<PgDn>' and moves the
cursor down by the number of the lines in
the window.

<ESC>< - identical to `<Home>', locates the cursor
at the first character in the buffer and
updates the screen appropriately.

<ESC>> - identical to `<End>', locates the cursor
immediately after the last character in
the buffer and updates the screen
appropriately.

In addition, the text editor provides the following movement

commands:

<ESC>, - locates the cursor at the first character
in the window.

<ESC>. - locates the cursor after the last
character in the window.

^A - moves the cursor to the beginning of the
line.

^E - moves the cursor to the end of the line.

^Z - scrolls the window up one line. If the
cursor was not located at the first line
of the window before executing this
command, it is left at the same buffer
location. Otherwise, the cursor is
located in the center of the screen.

<ESC>z - scrolls the window down one line. If the
cursor was not located at the last line
of the window before executing this
command, it is left at the same buffer
location. Otherwise, the cursor is
located in the center of the screen.

<ESC>! - causes the line that contains the cursor
to become the first line in the window.

If mouse is installed, you can move to ( almost ) any location by clicking on the desirable location.

2.17.7 Searches

dde supports incremental search for string and regular expression search ( regular expressions are supported only by the text editor ). An incremental search will match the first occurrence of every substring of the string that is typed. In the text editor, incremental search will be performed dynamically as the search string is entered. Entering `^S' in the text editor performs a forward incremental search, while `^R' performs a backward incremental search. To search in the word processor, type `<ESC>s', the string to search for and `<RETURN>'.

See 4.1.2.3 for information on regular expression searches.

2.17.8 File Handling

dde provides the ability to examine files by loading them at invocation, reading them into a buffer, inserting them at a particular point and executing them. Files may be modified by overwriting them with the file being edited or writing the contents of a buffer to the file. To load a file, its name should be specified as a parameter when the program is invoked ( see 2.16.1 ). Once you are inside the text editor, the following commands may be used to get the contents of a file into a buffer:

^X ^V - prompts for the name of a file to read and

selects a window in which to load it. If no buffer contains the specified file, the file is loaded from disk. Otherwise, a new window is attached to this buffer and the file ( the contents of this buffer ) is displayed starting from the beginning. The buffer which contains the file contents will be associated with this file.

^X ^R - prompts for the name of a file to read and

selects a window in which to load it. The file is always loaded from the disk and the buffer which contains the file contents will not be associated with this file.

^X ^I - prompts for the name of a file to read and

inserts the contents of the file at the current position. The cursor is set at the first character of the inserted data. The file is always loaded from the disk.

From inside the text editor you may write to a file(s) by executing one of the following commands:

^X ^W - prompts for name of a file to write to and

writes the contents of the current buffer to the named file.

^X ^S - writes the contents of the current buffer

to the file associated with it ( if any ).

^X ^M - writes the contents of each modified

buffer to the file associated with it ( if any).

^X ^F - writes the contents of each modified

buffer to the file associated with it ( if any ) and exits.

To perform file handling from within the word processor, go to the main menu ( by typing `<ESC>' ) and choose the appropriate operation:

Read - to read a file into the word

processor.

Write - to write the contents of the word

processing buffer to a file.

Insert - to insert a file at the current cursor

position in the word processing buffer.

Overwrite - to write out the contents of the word

processing buffer to the file associated with it ( if any ).

3. Windows

Windows are what distinguish dde from most other text processors. Like window applications on many advanced workstations, dde supports covered rectangular windows, i.e., windows that can overlap arbitrarily ( just like pieces of paper on a desk ). It allows the creation of any number of any sized windows and locates them in any position on or outside of the screen. dde provides commands to create, resize and move windows, to change window attributes ( e.g., user definable tabs ), modify a window's appearance and provide a flexible interface between data and window representation.

3.1 Window definition

dde assumes the working area to be a two-dimensional area "unrestricted" in all directions. The visible part of this area is the screen ( see 2.1 ). The window is a finite rectangular subset of the working area. It may be fully contained by the screen, partially contained by the screen or may not have any common point with the screen. There is a total ordering imposed on all the windows such that the window higher in the order covers windows that are lower ( this is called 2.5 dimensions, since the rectangles are thought to be layered in another dimension pointing out of the screen ).

The visible part of a window's perimeter may be outlined by a border symbol. Each window may have a status line, which contains information about the window ( see 3.2 ). The display ( working ) area of the window is the area inside the window's perimeter, excluding the status line. See 4.1.6.19 on how to affect appearance of a window.

3.2 Status Line

The status line holds information about the window, such as the name of the file associated with the window, statistics about the current cursor position, positioning in the window, etc. Listed below are fields within this line, starting from the leftmost position.

The leftmost field contains the number of the window. Each window is numbered starting with 1.

The field to right of the window number contains the word `Buffer' or `File' depending on the type of the windows buffer. `Buffer' appears if no file is associated with the buffer of this window. The full path name of the file, associated with the buffer of this window, follows `File'. If the file was updated, `*' follows this field.

The next field to the right contains statistics about the cursor location in this window:

- a percentage representing the number of
characters before the cursor as compared to
the total number of characters in the buffer

- the line number where the cursor is located

- the current total number of lines in the
buffer, associated with this window.

For example on a LINUX system:

5 File: /wd/ed/dde.doc* 25% line 451 of 2608

is a valid status line for a window ( numbered ) 5. This window represents file `dde.doc' in the directory `/wd/ed'. This file has been updated and currently has 2608 lines. The cursor is currently located on line 451, preceded by 25% of the characters in the buffer associated with this window. The same situation on a WINDOWS system would be:

5 File: c:\wd\ed\dde.doc* 25% line 451 of 2608

( assuming the file is located on drive `c' ).

3.3 Current window

At any point in time, there is a current window - a window that accepts input. No restrictions are imposed on the current window ( it may not be the highest in order, may be only partially displayed on the screen, may not be on the screen at all, etc. ). Most of the functions and commands provided by dde refer to the current window.

3.4 Standard window

The standard window is a window that is located in the center of the screen and occupies about 3/4 of the screen.

3.5 Zoomed window

A zoomed window is a window which is sized and located so that its display area and status line cover the screen. Zooming is the command that causes the window to be zoomed. After jumping to a particular window, you may wish to zoom it to utilize the full screen. Note, that zooming does not necessarily enlarge the window.

3.6 Icons

An icon represents the window when it is not being displayed. The window will continue to be updated, but stays invisible. Commands are provided that transform a window to an icon ( thus making it invisible ) and that transform an icon to a window ( thus displaying the contents of the window ).

3.7 Operations on windows

The operations allowed on windows include the following:

1. Move a window horizontally or vertically
2. Reshape a window's dimensions
3. Change a window's order in the window hierarchy
4. Select a window to be current
5. Create a new window
6. Change a window's attributes
7. Change a window to an icon or an icon to a window

In addition, some compound operations are provided ( e.g. - change window dimensions and location to cover the entire screen and make it the top window in the hierarchy ). See 4.1.6 for a detailed description of the window functions.

3.8 Menus

dde uses a multilevel, multiple choice menu system to allow you to chose a command or mode, set parameters and perform operations. Each menu level offers one or more groups, each with one or more choices. dde prints in bold the current item in every group, highlights the current item in the current group and prints a brief description of it.

Menus are handled by the following set of operations:

next_item -`<RightArrow>': moves to the next item in
the group

previous_item-`<LeftArrow>':moves to the previous
item in the group

up_group - `<TAB>': moves to the current item
in the next group in the
menu level.

down_group - `<BackSpace>': moves to the current item
in the previous group in
the menu level.

level_up - `<UpArrow>': moves to the current item
in the menu level, previous
to the current menu item.
If the current level is the
highest in the menu
hierarchy, the menu system
will be exited and dde will
continue its execution.

level_down - `<DownArrow>': moves to the current item
in the menu level,
following the current menu
item. If the current level
is not followed by another
level, the current menu
item will be chosen.

exit_menu - `<RETURN>': chooses the current item
and exits the menu system.

quit_menu - `<ESC>': cancels all previously made
choices and moves to the
highest level in the menu
system.

delay_menu - `^T': prompts for the delay time
in seconds and freezes dde
for that duration.

All menu choices are circular ( e.g., hitting `next_item' on the last item in the group moves the cursor to the first item in the group ). Menu choices may also be made by pressing the first letter of the desired item. In order to provide this capability, menu items, provided by dde, begin with a unique letter but may be slightly less descriptive.

3.9 Forms

Forms are menu items that allow data entry. Limited editing capacities ( described in 2.4 ) are supported while entering data into a form. All menu operations ( described in 3.8 ) are valid for forms, with the exception of `quit_menu'. Entering `quit_menu' the first time within a form will cancel all performed changes and load the form with its original data. Entering `quit_menu' a second time will operate as described in 3.8. When first invoked, dde sets up the form to contain the current value of the attribute controlled by this form.

4. Commands

dde provides a set of functions and commands to perform different text processing tasks. This chapter gives detailed description of all the functions and commands that are supported by dde.

4.1 Text Editor

Every function, supported by the text editor, may be called explicitly ( see 4.1.7.6 ). However, there is a way to bind a certain keystroke(s) with the dde function. This simply means that entering the keystroke(s) will cause execution of the associated function. See 4.1.8 for more details.

This section describes all the functions that are supported by the text editor and gives their default bindings. For some of these functions, there is more than one default binding. This means that there is more than one keystroke sequence assigned to the function, and that it can be executed either way. See 4.1.8.1 for a description of how to change a binding.

4.1.1 Movement functions

4.1.1.1 mv_c_r - move cursor right

Default binding: ^F, <RightArrow>

Moves the cursor one character forward; the end of a line and tabs count as one character. If the cursor is located at the end of the line, it is moved to the beginning of the next line.

4.1.1.2 mv_c_l - move cursor left

Default binding: ^B, <LeftArrow>

Moves the cursor one character backward; the end of a line and tabs count as one character. If the cursor is located at the beginning of the line, it is moved to the end of the previous line.

4.1.1.3 mv_c_u - move cursor up

Default binding: ^P, <UpArrow>

Moves the cursor up one line; attempts to keep the cursor at the same horizontal position.

4.1.1.4 mv_c_d - move cursor down

Default binding: ^N, <DownArrow>

Moves the cursor down one line; attempts to keep the cursor at the same horizontal position.

4.1.1.5 page_b - move cursor up by window size

Default binding: <ESC> V, <PgUp>

Moves the cursor up by the number of the lines in the window; attempts to keep the cursor at the same horizontal position.

4.1.1.6 page_f - move cursor down by window size

Default binding: ^V, <PgDn>

Moves the cursor down by the number of the lines in the window; attempts to keep the cursor at the same horizontal position.

4.1.1.7 mv_c_b - move cursor to the beginning of the line

Default binding: ^A

Moves the cursor to the beginning of the current line.

4.1.1.8 mv_c_e - move cursor to the end of the line

Default binding: ^E

Moves the cursor to the end of the current line. The cursor is positioned after the last character in the line.

4.1.1.9 mv_up - move current line to the top

Default binding: <ESC> !

Causes the line that contains the cursor to become the first line in the window; the cursor is kept to point to the same character position in the buffer.

4.1.1.10 mv_c_bb - move cursor to the beginning of the buffer

Default binding: <ESC> <, <Home>

Moves the cursor to the beginning of the buffer. Updates display appropriately.

4.1.1.11 mv_c_eb - move cursor to the end of the buffer

Default binding: <ESC> >, <End>

Moves the cursor to the end of the buffer. Updates display appropriately.

4.1.1.12 mv_c_first - move cursor to the beginning of the window

Default binding: <ESC> ,

Moves the cursor to the first character in the current window.

4.1.1.13 mv_c_last - move cursor to the end of the window

Default binding: <ESC> .

Moves the cursor to the last character in the current window.

4.1.1.14 scrl_u - scroll one line up

Default binding: ^Z

Scrolls the display of the current window one line up. If the function causes the line that contains the cursor to move out of the window, then the cursor is located in the center of the current window. Otherwise, the cursor position in the buffer is unchanged ( but it is changed on the screen ).

4.1.1.15 scrl_d - scroll one line down

Default binding: <ESC> z

Scrolls the display of the current window down one line. If the function causes the line that contains the cursor to move out of the window, then the cursor is located in the center of the current window. Otherwise, the cursor position in the buffer is unchanged ( but it is changed on the screen ).

4.1.1.16 g_to_l - go to line

Default binding: ^X l

dde prompts for a number to be entered ( "goto line:" ) and moves the cursor to the beginning of the specified line. Line numbers are counted starting from 1. If the entered number is larger than the number of lines in the current buffer, the cursor is moved to the last line in the buffer.

4.1.1.17 m_set - set mark

Default binding: ^@

Places a mark at the location of the cursor. The mark is defined by the index of the character in the buffer. The mark index is not changed if the cursor is moved, but might be updated if the buffer is updated. The cursor position and the mark define a region which is used by some of the dde functions ( see 4.1.3.3, 4.1.3.4 ).

4.1.1.18 m_exg - exchange mark and current cursor

Default binding: ^X ^X

Places the mark at the location of the cursor and moves the cursor to the character at the old mark index. Updates display appropriately.

4.1.1.19 m_c_xy - move cursor to screen position

Default binding: none

Prompts for coordinate of the location and moves the cursor to that location on the console. This function is automatically generated when cursor is moved using mouse.

4.1.2 Search and Replacement

4.1.2.1 f_srch - forward search

Default binding: ^S

Performs an incremental search from the current cursor location towards the end of the buffer. When this function is invoked, dde prompts with "I-search:" and expects the search string to be entered. It moves the cursor to the end of the string that matches the currently entered portion of the search string. The message "Failing I-search:" followed by the entered search string appears if no match is found.

Entering `<BackSpace>' deletes the last character from the searched string and moves the cursor back to the end of the string that was the last match for the new search string.

Entering `^S' performs a forward search from the current cursor location with the currently entered search string. If no search string is entered, the search string from the last ( forward or reverse ) search function is used.

Entering `<ESC>' exits a forward search without causing any additional actions.

Any other nonprintable input causes dde to exit the forward search and to interpret this input as the beginning of the next command.

4.1.2.2 r_srch - reverse search

Default binding: ^R

Performs an incremental search from the current cursor location towards the beginning of the buffer. When this function is invoked, dde prompts with "Reverse I-search:" and expects the search string to be entered. It moves the cursor to the beginning of the string that matches the currently entered search string. The message "Failing Reverse I-search:" followed by the entered search string appears if no match is found.

Entering `<BackSpace>' deletes the last character from the searched string and moves the cursor forward to the beginning of the string that was the last match for the new search string.

Entering `^R' performs a reverse search from the current cursor location with the currently entered search string. If no search string is entered, the search string from the last ( forward or reverse ) search function is used.

Entering `<ESC>' exits reverse search without causing any additional actions.

Any other nonprintable input causes dde to exit a reverse search and to interpret this input as the beginning of the next command.

4.1.2.3 f_resrch - regular expression forward search

Default binding: <ESC> ^S

Performs a ( see 2.13 ) search from the current cursor location towards the end of the buffer. When this function is invoked, dde prompts with "RE-search:" and expects the search string to be entered.

Entering `<RETURN>' starts the search or, if no search string is entered, causes the search string from the last regular expression search function to appear, ready for editing. See 2.4 for an explanation of the editing facilities available while entering a search string.

4.1.2.4 q_repl - replace string

Default binding: <ESC> q

dde prompts for the string to be replaced ( "Old string:" ), the replacement string ( "New string:" ), and then performs a forward search from the current cursor location for the string to be replaced. When the searched for string is found, dde waits for input and performs actions based on the input received as follows:

^G exits the function without changing the found
occurrence of the string to be replaced.

! changes all occurrences of the string to be
replaced to the replacement string, starting
from the one found.

During the replacement process, the status
line(s) for the affected buffer will be updated
to correspond with the position where
replacement takes place.

. changes the found occurrence of the string to
be replaced to the replacement string and exits
the function.

<SPACE> changes the current occurrence of the
string to be replaced with the replacement
string and continues to the next.

n does not change the current occurrence of the
string to be replaced, but continues to find
the next occurrence.

Upon terminating, this function reports the total number of changes that were made and returns the cursor to the position where the function was initiated.

4.1.2.5 q_re_repl - replace regular expression string

Default binding: <ESC> ^Q

dde prompts for the string to be replaced ( "Old string:" ), the replacement string ( "New string:" ) ( see 2.13.1 on how to specify input strings ), and performs a forward search from the current cursor location for the string to be replaced. When the searched for string is found, dde waits for input to be entered and performs actions based upon the received input as follows:

^G exits the function without changing the found
occurrence of the string to be replaced.

! changes all occurrences of the string to be
replaced to the replacement string, starting
from the one found.

During the replacement process, the status
line(s) for the affected buffer will be updated
to correspond with the position where
replacement takes place.

. changes the found occurrence of the string to
be replaced to the replacement string and exits
the function.

<SPACE> changes the current occurrence of the
string to be replaced with the replacement
string and continues to the next.

n does not change the current occurrence of the
string to be replaced, but continues to find
the next occurrence.

Upon terminating, this function reports the total number of changes that were made and returns the cursor to the position where the function was initiated.

4.1.3 Deletion

4.1.3.1 del_c - delete character

Default binding: ^D, <Del>

Deletes the character on which the cursor is located. If there is text past the cursor, this text will be shifted backwards. If the cursor is located at the end of the line, the next line is merged with the line on which the cursor is positioned.

4.1.3.2 del_cp - delete previous character

Default binding: ^H, <BackSpace>

Deletes the character that immediately precedes the cursor. If there is text past the cursor, this text will be shifted backwards. If the cursor is located at the beginning of the line, the line is merged with the previous line.

4.1.3.3 k_eol - kill to the end of the line

Default binding: ^K

Deletes characters from the current cursor location to the end of the line. If the cursor is positioned at the end of a line, then the end of line character is deleted. Otherwise, characters are deleted up to, but not including, the end of line character. The deleted characters are appended to the kill buffer. If the previous function was not `k_eol', the contents of the kill buffer will be erased prior to appending the deleted characters.

4.1.3.4 k_buf - delete a region

Default binding: ^W

Deletes characters in the region between the current cursor position and mark. The deleted data is moved to the kill buffer, replacing its old contents.

4.1.4 Insertion

4.1.4.1 cr_back - insert line

Default binding: ^O

Inserts the end of line character immediately after the cursor position. The cursor position remains unchanged and the screen is updated appropriately. To create an empty line, position the cursor on the beginning of the line before executing this function.

4.1.4.2 nl_ind - insert line and indent

Default binding: ^J, <ESC> i

Text consisting of the end of line character, followed by zero or more spaces is inserted at the position just before the cursor. Exactly enough spaces are entered to cause the newly created line to have the same indentation as the previous one. The first inserted character in the newly created line will be in the same column as the first non-blank character of the preceding line. The cursor is moved to the position of the first inserted character in the new line.

4.1.4.3 q_char - quote next character

Default binding: ^Q

Inserts the next input character into the current buffer without attempting to treat it as a command. If the next input character is a non-graphical character ( e.g. `^L' ) it is inserted into the current buffer. Otherwise, if the next two input characters are hexadecimal digits, the character of specified ( ) value is inserted into the current buffer.

This function may be used to insert special characters into the text ( e.g. `^L' ). See 2.10 on how non-ASCII characters will be displayed. See 5.2, 5.6 for an examples of a possible use.

4.1.4.4 yank - yank from the kill buffer

Default binding: ^Y

Inserts the contents of the kill buffer before the current cursor position. This function doesn't change the contents of the kill buffer, thus allowing the same data to be yanked more than one time.

4.1.5 Dealing with files

4.1.5.1 v_fil - visit file

Default binding: ^X ^V

dde prompts for the name of a file to read ( "file_name:" ) and loads the specified file into a window. The window is selected according to the following rules:

if the current window contains no file and no data -the file is loaded into this window;

else

if current window is large enough to be split horizontally ( see 4.1.9.5 ), it is split horizontally and the file is loaded into the bottom window;

else

if current window is large enough to be split vertically ( see 4.1.9.6 ) it is split vertically and the file is loaded into the right window;

else

a standard window ( see 3.4 ) is created and the file is loaded into it.

If no buffer contains the specified file, a new buffer of type `file' ( see 2.6 ) is created and the file is loaded from the disk. Otherwise, a new window is attached to this buffer and its context is displayed in it.

4.1.5.2 i_fil - insert file

Default binding: ^X ^I

dde prompts for the name of a file to be inserted ( "file_name:" ) and inserts it ( from the disk ) at the current position. The cursor is positioned at the first character of the inserted data.

4.1.5.3 r_fil - read file

Default binding: ^X ^R

dde prompts for a name of the file to be read ("file_name:" ) and loads the specified file into a window. The window is selected according to the following rules:

if the current window contains no file and no data, the file is loaded into it;

else

if current window is large enough to be split horizontally ( see 4.1.9.5 ), it is split horizontally and the file is loaded in the bottom window;

else

if current window is large enough to be split vertically ( see 4.1.9.6 ) it is split vertically and the file is loaded in the right window;

else

a standard window ( see 3.4 ) is created and the file is loaded into it.

The file is loaded from the disk into the selected windows buffer and the cursor is set at the first position of the buffer. Note that the buffer is of the type `buffer' ( see 2.6 ) and is not attached to the file.

4.1.5.4 e_fil - execute file

Default binding: <ESC> e

dde prompts for the name of a file ( "file_name:" ) and treats its contents as commands to be executed. See 2.12.3 how the context of the executed file is interpreted. See 5.2, 5.6 for examples of how to utilize this function.

4.1.5.5 w_fil - write file

Default binding: ^X ^W

dde prompts for the name of a file to write to ( "file_name:" ) and copies the contents of the current buffer to the named file. Note that no backup is created for the output file.

4.1.5.6 w_cfil - write current file

Default binding: ^X ^S

The contents of the current buffer are copied to the file associated with it ( if any ). dde creates a backup, if necessary ( see 2.16.1 ), prints a message signifying completion and marks the current buffer as not modified since the last write ( see 2.6 ).

4.1.5.7 w_modif - write modified files

Default binding: ^X ^M

dde copies the contents of each modified buffer to the file associated with it ( if any ). It creates a backup(s) if necessary ( see 2.16.1 ) and for each written file, prints a message to indicate it was successfully written and marks the associated buffer as not modified since the last write ( see 2.6 ).

4.1.5.8 w_exit - write modified files and exit

Default binding: ^X ^F

dde copies the contents of each modified buffer to the file associated with it ( if any ). It creates a backup(s) if necessary ( see 2.16.1 ) and for each written file prints a message to indicate the file was written. dde exits after writing out all modified files.

4.1.6 Window functions

dde supports covered rectangular windows ( overlapping windows ( see 3.1 ) ) and provides functions to deal with them. All window functions described in this section may be executed explicitly as described in 4.1.7.6. For most of these functions, the key binding is available only in the window mode ( see 4.1.6.20 ).

4.1.6.1 mv_w_r - move window right

Default binding: none

This function moves the current window one position to the right. The parts of the windows which were obscured ( covered ) by the leftmost column of the current window become visible.

4.1.6.2 mv_w_l - move window left

Default binding: none

dde moves the current window one position to the left. The parts of the windows which were obscured ( covered ) by the rightmost column of the current window become visible.

4.1.6.3 mv_w_u - move window up

Default binding: none

This function moves the current window up one position. The parts of the windows which were obscured ( covered ) by the bottom line of the current window become visible.

4.1.6.4 mv_w_d - move window down

Default binding: none

dde moves the current window down one position. The parts of the windows which were obscured ( covered ) by the upper line of the current window become visible.

4.1.6.5 cs_w_db - enlarge the vertical size

Default binding: ^X z

This function enlarges the vertical size ( number of lines ) of the current window by 1. The additional line is added to the bottom of the window and the display is updated appropriately.

4.1.6.6 cs_w_ds - decrease the vertical size

Default binding: ^X ^Z

dde decreases the vertical size ( number of lines ) of the current window by 1. The bottom line of the current window is eliminated and the display is updated appropriately.

4.1.6.7 cs_w_rb - enlarge the horizontal size

Default binding: none

dde enlarges the horizontal size ( number of columns ) of the current window by 1. The additional column is added to the right of the window and the display is updated appropriately.

4.1.6.8 cs_w_rs - decrease the horizontal size

Default binding: none

This function decreases the horizontal size (number of columns ) of the current window by 1. The right column of the current window is eliminated and the display is updated appropriately.

4.1.6.9 window_to_icon - convert window to icon

Default binding: ^X t

When this function is executed, dde prompts for the number of the window to be transformed ( "W#: " ) - enter the number of the desired window or `w' for word processing window, `b' for the window that contains information about buffers and windows ( see 4.1.9.4 ). It converts the specified window to an icon ( see 3.6 ) and updates the screen appropriately.

4.1.6.10 icon_to_window - convert icon to window

Default binding: ^X ^T

When this function is executed, dde prompts for the number of the icons window to be transformed ( "W#: " ) - enter the number of the desired window or `w' for word processing window, `b' for the window that contains information about buffers and windows ( see 4.1.9.4 ). It converts the the specified icon ( see 3.6 ) into a normal ( visible ) window and updates the screen appropriately.

4.1.6.11 jump_w - jump to the window

Default binding: none

When this function is executed, dde prompts for the number of the window which is to become the current window ( "W#: " ) - enter the number of the desired window or `w' for word processing window, `b' for the window that contains information about buffers and windows ( see 4.1.9.4 ). It makes the selected window current and positions the cursor at the location it was before leaving this window.

4.1.6.12 j_next - jump to the next window

Default binding: ^X n

This function jumps to the next numbered window. If there is no window that has a higher number than the current window, it jumps to the first window ( the window with the lowest number ). It makes the selected window current and positions the cursor at the location it was before leaving this window.

4.1.6.13 j_prev - jump to the previous window

Default binding: ^X p

dde jumps to the previous lowest numbered window. If there is no window that has a lower number than the current window, it jumps to the last window ( the window with the highest number ). It makes the selected window current and positions the cursor at the location it was before leaving this window.

4.1.6.14 rise_w - rise window

Default binding: none

This function increases the priority of the current window by one level. If there is a window that has a priority equal to the new priority of the current window, then the priority of that window is decreased by one level. The display is updated appropriately.

4.1.6.15 deep_w - deep window

Default binding: none

dde decreases the priority of the current window by one level. If there is a window that has a priority equal to the new priority of the current window, then the priority of that window is increased by one level. The display is updated appropriately.

4.1.6.16 sett_w - set tab size

Default binding: none

This function prompts for a number to be entered ( "new tab size: " ). The specified number becomes the new tab size for the current window ( only ) and the display is updated appropriately.

4.1.6.17 zr_w - zoom and rise

Default binding: ^X 1

dde makes the current window zoomed ( see 3.5 ) and gives it the highest priority.

4.1.6.18 born_w - create new window

Default binding: none

This function creates a new window that becomes the current window. The buffer associated with this window is empty. The window is given the highest priority. The upper left corner of this window is placed in the middle of the screen and the window is sized to occupy about 1/4 of the screen. The display is updated appropriately.

4.1.6.19 invoke_wind_menu - invoke window menu

Default binding: none

This function invokes window menu. dde provides you with full control over the appearance of the screen and its windows. The convenient way to do this is through window functions arranged in a menu system. While in the menu system, multiple selections may be made. All selections are executed when the menu system is exited. The following sections list the available menu choices at each level and explain their meaning. See 3.8 for more details on the menu system.

4.1.6.19.1 Options

Choices presented by this menu group allow you to choose which window(s) will be affected by commands selected from the window menu. The possible window selections are:

Current - only the current window will be
affected

Every - every currently created window
will be affected

Future_and_Current - the current window, as well as all
windows created in the future,
will be affected

Next - all windows created in
the future will be affected

All_and_Next - all currently created windows, as
well as all windows created in the
future, will be affected

4.1.6.19.2 Commands

The items at this menu level allow you to select command(s) that affect the appearance of the window(s) and/or screen. These commands may affect the status line of the window, the borders of the windows, the window's background or foreground, and the background of the screen console.

4.1.6.19.2.1 Exit

Choosing this item will cause dde to exit the window menu.

4.1.6.19.2.2 Status Line

The groups on this menu level allow you to affect the status line of the selected window(s). The status line is defined by its location inside the window and its foreground and background attributes.

4.1.6.19.2.2.1 LOCATION

The items in this menu group affect the location of the status line inside the selected window(s). The possible choices are:

Above_Down - the status line is located above the
lower border of the window. If the
window does not have a border, the
status line occupies the lowest line
of the window.

Down_On - the status line occupies the lowest
line of the window. If the window has
a border, the status line is located
on the lower border of the window.

Up_On - the status line occupies the highest
line of the window. If the window has
a border, the status line is located
on the upper border of the window.

Below_Up - the status line is located below the
highest border of the window. If the
window does not have a border, the
status line occupies the highest line
of the window.

No_Status_Line - the window does not have a status
line.

4.1.6.19.2.2.2 BACKGROUND

The items in this menu group affect the background attribute of the status line. The possible choices are:

Normal - the background is normal.

Alternate - the background is alternate.

4.1.6.19.2.2.3 FOREGROUND

The items in this menu group affect the foreground attribute of the status line. The possible choices are:

Normal - the foreground is normal.

Bold - the foreground is bold.

4.1.6.19.2.3 Border

The groups on this menu level allow you to affect the border of the window. You may specify whether the border should be present and if so, you may determine how the border will be displayed.

4.1.6.19.2.3.1 PRESENT

The items in this menu group specify if the border is present. The possible choices are:

Yes - the border is present.

No - the border is not present.

4.1.6.19.2.3.2 UPPER_RULER

The items in this menu group specify if the upper ruler will be printed. The upper ruler is a line that appears in place of the top border line and may help to determine the cursor position, line width, etc. Note that the upper ruler appears only when the border is present. The possible choices are:

Yes - the upper_ruler is printed.

No - the upper_ruler is not printed.

4.1.6.19.2.3.3 LEFT_RULER

The items in this menu group specify if the left ruler will be printed. The left ruler is a line that appears in the place of the left border line and may be used to determine the cursor position, page size width, etc. Note, that the left ruler appears only when the border is present. The possible choices are:

Yes - the left_ruler is printed.

No - the left_ruler is not printed.

4.1.6.19.2.3.4 BACKGROUND

The items in this menu group specify the background attribute of the window border. The possible choices are:

Normal - the background is normal.

Alternate - the background is alternate.

4.1.6.19.2.3.5 FOREGROUND

The items in this menu group specify the foreground attribute of the window border. The possible choices are:

Normal - the foreground is normal.

Bold - the foreground is bold.

4.1.6.19.2.4 Window

The groups on this menu level affect the appearance of the window. You may specify the window's foreground and background attributes.

4.1.6.19.2.4.1 BACKGROUND

The items in this menu group specify the background attribute of the window. The possible choices are:

Normal - the background is normal.

Alternate - the background is alternate.

4.1.6.19.2.4.2 FOREGROUND

The items in this menu group specify the foreground attribute of the window. The possible choices are:

Normal - the foreground is normal.

Bold - the foreground is bold.

4.1.6.19.2.5 Console

The items in this menu level specify the background of the screen console. The possible choices are:

Normal - the background is normal.

Alternate - the background is alternate.

4.1.6.19.3 Quit

Choosing this item will cause dde to exit window menu.

4.1.6.20 e_wind_m - enter window mode

Default binding: <ESC> w

This function causes dde to enter window mode. In this mode, the window functions, described earlier, become bound to the following keys:

l, <LeftArrow> : mv_w_l - move window left

r, <RightArrow>: mv_w_r - move window right

u, <UpArrow> : mv_w_u - move window up

d, <DownArrow> : mv_w_d - move window down

v : cs_w_db- enlarge the vertical size

g : cs_w_ds- decrease the vertical size

h : cs_w_rb- enlarge the horizontal size

y : cs_w_ds- decrease the horizontal size

c : born_w - create a new window

j : jump_w - jump to a window

a : rise_w - raise window priority

b : deep window - lower window priority

z : zr_w - zoom and raise window priority

t : sett_w - set tab size

? : help - comprehensive help information

<Ins> : undo - undo previous command

^L : rfrsh_s - refresh the screen

m : invoke_wind_menu - invoke window menu

<ESC> : exit window mode

4.1.7 Macros

dde provides powerful and comprehensive support of macros. It allows macro nesting, assigning names to macros, assigning macros to keystrokes, specifying parameters for macros, etc. The macros can be saved to a file, allowing them to be reused in the future.

dde provides normal and invisible macros. When a normal macro is created, each input character is entered into the macro body and interpreted as a dde command. When an invisible macro is created, each input character is entered into the macro body, but is not interpreted as a dde command. Therefore, creating an invisible macro will not cause any editing actions. This may be useful when creating a macro at initialization time ( see 2.16.2, 5.1 ).

During normal macro creation, and during macro execution, each character is interpreted exactly as dde would interpret it. The only exception is `^\' which has a different meaning when used with macros, as follows:

When a macro is being created, entering `^\' causes all input characters to not be entered into the macro body until `<RETURN>' is pressed.

When a macro is executed, `^\' causes dde to pause macro execution and accept input from the keyboard until `<RETURN>' is pressed. Note that this functionality does not depend on the binding of the `^\' character.

See 2.3 for some additional information.

4.1.7.1 b_d_mac - build unnamed macro

Default binding: ^X (

dde prints out the message "starting default macro" and creates a macro named "no_name_macro" that will consist of the following command(s).

4.1.7.2 b_n_mac - build named macro

Default binding: ^X [

dde prompts for the name of a macro to be created ( "macro name:" ) and, after the name is entered, puts the following command(s) into the macro body.

4.1.7.3 b_d_inv - build unnamed invisible macro

Default binding: <ESC> (

dde prints the string ( "starting default macro" ) and creates a macro named "no_name_macro" that will consist of the following command(s). The command(s) are not executed as they are entered.

4.1.7.4 b_n_inv - build named invisible macro

Default binding: <ESC> [

dde prompts for the name of a macro to be created ( "macro name:" ) and, after the name is entered, puts the following command(s) into the macro body. The command(s) are not executed as they are entered.

4.1.7.5 finish_macro - terminate execution or creation of the macro

Default binding: ^X ], ^X )

If this command is initiated during execution of a macro, the macro execution is terminated. If this command is executed during creation of a macro, dde prints a message indicating that the creation of the macro is completed and will not enter any further data into the macro body.

4.1.7.6 e_n_mac - execute named macro or function

Default binding: <ESC> x

dde prompts for the name of a macro or function to be executed ( "macro/func:" ). It first searches the list of macros and then, if no matching macro is found, searches the list of functions for the specified name. It then executes the matching macro or function.

4.1.7.7 e_d_mac - executes unnamed macro

Default binding: ^X e

Executes macro named "no_name_macro".

4.1.7.8 save_macro - save macro body on the file

Default binding: <ESC> s

dde prompts for the name of a macro to be saved ( "macro name:" ) and then, if macro does exist, the name of the file ( "file_name:" ) in which to save it. dde writes the body of the macro to the named file.

4.1.8 Key binding and description

dde allows the association of certain keystroke(s) with functions. The associated function will then be executed whenever the keystroke(s) are entered. No more than two keystroke(s) can be associated with a function. If a two keystroke sequence is used, the first key must be `<ESC>' or `^X'.

4.1.8.1 assign_key - assign function to keystroke

Default binding: <ESC> ^@

dde prompts for a key to be assigned ( "key:" ) and the name of a function ( "function:" ). It then binds the specified function to the key. In the case of an error ( e.g., a non-existent function ), dde beeps and performs no key assignment.

4.1.8.2 describe_key - describe a keystroke

Default binding: <ESC> ^A

dde prompts for a key to be described ( "key:" ) and, after the key is entered, prints the name of the function that is assigned to the specified key or reports that such a function does not exist ( i.e. the key is not assigned to any function ).

4.1.9 Miscellaneous

4.1.9.1 get_cnt - get count

Default binding: ^U

dde interprets the following string of digits as a number that is used as a count ( number of times ) for the following command to be executed. Any command entered immediately after the string of decimal digits will be executed the number of times indicated by the numeric value of the decimal string. If no decimal digits follow this key sequence, the execution count is set to 4. Note that decimal digits may be used to form a number here, regardless of their key binding.

4.1.9.2 shell_cmd - exit to shell

Default binding: ^_

This function preserves the state dde is currently in and exits to the shell from which you invoked dde. Any shell command may be executed. The command to return to dde is shell dependent ( under WINDOWS it is the `EXIT' command ). After returning to dde, the message "fork completed." appears on the information line and dde returns to the exact state it was in when it left for the shell.

4.1.9.3 exit_dde - exit dde

Default binding: ^C, ^X ^C, <ESC> ^C

dde first checks if there are any updated buffers. If there are, dde asks for confirmation to exit. If confirmation is received ( `y', `ye' or `yes' followed by `<RETURN>' is typed ), dde terminates. Otherwise, it continues executing.

4.1.9.4 b_inf - information about buffers and windows

Default binding: ^X ^B

This function causes information to be printed about buffers and windows. The first time this function is invoked, the standard window is created ( see 3.4 ), and the buffer and window information is printed within it. Any further calls to this function will give this window the highest priority and put its upper left corner close to the upper left corner of the screen, ensuring that at least part of the information is visible; the size and attributes of the window will remain unchanged.

Information about buffers and windows includes buffers name, size, state, type and is printed in the following format:

1. numeration of the item in information about buffers
and windows ( starting from 1 )

2. name of the associated file or macro

3. number of characters in the associated buffer

4. `C' if the buffer is changed, `U' otherwise

5. `F' if the buffer is associated with a file, `M' if
the buffer is associated with a macro, or `B' if
neither a macro nor a file is associated with it

6. list of windows which are attached to this buffer;
each member of this list has the form:

'letter'#'number',

where the 'number' is the number of the window and
the 'letter' is determined as follows:

`p' indicates a word processor window
`t' indicates an icon for a word processor window `i' indicates an icon for a regular window
`w' is used for all other windows;

if the window is the current window, the 'letter'
is printed in uppercase.

For example ( under WINDOWS ):

1. d:\wd\ed\doc\dde.doc 46715 U F w#1 W#2 i#3

2. F1_macro 6 C M

3. F2_macro 6 C M

4. F9_macro 4 C M

5. F3_macro 4 C M

4.1.9.5 hsplit - horizontal split of the current window

Default binding: ^X h, ^X 2

dde reduces the number of lines in the current window by a factor of 2, freeing the bottom part of the window. It creates a new window that occupies the freed area of the current window. The new window will have attributes specified by the window menu ( see 4.1.6.19 ) ( or default - identical to those of the old one ) and will use the same buffer. Areas around the cursor position in both windows are redisplayed. The newly created window becomes the current window.

4.1.9.6 vsplit - vertical split of the current window

Default binding: ^X v

dde reduces the number of columns in the current window by a factor of 2, freeing the right part of the window. It creates a new window that occupies the freed area of the current window. The new window will have attributes specified by the window menu ( see 4.1.6.19 ) ( or default - identical to those of the old one ) and will use the same buffer. Areas around the cursor position in both windows are redisplayed. The newly created window is made to be the current window.

4.1.9.7 rfrsh_s - refresh the screen

Default binding: ^L

This function causes the screen to be redisplayed.

4.1.9.8 undo - undo previous command

Default binding: ^X u, <Ins>

dde supports complete and full undo by allowing any command which affects the cursor or text to be undone. The undo function supported by dde doesn't just restore buffer and cursor position; it recreates the exact screen image which existed before the command being undone was executed. The number of commands that may be undone is 128. If this limit is exceeded or all commands have been undone, undo will print the message "can not undo" and terminate. Note that most of the commands supported by dde can be undone. This includes global substitution, deletion/insertion of any number of characters, window mode commands, etc. The examples of the commands that can not be undone include help command, write to files, exit to shell, etc.

4.1.9.9 delay_exec - delay of execution

Default binding: <ESC> ^T

dde prompts for the delay time ( "Enter delay time in seconds" ) and freezes execution for the specified number of seconds ( see 5.5 for possible usage, see 2.3 for side effects ).

4.1.9.10 help - comprehensive help information

Default binding: <ESC> h, <Help>

dde help support is based on the tree presentation utility ( see 4.3 ) and has an identical interface.

4.1.9.11 invoke_wp - invoke word processor

Default binding: <ESC> m

This function invokes the word processor by making the word processors window to be current and positions the cursor at the location it was before leaving this window. If the word processors window doesn't exist, dde creates it. The created word processors window will have border, left and right rulers and will be sized in such a way that its borders lie at the perimeter of the screen area that excludes the information line ( see 2.2 ).

4.1.9.12 tree_pr - invoke tree presentation utility

Default binding: none

This function invokes tree presentation utility. dde prompts for the name of an outline ( "enter name of the outline file: " ) and displays the input file according to its outline level(s) ( see 4.3 ).

4.2 Word Processor Commands

dde provides a comprehensive set of commands to perform different word processing tasks. Each command may be called through the menu system, by entering control characters or by entering function keys.

This section describes all the word processing commands that are supported by dde and the manner in which they are called.

4.2.1 Menu commands

The menu system is entered by pressing `<ESC>'. While in the menu system, multiple selections may be made. All selections are executed when the menu system is exited. The following sections list the available selections at each level and explain their meaning. See 3.8 for more details on the menu system.

4.2.1.1 Back

This command exits the menu system and resumes word processing.

4.2.1.2 Delete

dde deletes the characters in the region between the current cursor position and the mark. The deleted data is moved into the kill buffer.

4.2.1.3 Yank

dde inserts the contents of the kill buffer before the current cursor position. The content of the kill buffer is not affected by this command.

4.2.1.4 Format

dde allows you to change the format of the processed text. This includes setting the way the characters are displayed and printed, establishing text margins and alignment, etc.

4.2.1.4.1 Character

dde allows you to display and print characters in a variety of ways which combine the following four attributes: bold, italic, underlined and reverse ( see 2.14.1 ). The `Character' menu level allows you to select one of these attributes. It consists of four groups, each of which contains two items.

4.2.1.4.1.1 Bold

.bold;

This group controls the bold attribute of the displayed and/or printed character. Its two choices are:

Yes - all entered text characters will be in boldface

No - all entered text characters will not be boldface

4.2.1.4.1.2 Italic

This group controls the italic attribute of the displayed and/or printed character. Its two choices are:

Yes - all entered text characters will be in italics

No - all entered text characters will not be in
italics

Note that on terminals which can't provide an italic font, text for which an italic attribute is set is displayed as blinking.

4.2.1.4.1.3 Underline

This group controls the underlined attribute of the displayed and/or printed character. Its two choices are:

Yes - all entered text characters will be underlined

No - all entered text characters will not be
underlined

4.2.1.4.1.4 Reverse

This group controls the reverse attribute of the displayed character. Its two choices are:

Yes - all entered text characters will be displayed in
reverse video mode

No - all entered text characters will not be displayed
in reverse video mode

4.2.1.4.2 Paragraph

The items on this menu level affect the layout of the text. They allow you to choose a type of text alignment and to set up left and right margins ( see 2.14.2 ).

4.2.1.4.2.1 Alignment

dde supports four types of alignment: Left, Right, Centered and Justified ( see 2.14.2.2 ). Alignment can be selected by typing the first letter of a particular choice or by using `next_item'/ `previous_item' operations ( see 3.8 ).

4.2.1.4.2.2 Left Margin

This menu item is a form which allows you to establish the left margin for the current paragraph ( see 2.14.2.1 ). The valid values for a left margin are numbers in the range 1 to 132.

4.2.1.4.2.3 Right Margin

This menu item is a form which allows you to establish the right margin for the current paragraph ( see 2.14.2.1 ). The valid values for a right margin are numbers in the range 1 to 132.

4.2.1.5 Search - search for a string

dde allows you to perform an forward and backward search. During the search dde displays each found occurrence of every prefix of the entered string. If no match is found, the appropriate message is displayed, followed by the portion of the entered search string which was matched, terminated with the first mismatched character.

4.2.1.5.1 FOR

This form allows you to enter a search string.

4.2.1.5.2 DIRECTION

This group controls the direction of the search:

Forward - the search is performed from the current
cursor location towards the end of the
buffer
Backward - the search is performed from the current
cursor location towards the beginning of the
buffer

4.2.1.5.3 CASE

This group controls the way the match is established.

On - dde finds an exact match for the entered string
Off - dde considers lowercase letters to be equivalent
to uppercase letters

4.2.1.6 Grammar

dde provides interactive spell-checking which utilizes a dictionary of commonly used words. Words in the text are compared with those in the dictionary without regard for case.

4.2.1.6.1 Options

This menu level consists of three groups of items.

4.2.1.6.1.1 COMPARE

There are two ways dde compares text words against the dictionary of commonly used words:

Full - full compare is performed

Quick - dde assumes that the first 2 characters of the
word in the text are correct

4.2.1.6.1.2 REPLACE

There are two ways dde displays words to be
fixed ( replaced ):

Global - every occurrence of the word in the text is
displayed

Local - only the first occurrence of the word in the
text is displayed and fix ( if specified )
will apply to all occurrences of this word
in the text

4.2.1.6.1.3 FIND

There are two ways dde finds the words to be fixed:

Errors - only words not found in the dictionary of
commonly used words are selected for
correction

All - all words are chosen for correction

4.2.1.6.2 Run

dde performs interactive spell-checking. At each step of this process, dde maintains two windows. The first window, called the context window, displays the word to be fixed ( in high intensity ) in the context it which it appears in the text. The second window, called the correction window, displays words from the dictionary that are linguistically close to the word to be fixed.

4.2.1.6.2.1 Fix

This form allows you to enter the word that will replace the word to be fixed ( displayed in high intensity in the context window ). When invoked, it initially contains the word that is being fixed.

4.2.1.6.2.2 Leave

Entering this menu level causes dde to choose the next word to be fixed and to update the context and correction windows. If no actions are performed for this word to be fixed ( e.g., `Leave' is chosen again ), dde leaves this word unchanged and continues with the next one.

4.2.1.6.2.3 Quit

Entering this menu level, causes dde to terminate the fixing procedure and transfer control back to the previous menu level.

4.2.1.6.3 Quit

dde checks if there were fixes made and requests confirmation to make these changes to the word processing buffer - type `y', `ye' or `yes' followed by `<RETURN>' to confirm. After that, dde exits the spelling checker.

4.2.1.7 Print

dde does not support direct printing. Instead its allows you to format the document for an appropriate printer and to put the formatted output into the file. The file may then be directed to an appropriate printer.

4.2.1.7.1 File name

This form allows you to enter the name of the file to which formatted output will be written. The maximum size of a valid file name is 40 characters.

4.2.1.7.2 Options

This menu level contains two groups which allow you to choose a printer for formatting and set an appropriate print mode.

4.2.1.7.2.1 PRINTER

Items in this group allow you to select a printer as following:

Epson - selects Epson ( or compatible ) printer

HPLaser - selects HP laser printer

DEClps - selects DEC lps laser printer

Plain - creates output which is an ASCII file

4.2.1.7.2.2 MODE

Selection of items from this group affect printing to an Epson printer only.

Draft - formats for printing draft quality mode

NLQ - formats for printing in the near letter quality
mode

4.2.1.7.3 Copies

This form allows you to specify the number of copies to be printed. A valid number of copies is between 1 and 9.

4.2.1.8 Exit

dde checks if there are any updated buffers, and, if so, it asks for confirmation to exit. If is received ( `y', `ye' or `yes' followed by `<RETURN>' is typed ), dde exits the word processing environment. Otherwise, it continues from the point at which this function was called.

If word processing is being terminated and dde was invoked with `-wp' flag ( see 2.16.1 ), dde exits. Otherwise, dde deletes the word processor window and moves to the window from which the word processor was first called ( see 4.1.9.11 ).

4.2.1.9 Quit

If dde was invoked with `-wp' flag ( see 2.16.1 ), dde checks if there are any updated buffers, and, if so, dde asks for confirmation to exit. If is received ( `y', `ye' or `yes' followed by `<RETURN>' is typed ), dde terminates. Otherwise, it continues from the point at which this function was called. If the word processor was invoked from the editor ( see 4.1.9.11 ), dde moves to the window from which the word processor was invoked.

4.2.1.10 Help

dde word processing help support is based on the tree presentation utility ( see 4.3 ) and has an identical interface.

4.2.1.11 Read

dde prompts for the name of a file to read ( "file_name:" ) and loads this file.

4.2.1.12 Write

dde prompts for the name of a file to write to ( "file_name:" ) and copies the contents of the word processing buffer to the specified file.

4.2.1.13 Insert

dde prompts for the name of a file to be inserted ( "file_name:" ) and inserts it at the current position in the word processing buffer. The cursor is moved to the first character of the inserted data.

4.2.1.14 Overwrite

dde copies the contents of the word processing buffer to the file associated with it ( if any ). See 2.16.1 which describes how and when the backup is made.

4.2.1.15 Clear

Redisplays the screen.

4.2.1.16 Tree

This command invokes the tree presentation utility. dde prompts for the name of an outline ( "enter name of the outline file: " ) and displays the input file according to its outline level(s) ( see 4.3 ).

4.2.2 Function keys

The function and shifted function keys perform movement commands and commands which establish character attributes.

4.2.2.1 <F1> - repeat last search

Pressing `<F1>' will repeat an incremental search. The search string, search direction and search case will match those established for the previous search command and are not affected by the execution of this command.

4.2.2.2 <CF2>, <CF12> - move to the beginning of the line

This command moves the cursor to the beginning of the current line ( see also 4.2.3.7 ).

4.2.2.3 <SF2>, <SF12> - move cursor to the beginning of the window

Moves the cursor to the first character in the word processing window.

4.2.2.4 <F2>, <F12> - move to the beginning of the document

This command moves the cursor to the beginning of the word processing buffer.

4.2.2.5 <CF3>, <CF13> - move to the end of the line

This command moves the cursor to the end of the current line ( see also 4.2.3.8 ).

4.2.2.6 <SF3>, <SF13> - move cursor to the end of the window

Moves the cursor to the last character in the word processing window.

4.2.2.7 <F3>, <F13> - move to the end of the document

dde moves the cursor to the end of the word processing buffer.

4.2.2.8 <CF6>, <SF6>, <AF6> - set mark

dde places a mark at the location of the cursor. The mark is defined by the index of the character in the buffer. The mark index is not changed if the cursor is moved, but may be affected if the buffer is updated. The cursor position and the mark define a region which is used by many of the dde commands.

4.2.2.9 <F6> - exchange mark and cursor

This command places the mark at the location of the cursor and moves the cursor to the character at the old mark index.

4.2.2.10 <F4> - set region to normal

Execution of this command causes every character within a region to lose its bold, italic, underline or reverse attribute ( and thus become normal ). For example, if a character in the region was bold, italic and underlined, after pressing `<F4>' it will become normal. Characters in the region which are normal will be not affected by this command.

This command provides a combined functionality of some of the following commands ( that activated by pressing shifted function keys ) and may be especially useful on the terminals that do not support shifted function keys.

4.2.2.11 <CF7>, <F17> - start bold

This command causes all text entered after it to be in boldface ( in addition to already established attributes ). See also 4.2.1.4.1.1.

4.2.2.12 <AF7>, <SF17> - end bold

This command causes text entered after it to no longer be in boldface. See also 4.2.1.4.1.1.

4.2.2.13 <F7> - add bold to a region

This command causes every character within a region to be given the bold attribute, in addition to its previous attributes. For example, if a character in the region was italic and underlined, after pressing `<F7>' it will become bold, italic and underlined.

4.2.2.14 <SF7> - remove bold from a region

Execution of this command causes every character within a region to lose its bold attribute. For example, if a character in the region was bold, italic and underlined, after pressing `<SF7>' it will become italic and underlined. Characters in the region which don't have a bold attribute will be not affected by this command.

4.2.2.15 <CF8>, <F18> - start underline

This command causes text entered after it to be underlined ( in addition to already established attributes ). See also 4.2.1.4.1.3.

4.2.2.16 <AF8>, <SF18> - end underline

This command causes text entered after it to no longer be underlined. See also 4.2.1.4.1.3.

4.2.2.17 <F8> - add underline to a region

Execution of this command gives every character in a region the underline attribute, in addition to its previous attributes. For example, if a character in the region was bold and italic, after pressing `<F8>' it will become bold, italic and underlined.

4.2.2.18 <SF8> - remove underline from a region

Execution of this command removes the underline attribute from every character in the region. For example, if a character in the region was bold, italic and underlined, after pressing `<SF8>' it will become bold and italic. Characters in the region that don't have an underline attribute will be not affected by this command.

4.2.2.19 <CF9>, <F19> - start italic

This command causes all text entered after it to be in italics ( in addition to already established attributes ). See also 4.2.1.4.1.2.

4.2.2.20 <AF9>, <SF19> - end italic

This command causes entered text to no longer be given the italic attribute. See also 4.2.1.4.1.2.

4.2.2.21 <F9> - add italic to a region

Execution of this command will cause every character in a region to be given the italic attribute, in addition to its previous attributes. For example, if a character in the region was bold, after pressing `<F9>' it will become bold and italic.

4.2.2.22 <SF9> - remove italic from a region

Execution of this command will cause every character in a region to lose its italic attribute. For example, if a character in the region was bold, italic and underlined, after pressing `<SF9>' it will become bold and underlined. Characters in the region that don't have an italic attribute will be not affected by this command.

4.2.2.23 <CF10>, <F20> - start reverse

This command causes all text entered after it to be printed on the screen in reverse video. See also 4.2.1.4.1.4.

4.2.2.24 <AF10>, <SF20> - end reverse

This command causes entered text to no longer be given the reverse attribute. See also 4.2.1.4.1.4.

4.2.2.25 <F10> - reverse a region

Execution of this command will cause the background of every character in the region to become reverse. Note that this command does not affect other attributes of the characters in the region.

4.2.2.26 <SF10> - remove reverse from a region

Execution of this command removes the reverse video attribute from every character in the region. Note that this command does not affect other attributes of the characters in the region. Note also that characters in the region that don't have a reverse attribute will be not affected by this command.

4.2.3 Miscellaneous

4.2.3.1 <ESC> - enter menu

Pressing `<ESC>' causes dde to enter the menu system. See 4.2.1 for a complete description of the menu system.

4.2.3.2 <RETURN> - make new paragraph

Pressing `<RETURN>' will create a new line and move the cursor to the beginning of it. This new line will also be the beginning of a new paragraph. See 4.2.1.4.2 on what operations may be performed on paragraphs.

4.2.3.3 ^J - make new line

Entering `^J' will create a new line and move the cursor to the beginning of it. This, however, does not create a new paragraph.

4.2.3.4 ^@ - set mark

This command places the mark at the location of the cursor. The mark is not changed as the cursor is moved but might be affected if the word processing buffer is updated.

4.2.3.5 <BackSpace> - delete previous character

This command deletes the character that immediately precedes the cursor.

4.2.3.6 ^D, <Del> - delete character

This command deletes the character that the cursor is on.

4.2.3.7 ^A - move the cursor to the beginning of the line

This command moves the cursor to the beginning of the current line.

4.2.3.8 ^E - move the cursor to the end of the line

This command moves the cursor to the end of the current line.

4.2.3.9 ^L - insert form feed character

Entering `^L' will insert a form feed character into the word processing buffer. When printing the context of the word processing buffer the form feed character will cause the text that follows it to be printed starting on the new page.

The form feed character is displayed on the screen as .

4.2.3.10 ^O - toggle outline mode

Typing `^O' toggles outline mode. See 4.2.4.1 for a detailed explanation of this command.

4.2.3.11 ^B - increase outline level

See 4.2.4.2 for a detailed explanation of this command.

4.2.3.12 ^F - decrease outline level

See 4.2.4.3 for a detailed explanation of this command.

4.2.3.13 <LeftArrow> - move cursor left

dde moves the cursor one character backward - the end of a line and tabs count as one character.

4.2.3.14 <RightArrow> - move cursor right

dde moves the cursor one character forward - the end of a line and tabs count as one character.

4.2.3.15 <UpArrow> - move cursor up

This command moves the cursor up one line. It attempts to keep the cursor at the same vertical position.

4.2.3.16 <DownArrow> - move cursor down

dde moves the cursor down one line. It attempts to keep the cursor at the same vertical position.

4.2.3.17 <PgUp> - move cursor up by window size

Moves the cursor up by the number of the lines in the word processors window; attempts to keep the cursor at the same horizontal position.

4.2.3.18 <PgDn> - move cursor down by window size

Moves the cursor down by the number of the lines in the word processors window; attempts to keep the cursor at the same horizontal position.

4.2.3.19 <Home> - move to the beginning of the buffer

Moves the cursor to the beginning of the word processors buffer. Updates the display appropriately.

4.2.3.20 <End> - move to the end of the buffer

Moves the cursor to the end of the word processors buffer. Updates the display appropriately.

4.2.3.21 <Help> - comprehensive help information

This command provides help information. dde word processing help support is based on the tree presentation utility ( see 4.3 ) and has an identical interface.

4.2.4 Outline commands

dde provides commands to toggle outline mode and to increase/decrease outline level ( see 2.14.3 ).

4.2.4.1 ^O - Toggle outline mode

Typing `^O' toggles outline mode. If the word processor is in outline mode, outline mode is terminated and the word processing window is updated using the formatting information for each paragraph. The outline levels remain assigned to the paragraphs. If the word processor is not in outline mode, the outline mode is initiated and each paragraph is displayed according to its outline level as described in 2.14.3.2. You may now use commands to increase/decrease outline level ( as well as any other commands supported by dde ). See 2.3 on how outline mode is indicated by dde.

4.2.4.2 ^B - increase outline level

Typing `^B' when in outline mode increases the outline level of the paragraph on which the cursor is located by 1 and updates the screen appropriately. For example, outline level 1 becomes outline level 2. Note that this also causes outline level 0 to become outline level 1. Outline level 15 remains unchanged after this command is executed.

4.2.4.3 ^F - decrease outline level

Typing `^F' when in outline mode decreases the outline level of the paragraph on which the cursor is located by 1 and updates the screen appropriately. For example, outline level 3 becomes outline level 2. Note that this also causes outline level 1 to become outline level 0. Outline level 0 remains unchanged after this command is executed.

4.3 Tree presentation utility

The outlined document may be viewed as a tree with paragraphs of levels 1 or more being nodes and text paragraphs ( paragraphs of level 0 ) being leaves. Each node may have leaves and a set of subtrees consisting of all nodes that belong to it. The tree presentation utility allows you to access the outline as a tree, providing ways to reach its nodes and examine it leaves. You may invoke the tree presentation utility by specifying the command option `-h' on the command line ( see 2.16.1 ) or by selecting the `Tree' entry in the word processor's main menu ( see 4.2.1.16 ). In the latter case, dde prompts for the name of an outline file to be processed. After the tree presentation routine is invoked, it examines the outline file and, if no error is found, it displays up to 32 outline paragraphs of level 1. At this point, you may select one of these paragraphs with menu commands as described in 3.8. Once a paragraph is chosen, the tree presentation utility displays text and up to 32 outlined paragraphs of level 2 that belong to the paragraph selected at level 1, and allows one of these to be chosen. This will be continued until a text paragraph is reached ( no outlines of lower level ). When a text paragraph is chosen, the tree presentation utility creates the standard window ( see 3.4 ) and displays the formatted text in it by loading text into the buffer of the created window. You may scroll through or search this text using the following commands:

<Home> - moves to the beginning of the buffer

Moves the cursor to the beginning of the buffer. Updates the display appropriately.

<End> - moves to the end of the buffer

Moves the cursor to the end of the buffer. Updates the display appropriately.

<LeftArrow> - moves cursor left

Moves the cursor one character backward; the end of a line and tabs count as one character.

<RightArrow> - moves cursor right

Moves the cursor one character forward; the end of a line and tabs count as one character.

<UpArrow> - moves cursor up

Moves the cursor up one line; attempts to keep the cursor at the same vertical position.

<DownArrow> - moves cursor down

Moves the cursor down one line; attempts to keep the cursor at the same vertical position.

<PgDn> - moves cursor down by the size of the standard window

Moves the cursor down by the number of the lines in the standard window; attempts to keep the cursor at the same horizontal position.

<PgUp> - moves cursor up by the size of the standard window

Moves the cursor up by the number of lines in the standard window; attempts to keep the cursor at the same horizontal position.

< - moves cursor to the beginning of the line

Moves the cursor to the beginning of the current line.

> - moves cursor to the end of line

Moves the cursor to the end of the current line. The cursor is positioned after the last character in the line.

, - moves cursor to the beginning of the window

Moves the cursor to the first character in the current window. The display is not updated, only cursor position is changed.

. - moves cursor to the end of the window

Moves the cursor to the last character in the current window. The display is not updated, only cursor position is changed.

^R - performs reverse search

Performs an incremental search from the current cursor location towards the beginning of the buffer. When this command is executed, dde prompts with "Reverse I-search:" and expects the search string to be entered. It moves the cursor to the beginning of the string that matches the currently entered ( portion of the ) search string. The message, "Failing Reverse I-search:", followed by the entered search string appears if no match is found.

Entering `<BackSpace>' deletes the last character from the searched string and moves the cursor forward to the beginning of the string that was the last match for the new search string.

Entering `^R' performs reverse search from the current cursor location with the currently entered search string; if no search string is entered, the search string from the last ( forward or reverse ) search command is used.

Entering `<ESC>' exits reverse search without any additional actions.

Any other non printable input causes dde to exit a reverse search and to interpret this input as the beginning of the next command to be performed on the text of the outline.

^S - performs forward search

Performs an incremental search from the current cursor location towards the end of the buffer. Under invocation of this command dde prompts with "I-search:" and expects the search string to be entered. Its moves the cursor to the end of the string that matches the currently entered ( portion of the ) search string; the message "Failing I-search:" followed by the entered search string appears if no match is found.

Entering `<BackSpace>' deletes the last character from the searched string and moves the cursor back to the end of the string that was the last match for the new search string.

Entering `^S' performs a forward search from the current cursor location with the currently entered search string; if no search string is entered, the search string from the last ( forward or reverse ) search command is used.

Entering `<ESC>' exits forward search without any additional actions.

Any other non printable input causes dde to exit the forward search and to interpret this input as the beginning of the next command to be performed on the text of the outline.

^T - delays the execution

dde prompts for the delay time ( "Enter delay time in seconds" ) and freezes execution for the specified number of seconds ( see 5.5 for possible usage, see 2.3 for side effects ).

<ESC> - exits text display

dde removes the standard window, created to display the text, and returns to the item of the outline from which the command to view the text paragraph(s) was invoked.

5. Suggestions for using dde

This chapter contains hints and suggestions on using some of the features provided by dde. It should not be considered a comprehensive guide to the usage of dde. As you gain experience using the product, you will develop other techniques which suit your needs and professional habits.

5.1 Initialization

When first invoked, dde attempts to perform initialization as described in 2.16.2. During the initialization process, a set of macros may be created. It can be very convenient to create them as invisible macros ( see 4.1.7 ), so there creation would not have any side effects. They may also be assigned to function keys ( by specially naming them as described in 2.11 ) so that they provide a type of customized extension to dde.

5.2 Command files

To fully utilize the function `e_fil - execute file' you may create file(s) that contain a series of useful procedures. Many of these command files may be created and named appropriately to reflect their contents or functionality. They will provide support for a particular pattern of usage.

The text editor can be used to create these command files, either by assembling inserted commands ( and using `q_char - quote next character' - if non-ASCII characters need to be inserted ) or by creating a macro that contains the desired command and using the function `save_macro' to save the macro's body to a file. Then use the `e_fil' function.

If execution of the command files is used often, it may be desirable to create a macro which invokes a command file; the name of the command file to be executed may be specified as a macro parameter ( using `^\' - see 4.1.7 ). The macro may then be assigned to a function key ( see 2.11 ). Then merely pressing this function key and specifying the proper file name will invoke the desired command file. See 5.6 for an example of how to implement this.

5.3 Window switching

In order to efficiently utilize the multi-windowing provided by dde, you may wish to create macros which switch windows, jump to the next window and zoom it ( thus utilizing the full screen and hiding other windows ), change visual attributes of the current window in order to distinguish it from others, etc. Assigning these macros to function keys ( see 2.11 ) will provide the ability to execute complicated procedures which manipulate windows with a single keystroke. See 5.6 for some useful examples.

5.4 Context counting

An important side effect of the replacement function(s) is the ability to determine the number of times a certain string appears in the text. For example, if you wish to know how many times the string "foo" is used in the text, the function `q_repl - replace string' can be executed, with both the "Old string:" and the "New string:" specified as "foo" and `!' selected to indicate global substitution. Upon completion of this command, dde will print the total number of changes, which, in this case, will actually be equal to the number of times the string "foo" occurred in the buffer. Note that the cursor position will not be affected by this procedure, but the buffer will be marked as modified. If the string being counted is quite long, instead of retyping it in response to both the "Old string:" and the "New string:" prompts, you may specify "New string:" to be a shorter string ( or just hit the `<RETURN>' key ). After the command is completed and the count obtained, the undo function ( see 4.1.9.8 ) can be executed to undo the replacement, putting everything back as it was, but saving you some typing.

You may use `q_re_repl - replace regular expression string' to count more subtle string groups in the text.

5.5 Demos

Using dde, you may create demo presentations and then automatically display them. The key elements within dde which provide the means of doing this, are the abilities to specify an initialization file and to delay of execution. Follow the steps below to create a demo which can be executed automatically:

1. Create the outline which will be used for the demo.

2. Create the command file that loads the outline and
performs the actions to be demonstrated. Be sure to
allow enough time between the various commands ( use
the `delay the execution' command ( see 4.3 ) to
freeze execution for the prescribed interval ). For
example, if an outline listing different items in a
data base is to be automatically displayed, then
movement between different items and levels in the
outline would be controlled by commands. Between
each movement, there should be enough time for the
demo viewer to study what is currently being
displayed. Specifying an appropriate period of time
to the `delay the execution ' command, will achieve
this.

3. Invoke dde using `-c' switch with the name of the
created command file.

5.6 Examples

1. The following macro will be activated by pressing `<F1>' ( because its name is `F1_macro' ) and will execute a command file from the directory `/dde/cmds'. The name of the command file will be specified as a parameter to the macro.

Here is the body of the macro:

<ESC>[F1_macro

<ESC>e/dde/cmds/^\

^X]

Here is a character-by-character description of the macro:

`<ESC>[' - starts the creation of a named invisible
macro ( since the macro is invisible,
there will be no side effects during its
creation ).

`F1_macro' - specifies the name of the macro being
created. This name will allow the macro
to be executed by pressing the
`<F1>' function key.

`<ESC>e' - invokes the function `e_fil'
( assuming the default bindings have not
changed ). This function requires the
name of a file to be executed.

`/dde/cmds/' - specifies the prefix for a pathname of
the file to be executed by the
preceding `<ESC>e'.

`^\' - causes dde to pause macro execution and
accept the following input as the rest
of a filename of the command file to be
executed.

`^X]' - terminates the creation of this macro.

For example, if you want to execute the command file "/dde/cmds/exec", after invoking this macro, only `exec' ( terminated by `<RETURN>' ) will need to be typed.

2. The following macro is activated by pressing `<F2>' and always executes the file `nxt_wnd' in the current directory. The file `nxt_wnd' will make the foreground of the current window normal, jump to the next window and makes its foreground bold. This macro can be used to switch windows and distinguish the new current window from all others.

Here is the body of the macro:

<ESC>[F2_macro

<ESC>xe_fil

nxt_wnd

^X]

Here is a character-by-character description of the macro:

`<ESC>[' - starts the creation of a named invisible
macro ( since the macro is invisible,
there will be no side effects during its
creation ).

`F2_macro'- specifies the name of the macro being
created. This name will allow the macro
to be executed by pressing the
`<F2>' function key.

`<ESC>x' - invokes the function which executes a
function. The name of the function to be
executed must follow.

`e_fil' - specifies the name of the function to be
executed ( in this case, the function is
the one which invokes a command file.
Note that the function `e_fil' is invoked
by using `<ESC>x' and not its binding.

`nxt_wnd' - specifies the name of the command file to
be invoked.

`^X]' - terminates creation of this macro.

This is the contents of the command file `nxt_wnd':

<ESC>wmoc\kucw<TAB>n

<ESC>^Xn<ESC>wmcw<TAB>b

<ESC>

Here is a character-by-character description of the file:

`<ESC>w' - enters window mode.

`m' - activates the window menu in
window mode.

`o' - selects 'Options' from the
menu.

`c' - selects `Current' from the
menu ( `OPTIONS Current' ).

`\ku' - emulates an `<UpArrow>'
( see 2.12.3 ) which causes
the `level_up' command to be
executed within a menu
( see 3.8 ). This moves to the
next highest menu level.

`c' - selects `Commands' from the
menu.

`w' - selects `Window' from the menu
( `COMMAND Window' ).

`<TAB>' - causes the command `up_group'
to be executed within a menu
( see 3.8 ). In this case,
after the group is switched,
the current menu item is
`FOREGROUND'
(`COMMAND Window FOREGROUND').

`n' - selects `Normal' ( `COMMAND
Window FOREGROUND Normal' ).

`<RETURN>'( new line ) - executes the command
`exit_menu' ( see 3.8 ),
thereby causing the items
selected to be executed and
the menu system to be exited.

`<ESC>' - exits window mode.

`^Xn' - jumps to the next window.

`<ESC>w' - enters window mode (again, in
this case).

`m' - activates the window menu in
the window mode.

`c' - selects `Commands' from the
menu.

`w' - selects 'Window' from the menu
( `COMMAND Window' ).

`<TAB>' - causes the command `up_group'
to be executed within a menu
( see 3.8 ). In this case,
after the group is switched,
the current menu item is
`FOREGROUND'
(`COMMAND Window FOREGROUND').

`b' - selects `Bold' from the menu
( `COMMAND Window FOREGROUND
Bold' ).

`<RETURN>'( new line ) - executes the command
`exit_menu' ( see 3.8 ),
thereby causing the items
selected to be executed and
the menu system to be exited.

`<ESC>' - exits window mode.

Appendix A Terminal support

When running under the LINUX operating system, dde relies on the termcap or terminfo package to obtain information about the terminal and manipulate it. The following is the list of the termcap codes ( printed in bold ) used by dde. This information may help you to extend your termcap or terminfo data base for more efficient use of the product or to establish entries to support new terminals. See appropriate documentation on termcap/terminfo support by your system and for full explanation of the termcap codes.

li specifies the number of lines on the screen

co specifies the number of columns in a line

bl bell

cm cursor motion

cl clear screen

ho home cursor

do down one line

nd non-destructive space ( cursor right

ce clear to the end of the line

ac graphic charset pairs

eA enable alternate character set

as start alternate character set

ae end alternate character set

vs make cursor very visible

ve make cursor appear normal

pc pad character

ti begin program that use cup

te end program that use cup

ks begin key-pad transmit mode

ke end key-pad transmit mode

so begin standout mode

se end standout mode

me turn off all attributes

mb turn on blinking

md turn on bold

us start underline

ue end underline

kb sent by BackSpace key

kh sent by Home Key

@7 sent by End Key

kl sent by Left Arrow key

kr sent by Right Arrow key

ku sent by Up Arrow key

kd sent by Down Arrow key

kN sent by Next Page key

kP sent by Previous Page key

@0 sent by Find Key

*6 sent by Select Key

%1 sent by Help Key

%0 sent by Do Key

kI sent by Insert Key

kD sent by Delete Key

k1 sent by function key F1

k2 sent by function key F2

k3 sent by function key F3

k4 sent by function key F4

k5 sent by function key F5

k6 sent by function key F6

k7 sent by function key F7

k8 sent by function key F8

k9 sent by function key F9

k; sent by function key F10

F1 sent by function key F11

F2 sent by function key F12

F3 sent by function key F13

F4 sent by function key F14

F5 sent by function key F15

F6 sent by function key F16

F7 sent by function key F17

F8 sent by function key F18

F9 sent by function key F19

FA sent by function key F20

S1 sent by shifted function key F1

S2 sent by shifted function key F2

S3 sent by shifted function key F3

S4 sent by shifted function key F4

S5 sent by shifted function key F5

S6 sent by shifted function key F6

S7 sent by shifted function key F7

S8 sent by shifted function key F8

S9 sent by shifted function key F9

Sa sent by shifted function key F10

Sb sent by shifted function key F11

Sc sent by shifted function key F12

Sd sent by shifted function key F13

Se sent by shifted function key F14

Sd sent by shifted function key F15

Sg sent by shifted function key F16

Sh sent by shifted function key F17

Si sent by shifted function key F18

Sj sent by shifted function key F19

Sk sent by shifted function key F20

For the terminals that support user definable function keys ( e.g. VT100 family of terminals ), dde expects the following settings for the shifted function key definitions ( if not specified in termcap/terminfo package ):

<SF6> <ESC>O17~

<SF7> <ESC>O18~

<SF8> <ESC>O19~

<SF9> <ESC>O20~

<SF10> <ESC>O21~

<SF11> <ESC>O23~

<SF12> <ESC>O24~

<SF13> <ESC>O25~

<SF14> <ESC>O26~

<SF15> <ESC>O28~

<SF16> <ESC>O29~

<SF17> <ESC>O31~

<SF18> <ESC>O32~

<SF19> <ESC>O33~

<SF20> <ESC>O34~

Appendix B Execution File Format

The following are the rules which dde follows while interpreting the context of the execution file:

`\\' is interpreted as a single '\' character

`\kb' is interpreted as a <BackSpace> key

`\kh' is interpreted as a <Home> key

`\ke' is interpreted as a <End> key

`\kl' is interpreted as a <LeftArrow> key

`\kr' is interpreted as a <RightArrow> key

`\ku' is interpreted as a <UpArrow> key

`\kd' is interpreted as a <DownArrow> key

`\kn' is interpreted as a <PgDn> key

`\kp' is interpreted as a <PgUp> key

`\in' is interpreted as a <Ins> key

`\dl' is interpreted as a <Del> key

`\nd' is interpreted as a <Find> key

`\sl' is interpreted as a <Select> key

`\rm' is interpreted as a <Remove> key

`\hp' is interpreted as a <Help> key

`\do' is interpreted as a <Do> key

`\f1' is interpreted as a <F1> key

`\f2' is interpreted as a <F2> key

`\f3' is interpreted as a <F3> key

`\f4' is interpreted as a <F4> key

`\f5' is interpreted as a <F5> key

`\f6' is interpreted as a <F6> key

`\f7' is interpreted as a <F7> key

`\f8' is interpreted as a <F8> key

`\f9' is interpreted as a <F9> key

`\fa' is interpreted as a <F10> key

`\fb' is interpreted as a <F11> key

`\fc' is interpreted as a <F12> key

`\fd' is interpreted as a <F13> key

`\fe' is interpreted as a <F14> key

`\ff' is interpreted as a <F15> key

`\fg' is interpreted as a <F16> key

`\fh' is interpreted as a <F17> key

`\fi' is interpreted as a <F18> key

`\fj' is interpreted as a <F19> key

`\fk' is interpreted as a <F20> key

`\s1' is interpreted as a <SF1> key

`\s2' is interpreted as a <SF2> key

`\s3' is interpreted as a <SF3> key

`\s4' is interpreted as a <SF4> key

`\s5' is interpreted as a <SF5> key

`\s6' is interpreted as a <SF6> key

`\s7' is interpreted as a <SF7> key

`\s8' is interpreted as a <SF8> key

`\s9' is interpreted as a <SF9> key

`\sa' is interpreted as a <SF10> key

`\sb' is interpreted as a <SF11> key

`\sc' is interpreted as a <SF12> key

`\sd' is interpreted as a <SF13> key

`\se' is interpreted as a <SF14> key

`\sf' is interpreted as a <SF15> key

`\sg' is interpreted as a <SF16> key

`\sh' is interpreted as a <SF17> key

`\si' is interpreted as a <SF18> key

`\sj' is interpreted as a <SF19> key

`\sk' is interpreted as a <SF20> key

`\c1' is interpreted as a <CF1> key

`\c2' is interpreted as a <CF2> key

`\c3' is interpreted as a <CF3> key

`\c4' is interpreted as a <CF4> key

`\c5' is interpreted as a <CF5> key

`\c6' is interpreted as a <CF6> key

`\c7' is interpreted as a <CF7> key

`\c8' is interpreted as a <CF8> key

`\c9' is interpreted as a <CF9> key

`\ca' is interpreted as a <CF10> key

`\cb' is interpreted as a <CF11> key

`\cc' is interpreted as a <CF12> key

`\cd' is interpreted as a <CF13> key

`\ce' is interpreted as a <CF14> key

`\cf' is interpreted as a <CF15> key

`\cg' is interpreted as a <CF16> key

`\ch' is interpreted as a <CF17> key

`\ci' is interpreted as a <CF18> key

`\cj' is interpreted as a <CF19> key

`\ck' is interpreted as a <CF20> key

`\a1' is interpreted as a <AF1> key

`\a2' is interpreted as a <AF2> key

`\a3' is interpreted as a <AF3> key

`\a4' is interpreted as a <AF4> key

`\a5' is interpreted as a <AF5> key

`\a6' is interpreted as a <AF6> key

`\a7' is interpreted as a <AF7> key

`\a8' is interpreted as a <AF8> key

`\a9' is interpreted as a <AF9> key

`\aa' is interpreted as a <AF10> key

`\ab' is interpreted as a <AF11> key

`\ac' is interpreted as a <AF12> key

`\ad' is interpreted as a <AF13> key

`\ae' is interpreted as a <AF14> key

`\af' is interpreted as a <AF15> key

`\ag' is interpreted as a <AF16> key

`\ah' is interpreted as a <AF17> key

`\ai' is interpreted as a <AF18> key

`\aj' is interpreted as a <AF19> key

`\ak' is interpreted as a <AF20> key

any other character is interpreted "as is".

Appendix C Text Editors Function Summary and Default Binding

Movement functions

mv_c_r move cursor right ^F, <RightArrow>

mv_c_l move cursor left ^B, <LeftArrow>

mv_c_u move cursor up ^P, <UpArrow>

mv_c_d move cursor down ^N, <DownArrow>

page_b move cursor up
by window size <ESC> v, <PgUp>

page_f move cursor down
by window size ^V, <PgDn>

mv_c_b move cursor to
the beginning of
the line ^A

mv_c_e move cursor to
the end of the line ^E

mv_up move current line
to the top <ESC> !

mv_c_bb move cursor to
the beginning of
the buffer <ESC> <, <Home>

mv_c_eb move cursor to
the end of the buffer <ESC> >, <End>

mv_c_first move cursor to
the beginning of
the window <ESC> ,

mv_c_last move cursor to the end
of the window <ESC> .

scrl_u scroll one line up ^Z

scrl_d scroll one line down <ESC> z

g_to_l go to line ^X l

m_set set mark ^@

m_exg exchange mark and
current cursor ^X ^X

mv_c_xy move cursor to screen
position none

Search and Replacement

f_srch forward search ^S

r_srch reverse search ^R

f_resrch regular expression
forward search <ESC> ^S

q_repl replace string <ESC> q

q_re_repl replace regular
expression string <ESC> ^Q

Deletion

del_c delete character ^D, <Del>

del_cp delete previous character ^H, <BackSpace>

k_eol kill to the end
of the line ^K

k_buf delete a region ^W

Insertion

cr_back insert line ^O

nl_ind insert line and indent ^J, <ESC> i

q_char quote next character ^Q

yank yank from the kill buffer ^Y

Dealing with files

v_fil visit file ^X ^V

r_fil read file ^X ^R

i_fil insert file ^X ^I

e_fil execute file <ESC> e

w_fil write file ^X ^W

w_cfil write current file ^X ^S

w_modif write modified files ^X ^M

w_exit write modified files
and exit ^X ^F

Window functions

mv_w_r move window right none

mv_w_l move window left none

mv_w_u move window up none

mv_w_d move window down none

cs_w_db enlarge the vertical size ^X z

cs_w_ds decrease the vertical size ^X ^Z

cs_w_rb enlarge the

horizontal size none

cs_w_rs decrease the
horizontal size none

window_to_icon convert window to icon ^X t

icon_to_window convert icon to window ^X ^T

jump_w jump to the window none

j_next jump to the next window ^X n

j_prev jump to the
previous window ^X p

rise_w rise window none

deep_w deep window none

sett_w set tab size none

zr_w zoom and rise ^X 1

born_w create new window none

invoke_wind_menu invoke window menu none

e_wind_m enter window mode <ESC> w

Macros

b_d_mac build unnamed macro ^X (

b_n_mac build named macro ^X [

b_d_inv build unnamed
invisible macro <ESC> (

b_n_inv build named
invisible macro <ESC> [

finish_macro terminate execution or
creation of the macro ^X ], ^X )

e_n_mac execute
named macro or function <ESC> x

e_d_mac execute unnamed macro ^X e

save_macro save macro <ESC> s

Key binding and description

assign_key assign function
to keystroke <ESC> ^@

describe_key describe a keystroke <ESC> ^A

Miscellaneous

get_cnt get count ^U

shell_cmd exit to shell ^_

exit_dde exit dde ^C, ^X ^C, <ESC> ^C

b_inf information about
buffers and windows ^X ^B

hsplit horizontal split
of the current window ^X h, ^X 2

vsplit vertical split
of the current window ^X v

rfrsh_s refresh the screen ^L

undo undo previous command ^X u, <Ins>

help comprehensive help <ESC> h, <Help>

delay_exec delay of execution <ESC> ^T

invoke_wp invoke word processor <ESC> m

tree_pr invoke tree
presentation utility none

Appendix D Word Processors Command Summary

Function keys

<F1> repeat last search

<CF2>, <CF12> move to the beginning of the line

<SF2>, <SF12> move to the beginning of the window

<F2>, <F12> move to the beginning of the document

<CF3>, <CF13> move to the end of the line

<SF3>, <SF13> move to the end of the window

<F3>, <F13> move to the end of the document

<CF6>, <SF6>, <AF6> set mark

<F6> exchange mark and cursor

<F4> set region to normal

<CF7>, <F17> start bold

<AF7>, <SF17> end bold

<F7> add bold to a region

<SF7> remove bold from a region

<CF8>, <F18> start underline

<AF8>, <SF18> end underline

<F8> add underline to a region

<SF8> remove underline from a region

<CF9>, <F19> start italic

<AF9>, <SF19> end italic

<F9> add italic to a region

<SF9> remove italic from a region

<CF10>, <F20> start reverse

<AF10>, <SF20> end reverse

<F10> reverse a region

<SF10> remove reverse from a region

Miscellaneous

<ESC> enter menu

<RETURN> make new paragraph

^J make new line

^@ set mark

<BackSpace> delete previous character

^D, <Del> delete character

^A move the cursor to the beginning
of the line

^E move the cursor to the end of the line

^L insert form feed character

^O toggle outline mode

^B increase outline level

^F decrease outline level

<LeftArrow> move cursor left

<RightArrow> move cursor right

<UpArrow> move cursor up

<DownArrow> move cursor down

<PgUp> move cursor up by window size

<PgDn> move cursor down by window size

<Home> move to the beginning of the buffer

<End> move to the end of the buffer

<Help> comprehensive help information

Appendix E Command Summary for Tree Presentation Utility

<Home> move to the beginning of the buffer

<End> move to the end of the buffer

<LeftArrow> move cursor left

<RightArrow> move cursor right

<UpArrow> move cursor up

<DownArrow> move cursor down

<PgDn> move cursor down by the size
of the standard window

<PgUp> move cursor up by the size
of the standard window

< move cursor to the beginning of the line

> move cursor to the end of line

, move cursor to the beginning of the window

. move cursor to the end of the window

^R perform reverse search

^S perform forward search

^T delay the execution

<ESC> exit text display

Appendix F Using dde under X window system

This appendix describes the use of the dde in the X window environment. Refer to an appropriate documentation for detailed explanation of the X window terms used in this description.

When running in the X window environment dde allows you to set the different properties ( e.g. font, background and foreground colors, initial size of the window etc. ) and to specify there default values. It does it by obeying X window system guidelines. An appropriate option is searched till it found in the following order:

the command line arguments are parsed for an appropriate option ( see below ).

if there is an environment variable `XENVIRONMENT', then the file specified by it is searched for an appropriate option.

if there is an environment variable `HOME', then the file `.Xdefaults' in the directory specified by the environment variable `HOME', is searched for an appropriate option.

file `/usr/lib/X11/app-defaults/dde' ( if it exists ) is searched for an appropriate option.

If an appropriate option is not found, it is set to a default value as specified below.

The following is the list, of the resource names and there classes, that may be specified in a default file(s):

wboldBorderColor ( class `WboldBorderColor' ) - the color that is used to display the border of a window when it is bold. The default is "Goldenrod".

wBorderColor ( class `WBorderColor' ) - the color that is used to display the border of a window. The default is "Brown".

borderColor ( class `BorderColor' ) - the color that is used to display the border of the screen ( the border of the X windows that is a screen ). The default is "Blue".

background ( class `Background' ) - the background color of the screen. The default is "Black".

borderWidth ( class `BorderWidth' ) - the width in pixels of the border of the screen ( the border of the X windows that is a screen ). The default is "2".

cursorColor ( class `CursorColor' ) - the color that is used to display the text cursor. The default is "Red".

display ( class `Display' ) - display to be used. The default is the value of an environment variable `DISPLAY'.

foreground ( class `Foreground' ) - the color to display text. The default is "Green".

font ( class `Font' ) - the font to display text. The default is "fixed".

geometry ( class `Geometry' ) - geometry of the screen ( geometry of the X windows that is a screen ). The default is "=80x24+0+0".

title ( class `Title' ) - the name that may be used by the window manager when displaying application. The default is "dde".

iconName ( class `Title' ) - the string to name the icon of the application. The default is "dde".

The application class name is `Emacs'. If a color is specified, it should be one from the default color database ( see file `/usr/lib/X11/rgb.txt' ).

The following is the list of the command line arguments that are supported, when running under the X window system, together with those described in 2.16.1.

-bbc color - specifies the color that is used to display the border of a window when it is bold. The default is "Goldenrod".

-bc color - specifies the color that is used to display the border of a window. The default is "Brown".

-bd color - specifies the color that is used to display the border of the screen ( the border of the X windows that is a screen ). The default is "Blue".

-bg color - specifies the background color of the screen. The default is "Black".

-bw number - specifies the width in pixels of the border of the screen ( the border of the X windows that is a screen ). The default is "2".

-tc color - specifies the color that is used to display the text cursor. The default is "Red".

-display display - specifies the display to be used. The argument to the display option ( display ) is referred to as a standard display specification. The default is the value of an environment variable `DISPLAY'.

-fg color - specifies the color to display text. The default is "Green".

-fn font - specifies the font to display text. The default is "fixed".

-geometry=geometry - specifies geometry of the screen ( geometry of the X windows that is a screen ). The argument to the geometry option ( geometry ) is referred to as a standard geometry string with the values of width and height representing characters and offset values representing pixels. Note that there is no blank before `='. The default is "80x24+0+0".

-name name - specifies the name of the instance of the invocation. The default is "dde".

-wn name - specifies the name that may be used by the window manager when displaying application. The default is "dde".

-in name - specifies the string to name the icon of the application. The default is "dde".

Appendix G Using dde under Windows

This appendix describes the use of the dde in the Windows NT environment. Refer to an appropriate documentation for detailed explanation of the Windows NT terms used in this description.

When running in the Windows NT environment dde allows you to set the different properties ( e.g. font, background and foreground colors, initial size of the window etc. ) and to specify there default values.

The following is the list of the command line arguments that are supported, when running under Windows NT, together with those described in 2.16.1.

-bbc color - specifies the color that is used to display the border of a window when it is bold. The default is "Goldenrod".

-bc color - specifies the color that is used to display the border of a window. The default is "Brown".

-bg color - specifies the background color of the screen. The default is "Black".

-tc color - specifies the color that is used to display the text cursor. The default is "Red".

-fg color - specifies the color to display text. The default is "Green".

-geometry=geometry - specifies geometry of the screen ( geometry of the NT windows that is a screen ). The argument to the geometry option ( geometry ) is referred to as a standard geometry string with the values of width and height representing characters and offset values representing pixels. Note that there is no blank before `='. The default is "80x24+0+0".

-name name - specifies the name of the instance of the invocation. The default is "dde".

-wn name - specifies the name that may be used by the window manager when displaying application. The default is "dde".