This is Info file ../info/hyperbole.info, produced by Makeinfo-1.63
from the input file hyperbole.texi.


File: hyperbole.info,  Node: Outliner Keys,  Next: Suggestion or Bug Reporting,  Prev: Smart Key Reference,  Up: Top

Outliner Keys
*************

   This appendix summarizes the specialized key bindings available when
editing an outline with Hyperbole.  Each key is shown together with its
command binding and the documentation for that command.  Normal emacs
editing keys are modified to account for the structure within outlines.
An outliner command which overloads an Emacs command named *cmd* would
be named *kotl-mode:cmd*.

`kfile:write  {`C-x C-w'}'
     Write current outline to FILE.

`klink:create  {`C-c l'}'
     Insert at point an implicit link to REFERENCE.  REFERENCE should
     be a cell-ref or a string containing "filename, cell-ref".  See
     documentation for `kcell:ref-to-id' for valid cell-ref formats.

`kotl-mode:add-cell  {LFD}'
     Add a cell following current cell at optional RELATIVE-LEVEL with
     CONTENTS string.  Optional prefix arg RELATIVE-LEVEL means add as
     sibling if nil or >= 0, as child if equal to universal argument,
     `C-u', and as sibling of current cell's parent, otherwise.  If
     added as sibling of current level, RELATIVE-LEVEL is used as a
     repeat count for the number of cells to add.

     Return last newly added cell.

`kotl-mode:add-child  {`C-c a'}'
     Add a new cell to current kview as first child of current cell.

`kotl-mode:add-parent  {`C-c p'}'
     Add a new cell to current kview as sibling of current cell's
     parent.

`kotl-mode:append-cell  {`C-c +'}'
     Append CONTENTS-CELL to APPEND-TO-CELL.  APPEND-TO-CELL is
     refilled if neither cell has a no-fill property and
     kotl-mode:refill-flag is enabled.

`kotl-mode:back-to-indentation  {`M-m'}'
     Move point to the first non-read-only non-whitespace character on
     this line.

`kotl-mode:backward-cell  {`C-c C-b'}'
     Move to prefix ARGth prior cell (same level) within current view.
     Return number of cells left to move.

`kotl-mode:backward-char  {`C-b'}'
     Move point backward ARG (or 1) characters and return point.

`kotl-mode:backward-kill-word  {`M-DEL'}'
     Kill up to prefix ARG words preceding point within a single cell.

`kotl-mode:backward-sentence  {`M-a'}'
     Move point backward ARG (or 1) sentences and return point.

`kotl-mode:backward-word  {`M-b'}'
     Move point backward ARG (or 1) words and return point.

`kotl-mode:beginning-of-buffer  {`M-<'}'
     Move point to beginning of buffer and return point.

`kotl-mode:beginning-of-cell  {`C-c ,'}'
     Move point to beginning of current or ARGth - 1 prior cell and
     return point.

`kotl-mode:beginning-of-line  {`C-a'}'
     Move point to beginning of current or ARGth - 1 line and return
     point.

`kotl-mode:beginning-of-tree  {`C-c ^'}'
     Move point to the level 1 root of the current cell's tree.  Leave
     point at the start of the cell.

`kotl-mode:center-line  {`M-s'}'
     Center the line point is on, within the width specified by
     FILL-COLUMN.  This means adjusting the indentation so that it
     equals the distance between the end of the text and FILL-COLUMN.

`kotl-mode:center-paragraph  {`M-S'}'
     Center each nonblank line in the paragraph at or after point.  See
     `center-line' for more info.

`kotl-mode:copy-after  {`C-c c'}'
     Copy tree rooted at FROM-CELL-REF to follow tree rooted at
     TO-CELL-REF.  If prefix arg CHILD-P is non-nil, make FROM-CELL-REF
     the first child of TO-CELL-REF, otherwise make it the sibling
     following TO-CELL-REF.

     Leave point at the start of the root cell of the new tree.

`kotl-mode:copy-before  {`C-c C-c'}'
     Copy tree rooted at FROM-CELL-REF to precede tree rooted at
     TO-CELL-REF.  If prefix arg PARENT-P is non-nil, make
     FROM-CELL-REF the first child of TO-CELL-REF's parent, otherwise
     make it the preceding sibling of TO-CELL-REF.

     Leave point at the start of the root cell of the new tree.

`kotl-mode:copy-to-buffer  {`C-c M-c'}'
     Copy outline tree rooted at CELL-REF to a non-koutline BUFFER.
     Use 0 to copy the whole outline buffer.

`kotl-mode:copy-to-register  {`C-x x'}'
     Copy into REGISTER the region START to END.  With optional prefix
     arg DELETE-FLAG, delete region.

`kotl-mode:delete-backward-char  {`DEL'}'
     Delete up to the preceding prefix ARG characters.  Return number
     of characters deleted.  Optional KILL-FLAG non-nil means save in
     kill ring instead of deleting.  Does not delete across cell
     boundaries.

`kotl-mode:delete-blank-lines  {`C-x C-o'}'
     On blank line within a cell, delete all surrounding blank lines,
     leaving just one.  On isolated blank line, delete that one.  On
     nonblank line, delete all blank lines that follow it.

     If nothing but whitespace follows point until the end of a cell,
     delete all whitespace at the end of the cell.

`kotl-mode:delete-char  {`C-d'}'
     Delete up to prefix ARG characters following point.  Return number
     of characters deleted.  Optional KILL-FLAG non-nil means save in
     kill ring instead of deleting.  Does not delete across cell
     boundaries.

`kotl-mode:delete-indentation  {`M-^'}'
     Join this line to previous and fix up whitespace at join.  If
     there is a fill prefix, delete it from the beginning of this line.
     With argument, join this line to following line.

`kotl-mode:demote-tree  {`TAB'}'
     Move current kotl a maximum of prefix ARG levels lower in current
     view.  Each cell is refilled iff its *no-fill* attribute is nil and
     KOTL-MODE:REFILL-FLAG is non-nil.  With prefix ARG = 0, cells are
     demoted up to one level and kotl-mode:refill-flag is treated as
     true.

`kotl-mode:down-level  {`C-c C-d'}'
     Move down prefix ARG levels lower within current tree.

`kotl-mode:end-of-buffer  {`M->'}'
     Move point to end of buffer and return point.

`kotl-mode:end-of-cell  {`C-c .'}'
     Move point to end of current or ARGth - 1 succeeding cell and
     return point.

`kotl-mode:end-of-line  {`C-e'}'
     Move point to end of current or ARGth - 1 line and return point.

`kotl-mode:end-of-tree  {`C-c $'}'
     Move point to the last cell in tree rooted at the current cell.
     Leave point at the start of the cell.

`kotl-mode:exchange-cells  {`C-c e'}'
     Exchange CELL-REF-1 with CELL-REF-2 in current view.  Don't move
     point.

`kotl-mode:fill-cell  {`C-c M-j'}'
     Fill current cell within current view if it does not have the
     'no-fill attribute.  With optional JUSTIFY, justify cell as well.
     IGNORE-COLLAPSED-P is used when caller has already expanded cell,
     indicating it is not collapsed.

`kotl-mode:fill-paragraph  {`C-x f'}'
     Fill current paragraph within cell.  With optional JUSTIFY, justify
     paragraph as well.  Ignore any non-nil no-fill attribute attached
     to the cell.

`kotl-mode:fill-tree  {`C-M-j'}'
     Refill each cell within the tree whose root is at point.

`kotl-mode:first-sibling  {`C-c <'}'
     Move point to the first sibling of the present cell.  Leave point
     at the start of the cell or at its present position if it is
     already within the first sibling cell.

`kotl-mode:fkey-backward-char  {`left'}'
     Move point backward ARG (or 1) characters and return point.

`kotl-mode:fkey-forward-char  {`right'}'
     Move point forward ARG (or 1) characters and return point.

`kotl-mode:fkey-next-line  {`down'}'
     Move point to ARGth next line and return point.

`kotl-mode:fkey-previous-line  {`up'}'
     Move point to ARGth previous line and return point.

`kotl-mode:forward-cell  {`C-c C-f'}'
     Move to prefix ARGth following cell (same level) within current
     view.  Return number of cells left to move.

`kotl-mode:forward-char  {`C-f'}'
     Move point forward ARG (or 1) characters and return point.

`kotl-mode:forward-para  {`M-n'}'
     Move to prefix ARGth next cell (any level) within current view.

`kotl-mode:forward-paragraph  {`M-]'}'
     Move to prefix ARGth next cell (any level) within current view.

`kotl-mode:forward-sentence  {`M-e'}'
     Move point forward ARG (or 1) sentences and return point.

`kotl-mode:forward-word  {`M-f'}'
     Move point forward ARG (or 1) words and return point.

`kotl-mode:goto-cell  {`C-c g'}'
     Move point to start of cell given by CELL-REF.  (See
     'kcell:ref-to-id'.) Return point iff CELL-REF is found within
     current view.  With a prefix argument, CELL-REF is assigned the
     argument value for use as an idstamp.

     Optional second arg, ERROR-P, non-nil means signal an error if
     CELL-REF is not found within current view.  Will signal same error
     if called interactively when CELL-REF is not found.

`kotl-mode:hide-sublevels  {`C-X $'}'
     Hide all cells in outline at levels deeper than LEVELS-TO-KEEP (a
     number). Shows any hidden cells within LEVELS-TO-KEEP.  1 is the
     first level.

`kotl-mode:hide-subtree  {`C-M-h'}'
     Hide subtree, ignoring root, at optional CELL-REF (defaults to
     cell at point).

`kotl-mode:hide-tree  {`C-c BS'}'
     Collapse kotl rooted at optional CELL-REF (defaults to cell at
     point).

`kotl-mode:insert-file  {`C-x i'}'
     Insert each paragraph in IMPORT-FROM as a separate cell in the
     current view.  Insert as sibling cells following the current cell.
     IMPORT-FROM may be a buffer name or file name (file name
     completion is provided).

`kotl-mode:insert-register  {`C-c r i'}'
     Insert contents of register REGISTER at point in current cell.
     REGISTER is a character naming the register to insert.  Normally
     puts point before and mark after the inserted text.  If optional
     second arg is non-nil, puts mark before and point after.
     Interactively, second arg is non-nil if prefix arg is supplied.

`kotl-mode:just-one-space  {`M-\'}'
     Delete all spaces and tabs around point and leave one space.

`kotl-mode:kcell-help  {`C-c h'}'
     Display a temporary buffer with CELL-REF's properties.  CELL-REF
     defaults to current cell.  Optional prefix arg CELLS-FLAG selects
     the cells to print:   If = 1, print CELL-REF's cell only;   If >
     1, print CELL-REF's visible kotl (the tree rooted at CELL-REF);
     If < 1, print all visible cells in current view  (CELL-REF is not
     used).

     See also the documentation for `kotl-mode:properties'.

`kotl-mode:kill-contents  {`C-c k'}'
     Kill contents of cell from point to cell end.  With prefix ARG,
     kill entire cell contents.

`kotl-mode:kill-line  {`C-k'}'
     Kill ARG lines from point.

`kotl-mode:kill-region  {`C-w'}'
     Kill region between START and END within a single kcell.  With
     optional COPY-P equal to 't, copy region to kill ring but does not
     kill it.  With COPY-P any other non-nil value, return region as a
     string without affecting kill ring.

     If the buffer is read-only and COPY-P is nil, the region will not
     be deleted but it will be copied to the kill ring and then an
     error will be signaled.

`kotl-mode:kill-ring-save  {`M-w'}'
     Copy region between START and END within a single kcell to kill
     ring.

`kotl-mode:kill-sentence  {`M-k'}'
     Kill up to prefix ARG (or 1) sentences following point within a
     single cell.

`kotl-mode:kill-tree  {`C-c C-k'}'
     Kill ARG following trees starting with tree rooted at point.  If
     ARG is not a non-positive number, nothing is done.

`kotl-mode:kill-word  {`M-d'}'
     Kill up to prefix ARG words following point within a single cell.

`kotl-mode:last-sibling  {`C-c >'}'
     Move point to the last sibling of the present cell.  Leave point
     at the start of the cell or at its present position if it is
     already within the last sibling cell.

`kotl-mode:mail-tree  {`C-c @'}'
     Mail outline tree rooted at CELL-REF.  Use "0" for whole outline
     buffer.

`kotl-mode:move-after  {`C-c m'}'
     Move tree rooted at FROM-CELL-REF to follow tree rooted at
     TO-CELL-REF.  If prefix arg CHILD-P is non-nil, make FROM-CELL-REF
     the first child of TO-CELL-REF, otherwise make it the sibling
     following TO-CELL-REF.  With optional COPY-P, copies tree rather
     than moving it.

     Leave point at original location but return the tree's new start
     point.

`kotl-mode:move-before  {`C-c RET'}'
     Move tree rooted at FROM-CELL-REF to precede tree rooted at
     TO-CELL-REF.  If prefix arg PARENT-P is non-nil, make
     FROM-CELL-REF the first child of TO-CELL-REF's parent, otherwise
     make it the preceding sibling of TO-CELL-REF.  With optional
     COPY-P, copies tree rather than moving it.

     Leave point at original location but return the tree's new start
     point.

`kotl-mode:newline  {`RET'}'
     Insert a newline.  With ARG, insert ARG newlines.  In Auto Fill
     mode, if no numeric arg, break the preceding line if it is too
     long.

`kotl-mode:next-cell  {`C-c C-n'}'
     Move to prefix ARGth next cell (any level) within current view.

`kotl-mode:next-line  {`C-n'}'
     Move point to ARGth next line and return point.

`kotl-mode:open-line  {`C-o'}'
     Insert a newline and leave point before it.  With arg N, insert N
     newlines.

`kotl-mode:overview  {`C-c C-o'}'
     Show only the first line of each cell in the current outline.

`kotl-mode:previous-cell  {`C-c C-p'}'
     Move to prefix ARGth previous cell (any level) within current view.

`kotl-mode:previous-line  {`C-p'}'
     Move point to ARGth previous line and return point.

`kotl-mode:promote-tree  {`M-TAB'}'
     Move current kotl a maximum of prefix ARG levels higher in current
     view.  Each cell is refilled iff its *no-fill* attribute is nil and
     KOTL-MODE:REFILL-FLAG is non-nil.  With prefix ARG = 0, cells are
     promoted up to one level and kotl-mode:refill-flag is treated as
     true.

`kotl-mode:scroll-down  {`M-v'}'
     Scroll text of current window downward ARG lines; or a windowful
     if no ARG.

`kotl-mode:scroll-up  {`C-v'}'
     Scroll text of current window upward ARG lines; or a windowful if
     no ARG.

`kotl-mode:set-cell-attribute  {`C-c C-i'}'
     Include ATTRIBUTE VALUE with the current cell or the cell at
     optional POS.  Replaces any existing value that ATTRIBUTE has.
     When called interactively, it displays the setting in the
     minibuffer as confirmation.

`kotl-mode:set-fill-prefix  {`C-x l'}'
     Sets fill prefix to line up to point.  With prefix arg TURN-OFF or
     at begin of line, turns fill prefix off.

`kotl-mode:show-all  {`C-c C-a'}'
     Show (expand) all cells in current view.

`kotl-mode:show-subtree'
     Show subtree, ignoring root, at optional CELL-REF (defaults to
     cell at point).

`kotl-mode:show-tree  {`C-c C-s'}'
     Display fully expanded kotl rooted at CELL-REF.

`kotl-mode:split-cell  {`C-c s'}'
     Split cell into two cells and move to new cell.  Cell contents
     after point become part of newly created cell.  Default is to
     create new cell as sibling of current cell.  With optional
     universal ARG, `C-u', new cell is added as child of current cell.

`kotl-mode:top-cells  {`C-c C-t'}'
     Collapse all level 1 cells in view and hide any deeper sublevels.

`kotl-mode:transpose-cells  {`C-c t'}'
     Exchange current and previous visible cells, leaving point after
     both.  If no previous cell, exchange current with next cell.  With
     prefix ARG, take current cell and move it past ARG cells.  With
     prefix ARG = 0, interchange the cell that contains point with the
     cell that contains mark.

`kotl-mode:transpose-chars  {`C-t'}'
     Interchange characters around point, moving forward one character.
     With prefix ARG, take character before point and drag it forward
     past ARG other characters (backward if ARG negative).  If no
     prefix ARG and at end of line, the previous two characters are
     exchanged.

`kotl-mode:transpose-lines  {`C-x C-t'}'
     Exchange current line and previous line, leaving point after both.
     If no previous line, exchange current with next line.  With prefix
     ARG, take previous line and move it past ARG lines.  With prefix
     ARG = 0, interchange the line that contains point with the line
     that contains mark.

`kotl-mode:transpose-words  {`M-t'}'
     Interchange words around point, leaving point after both words.
     With prefix ARG, take word before or around point and drag it
     forward past ARG other words (backward if ARG negative).  If ARG
     is zero, the words around or after point and around or after mark
     are interchanged.

`kotl-mode:up-level  {`C-c C-u'}'
     Move up prefix ARG levels higher in current outline view.

`kotl-mode:yank  {`C-y'}'
     Reinsert the last stretch of killed text.  More precisely,
     reinsert the stretch of killed text most recently killed OR
     yanked.  Put point at end, and set mark at beginning.  With just
     C-u as argument, same but put point at beginning (and mark at end).
     With argument N, reinsert the Nth most recently killed stretch of
     killed text.  See also the command M-x kotl-mode:yank-pop.

`kotl-mode:yank-pop  {`M-y'}'
     Replace just-yanked stretch of killed text with a different
     stretch.  This command is allowed only immediately after a `yank'
     or a `yank-pop'.  At such a time, the region contains a stretch of
     reinserted previously-killed text.  `yank-pop' deletes that text
     and inserts in its place a different stretch of killed text.

     With no argument, the previous kill is inserted.  With argument N,
     insert the Nth previous kill.  If N is negative, this is a more
     recent kill.

     The sequence of kills wraps around, so that after the oldest one
     comes the newest one.

`kotl-mode:zap-to-char  {`M-z'}'
     Kill up to and including prefix ARG'th occurrence of CHAR.  Goes
     backward if ARG is negative; error if CHAR not found.

`kview:set-label-type  {`C-c C-l'}'
     Change kview's label display type to NEW-TYPE, updating all
     displayed labels.  See documentation for variable,
     kview:default-label-type, for valid values of NEW-TYPE.

`kvspec:activate  {`C-c C-v'}'
     Activate optional VIEW-SPEC or existing view spec in the current
     koutline.  VIEW-SPEC is a string.  See
     <${hyperb:dir}/kotl/EXAMPLE.kotl, 2b17=048> for details on valid
     view specs.

`kvspec:toggle-blank-lines {`C-c b'}'
     Toggle blank lines between cells on or off.


File: hyperbole.info,  Node: Suggestion or Bug Reporting,  Next: Questions and Answers,  Prev: Outliner Keys,  Up: Top

Suggestion or Bug Reporting
***************************

   *Note Mail Lists::, for complete details on Hyperbole mailing lists
and how to subscribe.

   If you find any errors in Hyperbole's operation or documentation,
feel free to report them to the Hyperbole discussion list:
<hyperbole@hub.ucsb.edu>.  Be sure to use the Msg/Compose-Hypb-Mail
minibuffer menu item whenever you send a message to the mail list since
it will insert important system version information for you.

   If you use Hyperbole mail or news support, *Note Buttons in Mail::, a
click with your Action Key on the Hyperbole mail list address will
insert a description of your Hyperbole configuration information into
your outgoing message, so that you do not have to type it.  This is
useful when composing a reply for the Hyperbole mail list.  Otherwise,
be sure to include your Emacs, Hyperbole and window system versions in
your message.  Your Hyperbole version number can be found in the
top-level Hyperbole menu.

   Please use your subject line to state the position that your message
takes on the topic that it addresses, e.g. send "Subject: Basic bug in
top-level Hyperbole menu." rather than "Subject: Hyperbole bug".  This
simple rule makes all e-mail communication much easier.

   If you have suggestions on how to improve Hyperbole, send them to the
same address.  Here are some issues you might address:

   * What did you like and dislike about the system?

   * What kinds of tasks, if any, does it seem to help you with?

   * What did you think of the Emacs-based user interface?

   * How was the Hyperbole Manual and other documentation?

   * Was the setup trivial, average or hard?

   * What areas of Hyperbole would you like to see expanded/added?

   * How does it compare to other hypertext tools you have used?

   * Was it easy or difficult to create your own types?  Why?

   * Did you get any use out of the external system encapsulations?


File: hyperbole.info,  Node: Questions and Answers,  Next: Future Work,  Prev: Suggestion or Bug Reporting,  Up: Top

Questions and Answers
*********************

*How can I change the Smart Mouse Key bindings?*
     Since the Smart Mouse Keys are set up for use under five different
     Emacs configurations, there is no easy way to provide user level
     customization.  The command, `hmouse-shift-buttons', can be used to
     select between shifted and unshifted Smart Mouse Keys.  Any other
     mouse key binding changes must be done by editing the
     `hmouse-setup' and `hmouse-get-bindings' functions in the
     `hmouse-sh.el' and `hmouse-reg.el' files.

     The HKEY-ALIST and HMOUSE-ALIST variable settings in
     `hui-mouse.el' and `hui-window.el' must be altered if you want to
     change what the Smart Keys do in particular contexts.  You should
     then update the Smart Key summary documentation in the file,
     `hypb-mouse.txt', and potentially the same summary in this manual.

*Missing Action Types*
     What if someone sends a mail message with a button for which I do
     not have the action type?  Or a button whose link referent I can't
     access?

     You receive an error that an action type is not defined or a link
     referent is not accessible/readable if you try to use the button.
     This is hardly different than trying to get through a locked door
     without a key; you try the doorknob, find that it is locked, and
     then realize that you need to take a different approach or else
     give up.

     Like all communication, people need to coordinate, which usually
     requires an iterative process.  If you get a mail message with a
     button for which you don't have the action type, you mail the
     sender and request it.

*How can I modify a number of global buttons in succession?*
     Rather than typing the name for each, it is quicker to jump to the
     global button file and edit the buttons there as you would any
     explicit buttons.  By default, the ButFile/PersonalFile menu item
     takes you to the file where global buttons are saved.

*Why is all the button data scattered across directories?*
     When you think of a hyper-space that you depend on every day, you
     don't want to have a single point of failure make you incapable of
     doing work.  With Hyperbole, if some directories become
     unavailable for a particular time (e.g. the filesystems on which
     they reside are dismounted) you can still work elsewhere with
     minimal effect.  We believe this to be a compelling factor to
     leave the design with external button data storage.

     This design also permits the potential addition of buttons to
     read-only media.

*Why are action types defined separately from their implicit button types?*
     Any category of button can make use of an action type.  Some
     action types are useful as behavior definitions for a variety of
     button categories, so all action types are defined separately to
     give them independence from those types which apply them.

     For implicit button types that require a lot of code, it is useful
     to add a module that includes the implicit button type definition,
     its action type definition and supporting code.


File: hyperbole.info,  Node: Future Work,  Next: References,  Prev: Questions and Answers,  Up: Top

Future Work
***********

This appendix is included for a number of reasons:

   * to better allow you to assess whether to work with Hyperbole by
     providing sketches of possible additions:

   * to direct further development effort towards known needs;

   * and to acknowledge known weaknesses in the current system.

     Note that due to a lack of volunteers to further develop
     Hyperbole, much of this work may not be done.  So if you want to
     see these features, encourage qualified people to volunteer.

Button Copying, Killing, and Yanking
     There is as yet no means of transferring explicit buttons among
     buffers.  We realize this is a critical need.  Users should be
     able to manipulate text with embedded buttons in ordinary ways.
     This will probably be implemented only for versions of Emacs 19
     and higher.  It will store the button attributes as text
     attributes within the buffers so that if a button is copied, its
     attributes follow.  When a buffer is saved, the attributes also
     will be saved.

Trails
     Trails are an extension to the basic history mechanism presently
     offered by Hyperbole.  Trails will allow a user to capture, edit
     and store a specific sequence and set of views of information for
     later replay by other users.  Conditional branching may also be
     supported.

Outliner View Mode
     This will complement the outliner editing mode by using simple one
     character keys that normally insert characters to instead modify
     the view of an outline and to move around in it, for ease of study.
     Switching between view and edit modes will also be simple.

Storage of button data within button source files
     The current design choice of storing buttons external to the
     source file was made under the assumption that people should be
     able to look at files that contain Hyperbole buttons with any
     standard editor or tool and not be bothered by the ugly button
     data (since they won't be able to utilize the buttons anyway, they
     don't need to see or have access to them).

     In many contexts, embedding the button data within the source
     files may be a better choice, so a provision which would allow
     selection of either configuration may be added.  Here are some of
     the PROs and CONs of both design choices:

                     POSITIVE                        NEGATIVE
          
          Button data in source file
                     Documents can stand alone.      All edit operators have
                     Normal file operations apply.   to account for file
                                                     structure and hide
                     Simplifies creation and         internal components.
                     facility expansion for
                     structured and multi-media
                     files.
          
          Button data external to source file
                     Files can be displayed and      Currently, bdata for
                     printed exactly as they look.   whole directory is
                     No special display formatting   locked when any bdata
                     is necessary.                   entry is locked.
          
                     Button-based searches and
                     database-type lookup operations
                     need only search one file
                     per directory.

Forms-based Interfaces
     This will allow one to create buttons more flexibly.  For example,
     button attributes could be given in any order.  Entry of long code
     sequences, quick note taking and cross-referencing would also be
     made easier.

Collaboration Support
     From the early stages of Hyperbole design, collaborative work
     environments have been considered.  A simple facility has
     demonstrated broadcast of button activations to a number of
     workstations on a local area network, so that one user can lead
     others around an information space, as during an online design
     review.  (This facility was never adapted to the current Hyperbole
     release, however.)  We shall do some work in specific
     collaborative mechanisms, but we also expect that others who
     concentrate in collaborative work will provide more extensive
     capabilities.


File: hyperbole.info,  Node: References,  Next: Key Binding Index,  Prev: Future Work,  Up: Top

References
**********

[AkMcYo88]
     Akscyn, R. M., D. L. McCracken and E. A. Yoder. KMS: A Distributed
     Hypermedia System for Managing Knowledge in Organizations.
     *Communications of the ACM*, Vol. 31, No. 7, July 1988, pp.
     820-835.

[Bro87]
     Brown, P. J. Turning Ideas into Products: The Guide System.
     *Proceedings of Hypertext '87*, November 13-15, 1987, Chapel Hill,
     NC.  ACM: NY, NY, pp. 33-40.

[Con87]
     Conklin, Jeff. Hypertext: An Introduction and Survey. *IEEE
     Computer*, Vol. 20, No. 9, September 1987, pp. 17-41.

[Eng68]
     Engelbart, D., and W. English.  A research center for augmenting
     human intellect. *Proceedings of the Fall Joint Computer
     Conference*, 33, 1, AFIPS Press: Montvale, NJ, 1968, pp. 395-410.

[Eng84a]
     Engelbart, D. C. Authorship Provisions in Augment.  *Proceedings
     of the 1984 COMPCON Conference (COMPCON '84 Digest)*, February
     27-March 1, 1984, San Francisco, CA. IEEE Computer Society Press,
     Spring, 1984.  465-472. (OAD,2250,)

[Eng84b]
     Engelbart, D. C. Collaboration Support Provisions in Augment.
     *Proceedings of the AFIPS Office Automation Conference (OAC '84
     Digest)*, February, 1984, Los Angeles, CA, 1984. 51-58. (OAD,2221,)

[Fos88]
     Foss, C. L. Effective Browsing in Hypertext Systems.  *Proceedings
     of the Conference on User-Oriented Content-Based Text and Image
     Handling (RIAO 88)*, March 21-24, MIT, Cambridge MA. Centre de
     Hautes Etudes Internationales d'Informatique Documentaire, 1988,
     pp. 82-98.

[GaSmMe86]
     Garrett, N., K. E. Smith and N. Meyrowitz. Intermedia: Issues,
     Strategies, and Tactics in the Design of a Hypermedia Document
     System.  *Computer-Supported Cooperative Work (CSCW '86)
     Proceedings*, December 3-5, Austin, TX, 1986, pp. 163-174.

[HaMoTr87]
     Halasz, F. G., T. P. Moran and R. H. Trigg. NoteCards in a
     Nutshell. *Proceedings of the CHI and GI '87 Conference on Human
     Factors in Computing Systems*, Toronto, J. M. Carroll and P. P.
     Tanner, (editors), ACM: NY, NY, April 1987, pp. 45-52.

[Har88]
     Harvey, G. *Understanding HyperCard.* Alameda, CA: SYBEX, Inc.,
     1988.

[KaCaLoLa92]
     Kaplan, S., A. M. Carroll, C. Love and D. M. LaLiberte.  *Epoch
     4.0 Manual.* Department of Computer Science, University of
     Illinois, Urbana, March 1992.

[KaKaBeLaDr90]
     Kaplan, S. J., M. D. Kapor, E. J. Belove, R. A.  Landsman, and T.
     R. Drake.  AGENDA: A personal Information Manager.  *Communications
     of the ACM*, No. 33, July 1990, pp. 105-116.

[Nel87a]
     Nelson, T. H.  *Computer Lib/Dream Machines.* MicroSoft Press,
     Redmond, WA, 1987.

[Nel87b]
     Nelson, T. H. *Literary Machines, Edition 87.1*.  Available from
     the Distributors, 702 South Michigan, South Bend, IN 46618, 1987.

[NoDr86]
     Norman, D. A. and S. W. Draper, editors.  *User Centered System
     Design.* Lawrence Erlbaum Associates: Hillsdale, New Jersey, 1986.

[Shn82]
     Shneiderman, B. The future of interactive systems and the emergence
     of direct manipulation.  *Behavior and Information Technology*,
     Vol. 1, 1982, pp. 237-256.

[Sta87]
     Stallman, R.  *GNU Emacs Manual.* Free Software Foundation,
     Cambridge: MA, March 1987.

[Tri86]
     Trigg, R., L. Suchman, and F. Halasz.  Supporting collaboration in
     NoteCards.  *Proceedings of the CSCW '86 Conference*, Austin, TX,
     December 1986, pp. 147-153.

[TrMoHa87]
     Trigg, R. H., T. P. Moran and F. G. Halasz.  Adaptability and
     Tailorability in NoteCards. *Proceedings of INTERACT '87*,
     Stuttgart, West Germany, September 1987.

[Wei92]
     Weiner, B.  *PIEmail: A Personalized Information Environment Mail
     Tool.*  Department of Computer Science Masters Project, Brown
     University: Providence, RI, May 10, 1992.

[YaHaMeDr88]
     Yankelovich, N., B. J. Haan, N. Meyrowitz and S. M.  Drucker.
     Intermedia: The Concept and the Construction of a Seamless
     Information Environment. *IEEE Computer*, Vol. 21, No. 1, January
     1988, pp.  81-96.

[YoAkMc89]
     Yoder, E. A., R. M. Akscyn and D. L. McCracken.  Collaboration in
     KMS, A Shared Hypermedia System. *Proceedings of the 1989 ACM
     Conference on Human Factors in Computer Systems (CHI '89)*, April
     30-May 4, 1989, Austin, TX, ACM: NY,NY, 1989, pp. 37-42.


File: hyperbole.info,  Node: Key Binding Index,  Next: Code and File Index,  Prev: References,  Up: Top

Key Binding Index
*****************

* Menu:

* ,:                                    Rolo Keys.
* .:                                    Rolo Keys.
* <:                                    Rolo Keys.
* >:                                    Rolo Keys.
* DEL:                                  Rolo Keys.
* SPC:                                  Rolo Keys.
* TAB:                                  Relocating and Copying.
* a:                                    Rolo Keys.
* Action Key:                           Smart Keys.
* Action Key, cell argument:            Relocating and Copying.
* Action Key, hide or show cell:        Hiding and Showing.
* Action Key, klink:                    Links.
* Action Key, web browsing:             Implicit Buttons.
* Assist Key:                           Smart Keys.
* Assist Key, listing attributes:       Cell Attributes.
* b:                                    Rolo Keys.
* C-c $:                                Moving Around.
* C-c +:                                Splitting and Appending.
* C-c ,:                                Moving Around.
* C-c .:                                Moving Around.
* C-c <:                                Moving Around.
* C-c >:                                Moving Around.
* C-c @:                                Relocating and Copying.
* C-c ^:                                Moving Around.
* C-c a:                                Adding and Killing.
* C-c b:                                View Specs.
* C-c c:                                Relocating and Copying.
* C-c C-a:                              Hiding and Showing.
* C-c C-b:                              Moving Around.
* C-c C-c:                              Relocating and Copying.
* C-c C-d:                              Moving Around.
* C-c C-f:                              Moving Around.
* C-c C-h:                              Hiding and Showing.
* C-c C-i:                              Cell Attributes.
* C-c C-k:                              Adding and Killing.
* C-c C-l:                              Autonumbering.
* C-c C-m:                              Relocating and Copying.
* C-c C-n:                              Moving Around.
* C-c C-o:                              Hiding and Showing.
* C-c C-p:                              Moving Around.
* C-c C-r:                              Renaming.
* C-c C-s:                              Hiding and Showing.
* C-c C-t:                              Hiding and Showing.
* C-c C-u:                              Moving Around.
* C-c C-v:                              View Specs.
* C-c C-y:                              Buttons in Mail.
* C-c e:                                Transposing.
* C-c h:                                Cell Attributes.
* C-c k:                                Adding and Killing.
* C-c l:                                Links.
* C-c m:                                Relocating and Copying.
* C-c M-c:                              Relocating and Copying.
* C-c M-j:                              Filling.
* C-c M-l:                              Autonumbering.
* C-c M-q:                              Filling.
* C-c p:                                Adding and Killing.
* C-c s:                                Splitting and Appending.
* C-c t <1>:                            Transposing.
* C-c t:                                Smart Keys.
* C-g:                                  Menus.
* C-h A:                                Smart Keys.
* C-h h <1>:                            Installing.
* C-h h:                                Menus.
* C-h t:                                Top.
* C-j:                                  Adding and Killing.
* C-M-h:                                Hiding and Showing.
* C-M-j:                                Filling.
* C-M-q:                                Filling.
* C-M-x:                                Creating Types.
* C-r:                                  Rolo Keys.
* C-t:                                  Menus.
* C-u C-c c:                            Relocating and Copying.
* C-u C-c C-c:                          Relocating and Copying.
* C-u C-c C-m:                          Relocating and Copying.
* C-u C-c h:                            Cell Attributes.
* C-u C-c k:                            Adding and Killing.
* C-u C-c m:                            Relocating and Copying.
* C-u C-c M-l:                          Autonumbering.
* C-u C-c s:                            Splitting and Appending.
* C-u c-j:                              Adding and Killing.
* C-u C-x i:                            Inserting and Importing.
* C-u M-o:                              By Dragging.
* C-u M-RET:                            Smart Keys.
* C-x $:                                Hiding and Showing.
* C-x C-e:                              Creating Types.
* C-x i:                                Inserting and Importing.
* C-x m:                                Buttons in Mail.
* C-x o:                                By Dragging.
* C-y:                                  Adding and Killing.
* e:                                    Rolo Keys.
* f:                                    Rolo Keys.
* h:                                    Rolo Keys.
* M-0 C-c t:                            Transposing.
* M-RET:                                Hiding and Showing.
* M-TAB:                                Relocating and Copying.
* M-j:                                  Filling.
* M-o:                                  By Dragging.
* M-q:                                  Filling.
* M-RET:                                Smart Keys.
* M-s:                                  Rolo Keys.
* M-TAB:                                Rolo Keys.
* n:                                    Rolo Keys.
* p:                                    Rolo Keys.
* q <1>:                                Rolo Keys.
* q:                                    Menus.
* r:                                    Rolo Keys.
* s:                                    Rolo Keys.
* t:                                    Rolo Keys.
* TAB:                                  Rolo Keys.
* u:                                    Rolo Keys.

