Programmer 7500/MAX_PROGRAMMERS.iso/PROGRAMS/UTILS/NOVELL/CB.ZIP/CB.HLP

Text File | 1990-07-05 | 53.1 KB | 1,277 lines

GENERAL
$i╔═════════════════════════════════════════════════════════╗$n
$i║ About Joan Riff's CB Simulator                          ║$n
$i╚═════════════════════════════════════════════════════════╝$n

Citizen's Band (CB) radio exists to allow the average citizen to use
the radio waves without having to become a communications expert. A
CB radio is simple to use, and allows many people to carry on a
simultaneous conversation over the airwaves.

$iJoan Riff's CB Simulator for PC Networks$n (hereinafter referred to
simply as CB) is a software product for use on PCs that are connected
to a local area network. Simply stated, CB is the digital equivalent
of a CB radio. CB allows users of a network to carry on a multi-party
simultaneous conversation, or $hconference$n.

Operation is simple: the user simply types lines of text. Every line
that the user types appears on the screen of every CB user, and lines
typed by all other CB participants appear on the user's screen.





$i╔═════════════════════════════════════════════════════════╗$n
$i║ CB Capabilities at a Glance                             ║$n
$i╚═════════════════════════════════════════════════════════╝$n

This CB simulator provides the following features:

    » Any of 19 simulated CB $hchannels$n may be used.
    » Multiple $husers$n can be transmitting on a channel at one time.
    » Multiple $hwindows$n can be on the screen at once, each one
      associated with one channel.
    » Each user has his own $hhandle$n by which he is identified, and
      which gets attached to his messages.
    » Incoming messages can be $hlogged$n to a Logfile.
    » ASCII files may be $htransmitted$n across a channel as if typed
      by a user.
    » Messages may be $hscrambled$n with a password in order to obtain
      a measure of privacy.
    » Messages may have $hattributes$n attached which cause them to
      beep and/or be displayed in an alternative color when received.
    » Messages which have scrolled off of the top of the window may be
      $hreviewed$n by scrolling backwards and forwards through them.
    » $hContext-sensitive help$n is always just a single keypress away.
    » Operation is configurable via $hconfiguration files$n,
      $henvironment variables$n, and $hcommand-line flags$n.
    » Individual users may be filtered out ($hdisabled$n), so that
      irrelevant messages don't clutter your screen.
    » This software runs on $hany network$n which provides multi-user
      access to a DOS directory - it is not dependent upon any specific
      network.
    » Up to 50 distinct handles (hence users) may be "on the air"
      at one time. The practical upper limit depends upon the efficiency
      of your network.
    » All of the PC's free real memory is used to hold incoming messages.
    » Common operations are handled immediately from the $hmain screen$n,
      making CB very easy to use.
    » Advanced operations are handled from within a $hpulldown menu$n
      $hinterface$n which allows you to navigate through all applicable
      choices before committing yourself.
    » A revolutionary new approach to software registration $hprotects$n
      this software against unauthorized use, while giving registered
      sites $hunrestricted access$n to the software.





$i╔═════════════════════════════════════════════════════════╗$n
$i║ CB Terminology                                          ║$n
$i╚═════════════════════════════════════════════════════════╝$n

$hchannel$n               A $hchannel$n is a medium of transmission. The
                      use of channels serves to compartmentalize communi-
                      cations, in that what is transmitted over one
                      channel can only be received by users who are
                      monitoring that channel. Each window on the screen
                      has a title line which describes the channel with
                      which that window is associated. There are 19
                      simulated channels available to the user of CB.

$hchannel name$n          A $hchannel name$n is the name associated with a
                      channel. Channels are named via parameters in the
                      CB configuration files (see "$iConfiguration Files$n"
                      below). A channel name is displayed in the $hwindow$n
                      $htitle line$n at the top of each screen window,
                      showing the channel with which that window is associ-
                      ated. Channel names are also used as an informal,
                      site-specific guide to their use.

$hconference$n            A $hconference$n is the sum total of all messages
                      that are transmitted by all users on a particular
                      channel. It is called a conference because in terms
                      of what is said and heard it is exactly as if all
                      participants were in the same room and would hear
                      whatever is said by any single participant, whereas
                      users of other channels would not be heard.

$hcurrent window$n        The $hcurrent window$n is the window into which you
                      are typing. It is highlighted on the screen in order
                      to differentiate it from any other windows which may
                      be on the screen. When you press the $h{Return}$n
                      key to transmit a message, that message gets sent
                      over whatever channel is associated with the current
                      window.

$hhandle$n                A $hhandle$n is the name by which the user wants to
                      be known to his CB audience. It can be anything at
                      all: a real name, a nickname, initials, or whatever.
                      It may be up to 16 characters long. Every received
                      message is identified on the left by the handle of
                      the transmitter of that message.

$hmessage$n               A $hmessage$n is a single line which is transmitted
                      over a channel. The transmit line at the bottom of
                      the current window holds the message which is cur-
                      rently being constructed for transmission. When you
                      press the $h{Return}$n key to transmit the message,
                      then the message is transmitted and the transmit
                      line is cleared to start a new message. Received
                      messages are identified on the left with the handle
                      of the person who transmitted the message, so that
                      you can keep track of who says what when many users
                      are on the same channel.

$hregistration$n          Each user of this software product must be
                      $hregistered$n with CCS in order to comply with the
                      copyright, and to ensure that this software is
                      used only by users who have legally purchased the
                      right to use it. The process of $hregistration$n is
                      fully described in "$iRegistration of this Software$n"
                      below.

$htransmit line$n         The $htransmit line$n is the one-line subwindow at
                      the bottom of a screen window. This space holds the
                      single line which is being prepared for transmission
                      over that window's channel. All keypresses which are
                      not CB commands are stored in this line for eventual
                      transmission over the channel when you press the
                      $h{Return}$n key.

$hwindow$n                A $hwindow$n is a boxed portion of the screen
                      which displays data for one channel. The upper
                      portion of the window displays messages which have
                      been $hreceived$n on that channel, and may be scrolled
                      backwards to view messages which have disappeared off
                      of the top of the window. The lower portion of the
                      window is a single line, and holds the current line
                      which is being prepared for $htransmission$n on
                      that channel. This is the $htransmit line$n. You
                      may have multiple windows on the screen at one time,
                      each monitoring a different channel.

$hwindow title line$n     The $hwindow title line$n is the top line of the
                      box which surrounds a $hwindow$n. This line is used
                      to identify the channel with which this window is
                      associated.



INSTALL
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Installing Joan Riff's CB Simulator on a Network        ║$n
$i╚═════════════════════════════════════════════════════════╝$n

Before it can be used, CB must be installed on a network by the
network administrator. Because CB is a network "groupware"
application, its installation is somewhat more involved than is
necessary for a stand-alone program. Nevertheless, its installation
can be reduced to the following simple steps:

1) Obtain one registration serial number from Computerwise Consulting
   Services for every network user that you want to have access to CB.
   See "$iRegistration of this Software$n" (below) for detailed
   information about the registration process.

2) Create a directory somewhere on a network drive to which all
   potential users will have access. Use your network's administrator
   utility to give all users $hfull$n access to this directory. All
   users must be able to search this directory for files, create files
   under this directory, and read/write all files under it.

3) Copy the following CB files to some directory on the network which
   is in every user's search path:

        $iCB.EXE$n        The executable program itself.
        $iCB_SITE.CFG$n   The site-wide configuration file.
        $iCB_USER.CFG$n   A sample user-specific configuration file.
        $iCB.HLP$n        The Online Help Facility text file.

4) Edit the $iCB_SITE.CFG$n file (which you just created in step 3)
   to reflect your own site-wide preferences. It is especially important
   that you change the "$hDirectory=$n" parameter so that it names the
   network directory that you created in step 2. Be $hsure$n to include
   the trailing '$h\\$n' character in this directory name!

5) Using the registration serial numbers obtained from CCS, you must
   install each CB user using $hone$n of the following techniques (it's
   your choice):

    a) You can create a unique batch file for every user ($iCB_BOB.BAT$n,
       for example), and store it in a network directory which is in
       every user's search path. Each such batch file should invoke
       CB with command-line flags which specify this user's serial
       number and handle. See "$iCommand-line Flags$n" below.

    b) You can copy the sample $iCB_USER.CFG$n file (created in step
       2 above) to a directory which appears in this user's DOS search
       path $hprior$n to any other directories, and then edit that file
       to contain this user's individual serial number and handle. This
       will cause CB to automatically find this file and obey the
       parameters contained in it. See "$iConfiguration Files$n" below.

    c) You can edit each user's AUTOEXEC.BAT file on his boot disk to
       set his serial number and handle via DOS $henvironment
       variables$n. See "$iDOS Environment Variables$n" below.

The program is now ready to be used. Installation is complete.












REGISTER
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Registration of this software                           ║$n
$i╚═════════════════════════════════════════════════════════╝$n

This program will only run properly when it detects the presence of a
valid registration serial number. This prevents the use of this
program by folks who haven't paid for it. Shareware, after all, means
"Try it $hbefore$n you buy it", not "Try it, like it, and keep using
it $hwithout$n paying for it".

Registration serial numbers may be obtained from CCS for the price of
$$20 per user per year. Orders may be placed with CCS at the
following address:

        CB Registration
        Computerwise Consulting Services
        P.O. Box 813, McLean, VA 22101
        [phone]

Be sure to indicate the number of registrations desired (@ 1 per
user), and to include payment for each such registration.

Once a registration serial number has been obtained from CCS, it may
be specified to this program in one of three ways:

  » Via a "$hRegistration=xxxxxxx$n" command in each user's personal
    $iCB_USER.CFG$n configuration file. See "$iConfiguration Files$n"
    below.

  » Via a "$hCBSERIAL=xxxxxxx$n" DOS environment variable. See "$iDOS $n
    $iEnvironment Variables$n" below.

  » Via a "$h-#xxxxxxx$n" command-line flag provided on the command line
    when the program is run. See "$iCommand-line Flags$n" below.

Remember - $heach$n user of this program needs to pass to CB his own
personal registration serial number in order to be able to talk to
other CB users.

You may install as many copies of this software as you like. You may
make backup copies of this software, because it is not copy-protected.
In short, you are not constrained in any way from performing prudent
software installation, distribution, or backup with this product, as
any responsible network administrator will no doubt do with all
network software that he owns. The only restriction is that $heach$n
$huser$n must have $hhis own$n individual serial number as described
above.






















FLAGS
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Starting CB: Command-Line Flags                         ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The following flags may be given on the command line which invokes CB:

       $h-hxxxx$n      Sets your CB handle to the name $hxxxx$n. This will
                   override any handle specified in a CB configuration
                   file $iand$n in the environment variable $hCBHANDLE$n.
                   If there are blanks in your handle, then be sure to
                   quote the entire flag like this:

                        "-hCrazy Ivan!"

                   If you don't quote it, then CB will treat each word
                   as a separate flag.

       $h-#xxxx$n      Specifies your registration serial number. This will
                   override any serial number specified in a CB configur-
                   ation file $iand$n in the environment variable $hCBSERIAL$n.
                   It must be specified $hSOMEWHERE$n (in one of these three
                   places) before the program will become fully functional.

       $h-o$n          Suppresses the loading of the Online Help file
                   $iCB.HLP$n. This will save the memory normally occupied
                   by that file, thus increasing the amount of memory
                   available for holding incoming messages, or for DOS
                   commands which you may want to run. This also means
                   that Online Help will be unavailable to you.

       $hfilename$n    Any command-line flag which does not start with a '-'
                   character is assumed to be the name of a configuration
                   file which is to be processed. Such files are processed
                   after the $iCB_SITE.CFG$n and $iCB_USER.CFG$n configuration
                   files, so any variables set from such files will
                   override prior values.










ENVIRON
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Starting CB: DOS Environment Variables                  ║$n
$i╚═════════════════════════════════════════════════════════╝$n

An alternative (and preferred) way to pass an individual's serial
number and password to the program is to set up two DOS environment
variables which CB checks for when it runs. This can eliminate the
need to build individual batch files which specify this information
via command-line flags.

The following DOS environment variables may be used to pass
information to this program:

       $hCBHANDLE=xxxx$n  Sets your CB handle to the name $hxxxx$n. This will
                      override any handle specified in a CB configuration
                      file, but will itself be overridden by the command-
                      line flag "$h-hxxxx$n" (if provided to this program
                      when it is invoked).

       $hCBSERIAL=xxxx$n  Sets your personal registration serial number
                      to $hxxxx$n. This will override any serial number
                      specified in a CB configuration file, but will
                      itself be overridden by the command-line flag
                      "$h-#xxxx$n" (if provided to this program when it
                      is invoked).

These may be set in your system's $hAUTOEXEC.BAT$n file (or from the
DOS command line) with the following commands:

        $iSET CBHANDLE=xxxx$n
        $iSET CBSERIAL=xxxx$n

The purpose of these variables is to specify your individual serial
number and handle so that CB can locate them when it begins execution.
If you set these variables in the $hAUTOEXEC.BAT$n file of your
system's boot disk, then you can just run the program directly via
the DOS command "$hCB$n", without having to have an individual batch
file created for you just to specify these things via command-line
parameters.







$i╔═════════════════════════════════════════════════════════╗$n
$i║ Searching For Files Via The DOS PATH Variable           ║$n
$i╚═════════════════════════════════════════════════════════╝$n

CB uses auxiliary files (the configuration files, its Online Help
file) for various purposes. When the program searches for these
files, it does so by looking $hfirst$n in the current DOS directory,
and $hthen$n in every directory that is defined in the DOS $hPATH$n
environment variable. This series of directories is sometimes known
as the DOS $hsearch path$n. Your DOS manual describes how to set and
use this environment variable.

When CB enters execution, it searches the DOS search path for an
ASCII text file named $iCB_SITE.CFG$n. This file - if found - is used
to initialize various configuration variables used by CB as it
executes. This file is meant to hold site-wide settings, which serve
as defaults.

After searching for that file, CB then searches for a similar file
called $iCB_USER.CFG$n. This will typically reside within an
individual user's own disk space, and is used to further customize
CB's operation. Any values which are defined in this file will
override the defaults that were specified in $iCB_SITE.CFG$n.

Lastly, CB searches for a file named $iCB.HLP$n, which holds the text
of the Online Help screens.

It is important to remember that the search for these various files
procedes through all directories in the $hPATH$n string $i in the $n
$i order in which they appear $n. Assume that the $hPATH$n string has
been set as follows:

        $iPATH=c:\\bin;c:\\mystuff;f:\\cb_stuff$n

Now assume that there are three files named $iCB_USER.CFG$n in three
separate directories:

        $iF:\\BBAUMANN\\CB_USER.CFG$n
        $iC:\\BIN\\CB_USER.CFG$n
        $iF:\\CB_STUFF\\CB_USER.CFG$n

The file at $iC:\\BIN\\CB_USER.CFG$h is the one that will be found and
used by CB.

If you meant the file at $iF:\\BBAUMANN\\CB_USER.CFG$n to be the one to
be used, then that's tough. The directory $iF:\\BBAUMANN$n isn't even
in the DOS search path, so it will not be searched (unless it just
happens to be the current DOS directory).

If you meant the file at $iF:\\CB_STUFF\\CB_USER.CFG$n to be the one to
be used, then that's tough too. Once CB finds the file that it's
looking for (in this case, the file at $iC:\\BIN\\CB_USER.CFG$n), it
stops looking. This, by the way, is very useful when you want to
override the file at $iF:\\CB_STUFF\\CB_USER.CFG$n by having the
program use the one at $iC:\\BIN\\CB_USER.CFG$n instead.

Please remember this when setting up your own files. Make sure that
you place them so that the above-described search will find the
proper files in the proper order.










CONFIG
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Configuring CB: The CB_SITE.CFG and CB_USER.CFG Files   ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The behavior of CB can be modified by commands contained in two
configuration files:

        $iCB_SITE.CFG$n     This is the site-wide configuration file, which
                        defines parameters which apply to all users on
                        the network.

        $iCB_USER.CFG$n     This is an individual user's configuration file,
                        which modifies CB according to the individual
                        user defined by this file.

Neither file is absolutely required, although you are strongly
encouraged to have at least the site configuration file $iCB_SITE.CFG$n.

Each line of these configuration files is of the form
$hKeyword=Value$n. The left side of the equation (up to and including
the equals sign) is a literal which must be entered $hexactly$n as
showm, including upper- and lower-case characters and embedded
spaces. The right side of the equation is set by you. There are
various types of entries, which are shown in the following examples
as follows:

    $hxxxx$n         The string $hxxxx$n stands for any string of your choice.
    $hYes$n | $hNo$n     One value must be entered, either "$hYes$n" or "$hNo$n".
    $hn$n            A number must be entered.

The various literal keywords which are recognized are as follows:

       $hChannel 01=xxxx$n         Specifies the name for CB Channel 01.
        ...                             ...
        ...                             ...
       $hChannel 19=xxxx$n         Specifies the name for CB Channel 19.

       $hCopyright=Yes$n | $hNo$n      Specifies whether the copyright screen
                               is to remain on the screen ($hYes$n) or
                               is to be cleared ($hNo$n) at program startup.
                               If there is anything wrong with the regi-
                               stration serial number, then this screen
                               is presented regardless of the setting of
                               this variable.

       $hDirectory=xxxxxxx$n       Specifies the name of a network directory
                               under which this program is to create its
                               temporary message files, and under which it
                               will look for other users' traffic. This must
                               be a complete network path, including the
                               trailing '\\' character. A failure to specify
                               the name of an existing directory will cause
                               an error when the program tries to establish
                               its network connection.

       $hHandle=xxxxxxx$n          Specifies the CB handle that you will be
                               known by. Each user should have a distinct
                               handle, although (as with a true CB radio)
                               this is not enforced. This handle may be
                               specified here, in the DOS environment
                               variable $hCBHANDLE$n, or on the command
                               line that runs CB as the command-line
                               flag "$h-hxxxxxxx$n".

       $hLogfile=xxxxxxx$n         Specifies the default name to be used for
                               the Logfile, to which incoming messages are
                               written when Logging is turned ON. You are
                               given the chance to explicitly specify the
                               name of the file to be written. This item
                               exists just to provide a convenient default.

       $hPage=xxxx$n               Specifies the DOS command which is to be
                               used to $hPAGE$n somebody on your particular
                               network. When you ask this program to page
                               somebody, it will pass to DOS the command
                               which you have specified here. You reserve
                               space in the command for the user's name by
                               inserting the reserved string "\\N". This
                               will be replaced with the name of the user
                               that you are paging.

                               With Novell, for instance, you can page
                               somebody using the Novell-supplied program
                               SEND. So your entry could read as follows:

                               $hPage=SEND "You're wanted on CB!" TO \\N$n

                               Note that the string "$hxxxx$n" may contain
                               embedded backslash escapes. These are
                               translated by this program before the string
                               is passed to DOS for execution. These escape
                               sequences are as follows:

                                     $h\\r$n    becomes a Carriage Return
                                     $h\\n$n    becomes a Line Feed
                                     $h\\b$n    becomes a Backspace
                                     $h\\t$n    becomes a Tab character
                                     $h\\f$n    becomes a Form Feed
                                     $h\\xFF$n  becomes a byte with the
                                                HEX value $hFF$n
                                     $h\\000$n  becomes a byte with the
                                                octal value $h000$n

                               This $hPage=$n variable is merely a
                               convenience, useful only if you want
                               this program to do the paging for you.
                               You could accomplish exactly the same
                               effect by issuing the appropriate DOS
                               command yourself from within this program.

       $hRefresh=n$n               Specifies the number of seconds between
                               checks for new messages. The argument n may
                               be from 1 to 29. The smaller the number, the
                               more responsive the program will be to new
                               traffic (at the expense of increased disk
                               activity). A larger number will mean that
                               more time may elapse between the time that
                               a message is posted and it appears on your
                               screen, but the program will pay more
                               attention to your keyboard.

       $hRegistration=xxxxxxx$n    Specifies your personal registration
                               serial number. Each user must have his own
                               distinct serial number, as provided by CCS.
                               This number may be specified here, in the
                               DOS environmemt variable $hCBSERIAL$n, or
                               on the command line that invokes CB as the
                               command-line flag "$h-#xxxxxxx$n". The
                               program will not be fully functional until
                               and unless a valid such number is presented
                               to it through one of these methods.

       $hSound=Yes$n | $hNo$n          Specifies whether sound is to be used
                               ($hYes$n) or suppressed ($hNo$n).




XMIT
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Talking on a CB Channel                                 ║$n
$i╚═════════════════════════════════════════════════════════╝$n

Once CB has been invoked, it is extremely easy to use. For most
applications, all that you need to do is type lines of text that you
want to broadcast to other users of CB, and watch the responses from
those users show up upon your screen.

As you type characters into the bottom line of your currently-active
window, you are composing a line which will be transmitted over that
window's channel. If the channel on which you are transmitting has
been $hscrambled$n, then outgoing lines will be automatically
scrambled as they are sent, and can only be meaningfully received by
CB users who have likewise scrambled that channel using exactly the
same password.

Normally, any keys which are pressed are inserted into the current
line which you are building. The following keys have special meaning:

       $h{Alt-A}$n     $hA$nttributes. This keypress pops up a one-line
                   menu showing various attributes which may be applied
                   to the line which is being entered. Press the key
                   corresponding to the attribute which is to be
                   toggled, or $h{Escape}$n to exit this menu. The
                   available attributes are:

                     $hB$neep       Causes a recipient's PC to beep when this
                                message is received.

                     $hC$nolor      Causes this message to be displayed in an
                                alternate color on the recipient's screen.

       $h{Alt-C}$n     $hC$nhannel. Switches the "current" window to be
                   tuned to the next available active channel. This is a
                   quick way to browse through several channels without
                   having to use pulldown menus.

       $h{Alt-W}$n     $hW$nindow. Makes the next window on the screen the
                   "current" window. This is a quick way to make another
                   window the current one without having to use pulldown
                   menus.

       $h{Alt-H}$n
       $h{F1}$n
                   $hH$nelp. Invokes online help for transmitting messages.

       $h{Alt-M}$n
       $h{F2}$n
                   $hM$nenu. Invokes the pulldown menu system, which
                   allows you to perform various operations.

       $h{Return}$n    Causes the current line to be transmitted over
                   the current channel. The window is then cleared in
                   preparation for the next line to be entered.

       $h{Right}$n     Moves the cursor one character to the right.
       $h{Left}$n      Moves the cursor one character to the left.
       $h{Home}$n      Moves the cursor to the far left limit of the line.
       $h{End}$n       Moves the cursor to the far right limit of the line.
       $h{Tab}$n       Inserts blanks up to the next 8-character TAB column.
       $h{Shift-Tab}$n Deletes backwards to the previous TAB column.
       $h{Backspace}$n Deletes the character to the left of the cursor.
       $h{Del}$n       Deletes the character at the cursor.
       $h{Ctrl-End}$n  Deletes to the end of the line.
       $h{Ins}$n       Toggles Insert/Overwrite mode for the transmit line.



RECV
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Listening to CB Channels                                ║$n
$i╚═════════════════════════════════════════════════════════╝$n

In the upper half of each window you are monitoring activity on the
indicated channel. Any messages that are transmitted (by you or
somebody else) on a channel are automatically displayed in the upper
part of the corresponding window. If a monitored channel has been
$hscrambled$n, then incoming scrambled messages will be automatically
unscrambled before being displayed, using whatever password you
specified when you asked the channel to be scrambled. If this
password is different from the password that was used by the
transmitter of a message, then the received data will appear as
garbage on your screen.

In addition to the keypresses described for transmitting (above), the
following keys are specifically related to the upper part of the
window, which displays received messages:

       $h{Up}$n
       $h{PgUp}$n
       $h{Ctrl-PgUp}$n
       $h{Down}$n
       $h{PgDn}$n
       $h{Ctrl-PgDn}$n

                These keys scroll the upper part of the "current"
                window backwards and forwards by lines, screens, or
                the entire in-memory buffer. This allows you to
                recall messages which may have scrolled off of the
                screen.

       $h{Ctrl-Right}$n
       $h{Ctrl-Left}$n

                These keys pan the upper part of the "current" window
                to the right and left in units of 8 columns. This is
                useful when viewing lines which are too long to be
                displayed within the confines of the window. Many
                users prefer to keep the window permanently panned 16
                columns to the right. This exactly hides the handles
                which are at the left edge of each line, and shows
                the greatest amount of text from each message line.



F1
$i╔═════════════════════════════════════════════════════════╗$n
$i║ About the {F1} Key                                      ║$n
$i╚═════════════════════════════════════════════════════════╝$n

If you are ever uncertain about some aspect of CB then just press
$h{F1}$n (Function Key number 1 on the PC keyboard). The $h{F1}$n key
is interpreted as a request for help. When pressed, it does one of
two things depending upon what's going on when it is pressed (that
is, depending upon the $hcontext$n within which help was requested):

     1) If you are seeing the standard CB screen (i.e. - you are
        not in the middle of a command or a question), then pressing
        the $h{F1}$n key will give you access to the full Online
        Help facility. This is a series of screens which explain
        various facets of this program. You may page forward and
        backward through these help screens.

     2) If you are being prompted for some input, or are pointing
        to some Pulldown Help Menu item, or have been shown some
        error message, then pressing the $h{F1}$n key will elicit
        a hint as to what is required or meant by the prompt or
        message. This hint will disappear by itself with your
        next keypress.
HELP
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Using Online Help                                       ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The Online Help facility is simply a means of browsing through the help
file $iCB.HLP$n. The following keys are available to you when using Online
Help:

       $h{Up}$n        Scrolls the text up one line.
       $h{PgUp}$n      Scrolls the text up one screen.
       $h{Down}$n      Scrolls the text down one line.
       $h{PgDn}$n      Scrolls the text down one screen.
       $h{Home}$n      Goes to the very first screen of Online Help.
       $h{End}$n       Goes to the very last screen of Online Help.
       $h{Escape}$n    Exits Online Help.








PULLDOWN
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Introduction                   ║$n
$i╚═════════════════════════════════════════════════════════╝$n

  $i                                                               $n
  $i NOTE: While in the Pulldown Menu Interface, communications    $n
  $i are temporarily frozen. They will be resumed when you exit    $n
  $i the Pulldown Menu Interface and return to the main CB screen. $n
  $i                                                               $n

Much can be accomplished with CB without ever leaving the main
screen. CB, however, is much more powerful than that main screen
would indicate.

In order to keep the main screen as simple and clean as possible, it
has not been cluttered with the dozens of commands that control CB's
more advanced operations. Instead, these additional commands have
been gathered together into an easy-to-use $hPulldown Menu Interface$n.

The Pulldown Menu Interface is inherently different from the command-
driven interface used in the main screen. There are many available
commands, and the menu approach is designed to let you see all
available options before you choose one, and to browse through those
choices without necessarily committing yourself. Lastly, it allows
you to back out of one series of menus, to pursue another menu path
if you choose to.




















$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Invoking the Menu System       ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The Pulldown Menu Interface is invoked from the main CB screen by
pressing $h{Alt-M}$n (that's "$hM$n" as in "$hM$nenu") or the $h{F2}$n key.
Once either key has been pressed, the top three lines of the screen
are replaced with the main menu. This is your point of entry into
the menu system.














$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The Main Menu Line             ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The topmost line of the screen has been replaced with the $hmain menu $n
$hline$n. This presents the various general categories of commands
which are supported by the menu system. One and only one of the names
on this line will be highlighted. This highlight is moved by using
the $h{Left}$n and $h{Right}$n keys, and defines the current $hmain menu$n
$hselection$n. As you move this highlight, the second line of the
screen changes. This line always holds a short description of the
highlighted selection. In other words, this line tells you what you
will be doing if you choose the highlighted menu selection.

Once you have highlighted the main menu choice that you want to
$hdescend$n, you select that choice by pressing the $h{Return}$n key.
Alternatively, you may select an entry in this (or any other) menu by
pressing the key which corresponds to the letter in each entry which
is in a different color. A $hpulldown menu$n then appears below the
selected main menu choice.



$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Pulldown Menus Themselves      ║$n
$i╚═════════════════════════════════════════════════════════╝$n

A $hpulldown menu$n appears when a menu selection has sub-selections
from which you may choose. One and only one entry in this vertical
menu is highlighted. You may move this highlight by pressing the keys
$h{Up}$n, $h{Down}$n, $h{PgUp}$n, and $h{PgDn}$n. As you move the highlight, the
description on the second line of the screen changes to suit the
entry that is highlighted. In this manner you may browse up and down
through the various menu entries until you arrive at just the one that
you want.

As with the horizontal main menu, an item is selected from a vertical
pulldown menu by moving the highlight to the desired entry and pressing
the $h{Return}$n key.







$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Menu Positioning               ║$n
$i╚═════════════════════════════════════════════════════════╝$n

CB makes every attempt to place pulldown menus in such a way that
superior menus remain visible, so that you can judge from the chain
of displayed menus just exactly how you got where you are. However,
CB won't let menus drop $htoo$n far down the screen, or else they
will obscure too much of the main CB screen.

Thus some menus may open up partially or completely $hon top of$n
superior menus. And if a pulldown menu contains more entries than can
be shown within the relatively limited vertical space allocated for
pulldown menus, then up and/or down arrows will appear in the margins
of the pulldown menu to indicate that more choices exist above or
below the indicated choices, which can be reached by scrolling the
menu upward or downward with the appropriate $h{Up}$n, $h{Down}$n,
$h{PgUp}$n, or $h{PgDn}$n keypresses.





$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Context-Sensitive Help         ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The short description on the second line of the screen might not give
you enough information about the highlighted choice to satisfy you.
As mentioned previously, the $h{F1}$n key may be pressed to obtain a
more explicit hint. This causes a $hhint box$n to appear which more
fully describes the highlighted choice.














$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: Backing Out                    ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The $h{Escape}$n key serves to $hback out$n of the current menu. This
returns you to the prior menu from which the current menu was
selected. If pressed when only the main menu is on the screen, this
keypress will exit the Pulldown Menu Interface back to the main CB
screen.














$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The CHANNEL Menu               ║$n
$i╚═════════════════════════════════════════════════════════╝$n

Choosing the "$hC$nhannel" entry from the main menu opens a pulldown
menu which shows the various operations that may be performed upon CB
channels.

$iChannel Disable$n

        This menu item allows you to $hdisable$n a given channel,
        which means that input from the given channel will be
        ignored. You won't see new messages from this channel on your
        screen, even if you have a window on your screen which is
        currently tuned to that channel. More importantly, internal
        memory won't be wasted holding messages from this channel,
        which means that more memory will be available to hold
        messages that you are really interested in, and DOS commands
        issued from within this program will have more memory in
        which to run.

        A pulldown menu is presented which allows you to select the
        channel which is to be disabled.

$iChannel Enable$n

        This menu choice allows you to $henable$n a channel, which
        undoes the effects of a disabled channel. Messages from the
        indicated channel will once again be accepted by this
        program, and passed to any windows which are tuned to the
        given channel.

$iChannel Scramble$n

        You may $hscramble$n a channel, which means that transmitted
        messages will be $hencrypted$n before they are transmitted
        over a channel and $hdecrypted$n upon receipt. This may be
        used to ensure a measure of privacy on the otherwise open
        simulated airwaves.

        When this menu selection is made, you are given the opportunity
        to select the channel which is to be scrambled. You are then
        asked for a $hpassword$n to be used to scramble data on the
        channel. This password may be up to 8 characters long. $hThis
        exact password must be used by all CB users who want to
        exchange scrambled messages$n!

        If a scrambled message is received by a user who has not
        scrambled the channel, it will not be displayed. If it is
        received by a user who $hhas$n scrambled the channel but who
        $hdid not$n scramble it with exactly the same password, then
        it may display as garbage on the screen.

        A scrambled channel is identified by a "$h@$n" character before
        the channel identification in the window title line.

$iChannel Unscramble$n

        This menu selection undoes the effect of scrambling a
        channel, so that once again messages will be sent and
        received in the clear.

$iChannel Tune$n

        This menu selection allows you to tune your current window to
        a specific channel. Whatever channel that window was formerly
        tuned to becomes irrelevant. From now on that window will
        monitor messages from the newly-tuned channel. Whatever
        channel you select is automatically $henabled$n.
$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The FILE Menu                  ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The "$hF$nile" main menu choice gives you access to the various file-
and DOS-related operations which can be performed.

$iFile DOS$n

        This menu selection allows you to execute a DOS command from
        within this program. Enter the DOS command which you want to
        execute. CB will pass that command to DOS for execution, and
        will then pause for you to press the $h{Return}$n key before
        it clears the DOS screen and returns to the CB screen.

        If you want to execute a series of DOS commands, then you may
        use this menu selection to enter the DOS command interpreter
        $iCOMMAND.COM$n. You indicate this by entering an empty
        command string (i.e. - you simply press $h{Return}$n instead
        of entering a command to be executed). This causes CB to
        invoke $iCOMMAND.COM$n, which displays the familiar DOS
        prompt and then processes your commands. To return to CB,
        issue the DOS command "$iEXIT$n".

$iFile Transmit$n

        This selection allows you to send an ASCII text file as if
        you typed it into the transmit line yourself. In fact, the
        file may be transmitted in either of two modes:

        $hM$nanual

                Each line of the file is read into the window's
                transmit line, where you may then edit it. The line
                will not be transmitted until you press $h{Return}$n
                as you would for any transmit line.

        $hA$nutomatic

                Each line is read into the window's transmit line,
                $hand then automatically transmitted over the channel$n.
                You do not need to press $h{Return}$n to transmit a
                line. Nor can you edit each line before it is sent.

$iFile Logfile$n

        This selection controls the $hLogfile$n, which is an ASCII
        file to which incoming messages are recorded. You may perform
        the following functions with the Logfile:

        $hOpen$n

                Open a new or existing Logfile, and start recording
                incoming messages to it. If the file already exists
                then you are given the choice of $happending to$n or
                $hoverwriting$n the contents of the file.

        $hClose$n

                Close an open Logfile. This is done automatically for
                you if you exit the program with an open Logfile.

        $hAnnotate$n

                Write a one-line message to the Logfile. You are
                prompted for a line to be written. That line is
                written to the open Logfile along with the current
                date and time.

$iFile Quit$n

        This selection allows you to exit from this program back to
        DOS. Any open files are automatically closed for you before
        the program actually exits.


















$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The HELP Menu                  ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The "$hH$nelp" pulldown menu gives you access to the Online Help
facility. The difference between accessing this facility through this
menu and via pressing the $h{F1}$n key from the main CB screen is
that this menu gives you an index of the helpfile. By selecting an
entry from this menu, you can enter the Online Help file at precisely
the screen which interests you.













$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The USER Menu                  ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The "$hU$nsers" pulldown menu allows you to perform various
operations associated with users of CB.

$iUsers Disable$n

        By $hdisabling$n a user, you cause incoming messages from
        that user to be ignored. Use this to filter out messages from
        a user who is hogging the channel, or is otherwise being
        obnoxious. You identify the user to be disabled by choosing
        his handle from a subordinate pulldown menu.

$iUsers Enable$n

        By $henabling$n a user, you undo the effects of $hdisabling$n
        that user. Once a user (again identified by handle) has been
        enabled, incoming messages from that user will again be
        accepted.

$iUsers Handle$n

        This selection allows you to change $hyour own$n handle (but
        nobody else's). You are prompted for your new handle. In
        response to this prompt, enter a string of up to 16
        characters. There is no requirement that this handle be
        unique, although things could conceivably get confusing if
        two or more users share a handle.

$iUsers Page$n

        This selection allows you to $hpage$n a network user who is
        currently not on CB. This is the preferred way to send a
        message to a person's screen to the effect that he is wanted
        on CB. Since he is not already on CB, of course, you can't
        very well send him a CB message. And electronic mail won't do
        because he may not read it for hours. So this command invokes
        your network's paging facility (as defined by your network
        administrator when he installed CB on your network and
        specified the "$iPage=$n" parameter in the CB configuration
        file) to send a short message to the person's screen. All
        that you need to know to use this command is the network name
        of the user. On some networks this is known as his $hlogin name$n.

        Once the paged user has received this message, he can at his
        leisure invoke CB and join the conference.





















$i╔═════════════════════════════════════════════════════════╗$n
$i║ Pulldown Menu Interface: The WINDOW Menu                ║$n
$i╚═════════════════════════════════════════════════════════╝$n

The "$hW$nindow" pulldown menu controls various operations related to
the current window.

$iWindow Channel$n

        This selection tunes the current window to the next channel
        which has been $henabled$n. If there are currently two
        channels which have been enabled, then this command will tune
        the current window to the "other" one. If there are more than
        two channels enabled, then subsequent invocations of this
        command will sequence through the entire list of enabled
        channels. Of course, if there is only one channel which has
        been enabled then this command will have no effect.

        Rather than having to go through the entire Pulldown Window
        Interface to accomplish this, you can accomplish the same
        thing by pressing $h{Alt-C}$n from the main CB screen.

$iWindow Next$n

        This selection makes the $hnext$n window on the screen the
        current window, assuming of course that you have at least two
        windows on the screen. That window then becomes highlighted,
        and its transmit line becomes active.

        Rather than having to go through the entire Pulldown Window
        Interface to accomplish this, you can accomplish the same
        thing by pressing $h{Alt-W}$n from the main CB screen.

$iWindow Kill$n

        This selection $hkills$n the current window (assuming of
        course that there are at least two windows on the screen),
        and gives its space to one of its neighboring windows.

        Along with $hW$nindow $hS$nplit this command allows you to
        control the number of windows on your screen.

$iWindow Split$n

        This selection $hsplits$n the current window into two,
        assuming of course that the window being split is large
        enough to support two separate windows. The two windows thus
        created are initially pointing to the same channel, but now
        that they are two separate windows you may independently
        change each window to suit your needs.

        Along with $hW$nindow $hK$nill this command allows you to
        control the number of windows on your screen.