-This is Info file ../../info/xemacs.info, produced by Makeinfo version
-1.68 from the input file xemacs.texi.
+This is ../info/xemacs.info, produced by makeinfo version 4.0b from
+xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
translation approved by the author instead of in the original English.
\1f
-File: xemacs.info, Node: Changing an Option, Next: Face Customization, Prev: Customization Groups, Up: Easy Customization
-
-Changing an Option
-..................
-
- Here is an example of what a user option looks like in the
-customization buffer:
-
- Kill Ring Max: [Hide] 30
- [State]: this option is unchanged from its standard setting.
- Maximum length of kill ring before oldest elements are thrown away.
-
- The text following `[Hide]', `30' in this case, indicates the
-current value of the option. If you see `[Show]' instead of `[Hide]',
-it means that the value is hidden; the customization buffer initially
-hides values that take up several lines. Invoke `[Show]' to show the
-value.
-
- The line after the option name indicates the "customization state"
-of the option: in the example above, it says you have not changed the
-option yet. The word `[State]' at the beginning of this line is
-active; you can get a menu of various operations by invoking it with
-`Mouse-1' or <RET>. These operations are essential for customizing the
-variable.
-
- The line after the `[State]' line displays the beginning of the
-option's documentation string. If there are more lines of
-documentation, this line ends with `[More]'; invoke this to show the
-full documentation string.
-
- To enter a new value for `Kill Ring Max', move point to the value
-and edit it textually. For example, you can type `M-d', then insert
-another number.
-
- When you begin to alter the text, you will see the `[State]' line
-change to say that you have edited the value:
-
- [State]: you have edited the value as text, but not set the option.
-
- Editing the value does not actually set the option variable. To do
-that, you must "set" the option. To do this, invoke the word `[State]'
-and choose `Set for Current Session'.
-
- The state of the option changes visibly when you set it:
-
- [State]: you have set this option, but not saved it for future sessions.
-
- You don't have to worry about specifying a value that is not valid;
-setting the option checks for validity and will not really install an
-unacceptable value.
-
- While editing a value or field that is a file name, directory name,
-command name, or anything else for which completion is defined, you can
-type `M-<TAB>' (`widget-complete') to do completion.
-
- Some options have a small fixed set of possible legitimate values.
-These options don't let you edit the value textually. Instead, an
-active field `[Value Menu]' appears before the value; invoke this field
-to edit the value. For a boolean "on or off" value, the active field
-says `[Toggle]', and it changes to the other value. `[Value Menu]' and
-`[Toggle]' edit the buffer; the changes take effect when you use the
-`Set for Current Session' operation.
-
- Some options have values with complex structure. For example, the
-value of `load-path' is a list of directories. Here is how it appears
-in the customization buffer:
-
- Load Path:
- [INS] [DEL] [Current dir?]: /usr/local/share/emacs/19.34.94/site-lisp
- [INS] [DEL] [Current dir?]: /usr/local/share/emacs/site-lisp
- [INS] [DEL] [Current dir?]: /usr/local/share/emacs/19.34.94/leim
- [INS] [DEL] [Current dir?]: /usr/local/share/emacs/19.34.94/lisp
- [INS] [DEL] [Current dir?]: /build/emacs/e19/lisp
- [INS] [DEL] [Current dir?]: /build/emacs/e19/lisp/gnus
- [INS]
- [State]: this item has been changed outside the customization buffer.
- List of directories to search for files to load....
-
-Each directory in the list appears on a separate line, and each line has
-several editable or active fields.
-
- You can edit any of the directory names. To delete a directory from
-the list, invoke `[DEL]' on that line. To insert a new directory in
-the list, invoke `[INS]' at the point where you want to insert it.
-
- You can also invoke `[Current dir?]' to switch between including a
-specific named directory in the path, and including `nil' in the path.
-(`nil' in a search path means "try the current directory.")
-
- Two special commands, <TAB> and `S-<TAB>', are useful for moving
-through the customization buffer. <TAB> (`widget-forward') moves
-forward to the next active or editable field; `S-<TAB>'
-(`widget-backward') moves backward to the previous active or editable
-field.
-
- Typing <RET> on an editable field also moves forward, just like
-<TAB>. The reason for this is that people have a tendency to type
-<RET> when they are finished editing a field. If you have occasion to
-insert a newline in an editable field, use `C-o' or `C-q C-j',
-
- Setting the option changes its value in the current Emacs session;
-"saving" the value changes it for future sessions as well. This works
-by writing code into your `~/.emacs' file so as to set the option
-variable again each time you start Emacs. To save the option, invoke
-`[State]' and select the `Save for Future Sessions' operation.
-
- You can also restore the option to its standard value by invoking
-`[State]' and selecting the `Reset' operation. There are actually
-three reset operations:
-
-`Reset to Current'
- If you have made some modifications and not yet set the option,
- this restores the text in the customization buffer to match the
- actual value.
-
-`Reset to Saved'
- This restores the value of the option to the last saved value, and
- updates the text accordingly.
-
-`Reset to Standard Settings'
- This sets the option to its standard value, and updates the text
- accordingly. This also eliminates any saved value for the option,
- so that you will get the standard value in future Emacs sessions.
-
- The state of a group indicates whether anything in that group has
-been edited, set or saved. You can select `Set for Current Session',
-`Save for Future Sessions' and the various kinds of `Reset' operation
-for the group; these operations on the group apply to all options in
-the group and its subgroups.
-
- Near the top of the customization buffer there are two lines
-containing several active fields:
-
- [Set] [Save] [Reset] [Done]
-
-Invoking `[Done]' buries this customization buffer. Each of the other
-fields performs an operation--set, save or reset--on each of the items
-in the buffer that could meaningfully be set, saved or reset.
+File: xemacs.info, Node: Holiday Customizing, Next: Date Display Format, Prev: Calendar Customizing, Up: Calendar Customization
+
+Customizing the Holidays
+........................
+
+ Emacs knows about holidays defined by entries on one of several
+lists. You can customize these lists of holidays to your own needs,
+adding or deleting holidays. The lists of holidays that Emacs uses are
+for general holidays (`general-holidays'), local holidays
+(`local-holidays'), Christian holidays (`christian-holidays'), Hebrew
+(Jewish) holidays (`hebrew-holidays'), Islamic (Moslem) holidays
+(`islamic-holidays'), and other holidays (`other-holidays').
+
+ The general holidays are, by default, holidays common throughout the
+United States. To eliminate these holidays, set `general-holidays' to
+`nil'.
+
+ There are no default local holidays (but sites may supply some). You
+can set the variable `local-holidays' to any list of holidays, as
+described below.
+
+ By default, Emacs does not include all the holidays of the religions
+that it knows, only those commonly found in secular calendars. For a
+more extensive collection of religious holidays, you can set any (or
+all) of the variables `all-christian-calendar-holidays',
+`all-hebrew-calendar-holidays', or `all-islamic-calendar-holidays' to
+`t'. If you want to eliminate the religious holidays, set any or all
+of the corresponding variables `christian-holidays', `hebrew-holidays',
+and `islamic-holidays' to `nil'.
+
+ You can set the variable `other-holidays' to any list of holidays.
+This list, normally empty, is intended for individual use.
+
+ Each of the lists (`general-holidays', `local-holidays',
+`christian-holidays', `hebrew-holidays', `islamic-holidays', and
+`other-holidays') is a list of "holiday forms", each holiday form
+describing a holiday (or sometimes a list of holidays).
+
+ Here is a table of the possible kinds of holiday form. Day numbers
+and month numbers count starting from 1, but "dayname" numbers count
+Sunday as 0. The element STRING is always the name of the holiday, as
+a string.
+
+`(holiday-fixed MONTH DAY STRING)'
+ A fixed date on the Gregorian calendar. MONTH and DAY are
+ numbers, STRING is the name of the holiday.
+
+`(holiday-float MONTH DAYNAME K STRING)'
+ The Kth DAYNAME in MONTH on the Gregorian calendar (DAYNAME=0 for
+ Sunday, and so on); negative K means count back from the end of
+ the month. STRING is the name of the holiday.
+
+`(holiday-hebrew MONTH DAY STRING)'
+ A fixed date on the Hebrew calendar. MONTH and DAY are numbers,
+ STRING is the name of the holiday.
+
+`(holiday-islamic MONTH DAY STRING)'
+ A fixed date on the Islamic calendar. MONTH and DAY are numbers,
+ STRING is the name of the holiday.
+
+`(holiday-julian MONTH DAY STRING)'
+ A fixed date on the Julian calendar. MONTH and DAY are numbers,
+ STRING is the name of the holiday.
+
+`(holiday-sexp SEXP STRING)'
+ A date calculated by the Lisp expression SEXP. The expression
+ should use the variable `year' to compute and return the date of a
+ holiday, or `nil' if the holiday doesn't happen this year. The
+ value of SEXP must represent the date as a list of the form
+ `(MONTH DAY YEAR)'. STRING is the name of the holiday.
+
+`(if CONDITION HOLIDAY-FORM &optional HOLIDAY-FORM)'
+ A holiday that happens only if CONDITION is true.
+
+`(FUNCTION [ARGS])'
+ A list of dates calculated by the function FUNCTION, called with
+ arguments ARGS.
+
+ For example, suppose you want to add Bastille Day, celebrated in
+France on July 14. You can do this by adding the following line to
+your init file:
+
+ (setq other-holidays '((holiday-fixed 7 14 "Bastille Day")))
+
+ *Note Init File::.
+
+The holiday form `(holiday-fixed 7 14 "Bastille Day")' specifies the
+fourteenth day of the seventh month (July).
+
+ Many holidays occur on a specific day of the week, at a specific time
+of month. Here is a holiday form describing Hurricane Supplication Day,
+celebrated in the Virgin Islands on the fourth Monday in August:
+
+ (holiday-float 8 1 4 "Hurricane Supplication Day")
+
+Here the 8 specifies August, the 1 specifies Monday (Sunday is 0,
+Tuesday is 2, and so on), and the 4 specifies the fourth occurrence in
+the month (1 specifies the first occurrence, 2 the second occurrence,
+-1 the last occurrence, -2 the second-to-last occurrence, and so on).
+
+ You can specify holidays that occur on fixed days of the Hebrew,
+Islamic, and Julian calendars too. For example,
+
+ (setq other-holidays
+ '((holiday-hebrew 10 2 "Last day of Hanukkah")
+ (holiday-islamic 3 12 "Mohammed's Birthday")
+ (holiday-julian 4 2 "Jefferson's Birthday")))
+
+adds the last day of Hanukkah (since the Hebrew months are numbered with
+1 starting from Nisan), the Islamic feast celebrating Mohammed's
+birthday (since the Islamic months are numbered from 1 starting with
+Muharram), and Thomas Jefferson's birthday, which is 2 April 1743 on the
+Julian calendar.
+
+ To include a holiday conditionally, use either Emacs Lisp's `if' or
+the `holiday-sexp' form. For example, American presidential elections
+occur on the first Tuesday after the first Monday in November of years
+divisible by 4:
+
+ (holiday-sexp (if (= 0 (% year 4))
+ (calendar-gregorian-from-absolute
+ (1+ (calendar-dayname-on-or-before
+ 1 (+ 6 (calendar-absolute-from-gregorian
+ (list 11 1 year))))))
+ "US Presidential Election"))
+
+or
+
+ (if (= 0 (% displayed-year 4))
+ (fixed 11
+ (extract-calendar-day
+ (calendar-gregorian-from-absolute
+ (1+ (calendar-dayname-on-or-before
+ 1 (+ 6 (calendar-absolute-from-gregorian
+ (list 11 1 displayed-year)))))))
+ "US Presidential Election"))
+
+ Some holidays just don't fit into any of these forms because special
+calculations are involved in their determination. In such cases you
+must write a Lisp function to do the calculation. To include eclipses,
+for example, add `(eclipses)' to `other-holidays' and write an Emacs
+Lisp function `eclipses' that returns a (possibly empty) list of the
+relevant Gregorian dates among the range visible in the calendar
+window, with descriptive strings, like this:
+
+ (((6 27 1991) "Lunar Eclipse") ((7 11 1991) "Solar Eclipse") ... )
\1f
-File: xemacs.info, Node: Face Customization, Next: Specific Customization, Prev: Changing an Option, Up: Easy Customization
-
-Customizing Faces
-.................
-
- In addition to user options, some customization groups also include
-faces. When you show the contents of a group, both the user options and
-the faces in the group appear in the customization buffer. Here is an
-example of how a face looks:
-
- Custom Changed Face: (sample)
- [State]: this face is unchanged from its standard setting.
- Face used when the customize item has been changed.
- Parent groups: [Custom Magic Faces]
- Attributes: [ ] Bold: [Toggle] off (nil)
- [ ] Italic: [Toggle] off (nil)
- [ ] Underline: [Toggle] off (nil)
- [ ] Foreground: white (sample)
- [ ] Background: blue (sample)
- [ ] Inverse: [Toggle] off (nil)
- [ ] Stipple:
- [ ] Font Family:
- [ ] Size:
- [ ] Strikethru: off
-
- Each face attribute has its own line. The `[X]' field before the
-attribute name indicates whether the attribute is "enabled"; `X' means
-that it is. You can enable or disable the attribute by invoking that
-field. When the attribute is enabled, you can change the attribute
-value in the usual ways.
-
- Setting, saving and resetting a face work like the same operations
-for options (*note Changing an Option::.).
-
- A face can specify different appearances for different types of
-display. For example, a face can make text red on a color display, but
-use a bold font on a monochrome display. To specify multiple
-appearances for a face, select `Show Display Types' in the menu you get
-from invoking `[State]'.
+File: xemacs.info, Node: Date Display Format, Next: Time Display Format, Prev: Holiday Customizing, Up: Calendar Customization
-\1f
-File: xemacs.info, Node: Specific Customization, Prev: Face Customization, Up: Easy Customization
+Date Display Format
+...................
-Customizing Specific Items
-..........................
+ You can customize the manner of displaying dates in the diary, in
+mode lines, and in messages by setting `calendar-date-display-form'.
+This variable holds a list of expressions that can involve the variables
+`month', `day', and `year', which are all numbers in string form, and
+`monthname' and `dayname', which are both alphabetic strings. In the
+American style, the default value of this list is as follows:
- Instead of finding the options you want to change by moving down
-through the structure of groups, you can specify the particular option,
-face or group that you want to customize.
+ ((if dayname (concat dayname ", ")) monthname " " day ", " year)
-`M-x customize-option <RET> OPTION <RET>'
- Set up a customization buffer with just one option, OPTION.
+while in the European style this value is the default:
-`M-x customize-face <RET> FACE <RET>'
- Set up a customization buffer with just one face, FACE.
+ ((if dayname (concat dayname ", ")) day " " monthname " " year)
-`M-x customize-group <RET> GROUP <RET>'
- Set up a customization buffer with just one group, GROUP.
+ + The ISO standard date representation is this:
-`M-x customize-apropos <RET> REGEXP <RET>'
- Set up a customization buffer with all the options, faces and
- groups that match REGEXP.
+ (year "-" month "-" day)
-`M-x customize-saved'
- Set up a customization buffer containing all options and faces
- that you have saved with customization buffers.
+This specifies a typical American format:
-`M-x customize-customized'
- Set up a customization buffer containing all options and faces
- that you have customized but not saved.
+ (month "/" day "/" (substring year -2))
- If you want to alter a particular user option variable with the
-customization buffer, and you know its name, you can use the command
-`M-x customize-option' and specify the option name. This sets up the
-customization buffer with just one option--the one that you asked for.
-Editing, setting and saving the value work as described above, but only
-for the specified option.
+\1f
+File: xemacs.info, Node: Time Display Format, Next: Daylight Savings, Prev: Date Display Format, Up: Calendar Customization
- Likewise, you can modify a specific face, chosen by name, using `M-x
-customize-face'.
+Time Display Format
+...................
- You can also set up the customization buffer with a specific group,
-using `M-x customize-group'. The immediate contents of the chosen
-group, including option variables, faces, and other groups, all appear
-as well. However, these subgroups' own contents start out hidden. You
-can show their contents in the usual way, by invoking `[Show]'.
+ The calendar and diary by default display times of day in the
+conventional American style with the hours from 1 through 12, minutes,
+and either `am' or `pm'. If you prefer the European style, also known
+in the US as military, in which the hours go from 00 to 23, you can
+alter the variable `calendar-time-display-form'. This variable is a
+list of expressions that can involve the variables `12-hours',
+`24-hours', and `minutes', which are all numbers in string form, and
+`am-pm' and `time-zone', which are both alphabetic strings. The
+default value of `calendar-time-display-form' is as follows:
- To control more precisely what to customize, you can use `M-x
-customize-apropos'. You specify a regular expression as argument; then
-all options, faces and groups whose names match this regular expression
-are set up in the customization buffer. If you specify an empty regular
-expression, this includes *all* groups, options and faces in the
-customization buffer (but that takes a long time).
+ (12-hours ":" minutes am-pm
+ (if time-zone " (") time-zone (if time-zone ")"))
- If you change option values and then decide the change was a mistake,
-you can use two special commands to revisit your previous changes. Use
-`customize-saved' to look at the options and faces that you have saved.
-Use `M-x customize-customized' to look at the options and faces that
-you have set but not saved.
+Here is a value that provides European style times:
-\1f
-File: xemacs.info, Node: Edit Options, Next: Locals, Prev: Easy Customization, Up: Variables
-
-Editing Variable Values
------------------------
-
-`M-x list-options'
- Display a buffer listing names, values, and documentation of all
- options.
-
-`M-x edit-options'
- Change option values by editing a list of options.
-
- `M-x list-options' displays a list of all Emacs option variables in
-an Emacs buffer named `*List Options*'. Each option is shown with its
-documentation and its current value. Here is what a portion of it might
-look like:
-
- ;; exec-path:
- ("." "/usr/local/bin" "/usr/ucb" "/bin" "/usr/bin" "/u2/emacs/etc")
- *List of directories to search programs to run in subprocesses.
- Each element is a string (directory name)
- or nil (try the default directory).
- ;;
- ;; fill-column:
- 75
- *Column beyond which automatic line-wrapping should happen.
- Automatically becomes local when set in any fashion.
- ;;
-
- `M-x edit-options' goes one step further and immediately selects the
-`*List Options*' buffer; this buffer uses the major mode Options mode,
-which provides commands that allow you to point at an option and change
-its value:
-
-`s'
- Set the variable point is in or near to a new value read using the
- minibuffer.
-
-`x'
- Toggle the variable point is in or near: if the value was `nil',
- it becomes `t'; otherwise it becomes `nil'.
-
-`1'
- Set the variable point is in or near to `t'.
-
-`0'
- Set the variable point is in or near to `nil'.
-
-`n'
-`p'
- Move to the next or previous variable.
+ (24-hours ":" minutes
+ (if time-zone " (") time-zone (if time-zone ")"))
-\1f
-File: xemacs.info, Node: Locals, Next: File Variables, Prev: Edit Options, Up: Variables
-
-Local Variables
----------------
-
-`M-x make-local-variable'
- Make a variable have a local value in the current buffer.
-
-`M-x kill-local-variable'
- Make a variable use its global value in the current buffer.
-
-`M-x make-variable-buffer-local'
- Mark a variable so that setting it will make it local to the
- buffer that is current at that time.
-
- You can make any variable "local" to a specific Emacs buffer. This
-means that the variable's value in that buffer is independent of its
-value in other buffers. A few variables are always local in every
-buffer. All other Emacs variables have a "global" value which is in
-effect in all buffers that have not made the variable local.
-
- Major modes always make the variables they set local to the buffer.
-This is why changing major modes in one buffer has no effect on other
-buffers.
-
- `M-x make-local-variable' reads the name of a variable and makes it
-local to the current buffer. Further changes in this buffer will not
-affect others, and changes in the global value will not affect this
-buffer.
-
- `M-x make-variable-buffer-local' reads the name of a variable and
-changes the future behavior of the variable so that it automatically
-becomes local when it is set. More precisely, once you have marked a
-variable in this way, the usual ways of setting the variable will
-automatically invoke `make-local-variable' first. We call such
-variables "per-buffer" variables.
-
- Some important variables have been marked per-buffer already. They
-include `abbrev-mode', `auto-fill-function', `case-fold-search',
-`comment-column', `ctl-arrow', `fill-column', `fill-prefix',
-`indent-tabs-mode', `left-margin',
-`mode-line-format', `overwrite-mode', `selective-display-ellipses',
-`selective-display', `tab-width', and `truncate-lines'. Some other
-variables are always local in every buffer, but they are used for
-internal purposes.
-
- Note: the variable `auto-fill-function' was formerly named
-`auto-fill-hook'.
-
- If you want a variable to cease to be local to the current buffer,
-call `M-x kill-local-variable' and provide the name of a variable to
-the prompt. The global value of the variable is again in effect in
-this buffer. Setting the major mode kills all the local variables of
-the buffer.
-
- To set the global value of a variable, regardless of whether the
-variable has a local value in the current buffer, you can use the Lisp
-function `setq-default'. It works like `setq'. If there is a local
-value in the current buffer, the local value is not affected by
-`setq-default'; thus, the new global value may not be visible until you
-switch to another buffer, as in the case of:
-
- (setq-default fill-column 75)
-
-`setq-default' is the only way to set the global value of a variable
-that has been marked with `make-variable-buffer-local'.
-
- Programs can look at a variable's default value with `default-value'.
-This function takes a symbol as an argument and returns its default
-value. The argument is evaluated; usually you must quote it
-explicitly, as in the case of:
-
- (default-value 'fill-column)
+gives military-style times like `21:07 (UT)' if time zone names are
+defined, and times like `21:07' if they are not.
\1f
-File: xemacs.info, Node: File Variables, Prev: Locals, Up: Variables
-
-Local Variables in Files
-------------------------
-
- A file can contain a "local variables list", which specifies the
-values to use for certain Emacs variables when that file is edited.
-Visiting the file checks for a local variables list and makes each
-variable in the list local to the buffer in which the file is visited,
-with the value specified in the file.
-
- A local variables list goes near the end of the file, in the last
-page. (It is often best to put it on a page by itself.) The local
-variables list starts with a line containing the string `Local
-Variables:', and ends with a line containing the string `End:'. In
-between come the variable names and values, one set per line, as
-`VARIABLE: VALUE'. The VALUEs are not evaluated; they are used
-literally.
-
- The line which starts the local variables list does not have to say
-just `Local Variables:'. If there is other text before `Local
-Variables:', that text is called the "prefix", and if there is other
-text after, that is called the "suffix". If a prefix or suffix are
-present, each entry in the local variables list should have the prefix
-before it and the suffix after it. This includes the `End:' line. The
-prefix and suffix are included to disguise the local variables list as
-a comment so the compiler or text formatter will ignore it. If you do
-not need to disguise the local variables list as a comment in this way,
-there is no need to include a prefix or a suffix.
-
- Two "variable" names are special in a local variables list: a value
-for the variable `mode' sets the major mode, and a value for the
-variable `eval' is simply evaluated as an expression and the value is
-ignored. These are not real variables; setting them in any other
-context does not have the same effect. If `mode' is used in a local
-variables list, it should be the first entry in the list.
-
- Here is an example of a local variables list:
- ;;; Local Variables: ***
- ;;; mode:lisp ***
- ;;; comment-column:0 ***
- ;;; comment-start: ";;; " ***
- ;;; comment-end:"***" ***
- ;;; End: ***
-
- Note that the prefix is `;;; ' and the suffix is ` ***'. Note also
-that comments in the file begin with and end with the same strings.
-Presumably the file contains code in a language which is enough like
-Lisp for Lisp mode to be useful but in which comments start and end
-differently. The prefix and suffix are used in the local variables
-list to make the list look like several lines of comments when the
-compiler or interpreter for that language reads the file.
-
- The start of the local variables list must be no more than 3000
-characters from the end of the file, and must be in the last page if the
-file is divided into pages. Otherwise, Emacs will not notice it is
-there. The purpose is twofold: a stray `Local Variables:' not in the
-last page does not confuse Emacs, and Emacs never needs to search a
-long file that contains no page markers and has no local variables list.
-
- You may be tempted to turn on Auto Fill mode with a local variable
-list. That is inappropriate. Whether you use Auto Fill mode or not is
-a matter of personal taste, not a matter of the contents of particular
-files. If you want to use Auto Fill, set up major mode hooks with your
-`.emacs' file to turn it on (when appropriate) for you alone (*note
-Init File::.). Don't try to use a local variable list that would
-impose your taste on everyone working with the file.
-
- XEmacs allows you to specify local variables in the first line of a
-file, in addition to specifying them in the `Local Variables' section
-at the end of a file.
-
- If the first line of a file contains two occurrences of ``-*-'',
-XEmacs uses the information between them to determine what the major
-mode and variable settings should be. For example, these are all legal:
-
- ;;; -*- mode: emacs-lisp -*-
- ;;; -*- mode: postscript; version-control: never -*-
- ;;; -*- tags-file-name: "/foo/bar/TAGS" -*-
-
- For historical reasons, the syntax ``-*- modename -*-'' is allowed
-as well; for example, you can use:
-
- ;;; -*- emacs-lisp -*-
-
- The variable `enable-local-variables' controls the use of local
-variables lists in files you visit. The value can be `t', `nil', or
-something else. A value of `t' means local variables lists are obeyed;
-`nil' means they are ignored; anything else means query.
-
- The command `M-x normal-mode' always obeys local variables lists and
-ignores this variable.
+File: xemacs.info, Node: Daylight Savings, Next: Diary Customizing, Prev: Time Display Format, Up: Calendar Customization
+
+Daylight Savings Time
+.....................
+
+ Emacs understands the difference between standard time and daylight
+savings time--the times given for sunrise, sunset, solstices,
+equinoxes, and the phases of the moon take that into account. The rules
+for daylight savings time vary from place to place and have also varied
+historically from year to year. To do the job properly, Emacs needs to
+know which rules to use.
+
+ Some operating systems keep track of the rules that apply to the
+place where you are; on these systems, Emacs gets the information it
+needs from the system automatically. If some or all of this
+information is missing, Emacs fills in the gaps with the rules
+currently used in Cambridge, Massachusetts. If the resulting rules are
+not what you want, you can tell Emacs the rules to use by setting
+certain variables.
+
+ If the default choice of rules is not appropriate for your location,
+you can tell Emacs the rules to use by setting the variables
+`calendar-daylight-savings-starts' and
+`calendar-daylight-savings-ends'. Their values should be Lisp
+expressions that refer to the variable `year', and evaluate to the
+Gregorian date on which daylight savings time starts or (respectively)
+ends, in the form of a list `(MONTH DAY YEAR)'. The values should be
+`nil' if your area does not use daylight savings time.
+
+ Emacs uses these expressions to determine the starting date of
+daylight savings time for the holiday list and for correcting times of
+day in the solar and lunar calculations.
+
+ The values for Cambridge, Massachusetts are as follows:
+
+ (calendar-nth-named-day 1 0 4 year)
+ (calendar-nth-named-day -1 0 10 year)
+
+That is, the first 0th day (Sunday) of the fourth month (April) in the
+year specified by `year', and the last Sunday of the tenth month
+(October) of that year. If daylight savings time were changed to start
+on October 1, you would set `calendar-daylight-savings-starts' to this:
+
+ (list 10 1 year)
+
+ For a more complex example, suppose daylight savings time begins on
+the first of Nisan on the Hebrew calendar. You should set
+`calendar-daylight-savings-starts' to this value:
+
+ (calendar-gregorian-from-absolute
+ (calendar-absolute-from-hebrew
+ (list 1 1 (+ year 3760))))
+
+because Nisan is the first month in the Hebrew calendar and the Hebrew
+year differs from the Gregorian year by 3760 at Nisan.
+
+ If there is no daylight savings time at your location, or if you want
+all times in standard time, set `calendar-daylight-savings-starts' and
+`calendar-daylight-savings-ends' to `nil'.
+
+ The variable `calendar-daylight-time-offset' specifies the
+difference between daylight savings time and standard time, measured in
+minutes. The value for Cambridge, Massachusetts is 60.
+
+ The two variables `calendar-daylight-savings-starts-time' and
+`calendar-daylight-savings-ends-time' specify the number of minutes
+after midnight local time when the transition to and from daylight
+savings time should occur. For Cambridge, Massachusetts both variables'
+values are 120.
\1f
-File: xemacs.info, Node: Keyboard Macros, Next: Key Bindings, Prev: Variables, Up: Customization
+File: xemacs.info, Node: Diary Customizing, Next: Hebrew/Islamic Entries, Prev: Daylight Savings, Up: Calendar Customization
+
+Customizing the Diary
+.....................
+
+ Ordinarily, the mode line of the diary buffer window indicates any
+holidays that fall on the date of the diary entries. The process of
+checking for holidays can take several seconds, so including holiday
+information delays the display of the diary buffer noticeably. If you'd
+prefer to have a faster display of the diary buffer but without the
+holiday information, set the variable `holidays-in-diary-buffer' to
+`nil'.
+
+ The variable `number-of-diary-entries' controls the number of days
+of diary entries to be displayed at one time. It affects the initial
+display when `view-diary-entries-initially' is `t', as well as the
+command `M-x diary'. For example, the default value is 1, which says
+to display only the current day's diary entries. If the value is 2,
+both the current day's and the next day's entries are displayed. The
+value can also be a vector of seven elements: for example, if the value
+is `[0 2 2 2 2 4 1]' then no diary entries appear on Sunday, the
+current date's and the next day's diary entries appear Monday through
+Thursday, Friday through Monday's entries appear on Friday, while on
+Saturday only that day's entries appear.
+
+ The variable `print-diary-entries-hook' is a normal hook run after
+preparation of a temporary buffer containing just the diary entries
+currently visible in the diary buffer. (The other, irrelevant diary
+entries are really absent from the temporary buffer; in the diary
+buffer, they are merely hidden.) The default value of this hook does
+the printing with the command `lpr-buffer'. If you want to use a
+different command to do the printing, just change the value of this
+hook. Other uses might include, for example, rearranging the lines into
+order by day and time.
+
+ You can customize the form of dates in your diary file, if neither
+the standard American nor European styles suits your needs, by setting
+the variable `diary-date-forms'. This variable is a list of patterns
+for recognizing a date. Each date pattern is a list whose elements may
+be regular expressions (*note Regexps::) or the symbols `month', `day',
+`year', `monthname', and `dayname'. All these elements serve as
+patterns that match certain kinds of text in the diary file. In order
+for the date pattern, as a whole, to match, all of its elements must
+match consecutively.
+
+ A regular expression in a date pattern matches in its usual fashion,
+using the standard syntax table altered so that `*' is a word
+constituent.
+
+ The symbols `month', `day', `year', `monthname', and `dayname' match
+the month number, day number, year number, month name, and day name of
+the date being considered. The symbols that match numbers allow
+leading zeros; those that match names allow three-letter abbreviations
+and capitalization. All the symbols can match `*'; since `*' in a
+diary entry means "any day", "any month", and so on, it should match
+regardless of the date being considered.
+
+ The default value of `diary-date-forms' in the American style is
+this:
+
+ ((month "/" day "[^/0-9]")
+ (month "/" day "/" year "[^0-9]")
+ (monthname " *" day "[^,0-9]")
+ (monthname " *" day ", *" year "[^0-9]")
+ (dayname "\\W"))
+
+Emacs matches of the diary entries with the date forms is done with the
+standard syntax table from Fundamental mode (*note Syntax Tables:
+(lispref)Syntax Tables.), but with the `*' changed so that it is a word
+constituent.
+
+ The date patterns in the list must be _mutually exclusive_ and must
+not match any portion of the diary entry itself, just the date and one
+character of whitespace. If, to be mutually exclusive, the pattern
+must match a portion of the diary entry text--beyond the whitespace
+that ends the date--then the first element of the date pattern _must_
+be `backup'. This causes the date recognizer to back up to the
+beginning of the current word of the diary entry, after finishing the
+match. Even if you use `backup', the date pattern must absolutely not
+match more than a portion of the first word of the diary entry. The
+default value of `diary-date-forms' in the European style is this list:
+
+ ((day "/" month "[^/0-9]")
+ (day "/" month "/" year "[^0-9]")
+ (backup day " *" monthname "\\W+\\<[^*0-9]")
+ (day " *" monthname " *" year "[^0-9]")
+ (dayname "\\W"))
+
+Notice the use of `backup' in the third pattern, because it needs to
+match part of a word beyond the date itself to distinguish it from the
+fourth pattern.
-Keyboard Macros
-===============
+\1f
+File: xemacs.info, Node: Hebrew/Islamic Entries, Next: Fancy Diary Display, Prev: Diary Customizing, Up: Calendar Customization
- A "keyboard macro" is a command defined by the user to abbreviate a
-sequence of keys. For example, if you discover that you are about to
-type `C-n C-d' forty times, you can speed your work by defining a
-keyboard macro to invoke `C-n C-d' and calling it with a repeat count
-of forty.
+Hebrew- and Islamic-Date Diary Entries
+......................................
-`C-x ('
- Start defining a keyboard macro (`start-kbd-macro').
+ Your diary file can have entries based on Hebrew or Islamic dates, as
+well as entries based on the world-standard Gregorian calendar.
+However, because recognition of such entries is time-consuming and most
+people don't use them, you must explicitly enable their use. If you
+want the diary to recognize Hebrew-date diary entries, for example, you
+must do this:
-`C-x )'
- End the definition of a keyboard macro (`end-kbd-macro').
+ (add-hook 'nongregorian-diary-listing-hook 'list-hebrew-diary-entries)
+ (add-hook 'nongregorian-diary-marking-hook 'mark-hebrew-diary-entries)
-`C-x e'
- Execute the most recent keyboard macro (`call-last-kbd-macro').
+If you want Islamic-date entries, do this:
-`C-u C-x ('
- Re-execute last keyboard macro, then add more keys to its
- definition.
+ (add-hook 'nongregorian-diary-listing-hook 'list-islamic-diary-entries)
+ (add-hook 'nongregorian-diary-marking-hook 'mark-islamic-diary-entries)
-`C-x q'
- When this point is reached during macro execution, ask for
- confirmation (`kbd-macro-query').
+ Hebrew- and Islamic-date diary entries have the same formats as
+Gregorian-date diary entries, except that `H' precedes a Hebrew date
+and `I' precedes an Islamic date. Moreover, because the Hebrew and
+Islamic month names are not uniquely specified by the first three
+letters, you may not abbreviate them. For example, a diary entry for
+the Hebrew date Heshvan 25 could look like this:
-`M-x name-last-kbd-macro'
- Give a command name (for the duration of the session) to the most
- recently defined keyboard macro.
+ HHeshvan 25 Happy Hebrew birthday!
-`M-x insert-kbd-macro'
- Insert in the buffer a keyboard macro's definition, as Lisp code.
+and would appear in the diary for any date that corresponds to Heshvan
+25 on the Hebrew calendar. And here is Islamic-date diary entry that
+matches Dhu al-Qada 25:
- Keyboard macros differ from other Emacs commands in that they are
-written in the Emacs command language rather than in Lisp. This makes
-it easier for the novice to write them and makes them more convenient as
-temporary hacks. However, the Emacs command language is not powerful
-enough as a programming language to be useful for writing anything
-general or complex. For such things, Lisp must be used.
+ IDhu al-Qada 25 Happy Islamic birthday!
- You define a keyboard macro by executing the commands which are its
-definition. Put differently, as you are defining a keyboard macro, the
-definition is being executed for the first time. This way, you see
-what the effects of your commands are, and don't have to figure them
-out in your head. When you are finished, the keyboard macro is defined
-and also has been executed once. You can then execute the same set of
-commands again by invoking the macro.
+and would appear in the diary for any date that corresponds to Dhu
+al-Qada 25 on the Islamic calendar.
-* Menu:
+ As with Gregorian-date diary entries, Hebrew- and Islamic-date
+entries are nonmarking if they are preceded with an ampersand (`&').
-* Basic Kbd Macro:: Defining and running keyboard macros.
-* Save Kbd Macro:: Giving keyboard macros names; saving them in files.
-* Kbd Macro Query:: Keyboard macros that do different things each use.
+ Here is a table of commands used in the calendar to create diary
+entries that match the selected date and other dates that are similar
+in the Hebrew or Islamic calendar:
-\1f
-File: xemacs.info, Node: Basic Kbd Macro, Next: Save Kbd Macro, Up: Keyboard Macros
+`i h d'
+ Add a diary entry for the Hebrew date corresponding to the
+ selected date (`insert-hebrew-diary-entry').
-Basic Use
----------
+`i h m'
+ Add a diary entry for the day of the Hebrew month corresponding to
+ the selected date (`insert-monthly-hebrew-diary-entry'). This
+ diary entry matches any date that has the same Hebrew
+ day-within-month as the selected date.
- To start defining a keyboard macro, type `C-x ('
-(`start-kbd-macro'). From then on, anything you type continues to be
-executed, but also becomes part of the definition of the macro. `Def'
-appears in the mode line to remind you of what is going on. When you
-are finished, the `C-x )' command (`end-kbd-macro') terminates the
-definition, without becoming part of it.
+`i h y'
+ Add a diary entry for the day of the Hebrew year corresponding to
+ the selected date (`insert-yearly-hebrew-diary-entry'). This diary
+ entry matches any date which has the same Hebrew month and
+ day-within-month as the selected date.
- For example,
+`i i d'
+ Add a diary entry for the Islamic date corresponding to the
+ selected date (`insert-islamic-diary-entry').
- C-x ( M-f foo C-x )
+`i i m'
+ Add a diary entry for the day of the Islamic month corresponding
+ to the selected date (`insert-monthly-islamic-diary-entry').
-defines a macro to move forward a word and then insert `foo'.
+`i i y'
+ Add a diary entry for the day of the Islamic year corresponding to
+ the selected date (`insert-yearly-islamic-diary-entry').
- You can give `C-x )' a repeat count as an argument, in which case it
-repeats the macro that many times right after defining it, but defining
-the macro counts as the first repetition (since it is executed as you
-define it). If you give `C-x )' an argument of 4, it executes the
-macro immediately 3 additional times. An argument of zero to `C-x e'
-or `C-x )' means repeat the macro indefinitely (until it gets an error
-or you type `C-g').
+ These commands work much like the corresponding commands for ordinary
+diary entries: they apply to the date that point is on in the calendar
+window, and what they do is insert just the date portion of a diary
+entry at the end of your diary file. You must then insert the rest of
+the diary entry.
- Once you have defined a macro, you can invoke it again with the `C-x
-e' command (`call-last-kbd-macro'). You can give the command a repeat
-count numeric argument to execute the macro many times.
+\1f
+File: xemacs.info, Node: Fancy Diary Display, Next: Included Diary Files, Prev: Hebrew/Islamic Entries, Up: Calendar Customization
- To repeat an operation at regularly spaced places in the text,
-define a macro and include as part of the macro the commands to move to
-the next place you want to use it. For example, if you want to change
-each line, you should position point at the start of a line, and define
-a macro to change that line and leave point at the start of the next
-line. Repeating the macro will then operate on successive lines.
+Fancy Diary Display
+...................
- After you have terminated the definition of a keyboard macro, you
-can add to the end of its definition by typing `C-u C-x ('. This is
-equivalent to plain `C-x (' followed by retyping the whole definition
-so far. As a consequence it re-executes the macro as previously
-defined.
+ Diary display works by preparing the diary buffer and then running
+the hook `diary-display-hook'. The default value of this hook
+(`simple-diary-display') hides the irrelevant diary entries and then
+displays the buffer. However, if you specify the hook as follows,
-\1f
-File: xemacs.info, Node: Save Kbd Macro, Next: Kbd Macro Query, Prev: Basic Kbd Macro, Up: Keyboard Macros
-
-Naming and Saving Keyboard Macros
----------------------------------
-
- To save a keyboard macro for longer than until you define the next
-one, you must give it a name using `M-x name-last-kbd-macro'. This
-reads a name as an argument using the minibuffer and defines that name
-to execute the macro. The macro name is a Lisp symbol, and defining it
-in this way makes it a valid command name for calling with `M-x' or for
-binding a key to with `global-set-key' (*note Keymaps::.). If you
-specify a name that has a prior definition other than another keyboard
-macro, Emacs prints an error message and nothing is changed.
-
- Once a macro has a command name, you can save its definition in a
-file. You can then use it in another editing session. First visit the
-file you want to save the definition in. Then use the command:
-
- M-x insert-kbd-macro <RET> MACRONAME <RET>
-
-This inserts some Lisp code that, when executed later, will define the
-same macro with the same definition it has now. You need not
-understand Lisp code to do this, because `insert-kbd-macro' writes the
-Lisp code for you. Then save the file. You can load the file with
-`load-file' (*note Lisp Libraries::.). If the file you save in is your
-initialization file `~/.emacs' (*note Init File::.), then the macro
-will be defined each time you run Emacs.
-
- If you give `insert-kbd-macro' a prefix argument, it creates
-additional Lisp code to record the keys (if any) that you have bound to
-the keyboard macro, so that the macro is reassigned the same keys when
-you load the file.
+ (add-hook 'diary-display-hook 'fancy-diary-display)
-\1f
-File: xemacs.info, Node: Kbd Macro Query, Prev: Save Kbd Macro, Up: Keyboard Macros
-
-Executing Macros With Variations
---------------------------------
-
- You can use `C-x q' (`kbd-macro-query'), to get an effect similar to
-that of `query-replace'. The macro asks you each time whether to make
-a change. When you are defining the macro, type `C-x q' at the point
-where you want the query to occur. During macro definition, the `C-x
-q' does nothing, but when you invoke the macro, `C-x q' reads a
-character from the terminal to decide whether to continue.
-
- The special answers to a `C-x q' query are <SPC>, <DEL>, `C-d',
-`C-l', and `C-r'. Any other character terminates execution of the
-keyboard macro and is then read as a command. <SPC> means to continue.
-<DEL> means to skip the remainder of this repetition of the macro,
-starting again from the beginning in the next repetition. `C-d' means
-to skip the remainder of this repetition and cancel further repetition.
-`C-l' redraws the frame and asks you again for a character to specify
-what to do. `C-r' enters a recursive editing level, in which you can
-perform editing that is not part of the macro. When you exit the
-recursive edit using `C-M-c', you are asked again how to continue with
-the keyboard macro. If you type a <SPC> at this time, the rest of the
-macro definition is executed. It is up to you to leave point and the
-text in a state such that the rest of the macro will do what you want.
-
- `C-u C-x q', which is `C-x q' with a numeric argument, performs a
-different function. It enters a recursive edit reading input from the
-keyboard, both when you type it during the definition of the macro and
-when it is executed from the macro. During definition, the editing you
-do inside the recursive edit does not become part of the macro. During
-macro execution, the recursive edit gives you a chance to do some
-particularized editing. *Note Recursive Edit::.
+this enables fancy diary display. It displays diary entries and
+holidays by copying them into a special buffer that exists only for the
+sake of display. Copying to a separate buffer provides an opportunity
+to change the displayed text to make it prettier--for example, to sort
+the entries by the dates they apply to.
-\1f
-File: xemacs.info, Node: Key Bindings, Next: Syntax, Prev: Keyboard Macros, Up: Customization
+ As with simple diary display, you can print a hard copy of the buffer
+with `print-diary-entries'. To print a hard copy of a day-by-day diary
+for a week by positioning point on Sunday of that week, type `7 d' and
+then do `M-x print-diary-entries'. As usual, the inclusion of the
+holidays slows down the display slightly; you can speed things up by
+setting the variable `holidays-in-diary-buffer' to `nil'.
-Customizing Key Bindings
-========================
+ Ordinarily, the fancy diary buffer does not show days for which
+there are no diary entries, even if that day is a holiday. If you want
+such days to be shown in the fancy diary buffer, set the variable
+`diary-list-include-blanks' to `t'.
- This section deals with the "keymaps" that define the bindings
-between keys and functions, and shows how you can customize these
-bindings.
+ If you use the fancy diary display, you can use the normal hook
+`list-diary-entries-hook' to sort each day's diary entries by their
+time of day. Add this line to your init file:
- A command is a Lisp function whose definition provides for
-interactive use. Like every Lisp function, a command has a function
-name, which is a Lisp symbol whose name usually consists of lower case
-letters and hyphens.
+ (add-hook 'list-diary-entries-hook 'sort-diary-entries t)
-* Menu:
+ *Note Init File::.
-* Keymaps:: Definition of the keymap data structure.
- Names of Emacs's standard keymaps.
-* Rebinding:: How to redefine one key's meaning conveniently.
-* Disabling:: Disabling a command means confirmation is required
- before it can be executed. This is done to protect
- beginners from surprises.
+For each day, this sorts diary entries that begin with a recognizable
+time of day according to their times. Diary entries without times come
+first within each day.
\1f
-File: xemacs.info, Node: Keymaps, Next: Rebinding, Up: Key Bindings
+File: xemacs.info, Node: Included Diary Files, Next: Sexp Diary Entries, Prev: Fancy Diary Display, Up: Calendar Customization
-Keymaps
--------
+Included Diary Files
+....................
- The bindings between characters and command functions are recorded in
-data structures called "keymaps". Emacs has many of these. One, the
-"global" keymap, defines the meanings of the single-character keys that
-are defined regardless of major mode. It is the value of the variable
-`global-map'.
+ Fancy diary display also has the ability to process included diary
+files. This permits a group of people to share a diary file for events
+that apply to all of them. Lines in the diary file of this form:
- Each major mode has another keymap, its "local keymap", which
-contains overriding definitions for the single-character keys that are
-redefined in that mode. Each buffer records which local keymap is
-installed for it at any time, and the current buffer's local keymap is
-the only one that directly affects command execution. The local keymaps
-for Lisp mode, C mode, and many other major modes always exist even when
-not in use. They are the values of the variables `lisp-mode-map',
-`c-mode-map', and so on. For less frequently used major modes, the
-local keymap is sometimes constructed only when the mode is used for the
-first time in a session, to save space.
+ #include "FILENAME"
- There are local keymaps for the minibuffer, too; they contain various
-completion and exit commands.
+includes the diary entries from the file FILENAME in the fancy diary
+buffer. The include mechanism is recursive, so that included files can
+include other files, and so on; you must be careful not to have a cycle
+of inclusions, of course. Here is how to enable the include facility:
- * `minibuffer-local-map' is used for ordinary input (no completion).
+ (add-hook 'list-diary-entries-hook 'include-other-diary-files)
+ (add-hook 'mark-diary-entries-hook 'mark-included-diary-files)
- * `minibuffer-local-ns-map' is similar, except that <SPC> exits just
- like <RET>. This is used mainly for Mocklisp compatibility.
+ The include mechanism works only with the fancy diary display,
+because ordinary diary display shows the entries directly from your
+diary file.
- * `minibuffer-local-completion-map' is for permissive completion.
+\1f
+File: xemacs.info, Node: Sexp Diary Entries, Next: Appt Customizing, Prev: Included Diary Files, Up: Calendar Customization
- * `minibuffer-local-must-match-map' is for strict completion and for
- cautious completion.
+Sexp Entries and the Fancy Diary Display
+........................................
- * `repeat-complex-command-map' is for use in `C-x <ESC>'.
+ Sexp diary entries allow you to do more than just have complicated
+conditions under which a diary entry applies. If you use the fancy
+diary display, sexp entries can generate the text of the entry depending
+on the date itself. For example, an anniversary diary entry can insert
+the number of years since the anniversary date into the text of the
+diary entry. Thus the `%d' in this dairy entry:
- * `isearch-mode-map' contains the bindings of the special keys which
- are bound in the pseudo-mode entered with `C-s' and `C-r'.
+ %%(diary-anniversary 10 31 1948) Arthur's birthday (%d years old)
- Finally, each prefix key has a keymap which defines the key sequences
-that start with it. For example, `ctl-x-map' is the keymap used for
-characters following a `C-x'.
+gets replaced by the age, so on October 31, 1990 the entry appears in
+the fancy diary buffer like this:
- * `ctl-x-map' is the variable name for the map used for characters
- that follow `C-x'.
+ Arthur's birthday (42 years old)
- * `help-map' is used for characters that follow `C-h'.
+If the diary file instead contains this entry:
- * `esc-map' is for characters that follow <ESC>. All Meta characters
- are actually defined by this map.
+ %%(diary-anniversary 10 31 1948) Arthur's %d%s birthday
- * `ctl-x-4-map' is for characters that follow `C-x 4'.
+the entry in the fancy diary buffer for October 31, 1990 appears like
+this:
- * `mode-specific-map' is for characters that follow `C-c'.
+ Arthur's 42nd birthday
- The definition of a prefix key is the keymap to use for looking up
-the following character. Sometimes the definition is actually a Lisp
-symbol whose function definition is the following character keymap. The
-effect is the same, but it provides a command name for the prefix key
-that you can use as a description of what the prefix key is for. Thus
-the binding of `C-x' is the symbol `Ctl-X-Prefix', whose function
-definition is the keymap for `C-x' commands, the value of `ctl-x-map'.
+ Similarly, cyclic diary entries can interpolate the number of
+repetitions that have occurred:
- Prefix key definitions can appear in either the global map or a
-local map. The definitions of `C-c', `C-x', `C-h', and <ESC> as prefix
-keys appear in the global map, so these prefix keys are always
-available. Major modes can locally redefine a key as a prefix by
-putting a prefix key definition for it in the local map.
+ %%(diary-cyclic 50 1 1 1990) Renew medication (%d%s time)
- A mode can also put a prefix definition of a global prefix character
-such as `C-x' into its local map. This is how major modes override the
-definitions of certain keys that start with `C-x'. This case is
-special, because the local definition does not entirely replace the
-global one. When both the global and local definitions of a key are
-other keymaps, the next character is looked up in both keymaps, with
-the local definition overriding the global one. The character after the
-`C-x' is looked up in both the major mode's own keymap for redefined
-`C-x' commands and in `ctl-x-map'. If the major mode's own keymap for
-`C-x' commands contains `nil', the definition from the global keymap
-for `C-x' commands is used.
+looks like this:
-\1f
-File: xemacs.info, Node: Rebinding, Next: Disabling, Prev: Keymaps, Up: Key Bindings
+ Renew medication (5th time)
-Changing Key Bindings
----------------------
+in the fancy diary display on September 8, 1990.
- You can redefine an Emacs key by changing its entry in a keymap.
-You can change the global keymap, in which case the change is effective
-in all major modes except those that have their own overriding local
-definitions for the same key. Or you can change the current buffer's
-local map, which affects all buffers using the same major mode.
+ The generality of sexp diary entries lets you specify any diary entry
+that you can describe algorithmically. A sexp diary entry contains an
+expression that computes whether the entry applies to any given date.
+If its value is non-`nil', the entry applies to that date; otherwise,
+it does not. The expression can use the variable `date' to find the
+date being considered; its value is a list (MONTH DAY YEAR) that refers
+to the Gregorian calendar.
-* Menu:
+ Suppose you get paid on the 21st of the month if it is a weekday, and
+on the Friday before if the 21st is on a weekend. Here is how to write
+a sexp diary entry that matches those dates:
-* Interactive Rebinding:: Changing Key Bindings Interactively
-* Programmatic Rebinding:: Changing Key Bindings Programmatically
-* Key Bindings Using Strings::Using Strings for Changing Key Bindings
+ &%%(let ((dayname (calendar-day-of-week date))
+ (day (car (cdr date))))
+ (or (and (= day 21) (memq dayname '(1 2 3 4 5)))
+ (and (memq day '(19 20)) (= dayname 5)))
+ ) Pay check deposited
-\1f
-File: xemacs.info, Node: Interactive Rebinding, Next: Programmatic Rebinding, Up: Rebinding
+applies to just those dates. This example illustrates how the sexp can
+depend on the variable `date'; this variable is a list (MONTH DAY YEAR)
+that gives the Gregorian date for which the diary entries are being
+found. If the value of the expression is `t', the entry applies to
+that date. If the expression evaluates to `nil', the entry does _not_
+apply to that date.
-Changing Key Bindings Interactively
-...................................
+ The following sexp diary entries take advantage of the ability (in
+the fancy diary display) to concoct diary entries whose text varies
+based on the date:
-`M-x global-set-key <RET> KEY CMD <RET>'
- Defines KEY globally to run CMD.
+`%%(diary-sunrise-sunset)'
+ Make a diary entry for the local times of today's sunrise and
+ sunset.
-`M-x local-set-key <RET> KEYS CMD <RET>'
- Defines KEY locally (in the major mode now in effect) to run CMD.
+`%%(diary-phases-of-moon)'
+ Make a diary entry for the phases (quarters) of the moon.
-`M-x local-unset-key <RET> KEYS <RET>'
- Removes the local binding of KEY.
+`%%(diary-day-of-year)'
+ Make a diary entry with today's day number in the current year and
+ the number of days remaining in the current year.
- CMD is a symbol naming an interactively-callable function.
+`%%(diary-iso-date)'
+ Make a diary entry with today's equivalent ISO commercial date.
- When called interactively, KEY is the next complete key sequence
-that you type. When called as a function, KEY is a string, a vector of
-events, or a vector of key-description lists as described in the
-`define-key' function description. The binding goes in the current
-buffer's local map, which is shared with other buffers in the same
-major mode.
+`%%(diary-julian-date)'
+ Make a diary entry with today's equivalent date on the Julian
+ calendar.
- The following example:
+`%%(diary-astro-day-number)'
+ Make a diary entry with today's equivalent astronomical (Julian)
+ day number.
- M-x global-set-key <RET> C-f next-line <RET>
+`%%(diary-hebrew-date)'
+ Make a diary entry with today's equivalent date on the Hebrew
+ calendar.
-redefines `C-f' to move down a line. The fact that CMD is read second
-makes it serve as a kind of confirmation for KEY.
+`%%(diary-islamic-date)'
+ Make a diary entry with today's equivalent date on the Islamic
+ calendar.
- These functions offer no way to specify a particular prefix keymap as
-the one to redefine in, but that is not necessary, as you can include
-prefixes in KEY. KEY is read by reading characters one by one until
-they amount to a complete key (that is, not a prefix key). Thus, if
-you type `C-f' for KEY, Emacs enters the minibuffer immediately to read
-CMD. But if you type `C-x', another character is read; if that
-character is `4', another character is read, and so on. For example,
+`%%(diary-french-date)'
+ Make a diary entry with today's equivalent date on the French
+ Revolutionary calendar.
- M-x global-set-key <RET> C-x 4 $ spell-other-window <RET>
+`%%(diary-mayan-date)'
+ Make a diary entry with today's equivalent date on the Mayan
+ calendar.
-redefines `C-x 4 $' to run the (fictitious) command
-`spell-other-window'.
+Thus including the diary entry
- The most general way to modify a keymap is the function
-`define-key', used in Lisp code (such as your `.emacs' file).
-`define-key' takes three arguments: the keymap, the key to modify in
-it, and the new definition. *Note Init File::, for an example.
-`substitute-key-definition' is used similarly; it takes three
-arguments, an old definition, a new definition, and a keymap, and
-redefines in that keymap all keys that were previously defined with the
-old definition to have the new definition instead.
+ &%%(diary-hebrew-date)
-\1f
-File: xemacs.info, Node: Programmatic Rebinding, Next: Key Bindings Using Strings, Prev: Interactive Rebinding, Up: Rebinding
+causes every day's diary display to contain the equivalent date on the
+Hebrew calendar, if you are using the fancy diary display. (With simple
+diary display, the line `&%%(diary-hebrew-date)' appears in the diary
+for any date, but does nothing particularly useful.)
-Changing Key Bindings Programmatically
-......................................
+ These functions can be used to construct sexp diary entries based on
+the Hebrew calendar in certain standard ways:
- You can use the functions `global-set-key' and `define-key' to
-rebind keys under program control.
+`%%(diary-rosh-hodesh)'
+ Make a diary entry that tells the occurrence and ritual
+ announcement of each new Hebrew month.
-``(global-set-key KEYS CMD)''
- Defines KEYS globally to run CMD.
+`%%(diary-parasha)'
+ Make a Saturday diary entry that tells the weekly synagogue
+ scripture reading.
-``(define-key KEYMAP KEYS DEF)''
- Defines KEYS to run DEF in the keymap KEYMAP.
+`%%(diary-sabbath-candles)'
+ Make a Friday diary entry that tells the _local time_ of Sabbath
+ candle lighting.
- KEYMAP is a keymap object.
+`%%(diary-omer)'
+ Make a diary entry that gives the omer count, when appropriate.
- KEYS is the sequence of keystrokes to bind.
+`%%(diary-yahrzeit MONTH DAY YEAR) NAME'
+ Make a diary entry marking the anniversary of a date of death.
+ The date is the _Gregorian_ (civil) date of death. The diary
+ entry appears on the proper Hebrew calendar anniversary and on the
+ day before. (In the European style, the order of the parameters
+ is changed to DAY, MONTH, YEAR.)
- DEF is anything that can be a key's definition:
-
- * `nil', meaning key is undefined in this keymap
+\1f
+File: xemacs.info, Node: Appt Customizing, Prev: Sexp Diary Entries, Up: Calendar Customization
- * A command, that is, a Lisp function suitable for interactive
- calling
+Customizing Appointment Reminders
+.................................
- * A string or key sequence vector, which is treated as a keyboard
- macro
+ You can specify exactly how Emacs reminds you of an appointment, and
+how far in advance it begins doing so, by setting these variables:
- * A keymap to define a prefix key
+`appt-message-warning-time'
+ The time in minutes before an appointment that the reminder
+ begins. The default is 10 minutes.
- * A symbol so that when the key is looked up, the symbol stands for
- its function definition, which should at that time be one of the
- above, or another symbol whose function definition is used, and so
- on
+`appt-audible'
+ If this is `t' (the default), Emacs rings the terminal bell for
+ appointment reminders.
- * A cons, `(string . defn)', meaning that DEFN is the definition
- (DEFN should be a valid definition in its own right)
+`appt-visible'
+ If this is `t' (the default), Emacs displays the appointment
+ message in echo area.
- * A cons, `(keymap . char)', meaning use the definition of CHAR in
- map KEYMAP
+`appt-display-mode-line'
+ If this is `t' (the default), Emacs displays the number of minutes
+ to the appointment on the mode line.
- For backward compatibility, XEmacs allows you to specify key
-sequences as strings. However, the preferred method is to use the
-representations of key sequences as vectors of keystrokes. *Note
-Keystrokes::, for more information about the rules for constructing key
-sequences.
+`appt-msg-window'
+ If this is `t' (the default), Emacs displays the appointment
+ message in another window.
- Emacs allows you to abbreviate representations for key sequences in
-most places where there is no ambiguity. Here are some rules for
-abbreviation:
+`appt-display-duration'
+ The number of seconds an appointment message is displayed. The
+ default is 5 seconds.
- * The keysym by itself is equivalent to a list of just that keysym,
- i.e., `f1' is equivalent to `(f1)'.
+\1f
+File: xemacs.info, Node: Sorting, Next: Shell, Prev: Calendar/Diary, Up: Top
+
+Sorting Text
+============
+
+ XEmacs provides several commands for sorting text in a buffer. All
+operate on the contents of the region (the text between point and the
+mark). They divide the text of the region into many "sort records",
+identify a "sort key" for each record, and then reorder the records
+using the order determined by the sort keys. The records are ordered so
+that their keys are in alphabetical order, or, for numerical sorting, in
+numerical order. In alphabetical sorting, all upper-case letters `A'
+through `Z' come before lower-case `a', in accordance with the ASCII
+character sequence.
+
+ The sort commands differ in how they divide the text into sort
+records and in which part of each record they use as the sort key.
+Most of the commands make each line a separate sort record, but some
+commands use paragraphs or pages as sort records. Most of the sort
+commands use each entire sort record as its own sort key, but some use
+only a portion of the record as the sort key.
+
+`M-x sort-lines'
+ Divide the region into lines and sort by comparing the entire text
+ of a line. A prefix argument means sort in descending order.
+
+`M-x sort-paragraphs'
+ Divide the region into paragraphs and sort by comparing the entire
+ text of a paragraph (except for leading blank lines). A prefix
+ argument means sort in descending order.
+
+`M-x sort-pages'
+ Divide the region into pages and sort by comparing the entire text
+ of a page (except for leading blank lines). A prefix argument
+ means sort in descending order.
+
+`M-x sort-fields'
+ Divide the region into lines and sort by comparing the contents of
+ one field in each line. Fields are defined as separated by
+ whitespace, so the first run of consecutive non-whitespace
+ characters in a line constitutes field 1, the second such run
+ constitutes field 2, etc.
+
+ You specify which field to sort by with a numeric argument: 1 to
+ sort by field 1, etc. A negative argument means sort in descending
+ order. Thus, minus 2 means sort by field 2 in reverse-alphabetical
+ order.
+
+`M-x sort-numeric-fields'
+ Like `M-x sort-fields', except the specified field is converted to
+ a number for each line and the numbers are compared. `10' comes
+ before `2' when considered as text, but after it when considered
+ as a number.
+
+`M-x sort-columns'
+ Like `M-x sort-fields', except that the text within each line used
+ for comparison comes from a fixed range of columns. An explanation
+ is given below.
+
+ For example, if the buffer contains:
+
+ On systems where clash detection (locking of files being edited) is
+ implemented, XEmacs also checks the first time you modify a buffer
+ whether the file has changed on disk since it was last visited or
+ saved. If it has, you are asked to confirm that you want to change
+ the buffer.
+
+then if you apply `M-x sort-lines' to the entire buffer you get:
+
+ On systems where clash detection (locking of files being edited) is
+ implemented, XEmacs also checks the first time you modify a buffer
+ saved. If it has, you are asked to confirm that you want to change
+ the buffer.
+ whether the file has changed on disk since it was last visited or
+
+where the upper case `O' comes before all lower case letters. If you
+apply instead `C-u 2 M-x sort-fields' you get:
+
+ saved. If it has, you are asked to confirm that you want to change
+ implemented, XEmacs also checks the first time you modify a buffer
+ the buffer.
+ On systems where clash detection (locking of files being edited) is
+ whether the file has changed on disk since it was last visited or
+
+where the sort keys were `If', `XEmacs', `buffer', `systems', and `the'.
+
+ `M-x sort-columns' requires more explanation. You specify the
+columns by putting point at one of the columns and the mark at the other
+column. Because this means you cannot put point or the mark at the
+beginning of the first line to sort, this command uses an unusual
+definition of `region': all of the line point is in is considered part
+of the region, and so is all of the line the mark is in.
+
+ For example, to sort a table by information found in columns 10 to
+15, you could put the mark on column 10 in the first line of the table,
+and point on column 15 in the last line of the table, and then use this
+command. Or you could put the mark on column 15 in the first line and
+point on column 10 in the last line.
+
+ This can be thought of as sorting the rectangle specified by point
+and the mark, except that the text on each line to the left or right of
+the rectangle moves along with the text inside the rectangle. *Note
+Rectangles::.
- * A keystroke by itself is equivalent to a vector containing just
- that keystroke, i.e., `(control a)' is equivalent to `[(control
- a)]'.
+\1f
+File: xemacs.info, Node: Shell, Next: Narrowing, Prev: Sorting, Up: Top
- * You can use ASCII codes for keysyms that have them. i.e., `65' is
- equivalent to `A'. (This is not so much an abbreviation as an
- alternate representation.)
+Running Shell Commands from XEmacs
+==================================
- Here are some examples of programmatically binding keys:
+ XEmacs has commands for passing single command lines to inferior
+shell processes; it can also run a shell interactively with input and
+output to an XEmacs buffer `*shell*'.
+`M-!'
+ Run a specified shell command line and display the output
+ (`shell-command').
- ;;; Bind `my-command' to <f1>
- (global-set-key 'f1 'my-command)
-
- ;;; Bind `my-command' to Shift-f1
- (global-set-key '(shift f1) 'my-command)
-
- ;;; Bind `my-command' to C-c Shift-f1
- (global-set-key '[(control c) (shift f1)] 'my-command)
-
- ;;; Bind `my-command' to the middle mouse button.
- (global-set-key 'button2 'my-command)
-
- ;;; Bind `my-command' to <META> <CTL> <Right Mouse Button>
- ;;; in the keymap that is in force when you are running `dired'.
- (define-key dired-mode-map '(meta control button3) 'my-command)
+`M-|'
+ Run a specified shell command line with region contents as input;
+ optionally replace the region with the output
+ (`shell-command-on-region').
-\1f
-File: xemacs.info, Node: Key Bindings Using Strings, Prev: Programmatic Rebinding, Up: Rebinding
+`M-x shell'
+ Run a subshell with input and output through an XEmacs buffer.
+ You can then give commands interactively.
-Using Strings for Changing Key Bindings
-.......................................
+`M-x term'
+ Run a subshell with input and output through an XEmacs buffer.
+ You can then give commands interactively. Full terminal emulation
+ is available.
- For backward compatibility, you can still use strings to represent
-key sequences. Thus you can use commands like the following:
+* Menu:
- ;;; Bind `end-of-line' to C-f
- (global-set-key "\C-f" 'end-of-line)
+* Single Shell:: How to run one shell command and return.
+* Interactive Shell:: Permanent shell taking input via XEmacs.
+* Shell Mode:: Special XEmacs commands used with permanent shell.
+* Terminal emulator:: An XEmacs window as a terminal emulator.
+* Term Mode:: Special XEmacs commands used in Term mode.
+* Paging in Term:: Paging in the terminal emulator.
- Note, however, that in some cases you may be binding more than one
-key sequence by using a single command. This situation can arise
-because in ASCII, `C-i' and <TAB> have the same representation.
-Therefore, when Emacs sees:
+\1f
+File: xemacs.info, Node: Single Shell, Next: Interactive Shell, Prev: Shell, Up: Shell
- (global-set-key "\C-i" 'end-of-line)
+Single Shell Commands
+---------------------
- it is unclear whether the user intended to bind `C-i' or <TAB>. The
-solution XEmacs adopts is to bind both of these key sequences.
+ `M-!' (`shell-command') reads a line of text using the minibuffer
+and creates an inferior shell to execute the line as a command.
+Standard input from the command comes from the null device. If the
+shell command produces any output, the output goes to an XEmacs buffer
+named `*Shell Command Output*', which is displayed in another window
+but not selected. A numeric argument, as in `M-1 M-!', directs this
+command to insert any output into the current buffer. In that case,
+point is left before the output and the mark is set after the output.
+
+ `M-|' (`shell-command-on-region') is like `M-!' but passes the
+contents of the region as input to the shell command, instead of no
+input. If a numeric argument is used to direct output to the current
+buffer, then the old region is deleted first and the output replaces it
+as the contents of the region.
+
+ Both `M-!' and `M-|' use `shell-file-name' to specify the shell to
+use. This variable is initialized based on your `SHELL' environment
+variable when you start XEmacs. If the file name does not specify a
+directory, the directories in the list `exec-path' are searched; this
+list is initialized based on the `PATH' environment variable when you
+start XEmacs. You can override either or both of these default
+initializations in your init file. *Note Init File::.
+
+ When you use `M-!' and `M-|', XEmacs has to wait until the shell
+command completes. You can quit with `C-g'; that terminates the shell
+command.
- After binding a command to two key sequences with a form like:
+\1f
+File: xemacs.info, Node: Interactive Shell, Next: Shell Mode, Prev: Single Shell, Up: Shell
+
+Interactive Inferior Shell
+--------------------------
+
+ To run a subshell interactively with its typescript in an XEmacs
+buffer, use `M-x shell'. This creates (or reuses) a buffer named
+`*shell*' and runs a subshell with input coming from and output going
+to that buffer. That is to say, any "terminal output" from the subshell
+will go into the buffer, advancing point, and any "terminal input" for
+the subshell comes from text in the buffer. To give input to the
+subshell, go to the end of the buffer and type the input, terminated by
+<RET>.
+
+ XEmacs does not wait for the subshell to do anything. You can switch
+windows or buffers and edit them while the shell is waiting, or while
+it is running a command. Output from the subshell waits until XEmacs
+has time to process it; this happens whenever XEmacs is waiting for
+keyboard input or for time to elapse.
+
+ To get multiple subshells, change the name of buffer `*shell*' to
+something different by using `M-x rename-buffer'. The next use of `M-x
+shell' creates a new buffer `*shell*' with its own subshell. By
+renaming this buffer as well you can create a third one, and so on.
+All the subshells run independently and in parallel.
+
+ The file name used to load the subshell is the value of the variable
+`explicit-shell-file-name', if that is non-`nil'. Otherwise, the
+environment variable `ESHELL' is used, or the environment variable
+`SHELL' if there is no `ESHELL'. If the file name specified is
+relative, the directories in the list `exec-path' are searched (*note
+Single Shell Commands: Single Shell.).
+
+ As soon as the subshell is started, it is sent as input the contents
+of the file `~/.emacs_SHELLNAME', if that file exists, where SHELLNAME
+is the name of the file that the shell was loaded from. For example,
+if you use `csh', the file sent to it is `~/.emacs_csh'.
+
+ `cd', `pushd', and `popd' commands given to the inferior shell are
+watched by XEmacs so it can keep the `*shell*' buffer's default
+directory the same as the shell's working directory. These commands
+are recognized syntactically by examining lines of input that are sent.
+If you use aliases for these commands, you can tell XEmacs to
+recognize them also. For example, if the value of the variable
+`shell-pushd-regexp' matches the beginning of a shell command line,
+that line is regarded as a `pushd' command. Change this variable when
+you add aliases for `pushd'. Likewise, `shell-popd-regexp' and
+`shell-cd-regexp' are used to recognize commands with the meaning of
+`popd' and `cd'.
+
+ `M-x shell-resync-dirs' queries the shell and resynchronizes XEmacs'
+idea of what the current directory stack is. `M-x
+shell-dirtrack-toggle' turns directory tracking on and off.
+
+ XEmacs keeps a history of the most recent commands you have typed in
+the `*shell*' buffer. If you are at the beginning of a shell command
+line and type <M-p>, the previous shell input is inserted into the
+buffer before point. Immediately typing <M-p> again deletes that input
+and inserts the one before it. By repeating <M-p> you can move
+backward through your commands until you find one you want to repeat.
+You may then edit the command before typing <RET> if you wish. <M-n>
+moves forward through the command history, in case you moved backward
+past the one you wanted while using <M-p>. If you type the first few
+characters of a previous command and then type <M-p>, the most recent
+shell input starting with those characters is inserted. This can be
+very convenient when you are repeating a sequence of shell commands.
+The variable `input-ring-size' controls how many commands are saved in
+your input history. The default is 30.
- (define-key global-map "\^X\^I" 'command-1)
+\1f
+File: xemacs.info, Node: Shell Mode, Next: Terminal emulator, Prev: Interactive Shell, Up: Shell
+
+Shell Mode
+----------
+
+ The shell buffer uses Shell mode, which defines several special keys
+attached to the `C-c' prefix. They are chosen to resemble the usual
+editing and job control characters present in shells that are not under
+XEmacs, except that you must type `C-c' first. Here is a list of the
+special key bindings of Shell mode:
+
+`<RET>'
+ At end of buffer send line as input; otherwise, copy current line
+ to end of buffer and send it (`send-shell-input'). When a line is
+ copied, any text at the beginning of the line that matches the
+ variable `shell-prompt-pattern' is left out; this variable's value
+ should be a regexp string that matches the prompts that you use in
+ your subshell.
+
+`C-c C-d'
+ Send end-of-file as input, probably causing the shell or its
+ current subjob to finish (`shell-send-eof').
+
+`C-d'
+ If point is not at the end of the buffer, delete the next
+ character just like most other modes. If point is at the end of
+ the buffer, send end-of-file as input, instead of generating an
+ error as in other modes (`comint-delchar-or-maybe-eof').
+
+`C-c C-u'
+ Kill all text that has yet to be sent as input
+ (`kill-shell-input').
+
+`C-c C-w'
+ Kill a word before point (`backward-kill-word').
+
+`C-c C-c'
+ Interrupt the shell or its current subjob if any
+ (`interrupt-shell-subjob').
+
+`C-c C-z'
+ Stop the shell or its current subjob if any (`stop-shell-subjob').
+
+`C-c C-\'
+ Send quit signal to the shell or its current subjob if any
+ (`quit-shell-subjob').
+
+`C-c C-o'
+ Delete last batch of output from shell (`kill-output-from-shell').
+
+`C-c C-r'
+ Scroll top of last batch of output to top of window
+ (`show-output-from-shell').
+
+`C-c C-y'
+ Copy the previous bunch of shell input and insert it into the
+ buffer before point (`copy-last-shell-input'). No final newline
+ is inserted, and the input copied is not resubmitted until you type
+ <RET>.
+
+`M-p'
+ Move backward through the input history. Search for a matching
+ command if you have typed the beginning of a command
+ (`comint-previous-input').
+
+`M-n'
+ Move forward through the input history. Useful when you are using
+ <M-p> quickly and go past the desired command
+ (`comint-next-input').
+
+`<TAB>'
+ Complete the file name preceding point (`comint-dynamic-complete').
- it is possible to redefine only one of those sequences like so:
+\1f
+File: xemacs.info, Node: Terminal emulator, Next: Term Mode, Prev: Shell Mode, Up: Shell
+
+Interactive Inferior Shell with Terminal Emulator
+-------------------------------------------------
+
+ To run a subshell in a terminal emulator, putting its typescript in
+an XEmacs buffer, use `M-x term'. This creates (or reuses) a buffer
+named `*term*' and runs a subshell with input coming from your keyboard
+and output going to that buffer.
+
+ All the normal keys that you type are sent without any interpretation
+by XEmacs directly to the subshell, as "terminal input." Any "echo" of
+your input is the responsibility of the subshell. (The exception is
+the terminal escape character, which by default is `C-c'. *note Term
+Mode::.) Any "terminal output" from the subshell goes into the buffer,
+advancing point.
+
+ Some programs (such as XEmacs itself) need to control the appearance
+on the terminal screen in detail. They do this by sending special
+control codes. The exact control codes needed vary from terminal to
+terminal, but nowadays most terminals and terminal emulators (including
+xterm) understand the so-called "ANSI escape sequences" (first
+popularized by the Digital's VT100 family of terminal). The term mode
+also understands these escape sequences, and for each control code does
+the appropriate thing to change the buffer so that the appearance of
+the window will match what it would be on a real terminal. Thus you
+can actually run XEmacs inside an XEmacs Term window!
+
+ XEmacs does not wait for the subshell to do anything. You can switch
+windows or buffers and edit them while the shell is waiting, or while
+it is running a command. Output from the subshell waits until XEmacs
+has time to process it; this happens whenever XEmacs is waiting for
+keyboard input or for time to elapse.
+
+ To make multiple terminal emulators, rename the buffer `*term*' to
+something different using `M-x rename-uniquely', just as with Shell
+mode.
+
+ The file name used to load the subshell is determined the same way
+as for Shell mode.
+
+ Unlike Shell mode, Term mode does not track the current directory by
+examining your input. Instead, if you use a programmable shell, you
+can have it tell Term what the current directory is. This is done
+automatically by bash for version 1.15 and later.
- (define-key global-map [(control x) (control i)] 'command-2)
- (define-key global-map [(control x) tab] 'command-3)
+\1f
+File: xemacs.info, Node: Term Mode, Next: Paging in Term, Prev: Terminal emulator, Up: Shell
- This applies only when running under a window system. If you are
-talking to Emacs through an ASCII-only channel, you do not get any of
-these features.
+Term Mode
+---------
- Here is a table of pairs of key sequences that behave in a similar
-fashion:
+ Term uses Term mode, which has two input modes: In line mode, Term
+basically acts like Shell mode. *Note Shell Mode::. In Char mode,
+each character is sent directly to the inferior subshell, except for
+the Term escape character, normally `C-c'.
- control h backspace
- control l clear
- control i tab
- control m return
- control j linefeed
- control [ escape
- control @ control space
+ To switch between line and char mode, use these commands:
+ findex term-char-mode
-\1f
-File: xemacs.info, Node: Disabling, Prev: Rebinding, Up: Key Bindings
+`C-c C-k'
+ Switch to line mode. Do nothing if already in line mode.
-Disabling Commands
-------------------
+`C-c C-j'
+ Switch to char mode. Do nothing if already in char mode.
- Disabling a command marks it as requiring confirmation before it can
-be executed. The purpose of disabling a command is to prevent
-beginning users from executing it by accident and being confused.
+ The following commands are only available in Char mode:
+`C-c C-c'
+ Send a literal <C-c> to the sub-shell.
- The direct mechanism for disabling a command is to have a non-`nil'
-`disabled' property on the Lisp symbol for the command. These
-properties are normally set by the user's `.emacs' file with Lisp
-expressions such as:
+`C-c C-x'
+ A prefix command to conveniently access the global <C-x> commands.
+ For example, `C-c C-x o' invokes the global binding of `C-x o',
+ which is normally `other-window'.
- (put 'delete-region 'disabled t)
+\1f
+File: xemacs.info, Node: Paging in Term, Prev: Term Mode, Up: Shell
- If the value of the `disabled' property is a string, that string is
-included in the message printed when the command is used:
+Paging in the terminal emulator
+-------------------------------
- (put 'delete-region 'disabled
- "Text deleted this way cannot be yanked back!\n")
+ Term mode has a pager feature. When the pager is enabled, term mode
+will pause at the end of each screenful.
- You can disable a command either by editing the `.emacs' file
-directly or with the command `M-x disable-command', which edits the
-`.emacs' file for you. *Note Init File::.
+`C-c C-q'
+ Toggles the pager feature: Disables the pager if it is enabled,
+ and vice versa. This works in both line and char modes. If the
+ pager enabled, the mode-line contains the word `page'.
- When you attempt to invoke a disabled command interactively in Emacs,
-a window is displayed containing the command's name, its documentation,
-and some instructions on what to do next; then Emacs asks for input
-saying whether to execute the command as requested, enable it and
-execute, or cancel it. If you decide to enable the command, you are
-asked whether to do this permanently or just for the current session.
-Enabling permanently works by automatically editing your `.emacs' file.
-You can use `M-x enable-command' at any time to enable any command
-permanently.
+ If the pager is enabled, and Term receives more than a screenful of
+output since your last input, Term will enter More break mode. This is
+indicated by `**MORE**' in the mode-line. Type a `Space' to display
+the next screenful of output. Type `?' to see your other options. The
+interface is similar to the Unix `more' program.
- Whether a command is disabled is independent of what key is used to
-invoke it; it also applies if the command is invoked using `M-x'.
-Disabling a command has no effect on calling it as a function from Lisp
-programs.
+\1f
+File: xemacs.info, Node: Narrowing, Next: Hardcopy, Prev: Shell, Up: Top
+
+Narrowing
+=========
+
+ "Narrowing" means focusing in on some portion of the buffer, making
+the rest temporarily invisible and inaccessible. Cancelling the
+narrowing and making the entire buffer once again visible is called
+"widening". The amount of narrowing in effect in a buffer at any time
+is called the buffer's "restriction".
+
+`C-x n n'
+ Narrow down to between point and mark (`narrow-to-region').
+
+`C-x n w'
+ Widen to make the entire buffer visible again (`widen').
+
+ Narrowing sometimes makes it easier to concentrate on a single
+subroutine or paragraph by eliminating clutter. It can also be used to
+restrict the range of operation of a replace command or repeating
+keyboard macro. The word `Narrow' appears in the mode line whenever
+narrowing is in effect. When you have narrowed to a part of the
+buffer, that part appears to be all there is. You can't see the rest,
+can't move into it (motion commands won't go outside the visible part),
+and can't change it in any way. However, the invisible text is not
+gone; if you save the file, it will be saved.
+
+ The primary narrowing command is `C-x n n' (`narrow-to-region'). It
+sets the current buffer's restrictions so that the text in the current
+region remains visible but all text before the region or after the
+region is invisible. Point and mark do not change.
+
+ Because narrowing can easily confuse users who do not understand it,
+`narrow-to-region' is normally a disabled command. Attempting to use
+this command asks for confirmation and gives you the option of enabling
+it; once you enable the command, confirmation will no longer be
+required. *Note Disabling::.
+
+ To undo narrowing, use `C-x n w' (`widen'). This makes all text in
+the buffer accessible again.
+
+ Use the `C-x =' command to get information on what part of the
+buffer you narrowed down. *Note Position Info::.
\1f
-File: xemacs.info, Node: Syntax, Next: Init File, Prev: Key Bindings, Up: Customization
+File: xemacs.info, Node: Hardcopy, Next: Recursive Edit, Prev: Narrowing, Up: Top
-The Syntax Table
-================
+Hardcopy Output
+===============
- All the Emacs commands which parse words or balance parentheses are
-controlled by the "syntax table". The syntax table specifies which
-characters are opening delimiters, which are parts of words, which are
-string quotes, and so on. Actually, each major mode has its own syntax
-table (though sometimes related major modes use the same one) which it
-installs in each buffer that uses that major mode. The syntax table
-installed in the current buffer is the one that all commands use, so we
-call it "the" syntax table. A syntax table is a Lisp object, a vector
-of length 256 whose elements are numbers.
+ The XEmacs commands for making hardcopy derive their names from the
+Unix commands `print' and `lpr'.
-* Menu:
+`M-x print-buffer'
+ Print hardcopy of current buffer using Unix command `print'
+ (`lpr -p'). This command adds page headings containing the file
+ name and page number.
-* Entry: Syntax Entry. What the syntax table records for each character.
-* Change: Syntax Change. How to change the information.
+`M-x lpr-buffer'
+ Print hardcopy of current buffer using Unix command `lpr'. This
+ command does not add page headings.
-\1f
-File: xemacs.info, Node: Syntax Entry, Next: Syntax Change, Up: Syntax
-
-Information About Each Character
---------------------------------
-
- The syntax table entry for a character is a number that encodes six
-pieces of information:
-
- * The syntactic class of the character, represented as a small
- integer
-
- * The matching delimiter, for delimiter characters only (the
- matching delimiter of `(' is `)', and vice versa)
-
- * A flag saying whether the character is the first character of a
- two-character comment starting sequence
-
- * A flag saying whether the character is the second character of a
- two-character comment starting sequence
-
- * A flag saying whether the character is the first character of a
- two-character comment ending sequence
-
- * A flag saying whether the character is the second character of a
- two-character comment ending sequence
-
- The syntactic classes are stored internally as small integers, but
-are usually described to or by the user with characters. For example,
-`(' is used to specify the syntactic class of opening delimiters. Here
-is a table of syntactic classes, with the characters that specify them.
-
-` '
- The class of whitespace characters.
-
-`w'
- The class of word-constituent characters.
-
-`_'
- The class of characters that are part of symbol names but not
- words. This class is represented by `_' because the character `_'
- has this class in both C and Lisp.
-
-`.'
- The class of punctuation characters that do not fit into any other
- special class.
-
-`('
- The class of opening delimiters.
-
-`)'
- The class of closing delimiters.
-
-`''
- The class of expression-adhering characters. These characters are
- part of a symbol if found within or adjacent to one, and are part
- of a following expression if immediately preceding one, but are
- like whitespace if surrounded by whitespace.
-
-`"'
- The class of string-quote characters. They match each other in
- pairs, and the characters within the pair all lose their syntactic
- significance except for the `\' and `/' classes of escape
- characters, which can be used to include a string-quote inside the
- string.
-
-`$'
- The class of self-matching delimiters. This is intended for TeX's
- `$', which is used both to enter and leave math mode. Thus, a
- pair of matching `$' characters surround each piece of math mode
- TeX input. A pair of adjacent `$' characters act like a single
- one for purposes of matching.
-
-`/'
- The class of escape characters that always just deny the following
- character its special syntactic significance. The character after
- one of these escapes is always treated as alphabetic.
-
-`\'
- The class of C-style escape characters. In practice, these are
- treated just like `/'-class characters, because the extra
- possibilities for C escapes (such as being followed by digits)
- have no effect on where the containing expression ends.
-
-`<'
- The class of comment-starting characters. Only single-character
- comment starters (such as `;' in Lisp mode) are represented this
- way.
-
-`>'
- The class of comment-ending characters. Newline has this syntax in
- Lisp mode.
-
- The characters flagged as part of two-character comment delimiters
-can have other syntactic functions most of the time. For example, `/'
-and `*' in C code, when found separately, have nothing to do with
-comments. The comment-delimiter significance overrides when the pair of
-characters occur together in the proper order. Only the list and sexp
-commands use the syntax table to find comments; the commands
-specifically for comments have other variables that tell them where to
-find comments. Moreover, the list and sexp commands notice comments
-only if `parse-sexp-ignore-comments' is non-`nil'. This variable is set
-to `nil' in modes where comment-terminator sequences are liable to
-appear where there is no comment, for example, in Lisp mode where the
-comment terminator is a newline but not every newline ends a comment.
+`M-x print-region'
+ Like `print-buffer', but prints only the current region.
-\1f
-File: xemacs.info, Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
-
-Altering Syntax Information
----------------------------
-
- It is possible to alter a character's syntax table entry by storing
-a new number in the appropriate element of the syntax table, but it
-would be hard to determine what number to use. Emacs therefore
-provides a command that allows you to specify the syntactic properties
-of a character in a convenient way.
-
- `M-x modify-syntax-entry' is the command to change a character's
-syntax. It can be used interactively and is also used by major modes
-to initialize their own syntax tables. Its first argument is the
-character to change. The second argument is a string that specifies the
-new syntax. When called from Lisp code, there is a third, optional
-argument, which specifies the syntax table in which to make the change.
-If not supplied, or if this command is called interactively, the third
-argument defaults to the current buffer's syntax table.
-
- 1. The first character in the string specifies the syntactic class.
- It is one of the characters in the previous table (*note Syntax
- Entry::.).
-
- 2. The second character is the matching delimiter. For a character
- that is not an opening or closing delimiter, this should be a
- space, and may be omitted if no following characters are needed.
-
- 3. The remaining characters are flags. The flag characters allowed
- are:
-
- `1'
- Flag this character as the first of a two-character comment
- starting sequence.
-
- `2'
- Flag this character as the second of a two-character comment
- starting sequence.
-
- `3'
- Flag this character as the first of a two-character comment
- ending sequence.
-
- `4'
- Flag this character as the second of a two-character comment
- ending sequence.
-
- Use `C-h s' (`describe-syntax') to display a description of the
-contents of the current syntax table. The description of each
-character includes both the string you have to pass to
-`modify-syntax-entry' to set up that character's current syntax, and
-some English to explain that string if necessary.
+`M-x lpr-region'
+ Like `lpr-buffer', but prints only the current region.
+
+ All the hardcopy commands pass extra switches to the `lpr' program
+based on the value of the variable `lpr-switches'. Its value should be
+a list of strings, each string a switch starting with `-'. For
+example, the value could be `("-Pfoo")' to print on printer `foo'.