.cw9
.he *WS5FILE: WordStar Release 5 Command Summary --CHR$(13)03DEC88*      -#-

*[TOGGLE FUNCTION:  
     If it's on, turn it off. If it's off, turn it on.]*



The following are Control-Key sequences. The first or only 
keystroke must be a control character; the second can be any 
version (uppercase, lowercase, control), except for embedded 
control-codes which must also be control keystrokes. 
Code keys such as ENTER are shown as such as <cr>, set off with 
spaces for clarity.

<esc>     Use shorthand definition
<esc> !   Enter current time
<esc> #   Enter last ^QM equation
<esc> $   Enter last ^QM result as dollar amount
<esc> @   Enter currnt date
<esc> ?   Show/change macro definitions
<esc> =   Enter last ^KM or ^QM result

^6:  (document mode:) soften a hard carriage-return
     (non-doc mode:)  auto-indent    

A:   Cursor to beginning of previous word                    
B:   Align (paragraph reform), from cursor to end of paragraph.
       ** Non-document: STRIP HIGH BITS FROM LINE **
C:   Cursor down one screenful
D:   Cursor right one character
E:   Cursor up one line
F:   Cursor to beginning of next word
G:   Delete character at cursor
H:   Backspace [same as normal WordStar ^S]
I:   Tab key

J.:  Help with dot commands
JB:  Help with paragraph reform
JD:  Help with dot commands
JF:  Help with flags
JJ:  Set help level
JP:  Help with markers
JR:  Help with ruler line
JS:  Help with status line
JV:  Help with text moves

K <number>:    Place numbered temporary marker at cursor
K?:  Word/character count
K':  Convert block to lowercase
K.:  Convert block to sentence case
K":  Convert block to upper case
KA:  Copy block from other window                      <WINDOW>
KB:  Mark block beginning at cursor site
KC:  Copy marked block to cursor site
KD:  Done. Save file, return to main menu.
     ** If window is open, close and save file there   <WINDOW>
KE:  Rename a DOS file
KF:  Run a DOS command 
KG:  Move block from other window                      <WINDOW>
KH:  Hide block markers toggle
KJ:  Delete a DOS file
KK:  Mark block end at cursor site
KL:  Change logged disk/path
KM:  Block math                                     <CALCULATOR>
KN:  Move column/block toggle
KO:  Copy a DOS file
KP:  Print a DOS file
KQ:  Quit file: abandon and return to menu.
     ** If window is open, abandon that                <WINDOW>
KR:  Read file into cursor site
KS:  Save file but don't leave it.    [Cursor no longer wanders] 
KV:  Move marked block to cursor site
KW:  Write block (to new file)
KX:  Save file and exit back to MSDOS [exiting WordStar].
KY:  Delete block
KZ:  Sort block

M:   Insert a hard carriage return. [Cursor follows <cr>.] 
     This is the code sent by the <enter> key.
N:   Insert a carriage return to right of cursor. 
     [Cursor "kicks" text down a line.]

OA:  Auto-align (automatic paragraph reform) toggle
OB:  Show soft-spaces (as dots) toggle
OC:  Center the line
OD:  Print control display toggle  
     [hides embedded control characters when off].
OE:  Insert soft hyphen
OF:  Set tabs and margins from "ruler" line in file. 
OG:  Paragraph tab.  Temporarily indents left margin, until  next 
     <cr> or ^B is typed, one tab-setting per ^OG.
OH:  Auto-hyphenation toggle
OI:  Set variable tab
OJ:  Right-justification toggle
OK:  Cursor to other window.                           <WINDOW>
     If window isn't open, open it.
OL:  Set left margin
OM:  Size window                                       <WINDOW>

ON:  NOTES ACCESS PREFIX                            <FOOTNOTES>
ONA: Create annotation                            <annotation>
ONC: Create comment                               <comment>
OND: Edit entry
ONE: Create endnote                               <endnote>
ONF: Create footnote                              <footnote>
ONG: Cursor to next note
ONI: Create index entry                           <index>
ONL: Spell-check notes
ONU: Align notes

OO:  Embed current ruler line as a .rr line
OP:  Run Page Preview                            <PAGE PREVIEW>
OR:  Set right margin 
OS:  Set onscreen line spacing 
OT:  Ruler line display toggle
OV:  Center text vertically
OW:  Word-wrap toggle
OX:  Margin release
OZ:  Number paragraph
     <cr>:               accept consecutive number
     <rightarrow>:       dive to deeper level
     <leftarrow>:        rise to higher level

P?:  Invoke printer menu, select a print-driver for file 
          ** WS5 TIES THE EDITED FILE TO A DEFAULT PRINTER **
P0:  Invoke extended characters menu
P=:  Invoke font list (choose font)
P-:  Invoke color menu
P*:  Custom print GRAPHICS TAG
P!:  Custom print DEFINE CODE
P.:  Move to tab, insert periods
P@:  Paragraph-reform align at column number

Multiple-control-code sequences =====================>>
PA:  Select alternate font or character pitch
       (type ^P ^A to insert ^A (01 hex) into file; 
        it's interpreted as a print-time command when WS 
        print the file. This applies to all multiples here.)
PB:  boldface toggle
PC:  Print-time embedded pause command
PD:  Double-strike toggle
PE:  Custom print function
PF:  Phantom space (daisy-wheel) or custom print function
PG:  Phantom rubout (daisy-wheel) or custom print function
PH:  Strikeover one char (print next char same place)
PJ:  Embed <linefeed> code
PK:  Left/right heading/footing control
      ** Mark beginning/end of index entry **          <INDEX>
PL:  Embed <formfeed> code
PM, P <cr>:  carriage-return without linefeed
      [overprints next line on previous one]
PN:  Select standard font or character pitch
PO:  Non-break space
PR:  Custom print function
PS:  Underline toggle
PT:  Superscript toggle
PV:  Subscript toggle
PW:  Custom print function
PX:  Strikeout toggle
PY:  Italic or ribbon-color toggle
<<=========================== Multiple-control-code sequences 

Q=:  Cursor to next font tag
Q?:  Display character-count to cursor
Q <number>:    Cursor to marker placed with ^K0 ... ^K9
QA:  Find and replace              [^L = "again"]
QB:  Cursor to beginning of marked block
QC:  Cursor to end of file
QD:  Cursor to rightmost character position
QE:  Cursor to top of screen
QF:  Find string. 
     *Options:*
          n = do it n times
          B = backward search
          G = global
          N = Automatic replace
          U = Ignore upper/lower case
          W = whole words only
     *Match characters:*
          ^A:  single character match
          ^N:  match <cr/lf>
         ^Ox:  match with anything except x
          ^S:  non-alphanumeric match

QG <char>:  Cursor forward to specified character
QG <cr>:  Cursor forward to end of paragraph
QH <char>:  Cursor back to specified character
QI <number>:   Cursor to specified page (doc) or line (non-doc)
QI- <cr>: Cursor to last page
QI+ <cr>: Cursor to next page
QJ:  Look up synonym (invoke thesaurus)               <THESAURUS>
QK:  Cursor to end of marked block
QL:  check document spelling from cursor on             <SPELLER>
QM:  Invokes popup calculator                        <CALCULATOR>
QN:  check word spelling at cursor                      <SPELLER>
QNL: check notes spelling from cursor on                <SPELLER>

QO:  check spelling of console-entered word             <SPELLER>
QP:  Cursor to position before last command
QQ:  Repeat next command at a number-controlled rate. fast:1
QR:  Cursor to top of file
QS:  Cursor to leftmost side
QT <char>:     Delete from cursor to specified character
QU:  Paragraph-reform from cursor to end of document
     ** Non-document mode: STRIP HIGH BITS FROM FILE **
QV:  Cursor to start of last find or replace
QW:  Continuous scroll down
QX:  Cursor to bottom of screen
QZ:  Continuous scroll up

R:   Cursor up one screenful.
     ** In command interaction, ^Remember previous response
S:   Cursor left one character.
T:   Delete word at following.
U:   Undo... restore deleted text.
     Interrupt. *USE THIS TO ABORT A COMMAND.*
V:   Insert-mode toggle
W:   Downscreen one line (top line appears)
X:   Cursor down one line
Y:   Delete the cursor's line
Z:   Upscreen one line (bottom line appears)
*DOT COMMANDS*
WS5 pays close attention to dot commands during editing. The  dot 
must be in the leftmost column. Command case doesn't mattter.
REM out a line with two dots in leftmost columns.
Dot commands are print-format and print-time-process commands for 
document printing and merge-printing.

aw on/off                alignment/wordwrap control
 (.aw on   turns it on from here to... 
  .aw off  ...or to end of file, whichever comes first.)
bn <number>              select sheet feed bin 
bp on/off                bidirectional printing on/off
cb                       column break              <COLUMNS>
cc <number>              conditional column break
co <number>              set number of columns
co <number> , <number>   set columns, gutter size
cp <number>              conditional page break
     (.cp5 = start new page if can't fit 5 lines on current one)
cs                       clear screen while printing
cvc>e                    print comment as endnote
cvc>f                    print comment as footnote
cve>f                    print endnote as footnote
cvf>e                    print footnote as endnote
cw <number>              character width in 1/120"
dm                       (print-time) display message
e# <number>              endnote starting number or style
f# <number>              footnote starting number or style
fi                       (print-time) insert file
fo
f1                       first footer line
f2                       second footer line
f3                       third footer line                         
fm <number>              set footer margin   (default 2)
f <header> e             footer (margin) on even pages only
f <number> o             footer (margin) on odd pages only
he
h1                       first header line
h2                       second header line
h3                       third header line
hm <number>              set header margin
h <number> e             header (margin) on even pages only
h <number> o             footer (margin) on odd pages only
ig                       ignore (comment. Dot-dot is easier.)
l# 0                     turn off line numbering
l# d                     line numbering continuous thru document
l# d <number>                 ...and set line number spacing
l# d <number>,<number>        ...and set number places pre-col 1
l# p                     line numbering fresh for each page
l# p <number>                 ...and set line number spacing
l# p <number>,<number>        ...and set number places pre-col 1
lh <number>              set line height
lm <number>              set left margin
lq on/off/dis            letter-quality control
ls <number>              set line spacing

ma                       set print-time variable to result of
                           math equation
mb <number>              set bottom margin
mt <number>              set top margin
oc on/off                auto-center group of lines
oj on/off                justification toggle
op                       omit page numbering
p# <number>              start paragraph numbering
p# <number>,x.x.x...
p# ,x.x.x....            set paragraph numbering format/style
     Z    uppercase letters
     z    lowercase letters
     I    uppercase Roman numerals
     i    lowercase Roman numberals
     9    numbers starting with 0
     1    numbers starting with 1

pa                       force page break
pc0                      center page number
pc <number>              set page number column
pe                       location to print endnotes
pf on/off/dis            print-time formatting toggle
     (.pf dis = discretionary)
pg                       restore default page numbers
pl                       page length in lines 
     (default 66 (perf-to-perf))

pm <number>              paragraph margin
pn <number>              set page numbering
po <number>              set page offset
po e <number>            set even page offset
po o <number>            set odd page offset
pr or=l/p                print orientation: landscape/portrait
ps on/off                proportional spacing toggle
rm <number>              set right margin                      
rp <number>              set times to print file
rr                       insert embedded ruler line
rr <number>              insert preformatted ruler line
     .rr0 -  .rr9
sr                       superscript/subscript roll
tb # <number>            decimal tab stop
tc                       create table of contents entry
tc <number>     (0 - 9)  define entry for table
uj on/off/dis
xe                       redefine ^PE code
xl                       redefine ^PL code
xq                       redefine ^PQ code
xr                       redefine ^PR code
xw                       redefine ^PW code
xx                       redefine strikeout char





Merge-Print process-control dot-commands:

av                       ask data for variable
df                       define data file or spreadsheet file
                          for .rv
rv                       read all variables from data file
rv*                      read selected variables from data file
rv*$x,$y...              use specific columns from spreadsheet
sv                       set variable

if el ei                 conditional print flow structure
     (print-time if, else, endif)
     for numeric comparisons, precede operators with #
     =    equal to       >    greater than        <    less
     <>   not equal to   >=   greater/equal       <=   less/equal

variables:
     &var&          substitute data
     &var/o&        remove line if variable is empty 
     &var/N&        substitute variable using formula N
                     (use .sv to define formula)
     &#&            substitute current page number
     &_&            substitute current line number
     &@&            substitute current date
     &!&            substitute current time


+--------------------------------------------+
|     Ruler Line display characters:         |
|                                            |
|     L    left margin                       |
|     R    right margin                      |
|     P    paragraph margin                  |
|     V    temporary indent                  |
|     !    tab stop                          |
|     #    decimal tab stop                  |
|     -    space                             |
+--------------------------------------------+



..eof WSFILE/usr13 --CHR$(13) 18OCT83