|
0
|
1 \input texinfo
|
|
|
2 @c
|
|
|
3 @c FILE: hypb.texi
|
|
|
4 @c SUMMARY: The Hyperbole User Manual for V3
|
|
|
5 @c USAGE: Hardcopy man from TeX; Info man from 'texinfo-format-buffer'.
|
|
|
6 @c
|
|
|
7 @c AUTHOR: Bob Weiner
|
|
|
8 @c ORG: Brown U.
|
|
|
9 @c
|
|
|
10 @c ORIG-DATE: 6-Nov-91 at 11:18:03
|
|
|
11 @c LAST-MOD: 3-Nov-95 at 23:55:27 by Bob Weiner
|
|
|
12
|
|
|
13 @c %**start of header (This is for running Texinfo on a region.)
|
|
|
14 @setfilename ../info/hyperbole.info
|
|
|
15 @settitle Hyperbole User Manual
|
|
|
16 @c %**end of header (This is for running Texinfo on a region.)
|
|
|
17 @synindex vr fn
|
|
|
18
|
|
|
19 @iftex
|
|
|
20 @finalout
|
|
|
21 @end iftex
|
|
|
22
|
|
|
23 @titlepage
|
|
|
24 @sp 4
|
|
|
25 @center @titlefont{Hyperbole Manual}
|
|
|
26 @sp 1
|
|
|
27 @center Everyday Information Management
|
|
|
28 @sp 5
|
|
|
29 @center Bob Weiner
|
|
|
30 @sp 1
|
|
|
31 @center E-mail: <hyperbole@@hub.ucsb.edu> (This is a mail list.)
|
|
|
32 @sp 2
|
|
|
33 @center Edition 4.01
|
|
|
34 @sp 2
|
|
|
35 @center November 3, 1995
|
|
|
36
|
|
|
37 @page
|
|
|
38 @vskip 0pt plus 1filll
|
|
|
39 Copyright @copyright{} 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
|
|
|
40
|
|
|
41 All trademarks referenced herein are trademarks of their respective
|
|
|
42 holders.
|
|
|
43 @setchapternewpage odd
|
|
|
44 @end titlepage
|
|
|
45 @page
|
|
|
46
|
|
|
47 @node Top, Introduction, (dir), (dir)
|
|
|
48 @c node-name, next, previous, up
|
|
|
49 @unnumbered Preface
|
|
|
50
|
|
|
51 @ifinfo
|
|
|
52 @noindent
|
|
|
53 Copyright @copyright{} 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
|
|
|
54
|
|
|
55 All trademarks referenced herein are trademarks of their respective holders.
|
|
|
56
|
|
|
57 @end ifinfo
|
|
|
58 This edition of the Hyperbole User Manual is for use with any version
|
|
|
59 4.01 or greater of Hyperbole.
|
|
|
60
|
|
|
61 Hyperbole is free software; you can use it, redistribute it and/or modify it
|
|
|
62 without fee under the terms of the GNU General Public License as published by
|
|
|
63 the Free Software Foundation; either version 2, or (at your option) any later
|
|
|
64 version.
|
|
|
65
|
|
|
66 Hyperbole is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
67 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
|
68 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
69
|
|
|
70 You should have received a copy of the GNU General Public License
|
|
|
71 along with GNU Emacs or XEmacs; see the file COPYING. If not, write to
|
|
|
72 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
73
|
|
|
74 @cindex credits
|
|
|
75 @cindex InfoDock, obtaining
|
|
|
76 @cindex Hyperbole, obtaining
|
|
|
77 @cindex anonymous ftp
|
|
|
78 Hyperbole was designed and written by Bob Weiner. Motorola,
|
|
|
79 Inc@. funded and donated this work for free redistribution as part of
|
|
|
80 the InfoDock integrated software engineering and productivity toolset.
|
|
|
81 For information on how to obtain Hyperbole, @ref{Obtaining}. InfoDock
|
|
|
82 can be found at the same location.
|
|
|
83
|
|
|
84 This manual explains user operation and summarizes basic developer
|
|
|
85 facilities of Hyperbole. This major release of Hyperbole concentrates
|
|
|
86 on providing convenient access to information and control over its
|
|
|
87 display. The Hyperbole outliner emphasizes flexible views and structure
|
|
|
88 manipulation within bodies of information.
|
|
|
89
|
|
|
90 @cindex Hyperbole
|
|
|
91 @cindex hypertext
|
|
|
92 @cindex Emacs Lisp
|
|
|
93 @cindex Emacs 19
|
|
|
94 @cindex Epoch
|
|
|
95 @cindex XEmacs
|
|
|
96 @cindex Lucid Emacs
|
|
|
97 Hyperbole (pronounced Hi-purr-boe-lee) is an open, efficient,
|
|
|
98 programmable information management and hypertext system. It is
|
|
|
99 intended for everyday work on any UNIX platform supported by GNU Emacs.
|
|
|
100 It works well with the versions of Emacs that support multiple X or
|
|
|
101 NEXTSTEP windows: Emacs 19, XEmacs (formerly called Lucid Emacs) and
|
|
|
102 Epoch. Hyperbole allows hypertext buttons to be embedded within
|
|
|
103 unstructured and structured files, mail messages and news articles. It
|
|
|
104 offers intuitive mouse-based control of information display within
|
|
|
105 multiple windows. It also provides point-and-click access to Info
|
|
|
106 manuals, ftp archives, Wide-Area Information Servers (WAIS), and the
|
|
|
107 World-Wide Web (WWW) hypertext system through encapsulations of software
|
|
|
108 that support these protocols.
|
|
|
109
|
|
|
110 @noindent
|
|
|
111 Hyperbole consists of four parts:
|
|
|
112
|
|
|
113 @table @bullet
|
|
|
114 @item Info Management
|
|
|
115 an interactive information management interface, including a powerful
|
|
|
116 rolodex, which anyone can use. It is easy to pick up and use since it
|
|
|
117 introduces only a few new mechanisms and provides user-level facilities
|
|
|
118 through a menu interface, which you control from the keyboard or the
|
|
|
119 mouse;
|
|
|
120
|
|
|
121 @item Hypertext Outliner
|
|
|
122 an outliner with multi-level autonumbering and permanent ids attached to
|
|
|
123 each outline node for use as hypertext link anchors, plus flexible view
|
|
|
124 specifications that can be embedded within links or used interactively;
|
|
|
125
|
|
|
126 @item Button Types
|
|
|
127 a set of hyper-button types that provides core hypertext and other
|
|
|
128 behaviors. Users can make simple changes to button types and those
|
|
|
129 familiar with Emacs Lisp can quickly prototype and deliver new types;
|
|
|
130
|
|
|
131 @item Programming Library
|
|
|
132 a set of programming library classes for system developers who want to
|
|
|
133 integrate Hyperbole with another user interface or as a back-end to a
|
|
|
134 distinct system. (All of Hyperbole is written in Emacs Lisp for ease of
|
|
|
135 modification. Although Hyperbole was initially designed as a prototype,
|
|
|
136 it has been engineered for real-world usage and is well structured.)
|
|
|
137 @end table
|
|
|
138
|
|
|
139 @cindex GNU Emacs
|
|
|
140 @kindex C-h t
|
|
|
141 @vindex file, DEMO
|
|
|
142 @cindex demonstration
|
|
|
143 @cindex button demo
|
|
|
144 Hyperbole may be used simply for browsing through documents
|
|
|
145 pre-configured with Hyperbole buttons, in which case, one can safely
|
|
|
146 ignore most of the information in this manual. The @file{DEMO} file
|
|
|
147 included in the Hyperbole distribution demonstrates many of Hyperbole's
|
|
|
148 standard facilities. It offers a much less technical introduction for
|
|
|
149 Hyperbole users by providing good examples of how buttons may be
|
|
|
150 used and an introduction to the outliner.
|
|
|
151
|
|
|
152 So if this manual is too detailed for your taste, you can skip it
|
|
|
153 entirely and just jump right into the demonstration, normally by typing
|
|
|
154 @{@kbd{C-h h d d}@}, assuming Hyperbole has already been installed at
|
|
|
155 your site. Otherwise, @ref{Installation}, for Hyperbole installation
|
|
|
156 and configuration information.
|
|
|
157
|
|
|
158 Many users, however, will want to do more than browse with Hyperbole,
|
|
|
159 e.g@. create their own buttons. The standard Hyperbole button editing
|
|
|
160 user interface is GNU Emacs-based, so a basic familiarity with the Emacs
|
|
|
161 editing model is useful. The material covered in the GNU Emacs
|
|
|
162 tutorial, normally bound to @{@kbd{C-h t}@} within Emacs, is more than
|
|
|
163 sufficient as background. If some GNU Emacs terms are unfamiliar to
|
|
|
164 you, @ref{Glossary, Emacs Glossary,, emacs, the GNU Emacs Manual}.
|
|
|
165
|
|
|
166 Before we delve into Hyperbole, a number of acknowledgments are in
|
|
|
167 order. Peter Wegner has encouraged the growth in this work. Morris
|
|
|
168 Moore has helped me pursue my own research visions and kept me striving
|
|
|
169 for excellence. Doug Engelbart has shown me the bigger picture and
|
|
|
170 continues to be an inspiration. His work provides a model from which I
|
|
|
171 am beginning to draw. Kellie Clark and I jointly designed the Hyperbole
|
|
|
172 outliner while sharing a life together. Chris Nuzum, as a user of
|
|
|
173 Hyperbole, has helped demonstrate its power since its inception; he
|
|
|
174 knows how to work with Hyperbole far better than I.
|
|
|
175
|
|
|
176 @menu
|
|
|
177 * Introduction::
|
|
|
178 * Installation::
|
|
|
179 * Buttons::
|
|
|
180 * Smart Keys::
|
|
|
181 * Menus::
|
|
|
182 * Entering Arguments::
|
|
|
183 * Outliner::
|
|
|
184 * Rolodex::
|
|
|
185 * Window Configurations::
|
|
|
186 * Developing with Hyperbole::
|
|
|
187 * Glossary::
|
|
|
188 * Smart Key Reference::
|
|
|
189 * Outliner Keys::
|
|
|
190 * Suggestion or Bug Reporting::
|
|
|
191 * Questions and Answers::
|
|
|
192 * Future Work::
|
|
|
193 * References::
|
|
|
194 * Key Binding Index::
|
|
|
195 * Code and File Index::
|
|
|
196 * Concept Index::
|
|
|
197
|
|
|
198 --- The Detailed Node Listing ---
|
|
|
199
|
|
|
200 Introduction
|
|
|
201
|
|
|
202 * Hyperbole Overview::
|
|
|
203 * Mail Lists::
|
|
|
204 * Manual Overview::
|
|
|
205
|
|
|
206 Installation
|
|
|
207
|
|
|
208 * Obtaining::
|
|
|
209 * Building::
|
|
|
210 * Installing::
|
|
|
211 * Configuring::
|
|
|
212
|
|
|
213 Configuring
|
|
|
214
|
|
|
215 * Internal Viewers::
|
|
|
216 * External Viewers::
|
|
|
217 * Link Variable Substitution::
|
|
|
218 * Button Colors::
|
|
|
219
|
|
|
220 Buttons
|
|
|
221
|
|
|
222 * Explicit Buttons::
|
|
|
223 * Global Buttons::
|
|
|
224 * Implicit Buttons::
|
|
|
225 * Action Types::
|
|
|
226 * Button Type Precedence::
|
|
|
227 * Button Files::
|
|
|
228 * Utilizing Explicit Buttons::
|
|
|
229
|
|
|
230 Utilizing Explicit Buttons
|
|
|
231
|
|
|
232 * Creation::
|
|
|
233 * Renaming::
|
|
|
234 * Deletion::
|
|
|
235 * Modification::
|
|
|
236 * Location::
|
|
|
237 * Buttons in Mail::
|
|
|
238 * Buttons in News::
|
|
|
239
|
|
|
240 Creation
|
|
|
241
|
|
|
242 * By Dragging:: Creation Via Action Key Drags
|
|
|
243 * By Menu:: Creation Via Menus
|
|
|
244
|
|
|
245 Outliner
|
|
|
246
|
|
|
247 * Menu Commands::
|
|
|
248 * Creating Outlines::
|
|
|
249 * Autonumbering::
|
|
|
250 * Idstamps::
|
|
|
251 * Editing::
|
|
|
252 * Viewing::
|
|
|
253 * Links::
|
|
|
254 * Cell Attributes::
|
|
|
255 * Outliner History::
|
|
|
256
|
|
|
257 Editing
|
|
|
258
|
|
|
259 * Adding and Killing::
|
|
|
260 * Moving Around::
|
|
|
261 * Relocating and Copying::
|
|
|
262 * Filling::
|
|
|
263 * Transposing::
|
|
|
264 * Splitting and Appending::
|
|
|
265 * Inserting and Importing::
|
|
|
266
|
|
|
267 Viewing
|
|
|
268
|
|
|
269 * Hiding and Showing::
|
|
|
270 * View Specs::
|
|
|
271
|
|
|
272 Rolodex
|
|
|
273
|
|
|
274 * Rolo Concepts::
|
|
|
275 * Rolo Menu::
|
|
|
276 * Rolo Keys::
|
|
|
277 * Rolo Settings::
|
|
|
278
|
|
|
279 Developing with Hyperbole
|
|
|
280
|
|
|
281 * Hook Variables::
|
|
|
282 * Creating Types::
|
|
|
283 * Explicit Button Technicalities::
|
|
|
284 * Encapsulating Systems::
|
|
|
285 * Embedding Hyperbole::
|
|
|
286
|
|
|
287 Creating Types
|
|
|
288
|
|
|
289 * Action Type Creation::
|
|
|
290 * Implicit Button Types::
|
|
|
291
|
|
|
292 Explicit Button Technicalities
|
|
|
293
|
|
|
294 * Button Label Normalization::
|
|
|
295 * Operational and Storage Formats::
|
|
|
296 * Programmatic Button Creation::
|
|
|
297
|
|
|
298 Smart Key Reference
|
|
|
299
|
|
|
300 * Smart Mouse Keys::
|
|
|
301 * Smart Keyboard Keys::
|
|
|
302 @end menu
|
|
|
303
|
|
|
304 @node Introduction, Installation, Top, Top
|
|
|
305 @chapter Introduction
|
|
|
306
|
|
|
307 This chapter describes what Hyperbole is, lists some of its potential
|
|
|
308 applications, explains how to subscribe to its mail lists, and then
|
|
|
309 summarizes the structure of the rest of the manual.
|
|
|
310
|
|
|
311 @menu
|
|
|
312 * Hyperbole Overview::
|
|
|
313 * Mail Lists::
|
|
|
314 * Manual Overview::
|
|
|
315 @end menu
|
|
|
316
|
|
|
317 @node Hyperbole Overview, Mail Lists, Introduction, Introduction
|
|
|
318 @section Hyperbole Overview
|
|
|
319 @cindex button
|
|
|
320 A Hyperbole user works with @emph{buttons} embedded within textual
|
|
|
321 documents; he may create, modify, move or delete buttons. Each button
|
|
|
322 performs a specific action, such as linking to a file or executing a
|
|
|
323 shell command.
|
|
|
324
|
|
|
325 @cindex button, explicit
|
|
|
326 @cindex button, global
|
|
|
327 @cindex button, implicit
|
|
|
328 @cindex button category
|
|
|
329 @cindex explicit button
|
|
|
330 @cindex global button
|
|
|
331 @cindex implicit button
|
|
|
332 There are three categories of Hyperbole buttons:
|
|
|
333 @table @dfn
|
|
|
334 @item explicit buttons
|
|
|
335 created by Hyperbole, accessible from within a single document;
|
|
|
336
|
|
|
337 @item global buttons
|
|
|
338 created by Hyperbole, accessible anywhere within a user's network of
|
|
|
339 documents;
|
|
|
340
|
|
|
341 @item implicit buttons
|
|
|
342 created and managed by other programs or embedded within the structure
|
|
|
343 of a document, accessible from within a single document. Hyperbole
|
|
|
344 recognizes implicit buttons by contextual patterns given in their type
|
|
|
345 specifications (explained later).
|
|
|
346 @end table
|
|
|
347
|
|
|
348 Explicit Hyperbole buttons may be embedded within any type of text file.
|
|
|
349 Implicit buttons may be recognized anywhere within a text file,
|
|
|
350 depending on the implicit button types that are available. All global
|
|
|
351 buttons are stored in a single location and activated by entering their
|
|
|
352 names, rather than by direct selection, the means used to activate
|
|
|
353 explicit and implicit buttons.
|
|
|
354
|
|
|
355 @noindent
|
|
|
356 To summarize:
|
|
|
357
|
|
|
358 @example
|
|
|
359 Button Category Active Within Activation Means Managed By
|
|
|
360 ========================================================================
|
|
|
361 Explicit a single document direct selection Hyperbole
|
|
|
362 Global any document specifying its name Hyperbole
|
|
|
363 Implicit a matching context direct selection other tools
|
|
|
364 ========================================================================
|
|
|
365 @end example
|
|
|
366
|
|
|
367 @cindex terminal use
|
|
|
368 Hyperbole buttons may be clicked upon with a mouse to activate them or
|
|
|
369 to describe their actions. Thus, a user can always check how a button
|
|
|
370 will act before activating it. Buttons may also be activated from a
|
|
|
371 keyboard. (In fact, virtually all Hyperbole operations, including menu
|
|
|
372 usage, may be performed from any standard character terminal interface,
|
|
|
373 so one need not be anchored to a workstation all day). @xref{Smart
|
|
|
374 Keys}.
|
|
|
375
|
|
|
376 @cindex Hyperbole features
|
|
|
377 Hyperbole does not enforce any particular hypertext or information
|
|
|
378 management model, but instead allows you to organize your information in
|
|
|
379 large or small chunks as you see fit. The Hyperbole outliner organizes
|
|
|
380 information hierarchies which may also contain links to external
|
|
|
381 information sources.
|
|
|
382
|
|
|
383 @noindent
|
|
|
384 Some of Hyperbole's most important features include:
|
|
|
385
|
|
|
386 @itemize @bullet
|
|
|
387 @item
|
|
|
388 Buttons may link to information or may execute procedures, such as
|
|
|
389 starting or communicating with external programs;
|
|
|
390
|
|
|
391 @item
|
|
|
392 One simply drags between a button source location and a link destination
|
|
|
393 to create or to modify a link button. The same result can be achieved
|
|
|
394 from the keyboard.
|
|
|
395
|
|
|
396 @item
|
|
|
397 Buttons may be embedded within electronic mail messages;
|
|
|
398
|
|
|
399 @item
|
|
|
400 Outlines allow rapid browsing, editing and movement of chunks of
|
|
|
401 information organized into trees (hierarchies);
|
|
|
402
|
|
|
403 @item
|
|
|
404 Other hypertext and information retrieval systems may be encapsulated
|
|
|
405 under a Hyperbole user interface (a number of samples are provided).
|
|
|
406 @end itemize
|
|
|
407
|
|
|
408 @cindex Hyperbole applications
|
|
|
409 @noindent
|
|
|
410 Typical Hyperbole applications include:
|
|
|
411
|
|
|
412 @table @strong
|
|
|
413 @item personal information management
|
|
|
414 Overlapping link paths provide a variety of views into an information space.
|
|
|
415 A search facility locates buttons in context and permits quick selection.
|
|
|
416
|
|
|
417 @item documentation and code browsing
|
|
|
418 Cross-references may be embedded within documentation. One can add a
|
|
|
419 point-and-click interface to existing documentation, link code with
|
|
|
420 associated design documents, or jump to the definition of an identifier
|
|
|
421 by selecting its name within code or documentation.
|
|
|
422
|
|
|
423 @item brainstorming
|
|
|
424 The Hyperbole outliner, @xref{Outliner}, is an
|
|
|
425 effective tool for capturing ideas and then quickly reorganizing them in
|
|
|
426 a meaningful way. Links to related ideas are easy to create,
|
|
|
427 eliminating the need to copy and paste information into a single place.
|
|
|
428
|
|
|
429 @item help/training systems
|
|
|
430 Tutorials containing buttons can show students how things work while
|
|
|
431 explaining the concepts, e.g@. an introduction to local commands. This
|
|
|
432 technique can be much more effective than written documentation alone.
|
|
|
433
|
|
|
434 @item archive managers
|
|
|
435 Programs that manage archives from incoming information streams may be
|
|
|
436 supplemented by having them add topic-based buttons that link to the
|
|
|
437 archive holdings. Users can then search and create their own links to
|
|
|
438 archive entries.
|
|
|
439 @end table
|
|
|
440
|
|
|
441 @node Mail Lists, Manual Overview, Hyperbole Overview, Introduction
|
|
|
442 @section Mail Lists
|
|
|
443
|
|
|
444 If you maintain or use Hyperbole, you should consider joining one of the
|
|
|
445 two Hyperbole interest mailing lists. @xref{Menus}, and the description
|
|
2
|
446 of the Msg/ menu item, for a convenient means of joining and mailing
|
|
0
|
447 to these lists.
|
|
|
448
|
|
|
449 @cindex mail lists
|
|
|
450 @cindex e-mail
|
|
|
451 There are several Hyperbole-related mail addresses. Learn what each is
|
|
|
452 for before you mail to any of them.
|
|
|
453
|
|
|
454 @cindex mail list requests
|
|
|
455 @cindex joining a mail list
|
|
|
456 @cindex subscribing to a mail list
|
|
|
457 @cindex unsubscribing from a mail list
|
|
|
458 @format
|
|
|
459 <hyperbole-request@@hub.ucsb.edu>
|
|
|
460 <hyperbole-announce-request@@hub.ucsb.edu>
|
|
|
461 @end format
|
|
|
462
|
|
|
463 @display
|
|
|
464 @strong{All} mail concerning administration of the Hyperbole mailing
|
|
|
465 lists should be sent to the appropriate one of these addresses. That
|
|
|
466 includes addition, change, or deletion requests. Don't consider sending
|
|
|
467 such a request to a Hyperbole mail list or people will wonder why you
|
|
|
468 don't know that all Internet mail lists have a -request address for
|
|
|
469 administrative requests.@refill
|
|
|
470
|
|
|
471 Use the following formats on your subject line to execute requests,
|
|
|
472 where you substitute your own values for the <> delimited items.@refill
|
|
|
473
|
|
|
474 Subject: Subscribe '<' <user@@domain> '>' (<your name>).
|
|
|
475 Subject: Unsubscribe '<' <user@@domain> '>'.
|
|
|
476
|
|
|
477 To change your address, you must unsubscribe your old address in one
|
|
|
478 message and then subscribe your new address in another message.@refill
|
|
|
479
|
|
|
480 For example:
|
|
|
481
|
|
|
482 To: hyperbole-announce-request@@hub.ucsb.edu
|
|
|
483 Subject: Unsubscribe <joe@@any.com>.
|
|
|
484
|
|
|
485 To: hyperbole-announce-request@@hub.ucsb.edu
|
|
|
486 Subject: Subscribe <joe@@any.com> (Joe Williams).
|
|
|
487 @end display
|
|
|
488
|
|
|
489 @noindent
|
|
|
490 There are two Hyperbole-related mail lists. Subscribe to one or the other,
|
|
|
491 not to both.
|
|
|
492
|
|
|
493 @cindex hyperbole mail list
|
|
|
494 @format
|
|
|
495 <hyperbole@@hub.ucsb.edu>
|
|
|
496 @end format
|
|
|
497
|
|
|
498 @display
|
|
|
499 Mail list for discussion of all Hyperbole issues. Bug reports and
|
|
|
500 suggestions may also be sent here.@refill
|
|
|
501
|
|
|
502 @cindex e-mail, effective communication
|
|
|
503 @cindex effective communication
|
|
|
504 Always use your Subject and/or Summary: lines to state the position that
|
|
|
505 your message takes on the topic that it addresses.
|
|
|
506
|
|
|
507 For example, send:
|
|
|
508
|
|
|
509 Subject: Basic bug in top-level minibuffer menu.
|
|
|
510
|
|
|
511 rather than:
|
|
|
512
|
|
|
513 Subject: Hyperbole bug.
|
|
|
514
|
|
|
515 Statements end with periods, questions with question marks (typically),
|
|
|
516 and high energy, high impact declarations with exclamation points. This
|
|
|
517 simple rule makes all e-mail communication much easier for recipients to
|
|
|
518 handle appropriately.@refill
|
|
|
519
|
|
|
520 @cindex Hyperbole version
|
|
|
521 @cindex Emacs version
|
|
|
522 @vindex emacs-version
|
|
|
523 If you ask a question, your subject line should end with a ?,
|
|
|
524 e.g@. "Subject: How can man page SEE ALSOs be made implicit buttons?" A
|
|
|
525 "Subject: Re: How can ..." then indicates an answer to the question.
|
|
|
526 Question messages should normally include your Hyperbole and Emacs
|
|
|
527 version numbers and clearly explain your problem and surrounding issues.
|
|
|
528 Otherwise, you will simply waste the time of those who may want to help
|
|
|
529 you. (Your top-level Hyperbole menu shows its version number and @{@kbd{M-x
|
|
|
530 emacs-version @key{RET}}@} gives the other.)@refill
|
|
|
531
|
|
|
532 If you ask questions, you should consider adding to the discussion by
|
|
|
533 telling people the kinds of work you are doing or contemplating doing
|
|
|
534 with Hyperbole. In this way, the list will not be overwhelmed by
|
|
|
535 messages that ask for, but provide no information.@refill
|
|
|
536 @end display
|
|
|
537
|
|
|
538 @cindex hyperbole-announce mail list
|
|
|
539 @format
|
|
|
540 <hyperbole-announce@@hub.ucsb.edu>
|
|
|
541 @end format
|
|
|
542
|
|
|
543 @display
|
|
|
544 Those who don't want to participate in the discussion but want to hear
|
|
|
545 about bug fixes and new releases of Hyperbole should subscribe to this
|
|
|
546 list. Anyone on the `hyperbole' list is automatically on this one too,
|
|
|
547 so there is no need to subscribe to this one in that case. This list is
|
|
|
548 for official fixes and announcements so don't send your own fixes here.
|
|
|
549 Send them to `hyperbole' instead.
|
|
|
550 @end display
|
|
|
551
|
|
|
552
|
|
|
553 @node Manual Overview, , Mail Lists, Introduction
|
|
|
554 @section Manual Overview
|
|
|
555
|
|
|
556 Remember that the @file{DEMO} file included in the Hyperbole
|
|
|
557 distribution demonstrates many of Hyperbole's standard facilities,
|
|
|
558 (@pxref{Top, Preface}) for more details.
|
|
|
559
|
|
|
560 @xref{Glossary}, for definitions of Hyperbole terms for quick
|
|
|
561 reference, so in some cases terms are not precisely defined within the
|
|
|
562 text. Be sure to reference the glossary if a term is unclear to you.
|
|
|
563 Although you need not have a keen understanding of all of these terms, a
|
|
|
564 quick scan of the Glossary should help throughout Hyperbole use.
|
|
|
565
|
|
|
566 If you have a question, feature suggestion or bug report on Hyperbole,
|
|
|
567 follow the instructions given in @ref{Suggestion or Bug Reporting}. A few
|
|
|
568 commonly asked questions are answered in the manual, @ref{Questions and
|
|
|
569 Answers}. If you are interested in classic articles on hypertext,
|
|
|
570 @ref{References}.
|
|
|
571
|
|
|
572 @xref{Installation}, for explanations of how to obtain, install, configure
|
|
|
573 and load Hyperbole for use.
|
|
|
574
|
|
|
575 @xref{Buttons}, for an overview of Hyperbole buttons and how to use them.
|
|
|
576
|
|
|
577 @xref{Smart Keys}, for an explanation of the innovative,
|
|
|
578 context-sensitive mouse and keyboard Action and Assist Keys offered by
|
|
|
579 Hyperbole. @xref{Smart Key Reference}, for a complete reference on what
|
|
|
580 the Action and Assist Keys do in each particular context that they
|
|
|
581 recognize.
|
|
|
582
|
|
|
583 (Keep in mind as you read about how to use Hyperbole that in many cases,
|
|
|
584 it provides a number of overlapping interaction methods are provided to
|
|
|
585 support different work styles and hardware limitations. You need learn
|
|
|
586 only one with which you can become comfortable, in such instances.)
|
|
|
587
|
|
|
588 @xref{Menus}, for summaries of Hyperbole menu commands and how to use
|
|
|
589 the minibuffer-based menus that work on dumb terminals.
|
|
|
590
|
|
|
591 @xref{Entering Arguments}, for special support that Hyperbole provides for
|
|
|
592 entering arguments when prompted for them.
|
|
|
593
|
|
|
594 @xref{Outliner}, for concept and usage information on the
|
|
|
595 autonumbered, hypertextual outliner. A full summary of the outliner
|
|
|
596 commands that are bound to keys may be found in @ref{Outliner Keys}.
|
|
|
597
|
|
|
598 @xref{Rolodex}, for concept and usage information on the
|
|
|
599 rapid lookup, hierarchical, free text record management system included
|
|
|
600 with Hyperbole.
|
|
|
601
|
|
|
602 @xref{Window Configurations}, for instructions on how to save and restore
|
|
|
603 the set of buffers and windows that appear with a frame. This feature
|
|
|
604 lets you switch among working contexts easily, even on a dumb terminal.
|
|
|
605 Such configurations only last throughout your current editor session.
|
|
|
606
|
|
|
607 Developers comfortable with Emacs Lisp will want to continue on through
|
|
|
608 to, @ref{Developing with Hyperbole}.
|
|
|
609
|
|
|
610 @xref{Future Work}, for future directions in Hyperbole's evolution.
|
|
|
611
|
|
|
612
|
|
|
613 @node Installation, Buttons, Introduction, Top
|
|
|
614 @chapter Installation
|
|
|
615
|
|
|
616 @cindex installation
|
|
|
617 Hyperbole must be installed at your site before you can use it. The
|
|
|
618 following sections explain how to obtain, install and configure
|
|
|
619 Hyperbole for use.
|
|
|
620
|
|
|
621 @vindex file, hsite.el
|
|
|
622 @cindex customization, init
|
|
|
623 If you want to customize the basic Hyperbole initialization sequence for
|
|
|
624 yourself rather than the users at your site, you should make a personal
|
|
|
625 copy of the @file{hsite.el} file, modify it the way you want, and then
|
|
|
626 load it. (If you are familiar with Emacs Lisp, @ref{Hook Variables}.)
|
|
|
627
|
|
|
628 @menu
|
|
|
629 * Obtaining::
|
|
|
630 * Building::
|
|
|
631 * Installing::
|
|
|
632 * Configuring::
|
|
|
633 @end menu
|
|
|
634
|
|
|
635 @node Obtaining, Building, Installation, Installation
|
|
|
636 @section Obtaining
|
|
|
637
|
|
|
638 @cindex InfoDock
|
|
|
639 @cindex ftp
|
|
|
640 @cindex anonymous ftp
|
|
|
641 Hyperbole is actually part of an integrated tool framework that we have
|
|
|
642 developed called InfoDock. InfoDock provides a modern user interface on top
|
|
|
643 of Emacs, information management, and powerful software development tools,
|
|
|
644 all in one package. Hyperbole or InfoDock can be obtained via anonymous
|
|
|
645 ftp on the Internet from:
|
|
|
646
|
|
|
647 @file{ftp://ftp.xemacs.org/pub/infodock}.
|
|
|
648
|
|
|
649 @cindex downloading Hyperbole
|
|
|
650 @cindex obtaining Hyperbole
|
|
|
651 @cindex Hyperbole, obtaining
|
|
|
652 @noindent
|
|
|
653 Here are detailed instructions for downloading and unpacking Hyperbole.
|
|
|
654
|
|
|
655 Move to a directory below which you want the @file{hyperbole} directory to
|
|
|
656 be created. Unpacking the Hyperbole archive will create the
|
|
|
657 @file{hyperbole} directory and will place all of the files below it.
|
|
|
658
|
|
|
659 @example
|
|
|
660 cd <LOCAL-EMACS-LISP-DIR>
|
|
|
661 @end example
|
|
|
662
|
|
|
663 @noindent
|
|
|
664 Ftp to ftp.xemacs.org (Internet Host ID = 128.174.252.16):
|
|
|
665
|
|
|
666 @example
|
|
|
667 prompt> ftp ftp.xemacs.org
|
|
|
668 @end example
|
|
|
669
|
|
|
670 @noindent
|
|
|
671 Login as @emph{anonymous} with your own @emph{<user-id>@@<site-name>} as
|
|
|
672 a password.
|
|
|
673
|
|
|
674 @example
|
|
|
675 Name (ftp.xemacs.org): anonymous
|
|
|
676 331 Guest login ok, send EMAIL address (e.g@. user@@host.domain)
|
|
|
677 as password.
|
|
|
678 Password:
|
|
|
679 230 Guest login ok, access restrictions apply.
|
|
|
680 @end example
|
|
|
681
|
|
|
682 @noindent
|
|
|
683 Move to the Hyperbole directory:
|
|
|
684
|
|
|
685 @example
|
|
|
686 ftp> cd pub/infodock
|
|
|
687 @end example
|
|
|
688
|
|
|
689 @noindent
|
|
|
690 Set your transfer mode to binary:
|
|
|
691
|
|
|
692 @example
|
|
|
693 ftp> bin
|
|
|
694 200 Type set to I.
|
|
|
695 @end example
|
|
|
696
|
|
|
697 @noindent
|
|
|
698 Turn off prompting:
|
|
|
699
|
|
|
700 @example
|
|
|
701 ftp> prompt
|
|
|
702 Interactive mode off.
|
|
|
703 @end example
|
|
|
704
|
|
|
705 @noindent
|
|
|
706 Retrieve just the Hyperbole archive and any diff-based patches (there may not
|
|
|
707 be any patches):
|
|
|
708
|
|
|
709 @example
|
|
|
710 ftp> mget hyperbole*
|
|
|
711 ftp> mget hdiff*
|
|
|
712 @end example
|
|
|
713
|
|
|
714 @noindent
|
|
|
715 Close the ftp connection:
|
|
|
716
|
|
|
717 @example
|
|
|
718 ftp> quit
|
|
|
719 221 Goodbye.
|
|
|
720 @end example
|
|
|
721
|
|
|
722 @cindex gzcat
|
|
|
723 @cindex zcat
|
|
|
724 @cindex gunzip
|
|
|
725 @cindex tar archive
|
|
|
726 @cindex uncompressing archives
|
|
|
727 @cindex unpacking archives
|
|
|
728 @noindent
|
|
|
729 Unpack the tar archive using the GNU version of the @code{zcat} program,
|
|
|
730 sometimes called @code{gzcat} or the @code{gunzip} program:
|
|
|
731
|
|
|
732 @example
|
|
|
733 zcat hyperbole*tar.gz | tar xvf -
|
|
|
734 or
|
|
|
735 gunzip hyperbole*tar.gz; tar xvf hyperbole*tar
|
|
|
736 @end example
|
|
|
737
|
|
|
738 @noindent
|
|
|
739 Apply any patches you retrieved:
|
|
|
740
|
|
|
741 @example
|
|
|
742 cd hyperbole; patch < <patch-file>
|
|
|
743 @end example
|
|
|
744
|
|
|
745
|
|
|
746 @node Building, Installing, Obtaining, Installation
|
|
|
747 @section Building
|
|
|
748
|
|
|
749 @vindex file, Makefile
|
|
|
750 @vindex file, hsite.el
|
|
|
751 @cindex Hyperbole, building
|
|
|
752 @cindex building Hyperbole
|
|
|
753 The following explains how to Use the Hyperbole @file{Makefile} to
|
|
|
754 compile any needed code, to generate the @file{hsite.el} file used for
|
|
|
755 site-specific Hyperbole customization, and to produce printable
|
|
|
756 documentation.
|
|
|
757
|
|
|
758 @vindex EMACS, environment variable
|
|
|
759 @cindex compiling Lisp
|
|
|
760 @cindex Lisp compilation
|
|
|
761 Edit the line near the top of @file{Makefile} that represents the emacs
|
|
|
762 version that you use, so that it corresponds to the emacs executable
|
|
|
763 name used on your system. Then immediatly below there, set the
|
|
|
764 @var{EMACS} variable to the variable name for the emacs that you will
|
|
|
765 use to compile the Hyperbole Lisp files.
|
|
|
766
|
|
|
767 @vindex SITE-PRELOADS, environment variable
|
|
|
768 You may also have to set the @var{SITE-PRELOADS} variable defined further down
|
|
|
769 in the file; follow the instructions that precede the @var{SITE-PRELOADS =}
|
|
|
770 line. Make these changes now and save the @file{Makefile}.
|
|
|
771
|
|
|
772 @cindex HYPERBOLE-DIR
|
|
|
773 The following instructions use the term @file{<HYPERBOLE-DIR>/} to refer
|
|
|
774 to your @file{hyperbole/} directory, so substitute your own value.
|
|
|
775
|
|
|
776 @noindent
|
|
|
777 To install Hyperbole for use with InfoDock, XEmacs, GNU Emacs or Epoch, from
|
|
|
778 a shell:
|
|
|
779
|
|
|
780 @example
|
|
|
781 cd <HYPERBOLE-DIR>; make
|
|
|
782 @end example
|
|
|
783
|
|
|
784 @noindent
|
|
|
785 All of the .elc compiled Lisp files are already built for XEmacs and V19, so
|
|
|
786 this build will finish very quickly. If you really want to rebuild all of
|
|
|
787 the .elc files, use:
|
|
|
788
|
|
|
789 @example
|
|
|
790 cd <HYPERBOLE-DIR>; make all-elc
|
|
|
791 @end example
|
|
|
792
|
|
|
793 @cindex Postscript
|
|
|
794 @cindex manual, generating Postscript
|
|
|
795 @vindex file, man/hyperbole.ps
|
|
|
796 @noindent
|
|
|
797 To produce the Postscript version of the Hyperbole manual, you must have
|
|
|
798 the TeX formatter on your system:
|
|
|
799
|
|
|
800 @example
|
|
|
801 cd <HYPERBOLE-DIR>; make ps
|
|
|
802 @end example
|
|
|
803
|
|
|
804 @noindent
|
|
|
805 To install Hyperbole for use with GNU Emacs V18 or Epoch:
|
|
|
806
|
|
|
807 @example
|
|
|
808 cd <HYPERBOLE-DIR>; make all-elc-v18
|
|
|
809 @end example
|
|
|
810
|
|
|
811 @noindent
|
|
|
812 This will produce a complete set of Emacs V18 .elc files.
|
|
|
813
|
|
|
814
|
|
|
815 @node Installing, Configuring, Building, Installation
|
|
|
816 @section Installing
|
|
|
817
|
|
|
818 @cindex configuration
|
|
|
819 You may want to explore the Hyperbole configuration options before
|
|
|
820 installing it. @xref{Configuring}. If you just want to get up and
|
|
|
821 running quickly, however, there is no need to configure anything, just
|
|
|
822 follow these instructions to install Hyperbole.
|
|
|
823
|
|
|
824 @cindex Hyperbole, initializing
|
|
|
825 @cindex initializing Hyperbole
|
|
|
826 @cindex installation
|
|
|
827 @cindex site initialization
|
|
|
828 @vindex file, hsite.el
|
|
|
829 @vindex file, ~/.emacs
|
|
|
830 Add the following lines to a site initialization file such as
|
|
|
831 @file{site-start.el} to set up so that all users have Hyperbole
|
|
|
832 loaded for them when they run Emacs. Otherwise, each user will have to
|
|
|
833 add these lines to his own @file{~/.emacs} initialization file.
|
|
|
834
|
|
|
835 @cindex autoloading Hyperbole
|
|
|
836 @cindex Hyperbole, autoloading
|
|
|
837 @noindent
|
|
|
838 To autoload Hyperbole so that it loads only when needed:
|
|
|
839
|
|
|
840 @vindex hyperb:dir
|
|
|
841 @vindex file, hversion.el
|
|
|
842 @vindex file, hyperbole.el
|
|
|
843 @lisp
|
|
|
844 (defvar hyperb:dir "<HYPERBOLE-DIR>/")
|
|
|
845 "Directory where the Hyperbole executable code is kept.
|
|
|
846 It must end with a directory separator character.")
|
|
|
847
|
|
|
848 (load (expand-file-name "hversion" hyperb:dir))
|
|
|
849 (load (expand-file-name "hyperbole" hyperb:dir))
|
|
|
850 @end lisp
|
|
|
851
|
|
|
852 @cindex loading Hyperbole
|
|
|
853 @cindex Hyperbole, loading
|
|
|
854 This establishes a few key bindings and sets up Hyperbole to
|
|
|
855 automatically load whenever you activate its menu. If you would rather
|
|
|
856 have the whole Hyperbole system loaded when you start up so that you can
|
|
|
857 always use the Smart Keys and other facilities, add the additional line:
|
|
|
858
|
|
|
859 @lisp
|
|
|
860 (require 'hsite)
|
|
|
861 @end lisp
|
|
|
862
|
|
|
863 If you use mouse keys, be sure to add the above lines after any setup of
|
|
|
864 mouse key bindings, to ensure that Hyperbole's mouse keys are properly
|
|
|
865 initialized. @xref{Smart Keys}, for further details. If you use any
|
|
|
866 Hyperbole mail or news support, @ref{Buttons in Mail}, be certain to
|
|
|
867 perform all of your personal mail/news initializations before the point
|
|
|
868 at which you load Hyperbole. Otherwise, the mail/news support may not
|
|
|
869 be configured properly. For example, if you use the Emacs add-on
|
|
|
870 Supercite package, its setup should come before Hyperbole initialization.
|
|
|
871
|
|
|
872 @cindex Hyperbole manual
|
|
|
873 @noindent
|
|
|
874 The Hyperbole Manual is included in the distribution in two forms:
|
|
|
875
|
|
|
876 @cindex Info manual
|
|
|
877 @cindex Texinfo manual
|
|
|
878 @vindex file, man/hyperbole.info
|
|
|
879 @vindex file, man/hyperbole.texi
|
|
|
880 @example
|
|
|
881 @file{man/hyperbole.info} - online version
|
|
|
882 @file{man/hyperbole.texi} - source form
|
|
|
883 @end example
|
|
|
884
|
|
|
885 @vindex Info-directory-list
|
|
|
886 @noindent
|
|
|
887 To add pointers to the Info version of the Hyperbole manual within your
|
|
|
888 Info directory, follow these instructions. If @var{Info-directory-list}
|
|
|
889 is bound as a variable within your Emacs (all versions except V18 and
|
|
|
890 Epoch), then you can simply set it so that <HYPERBOLE-DIR> is an element
|
|
|
891 in the list:
|
|
|
892
|
|
|
893 @lisp
|
|
|
894 (setq Info-directory-list (cons "<HYPERBOLE-DIR>" Info-directory-list))
|
|
|
895 @end lisp
|
|
|
896
|
|
|
897 @noindent
|
|
|
898 Otherwise, from a shell:
|
|
|
899
|
|
|
900 @vindex Info-directory
|
|
|
901 @example
|
|
|
902 cd to the directory given by your @var{Info-directory} variable
|
|
|
903 rm hyperbole.info*; cp <HYPERBOLE-DIR>/man/hyperbole.info* .
|
|
|
904 @end example
|
|
|
905
|
|
|
906 @noindent
|
|
|
907 For all versions of Emacs, add an Info menu entry for the Hyperbole
|
|
|
908 manual in your Info @file{dir} file (the `*' should be placed in the
|
|
|
909 first column of the file):
|
|
|
910
|
|
|
911 @example
|
|
|
912 * Hyperbole:: GNU Emacs-based everyday information management system.
|
|
|
913 Use @{C-h h d d@} for a demonstration. Includes context-sensitive
|
|
|
914 mouse and keyboard support, a powerful rolodex, an autonumbered
|
|
|
915 outliner with hyperlink anchors for each outline cell, and extensible
|
|
|
916 hypertext facilities including hyper-links in mail and news messages.
|
|
|
917 @end example
|
|
|
918
|
|
|
919 @cindex invoking Hyperbole
|
|
|
920 @cindex starting Hyperbole
|
|
|
921 @cindex Hyperbole, starting
|
|
|
922 @cindex Hyperbole main menu
|
|
|
923 @kindex C-h h
|
|
|
924 @findex hyperbole
|
|
|
925 That's all there is to the installation. Once Hyperbole has been
|
|
|
926 installed for use at your site, you can invoke it with @{@kbd{C-h h}@}
|
|
|
927 or @{@kbd{M-x hyperbole @key{RET}}@} to bring up the Hyperbole main menu
|
|
|
928 in the minibuffer window.
|
|
|
929
|
|
|
930
|
|
|
931 @node Configuring, , Installing, Installation
|
|
|
932 @section Configuring
|
|
|
933
|
|
|
934 @cindex configuration
|
|
|
935 @vindex file, hyperbole.el
|
|
|
936 @vindex file, hsite.el
|
|
|
937 There are many Hyperbole configuration options that may be changed by
|
|
|
938 editing the @file{hyperbole.el} and @file{hsite.el} files in the
|
|
|
939 @file{hyperbole/} directory. The following sections discuss the
|
|
|
940 configuration options most likely to be of interest to users.
|
|
|
941
|
|
|
942 @menu
|
|
|
943 * Internal Viewers::
|
|
|
944 * External Viewers::
|
|
|
945 * Link Variable Substitution::
|
|
|
946 * Button Colors::
|
|
|
947 @end menu
|
|
|
948
|
|
|
949
|
|
|
950 @node Internal Viewers, External Viewers, Configuring, Configuring
|
|
|
951 @subsection Internal Viewers
|
|
|
952 @vindex hpath:display-alist
|
|
|
953 @vindex file, hsite.el
|
|
|
954 @cindex file display function
|
|
|
955 @cindex display function
|
|
|
956 @cindex internal viewer
|
|
|
957 @cindex link, display function
|
|
|
958 When given a file name, Hyperbole will by default display the file for
|
|
|
959 editing within an Emacs buffer. The @var{hpath:display-alist} variable
|
|
|
960 can be used to specify file name patterns, such as matching suffixes,
|
|
|
961 which will invoke a special Emacs Lisp function to display any matching
|
|
|
962 files within Emacs. This can be used to format raw data files for
|
|
|
963 convenient display.
|
|
|
964
|
|
|
965 Configure the @var{hpath:display-alist} variable in @file{hsite.el}.
|
|
|
966 Its value is an association list whose elements are
|
|
|
967 (<file-name-regular-expression> . <function-of-one-arg>) pairs. Any
|
|
|
968 path whose name matches a <file-name-regular-expression> will be
|
|
|
969 displayed by calling the associated <function-of-one-arg> with the file
|
|
|
970 name as the argument.@refill
|
|
|
971
|
|
|
972 @xref{External Viewers}, for instructions on associating file names with
|
|
|
973 external, window-system specific viewers.
|
|
|
974
|
|
|
975 @node External Viewers, Link Variable Substitution, Internal Viewers, Configuring
|
|
|
976 @subsection External Viewers
|
|
|
977 @vindex hpath:find-alist
|
|
|
978 @vindex file, hsite.el
|
|
|
979 @cindex window system
|
|
|
980 @cindex external program
|
|
|
981 @cindex external viewer
|
|
|
982 @cindex link, viewer program
|
|
|
983 If you will be using Hyperbole under a window system, you may want to
|
|
|
984 configure the @var{hpath:find-alist} variable in @file{hsite.el} to
|
|
|
985 support hyperlinks which open files using non-Emacs tools, e.g@. a
|
|
|
986 fax reader or a bitmap viewer.
|
|
|
987
|
|
|
988 The value of @var{hpath:find-alist} is determined when Hyperbole is
|
|
|
989 initialized based upon the current window system and the version of
|
|
|
990 Emacs in use. The value is an association list whose elements are
|
|
|
991 (<file-name-regular-expression> . <viewer-program>) pairs. Any path
|
|
|
992 whose name matches a <file-name-regular-expression> will be
|
|
|
993 displayed using the corresponding viewer-program. If a <viewer-program>
|
|
|
994 entry contains a @code{%s} string, the filename to display will be
|
|
|
995 substituted at that point within the string. Otherwise, the filename
|
|
|
996 will be appended to the <viewer-program> entry. See the "x-suffixes"
|
|
|
997 and "nextstep-suffixes" settings within the definition of
|
|
|
998 @var{hpath:find-alist} as examples.@refill
|
|
|
999
|
|
|
1000 @node Link Variable Substitution, Button Colors, External Viewers, Configuring
|
|
|
1001 @subsection Link Variable Substitution
|
|
|
1002 @vindex hpath:variables
|
|
|
1003 @cindex environment variables
|
|
|
1004 @cindex Emacs Lisp variables
|
|
|
1005 @cindex Lisp variables
|
|
|
1006 Another variable to consider modifying in the @file{hsite.el} file is
|
|
|
1007 @var{hpath:variables}. This variable consists of a list of Emacs Lisp
|
|
|
1008 variable names, each of which may have a pathname or a list of pathnames
|
|
|
1009 as a value. Whenever a Hyperbole file or directory link button is
|
|
|
1010 created, its pathname is compared against the values in
|
|
|
1011 @var{hpath:variables}. The first match found, if any, is selected and
|
|
|
1012 its associated variable name is substituted into the link pathname, in
|
|
|
1013 place of its literal value. When the link is resolved (the button is
|
|
|
1014 activated), Hyperbole replaces each variable with the first matching
|
|
|
1015 value from this list. (Environment variables are also replaced whenever
|
|
|
1016 link paths are resolved.
|
|
|
1017
|
|
|
1018 This permits sharing of links over wide areas, where the variable values
|
|
|
1019 may differ between link creator and link activator. The entire process
|
|
|
1020 is wholly transparent to the user; it is explained here simply to help
|
|
|
1021 you in deciding whether or not to modify the value of
|
|
|
1022 @var{hpath:variables}.
|
|
|
1023
|
|
|
1024 @node Button Colors, , Link Variable Substitution, Configuring
|
|
|
1025 @subsection Configuring Button Colors
|
|
|
1026 @cindex XEmacs support
|
|
|
1027 @cindex Emacs 19 support
|
|
|
1028 @cindex Epoch support
|
|
|
1029 @cindex button highlighting
|
|
|
1030 @cindex button flashing
|
|
|
1031 @vindex file, hui-ep*.el
|
|
|
1032 @findex hproperty:cycle-but-color
|
|
|
1033 When Hyperbole is run under a window system together with Emacs 19,
|
|
|
1034 XEmacs or Epoch, it automatically highlights any explicit buttons in
|
|
|
1035 a buffer and makes them flash when selected. The main setting
|
|
|
1036 you may want change is the selection of a color (or style) for button
|
|
|
1037 highlighting and button flashing. See the @file{hui-*-b*.el} files for
|
|
|
1038 lists of potential colors and the code which supports this behavior. A
|
|
|
1039 call to @code{(hproperty:cycle-but-color)} within a Hyperbole
|
|
|
1040 initialization sequence in the @file{hsite.el} file changes the color
|
|
|
1041 used to highlight and flash explicit buttons.
|
|
|
1042
|
|
|
1043 @cindex button emphasis
|
|
|
1044 @vindex hproperty:but-emphasize-p
|
|
|
1045 @vindex file, hsite.el
|
|
|
1046 Additionally, under XEmacs and Emacs 19, if @var{hproperty:but-emphasize-p}
|
|
|
1047 is set to @code{t} in @file{hsite.el}, then whenever the mouse pointer
|
|
|
1048 moves over an explicit button, it will be emphasized in a different
|
|
|
1049 color or style. This emphasis is in addition to any non-mouse-sensitive
|
|
|
1050 button highlighting.
|
|
|
1051
|
|
|
1052 @cindex button highlighting, forcing
|
|
|
1053 @findex hproperty:but-create
|
|
|
1054 If you read in a file with explicit buttons before you load Hyperbole,
|
|
|
1055 these buttons won't be highlighted. Load Hyperbole and then use
|
|
|
1056 @code{M-x hproperty:but-create @key{RET}} to highlight the buttons in
|
|
|
1057 the current buffer.
|
|
|
1058
|
|
|
1059
|
|
|
1060 @node Buttons, Smart Keys, Installation, Top
|
|
|
1061 @chapter Buttons
|
|
|
1062
|
|
|
1063 This chapter explains the user-level notion of Hyperbole buttons.
|
|
|
1064 Hyperbole buttons that are stored in files persist across Emacs
|
|
|
1065 sessions, so they provide a convenient means of linking from one
|
|
|
1066 information source to another.
|
|
|
1067
|
|
|
1068 @menu
|
|
|
1069 * Explicit Buttons::
|
|
|
1070 * Global Buttons::
|
|
|
1071 * Implicit Buttons::
|
|
|
1072 * Action Types::
|
|
|
1073 * Button Type Precedence::
|
|
|
1074 * Button Files::
|
|
|
1075 * Utilizing Explicit Buttons::
|
|
|
1076 @end menu
|
|
|
1077
|
|
|
1078 @node Explicit Buttons, Global Buttons, Buttons, Buttons
|
|
|
1079 @section Explicit Buttons
|
|
|
1080
|
|
|
1081 @cindex explicit button
|
|
|
1082 @cindex button, explicit
|
|
|
1083 @cindex button label
|
|
|
1084 Hyperbole creates and manages @emph{explicit buttons} which look like
|
|
|
1085 this @code{<(fake button)>} to a Hyperbole user. They are quickly
|
|
|
1086 recognizable, yet relatively non-distracting as one scans the text in
|
|
|
1087 which they are embedded. The text between the @code{<(} and
|
|
|
1088 @code{)>} delimiters is called the @dfn{button label}. Spacing between
|
|
|
1089 words within a button label is irrelevant to Hyperbole, so button labels
|
|
|
1090 may wrap across several lines without causing a problem.
|
|
|
1091
|
|
|
1092 @cindex button data
|
|
|
1093 @cindex button attribute
|
|
|
1094 @vindex file, .hypb
|
|
|
1095 Hyperbole stores the @dfn{button data} that gives an explicit button its
|
|
|
1096 behavior, separately from the button label, in a file named @file{.hypb}
|
|
|
1097 within the same directory as the file in which the button is created.
|
|
|
1098 Thus, all files in the same directory share a common button data file.
|
|
|
1099 Button data is comprised of individual @dfn{button attribute} values. A
|
|
|
1100 user never sees this data in its raw form but may see a formatted
|
|
|
1101 version by asking for help on a button.
|
|
|
1102
|
|
|
1103 @cindex button, moving
|
|
|
1104 @cindex moving buttons
|
|
|
1105 Explicit buttons may be freely moved about within the buffer in which
|
|
|
1106 they are created. (No present support exists for moving buttons between
|
|
|
1107 buffers). A single button may also appear multiple times within the
|
|
|
1108 same buffer; one simply copies the button label with its delimiters
|
|
|
1109 to a new location in such cases.
|
|
|
1110
|
|
|
1111 Each explicit button is assigned an action type which determines the
|
|
|
1112 actions that it performs. @dfn{Link action types} connect buttons to
|
|
|
1113 particular types of referents. @dfn{Activation} of such buttons then
|
|
|
1114 displays the referents.
|
|
|
1115
|
|
|
1116 @cindex linking, in-place
|
|
|
1117 @cindex Hyperbole data model
|
|
|
1118 Hyperbole does not manage referent data; this is left to the
|
|
|
1119 applications that generate the data. This means that Hyperbole
|
|
|
1120 provides in-place linking and does not require reformatting of data to
|
|
|
1121 integrate it with a Hyperbole framework.
|
|
|
1122
|
|
|
1123 @node Global Buttons, Implicit Buttons, Explicit Buttons, Buttons
|
|
|
1124 @section Global Buttons
|
|
|
1125
|
|
|
1126 @cindex global button
|
|
|
1127 @cindex button, global
|
|
|
1128 @cindex button label
|
|
|
1129 Access to explicit buttons depends upon the information on your screen
|
|
|
1130 since they are embedded within particular buffers. Sometimes it is
|
|
|
1131 useful to activate buttons without regard to the information with which
|
|
|
1132 you are presently working. In such instances, you use @dfn{global
|
|
|
1133 buttons}, which are simply explicit buttons which may be activated or
|
|
|
1134 otherwise operated upon by entering their labels when they are prompted
|
|
|
1135 for, rather than selecting the buttons within a buffer.
|
|
|
1136
|
|
|
1137 If you want a permanent link to a file section that you can follow at
|
|
|
1138 any time, you can use a global button. Or what about an Emacs keyboard
|
|
|
1139 macro that you use frequently? Create an @code{exec-kbd-macro} button
|
|
|
1140 with an easy to type name and then you can easily activate it whenever
|
|
|
1141 the need arises.
|
|
|
1142
|
|
|
1143 @node Implicit Buttons, Action Types, Global Buttons, Buttons
|
|
|
1144 @section Implicit Buttons
|
|
|
1145
|
|
|
1146 @cindex button, implicit
|
|
|
1147 @cindex implicit button
|
|
|
1148 Implicit buttons are those defined by the natural structure of a
|
|
|
1149 document. They are identified by contextual patterns which limit the
|
|
|
1150 locations or states in which they can appear. Their behavior is
|
|
|
1151 determined by one or more actions which they trigger when activated. An
|
|
|
1152 action is derived from either a Hyperbole action type specification,
|
|
|
1153 @ref{Action Types}, or an Emacs Lisp function. Implicit
|
|
|
1154 button types may use the same action types that explicit buttons do.
|
|
|
1155
|
|
|
1156 @vindex file, hibtypes.el
|
|
|
1157 @cindex context
|
|
|
1158 Implicit buttons never have any button data associated with them. They
|
|
|
1159 are recognized in context based on predicate matches defined within
|
|
|
1160 implicit button types. For example, Hyperbole recognizes file names
|
|
|
1161 enclosed in double quotes and can quickly display their associated files
|
|
|
1162 in response to simple mouse clicks.
|
|
|
1163
|
|
|
1164 @cindex ibtypes, list of
|
|
|
1165 @noindent
|
|
|
1166 See @file{hibtypes.el} for complete examples. Standard implicit button
|
|
|
1167 types include (in alphabetical order):
|
|
|
1168
|
|
|
1169 @table @code
|
|
|
1170
|
|
|
1171 @item annot-bib
|
|
|
1172 @findex ibtypes::annot-bib
|
|
|
1173 @cindex bibliography
|
|
|
1174 @cindex reference
|
|
|
1175 Displays annotated bibliography entries referenced internally, delimeters = [].
|
|
|
1176 References must be delimited by square brackets, must begin with a
|
|
|
1177 word constituent character, and must not be in buffers whose
|
|
|
1178 names begin with a ' ' or '*' character.
|
|
|
1179
|
|
|
1180 @item completion
|
|
|
1181 @findex ibtypes::completion
|
|
|
1182 @cindex completion
|
|
|
1183 Inserts completion at point into minibuffer or other window.
|
|
|
1184
|
|
|
1185 @item dir-summary
|
|
|
1186 @findex ibtypes::dir-summary
|
|
|
1187 @vindex file, MANIFEST
|
|
|
1188 @vindex file, DIR
|
|
|
1189 Detects filename buttons in files named "MANIFEST" or "DIR".
|
|
|
1190 Displays selected files.
|
|
|
1191 Each file name must be at the beginning of the line and must be followed
|
|
|
1192 by one or more spaces and then another non-space, non-parenthesis, non-brace
|
|
|
1193 character.
|
|
|
1194
|
|
|
1195 @item doc-id
|
|
|
1196 @findex ibtypes::doc-id
|
|
|
1197 @cindex online library
|
|
|
1198 @cindex document identifier
|
|
|
1199 Displays an index entry for a site-specific document given its id. Ids
|
|
|
1200 must be delimited by 'doc-id-start' and 'doc-id-end' and must match the
|
|
|
1201 function given by 'doc-id-p'. This permits creation of catalogued
|
|
|
1202 online libraries. See @file{$@{hyperb:dir@}/hib-doc-id.el} for more
|
|
|
1203 information.@refill
|
|
|
1204
|
|
|
1205 @item elisp-compiler-msg
|
|
|
1206 @findex ibtypes::elisp-compiler-msg
|
|
|
1207 @cindex byte compiler error
|
|
|
1208 @cindex Emacs Lisp compiler error
|
|
|
1209 @cindex compiler error
|
|
|
1210 Jumps to source code for definition associated with byte-compiler error
|
|
|
1211 message. Works when activated anywhere within an error line.
|
|
|
1212
|
|
|
1213 @item debugger-source
|
|
|
1214 @findex ibtypes::debugger-source
|
|
|
1215 @cindex gdb
|
|
|
1216 @cindex dbx
|
|
|
1217 @cindex xdb
|
|
|
1218 @cindex stack frame
|
|
|
1219 @cindex breakpoint
|
|
|
1220 @cindex source line
|
|
|
1221 Jumps to source line associated with debugger stack frame or breakpoint lines.
|
|
|
1222 This works with gdb, dbx, and xdb. Such lines are recognized in any buffer.
|
|
|
1223
|
|
|
1224 @item grep-msg
|
|
|
1225 @findex ibtypes::grep-msg
|
|
|
1226 @cindex grep
|
|
|
1227 @cindex compiler error
|
|
|
1228 Jumps to line associated with grep or compilation error msgs.
|
|
|
1229 Messages are recognized in any buffer.
|
|
|
1230
|
|
|
1231 @item hyp-address
|
|
|
1232 @findex ibtypes::hyp-address
|
|
|
1233 @cindex Hyperbole mail list
|
|
|
1234 Turns a Hyperbole e-mail list address into an implicit button which
|
|
|
1235 inserts Hyperbole environment information.
|
|
|
1236 Useful when sending mail to a Hyperbole mail list. See also the
|
|
|
1237 documentation for @code{actypes::hyp-config}.
|
|
|
1238
|
|
|
1239 @item hyp-source
|
|
|
1240 @findex ibtypes::hyp-source
|
|
|
1241 @cindex Hyperbole report
|
|
|
1242 Turns source location entries in Hyperbole reports into buttons that jump to the associated location.
|
|
|
1243
|
|
|
1244 @item Info-node
|
|
|
1245 @findex ibtypes::Info-node
|
|
|
1246 @cindex Info node
|
|
|
1247 Makes "(file)node" buttons display the associated Info node.
|
|
|
1248
|
|
|
1249 @item kbd-key
|
|
|
1250 @findex ibtypes::kbd-key
|
|
|
1251 @cindex key sequence
|
|
|
1252 Executes a key sequence delimited by curly braces.
|
|
|
1253 Key sequences should be in human readable form, e.g@. @{@kbd{C-b}@}.
|
|
|
1254 Forms such as @{@}, @{@}, and @{^b@} will not be recognized.
|
|
|
1255
|
|
|
1256 @item klink
|
|
|
1257 @findex ibtypes::klink
|
|
|
1258 @cindex klink
|
|
|
1259 @cindex koutline link
|
|
|
1260 @cindex kcell link
|
|
|
1261 Follows a link delimited by <> to a koutline cell.
|
|
|
1262 See documentation for @code{actypes::link-to-kotl} for valid link
|
|
|
1263 specifiers.
|
|
|
1264
|
|
|
1265 @item mail-address
|
|
|
1266 @findex ibtypes::mail-address
|
|
|
1267 @cindex e-mail address
|
|
|
1268 @cindex rolodex address
|
|
|
1269 @cindex address
|
|
|
1270 If on an e-mail address in a specific buffer type, mail to that address
|
|
|
1271 in another window. Applies to the rolodex match buffer, any buffer
|
|
|
1272 attached to a file in @var{rolo-file-list}, or any buffer with @file{mail}
|
|
|
1273 or @file{rolo} (case-insensitive) within its name.
|
|
|
1274
|
|
|
1275 @item man-apropos
|
|
|
1276 @findex ibtypes::man-apropos
|
|
|
1277 @item UNIX manual
|
|
|
1278 @item man pages
|
|
|
1279 @item man apropos
|
|
|
1280 Makes man apropos entries display associated man pages when selected.
|
|
|
1281
|
|
|
1282 @item patch-msg
|
|
|
1283 @findex ibtypes::patch-msg
|
|
|
1284 @cindex patch output
|
|
|
1285 Jumps to source code associated with output from the @code{patch}
|
|
|
1286 program. Patch applies diffs to source code.
|
|
|
1287
|
|
|
1288 @item pathname
|
|
|
1289 @findex ibtypes::pathname
|
|
|
1290 @findex hpath:at-p
|
|
|
1291 @findex hpath:find
|
|
|
1292 @vindex hpath:suffixes
|
|
|
1293 @cindex ange-ftp
|
|
|
1294 @cindex efs
|
|
|
1295 @cindex pathname
|
|
|
1296 @cindex remote path
|
|
|
1297 @cindex filename
|
|
|
1298 @cindex link, pathname
|
|
|
1299 Makes a delimited, valid pathname display the path entry.
|
|
|
1300 Also works for delimited and non-delimited ange-ftp and efs pathnames.
|
|
|
1301 See @code{hpath:at-p} function documentation for possible delimiters.
|
|
|
1302 See @var{hpath:suffixes} variable documentation for suffixes that are
|
|
|
1303 added to or removed from pathname when searching for a valid match.
|
|
|
1304 See @code{hpath:find} function documentation and
|
|
|
1305 @var{hpath:display-alist} and @var{hpath:find-alist} variable
|
|
|
1306 documentation for special file display options.
|
|
|
1307
|
|
|
1308 @item rfc
|
|
|
1309 @findex ibtypes::rfc
|
|
|
1310 @cindex Internet RFC
|
|
|
1311 @cindex Request For Comment
|
|
|
1312 @cindex RFC
|
|
|
1313 @cindex ange-ftp
|
|
|
1314 @cindex efs
|
|
|
1315 Retrieves and displays an Internet rfc referenced at point.
|
|
|
1316 Requires ange-ftp or efs when needed for remote retrievals. The
|
|
|
1317 following formats are recognized: RFC822, rfc-822, and RFC 822. The
|
|
|
1318 @var{hpath:rfc} variable specifies the location from which to retrieve
|
|
|
1319 RFCs."
|
|
|
1320
|
|
|
1321 @item rfc-toc
|
|
|
1322 @findex ibtypes::rfc-toc
|
|
|
1323 @cindex Internet RFC
|
|
|
1324 @cindex Request For Comment
|
|
|
1325 @cindex RFC
|
|
|
1326 @cindex table of contents
|
|
|
1327 Summarizes contents of an Internet rfc from anywhere within rfc buffer.
|
|
|
1328 Each line in summary may be selected to jump to section.
|
|
|
1329
|
|
|
1330 @item text-toc
|
|
|
1331 @findex ibtypes::text-toc
|
|
|
1332 @cindex table of contents
|
|
|
1333 @cindex toc implicit button type
|
|
|
1334 Jumps to the text file section referenced by a table of contents entry
|
|
|
1335 at point. File name must contain @file{README} and there must be a
|
|
|
1336 `Table of Contents' or `Contents' label on a line by itself (it may
|
|
|
1337 begin with an asterisk), preceding the table of contents. Each toc
|
|
|
1338 entry must begin with some whitespace followed by one or more asterisk
|
|
|
1339 characters. Each file section name line must start with one or more
|
|
|
1340 asterisk characters at the very beginning of the line.
|
|
|
1341
|
|
|
1342 @item www-url
|
|
|
1343 @findex ibtypes::www-url
|
|
|
1344 @cindex URL
|
|
|
1345 @cindex World-wide Web
|
|
|
1346 @cindex WWW
|
|
|
1347 @cindex Action Key, web browsing
|
|
|
1348 @kindex Action Key, web browsing
|
|
|
1349 @vindex action-key-url-function
|
|
|
1350 When not in a w3 browser buffer, follow any non-ftp url (link) at point.
|
|
|
1351 The variable, @var{action-key-url-function}, can be used to customize
|
|
|
1352 the url browser that is used.
|
|
|
1353 @end table
|
|
|
1354
|
|
|
1355 The Hyperbole Smart Keys offer extensive additional context-sensitive
|
|
|
1356 point-and-click type behavior beyond these standard implicit button
|
|
|
1357 types. @xref{Smart Keys}.
|
|
|
1358
|
|
|
1359
|
|
|
1360 @node Action Types, Button Type Precedence, Implicit Buttons, Buttons
|
|
|
1361 @section Action Types
|
|
|
1362
|
|
|
1363 @cindex action type
|
|
|
1364 @cindex argument, use
|
|
|
1365 @cindex action
|
|
|
1366 @dfn{Action types} provide action procedures that specify button behavior.
|
|
|
1367 The arguments needed by an action type are prompted for at button creation
|
|
|
1368 time. When a button is activated, the stored arguments are fed to the
|
|
|
1369 action type's @dfn{action} body to achieve the desired result. Hyperbole
|
|
|
1370 handles all of this transparently.
|
|
|
1371
|
|
|
1372 @cindex actypes, list of
|
|
|
1373 @noindent
|
|
|
1374 Standard action types in alphabetical order include:
|
|
|
1375
|
|
|
1376 @table @code
|
|
|
1377 @item annot-bib
|
|
|
1378 @findex actypes::annot-bib
|
|
|
1379 Follows internal ref KEY within an annotated bibliography, delimiters=[].
|
|
|
1380
|
|
|
1381 @item completion
|
|
|
1382 @findex actypes::completion
|
|
|
1383 Inserts completion at point into minibuffer or other window.
|
|
|
1384 Unless at end of buffer or if completion has already been inserted, then
|
|
|
1385 deletes completions window.
|
|
|
1386
|
|
|
1387 @item eval-elisp
|
|
|
1388 @findex actypes::eval-elisp
|
|
|
1389 Evaluates a Lisp expression LISP-EXPR.
|
|
|
1390
|
|
|
1391 @item exec-kbd-macro
|
|
|
1392 @findex actypes::exec-kbd-macro
|
|
|
1393 Executes KBD-MACRO REPEAT-COUNT times.
|
|
|
1394 KBD-MACRO may be a string of editor command characters or a function symbol.
|
|
|
1395 Optional REPEAT-COUNT nil means execute once, zero means repeat until
|
|
|
1396 error.
|
|
|
1397
|
|
|
1398 @item exec-shell-cmd
|
|
|
1399 @findex actypes::exec-shell-cmd
|
|
|
1400 Executes a SHELL-CMD string asynchronously.
|
|
|
1401 Optional non-nil second argument INTERNAL-CMD means do not display the shell
|
|
|
1402 command line executed. Optional non-nil third argument KILL-PREV means
|
|
|
1403 kill last output to shell buffer before executing SHELL-CMD.
|
|
|
1404
|
|
|
1405 @item exec-window-cmd
|
|
|
1406 @findex actypes::exec-window-cmd
|
|
|
1407 Executes an external window-based SHELL-CMD string asynchronously.
|
|
|
1408
|
|
|
1409 @item hyp-config
|
|
|
1410 @findex actypes::hyp-config
|
|
|
1411 Inserts Hyperbole configuration info at end of optional OUT-BUF or current.
|
|
|
1412
|
|
|
1413 @item hyp-request
|
|
|
1414 @findex actypes::hyp-request
|
|
|
1415 Inserts Hyperbole mail list request help into optional OUT-BUF or current.
|
|
|
1416
|
|
|
1417 @item hyp-source
|
|
|
1418 @findex actypes::hyp-source
|
|
|
1419 Displays a buffer or file from a line beginning with 'hbut:source-prefix'.
|
|
|
1420
|
|
|
1421 @item kbd-key
|
|
|
1422 @findex actypes::kbd-key
|
|
|
1423 Executes the function binding for KEY-SEQUENCE, delimited by @{@}.
|
|
|
1424 Returns t if a KEY-SEQUENCE has a binding, else nil.
|
|
|
1425
|
|
|
1426 @item link-to-buffer-tmp
|
|
|
1427 @findex actypes::link-to-buffer-tmp
|
|
|
1428 Displays a BUFFER in another window.
|
|
|
1429 Link is generally only good for current Emacs session.
|
|
|
1430 Use 'link-to-file' instead for a permanent link.
|
|
|
1431
|
|
|
1432 @item link-to-directory
|
|
|
1433 @findex actypes::link-to-directory
|
|
|
1434 Displays a DIRECTORY in Dired mode in another window.
|
|
|
1435
|
|
|
1436 @item link-to-doc
|
|
|
1437 @findex actypes::link-to-doc
|
|
|
1438 Displays online version of a document given by DOC-ID, in other window.
|
|
|
1439 If the online version of a document is not found in
|
|
|
1440 @var{doc-id-indices}, an error is signalled.
|
|
|
1441
|
|
|
1442 @item link-to-ebut
|
|
|
1443 @findex actypes::link-to-ebut
|
|
|
1444 Performs action given by another button, specified by KEY and KEY-FILE.
|
|
|
1445
|
|
|
1446 @item link-to-elisp-doc
|
|
|
1447 @findex actypes::link-to-elisp-doc
|
|
|
1448 Displays documentation for FUNC-SYMBOL.
|
|
|
1449
|
|
|
1450 @item link-to-file
|
|
|
1451 @findex actypes::link-to-file
|
|
|
1452 Displays a PATH in another window scrolled to optional POINT.
|
|
|
1453 With POINT, buffer is displayed with POINT at the top of the window.
|
|
|
1454
|
|
|
1455 @item link-to-file-line
|
|
|
1456 @findex actypes::link-to-file-line
|
|
|
1457 Displays a PATH in another window scrolled to LINE-NUM.
|
|
|
1458
|
|
|
1459 @item link-to-kcell
|
|
|
1460 @findex actypes::link-to-kcell
|
|
|
1461 Displays FILE with kcell given by CELL-REF at the top of the window.
|
|
|
1462 CELL-REF may be a kcell's display label or its permanant idstamp.
|
|
|
1463 If FILE is nil, the current buffer is used.
|
|
|
1464 If CELL-REF is nil, the first cell in the view is shown.
|
|
|
1465
|
|
|
1466 @item link-to-kotl
|
|
|
1467 @findex actypes::link-to-kotl
|
|
|
1468 Displays at the top of another window the referent pointed to by LINK.
|
|
|
1469 LINK may be of any of the following forms, with or without delimiters:
|
|
|
1470 @example
|
|
|
1471 < pathname [, cell-ref] >
|
|
|
1472 < [-!&] pathname >
|
|
|
1473 < @@ cell-ref >
|
|
|
1474 @end example
|
|
|
1475
|
|
|
1476 @noindent
|
|
|
1477 See documentation for @code{kcell:ref-to-id} for valid cell-ref formats.
|
|
|
1478
|
|
|
1479
|
|
|
1480 @item link-to-Info-node
|
|
|
1481 @findex actypes::link-to-Info-node
|
|
|
1482 Displays an Info NODE in another window.
|
|
|
1483 NODE must be a string of the form '(file)nodename'.
|
|
|
1484
|
|
|
1485 @item link-to-mail
|
|
|
1486 @findex actypes::link-to-mail
|
|
|
1487 Displays mail msg with MAIL-MSG-ID from MAIL-FILE in other window.
|
|
|
1488 See documentation for the variable @var{hmail:init-function} for
|
|
|
1489 information on how to specify a mail reader to use.
|
|
|
1490
|
|
|
1491 @item link-to-regexp-match
|
|
|
1492 @findex actypes::link-to-regexp-match
|
|
|
1493 Finds REGEXP's Nth occurrence in FILE and displays location at window top.
|
|
|
1494 Returns t if found, signals an error if not.
|
|
|
1495
|
|
|
1496 @item link-to-rfc
|
|
|
1497 @findex actypes::link-to-rfc
|
|
|
1498 Retrieves and displays an Internet rfc given by RFC-NUM.
|
|
|
1499 RFC-NUM may be a string or an integer. Requires ange-ftp or efs for
|
|
|
1500 remote retrievals.
|
|
|
1501
|
|
|
1502 @item link-to-string-match
|
|
|
1503 @findex actypes::link-to-string-match
|
|
|
1504 Finds STRING's Nth occurrence in FILE and displays location at window top.
|
|
|
1505 Returns t if found, nil if not.
|
|
|
1506
|
|
|
1507 @item man-show
|
|
|
1508 @findex actypes::man-show
|
|
|
1509 Displays man page on TOPIC, which may be of the form @code{<command>(<section>}).
|
|
|
1510
|
|
|
1511 @item rfc-toc
|
|
|
1512 @findex actypes::rfc-toc
|
|
|
1513 Computes and displays summary of an Internet rfc in BUF-NAME.
|
|
|
1514 Assumes point has already been moved to start of region to summarize.
|
|
|
1515 Optional OPOINT is point to return to in BUF-NAME after displaying summary.
|
|
|
1516
|
|
|
1517 @item text-toc
|
|
|
1518 @findex actypes::text-toc
|
|
|
1519 @cindex table of contents
|
|
|
1520 @cindex toc action type
|
|
|
1521 Jumps to the text file SECTION referenced by a table of contents entry
|
|
|
1522 at point.
|
|
|
1523
|
|
|
1524 @item www-url
|
|
|
1525 @findex actypes::www-url
|
|
|
1526 @cindex URL
|
|
|
1527 @cindex World-wide Web
|
|
|
1528 @cindex WWW
|
|
|
1529 @vindex action-key-url-function
|
|
|
1530 Follows a link given by URL.
|
|
|
1531 The variable, @var{action-key-url-function}, can be used to customize
|
|
|
1532 the url browser that is used.
|
|
|
1533 @end table
|
|
|
1534
|
|
|
1535 @cindex action
|
|
|
1536 @vindex hui:ebut-prompt-for-action
|
|
|
1537 The use of action types provides a convenient way of specifying button
|
|
|
1538 behavior without the need to know how to program. Expert users who are
|
|
|
1539 familiar with Emacs Lisp, however, may find that they often want to
|
|
|
1540 tailor button actions in a variety of ways not easily captured within a
|
|
|
1541 type system. In such cases, @var{hui:ebut-prompt-for-action} should be
|
|
|
1542 set non-nil. This will cause Hyperbole to prompt for an action to
|
|
|
1543 override the button's action type at each explicit button creation. For
|
|
|
1544 those cases where the action type is sufficient, a nil value should be
|
|
|
1545 entered for the action. An action may be any Lisp form that may be
|
|
|
1546 evaluated.
|
|
|
1547
|
|
|
1548 @node Button Type Precedence, Button Files, Action Types, Buttons
|
|
|
1549 @section Button Type Precedence
|
|
|
1550
|
|
|
1551 @cindex button precedence
|
|
|
1552 @cindex button label overlap
|
|
|
1553 Explicit buttons always take precedence over implicit buttons. Thus, if
|
|
|
1554 a button selection is made which falls within both an explicit and
|
|
|
1555 implicit button, only the explicit button will be selected. Explicit
|
|
|
1556 button labels are not allowed to overlap; Hyperbole's behavior in such
|
|
|
1557 cases is undefined.
|
|
|
1558
|
|
|
1559 @cindex ibtype, evaluation order
|
|
|
1560 If there is no explicit button at point during a selection request, then
|
|
|
1561 each implicit button type predicate is tested in turn until one returns
|
|
|
1562 non-nil or all are exhausted. Since two implicit button types may have
|
|
|
1563 overlapping domains (those contexts in which their predicates are true),
|
|
|
1564 only the first matching type is used. The type predicates are tested
|
|
|
1565 in @strong{reverse} order of definition, i.e@. most recently entered
|
|
|
1566 types are tested first, so that personal types defined after standard
|
|
|
1567 system types take precedence. It is important to keep this order in
|
|
|
1568 mind when defining new implicit button types. By making their match
|
|
|
1569 predicates as specific as possible, one can minimize any overlapping of
|
|
|
1570 implicit button type domains.
|
|
|
1571
|
|
|
1572 @cindex type redefinition
|
|
|
1573 Once a type name is defined, its precedence relative to other types
|
|
|
1574 remains the same even if you redefine the body of the type, as long as
|
|
|
1575 you don't change its name. This allows incremental modifications to
|
|
|
1576 types without having to worry about shifts in type precedence.
|
|
|
1577 @xref{Creating Types}, for information on how to develop
|
|
|
1578 or modify types.
|
|
|
1579
|
|
|
1580 @node Button Files, Utilizing Explicit Buttons, Button Type Precedence, Buttons
|
|
|
1581 @section Button Files
|
|
|
1582
|
|
|
1583 @cindex button files
|
|
|
1584 It is often convenient to create lists of buttons that can be used as
|
|
|
1585 menus to provide centralized access to distributed information pools or
|
|
|
1586 for other purposes. These files can serve as useful roadmaps to help
|
|
|
1587 efficiently guide a user through both unfamiliar and highly familiar
|
|
|
1588 information spaces. Files that are created specifically for this
|
|
|
1589 purpose, we call @dfn{button files}.
|
|
|
1590
|
|
|
1591 @vindex hbmap:filename
|
|
|
1592 @cindex button file, personal
|
|
|
1593 @cindex button file, directory
|
|
|
1594 The Hyperbole menu system provides quick access to two types of these
|
|
|
1595 button files: personal and directory-specific, through the ButFile menu.
|
|
|
1596 (The variable, @var{hbmap:filename}, contains the base name of these
|
|
|
1597 standard button files. Its standard value is @file{HYPB}.)
|
|
|
1598
|
|
|
1599 @vindex dir, ~/.hyperb
|
|
|
1600 @vindex hbmap:dir-user
|
|
|
1601 @cindex global button
|
|
|
1602 A personal button file may serve as a user's own roadmap to frequently
|
|
|
1603 used resources. Selection of the ButFile/PersonalFile menu item
|
|
|
1604 displays this file for editing. The default personal button file is
|
|
|
1605 stored within the directory given by the @var{hbmap:dir-user} variable
|
|
|
1606 whose standard value is @file{~/.hyperb}. The standard Hyperbole
|
|
|
1607 configuration also appends all global buttons to the end of this file,
|
|
|
1608 one per line, as they are created. So you can edit or annotate them
|
|
|
1609 within the file.
|
|
|
1610
|
|
|
1611 A directory-specific button file may exist for each file system
|
|
|
1612 directory. Such files are useful for explaining the contents of
|
|
|
1613 directories and pointing readers to particular highlights within the
|
|
|
1614 directories. Selection of the ButFile/DirFile menu item displays the
|
|
|
1615 button file for the current directory; this provides an easy means of
|
|
|
1616 updating this file when working on a file within the same directory.
|
|
|
1617 If you want to view some other directory-specific button file, simply
|
|
|
1618 use the normal Emacs file finding commands.
|
|
|
1619
|
|
|
1620 One might suggest that menu quick access be provided for group-specific
|
|
|
1621 and site-specific button files. Instead, link buttons to such things
|
|
|
1622 should be placed at the top of your personal button file. This provides
|
|
|
1623 a more flexible means of quick access.
|
|
|
1624
|
|
|
1625 @node Utilizing Explicit Buttons, , Button Files, Buttons
|
|
|
1626 @section Utilizing Explicit Buttons
|
|
|
1627
|
|
|
1628 Explicit buttons are a fundamental building block for creating personal
|
|
|
1629 or organizational hypertext networks with Hyperbole. This section
|
|
|
1630 summarizes the user-level operations available for managing these
|
|
|
1631 buttons.
|
|
|
1632
|
|
|
1633 @menu
|
|
|
1634 * Creation::
|
|
|
1635 * Renaming::
|
|
|
1636 * Deletion::
|
|
|
1637 * Modification::
|
|
|
1638 * Location::
|
|
|
1639 * Buttons in Mail::
|
|
|
1640 * Buttons in News::
|
|
|
1641 @end menu
|
|
|
1642
|
|
|
1643 @node Creation, Renaming, Utilizing Explicit Buttons, Utilizing Explicit Buttons
|
|
|
1644 @subsection Creation
|
|
|
1645
|
|
|
1646 @menu
|
|
|
1647 * By Dragging:: Creation Via Action Key Drags
|
|
|
1648 * By Menu:: Creation Via Menus
|
|
|
1649 @end menu
|
|
|
1650
|
|
|
1651 @node By Dragging, By Menu, Creation, Creation
|
|
|
1652 @subsubsection Creation Via Action Key Drags
|
|
|
1653
|
|
|
1654 @cindex explicit button, creation
|
|
|
1655 @cindex button, creation
|
|
|
1656 @cindex link, creation
|
|
|
1657 @cindex drag
|
|
|
1658 @cindex Action Key drag
|
|
|
1659 The most efficient way to create an explicit button interactively is to
|
|
|
1660 use the mouse Action Key to drag from a button source window to a window
|
|
|
1661 showing its link referent. More specifically, you should split your
|
|
|
1662 current Emacs frame into two windows: one which contains the point at
|
|
|
1663 which you want a button to be inserted and another which shows the point
|
|
|
1664 to which you want to link. Depress the mouse Action Key at the point at
|
|
|
1665 which the button should be inserted, drag to the other window and
|
|
|
1666 release it at the point of the link referent. The process becomes quite
|
|
|
1667 simple with a little practice. (@xref{By Menu, Creation Via Menus}, for a
|
|
|
1668 more detailed explanation of the explicit button creation process.)
|
|
|
1669
|
|
|
1670 Hyperbole uses the link referent context to determine the type of link
|
|
|
1671 to make. If there are a few different types of links which are
|
|
|
1672 applicable from the context, you will be prompted with a list of the
|
|
|
1673 types. Simply use the Action Key or the first letter of the link
|
|
|
1674 type to select one of the type names and to finish the link creation.
|
|
|
1675 Hyperbole will then insert explicit button delimiters around the button
|
|
|
1676 label and will display a message in the minibuffer indicating both the
|
|
|
1677 button name and its action/link type.
|
|
|
1678
|
|
|
1679 @kindex M-o
|
|
|
1680 @kindex C-u M-o
|
|
|
1681 @kindex C-x o
|
|
|
1682 @findex hkey-operate
|
|
|
1683 If you run Emacs under a window system, you can emulate an Action Key
|
|
|
1684 drag from the keyboard by: hitting @{@kbd{M-o}@}, the
|
|
|
1685 @code{hkey-operate} command, at the button source location, moving
|
|
|
1686 to the link destination, e.g@. with @{@kbd{C-x o}@}, and then hitting
|
|
|
1687 @{@kbd{M-o}@} again. This simulates a depress and then release of the
|
|
|
1688 Action Key. @{@kbd{C-u M-o}@} emulates drags of the Assist Key.
|
|
|
1689 This will not work when Hyperbole is run from a dumb terminal Emacs
|
|
|
1690 session since drag actions are not supported without a window system.
|
|
|
1691
|
|
|
1692 @page
|
|
|
1693 @node By Menu, , By Dragging, Creation
|
|
|
1694 @subsubsection Creation Via Menus
|
|
|
1695
|
|
|
1696 You can alternatively use the Hyperbole menus to create explicit
|
|
|
1697 buttons. First, mark a short region of text in any fashion allowed by
|
|
|
1698 GNU Emacs and then select the Hyperbole menu item sequence, Ebut/Create.
|
|
|
1699 You will be prompted for the button's label with the marked region as
|
|
|
1700 the default. If you accept the default and enter the rest of the
|
|
|
1701 information you are prompted for, the button will be created within the
|
|
|
1702 current buffer and Hyperbole will surround the marked region with
|
|
|
1703 explicit button delimiters to indicate success.
|
|
|
1704
|
|
|
1705 If you do not mark a region before invoking the button create command,
|
|
|
1706 you will be prompted for both a label and a target buffer for the button
|
|
|
1707 and the delimited label text will be inserted into the target buffer
|
|
|
1708 after a successful button creation.
|
|
|
1709
|
|
|
1710 After Hyperbole has the button label and its target buffer, it will
|
|
|
1711 prompt you for an action type for the button. Use the @{@kbd{?}@}
|
|
|
1712 completion help key to see the available types. The type selected
|
|
|
1713 determines any following values for which you will be prompted.
|
|
|
1714
|
|
|
1715 @cindex button instance
|
|
|
1716 @cindex instance number
|
|
|
1717 If a previous button with the same label exists in the same buffer,
|
|
|
1718 Hyperbole will add an @dfn{instance number} to the label when it adds
|
|
|
1719 the delimiters so that the name is unique. Thus, you don't have to
|
|
|
1720 worry about accidental button name conflicts. If you want the same
|
|
|
1721 button to appear in multiple places within the buffer, just enter the
|
|
|
1722 label again and delimit it yourself. Hyperbole will interpret all
|
|
|
1723 occurrences of the same delimited label within a buffer as the same
|
|
|
1724 button.
|
|
|
1725
|
|
|
1726 @cindex link, creation
|
|
|
1727 If you create link buttons using the Hyperbole menus, the best technique
|
|
|
1728 is to place on screen both the source buffer for the button and the
|
|
|
1729 buffer to which it will link. Mark the region of text to use for your
|
|
|
1730 button label, invoke the button create command from the menu, choose an
|
|
|
1731 action type which begins with @code{link-to-} and then use the direct
|
|
|
1732 selection techniques mentioned in @ref{Entering Arguments}, to select
|
|
|
1733 the link referent.
|
|
|
1734
|
|
|
1735
|
|
|
1736 @node Renaming, Deletion, Creation, Utilizing Explicit Buttons
|
|
|
1737 @subsection Renaming
|
|
|
1738
|
|
|
1739 @cindex explicit button, renaming
|
|
|
1740 @cindex button, renaming
|
|
|
1741 Once an explicit button has been created, its label text must be
|
|
|
1742 treated specially. Any inter-word spacing within the label may be
|
|
|
1743 freely changed, as may happen when a paragraph is refilled. But a
|
|
|
1744 special command must be invoked to rename it.
|
|
|
1745
|
|
|
1746 The rename command operates in two different ways. If point is within a
|
|
|
1747 button label when it is invoked, it will tell you to edit the button
|
|
|
1748 label and then invoke the rename command again. The second invocation
|
|
|
1749 will actually rename the button. If instead the command is originally
|
|
|
1750 invoked outside of any explicit button, it will prompt for the button
|
|
|
1751 label to replace and the label to replace it with and then will perform
|
|
|
1752 the rename. All occurrences of the same button in the buffer will be
|
|
|
1753 renamed, so you need locate only one occurrence of the button.
|
|
|
1754
|
|
|
1755 @vindex file, .~/.emacs
|
|
|
1756 @vindex file, hsite.el
|
|
|
1757 @kindex C-c C-r
|
|
|
1758 The rename command may be invoked from the Hyperbole menu via
|
|
|
1759 Ebut/Rename. A faster method is to use a key bound to the
|
|
|
1760 @code{hui:ebut-rename} command. Your site installation may include such
|
|
|
1761 a key. @{@kbd{C-h w hui:ebut-rename @key{RET}}@} should show you any
|
|
|
1762 key it is on. If no key binding has been established or if you prefer
|
|
|
1763 one of your own, simply bind it within your @file{~/.emacs} file. We
|
|
|
1764 recommend the @{@kbd{C-c C-r}@} key, as in: @code{(global-set-key
|
|
|
1765 "\C-c\C-r" 'hui:ebut-rename)}.
|
|
|
1766
|
|
|
1767
|
|
|
1768 @node Deletion, Modification, Renaming, Utilizing Explicit Buttons
|
|
|
1769 @subsection Deletion
|
|
|
1770
|
|
|
1771 @cindex explicit button, deleting
|
|
|
1772 @cindex button, deleting
|
|
|
1773 Ebut/Delete works similarly to the Rename command but deletes the
|
|
|
1774 selected button. The button's delimiters are removed to confirm the
|
|
|
1775 delete. If the delete command is invoked with a prefix argument, then
|
|
|
1776 both the button label and the delimiters are removed as confirmation.
|
|
|
1777
|
|
|
1778 @vindex hui:ebut-delete-confirm-p
|
|
|
1779 Presently there is no way to recover a deleted button; it must
|
|
|
1780 be recreated. Therefore, the @var{hui:ebut-delete-confirm-p} variable
|
|
|
1781 is true by default, causing Hyperbole to require confirmation before
|
|
|
1782 interactively deleting explicit buttons. Set it to nil if you prefer no
|
|
|
1783 confirmation.
|
|
|
1784
|
|
|
1785 @node Modification, Location, Deletion, Utilizing Explicit Buttons
|
|
|
1786 @subsection Modification
|
|
|
1787
|
|
|
1788 @cindex explicit button, modifying
|
|
|
1789 @cindex button, modifying
|
|
|
1790 @cindex Smart Mouse Key drag
|
|
|
1791 Ebut/Modify prompts you with each of the elements from the button's
|
|
|
1792 data list and allows you to modify each in turn.
|
|
|
1793
|
|
|
1794 There is a quicker way to modify explicit link buttons. Simply drag with the
|
|
|
1795 mouse Action Key from within the button label to a link destination in a
|
|
|
1796 different window, just as you would when creating a new button with a mouse
|
|
|
1797 drag. Remember that drags may also be emulated from the keyboard.
|
|
|
1798 @xref{Creation}.
|
|
|
1799
|
|
|
1800 @node Location, Buttons in Mail, Modification, Utilizing Explicit Buttons
|
|
|
1801 @subsection Location
|
|
|
1802
|
|
|
1803 @cindex explicit button, summarizing
|
|
|
1804 @cindex button, summarizing
|
|
|
1805 @cindex button, help
|
|
|
1806 The Ebut/Help menu can be used to summarize a single explicit button or
|
|
|
1807 all such buttons within a single buffer. The buttons summarized may
|
|
|
1808 then be activated directly from the summary.
|
|
|
1809
|
|
|
1810 Ebut/Help/BufferButs summarizes the explicit buttons in the order in
|
|
|
1811 which they appear in the buffer. Ebut/Help/CurrentBut summarizes only
|
|
|
1812 the button at point. Ebut/Help/OrderedButs summarizes the buttons in
|
|
|
1813 alphabetical order. All of these summary commands eliminate duplicate
|
|
|
1814 instances of buttons from their help displays.
|
|
|
1815
|
|
|
1816 @cindex explicit button, searching
|
|
|
1817 @cindex button, searching
|
|
|
1818 Ebut/Search prompts for a search pattern and searches across all the
|
|
|
1819 locations in which you have previously created explicit buttons. It
|
|
|
1820 asks you whether to match to any part of a button label or only complete
|
|
|
1821 labels. It then displays a list of button matches with a single line of
|
|
|
1822 surrounding context from their sources. Any button in the match list
|
|
|
1823 may be activated as usual. An Action Key press on the surrounding context
|
|
|
1824 jumps to the associated source line or a press on the filename preceding
|
|
|
1825 the matches jumps to the file without selecting a particular line.
|
|
|
1826
|
|
|
1827 There are presently no user-level facilities for globally locating buttons
|
|
|
1828 created by others or for searching on particular button attributes.
|
|
|
1829
|
|
|
1830 @node Buttons in Mail, Buttons in News, Location, Utilizing Explicit Buttons
|
|
|
1831 @subsection Buttons in Mail
|
|
|
1832
|
|
|
1833 @kindex C-x m
|
|
|
1834 @findex mail
|
|
|
1835 Hyperbole allows the embedding of buttons within electronic mail
|
|
|
1836 messages that are composed in Emacs with the standard @code{(mail)}
|
|
|
1837 command, normally bound to @{@kbd{C-x m}@} or with other Emacs-based
|
|
|
1838 mail composing functions. An enhanced mail reader can then be used
|
|
|
1839 to activate the buttons within messages just like any other buttons.
|
|
|
1840
|
|
|
1841 @cindex button, mailing
|
|
|
1842 @cindex button, posting
|
|
|
1843 @cindex mailing buttons
|
|
|
1844 @cindex posting buttons
|
|
|
1845 @cindex mail reader
|
|
|
1846 @cindex mailer initialization
|
|
|
1847 @cindex RMAIL
|
|
|
1848 @cindex VM
|
|
|
1849 @cindex PIEmail
|
|
|
1850 @cindex MH-e
|
|
|
1851 @cindex GNUS
|
|
|
1852 @cindex USENET
|
|
|
1853 @cindex news
|
|
|
1854 @vindex file, hmail.el
|
|
|
1855 Hyperbole automatically supports the following mail readers: Rmail,
|
|
|
1856 @ref{Rmail,,,emacs, the GNU Emacs Manual}, VM, @ref{Introduction,,,vm,
|
|
|
1857 the VM Manual}, and PIEmail, and MH-e. Button inclusion and activation
|
|
|
1858 within USENET news articles is also supported in the same fashion via
|
|
|
1859 the GNUS news reader, @ref{Introduction,,,gnus, the GNUS Manual}, if
|
|
|
1860 available at your site. (The @file{hmail.el} file provides a
|
|
|
1861 generalized interface that can be used to hook in other mail or news
|
|
|
1862 readers if the necessary interface functions are written.)
|
|
|
1863
|
|
|
1864 @vindex mail-yank-original
|
|
|
1865 @kindex C-c C-y
|
|
|
1866 @cindex mail inclusion
|
|
|
1867 All explicit buttons to be mailed must be created within the outgoing
|
|
|
1868 message buffer. There is no present support for including text from
|
|
|
1869 other buffers or files which contain explicit buttons, except for the
|
|
|
1870 ability to yank the contents of a message being replied to, together
|
|
|
1871 with all of its buttons, via the @code{(mail-yank-original)} command
|
|
|
1872 bound to @{@kbd{C-c C-y}@}. From a user's perspective, buttons are
|
|
|
1873 created in precisely the same way as in any other buffer. They also
|
|
|
1874 appear just like any other buttons to both the message sender and the
|
|
|
1875 reader who uses the Hyperbole enhanced readers. Button operation may be
|
|
|
1876 tested any time before a message is sent. A person who does not use
|
|
|
1877 Hyperbole enhanced mail readers can still send messages with embedded
|
|
|
1878 buttons since mail composing is independent of any mail reader
|
|
|
1879 choice.
|
|
|
1880
|
|
|
1881 Hyperbole buttons embedded within received mail messages act just like
|
|
|
1882 any other buttons. The mail does not contain any of the action type
|
|
|
1883 definitions used by the buttons, so the receiver must have these or she
|
|
|
1884 will receive an error when she activates the buttons. Buttons which
|
|
|
1885 appear in message @emph{Subject} lines are copied to summary buffers
|
|
|
1886 whenever such summaries are generated. Thus, they may be activated from
|
|
|
1887 either the message or summary buffers.
|
|
|
1888
|
|
|
1889 Nothing bad will happen if a mail message with explicit buttons is sent
|
|
|
1890 to a non-Hyperbole user. The user will simply see the text
|
|
|
1891 of the message followed by a series of lines of button data at its end.
|
|
|
1892 Hyperbole mail users never see this data in its raw form.
|
|
|
1893
|
|
|
1894 @vindex smail:comment
|
|
|
1895 @cindex mail comment
|
|
|
1896 In order to alert readers of your mail messages that you can utilize
|
|
|
1897 Hyperbole mail buttons, the system automatically inserts a comment into
|
|
|
1898 each mail message that you compose to announce this fact. The variable,
|
|
|
1899 @var{smail:comment} controls this behavior. See its documentation for
|
|
|
1900 technical details. By default, it produces a message of the form:
|
|
|
1901
|
|
|
1902 @example
|
|
|
1903 Comments: Hyperbole mail buttons accepted, vX.XX.
|
|
|
1904 @end example
|
|
|
1905
|
|
|
1906 @vindex file, ~/.emacs
|
|
|
1907 @noindent
|
|
|
1908 where the X's indicate your Hyperbole version number. You can cut this
|
|
|
1909 out of particular messages before you send them. If you don't want any
|
|
|
1910 message at all, add the following to your @file{~/.emacs} file before
|
|
|
1911 the point at which you load Hyperbole.
|
|
|
1912
|
|
|
1913 @lisp
|
|
|
1914 (setq smail:comment nil)
|
|
|
1915 @end lisp
|
|
|
1916
|
|
|
1917 @cindex actype, link-to-mail
|
|
|
1918 A final mail-related facility provided by Hyperbole is the ability to
|
|
|
1919 save a pointer to a received mail message by creating an explicit button
|
|
|
1920 with a @code{link-to-mail} action type. When prompted for the mail
|
|
|
1921 message to link to, if you press the Action Key on an Rmail message, the
|
|
|
1922 appropriate parameter will be copied to the argument prompt, as
|
|
|
1923 described in @ref{Entering Arguments}.
|
|
|
1924
|
|
|
1925
|
|
|
1926 @node Buttons in News, , Buttons in Mail, Utilizing Explicit Buttons
|
|
|
1927 @subsection Buttons in News
|
|
|
1928
|
|
|
1929 @cindex button, posting
|
|
|
1930 @cindex news reader/poster
|
|
|
1931 @cindex posting news
|
|
|
1932 @cindex GNUS
|
|
|
1933 @cindex USENET
|
|
|
1934 @vindex file, hgnus.el
|
|
|
1935 @vindex file, hsite.el
|
|
|
1936 Explicit buttons may be embedded within outgoing USENET news articles
|
|
|
1937 and may be activated from news articles that are being read. This
|
|
|
1938 support is available for the GNUS news reader. It is enabled by default
|
|
|
1939 within @file{hsite.el} by autoloading the @file{hgnus.el} file.
|
|
|
1940
|
|
|
1941 All Hyperbole support should work just as it does when reading or
|
|
|
1942 sending mail. @xref{Buttons in Mail}. When reading news, buttons which
|
|
|
1943 appear in message @emph{Subject} lines may be activated within the GNUS
|
|
|
1944 subject buffer as well as the article buffer. When posting news, the
|
|
|
1945 *post-news* buffer is used for outgoing news articles rather than the
|
|
|
1946 *mail* buffer.
|
|
|
1947
|
|
|
1948 Remember that the articles you post do not contain the action type
|
|
|
1949 definitions used by the buttons, so the receiver must have these or she
|
|
|
1950 will receive an error when he activates the buttons. You should also
|
|
|
1951 keep in mind that most USENET readers will not be using Hyperbole, so if
|
|
|
1952 they receive a news article containing explicit buttons, they will
|
|
|
1953 wonder what the button data at the end of the message is. You should
|
|
|
1954 therefore limit distribution of such messages. For example, if most
|
|
|
1955 people at your site read news with GNUS and use Hyperbole, it would be
|
|
|
1956 reasonable to embed buttons in postings to local newsgroups.
|
|
|
1957
|
|
|
1958 @cindex news comment
|
|
|
1959 In order to alert readers of your postings that you can utilize
|
|
|
1960 Hyperbole mail buttons embedded within personal replies,
|
|
|
1961 the system automatically inserts the same comment that is included
|
|
|
1962 within mail messages to announce this fact. @xref{Buttons in Mail}, for
|
|
|
1963 details and an explanation of how to turn this feature off.
|
|
|
1964
|
|
|
1965 @node Smart Keys, Menus, Buttons, Top
|
|
|
1966 @chapter Smart Keys
|
|
|
1967
|
|
|
1968 @cindex Smart Key
|
|
|
1969 @cindex mouse support
|
|
|
1970 @cindex Action Key
|
|
|
1971 @cindex Assist Key
|
|
|
1972 @kindex Action Key
|
|
|
1973 @kindex Assist Key
|
|
|
1974 Hyperbole provides two special @dfn{Smart Keys} that perform
|
|
|
1975 context-sensitive operations, the Action Key and the Assist Key. By
|
|
|
1976 default, the @dfn{Action Key} is bound to your shift-middle mouse button (or
|
|
|
1977 shift-left on a 2-button mouse) and the @dfn{Assist Key} is bound to your
|
|
|
1978 shift-right mouse button, assuming Hyperbole is run under an external window
|
|
|
1979 system. (InfoDock users should use the middle mouse button as the
|
|
|
1980 Action Key, instead.)
|
|
|
1981
|
|
|
1982 @findex hmouse-shift-buttons
|
|
|
1983 Mouse configuration is automatic for InfoDock, XEmacs, and Epoch under
|
|
|
1984 the X window system and for GNU Emacs versions 18 and 19 under X,
|
|
|
1985 OpenWindows, NEXTSTEP, SunView and Apollo's Display Manager, assuming
|
|
|
1986 your Emacs program has been built with support for any of these window
|
|
|
1987 systems. The command, @code{hmouse-shift-buttons}, can be used to
|
|
|
1988 select between shifted and unshifted Smart Mouse Keys.
|
|
|
1989
|
|
|
1990 @vindex hkey-init
|
|
|
1991 @kindex C-u M-RET
|
|
|
1992 @kindex M-RET
|
|
|
1993 By default (if @var{hkey-init} is set to @code{t} in @file{hsite.el}),
|
|
|
1994 then @{@kbd{M-@key{RET}}@} may also be used as the Action Key and
|
|
|
1995 @{@kbd{C-u M-@key{RET}}@} may be used as the Assist Key. In many
|
|
|
1996 read-only modes like Dired and Rmail,
|
|
|
1997 @{@key{RET}@} also functions as the Action Key. These key bindings allow
|
|
|
1998 context sensitive operation from any keyboard.
|
|
|
1999
|
|
|
2000 @cindex key binding, smart keys
|
|
|
2001 @cindex smart key commands
|
|
|
2002 @findex action-key
|
|
|
2003 @findex assist-key
|
|
|
2004 @findex action-mouse-key
|
|
|
2005 @findex assist-mouse-key
|
|
|
2006 If you prefer other key bindings, simply bind the commands
|
|
|
2007 @code{action-key} and @code{assist-key} to keyboard keys.
|
|
|
2008 @code{hkey-either} may be used instead if you prefer a single
|
|
|
2009 key binding for both commands; a prefix argument then invokes
|
|
|
2010 @code{assist-key}.
|
|
|
2011
|
|
|
2012 You may also bind @code{action-mouse-key} and @code{assist-mouse-key}
|
|
|
2013 to mouse keys, as you like.
|
|
|
2014
|
|
|
2015 @cindex button activation
|
|
|
2016 @cindex activation
|
|
|
2017 @cindex button help
|
|
|
2018 The Action Key generally selects entities, creates links and
|
|
|
2019 activates buttons. The Assist Key generally provides help,
|
|
|
2020 such as reporting on a button's attributes, or serves a complementary
|
|
|
2021 function to whatever the Action Key does within a context.
|
|
|
2022
|
|
|
2023 @cindex Smart Key operation
|
|
|
2024 You can get a summary of what the Smart Keys do in all of their
|
|
|
2025 different contexts by pressing the Assist Key in the right
|
|
|
2026 corner (within the rightmost 3 characters) of a window modeline or by
|
|
|
2027 using the Hyperbole Doc/SmartKy menu entry.
|
|
|
2028
|
|
|
2029 The following table is an example of this summary. Much of the browsing
|
|
|
2030 power of Hyperbole comes from use of the Smart Keys, so you should spend
|
|
|
2031 some time practicing how to use them. This table may appear daunting at
|
|
|
2032 first, but as you practice and notice that the Smart Keys do just a few
|
|
|
2033 context-sensitive things per editor mode, you will find it easy to just
|
|
|
2034 point and click and let Hyperbole do the rest.
|
|
|
2035
|
|
|
2036 For extensive reference documentation on the Smart Keys, @ref{Smart
|
|
|
2037 Key Reference}.
|
|
|
2038
|
|
|
2039 @page
|
|
|
2040 @iftex
|
|
|
2041 @example
|
|
|
2042 @include ../etc/hypb-mouse.txt
|
|
|
2043 @end example
|
|
|
2044 @end iftex
|
|
|
2045 @ifinfo
|
|
|
2046 @format
|
|
|
2047 @include ../etc/hypb-mouse.txt
|
|
|
2048 @end format
|
|
|
2049 @end ifinfo
|
|
|
2050
|
|
|
2051 @vindex action-key-default-function
|
|
|
2052 @vindex assist-key-default-function
|
|
|
2053 Note how the last line in the table explains the default behavior of the
|
|
|
2054 Smart Keys. That is what they do when they cannot find a context match
|
|
|
2055 at your current location. See the documentation for the variables
|
|
|
2056 @var{action-key-default-function} and @var{assist-key-default-function}
|
|
|
2057 for information on how to customize the behavior of the Smart Keys
|
|
|
2058 within default contexts.
|
|
|
2059
|
|
|
2060 @cindex Hyperbole help
|
|
|
2061 A prime design criterion of Hyperbole's user interface is that one
|
|
|
2062 should be able to see what an operation will do before using it.
|
|
|
2063 The Assist Key shows you what a button or minibuffer menu item will do
|
|
|
2064 before you activate it. Hyperbole also shows the result of directly
|
|
|
2065 selecting an argument value with the mouse, to provide feedback as to
|
|
|
2066 whether the right item has been selected. A second click is necessary
|
|
|
2067 before an argument is accepted and processed.
|
|
|
2068
|
|
|
2069 @cindex Smart Key help
|
|
|
2070 @cindex help, Smart Key
|
|
|
2071 @cindex context sensitive help
|
|
|
2072 When you use a mouse and you want to find out what either of the Smart
|
|
|
2073 Keys does within a context, depress the one you want to check on and
|
|
|
2074 hold it down, then press the other and release as you please. A help
|
|
|
2075 buffer will pop up explaining the actions that will be performed in that
|
|
|
2076 context, if any. A press of either Smart Key at the end of that
|
|
|
2077 help buffer will restore your display to its configuration prior to
|
|
|
2078 invoking help.
|
|
|
2079
|
|
|
2080 @kindex C-h A
|
|
|
2081 @vindex hkey-init
|
|
|
2082 By default (if @var{hkey-init} is left set equal to @code{t} in
|
|
|
2083 @file{hsite.el}), then @{@kbd{C-h A}@} will display this same
|
|
|
2084 context-sensitive help for the Action Key while @{@kbd{C-u C-h
|
|
|
2085 A}@} will display the help for the Assist Key. Note that
|
|
|
2086 @{@kbd{C-h a}@} will perform a function unrelated to Hyperbole, so you
|
|
|
2087 must press the shift key when you hit the @kbd{A} character.
|
|
|
2088
|
|
|
2089 @cindex Smart Key toggle
|
|
|
2090 @cindex mouse key toggle
|
|
|
2091 @vindex file, ~/.emacs
|
|
|
2092 @vindex file, hsite.el
|
|
|
2093 @kindex C-c t
|
|
|
2094 When Hyperbole is installed, a key may be bound which allows you
|
|
|
2095 to switch between the Smart Key mouse bindings and your prior ones.
|
|
|
2096 @kbd{C-h w hmouse-toggle-bindings @key{RET}} should show you any key
|
|
|
2097 which performs this command. If no key binding has been established or
|
|
|
2098 if you prefer one of your own, simply select a key and bind it
|
|
|
2099 within your @file{~/.emacs} file. For example, @code{(global-set-key
|
|
|
2100 "\C-ct" 'hmouse-toggle-bindings)}.
|
|
|
2101
|
|
|
2102
|
|
|
2103 @node Menus, Entering Arguments, Smart Keys, Top
|
|
|
2104 @chapter Menus
|
|
|
2105
|
|
|
2106 @cindex InfoDock
|
|
|
2107 @cindex XEmacs
|
|
|
2108 @cindex Emacs 19
|
|
|
2109 @cindex menu use
|
|
|
2110 @cindex menubar, Hyperbole menu
|
|
|
2111 Under InfoDock, XEmacs, and Emacs 19, pulldown and popup menus are
|
|
|
2112 available to invoke Hyperbole commands, including those from the rolodex
|
|
|
2113 and the outliner. These menus operate like any other X window menus.
|
|
|
2114 Use the Quit command on the Hyperbole menubar menu to get rid of the
|
|
|
2115 menu if you do not need it. Invoking Hyperbole again will add the menu
|
|
|
2116 back to the menubar.
|
|
|
2117
|
|
|
2118 @cindex minibuffer menus
|
|
|
2119 This section discusses only the specialized @dfn{minibuffer menus} that
|
|
|
2120 appear in the minibuffer window and that work with all Emacs versions.
|
|
|
2121 Minibuffer menu items may be selected from either the keyboard or via
|
|
|
2122 mouse clicks. When used with the keyboard, they provide rapid command
|
|
|
2123 access similar to key bindings.
|
|
|
2124
|
|
|
2125 @kindex C-h h
|
|
|
2126 @vindex action-key-default-function
|
|
|
2127 @cindex menu, top level
|
|
|
2128 The top level menu is invoked from a key given in your @file{hsite.el}
|
|
|
2129 file (by default, @{@kbd{C-h h}@}) or via an Action Key press in a
|
|
|
2130 location with no other action defined. The menu will appear in the
|
|
|
2131 minibuffer and should look mostly like so:
|
|
|
2132
|
|
|
2133 @noindent
|
|
|
2134 @example
|
|
|
2135 Hy4> Act Butfile/ Doc/ Ebut/ Gbut/ Hist Ibut/ Msg/ Otl/ Rolo/ Win/
|
|
|
2136 @end example
|
|
|
2137
|
|
|
2138 @noindent
|
|
|
2139 The above menu items can be summarized as follows:
|
|
|
2140
|
|
|
2141 @table @strong
|
|
|
2142 @cindex menu, Act
|
|
|
2143 @item Act
|
|
|
2144 Perform the action associated with any button at point or prompt for the
|
|
|
2145 name of an explicit button to activate if point is not on one.
|
|
|
2146
|
|
|
2147 @cindex menu, ButFile
|
|
|
2148 @cindex button file, HYPB
|
|
|
2149 @vindex file, HYPB
|
|
|
2150 @item Butfile/
|
|
|
2151 Display a local or global file of buttons, providing easy access.
|
|
|
2152 @file{HYPB} for a local button file and @file{~/.hyperb/HYPB} for your
|
|
|
2153 global file. These are good places to start your button creation testing.
|
|
|
2154
|
|
|
2155 @cindex menu, EBut
|
|
|
2156 @item Ebut/
|
|
|
2157 All explicit button commands.
|
|
|
2158
|
|
|
2159 @cindex menu, Doc
|
|
|
2160 @cindex menu, Types
|
|
|
2161 @item Doc/
|
|
|
2162 Hyperbole documentation quick access. Contains Types/ submenu for
|
|
|
2163 documentation on Hyperbole implicit button and action types.
|
|
|
2164
|
|
|
2165 @cindex menu, Global Buttons
|
|
|
2166 @item Gbut/
|
|
|
2167 All global button commands. Global buttons are accessed by name
|
|
|
2168 rather than by direct selection.
|
|
|
2169
|
|
|
2170 @cindex menu, History
|
|
|
2171 @cindex history
|
|
|
2172 @item Hist
|
|
|
2173 Jumps back to last position in button traversal history.
|
|
|
2174
|
|
|
2175 @cindex menu, Implicit Buttons
|
|
|
2176 @item Ibut/
|
|
|
2177 All implicit button commands.
|
|
|
2178
|
|
|
2179 @cindex menu, Message
|
|
|
2180 @item Msg/
|
|
|
2181 Hyperbole-specific mail and news messaging support commands.
|
|
|
2182 Use this to send mail to the Hyperbole discussion list or to
|
|
|
2183 add/modify your entry on a Hyperbole mail list.
|
|
|
2184
|
|
|
2185 @cindex menu, Outliner
|
|
|
2186 @item Otl/
|
|
|
2187 Autonumbered, structured outliner and hyper-node manager commands.
|
|
|
2188 @xref{Outliner}.
|
|
|
2189
|
|
|
2190 @cindex menu, Rolodex
|
|
|
2191 @item Rolo/
|
|
|
2192 Hierarchical, multi-file rolodex lookup and edit commands.
|
|
|
2193 @xref{Rolodex}.
|
|
|
2194
|
|
|
2195 @cindex menu, Window Configurations
|
|
|
2196 @cindex menu, Windows
|
|
|
2197 @item Win/
|
|
|
2198 Window configuration management such as adding and restoring window
|
|
|
2199 configurations by name. @xref{Window Configurations}.
|
|
|
2200
|
|
|
2201 @end table
|
|
|
2202
|
|
|
2203 @cindex submenus
|
|
|
2204 @cindex menu help
|
|
|
2205 @cindex help, menu items
|
|
|
2206 All menu items are selected via the first character of their names
|
|
|
2207 (letter case does not matter) or via a press of the Action Key. "/" at
|
|
|
2208 the end of an item name indicates that it brings up a sub-menu. A press
|
|
|
2209 of the Assist Key on an item displays help for the item, including the
|
|
|
2210 action that it performs.
|
|
|
2211
|
|
|
2212 @kindex C-t
|
|
|
2213 @kindex q
|
|
|
2214 @kindex C-g
|
|
|
2215 While a menu is active, to re-activate the top-level Hyperbole menu, you
|
|
|
2216 must use @{@kbd{C-t}@}. This allows you to browse the submenus and then
|
|
|
2217 return to the top. You can quit without selecting an item by using
|
|
|
2218 @{@kbd{q}@}. @{@kbd{C-g}@} aborts whether you are at a menu prompt or
|
|
|
2219 any other Hyperbole prompt.
|
|
|
2220
|
|
|
2221
|
|
|
2222
|
|
|
2223 @node Entering Arguments, Outliner, Menus, Top
|
|
|
2224 @chapter Entering Arguments
|
|
|
2225
|
|
|
2226 @cindex argument entry
|
|
|
2227 @cindex direct selection
|
|
|
2228 @cindex double click
|
|
|
2229 Many Hyperbole commands prompt you for arguments. The standard
|
|
|
2230 Hyperbole user interface has an extensive core of argument types that it
|
|
|
2231 recognizes. Whenever Hyperbole is prompting you for an argument, it
|
|
|
2232 knows the type that it needs and provides some error checking to help
|
|
|
2233 you get it right. More importantly, it allows you to press the Action
|
|
|
2234 Key within an entity that you want to use as an argument and it will grab the
|
|
|
2235 appropriate thing and show it to you at the input prompt within the
|
|
|
2236 minibuffer. If you press the Action Key again at the same point (click
|
|
|
2237 with a mouse) on the same thing again, it accepts the entity as the
|
|
|
2238 argument and moves on. Thus, a double click registers a desired
|
|
|
2239 argument. Double-quoted strings, pathnames, mail messages, Info nodes,
|
|
|
2240 dired listings, buffers, numbers, completion items and so forth are all
|
|
|
2241 recognized at appropriate times. All of the argument types mentioned in
|
|
|
2242 the documentation for the Emacs Lisp @code{(interactive)} function are
|
|
|
2243 recognized. Experiment a little and you will quickly get used to this
|
|
|
2244 direct selection technique.
|
|
|
2245
|
|
|
2246 @cindex completion
|
|
|
2247 Wherever possible, standard Emacs completion is offered, see
|
|
|
2248 @ref{Completion,,,emacs, the Gnu Emacs Manual}. Remember to use @{@kbd{?}@}
|
|
|
2249 to see what your possibilities for an argument are. Once you have a
|
|
|
2250 list of possible completions on screen, you can double click the Action
|
|
|
2251 Key on any one to enter it as the argument.
|
|
|
2252
|
|
|
2253
|
|
|
2254 @node Outliner, Rolodex, Entering Arguments, Top
|
|
|
2255 @chapter Outliner
|
|
|
2256
|
|
|
2257 @cindex outliner
|
|
|
2258 @cindex autonumber
|
|
|
2259 @cindex relative autonumber
|
|
|
2260 @cindex permanent identifier
|
|
|
2261 @cindex idstamp
|
|
|
2262 @cindex hyperlink anchor
|
|
|
2263 The Hyperbole outliner, also known as the Koutliner (pronounced
|
|
|
2264 Kay-outliner), produces structured, autonumbered documents composed of
|
|
|
2265 hierarchies of cells. Each @dfn{cell} has two identifiers, a
|
|
|
2266 @dfn{relative identifier} indicating its present position within the
|
|
|
2267 outline and a @dfn{permanent identifier} called an @dfn{idstamp},
|
|
|
2268 suitable for use within hyperlink references to the cell. The idstamp
|
|
|
2269 is typically not displayed but is available when needed.
|
|
|
2270 @xref{Autonumbering}.
|
|
|
2271
|
|
|
2272 Cells also store their time of creation and the user who created the
|
|
|
2273 cell. User-defined attributes may also be added to cells. @xref{Cell
|
|
|
2274 Attributes}.
|
|
|
2275
|
|
|
2276 @cindex menu, Outline
|
|
|
2277 The outliner works only under GNU Emacs version 19 or higher, XEmacs
|
|
|
2278 version 19.9 or higher or under InfoDock. You can tell whether you are
|
|
|
2279 running a version of Emacs which supports the outliner by hitting
|
|
|
2280 @{@kbd{C-h h}@} to display the Hyperbole menu. If you see an
|
|
|
2281 @code{Otl/} entry in the menu, then the outliner is available.
|
|
|
2282 Otherwise, the outliner does not work with your version of Emacs, so
|
|
|
2283 this section of the manual will not be of interest to you. (The same is
|
|
|
2284 true of the Hyperbole/Outline pulldown menu; if it appears, the outliner
|
|
|
2285 is available for use.)
|
|
|
2286
|
|
|
2287 @vindex file, EXAMPLE.kotl
|
|
|
2288 @cindex menu, Outline/Example
|
|
|
2289 This chapter expands on the information given in @file{EXAMPLE.kotl}
|
|
|
2290 file included with Hyperbole. Use @{@kbd{C-h h o e}@} to display that
|
|
|
2291 file. It is an actual outline file that explains major outliner
|
|
|
2292 operations. You can test out the viewing and motion commands with this
|
|
|
2293 file. If you want to experiment with editing operations, use @{@kbd{C-x
|
|
|
2294 C-w}@} to write the outline to a temporary file such as,
|
|
|
2295 @file{/tmp/e.kotl}, and then use @{@kbd{C-x C-q}@} to make the outline
|
|
|
2296 editable.
|
|
|
2297
|
|
|
2298 @xref{Outliner Keys}, for a full summary of the key bindings and
|
|
|
2299 commands available in the outliner.
|
|
|
2300
|
|
|
2301 @menu
|
|
|
2302 * Menu Commands::
|
|
|
2303 * Creating Outlines::
|
|
|
2304 * Autonumbering::
|
|
|
2305 * Idstamps::
|
|
|
2306 * Editing::
|
|
|
2307 * Viewing::
|
|
|
2308 * Links::
|
|
|
2309 * Cell Attributes::
|
|
|
2310 * Outliner History::
|
|
|
2311 @end menu
|
|
|
2312
|
|
|
2313
|
|
|
2314 @node Menu Commands, Creating Outlines, Outliner, Outliner
|
|
|
2315 @section Menu Commands
|
|
|
2316
|
|
|
2317 The Otl/ menu entry on the Hyperbole top-level menu provides access to
|
|
|
2318 a number of major outliner commands:
|
|
|
2319
|
|
|
2320 @example
|
|
|
2321 @group
|
|
|
2322 @cindex outliner commands
|
|
|
2323 @cindex Koutliner commands
|
|
|
2324 @findex kotl-mode:show-all
|
|
|
2325 @findex kvspec:toggle-blank-lines
|
|
|
2326 @findex kfile:find
|
|
|
2327 @findex kotl-mode:hide-sublevels
|
|
|
2328 @findex kotl-mode:hide-tree
|
|
|
2329 @findex kotl-mode:kill-tree
|
|
|
2330 @findex klink:create
|
|
|
2331 @findex kotl-mode:overview
|
|
|
2332 @findex kotl-mode:show-tree
|
|
|
2333 @findex kotl-mode:top-cells
|
|
|
2334 @findex kvspec:activate
|
|
|
2335 @cindex menu, Outline
|
|
|
2336 Menu Item Command Description
|
|
|
2337 ====================================================================
|
|
|
2338 All kotl-mode:show-all Expand all cells
|
|
|
2339 Blanks kvspec:toggle-blank-lines Toggle blank lines on or off
|
|
|
2340 Create kfile:find Edit or create an outline
|
|
|
2341 Downto kotl-mode:hide-sublevels Hide cells deeper than a level
|
|
|
2342 Examp <sample outliner file> Show self-descriptive example
|
|
|
2343 Hide kotl-mode:hide-tree Hide tree with root at point
|
|
|
2344 Info <outliner documentation> Show outliner manual section
|
|
|
2345 Kill kotl-mode:kill-tree Kill the current tree
|
|
|
2346 Link klink:create Create a link to another cell
|
|
|
2347 Overvw kotl-mode:overview Show first line of each cell
|
|
|
2348 Show kotl-mode:show-tree Show tree with root at point
|
|
|
2349 Top kotl-mode:top-cells Collapse to top-level cells
|
|
|
2350 Vspec kvspec:activate Set a view specification
|
|
|
2351 ====================================================================
|
|
|
2352 @end group
|
|
|
2353 @end example
|
|
|
2354
|
|
|
2355
|
|
|
2356 @node Creating Outlines, Autonumbering, Menu Commands, Outliner
|
|
|
2357 @section Creating Outlines
|
|
|
2358
|
|
|
2359 @cindex outline file suffix
|
|
|
2360 @cindex outline, creating
|
|
|
2361 @vindex file, .kotl suffix
|
|
|
2362 In addition to the Otl/Create menu item, you can create and experiment
|
|
|
2363 with outline files simply by finding a file, @{@kbd{C-x C-f}@} with a
|
|
|
2364 @file{.kotl} suffix. @file{.kot} will also work for DOS or
|
|
|
2365 Windows-impaired users.
|
|
|
2366
|
|
|
2367 @cindex root cell
|
|
|
2368 @cindex top-level cell
|
|
|
2369 @cindex cell, top-level
|
|
|
2370 @cindex cell, idstamp 0
|
|
|
2371 When a new koutline is created, an invisible root cell is created. Its
|
|
|
2372 permanent and relative ids are both 0, and it is considered to be at
|
|
|
2373 level 0 in the outline. All visible cells in the outline are at level 1
|
|
|
2374 or deeper, and thus are descendants of this root cell. Some koutliner
|
|
|
2375 commands prompt for cell numbers as arguments. An argument of 0 makes
|
|
|
2376 commands operate upon the entire outline.
|
|
|
2377
|
|
|
2378 An initial level 1 cell is also created to make it easy to start
|
|
|
2379 entering text in the outline. A koutline always has at least one
|
|
|
2380 visible cell in it.
|
|
|
2381
|
|
|
2382 @xref{Autonumbering}, which explains how cells are labeled according to their
|
|
|
2383 respective levels in the outline and how these labels are updated as the
|
|
|
2384 structure of the outline changes.
|
|
|
2385
|
|
|
2386
|
|
|
2387 @node Autonumbering, Idstamps, Creating Outlines, Outliner
|
|
|
2388 @section Autonumbering
|
|
|
2389
|
|
|
2390 @cindex autonumber
|
|
|
2391 @cindex relative identifier
|
|
|
2392 @xref{Adding and Killing}, which explains how to add new cells to or remove
|
|
|
2393 cells from a koutline. As you do this, or as you promote or demote
|
|
|
2394 cells within the outline, the labels preceding the contents of each cell
|
|
|
2395 automatically update to reflect the new structure. These labels are
|
|
|
2396 also known as @dfn{autonumbers} and as @dfn{relative ids} because they
|
|
|
2397 change as the structure changes.
|
|
|
2398
|
|
|
2399 @cindex outline structure
|
|
|
2400 The outline structure is shown by these labels and by the indentation of
|
|
|
2401 each outline level. Normally, each deeper level is indented another
|
|
|
2402 three characters, to reflect the nesting.
|
|
|
2403
|
|
|
2404 @cindex label type, alpha
|
|
|
2405 @cindex label type, legal
|
|
|
2406 @cindex alpha labels
|
|
|
2407 @cindex legal labels
|
|
|
2408 @cindex outline, label type
|
|
|
2409 The default autonumbers are called @dfn{alphanumeric labels} because
|
|
|
2410 they alternate between using numbers and letters to distinguish each
|
|
|
2411 successive level. Each alphanumeric label uniquely identifies a cell's
|
|
|
2412 position in an outline, so that there is no need to scan back to prior
|
|
|
2413 cells to see what the current section number of an outline is. This is
|
|
|
2414 similar to a legal numbering scheme but without all the period
|
|
|
2415 characters between level numbers. As an example, 1b3 is equivalent to a
|
|
|
2416 legal label of 1.2.3. Both refer to the 3rd cell at level 3,
|
|
|
2417 below the 2nd child of the first cell at level 1. Said another way,
|
|
|
2418 this is the 3rd child of the 1st cell's 2nd child. In other words, it
|
|
|
2419 is easier to visualize hierarchies than to talk about them.
|
|
|
2420
|
|
|
2421 Alphanumeric labels are the default because they are shorter and easier
|
|
|
2422 to read aloud than equivalent legal ones. They also simplify
|
|
|
2423 distinguishing between even and odd level labels because of the
|
|
|
2424 alternating character set.
|
|
|
2425
|
|
|
2426 @kindex C-c C-l
|
|
|
2427 @cindex label type, changing
|
|
|
2428 You can change the labeling scheme used in a particular outline with the
|
|
|
2429 command @{@kbd{C-c C-l}@}. A @{@kbd{?}@} then will show all of your
|
|
|
2430 options. Legal labels, partial alpha labels (single level autonumbering
|
|
|
2431 where only the last part of the level number is shown, as commonly seen
|
|
|
2432 in other outliner products), idstamps (permanent cell ids), and star
|
|
|
2433 outline level labels (Emacs asterisk-based outline labeling) are all
|
|
|
2434 available. Or you may choose to turn autonumbering off. Cells are
|
|
|
2435 still indented to reflect the outline structure whether or not labels
|
|
|
2436 are displayed.
|
|
|
2437
|
|
|
2438 @cindex label separator, changing
|
|
|
2439 @cindex cell, label separator
|
|
|
2440 @cindex outline, label separator
|
|
|
2441 @kindex C-c M-l
|
|
|
2442 @kindex C-u C-c M-l
|
|
|
2443 A cell label is normally followed by two spaces, called the @dfn{label
|
|
|
2444 separator}, prior to the start of the cell contents. You can change the
|
|
|
2445 separator with for the current outline with @{@kbd{C-c M-l}@}.
|
|
|
2446 @{@kbd{C-u C-c M-l}@} will additionally change the default separator
|
|
|
2447 value used when new outlines are created (for the current session only).
|
|
|
2448 For example, use the value ". " to get a trailing period after each cell
|
|
|
2449 label. The separator must be at least two characters long but may be
|
|
|
2450 longer.
|
|
|
2451
|
|
|
2452 @vindex file, ~/.emacs
|
|
|
2453 @cindex initialization file
|
|
|
2454 If you find a separator that you prefer for all outlines, change the
|
|
|
2455 separator setting permanently by adding the following line to your Emacs
|
|
|
2456 initialization file, @file{~/.emacs}, substituting for `your-separator':
|
|
|
2457
|
|
|
2458 @cindex label separator, default
|
|
|
2459 @vindex kview:default-label-separator
|
|
|
2460 @lisp
|
|
|
2461 (setq kview:default-label-separator "your-separator")
|
|
|
2462 @end lisp
|
|
|
2463
|
|
|
2464
|
|
|
2465 @node Idstamps, Editing, Autonumbering, Outliner
|
|
|
2466 @section Idstamps
|
|
|
2467
|
|
|
2468 @cindex permanent identifier
|
|
|
2469 @cindex idstamp
|
|
|
2470 Idstamps (permanent ids) are associated with each cell and can be
|
|
|
2471 used in hyperlinks that are maintained as cells are reordered in a file.
|
|
|
2472 @xref{Links}. Idstamps may also be displayed in place of the outline
|
|
|
2473 level relative ids. Use @{@kbd{C-c C-l id RET}@}.
|
|
|
2474
|
|
|
2475 @cindex idstamp counter
|
|
|
2476 An idstamp counter for each outline starts at 0 and is incremented by
|
|
|
2477 one each time a cell is added to the outline. This idstamp stays with
|
|
|
2478 the cell no matter where it is moved within the outline. If the cell is
|
|
|
2479 deleted, its idstamp is not reused.
|
|
|
2480
|
|
|
2481 @cindex root cell
|
|
|
2482 @cindex top-level cell
|
|
|
2483 @cindex cell, top-level
|
|
|
2484 @cindex cell, idstamp 0
|
|
|
2485 @cindex idstamp 0
|
|
|
2486 The 0 idstamp is always assigned to the root node of the entire outline.
|
|
|
2487 This node is never visible within the outline, but is used so that the
|
|
|
2488 outline may be treated as a single tree when needed. Idstamps always
|
|
|
2489 begin with a 0, as in 012, to distinguish them from relative ids.
|
|
|
2490
|
|
|
2491
|
|
|
2492 @node Editing, Viewing, Idstamps, Outliner
|
|
|
2493 @section Editing
|
|
|
2494
|
|
|
2495 You edit text and move around in the Koutliner just as you would in any
|
|
|
2496 other Emacs buffer, except when you want to deal with the structural
|
|
|
2497 components of an outline. Within the contents of a cell, all of your
|
|
|
2498 standard editing keys should work properly. You can just type in text
|
|
|
2499 and the left and right margins of the lines will be maintained for you.
|
|
|
2500 @xref{Filling}, for the times when you need to refill a paragraph or to
|
|
|
2501 control when filling occurs.@refill
|
|
|
2502
|
|
|
2503 Don't invoke editing commands with @{@kbd{M-x command-name @key{RET}}@}
|
|
|
2504 since the Koutliner uses special differently named commands made to act
|
|
|
2505 like the regular editing commands but which account for the structure
|
|
|
2506 and indentation in koutlines.
|
|
|
2507
|
|
|
2508 @cindex cell, selection
|
|
|
2509 You can use the mouse to select parts of the contents of a single cell
|
|
|
2510 for editing. But don't drag across cell boundaries and then edit the
|
|
|
2511 selected region, since that can destroy the outline structure.
|
|
|
2512
|
|
|
2513 @menu
|
|
|
2514 * Adding and Killing::
|
|
|
2515 * Moving Around::
|
|
|
2516 * Relocating and Copying::
|
|
|
2517 * Filling::
|
|
|
2518 * Transposing::
|
|
|
2519 * Splitting and Appending::
|
|
|
2520 * Inserting and Importing::
|
|
|
2521 @end menu
|
|
|
2522
|
|
|
2523 @node Adding and Killing, Relocating and Copying, Editing, Editing
|
|
|
2524 @subsection Adding and Killing
|
|
|
2525
|
|
|
2526 @kindex C-j
|
|
|
2527 @kindex C-u c-j
|
|
|
2528 @kindex C-c a
|
|
|
2529 @kindex C-c p
|
|
|
2530 @cindex cell, adding
|
|
|
2531 @cindex cell, creating
|
|
|
2532 @{@kbd{C-j}@} adds a new cell as a successor sibling of the
|
|
|
2533 current cell, that is, the next cell at the same level as the current
|
|
|
2534 cell. If you enter a positive number as a prefix argument, that number
|
|
|
2535 of cells will be inserted, all at the same level. @{@kbd{C-u C-j}@} is
|
|
|
2536 handled specially. It adds a single cell as a child of the current cell.
|
|
|
2537 @{@kbd{C-c a}@} does the same thing. @{@kbd{C-c p}@} adds the cell as
|
|
|
2538 the successor of the current cell's parent.
|
|
|
2539
|
|
|
2540 @kindex C-c C-k
|
|
|
2541 @kindex C-c k
|
|
|
2542 @kindex C-u C-c k
|
|
|
2543 @kindex C-y
|
|
|
2544 @cindex cell, killing
|
|
|
2545 @cindex cell, yanking contents
|
|
|
2546 @cindex tree, killing
|
|
|
2547 @{@kbd{C-c C-k}@} kills the current cell and its entire subtree.
|
|
|
2548 @{@kbd{C-c k}@} kills the contents of a cell from point through the end
|
|
|
2549 of the cell; it does not remove the cell itself. @{@kbd{C-u C-c k}@}
|
|
|
2550 kills the entire contents of the cell regardless of the location of
|
|
|
2551 point. You may then yank the contents into another cell or another
|
|
|
2552 buffer with @{@kbd{C-y}@}.
|
|
|
2553
|
|
|
2554
|
|
|
2555 @node Relocating and Copying, Moving Around, Adding and Killing, Editing
|
|
|
2556 @subsection Relocating and Copying
|
|
|
2557
|
|
|
2558 @cindex promotion
|
|
|
2559 @cindex demotion
|
|
|
2560 @cindex tree, promoting
|
|
|
2561 @cindex tree, demoting
|
|
|
2562 @dfn{Demotion} is the act of moving a tree down one or more levels in the
|
|
|
2563 outline. The new tree will become either the successor or the first
|
|
|
2564 child of the cell which precedes it in the outline. @dfn{Promotion} is
|
|
|
2565 the inverse operation. Note that trees (cells and their entire
|
|
|
2566 substructure) are promoted and demoted, not individual cells.
|
|
|
2567
|
|
|
2568 @kindex @key{TAB}
|
|
|
2569 @kindex M-@key{TAB}
|
|
|
2570 Trees may be demoted or promoted by pressing @{@key{TAB}@} or
|
|
|
2571 @{@kbd{M-@key{TAB}}@} respectively, as in most outliners today.
|
|
|
2572 @{@kbd{M-0 @key{TAB}}@} and @{@kbd{M-0 M-@key{TAB}}@} demote and
|
|
|
2573 promote trees and additionally refill each cell that is not specially
|
|
|
2574 marked to prevent refilling. @xref{Filling}. A positive or negative
|
|
|
2575 prefix argument to these commands promotes or demotes the tree up to a
|
|
|
2576 maximum of the number of levels given by the argument. The outline may
|
|
|
2577 not support movement of the tree by the number of levels requested.
|
|
|
2578
|
|
|
2579 @cindex tree, copying
|
|
|
2580 @cindex tree, moving
|
|
|
2581 @cindex Action Key, cell argument
|
|
|
2582 @kindex Action Key, cell argument
|
|
|
2583 For maximum flexibility in rearranging outlines, there are commands that
|
|
|
2584 move or copy entire trees. Each of these commands prompts for the label
|
|
|
2585 of the root cell to move or copy and for second cell at the new location
|
|
|
2586 for the moved or copied tree. You can either accept the default
|
|
|
2587 provided, type in the cell label or when a mouse is available, simple
|
|
|
2588 double click with the Action Key on the contents of a cell. The
|
|
|
2589 Koutliner knows to use the cell's label in such cases.
|
|
|
2590
|
|
|
2591 In these following commands, words delimited with <> represent the
|
|
|
2592 arguments for which each command prompts. Note how the use of prefix
|
|
|
2593 arguments changes each command's behavior from insertion at the sibling
|
|
|
2594 level to insertion at the child level.
|
|
|
2595
|
|
|
2596 @table @kbd
|
|
|
2597 @kindex C-c c
|
|
|
2598 @item C-c c
|
|
|
2599 Copy <tree> to be the successor of <cell>.
|
|
|
2600 @kindex C-u C-c c
|
|
|
2601 @itemx C-u C-c c
|
|
|
2602 Copy <tree> to follow as the first child of <cell>.
|
|
|
2603
|
|
|
2604 @kindex C-c C-c
|
|
|
2605 @item C-c C-c
|
|
|
2606 Copy <tree> to be the predecessor of <cell>.
|
|
|
2607 @kindex C-u C-c C-c
|
|
|
2608 @itemx C-u C-c C-c
|
|
|
2609 Copy <tree> to be the first child of the parent of <cell>.
|
|
|
2610
|
|
|
2611 @kindex C-c m
|
|
|
2612 @item C-c m
|
|
|
2613 Move <tree> to be the successor of <cell>.
|
|
|
2614 @kindex C-u C-c m
|
|
|
2615 @itemx C-u C-c m
|
|
|
2616 Move <tree> to follow as the first child of <cell>.
|
|
|
2617
|
|
|
2618 @kindex C-c C-m
|
|
|
2619 @item C-c C-m
|
|
|
2620 Move <tree> to precede <cell>.
|
|
|
2621 @kindex C-u C-c C-m
|
|
|
2622 @itemx C-u C-c C-m
|
|
|
2623 Move <tree> to be the first child of the parent of <cell>.
|
|
|
2624 @end table
|
|
|
2625
|
|
|
2626 @cindex mouse, moving trees
|
|
|
2627 If you have mouse support under Hyperbole, you can move entire trees
|
|
|
2628 with mouse clicks. Simply click the Assist Key within the indentation
|
|
|
2629 to the left of a cell and you will be prompted for a tree to move.
|
|
|
2630 Double click the Action Key within the contents the root cell of the tree
|
|
|
2631 to move and then double click within the contents of the root cell of the
|
|
|
2632 tree you want it to follow as a sucessor.
|
|
|
2633
|
|
|
2634 Copying and moving only work within a single outline right now, so don't
|
|
|
2635 try to use them to move trees across different outline files. You can,
|
|
|
2636 however, copy an outline tree to a non-outline buffer with:
|
|
|
2637
|
|
|
2638 @cindex tree, exporting
|
|
|
2639 @cindex outline, exporting
|
|
|
2640 @cindex tree, mailing
|
|
|
2641 @cindex outline, mailing
|
|
|
2642 @cindex exporting an outline
|
|
|
2643 @cindex mailing an outline
|
|
|
2644 @table @kbd
|
|
|
2645 @kindex C-c M-c
|
|
|
2646 @item C-c M-c
|
|
|
2647 Copy <tree> to a non-koutline buffer.
|
|
|
2648 @kindex C-c @@
|
|
|
2649 @itemx C-c @@
|
|
|
2650 Copy a <tree> to an outgoing mail message.
|
|
|
2651 @end table
|
|
|
2652
|
|
|
2653 @node Moving Around, Filling, Relocating and Copying, Editing
|
|
|
2654 @subsection Moving Around
|
|
|
2655
|
|
|
2656 @cindex outline, motion
|
|
|
2657 In addition to normal Emacs movement commands, you can move within a
|
|
|
2658 cell or from one cell or tree to another.
|
|
|
2659
|
|
|
2660 @table @kbd
|
|
|
2661 @kindex C-c ,
|
|
|
2662 @item C-c ,
|
|
|
2663 Move to the beginning of the current cell.
|
|
|
2664 @kindex C-c .
|
|
|
2665 @itemx C-c .
|
|
|
2666 Move to the end of the current cell.
|
|
|
2667
|
|
|
2668 @kindex C-c C-n
|
|
|
2669 @item C-c C-n
|
|
|
2670 Move to the next visible cell, regardless of level.
|
|
|
2671 @kindex C-c C-p
|
|
|
2672 @itemx C-c C-p
|
|
|
2673 Move to the previous visible cell, regardless of level.
|
|
|
2674
|
|
|
2675 @kindex C-c C-f
|
|
|
2676 @item C-c C-f
|
|
|
2677 Move forward to this cell's successor, if any.
|
|
|
2678 @kindex C-c C-b
|
|
|
2679 @itemx C-c C-b
|
|
|
2680 Move backward to this cell's predecessor, if any.
|
|
|
2681
|
|
|
2682 @kindex C-c C-d
|
|
|
2683 @item C-c C-d
|
|
|
2684 Move to the first child of the current cell, if any.
|
|
|
2685 @kindex C-c C-u
|
|
|
2686 @itemx C-c C-u
|
|
|
2687 Move to the parent cell of the current cell, if any.
|
|
|
2688
|
|
|
2689 @kindex C-c <
|
|
|
2690 @item C-c <
|
|
|
2691 Move to the first sibling at the current level within this tree.
|
|
|
2692 @kindex C-c >
|
|
|
2693 @itemx C-c >
|
|
|
2694 Move to the last sibling at the current level within this tree.
|
|
|
2695
|
|
|
2696 @kindex C-c ^
|
|
|
2697 @item C-c ^
|
|
|
2698 Move to the level 1 root cell of the current tree.
|
|
|
2699 @kindex C-c $
|
|
|
2700 @itemx C-c $
|
|
|
2701 Move to the last cell in the tree rooted at point, regardless of level.
|
|
|
2702 @end table
|
|
|
2703
|
|
|
2704
|
|
|
2705 @node Filling, Transposing, Moving Around, Editing
|
|
|
2706 @subsection Filling
|
|
|
2707
|
|
|
2708 @cindex outline, filling
|
|
|
2709 Filling is the process of extending lines that are shorter than the
|
|
|
2710 right margin and reducing lines which extend past the margin by moving
|
|
|
2711 words among the lines. Commands are provided to fill a paragraph within
|
|
|
2712 a cell or a whole cell, which may have multiple paragraphs.
|
|
|
2713
|
|
|
2714 @cindex filling
|
|
|
2715 @cindex cell, filling
|
|
|
2716 @cindex paragraph, filling
|
|
|
2717 @cindex tree, filling
|
|
|
2718 @cindex margin
|
|
|
2719 @kindex M-q
|
|
|
2720 @kindex M-j
|
|
|
2721 @kindex C-c M-q
|
|
|
2722 @kindex C-c M-j
|
|
|
2723 @kindex C-M-q
|
|
|
2724 @kindex C-M-j
|
|
|
2725 @{@kbd{M-q}@} or @{@kbd{M-j}@} refills a paragraph within a
|
|
|
2726 cell so that its lines wrap within the current margin settings.
|
|
|
2727 @{@kbd{C-c M-q}@} or @{@kbd{C-c M-j}@} refills all paragraphs within a
|
|
|
2728 cell. @{@kbd{C-M-q}@} or @{@kbd{C-M-j}@} refills all cells within a
|
|
|
2729 tree. See your Emacs or InfoDock manual for information on how to set
|
|
|
2730 the left and right margins.
|
|
|
2731
|
|
|
2732 @vindex kotl-mode:refill-flag
|
|
|
2733 @cindex refilling
|
|
|
2734 @cindex attribute, no-fill
|
|
|
2735 @cindex cell, no-fill attribute
|
|
|
2736 Set the variable, @var{kotl-mode:refill-flag}, to t if you want
|
|
|
2737 moving, promoting, demoting, exchanging, splitting and appending cells
|
|
|
2738 to also automatically refill each cell. Generally, this is not
|
|
|
2739 recommended since if you happen to move a cell that you have carefully
|
|
|
2740 formatted and forgot to give it a `no-fill' property, your formatting
|
|
|
2741 will be lost.
|
|
|
2742
|
|
|
2743
|
|
|
2744 @node Transposing, Splitting and Appending, Filling, Editing
|
|
|
2745 @subsection Transposing
|
|
|
2746
|
|
|
2747 The Koutliner move and copy commands rearrange entire trees. The
|
|
|
2748 following two commands, in contrast, exchange the locations of two
|
|
|
2749 individual cells.
|
|
|
2750
|
|
|
2751 @kindex C-c e
|
|
|
2752 @cindex cell, transposing
|
|
|
2753 @cindex cell, exchanging
|
|
|
2754 @cindex exchanging cells
|
|
|
2755 @cindex transposing cells
|
|
|
2756 @{@kbd{C-c e}@} prompts for two cell addresses and exchanges the cell
|
|
|
2757 locations.
|
|
|
2758
|
|
|
2759 @kindex C-c t
|
|
|
2760 @{@kbd{C-c t}@} does not prompt. It exchanges the current
|
|
|
2761 and immediatly prior cell, regardless of their levels. If there is no
|
|
|
2762 prior cell it exchanges the current and next cell.
|
|
|
2763
|
|
|
2764 @cindex cell, mark and point
|
|
|
2765 @kindex M-0 C-c t
|
|
|
2766 @{@kbd{M-0 C-c t}@} exchanges the cells in which point and mark fall.
|
|
|
2767 @{@kbd{C-c t}@} with a non-zero numeric prefix argument, N, moves
|
|
|
2768 the current tree past maximally the next N visible cells. If there are
|
|
|
2769 fewer visible, it makes the current cell the last cell in the outline.
|
|
|
2770
|
|
|
2771
|
|
|
2772 @node Splitting and Appending, Inserting and Importing, Transposing, Editing
|
|
|
2773 @subsection Splitting and Appending
|
|
|
2774
|
|
|
2775 @cindex splitting a cell
|
|
|
2776 @cindex cell, splitting
|
|
|
2777 @kindex C-c s
|
|
|
2778 @kindex C-u C-c s
|
|
|
2779 You can split one cell into two adjacent sibling cells with @{@kbd{C-c
|
|
|
2780 s}@}. This leaves the cell contents preceding point in the current
|
|
|
2781 cell, minus any trailing whitespace, and moves the contents following
|
|
|
2782 point to a new sibling cell which is inserted into the outline.
|
|
|
2783 @{@kbd{C-u C-c s}@} instead adds the new cell as the first child of the
|
|
|
2784 original cell, rather than as its successor.
|
|
|
2785
|
|
|
2786 All cell attributes in the original cell are propagated to the new one,
|
|
|
2787 aside from the creation attributes and idstamp.
|
|
|
2788
|
|
|
2789 @kindex C-c +
|
|
|
2790 @cindex cell, appending
|
|
|
2791 @cindex appending to a cell
|
|
|
2792 @cindex attribute, no-fill
|
|
|
2793 @cindex cell, no-fill attribute
|
|
|
2794 @{@kbd{C-c +}@} appends the contents of a specified cell to the end of
|
|
|
2795 another cell. It has no effect on cell attributes, except that if one
|
|
|
2796 cell has a `no-fill' attribute that prevents all but user requested
|
|
|
2797 filling of a cell, then the cell appended to inherits this property.
|
|
|
2798 This helps maintain any special formatting the appended text may have.
|
|
|
2799
|
|
|
2800
|
|
|
2801 @node Inserting and Importing, , Splitting and Appending, Editing
|
|
|
2802 @subsection Inserting and Importing
|
|
|
2803
|
|
|
2804 @cindex outline, inserting into
|
|
|
2805 @cindex outline, importing into
|
|
|
2806 @cindex importation
|
|
|
2807 @cindex insertion
|
|
|
2808 @kindex C-x i
|
|
|
2809 @cindex outline, foreign file
|
|
|
2810 The elements of another buffer or file may be inserted into a koutline
|
|
|
2811 as a set of cells by using the @{@kbd{C-x i}@} command. When prompted,
|
|
|
2812 you may use a buffer name or file name from which to insert, though
|
|
|
2813 completion is provided only for file names.
|
|
|
2814
|
|
|
2815 @kindex C-u C-x i
|
|
|
2816 The elements from the original buffer are converted into kcells and
|
|
|
2817 inserted as the successors of the current cell. If @{@kbd{C-u C-x i}@}
|
|
|
2818 is used, they are instead inserted as the inital children of the current
|
|
|
2819 cell.
|
|
|
2820
|
|
|
2821 @vindex kimport:mode-alist
|
|
|
2822 @vindex kimport:suffix-alist
|
|
|
2823 @cindex outline, conversion
|
|
|
2824 @findex kotl-mode
|
|
|
2825 @cindex outline mode
|
|
|
2826 @cindex koutline mode
|
|
|
2827 @cindex file, importing
|
|
|
2828 @cindex importing a file
|
|
|
2829 See the documentation for the variables, kimport:mode-alist and
|
|
|
2830 kimport:suffix-alist, for information on mode and suffix-specific
|
|
|
2831 conversions performed on file elements before they are inserted. This
|
|
|
2832 same conversion process applies if you invoke @{@kbd{M-x kotl-mode
|
|
|
2833 RET}@} in a non-koutline buffer or if you perform a generic file import
|
|
|
2834 as described later in this section.
|
|
|
2835
|
|
|
2836 @findex kotl-mode:insert-file-contents
|
|
|
2837 Use @{@kbd{M-x kotl-mode:insert-file-contents RET}@} to insert the
|
|
|
2838 entire contents of a file into the current cell at the location of
|
|
|
2839 point.
|
|
|
2840
|
|
|
2841 @findex kimport:file
|
|
|
2842 The outliner presently supports conversion of three types of files into
|
|
|
2843 koutline files. You can choose to import a file into an existing
|
|
|
2844 koutline, following the tree at point, or to create a new koutline of
|
|
|
2845 the imported file contents. @{@kbd{M-x kimport:file RET}@} will select
|
|
|
2846 the importation type based on the buffer or file name suffix of the file
|
|
|
2847 to import.
|
|
|
2848
|
|
|
2849 @findex kotl-mode
|
|
|
2850 If you want to convert a buffer from some other mode into a koutline and
|
|
|
2851 then want to save the converted buffer back to its original file,
|
|
|
2852 thereby replacing the original format, then use @{@kbd{M-x kotl-mode
|
|
|
2853 RET}@} to convert the buffer into a koutline. Remember that you will
|
|
|
2854 lose the old format of the buffer when you do this.
|
|
|
2855
|
|
|
2856 Use one of the following commands if you really need explicit control over the
|
|
|
2857 type of importation used on some text. With these commands, your
|
|
|
2858 original file remains intact.
|
|
|
2859
|
|
|
2860 @findex kimport:text
|
|
|
2861 @cindex text file
|
|
|
2862 Use @{@kbd{M-x kimport:text RET}@} and you will be prompted for a text
|
|
|
2863 buffer or file to import and the new koutline buffer or file to create
|
|
|
2864 from its text. It will also import the contents, attributes and level
|
|
|
2865 structure of cells from a koutline.
|
|
|
2866
|
|
|
2867 @findex kimport:star-outline
|
|
|
2868 @cindex emacs outline
|
|
|
2869 @cindex star outline
|
|
|
2870 Star outlines are standard Emacs outlines where each entry begins with
|
|
|
2871 one or more asterisk characters. Use @{@kbd{M-x kimport:star-outline
|
|
|
2872 RET}@} and you will be prompted for the star outline buffer or file to
|
|
|
2873 import and the new koutline buffer or file to create.
|
|
|
2874
|
|
|
2875 @cindex Augment outline
|
|
|
2876 @findex kimport:aug-post-outline
|
|
|
2877 (Skip this if you are unfamiliar with the Augment system.) Files
|
|
|
2878 exported from the Augment system as text often have alphanumeric
|
|
|
2879 statement identifiers on the right side. You can import such files
|
|
|
2880 while maintaining there outline structure. Use @{@kbd{M-x
|
|
|
2881 kimport:aug-post-outline RET}@} and you will be prompted for the Augment
|
|
|
2882 buffer or file to import and the koutline to create.
|
|
|
2883
|
|
|
2884
|
|
|
2885 @node Viewing, Links, Editing, Outliner
|
|
|
2886 @section Viewing
|
|
|
2887
|
|
|
2888 @cindex outline, viewing
|
|
|
2889 @cindex view
|
|
|
2890 The Koutliner has very flexible viewing facilities to allow you to
|
|
|
2891 effectively browse and study large amounts of material.
|
|
|
2892
|
|
|
2893 @menu
|
|
|
2894 * Hiding and Showing::
|
|
|
2895 * View Specs::
|
|
|
2896 @end menu
|
|
|
2897
|
|
|
2898 @node Hiding and Showing, View Specs, Viewing, Viewing
|
|
|
2899 @subsection Hiding and Showing
|
|
|
2900
|
|
|
2901 @cindex outline, hiding
|
|
|
2902 @cindex outline, showing
|
|
|
2903 @cindex collapsing
|
|
|
2904 @cindex expanding
|
|
|
2905 @cindex hiding
|
|
|
2906 @cindex showing
|
|
|
2907 Individual cells, branches, or particular levels in the outline may be
|
|
|
2908 hidden or shown. These commands work even when an outline buffer is
|
|
|
2909 read-only, e.g. when its file is not checked out of a version control
|
|
|
2910 system yet, so that you can get effective views of an outline without
|
|
|
2911 editing it. Some of these commands affect the current view spec,
|
|
|
2912 @ref{View Specs}.
|
|
|
2913
|
|
|
2914 @table @kbd
|
|
|
2915 @cindex hide tree
|
|
|
2916 @cindex tree, show
|
|
|
2917 @kindex C-c C-h
|
|
|
2918 @item C-c C-h
|
|
|
2919 Hide (collapse) the tree rooted at point.
|
|
|
2920 @cindex show tree
|
|
|
2921 @cindex tree, show
|
|
|
2922 @kindex C-c C-s
|
|
|
2923 @itemx C-c C-s
|
|
|
2924 Show (expand) the tree rooted at point.
|
|
|
2925
|
|
|
2926 @cindex outline, all cells
|
|
|
2927 @cindex cell, show all
|
|
|
2928 @kindex C-c C-a
|
|
|
2929 @item C-c C-a
|
|
|
2930 Show (expand) all of the cells in the outline.
|
|
|
2931 @cindex level
|
|
|
2932 @cindex cell, show levels
|
|
|
2933 @cindex outline, show levels
|
|
|
2934 @kindex C-x $
|
|
|
2935 @itemx C-x $
|
|
|
2936 Show all of the cells down to a particular <level>. You are prompted
|
|
|
2937 for the level or a prefix argument may be given.
|
|
|
2938
|
|
|
2939 @cindex subtree, hide
|
|
|
2940 @cindex tree, hide subtree
|
|
|
2941 @cindex cell, hide subtree
|
|
|
2942 @cindex hide subtree
|
|
|
2943 @kindex C-M-h
|
|
|
2944 @item C-M-h
|
|
|
2945 Hide the subtree at point, excluding the root cell.
|
|
|
2946 @cindex subtree, show
|
|
|
2947 @cindex tree, show subtree
|
|
|
2948 @cindex cell, show subtree
|
|
|
2949 @cindex show subtree
|
|
|
2950 @itemx M-x kotl-mode:show-subtree
|
|
|
2951 Show the subtree at point. Use @{@kbd{C-c C-s}@} to achieve a similar
|
|
|
2952 effect. The only difference is that it will expand the root cell too.
|
|
|
2953
|
|
|
2954 @cindex overview
|
|
|
2955 @cindex outline, overview
|
|
|
2956 @kindex C-c C-o
|
|
|
2957 @item C-c C-o
|
|
|
2958 Show an overview of the outline by showing only the first line of
|
|
|
2959 every cell. This also turns off blank lines between cells to maximize
|
|
|
2960 your view of the outline.
|
|
|
2961 @cindex top-level view
|
|
|
2962 @cindex outline, top-level
|
|
|
2963 @kindex C-c C-t
|
|
|
2964 @itemx C-c C-t
|
|
|
2965 Show a top-level view of the outline by showing only the first line of
|
|
|
2966 each level one cell. This does not turn off blank lines.
|
|
|
2967 @end table
|
|
|
2968
|
|
|
2969 @kindex Action Key, hide or show cell
|
|
|
2970 @cindex Action Key, hide or show cell
|
|
|
2971 @cindex cell, collapse
|
|
|
2972 @cindex cell, expand
|
|
|
2973 @kindex M-@key{RET}
|
|
|
2974 A click or a press of the Action Key within a cell's body, but not on a
|
|
|
2975 Hyperbole button, toggles between hiding and showing the tree rooted at
|
|
|
2976 point. Try it with either your mouse or with @{@kbd{M-@key{RET}}@}.
|
|
|
2977
|
|
|
2978
|
|
|
2979 @node View Specs, , Hiding and Showing, Viewing
|
|
|
2980 @subsection View Specs
|
|
|
2981
|
|
|
2982 @cindex view spec
|
|
|
2983 @cindex modeline, view spec
|
|
|
2984 @vindex kvspec:string
|
|
|
2985 @cindex pipe character
|
|
|
2986 @cindex |
|
|
|
2987 @cindex <|viewspec>
|
|
|
2988 @dfn{View specifications} (view specs, for short) are short codes used
|
|
|
2989 to control the view of a koutline. The view specs in effect for an
|
|
|
2990 outline are always displayed in the modeline of the outline's window,
|
|
|
2991 following the outline buffer name, unless the variable,
|
|
|
2992 @var{kvspec:string}, has been set to @code{nil} to disable view spec
|
|
|
2993 modeline display. The modeline display appears as <|viewspec> so that
|
|
|
2994 you can easily pick them out. The | (pipe character) is also used in
|
|
|
2995 links that specify view specs to indicate the start of a view spec
|
|
|
2996 sequence. @xref{Links}.
|
|
|
2997
|
|
|
2998 @cindex outline, view specs
|
|
|
2999 The current view spec is saved whenever the outline is saved. The next
|
|
|
3000 time the outline is read in, this will be the initial view.
|
|
|
3001
|
|
2
|
3002 The rest of this section documents the view spec characters that are
|
|
0
|
3003 presently supported and explains how to invoke a view spec. There is no
|
|
|
3004 user-level way to add your own view spec characters, so all character
|
|
|
3005 codes are reserved for future use.
|
|
|
3006
|
|
|
3007 @kindex C-c C-v
|
|
|
3008 @cindex view spec, setting
|
|
|
3009 @cindex view spec, changing
|
|
|
3010 @cindex changing the view spec
|
|
|
3011 @cindex setting the view spec
|
|
|
3012 @{@kbd{C-c C-v}@} prompts for a new view spec setting in which the following
|
|
|
3013 codes are valid. Any invalid characters in a view spec are ignored.
|
|
|
3014 Characters are evaluated in an order meant to do the right thing, even
|
|
|
3015 when you use conflicting view spec characters. The standard initial
|
|
|
3016 view spec is <|ben>.
|
|
|
3017
|
|
|
3018 @cindex view spec, characters
|
|
|
3019 @table @kbd
|
|
|
3020 @cindex view spec, all lines and levels
|
|
|
3021 @item a
|
|
|
3022 Show all cell levels and all lines in cells.
|
|
|
3023
|
|
|
3024 @kindex C-c b
|
|
|
3025 @cindex blank lines, toggle
|
|
|
3026 @cindex view spec, blank lines
|
|
|
3027 @kindex C-c b
|
|
|
3028 @cindex toggling blank lines
|
|
|
3029 @item b
|
|
|
3030 Turn on blank lines between cells. Without this character, blank lines
|
|
|
3031 will be turned off. You can also use the @{@kbd{C-c b}@} key binding to
|
|
|
3032 toggle line numbers on and off independent of any other view settings.
|
|
|
3033
|
|
|
3034 @cindex view spec, lines per cell
|
|
|
3035 @cindex hide lines
|
|
|
3036 @cindex collapse lines
|
|
|
3037 @cindex cutoff lines
|
|
|
3038 @item cN
|
|
|
3039 Hide any lines greater than N in each cell. 0 means don't cutoff any
|
|
|
3040 lines.
|
|
|
3041
|
|
|
3042 @cindex ellipses
|
|
|
3043 @cindex view spec, ellipses
|
|
|
3044 @item e
|
|
|
3045 Show ellipses when some content of a cell or its subtree is hidden.
|
|
|
3046
|
|
|
3047 @cindex level
|
|
|
3048 @cindex cell, hiding levels
|
|
|
3049 @cindex hide levels
|
|
|
3050 @cindex view spec, show levels
|
|
|
3051 @item lN
|
|
|
3052 Hide cells at levels deeper than N. 0 means don't hide any cells.
|
|
|
3053
|
|
|
3054 @cindex label type
|
|
|
3055 @cindex view spec, label type
|
|
|
3056 @vindex kview:default-label-type
|
|
|
3057 @cindex default label type
|
|
|
3058 @item n
|
|
|
3059 Turn on the default label type, as given by the variable,
|
|
|
3060 @var{kview:default-label-type}. Normally, this is alphanumeric labels.
|
|
|
3061 @cindex label type, idstamps
|
|
|
3062 @itemx n0
|
|
|
3063 Display idstamps.
|
|
|
3064 @cindex label type, alpha
|
|
|
3065 @itemx n1
|
|
|
3066 Display alpha labels.
|
|
|
3067 @cindex label type, partial alpha
|
|
|
3068 @itemx n2
|
|
|
3069 Display partial alpha labels (don't use this, as full alpha labels are
|
|
|
3070 better).
|
|
|
3071 @cindex label type, legal
|
|
|
3072 @itemx n.
|
|
|
3073 Display legal labels.
|
|
|
3074 @cindex label type, star
|
|
|
3075 @cindex label type, asterisk
|
|
|
3076 @itemx n*
|
|
|
3077 Display star labels. A level three cell would have three asterisks as a
|
|
|
3078 label, for example.
|
|
|
3079 @cindex label type, no labels
|
|
|
3080 @itemx n~
|
|
|
3081 Turn off labels. (n viewspec is removed from modeline).
|
|
|
3082 @end table
|
|
|
3083
|
|
|
3084 @cindex view spec, example
|
|
|
3085 As a test, use @{@kbd{C-h h o e}@} to display the example koutline.
|
|
|
3086 Then use @{@kbd{C-c C-v}@} to set a view spec of `c2l1'. This will turn
|
|
|
3087 off blank lines, clip each cell after its second line, and hide all
|
|
|
3088 cells below level one.
|
|
|
3089
|
|
|
3090
|
|
|
3091 @node Links, Cell Attributes, Viewing, Outliner
|
|
|
3092 @section Links
|
|
|
3093
|
|
|
3094 @cindex link
|
|
|
3095 @cindex hyperlink
|
|
|
3096 @cindex klink
|
|
|
3097 @cindex <> delimiters
|
|
|
3098 Hyperlinks may be embedded in cells and may refer to other cells or
|
|
|
3099 external sources of information. Explicit Hyperbole buttons may be
|
|
|
3100 created as usual via mouse drags, @ref{By Dragging, Creation Via Action
|
|
|
3101 Key Drags}. A @dfn{klink} is a special implicit link button, delimited
|
|
|
3102 by <> separators, that jumps to a specific outline cell. This section
|
|
|
3103 discusses klinks.
|
|
|
3104
|
|
|
3105 @kindex Action Key, klink
|
|
|
3106 @cindex Action Key, klink
|
|
|
3107 @cindex klink, activating
|
|
|
3108 @cindex klink referent
|
|
|
3109 Press the Action Key over a klink to follow it. This will flash the
|
|
|
3110 klink as a button and then will display its referent in the other
|
|
|
3111 window. If the klink contains a view spec, that will be used when the
|
|
|
3112 referent is displayed.
|
|
|
3113
|
|
|
3114 @cindex klink, inserting
|
|
|
3115 @kindex C-c l
|
|
|
3116 There are a number of easy ways to insert klinks into koutlines. If you
|
|
|
3117 have mouse support under Hyperbole, simply click the Action Key within
|
|
|
3118 the indentation to the left of a cell text. If you then double click on
|
|
|
3119 some cell, a link to that cell will be inserted where you started. From
|
|
|
3120 a keyboard, use @{@kbd{C-c l}@} when in a koutline or @{@kbd{C-h h o
|
|
|
3121 l}@} when not in a koutline to insert a klink. Since klinks are
|
|
|
3122 implicit buttons, you can type in the text of the klink just as you see
|
|
|
3123 it in the examples below and it will work exactly as if it had been
|
|
|
3124 entered with the insert link command.
|
|
|
3125
|
|
|
3126 @cindex klink, formats
|
|
|
3127 @noindent
|
|
|
3128 There are basically three forms of klinks:
|
|
|
3129
|
|
|
3130 @table @bullet
|
|
|
3131 @cindex internal klink
|
|
|
3132 @cindex klink, internal
|
|
|
3133 @cindex <@@ klink>
|
|
|
3134 @item internal
|
|
|
3135 <@@ 2b=06> is an internal klink, since it refers to the koutline in which
|
|
|
3136 it is embedded. When activated, it jumps to the cell within the current
|
|
|
3137 outline which has permanent id `06' and relative id `2b'. <@@ 06> does
|
|
|
3138 the same thing, as does <@@ 2b>, though this latter form will not
|
|
|
3139 maintain the link properly if the cell is moved elsewhere within the
|
|
|
3140 outline. The form, <@@ 2b=06 |ben> additionally sets the view spec of
|
|
|
3141 the current outline back to the default value, with a blank line between
|
|
|
3142 each cell and all levels and lines of cells displayed.
|
|
|
3143
|
|
|
3144 @cindex external klink
|
|
|
3145 @cindex klink, external
|
|
|
3146 @item external
|
|
|
3147 The second klink format is an external link to another koutline, such
|
|
|
3148 as, <EXAMPLE.kotl, 3=012 |c1e>, which displays the named file, starting
|
|
|
3149 at the cell 3 (whose permanent identifer is 012), with the view
|
|
|
3150 specification of: blank lines turned off, cutoff after one line per
|
|
|
3151 cell, and show ellipses for cells or trees which are clipped.
|
|
|
3152
|
|
|
3153 @cindex klink, view spec
|
|
|
3154 @cindex view spec klink
|
|
|
3155 @item view spec
|
|
|
3156 The third format simply allows you to set a view spec for the current
|
|
|
3157 koutline. For example, <|ben>, when activated, sets the view in the
|
|
|
3158 current outline to display blank lines, ellipses following collapsed
|
|
|
3159 lines and standard alphanumeric numbering.
|
|
|
3160 @end table
|
|
|
3161
|
|
|
3162
|
|
|
3163 @node Cell Attributes, Outliner History, Links, Outliner
|
|
|
3164 @section Cell Attributes
|
|
|
3165
|
|
|
3166 @cindex cell, attribute
|
|
|
3167 @cindex attribute
|
|
|
3168 @dfn{Attributes} are named variables whose values are specific to a
|
|
|
3169 particular outline cell. Thus, each cell has its own attribute list.
|
|
|
3170 Every cell has three standard attributes:
|
|
|
3171
|
|
|
3172 @table @bullet
|
|
|
3173 @cindex idstamp attribute
|
|
|
3174 @item idstamp
|
|
|
3175 The permanent id of the cell, typically used in cross-file hyperlinks
|
|
|
3176 that reference the cell.
|
|
|
3177
|
|
|
3178 @cindex creator attribute
|
|
|
3179 @cindex e-mail address
|
|
|
3180 @cindex mail address
|
|
|
3181 @item creator
|
|
|
3182 The e-mail address of the person who created this cell.
|
|
|
3183
|
|
|
3184 @cindex create-time attribute
|
|
|
3185 @cindex cell, creation time
|
|
|
3186 @item create-time
|
|
|
3187 The time at which the cell was created. This is stored in a form that
|
|
|
3188 allows for easy data comparisons but is displayed in a human readable
|
|
|
3189 format, such as "Jan 28 18:27:59 CST 1994".
|
|
|
3190 @end table
|
|
|
3191
|
|
|
3192 @kindex C-c C-i
|
|
|
3193 @cindex attribute, adding
|
|
|
3194 @cindex attribute, modifying
|
|
|
3195 @cindex attribute, removing
|
|
|
3196 @{@kbd{C-c C-i}@} is the command to add an attribute to or to modify an
|
|
|
3197 existing attribute in the cell at point. Think of it as inserting an
|
|
|
3198 attribute value. To remove an attribute from cell, set its value to
|
|
|
3199 @code{nil}.
|
|
|
3200
|
|
|
3201
|
|
|
3202 @cindex attribute, no-fill
|
|
|
3203 @cindex cell, no-fill attribute
|
|
|
3204 @cindex no-fill attribute
|
|
|
3205 @vindex kotl-mode:refill-flag
|
|
|
3206 The `no-fill' attribute is special. When added with a non-nil value, it
|
|
|
3207 prevents moving, promoting, demoting, exchanging, splitting and
|
|
|
3208 appending cells from refilling the cell, even if the variable,
|
|
|
3209 @var{kotl-mode:refill-flag}, is set to t. It does not prevent you from
|
|
|
3210 invoking explicit commands that refill the cell. @xref{Filling}.
|
|
|
3211
|
|
|
3212 @kindex Assist Key, listing attributes
|
|
|
3213 @cindex Assist Key, listing attributes
|
|
|
3214 @cindex listing attributes
|
|
|
3215 @cindex outline, attribute list
|
|
|
3216 The attribute lists for the cells in the tree rooted at point can be
|
|
|
3217 displayed by pressing the Assist Key within the contents of a cell.
|
|
|
3218
|
|
|
3219 @kindex C-c h
|
|
|
3220 @kindex C-u C-c h
|
|
|
3221 @{@kbd{C-c h}@} prompts for a cell label and displays the cell's
|
|
|
3222 attributes. @{@kbd{C-u C-c h}@} prompts for a cell label and displays
|
|
|
3223 the attributes for it and its subtree; use 0 as the kcell id to see
|
|
|
3224 attributes for all visible cells in the outline.
|
|
|
3225
|
|
|
3226
|
|
|
3227 @node Outliner History, , Cell Attributes, Outliner
|
|
|
3228 @section Outliner History
|
|
|
3229
|
|
|
3230 @cindex NLS
|
|
|
3231 @cindex Augment
|
|
|
3232 @cindex Engelbart
|
|
|
3233 Much of the Hyperbole outliner design is based upon concepts pioneered
|
|
|
3234 in the NLS/Augment system, @cite{[Eng84a]}. Augment treated documents as
|
|
|
3235 a hierarchical set of nodes, called statements, rather than cells.
|
|
|
3236 Every Augment document utilized this intrinsic structure.
|
|
|
3237
|
|
|
3238 @cindex distributed collaboration
|
|
|
3239 @cindex collaboration
|
|
|
3240 The system could rapidly change the view of a document by collapsing,
|
|
|
3241 expanding, generating, clipping, filtering, including or reordering
|
|
|
3242 these nodes. It could also map individual views to multiple workstation
|
|
|
3243 displays across a network to aid in distributed, collaborative work.
|
|
|
3244
|
|
|
3245 @cindex knowledge transfer
|
|
|
3246 @cindex idea structuring
|
|
|
3247 @cindex cross referencing
|
|
|
3248 These facilities aided greatly in idea structuring, cross-referencing,
|
|
|
3249 and knowledge transfer. The Koutliner is a start at bringing
|
|
|
3250 these capabilities back into the mainstream of modern computing culture.
|
|
|
3251
|
|
|
3252
|
|
|
3253 @node Rolodex, Window Configurations, Outliner, Top
|
|
|
3254 @chapter Rolodex
|
|
|
3255
|
|
|
3256 @cindex rolodex
|
|
|
3257 @cindex wrolo
|
|
|
3258 Hyperbole includes a complete, advanced rolodex system, Wrolo, for
|
|
|
3259 convenient management of hierarchical, record-oriented information.
|
|
|
3260
|
|
|
3261 @cindex rolo, buttons in
|
|
|
3262 Hyperbole buttons may be included within rolodex records and then
|
|
|
3263 manually activated whenever their records are retrieved.
|
|
|
3264
|
|
|
3265 @vindex file, wrolo.el
|
|
|
3266 See the description at the top of the @file{wrolo.el} file for
|
|
|
3267 details on programmatic interfacing to the rolodex. The following
|
|
|
3268 subsections explain use and basic customization of the rolodex.
|
|
|
3269
|
|
|
3270 @menu
|
|
|
3271 * Rolo Concepts::
|
|
|
3272 * Rolo Menu::
|
|
|
3273 * Rolo Keys::
|
|
|
3274 * Rolo Settings::
|
|
|
3275 @end menu
|
|
|
3276
|
|
|
3277 @node Rolo Concepts, Rolo Menu, Rolodex, Rolodex
|
|
|
3278 @section Rolo Concepts
|
|
|
3279
|
|
|
3280 @cindex rolodex file
|
|
|
3281 @cindex rolodex entry
|
|
|
3282 The rolodex manages and searches rolodex files. A @dfn{rolodex file}
|
|
|
3283 consists of an optional header which starts and ends with a line of
|
|
|
3284 equal signs (at least three equal signs starting at the beginning of a
|
|
|
3285 line), followed by any non-negative number of rolodex records. You must
|
|
|
3286 manually add a header to any rolodex file if you want it to have one.
|
|
|
3287
|
|
|
3288 @noindent
|
|
|
3289 Here is an example of a simple rolodex file.
|
|
|
3290
|
|
|
3291 @example
|
|
|
3292 @group
|
|
|
3293 ==================================================================
|
|
|
3294 PERSONAL ROLODEX
|
|
|
3295 <Last-Name>, <First> <Email> W<Work#> F<Fax#>
|
|
|
3296 ==================================================================
|
|
|
3297 * Smith, John <js@@hiho.com> W708-555-2001 F708-321-1492
|
|
|
3298 Chief Ether Maintainer, HiHo Industries
|
|
|
3299 10/24/95
|
|
|
3300 @end group
|
|
|
3301 @end example
|
|
|
3302
|
|
|
3303 We call rolodex records, @dfn{entries}. Entries begin with a delimiter,
|
|
|
3304 some number of `*' characters at the beginning of a line. Entries may
|
|
|
3305 be arranged in a hierarchy, where child entries begin with one more `*'
|
|
|
3306 characters than do their parents. Top level entries begin with a single
|
|
|
3307 `*'.
|
|
|
3308
|
|
|
3309 Beyond this initial delimiter, entries are completely free-form text.
|
|
|
3310 It is best to use a "lastname, firstname" format, however, when adding
|
|
|
3311 contact entries into a rolodex. Then the rolodex system will
|
|
|
3312 automatically keep your entries alphabetized as you enter them. You'll
|
|
|
3313 also be able to sort them whenever you desire.
|
|
|
3314
|
|
|
3315 Any search done on the rolodex scans the full text of each entry.
|
|
|
3316 During a search, the rolodex file header separator lines and anything in
|
|
|
3317 between are appended to the buffer of matched entries before any entries
|
|
|
3318 are retrieved from the file. Whenever an entry is matched, it and all
|
|
|
3319 of its descendant entries are retrieved. If your Emacs version supports
|
|
|
3320 textual highlighting, each search match is highlighted for quick, visual
|
|
|
3321 location.
|
|
|
3322
|
|
|
3323 @noindent
|
|
|
3324 For example, a search on "Company" could retrieve the following:
|
|
|
3325
|
|
|
3326 @example
|
|
|
3327 @group
|
|
|
3328 ==================================================================
|
|
|
3329 COMPANY ROLODEX
|
|
|
3330 ==================================================================
|
|
|
3331 * Company
|
|
|
3332 ** Manager
|
|
|
3333 *** Underlings
|
|
|
3334 @end group
|
|
|
3335 @end example
|
|
|
3336
|
|
|
3337 @noindent
|
|
|
3338 Thus, searching for Company retrieves all listed employees.
|
|
|
3339 Searching for Manager turns up all Underlings.
|
|
|
3340
|
|
|
3341
|
|
|
3342 @node Rolo Menu, Rolo Keys, Rolo Concepts, Rolodex
|
|
|
3343 @section Rolo Menu
|
|
|
3344
|
|
|
3345 @cindex rolodex menu
|
|
|
3346 The Rolo/ menu entry on the Hyperbole top-level menu provides the
|
|
|
3347 user interface to the rolodex. The rolo menu provides access to the
|
|
|
3348 following commands:
|
|
|
3349
|
|
|
3350 @example
|
|
|
3351 @group
|
|
|
3352 @cindex rolodex commands
|
|
|
3353 @cindex Wrolo commands
|
|
|
3354 @findex rolo-add
|
|
|
3355 @findex rolo-display-matches
|
|
|
3356 @findex rolo-edit
|
|
|
3357 @findex rolo-kill
|
|
|
3358 @findex rolo-mail-to
|
|
|
3359 @findex rolo-sort
|
|
|
3360 @findex rolo-grep
|
|
|
3361 @findex rolo-fgrep
|
|
|
3362 @findex rolo-word
|
|
|
3363 @findex rolo-yank
|
|
|
3364 Menu Item Command Description
|
|
|
3365 ====================================================================
|
|
|
3366 Add rolo-add Adds a rolodex entry
|
|
|
3367 Display rolo-display-matches Displays last matches again
|
|
|
3368 Edit rolo-edit Edits an existing rolodex entry
|
|
|
3369 Info Displays Rolodex manual entry
|
|
|
3370 Kill rolo-kill Removes an entry from the rolodex
|
|
|
3371 Mail rolo-mail Mail to address following point
|
|
|
3372 Order rolo-sort Sorts all levels in rolodex
|
|
|
3373 RegexFind rolo-grep Finds all entries containing
|
|
|
3374 a regular expression
|
|
|
3375 StringFind rolo-fgrep Finds all entries containing
|
|
|
3376 a string
|
|
|
3377 WordFind rolo-word Finds all entries containing
|
|
|
3378 a string of whole words
|
|
|
3379 Yank rolo-yank Inserts first matching rolodex
|
|
|
3380 entry at point
|
|
|
3381 ====================================================================
|
|
|
3382 @end group
|
|
|
3383 @end example
|
|
|
3384
|
|
|
3385 A prefix argument used with either of the find commands listed above
|
|
|
3386 limits the search to a maximum number of matches given by the argument.
|
|
|
3387 The search is terminated whenever that number of matches is found.
|
|
|
3388
|
|
|
3389 For any of the above commands that prompt for a name, you may use the
|
|
|
3390 form parent/child to locate a child entry below a parent entry. So for
|
|
|
3391 a rolodex which looked like so:
|
|
|
3392
|
|
|
3393 @example
|
|
|
3394 @group
|
|
|
3395 * Company
|
|
|
3396 ** Manager
|
|
|
3397 *** Underlings
|
|
|
3398 @end group
|
|
|
3399 @end example
|
|
|
3400
|
|
|
3401 @noindent
|
|
|
3402 You could edit the Underlings entry by identifying it as
|
|
|
3403 Company/Manager/Underlings. Do not use this hierarchical notation in
|
|
|
3404 search expressions since the whole rolodex will be searched anyway.
|
|
|
3405 Thus, "Underlings" as a search pattern will find an entry containing
|
|
|
3406 "Underlings" at any level in a hierarchy, like so:
|
|
|
3407
|
|
|
3408 @example
|
|
|
3409 *** Underlings
|
|
|
3410 @end example
|
|
|
3411
|
|
|
3412 @node Rolo Keys, Rolo Settings, Rolo Menu, Rolodex
|
|
|
3413 @section Rolo Keys
|
|
|
3414
|
|
|
3415 @kindex e
|
|
|
3416 @cindex rolodex, editing an entry
|
|
|
3417 Use the @{@kbd{e}@} key to edit the entry at point within the rolodex
|
|
|
3418 source file.
|
|
|
3419
|
|
|
3420 @cindex wrolo menu
|
|
|
3421 @cindex rolodex keys
|
|
|
3422 After a rolodex search is performed, point is left in the @dfn{rolodex
|
|
|
3423 match buffer}, @file{*Rolodex*}, which uses @code{wrolo-mode} to
|
|
|
3424 simplify browsing many rolodex matches. Press @{@kbd{?}@} when in the
|
|
|
3425 match buffer for a summary of available keys.
|
|
|
3426
|
|
|
3427 @kindex TAB
|
|
|
3428 @kindex M-TAB
|
|
|
3429 @kindex r
|
|
|
3430 @cindex rolodex, highlighting matches
|
|
|
3431 @cindex rolodex, finding matches
|
|
|
3432 @cindex rolodex, moving through matches
|
|
|
3433 If your Emacs version supports textual highlighting, each search match
|
|
|
3434 is highlighted for quick, visual location. @{@key{TAB}@} moves point
|
|
|
3435 forward to successive spans of text which match the search expression.
|
|
|
3436 @{@kbd{M-@key{TAB}}@} or @{@kbd{r}@} moves point backward to earlier
|
|
|
3437 matches. These keys allow you to quickly find the matching entry of
|
|
|
3438 most interest to you if your search expression failed to narrow the
|
|
|
3439 matches sufficiently.
|
|
|
3440
|
|
|
3441 @kindex M-s
|
|
|
3442 @kindex C-r
|
|
|
3443 @cindex rolodex, extending a match
|
|
|
3444 @cindex rolodex, interactive searching
|
|
|
3445 If you want to extend the match expression with some more characters to
|
|
|
3446 find a particular entry, use @{@kbd{M-s}@}, which performs an
|
|
|
3447 interactive search forward for the match expression. You can add or
|
|
|
3448 delete characters to this expression to find different occurences.
|
|
|
3449 @{@kbd{C-r}@} will reverse the direction of the search.
|
|
|
3450
|
|
|
3451 @kindex a
|
|
|
3452 @kindex h
|
|
|
3453 @kindex s
|
|
|
3454 @kindex t
|
|
|
3455 @cindex rolodex, outlining
|
|
|
3456 Single key outlining commands are also available for browsing matches.
|
|
|
3457 If your search matches a large number of entries, use
|
|
|
3458 @{@kbd{t}@} to get a top-level overview of all the entries. Each entry
|
|
|
3459 is collapsed so that only its first line shows. Press @{@kbd{s}@} to
|
|
|
3460 show (expand) the entry at point. Use @{@kbd{h}@} to hide (collapse)
|
|
|
3461 the entry again. Press @{@kbd{a}@} to expand all entries in the buffer.
|
|
|
3462
|
|
|
3463 Many other keys are defined to help you move through matching entries.
|
|
|
3464
|
|
|
3465 @cindex rolodex, moving to entries
|
|
|
3466 @table @kbd
|
|
|
3467 @kindex b
|
|
|
3468 @item b
|
|
|
3469 Move to the previous entry at the same level as the current entry.
|
|
|
3470 @kindex f
|
|
|
3471 @item f
|
|
|
3472 Move to the next entry at the same level as the current entry.
|
|
|
3473 @kindex n
|
|
|
3474 @item n
|
|
|
3475 Move to the next entry at any level.
|
|
|
3476 @kindex p
|
|
|
3477 @item p
|
|
|
3478 Move to the previous entry at any level.
|
|
|
3479 @kindex u
|
|
|
3480 @item u
|
|
2
|
3481 Move to the previous entry one level up.
|
|
0
|
3482 @kindex .
|
|
|
3483 @kindex <
|
|
|
3484 @item .
|
|
|
3485 @itemx <
|
|
|
3486 Move to the beginning of the buffer.
|
|
|
3487 @kindex ,
|
|
|
3488 @kindex >
|
|
|
3489 @item ,
|
|
|
3490 @itemx >
|
|
|
3491 Move to the end of the buffer.
|
|
|
3492 @kindex @key{DEL}
|
|
|
3493 @item @key{DEL}
|
|
|
3494 Scroll backward a windowful.
|
|
|
3495 @kindex @key{SPC}
|
|
|
3496 @item @key{SPC}
|
|
|
3497 Scroll forward a windowful.
|
|
|
3498 @end table
|
|
|
3499
|
|
|
3500 @kindex q
|
|
|
3501 @cindex rolodex, quitting
|
|
|
3502 Once you have found an entry of interest and you want to remove the
|
|
|
3503 rolodex match buffer, use @{@kbd{q}@} to quit. This will restore your
|
|
|
3504 current frame to its state prior to the rolodex search.
|
|
|
3505
|
|
|
3506 @node Rolo Settings, , Rolo Keys, Rolodex
|
|
|
3507 @section Rolo Settings
|
|
|
3508
|
|
|
3509 @vindex rolo-highlight-face
|
|
|
3510 @cindex rolodex, highlighting matches
|
|
|
3511 If textual highlighting is available in your Emacs on your current
|
|
|
3512 display type, the rolodex uses the value of @var{rolo-highlight-face} as
|
|
|
3513 the face to use to highlight search matches.
|
|
|
3514
|
|
|
3515 @vindex rolo-kill-buffers-after-use
|
|
|
3516 The buffers containing the rolodex files are not killed after a search
|
|
|
3517 on the assumption that another search is likely to follow within this
|
|
|
3518 Emacs session. You may wish to change this behavior with the following
|
|
|
3519 setting: @code{(setq rolo-kill-buffers-after-use t)}.
|
|
|
3520
|
|
|
3521 @vindex rolo-save-buffers-after-use
|
|
|
3522 After an entry is killed, the modified rolodex file is automatically
|
|
|
3523 saved. If you would rather always save files yourself, use this
|
|
|
3524 setting: @code{(setq rolo-save-buffers-after-use nil)}.
|
|
|
3525
|
|
|
3526 @vindex rolo-email-format
|
|
|
3527 When adding an entry from within a buffer containing a mail message, the
|
|
|
3528 rolodex add function will extract the sender's name and e-mail address
|
|
|
3529 and prompt you with the name as a default. If you accept it, it will
|
|
|
3530 enter the name and the email address using the format given by the
|
|
|
3531 @var{rolo-email-format} variable. See its documentation if you want to
|
|
|
3532 change its value.
|
|
|
3533
|
|
|
3534 @vindex rolo-file-list
|
|
|
3535 @cindex rolodex, personal
|
|
|
3536 The files used in any rolodex search are given by the
|
|
|
3537 @var{rolo-file-list} variable, whose default value is
|
|
|
3538 @code{("~/.rolodex.otl")}, so that searches initially scan only your
|
|
|
3539 personal rolodex. Any entries added to this list should be file
|
|
|
3540 pathnames. If a file in the list does not exist or is not readable, it
|
|
|
3541 is skipped. Files are searched in the order in which they appear in the
|
|
|
3542 list. In general, you should leave your personal rolodex file as the
|
|
|
3543 first entry in the list, since this is the only file to which the rolo
|
|
|
3544 menu Add command adds entries.@refill
|
|
|
3545
|
|
|
3546 @vindex rolo-entry-regexp
|
|
|
3547 The rolodex entry start delimiter is given by the regular expression
|
|
|
3548 variable, @var{rolo-entry-regexp}, whose default value is "^\*+".
|
|
|
3549
|
|
|
3550 @vindex rolo-hdr-regexp
|
|
|
3551 A rolodex file may begin with an optional header section which is copied
|
|
|
3552 to the match display buffer whenever any matches are found during a
|
|
|
3553 search. The start and end lines of this header are controlled by
|
|
|
3554 the regular expression variable, @var{rolo-hdr-regexp}, whose default
|
|
|
3555 value is "^===". This allows lines of all equal signs to visually
|
|
|
3556 separate matching entries from multiple files retrieved from a single
|
|
|
3557 search.
|
|
|
3558
|
|
|
3559 @node Window Configurations, Developing with Hyperbole, Rolodex, Top
|
|
|
3560 @chapter Window Configurations
|
|
|
3561
|
|
|
3562 @cindex window configurations
|
|
|
3563 @cindex restoring windows
|
|
|
3564 @cindex saving window configurations
|
|
|
3565 @vindex file, wconfig.el
|
|
|
3566 Hyperbole includes the @file{wconfig.el} package which lets you save and
|
|
|
3567 restore window configurations, i.e@. the window layout and buffers
|
|
|
3568 displayed within an Emacs frame. This is useful to save a particular
|
|
|
3569 working context and then to jump back to it at a later time during an
|
|
|
3570 Emacs session. It is also useful during demonstrations to pull up many
|
|
|
3571 informational artifacts all at once, e.g@. all of the windows for a
|
|
|
3572 particular subsystem. None of this information is stored between Emacs
|
|
|
3573 sessions, so your window configurations will last only through a single
|
|
|
3574 session of use.
|
|
|
3575
|
|
|
3576 The wconfig library provides two distinct means of managing window
|
|
|
3577 configurations. The first means associates a name with each stored
|
|
|
3578 window configuration. The name can then be used to retrieve the window
|
|
|
3579 configuration later. The second means uses a ring structure to save
|
|
|
3580 window configurations and then allows browsing through the sequence of
|
|
|
3581 saved configurations.
|
|
|
3582
|
|
|
3583 The Win/ menu entry on the Hyperbole top-level menu displays a menu of
|
|
|
3584 window configuration commands:
|
|
|
3585
|
|
|
3586 @noindent
|
|
|
3587 @display
|
|
|
3588 WinConfig> AddName DeleteName RestoreName PopRing SaveRing YankRing
|
|
|
3589 @end display
|
|
|
3590
|
|
|
3591 @example
|
|
|
3592 @group
|
|
|
3593 @cindex wconfig commands
|
|
|
3594 @cindex window configuration commands
|
|
|
3595 @findex wconfig-add-by-name
|
|
|
3596 @findex wconfig-delete-by-name
|
|
|
3597 @findex wconfig-restore-by-name
|
|
|
3598 @findex wconfig-delete-pop
|
|
|
3599 @findex wconfig-ring-save
|
|
|
3600 @findex wconfig-yank-pop
|
|
|
3601 Menu Item Command Description
|
|
|
3602 ====================================================================
|
|
|
3603 AddName wconfig-add-by-name Name current wconfig
|
|
|
3604 DeleteName wconfig-delete-by-name Delete wconfig with name
|
|
|
3605 RestoreName wconfig-restore-by-name Restore wconfig by name
|
|
|
3606
|
|
|
3607 PopRing wconfig-delete-pop Restore and delete wconfig
|
|
|
3608 SaveRing wconfig-ring-save Store wconfig to ring
|
|
|
3609 YankRing wconfig-yank-pop Restore next wconfig
|
|
|
3610 ====================================================================
|
|
|
3611 @end group
|
|
|
3612 @end example
|
|
|
3613
|
|
|
3614 Saving and restoring window configurations by name is the easiest
|
|
|
3615 method, but it requires that you input the chosen name from the
|
|
|
3616 keyboard. The ring commands permit saving and restoring through mouse
|
|
|
3617 interaction only, if so desired. The prior section, @ref{Smart Keys},
|
|
|
3618 mentions how to save and restore window configurations with the Smart Keys.
|
|
|
3619 Since the ring commands are a bit more complex than their by-name
|
|
|
3620 counterparts, the following paragraphs explain them in more detail.
|
|
|
3621
|
|
|
3622 @vindex kill-ring
|
|
|
3623 Wconfig creates a ring structure that operates just like the Emacs
|
|
|
3624 @var{kill-ring}, @ref{Kill Ring,,,emacs, The GNU Emacs Manual}, but its
|
|
|
3625 elements are window configurations rather than text regions. One can
|
|
|
3626 add an element to the ring based upon the current window configuration.
|
|
|
3627 After several elements are in the ring, one can walk through all of them
|
|
|
3628 in sequence until the desired configuration is restored.
|
|
|
3629
|
|
|
3630 @findex wconfig-ring-save
|
|
|
3631 SaveRing executes the @code{wconfig-ring-save} command which
|
|
|
3632 saves the current window configuration to the ring.
|
|
|
3633
|
|
|
3634 @findex wconfig-yank-pop
|
|
|
3635 YankRing executes the @code{wconfig-yank-pop} command. It restores the
|
|
|
3636 window configuration from the currently pointed to configuration in the
|
|
|
3637 ring. It does not delete this configuration from the ring but it does
|
|
|
3638 move the pointer to the prior ring element. Repeated calls to this
|
|
|
3639 command thus restore successive window configurations until the ring
|
|
|
3640 pointer wraps around. Simply stop when a desired configuration appears
|
|
|
3641 and use @{@kbd{q}@} to quit from the minibuffer menu.
|
|
|
3642
|
|
|
3643 @findex wconfig-delete-pop
|
|
|
3644 PopRing calls the @code{wconfig-delete-pop} command.
|
|
|
3645 It is used to restore a previously saved configuration and at the same
|
|
|
3646 time delete it from the ring. Simply stop when a desired configuration
|
|
|
3647 appears and use @{@kbd{q}@} to quit from the minibuffer menu.
|
|
|
3648
|
|
|
3649 @vindex wconfig-ring-max
|
|
|
3650 The maximum number of elements the ring can hold is set by the
|
|
|
3651 @var{wconfig-ring-max} variable whose default is 10. Any saves beyond
|
|
|
3652 this value cause deletion of the oldest element in the ring before
|
|
|
3653 a new one is added.
|
|
|
3654
|
|
|
3655 @node Developing with Hyperbole, Glossary, Window Configurations, Top
|
|
|
3656 @chapter Developing with Hyperbole
|
|
|
3657
|
|
|
3658 This chapter is only for people who are familiar with Emacs Lisp and
|
|
|
3659 wish to customize Hyperbole, to extend it, or to develop other systems
|
|
|
3660 using Hyperbole as a base.
|
|
|
3661
|
|
|
3662 @menu
|
|
|
3663 * Hook Variables::
|
|
|
3664 * Creating Types::
|
|
|
3665 * Explicit Button Technicalities::
|
|
|
3666 * Encapsulating Systems::
|
|
|
3667 * Embedding Hyperbole::
|
|
|
3668 @end menu
|
|
|
3669
|
|
|
3670 @node Hook Variables, Creating Types, Developing with Hyperbole, Developing with Hyperbole
|
|
|
3671 @section Hook Variables
|
|
|
3672
|
|
|
3673 @cindex variables
|
|
|
3674 @cindex hook variables
|
|
|
3675 Hyperbole provides a number of hook variables that allow you to adjust
|
|
|
3676 its basic operations to meet your own needs, without requiring you to
|
|
|
3677 change the code for those operations.
|
|
|
3678
|
|
|
3679 We find it best to always set the value of hook variables either to nil
|
|
|
3680 or to a list of function names of no arguments, each of which will be
|
|
|
3681 called in sequence when the hook is triggered.
|
|
|
3682
|
|
|
3683 Given the name of a function, a Hyperbole hook variable triggered within
|
|
|
3684 that function has the same name as the function with a @code{-hook}
|
|
|
3685 appended. Hyperbole provides the following hook variables:
|
|
|
3686
|
|
|
3687 @table @var
|
|
|
3688
|
|
|
3689 @vindex hyperb:init-hook
|
|
|
3690 @item hyperb:init-hook
|
|
|
3691 For customization at Hyperbole initialization time. Use this to load
|
|
|
3692 any personal Hyperbole type definitions you might have. It is run after
|
|
|
3693 Hyperbole support code is loaded but before Hyperbole session
|
|
|
3694 initializations take place.
|
|
|
3695
|
|
|
3696 @vindex action:act-hook
|
|
|
3697 @vindex hbut:current
|
|
|
3698 @item action:act-hook
|
|
|
3699 Run before each Hyperbole button activation.
|
|
|
3700 The variable @var{hbut:current} contains the button to be activated when
|
|
|
3701 this is run.
|
|
|
3702
|
|
|
3703 @vindex ebut:create-hook
|
|
|
3704 @item ebut:create-hook
|
|
|
3705 To add to the Hyperbole explicit button creation process.
|
|
|
3706
|
|
|
3707 @vindex ebut:delete-hook
|
|
|
3708 @item ebut:delete-hook
|
|
|
3709 To add to the Hyperbole explicit button deletion process.
|
|
|
3710
|
|
|
3711 @vindex ebut:modify-hook
|
|
|
3712 @item ebut:modify-hook
|
|
|
3713 Executed when an explicit button's attributes are modified.
|
|
|
3714
|
|
|
3715 @vindex hibtypes:begin-load-hook
|
|
|
3716 @item hibtypes:begin-load-hook
|
|
|
3717 Executed prior to loading of standard Hyperbole implicit button types.
|
|
|
3718 Used to load site-specific low priority implicit button types since
|
|
|
3719 lowest priority ibtypes are loaded first.
|
|
|
3720
|
|
|
3721 @vindex hibtypes:end-load-hook
|
|
|
3722 @item hibtypes:end-load-hook
|
|
|
3723 Executed after loading of standard Hyperbole implicit button types.
|
|
|
3724 Used to load site-specific high priority implicit button types since
|
|
|
3725 highest priority ibtypes are loaded last.
|
|
|
3726
|
|
|
3727 @vindex htype:create-hook
|
|
|
3728 @item htype:create-hook
|
|
|
3729 Executed when a Hyperbole type (e.g@. action type or implicit button
|
|
|
3730 type) is added to the environment.
|
|
|
3731
|
|
|
3732 @vindex htype:delete-hook
|
|
|
3733 @item htype:delete-hook
|
|
|
3734 Executed when a type is deleted from the environment.
|
|
|
3735
|
|
|
3736 @vindex kotl-mode-hook
|
|
|
3737 @item kotl-mode-hook
|
|
|
3738 Executed when a Koutline is created or read in or when kotl-mode is
|
|
|
3739 invoked.
|
|
|
3740
|
|
|
3741 @vindex wrolo-display-hook
|
|
|
3742 @item wrolo-display-hook
|
|
|
3743 Executed when rolodex matches are displayed.
|
|
|
3744
|
|
|
3745 @vindex wrolo-mode-hook
|
|
|
3746 @item wrolo-mode-hook
|
|
|
3747 Executed when a rolodex match buffer is created and put into wrolo-mode.
|
|
|
3748
|
|
|
3749 @vindex wrolo-yank-reformat-function
|
|
|
3750 @cindex yank, reformatting
|
|
|
3751 @item wrolo-yank-reformat-function
|
|
|
3752 A variable whose value may be set to a function of two arguments, START
|
|
|
3753 and END, indicating the region of the rolodex entry yanked into the
|
|
|
3754 current buffer by the rolo-yank command. The function may reformat this
|
|
|
3755 region to meed user-specific needs.
|
|
|
3756
|
|
|
3757 @end table
|
|
|
3758
|
|
|
3759 @noindent
|
|
|
3760 Hyperbole also makes use of a number of external Emacs hook variables.
|
|
|
3761
|
|
|
3762 @table @var
|
|
|
3763
|
|
|
3764 @vindex find-file-hooks
|
|
|
3765 @cindex button highlighting
|
|
|
3766 @item find-file-hooks
|
|
|
3767 This is called whenever a file is read into a GNU Emacs buffer.
|
|
|
3768 Hyperbole uses it to highlight any buttons within files when run under
|
|
|
3769 any NEXTSTEP or X window system-based versions of GNU Emacs.
|
|
|
3770
|
|
|
3771 @vindex write-file-hooks
|
|
|
3772 @cindex button data saving
|
|
|
3773 @item write-file-hooks
|
|
|
3774 This is called whenever a GNU Emacs buffer is written to a file.
|
|
|
3775 Hyperbole uses it to save any modified button data associated with the
|
|
|
3776 file's directory.
|
|
|
3777
|
|
|
3778 @cindex mail hooks
|
|
|
3779 @cindex news hooks
|
|
|
3780 Hyperbole mail and news facilities also utilize a number of external hook
|
|
|
3781 variables. These hide button data and highlight buttons if possible.
|
|
|
3782 See the various support files for details.
|
|
|
3783 @end table
|
|
|
3784
|
|
|
3785 @node Creating Types, Explicit Button Technicalities, Hook Variables, Developing with Hyperbole
|
|
|
3786 @section Creating Types
|
|
|
3787
|
|
|
3788 @cindex type definition
|
|
|
3789 @cindex type redefinition
|
|
|
3790 @noindent
|
|
|
3791 To define or redefine a single Hyperbole type, you may either:
|
|
|
3792
|
|
|
3793 @itemize @bullet
|
|
|
3794 @kindex C-M-x
|
|
|
3795 @findex eval-defun
|
|
|
3796 @kindex C-x C-e
|
|
|
3797 @findex eval-last-sexp
|
|
|
3798 @item
|
|
|
3799 move your Emacs point to within the type definition and use
|
|
|
3800 @{@kbd{C-M-x}@} @code{(eval-defun)} (only works in Emacs Lisp mode);
|
|
|
3801
|
|
|
3802 @item
|
|
|
3803 or move your point to the end of the last line of the type definition and
|
|
|
3804 use @{@kbd{C-x C-e}@} @code{(eval-last-sexp)} (works in most modes).
|
|
|
3805 @end itemize
|
|
|
3806
|
|
|
3807 @cindex Hyperbole types
|
|
|
3808 @vindex class, htype
|
|
|
3809 The functions from the @code{htype} class may be applied to any
|
|
|
3810 Hyperbole types, if needed.
|
|
|
3811
|
|
|
3812 @vindex file, hactypes.el
|
|
|
3813 @vindex file, hibtypes.el
|
|
|
3814 The following subsections explain the specifics of Hyperbole type
|
|
|
3815 definitions which are beyond standard practice for Emacs Lisp programming.
|
|
|
3816 See the definitions of the standard types in @file{hactypes.el}
|
|
|
3817 and @file{hibtypes.el} for examples.
|
|
|
3818
|
|
|
3819 @menu
|
|
|
3820 * Action Type Creation::
|
|
|
3821 * Implicit Button Types::
|
|
|
3822 @end menu
|
|
|
3823
|
|
|
3824 @node Action Type Creation, Implicit Button Types, Creating Types, Creating Types
|
|
|
3825 @subsection Action Type Creation
|
|
|
3826
|
|
|
3827 @findex actype:create
|
|
|
3828 @vindex file, hactypes.el
|
|
|
3829 @vindex file, hbut.el
|
|
|
3830 New forms of explicit buttons may be created by adding new action types
|
|
|
3831 to a Hyperbole environment. The file, @file{hactypes.el}, provides
|
|
|
3832 many examples of working action types.
|
|
|
3833
|
|
|
3834 @cindex action type, creation
|
|
|
3835 @findex defact
|
|
|
3836 @findex actype:create
|
|
|
3837 An action type is created, i.e@. loaded into the Hyperbole environment,
|
|
|
3838 with the @code{(defact)} function (which is an alias for
|
|
|
3839 @code{(actype:create)}). The calling signature for this function is
|
|
|
3840 given in its documentation; it is the same as that of @code{(defun)}
|
|
|
3841 except that a documentation string is required. (An interactive calling
|
|
|
3842 form is also required if the action type has formal parameters and is to
|
|
|
3843 be used in explicit button definitions. Implicit buttons never use an
|
|
|
3844 action type's interactive form. It is good practice to include an
|
|
|
3845 interactive form since the type creator cannot know how users may choose
|
|
|
3846 to apply the type.)@refill
|
|
|
3847
|
|
|
3848 An action type's parameters are used differently than those of a
|
|
|
3849 function being called. Its interactive calling form is used when an
|
|
|
3850 explicit button is created to prompt for type-specific button
|
|
|
3851 attributes. The rest of its body is used when a button with that action
|
|
|
3852 type is activated. Then the button attributes together with the action
|
|
|
3853 type body are used to form an action that is executed in response to the
|
|
|
3854 button activation. The action's result is returned to the action caller
|
|
|
3855 unless it returns nil, in which case t is returned to the caller to
|
|
|
3856 ensure that it registers the performance of the action.
|
|
|
3857
|
|
|
3858 An action type body may perform any computation using Emacs Lisp and
|
|
|
3859 Hyperbole functions.
|
|
|
3860
|
|
|
3861 @cindex interactive form
|
|
|
3862 @findex interactive
|
|
|
3863 The interactive calling form for an action type is of the same form as
|
|
|
3864 that of a regular Emacs Lisp function definition (see the documentation
|
|
|
3865 for the Emacs Lisp @code{(interactive)} form). It may additionally use
|
|
|
3866 Hyperbole command character extensions when the form is given as a
|
|
|
3867 string. Each such extension character @emph{must} be preceded by a plus
|
|
|
3868 sign, @code{+}, in order to be recognized since such characters may also
|
|
|
3869 have standard interactive form meanings.
|
|
|
3870
|
|
|
3871 The present Hyperbole extension characters are:
|
|
|
3872
|
|
|
3873 @table @strong
|
|
|
3874 @cindex argument, Info node
|
|
|
3875 @cindex interactive cmd char, +I
|
|
|
3876 @item +I
|
|
|
3877 Prompts for an existing Info node name and file.
|
|
|
3878
|
|
|
3879 @cindex argument, kcell
|
|
|
3880 @cindex argument, koutline
|
|
|
3881 @cindex interactive cmd char, +K
|
|
|
3882 @item +K
|
|
|
3883 Prompts for an existing kcell identifier, either a full outline level
|
|
|
3884 identifier or a permanent idstamp.
|
|
|
3885
|
|
|
3886 @cindex interactive cmd char, +M
|
|
|
3887 @cindex argument, mail message
|
|
|
3888 @item +M
|
|
|
3889 Prompts for a mail message date and the file name it resides in.
|
|
|
3890 The mail parameters prompted for by this character code are likely to
|
|
|
3891 change in the future.
|
|
|
3892
|
|
|
3893 @cindex argument, view spec
|
|
|
3894 @cindex interactive cmd char, +V
|
|
|
3895 @item +V
|
|
|
3896 Prompts for a Hyperbole view specification.
|
|
|
3897 Not yet available for use.
|
|
|
3898
|
|
|
3899 @end table
|
|
|
3900
|
|
|
3901 @vindex class, hargs
|
|
|
3902 @cindex argument, reading
|
|
|
3903 Arguments are read by the functions in Hyperbole's @code{hargs} class,
|
|
|
3904 rather than the standard Lisp @code{read} functions, in order to allow
|
|
|
3905 direct selection of arguments via the Action Key.
|
|
|
3906
|
|
|
3907 If an action type create is successful, the symbol that Hyperbole uses
|
|
|
3908 internally to reference the type is returned. @code{Nil} is returned on
|
|
|
3909 failure so that you may test whether or not the operation succeeds.
|
|
|
3910
|
|
|
3911 Once you have defined an action type within your present Hyperbole
|
|
|
3912 environment, you can create new explicit buttons which use it. There is
|
|
|
3913 no explicit button type beyond its action type, so no further work is
|
|
|
3914 necessary.
|
|
|
3915
|
|
|
3916 @findex actype:delete
|
|
|
3917 Call @code{(actype:delete)} to remove an action type from a Hyperbole
|
|
|
3918 environment. It takes a single parameter which should be the same type
|
|
|
3919 symbol used in the type definition call (not the Hyperbole symbol
|
|
|
3920 returned by the call).
|
|
|
3921
|
|
|
3922 @node Implicit Button Types, , Action Type Creation, Creating Types
|
|
|
3923 @subsection Implicit Button Types
|
|
|
3924
|
|
|
3925 @cindex implicit button type
|
|
|
3926 @cindex ibtype
|
|
|
3927 @findex defib
|
|
|
3928 @findex ibtype:create
|
|
|
3929 An implicit button type is created or loaded via the @code{(defib)}
|
|
|
3930 function (which is an alias for @code{(ibtype:create)}). The calling
|
|
|
3931 signature for this function is given in its documentation; it is the
|
|
|
3932 same as that of @code{(defun)}, but with a number of constraints. The
|
|
|
3933 parameter list should always be empty since no parameters will be used.
|
|
|
3934 A documentation string is required. The type's body follows this.
|
|
|
3935
|
|
|
3936 @cindex ibtype, predicate
|
|
|
3937 @cindex ibtype, argument
|
|
|
3938 @cindex ibtype, return val
|
|
|
3939 @cindex ibtype, actype
|
|
|
3940 The body of an implicit button type is a predicate which determines
|
|
|
3941 whether or not point is within an implicit button of the type. If not,
|
|
|
3942 the predicate returns @code{nil}. If so, it may optionally setup to
|
|
|
3943 flash the button and then perform one or more actions. A call of the
|
|
|
3944 form: @code{(ibut:label-set label start-pos end-pos)} is used to setup
|
|
|
3945 the button flashing, if desired. This is then typically immediately
|
|
|
3946 followed by an action invocation of the form:
|
|
|
3947 @code{(hact 'actype &rest actype-arguments)}. It is imperative that all
|
|
|
3948 actions (non-predicate code) be invoked through the @code{(hact)}
|
|
|
3949 function rather than directly or your ibtypes will not work properly.
|
|
|
3950 (Hyperbole first tests to see if any ibtype matches the current context
|
|
|
3951 before activating any type, so it ensures that @code{(hact)} calls are
|
|
|
3952 disabled during this testing.) Any action types used may be created
|
|
|
3953 before or after the implicit button type definition but obviously should
|
|
|
3954 be defined before any implicit buttons of the given type are activated;
|
|
|
3955 an error will result, otherwise.
|
|
|
3956
|
|
|
3957 If an implicit button type create is successful, the symbol that
|
|
|
3958 Hyperbole uses internally to reference the type is returned. @code{Nil}
|
|
|
3959 is returned on failure so that you may test whether or not the operation
|
|
|
3960 succeeds. Implicit button type names and action type names may be the
|
|
|
3961 same without any conflict. In fact, such naming is encouraged when an
|
|
|
3962 implicit button type is the exclusive user of an action type.
|
|
|
3963
|
|
|
3964 @findex ibtype:delete
|
|
|
3965 Call @code{(ibtype:delete)} to remove an implicit button type from a
|
|
|
3966 Hyperbole environment. It takes a single parameter which should be the
|
|
|
3967 same type symbol used in the type definition call (not the Hyperbole
|
|
|
3968 symbol returned by the call). This will not delete the action type used
|
|
|
3969 by the implicit button; that must be done separately.
|
|
|
3970
|
|
|
3971 @cindex ibtype, help
|
|
|
3972 @findex ibut:at-p
|
|
|
3973 @vindex class, hattr
|
|
|
3974 @vindex class, hbut
|
|
|
3975 @vindex file, hib-kbd.el
|
|
|
3976 By default, a request for help on an implicit button will display the
|
|
|
3977 button's attributes in the same manner as is done for explicit buttons.
|
|
|
3978 For some implicit button types, other forms of help will be more
|
|
|
3979 appropriate. If an Emacs Lisp function is defined whose name is formed
|
|
|
3980 from the concatenation of the type name followed by @code{:help}, e.g@.
|
|
|
3981 @code{my-ibtype:help}, it is used to respond to requests for
|
|
|
3982 help on buttons of that type. Any such function should take a single
|
|
|
3983 argument of an implicit button construct. (This is what
|
|
|
3984 @code{(ibut:at-p)} returns when point is within an implicit button
|
|
|
3985 context.) The button may be queried for its attributes using functions
|
|
|
3986 from the @code{hbut} and @code{hattr} classes. See the @file{hib-kbd.el}
|
|
|
3987 file for an example of a custom help function.
|
|
|
3988
|
|
|
3989 @node Explicit Button Technicalities, Encapsulating Systems, Creating Types, Developing with Hyperbole
|
|
|
3990 @section Explicit Button Technicalities
|
|
|
3991 @menu
|
|
|
3992 * Button Label Normalization::
|
|
|
3993 * Operational and Storage Formats::
|
|
|
3994 * Programmatic Button Creation::
|
|
|
3995 @end menu
|
|
|
3996
|
|
|
3997 @node Button Label Normalization, Operational and Storage Formats, Explicit Button Technicalities, Explicit Button Technicalities
|
|
|
3998 @subsection Button Label Normalization
|
|
|
3999 @cindex normalized label
|
|
|
4000 @cindex button label
|
|
|
4001 @cindex button key
|
|
|
4002 @vindex hbut:label-to-key
|
|
|
4003 Hyperbole uses a normalized form of button labels called button keys (or
|
|
|
4004 label keys) for all internal operations. See the documentation for the
|
|
|
4005 function @code{(hbut:label-to-key)} for details of the normalization
|
|
|
4006 process. The normalized form permits Hyperbole to recognize buttons that
|
|
|
4007 are the same but whose labels appear different from one another, due to
|
|
|
4008 text formatting conventions. For example, all of the following would
|
|
|
4009 be recognized as the same button.
|
|
|
4010
|
|
|
4011 @example
|
|
|
4012 <(fake button)> <( fake button)>
|
|
|
4013
|
|
|
4014 Pam> <(fake
|
|
|
4015 Pam> button)>
|
|
|
4016
|
|
|
4017 ;; <(fake
|
|
|
4018 ;; button)>
|
|
|
4019
|
|
|
4020 /* <( fake */
|
|
|
4021 /* button )> */
|
|
|
4022 @end example
|
|
|
4023
|
|
|
4024 @vindex hbut:fill-prefix-regexps
|
|
|
4025 @vindex fill-prefix
|
|
|
4026 @cindex fill prefix
|
|
|
4027 @cindex button, multiple lines
|
|
|
4028 @cindex button, split across lines
|
|
|
4029 The last three examples demonstrate how Hyperbole ignores common fill
|
|
|
4030 prefix patterns that happen to fall within the middle of a button label
|
|
|
4031 that spans multiple lines. As long as such buttons are selected with
|
|
|
4032 point at a location within the label's first line, the button will be
|
|
|
4033 recognized. The variable @var{hbut:fill-prefix-regexps} holds the list
|
|
|
4034 of fill prefixes recognized when embedded within button labels. All
|
|
|
4035 such prefixes are recognized (one per button label), regardless of the
|
|
|
4036 setting of the GNU Emacs variable, @var{fill-prefix}, so no user
|
|
|
4037 intervention is required.
|
|
|
4038
|
|
|
4039 @node Operational and Storage Formats, Programmatic Button Creation, Button Label Normalization, Explicit Button Technicalities
|
|
|
4040 @subsection Operational and Storage Formats
|
|
|
4041
|
|
|
4042 @cindex explicit button, formats
|
|
|
4043 @cindex explicit button, storage
|
|
|
4044 @cindex storage manager
|
|
|
4045 @cindex button attributes
|
|
|
4046 @vindex hbut:current
|
|
|
4047 Hyperbole uses a terse format to store explicit buttons and a more
|
|
|
4048 meaningful one to show users and to manipulate during editing. The
|
|
|
4049 terse format consists solely of button attribute values whereas the edit
|
|
|
4050 format includes an attribute name with each attribute value. A button
|
|
|
4051 in edit format consists of a Lisp symbol together with its attribute list
|
|
|
4052 which holds the attribute names and values. In this way, buttons may be
|
|
|
4053 passed along from function to function simply by passing the symbol to
|
|
|
4054 which the button is attached. Most functions utilize the pre-defined
|
|
|
4055 @var{hbut:current} symbol by default to store and retrieve the last
|
|
|
4056 encountered button in edit format.
|
|
|
4057
|
|
|
4058 @vindex class, hbdata
|
|
|
4059 @vindex class, ebut
|
|
|
4060 @vindex class, hbut
|
|
|
4061 The @code{hbdata} class handles the terse, stored format. The
|
|
|
4062 @code{hbut}, @code{ebut}, and @code{ibut} classes work with the
|
|
|
4063 name/value format. This separation permits the wholesale replacement of
|
|
|
4064 the storage manager with another, with any interface changes hidden from
|
|
|
4065 any Hyperbole client programming.
|
|
|
4066
|
|
|
4067 @node Programmatic Button Creation, , Operational and Storage Formats, Explicit Button Technicalities
|
|
|
4068 @subsection Programmatic Button Creation
|
|
|
4069
|
|
|
4070 @cindex explicit button, creation
|
|
|
4071 A common need when developing with Hyperbole is the ability to create or
|
|
|
4072 modify explicit buttons without user interaction. For example, an
|
|
|
4073 application might require the addition of an explicit summary button to
|
|
|
4074 a file for each new mail message a user reads that contains a set of
|
|
|
4075 keywords. The user could then check the summary file and jump to
|
|
|
4076 desired messages quickly.
|
|
|
4077
|
|
|
4078 @vindex class, ebut
|
|
|
4079 @vindex file, hbut.el
|
|
|
4080 @findex ebut:create
|
|
|
4081 @findex ebut:map
|
|
|
4082 The Hyperbole class @code{ebut} supports programmatic access to explicit
|
|
|
4083 buttons. See it within the @file{hbut.el} file for full details. The
|
|
|
4084 documentation for @code{(ebut:create)} explains the set of attributes
|
|
|
4085 settings necessary to create an explicit button. For operations over
|
|
|
4086 the whole set of buttons within the visible (non-narrowed) portion of a
|
|
|
4087 buffer, use the @code{(ebut:map)} function.
|
|
|
4088
|
|
|
4089 @page
|
|
|
4090 @node Encapsulating Systems, Embedding Hyperbole, Explicit Button Technicalities, Developing with Hyperbole
|
|
|
4091 @section Encapsulating Systems
|
|
|
4092
|
|
|
4093 @vindex file, hsys-*
|
|
|
4094 @cindex Hyperbole, system encapsulation
|
|
|
4095 @cindex system encapsulation
|
|
|
4096 A powerful use of implicit button types is to provide a Hyperbole-based
|
|
|
4097 interface to external systems. The basic idea is to interpret patterns
|
|
|
4098 output by the application as implicit buttons.
|
|
|
4099
|
|
|
4100 See the @file{hsys-*} files for examples of how to do this.
|
|
|
4101 Encapsulations are provided for the following systems (the systems
|
|
|
4102 themselves are not included with Hyperbole):
|
|
|
4103
|
|
|
4104 @table @bullet
|
|
|
4105 @item World-Wide Web
|
|
|
4106 The world-wide web system originally developed at CERN, that now spans
|
|
|
4107 the Internet universe. This is automatically loaded by Hyperbole so
|
|
|
4108 that a press of the Action Key follows a URL.
|
|
|
4109
|
|
|
4110 @item WAIS
|
|
|
4111 The Wide Area Information Systems full text-retrieval system orginally
|
|
|
4112 developed at Thinking Machines and then later at WAIS Inc.
|
|
|
4113
|
|
|
4114 @item HyperBase
|
|
|
4115 A hypertextual storage manager that stores textual nodes as records with
|
|
|
4116 locking so that multiple users can read and edit hypertexts.
|
|
|
4117 @end table
|
|
|
4118
|
|
|
4119
|
|
|
4120 @node Embedding Hyperbole, , Encapsulating Systems, Developing with Hyperbole
|
|
|
4121 @section Embedding Hyperbole
|
|
|
4122
|
|
|
4123 [NOTE: We have never done this ourselves, though we have done similar
|
|
|
4124 things which leads us to infer that the task should not be difficult.]
|
|
|
4125
|
|
|
4126 @cindex Hyperbole API
|
|
|
4127 @cindex API
|
|
|
4128 @cindex programming interface
|
|
|
4129 @cindex Hyperbole, embedding
|
|
|
4130 The standard Emacs-based Hyperbole user interface has purposely been
|
|
|
4131 separated from the Hyperbole backend to support the development of
|
|
|
4132 alternative interfaces and the embedding of Hyperbole functionality
|
|
|
4133 within other system prototypes. The Hyperbole backend functionality
|
|
|
4134 that system developers can make use of is called its Application
|
|
|
4135 Programming Interface (API). The API may be used to make server-based
|
|
|
4136 calls to Hyperbole when Emacs is run as a non-interactive (batch)
|
|
|
4137 process, with its input/output streams attached to another process.
|
|
|
4138
|
|
|
4139 The public functions and variables from the following files may be
|
|
|
4140 considered the present Hyperbole API:
|
|
|
4141
|
|
|
4142 @noindent
|
|
|
4143 @file{hact.el}, @file{hargs.el}, @file{hbmap.el}, @file{hbut.el},
|
|
|
4144 @file{hhist.el}, @file{hmail.el}, @file{hmoccur.el}, @file{hpath.el},
|
|
|
4145 @file{htz.el}, @file{hypb.el}, @file{set.el}, @file{wconfig.el},
|
|
|
4146 @file{wrolo.el}, and @file{wrolo-logic.el}.@refill
|
|
|
4147
|
|
|
4148 @noindent
|
|
|
4149 Note when looking at these files, that they are divided into sections
|
|
|
4150 that separate one data abstraction (class) from another. A line of
|
|
|
4151 dashes within a class separates public parts of the class from the
|
|
|
4152 private parts that follow the line.
|
|
|
4153
|
|
|
4154 This API does not include the Hyperbole outliner, as it has been
|
|
|
4155 designed for interactive use, rather than programmatic extensibility.
|
|
|
4156 You can certainly study its code, below the @file{hyperbole/kotl/}
|
|
|
4157 directory and learn to program it, however.
|
|
|
4158
|
|
|
4159
|
|
|
4160 @node Glossary, Smart Key Reference, Developing with Hyperbole, Top
|
|
|
4161 @appendix Glossary
|
|
|
4162
|
|
|
4163 Concepts pertinent to operational usage of Hyperbole are defined here.
|
|
|
4164 If some GNU Emacs terms are unfamiliar to you, @ref{Glossary, Emacs
|
|
|
4165 Glossary,, emacs, the GNU Emacs Manual}.
|
|
|
4166
|
|
|
4167 @table @code
|
|
|
4168
|
|
|
4169 @cindex action
|
|
|
4170 @item action
|
|
|
4171 An executable behavior associated with a Hyperbole button. A specific
|
|
|
4172 class of actions which display entities are called @emph{links},
|
|
|
4173 such as a link to a file.
|
|
|
4174
|
|
|
4175 @cindex Action Key
|
|
|
4176 @item Action Key
|
|
|
4177 See @emph{Smart Key}.
|
|
|
4178
|
|
|
4179 @cindex action type
|
|
|
4180 @item action type
|
|
|
4181 A behavioral specification for use within Hyperbole buttons. Action
|
|
|
4182 types usually contain a set of parameters which must be given values for
|
|
|
4183 each button with which they are associated. An action type together
|
|
|
4184 with a set of values, called arguments, may be considered an @emph{action}.
|
|
|
4185 @emph{Actype} is a synonym for action type.
|
|
|
4186
|
|
|
4187 @cindex activation
|
|
|
4188 @item activation
|
|
|
4189 Request for a Hyperbole button to perform its action.
|
|
|
4190 Ordinarily the user presses a key which selects and activates a button.
|
|
|
4191
|
|
|
4192 @cindex ange-ftp
|
|
|
4193 @cindex ftp
|
|
|
4194 @item ange-ftp
|
|
|
4195 A standard GNU Emacs Lisp package which allows one to use pathnames
|
|
|
4196 that are accessible via the Internet File Transfer Protocol (ftp) just
|
|
|
4197 like other pathnames, for example when finding a file. The
|
|
|
4198 latest version of ange-ftp may always be obtained via anonymous ftp to:
|
|
|
4199 @file{/ftp.gnu.ai.mit.edu:ange-ftp/ange-ftp.tar.gz}.
|
|
|
4200
|
|
|
4201 @cindex argument
|
|
|
4202 @item argument
|
|
|
4203 A button-specific value fed to a Hyperbole type specification when the
|
|
|
4204 button is activated.
|
|
|
4205
|
|
|
4206 @cindex Assist Key
|
|
|
4207 @item Assist Key
|
|
|
4208 See @emph{Smart Key}.
|
|
|
4209
|
|
|
4210 @cindex attributes
|
|
|
4211 @item attributes
|
|
|
4212 Slot names associated with Hyperbole buttons. An @emph{attribute value}
|
|
|
4213 is associated with each button attribute.
|
|
|
4214
|
|
|
4215 @cindex Augment
|
|
|
4216 @cindex NLS
|
|
|
4217 @cindex hypertext
|
|
|
4218 @cindex interactive computing
|
|
|
4219 @cindex mouse
|
|
|
4220 @cindex windows
|
|
|
4221 @cindex hypertext
|
|
|
4222 @cindex outline processor
|
|
|
4223 @cindex groupware
|
|
|
4224 @cindex digital signature
|
|
|
4225 @cindex Engelbart
|
|
|
4226 @item Augment
|
|
|
4227 The Augment system, originally named NLS, was a pioneering research and
|
|
|
4228 production system aimed at augmenting human intellect and group
|
|
|
4229 knowledge processing capabilities through integrated tools and
|
|
|
4230 organizational development strategies. This approach led to the
|
|
|
4231 invention of much of interactive computing technology decades ahead of
|
|
|
4232 other efforts, including: the mouse, screen windows, true hypertext,
|
|
|
4233 outline processors, groupware, and digitally signed documents.
|
|
|
4234 @xref{References}, which cites several Douglas Engelbart papers on the
|
|
|
4235 subject. The Koutliner concept emerged from studies of publicly
|
|
|
4236 available information concerning Augment.
|
|
|
4237
|
|
|
4238 @cindex button
|
|
|
4239 @item button
|
|
|
4240 A selectable Hyperbole construct which performs an action. A button
|
|
|
4241 consists of a set of attributes that includes: a textual label, a
|
|
|
4242 category, a type and zero or more arguments. @emph{Explicit buttons}
|
|
|
4243 also have creator, create time, last modifier, and last modifier time
|
|
|
4244 attributes.
|
|
|
4245
|
|
|
4246 Buttons provide the user's gateway to information. The user sees and
|
|
|
4247 interacts with button labels, the rest of the button data is managed
|
|
|
4248 invisibly by Hyperbole and displayed only in response to user queries.
|
|
|
4249
|
|
|
4250 @cindex button activation
|
|
|
4251 @item button activation
|
|
|
4252 See @emph{activation}.
|
|
|
4253
|
|
|
4254 @cindex button attributes
|
|
|
4255 @item button attributes
|
|
|
4256 See @emph{attributes}.
|
|
|
4257
|
|
|
4258 @cindex button data
|
|
|
4259 @item button data
|
|
|
4260 Lists of button attribute values explicitly saved and managed by Hyperbole.
|
|
|
4261 One list for each button created by Hyperbole.
|
|
|
4262
|
|
|
4263 @cindex button file, local
|
|
|
4264 @item button file, local
|
|
|
4265 A per-directory file named @file{HYPB} that may be used to store any
|
|
|
4266 desired buttons and may then be displayed via a menu selection whenever
|
|
|
4267 a user is within that directory.
|
|
|
4268
|
|
|
4269 @cindex button file, personal
|
|
|
4270 @item button file, personal
|
|
|
4271 A per-user file named @file{HYPB} that may be used to store any desired
|
|
|
4272 buttons and may then be displayed via a menu selection.
|
|
|
4273
|
|
|
4274 @cindex button key
|
|
|
4275 @item button key
|
|
|
4276 A normalized form of a @emph{button label} used internally by Hyperbole.
|
|
|
4277
|
|
|
4278 @cindex button label
|
|
|
4279 @item button label
|
|
|
4280 A text string that visually indicates a Hyperbole button location and
|
|
|
4281 provides it with a name and unique identifier. Within a buffer, buttons
|
|
|
4282 with the same label are considered separate views of the same button and
|
|
|
4283 so behave exactly alike. Since button labels are simply text strings,
|
|
|
4284 they may be embedded within any text to provide non-linear information
|
|
|
4285 or operational access points.
|
|
|
4286
|
|
|
4287 The maximum length of a button label is limited by the variable
|
|
|
4288 @var{ebut:max-len}.
|
|
|
4289
|
|
|
4290 @cindex button selection
|
|
|
4291 @item button selection
|
|
|
4292 The act of designating a Hyperbole button upon which to operate.
|
|
|
4293 Use the Action Key to select a button.
|
|
|
4294
|
|
|
4295 @cindex category
|
|
|
4296 @item category
|
|
|
4297 A high-level, conceptual grouping of Hyperbole buttons into classes.
|
|
|
4298 @emph{Implicit} and @emph{explicit} groupings represent categories.
|
|
|
4299
|
|
|
4300 @cindex cell
|
|
|
4301 @item cell
|
|
|
4302 See @emph{kcell}.
|
|
|
4303
|
|
|
4304 @cindex children
|
|
|
4305 @item children
|
|
|
4306 The set of koutline cells which share a common parent cell and are one
|
|
|
4307 level deeper than the parent.
|
|
|
4308
|
|
|
4309 @cindex class
|
|
|
4310 @item class
|
|
|
4311 A group of functions and variables with the same prefix in their names,
|
|
|
4312 used to provide an interface to an internal or external Hyperbole
|
|
|
4313 abstraction.
|
|
|
4314
|
|
|
4315 @cindex context
|
|
|
4316 @item context
|
|
|
4317 A programmatic or positional state recognized by Hyperbole.
|
|
|
4318 We speak of Smart Key and implicit button contexts. Both are typically
|
|
|
4319 defined in terms of surrounding patterns within a buffer, but may be
|
|
|
4320 defined by arbitrary Emacs Lisp predicates. (Context may come to have a
|
|
|
4321 broader meaning within future versions of Hyperbole.)
|
|
|
4322
|
|
|
4323 @cindex environment
|
|
|
4324 @item environment
|
|
|
4325 See @emph{Hyperbole environment}.
|
|
|
4326
|
|
|
4327 @cindex efs
|
|
|
4328 @item efs
|
|
|
4329 The much larger successor to ange-ftp. It does the same thing as
|
|
|
4330 ange-ftp but works with more types of ftp hosts. See @emph{ange-ftp}.
|
|
|
4331
|
|
|
4332 @cindex explicit button
|
|
|
4333 @item explicit button
|
|
|
4334 A button created and managed by Hyperbole. By default, explicit buttons
|
|
|
4335 are delimited like this @code{<(fake button)>}. Direct selection is
|
|
|
4336 used to operate upon an explicit button.
|
|
|
4337
|
|
|
4338 @cindex global button
|
|
|
4339 @item global button
|
|
|
4340 @vindex gbut:file
|
|
|
4341 A form of explicit button which is typically accessed by name rather
|
|
|
4342 than direct selection. Global buttons are useful when one wants
|
|
|
4343 quick access to actions such as jumping to common file locations or for
|
|
|
4344 performing sequences of operations. One need not locate them since they
|
|
|
4345 are always available by name, with full completion offered. All global
|
|
|
4346 buttons are stored in the file given by the variable @var{gbut:file} and
|
|
|
4347 may be activated as regular explicit buttons by visiting this file. By
|
|
|
4348 default, this is the same as the user's personal button file.
|
|
|
4349
|
|
|
4350 @cindex global button file
|
|
|
4351 @item global button file
|
|
|
4352 See @emph{button file, personal}.
|
|
|
4353
|
|
|
4354 @findex run-hooks
|
|
|
4355 @cindex hook variable
|
|
|
4356 @item hook variable
|
|
|
4357 A variable that permits customization of an existing function's
|
|
|
4358 operation without the need to edit the function's code. See also the
|
|
|
4359 documentation for the function @code{(run-hooks)}.
|
|
|
4360
|
|
|
4361 @cindex Hyperbole
|
|
|
4362 @item Hyperbole
|
|
|
4363 A flexible, programmable information management and viewing system built
|
|
|
4364 on top of GNU Emacs. It utilizes a button-action model and supports
|
|
|
4365 hypertextual linkages. Hyperbole is all things to all people.
|
|
|
4366
|
|
|
4367 @cindex Hyperbole environment
|
|
|
4368 @item Hyperbole environment
|
|
|
4369 A programmatic context within which Hyperbole operates. This includes
|
|
|
4370 the set of Hyperbole types defined and the set of Hyperbole code modules
|
|
|
4371 loaded. It does not include the set of accessible buttons.
|
|
|
4372 Although the entire Emacs environment is available to Hyperbole, we do
|
|
|
4373 not speak of this as part of the Hyperbole environment.
|
|
|
4374
|
|
|
4375 @cindex hypertext
|
|
|
4376 @item hypertext
|
|
|
4377 A text or group of texts which may be explored in a non-linear fashion
|
|
|
4378 through associative linkages embedded throughout the text. Instead of
|
|
|
4379 simply referring to other pieces of work, hypertext references when
|
|
|
4380 followed actually take you to the works themselves.
|
|
|
4381
|
|
|
4382 @cindex implicit button
|
|
|
4383 @item implicit button
|
|
|
4384 A button recognized contextually by Hyperbole. Such buttons contain no
|
|
|
4385 button data. See also @emph{implicit button type}.
|
|
|
4386
|
|
|
4387 @cindex implicit button type
|
|
|
4388 @item implicit button type
|
|
|
4389 A specification of how to recognize and activate implicit buttons of a
|
|
|
4390 specific kind. Implicit button types often utilize structure internal
|
|
|
4391 to documents created and managed without Hyperbole assistance, for
|
|
|
4392 example, programming documentation. @emph{Ibtype} is a synonym for
|
|
|
4393 implicit button type. See also @emph{system encapsulation}.
|
|
|
4394
|
|
|
4395 @cindex instance number
|
|
|
4396 @item instance number
|
|
|
4397 A colon prefaced number appended to the label of a newly created button
|
|
|
4398 when the button's label duplicates the label of an existing button in
|
|
|
4399 the current buffer. This number makes the label unique and so allows
|
|
|
4400 any number of buttons with the same base label within a single buffer.
|
|
|
4401
|
|
|
4402 @cindex koutline
|
|
|
4403 @item koutline
|
|
|
4404 A hierarchically ordered grouping of cells which may be stored as a file
|
|
|
4405 and viewed and edited as an outline.
|
|
|
4406
|
|
|
4407 @cindex Koutliner
|
|
|
4408 @item Koutliner
|
|
|
4409 Koutliner, the Hyperbole outliner, is a powerful autonumbering outliner
|
|
|
4410 with permanent hypertext anchors for easy hyperlinking and view
|
|
|
4411 specs for rapid outline view alteration.
|
|
|
4412
|
|
|
4413 @cindex kcell
|
|
|
4414 @item kcell
|
|
|
4415 Cells or kcells are elements within koutlines. Each cell contains
|
|
|
4416 textual and graphical contents, a relative identifier, a permanent
|
|
|
4417 identifier and a set of attributes such as the user who created the cell
|
|
|
4418 and the time of creation. See also @emph{Koutliner}.
|
|
|
4419
|
|
|
4420 @cindex link
|
|
|
4421 @item link
|
|
|
4422 A reference from a Hyperbole button to an entity. The referenced entity
|
|
|
4423 is sometimes called a @emph{node} or @emph{referent}.
|
|
|
4424 A specific class of actions which display entities are called
|
|
|
4425 @emph{links}, such as a link to a file.
|
|
|
4426
|
|
|
4427 @cindex local button file
|
|
|
4428 @item local button file
|
|
|
4429 See @emph{button file, local}.
|
|
|
4430
|
|
|
4431 @cindex minibuffer window
|
|
|
4432 @item minibuffer window
|
|
|
4433 The one line window at the bottom of a frame where messages and prompts
|
|
|
4434 are displayed.
|
|
|
4435
|
|
|
4436 @cindex minibuffer menu
|
|
|
4437 @item minibuffer menu
|
|
|
4438 A Hyperbole menu displayed in the minibuffer window. Each menu item
|
|
|
4439 within a minibuffer menu begins with a different letter that can be used
|
|
|
4440 to invoke the item (case doesn't matter). Items that display other
|
|
|
4441 menus end with a forward slash, /.
|
|
|
4442
|
|
|
4443 @cindex mouse button
|
|
|
4444 @item mouse button
|
|
|
4445 @item mouse key
|
|
|
4446 See @emph{Smart Key}.
|
|
|
4447
|
|
|
4448 @cindex node
|
|
|
4449 @item node
|
|
|
4450 See @emph{link} or @emph{cell}.
|
|
|
4451
|
|
|
4452 @cindex outline
|
|
|
4453 @item outline
|
|
|
4454 See @emph{koutline}.
|
|
|
4455
|
|
|
4456 @cindex parent
|
|
|
4457 @item parent
|
|
|
4458 Any koutline cell which has children.
|
|
|
4459
|
|
|
4460 @cindex predecessor
|
|
|
4461 @item predecessor
|
|
|
4462 The previous same level koutline cell with the same parent.
|
|
|
4463
|
|
|
4464 @cindex predicate
|
|
|
4465 @item predicate
|
|
|
4466 A boolean (nil = false, non-nil = true) Lisp expression typically
|
|
|
4467 evaluated as part of a conditional expression.
|
|
|
4468
|
|
|
4469 @cindex referent
|
|
|
4470 @item referent
|
|
|
4471 See @emph{link}.
|
|
|
4472
|
|
|
4473 @cindex rolodex
|
|
|
4474 @item rolodex
|
|
|
4475 Wrolo, the Hyperbole rolodex, provides rapid lookup of multi-line,
|
|
|
4476 hierarchically ordered free form text records.
|
|
|
4477
|
|
|
4478 @cindex root cell
|
|
|
4479 @item root cell
|
|
|
4480 A koutline cell which has cells below it. All such cells share the same
|
|
|
4481 root cell.
|
|
|
4482
|
|
|
4483 @cindex Smart Key
|
|
|
4484 @vindex smart-scroll-proportional
|
|
|
4485 @cindex proportional scrolling
|
|
|
4486 @cindex scrolling
|
|
|
4487 @item Smart Key
|
|
|
4488 A context-sensitive key used within Hyperbole and beyond. Actually,
|
|
|
4489 there are two Smart Keys, the Action Key and the Assist Key. The
|
|
|
4490 Action Key, typically bound to the shift-middle mouse key (or shift-left
|
|
|
4491 mouse key on a 2-button mouse), activates Hyperbole buttons and scrolls
|
|
|
4492 the current buffer line to the top of the window when pressed at the end
|
|
|
4493 of a line. The Assist Key, typically bound to the shift-right mouse
|
|
|
4494 key, explains what a Hyperbole button does or scrolls the current line
|
|
|
4495 to the bottom of the window when pressed at the end of a line. (See the
|
|
|
4496 documentation for the variable, @var{smart-scroll-proportional}, for
|
|
|
4497 information on how to make these keys scroll forward and backward a
|
|
|
4498 windowful at a time).
|
|
|
4499
|
|
|
4500 To see what a Smart Key will do within a particular context, depress and
|
|
|
4501 hold the key at the point desired and depress the other Smart Key. A
|
|
|
4502 buffer containing a description of its contextual function will then be
|
|
|
4503 displayed. You may release the two keys in any order after you have
|
|
|
4504 them both depressed. A press of the Assist Key in an unsupported
|
|
|
4505 context displays a summary of Smart Key functions in each context, as
|
|
|
4506 does the Doc/SmartKy menu item.
|
|
|
4507
|
|
|
4508 @cindex source buffer
|
|
|
4509 @cindex source file
|
|
|
4510 @item source buffer / file
|
|
|
4511 The buffer or file within which a Hyperbole button is embedded.
|
|
|
4512
|
|
|
4513 @cindex subtree
|
|
|
4514 @item subtree
|
|
|
4515 All of the cells in a koutline which share the same root cell, excluding
|
|
|
4516 the root cell.
|
|
|
4517
|
|
|
4518 @cindex successor
|
|
|
4519 @item successor
|
|
|
4520 The next same level koutline cell with the same parent.
|
|
|
4521
|
|
|
4522 @cindex system encapsulation
|
|
|
4523 @item system encapsulation
|
|
|
4524 Use of Hyperbole to provide an improved or simply consistent user
|
|
|
4525 interface to another system. Typically, implicit button types are
|
|
|
4526 defined to recognize and activate button-type constructs managed by the
|
|
|
4527 other system.
|
|
|
4528
|
|
|
4529 @cindex tree
|
|
|
4530 @item tree
|
|
|
4531 The set of cells in a koutline that share a common root cell, including
|
|
|
4532 the root cell.
|
|
|
4533
|
|
|
4534 @cindex view
|
|
|
4535 @item view
|
|
|
4536 A perspective on some information. A view can affect the extent of the
|
|
|
4537 information displayed, its format, modes used to operate on it, its
|
|
|
4538 display location and so forth.
|
|
|
4539
|
|
|
4540 @cindex view spec
|
|
|
4541 @item view spec
|
|
|
4542 A terse (and to the uninitiated, cryptic) string that specifies a
|
|
|
4543 particular view of koutline or a link referent. If a view spec is in
|
|
|
4544 use in a buffer, the view spec appears in the modeline delimited by
|
|
|
4545 <|view spec>.
|
|
|
4546
|
|
|
4547 @end table
|
|
|
4548
|
|
|
4549 @node Smart Key Reference, Outliner Keys, Glossary, Top
|
|
|
4550 @appendix Smart Key Reference
|
|
|
4551
|
|
|
4552 This appendix supplies complete documentation on Smart Key operation. It is
|
|
|
4553 quite extensive and is meant for reference rather than sequential reading.
|
|
|
4554 @xref{Smart Keys}, for a description of the Smart Keys. That section also
|
|
|
4555 describes how to get context-sensitive Smart Key help, with which you can
|
|
|
4556 explore Smart Key operation bit by bit.
|
|
|
4557
|
|
|
4558 Smart Key operations are context-sensitive. Contexts are described herein as
|
|
|
4559 conditionals, e.g@. when depressed here, if this is true, etc. Each Smart
|
|
|
4560 Key context is listed in the order in which it will be checked. The first
|
|
|
4561 matching context is always the one applied. Within each context, the
|
|
|
4562 actions performed by the Action and Assist Keys are listed.
|
|
|
4563
|
|
|
4564 @menu
|
|
|
4565 * Smart Mouse Keys::
|
|
|
4566 * Smart Keyboard Keys::
|
|
|
4567 @end menu
|
|
|
4568
|
|
|
4569 @node Smart Mouse Keys, Smart Keyboard Keys, Smart Key Reference, Smart Key Reference
|
|
|
4570 @section Smart Mouse Keys
|
|
|
4571
|
|
|
4572 @cindex Smart Mouse Keys
|
|
|
4573 Smart Key drags and modeline presses can only be used when running under
|
|
|
4574 a window system with mouse key support. So keep in mind that the
|
|
|
4575 operations in this section apply only if you have mouse support within
|
|
|
4576 Hyperbole. The Smart Key operations in, @ref{Smart Keyboard Keys},
|
|
|
4577 apply to both mouse and keyboard Smart Key usage.
|
|
|
4578
|
|
|
4579 @format
|
|
|
4580 @group
|
|
|
4581 @cindex drag, side edge
|
|
|
4582 @cindex side drag
|
|
|
4583 If dragged from a side-by-side window edge or from the immediate left of
|
|
|
4584 a vertical scroll bar:
|
|
|
4585 ACTION or ASSIST
|
|
|
4586 Resizes adjacent window sides to the point of drag release.
|
|
|
4587 @end group
|
|
|
4588 @end format
|
|
|
4589
|
|
|
4590 @format
|
|
|
4591 @group
|
|
|
4592 @cindex drag, between windows
|
|
|
4593 If dragged from inside one window to another:
|
|
|
4594 ACTION
|
|
|
4595 Creates a new link button at the drag start location, linked to the
|
|
|
4596 drag end location. If drag start position is within a button,
|
|
|
4597 modifies the button to link to drag end location.
|
|
|
4598 ASSIST
|
|
|
4599 Swaps buffers in the two windows.
|
|
|
4600 @end group
|
|
|
4601 @end format
|
|
|
4602
|
|
|
4603 @page
|
|
|
4604 @format
|
|
|
4605 @group
|
|
|
4606 @cindex drag, horizontal
|
|
|
4607 @cindex horizontal drag
|
|
|
4608 If dragged horizontally within a single window while depressed
|
|
|
4609 (hmouse-x-drag-sensitivity sets the minimal horizontal movement which
|
|
|
4610 registers a drag):
|
|
|
4611 ACTION
|
|
|
4612 Goes to buffer end if drag was to the right, otherwise goes to beginning.
|
|
|
4613 ASSIST
|
|
|
4614 Splits window vertically if drag was to the right, otherwise deletes
|
|
|
4615 window.
|
|
|
4616 @end group
|
|
|
4617 @end format
|
|
|
4618
|
|
|
4619 @format
|
|
|
4620 @group
|
|
|
4621 @cindex depress, modeline
|
|
|
4622 @cindex modeline depress
|
|
|
4623 If depressed within a window mode line:
|
|
|
4624 ACTION
|
|
|
4625 (1) clicked on left edge of a window's modeline,
|
|
|
4626 window's buffer is buried (placed at bottom of buffer list);
|
|
|
4627 (2) clicked on right edge of a window's modeline,
|
|
|
4628 the Info buffer is displayed, or if already displayed and the
|
|
|
4629 modeline clicked belongs to a window displaying Info, the Info
|
|
|
4630 buffer is hidden;
|
|
|
4631 (3) clicked anywhere in the middle of a window's modeline,
|
|
|
4632 the functions listed in 'assist-key-modeline-hook' are
|
|
|
4633 called;
|
|
|
4634 (4) dragged vertically from modeline to within a window,
|
|
|
4635 the modeline is moved to point of key release, thereby resizing
|
|
|
4636 its window and potentially its vertical neighbors.
|
|
|
4637 ASSIST
|
|
|
4638 (1) clicked on left edge of a window's modeline,
|
|
|
4639 bottom buffer in buffer list is unburied and placed in window;
|
|
|
4640 (2) clicked on right edge of a window's modeline,
|
|
|
4641 the summary of Smart Key behavior is displayed, or if already
|
|
|
4642 displayed and the modeline clicked belongs to a window displaying
|
|
|
4643 the summary, the summary buffer is hidden;
|
|
|
4644 (3) clicked anywhere in the middle of a window's modeline,
|
|
|
4645 a popup menu (if available) is displayed;
|
|
|
4646 (4) dragged vertically from modeline to within a window,
|
|
|
4647 the modeline is moved to point of key release, thereby resizing
|
|
|
4648 its window and potentially its vertical neighbors.
|
|
|
4649 @end group
|
|
|
4650 @end format
|
|
|
4651
|
|
|
4652 @page
|
|
|
4653 @format
|
|
|
4654 @group
|
|
|
4655 @cindex drag, vertical
|
|
|
4656 @cindex vertical drag
|
|
|
4657 If dragged vertically within a single window while depressed
|
|
|
4658 (hmouse-y-drag-sensitivity sets the minimal vertical movement which
|
|
|
4659 registers a drag):
|
|
|
4660 ACTION or ASSIST
|
|
|
4661 Splits current window into two side-by-side windows.
|
|
|
4662 @end group
|
|
|
4663 @end format
|
|
|
4664
|
|
|
4665 @format
|
|
|
4666 @group
|
|
|
4667 @cindex drag, diagonal
|
|
|
4668 @cindex diagonal drag
|
|
|
4669 If dragged diagonally within a single window while depressed
|
|
|
4670 (hmouse-x-diagonal-sensitivity and hmouse-y-diagonal-sensitivity set the
|
|
|
4671 minimal diagonal movement which registers a drag):
|
|
|
4672 ACTION
|
|
|
4673 Save current window configuration onto a ring of window configurations.
|
|
|
4674 ASSIST
|
|
|
4675 Restores prior window configuration from ring. A prefix argument N
|
|
|
4676 specifies the Nth prior configuration from the ring.
|
|
|
4677 @end group
|
|
|
4678 @end format
|
|
|
4679
|
|
|
4680 @page
|
|
|
4681
|
|
|
4682 @node Smart Keyboard Keys, , Smart Mouse Keys, Smart Key Reference
|
|
|
4683 @section Smart Keyboard Keys
|
|
|
4684
|
|
|
4685 @cindex Smart Keyboard Keys
|
|
|
4686 @format
|
|
|
4687 @group
|
|
|
4688 When prompting for a Hyperbole argument, a press in the minibuffer:
|
|
|
4689 ACTION
|
|
|
4690 Terminates this minibuffer argument.
|
|
|
4691 ASSIST
|
|
|
4692 Offers completion help for current minibuffer argument.
|
|
|
4693 @end group
|
|
|
4694 @end format
|
|
|
4695
|
|
|
4696 @format
|
|
|
4697 @group
|
|
|
4698 When reading a Hyperbole menu item or a Hyperbole completion-based argument:
|
|
|
4699 ACTION
|
|
|
4700 Returns value selected at point if any, else nil. If
|
|
|
4701 value is the same as the contents of the minibuffer, it is used as the
|
|
|
4702 current minibuffer argument, otherwise, the minibuffer is erased and
|
|
|
4703 value is inserted there.
|
|
|
4704
|
|
|
4705 ASSIST
|
|
|
4706 Displays Hyperbole menu item help when item is selected.
|
|
|
4707 @end group
|
|
|
4708 @end format
|
|
|
4709
|
|
|
4710 @vindex smart-scroll-proportional
|
|
|
4711 @cindex proportional scrolling
|
|
|
4712 @cindex scrolling
|
|
|
4713 @format
|
|
|
4714 @group
|
|
|
4715 @cindex click, end of line
|
|
|
4716 @cindex end of line click
|
|
|
4717 When pressed at the end of a line but not the end of a buffer:
|
|
|
4718 ACTION
|
|
|
4719 Scrolls up according to value of smart-scroll-proportional. If
|
|
|
4720 smart-scroll-proportional is nil or if point is on the top
|
|
|
4721 window line, scrolls up (forward) a windowful. Otherwise, tries to
|
|
|
4722 bring current line to top of window. Leaves point at end of line and
|
|
|
4723 returns t if scrolled, nil if not.
|
|
|
4724 ASSIST
|
|
|
4725 Scrolls down according to value of smart-scroll-proportional. If
|
|
|
4726 smart-scroll-proportional is nil or if point is on the
|
|
|
4727 bottom window line, scrolls down (backward) a windowful. Otherwise,
|
|
|
4728 tries to bring current line to bottom of window. Leaves point at end of
|
|
|
4729 line and returns t if scrolled, nil if not.
|
|
|
4730 @end group
|
|
|
4731 @end format
|
|
|
4732
|
|
|
4733 @format
|
|
|
4734 @group
|
|
|
4735 @cindex click, button
|
|
|
4736 @cindex button click
|
|
|
4737 When pressed on a Hyperbole button:
|
|
|
4738 ACTION
|
|
|
4739 Activates button.
|
|
|
4740 ASSIST
|
|
|
4741 Displays help for button, typically a summary of its attributes.
|
|
|
4742 @end group
|
|
|
4743 @end format
|
|
|
4744
|
|
|
4745 @format
|
|
|
4746 @group
|
|
|
4747 If pressed within a buffer in View major or minor mode:
|
|
|
4748 ACTION
|
|
|
4749 Scrolls buffer forward a windowful and quits from view mode when at
|
|
|
4750 the last line of the buffer.
|
|
|
4751 ASSIST
|
|
|
4752 Scrolls buffer backward a windowful.
|
|
|
4753 @end group
|
|
|
4754 @end format
|
|
|
4755
|
|
|
4756 @format
|
|
|
4757 @group
|
|
|
4758 When pressed within a Hyperbole outliner buffer (kotl-mode):
|
|
|
4759 ACTION
|
|
|
4760 (1) at the end of buffer, uncollapse and unhide all cells in view;
|
|
|
4761 (2) within a cell, if its subtree is hidden then show it,
|
|
|
4762 otherwise hide it;
|
|
|
4763 (3) between cells or within the read-only indentation region to the
|
|
|
4764 left of a cell, then move point to prior location and begin
|
|
|
4765 creation of a klink to some other outline cell; hit the Action
|
|
|
4766 Key twice to select the link referent cell;
|
|
|
4767 (4) anywhere else, scroll up a windowful.
|
|
|
4768 ASSIST
|
|
|
4769 (1) at the end of buffer, collapse all cells and hide all non-level-one
|
|
|
4770 cells;
|
|
|
4771 (2) on a header line but not at the beginning or end, display
|
|
|
4772 properties of each cell in kotl beginning at point;
|
|
|
4773 (3) between cells or within the read-only indentation region to the
|
|
|
4774 left of a cell, then move point to prior location and prompt to
|
|
|
4775 move one tree to a new location in the outline; hit the Action
|
|
|
4776 Key twice to select the tree to move and where to move it;
|
|
|
4777 (4) anywhere else, scroll down a windowful.
|
|
|
4778 @end group
|
|
|
4779 @end format
|
|
|
4780
|
|
|
4781 @format
|
|
|
4782 @group
|
|
|
4783 When pressed on a Smart Menu item:
|
|
|
4784 ACTION
|
|
|
4785 Activates item.
|
|
|
4786 ASSIST
|
|
|
4787 Displays help for item.
|
|
|
4788 @end group
|
|
|
4789 @end format
|
|
|
4790
|
|
|
4791 @page
|
|
|
4792 @format
|
|
|
4793 @group
|
|
|
4794 When pressed at the end of a Help buffer:
|
|
|
4795 ACTION or ASSIST
|
|
|
4796 Restores window configuration prior to help display.
|
|
|
4797 @end group
|
|
|
4798 @end format
|
|
|
4799
|
|
|
4800 @format
|
|
|
4801 @group
|
|
|
4802 When pressed within an OO-Browser listing window:
|
|
|
4803 ACTION
|
|
|
4804 (1) in a blank buffer or at the end of a buffer, browser help
|
|
|
4805 information is displayed in the viewer window;
|
|
|
4806 (2) at the beginning of a (non-single char) class name, the class'
|
|
|
4807 ancestors are listed;
|
|
|
4808 (3) at the end of an entry line, scrolls listing up;
|
|
|
4809 (4) on the '...', following a class name, point is moved to the class
|
|
|
4810 descendency expansion;
|
|
|
4811 (5) before an element name, the implementor classes of the name are
|
|
|
4812 listed;
|
|
|
4813 (6) anywhere else on an entry line, the source is displayed for editing.
|
|
|
4814 ASSIST
|
|
|
4815 (1) in a blank buffer, a selection list of buffer files is displayed;
|
|
|
4816 (2) at the beginning of a (non-single char) entry, the class'
|
|
|
4817 descendants are listed;
|
|
|
4818 (3) at the end of an entry line, scrolls listing down;
|
|
|
4819 (4) on the '...', following a class name, point is moved to the class
|
|
|
4820 expansion;
|
|
|
4821 (5) anywhere else on a class entry line, lists the class' elements;
|
|
|
4822 (6) anywhere else on an element line, lists the element's implementor
|
|
|
4823 classes;
|
|
|
4824 (7) on a blank line following all entries, the current listing buffer
|
|
|
4825 is exited.
|
|
|
4826 @end group
|
|
|
4827 @end format
|
|
|
4828
|
|
|
4829 @format
|
|
|
4830 @group
|
|
|
4831 When pressed within an OO-Browser Command Help Menu buffer:
|
|
|
4832 ACTION
|
|
|
4833 Executes an OO-Browser command whose key binding is at point.
|
|
|
4834 ASSIST
|
|
|
4835 Displays help for an OO-Browser command whose key binding is at point.
|
|
|
4836 @end group
|
|
|
4837 @end format
|
|
|
4838
|
|
|
4839 @format
|
|
|
4840 @group
|
|
|
4841 When pressed on an identifier within an OO-Browser source file:
|
|
|
4842 ACTION
|
|
|
4843 Tries to display identifier definition.
|
|
|
4844 ASSIST
|
|
|
4845 Not applicable.
|
|
|
4846 @end group
|
|
|
4847 @end format
|
|
|
4848
|
|
|
4849 @page
|
|
|
4850 @format
|
|
|
4851 @group
|
|
|
4852 When pressed within a C source code file:
|
|
|
4853 ACTION
|
|
|
4854 Jumps to the definition of selected C construct:
|
|
|
4855 (1) on a '#include' statement, the include file is displayed;
|
|
|
4856 Look for include file in directory lists
|
|
|
4857 'smart-c-cpp-include-dirs' and 'smart-c-include-dirs'.
|
|
|
4858 (2) on a C identifier, the identifier definition is displayed,
|
|
|
4859 assuming the identifier is found within an 'etags' generated tag file
|
|
|
4860 in the current directory or any of its ancestor directories.
|
|
|
4861 (3) if 'smart-c-use-lib-man' is non-nil, the C identifier is
|
|
|
4862 recognized as a library symbol, and a man page is found for the
|
|
|
4863 identifier, then the man page is displayed.
|
|
|
4864 ASSIST
|
|
|
4865 Jumps to the next tag matching an identifier at point.
|
|
|
4866 @end group
|
|
|
4867 @end format
|
|
|
4868
|
|
|
4869 @format
|
|
|
4870 @group
|
|
|
4871 When pressed within an assembly source code file:
|
|
|
4872 ACTION
|
|
|
4873 Jumps to the definition of selected assembly construct:
|
|
|
4874 (1) on an include statement, the include file is displayed;
|
|
|
4875 Look for include file in directory list
|
|
|
4876 'smart-asm-include-dirs'.
|
|
|
4877 (2) on an identifier, the identifier definition is displayed,
|
|
|
4878 assuming the identifier is found within an 'etags' generated
|
|
|
4879 tag file in the current directory or any of its ancestor
|
|
|
4880 directories.
|
|
|
4881 ASSIST
|
|
|
4882 Jumps to the next tag matching an identifier at point.
|
|
|
4883 @end group
|
|
|
4884 @end format
|
|
|
4885
|
|
|
4886 @page
|
|
|
4887 @format
|
|
|
4888 @group
|
|
|
4889 When pressed within a C++ source code file:
|
|
|
4890 ACTION
|
|
|
4891 Jumps to the definition of selected C+ construct:
|
|
|
4892 (1) on a '#include' statement, the include file is displayed;
|
|
|
4893 Look for include file in directory lists
|
|
|
4894 'smart-c-cpp-include-dirs' and 'smart-c-include-dirs'.
|
|
|
4895 (2) on a C++ identifier, the identifier definition is displayed,
|
|
|
4896 assuming the identifier is found within an 'etags' generated tag file
|
|
|
4897 in the current directory or any of its ancestor directories.
|
|
|
4898 (3) if 'smart-c-use-lib-man' is non-nil, the C++ identifier is
|
|
|
4899 recognized as a library symbol, and a man page is found for the
|
|
|
4900 identifier, then the man page is displayed.
|
|
|
4901 ASSIST
|
|
|
4902 Jumps to the next tag matching an identifier at point.
|
|
|
4903 @end group
|
|
|
4904 @end format
|
|
|
4905
|
|
|
4906 @format
|
|
|
4907 @group
|
|
|
4908 When pressed within a Objective-C source code file:
|
|
|
4909 ACTION
|
|
|
4910 Jumps to the definition of selected C+ construct:
|
|
|
4911 (1) on a '#include' statement, the include file is displayed;
|
|
|
4912 Look for include file in directory lists
|
|
|
4913 'smart-c-cpp-include-dirs' and 'smart-c-include-dirs'.
|
|
|
4914 (2) on an Objective-C identifier, the identifier definition is displayed,
|
|
|
4915 assuming the identifier is found within an 'etags' generated tag file
|
|
|
4916 in the current directory or any of its ancestor directories.
|
|
|
4917 (3) if 'smart-c-use-lib-man' is non-nil, the Objective-C identifier is
|
|
|
4918 recognized as a library symbol, and a man page is found for the
|
|
|
4919 identifier, then the man page is displayed.
|
|
|
4920 ASSIST
|
|
|
4921 Jumps to the next tag matching an identifier at point.
|
|
|
4922 @end group
|
|
|
4923 @end format
|
|
|
4924
|
|
|
4925 @page
|
|
|
4926 @format
|
|
|
4927 @group
|
|
|
4928 When pressed on a Lisp symbol within a Lisp code buffer:
|
|
|
4929 ACTION
|
|
|
4930 Jumps to the definition of any selected Lisp construct.
|
|
|
4931 If on an Emacs Lisp require, load, or autoload clause and 'find-library'
|
|
|
4932 from load-library package by Hallvard Furuseth <hallvard@@ifi.uio.no> has
|
|
|
4933 been loaded, jumps to library source, if possible.
|
|
|
4934 ASSIST
|
|
|
4935 Jumps to the next tag matching an identifier at point or if using the
|
|
|
4936 "wtags" package and identifier is an Emacs Lisp symbol, then displays
|
|
|
4937 documentation for the symbol.
|
|
|
4938 @end group
|
|
|
4939 @end format
|
|
|
4940
|
|
|
4941 @format
|
|
|
4942 @group
|
|
|
4943 When the OO-Browser has been loaded and the press is within a C++ buffer:
|
|
|
4944 ACTION or ASSIST
|
|
|
4945 Jumps to the definition of selected C++ construct via OO-Browser support.
|
|
|
4946 (1) on a '#include' statement, the include file is displayed;
|
|
|
4947 Look for include file in directory lists
|
|
|
4948 'smart-c-cpp-include-dirs' and 'smart-c-include-dirs'.
|
|
|
4949 (2) within a method declaration, its definition is displayed;
|
|
|
4950 (3) on a class name, the class definition is shown.
|
|
|
4951 @end group
|
|
|
4952 @end format
|
|
|
4953
|
|
|
4954 @format
|
|
|
4955 @group
|
|
|
4956 When the OO-Browser has been loaded and the press is within a
|
|
|
4957 Objective-C buffer:
|
|
|
4958 ACTION or ASSIST
|
|
|
4959 Jumps to the definition of selected Objective-C construct via
|
|
|
4960 OO-Browser support.
|
|
|
4961 (1) on a '#include' statement, the include file is displayed;
|
|
|
4962 Look for include file in directory lists
|
|
|
4963 'smart-c-cpp-include-dirs' and 'smart-c-include-dirs'.
|
|
|
4964 (2) within a method declaration, its definition is displayed;
|
|
|
4965 (3) on a class name, the class definition is shown.
|
|
|
4966 @end group
|
|
|
4967 @end format
|
|
|
4968
|
|
|
4969 @format
|
|
|
4970 @group
|
|
|
4971 When pressed within an occur-mode or moccur-mode buffer:
|
|
|
4972 ACTION or ASSIST
|
|
|
4973 Jumps to the source buffer and line of the current occurrence.
|
|
|
4974 @end group
|
|
|
4975 @end format
|
|
|
4976
|
|
|
4977 @page
|
|
|
4978 @format
|
|
|
4979 @group
|
|
|
4980 When pressed within a calendar-mode buffer:
|
|
|
4981 ACTION
|
|
|
4982 (1) at the end of the buffer, the calendar is scrolled forward 3 months;
|
|
|
4983 (2) to the left of any dates on a calendar line, the calendar is scrolled
|
|
|
4984 backward 3 months;
|
|
|
4985 (3) on a date, the diary entries for the date, if any, are displayed.
|
|
|
4986 ASSIST
|
|
|
4987 (1) at the end of the buffer, the calendar is scrolled backward 3 months;
|
|
|
4988 (2) to the left of any dates on a calendar line, the calendar is scrolled
|
|
|
4989 forward 3 months;
|
|
|
4990 (3) anywhere else, all dates with marking diary entries are marked in the
|
|
|
4991 calendar window.
|
|
|
4992 @end group
|
|
|
4993 @end format
|
|
|
4994
|
|
|
4995 @format
|
|
|
4996 @group
|
|
|
4997 When pressed within a man page apropos buffer:
|
|
|
4998 ACTION
|
|
|
4999 (1) on a UNIX man apropos entry, the man page for that entry is
|
|
|
5000 displayed in another window;
|
|
|
5001 (2) on or after the last line, the buffer in the other window is
|
|
|
5002 scrolled up a windowful.
|
|
|
5003 ASSIST
|
|
|
5004 (1) on a UNIX man apropos entry, the man page for that entry is
|
|
|
5005 displayed in another window;
|
|
|
5006 (2) on or after the last line, the buffer in the other window is
|
|
|
5007 scrolled down a windowful.
|
|
|
5008 @end group
|
|
|
5009 @end format
|
|
|
5010
|
|
|
5011 @format
|
|
|
5012 @group
|
|
|
5013 If Smart Menu package has been loaded and 'hkey-always-display-menu' is
|
|
|
5014 non-nil:
|
|
|
5015 ACTION or ASSIST
|
|
|
5016 Pops up a window with a Smart Menu of commands.
|
|
|
5017 Menu displayed is selected by (smart-menu-choose-menu).
|
|
|
5018 @end group
|
|
|
5019 @end format
|
|
|
5020
|
|
|
5021 @page
|
|
|
5022 @format
|
|
|
5023 @group
|
|
|
5024 If pressed within an outline-mode buffer or when 'selective-display' is
|
|
|
5025 non-nil:
|
|
|
5026 ACTION
|
|
|
5027 Collapses, expands, and moves outline entries.
|
|
|
5028 (1) after an outline heading has been cut via the Action Key, then paste
|
|
|
5029 the cut heading at point;
|
|
|
5030 (2) at the end of buffer, show all buffer text
|
|
|
5031 (3) at the beginning of a heading line, cut the headings subtree from the
|
|
|
5032 buffer;
|
|
|
5033 (4) on a header line but not at the beginning or end, if headings
|
|
|
5034 subtree is hidden then show it, otherwise hide it;
|
|
|
5035 (5) anywhere else, scroll up a windowful.
|
|
|
5036 ASSIST
|
|
|
5037 (1) after an outline heading has been cut via the Action Key, allow
|
|
|
5038 multiple pastes throughout the buffer (last paste should be done
|
|
|
5039 with the Action Key, not the Assist Key);
|
|
|
5040 (2) at the end of buffer, hide all bodies in buffer;
|
|
|
5041 (3) at the beginning of a heading line, cut the current heading (sans
|
|
|
5042 subtree) from the buffer;
|
|
|
5043 (4) on a header line but not at the beginning or end, if heading body is
|
|
|
5044 hidden then show it, otherwise hide it;
|
|
|
5045 (5) anywhere else, scroll down a windowful.
|
|
|
5046 @end group
|
|
|
5047 @end format
|
|
|
5048
|
|
|
5049 @format
|
|
|
5050 @group
|
|
|
5051 @cindex click, Info
|
|
|
5052 @cindex Info browsing
|
|
|
5053 If pressed within an Info manual node:
|
|
|
5054 ACTION
|
|
|
5055 (1) the first line of an Info Menu Entry or Cross Reference, the desired
|
|
|
5056 node is found;
|
|
|
5057 (2) the Up,Next,or Previous entries of a Node Header (first line),
|
|
|
5058 the desired node is found;
|
|
|
5059 (3) the File entry of a Node Header (first line),
|
|
|
5060 the 'Top' node within that file is found;
|
|
|
5061 (4) at the end of the current node, the Next node is found (this will
|
|
|
5062 descend subtrees if the function 'Info-global-next' is bound);
|
|
|
5063 (5) anywhere else (e.g@. at the end of a line), the current node entry is
|
|
|
5064 scrolled up a windowful.
|
|
|
5065 ASSIST
|
|
|
5066 (1) the first line of an Info Menu Entry or Cross Reference, the desired
|
|
|
5067 node is found;
|
|
|
5068 (2) the Up,Next,or Previous entries of a Node Header (first line),
|
|
|
5069 the last node in the history list is found;
|
|
|
5070 (3) the File entry of a Node Header (first line),
|
|
|
5071 the 'DIR' root-level node is found;
|
|
|
5072 (4) at the end of the current node, the Previous node is found (this will
|
|
|
5073 return from subtrees if the function 'Info-global-prev is bound);
|
|
|
5074 (5) anywhere else (e.g@. at the end of a line), the current node entry is
|
|
|
5075 scrolled down a windowful.
|
|
|
5076 @end group
|
|
|
5077 @end format
|
|
|
5078
|
|
|
5079 @page
|
|
|
5080 @format
|
|
|
5081 @group
|
|
|
5082 If pressed within a Hyperbole-supported mail reader, 'hmail:reader', or mail
|
|
|
5083 summary mode, 'hmail:lister', buffer at:
|
|
|
5084 ACTION
|
|
|
5085 (1) a msg buffer, within the first line or at the end of a message,
|
|
|
5086 the next undeleted message is displayed;
|
|
|
5087 (2) a msg buffer within the first line of an Info cross reference, the
|
|
|
5088 reference is followed;
|
|
|
5089 (3) anywhere else in a msg buffer, the window is scrolled up one
|
|
|
5090 windowful;
|
|
|
5091 (4) a msg summary buffer on a header entry, the message corresponding to
|
|
|
5092 the header is displayed in the msg window;
|
|
|
5093 (5) a msg summary buffer, on or after the last line, the messages marked
|
|
|
5094 for deletion are expunged.
|
|
|
5095 ASSIST
|
|
|
5096 (1) a msg buffer, within the first line or at the end of a message,
|
|
|
5097 the previous undeleted message is displayed;
|
|
|
5098 (2) a msg buffer within the first line of an Info cross reference, the
|
|
|
5099 reference is followed;
|
|
|
5100 (3) anywhere else in a msg buffer, the window is scrolled down one
|
|
|
5101 windowful;
|
|
|
5102 (4) a msg summary buffer on a header entry, the message corresponding to
|
|
|
5103 the header is marked as deleted;
|
|
|
5104 (5) a msg summary buffer, on or after the last line, all messages are
|
|
|
5105 marked undeleted.
|
|
|
5106 @end group
|
|
|
5107 @end format
|
|
|
5108
|
|
|
5109 @format
|
|
|
5110 @group
|
|
|
5111 @cindex click, GNUS
|
|
|
5112 @cindex GNUS browsing
|
|
|
5113 If pressed within a GNUS listing of newsgroups buffer at:
|
|
|
5114 ACTION
|
|
|
5115 (1) a GNUS-GROUP line, that newsgroup is read;
|
|
|
5116 (2) to the left of any GNUS-GROUP line, on any of the whitespace, the
|
|
|
5117 current group is unsubscribed or resubscribed;
|
|
|
5118 (3) at the end of the GNUS-GROUP buffer, after all lines, checks for new
|
|
|
5119 news.
|
|
|
5120 ASSIST
|
|
|
5121 (1) a GNUS-GROUP line, that newsgroup is read;
|
|
|
5122 (2) to the left of any GNUS-GROUP line, on any of the whitespace, the
|
|
|
5123 user is prompted for a group name to subscribe or unsubscribe to;
|
|
|
5124 (3) at the end of the GNUS-GROUP buffer, after all lines, quits from the
|
|
|
5125 newsreader.
|
|
|
5126 @end group
|
|
|
5127 @end format
|
|
|
5128
|
|
|
5129 @page
|
|
|
5130 @format
|
|
|
5131 @group
|
|
|
5132 If pressed within a GNUS newsreader subject listing buffer at:
|
|
|
5133 ACTION
|
|
|
5134 (1) a GNUS-SUBJECT line, that article is read, marked deleted, and
|
|
|
5135 scrolled forward;
|
|
|
5136 (2) at the end of the GNUS-SUBJECT buffer, the next undeleted article
|
|
|
5137 is read or the next group is entered.
|
|
|
5138 ASSIST
|
|
|
5139 (1) a GNUS-SUBJECT line, that article is read and scrolled backward;
|
|
|
5140 (2) at the end of the GNUS-SUBJECT buffer, the subject is exited, the
|
|
|
5141 user is returned to group mode.
|
|
|
5142 @end group
|
|
|
5143 @end format
|
|
|
5144
|
|
|
5145 @format
|
|
|
5146 @group
|
|
|
5147 If pressed within a GNUS newsreader article buffer at:
|
|
|
5148 ACTION
|
|
|
5149 (1) the first line or end of an article, the next unread message is
|
|
|
5150 displayed;
|
|
|
5151 (2) the first line of an Info cross reference, the reference is followed;
|
|
|
5152 (3) anywhere else, the window is scrolled up a windowful.
|
|
|
5153 ASSIST
|
|
|
5154 (1) the first line or end of an article, the previous message is
|
|
|
5155 displayed;
|
|
|
5156 (2) the first line of an Info cross reference, the reference is followed;
|
|
|
5157 (3) anywhere else, the window is scrolled down a windowful.
|
|
|
5158 @end group
|
|
|
5159 @end format
|
|
|
5160
|
|
|
5161 @page
|
|
|
5162 @format
|
|
|
5163 @group
|
|
|
5164 @cindex click, buffer menu
|
|
|
5165 @cindex buffer menu
|
|
|
5166 If pressed within a listing of buffers (Buffer-menu-mode):
|
|
|
5167 ACTION
|
|
|
5168 (1) on the first column of an entry, the selected buffer is marked for
|
|
|
5169 display;
|
|
|
5170 (2) on the second column of an entry, the selected buffer is marked to be
|
|
|
5171 saved;
|
|
|
5172 (3) anywhere else within an entry line, all saves and deletes are done,
|
|
|
5173 and selected buffers are displayed, including the one just clicked
|
|
|
5174 on (if in the OO-Browser, only the selected buffer is displayed);
|
|
|
5175 (4) on or after the last line in the buffer, all saves and deletes are
|
|
|
5176 done.
|
|
|
5177 ASSIST
|
|
|
5178 (1) on the first or second column of an entry, the selected buffer is
|
|
|
5179 unmarked for display and for saving or deletion;
|
|
|
5180 (2) anywhere else within an entry line, the selected buffer is marked for
|
|
|
5181 deletion;
|
|
|
5182 (3) on or after the last line in the buffer, all display, save, and delete
|
|
|
5183 marks on all entries are undone.
|
|
|
5184 @end group
|
|
|
5185 @end format
|
|
|
5186
|
|
|
5187 @format
|
|
|
5188 @group
|
|
|
5189 @cindex click, dired
|
|
|
5190 @cindex dired browsing
|
|
|
5191 If pressed within a dired-mode buffer:
|
|
|
5192 ACTION
|
|
|
5193 (1) within an entry line, the selected file/directory is displayed
|
|
|
5194 for editing in the other window;
|
|
|
5195 (2) on or after the last line in the buffer, if any deletes are to be
|
|
|
5196 performed, they are executed after user verification, otherwise, this
|
|
|
5197 dired invocation is quit.
|
|
|
5198 ASSIST
|
|
|
5199 (1) on a '~' character, all backup files in the directory are marked for
|
|
|
5200 deletion;
|
|
|
5201 (2) on a '#' character, all auto-save files in the directory are marked
|
|
|
5202 for deletion;
|
|
|
5203 (3) anywhere else within an entry line, the current entry is marked for
|
|
|
5204 deletion;
|
|
|
5205 (4) on or after the last line in the buffer, all delete marks on all
|
|
|
5206 entries are undone.
|
|
|
5207 @end group
|
|
|
5208 @end format
|
|
|
5209
|
|
|
5210 @page
|
|
|
5211 @format
|
|
|
5212 @group
|
|
|
5213 @cindex click, tar
|
|
|
5214 @cindex tar archive browsing
|
|
|
5215 @cindex extracting from tar files
|
|
|
5216 If pressed within a tar-mode buffer:
|
|
|
5217 ACTION
|
|
|
5218 (1) within an entry line, the selected file/directory is displayed
|
|
|
5219 for editing in the other window;
|
|
|
5220 (2) on or after the last line in the buffer, if any deletes are to be
|
|
|
5221 performed, they are executed after user verification, otherwise, this
|
|
|
5222 tar file browser is quit.
|
|
|
5223 ASSIST
|
|
|
5224 (1) on an entry line, the current entry is marked for deletion;
|
|
|
5225 (2) on or after the last line in the buffer, all delete marks on all
|
|
|
5226 entries are undone.
|
|
|
5227 @end group
|
|
|
5228 @end format
|
|
|
5229
|
|
|
5230 @format
|
|
|
5231 @group
|
|
|
5232 @cindex man page references
|
|
|
5233 If pressed on a cross reference within a man page entry section labeled
|
|
|
5234 NAME, SEE ALSO, or PACKAGES USED, or within a man page C routine
|
|
|
5235 specification (see 'smart-man-c-routine-ref') and man page buffer
|
|
|
5236 has either an attached file or else a @var{man-path} local variable
|
|
|
5237 containing its pathname:
|
|
|
5238 ACTION or ASSIST
|
|
|
5239 Displays man page or source code for cross reference.
|
|
|
5240 @end group
|
|
|
5241 @end format
|
|
|
5242
|
|
|
5243 @format
|
|
|
5244 @group
|
|
|
5245 @cindex click, world-wide web
|
|
|
5246 @cindex W3
|
|
|
5247 @cindex URL
|
|
|
5248 @cindex world-wide web
|
|
|
5249 If pressed on a world-wide web universal resource locator:
|
|
|
5250 ACTION
|
|
|
5251 Displays the URL referent at point.
|
|
|
5252 ASSIST
|
|
|
5253 Goes back to a previously displayed web page.
|
|
|
5254 @end group
|
|
|
5255 @end format
|
|
|
5256
|
|
|
5257 @format
|
|
|
5258 @group
|
|
|
5259 @cindex game, gomoku
|
|
|
5260 @cindex gomoku
|
|
|
5261 If pressed in a Gomoku game buffer.
|
|
|
5262 ACTION
|
|
|
5263 Makes a move at the space pointed to.
|
|
|
5264 ASSIST
|
|
|
5265 Takes back a prior move made at the space pointed to.
|
|
|
5266 @end group
|
|
|
5267 @end format
|
|
|
5268
|
|
|
5269 @format
|
|
|
5270 @group
|
|
|
5271 @cindex click, wrolo matches
|
|
|
5272 @cindex wrolo matches
|
|
|
5273 If pressed within an entry in the wrolo match display buffer:
|
|
|
5274 ACTION or ASSIST
|
|
|
5275 The entry is edited in the other window.
|
|
|
5276 @end group
|
|
|
5277 @end format
|
|
|
5278
|
|
|
5279 @node Outliner Keys, Suggestion or Bug Reporting, Smart Key Reference, Top
|
|
|
5280 @appendix Outliner Keys
|
|
|
5281
|
|
|
5282 @cindex outliner keys
|
|
|
5283 This appendix summarizes the specialized key bindings available when
|
|
|
5284 editing an outline with Hyperbole. Each key is shown together with its
|
|
|
5285 command binding and the documentation for that command. Normal emacs
|
|
|
5286 editing keys are modified to account for the structure within outlines.
|
|
|
5287 An outliner command which overloads an Emacs command named @emph{cmd}
|
|
|
5288 would be named @emph{kotl-mode:cmd}.
|
|
|
5289
|
|
|
5290 @table @code
|
|
|
5291
|
|
|
5292 @findex kfile:write
|
|
|
5293 @item kfile:write @{@kbd{C-x C-w}@}
|
|
|
5294 Write current outline to FILE.
|
|
|
5295
|
|
|
5296 @findex klink:create
|
|
|
5297 @item klink:create @{@kbd{C-c l}@}
|
|
|
5298 Insert at point an implicit link to REFERENCE.
|
|
|
5299 REFERENCE should be a cell-ref or a string containing "filename, cell-ref".
|
|
|
5300 See documentation for @code{kcell:ref-to-id} for valid cell-ref formats.
|
|
|
5301
|
|
|
5302 @findex kotl-mode:add-cell
|
|
|
5303 @item kotl-mode:add-cell @{@key{LFD}@}
|
|
|
5304 Add a cell following current cell at optional RELATIVE-LEVEL with CONTENTS string.
|
|
|
5305 Optional prefix arg RELATIVE-LEVEL means add as sibling if nil or >= 0, as child
|
|
|
5306 if equal to universal argument, @kbd{C-u}, and as sibling of current cell's
|
|
|
5307 parent, otherwise. If added as sibling of current level, RELATIVE-LEVEL is
|
|
|
5308 used as a repeat count for the number of cells to add.
|
|
|
5309
|
|
|
5310 Return last newly added cell.
|
|
|
5311
|
|
|
5312 @findex kotl-mode:add-child
|
|
|
5313 @item kotl-mode:add-child @{@kbd{C-c a}@}
|
|
|
5314 Add a new cell to current kview as first child of current cell.
|
|
|
5315
|
|
|
5316 @findex kotl-mode:add-parent
|
|
|
5317 @item kotl-mode:add-parent @{@kbd{C-c p}@}
|
|
|
5318 Add a new cell to current kview as sibling of current cell's parent.
|
|
|
5319
|
|
|
5320 @findex kotl-mode:append-cell
|
|
|
5321 @item kotl-mode:append-cell @{@kbd{C-c +}@}
|
|
|
5322 Append CONTENTS-CELL to APPEND-TO-CELL.
|
|
|
5323 APPEND-TO-CELL is refilled if neither cell has a no-fill property and
|
|
|
5324 kotl-mode:refill-flag is enabled.
|
|
|
5325
|
|
|
5326 @findex kotl-mode:back-to-indentation
|
|
|
5327 @item kotl-mode:back-to-indentation @{@kbd{M-m}@}
|
|
|
5328 Move point to the first non-read-only non-whitespace character on this line.
|
|
|
5329
|
|
|
5330 @findex kotl-mode:backward-cell
|
|
|
5331 @item kotl-mode:backward-cell @{@kbd{C-c C-b}@}
|
|
|
5332 Move to prefix ARGth prior cell (same level) within current view.
|
|
|
5333 Return number of cells left to move.
|
|
|
5334
|
|
|
5335 @findex kotl-mode:backward-char
|
|
|
5336 @item kotl-mode:backward-char @{@kbd{C-b}@}
|
|
|
5337 Move point backward ARG (or 1) characters and return point.
|
|
|
5338
|
|
|
5339 @findex kotl-mode:backward-kill-word
|
|
|
5340 @item kotl-mode:backward-kill-word @{@kbd{M-DEL}@}
|
|
|
5341 Kill up to prefix ARG words preceding point within a single cell.
|
|
|
5342
|
|
|
5343 @findex kotl-mode:backward-sentence
|
|
|
5344 @item kotl-mode:backward-sentence @{@kbd{M-a}@}
|
|
|
5345 Move point backward ARG (or 1) sentences and return point.
|
|
|
5346
|
|
|
5347 @findex kotl-mode:backward-word
|
|
|
5348 @item kotl-mode:backward-word @{@kbd{M-b}@}
|
|
|
5349 Move point backward ARG (or 1) words and return point.
|
|
|
5350
|
|
|
5351 @findex kotl-mode:beginning-of-buffer
|
|
|
5352 @item kotl-mode:beginning-of-buffer @{@kbd{M-<}@}
|
|
|
5353 Move point to beginning of buffer and return point.
|
|
|
5354
|
|
|
5355 @findex kotl-mode:beginning-of-cell
|
|
|
5356 @item kotl-mode:beginning-of-cell @{@kbd{C-c ,}@}
|
|
|
5357 Move point to beginning of current or ARGth - 1 prior cell and return point.
|
|
|
5358
|
|
|
5359 @findex kotl-mode:beginning-of-line
|
|
|
5360 @item kotl-mode:beginning-of-line @{@kbd{C-a}@}
|
|
|
5361 Move point to beginning of current or ARGth - 1 line and return point.
|
|
|
5362
|
|
|
5363 @findex kotl-mode:beginning-of-tree
|
|
|
5364 @item kotl-mode:beginning-of-tree @{@kbd{C-c ^}@}
|
|
|
5365 Move point to the level 1 root of the current cell's tree.
|
|
|
5366 Leave point at the start of the cell.
|
|
|
5367
|
|
|
5368 @findex kotl-mode:center-line
|
|
|
5369 @item kotl-mode:center-line @{@kbd{M-s}@}
|
|
|
5370 @vindex fill-column
|
|
|
5371 Center the line point is on, within the width specified by @var{fill-column}.
|
|
|
5372 This means adjusting the indentation so that it equals the distance between
|
|
|
5373 the end of the text and @var{fill-column}.
|
|
|
5374
|
|
|
5375 @findex kotl-mode:center-paragraph
|
|
|
5376 @item kotl-mode:center-paragraph @{@kbd{M-S}@}
|
|
|
5377 Center each nonblank line in the paragraph at or after point.
|
|
|
5378 See @code{center-line} for more info.
|
|
|
5379
|
|
|
5380 @findex kotl-mode:copy-after
|
|
|
5381 @item kotl-mode:copy-after @{@kbd{C-c c}@}
|
|
|
5382 Copy tree rooted at FROM-CELL-REF to follow tree rooted at TO-CELL-REF.
|
|
|
5383 If prefix arg CHILD-P is non-nil, make FROM-CELL-REF the first child of
|
|
|
5384 TO-CELL-REF, otherwise make it the sibling following TO-CELL-REF.
|
|
|
5385
|
|
|
5386 Leave point at the start of the root cell of the new tree.
|
|
|
5387
|
|
|
5388 @findex kotl-mode:copy-before
|
|
|
5389 @item kotl-mode:copy-before @{@kbd{C-c C-c}@}
|
|
|
5390 Copy tree rooted at FROM-CELL-REF to precede tree rooted at TO-CELL-REF.
|
|
|
5391 If prefix arg PARENT-P is non-nil, make FROM-CELL-REF the first child of
|
|
|
5392 TO-CELL-REF's parent, otherwise make it the preceding sibling of TO-CELL-REF.
|
|
|
5393
|
|
|
5394 Leave point at the start of the root cell of the new tree.
|
|
|
5395
|
|
|
5396 @findex kotl-mode:copy-to-buffer
|
|
|
5397 @item kotl-mode:copy-to-buffer @{@kbd{C-c M-c}@}
|
|
|
5398 Copy outline tree rooted at CELL-REF to a non-koutline BUFFER.
|
|
|
5399 Use 0 to copy the whole outline buffer.
|
|
|
5400
|
|
|
5401 @findex kotl-mode:copy-to-register
|
|
|
5402 @item kotl-mode:copy-to-register @{@kbd{C-x x}@}
|
|
|
5403 Copy into REGISTER the region START to END.
|
|
|
5404 With optional prefix arg DELETE-FLAG, delete region.
|
|
|
5405
|
|
|
5406 @findex kotl-mode:delete-backward-char
|
|
|
5407 @item kotl-mode:delete-backward-char @{@kbd{DEL}@}
|
|
|
5408 Delete up to the preceding prefix ARG characters.
|
|
|
5409 Return number of characters deleted.
|
|
|
5410 Optional KILL-FLAG non-nil means save in kill ring instead of deleting.
|
|
|
5411 Does not delete across cell boundaries.
|
|
|
5412
|
|
|
5413 @findex kotl-mode:delete-blank-lines
|
|
|
5414 @item kotl-mode:delete-blank-lines @{@kbd{C-x C-o}@}
|
|
|
5415 On blank line within a cell, delete all surrounding blank lines, leaving just one.
|
|
|
5416 On isolated blank line, delete that one.
|
|
|
5417 On nonblank line, delete all blank lines that follow it.
|
|
|
5418
|
|
|
5419 If nothing but whitespace follows point until the end of a cell, delete all
|
|
|
5420 whitespace at the end of the cell.
|
|
|
5421
|
|
|
5422 @findex kotl-mode:delete-char
|
|
|
5423 @item kotl-mode:delete-char @{@kbd{C-d}@}
|
|
|
5424 Delete up to prefix ARG characters following point.
|
|
|
5425 Return number of characters deleted.
|
|
|
5426 Optional KILL-FLAG non-nil means save in kill ring instead of deleting.
|
|
|
5427 Does not delete across cell boundaries.
|
|
|
5428
|
|
|
5429 @findex kotl-mode:delete-indentation
|
|
|
5430 @item kotl-mode:delete-indentation @{@kbd{M-^}@}
|
|
|
5431 Join this line to previous and fix up whitespace at join.
|
|
|
5432 If there is a fill prefix, delete it from the beginning of this line.
|
|
|
5433 With argument, join this line to following line.
|
|
|
5434
|
|
|
5435 @findex kotl-mode:demote-tree
|
|
|
5436 @vindex kotl-mode:refill-flag
|
|
|
5437 @item kotl-mode:demote-tree @{@kbd{TAB}@}
|
|
|
5438 Move current kotl a maximum of prefix ARG levels lower in current view.
|
|
|
5439 Each cell is refilled iff its @emph{no-fill} attribute is nil and
|
|
|
5440 @var{kotl-mode:refill-flag} is non-nil. With prefix ARG = 0, cells are
|
|
|
5441 demoted up to one level and kotl-mode:refill-flag is treated as true.
|
|
|
5442
|
|
|
5443 @findex kotl-mode:down-level
|
|
|
5444 @item kotl-mode:down-level @{@kbd{C-c C-d}@}
|
|
|
5445 Move down prefix ARG levels lower within current tree.
|
|
|
5446
|
|
|
5447 @findex kotl-mode:end-of-buffer
|
|
|
5448 @item kotl-mode:end-of-buffer @{@kbd{M->}@}
|
|
|
5449 Move point to end of buffer and return point.
|
|
|
5450
|
|
|
5451 @findex kotl-mode:end-of-cell
|
|
|
5452 @item kotl-mode:end-of-cell @{@kbd{C-c .}@}
|
|
|
5453 Move point to end of current or ARGth - 1 succeeding cell and return point.
|
|
|
5454
|
|
|
5455 @findex kotl-mode:end-of-line
|
|
|
5456 @item kotl-mode:end-of-line @{@kbd{C-e}@}
|
|
|
5457 Move point to end of current or ARGth - 1 line and return point.
|
|
|
5458
|
|
|
5459 @findex kotl-mode:end-of-tree
|
|
|
5460 @item kotl-mode:end-of-tree @{@kbd{C-c $}@}
|
|
|
5461 Move point to the last cell in tree rooted at the current cell.
|
|
|
5462 Leave point at the start of the cell.
|
|
|
5463
|
|
|
5464 @findex kotl-mode:exchange-cells
|
|
|
5465 @item kotl-mode:exchange-cells @{@kbd{C-c e}@}
|
|
|
5466 Exchange CELL-REF-1 with CELL-REF-2 in current view. Don't move point.
|
|
|
5467
|
|
|
5468 @findex kotl-mode:fill-cell
|
|
|
5469 @item kotl-mode:fill-cell @{@kbd{C-c M-j}@}
|
|
|
5470 Fill current cell within current view if it does not have the 'no-fill attribute.
|
|
|
5471 With optional JUSTIFY, justify cell as well.
|
|
|
5472 IGNORE-COLLAPSED-P is used when caller has already expanded cell, indicating
|
|
|
5473 it is not collapsed.
|
|
|
5474
|
|
|
5475 @findex kotl-mode:fill-paragraph
|
|
|
5476 @item kotl-mode:fill-paragraph @{@kbd{C-x f}@}
|
|
|
5477 Fill current paragraph within cell. With optional JUSTIFY, justify
|
|
|
5478 paragraph as well. Ignore any non-nil no-fill attribute attached to the
|
|
|
5479 cell.
|
|
|
5480
|
|
|
5481 @findex kotl-mode:fill-tree
|
|
|
5482 @item kotl-mode:fill-tree @{@kbd{C-M-j}@}
|
|
|
5483 Refill each cell within the tree whose root is at point.
|
|
|
5484
|
|
|
5485 @findex kotl-mode:first-sibling
|
|
|
5486 @item kotl-mode:first-sibling @{@kbd{C-c <}@}
|
|
|
5487 Move point to the first sibling of the present cell.
|
|
|
5488 Leave point at the start of the cell or at its present position if it is
|
|
|
5489 already within the first sibling cell.
|
|
|
5490
|
|
|
5491 @findex kotl-mode:fkey-backward-char
|
|
|
5492 @item kotl-mode:fkey-backward-char @{@kbd{left}@}
|
|
|
5493 Move point backward ARG (or 1) characters and return point.
|
|
|
5494
|
|
|
5495 @findex kotl-mode:fkey-forward-char
|
|
|
5496 @item kotl-mode:fkey-forward-char @{@kbd{right}@}
|
|
|
5497 Move point forward ARG (or 1) characters and return point.
|
|
|
5498
|
|
|
5499 @findex kotl-mode:fkey-next-line
|
|
|
5500 @item kotl-mode:fkey-next-line @{@kbd{down}@}
|
|
|
5501 Move point to ARGth next line and return point.
|
|
|
5502
|
|
|
5503 @findex kotl-mode:fkey-previous-line
|
|
|
5504 @item kotl-mode:fkey-previous-line @{@kbd{up}@}
|
|
|
5505 Move point to ARGth previous line and return point.
|
|
|
5506
|
|
|
5507 @findex kotl-mode:forward-cell
|
|
|
5508 @item kotl-mode:forward-cell @{@kbd{C-c C-f}@}
|
|
|
5509 Move to prefix ARGth following cell (same level) within current view.
|
|
|
5510 Return number of cells left to move.
|
|
|
5511
|
|
|
5512 @findex kotl-mode:forward-char
|
|
|
5513 @item kotl-mode:forward-char @{@kbd{C-f}@}
|
|
|
5514 Move point forward ARG (or 1) characters and return point.
|
|
|
5515
|
|
|
5516 @findex kotl-mode:forward-para
|
|
|
5517 @item kotl-mode:forward-para @{@kbd{M-n}@}
|
|
|
5518 Move to prefix ARGth next cell (any level) within current view.
|
|
|
5519
|
|
|
5520 @findex kotl-mode:forward-paragraph
|
|
|
5521 @item kotl-mode:forward-paragraph @{@kbd{M-]}@}
|
|
|
5522 Move to prefix ARGth next cell (any level) within current view.
|
|
|
5523
|
|
|
5524 @findex kotl-mode:forward-sentence
|
|
|
5525 @item kotl-mode:forward-sentence @{@kbd{M-e}@}
|
|
|
5526 Move point forward ARG (or 1) sentences and return point.
|
|
|
5527
|
|
|
5528 @findex kotl-mode:forward-word
|
|
|
5529 @item kotl-mode:forward-word @{@kbd{M-f}@}
|
|
|
5530 Move point forward ARG (or 1) words and return point.
|
|
|
5531
|
|
|
5532 @findex kotl-mode:goto-cell
|
|
|
5533 @item kotl-mode:goto-cell @{@kbd{C-c g}@}
|
|
|
5534 Move point to start of cell given by CELL-REF. (See 'kcell:ref-to-id'.)
|
|
|
5535 Return point iff CELL-REF is found within current view.
|
|
|
5536 With a prefix argument, CELL-REF is assigned the argument value for use
|
|
|
5537 as an idstamp.
|
|
|
5538
|
|
|
5539 Optional second arg, ERROR-P, non-nil means signal an error if CELL-REF is
|
|
|
5540 not found within current view. Will signal same error if called
|
|
|
5541 interactively when CELL-REF is not found.
|
|
|
5542
|
|
|
5543 @findex kotl-mode:hide-sublevels
|
|
|
5544 @item kotl-mode:hide-sublevels @{@kbd{C-X $}@}
|
|
|
5545 Hide all cells in outline at levels deeper than LEVELS-TO-KEEP (a
|
|
|
5546 number). Shows any hidden cells within LEVELS-TO-KEEP. 1 is the first
|
|
|
5547 level.
|
|
|
5548
|
|
|
5549 @findex kotl-mode:hide-subtree
|
|
|
5550 @item kotl-mode:hide-subtree @{@kbd{C-M-h}@}
|
|
|
5551 Hide subtree, ignoring root, at optional CELL-REF (defaults to cell at
|
|
|
5552 point).
|
|
|
5553
|
|
|
5554 @findex kotl-mode:hide-tree
|
|
|
5555 @item kotl-mode:hide-tree @{@kbd{C-c BS}@}
|
|
|
5556 Collapse kotl rooted at optional CELL-REF (defaults to cell at point).
|
|
|
5557
|
|
|
5558 @findex kotl-mode:insert-file
|
|
|
5559 @item kotl-mode:insert-file @{@kbd{C-x i}@}
|
|
|
5560 Insert each paragraph in IMPORT-FROM as a separate cell in the current view.
|
|
|
5561 Insert as sibling cells following the current cell. IMPORT-FROM may be a
|
|
|
5562 buffer name or file name (file name completion is provided).
|
|
|
5563
|
|
|
5564 @findex kotl-mode:insert-register
|
|
|
5565 @item kotl-mode:insert-register @{@kbd{C-c r i}@}
|
|
|
5566 Insert contents of register REGISTER at point in current cell.
|
|
|
5567 REGISTER is a character naming the register to insert.
|
|
|
5568 Normally puts point before and mark after the inserted text.
|
|
|
5569 If optional second arg is non-nil, puts mark before and point after.
|
|
|
5570 Interactively, second arg is non-nil if prefix arg is supplied.
|
|
|
5571
|
|
|
5572 @findex kotl-mode:just-one-space
|
|
|
5573 @item kotl-mode:just-one-space @{@kbd{M-\}@}
|
|
|
5574 Delete all spaces and tabs around point and leave one space.
|
|
|
5575
|
|
|
5576 @findex kotl-mode:kcell-help
|
|
|
5577 @item kotl-mode:kcell-help @{@kbd{C-c h}@}
|
|
|
5578 Display a temporary buffer with CELL-REF's properties.
|
|
|
5579 CELL-REF defaults to current cell.
|
|
|
5580 Optional prefix arg CELLS-FLAG selects the cells to print:
|
|
|
5581 If = 1, print CELL-REF's cell only;
|
|
|
5582 If > 1, print CELL-REF's visible kotl (the tree rooted at CELL-REF);
|
|
|
5583 If < 1, print all visible cells in current view (CELL-REF is not used).
|
|
|
5584
|
|
|
5585 See also the documentation for @code{kotl-mode:properties}.
|
|
|
5586
|
|
|
5587 @findex kotl-mode:kill-contents
|
|
|
5588 @item kotl-mode:kill-contents @{@kbd{C-c k}@}
|
|
|
5589 Kill contents of cell from point to cell end.
|
|
|
5590 With prefix ARG, kill entire cell contents.
|
|
|
5591
|
|
|
5592 @findex kotl-mode:kill-line
|
|
|
5593 @item kotl-mode:kill-line @{@kbd{C-k}@}
|
|
|
5594 Kill ARG lines from point.
|
|
|
5595
|
|
|
5596 @findex kotl-mode:kill-region
|
|
|
5597 @item kotl-mode:kill-region @{@kbd{C-w}@}
|
|
|
5598 Kill region between START and END within a single kcell.
|
|
|
5599 With optional COPY-P equal to 't, copy region to kill ring but does not
|
|
|
5600 kill it. With COPY-P any other non-nil value, return region as a
|
|
|
5601 string without affecting kill ring.
|
|
|
5602
|
|
|
5603 If the buffer is read-only and COPY-P is nil, the region will not be deleted
|
|
|
5604 but it will be copied to the kill ring and then an error will be signaled.
|
|
|
5605
|
|
|
5606 @findex kotl-mode:kill-ring-save
|
|
|
5607 @item kotl-mode:kill-ring-save @{@kbd{M-w}@}
|
|
|
5608 Copy region between START and END within a single kcell to kill ring.
|
|
|
5609
|
|
|
5610 @findex kotl-mode:kill-sentence
|
|
|
5611 @item kotl-mode:kill-sentence @{@kbd{M-k}@}
|
|
|
5612 Kill up to prefix ARG (or 1) sentences following point within a single cell.
|
|
|
5613
|
|
|
5614 @findex kotl-mode:kill-tree
|
|
|
5615 @item kotl-mode:kill-tree @{@kbd{C-c C-k}@}
|
|
|
5616 Kill ARG following trees starting with tree rooted at point.
|
|
|
5617 If ARG is not a non-positive number, nothing is done.
|
|
|
5618
|
|
|
5619 @findex kotl-mode:kill-word
|
|
|
5620 @item kotl-mode:kill-word @{@kbd{M-d}@}
|
|
|
5621 Kill up to prefix ARG words following point within a single cell.
|
|
|
5622
|
|
|
5623 @findex kotl-mode:last-sibling
|
|
|
5624 @item kotl-mode:last-sibling @{@kbd{C-c >}@}
|
|
|
5625 Move point to the last sibling of the present cell.
|
|
|
5626 Leave point at the start of the cell or at its present position if it is
|
|
|
5627 already within the last sibling cell.
|
|
|
5628
|
|
|
5629 @findex kotl-mode:mail-tree
|
|
|
5630 @item kotl-mode:mail-tree @{@kbd{C-c @@}@}
|
|
|
5631 Mail outline tree rooted at CELL-REF. Use "0" for whole outline buffer.
|
|
|
5632
|
|
|
5633 @findex kotl-mode:move-after
|
|
|
5634 @item kotl-mode:move-after @{@kbd{C-c m}@}
|
|
|
5635 Move tree rooted at FROM-CELL-REF to follow tree rooted at TO-CELL-REF.
|
|
|
5636 If prefix arg CHILD-P is non-nil, make FROM-CELL-REF the first child of
|
|
|
5637 TO-CELL-REF, otherwise make it the sibling following TO-CELL-REF.
|
|
|
5638 With optional COPY-P, copies tree rather than moving it.
|
|
|
5639
|
|
|
5640 Leave point at original location but return the tree's new start point.
|
|
|
5641
|
|
|
5642 @findex kotl-mode:move-before
|
|
|
5643 @item kotl-mode:move-before @{@kbd{C-c RET}@}
|
|
|
5644 Move tree rooted at FROM-CELL-REF to precede tree rooted at TO-CELL-REF.
|
|
|
5645 If prefix arg PARENT-P is non-nil, make FROM-CELL-REF the first child of
|
|
|
5646 TO-CELL-REF's parent, otherwise make it the preceding sibling of TO-CELL-REF.
|
|
|
5647 With optional COPY-P, copies tree rather than moving it.
|
|
|
5648
|
|
|
5649 Leave point at original location but return the tree's new start point.
|
|
|
5650
|
|
|
5651 @findex kotl-mode:newline
|
|
|
5652 @item kotl-mode:newline @{@kbd{RET}@}
|
|
|
5653 Insert a newline. With ARG, insert ARG newlines.
|
|
|
5654 In Auto Fill mode, if no numeric arg, break the preceding line if it is
|
|
|
5655 too long.
|
|
|
5656
|
|
|
5657 @findex kotl-mode:next-cell
|
|
|
5658 @item kotl-mode:next-cell @{@kbd{C-c C-n}@}
|
|
|
5659 Move to prefix ARGth next cell (any level) within current view.
|
|
|
5660
|
|
|
5661 @findex kotl-mode:next-line
|
|
|
5662 @item kotl-mode:next-line @{@kbd{C-n}@}
|
|
|
5663 Move point to ARGth next line and return point.
|
|
|
5664
|
|
|
5665 @findex kotl-mode:open-line
|
|
|
5666 @item kotl-mode:open-line @{@kbd{C-o}@}
|
|
|
5667 Insert a newline and leave point before it.
|
|
|
5668 With arg N, insert N newlines.
|
|
|
5669
|
|
|
5670 @findex kotl-mode:overview
|
|
|
5671 @item kotl-mode:overview @{@kbd{C-c C-o}@}
|
|
|
5672 Show only the first line of each cell in the current outline.
|
|
|
5673
|
|
|
5674 @findex kotl-mode:previous-cell
|
|
|
5675 @item kotl-mode:previous-cell @{@kbd{C-c C-p}@}
|
|
|
5676 Move to prefix ARGth previous cell (any level) within current view.
|
|
|
5677
|
|
|
5678 @findex kotl-mode:previous-line
|
|
|
5679 @item kotl-mode:previous-line @{@kbd{C-p}@}
|
|
|
5680 Move point to ARGth previous line and return point.
|
|
|
5681
|
|
|
5682 @findex kotl-mode:promote-tree
|
|
|
5683 @vindex kotl-mode:refill-flag
|
|
|
5684 @item kotl-mode:promote-tree @{@kbd{M-TAB}@}
|
|
|
5685 Move current kotl a maximum of prefix ARG levels higher in current view.
|
|
|
5686 Each cell is refilled iff its @emph{no-fill} attribute is nil and
|
|
|
5687 @var{kotl-mode:refill-flag} is non-nil. With prefix ARG = 0, cells are
|
|
|
5688 promoted up to one level and kotl-mode:refill-flag is treated as true.
|
|
|
5689
|
|
|
5690 @findex kotl-mode:scroll-down
|
|
|
5691 @item kotl-mode:scroll-down @{@kbd{M-v}@}
|
|
|
5692 Scroll text of current window downward ARG lines; or a windowful if no ARG.
|
|
|
5693
|
|
|
5694 @findex kotl-mode:scroll-up
|
|
|
5695 @item kotl-mode:scroll-up @{@kbd{C-v}@}
|
|
|
5696 Scroll text of current window upward ARG lines; or a windowful if no ARG.
|
|
|
5697
|
|
|
5698 @findex kotl-mode:set-cell-attribute
|
|
|
5699 @item kotl-mode:set-cell-attribute @{@kbd{C-c C-i}@}
|
|
|
5700 Include ATTRIBUTE VALUE with the current cell or the cell at optional POS.
|
|
|
5701 Replaces any existing value that ATTRIBUTE has.
|
|
|
5702 When called interactively, it displays the setting in the minibuffer as
|
|
|
5703 confirmation.
|
|
|
5704
|
|
|
5705 @findex kotl-mode:set-fill-prefix
|
|
|
5706 @item kotl-mode:set-fill-prefix @{@kbd{C-x l}@}
|
|
|
5707 Sets fill prefix to line up to point.
|
|
|
5708 With prefix arg TURN-OFF or at begin of line, turns fill prefix off.
|
|
|
5709
|
|
|
5710 @findex kotl-mode:show-all
|
|
|
5711 @item kotl-mode:show-all @{@kbd{C-c C-a}@}
|
|
|
5712 Show (expand) all cells in current view.
|
|
|
5713
|
|
|
5714 @findex kotl-mode:show-subtree
|
|
|
5715 @item kotl-mode:show-subtree
|
|
|
5716 Show subtree, ignoring root, at optional CELL-REF (defaults to cell at
|
|
|
5717 point).
|
|
|
5718
|
|
|
5719 @findex kotl-mode:show-tree
|
|
|
5720 @item kotl-mode:show-tree @{@kbd{C-c C-s}@}
|
|
|
5721 Display fully expanded kotl rooted at CELL-REF.
|
|
|
5722
|
|
|
5723 @findex kotl-mode:split-cell
|
|
|
5724 @item kotl-mode:split-cell @{@kbd{C-c s}@}
|
|
|
5725 Split cell into two cells and move to new cell.
|
|
|
5726 Cell contents after point become part of newly created cell.
|
|
|
5727 Default is to create new cell as sibling of current cell.
|
|
|
5728 With optional universal ARG, @kbd{C-u}, new cell is added as child of
|
|
|
5729 current cell.
|
|
|
5730
|
|
|
5731 @findex kotl-mode:top-cells
|
|
|
5732 @item kotl-mode:top-cells @{@kbd{C-c C-t}@}
|
|
|
5733 Collapse all level 1 cells in view and hide any deeper sublevels.
|
|
|
5734
|
|
|
5735 @findex kotl-mode:transpose-cells
|
|
|
5736 @item kotl-mode:transpose-cells @{@kbd{C-c t}@}
|
|
|
5737 Exchange current and previous visible cells, leaving point after both.
|
|
|
5738 If no previous cell, exchange current with next cell.
|
|
|
5739 With prefix ARG, take current cell and move it past ARG cells.
|
|
|
5740 With prefix ARG = 0, interchange the cell that contains point with the cell
|
|
|
5741 that contains mark.
|
|
|
5742
|
|
|
5743 @findex kotl-mode:transpose-chars
|
|
|
5744 @item kotl-mode:transpose-chars @{@kbd{C-t}@}
|
|
|
5745 Interchange characters around point, moving forward one character.
|
|
|
5746 With prefix ARG, take character before point and drag it forward past ARG
|
|
|
5747 other characters (backward if ARG negative).
|
|
|
5748 If no prefix ARG and at end of line, the previous two characters are
|
|
|
5749 exchanged.
|
|
|
5750
|
|
|
5751 @findex kotl-mode:transpose-lines
|
|
|
5752 @item kotl-mode:transpose-lines @{@kbd{C-x C-t}@}
|
|
|
5753 Exchange current line and previous line, leaving point after both.
|
|
|
5754 If no previous line, exchange current with next line.
|
|
|
5755 With prefix ARG, take previous line and move it past ARG lines.
|
|
|
5756 With prefix ARG = 0, interchange the line that contains point with the line
|
|
|
5757 that contains mark.
|
|
|
5758
|
|
|
5759 @findex kotl-mode:transpose-words
|
|
|
5760 @item kotl-mode:transpose-words @{@kbd{M-t}@}
|
|
|
5761 Interchange words around point, leaving point after both words.
|
|
|
5762 With prefix ARG, take word before or around point and drag it forward past
|
|
|
5763 ARG other words (backward if ARG negative). If ARG is zero, the words around
|
|
|
5764 or after point and around or after mark are interchanged.
|
|
|
5765
|
|
|
5766 @findex kotl-mode:up-level
|
|
|
5767 @item kotl-mode:up-level @{@kbd{C-c C-u}@}
|
|
|
5768 Move up prefix ARG levels higher in current outline view.
|
|
|
5769
|
|
|
5770 @findex kotl-mode:yank
|
|
|
5771 @item kotl-mode:yank @{@kbd{C-y}@}
|
|
|
5772 Reinsert the last stretch of killed text.
|
|
|
5773 More precisely, reinsert the stretch of killed text most recently
|
|
|
5774 killed OR yanked. Put point at end, and set mark at beginning.
|
|
|
5775 With just C-u as argument, same but put point at beginning (and mark at end).
|
|
|
5776 With argument N, reinsert the Nth most recently killed stretch of killed
|
|
|
5777 text.
|
|
|
5778 See also the command M-x kotl-mode:yank-pop.
|
|
|
5779
|
|
|
5780 @findex kotl-mode:yank-pop
|
|
|
5781 @item kotl-mode:yank-pop @{@kbd{M-y}@}
|
|
|
5782 Replace just-yanked stretch of killed text with a different stretch.
|
|
|
5783 This command is allowed only immediately after a @code{yank} or a
|
|
|
5784 @code{yank-pop}. At such a time, the region contains a stretch of
|
|
|
5785 reinserted previously-killed text. @code{yank-pop} deletes that text
|
|
|
5786 and inserts in its place a different stretch of killed text.
|
|
|
5787
|
|
|
5788 With no argument, the previous kill is inserted.
|
|
|
5789 With argument N, insert the Nth previous kill.
|
|
|
5790 If N is negative, this is a more recent kill.
|
|
|
5791
|
|
|
5792 The sequence of kills wraps around, so that after the oldest one
|
|
|
5793 comes the newest one.
|
|
|
5794
|
|
|
5795 @findex kotl-mode:zap-to-char
|
|
|
5796 @item kotl-mode:zap-to-char @{@kbd{M-z}@}
|
|
|
5797 Kill up to and including prefix ARG'th occurrence of CHAR.
|
|
|
5798 Goes backward if ARG is negative; error if CHAR not found.
|
|
|
5799
|
|
|
5800 @findex kview:set-label-type
|
|
|
5801 @item kview:set-label-type @{@kbd{C-c C-l}@}
|
|
|
5802 Change kview's label display type to NEW-TYPE, updating all displayed labels.
|
|
|
5803 See documentation for variable, kview:default-label-type, for
|
|
|
5804 valid values of NEW-TYPE.
|
|
|
5805
|
|
|
5806 @findex kvspec:activate
|
|
|
5807 @item kvspec:activate @{@kbd{C-c C-v}@}
|
|
|
5808 Activate optional VIEW-SPEC or existing view spec in the current koutline.
|
|
|
5809 VIEW-SPEC is a string. See <$@{hyperb:dir@}/kotl/EXAMPLE.kotl, 2b17=048> for
|
|
|
5810 details on valid view specs.
|
|
|
5811
|
|
|
5812 @findex kvspec:toggle-blank-lines
|
|
|
5813 @item kvspec:toggle-blank-lines @{@kbd{C-c b}@}
|
|
|
5814 Toggle blank lines between cells on or off.
|
|
|
5815
|
|
|
5816 @end table
|
|
|
5817
|
|
|
5818 @node Suggestion or Bug Reporting, Questions and Answers, Outliner Keys, Top
|
|
|
5819 @appendix Suggestion or Bug Reporting
|
|
|
5820
|
|
|
5821 @xref{Mail Lists}, for complete details on Hyperbole mailing lists and
|
|
|
5822 how to subscribe.
|
|
|
5823
|
|
|
5824 @cindex version description
|
|
|
5825 @cindex Hyperbole version
|
|
|
5826 If you find any errors in Hyperbole's operation or documentation, feel
|
|
|
5827 free to report them to the Hyperbole discussion list:
|
|
|
5828 <hyperbole@@hub.ucsb.edu>. Be sure to use the Msg/Compose-Hypb-Mail
|
|
|
5829 minibuffer menu item whenever you send a message to the mail list since
|
|
|
5830 it will insert important system version information for you.
|
|
|
5831
|
|
|
5832 If you use Hyperbole mail or news support, @ref{Buttons in Mail}, a
|
|
|
5833 click with your Action Key on the Hyperbole mail list address
|
|
|
5834 will insert a description of your Hyperbole configuration information
|
|
|
5835 into your outgoing message, so that you do not have to type it. This is
|
|
|
5836 useful when composing a reply for the Hyperbole mail list. Otherwise,
|
|
|
5837 be sure to include your Emacs, Hyperbole and window system versions in
|
|
|
5838 your message. Your Hyperbole version number can be found in the
|
|
|
5839 top-level Hyperbole menu.
|
|
|
5840
|
|
|
5841 Please use your subject line to state the position that your message
|
|
|
5842 takes on the topic that it addresses, e.g@. send "Subject: Basic bug in
|
|
|
5843 top-level Hyperbole menu." rather than "Subject: Hyperbole bug". This
|
|
|
5844 simple rule makes all e-mail communication much easier.
|
|
|
5845
|
|
|
5846 If you have suggestions on how to improve Hyperbole, send them to the
|
|
|
5847 same address. Here are some issues you might address:
|
|
|
5848
|
|
|
5849 @itemize @bullet
|
|
|
5850 @item
|
|
|
5851 What did you like and dislike about the system?
|
|
|
5852 @item
|
|
|
5853 What kinds of tasks, if any, does it seem to help you with?
|
|
|
5854 @item
|
|
|
5855 What did you think of the Emacs-based user interface?
|
|
|
5856 @item
|
|
|
5857 How was the Hyperbole Manual and other documentation?
|
|
|
5858 @item
|
|
|
5859 Was the setup trivial, average or hard?
|
|
|
5860 @item
|
|
|
5861 What areas of Hyperbole would you like to see expanded/added?
|
|
|
5862 @item
|
|
|
5863 How does it compare to other hypertext tools you have used?
|
|
|
5864 @item
|
|
|
5865 Was it easy or difficult to create your own types? Why?
|
|
|
5866 @item
|
|
|
5867 Did you get any use out of the external system encapsulations?
|
|
|
5868 @end itemize
|
|
|
5869
|
|
|
5870 @node Questions and Answers, Future Work, Suggestion or Bug Reporting, Top
|
|
|
5871 @appendix Questions and Answers
|
|
|
5872
|
|
|
5873 @table @emph
|
|
|
5874 @cindex Smart Key
|
|
|
5875 @cindex mouse key bindings
|
|
|
5876 @findex hmouse-setup
|
|
|
5877 @findex hmouse-get-bindings
|
|
|
5878 @vindex file, hmouse-sh.el
|
|
|
5879 @vindex file, hmouse-reg.el
|
|
|
5880 @item How can I change the Smart Mouse Key bindings?
|
|
|
5881 @findex hmouse-shift-buttons
|
|
|
5882 Since the Smart Mouse Keys are set up for use under five different Emacs
|
|
|
5883 configurations, there is no easy way to provide user level
|
|
|
5884 customization. The command, @code{hmouse-shift-buttons}, can be used to
|
|
|
5885 select between shifted and unshifted Smart Mouse Keys. Any other mouse
|
|
|
5886 key binding changes must be done by editing the @code{hmouse-setup} and
|
|
|
5887 @code{hmouse-get-bindings} functions in the @file{hmouse-sh.el} and
|
|
|
5888 @file{hmouse-reg.el} files.
|
|
|
5889
|
|
|
5890 @vindex file, hmouse-key.el
|
|
|
5891 @vindex file, hui-window.el
|
|
|
5892 @vindex hkey-alist
|
|
|
5893 @vindex hmouse-alist
|
|
|
5894 The @var{hkey-alist} and @var{hmouse-alist} variable
|
|
|
5895 settings in @file{hui-mouse.el} and @file{hui-window.el} must be altered
|
|
|
5896 if you want to change what the Smart Keys do in particular contexts.
|
|
|
5897 You should then update the Smart Key summary documentation in the file,
|
|
|
5898 @file{hypb-mouse.txt}, and potentially the same summary in this manual.
|
|
|
5899
|
|
|
5900
|
|
|
5901 @item Missing Action Types
|
|
|
5902
|
|
|
5903 What if someone sends a mail message with a button for which I do
|
|
|
5904 not have the action type? Or a button whose link referent I can't access?
|
|
|
5905
|
|
|
5906 You receive an error that an action type is not defined or a link
|
|
|
5907 referent is not accessible/readable if you try to use the button. This
|
|
|
5908 is hardly different than trying to get through a locked door without a
|
|
|
5909 key; you try the doorknob, find that it is locked, and then realize that
|
|
|
5910 you need to take a different approach or else give up.
|
|
|
5911
|
|
|
5912 Like all communication, people need to coordinate, which usually
|
|
|
5913 requires an iterative process. If you get a mail message with a button
|
|
|
5914 for which you don't have the action type, you mail the sender and
|
|
|
5915 request it.
|
|
|
5916
|
|
|
5917 @cindex global button, modify
|
|
|
5918 @item How can I modify a number of global buttons in succession?
|
|
|
5919
|
|
|
5920 Rather than typing the name for each, it is quicker to jump to the
|
|
|
5921 global button file and edit the buttons there as you would any explicit
|
|
|
5922 buttons. By default, the ButFile/PersonalFile menu item takes you to
|
|
|
5923 the file where global buttons are saved.
|
|
|
5924
|
|
|
5925 @item Why is all the button data scattered across directories?
|
|
|
5926
|
|
|
5927 When you think of a hyper-space that you depend on every day, you don't
|
|
|
5928 want to have a single point of failure make you incapable of doing work.
|
|
|
5929 With Hyperbole, if some directories become unavailable for a particular
|
|
|
5930 time (e.g@. the filesystems on which they reside are dismounted) you can
|
|
|
5931 still work elsewhere with minimal effect. We believe this to be a
|
|
|
5932 compelling factor to leave the design with external button data storage.
|
|
|
5933
|
|
|
5934 This design also permits the potential addition of buttons to read-only
|
|
|
5935 media.
|
|
|
5936
|
|
|
5937 @item Why are action types defined separately from their implicit button types?
|
|
|
5938
|
|
|
5939 Any category of button can make use of an action type. Some action types
|
|
|
5940 are useful as behavior definitions for a variety of button categories,
|
|
|
5941 so all action types are defined separately to give them independence
|
|
|
5942 from those types which apply them.
|
|
|
5943
|
|
|
5944 For implicit button types that require a lot of code, it is useful to
|
|
|
5945 add a module that includes the implicit button type definition, its
|
|
|
5946 action type definition and supporting code.
|
|
|
5947
|
|
|
5948 @end table
|
|
|
5949
|
|
|
5950
|
|
|
5951 @node Future Work, References, Questions and Answers, Top
|
|
|
5952 @appendix Future Work
|
|
|
5953
|
|
|
5954 @noindent
|
|
|
5955 This appendix is included for a number of reasons:
|
|
|
5956
|
|
|
5957 @itemize @bullet
|
|
|
5958 @item
|
|
|
5959 to better allow you to assess whether to work with Hyperbole by
|
|
|
5960 providing sketches of possible additions:
|
|
|
5961 @item
|
|
|
5962 to direct further development effort towards known needs;
|
|
|
5963 @item
|
|
|
5964 and to acknowledge known weaknesses in the current system.
|
|
|
5965 @end itemize
|
|
|
5966
|
|
|
5967 @table @asis
|
|
|
5968
|
|
|
5969 Note that due to a lack of volunteers to further develop Hyperbole, much
|
|
|
5970 of this work may not be done. So if you want to see these features,
|
|
|
5971 encourage qualified people to volunteer.
|
|
|
5972
|
|
|
5973 @item Button Copying, Killing, and Yanking
|
|
|
5974 There is as yet no means of transferring explicit buttons among buffers.
|
|
|
5975 We realize this is a critical need. Users should be able to manipulate
|
|
|
5976 text with embedded buttons in ordinary ways. This will probably be
|
|
|
5977 implemented only for versions of Emacs 19 and higher. It will store the
|
|
|
5978 button attributes as text attributes within the buffers so that if a
|
|
|
5979 button is copied, its attributes follow. When a buffer is saved, the
|
|
|
5980 attributes also will be saved.
|
|
|
5981
|
|
|
5982 @item Trails
|
|
|
5983 Trails are an extension to the basic history mechanism presently offered
|
|
|
5984 by Hyperbole. Trails will allow a user to capture, edit and store a
|
|
|
5985 specific sequence and set of views of information for later replay by
|
|
|
5986 other users. Conditional branching may also be supported.
|
|
|
5987
|
|
|
5988 @item Outliner View Mode
|
|
|
5989 This will complement the outliner editing mode by using simple one
|
|
|
5990 character keys that normally insert characters to instead modify the
|
|
|
5991 view of an outline and to move around in it, for ease of study.
|
|
|
5992 Switching between view and edit modes will also be simple.
|
|
|
5993
|
|
|
5994 @item Storage of button data within button source files
|
|
|
5995 The current design choice of storing buttons external to the source file
|
|
|
5996 was made under the assumption that people should be able to look at
|
|
|
5997 files that contain Hyperbole buttons with any standard editor or tool
|
|
|
5998 and not be bothered by the ugly button data (since they won't be able to
|
|
|
5999 utilize the buttons anyway, they don't need to see or have access to
|
|
|
6000 them).
|
|
|
6001
|
|
|
6002 In many contexts, embedding the button data within the source files may
|
|
|
6003 be a better choice, so a provision which would allow selection of either
|
|
|
6004 configuration may be added. Here are some of the PROs and CONs of both
|
|
|
6005 design choices:
|
|
|
6006 @sp 1
|
|
|
6007
|
|
|
6008 @example
|
|
|
6009 @group
|
|
|
6010 POSITIVE NEGATIVE
|
|
|
6011
|
|
|
6012 Button data in source file
|
|
|
6013 Documents can stand alone. All edit operators have
|
|
|
6014 Normal file operations apply. to account for file
|
|
|
6015 structure and hide
|
|
|
6016 Simplifies creation and internal components.
|
|
|
6017 facility expansion for
|
|
|
6018 structured and multi-media
|
|
|
6019 files.
|
|
|
6020
|
|
|
6021 Button data external to source file
|
|
|
6022 Files can be displayed and Currently, bdata for
|
|
|
6023 printed exactly as they look. whole directory is
|
|
|
6024 No special display formatting locked when any bdata
|
|
|
6025 is necessary. entry is locked.
|
|
|
6026
|
|
|
6027 Button-based searches and
|
|
|
6028 database-type lookup operations
|
|
|
6029 need only search one file
|
|
|
6030 per directory.
|
|
|
6031 @end group
|
|
|
6032 @end example
|
|
|
6033 @sp 2
|
|
|
6034
|
|
|
6035 @item Forms-based Interfaces
|
|
|
6036
|
|
|
6037 This will allow one to create buttons more flexibly. For example, button
|
|
|
6038 attributes could be given in any order. Entry of long code sequences,
|
|
|
6039 quick note taking and cross-referencing would also be made easier.
|
|
|
6040
|
|
|
6041 @item Collaboration Support
|
|
|
6042
|
|
|
6043 From the early stages of Hyperbole design, collaborative work
|
|
|
6044 environments have been considered. A simple facility has demonstrated
|
|
|
6045 broadcast of button activations to a number of workstations on a local
|
|
|
6046 area network, so that one user can lead others around an information
|
|
|
6047 space, as during an online design review. (This facility was never
|
|
|
6048 adapted to the current Hyperbole release, however.) We shall do some
|
|
|
6049 work in specific collaborative mechanisms, but we also expect that
|
|
|
6050 others who concentrate in collaborative work will provide more extensive
|
|
|
6051 capabilities.
|
|
|
6052
|
|
|
6053 @end table
|
|
|
6054
|
|
|
6055 @node References, Key Binding Index, Future Work, Top
|
|
|
6056 @appendix References
|
|
|
6057
|
|
|
6058 @table @b
|
|
|
6059 @item [AkMcYo88]
|
|
|
6060 Akscyn, R. M., D. L. McCracken and E. A. Yoder. KMS: A
|
|
|
6061 Distributed Hypermedia System for Managing Knowledge in Organizations.
|
|
|
6062 @emph{Communications of the ACM}, Vol. 31, No. 7, July 1988, pp. 820-835.
|
|
|
6063
|
|
|
6064 @item [Bro87]
|
|
|
6065 Brown, P. J. Turning Ideas into Products: The Guide System.
|
|
|
6066 @emph{Proceedings of Hypertext '87}, November 13-15, 1987, Chapel Hill, NC.
|
|
|
6067 ACM: NY, NY, pp. 33-40.
|
|
|
6068
|
|
|
6069 @item [Con87]
|
|
|
6070 Conklin, Jeff. Hypertext: An Introduction and Survey. @emph{IEEE
|
|
|
6071 Computer}, Vol. 20, No. 9, September 1987, pp. 17-41.
|
|
|
6072
|
|
|
6073 @item [Eng68]
|
|
|
6074 Engelbart, D., and W. English. A research center for augmenting
|
|
|
6075 human intellect. @emph{Proceedings of the Fall Joint Computer Conference},
|
|
|
6076 33, 1, AFIPS Press: Montvale, NJ, 1968, pp. 395-410.
|
|
|
6077
|
|
|
6078 @item [Eng84a]
|
|
|
6079 Engelbart, D. C. Authorship Provisions in Augment.
|
|
|
6080 @emph{Proceedings of the 1984 COMPCON Conference (COMPCON '84 Digest)},
|
|
|
6081 February 27-March 1, 1984, San Francisco, CA. IEEE Computer Society Press,
|
|
|
6082 Spring, 1984. 465-472. (OAD,2250,)
|
|
|
6083
|
|
|
6084 @item [Eng84b]
|
|
|
6085 Engelbart, D. C. Collaboration Support Provisions in Augment.
|
|
|
6086 @emph{Proceedings of the AFIPS Office Automation Conference (OAC '84 Digest)},
|
|
|
6087 February, 1984, Los Angeles, CA, 1984. 51-58. (OAD,2221,)
|
|
|
6088
|
|
|
6089 @item [Fos88]
|
|
|
6090 Foss, C. L. Effective Browsing in Hypertext Systems.
|
|
|
6091 @emph{Proceedings of the Conference on User-Oriented Content-Based Text and
|
|
|
6092 Image Handling (RIAO 88)}, March 21-24, MIT, Cambridge MA. Centre de Hautes
|
|
|
6093 Etudes Internationales d'Informatique Documentaire, 1988, pp. 82-98.
|
|
|
6094
|
|
|
6095 @item [GaSmMe86]
|
|
|
6096 Garrett, N., K. E. Smith and N. Meyrowitz. Intermedia: Issues,
|
|
|
6097 Strategies, and Tactics in the Design of a Hypermedia Document System.
|
|
|
6098 @emph{Computer-Supported Cooperative Work (CSCW '86) Proceedings}, December
|
|
|
6099 3-5, Austin, TX, 1986, pp. 163-174.
|
|
|
6100
|
|
|
6101 @item [HaMoTr87]
|
|
|
6102 Halasz, F. G., T. P. Moran and R. H. Trigg. NoteCards in a
|
|
|
6103 Nutshell. @emph{Proceedings of the CHI and GI '87 Conference on Human Factors
|
|
|
6104 in Computing Systems}, Toronto, J. M. Carroll and P. P. Tanner, (editors),
|
|
|
6105 ACM: NY, NY, April 1987, pp. 45-52.
|
|
|
6106
|
|
|
6107 @item [Har88]
|
|
|
6108 Harvey, G. @emph{Understanding HyperCard.} Alameda, CA: SYBEX, Inc.,
|
|
|
6109 1988.
|
|
|
6110
|
|
|
6111 @item [KaCaLoLa92]
|
|
|
6112 Kaplan, S., A. M. Carroll, C. Love and D. M. LaLiberte.
|
|
|
6113 @emph{Epoch 4.0 Manual.} Department of Computer Science, University of
|
|
|
6114 Illinois, Urbana, March 1992.
|
|
|
6115
|
|
|
6116 @item [KaKaBeLaDr90]
|
|
|
6117 Kaplan, S. J., M. D. Kapor, E. J. Belove, R. A. Landsman, and
|
|
|
6118 T. R. Drake. AGENDA: A personal Information Manager. @emph{Communications
|
|
|
6119 of the ACM}, No. 33, July 1990, pp. 105-116.
|
|
|
6120
|
|
|
6121 @item [Nel87a]
|
|
|
6122 Nelson, T. H. @emph{Computer Lib/Dream Machines.} MicroSoft Press,
|
|
|
6123 Redmond, WA, 1987.
|
|
|
6124
|
|
|
6125 @item [Nel87b]
|
|
|
6126 Nelson, T. H. @emph{Literary Machines, Edition 87.1}. Available
|
|
|
6127 from the Distributors, 702 South Michigan, South Bend, IN 46618, 1987.
|
|
|
6128
|
|
|
6129 @item [NoDr86]
|
|
|
6130 Norman, D. A. and S. W. Draper, editors. @emph{User Centered System
|
|
|
6131 Design.} Lawrence Erlbaum Associates: Hillsdale, New Jersey, 1986.
|
|
|
6132
|
|
|
6133 @item [Shn82]
|
|
|
6134 Shneiderman, B. The future of interactive systems and the emergence
|
|
|
6135 of direct manipulation. @emph{Behavior and Information Technology}, Vol. 1,
|
|
|
6136 1982, pp. 237-256.
|
|
|
6137
|
|
|
6138 @item [Sta87]
|
|
|
6139 Stallman, R. @emph{GNU Emacs Manual.} Free Software Foundation,
|
|
|
6140 Cambridge: MA, March 1987.
|
|
|
6141
|
|
|
6142 @item [Tri86]
|
|
|
6143 Trigg, R., L. Suchman, and F. Halasz. Supporting collaboration in
|
|
|
6144 NoteCards. @emph{Proceedings of the CSCW '86 Conference}, Austin, TX,
|
|
|
6145 December 1986, pp. 147-153.
|
|
|
6146
|
|
|
6147 @item [TrMoHa87]
|
|
|
6148 Trigg, R. H., T. P. Moran and F. G. Halasz. Adaptability and
|
|
|
6149 Tailorability in NoteCards. @emph{Proceedings of INTERACT '87}, Stuttgart,
|
|
|
6150 West Germany, September 1987.
|
|
|
6151
|
|
|
6152 @item [Wei92]
|
|
|
6153 Weiner, B. @emph{PIEmail: A Personalized Information Environment
|
|
|
6154 Mail Tool.} Department of Computer Science Masters Project, Brown
|
|
|
6155 University: Providence, RI, May 10, 1992.
|
|
|
6156
|
|
|
6157 @item [YaHaMeDr88]
|
|
|
6158 Yankelovich, N., B. J. Haan, N. Meyrowitz and S. M. Drucker.
|
|
|
6159 Intermedia: The Concept and the Construction of a Seamless Information
|
|
|
6160 Environment. @emph{IEEE Computer}, Vol. 21, No. 1, January 1988, pp. 81-96.
|
|
|
6161
|
|
|
6162 @item [YoAkMc89]
|
|
|
6163 Yoder, E. A., R. M. Akscyn and D. L. McCracken. Collaboration in
|
|
|
6164 KMS, A Shared Hypermedia System. @emph{Proceedings of the 1989 ACM Conference
|
|
|
6165 on Human Factors in Computer Systems (CHI '89)}, April 30-May 4, 1989,
|
|
|
6166 Austin, TX, ACM: NY,NY, 1989, pp. 37-42.
|
|
|
6167
|
|
|
6168 @end table
|
|
|
6169
|
|
|
6170
|
|
|
6171 @c ***************************
|
|
|
6172 @c Indices
|
|
|
6173 @c ***************************
|
|
|
6174
|
|
|
6175 @node Key Binding Index, Code and File Index, References, Top
|
|
|
6176 @unnumbered Key Binding Index
|
|
|
6177
|
|
|
6178 @printindex ky
|
|
|
6179
|
|
|
6180 @node Code and File Index, Concept Index, Key Binding Index, Top
|
|
|
6181 @unnumbered Code and File Index
|
|
|
6182
|
|
|
6183 @printindex fn
|
|
|
6184
|
|
|
6185 @node Concept Index, , Code and File Index, Top
|
|
|
6186 @unnumbered Concept Index
|
|
|
6187
|
|
|
6188 @printindex cp
|
|
|
6189
|
|
|
6190 @page
|
|
|
6191 @summarycontents
|
|
|
6192 @contents
|
|
|
6193 @bye
|
