This is ../info/emacs, produced by makeinfo version 4.0 from emacs.texi.
This is the Fourteenth edition of the `GNU Emacs Manual', updated
for Emacs version 21.1.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Emacs: (emacs). The extensible self-documenting text editor.
END-INFO-DIR-ENTRY
Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA 02111-1307 USA
Copyright (C) 1985,
1986,1987,1993,1994,1995,1996,1997,1998,1999,2000,2001 Free Software
Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "The GNU Manifesto", "Distribution" and "GNU
GENERAL PUBLIC LICENSE", with the Front-Cover texts being "A GNU
Manual," and with the Back-Cover Texts as in (a) below. A copy of the
license is included in the section entitled "GNU Free Documentation
License."
(a) The FSF's Back-Cover Text is: "You have freedom to copy and
modify this GNU Manual, like GNU software. Copies published by the Free
Software Foundation raise funds for GNU development."
File: emacs, Node: Sentences, Next: Paragraphs, Prev: Words, Up: Text
Sentences
=========
The Emacs commands for manipulating sentences and paragraphs are
mostly on Meta keys, so as to be like the word-handling commands.
`M-a'
Move back to the beginning of the sentence (`backward-sentence').
`M-e'
Move forward to the end of the sentence (`forward-sentence').
`M-k'
Kill forward to the end of the sentence (`kill-sentence').
`C-x <DEL>'
Kill back to the beginning of the sentence
(`backward-kill-sentence').
The commands `M-a' and `M-e' (`backward-sentence' and
`forward-sentence') move to the beginning and end of the current
sentence, respectively. They were chosen to resemble `C-a' and `C-e',
which move to the beginning and end of a line. Unlike them, `M-a' and
`M-e' if repeated or given numeric arguments move over successive
sentences.
Moving backward over a sentence places point just before the first
character of the sentence; moving forward places point right after the
punctuation that ends the sentence. Neither one moves over the
whitespace at the sentence boundary.
Just as `C-a' and `C-e' have a kill command, `C-k', to go with them,
so `M-a' and `M-e' have a corresponding kill command `M-k'
(`kill-sentence') which kills from point to the end of the sentence.
With minus one as an argument it kills back to the beginning of the
sentence. Larger arguments serve as a repeat count. There is also a
command, `C-x <DEL>' (`backward-kill-sentence'), for killing back to
the beginning of a sentence. This command is useful when you change
your mind in the middle of composing text.
The sentence commands assume that you follow the American typist's
convention of putting two spaces at the end of a sentence; they consider
a sentence to end wherever there is a `.', `?' or `!' followed by the
end of a line or two spaces, with any number of `)', `]', `'', or `"'
characters allowed in between. A sentence also begins or ends wherever
a paragraph begins or ends.
The variable `sentence-end' controls recognition of the end of a
sentence. It is a regexp that matches the last few characters of a
sentence, together with the whitespace following the sentence. Its
normal value is
"[.?!][]\"')]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
This example is explained in the section on regexps. *Note Regexps::.
If you want to use just one space between sentences, you should set
`sentence-end' to this value:
"[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*"
You should also set the variable `sentence-end-double-space' to `nil'
so that the fill commands expect and leave just one space at the end of
a sentence. Note that this makes it impossible to distinguish between
periods that end sentences and those that indicate abbreviations.
File: emacs, Node: Paragraphs, Next: Pages, Prev: Sentences, Up: Text
Paragraphs
==========
The Emacs commands for manipulating paragraphs are also Meta keys.
`M-{'
Move back to previous paragraph beginning (`backward-paragraph').
`M-}'
Move forward to next paragraph end (`forward-paragraph').
`M-h'
Put point and mark around this or next paragraph
(`mark-paragraph').
`M-{' moves to the beginning of the current or previous paragraph,
while `M-}' moves to the end of the current or next paragraph. Blank
lines and text-formatter command lines separate paragraphs and are not
considered part of any paragraph. In Fundamental mode, but not in Text
mode, an indented line also starts a new paragraph. (If a paragraph is
preceded by a blank line, these commands treat that blank line as the
beginning of the paragraph.)
In major modes for programs, paragraphs begin and end only at blank
lines. This makes the paragraph commands continue to be useful even
though there are no paragraphs per se.
When there is a fill prefix, then paragraphs are delimited by all
lines which don't start with the fill prefix. *Note Filling::.
When you wish to operate on a paragraph, you can use the command
`M-h' (`mark-paragraph') to set the region around it. Thus, for
example, `M-h C-w' kills the paragraph around or after point. The
`M-h' command puts point at the beginning and mark at the end of the
paragraph point was in. In Transient Mark mode, it activates the mark.
If point is between paragraphs (in a run of blank lines, or at a
boundary), the paragraph following point is surrounded by point and
mark. If there are blank lines preceding the first line of the
paragraph, one of these blank lines is included in the region.
The precise definition of a paragraph boundary is controlled by the
variables `paragraph-separate' and `paragraph-start'. The value of
`paragraph-start' is a regexp that should match any line that either
starts or separates paragraphs. The value of `paragraph-separate' is
another regexp that should match only lines that separate paragraphs
without being part of any paragraph (for example, blank lines). Lines
that start a new paragraph and are contained in it must match only
`paragraph-start', not `paragraph-separate'. For example, in
Fundamental mode, `paragraph-start' is `"[ \t\n\f]"', and
`paragraph-separate' is `"[ \t\f]*$"'.
Normally it is desirable for page boundaries to separate paragraphs.
The default values of these variables recognize the usual separator for
pages.
File: emacs, Node: Pages, Next: Filling, Prev: Paragraphs, Up: Text
Pages
=====
Files are often thought of as divided into "pages" by the "formfeed"
character (ASCII control-L, octal code 014). When you print hardcopy
for a file, this character forces a page break; thus, each page of the
file goes on a separate page on paper. Most Emacs commands treat the
page-separator character just like any other character: you can insert
it with `C-q C-l', and delete it with <DEL>. Thus, you are free to
paginate your file or not. However, since pages are often meaningful
divisions of the file, Emacs provides commands to move over them and
operate on them.
`C-x ['
Move point to previous page boundary (`backward-page').
`C-x ]'
Move point to next page boundary (`forward-page').
`C-x C-p'
Put point and mark around this page (or another page)
(`mark-page').
`C-x l'
Count the lines in this page (`count-lines-page').
The `C-x [' (`backward-page') command moves point to immediately
after the previous page delimiter. If point is already right after a
page delimiter, it skips that one and stops at the previous one. A
numeric argument serves as a repeat count. The `C-x ]' (`forward-page')
command moves forward past the next page delimiter.
The `C-x C-p' command (`mark-page') puts point at the beginning of
the current page and the mark at the end. The page delimiter at the
end is included (the mark follows it). The page delimiter at the front
is excluded (point follows it). In Transient Mark mode, this command
activates the mark.
`C-x C-p C-w' is a handy way to kill a page to move it elsewhere.
If you move to another page delimiter with `C-x [' and `C-x ]', then
yank the killed page, all the pages will be properly delimited once
again. The reason `C-x C-p' includes only the following page delimiter
in the region is to ensure that.
A numeric argument to `C-x C-p' is used to specify which page to go
to, relative to the current one. Zero means the current page. One
means the next page, and -1 means the previous one.
The `C-x l' command (`count-lines-page') is good for deciding where
to break a page in two. It displays in the echo area the total number
of lines in the current page, and then divides it up into those
preceding the current line and those following, as in
Page has 96 (72+25) lines
Notice that the sum is off by one; this is correct if point is not at
the beginning of a line.
The variable `page-delimiter' controls where pages begin. Its value
is a regexp that matches the beginning of a line that separates pages.
The normal value of this variable is `"^\f"', which matches a formfeed
character at the beginning of a line.
File: emacs, Node: Filling, Next: Case, Prev: Pages, Up: Text
Filling Text
============
"Filling" text means breaking it up into lines that fit a specified
width. Emacs does filling in two ways. In Auto Fill mode, inserting
text with self-inserting characters also automatically fills it. There
are also explicit fill commands that you can use when editing text
leaves it unfilled. When you edit formatted text, you can specify a
style of filling for each portion of the text (*note Formatted Text::).
* Menu:
* Auto Fill:: Auto Fill mode breaks long lines automatically.
* Refill:: Keeping paragraphs filled.
* Fill Commands:: Commands to refill paragraphs and center lines.
* Fill Prefix:: Filling paragraphs that are indented
or in a comment, etc.
* Adaptive Fill:: How Emacs can determine the fill prefix automatically.
File: emacs, Node: Auto Fill, Next: Refill, Up: Filling
Auto Fill Mode
--------------
"Auto Fill" mode is a minor mode in which lines are broken
automatically when they become too wide. Breaking happens only when
you type a <SPC> or <RET>.
`M-x auto-fill-mode'
Enable or disable Auto Fill mode.
`<SPC>'
`<RET>'
In Auto Fill mode, break lines when appropriate.
`M-x auto-fill-mode' turns Auto Fill mode on if it was off, or off
if it was on. With a positive numeric argument it always turns Auto
Fill mode on, and with a negative argument always turns it off. You can
see when Auto Fill mode is in effect by the presence of the word `Fill'
in the mode line, inside the parentheses. Auto Fill mode is a minor
mode which is enabled or disabled for each buffer individually. *Note
Minor Modes::.
In Auto Fill mode, lines are broken automatically at spaces when they
get longer than the desired width. Line breaking and rearrangement
takes place only when you type <SPC> or <RET>. If you wish to insert a
space or newline without permitting line-breaking, type `C-q <SPC>' or
`C-q C-j' (recall that a newline is really a control-J). Also, `C-o'
inserts a newline without line breaking.
Auto Fill mode works well with programming-language modes, because it
indents new lines with <TAB>. If a line ending in a comment gets too
long, the text of the comment is split into two comment lines.
Optionally, new comment delimiters are inserted at the end of the first
line and the beginning of the second so that each line is a separate
comment; the variable `comment-multi-line' controls the choice (*note
Comments::).
Adaptive filling (*note Adaptive Fill::) works for Auto Filling as
well as for explicit fill commands. It takes a fill prefix
automatically from the second or first line of a paragraph.
Auto Fill mode does not refill entire paragraphs; it can break lines
but cannot merge lines. So editing in the middle of a paragraph can
result in a paragraph that is not correctly filled. The easiest way to
make the paragraph properly filled again is usually with the explicit
fill commands. *Note Fill Commands::.
Many users like Auto Fill mode and want to use it in all text files.
The section on init files says how to arrange this permanently for
yourself. *Note Init File::.
File: emacs, Node: Refill, Next: Fill Commands, Prev: Auto Fill, Up: Filling
Refill Mode
-----------
Refill minor mode provides support for keeping paragraphs filled as
you type or modify them in other ways. It provides an effect similar
to typical word processor behavior. This works by running a
paragraph-filling command at suitable times.
When you are typing text, only characters which normally trigger
auto filling, like the space character, will trigger refilling. This
is to avoid making it too slow. Apart from self-inserting characters,
other commands which modify the text cause refilling.
The current implementation is preliminary and probably not robust.
We expect to improve on it.
To toggle the use of Refill mode in the current buffer, type `M-x
refill-mode'.
File: emacs, Node: Fill Commands, Next: Fill Prefix, Prev: Refill, Up: Filling
Explicit Fill Commands
----------------------
`M-q'
Fill current paragraph (`fill-paragraph').
`C-x f'
Set the fill column (`set-fill-column').
`M-x fill-region'
Fill each paragraph in the region (`fill-region').
`M-x fill-region-as-paragraph'
Fill the region, considering it as one paragraph.
`M-s'
Center a line.
To refill a paragraph, use the command `M-q' (`fill-paragraph').
This operates on the paragraph that point is inside, or the one after
point if point is between paragraphs. Refilling works by removing all
the line-breaks, then inserting new ones where necessary.
To refill many paragraphs, use `M-x fill-region', which divides the
region into paragraphs and fills each of them.
`M-q' and `fill-region' use the same criteria as `M-h' for finding
paragraph boundaries (*note Paragraphs::). For more control, you can
use `M-x fill-region-as-paragraph', which refills everything between
point and mark. This command deletes any blank lines within the
region, so separate blocks of text end up combined into one block.
A numeric argument to `M-q' causes it to "justify" the text as well
as filling it. This means that extra spaces are inserted to make the
right margin line up exactly at the fill column. To remove the extra
spaces, use `M-q' with no argument. (Likewise for `fill-region'.)
Another way to control justification, and choose other styles of
filling, is with the `justification' text property; see *Note Format
Justification::.
The command `M-s' (`center-line') centers the current line within
the current fill column. With an argument N, it centers N lines
individually and moves past them.
The maximum line width for filling is in the variable `fill-column'.
Altering the value of `fill-column' makes it local to the current
buffer; until that time, the default value is in effect. The default
is initially 70. *Note Locals::. The easiest way to set `fill-column'
is to use the command `C-x f' (`set-fill-column'). With a numeric
argument, it uses that as the new fill column. With just `C-u' as
argument, it sets `fill-column' to the current horizontal position of
point.
Emacs commands normally consider a period followed by two spaces or
by a newline as the end of a sentence; a period followed by just one
space indicates an abbreviation and not the end of a sentence. To
preserve the distinction between these two ways of using a period, the
fill commands do not break a line after a period followed by just one
space.
If the variable `sentence-end-double-space' is `nil', the fill
commands expect and leave just one space at the end of a sentence.
Ordinarily this variable is `t', so the fill commands insist on two
spaces for the end of a sentence, as explained above. *Note
Sentences::.
If the variable `colon-double-space' is non-`nil', the fill commands
put two spaces after a colon.
Some languages do not use period to indicate end of sentence. For
example, a sentence in Thai text ends with double space but without a
period. Set the variable `sentence-end-without-period' to `t' to tell
the sentence commands that a period is not necessary.
File: emacs, Node: Fill Prefix, Next: Adaptive Fill, Prev: Fill Commands, Up: Filling
The Fill Prefix
---------------
To fill a paragraph in which each line starts with a special marker
(which might be a few spaces, giving an indented paragraph), you can use
the "fill prefix" feature. The fill prefix is a string that Emacs
expects every line to start with, and which is not included in filling.
You can specify a fill prefix explicitly; Emacs can also deduce the
fill prefix automatically (*note Adaptive Fill::).
`C-x .'
Set the fill prefix (`set-fill-prefix').
`M-q'
Fill a paragraph using current fill prefix (`fill-paragraph').
`M-x fill-individual-paragraphs'
Fill the region, considering each change of indentation as
starting a new paragraph.
`M-x fill-nonuniform-paragraphs'
Fill the region, considering only paragraph-separator lines as
starting a new paragraph.
To specify a fill prefix, move to a line that starts with the desired
prefix, put point at the end of the prefix, and give the command
`C-x .' (`set-fill-prefix'). That's a period after the `C-x'. To turn
off the fill prefix, specify an empty prefix: type `C-x .' with point
at the beginning of a line.
When a fill prefix is in effect, the fill commands remove the fill
prefix from each line before filling and insert it on each line after
filling. Auto Fill mode also inserts the fill prefix automatically when
it makes a new line. The `C-o' command inserts the fill prefix on new
lines it creates, when you use it at the beginning of a line (*note
Blank Lines::). Conversely, the command `M-^' deletes the prefix (if
it occurs) after the newline that it deletes (*note Indentation::).
For example, if `fill-column' is 40 and you set the fill prefix to
`;; ', then `M-q' in the following text
;; This is an
;; example of a paragraph
;; inside a Lisp-style comment.
produces this:
;; This is an example of a paragraph
;; inside a Lisp-style comment.
Lines that do not start with the fill prefix are considered to start
paragraphs, both in `M-q' and the paragraph commands; this gives good
results for paragraphs with hanging indentation (every line indented
except the first one). Lines which are blank or indented once the
prefix is removed also separate or start paragraphs; this is what you
want if you are writing multi-paragraph comments with a comment
delimiter on each line.
You can use `M-x fill-individual-paragraphs' to set the fill prefix
for each paragraph automatically. This command divides the region into
paragraphs, treating every change in the amount of indentation as the
start of a new paragraph, and fills each of these paragraphs. Thus,
all the lines in one "paragraph" have the same amount of indentation.
That indentation serves as the fill prefix for that paragraph.
`M-x fill-nonuniform-paragraphs' is a similar command that divides
the region into paragraphs in a different way. It considers only
paragraph-separating lines (as defined by `paragraph-separate') as
starting a new paragraph. Since this means that the lines of one
paragraph may have different amounts of indentation, the fill prefix
used is the smallest amount of indentation of any of the lines of the
paragraph. This gives good results with styles that indent a
paragraph's first line more or less that the rest of the paragraph.
The fill prefix is stored in the variable `fill-prefix'. Its value
is a string, or `nil' when there is no fill prefix. This is a
per-buffer variable; altering the variable affects only the current
buffer, but there is a default value which you can change as well.
*Note Locals::.
The `indentation' text property provides another way to control the
amount of indentation paragraphs receive. *Note Format Indentation::.
File: emacs, Node: Adaptive Fill, Prev: Fill Prefix, Up: Filling
Adaptive Filling
----------------
The fill commands can deduce the proper fill prefix for a paragraph
automatically in certain cases: either whitespace or certain punctuation
characters at the beginning of a line are propagated to all lines of the
paragraph.
If the paragraph has two or more lines, the fill prefix is taken from
the paragraph's second line, but only if it appears on the first line as
well.
If a paragraph has just one line, fill commands _may_ take a prefix
from that line. The decision is complicated because there are three
reasonable things to do in such a case:
* Use the first line's prefix on all the lines of the paragraph.
* Indent subsequent lines with whitespace, so that they line up
under the text that follows the prefix on the first line, but
don't actually copy the prefix from the first line.
* Don't do anything special with the second and following lines.
All three of these styles of formatting are commonly used. So the
fill commands try to determine what you would like, based on the prefix
that appears and on the major mode. Here is how.
If the prefix found on the first line matches
`adaptive-fill-first-line-regexp', or if it appears to be a
comment-starting sequence (this depends on the major mode), then the
prefix found is used for filling the paragraph, provided it would not
act as a paragraph starter on subsequent lines.
Otherwise, the prefix found is converted to an equivalent number of
spaces, and those spaces are used as the fill prefix for the rest of the
lines, provided they would not act as a paragraph starter on subsequent
lines.
In Text mode, and other modes where only blank lines and page
delimiters separate paragraphs, the prefix chosen by adaptive filling
never acts as a paragraph starter, so it can always be used for filling.
The variable `adaptive-fill-regexp' determines what kinds of line
beginnings can serve as a fill prefix: any characters at the start of
the line that match this regular expression are used. If you set the
variable `adaptive-fill-mode' to `nil', the fill prefix is never chosen
automatically.
You can specify more complex ways of choosing a fill prefix
automatically by setting the variable `adaptive-fill-function' to a
function. This function is called with point after the left margin of a
line, and it should return the appropriate fill prefix based on that
line. If it returns `nil', that means it sees no fill prefix in that
line.
File: emacs, Node: Case, Next: Text Mode, Prev: Filling, Up: Text
Case Conversion Commands
========================
Emacs has commands for converting either a single word or any
arbitrary range of text to upper case or to lower case.
`M-l'
Convert following word to lower case (`downcase-word').
`M-u'
Convert following word to upper case (`upcase-word').
`M-c'
Capitalize the following word (`capitalize-word').
`C-x C-l'
Convert region to lower case (`downcase-region').
`C-x C-u'
Convert region to upper case (`upcase-region').
The word conversion commands are the most useful. `M-l'
(`downcase-word') converts the word after point to lower case, moving
past it. Thus, repeating `M-l' converts successive words. `M-u'
(`upcase-word') converts to all capitals instead, while `M-c'
(`capitalize-word') puts the first letter of the word into upper case
and the rest into lower case. All these commands convert several words
at once if given an argument. They are especially convenient for
converting a large amount of text from all upper case to mixed case,
because you can move through the text using `M-l', `M-u' or `M-c' on
each word as appropriate, occasionally using `M-f' instead to skip a
word.
When given a negative argument, the word case conversion commands
apply to the appropriate number of words before point, but do not move
point. This is convenient when you have just typed a word in the wrong
case: you can give the case conversion command and continue typing.
If a word case conversion command is given in the middle of a word,
it applies only to the part of the word which follows point. This is
just like what `M-d' (`kill-word') does. With a negative argument,
case conversion applies only to the part of the word before point.
The other case conversion commands are `C-x C-u' (`upcase-region')
and `C-x C-l' (`downcase-region'), which convert everything between
point and mark to the specified case. Point and mark do not move.
The region case conversion commands `upcase-region' and
`downcase-region' are normally disabled. This means that they ask for
confirmation if you try to use them. When you confirm, you may enable
the command, which means it will not ask for confirmation again. *Note
Disabling::.
File: emacs, Node: Text Mode, Next: Outline Mode, Prev: Case, Up: Text
Text Mode
=========
When you edit files of text in a human language, it's more convenient
to use Text mode rather than Fundamental mode. To enter Text mode, type
`M-x text-mode'.
In Text mode, only blank lines and page delimiters separate
paragraphs. As a result, paragraphs can be indented, and adaptive
filling determines what indentation to use when filling a paragraph.
*Note Adaptive Fill::.
Text mode defines <TAB> to run `indent-relative' (*note
Indentation::), so that you can conveniently indent a line like the
previous line. When the previous line is not indented,
`indent-relative' runs `tab-to-tab-stop', which uses Emacs tab stops
that you can set (*note Tab Stops::).
Text mode turns off the features concerned with comments except when
you explicitly invoke them. It changes the syntax table so that periods
are not considered part of a word, while apostrophes, backspaces and
underlines are considered part of words.
If you indent the first lines of paragraphs, then you should use
Paragraph-Indent Text mode rather than Text mode. In this mode, you do
not need to have blank lines between paragraphs, because the first-line
indentation is sufficient to start a paragraph; however paragraphs in
which every line is indented are not supported. Use `M-x
paragraph-indent-text-mode' to enter this mode. Use `M-x
paragraph-indent-minor-mode' to enter an equivalent minor mode, for
instance during mail composition.
Text mode, and all the modes based on it, define `M-<TAB>' as the
command `ispell-complete-word', which performs completion of the
partial word in the buffer before point, using the spelling dictionary
as the space of possible words. *Note Spelling::.
Entering Text mode runs the hook `text-mode-hook'. Other major
modes related to Text mode also run this hook, followed by hooks of
their own; this includes Paragraph-Indent Text mode, Nroff mode, TeX
mode, Outline mode, and Mail mode. Hook functions on `text-mode-hook'
can look at the value of `major-mode' to see which of these modes is
actually being entered. *Note Hooks::.
Emacs provides two other modes for editing text that is to be passed
through a text formatter to produce fancy formatted printed output.
*Note Nroff Mode::, for editing input to the formatter nroff. *Note
TeX Mode::, for editing input to the formatter TeX.
Another mode is used for editing outlines. It allows you to view the
text at various levels of detail. You can view either the outline
headings alone or both headings and text; you can also hide some of the
headings at lower levels from view to make the high level structure more
visible. *Note Outline Mode::.
File: emacs, Node: Outline Mode, Next: TeX Mode, Prev: Text Mode, Up: Text
Outline Mode
============
Outline mode is a major mode much like Text mode but intended for
editing outlines. It allows you to make parts of the text temporarily
invisible so that you can see the outline structure. Type `M-x
outline-mode' to switch to Outline mode as the major mode of the current
buffer.
When Outline mode makes a line invisible, the line does not appear on
the screen. The screen appears exactly as if the invisible line were
deleted, except that an ellipsis (three periods in a row) appears at the
end of the previous visible line (only one ellipsis no matter how many
invisible lines follow).
Editing commands that operate on lines, such as `C-n' and `C-p',
treat the text of the invisible line as part of the previous visible
line. Killing an entire visible line, including its terminating
newline, really kills all the following invisible lines along with it.
Outline minor mode provides the same commands as the major mode,
Outline mode, but you can use it in conjunction with other major modes.
Type `M-x outline-minor-mode' to enable the Outline minor mode in the
current buffer. You can also specify this in the text of a file, with
a file local variable of the form `mode: outline-minor' (*note File
Variables::).
The major mode, Outline mode, provides special key bindings on the
`C-c' prefix. Outline minor mode provides similar bindings with `C-c
@' as the prefix; this is to reduce the conflicts with the major mode's
special commands. (The variable `outline-minor-mode-prefix' controls
the prefix used.)
Entering Outline mode runs the hook `text-mode-hook' followed by the
hook `outline-mode-hook' (*note Hooks::).
* Menu:
* Format: Outline Format. What the text of an outline looks like.
* Motion: Outline Motion. Special commands for moving through
outlines.
* Visibility: Outline Visibility. Commands to control what is visible.
* Views: Outline Views. Outlines and multiple views.
* Foldout:: Folding editing.
File: emacs, Node: Outline Format, Next: Outline Motion, Up: Outline Mode
Format of Outlines
------------------
Outline mode assumes that the lines in the buffer are of two types:
"heading lines" and "body lines". A heading line represents a topic in
the outline. Heading lines start with one or more stars; the number of
stars determines the depth of the heading in the outline structure.
Thus, a heading line with one star is a major topic; all the heading
lines with two stars between it and the next one-star heading are its
subtopics; and so on. Any line that is not a heading line is a body
line. Body lines belong with the preceding heading line. Here is an
example:
* Food
This is the body,
which says something about the topic of food.
** Delicious Food
This is the body of the second-level header.
** Distasteful Food
This could have
a body too, with
several lines.
*** Dormitory Food
* Shelter
Another first-level topic with its header line.
A heading line together with all following body lines is called
collectively an "entry". A heading line together with all following
deeper heading lines and their body lines is called a "subtree".
You can customize the criterion for distinguishing heading lines by
setting the variable `outline-regexp'. Any line whose beginning has a
match for this regexp is considered a heading line. Matches that start
within a line (not at the left margin) do not count. The length of the
matching text determines the level of the heading; longer matches make
a more deeply nested level. Thus, for example, if a text formatter has
commands `@chapter', `@section' and `@subsection' to divide the
document into chapters and sections, you could make those lines count
as heading lines by setting `outline-regexp' to
`"@chap\\|@\\(sub\\)*section"'. Note the trick: the two words
`chapter' and `section' are equally long, but by defining the regexp to
match only `chap' we ensure that the length of the text matched on a
chapter heading is shorter, so that Outline mode will know that
sections are contained in chapters. This works as long as no other
command starts with `@chap'.
You can change the rule for calculating the level of a heading line
by setting the variable `outline-level'. The value of `outline-level'
should be a function that takes no arguments and returns the level of
the current heading. Some major modes such as C, Nroff, and Emacs Lisp
mode set this variable and `outline-regexp' in order to work with
Outline minor mode.
File: emacs, Node: Outline Motion, Next: Outline Visibility, Prev: Outline Format, Up: Outline Mode
Outline Motion Commands
-----------------------
Outline mode provides special motion commands that move backward and
forward to heading lines.
`C-c C-n'
Move point to the next visible heading line
(`outline-next-visible-heading').
`C-c C-p'
Move point to the previous visible heading line
(`outline-previous-visible-heading').
`C-c C-f'
Move point to the next visible heading line at the same level as
the one point is on (`outline-forward-same-level').
`C-c C-b'
Move point to the previous visible heading line at the same level
(`outline-backward-same-level').
`C-c C-u'
Move point up to a lower-level (more inclusive) visible heading
line (`outline-up-heading').
`C-c C-n' (`outline-next-visible-heading') moves down to the next
heading line. `C-c C-p' (`outline-previous-visible-heading') moves
similarly backward. Both accept numeric arguments as repeat counts.
The names emphasize that invisible headings are skipped, but this is
not really a special feature. All editing commands that look for lines
ignore the invisible lines automatically.
More powerful motion commands understand the level structure of
headings. `C-c C-f' (`outline-forward-same-level') and `C-c C-b'
(`outline-backward-same-level') move from one heading line to another
visible heading at the same depth in the outline. `C-c C-u'
(`outline-up-heading') moves backward to another heading that is less
deeply nested.
File: emacs, Node: Outline Visibility, Next: Outline Views, Prev: Outline Motion, Up: Outline Mode
Outline Visibility Commands
---------------------------
The other special commands of outline mode are used to make lines
visible or invisible. Their names all start with `hide' or `show'.
Most of them fall into pairs of opposites. They are not undoable;
instead, you can undo right past them. Making lines visible or
invisible is simply not recorded by the undo mechanism.
`C-c C-t'
Make all body lines in the buffer invisible (`hide-body').
`C-c C-a'
Make all lines in the buffer visible (`show-all').
`C-c C-d'
Make everything under this heading invisible, not including this
heading itself (`hide-subtree').
`C-c C-s'
Make everything under this heading visible, including body,
subheadings, and their bodies (`show-subtree').
`C-c C-l'
Make the body of this heading line, and of all its subheadings,
invisible (`hide-leaves').
`C-c C-k'
Make all subheadings of this heading line, at all levels, visible
(`show-branches').
`C-c C-i'
Make immediate subheadings (one level down) of this heading line
visible (`show-children').
`C-c C-c'
Make this heading line's body invisible (`hide-entry').
`C-c C-e'
Make this heading line's body visible (`show-entry').
`C-c C-q'
Hide everything except the top N levels of heading lines
(`hide-sublevels').
`C-c C-o'
Hide everything except for the heading or body that point is in,
plus the headings leading up from there to the top level of the
outline (`hide-other').
Two commands that are exact opposites are `C-c C-c' (`hide-entry')
and `C-c C-e' (`show-entry'). They are used with point on a heading
line, and apply only to the body lines of that heading. Subheadings
and their bodies are not affected.
Two more powerful opposites are `C-c C-d' (`hide-subtree') and `C-c
C-s' (`show-subtree'). Both expect to be used when point is on a
heading line, and both apply to all the lines of that heading's
"subtree": its body, all its subheadings, both direct and indirect, and
all of their bodies. In other words, the subtree contains everything
following this heading line, up to and not including the next heading of
the same or higher rank.
Intermediate between a visible subtree and an invisible one is having
all the subheadings visible but none of the body. There are two
commands for doing this, depending on whether you want to hide the
bodies or make the subheadings visible. They are `C-c C-l'
(`hide-leaves') and `C-c C-k' (`show-branches').
A little weaker than `show-branches' is `C-c C-i' (`show-children').
It makes just the direct subheadings visible--those one level down.
Deeper subheadings remain invisible, if they were invisible.
Two commands have a blanket effect on the whole file. `C-c C-t'
(`hide-body') makes all body lines invisible, so that you see just the
outline structure. `C-c C-a' (`show-all') makes all lines visible.
These commands can be thought of as a pair of opposites even though
`C-c C-a' applies to more than just body lines.
The command `C-c C-q' (`hide-sublevels') hides all but the top level
headings. With a numeric argument N, it hides everything except the
top N levels of heading lines.
The command `C-c C-o' (`hide-other') hides everything except the
heading or body text that point is in, plus its parents (the headers
leading up from there to top level in the outline).
You can turn off the use of ellipses at the ends of visible lines by
setting `selective-display-ellipses' to `nil'. Then there is no
visible indication of the presence of invisible lines.
When incremental search finds text that is hidden by Outline mode,
it makes that part of the buffer visible. If you exit the search at
that position, the text remains visible.
File: emacs, Node: Outline Views, Next: Foldout, Prev: Outline Visibility, Up: Outline Mode
Viewing One Outline in Multiple Views
-------------------------------------
You can display two views of a single outline at the same time, in
different windows. To do this, you must create an indirect buffer using
`M-x make-indirect-buffer'. The first argument of this command is the
existing outline buffer name, and its second argument is the name to
use for the new indirect buffer. *Note Indirect Buffers::.
Once the indirect buffer exists, you can display it in a window in
the normal fashion, with `C-x 4 b' or other Emacs commands. The Outline
mode commands to show and hide parts of the text operate on each buffer
independently; as a result, each buffer can have its own view. If you
want more than two views on the same outline, create additional indirect
buffers.
File: emacs, Node: Foldout, Prev: Outline Views, Up: Outline Mode
Folding Editing
---------------
The Foldout package extends Outline mode and Outline minor mode with
"folding" commands. The idea of folding is that you zoom in on a
nested portion of the outline, while hiding its relatives at higher
levels.
Consider an Outline mode buffer all the text and subheadings under
level-1 headings hidden. To look at what is hidden under one of these
headings, you could use `C-c C-e' (`M-x show-entry') to expose the
body, or `C-c C-i' to expose the child (level-2) headings.
With Foldout, you use `C-c C-z' (`M-x foldout-zoom-subtree'). This
exposes the body and child subheadings, and narrows the buffer so that
only the level-1 heading, the body and the level-2 headings are
visible. Now to look under one of the level-2 headings, position the
cursor on it and use `C-c C-z' again. This exposes the level-2 body
and its level-3 child subheadings and narrows the buffer again. Zooming
in on successive subheadings can be done as much as you like. A string
in the mode line shows how deep you've gone.
When zooming in on a heading, to see only the child subheadings
specify a numeric argument: `C-u C-c C-z'. The number of levels of
children can be specified too (compare `M-x show-children'), e.g. `M-2
C-c C-z' exposes two levels of child subheadings. Alternatively, the
body can be specified with a negative argument: `M-- C-c C-z'. The
whole subtree can be expanded, similarly to `C-c C-s' (`M-x
show-subtree'), by specifying a zero argument: `M-0 C-c C-z'.
While you're zoomed in, you can still use Outline mode's exposure and
hiding functions without disturbing Foldout. Also, since the buffer is
narrowed, "global" editing actions will only affect text under the
zoomed-in heading. This is useful for restricting changes to a
particular chapter or section of your document.
To unzoom (exit) a fold, use `C-c C-x' (`M-x foldout-exit-fold').
This hides all the text and subheadings under the top-level heading and
returns you to the previous view of the buffer. Specifying a numeric
argument exits that many levels of folds. Specifying a zero argument
exits all folds.
To cancel the narrowing of a fold without hiding the text and
subheadings, specify a negative argument. For example, `M--2 C-c C-x'
exits two folds and leaves the text and subheadings exposed.
Foldout mode also provides mouse commands for entering and exiting
folds, and for showing and hiding text:
`M-C-Mouse-1' zooms in on the heading clicked on
single click: expose body.
double click: expose subheadings.
triple click: expose body and subheadings.
quad click: expose entire subtree.
`M-C-Mouse-2' exposes text under the heading clicked on
single click: expose body.
double click: expose subheadings.
triple click: expose body and subheadings.
quad click: expose entire subtree.
`M-C-Mouse-3' hides text under the heading clicked on or exits fold
single click: hide subtree.
double click: exit fold and hide text.
triple click: exit fold without hiding text.
quad click: exit all folds and hide text.
You can specify different modifier keys (instead of `Control-Meta-')
by setting `foldout-mouse-modifiers'; but if you have already loaded
the `foldout.el' library, you must reload it in order for this to take
effect.
To use the Foldout package, you can type `M-x load-library <RET>
foldout <RET>'; or you can arrange for to do that automatically by
putting this in your `.emacs' file:
(eval-after-load "outline" '(require 'foldout))
File: emacs, Node: TeX Mode, Next: Nroff Mode, Prev: Outline Mode, Up: Text
TeX Mode
========
TeX is a powerful text formatter written by Donald Knuth; it is also
free, like GNU Emacs. LaTeX is a simplified input format for TeX,
implemented by TeX macros; it comes with TeX. SliTeX is a special form
of LaTeX.(1)
Emacs has a special TeX mode for editing TeX input files. It
provides facilities for checking the balance of delimiters and for
invoking TeX on all or part of the file.
TeX mode has three variants, Plain TeX mode, LaTeX mode, and SliTeX
mode (these three distinct major modes differ only slightly). They are
designed for editing the three different formats. The command `M-x
tex-mode' looks at the contents of the buffer to determine whether the
contents appear to be either LaTeX input or SliTeX input; if so, it
selects the appropriate mode. If the file contents do not appear to be
LaTeX or SliTeX, it selects Plain TeX mode. If the contents are
insufficient to determine this, the variable `tex-default-mode'
controls which mode is used.
When `M-x tex-mode' does not guess right, you can use the commands
`M-x plain-tex-mode', `M-x latex-mode', and `M-x slitex-mode' to select
explicitly the particular variants of TeX mode.
* Menu:
* Editing: TeX Editing. Special commands for editing in TeX mode.
* LaTeX: LaTeX Editing. Additional commands for LaTeX input files.
* Printing: TeX Print. Commands for printing part of a file with TeX.
* Misc: TeX Misc. Customization of TeX mode, and related features.
---------- Footnotes ----------
(1) SliTeX is obsoleted by the `slides' document class in recent
LaTeX versions.
File: emacs, Node: TeX Editing, Next: LaTeX Editing, Up: TeX Mode
TeX Editing Commands
--------------------
Here are the special commands provided in TeX mode for editing the
text of the file.
`"'
Insert, according to context, either ```' or `"' or `'''
(`tex-insert-quote').
`C-j'
Insert a paragraph break (two newlines) and check the previous
paragraph for unbalanced braces or dollar signs
(`tex-terminate-paragraph').
`M-x tex-validate-region'
Check each paragraph in the region for unbalanced braces or dollar
signs.
`C-c {'
Insert `{}' and position point between them (`tex-insert-braces').
`C-c }'
Move forward past the next unmatched close brace (`up-list').
In TeX, the character `"' is not normally used; we use ```' to start
a quotation and `''' to end one. To make editing easier under this
formatting convention, TeX mode overrides the normal meaning of the key
`"' with a command that inserts a pair of single-quotes or backquotes
(`tex-insert-quote'). To be precise, this command inserts ```' after
whitespace or an open brace, `"' after a backslash, and `''' after any
other character.
If you need the character `"' itself in unusual contexts, use `C-q'
to insert it. Also, `"' with a numeric argument always inserts that
number of `"' characters. You can turn off the feature of `"'
expansion by eliminating that binding in the local map (*note Key
Bindings::).
In TeX mode, `$' has a special syntax code which attempts to
understand the way TeX math mode delimiters match. When you insert a
`$' that is meant to exit math mode, the position of the matching `$'
that entered math mode is displayed for a second. This is the same
feature that displays the open brace that matches a close brace that is
inserted. However, there is no way to tell whether a `$' enters math
mode or leaves it; so when you insert a `$' that enters math mode, the
previous `$' position is shown as if it were a match, even though they
are actually unrelated.
TeX uses braces as delimiters that must match. Some users prefer to
keep braces balanced at all times, rather than inserting them singly.
Use `C-c {' (`tex-insert-braces') to insert a pair of braces. It
leaves point between the two braces so you can insert the text that
belongs inside. Afterward, use the command `C-c }' (`up-list') to move
forward past the close brace.
There are two commands for checking the matching of braces. `C-j'
(`tex-terminate-paragraph') checks the paragraph before point, and
inserts two newlines to start a new paragraph. It outputs a message in
the echo area if any mismatch is found. `M-x tex-validate-region'
checks a region, paragraph by paragraph. The errors are listed in the
`*Occur*' buffer, and you can use `C-c C-c' or `Mouse-2' in that buffer
to go to a particular mismatch.
Note that Emacs commands count square brackets and parentheses in
TeX mode, not just braces. This is not strictly correct for the
purpose of checking TeX syntax. However, parentheses and square
brackets are likely to be used in text as matching delimiters and it is
useful for the various motion commands and automatic match display to
work with them.
File: emacs, Node: LaTeX Editing, Next: TeX Print, Prev: TeX Editing, Up: TeX Mode
LaTeX Editing Commands
----------------------
LaTeX mode, and its variant, SliTeX mode, provide a few extra
features not applicable to plain TeX.
`C-c C-o'
Insert `\begin' and `\end' for LaTeX block and position point on a
line between them (`tex-latex-block').
`C-c C-e'
Close the innermost LaTeX block not yet closed
(`tex-close-latex-block').
In LaTeX input, `\begin' and `\end' commands are used to group
blocks of text. To insert a `\begin' and a matching `\end' (on a new
line following the `\begin'), use `C-c C-o' (`tex-latex-block'). A
blank line is inserted between the two, and point is left there. You
can use completion when you enter the block type; to specify additional
block type names beyond the standard list, set the variable
`latex-block-names'. For example, here's how to add `theorem',
`corollary', and `proof':
(setq latex-block-names '("theorem" "corollary" "proof"))
In LaTeX input, `\begin' and `\end' commands must balance. You can
use `C-c C-e' (`tex-close-latex-block') to insert automatically a
matching `\end' to match the last unmatched `\begin'. It indents the
`\end' to match the corresponding `\begin'. It inserts a newline after
`\end' if point is at the beginning of a line.