-Certain operations invoked from menus will use a window system dialog
-box to get information via the mouse if such dialog boxes are supported.
-This includes yes/no questions and file selection under Motif/LessTif
-and MS Windows. Customize the option @code{use-dialog-box} to suppress
-the use of dialog boxes.
-
-@node Faces
-@section Using Multiple Typefaces
-@cindex faces
-
- When using Emacs with X, you can set up multiple styles of displaying
-characters. The aspects of style that you can control are the type
-font, the foreground color, the background color, and whether to
-underline. Emacs on MS-DOS supports faces partially by letting you
-control the foreground and background colors of each face
-(@pxref{MS-DOS}). On non-windowed terminals faces are supported to the
-extent the terminal can display them.
-
- The way you control display style is by defining named @dfn{faces}.
-Each face can specify a type font, a foreground color, a background
-color, and an underline flag; but it does not have to specify all of
-them. Then by specifying the face or faces to use for a given part
-of the text in the buffer, you control how that text appears.
-
- The style of display used for a given character in the text is
-determined by combining several faces. Any aspect of the display style
-that isn't specified by overlays or text properties comes from the frame
-itself.
-
- Enriched mode, the mode for editing formatted text, includes several
-commands and menus for specifying faces. @xref{Format Faces}, for how
-to specify the font for text in the buffer. @xref{Format Colors}, for
-how to specify the foreground and background color.
-
- To alter the appearance of a face, use the customization buffer.
-@xref{Face Customization}. You can also use X resources to specify
-attributes of particular faces (@pxref{Resources X}).
-
-@findex list-faces-display
- To see what faces are currently defined, and what they look like, type
-@kbd{M-x list-faces-display}. It's possible for a given face to look
-different in different frames; this command shows the appearance in the
-frame in which you type it. Here's a list of the standardly defined
-faces:
-
-@table @code
-@item default
-This face is used for ordinary text that doesn't specify any other face.
-@item modeline
-This face is used for mode lines. By default, it's drawn with shadows
-for a `raised' effect under X and set up as the inverse of the default
-face on non-windowed terminals. @xref{Display Vars}.
-@item header-line
-Similar to @code{modeline} for a window's header line.
-@item highlight
-This face is used for highlighting portions of text, in various modes.
-@item region
-This face is used for displaying a selected region (when Transient Mark
-mode is enabled---see below).
-@item secondary-selection
-This face is used for displaying a secondary selection (@pxref{Secondary
-Selection}).
-@item bold
-This face uses a bold variant of the default font, if it has one.
-@item italic
-This face uses an italic variant of the default font, if it has one.
-@item bold-italic
-This face uses a bold italic variant of the default font, if it has one.
-@item underline
-This face underlines text.
-@item fixed-pitch
-The basic fixed-pitch face.
-@item fringe
-The face for the fringes to the left and right of windows under X.
-@item scroll-bar
-This face determines the colors of the scroll bar.
-@item border
-This face determines the color of the frame border.
-@item cursor
-This face determines the color of the cursor.
-@item mouse
-This face determines the color of the mouse pointer.
-@item tool-bar
-The basic tool-bar face.
-@item menu
-This face determines the colors and font of Emacs's menus. Setting the
-font of LessTif/Motif menus is currently not supported; attempts to set
-the font are ignored in this case.
-@item trailing-whitespace
-The face for highlighting trailing whitespace when
-@code{show-trailing-whitespace} is non-nil.
-@item variable-pitch
-The basic variable-pitch face.
-@end table
-
-@cindex @code{region} face
- When Transient Mark mode is enabled, the text of the region is
-highlighted when the mark is active. This uses the face named
-@code{region}; you can control the style of highlighting by changing the
-style of this face (@pxref{Face Customization}). @xref{Transient Mark},
-for more information about Transient Mark mode and activation and
-deactivation of the mark.
-
- One easy way to use faces is to turn on Font Lock mode. This minor
-mode, which is always local to a particular buffer, arranges to
-choose faces according to the syntax of the text you are editing. It
-can recognize comments and strings in most languages; in several
-languages, it can also recognize and properly highlight various other
-important constructs. @xref{Font Lock}, for more information about
-Font Lock mode and syntactic highlighting.
-
- You can print out the buffer with the highlighting that appears
-on your screen using the command @code{ps-print-buffer-with-faces}.
-@xref{PostScript}.
-
-@node Font Lock
-@section Font Lock mode
-@cindex Font Lock mode
-@cindex mode, Font Lock
-@cindex syntax highlighting
-@cindex syntax coloring
-
- Font Lock mode is a minor mode, always local to a particular
-buffer, which highlights (or ``fontifies'') using various faces
-according to the syntax of the text you are editing. It can
-recognize comments and strings in most languages; in several
-languages, it can also recognize and properly highlight various other
-important constructs---for example, names of functions being defined
-or reserved keywords.
-
-@findex font-lock-mode
-@findex turn-on-font-lock
- The command @kbd{M-x font-lock-mode} turns Font Lock mode on or off
-according to the argument, and toggles the mode when it has no argument.
-The function @code{turn-on-font-lock} unconditionally enables Font Lock
-mode. This is useful in mode-hook functions. For example, to enable
-Font Lock mode whenever you edit a C file, you can do this:
-
-@example
-(add-hook 'c-mode-hook 'turn-on-font-lock)
-@end example
-
-@findex global-font-lock-mode
-@vindex global-font-lock-mode
- To turn on Font Lock mode automatically in all modes which support it,
-customize the user option @code{global-font-lock-mode} or use the
-function @code{global-font-lock-mode}, like this:
-
-@example
-(global-font-lock-mode 1)
-@end example
-
-@kindex M-g M-g
-@findex font-lock-fontify-block
- In Font Lock mode, when you edit the text, the highlighting updates
-automatically in the line that you changed. Most changes don't affect
-the highlighting of subsequent lines, but occasionally they do. To
-rehighlight a range of lines, use the command @kbd{M-g M-g}
-(@code{font-lock-fontify-block}).
-
-@vindex font-lock-mark-block-function
- In certain major modes, @kbd{M-g M-g} refontifies the entire current
-function. (The variable @code{font-lock-mark-block-function} controls
-how to find the current function.) In other major modes, @kbd{M-g M-g}
-refontifies 16 lines above and below point.
-
- With a prefix argument @var{n}, @kbd{M-g M-g} refontifies @var{n}
-lines above and below point, regardless of the mode.
-
- To get the full benefit of Font Lock mode, you need to choose a
-default font which has bold, italic, and bold-italic variants; or else
-you need to have a color or gray-scale screen.
-
-@vindex font-lock-maximum-decoration
- The variable @code{font-lock-maximum-decoration} specifies the
-preferred level of fontification, for modes that provide multiple
-levels. Level 1 is the least amount of fontification; some modes
-support levels as high as 3. The normal default is ``as high as
-possible.'' You can specify an integer, which applies to all modes, or
-you can specify different numbers for particular major modes; for
-example, to use level 1 for C/C++ modes, and the default level
-otherwise, use this:
-
-@example
-(setq font-lock-maximum-decoration
- '((c-mode . 1) (c++-mode . 1)))
-@end example
-
-@vindex font-lock-maximum-size
- Fontification can be too slow for large buffers, so you can suppress
-it. The variable @code{font-lock-maximum-size} specifies a buffer size,
-beyond which buffer fontification is suppressed.
-
-@c @w is used below to prevent a bad page-break.
-@vindex font-lock-beginning-of-syntax-function
- Comment and string fontification (or ``syntactic'' fontification)
-relies on analysis of the syntactic structure of the buffer text. For
-the purposes of speed, some modes including C mode and Lisp mode rely on
-a special convention: an open-parenthesis in the leftmost column always
-defines the @w{beginning} of a defun, and is thus always outside any string
-or comment. (@xref{Defuns}.) If you don't follow this convention,
-then Font Lock mode can misfontify the text after an open-parenthesis in
-the leftmost column that is inside a string or comment.
-
- The variable @code{font-lock-beginning-of-syntax-function} (always
-buffer-local) specifies how Font Lock mode can find a position
-guaranteed to be outside any comment or string. In modes which use the
-leftmost column parenthesis convention, the default value of the variable
-is @code{beginning-of-defun}---that tells Font Lock mode to use the
-convention. If you set this variable to @code{nil}, Font Lock no longer
-relies on the convention. This avoids incorrect results, but the price
-is that, in some cases, fontification for a changed text must rescan
-buffer text from the beginning of the buffer.
-
-@findex font-lock-add-keywords
- Font Lock highlighting patterns already exist for many modes, but you
-may want to fontify additional patterns. You can use the function
-@code{font-lock-add-keywords}, to add your own highlighting patterns for
-a particular mode. For example, to highlight @samp{FIXME:} words in C
-comments, use this:
-
-@example
-(font-lock-add-keywords
- 'c-mode
- '(("\\<\\(FIXME\\):" 1 font-lock-warning-face t)))
-@end example
-
-@node Support Modes
-@section Font Lock Support Modes
-
- Font Lock support modes make Font Lock mode faster for large buffers.
-There are two support modes: Fast Lock mode and Lazy Lock mode. They
-use two different methods of speeding up Font Lock mode.
-
-@menu
-* Fast Lock Mode:: Saving font information in files.
-* Lazy Lock Mode:: Fontifying only text that is actually displayed.
-* JIT Lock Mode:: Like Lazy Lock, but generally faster.
-* Fast or Lazy:: Which support mode is best for you?
-@end menu
-
-@node Fast Lock Mode
-@subsection Fast Lock Mode
-
-@cindex Fast Lock mode
-@cindex mode, Fast Lock
- To make Font Lock mode faster for buffers visiting large files, you
-can use Fast Lock mode. Fast Lock mode saves the font information for
-each file in a separate cache file; each time you visit the file, it
-rereads the font information from the cache file instead of refontifying
-the text from scratch.
-
-@findex fast-lock-mode
- The command @kbd{M-x fast-lock-mode} turns Fast Lock mode on or off,
-according to the argument (with no argument, it toggles). You can also
-arrange to enable Fast Lock mode whenever you use Font Lock mode, like
-this:
-
-@example
-(setq font-lock-support-mode 'fast-lock-mode)
-@end example
-
-@vindex fast-lock-minimum-size
- It is not worth writing a cache file for small buffers. Therefore,
-the variable @code{fast-lock-minimum-size} specifies a minimum file size
-for caching font information.
-
-@vindex fast-lock-cache-directories
- The variable @code{fast-lock-cache-directories} specifies where to put
-the cache files. Its value is a list of directories to try; @code{"."}
-means the same directory as the file being edited. The default value is
-@w{@code{("." "~/.emacs-flc")}}, which means to use the same directory if
-possible, and otherwise the directory @file{~/.emacs-flc}.
-
-@vindex fast-lock-save-others
- The variable @code{fast-lock-save-others} specifies whether Fast Lock
-mode should save cache files for files that you do not own. A
-non-@code{nil} value means yes (and that is the default).
-
-@node Lazy Lock Mode
-@subsection Lazy Lock Mode
-@cindex Lazy Lock mode
-@cindex mode, Lazy Lock
-
- To make Font Lock mode faster for large buffers, you can use Lazy Lock
-mode to reduce the amount of text that is fontified. In Lazy Lock mode,
-buffer fontification is demand-driven; it happens to portions of the
-buffer that are about to be displayed. And fontification of your
-changes is deferred; it happens only when Emacs has been idle for a
-certain short period of time.
-
-@findex lazy-lock-mode
- The command @kbd{M-x lazy-lock-mode} turns Lazy Lock mode on or off,
-according to the argument (with no argument, it toggles). You can also
-arrange to enable Lazy Lock mode whenever you use Font Lock mode, like
-this:
-
-@example
-(setq font-lock-support-mode 'lazy-lock-mode)
-@end example
-
-@vindex lazy-lock-minimum-size
- It is not worth avoiding buffer fontification for small buffers.
-Therefore, the variable @code{lazy-lock-minimum-size} specifies a
-minimum buffer size for demand-driven buffer fontification. Buffers
-smaller than that are fontified all at once, as in plain Font Lock mode.
-
-@vindex lazy-lock-defer-time
- When you alter the buffer, Lazy Lock mode defers fontification of the
-text you changed. The variable @code{lazy-lock-defer-time} specifies
-how many seconds Emacs must be idle before it starts fontifying your
-changes. If the value is 0, then changes are fontified immediately, as
-in plain Font Lock mode.
-
-@vindex lazy-lock-defer-on-scrolling
- Lazy Lock mode normally fontifies newly visible portions of the buffer
-before they are first displayed. However, if the value of
-@code{lazy-lock-defer-on-scrolling} is non-@code{nil}, newly visible
-text is fontified only when Emacs is idle for
-@code{lazy-lock-defer-time} seconds.
-
-@vindex lazy-lock-defer-contextually
- In some modes, including C mode and Emacs Lisp mode, changes in one
-line's contents can alter the context for subsequent lines, and thus
-change how they ought to be fontified. Ordinarily, you must type
-@kbd{M-g M-g} to refontify the subsequent lines. However, if you set
-the variable @code{lazy-lock-defer-contextually} to non-@code{nil}, Lazy
-Lock mode does this automatically, after @code{lazy-lock-defer-time}
-seconds.
-
-@cindex stealth fontification
- When Emacs is idle for a long time, Lazy Lock fontifies additional
-portions of the buffer, not yet displayed, in case you will display them
-later. This is called @dfn{stealth fontification}.
-
-@vindex lazy-lock-stealth-time
-@vindex lazy-lock-stealth-lines
-@vindex lazy-lock-stealth-verbose
- The variable @code{lazy-lock-stealth-time} specifies how many seconds
-Emacs has to be idle before stealth fontification starts. A value of
-@code{nil} means no stealth fontification. The variables
-@code{lazy-lock-stealth-lines} and @code{lazy-lock-stealth-verbose}
-specify the granularity and verbosity of stealth fontification.
-
-@node JIT Lock Mode
-@subsection JIT Lock Mode
-
-@findex jit-lock-mode
-This Just-In-time support mode is roughly equivalent to Lazy Lock but is
-generally faster and more robust. It supports stealth and deferred
-contextual fontification.
-
-Font-lock uses @code{jit-lock-mode} as default support mode, so you
-don't have to do anything to activate it.
-
-@node Fast or Lazy
-@subsection Fast Lock or Lazy Lock?
-
- Here is a simple guide to help you choose one of the Font Lock support
-modes.
-
-@itemize @bullet
-@item
-Fast Lock mode intervenes only during file visiting and buffer
-killing (and related events); therefore buffer editing and window
-scrolling are no faster or slower than in plain Font Lock mode.
-
-@item
-Fast Lock mode is slower at reading a cache file than Lazy Lock
-mode is at fontifying a window; therefore Fast Lock mode is slower at
-visiting a file than Lazy Lock mode.
-
-@item
-Lazy Lock mode intervenes during window scrolling to fontify text that
-scrolls onto the screen; therefore, scrolling is slower than in plain
-Font Lock mode.
-
-@item
-Lazy Lock mode doesn't fontify during buffer editing (it defers
-fontification of changes); therefore, editing is faster than in plain
-Font Lock mode.
-
-@item
-Fast Lock mode can be fooled by a file that is kept under version
-control software; therefore buffer fontification may occur even when
-a cache file exists for the file.
-
-@item
-Fast Lock mode only works with a buffer visiting a file; Lazy Lock
-mode works with any buffer.
-
-@item
-Fast Lock mode generates cache files; Lazy Lock mode does not.
-@end itemize
-
-@vindex font-lock-support-mode
- The variable @code{font-lock-support-mode} specifies which of these
-support modes to use; for example, to specify that Fast Lock mode is
-used for C/C++ modes, and Lazy Lock mode otherwise, set the variable
-like this:
-
-@example
-(setq font-lock-support-mode
- '((c-mode . fast-lock-mode) (c++-mode . fast-lock-mode)
- (t . lazy-lock-mode)))
-@end example
-
-@node Highlight Changes
-@section Highlight Changes Mode
-
-@findex highlight-changes-mode
- Use @kbd{M-x highlight-changes-mode} to enable a minor mode
-that uses faces (colors, typically) to indicate which parts of
-the buffer were changed most recently.
-
-@node Highlight Interactively
-@section Interactive Highlighting of Arbitrary Text
-
-@cindex highlighting, arbitrary text
-@cindex interactive highlighting
- Sometimes, you could need to highlight arbitrary strings in the
-buffer. For example, you might wish to see all the references to a
-certain variable in a program source file or highlight certain parts in
-a voluminous output of some program, or make certain cliches stand out.
-
-@findex hi-lock-mode
- Use the @kbd{M-x hi-lock-mode} command to turn on a minor mode that
-allows you to specify regular expressions of the text to be highlighted.
-@code{hi-lock-mode} works like Font Lock (@pxref{Font Lock}), except
-that it lets you control what parts of text are highlighted.
-@code{hi-lock-mode} provides several functions:
-
-@table @kbd
-@item C-x w h
-@kindex C-x w i
-@findex highlight-regexp
-Specify the regular expression (@pxref{Regexps}) for the parts of buffer
-text that are to be highlighted (@code{highlight-regexp}). It prompts
-for the regular expression, then for the name of the face with which to
-highlight the text that matches.
-
-@item C-x w r
-@kindex C-x w r
-@findex unhighlight-regexp
-Unhighlight @var{regexp} (@code{unhighlight-regexp}). Prompts for the
-regular expression, and will accept only one of the regexps inserted by
-other @code{hi-lock} commands.
-
-@item C-x w l
-@kindex C-x w l
-@findex highlight-lines-matching-regexp
-@cindex lines, highlighting
-@cindex highlighting lines of text
-Specify the regular expression (@pxref{Regexps}) for the lines of buffer
-text that are to be highlighted
-(@code{highlight-lines-matching-regexp}). It prompts for the regular
-expression, then for the name of the face with which to highlight the
-matching lines.
-
-@item C-x w b
-@kindex C-x w b
-@findex hi-lock-write-interactive-patterns
-This runs the @code{hi-lock-write-interactive-patterns} command which
-inserts the patterns added by @kbd{M-x highlight-regexp} and @kbd{M-x
-highlight-lines-matching-regexp} into the current buffer at point, as
-comments. These patterns will be read the next time the file is
-visited, or when the @kbd{M-x hi-lock-find-patterns} command is issued.
-
-@item C-x w i
-@kindex C-x w i
-@findex hi-lock-find-patterns
-@vindex hi-lock-exclude-modes
-Re-read patterns stored in a buffer in the format produced by @kbd{M-x
-hi-lock-write-interactive-patterns}
-(@code{hi-lock-write-interactive-patterns}. If you invoke this command
-in a buffer whose major mode is a member of the list that is the value
-of the variable @code{hi-lock-exclude-modes}, this command has no
-effect.
-@end table
-
-
-@node Trailing Whitespace
-@section Trailing Whitespace
-
-@cindex trailing whitespace
-@cindex whitespace, trailing
-@vindex show-trailing-whitespace
-The option @code{show-trailing-whitespace} can be customized so that
-Emacs displays trailing whitespace in the face
-@code{trailing-whitespace}. Trailing whitespace is defined as spaces or
-tabs at the end of a line. To avoid busy highlighting when entering new
-text, trailing whitespace is not displayed if point is at the end of the
-line containing the whitespace.