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