@comment Tell Emacs to use -*-texinfo-*- mode
@comment $Id: user-ref.tex,v 2.5 91/09/01 23:04:54 royce Exp $

@node User Command Reference, Aide and Co-Sysop Command Reference, Sysop Theory, Top
@chapter User Command Reference
@cindex User commands
@cindex Commands, user

This chapter documents in gory detail the basic single-key and multi-key
extended commands that all users have access to.  Most of this information
is present in a more terse format in the online menus and help files, which
you should encourage your users to read often in order to make the best use
of Fnordadel's capabilities.  Don't be surprised, however, when they ignore
all the documentation available to them in favor of doing things inefficiently
or complaining that they can't figure out how things work.  Users are like
that.

The chapter will deal will single-key commands first, then multi-key,
and finish with miscellaneous functions.

@node Single-key User commands, Multi-key User Commands, User Command Reference, User Command Reference
@section Single-key User Commands
@cindex Single-key user commands
@cindex Commands, single-key user level

The Fnordadel single-key commands will allow you and your users to carry out
the majority of your activities on the system.  They do the things people most
often wish done, and have therefore been streamlined so they don't get in the way.
This has the side effect of making them inflexible, but flexibility is what the
multi-key commands (coming up soon) are for.

@node Room prompt commands, Pseudo commands, Single-key User commands, Single-key User commands
@subsection Room prompt commands
@cindex Room prompt level single-key commands

Users hitting the @samp{?} key at a room prompt will see something like
the following list of commands:

@cindex Single-key commands menu
@example
MESSAGES:
[E]nter message
[F]orward read
[N]ew messages
[O]ld messages
[R]everse read
[=]read headers of new messages
[#]message number

NAVIGATION:
[B]ackup from this room
[G]oto next room with new messages
[K]nown rooms list
[M]ail room direct
[S]kip room
[U]ngoto from this room
[+]next room (new messages or not)
[-]previous room (new messages or not)
[>]next floor
[<]previous floor

OTHERS:
[C]hat with Sysop
[D]ownload file
[H]elp
[I]nformation on this room
[L]ogin (Must do this!)
[T]erminate (Goodbye)
[U]pload file
[Z] Forget this room

[.] prefixes extended commands.
[;] prefixes floor commands.
[!] prefixes door commands.
@end example

@node Entering and reading messages, Navigation, Room prompt commands, Room prompt commands
@subsubsection Entering and reading messages
@cindex Commands, message reading/entering, single-key
@cindex Message reading commands, single-key
@cindex Message entering commands, single-key

You and (more importantly) your users will be spending a lot of time entering
messages, and reading ones posted by other users.  There is one basic way to enter
messages, but several ways to read them, reflecting the differences between old and
new messages in a room.

@ftable @code
@item [E]nter message
@cindex Network privileges
@cindex Networked message
This command is one that will be heavily used on your system,
with any luck.  When executed, it will take the user straight into
message entry mode, unless the current room is the @code{Mail>} room.  (In
@code{Mail>}, the system will first ask for the name of a user to whom the
message will be sent, privately.)  If the right combination of user
@dfn{net privileges} and room status exists, the system will make the message
@dfn{networked}, automatically.  @xref{Roomsharing}.

An opening help message will be displayed by the system
just before going into the editor, unless the user has set
@cindex Expert mode
@dfn{expert mode} on (@pxref{User Configuration}).  This message can be altered,
but we recommend keeping it a bit on the verbose side, since
the Fnordadel editor is not like very many others out there.  For full
details on the message editor, see @ref{The Message Editor}.

@item [F]orward read
This command is infrequently used.  It will cause the system to display
all messages in the current room, starting with the oldest and ending with
the newest.  Users will rarely be concerned with the ancient history that
this command will dredge up, but it's there for the curious.

Message display is automatically placed in @samp{more} mode if the current
room is @code{Mail>}, or the user has configured @samp{more} mode to be used
by default.  @xref{More Mode}.

@item [N]ew messages
This command is the most frequently used, and will cause the system to
display all new messages in the current room, in the order they were entered.
If the user configuration flag ``show last old message on [N]ew'' is set,
the last old message in the room (if any) will be displayed first,
followed by the new messages in normal fashion.  @xref{User Configuration}.

Message display is automatically placed in @samp{more} mode if the current
room is @code{Mail>}, or the user has configured @samp{more} mode to be used
by default.  @xref{More Mode}.

@item [O]ld messages
This command is the opposite of @code{[N]ew}, and allows for reading old
messages in the room, in reverse order of entry.  It is often used, since it
will quickly show the discussion leading up to the room's newer messages.

Message display is automatically placed in @samp{more} mode if the current
room is @code{Mail>}, or the user has configured @samp{more} mode to be used
by default.  @xref{More Mode}.

@item [R]everse read
This command is like @code{[O]ld}, and is the opposite of @code{[F]orward}.
It starts displaying messages with the newest one in the room, and works
backwards from there.

Message display is automatically placed in @samp{more} mode if the current
room is @code{Mail>}, or the user has configured @samp{more} mode to be used
by default.  @xref{More Mode}.

@item [=]headers of new messages
This command allows users to quickly skim through the new
messages in the current room, viewing only selected header information
from each message (for example, ``91Aug19 7:38 am from: Mr. Neutron'').
The Sysop and Co-Sysops will be shown somewhat more information than will
regular users or Aides (e.g. ``176641 (176641) 91Aug31 3:19 pm: from Not
Quite Cricket'', where the first two numbers are the local and original
message ID numbers, respectively).

In the @code{Mail>} room, the "from:" information will be replaced by
"to:" information, for those messages entered by the user seeing the
headers.  Additional information will be shown on the console if
@pindex +debug (citadel)
@code{citadel} is started with the @samp{+debug} option.  Subject lines
will also be shown for net messages originating on STadel systems that
were sent over with subjects.

This command never uses @samp{more} mode to display headers.  Also, it is
not of much use in anonymous rooms, where there is no header information
to speak of.

@item [#]message number
@cindex Message ID number
This command will probably be rarely used by anybody.  What it does is
allow a user to read a specific message in a room, by supplying its
message ID number.  Message ID numbers can be obtained by Co-Sysops
using @samp{=}, described above, or @samp{.R=}, described in
@ref{Multi-key message reading commands}.
Normal users can only get message ID numbers in anonymous rooms, where
they are a normal part of each message header.
@end ftable
@comment Now finished Entering and reading messages

@node Navigation, Other room prompt commands, Entering and reading messages, Room prompt commands
@subsubsection Navigating between rooms
@cindex Commands, navigation, single-key
@cindex Navigation commands, single-key

In order to use all of those commands you learned about in the previous
section, you will probably want a way to move about among the rooms on
the system.  Take it from us, the @code{Lobby>} room can get boring real fast.

@ftable @code
@item [B]ackup from this room
This command is equivalent to the old @code{[U]ngoto} command,
and allows the user to reverse the effects of the
last few goto and/or skip commands.  @code{[B]ackup} returns the user to the
room he/she left prior to entering the current room.  New messages in the
room exited are not updated in any way; normal use of @code{[G]oto} or
@code{[S]kip} will return the user to these rooms once more.   All messages in
each room re-entered via @code{[B]ackup}, which were new when the user last
entered the room, are re-marked as new.

@code{[B]ackup} can be
used several times in succession.  The system currently keeps track of
the 16 most recently-visited rooms for use by @code{[B]ackup}/@code{[U]ngoto}.

@item [G]oto next room with new messages
This command will take a user to the next room on the
system that has at least one new message in it, and mark all of the
messages in the room being left as old.  When there are no more new
messages in any room accessible to the user, @code{[G]oto} returns to the
@code{Lobby>} room and will continue to do so however many additional
times it is executed.  For non-experts, a message will be displayed
stating that there are no more new messages.

This command is the main one you and your users will employ
to move around the system.  You should make sure that you and they
understand its use.  For an example of improper commands to use for
general movement, see @code{[+]} and @code{[-]}, coming up.  It is
important that @code{[G]oto}
(or its big brother @code{.G(oto)}; @pxref{Multi-key navigation commands})
be used so that messages read in rooms visited are marked by the
system as being old for future visits to the room.  If this is not
done, users will see the same messages over and over again, which
is a waste of their time and system time.

@item [K]nown rooms list
This command will display a list of all rooms known to the
user executing it.  For the Sysop, this list will be all existing
rooms.  For a user with Aide or Co-Sysop status, this list will contain
most existing rooms, missing only invitation-only rooms to which the
Aide has not been invited, and those rooms which the Aide or Co-Sysop has used
@code{[Z]forget} to forget about.  For normal users, this list will just
contain regular public rooms, and the odd private rooms to which
they may have been invited.  The list is broken into two groups, the
first of which is rooms containing new messages, and the second of
which is rooms containing no new messages.

Private rooms are marked with with an asterisk (@samp{*}), and
will never show up in the @code{[K]nown list} unless the user has access.
Forgotten rooms will also never show up again unless the user
unforgets them.  @xref{Other room prompt commands}.  Finally, if the user is in
floor mode, only rooms on the current floor will be displayed.  To
see all rooms, use the @code{;K(nown floors)} floor command
(@pxref{Multi-key User Floor Commands}),
or the @code{.K(nown)} extended command (@pxref{Multi-key navigation commands}).
@xref{Other multi-key commands}, for the command to view
forgotten rooms, @code{.Z(list-forgotten)}.

@item [M]ail room direct
This command is a short-cut method of doing a @code{.S(kip) mail}
command.  It takes the user directly to the @code{Mail>} room, but does not
mark any messages in the current room as ``old''.  This allows the user
to return to the room later and find it just as he/she left it before
heading to @code{Mail>}.

@item [S]kip room
This command acts like @code{[G]oto}, taking the user to the next
room with new messages (or the @code{Lobby} room if no new messages
remain).  The difference is that the messages in the room being
departed are not marked by the system as being old, whether the user
has read them or not.  This command permits users to return to an
interesting discussion later, even during another login hours or
days ahead, and again read ``new'' messages to review what was said.

Due to the way that Fnordadel keeps track of which messages
in a room are new to a user and which aren't, users who persist in
skipping through rooms, signing off, and coming back later, will
find that Fnordadel slowly starts marking skipped messages as
being old.  As a general rule of thumb, messages that were entered
after a user's previous call, but before the current call, can be
skipped 8 times, after which they will become old.
Makes perfect sense, right?

@item [U]ngoto from this room
This command reverses the action of the user's last room
navigation command, such as @code{[G]oto} or @code{[S]kip}, or their multi-key
extended siblings.  See @code{[B]ackup} in this section for more details.

@pindex +backup (citadel)
This command will not be available if the Sysop started @code{citadel}
with the command-line option @samp{+backup}.  In such cases, the @code{[U]pload}
command replaces the @code{[U]ngoto} command.  (In either case,
@code{[B]ackup} is always available.)  This difference causes some
confusion, but was implemented because some people would rather have
the old @code{[U]ngoto} than a quick way to upload files.  You pick!

@item [+]next room
@itemx [-]previous room
These commands send the user to the next or previous room on the
system, @emph{whether there are new messages in it or not}.  If the user is
operating in floor mode, these commands will not leave the current
floor, but will loop from the last room on the floor back to the
first one, or vice versa, as appropriate.

These commands operate like @code{[S]kip}, in that they do not mark any
messages as old in the room being left behind.  For this reason, you
may wish to delete these commands from the
list of basic commands produced by hitting @samp{?}.  We have observed
inexperienced users falling into the trap of using them for
all their room navigation, rather than @code{[G]oto}.  Thus they read the
same messages again and again each time they call, wasting a lot of time.

@item [>]next floor
@itemx [<]previous floor
These commands take the user to the first room of the next or previous
floor on the system, if the user is in floor mode.  If the user is
on the last floor, @code{[>]next} will take him/her to the first floor;
similarly, the @code{[<]previous} command from the first floor will wrap
around to the last floor.
No messages are flagged as old in the room left behind.  @xref{Floors},
for a look at floors.
@end ftable
@comment Now done Navigating between rooms

@node Other room prompt commands,  , Navigation, Room prompt commands
@subsubsection Other commands

There remain several single-key commands that don't fit the above
two command categories (message processing and room navigation).  Don't
forget about them, though, because several are essential to everybody's
life, liberty and happiness.

@ftable @code
@item [C]hat with Sysop
Users wanna talk with the Sysop?  This is the command.
Users calling for a chat will either be told that the Sysop is
being paged, or if he or she has turned the chat option off
(see @code{[C]hat toggle} in @ref{Sysop Special Functions}),
they will see a message the contents of which live
in the @file{nochat.blb} file in the system's help file directory,
@vindex helpdir
@code{#helpdir}.  If a user has Aide status, the chat flag can be over-ridden
by a special Aide command.  @xref{The .A(ide) command}.
If the Sysop does not answer the chat call, a @samp{*} flag is put on
the status line to let him know somebody wanted a chat.  @xref{Status line}.

@item [D]ownload file
This is a quickie synonym for the extended command
@code{.R(ead) <protocol> F(ile)}, which sends files to a user by his/her
default transfer protocol (@pxref{User Configuration}).  Fnordadel will
prompt for the names of the files to send.  Note that this only works in
directory rooms that permit user downloads, of course.
@xref{Multi-key file reading commands}, and @ref{File Transfers}.

@item [H]elp
Okay, so you've given up.  You're tired of Fnordadel
assuming you want to be treated like an adult, and instead want to
be coddled in a mammoth maze of menu-driven madness!  Well, this command won't
quite do that, but it's close.  When you hit @samp{H}, you'll get a brief
listing of basic, single-key commands in a somewhat narrative
format.  This is simply a text file called @file{dohelp.hlp} in
@vindex helpdir
@code{#helpdir},
and like any of the @samp{.hlp}, @samp{.blb} or @samp{.mnu} files in that directory, the
Sysop may modify it to suit his or her tastes using any text editor
capable of saving @sc{ascii} text.

Note that you may branch out to other help screens.  At
the bottom of the @code{[H]elp} list, you are told that you can either hit
a carriage-return (which will take you back to the room prompt) or
type one of several letters to take you to other, more detailed help
screens.  Most of the other screens work in the same fashion.

Note also that any help file may be @code{[P]aused} just like any
other text being output from the system.  Finally, we realise that
you, as Sysop, have a mind like a steel trap and won't ever need
any of this help stuff.  When we say ``you'' above, we of course mean
other users.

@item [I]nformation on this room
This command allows users to view an optional information file,
which (presumably) tells them something about the current room, followed
by the total and new numbers of messages in the room.  The
info file is formatted exactly like a normal message, and has as its header
the file's date and time of last modification, and the user name of the
modifier.  @xref{The .A(ide) command}, for the Aide commands that deal with
room information files.  Room information is optional for each room.
There is one information file per room, and they all live in
@vindex roomdir
@code{#roomdir}
with the room data files.

Aides and Co-Sysops will also be shown some extra information about the
room, duplicating the details that the @code{[V]iew} command displays
during room editing.

@item [L]ogin
This command is how all users get onto the system in the
first place.  Depending on the setting of the
@vindex getname
@code{#getname} parameter
in @file{ctdlcnfg.sys}, when @code{[L]ogin} is executed the system will either
prompt for a password or for both a user name and a password.

This second possibility is popularly known as ``paranoid
mode'' and is used by Sysops who wish to discourage people from
attempting to guess passwords at random.  It's much easier to guess
a password which could get you into any user's account than it is
to guess a password of a particular user's account.

@item [T]erminate
This command logs users off the system properly.  As with
many commands, it will ask for confirmation.  There are, of course,
many ways for a user to leave the system improperly.  For a look
at them, see @ref{The call-log}.

@item [U]pload file
This is a quickie synonym for the extended command
@code{.E(nter) <protocol> F(ile)},
which lets a user upload a file by his/her default
transfer protocol (@pxref{User Configuration}).
Fnordadel will prompt for the name of the file and a
short description.  Naturally this only works in directory rooms that
permit user uploads.
@xref{Multi-key file entry commands}, and @ref{File Transfers},
for more information.

If the user executing the
command is not an expert, the system will prompt for a file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@pindex +backup (citadel)
This command will only be available if you started @code{citadel}
with the command-line option @samp{+backup}.  If you didn't, the @code{[U]ngoto}
command replaces @code{[U]pload}.  (In either case,
@code{[B]ackup} is always available.)  This difference causes some
confusion, but was implemented because some people would rather have
@code{[U]ngoto} than a quick way to upload files.  You be the judge.

@item [Z]Forget this room
@cindex Forget a room
If users find that the conversation in a particular room
fills them with ennui, they can @dfn{forget} the room simply by using
this command at the room's main prompt.  The room will no longer show
up in their list of known rooms, and they will no longer be taken to it
by any single-key navigation command, for example @code{[G]oto}.  In this
manner, users may tailor the sometimes vast numbers of different
discussions on a Fnordadel down to a smaller number that actually
interest them.

@cindex Unforget a room
In order to remember, or @dfn{unforget}, this room later on, if this is ever
desired, users can execute the multi-key command @code{.G(oto) @var{roomname}},
discussed in @ref{Multi-key navigation commands},
where @var{roomname} is the full and complete
name of the room to which they wish restored access.  This works fine for
both normal public rooms and hidden rooms, but if a user forgets an
invitation-only private room, this method will not regain access to
that room.  @xref{Rooms}.

Note:  The Sysop can not forget rooms.

@item [.] prefixes multi-key commands
@itemx [;] prefixes floor commands
We'll get to these in the next main sections, @ref{Multi-key User Commands},
and @ref{Multi-key User Floor Commands}.

@item [!] prefixes door commands
@xref{Doors}, for the complete scoop.
@end ftable
@comment Now done Other commands

@node Pseudo commands,  , Room prompt commands, Single-key User commands
@subsection Pseudo commands
@cindex Pseudo commands
@cindex Commands, output control
@cindex Output control keys

There are four single-key pseudo-commands that users will see
and use all the time.  They control output from Fnordadel whenever
something is being displayed.  The commands are:

@table @code
@item [J]ump
@findex [J]ump (output control)
This control command causes the system to jump to the
start of the next paragraph in whatever is being displayed.
This is a good way to skip ahead through long-winded messages
to find a part later in the text.

@item [P]ause
@findex [P]ause (output control)
This control command is used all the time.  It pauses
output, and waits of the user to press another key to restart
things.  Certain keys pressed while output is paused allow for
message deletion, movement, or journalling.  @xref{Deleting Messages},
@ref{Aide message deletion and movement}, and @ref{Message journalling}.

The @samp{^S} (Control-S) key will do the same thing as @code{[P]ause}.

@item [N]ext
@findex [N]ext (output control)
This command will cause the system to abort the display
of the current item and start the next one.  The only situation
in which this command makes sense is while reading messages in
a room.

The @samp{^O} (Control-O) key will do the same thing as @code{[N]ext}.

@item [S]top
@findex [S]top (output control)
This command will halt output from the system and
return the user to a command prompt.  In some cases when
Fnordadel is displaying important information, the @code{[S]top}
command will be ignored to ensure the user sees what is being
sent.
@end table

@node Multi-key User Commands, Multi-key User Floor Commands, Single-key User commands, User Command Reference
@section Multi-key User Commands
@cindex Commands, multi-key user
@cindex Multi-key user commands

The multi-key commands seem endless, but there really is a finite number of
them.  It's the options that are endless.  Before explaining in
more detail, the best piece of general advice is ``don't be afraid to
experiment with these commands''.  You can't hurt Fnordadel much, and you'll
be getting hands-on training to boot.  Besides, you should be making backups
anyway.

Multi-key commands start with a mode character.  For normal extended commands,
the character to use is @samp{.}.  Executing the @samp{.?} command will produce
a list of multi-key commands something like the following:

@cindex Extended commands menu
@cindex Multi-key commands menu
@example
.B(ackup) @var{roomname}

.E(nter) ?

.E(nter) M(essage)
.E(nter) N(et-message)
.E(nter) L(ocal-message)

.E(nter) [XYWV] [MNL]
         X(modem)
         Y(modem)
         W(xmodem)
         V(anilla)

.E(nter) H(eld-message)

.E(nter) F(ile) @var{file.ext}

.E(nter) [XYWV] F(ile) @var{file.ext}
         X(modem)
         Y(modem)
         W(xmodem)
         V(anilla)

.E(nter) C(onfiguration)
.E(nter) O(ption) @var{configoption}
.E(nter) P(assword)
.E(nter) R(oom)

.G(oto) ?
.G(oto) @var{roomname}

.H(elp) ?
.H(elp) @var{topic}

.K(nown) ?
.K(nown) [DHNP] <CR>
.K(nown) [DHNP] R(ooms) @var{roomname}
         D(irectory rooms)
         H(idden rooms)
         N(etwork rooms)
         P(ublic rooms)

.R(ead) ?

.R(ead) A(ll)
.R(ead) G(lobal)
.R(ead) N(ew)
.R(ead) O(ld)
.R(ead) R(everse)

.R(ead) [MUL+-~=XYWVC] [AGNOR]
        M(ore)
        U(ser) @var{username}
        L(ocal)
        + (After) @var{date}
        - (Before) @var{date}
        ~(not)
        =(headers)
        X(modem)
        Y(modem)
        W(xmodem)
        V(anilla)
        C(apture)

.R(ead) D(irectory) @var{*.doc}
.R(ead) E(xtended directory) @var{*.foo}

.R(ead) [M+-XYWVC] [DE] @var{files.ext}
        M(ore)
        + (After) @var{date}
        - (Before) @var{date}
        X(modem)
        Y(modem)
        W(xmodem)
        V(anilla)
        C(apture)

.R(ead) F(ile) @var{foobar.txt}

.R(ead) [+-XYWVCT] [FB] @var{files.ext}
        + (After) @var{date}
        - (Before) @var{date}
        X(modem)
        Y(modem)
        W(xmodem)
        V(anilla)
        C(apture)
        T(ext)

.R(ead) H(eader) @var{foo.arc}
.R(ead) I(nvited)
.R(ead) S(tatus)
.R(ead) # (message number)

.S(kip) ?
.S(kip) @var{roomname}

.T(erminate) ?
.T(erminate) S(tay)
.T(erminate) Q(uit-also)
.T(erminate) P(unt)
.T(erminate) Y(es)

.U(ngoto) @var{roomname}
or
.U(pload) @var{file.ext}

.Z (list forgotten)
@end example

The above list of commands will now be dealt with in similar logical groupings as
used in the single-key commands section.  (Due to their respective size, we will
split the @samp{enter} and @samp{read} commands into their own sections.)

Note:  There are some additional extended commands that are documented in
later chapters, as they are not accessible by normal users.  Also, there are
some extended commands that are not documented at all, for a variety of
reasons other than because we forgot.  In the case of these latter commands, they are
usually identical to existing single-key commands, and we don't wish to give
people an excuse to be less efficient than they should be.  Also, such commands might
be removed at any time, as the whim takes us, so don't build your life around
them.

@node Multi-key enter commands, Multi-key read commands, Multi-key User Commands, Multi-key User Commands
@subsection Enter commands
@cindex Commands, enter, multi-key
@cindex Enter commands, multi-key
@cindex Multi-key enter commands

Just as with single-key commands, there are extended commands for entering
information to the system.  However, much greater flexibility is possible with the
extended @code{.E(nter)} command.  One reason is that it can be used to enter a
variety of things, including messages, files, user configuration settings, and
more.  Another reason is that many of these things can be entered either
interactively or via a transfer protocol.

@node Multi-key message entry commands, Multi-key file entry commands, Multi-key enter commands, Multi-key enter commands
@subsubsection Entering messages
@cindex Entering messages
@cindex Message entry commands, multi-key
@cindex Multi-key message entry commands

There are several ways to enter messages, based on the type of message to be
entered and how it is to be entered.

@ftable @code
@item .E(nter) M(essage)
This is the basic multi-key message entry command.  @xref{The Message Editor},
for details on the message editor.  The command allows
normal entry of a message in a
room.  It is identical to the single-key @code{[E]nter} command.  The system
may make the message a networked message, if the right combination of
user net privileges and room status exists; otherwise, the message will
be non-networked.

@item .E(nter) N(et-message)
@cindex Networked message
This form of the command allows a user to
attempt to explicitly enter a @dfn{networked}
message.  There are several reasons why the system may not permit this.
Firstly, the current room might not be a shared room.  Network
messages can't be used in non-networked rooms.  (Note that @code{Mail>} is
considered to be a networked room even though the Sysop can't
explicitly share it with any other nodes.)

Secondly, the user may not have the requisite privileges in a
given room to enter a networked message.  In normal shared rooms, the
user must have been given network privileges by the Sysop; see
@ref{User Status Commands}.
(This can be done automatically using the
@vindex allnet
@code{#allnet} parameter in
@file{ctdlcnfg.sys}; see @file{ctdlcnfg.doc} for details.)

Finally, in the @code{Mail>} room, the user must have enough long-distance
credits (supplied by the Sysop, of course) if the destination system
is designated long-distance by the Sysop.  Normally, l-d credits are
not used;
however, to control l-d mail traffic the Sysop may define l-d net costs in
@file{ctdlcnfg.sys}
(see @file{ctdlcnfg.doc}, parameters
@vindex ld-cost
@code{#ld-cost} and
@vindex hub-cost
@code{#hub-cost}),
and assign credits to users (@pxref{User Status Commands}).

@item .E(nter) L(ocal-message)
@cindex Local (non-networked) message
The @code{.E(nter) L(ocal-message)} command allows a user to force a message
to be @dfn{local}, i.e. non-networked, in rooms that the Sysop has set up to
automatically ``nettify'' all messages entered.  Such auto-net rooms are
convenient, but now and then users may wish to post comments that
should not be
sent across the net.  This is especially true of users who have Aide,
Co-Sysop or Sysop status, since Fnordadel treats all networked rooms as if they
were auto-netted, for these classes of users.

@item .E(nter) [XYWV] [MNL]
This class of commands gives users the ability to compose
their messages on their own systems using any editor or word processor
that can save text to an @sc{ascii} file, and then upload the results to
Fnordadel as a message.  When Fnordadel has received the entire
transmission, it places the user into the message editor to allow for
any needed touch-up work.

The individual command types (@code{M(essage)}, @code{N(et-message)}
and @code{L(ocal-message)})
are subject to the same restrictions described in
@ref{Multi-key message entry commands}.
Here are the currently available transfer protocols:

@table @code
@findex X(modem) [.E(nter) modifier]
@findex Y(modem) [.E(nter) modifier]
@findex W(xmodem) [.E(nter) modifier]
@findex V(anilla) [.E(nter) modifier]
@item X(modem)
@itemx Y(modem)
@itemx W(xmodem)
@itemx V(anilla)
The first two protocols will be used almost exclusively.  For
details about the various protocols, see
@ref{Protocols, , File Transfer Protocols}.  Note that Wxmodem
may not be available, since we may have disabled the code we
inherited due to problems we haven't had inclination to fix.
@end table

@item .E(nter) H(eld-message)
This command allows a user to continue editing a message that
was previously saved in the held buffer by the @code{[H]old} command in the
message editor (@pxref{The Message Editor}).  A message held in one room may
be continued in another, reheld and restarted later, and so on.  The
Sysop can set the @file{ctdlcnfg.sys}
@vindex keephold
@code{#keephold} parameter to make Fnordadel
preserve users' held messages between login sessions.  If this is done,
held messages are stored in files in the directory
@vindex holddir
@code{#holddir} specified
in @file{ctdlcnfg.sys}.  A user may have only one held message at a time.
Users may also continue held
messages from the @samp{more} prompt (@pxref{More Mode}).
@end ftable
@comment Now done Entering messages

@node Multi-key file entry commands, Other multi-key entry commands, Multi-key message entry commands, Multi-key enter commands
@subsubsection Entering files
@cindex Entering files
@cindex Multi-key file entry commands
@cindex Commands, file entry, multi-key

There are fewer @code{.E(nter)} commands related to files than messages,
mainly because the system does not distinguish between different types of
files.  A file is a file is a file.

@table @code
@item .E(nter) F(ile) @var{file.ext}
@findex .E(nter) F(ile)
This is the basic file uploading command, and allows users to
transfer any sort of file to your system, providing that they have
access to a directory room that permits user uploads.  The transfer
protocol used defaults to the user's defined default protocol
(@pxref{User Configuration} for the command to set the default).
The system will
prompt for the name of the file to upload, and a short description.
@xref{File Transfers}, for more.

As usual, if the user executing the
command is not an expert, the system will prompt for a file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@item .E(nter) [XYWV] F(ile) @var{file.ext}
@findex .E(nter) [XYWV] F(ile)
This modification of the above command allows the user to
specify a file transfer protocol to use in uploading a file.
As always, if the user executing the
command is not an expert, the system will prompt for a file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.  Here are the supported
protocols:

@table @code
@findex X(modem) [.E(nter) modifier]
@findex Y(modem) [.E(nter) modifier]
@findex W(xmodem) [.E(nter) modifier]
@findex V(anilla) [.E(nter) modifier]
@item X(modem)
@itemx Y(modem)
@itemx W(xmodem)
@itemx V(anilla)
The first two protocols will be used almost exclusively.  For
details about the various protocols, see
@ref{Protocols, , File Transfer Protocols}.  For other details on
file transfers, @pxref{File Transfers}.  Note that Wxmodem
may not be available, since we may have disabled the code we
inherited due to problems we haven't had inclination to fix.
@end table
@end table
@comment Now done Entering files

@node Other multi-key entry commands,  , Multi-key file entry commands, Multi-key enter commands
@subsubsection Entering other information

There are several @code{.E(nter)} commands that have nothing to do with
messages or files.  However, they involve sending information to the system,
so the Citadel Gods decreed that they be @code{.E(nter)} commands.

@table @code
@item .E(nter) ?
@findex .E(nter) ?
This command simply displays one of Fnordadel's many help
files, which contains a brief list of the many @code{.E(nter)} options.

@item .E(nter) C(onfiguration)
@findex .E(nter) C(onfiguration)
This command calls up a menu that allows a user to change the
configuration data that he/she supplied when first logging onto the
system.  All user options may be altered in this menu except for name
and password.  Note that some of the options in this menu are not
settable by the user when he/she first logs in, if the ``Are you an
expert?'' question is answered with @samp{no}.  In such cases, some of the
more esoteric options are given default values by the system, and then
left well enough alone until the user stumbles across them in @samp{.EC}.
@xref{User Configuration}.

@item .E(nter) O(ption) @var{configoption}
@findex .E(nter) O(ption)
This command is a short-cut way for a user to change one of
his/her configuration options.  It avoids going through the menu in
the @code{.E(nter) C(onfiguration)} command.  The @var{configoption} option can
be any command available in the @samp{.EC} menu, and will produce the same
prompt and take the same answers.

@item .E(nter) P(assword)
@findex .E(nter) P(assword)
This command allows a user to change his/her password.  We
recommend that all users periodically change their passwords to guard
against so-called ``hackers''.

@item .E(nter) R(oom)
@findex .E(nter) R(oom)
This command allows a user to create a new room on the system.
A parameter in @file{ctdlcnfg.sys} (see
@vindex all-room
@code{#all-room} in @file{ctdlcnfg.doc}) permits
the Sysop to allow this command to be used either by all users, or
only by users with Aide or Co-Sysop status.  If a normal user executes
this command, he/she will be able to create only normal rooms and
hidden rooms.  Invitation-only status, directory status, and all other
attributes can only be set by an Aide or Co-Sysop.  Or the Sysop itself,
of course.

If there is no space for the new room (see the
@vindex maxrooms
@code{#maxrooms}
parameter in @file{ctdlcnfg.doc}), it will look for any temporary non-shared
rooms that
are currently empty.  If one such room is found, Fnordadel will
purge it to make way for the room being created.  If no killable rooms
are found, the system will display a message to the effect that no
space is available, and abort the operation.

This command also gives users a chance to create the initial room info file
using the message editor.  The contents of this file are shown to users when
they use the @code{[I]nfo} command.  @xref{Other room prompt commands}.  The
Sysop can define a @file{ctdlcnfg.sys} parameter called
@vindex infook
@code{#infook}, which controls whether all users or only Aides and Co-Sysops
are allowed to create info files.  Another parameter called
@vindex infomax
@code{#infomax} controls the maximum size of info files.
@end table
@comment Now done Entering other information

@node Multi-key read commands, Multi-key navigation commands, Multi-key enter commands, Multi-key User Commands
@subsection Read commands
@cindex Commands, reading, multi-key
@cindex Multi-key read commands

As with the @code{.E(nter)} command detailed above, there is also a very flexible
@code{.R(ead)} command.  It permits users to read messages, download files, and
display other kinds of information, with an even larger array of options than
available with @code{.E(nter)}.

@node Multi-key message reading commands, Multi-key file reading commands, Multi-key read commands, Multi-key read commands
@subsubsection Reading messages
@cindex Commands, message reading, multi-key
@cindex Multi-key message reading commands
@cindex Reading messages

Since Citadels were originally highly discussion-oriented, the oldest and most
used @code{.R(ead)} commands deal with messages.  A large collection of options
allows users to read messages in strange and wonderful ways.

@ftable @code
@item .R(ead) A(ll)
The @code{.R(ead) A(ll)} command is the same as the single-key
@code{[F]orward} command,
and demonstrates one of the few instances in which the single-key
commands aren't consistent with the extended commands.  @samp{.RF} is for the
@code{.R(ead) F(ile)} command, so @samp{A} for @code{A(ll)} was used instead.  Oh, by the
way, this command displays all messages in the current room, starting
with the oldest.

@item .R(ead) G(lobal)
The @code{.R(ead) G(lobal)} command does not have a single-key
equivalent.  This command will cause the system to
display all new messages in all rooms on the system, returning
the user to the @code{Lobby>} room when done.

This command is not frequently used, but can be beneficial for
the odd person who likes to peruse messages at great length.  Using the
message downloading capabilities of Fnordadel (described in @ref{Multi-key
message reading commands}, and in @ref{File Transfers}),
in conjunction with @code{G(lobal)} allows a user
to quickly transfer all new messages to his/her own system, where they
can be read at leisure without monopolizing the @sc{bbs}.

Of course, lurkers (users who always read but never post) can
use the @code{G(lobal)} command, too, since it allows them to see everything
with a minimum of key-strokes expended.  We tend to discourage such
activity whenever possible, on philosophical grounds.

@item .R(ead) N(ew)
The @code{.R(ead) N(ew)} command is the extended equivalent of the
single-key @code{[N]ew} command, and displays all new messages in the room,
from oldest to newest.

@item .R(ead) O(ld)
The @code{.R(ead) O(ld)} command does the same as the single-key
@code{[O]ld} command, and displays only old, previously-read messages in
reverse order, from newest to oldest.

@item .R(ead) R(everse)
The @code{.R(ead) R(everse)} command acts just like the
single-key @code{[R]everse} command, and displays all messages in the room in
reverse order, from newest to oldest.

@item .R(ead) [MUL+-~=XYWVC] [AGNOR]
The previous five basic message-oriented @code{.R(ead)} commands can
be supplemented with various options to make life easier and/or more
interesting.  These options can frequently be used in conjunction with
each other to produce compounded effects that literally boggle the
imagination.  Well, our imaginations, anyway.  Here, then, are
the currently available modifiers:

@table @code
@item M(ore)
@findex M(ore) [.R(ead) modifier]
The @code{M(ore)} modifier is a relatively recent addition to
Citadel, which historically has been anti-menu in philosophy.
We guess it's true that one can have too much of a good thing,
even if it's philosophy.

What @code{M(ore)} does for users is cause Fnordadel to display
messages in @samp{more} mode.  The system pauses after each message
displayed by any of the reading commands, to permit the digestion of
what was just read, and/or the entry of a few other commands, without
breaking out of the message-reading sequence.  Hitting @samp{?} at the
@samp{more cmd:} prompt should produce a list that looks like this:

@cindex More menu
@example
[A]- this message again
[B]ackup to previous message
[D]elete this message
[H]- continue held message
[N]ext message (also <SPACE>, <CR>)
[R]eply to this message
e[X]it message reader (also [Q]uit, [S]top)
@end example

For details on this option, see @ref{More Mode}.

@item U(ser) @var{username}
@findex U(ser) [.R(ead) modifier]
This @code{.R(ead)} modifier allows for the reading of just
those messages from a specific user.  If in the @code{Mail>} room,
messages both from and to the specified user will be shown.
After all modifiers have been supplied and one of the message-reading
commands (@samp{[AGNOR]}) is chosen, Fnordadel will ask for a
user name.

Entering a full or partial user name here will then
limit message display as described.  If the name given does
not match the author (or recipient, in the case of the @code{Mail>}
room) of any message, nothing will be displayed.

This modifier
may be inverted when used in conjunction with the @samp{~} modifier;
see @ref{Multi-key read commands}.  In such cases, it will show all messages
@emph{not} to or from the specified user.

@item L(ocal)
@findex L(ocal) [.R(ead) modifier]
This option is usable only in a shared room (remember
that @code{Mail>} is shared).  It limits messages being displayed to
those that were entered on this system, ignoring all messages
that may have come in over the network from other systems.

This modifier
may be inverted when used in conjunction with the @samp{~} modifier;
see @ref{Multi-key read commands}.  In such cases, it will show all messages
@emph{not} originating on this system (i.e. all those that came in
over the network).

@item + (After) @var{date}
@findex +(After) [.R(ead) modifier]
This option, and the following one, allow the user to
qualify the system's message display by giving date boundaries.
With the @code{+ (After)} option, the user may specify that messages
must be after a given date, which will be prompted for after all
other options are entered and a message-reading command
(@samp{[AGNOR]}) is given.

The format of the date is the same as all
dates displayed by Fnordadel, @samp{YYMMMDD}, where @samp{YY} is the year,
@samp{MMM} is the English abbreviation of the month, and @samp{DD} is the
day.  Example:  @samp{90Oct05}.  The year, @samp{YY}, may be ommitted, and
the current year will be assumed.  If the entire date is omitted (i.e.,
the user just hits @samp{<CR>} in response to the prompt), the system
will use the date and time of last call.

@code{+ (After)} and @code{- (Before)} can be used together.  See the next
section for details.

@item - (Before) @var{date}
@findex -(Before) [.R(ead) modifier]
This option is the reverse of the above option, and
specifies that all messages be prior to a given date.  The year can
be omitted, to indicate the current year should be used.  If the
entire date is omitted (i.e., the user just hits @samp{<CR>} in
response to the prompt), the system will use the date and time of last call.

@code{+ (After)} and @code{- (Before)} can be used together,
if desired, to specify a range of dates.  The range is inclusive.  So,
for example, entering @samp{.R+-A} and answering @samp{91Jan10} for the
``after'' date and @samp{91Jan15} for the ``before'' date, would net
you all messages entered on or after 91Jan10, and on or before 91Jan15.
The system does no checking to ensure that the two dates form a sensible
range.  Thus, if you reversed the two dates in the above example, the
system would search long and hard and find nothing.

@item ~(not)
@findex ~(not) [.R(ead) modifier]
This modifier works on certain other modifiers and
commands, and allows the user to negate or invert the normal
meaning of the resulting command.  @code{~(not)} currently has an
effect when followed by @code{M(ore)}, @code{U(user)}, @code{L(ocal)}
or @code{I(nvited)}
(with the @code{.R(ead) I(nvited)} command, described later).  When
followed by itself, it does what you'd expect, and negates
itself.  Useful, eh wot?

The @code{~(not) M(ore)} sequence is useful in @code{Mail>}, or if
a user has
the @samp{more} prompt enabled by default in his/her configuration,
and wishes to read some messages without using @samp{more}.  The
@code{~(not) U(ser)} sequence will display all messages @emph{except}
those to or from the specified user.  The @code{~(not) L(ocal)}
sequence, usable only in a shared room, will display only
messages that did not originate on this system.  The
@code{~(not) I(nvited)} sequence, usable only in a private room,
will list all users who do not have access to the room.

@item =(headers)
@findex =(headers) [.R(ead) modifier]
This modifier is similar in purpose to the single-key
@code{[=]new headers} command.
It tells Fnordadel to
display only the headers of the messages that are shown.  Users
with Aide, Co-Sysop or Sysop status will see somewhat different header
information than will regular users.  For a full description, see
@ref{Entering and reading messages}.

@findex X(modem) [.R(ead) modifier]
@findex Y(modem) [.R(ead) modifier]
@findex W(xmodem) [.R(ead) modifier]
@findex V(anilla) [.R(ead) modifier]
@item X(modem)
@itemx Y(modem)
@itemx W(xmodem)
@itemx V(anilla)
The above four options shouldn't be surprising in what
they mean.  They permit users to download a selection of
messages (optionally qualified by other @code{.R(ead)} modifiers)
using a standard file transfer protocol.  The resulting text
file can be read or edited on the user's own system.  For
details about the various protocols, see
@ref{Protocols, , File Transfer Protocols}.  Note that Wxmodem
may not be available, since we may have disabled the code we
inherited due to problems we haven't had inclination to fix.

@item C(apture)
@findex C(apture) [.R(ead) modifier]
This @code{.R(ead)} option permits users to capture the
selected messages into the held buffer, rather than display
them on the screen.  This feature is generally used to capture
a single message into the buffer, for purposes of quoting at
some length from it.
@end table

@item .R(ead) # (message number)
@cindex Message ID number
This command will probably be rarely used by anybody.  What it does is
allow a user to read a specific message in a room, by supplying its
message ID number.  Message ID numbers can be obtained by Co-Sysops
using @samp{.R=}, described in this section.  Normal users can only
get message ID numbers in anonymous rooms, where they are a normal part
of each message header.
@end ftable
@comment Now done Reading messages

@node Multi-key file reading commands, Other multi-key read commands, Multi-key message reading commands, Multi-key read commands
@subsubsection Reading files
@cindex Multi-key file reading commands
@cindex Reading files
@cindex Downloading files
@cindex File reading commands
@cindex Commands, file reading, multi-key

As time went by, and more people started using Citadels as general-purpose
@sc{bbs}es, the need for file-transfer capabilities grew.  Thus a number of
file reading commands were added (and continue to be expanded upon), which
more or less parallel appropriate message reading options.

@table @code
@item .R(ead) D(irectory) @var{*.doc}
@findex .R(ead) D(irectory)
This command enables users to get a list of files in a
directory room.  The list is sorted alphabetically by file name, and
the size of each file is listed.  After all files have been shown, the
total number of bytes taken by them will be displayed.  Users on the
system console will also be shown the total bytes free in the room,
and what directory the room is linked to on the storage device.

A single file name or mask containing wild-card characters
may be supplied with the command.  The system will search the directory
for all matches to the value entered, if any, and display them.  The
normal wild-cards (@samp{*} to match any sequence of characters, and @samp{?} to
match any single character) may be used.  If the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@item .R(ead) E(xtended directory) @var{*.foo}
@findex .R(ead) E(xtended directory)
This command is like the one above, with the difference that a
description will be displayed for each file, if there is one defined.
The system will automatically request a short description from users
who upload files to the system, but if files are put into the room in
any other fashion, the Sysop will need to manually create descriptions
for them in the directory's @code{.fdr} file.  @xref{File Directories}.

Again, a single file name or mask containing wild-cards
may be supplied with the command.  The system will search the directory
for all matches to the value entered, if any, and display them.  The
normal wild-cards (@samp{*} to match any sequence of characters, and @samp{?} to
match any single character) may be used.  If the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@item .R(ead) [M+-XYWVC] [DE] @var{files.ext}
@findex .R(ead) [M+-XYWVC] [DE]
The directory commands described above have some options to
improve their usefulness.  As above, if the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@table @code
@item M(ore)
@findex M(ore) [.R(ead) modifier]
This facility, a recent addition, gives to file
operations some of the same functionality that @code{M(ore)} has
given to message operations in the past.  We call the use of
@code{M(ore)} with file transfers the @dfn{file browser}, since it lets
users browse through directories of files, one at a time,
and do various things with them.  Hitting @samp{?} at the
@code{Browse cmd:} prompt should display a list like this:

@cindex Browser menu
@example
[A]- view this entry again
[B]ackup to previous file
[C]lear batch list
[H]eader listing of ARC, LZH, ZOO file
[M]ark this file for batch transfer
[N]ext file (also <SPACE>, <CR>)
[U]nmark a file
[V]iew batch list
e[X]it the browser (also [Q]uit, [S]top)
@end example

@xref{The File Browser}, for a full treatment.

@item + (After) @var{date}
@findex +(After) [.R(ead) modifier]
This option will cause the system to request a date
from the user.  Only those files with date stamps after the
given date will be shown.  The date format is the same as used
by the rest of Fnordadel, @samp{YYMMMDD}.  The year, @samp{YY}, may be
ommitted.  @xref{Multi-key message reading commands}, for other details.

@code{+ (After)} and @code{- (Before)} can be used together.  See the next
section for details.

@item - (Before) @var{date}
@findex -(Before) [.R(ead) modifier]
This option, if you can't guess, will cause the system
to display only those files with date stamps prior to the
user's given date.  @xref{Multi-key message reading commands}.

@code{+ (After)} and @code{- (Before)} can be used together,
if desired, to specify a range of dates.  The range is inclusive.  So,
for example, entering @samp{.R+-A} and answering @samp{91Jan10} for the
``after'' date and @samp{91Jan15} for the ``before'' date, would net
you a list of all files uploaded on or after 91Jan10, and on or before 91Jan15.
The system does no checking to ensure that the two dates form a sensible
range.  Thus, if you reversed the two dates in the above example, the
system would search long and hard and find nothing.

@findex X(modem) [.R(ead) modifier]
@findex Y(modem) [.R(ead) modifier]
@findex W(xmodem) [.R(ead) modifier]
@findex V(anilla) [.R(ead) modifier]
@item X(modem)
@itemx Y(modem)
@itemx W(xmodem)
@itemx V(anilla)
The above four options are the standard transfer protocols you've
no doubt come to love.  Their use with @samp{.RD} or @samp{.RE}
permit users to download a directory listing
(optionally qualified by other @code{.R(ead)} modifiers)
using a standard file transfer protocol.  The resulting text
file can be examined on the user's own system at his/her leisure.
For details about the various protocols, see
@ref{Protocols, , File Transfer Protocols}.  Note that Wxmodem
may not be available, since we may have disabled the code we
inherited due to problems we haven't had inclination to fix.

@item C(apture)
@findex C(apture) [.R(ead) modifier]
This @code{.R(ead)} option permits users to capture the
selected directory listing into their held message buffers.
It is probably best suited for use in shared rooms where you wish
to let other systems know about files on-line on your system.
Users actually calling your system can do a @samp{.RE} command
themselves, so why enter a redundant message?
@end table

@item .R(ead) F(ile) @var{foobar.txt}
@findex .R(ead) F(ile)
This command, usable only in a directory room, will cause
Fnordadel to display the contents of the specified file on the user's
terminal.  Hopefully, the user will only do this for text files, since
binary or compressed files are not very interesting to read.  No
formatting to the user's configured screen width is done, so if the
text file is formatted with lines longer than the user's terminal can
display, a mess will result.  See the @code{T(ext)} modifier in
@ref{Multi-key file reading commands}, for a way around this.

As mentioned before, if the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@item .R(ead) [+-XYWVCT] [FB] @var{files.ext}
@findex .R(ead) [+-XYWVCT] [FB]
The @code{.R(ead) F(ile)} command, like the message-reading commands,
has many modifiers to increase your joy in using Fnordadel.  They
can frequently be strung together to increase your confusion.  Finally,
as if that wasn't enough, a special variant of the command,
@code{.R(ead) B(atch file)}, is available for downloading multiple
files at a time, using Xmodem or Ymodem.

As mentioned before, if the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.  Now, here are the available
modifiers:

@table @code
@findex +(After) [.R(ead) modifier]
@findex -(Before) [.R(ead) modifier]
@item + (After) @var{date}
@itemx - (Before) @var{date}
The above two modifiers work just like they do with
directories and message display.  @xref{Multi-key message reading commands},
for details on how to do it.

@findex X(modem) [.R(ead) modifier]
@findex Y(modem) [.R(ead) modifier]
@findex W(xmodem) [.R(ead) modifier]
@findex V(anilla) [.R(ead) modifier]
@item X(modem)
@itemx Y(modem)
@itemx W(xmodem)
@itemx V(anilla)
The above four protocol modifiers work in the same fashion as they do in
other instances, with the addition that if Xmodem or Ymodem is chosen, the
user may also do a batch file transfer.  @xref{File Transfers}, for details.

@item C(apture)
@findex C(apture) [.R(ead) modifier]
This modifier works like the @code{C(apture)} modifier
for message-reading commands.  It allows the contents of one or more text
files in a directory room to be sent to a user's held
buffer, there to be mangled at his/her whim.  Note that the
system can't tell a text file from a binary or compressed file,
so be careful what gets captured.  Also note that only the first
10000 characters of the file(s) will be captured; this is the maximum
Fnordadel message size.

@item T(ext)
@findex T(ext) [.R(ead) modifier]
This modifier allows users to view the contents of
text files with the normal Fnordadel formatting tricks done
to them.  If a text file is properly formatted, the results
will be lovely to behold.  If it isn't, however, the results
will be heinous.  The typical problem encountered is with
paragraphs not being indented on the first line; Fnordadel
will run them into the previous paragraph just as it will with
messages typed on the system.

@item Batch downloads
This is a fun feature for file-mongers to use, as it
allows them to download multiple files via one single solitary
@code{.R(ead)} command.  The command must be used after the @code{X(modem)}
or @code{Y(modem)} modifiers, or the user will get something that says
@code{B(inary file)} and doesn't do anything useful.

Standard Ymodem batch protocol is supported.  The user
may supply several different file names after the command, any
of which may contain standard wild-cards @samp{*} and @samp{?}.

Alternatively, if the user has compiled a list of
files to batch-transfer, using the file browser (@pxref{The File Browser}),
he/she can just hit @samp{<CR>} instead of
entering any file names.  The entire batch list will then be
transferred.
@end table

@item .R(ead) H(eader) @var{foo.arc}
@findex .R(ead) H(eader)
This command, which can be used only in a directory room, will
display the header information for any @code{.arc} file in the room.
Callers may use this to get an idea of the contents of an @code{.arc} file
before downloading it.  The @code{.arc} format is the only one supported by
Fnordadel ``out of the box''.  However, the Sysop can define special
door programs that will enable users to execute this command for
additional formats, such as @code{.zoo} and @code{.lzh}.
@xref{Archiver doors},
for more information on doing this.  Also consult @file{ctdlcnfg.doc}.

As mentioned before, if the user executing the
command is not an expert, the system will prompt for the file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.
@end table
@comment Now done Reading files

@node Other multi-key read commands,  , Multi-key file reading commands, Multi-key read commands
@subsubsection Reading other information

@ftable @code
@item .R(ead) ?
This command, predictably, will cause the system to display a
brief help file about the @code{.R(ead)} command.  Naturally, the Sysop will
have configured the help files properly so as to make this possible.

@item .R(ead) I(nvited)
This command, usable only in hidden or invitation-only rooms,
will show the user executing it a list of all users with access to the
room.  The command may be inverted using the @samp{~} modifier, in which
case the list will contain all users lacking access to the room.
@xref{Multi-key message reading commands}, for details on @samp{~}.

@item .R(ead) S(tatus)
This command will display for the user some mostly meaningless
and occasionally esoteric status information about the system.  Try it
and you'll see what we mean.  We also added some useful data
about various privileges possessed and the values of various user call
limits.
@end ftable
@comment Now done Reading other information

@node Multi-key navigation commands, Other multi-key commands, Multi-key read commands, Multi-key User Commands
@subsection Navigation commands
@cindex Commands, navigation, multi-key
@cindex Navigation commands, multi-key
@cindex Multi-key navigation commands

After reading the perhaps bewildering set of possibilities available with
@code{.E(nter)} and @code{.R(ead)}, you should be pleased to find that room
navigation is a more straightforward affair.  However, true to form, the
multi-key navigation commands offer a few things not available with their
single-key counter-parts.

@table @code
@item .B(ackup) @var{roomname}
@findex .B(ackup)
This command provides a way to leave the current room (without
updating any of its messages as ``old'') and return to a previously-visited
room.  Any messages in the second room, if ``new'' at the time of login and
now marked as ``old'', are unmarked, and may again be read using @code{[N]ew}.

@code{.B(ackup)} is the multi-key sibling of the @code{[B]ackup} command
(@pxref{Navigation}), and is functionally identical to the @code{.U(ngoto)}
command (see below).  @code{.U(ngoto)} may not be available on any given
Fnordadel, so be aware that @code{.B(ackup)} is always there.

@item .G(oto) ?
@findex .G(oto) ?
This is identical to the single-key command @code{[K]nown-rooms}.
@xref{Navigation}.

@item .G(oto) @var{roomname}
@findex .G(oto)
This command allows the user to leave the current room (at
which time Fnordadel will mark all messages in the room as ``old'', i.e. as having
been read), and proceed to another room.  The difference between this
command and the single-key @code{[G]oto} command is that here the user gives
a room name explicitly, and the system will go there whether it has
new messages in it or not.  @code{[G]oto} only goes to rooms containing new
messages.

In order to be more useful, the @code{.G(oto)} command allows sub-strings
of room names to be used.  Thus, the @var{roomname} value can be
just a few sequential characters from anywhere in a room's name, and
Fnordadel will find it and go there.  If two or more rooms match
the sub-string, the system will go to the first one as appearing in the
known rooms list.

@item .K(nown) ?
@findex .K(nown) ?
This command will display a short list of the available
@code{.K(nown)} options.

@item .K(nown) [DHNP] <CR>
@findex .K(nown) [DHNP] <CR>
The basic command @code{.K(nown) <CR>} command is like the single-key
@code{[K]nown} command, and displays a list of rooms accessible by
the current user.  This command differs from the single-key version in
that the list may contain rooms from any floor, whether the user is
operating in floor mode or not.  Also, the list will not be separated
into groups of rooms based on presence or absence of new messages in
The rooms.  See also @ref{Navigation}, (@code{[K]nown-rooms});
@ref{Other multi-key commands}, (@code{.Z(list forgotten)});
and @ref{Multi-key User Floor Commands}, (@code{;K(nown floors)}).

The command can be further augmented by several options:
@code{D(irectory rooms)}, @code{H(idden rooms)}, @code{N(etwork rooms)} and
@code{P(ublic rooms)}.
The options can be mixed and matched in any order, and will restrict
the types of rooms shown by @code{.K(nown)} to those matching @emph{all} the options.
That is, for a room to be shown, it must match each attribute entered
by the user.  So @samp{.KD<CR>} will show all directory rooms, while @samp{.KDH<CR>}
will show all directory rooms that are also hidden.

@item .K(nown) [DHNP] R(ooms) @var{roomname}
@findex .K(nown) [DHNP] R(ooms)
This command will display for the user a list of known rooms
matching the @var{roomname} value entered.  Fnordadel searches for all
room names containing the sequence of characters in the entered string
and lists them.  The room type options @code{[DHNP]} described in the
previous section are available, and work the same way.

@item .S(kip) ?
@findex .S(kip) ?
This command will display a short help screen concerning the
use of the @code{.S(kip)} command.  (Assuming the help files are in order,
of course.)

@item .S(kip) @var{roomname}
@findex .S(kip)
This command is to the single-key @code{[S]kip} command as @code{.G(oto)}
is to the single-key @code{[G]oto} command.  It allows the user to leave the
current room and proceed to another one as specified by the @var{roomname}
value.  @var{roomname} may be just a few characters of the room's full
name, and Fnordadel will properly find it and go there.  As with
@code{.G(oto)}, if more than one room's name matches the entered value, the
system will go to the first one as appearing in the known rooms list.

The difference between @code{.S(kip)} and @code{.G(oto)} is the same as that
between @code{[S]kip} and @code{[G]oto}.  Namely, @code{.S(kip)} does not mark any messages
in the current room as having been read by the user.  The user may
return to the room later the same session, or on the next call, and
find the same new messages awaiting.  @xref{Navigation}, on @code{[S]kip}.

@item .U(ngoto) @var{roomname}
@findex .U(ngoto)
This command is identical in function to @code{.B(ackup)}, and the
multi-key counter-part of @code{[B]ackup}/@code{[U]ngoto}.  The command provides a
way to leave the current room (without updating any of its messages as
``old'') and return to a previously-visited room.  Any messages in the
second room, if ``new'' at login time and subsequently marked as ``old'',
are unmarked, and may again be read using @code{[N]ew}.

@pindex +backup (citadel)
This command will be unavailable if @code{citadel} is started
with the @samp{+backup} command-line option.  In such a case, the @code{.U(pload)}
command is active, and @code{.B(ackup)} must be used by people who wish to
do this sort of ungotoing.
@end table
@comment Now done Navigating between rooms

@node Other multi-key commands,  , Multi-key navigation commands, Multi-key User Commands
@subsection Other multi-key commands

Finally, there are a few additional miscellaneous multi-key commands that
will prove useful from time to time.

@ftable @code
@item .H(elp) ?
Assuming the system help files are set up properly, this
command will take the user to the main help menu, and present the list
of topics about which help is available.

@item .H(elp) @var{topic}
This command short-cuts the above main help menu, and goes
directly to the topic @var{topic} as entered by the user.  The list of
available topics can be seen by using the command @code{.H(elp) ?}.

@item .T(erminate) ?
This command will show the user a list of available options
with the @code{.T(erminate)} command.  These options allow the user more
flexibility in how the system treats his/her exit, than does the
single-key @code{[T]erminate} command.

@item .T(erminate) S(tay)
This command allows the current user to log off the system,
updating all necessary records concerning what rooms were visited,
what messages were read, and so on.  The only difference from the
normal @code{[T]erminate} command is that Fnordadel will not cause the modem
to hang up on the user.  This allows him/her, or another person sitting
there, to then sign on with another account, without having to dial
the system back and possibly get beat to the punch by the hundreds of
other loyal users trying to call.

@item .T(erminate) Q(uit-also)
This command behaves the same as @code{[T]erminate}.  Why anybody
would want to use it is beyond us.

@item .T(erminate) P(unt)
This command is another useful one.  After executing it, the
system will log the user off and hang up the modem as usual.  However,
the system does not update any room-related records, such as what
rooms were visited or forgotten, or what messages were read.  In other
words, it's
just like the user never called.  This is good if a user has an
interruption force a termination before everything was read or written,
and wants to call again later and see everything the way it was for the
current call.

Configuration changes made using @samp{.EC} or @samp{.EO} are not lost,
and the receipt flags on messages in @code{Mail>} are also permanently
updated (i.e., authors or mail to you will be able to tell you read their
messages even though you left using @code{P(unt)}).

@item .T(erminate) Y(es)
This command, like @code{.T(erminate) Q(uit-also)}, is just the
same as @code{[T]erminate}.  One day we really must eliminate some of this
repetitive redundancy.

@item .U(pload) @var{file.ext}
This command is the extended counter-part to the single-key
command @code{[U]pload}.  It behaves identically.  @xref{Other room prompt
commands}.  This
@pindex +backup (citadel)
command is only available if @code{citadel} is started
with the @samp{+backup} command-line option.  Otherwise, the @code{.U(ngoto)}
command is active.

As usual, if the user executing the
command is not an expert, the system will prompt for a file name;
otherwise, no prompt is given, and the system will wait for the file
name to be typed on the command line.

@item .Z (list forgotten)
This command fills the gap left by @code{[K]nown}, @code{.K(nown)} and
@code{;K(nown)}, by giving the user a list of rooms that he/she used
@code{[Z](forget)} to forget about.  This allows the user to regain access
to those rooms, by using @code{.G(oto)} and the full room name, to return to
a room.  Once done, the room will be unforgotten.

One thing that this command won't do is list forgotten hidden
or invitation-only rooms.  If the user forgets a hidden room, he/she
can still get back to it by using @code{.G(oto)} with the room's full name,
but that name will have to be remembered or obtained without any help
from Fnordadel.  Invitation-only rooms can't be entered again unless
the user is reinvited.
@end ftable
@comment Now done Other commands

@node Multi-key User Floor Commands, The Message Editor, Multi-key User Commands, User Command Reference
@section Multi-key User Floor Commands
@cindex Floor commands, multi-key
@cindex Commands, floor, multi-key

In addition to the extended commands described above, there are some
multi-key commands that apply specifically to floors.  These are signified
by starting the command with the @samp{;} character to indicate that a
floor command is about to happen.  As with @samp{.?}, @samp{;?} will show a
list of available extended floor commands.  It should look like this:

@cindex Floor commands menu
@example
;C(onfigure floor mode)
;G(oto) @var{floorname}
;K(nown floors list)
;R(ead) floor w/ all .R(ead) options
;S(kip all rooms on this floor)
;Z (forget this floor)
;> (move to next floor)
;< (move to previous floor)
@end example

@ftable @code
@item ;C(onfigure floor mode)
This is a quickie way to switch from floor mode to normal
mode (or vice versa).  The current state of floor mode will be saved
for subsequent logins.  This can also be done in the @samp{.EC} menu
or with the @samp{.EO} command---see @ref{Other multi-key entry commands},
and @ref{User Configuration}.

@item ;G(oto) @var{floorname}
This command takes a full or partial name of a floor, and
takes the user to the first room in said floor, if found and accessible
by the user.  Any new messages
in the room being left via @code{;G(oto)} are marked as old, as per usual.

@item ;K(nown floors list)
This is the most commonly used floor command.  It prints a
nice formatted list of all floors in the system, and which rooms are
on which floor.  The list is printed in two parts: first, the floors
containing rooms with unread messages, and second, those floors without
such rooms.  A floor will be listed as having rooms with unread
messages no matter how many such rooms are on the floor; there may be
only one.

If none of the rooms on a floor are accessible to a user,
he/she will not be shown any information about the floor.

@item ;R(ead floor)
This command is like @code{.R(ead)}, but traverses all rooms on the
current floor looking for messages.  All @code{.R(ead)} options are usable,
although @code{G(lobal)} in particular wouldn't make sense since it goes after
all rooms on the system.  If the user isn't in floor mode, this
command will have exactly the same effect as @code{.R(ead)}.

@item ;S(kip this floor)
This command causes @emph{all} rooms on the current floor with unread
messages to be marked as skipped.  The user is taken to the next
floor containing unread messages.

@item ;Z (forget this floor)
This is a fairly dangerous command, in that it causes all
rooms on the current floor to be forgotten (a la the @code{[Z]forget} command).
The user is taken to the base floor after executing this command.
@xref{Other room prompt commands}.

@item ;> (move to next floor)
@itemx ;< (move to previous floor)
The @code{;> (next)} and @code{;< (previous)} commands are identical to the
single key @code{[>]next} and @code{[<]previous} commands.  @xref{Navigation}.
@end ftable

@node The Message Editor, User Configuration, Multi-key User Floor Commands, User Command Reference
@section The Message Editor
@cindex Editing messages
@cindex Message editor

As mentioned earlier, the Fnordadel message editor is rather unlike
the editors on most other systems.
The big difference is that a message, to Fnordadel, is
just a long string of characters up to 10000 in number.  In most
other systems, a message is a series of lines, each of which is a
string of characters that usually can't exceed 80 (or so) in number.
Message editing on such systems can be cumbersome, since every
command works on the message lines.  Sadly, the editor's concept of
lines rarely meshes with the user's concept of sentences and
paragraphs.  This causes trouble when text needs to be deleted or
added to the message.

In Fnordadel, there are no message ``lines'', just straight
text.  The only thing that Fnordadel recognizes is the
concept of a paragraph.  Paragraphs are separated by a carriage-return in
the text, followed by at least one space.  This is a crucial fact
that causes people a lot of confusion, so it will be emphasized:
@quotation
If a @samp{<CR>} is typed and @emph{not} followed by at least one space,
Fnordadel will throw the @samp{<CR>} away, and replace it with a simple
space character.  This permits the system to format things nicely for users
with a different screen width than the author, no matter how many spurious
@samp{<CR>} characters the author may enter.  Line-based editors usually do
not work this way.
@end quotation
While entering the text of a message, Fnordadel doesn't
worry about making it look pretty by doing word-wrap, i.e.
preventing whole words from being broken on the right-hand margin of
the user's screen while he/she types.  Fnordadel performs no
pretty formatting on
the message until it is actually displayed, at which time it will
oblige the user reading it by formatting everything neatly out
according to the configured screen width.

At various times during the course of entering a message,
it is likely that a user will want to do things such as display
the text entered so far, perform some edits, or save the message.
To get out of message entry mode, the user must enter two @samp{<CR>s}
in a row.  He or she will then be sitting
at the main message editor prompt, which also shows the current room
name (for those forgetful types).  Pressing @samp{?} will generate this list:

@cindex Editor menu
@cindex Message editor menu
@example
Editing:
[B]lock replace text
[D]elete text
[I]nsert paragraph break
[K]ill text block
[R]eplace text

Control:
[A]bort entry
[C]ontinue
[H]old Message for later
[L]ocal save
[N]etwork save (shared rooms/mail)
An[O]nymous message toggle
[P]rint formatted
[S]ave message
@end example

@table @code
@item [B]lock replace text
This command allows the user to replace a large
chunk of text with something else.  When it is invoked,
Fnordadel will prompt for the starting and ending strings
of text which ``frame'' (and are included in) the block of
text to be replaced.

If the two strings do not match a block of text
somewhere in the message, Fnordadel will say as much and
return to the editor prompt.  Otherwise, the system will
prompt for the replacement text, which is limited to about
200 characters in size.  The user may just hit a carriage-return
here to cause the block of text to be replaced with
nothing (i.e. deleted).

When the replacement text is entered, Fnordadel
will then echo back to the screen the entire block of text
it found as a match for the starting and ending search text.
The system will display a little bit of additional text
before and after the matching block to give an idea of the
context surrounding the block, so the user can make sure
the right stuff is going to be replaced.  Following will
appear a prompt:

@example
Replace this one? (Y/N/[A]ll/[Q]uit):
@end example

At this point, the user may enter @samp{Y} to cause the replacement,
or @samp{N} to cancel it.  In either case, the
system will search for another match to the starting
and ending text.  If found, the prompt will appear again.

If the @code{[A]ll} option is chosen at some point, the
system will then automatically search out and replace all
remaining instances of the starting and ending text,
starting with the block currently displayed.  The process is
unstoppable, so be sure it's what is desired.

The @code{[Q]uit} option will cancel the current replacement
being asked about, and stop the system from looking for
any remaining candidates.  Once the searching stops, by
@code{[Q]uit} or because there are no more matches, the system
will report how many matches were found and how many were
actually replaced.

One thing to note about all of the Fnordadel
delete/replace commands is that they search for text in
reverse, from the end of the message towards the start.
This is done because, in general, users want to change the
text they typed recently more often than the text they
typed awhile ago.

@item [D]elete text
This command permits the user to specify a single
(usually short) text string to be deleted from the message.
If the string is found, it will be echoed back for
confirmation, with some surrounding text for context.  As
with @code{[B]lock replace}, a prompt will appear allowing @code{[A]ll}
instances to be deleted, or the process to be @code{[Q]uit}.

@item [I]nsert paragraph break
So you've written a 10K message and just realized
that you didn't put a single paragraph break in it?  Bad
form, you're sure to lose face.  You can correct the faux pas
using this
command.  Simply invoke it and supply a short text string
that uniquely identifies the place in your message where
you want a paragraph break.  Fnordadel will find the
string, and insert a break just before it.  That's @emph{before},
not after.

Note that the system does not, at the moment,
prompt the user when it has found a match for the search
string.  Be careful not to insert breaks in spurious
loca

tions.

@item [K]ill text block
This command is the deletion equivalent of
@code{[B]lock replace}, and works in a similar fashion.  The sole change is
that @code{[K]ill} doesn't ask for replacement text, since there
isn't going to be any replacement except hard vacuum.

@item [R]eplace text
This command is the replacement equivalent of the
@code{[D]elete} text command above.  It functions in the same manner
as @code{[B]lock replace}, but requests only a single (usually
short) text string to search for.

@item [A]bort entry
This command permits the user to throw the message
away if he or she has second thoughts about it.  The system
will prompt for confirmation before tossing the message.  Ain't
that considerate?

@item [C]ontinue
This command allows the user to resume message entry
where it was left off.  The two carriage-returns entered to
escape from message entry mode before are not kept around,
so message entry will continue immediately after the last
character typed before the two @samp{<CR>}s.  The last few words of
the text so far are redisplayed so the user can recapture
his or her train of thought.

@item [H]old message for later
This command is very handy when used properly.
[H]olding the message
will store it in a temporary buffer where it can be retrieved
later using the @code{.E(nter) H(eld-message)} command (@pxref{Multi-key
message entry commands}), or using @code{[H]eld message} from `more' mode
(@pxref{More Mode}).

Meanwhile, however, after pressing @samp{H}, the user is
returned to the room prompt and can go about normal activities
like reading other messages and moving to other rooms.  The
held message does not have to be continued in the room in
which it was originally started; it can be resurrected and
saved into any other room, even @code{Mail>}.

This command is particularly useful for replying to
several different messages within a single message.  The user
may enter a reply to one message, @code{[H]old} the reply, and
continue reading additional messages and tacking replies
onto his/her own existing message.  This is usually considered to
be good form, especially if posting a series of replies in a
networked room.  One message is easier to transmit than many,
and also will take up fewer valuable slots on other variants of Citadel
that can only store a fixed number of messages in each room.

Each held message is squirreled away in a disk file,
from where it is retrieved when the user continues it.  A
@file{ctdlcnfg.sys} parameter called
@vindex keephold
@code{#keephold} lets the Sysop
choose to have Fnordadel throw away each hold file when the
user who saved it logs out, or to keep the hold file until
the user continues his/her message.  This could be any time in
the future (unless the user's account scrolls off the system
before he/she continues the message), so the hold files might
take up quite a bit of space.  If this happens, the Sysop can
delete them manually from @sc{gem} or a command shell.

@item [L]ocal save
This command allows a user to force Fnordadel to
save a message as a non-networked message, in a room that
might otherwise automatically send the message out over the
network.  It is typically used when entering a reply to
something that should be kept local due to being of purely
local interest, or just plain snarky in tone.  Other
Sysops on the network usually won't like to see either type
of message coming from your system.

This command works in the @code{Mail>} room, as well.  If
a message has been entered to a user residing at another
system on the network, hitting @samp{L} allows redirecting the
message to a user on the local system instead.

@item [N]etwork save
This command has the opposite effect of @code{[L]ocal save},
above.  One additional restriction, however, is that not all
users may have the necessary status to make a message go
out over the network.  This depends on the
@vindex allnet
@code{#allnet} parameter
in @file{ctdlcnfg.sys}.  If
@vindex allnet
@code{#allnet} is not set, the Sysop must grant
network privileges to users on an individual basis.
See @code{.E(nter) N(et-message)} in
@ref{Multi-key message entry commands},
@vindex allnet
@code{#allnet} in @ref{Optional parameters, , Optional networking parameters},
and @ref{User Status Commands}.

As with @code{[L]ocal save}, @code{[N]etwork save} works in @code{Mail>}.
If users wish to send mail to long-distance systems, they will
@cindex Network credits
need @dfn{long-distance network credits} in addition to network privileges.

@item An[O]nymous message toggle
In rooms which are anonymous, author names and the dates/times of entry are
normally not stored or shown with messages.  If a user wishes to
unquestionably identify a message as his or her own, however, this command
will override the normal anonymity of the room and put a standard header on
the message.  @xref{Rooms}, and the @code{.A(ide) E(dit)} command in
@ref{The .A(ide) command}, for more on anonymous rooms.

@item [P]rint formatted
This command will display the message text entered
so far, nicely formatted to the user's configured screen
width.  Message display can be manipulated using @code{[P]ause},
@code{[J]ump}, etc., as usual.

@item [S]ave message
Here's where all the hard work pays off!  @code{[S]ave} the
message and then sit back and wait for all the plaudits and
applause to come pouring in.  Just don't forget to duck the
tomatoes and rotten eggs from the unenlightened.
@end table

@node User Configuration, More Mode, The Message Editor, User Command Reference
@section User Configuration
@cindex User configuration
@cindex Configuration, user
@cindex Options, user

There is an ever-increasing list of personal configuration options that
a Fnordadel user can set.  Some of them (all of them, if a user claims
Citadel expertise) are set when each user first logs into the system.  If
they ever need changing, there exist the @code{.E(nter) C(onfiguration)}
and @code{.E(nter) O(ption)} commands.  @samp{.EC} is a menu-driven; each
option in its menu can also be set directly by @samp{.EO}.
@xref{Other multi-key entry commands}.
The list of options is as follows:
@cindex User configuration menu
@example
[A]uto new
[E]xpert mode
[F]loor mode
[L]inefeeds switch
[N]ulls
[O]- show last old message on [N]ew
[P]ause between messages
[R]unning count of msgs while reading
[T]- show time of message creation
[V]iew configuration
[W]idth of screen
e[X]it
[Y]- set default transfer protocol
@end example

@table @code
@item [A]uto new
This flag tells the system whether it should automatically show the
user all new @code{Lobby>} messages after he or she logs in.  Most Citadels
do this whether you like it or not.  We didn't like it, so we took
it out.  After much protest, we put it back in as a configurable thing.
The default the first time this question is posed (when a new user first
logs in) is set by the @file{ctdlcnfg.sys} parameter
@vindex defautonew
@code{#defautonew}.

@item [E]xpert mode
This parameter allows a user to control Fnordadel's
behavior in some ways.  In general, an experienced user is
shown far less verbose information in terms of command prompts
and automatic help messages.  The default the first time this
question is asked (during login) is ``no''.

@item [F]loor mode
This option allows the user to control whether he/she will use the system in
floor mode.  If ``no'', the system will appear to be one big unorganized
collection of rooms.  If ``yes'', rooms will be grouped by their defined
floors, if there are any.  The default here is ``yes''.  @xref{Floors}, for a
description of floors, and @ref{Multi-key User Floor Commands}, for commands
to use them.  The default the first time this question is asked
(during login) is set by the @file{ctdlcnfg.sys} parameter
@vindex deffloormode
@code{#deffloormode}.

@item [L]inefeeds switch
This parameters allows a user to tell Fnordadel
whether each line output by the system should be ended with just a carriage-return
(@samp{<CR>}) character, or both a @samp{<CR>} and a line-feed (@samp{<LF>}).  On some
terminals (mostly ancient ones), a @samp{<CR>} character only causes
the cursor to return to the left margin, not to advance a line
as well.  Thus the @samp{<LF>} characters might be needed.  The default
here the first time through (during login) is ``yes'', to output both
@samp{<CR>} and @samp{<LF>}.

@item [N]ulls
This is the number of non-displaying @sc{ascii} ``null'' characters
that Fnordadel will output at the end of each line on the
screen.  This capability, which is mostly not understood by
users these days, allows them to cause Fnordadel to slow
output down for them.  (Nulls are non-displaying characters,
but they still take time to send over the modem.)  Users with fast modems (2400 bps and
higher) can use this feature to help them read what's being
sent without having to hit the @code{[P]ause} key until it breaks.
The initial default value (during login) is 0 nulls.

@item [O]- show last old message on [N]ew
This option allows the user to specify whether
Fnordadel should show the last old (i.e. previously
read) message in a room, if there is one, each time
the @code{[N]ew} command is used.  Users with memory problems might
want to answer ``yes'', and use the last old message to remind
them of the discussion.  The first-time default answer
here (during login) is controlled by the @file{ctdlcnfg.sys} parameter
@vindex deflastold
@code{#deflastold}.

@item [P]ause between messages
This option allows a user to specify the @samp{more}
prompt to be automatically used by all message-reading
commands.  @xref{More Mode}, for details about the @samp{more}
prompt.  Note that @samp{more} mode is never the default for file-reading
commands.  Also note that the @samp{more} default can be
overridden using the @samp{~} modifier with @code{.R(ead)}; see
@ref{Multi-key message reading commands}.
The default value to this flag when a new user
signs on is initially
controlled by the @file{ctdlcnfg.sys} parameter
@vindex defreadmore
@code{#defreadmore}.

@item [R]unning count of msgs while reading
This parameter allows a user to tell Fnordadel to
show him/her a running downward count of the number of messages
remaining to be read, while using any message-reading command.
The count is shown in the message header as ``(n left)'', where
``n'' is the number of messages still to be read.  This option's
initial default value for new users is set with the @file{ctdlcnfg.sys}
parameter
@vindex defnumleft
@code{#defnumleft}.

@item [T]- show time of message creation
This option allows the user to control whether
Fnordadel will display message creation times in
message headers, or just creation dates.  The default
here when new users login is set by the @file{ctdlcnfg.sys}
@vindex defshowtime
@code{#defshowtime} parameter.

@item [V]iew configuration
This command does the obvious, and displays the user's
current configuration settings.

@item [W]idth of screen
This is the user's terminal's line width in characters.
Fnordadel imposes a range limit of 10 characters minimum,
255 characters maximum.  Most users these days will have an
80-character screen width.

Due to the way Fnordadel formats
information for display, it's a good idea to set this value to
1 less than the actual width.  Thus an 80-column user would
answer 79.  Doing this prevents the odd spurious blank line
from showing up.  The default value here is whatever the Sysop
has defined as the system's screen width (see @code{width} parameter
in @file{ctdlcnfg.doc}).

@item e[X]it
Another obvious command.  This one exits the menu and
returns the user to the room prompt.  Any changes made in the
menu are updated into the user's log entry.

@item [Y]- set default transfer protocol
This command allows the user to set a default transfer
protocol.  The choice may be made from:  Xmodem, Ymodem and
Wxmodem.  Wxmodem may not be available, since we don't believe
the code works anyway, and have never bothered to fix it.

The protocol specified here will be used with the
@code{[D]ownload}, @code{[U]pload} (if the Sysop has made it available) and
@code{.E(nter) F(ile)} commands.  All are documented in this chapter.
See also @ref{File Transfers}.
The default value used for this option when users first login is ``Xmodem''.
@end table
@comment Now done User Configuration

@node More Mode, Deleting Messages, User Configuration, User Command Reference
@section More Mode
@cindex More mode
@cindex Pausing between messages

As mentioned in @ref{Multi-key read commands}, one of the message-reading
options available is called @code{M(ore)}.  To recap briefly, with
@samp{more} mode, the system pauses after each message displayed by any
of the message-reading commands, to permit the digestion of what was just
read, and/or the entry of a few other commands, without breaking out of
the message-reading sequence.

@code{M(ore)} is used by default by all of the message-reading commands
when the user is in @code{Mail>}.  There is also a user configuration
option that will make the system default to @samp{more} mode all the time, in
all rooms, with both single- and multi-key commands.  @xref{User Configuration}.

Hitting @samp{?} at the @samp{more cmd:} prompt will display a list of
available options:

@cindex More menu
@example
[A]- this message again
[B]ackup to previous message
[D]elete this message
[H]- continue held message
[N]ext message (also <SPACE>, <CR>)
[R]eply to this message
e[X]it message reader (also [Q]uit, [S]top)
@end example

@table @code
@item [A]- this message again
This @code{M(ore)} command will cause the system to
redisplay the message just read, for further critical
examination, or for the short of memory.

@item [B]ackup to previous message
The command backs up one message, and shows
what has gone before.  The command does nothing if
there is no previous message.  Note that if reading
new messages, one can not back up into those that are
old.  The reverse is also true.

@item [D]elete this message
This command allows users to delete messages.
@xref{Deleting Messages}, for more.

@item [H]- continue held message
This @code{M(ore)} command is quite useful, as it
permits the user to jump into the held buffer and add
to a message already in progress.  Once the desired
additions have been made to the message, it can be held
again or saved, and the system will resume the message-reading
cycle where it left off.

@item [N]ext message (also <SPACE>, <CR>)
This command, or its equivalents,
will cause the system to move on to the next message
in the sequence.  When
there are no more messages to be read, the user is
returned to the regular room prompt.  Messages entered
by the user during reading are not shown, if reading in
an old-to-new direction.

@item [R]eply to this message
This command permits the user to start a new
message which will be in reply to the message just
read.  In all rooms except @code{Mail>}, the reply has no
special significance.  In @code{Mail>}, however, the system
will automatically address the new message to the
author of the message to which the user is replying.
As with all messages, the user can @code{[H]old} it if so
desired.  Whether it is held or saved, the system will
return to the message-reading cycle where it left off.

The system may prevent the reply for a variety
of reasons:  the would-be recipient of the message is
no longer in the user log; the message must be netted
to reach the recipient, and the replier doesn't have
net privileges or sufficient l-d credits; the message
must be netted but the system can't recognize the
destination net node; etc.

@item e[X]it message reader (also [Q]uit, [S]top)
This command halts the message-reading cycle
immediately and returns the user to the room prompt.
@end table
@comment End of More options table

There are a few additional @code{M(ore)} commands
available to users with Aide, Co-Sysop or Sysop status.  They permit
moving, copying and journalling messages, and other more
esoteric things.
@xref{Aide message deletion and movement}, @ref{Message journalling},
@ref{Promoting local messages to net messages}, and @ref{Mail receipt flag}.
Also, use of @code{M(ore)} can be negated when the
modifier is used in conjunction with the @samp{~} modifier; see
@ref{Multi-key message reading commands}.

@node Deleting Messages,  , More Mode, User Command Reference
@section Deleting Messages
@cindex Message deletion
@cindex Deleting messages

Users who enter messages may find, from time to time, that it is
necessary to delete one for some reason or other.  Fnordadel permits regular
users to delete messages, with the following restrictions:

@itemize @bullet
@item
A message must have been authored by the user trying to delete it.
@item
A message in a normal room (i.e., not @code{Mail>}) must have been entered
by the user during his or her current login session, to be deletable.
Once the user logs out, all messages in normal rooms become locked.
Only an Aide, Co-Sysop or the Sysop can delete them then.
@item
A message in the @code{Mail>} room can be deleted by the author at any
point, provided that the intended recipient has not read the message
yet.  Fnordadel keeps track of whether @code{Mail>} messages are read or
unread by their recipients; once the recipient has seen the message,
there is no point deleting it.
@end itemize

Assuming that the above restrictions permit a user to delete a given
message, there are two ways to carry out the deletion:

@enumerate
@item
While reading messages normally
@itemize @minus
@item
Use normal message-reading commands (e.g. @code{[N]ew} or @code{[R]everse})
to display the desired message on screen, and @code{[P]ause} the
system somewhere in the body of the target message's text.
@item
While the system is paused, hit @samp{D} for @code{[D]elete}.
@item
The system will resume displaying the message through to its
end, then display a prompt like this:

@example
[D]elete [A]bort?
@end example

@item
To delete the message, hit @samp{D}.  To abort the process, hit @samp{A}.
@end itemize

@item
While reading mesages using @samp{more}
@itemize @minus
@item
Since the above method can be cumbersome, or down-right difficult
in the case of small messages that scroll by before you
can pause the system, users may also select the @code{[D]elete}
command from the @code{.R(ead) M(ore)} prompt.  @xref{More Mode}.
@item
The rest proceeds as above.
@end itemize
@end enumerate
