xemacs-beta: man/lispref/commands.texi comparison

comparison man/lispref/commands.texi @ 5791:9fae6227ede5

Silence texinfo 5.2 warnings, primarily by adding next, prev, and up pointers to all nodes. See xemacs-patches message with ID <5315f7bf.sHpFD7lXYR05GH6E%james@xemacs.org>.

author	Jerry James <james@xemacs.org>
date	Thu, 27 Mar 2014 08:59:03 -0600
parents	62b9ef1ed4ac
children

comparison

equal deleted inserted replaced

-:dcf9067f26bb
+:9fae6227ede5
 * Disabling Commands::  How the command loop handles disabled commands.
 * Command History::     How the command history is set up, and how accessed.
 * Keyboard Macros::     How keyboard macros are implemented.
 @end menu
-@node Command Overview
+@node Command Overview, Defining Commands, Command Loop, Command Loop
 @section Command Loop Overview
 The command loop in XEmacs is a standard event loop, reading events
 one at a time with @code{next-event} and handling them with
 @code{dispatch-event}.  An event is typically a single user action, such
 Quitting is suppressed while running @code{pre-command-hook} and
 @code{post-command-hook}.  If an error happens while executing one of
 these hooks, it terminates execution of the hook, but that is all it
 does.
-@node Defining Commands
+@node Defining Commands, Interactive Call, Command Overview, Command Loop
 @section Defining Commands
 @cindex defining commands
 @cindex commands, defining
 @cindex functions, making them interactive
 @cindex interactive function
 * Interactive Codes::     The standard letter-codes for reading arguments
 in various ways.
 * Interactive Examples::  Examples of how to read interactive arguments.
 @end menu
-@node Using Interactive
+@node Using Interactive, Interactive Codes, Defining Commands, Defining Commands
 @subsection Using @code{interactive}
 This section describes how to write the @code{interactive} form that
 makes a Lisp function an interactively-callable command.
 which may be any funcallable object.  The specification will be returned
 as the list of the symbol @code{interactive} and the specs.  If
 @var{function} is not interactive, @code{nil} will be returned.
 @end defun
-@node Interactive Codes
+@node Interactive Codes, Interactive Examples, Using Interactive, Defining Commands
 @subsection Code Characters for @code{interactive}
 @cindex interactive code description
 @cindex description for interactive codes
 @cindex codes, interactive, description of
 @cindex characters for interactive codes
 @cindex evaluated expression argument
 A Lisp form is read as with @kbd{x}, but then evaluated so that its
 value becomes the argument for the command.  Prompt.
 @end table
-@node Interactive Examples
+@node Interactive Examples,  , Interactive Codes, Defining Commands
 @subsection Examples of Using @code{interactive}
 @cindex examples of using @code{interactive}
 @cindex @code{interactive}, examples of using
 Here are some examples of @code{interactive}:
 (three-b "*scratch*" "declarations.texi" "*mail*")
 @result{} nil
 @end group
 @end example
-@node Interactive Call
+@node Interactive Call, Command Loop Info, Defining Commands, Command Loop
 @section Interactive Call
 @cindex interactive call
 After the command loop has translated a key sequence into a
 definition, it invokes that definition using the function
 @result{} (nil t)
 @end group
 @end example
 @end defun
-@node Command Loop Info
+@node Command Loop Info, Events, Interactive Call, Command Loop
 @section Information from the Command Loop
 The editor command loop sets several Lisp variables to keep status
 records for itself and for commands that are run.
 in the same command will be echoed as well.
 If the value is zero, then command input is not echoed.
 @end defvar
-@node Events
+@node Events, Reading Input, Command Loop Info, Command Loop
 @section Events
 @cindex events
 @cindex input events
 The XEmacs command loop reads a sequence of @dfn{events} that
 * Working With Events::		Creating, copying, and destroying events.
 * Converting Events::		Converting between events, keys, and
 				  characters.
 @end menu
-@node Event Types
+@node Event Types, Event Contents, Events, Events
 @subsection Event Types
 Events represent keyboard or mouse activity or status changes of various
 sorts, such as process input being available or a timeout being triggered.
 The different event types are as follows:
 is sometimes placed in the event queue when a magic event is processed.
 This kind of event should generally just be passed off to
 @code{dispatch-event}.  @xref{Dispatching an Event}.
 @end table
-@node Event Contents
+@node Event Contents, Event Predicates, Event Types, Events
 @subsection Contents of the Different Types of Events
 Every event, no matter what type it is, contains a timestamp (which is
 typically an offset in milliseconds from when the X server was started)
 indicating when the event occurred.  In addition, many events contain
 @item magic
 Some window-system-specific event has occurred.
 @end table
 @end defun
-@node Event Predicates
+@node Event Predicates, Accessing Mouse Event Positions, Event Contents, Events
 @subsection Event Predicates
 The following predicates return whether an object is an event of a
 particular type.
 @defun event-live-p object
 This is true if @var{object} is any event that has not been deallocated.
 @end defun
-@node Accessing Mouse Event Positions
+@node Accessing Mouse Event Positions, Accessing Other Event Info, Event Predicates, Events
 @subsection Accessing the Position of a Mouse Event
 Unlike other events, mouse events (i.e. motion, button-press,
 button-release, and drag or drop type misc-user events) occur in a
 particular location on the screen. Many primitives are provided for
 * Event Glyph Position Info::
 * Event Toolbar Position Info::
 * Other Event Position Info::
 @end menu
-@node Frame-Level Event Position Info
+@node Frame-Level Event Position Info, Window-Level Event Position Info, Accessing Mouse Event Positions, Accessing Mouse Event Positions
 @subsubsection Frame-Level Event Position Info
 The following functions return frame-level information about where
 a mouse event occurred.
 This function returns the Y position in pixels of the given mouse event.
 The value returned is relative to the frame the event occurred in.
 This will signal an error if the event is not a mouse event.
 @end defun
-@node Window-Level Event Position Info
+@node Window-Level Event Position Info, Event Text Position Info, Frame-Level Event Position Info, Accessing Mouse Event Positions
 @subsubsection Window-Level Event Position Info
 The following functions return window-level information about where
 a mouse event occurred.
 The value returned is relative to the window the event occurred in.
 This will signal an error if the event is not a mouse-motion, button-press,
 button-release, or misc-user event.
 @end defun
-@node Event Text Position Info
+@node Event Text Position Info, Event Glyph Position Info, Window-Level Event Position Info, Accessing Mouse Event Positions
 @subsubsection Event Text Position Info
 The following functions return information about the text (including the
 modeline) that a mouse event occurred over or near.
 that window, the closest point is the end of the line containing the Y
 position.  If the Y pixel position is above a window, 0 is returned.  If
 it is below a window, the value of @code{(window-end)} is returned.
 @end defun
-@node Event Glyph Position Info
+@node Event Glyph Position Info, Event Toolbar Position Info, Event Text Position Info, Accessing Mouse Event Positions
 @subsubsection Event Glyph Position Info
 The following functions return information about the glyph (if any) that
 a mouse event occurred over.
 glyph, this function returns the Y position of the pointer relative to
 the upper left of the glyph.  If the event is not over a glyph, it returns
 @code{nil}.
 @end defun
-@node Event Toolbar Position Info
+@node Event Toolbar Position Info, Other Event Position Info, Event Glyph Position Info, Accessing Mouse Event Positions
 @subsubsection Event Toolbar Position Info
 @defun event-over-toolbar-p event
 Given a mouse-motion, button-press, button-release, or misc-user event, this
 function returns @code{t} if the event is over a toolbar.  Otherwise,
 If the given mouse-motion, button-press, button-release, or misc-user event
 happened on top of a toolbar button, this function returns the button.
 Otherwise, @code{nil} is returned.
 @end defun
-@node Other Event Position Info
+@node Other Event Position Info,  , Event Toolbar Position Info, Accessing Mouse Event Positions
 @subsubsection Other Event Position Info
 @defun event-over-border-p event
 Given a mouse-motion, button-press, button-release, or misc-user event, this
 function returns @code{t} if the event is over an internal toolbar.
 Otherwise, @code{nil} is returned.
 @end defun
-@node Accessing Other Event Info
+@node Accessing Other Event Info, Working With Events, Accessing Mouse Event Positions, Events
 @subsection Accessing the Other Contents of Events
 The following functions allow access to the contents of events other than
 the position info described in the previous section.
 @defun event-process event
 This function returns the process of the given process event.
 @end defun
-@node Working With Events
+@node Working With Events, Converting Events, Accessing Other Event Info, Events
 @subsection Working With Events
 XEmacs provides primitives for creating, copying, and destroying event
 objects.  Many functions that return events take an event object as an
 argument and fill in the fields of this event; or they make accept
 objects are garbage-collected like all other objects; however, it may be
 more efficient to explicitly deallocate events when you are sure that
 it is safe to do so.
 @end defun
-@node Converting Events
+@node Converting Events,  , Working With Events, Events
 @subsection Converting Events
 XEmacs provides some auxiliary functions for converting between events
 and other ways of representing keys.  These are useful when working with
 @sc{ascii} strings and with keymaps.
 Given a vector of event objects, this function returns a vector of key
 descriptors, or a string (if they all fit in the @sc{ascii} range).
 Optional arg @var{no-mice} means that button events are not allowed.
 @end defun
-@node Reading Input
+@node Reading Input, Waiting, Events, Command Loop
 @section Reading Input
 The editor command loop reads keyboard input using the function
 @code{next-event} and constructs key sequences out of the events using
 @code{dispatch-event}.  Lisp programs can also use the function
 * Dispatching an Event::        What to do with an event once it has been read.
 * Quoted Character Input::	Asking the user to specify a character.
 * Peeking and Discarding::    	How to reread or throw away input events.
 @end menu
-@node Key Sequence Input
+@node Key Sequence Input, Reading One Event, Reading Input, Reading Input
 @subsection Key Sequence Input
 @cindex key sequence input
 Lisp programs can read input a key sequence at a time by calling
 @code{read-key-sequence}; for example, @code{describe-key} uses it to
 If an input character is an upper-case letter and has no key binding,
 but its lower-case equivalent has one, then @code{read-key-sequence}
 converts the character to lower case.  Note that @code{lookup-key} does
 not perform case conversion in this way.
-@node Reading One Event
+@node Reading One Event, Dispatching an Event, Key Sequence Input, Reading Input
 @subsection Reading One Event
 The lowest level functions for command input are those which read a
 single event.  These functions often make a distinction between
 @dfn{command events}, which are user actions (keystrokes and mouse
 @defun enqueue-eval-event function object
 This function adds an eval event to the back of the queue.  The
 eval event will be the next event read after all pending events.
 @end defun
-@node Dispatching an Event
+@node Dispatching an Event, Quoted Character Input, Reading One Event, Reading Input
 @subsection Dispatching an Event
 @cindex dispatching an event
 @defun dispatch-event event
 Given an event object returned by @code{next-event}, this function
 executes it.  This is the basic function that makes XEmacs respond to
 user input; it also deals with notifications from the window system
 (such as Expose events).
 @end defun
-@node Quoted Character Input
+@node Quoted Character Input, Peeking and Discarding, Dispatching an Event, Reading Input
 @subsection Quoted Character Input
 @cindex quoted character input
 You can use the function @code{read-quoted-char} to ask the user to
 specify a character, and allow the user to specify a control or meta
 @end group
 @end example
 @end defun
 @need 2000
-@node Peeking and Discarding
+@node Peeking and Discarding,  , Quoted Character Input, Reading Input
 @subsection Miscellaneous Event Input Features
 This section describes how to ``peek ahead'' at events without using
 them up, how to check for pending input, and how to discard pending
 input.
 (discard-input))
 @result{} nil
 @end example
 @end defun
-@node Waiting
+@node Waiting, Quitting, Reading Input, Command Loop
 @section Waiting for Elapsed Time or Input
 @cindex pausing
 @cindex waiting
 The wait functions are designed to wait for a certain amount of time
 Use @code{sleep-for} when you wish to guarantee a delay.
 @end defun
 @xref{Time of Day}, for functions to get the current time.
-@node Quitting
+@node Quitting, Prefix Command Arguments, Waiting, Command Loop
 @section Quitting
 @cindex @kbd{C-g}
 @cindex quitting
 Typing @kbd{C-g} while a Lisp function is running causes XEmacs to
 @end deffn
 You can specify a character other than @kbd{C-g} to use for quitting.
 See the function @code{set-input-mode} in @ref{Terminal Input}.
-@node Prefix Command Arguments
+@node Prefix Command Arguments, Recursive Editing, Quitting, Command Loop
 @section Prefix Command Arguments
 @cindex prefix argument
 @cindex raw prefix argument
 @cindex numeric prefix argument
 argument @var{arg} is the raw prefix argument as it was before this
 command; its value is negated to form the new prefix argument.  Don't
 call this command yourself unless you know what you are doing.
 @end deffn
-@node Recursive Editing
+@node Recursive Editing, Disabling Commands, Prefix Command Arguments, Command Loop
 @section Recursive Editing
 @cindex recursive command loop
 @cindex recursive editing level
 @cindex command loop, recursive
 @defun recursion-depth
 This function returns the current depth of recursive edits.  When no
 recursive edit is active, it returns 0.
 @end defun
-@node Disabling Commands
+@node Disabling Commands, Command History, Recursive Editing, Command Loop
 @section Disabling Commands
 @cindex disabled command
 @dfn{Disabling a command} marks the command as requiring user
 confirmation before it can be executed.  Disabling is used for commands
 By default, @code{disabled-command-hook} contains a function that asks
 the user whether to proceed.
 @end defvar
-@node Command History
+@node Command History, Keyboard Macros, Disabling Commands, Command Loop
 @section Command History
 @cindex command history
 @cindex complex command
 @cindex history of commands
 @code{list-command-history} are described in the user manual
 (@pxref{Repetition,,, xemacs, The XEmacs User's Manual}).  Within the
 minibuffer, the history commands used are the same ones available in any
 minibuffer.
-@node Keyboard Macros
+@node Keyboard Macros,  , Command History, Command Loop
 @section Keyboard Macros
 @cindex keyboard macros
 A @dfn{keyboard macro} is a canned sequence of input events that can
 be considered a command and made the definition of a key.  The Lisp

Mercurial > hg > xemacs-beta

comparison man/lispref/commands.texi @ 5791:9fae6227ede5