Oakland CPM Archive/oakcpm.iso/cpm/cpminfo/cpm-cc06.azt/CPM-CC06.ART

Text File | 1986-12-27 | 13.6 KB | 264 lines

==============================================================================
[   THE KAY*FOG RBBS  |  CPM-CC06.ART  |  posted 01/18/86  |  261 lines 14k  ]

          The CP/M Connection                   Originally published in
                  by                               Computer Currents
             Ted Silveira                           2550 9th Street
  (copyright and all rights reserved)             Berkeley, CA  94710


                                 June 4, 1985
                              KEYS AND OUTLINES

     If you own a CP/M computer, it's easy to feel left out.  When you read
most major computer magazines, you get the impression that no one bothers
to write software for anything except IBM and Apple anymore.  Well, take
heart.  Two hot items currently are key-redefinition programs (SuperKey,
ProKey, etc.) and outline processors (ThinkTank, MaxThink, etc.), and CP/M
users can get them free from the public domain.


QK21

     QK21 (QwikKey version 2.1), by Anton Fleig, is a public domain key-
redefinition program.  It lets you redefine a key to be any string of
characters you want, either plain text (your name, address, and phone
number) or a program command (like ^K^S^Q^P in WordStar).  You can then run
another program, like WordStar, and everything will go normally, until you
hit the redefined key.  At that point, the key-redefinition program will
spit out the stored string of characters just as if you'd typed it at the
keyboard, only faster.

     Key-redefinition programs are meant to work with other programs, and
they work especially well with word processors.  WordStar, for example, has
no command to move forward or backward by pages (only by screens).  But by
using a key-redefinition program, I can create my own page-forward
command--I set one key to send out the sequence [^C^C^C^X^X^X^X^Z^Z^Z^Z^Z].
This sequence would be too clumsy if I had to type it in each time.  But
with the key-redefinition program, I just hit one key, and the program does
the work, fast.  I've become so addicted to this trick that I now have a
set of 20 "new" WordStar commands, including ones to move to the beginning
or end of a sentence or paragraph and to delete a sentence or paragraph.

     QK21 isn't quite as versatile as the commercial key-redefinition
programs, but it's very useful.  It can redefine any key on your keyboard,
including special function keys.  It can redefine up to 31 different keys,
and each definition can be approximately 30 characters long (31 minus the
number of characters originally sent by the key).

     QK21 lets you save and load sets of key definitions, so you can have
one set for your word processor, another for your spreadsheet, and so on.
It also lets you make new definitions "on-the-fly," in the middle of using
another program.  For example, about one paragraph into this article, I set
one of my keys to send the characters [QK21], without leaving WordStar.

     QK21 handles special function keys well.  My Televideo 925 terminal
has function keys that send out a three character sequence, starting with
^A and ending with ^M (so one key sends out ^AA^M, the next ^AB^M, and so
on).  QK21 handles this sequence perfectly, recognizing the ^A as the lead-
in character, redefining the following character, and ignoring the trailing
^M.  It can also distinguish between the sequence ^AB^M sent by a function
key, which it translates, and the same sequence typed in at the keyboard,
which it ignores.  Without this feature, I wouldn't be able to use my
function keys with WordStar, which uses ^A as one of its major commands.

     The QK21 documentation also tells you how to send characters that
aren't on your keyboard, if you're handy with DDT.COM or a disk editor like
DU.  You could use the same method to make QK21 distinguish between keypad
and keyboard characters, if your computer sets the high bit on keypad
characters (as Kaypros do, for example).

     All key-redefinition programs have a few drawbacks in common, because
of the way they work.  First, all steal part of your computer's upper
memory for themselves and the key definitions.  With QK21, you lose close
to 4K, so if you have a very large spreadsheet or BASIC program, for
example, that just fits in memory under normal circumstances, it may not
fit with QK21 running.  (You can easily remove QK21 when you need to and
reload it later.)

     Second, all key-redefinition programs change certain addresses in CP/M
in order to intercept characters from the keyboard before they go to CP/M
or another program.  This interception can cause conflicts with a few other
programs, mostly those that also want to intercept these characters.
Again, the solution is to remove QK21 temporarily.

     QK21 also has a few weaknesses of its own.  It accepts only a limited
number of definitions, though enough for most purposes.  It won't let one
definition call another definition.  And it gives you no way to control the
speed at which it sends out its stored strings.  With most programs, like
WordStar, that's no problem, but a few, like dBase II, will gag if they get
characters too quickly.

     Most important, QK21 has no "supershift" key.  You can redefine
function keys easily, if you have them.  But if you don't, you can only
redefine your regular keyboard keys, which means that you won't be able to
use those keys in their usual way.  Most people can find half a dozen
keyboard keys they don't use, but after that, it's a problem.  Commercial
programs get around this problem by defining a supershift key, usually the
backslash (\).  With the supershift, you can redefine the two-key sequence
[\A] however you want and still be able to use your normal [A] when you
need it.

     Though QK21 has some limitations, its good points more than make up
for them.  And if you've never used a key-redefinition program, you have a
treat in store.


TOUR20

     TOUR20's author, Ed Taychert, calls it a "document hierarchy editor,"
but most people will call it an "outline processor."  Briefly, TOUR20 is a
tool for handling ideas rather than for writing text.  You jot down ideas
in one-line headings, shuffle the headings around and arrange them
hierarchically, with indentations:

0. Contents
     1. What are the TOUR20 commands?
          1.1 For adding new headings
               1.1.1 APPEND
               1.1.2 INSERT
          1.2 For moving around
               1.2.1 UP and DOWN
               1.2.2 NEXT and BACK
               1.2.3 <INDEX>
               1.2.4 TOP
          1.3 For editing outlines
               1.3.1 CUT and PASTE
               1.3.2 CHANGE
               1.3.3 DELETE
          1.4 For viewing outlines
               1.4.1 VIEW and LIST
               1.4.2 SUBTREES
               1.4.3 ENTIRE
          1.5 For adding text
               1.5.1 INTRO
               1.5.2 SUMMARY
          1.6 For reading and writing files
               1.6.1 WRITE
               1.6.2 READ
               1.6.3 TYPE

     The basic unit in TOUR20 is the heading, a one-line (or slightly
longer) piece of text.  These can be entered one at a time or in an
automatic append mode that lets you dash off a string of headings and worry
about exactly where they belong later.  A heading can also be inserted into
an existing outline at any point, causing all following headings to be
renumbered.

     You move through the outline you've created by using UP and DOWN
(which move you up or down a level), NEXT and BACK (which move you forward
or backward one item, regardless of level), or <INDEX>.  <INDEX> is the
address of a particular heading, specified by its levels; in the outline
above, the index 0.1.3.1 would take you to the heading "CUT and PASTE."

      When it's time to edit, you can CHANGE any heading (rewrite it, in
other words).  You can also DELETE any heading, which also deletes any
subordinate headings so that deleting heading 1.5 above would also delete
1.5.1, 1.5.2, and 1.5.3.

     The most important editing tools are CUT and PASTE.  CUT removes a
heading and stores it in a buffer; PASTE takes the heading out of the
buffer and places wherever you want.  You can cut 20 headings before
pasting, but you must be careful about the order--the last heading cut is
the first heading pasted.

     While you're working, you see only a small part of your outline--the
current heading and its immediate subheadings.  If your current heading
were 1.4 above, you'd see only subheadings 1.4.1, 1.4.2, and 1.4.3.  This
"information hiding" is meant to help you concentrate on parts of your
problem or project.  You can use VIEW (or LIST) to see other parts of the
outline, SUBTREES to see everything below any particular heading (its
subheadings, their sub-subheadings, and so on), and ENTIRE to see the
complete outline.

     TOUR20 has only two commands for adding text to the outline.  INTRO
will place a block of text before a group of subheadings, and SUMMARIZE
will place one after; both are very limited.

     TOUR20 can also WRITE all or part of your outline into a disk file,
READ another TOUR20 file into your current outline, and TYPE a text file on
the screen without inserting it into the outline.

     What's TOUR20 like to use?  It has a strong personality; you could
even say it has a theory about life.  TOUR20 believes you'll do best if you
work with a top-down, divide-and-conquer approach, gradually breaking your
project or problem into smaller and smaller pieces.  It also believes you
should concentrate on one section at a time.  You don't have to play along,
but that's the way TOUR20 "wants" to work.

     In practice, you'll probably use TOUR20 one of two ways.  You can use
the top-down method by stating your subject in a general form ("What are
the TOUR20 commands?").  You divide that into smaller pieces (movement
commands, editing commands, etc.), and those pieces into still smaller
ones, refining and extending your outline, focusing on each small section,
until you have everything worked out in detail.  As you work, you use the
viewing commands to see how your current section fits into the general
scheme, and you use the editing commands to rearrange things as new ideas
crop up.  This approach suits TOUR20 very well and can turn huge projects
into a series of manageable steps.

     You can also use the brainstorming approach.  Here you put TOUR20 into
APPEND mode and bang in a series of ideas, without regard to their
relationship to each other or their level of generality.  In the process,
you create a list of ideas, questions, and odd bits of information.  Then
you sort through your list, using CUT, PASTE, and other editing commands to
discard the junk and to group related details under more general ideas.
Your structure and your controlling idea grow out of the details as you
fight to get them in order.  This approach also works but doesn't go as
smoothly as the top-down approach, largely because it's inherently messier,
partly because TOUR20 makes it easier to work with small sections than with
the whole outline.

     With either method, your final steps will be adding any necessary text
with INTRODUCE and SUMMARIZE, and then creating a paper printout (formatted
with indentations) or a disk file (no indentations, unfortunately) for
reference.  All the output is done through a separate program, ROFFTOUR--
not an easy program to make friends with and not up to the quality of TOUR
itself.

     TOUR20 has at least three weak spots in its generally solid user
interface:

     1) You can enter a very long heading--TOUR20 will simply wrap the line
when you hit the edge of the screen--but at about 130 characters, TOUR20
starts putting your text in the next heading, without any warning.  You
don't find out what's happened until you hit <RETURN>.

     2) If you accidentally hit ^C during a session, you drop straight out
of TOUR20 into CP/M, without any chance to save your work.

     3) If you hit ^Z accidentally, TOUR20 goes into an infinite loop (at
least on my machine).

     You're warned against these last two in the documentation, but that's
no protection against accidents.  All three of these problems need to be
fixed.

     Is TOUR20 worth having?  Absolutely yes--it's an interesting new
program and easy to use, once you're familiar with it.  TOUR20 lets you do
things you can't do with a word processor, and because it works entirely in
memory, it's fast.

     You have to get a feel for how the program works and understand its
limits.  At first, TOUR20 and I circled each other two stray cats.  But now
it's settled in to a regular space on my working disks.

     TOUR20 was originally released as "shareware" (free distribution, $30
suggested contribution), but Ed Taychert has now generously released it
completely into the public domain and plans to remove the shareware notice
for TOUR21.


     Next issue, some odds and ends--a batch of miscellaneous programs
useful for people who work with words.

------------------------------------------------------------------------------
      Ted Silveira is a freelance writer and contributing editor to several
   computer-oriented publications.  He appreciates suggestions or feedback
   and can be reached through the KAY*FOG RBBS [phone] and CompuServe
   (72135,1447) or by mail to 2756 Mattison Lane, Santa Cruz, CA 95065.

-------------------------  End of CPM-CC06.ART Text  -------------------------