^^MOVE TOP                                                                    
This command positions the cursor to the first line of the buffer,            
scrolling or repainting the screen as necessary. pEDIT keeps all text in      
memory, making it very fast to move to the top of the buffer from any         
point in the buffer.                                                          
^^MOVE BOTTOM                                                                 
This function moves the cursor to the dummy last line at the end of the       
buffer. The screen will scroll or repaint as required.                        
^^MOVE HOME                                                                   
The action of MoveHome depends on the position of the cursor within the       
current line. If the cursor is not at the beginning of the line, it will      
move there. If it is at the start of a line, it will move to the start of     
the previous line. This command is normally bound to the <Home> key.          
^^MOVE END                                                                    
The action of MoveEnd depends on the position of the cursor within the        
current line. If the cursor is not at the end of the line, it will move       
there. If it is at the end of a line, it will move to the end of the next     
line. This command is normally bound to the <End> key.                        
^^MOVE UP                                                                     
Moves the cursor up one line in the current buffer. There is no action if     
the cursor is already on the first line of the buffer. Note that pEDIT        
attempts to keep the cursor as close to the same column as possible. The      
command is normally bound to the <Up> key.                                    
^^MOVE DOWN                                                                   
MoveDown moves the cursor down one line in the current buffer. The cursor     
cannot move if it is already on the dummy last line of the buffer. pEDIT      
will keep the cursor as close as possible to the same column. This command    
is normally bound to the <Down> key.                                          
^^MOVE LEFT                                                                   
Moves the cursor left one character position. If the cursor is at the         
beginning of a line, it will wrap to the end of the previous line. This       
command is normally bound to the <Left> key.                                  
^^MOVE RIGHT                                                                  
Moves the cursor right one character position. If the cursor is at the end    
of a line, it will wrap to the beginning of the next line. This command is    
normally bound to the <Right> key.                                            
^^MOVE WORD                                                                   
MoveWord will move the cursor to the beginning of the next word in the        
current direction. If the direction is Forward, it will move toward the       
end of the buffer; if the direction is Reverse, toward the beginning of       
the buffer.                                                                   
                                                                              
The screen will scroll or repaint depending on the state of Select. If        
Select is active, the screen will be redisplayed. If Select is not active,    
scrolling will take place to keep the cursor on the fourth line from the      
top or bottom of the window.                                                  
^^INSERT CHAR                                                                 
This is the default when one of the typing keys is pressed. In Insert         
mode, the character will be inserted into the buffer at the current cursor    
position; text to the right is "shoved over" to make room. In Overstrike      
mode, the character is simply overwritten.                                    
                                                                              
pEDIT uses automatic word wrap to keep text between the defined margins as    
you type. If a word will not fit inside the current right margin, it will     
be moved to the start of the next line. The first line of a paragraph will    
be automatically indented if the PIndent parameter is set.                    
                                                                              
When the Tab key is pressed, the cursor will move to the next tab stop.       
pEDIT supports only tab stops at every eighth column. Control characters      
display as a caret (^) followed by the displayable character, i.e. Ctrl-A     
shows as ^A.                                                                  
^^OPEN LINE                                                                   
This function opens up a new (empty) line for text insertion. The end         
result is the same as pressing Enter followed by MoveLeft except that         
there will be no indenting.                                                   
^^FILL PARAGRAPH                                                              
Reformats a paragraph or portion of a paragraph to fit within the defined     
margins. Paragraph indenting, if any, is honored for the first line. Use      
this command after you have inserted or deleted text or changed margins.      
                                                                              
The SetMargins and SetPIndent commands are used to set the margins and        
paragraph indent, respectively. Reformatting begins at the current line       
and stops at the end of the paragraph. A paragraph is defined as contig-      
uous text bounded by empty lines both above and below.                        
^^INDENT                                                                      
This function is very useful in programming when you want to indent a         
section of code in or out without having to manually edit each line.          
Indenting is by levels where one level is 4 character positions or one-       
half a tab stop. Indent uses tabs and spaces to indent the line to the        
desired offset.                                                               
                                                                              
To use indent (1) position the cursor to the start of the first line, (2)     
toggle Select on, (3) highlight the entire range of lines to be indented      
and (4) issue the "INDENT" or "INDENT n" command. Specify the number of       
levels (n) as a positive or negative integer - positive for 'out' (toward     
the right), negative for 'in'.                                                
^^AUTO INDENT                                                                 
This function is very useful in programming. It is used to automatically      
indent a new line the same as the previous line. pEDIT uses the same          
leading whitespace (spaces and tabs) as the previous line. AutoIndent is      
normally used at the end of a line but the command can be issued anywhere.    
The command is normally bound to <Ctrl-Enter>.                                
^^CENTER LINE                                                                 
This command centers the current line - the line the cursor is on -           
between the existing margins. Only spaces are used to indent the line to      
the appropriate position.                                                     
^^CAPITAL WORD                                                                
Capitalizes the current word starting at the current position of the          
cursor within the word. The case change does not start at the beginning of    
the word; this is to allow, for example, 'Compuserve' to be changed to        
'CompuServe'.                                                                 
^^LOWER WORD                                                                  
This command converts the current word to lower-case starting at the          
current position within the word. All characters from the cursor to the       
end of the word will be changed to lower-case.                                
^^UPPER WORD                                                                  
UpperWord converts the current word to upper-case, again starting at the      
current character position and not at the beginning of the word.              
^^QUOTE CHAR                                                                  
This function is used to enter special characters into the text. pEDIT        
prompts you with "Press key to be added: "; at this point press one of the    
special keys. For example, to insert a form feed (Ctrl-L, Ascii 12) press     
Ctrl-V followed by Ctrl-L. The character will show as '^L' on the screen.     
                                                                              
The feature can also be used with Find and Replace. To find a line feed       
(Ctrl-J, Ascii 10) for example, press the DoCommand key and enter "FIND       
^V^J".                                                                        
                                                                              
Note that extended keys such as the PC keypad and function keys cannot be     
quoted. The PC graphics characters - those above Ascii 127 - are inserted     
in a special way. Hold down the Alt key and enter the decimal value of the    
character using the numeric keypad only; release the Alt key when done.       
^^TRANS CHAR                                                                  
This command transposes (swaps) two characters of text within a line. The     
cursor must be on the second character when you issue the command. The        
cursor cannot be positioned past the end of the line.                         
^^ERASE CHAR                                                                  
Deletes the current character - the character the cursor is on. The action    
is dependent on the current mode. In Insert mode, the character is deleted    
and text to the right of the cursor is shifted left to "fill in the hole".    
In Overstrike mode, the character is replaced by a space.                     
^^ERASE PREV                                                                  
Deletes the previous character - the character to the left of the cursor.     
In Insert mode, the character is deleted and text to the right of the         
cursor is again shifted toward the left. In Overstrike mode, the character    
is replaced by a space.                                                       
                                                                              
ErasePrev is permanently bound to the Backspace key which cannot be           
redefined. BackSpace therefore functions the same as it does at the DOS       
(Operating System) level.                                                     
^^ERASE WORD                                                                  
EraseWord deletes text from the current position in a word to the end of      
the word. The current direction (Forward/Reverse) does not affect the         
action; deletion is always toward the end of the word.                        
                                                                              
The current mode also has no effect on EraseWord. The entire word (or         
portion of a word) will be erased.                                            
^^ERASE LINE                                                                  
Erases an entire line or a portion of a line. If the cursor is at the         
beginning of a line, the entire line - including the end of line marker -     
is erased and stored in the text buffer. If the cursor is not at the          
beginning of a line, deletion is from the current position to the end of      
the line.                                                                     
^^RESTORE TEXT                                                                
This command restores the text last deleted by EraseWord or EraseLine.        
This text is stored in a special text buffer for later restoration. This      
text buffer is rebuilt after every action so only the last erasure can be     
restored.                                                                     
^^FIND                                                                        
Used to search for a text string. To initiate this function, press the        
Find key and respond to "String to find" or press DoCommand and enter         
"FIND <text>". The direction of the search will be in the current             
direction. An executing Find operation can be cancelled by pressing the       
Abort key.                                                                    
                                                                              
If the target string is all lowercase, the operation will be case-            
insensitive; that is 'pedit' will match 'pedit', 'pEDIT' and 'PEDIT'. If,     
however, the target contains any uppercase characters, the match will be      
exact, i.e. 'pEDIT' matches only 'pEDIT'.                                     
                                                                              
Special symbols are used to match beginning of line (bol) and end of line     
(eol). Use '\\<' for bol and '\\>' for eol. For example, '.\\>' matches a     
period only if it is at the end of a line.                                    
^^FINDNEXT                                                                    
This command will find the next occurrence of the last search string you      
specified. It is advisable to have Findnext bound to a key so only a          
single key press is required to repeat the last search operation.             
^^REPLACE                                                                     
pEDIT has a very powerful search and replace function. To initiate it,        
either press the Replace key and reply to the "Old string:" and "New          
string:" prompts, or press DoCommand and enter "REPLACE <old> <new>".         
                                                                              
pEDIT will search for each occurrence of 'old' and prompt you with            
"Replace (Y)es (N)o (A)ll (L)ast (Q)uit: "                                    
                                                                              
    Y, Enter - replace this occurrence                                        
    N        - skip this replacement                                          
    A        - replace all occurrences from this point                        
    L        - make this the last replacement and quit                        
    Q        - quit.                                                          
                                                                              
Matching the old string will follow the rules listed for the Find command.    
The same wild cards as Find are permitted in the 'old' string only.           
^^GET FILE                                                                    
This command loads in a new file for editing. pEDIT supports wildcard         
file specifications of the type '*.*' and '*.BAS'. If more than one file      
matches the specification, you will be presented with a list of all           
matching file names in alpha order. Use the arrow keys to highlight the       
desired file and press Enter. Press the Abort key to cancel.                  
                                                                              
Once a file has been selected, pEDIT will create a buffer for the file and    
load its contents into memory. The status line will show the new buffer       
name and the first screen of text, if any, will be displayed. If no           
matching file exists, pEDIT will display "Creating file" and present an       
empty screen.                                                                 
                                                                              
pEDIT allows a total of 6 user buffers.                                       
^^INCLUDE FILE                                                                
Reads in the specified file from disk and inserts it into the buffer          
starting at the current cursor location. The result is the same as if the     
user typed in the text contained in the file.                                 
                                                                              
Include File should be used only for relatively small files. The function     
uses the normal InsertChar routine, not the much faster GetFile which         
loads text directly into memory.                                              
^^WRITE FILE                                                                  
WriteFile is used to save the contents of the current buffer to disk          
without terminating the editing session. If no associated file name has       
been specified, pEDIT will ask for one.                                       
                                                                              
pEDIT verifies that there is sufficient disk space for the file BEFORE        
starting the save operation. The section on Error Handling has a full         
description of what to do if you get an error while saving a file.            
                                                                              
You can change the name of the associated file at any time by using the       
RenameFile command.                                                           
^^RENAME FILE                                                                 
This command changes the name of the disk file associated with the current    
buffer. The new name will be used at the time of the next WriteFile           
operation.                                                                    
                                                                              
Use RenameFile when you want to save a file under a name other than the       
one the it was called up under.                                               
^^SHOW BUFFER                                                                 
This command displays detailed information about the current buffer: the      
buffer name, associated file name, current mode and direction, number of      
lines and characters of text, etc. The status line also shows the pEDIT       
version number.                                                               
^^LIST BUFFERS                                                                
This function lists a summary of all defined buffers - the two system         
buffers (COMMAND and DOS) plus up to 6 user buffers. The following items      
are displayed: buffer name, number of lines in the buffer, buffer type        
(System or User), whether or not the buffer has been modified and the name    
of the file associated with the buffer.                                       
^^BUFFER                                                                      
Use this command to switch between buffers. You will be presented with a      
BUFFER window containing the names of all buffers except the COMMAND          
buffer. The cursor will be positioned on the first User buffer. Use the       
up and down arrow keys to highlight the desired buffer name; press Enter      
to select that buffer.                                                        
                                                                              
It is no longer possible to switch to the COMMAND buffer.                     
^^TRIM BUFFER                                                                 
This function 'trims' the current buffer by removing trailing blanks from     
all lines of text.                                                            
                                                                              
TrimBuffer is useful in any document where a left margin has been defined.    
pEDIT automatically indents every line to the specified left margin, which    
can result in "empty" lines between paragraphs. These empty lines can take    
up a lot of space in a large document.                                        
^^CHANGE MODE                                                                 
ChangeMode is used to toggle between Insert and Overstrike modes. If the      
mode is Insert when the command is given, it will change to Overstrike and    
vice versa.                                                                   
^^CHANGE DIR                                                                  
Use this command to toggle between the Forward and Reverse directions.        
Note that only Find, Findnext, Replace and MoveWord use the buffer            
direction.                                                                    
^^MARK                                                                        
This function is used to 'mark' a particular place in a buffer so you can     
return to it at some later time. There can be only one marker in each         
buffer. pEDIT tries to stay as close as possible to the original mark as      
text is inserted and deleted.                                                 
^^GOTO MARK                                                                   
This command moves to the position (line and offset) defined by the last      
Mark command.                                                                 
^^LINE                                                                        
The Line command is used to display the current line number or move to a      
particular line in the buffer. Enter "LINE" by itself to display the          
current line and number of lines; use "LINE nn" to move to line number nn.    
^^ONE WINDOW                                                                  
The OneWindow command 'unsplits' the screen. If there are 2 windows on        
screen, the current window - the one the cursor is in - becomes the only      
window. The screen will be repainted to show a full 21 lines of text. The     
line the cursor was on when the command was issued becomes the top line of    
the window.                                                                   
^^TWO WINDOWS                                                                 
TwoWindows 'splits' the screen if there is only one window visible. Both      
windows will initially show the same 10 lines of the current buffer. The      
cursor will move to the other window anticipating that you want to load in    
another file.                                                                 
^^OTHER WINDOW                                                                
If the screen is split, this command will move the cursor to the other        
window. The cursor will move to the row and column stored the last time       
the cursor was in the window.                                                 
^^PREV SCREEN                                                                 
Scrolls the screen up - towards the beginning of the buffer. The number of    
lines scrolled will equal the number of rows on screen - 21 or 10             
depending on the window size. The current direction has no effect on this     
command.                                                                      
                                                                              
If the screen cannot scroll the full amount, the cursor will move up until    
it hits the first line of the buffer. This command is normally bound to       
the <PgUp> key.                                                               
^^NEXT SCREEN                                                                 
Scrolls the screen down (toward the end of the buffer) by the number of       
rows in the current window. The current direction has no effect. The          
command is normally bound to the <PgDn> key.                                  
                                                                              
If the screen cannot scroll the full amount, the cursor will move until it    
hits the dummy line at the end of the buffer.                                 
^^SHIFT LEFT                                                                  
The Shift commands provide for horizontal scrolling - the ability to see      
text beyond column 80. ShiftLeft moves the window to the left (toward the     
left margin) the specified number of columns.                                 
^^SHIFT RIGHT                                                                 
ShiftRight shifts the screen to the right - toward the end of the line -      
by the number of columns you specify. How far the window can be shifted is    
limited only by pEDIT's maximum line length of 32767 characters.              
^^LEARN                                                                       
The Learn command is used to start recording keystrokes. The recording        
will continue until the Remember command is given. pEDIT will store all       
typing keys, function keys and special keys such as control keys.             
                                                                              
Any keystrokes can be stored in a pEDIT Version 2 key macro. The only         
restriction is that a macro containing a REPEAT command cannot, for           
obvious reasons, itself be repeated.                                          
^^REMEMBER                                                                    
Remember is used to end the keystroke recording started by Learn. pEDIT       
will ask for a key to bind to; press any of the definable keys on the         
keyboard. You cannot bind to the Tab, Enter or Backspace keys. Only one       
keyboard or dynamic macro can be defined at a time.                           
                                                                              
A macro must not be bound to a key that is contained within the macro. If     
this happens, the macro routine will go into a loop and probably crash the    
system.                                                                       
^^SAVE MACRO                                                                  
SaveMacro is used to save the currently defined keyboard macro to disk.       
Enter only a file name; pEDIT automatically adds the extension '.PMC'. The    
editor will write the macro file in the directory pointed to by the PEDIT     
environment variable, or if none is defined, in the current directory.        
                                                                              
If a file of the same name already exists, you will be given the chance to    
overwrite it or cancel.                                                       
^^EXECUTE                                                                     
Execute is used to execute a macro. When this command is issued, the          
keystrokes are 'replayed' as if you entered them. There are two forms of      
this command: one for a dynamic macro, one for a disk macro. See the          
section titled 'Macro Facility' for more information.                         
                                                                              
Use 'EXECUTE' by itself for the single dynamic macro. To execute a disk       
macro, use a command of the form 'EXECUTE filename' where 'filename' is a     
valid DOS file name without an extension. pEDIT automatically adds the        
file type .PMC to all disk macro file names.                                  
^^SELECT TEXT                                                                 
SelectText is a toggle that turns the select state on/off. If the state is    
off, it will be turned on and vice versa. When active, selected text is       
highlighted in reverse video as the cursor is moved. Select is                
automatically turned off after any RemoveText or StoreText command. To        
cancel the selection, simply issue the command again.                         
^^REMOVE TEXT                                                                 
This command removes the selected text and stores it in the paste buffer.     
The paste buffer is rebuilt every time RemoveText is invoked so only the      
most recently deleted text is available.                                      
^^STORE TEXT                                                                  
StoreText is similar to RemoveText except that the text is not removed        
from the buffer. The paste buffer is rebuilt to contain the selected text.    
Use this command whenever you want to make a copy of some text without        
deleting it.                                                                  
^^INSERT HERE                                                                 
Inserts text from the paste buffer into the current buffer starting at the    
current cursor position. Note that InsertHere can be invoked more than        
once to make multiple copies of the stored text.                              
^^DO COMMAND                                                                  
When the "Do" key is pressed the editor will respond with the 'Command: '     
prompt. At this point you can enter any valid pEDIT command. Commands can     
be upper- or lower-case or mixed. Note that commands must be entered in       
full with spaces in between words.                                            
                                                                              
The Command line is really a one-line window into the COMMAND buffer. All     
defined keys can be used on the command line for editing the current line     
or recalling previous commands. Use MoveUp and MoveDown to scroll up and      
down through the stored commands.                                             
^^RECALL                                                                      
Recall is used to recall the last command given via DoCommand. The end        
result is the same as pressing the DoCommand key followed by the up arrow     
with one important difference; the previous command is copied to the          
current command line. The command can of course be edited before pressing     
Enter to begin execution.                                                     
^^ABORT                                                                       
pEDIT now has a user-definable abort key. It is no longer 'hardwired' to      
Ctrl-C; this conflicted with WordStar which uses Ctrl-C as a command key.     
                                                                              
The abort key should be defined in your initialization file.                  
^^REFRESH SCREEN                                                              
This command is used to clear and repaint the screen. Use RefreshScreen       
if, for any reason, the screen should be overwritten or otherwise             
obliterated. Everything - including reverse video - will be redrawn.          
^^DEFINE SHIFT                                                                
This function defines a shift or "lead-in" key for multi-key commands. It     
signals pEDIT when to expect a second keystroke; therefore a shift key        
cannot be a command key by itself.                                            
                                                                              
Normally this command would be specified in pEDIT's init file before other    
key definitions. A maximum of 5 shift keys can be defined.                    
^^DEFINE KEY                                                                  
Used to dynamically define a key during an editing session. pEDIT will ask    
for a procedure name and a key press. The procedure name is any valid         
pEDIT command entered in full (no abbreviations) with or without              
parameters. An example is "SET SCOPE GLOBAL".                                 
                                                                              
It is best to put key bindings in the initialization file so they are         
automatically defined when the editor is invoked.                             
^^SHOW KEY                                                                    
Used to show what procedure is bound to a key. pEDIT will prompt for a key    
press and display the name of the procedure, if any, bound to that key.       
^^LIST KEYS                                                                   
Lists all defined keys and the procedures bound to them. pEDIT will pause     
in between screens; press Enter to continue to the next screen.               
^^SPAWN                                                                       
This function spawns or shells you to DOS. A second copy of COMMAND.COM is    
loaded into memory to process commands. You may then enter DOS commands       
and do anything you can do at the operating system level. Type 'EXIT' to      
return to the editor exactly as you left it.                                  
                                                                              
If you have a floppy-only system, COMMAND.COM must be available or the        
spawn will fail. Some versions of DOS prior to 3.x have a problem with        
"SHELL" and may not work properly.                                            
                                                                              
pEDIT tries to keep 50-70k of memory free for the Spawn and Dos commands;     
this will not leave sufficient memory for anything but DOS resident           
commands (DIR, TYPE, etc.) and small programs. If more memory is needed,      
use the eXtended Spawn function (XSpawn).                                     
^^XSPAWN                                                                      
This function serves the same purpose as Spawn but with one important         
extension. All text memory is swapped out to disk, leaving much more          
memory available to DOS. On a machine with 640k, about 350k will be freed     
up - more than enough to compile and run other programs - even another        
copy of pEDIT.                                                                
                                                                              
The restrictions noted for Spawn apply here. Also, you must be careful not    
to delete pEDIT's temporary swap files. See the section titled 'Extended      
DOS Shell' for more information.                                              
^^REPEAT                                                                      
Repeat lets you repeat any key press up to 32767 times. Only the next         
single key press - typing, function, Ctrl, Alt - is repeated.                 
                                                                              
The repeat count is shown by 'Repeat: ' on the message line. Use BackSpace    
to correct the count; set the count to zero if you wish to cancel.            
                                                                              
You can end a repeat loop by pressing the Abort key.                          
^^SET AUTOSAVE                                                                
pEDIT has an 'autosave' function that automatically saves your work to        
disk. If autosave is on, pEDIT will periodically do a WriteFile if changes    
have been made. The 'Working . . .' message will appear and the disk          
access light will come on. You will be told how many lines were written.      
The usage is 'SET AUTOSAVE ON|OFF'.                                           
^^SET COLOR                                                                   
SetColor lets you choose foreground and background colors on a color          
(CGA/EGA/VGA) monitor. For monochrome, the only legal combinations are        
"SET COLOR blk wht" and "SET COLOR wht blk". Here 'blk' and 'wht' refer to    
the mono colors whatever they may be - black and white, black and green,      
etc.                                                                          
                                                                              
The usage is 'SET COLOR fground bground'. See the Appendix for a list of      
valid color code names.                                                       
^^SET LINES                                                                   
SetLines lets you switch between 25 and 43 line mode on an EGA or VGA         
monitor. These displays can show more than the normal 25 lines of text.       
Note that screen writing and scrolling are generally much slower in 43-       
line mode. The SetLines command cannot be given when the screen is split.     
VGA 50 line mode is not supported. The usage is 'SET LINES 25|43'.            
^^SET MARGINS                                                                 
This command lets you set left and right text margins. The default margins    
are 1 and 80. The left margin must be greater than zero and the right         
margin has to be greater than the left. The usage is "SET MARGINS left        
right".                                                                       
^^SET PINDENT                                                                 
Used to set the paragraph indent, i.e. the number of columns by which to      
indent the first line of a paragraph. The usage is "SET PINDNT nn" where      
nn is zero or a positve integer.                                              
^^SET SCOPE                                                                   
Specifies the "scope" for all Find and Replace operations. If the scope is    
local, only the current buffer will be searched. If the scope is global,      
all user buffers will be searched and 'Global' will show on the status        
line. The format of this command is "SET SCOPE local|global".                 
                                                                              
Things can get out of hand if some buffers are searched in a forward          
direction while others are searched in reverse. For this reason, the          
direction for all buffers is temporarily set to Forward during a global       
search.                                                                       
^^DOS                                                                         
The Dos function spawns or "shells" a command to DOS for execution. The       
output from the command will be placed in the DOS buffer as text. If only     
one window is on-screen, pEDIT will split the screen and map the DOS          
buffer to the other window.                                                   
                                                                              
A second copy of COMMAND.COM must be loaded into memory to handle the         
request. See Spawn for a discussion of limitations and cautions.              
^^XDOS                                                                        
The eXtended DOS function (XDos) uses an intelligent DOS shell to free up     
additional memory for the execution of DOS commands. See the description      
of XSpawn and the section titled 'Extended DOS Shell'.                        
                                                                              
A common use of XDos would be to compile a program from within the editor.    
For example, 'XDOS BC TEST /O ;' would be used to compile a QuickBASIC        
program. The compiler output will of course be directed into the DOS          
buffer.                                                                       
^^HELP                                                                        
The Help command provides full on-line help for every pEDIT command. The      
editor looks for a help file named PEDIT.HLP in the directory defined by      
the PEDIT environment variable, or if none is defined, in the current         
directory.                                                                    
                                                                              
You will be presented with a HELP window containing an alphabetical list      
of all pEDIT commands. Use the arrow keys to highlight the command you        
want help with and press Enter. The function can be cancelled by pressing     
Abort.                                                                        
^^KEYBOARD                                                                    
This function displays the contents of the file PEDIT.KEY on the screen in    
a KEYBOARD window. The editor looks for this file in the directory            
specified by the PEDIT environment variable, or in the current directory.     
Normally this command is used to display a diagram of your keyboard and/or    
a list of the keys you have defined.                                          
^^RULER                                                                       
Toggles an 80-column on-screen ruler on and off. The ruler temporarily        
overwrites the status line.                                                   
^^QUIT                                                                        
Use the Quit command to abort an editing session. Abort MEANS abort - any     
changes you have made will be lost. If any User buffers have been             
modified, pEDIT gives you the option of not quitting by displaying            
"Buffer(s) modified - quit (Y/N)? ". Enter Y to abort, N to cancel the        
abort and resume editing.                                                     
^^EXIT                                                                        
The Exit command terminates the editing session and returns you to DOS.       
The current buffer is automatically written to disk if it has been            
modified. If any other user buffers have been altered, pEDIT asks you one     
at a time if you want to write them. Answer Y to save the buffer, N to        
skip it.                                                                      
