                         The LysKOM Project
		   ---------------------------------
                  A client written in GNU-emacs lisp.
                   ---------------------------------
              Documentation current to client version 0.34

Copyright (C) 1991 Lysator

Permission is given to copy this manual and distribute the copies,
provided the above copyright notice and this paragraph is retained
on all copies.

The authors of this client are all members of Lysator Academic Computer
Association at the University of Link|ping (LiTH), Sweden.

The principal people currently working on the project are:

Per Cederqvist --- `ceder@lysator.liu.se'
Inge Wallin ---	`ingwa@isy.liu.se' or `inge@lysator.liu.se'
Linus Tolke ---	`linus@lysator.liu.se'

Introduction
************

The purpose of this document is to serve as a complete description of
the elisp client (see below) to enable the full use of its immense power.
A basic knowledge of GNU-emacs is assumed.

Background
**********

LysKOM is a conferencing system inspired by KOM, created by QZ
in Stockholm. This system ran on machines from Digital Equipment, using
the Tops-10 and TOPS-20 operating systems and is, through several
queer permutations and incarnations, available as a commercial system
today, e.g. as EuroCOM.

The reason for the development of LysKOM was that the KOM system
available to Lysator was going to be shut down (actually the machine
KOM was running on). KOM had become an addiction to some people and it was
soon decided that a replacement was necessary. (If you are worried of
becoming addicted to LysKOM you can stop reading here...)

An early decision when we started development was that it should be possible
to provide several different user interfaces, accessing the same database.
Some people want to see a graphical view of the relations between
articles, while others want to keep using their old VT100 terminals.
Another desicion was that the system was going to run under UNIX, since
the future of UNIX seemed bright, combined with the fact that Lysator
members have lots of UNIX experience and Lysator owns several UNIX
computers.

Partly due to these decisions, we chose a server-client model for
the system. A central server stores all articles and the rest of the
data comprising the LysKOM database. A large number of clients can
then connect to this server, concurrently, using TCP/IP networking.

Early on, we started on a client written in C, which was going to be
a true copy of KOM. Many problems were however discovered, which were
bigger than originally thought. The C client is at present not
finished, although it has some rudimentary functionality. The C client
is also called "The TTY client" since it doesn't contain any fancy
screen displays at all and can even be run on old Teletype equipment.

Instead, we started developing a client in elisp to help debug the
server, and this client has since been considerably enlarged and
improved by several different Lysator members. It has proved to be
easy to modify, augment and debug. This document is a basic user guide
for the elisp client.

LysKOM uses the client-server paradigm.

The Server
**********

The server, or database handler, is written in C and runs on
`lysator.liu.se' (IP-number 130.236.254.1). The database is currently
readable for some of Lysator's members, which may seem like a bug but
it's actually a conscious decision; we don't want to give a false
impression of security, since there are too many privileged users on
our machine for us to be able to guarantee high levels of security.
For other server installations the situation is naturally different.

Basics
******

There are different procedures for using LysKOM depending on
the machine you are connecting from. These procedures are all described
below.

>From machines at Lysator

It is easiest to use LysKOM from some of Lysator's UNIX machines
(`lage', `lave', `laila', `leopold', `lysator',
`robert', `robin', `ruben' or `nanny').
When emacs is started, it's enough to type:

             M-x lyskom

to get started. Answer the question on server by simply pressing RET.

>From the student machines at IDA (dept. of CS at LiTH):

Add the line

     (autoload 'lyskom "~d88perce/lyskom" "Start LysKOM" t)

in your `.emacs' file. Restart emacs or read `.emacs' into your
emacs again. Type `M-x lyskom'. When asked about the server, you
answer `obel18' and hold your breath. Don't use IDA's machines if
they are heavily loaded.

>From other machines

Get the client by anonymous FTP to `ftp.lysator.liu.se' (130.236.254.1).
The elisp client is in the directory `pub/lyskom/elisp-client' in
different versions. Make sure to get the newest (highest-numbered) version
and remember to use binary mode to transfer the files.

If emacs says `"Unknown host"' when you are trying to connect, you
must ask your system administrator to add
`130.236.254.1 lysator.liu.se kom.lysator.liu.se' in the system host
table, or relink emacs with `-lresolv' to enable emacs to use
a name server. Unfortunately you can't give IP-numbers to emacs.

If you are on a system where `open-network-stream' is undefined,
you can probably get that function with accompanying programs from the
GNUS distribution and use it with LysKOM.

Getting started with LysKOM
***************************

After answering the question on server and the connection between client
and server is established, you will be asked for your name. It's customary
to enter first and last name, plus some organizational description:

             Inge Wallin, ISY

If your name was unique you will be asked to confirm your spelling and
then be prompted for a password. The password is stored encrypted in the
database.

After a while you will get a window looking like this:

             Recipient: <1> Presentation (av nya) m|ten
             Subject: Inge Wallin, ISY
             --- Write below. Post: C-c C-c, Kill: C-c C-k, Help: C-h m ---
             Name:
             Address:

             Telephone:
             Email-address:

             Other:

Write a short presentation of yourself. You should at least include
your real name (in case you prefer to appear under a pseudonym),
your address, telephone number and email address. This is however not
a strict requirement to get access to the server at Lysator. When you
post your presentation it will be sent to a special conference, where
everyone can read it.

Type C-c C-c to post the article when you are finished.

The Prompt
**********

When LysKOM is ready to accept a new command, a prompt is given.
The prompt may look like:

     Go to next conference -
     Read next article -
     Time -

When you see the prompt you can give a command. Please be nice to the
client and do not bang on your keyboard before you see the prompt. The
client is a sensitive nature, especially during the login phase.

Scrolling
*********

When the text is too large for one screen page, you will see a percentage
figure in the mode line (e.g. I am 17% into this document at the moment).
Press space bar when you have finished reading the current page, and the
next page will be shown.

Commands
********

There are two kinds of commands; those bound to special keys and those
necessary to type out. Most commands can be given both ways. To give
a command using its full name, press `x' (which is supposed to stand
for eXtended command). You will then be prompted for the command
on emacs' message line and pressing `?' will produce a list of
available commands.

The number of commands are steadily increasing. The following commands are
those available in the version give in the title of this document.
First is shown which key the command is (normally) bound to, followed by
the full name to give after typing `x'. There are special
conferences in LysKOM where announcements of new features are
regularly made.

Commands for Reading articles.
==============================

SPC (space bar) or RET

     Performs the default action, i.e. what the prompt says.

LFD (or NEWLINE)

     Same as space bar or RET, but first repositions the cursor on top of the
     screen.

`na'		`(Read) next article'

     Jump to next article and display it. If you were reviewing articles,
     the review information is saved and you can later continue reviewing
     with `rn' (Review next article).

`nc'		`(Go to) next conference'

     Go to the next conference with unread articles. The unread articles in the
     current conference are remembered and the conference is placed last in
     the list of conferences with unread contributions.

`j'		`Skip (all) comments'

     Skip all comments to the currently read article or comment. That is,
     mark them as read without showing them. This is done recursively, so
     that all comments to comments are also removed. (`j' can be thought
     to stand for "Jump" or "Junk" (:-) ).

`o'		`Only (the) last'

     Only show the most recent number of articles. The number of articles
     is prompted for. All other articles are marked as read.

		`Postpone reading'

     You will be prompted for the number of articles you would like to read now,
     and the rest are "forgotten" until your next session.

`M-p'		(No such extended command)

     This command exists to make it easier to find the beginning of the
     current article showed in the buffer.

`M-n'		(No such extended command)

     This is the opposite to the `M-p' command, placing the cursor at
     the end of the current article.

DEL		(No such extended command)

     This command scrolls back to the previous page. SPC scrolls forward
     again.

You can always get help. (Talk about positive affirmations...)

`?'		`Help'

     Describes the special LysKOM mode and all key bindings. You can always
     press `?' in the middle of a command to see the currently available
     alternatives.

Following this paragraph is a list of all commands available for writing
articles.

`m'		`Write (a) letter'

     Write a letter (LysKOM-mail) to a person or a conference. You will be
     prompted for the name. It is possible to send letters to closed conferences,
     even if you are not a participant. If the person/conference has a note
     on the door (see (Post) note (on the) door.

`a'		`Write (an) article'

     Write an article in the conference you are currently present. Please refer
     to the following sections for more informations about command available
     when composing the article.

`c'		`(Write) comment'

     Write a comment to the most currently read (or written) article. To comment
     another article, give the article number before you press `c'.

`C'		`(Write) comment (to) previous article'

     Comments the next most currently read article. This is a handy command
     in case you just did `rc' (`Review (the) commented (article)')
     and then decide to comment.

`F'		`(Write) footnote'

     Write a footnote to the most currently read (or written) article. To comment
     another article, give the article number before you press `F'.
     You can only write footnotes to your own articles.
     (see Footnote.)

`p'		`(Write) personal reply (by letter)'

     Write a personal answer to the author of the latest read article.

These commands provide different kinds of information.

`w'		`Who (is on)'

     Displays a list of the persons currently connected to this LysKOM server.
     Additional information is given on their host and what they are doing.
     The list is sorted according to session number and your own session is
     marked with an asterisk.

`lc'		`List conferences'

     Lists all conferences matching a given string. The string "a" matches all
     conferences with names beginning with "a" (or "A"). You will be prompted
     for the string. Press RET to get a full list of all conferences.  An
     asterisk (`*') is diplayed in front of all conferences of which you
     are not a participant.

`ln'		`List news'

     Lists all conferences containing unread articles, as well as the
     number of articles.

`lu'		`List users'

     Lists all users (persons) matching a given string, exactly as for the
     `List conferences' command.

`ls'		`List subscriptions'

     Lists all conferences you participate in, along with their priority
     and numer of unread articles.

`la'		`List article (subjects)'

     Lists all subject and author of the currently unread articles in the
     present conference, or among your marked articles.

Following is a description on how to join and leave conferences.

`g'		`Go (to) conference'

     Go to a new conference and start reading articles there. You will be prompted
     for the name of the conference.

     In case you aren't a member of the conference, you will be asked if you
     would like to join the conference. An affirmative answer makes you a
     member, exactly in the same way as if you had used the `S' command
     (`Subscribe (to) conference').

`S'		`Subscribe (to) conference'

     Prompts you for a conference and makes you a member. New conferences are
     placed last on the list and with a default priority of `100'. The
     variable controlling the default priority is
     `kom-membership-default-priority'.
     (see kom-membership-default-priority.)

     The variable controlling the placement is
     `kom-membership-default-placement'.
     (see kom-membership-default-placement.)

     You can change both priority and placement of your subscribed conferences
     using the `Prioritize conferences' extended command.

     It is impossible to join closed conferences. In this case, the conference
     creator (or LysKOM administrator) must manually add you to the conference..

		`Unsubscribe (to) conference'

     Prompts you for the name of the conference to which you want to
     unsubscribe. All information about read articles in the conference is
     lost when you unsubscribe. This command isn't normally bound to
     any key.

`q'		`Quit'

     Quits LysKOM. Just exiting Emacs or removing the LysKOM buffer
     works just as well.

Miscellaneous LysKOM commands
=============================

`R'		`Recover'

     Resets a couple of internal data structures in the client. Can be used
     when the client is hung, for some reason, or when the client and the
     server starts disagreeing on the communication protocol. This can happen
     if you press `C-g' during some critical operation in
     the client.

`t'		`Time'

     Shows you the server's notion of the current date and time.

`fp'		`(Please) pat my head'

     Gives you some encouragement.

`fk'		`(Please) kick my butt'

     Could be beneficial when you start admiring your own articles too much.

`W'		`Wait (for news)'

     Enters a busy-wait mode, where the client starts waiting for an article
     in a conference with a higher priority than the current conference. You
     can also specify the desired priority as a prefix argument.

     Exit this mode by typing any command.

		`Display who (list)'

     LysKOM continually keeps track of people using the server and this
     command will display this list in a temporary window. The height of
     this window is governed by the variable
     `kom-who-buffer-size-when-displaying'.
     (see Window size.)

		`Kill session'

     You can kill any session belonging to you, unless you are an Administrator.
     (see Administrator.)
     This could be useful if you forget to log out from another machine than the
     one you are currently running the client on.

You can customize your personal parameters with several different commands.

`Ap'		`Change presentation'

     Changes (Alters) the presentation for a conference or a person. You will be
     prompted for the person/conference. Just pressing RET will change
     your own presentation. You will be placed in an edit window. Just post
     the article as usual when you are finished with the new presentation.

A multitude of commands exist for reviewing articles.
When a review command gives rise to many displayed articles, LysKOM displays
one article and remembers the others on a special "review stack". There
are special commands for handling this review stack too.

`r SPC'		`Review article'

     Review some existing article. You can give an article number right after the
     `r', or you can use `r SPC' which will prompt you for the
     number (defaulting to the most recently read/written).

`rc'		`Review (the) commented (article)'

     Review the (those) article(s) which the just read article is a
     comment to.

`rac'		`Review all comments'

     Review all articles which are comments to the just read article.

`rar'		`Review all comments recursively'

     Review all articles which are comments to the just read article. This is
     done recursively, so that comments to the comments are also reviewed,
     ad infinitum (or until you run out of comments, whichever happens first...).

`ro'		`Review original (article)'

     Review the root article of the current comment-tree.

`rn'		`Review next'

     Reviews the next article in the review stack.

`rl'		`Review last'

     Review some last number of articles by a person. Give the number of articles
     as a prefix argument. Then you will be prompted for the person and
     conference. Answering a prompt with just RET will give you "any"
     person/conference.

     The default number of articles is `1'. If you specify `0' articles,
     you will get all articles. If you specify a negative number, you will
     instead see the first number of articles.

     The conference might be your own mailbox, but you can't use this command to
     review articles from you to another person's mailbox, due to a an overly
     restrictive server. This will however be fixed in the future (maybe it is
     already!).

`rj'		`Review and skip'

     Completely clears the review stack.

`rs'		`Review stack'

     Displays the review stack, which is a result of all active review commands.

`rp'		`Review presentation'

     Prompts you for the name of a person or conference and reviews their
     presentation.

`rr'		`Review tree'

     Review the whole current comment tree all the way down from the root article,
     for the just read article.

`B'		`(Review) Backwards'

     Usually, reviewed articles are presented chronological order. `B' reverses
     the direction to "most recent first". It only reverses the direction for
     the current review stack, though.

With these commands you can retrieve status for persons and conferences.

`sc'		`Status (of) conference'

     Displays some information about a conference. If there's a note on the door
     (see (Post) note (on the) door.

     You will also be asked if you want to see the list of members. Answer `y'
     to get this list, `n' otherwise.

`su'		`Status (of) user'

     Displays some information about a person. If there's a note on the door
     (see (Post) note (on the) door.

     You will also be asked if you want to see the list of subscribed
     conferences.. Answer `y' to get this list, `n' otherwise.

`sa'		`Save article (in file)'

     Save the last read article in a file. You will be prompted for the file
     name and the article will be appended to the file.

You can mark interesting articles so that you may find them easier later.

There is a rather extensive amount of functionality planned for marks (and
provided for in the server) but at the moment only these commands are
available in this client:

`M'		`Mark (article)'

     You are prompted for an article number (the last read is default) and
     the article is marked with a numeric mark.

     If the variable `kom-default-mark' isn't set, the mark is `100'.
     If the variable is `nil', you will be prompted to enter the number
     for the mark. (see kom-default-mark.)

`U'		`Unmark (article)'

     You are prompted for an article number (the last read is default) and the
     mark is removed from that article.

`ram'		`Review all marked (articles)'

     Review all articles previously marked with `Mark (article)'.

`rm'		`Review marked (articles)'

     Prompts you for a numerical mark and reviews only articles with that mark.

The following commands are normally only available under the `x' menu.

`Create conference'

     Create a new conference. You will be prompted to supply some attributes,
     like if it's going to be open to the public or closed.

`Delete conference'

     Delete a conference. You must be the organizer or LysKOM]
     Prompts you for the article number and removes it. You can also give the
     number as a prefix argument.

Commands for adding and subtracting.
====================================

You can add a recipient (or carbon copy recipient) to an article,
a member to a conference or an article as a comment to another article.

`Add recipient'

     Prompts you for the article number and a person or conference, who/which will
     be added to the list of receivers to the article.

`Remove recipient'

     Prompts you for the article number and a person or conference, who/which will
     be removed from the list of receivers to the article.

     Only the organizer for the recipient and the author of the article may
     remove recipients.

`Add comment'

     Prompts you for two article numbers. The first article will be commented
     by the second.

`Remove comment'

     Prompts you for two article numbers. If the first article has the second
     as a comment, this comment link will be removed.

`Add subscriber'

     Prompts you for the person to add and to which conference. This command
     must be used to add members to a closed conference and is only available
     to the organizer of the conference. It can also be used for adding persons
     to other person's mailboxes, enabling the first person to read the
     second person's letters.

`Remove subscriber'

     Prompts you for the person to remove and from which conference.

`New User'

     Log out the current person from LysKOM and start anew, but without starting
     a new session.

`Change name'

     Prompts you for the person or conference that should have the name changed.
     You must be the organizer.

`Change password'

     Prompts you for the person whose password should be changes, as well as
     old and new passwords.

     You can change the password for anything or anyone you organize. The
     LysKOM administrator may change anyone's password.

`(Post) note (on the) door'

     Asks for the person or conference, then opens an edit window for you to
     write the note in.

     The note will be shown to any person who is trying to write an article
     to the person or conference in question. This function might thus be
     useful when you are going away and want to leave a temporary address
     where you can be reached. The note is also displayed by the
     `Status (of) user' command. (see Status (of) user.

`Change organizer'

     Prompts you for the person or conference to change the organizer for, as
     well as the name of the new organizer.

`Change expiration'

     Prompts you for the name of the conference, as well as the new expiration
     time (in days). You must be the organizer or LysKOM administrator.

`Send message'

     Prompts you for the name of the person you want to send a message to,
     as well as for the message to send.

     The message is "asynchronous", which means that it will be immediately
     shown on the recipient's screen. Thus, the recipient must be connected
     to the server. The message isn't stored anywhere in the system.

     To send to all connected users, press RET in reply to the name
     question.

`Prioritize conferences'

     Pops up a new buffer containing a list of all your conferences, in the
     order they are stored in the server. There are some special commands
     available in this buffer to enable convenient customization of conference
     order and priority. Here follows a list of those commands:

     `u'

          Moves the conference upwards. A prefix argument may specify the number
          of positions (default `1').

     `d'

          Moves the conference downwards. A prefix argument may specify the number
          of positions (default `1').

     `p'

          Prompts you for a new priority and assigns it to the conference.

     `C-k'		`Kill'

          Marks the conference as belonging on the "kill" stack. A prefix argument
          may specify the number of conferences to put on the stack (default `1').
          The fact that the conference is on the kill stack is signified by a dash
          in the first position of the line.

     `C-y'		`Yank'

          Takes the first conference on the kill stack (the topmost one) and inserts
          it before the line the cursor is on. Given a prefix argument, that number
          of lines from the kill stack are inserted.

     `q' or `C-c C-c'

          Both of these commands return you to your LysKOM session and the
          client will update your list in the server accordingly.

     `C-k' and `C-y' are well suited for moving blocks of conferences
     to different places. `u' and `d' are useful for the final
     adjustments.

Change options

     Pops up a new buffer listing current values of all switches and variables.
     This works exactly the same as with the standard emacs function
     `edit-options', but it only contains stuff pertinent to LysKOM.
     (see Customizing (emacs).)

     All commands work the same as in the `edit-options' mode and the
     most important are:
     `0'
          Set the value to nil.
     `1'
          Set the value to t.
     `s'
          Lets you set the priority on a conference.
     `n'
          Go to the next variable.
     `p'
          Go to the previous variable.

     When you're satisfied with your configuration and want to save them in
     LysKOM, type `C-c C-c'.

     If you regret your changes and want to throw them away, type `C-c C-k'.

     If you change variable values in some other way than the above mentioned,
     but before you type `C-c C-c', your changes will be saved. On the other
     hand, if you change the values without typing `C-c C-c', they will not
     be saved.

Administer
**********

`Become administrator'

     To be able to use the following commands, you must first become
     administrator with this command. Furthermore, you must have the
     necessary administrative rights in the database for your person.

`Become (normal) user'

     Makes you a normal user again, with no special privileges. Recommended
     when you have finishedd what you were doing, so you, for example, don't
     happen to read articles you are normally not allowed to read, etc.

`Shut down (server)'

     Saves the database and shuts down the server. There might however usually
     be some program which will restart the server again.

`Change login message'

     Changes the login message (message-of-the-day).

`Remove login message'

     Removes the login message (sigh, do we have to write this out? (:-) ).

Names
*****

When specifying a name for a conference or person, it is sufficient to
a unique part of the name. For example, at the moment it's enough to
write `ce' to login as `ceder'. Parts within parentheses aren't
taken into consideration, making `John Doe' equivalent to
`(My names are) John (and) Doe (as last name!)'. Usually, you can also
write `p 10' and `c 10' to refer to person (or conference) number 10.

If the name consists of more than one word, e.g. first and last name, it's
enough to write unique parts of the names. Suppose we have two persons
called `Jane Dawson' and `Jane Dywer'. Then neither `jane' nor
`j d' will determine the name uniquely, but `j da' or `j dy'
will! This rule is also valid for conference names.

Writing Articles
****************

For each article you write you get a new edit buffer. You can write as many
articles you like at the same time and it doesn't matter in which order
you post them. If you loose the connection to the server you can't post
them, of course, but you can save them to a file with the standard file
commands in Emacs and retrieve them later.

Topmost in the buffer are a number of lines specifying recipient(s) and
if the article is a comment to one or more articles. You can change this
header, but be careful. Use the special commands instead of editing
this field yourself, to minimize the risk of corrupting the format.
There are four different optional specifications possible:

     	Recipient: <#> Name
     	Carbon copy: <#> Name
     	Comment to article #.
     	Footnote to article #.

Here, `#' is a decimal number. `Name' is a conference or person name.
When modifying these fields, it's enough that the first two characters and the
number are correct. Note that the number must be inside angle brackets
for the first two lines. A permissible header would thus be:

     	Re<6>
     	Ca<80>
     	Co118
     	Co 148
     	Footnote 12.

This article will have conference `6' as recipient and conference
`80' will receive a carbon copy. The only difference between being a
recipient and receiving a carbon copy is that the recipient will continue
to receive subsequent comments to the article while the `CC' receiver
will not. Note also that conferences and persons share the same number
space so that conference `80' in the above example could just as well be
person `80'.

The article is furthermore a comment to articles `118' and `148'
and even a footnote to article `12'. A footnote and a comment is
basically the same thing, except that only an author may footnote their
own article and that footnotes are showed before all other comments.

The client blindly trusts the number, making the text after the angle brackets
(the conference or person name) irrelevant. (A relephant? Atsa no relephant!)

You can mix the header lines to your full liking, but you mustn't insert
any other kind of line before the `Subject: ' line, not even a
blank line.

So if you want to add another conference or person as a recipient of your
article, you need to know the number, or, preferrably, you use one of
the special commands described below.

After the header lines there must be a `Subject: ' line. It should
look like this:

     	Subject:   - Write your subject here -

When you comment an article, you will inherit its subject line.

After the subject line, there is a line which only purpose is to separate
the headers from the body. You should write your article after this line.

All the standard emacs commands work, but there are also some special
LysKOM commands available:

`C-c C-c'

     To post your article, type `C-c C-c'. LysKOM will ask for the subject,
     enabling you to change it before you post, or accept it and just hit RET.
     When you hit RET the article will be posted. This is done asynchronously
     so you may continue reading while the article is being posted. When the server
     accepts the article, a message will be shown in the buffer.

     If you change your mind after typing `C-c C-c' but before pressing the
     final RET, you can type `C-g' to be able to continue writing.

`C-c C-k' or `C-c k'

     If you change your mind about writing an article, you can quit with
     `C-c C-k' or `C-c k'. The edit buffer will be removed and you
     returned to the LysKOM buffer.

`C-c i c' and `C-c i'

     If you would like to insert parts of the article you are commenting in
     your own article, type `C-c i c'. The article will be inserted
     with an `>' on the beginning of every line. If you want to insert
     an arbitrary article, type `C-c i' followed by the article number.

`C-c r c'

     If you just want to look at the commented article again, type `C-c r c'.
     It will place the article in its own window, with the headers removed to
     save space. Note that you can get approximately this behaviour default
     by setting the switch `kom-write-texts-in-window' to `'other'.
     See more about this below.

`C-c a r' and `C-c a c'

     If you want to add extra recipients or carbon copy receivers, use these
     two commands. They are preferrable to editing the header yourself.
     You will be prompted for the conference or person to add.

The Who buffer
**************

`Display who (list)'

     The elisp client continuously updates a list of all users connected to the
     server and what they are presently doing, in the Who buffer. Use the
     command `Display who (list)' to show it on your screen.

Switches
********

The client has a number of switches and variables for making customization
simple and straightforward. The difference between switches and variables
in the elisp client is mostly academic. Switches can only contain values
>from a (small) predefined set. Otherwise they are handled the same way
as variables.

The switches and variables are changed with the `Change options'.
(see Change options.)  (Note, that if you instead
use the built-in Emacs function `M-x set-variable' the value will
not be retained between different client invocations). Following is a list of
switches, their possible values and how they affect the client.

This is the layout: First the switch name, followed by the default value.
Then the different possible values are discussed in the following text.

Switches are marked with `common' or `elisp' depending on which
part of the user area they are saved in.

`kom-created-texts-are-read'		`t' (`common')

     All articles created by yourself are marked read if this is non-`nil'.

`kom-reading-puts-comments-in-pointers-last'	`t' (`common')

     If the switch is `nil', lines like `Comment in article N by NN'
     are placed in the article header. Otherwise following the end of the article.

`kom-print-number-of-unread-on-entrance'		`t'

     When the switch is non-`nil' the number of unread articles are
     printed immediately when you enter a new conference.

`kom-higher-priority-breaks'		`nil' (`elisp')

     This switch controls how a new article in a conference with higher priority
     than the present should interrupt the reading sequence. This interruption
     is either notified by `Read next prioritized article' or
     `Go to next prioritized conference' as the new prompt. After the first
     prompt, you will, after reading the prioritized article, return to exactly
     the place where you left off reading.
     `nil'
          Will break only after you are through with the current conference.
     `t'
          Will break as soon as you have read through the current comment
          chain. That is, when the next prompt would have been `Read next article'.
     `express'
          Will break immediately, regardless of what you are reading.

`kom-default-mark'		`100' (`common')

     Unless this switch is `nil', it must be a number between `1' and
     `255'. This is then the default mark articles will get when marked. If
     the switch is `nil' the client will ask for the mark each time you
     mark an article. (Note: marking will be more flexible in the future).

`kom-presence-messages'		`t' (`common')

     When non-`nil' the client will report about people entering and
     leaving LysKOM.

`kom-presence-messages-in-buffer'		`presence' (`elisp')

     This switch governs which LysKOM messages should be entered in the
     buffer. The normal behaviour is that messages are displayed on the message line.
     You can also get messages both in the buffer and the message line. This
     switch may take on three values:
     `nil'
          No presence messages should be displayed.
     `presence'
          Presence messages are written in the buffer. All other
          messages are only displayed on the mode line.
     `t'
          All messages are written in the buffer. This includes
          presence messages as well as what people who are in the same conference as
          yourself are doing.

`kom-show-where-and-what'		`t' (`elisp')

     This switch controls the `Who (is on)' command. If the switch is
     non-`nil' the client will display from which machine a user is
     logged-on as well as what she is doing. (see Who (is on).)

`kom-read-depth-first'		`t' (`common')

     If `nil', then comment trees are displayed breadth-first. Otherwise
     they are displayed depth-first, i.e. comments and footnotes are always
     displayed before new articles.

`kom-dashed-lines'			`t' (`common')

     If the switch is non-`nil' the client will frame the article body
     with two dashed (`-') lines.

`kom-confirm-multiple-recipients'		`t' (`elisp')

     vindex{`kom-confirm-multiple-recipients'}
     If you comment an article with several recipients, the client will ask you
     about each recipient if this switch is non-`nil'.

`kom-emacs-knows-iso-8859-1'		`nil'

     If this switch is `nil' then all characters will be converted to
     "swedish ascii". Otherwise they will be undisturbed. This switch is different
     >from all the other ones in that it is never stored in the server, but only
     local to your Emacs.

Variables
*********

There are also a number of variables for customizing the client's behaviour.
As variables, they can have almost any value. Variables are changed and
saved the same way as switches.

Variables are marked with `common' or `elisp' depending on where
they are stored in the user area.

`kom-mercial'				`"Is waiting.'" (`elisp')

     This variable contains the string which is your "activity" message when
     you have finished reading all unread articles. You are urged to use your
     humour and creativity in customizing this variable...

`kom-page-before-command'		`nil' (`elisp')

     If this variable is `t' the client will do a `(recenter 0)' before
     each command execution. If this variable contains a list of commands, the
     client will perform a `(recenter 0)' before executing any command
     in this list. (Note: using LFD to execute the default command always
     does a `(recenter 0)' regardless of this variable).

`kom-write-texts-in-window'		`nil' (`elisp')

     If the switch is `nil' the LysKOM Emacs window is also used to display
     the edit buffer. If the switch contains a buffer or a string, the window
     this buffer is showed in will be used. If the value is `'other' then
     Emacs will select another window than the LysKOM window, or create a
     new window if necessary.

`kom-membership-default-priority'	`100' (`elisp')

     The default priority all newly joined conferences will have. If it is
     set to `nil' then LysKOM will ask you for a priority each time
     you join a new conference.

`kom-membership-default-placement'	`last' (`elisp')

     Governs the placement of newly joined conferences, in your list of all
     subscribed conferences. As mentioned before, the order of the conferences
     in this list is the order you will read them.

     The switch might take on the following values:

     `first'
          New conferences are inserted first.
     `last'
          New conferences are inserted last.
     a number
          New conferences will be inserted at this position. The number
          `0' means the same as `first' while a *very large* number
          will have the same effect as `last'.

`lyskom-header-separator'			(`elisp')

     This is the string separating the article header from the body when
     writing articles. Default value:
     `"--- Write below. Post:C-c C-c, Kill:C-c C-k, Help: C-h m ---"'

`lyskom-prompt-text'			`" - "' (`elisp')

     The prompt will end with the text in this variable.

`lyskom-prompt-executing-default-command-text'`"."' (`elisp')

     When choosing to execute the default command (with SPC, LFP or
     RET) the last part of the prompt is changed to this string.

`kom-who-buffer-size-when-displaying'	`10' (elisp)

     The number of screen lines to set aside for the Who buffer, when displayed
     by the `Display who (list)' command.

`kom-do-when-starting'			`nil' (`elisp')

     This variable may contain commands to be automatically executed at the
     time of login. The value should be a list of commands.

     Suppose you set `kom-do-when-starting' to `("w" "ln")' - then each
     time you login, the client will first list the present users and then
     give you a list of your unread articles.

`kom-do-when-done'			`("}am" "t")' (`elisp')

     This variable may contain commands to be executed when you have finished
     reading all unread articles. Each command in the list first displays
     a prompt, where naturally all normal commands are available.

     If an element is `kom-do-when-done' is a list, then the elements in this
     list are executed one-by-one. The last element in `kom-do-when-done'
     will be repeated until you exit LysKOM.

     A small example may clarify matters:

     If you set `kom-do-when-done' to:

          ("ram" "t" ("q" "fp"))

     then, supposing you press SPC to each prompt, the following will happen:

          (Read) next article -      ; This is the last unread article
               <The article is displayed here>
          Review all marked (articles) -
          Review next article -      ; We only have one marked article
               <The article is displayed here>
          Se tiden -                 ; Before we have time to press SPC here,
                                     ; a new article is created and the prompt
                                     ; immediately changes to...
          Read next article -
               <The article is displayed here>
          Time -                     ; We have read the article and choose to see the time
          Quit -                     ; Answer no.
          Command:"fp" -             ; Keyboard macro
                                     ; You will get a pat on your head here.
          Quit -                     ; Quit appears again.
                                     ; We answer no a second time.
          Command:"fp"               ; And "fp" appears again.
          Quit -                     ; And quit again...

     The elements have to by LysKOM commands, i.e. they must be possible to
     interpret as keyboard macros or as Emacs functions.

`lyskom-fetch-map-nos'			`50' (`elisp')

     Decides how large maps to fetch at a time. (You're not supposed to
     understand this).

`lyskom-prefetch-conf-tresh'		`50' (`elisp')

     If the number of unread articles in the currently fetched conferences
     is smaller than this number, the client will fetch another batch.

`lyskom-prefetch-confs'			`10' (`elisp')

     Decides how many conferences to fetch at a time.

`lyskom-prefetch-texts'			`3' (`elisp')

     Decides how many articles to prefetch.

Hooks
*****

There are a number of hooks in the elisp client. A hook is a variable that
the user can define to be a function. Each hook is connected to some special
client feature and if the hook is set, the function will be executed when
this feature is activated. For further information about hooks, please
refer to the Emacs documentation. (see Hooks (elisp).)

The hooks are marked with `common' or `elisp' depending on where
in the user area they are saved.

`lyskom-init-hook'

     This hook will be called after the client is loaded. Could be used to
     redefine LysKOM functions or load your own functions.

`lyskom-mode-hook'

     Will be called when the LysKOM buffer is created. Could be used for
     making your own key bindings, local to this buffer.

`lyskom-new-text-hook' (`elisp')

     Will be called when the client gets a message that a new article has been
     created. The article will first be inserted into all internal structures and
     registered, followed by removal of the prompt. Then this hook will be
     called. Lastly, the new prompt will be output. This enables the hook to
     e.g. rearrange the articles or take some other action, which might
     give another prompt than the default.

     If you don't want the client to output the message `Article 4711 is created',
     you have to set the local variable `no-message' to something other
     than `nil' in this hook. You can also make use of the fact that the
     local variable `text-stat' is bound to the status of the article which
     was responsible for the execution of the hook.

`lyskom-who-info-has-changed-hook' (`elisp')

     Will be called each time something in the Who buffer is changed. Please note,
     though, that the current buffer is the LysKOM buffer, not the Who buffer.
     The hook might be used to e.g. pop up the Who buffer each time a friend
     of yours enters LysKOM.

`lyskom-edit-mode-mode-hook'

     Will be called when you are about to write an article. Could be used to
     change the major mode in the edit buffer. LysKOM will always rebind
     some keys to make it possible to post the article but otherwise you are
     free to set the mode to your liking.

     Example:

          (setq lyskom-edit-mode-mode-hook 'swedish-mode)

     In this example it is assumed that `swedish-mode' exists.

     If you rebind keys to generate alternate characters, they will not only
     be valid in this buffer, but also in the minibuffer when the client asks
     for the subject.

`lyskom-edit-mode-hook'

     Will be called after the client has performed all initializations, but
     before you are allowed to start writing the text. Here you might put
     things you want to do to the edit buffer. Maybe turn off `auto-save-mode'
     or set the `fill-column'.

     Not to be confused with `lyskom-edit-mode-mode-hook'.

`lyskom-prioritize-mode-hook'

     Will be called when the prioritize buffer is created. Maybe you want to
     have private functions loaded or other keyboard bindings in this mode.

`kom-quit-hook'

     Will be called when your LysKOM session is terminated. E.g. if you also
     want to kill your Emacs.

Environment Variables
*********************

`KOMSERVER'
     Default LysKOM server. If `KOMSERVER' is set
     then the user doesn't have to specify which server to
     use at the first login. Otherwise, the default server is probably
     `kom.lysator.liu.se'.

`KOMNAME'
     Default user name. If `KOMNAME' is set, the
     client will not ask for your name at login.

`KOMPASSWORD'
     Default password. If `KOMPASSWORD' is set,
     the client will not ask for your password.
     It is not very appropriate to have `KOMPASSWORD' set without having
     `KOMNAME' set. Please observe that on certain UNIX systems anyone
     might view the settings of your environment variables with `ps -axeww'.

Bug Reports
***********

There are probably still some bugs in the client. If you encounter something
which should work differently, or not working at all, please write a
report and mail it to `bug-lyskom@lysator.liu.se'. In fact, you can
send any kinds of comments to this address.

A bug report should contain information about:

Which emacs you run. Name and version number.

Which version of the elisp client you run.

Which LysKOM server you have connected to and its version number.

It is important that the bug report contains all available information
on your actions, so run `kom-compile-bug-report' and send the result
to the above address. If you don't run this function you need to describe
the problem extremely thorough for us to be able to make use of your report.

In case you find and fix the problem yourself, please send a context diff.

Files
*****

`lysator:/usr/local/lib/elisp/lyskom.el'
     Latest version of the client.
`lysator:~ftp/pub/lyskom/elisp-client/lyskom-ver.nr.elc'
     Ditto.

Happy hacking!

     /ceder

     /Inge

     /Linus