This is Info file ../info/emacs, produced by Makeinfo-1.55 from the
input file emacs.texi.


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.  Invoke `M-x text-mode'
to enter Text mode.  In Text mode, TAB runs the function
`tab-to-tab-stop', which allows you to use arbitrary tab stops set with
`M-x edit-tab-stops' (*note Tab Stops::.).  Features concerned with
comments in programs are turned off in Text mode except when explicitly
invoked.  The syntax table is changed so that periods are not
considered part of a word, while apostrophes, backspaces and underlines
are part of words.

   A similar variant mode is Indented Text mode, intended for editing
text in which most lines are indented.  This mode defines TAB to run
`indent-relative' (*note Indentation::.), and makes Auto Fill indent
the lines it creates.  The result is that normally a line made by Auto
Filling, or by LFD, is indented just like the previous line.  In
Indented Text mode, only blank lines separate paragraphs--indented
lines continue the current paragraph.  Use `M-x indented-text-mode' to
select this mode.

   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 or Indented 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 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::.

* Menu:

  Emacs provides two other modes for editing text that is to be passed
through a text formatter to produce fancy formatted printed output.

* Nroff Mode::	  The major mode for editing input to the formatter nroff.
* TeX Mode::	  The major modes 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.

* Outline Mode::  The major mode for editing outlines.


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).

   All editing commands treat the text of the invisible line as part of
the previous visible line.  For example, `C-n' moves onto the next
visible line.  Killing an entire visible line, including its
terminating newline, really kills all the following invisible lines
along with it; yanking it all back yanks the invisible lines and they
remain invisible.

   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.


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'.

   It is possible to 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 in order to work with
Outline minor mode.

   Outline mode makes a line invisible by changing the newline before it
into an ASCII control-M (code 015).  Most editing commands that work on
lines treat an invisible line as part of the previous line because,
strictly speaking, it *is* part of that line, since there is no longer a
newline in between.  When you save the file in Outline mode, control-M
characters are saved as newlines, so the invisible lines become ordinary
lines in the file.  But saving does not change the visibility status of
a line inside Emacs.


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' (`next-visible-heading') moves down to the next heading
line.  `C-c C-p' (`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.


File: emacs,  Node: Outline Views,  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, by means of an alternative implementation of Outline
mode called `noutline'.

   To do this, first load the library `noutline' with `M-x load-library
RET noutline RET'.  This loads the alternative implementation of
Outline mode.  It provides the same command names and key bindings as
regular Outline mode, but it implements them differently.

   Then, to display a second view of an outline buffer, 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.

   In a future Emacs version, the alternative `noutline' implementation
will probably become the principal implementation.


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.

   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.
* Getting: TeX Distrib.   Getting the latest Unix TeX distribution.


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').

`LFD'
     Insert a paragraph break (two newlines) and check the previous
     paragraph for unbalanced braces or dollar signs
     (`tex-terminate-paragraph').

`M-x validate-tex-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.

   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.  LFD
(`tex-terminate-paragraph') checks the paragraph before point, and
inserts two newlines to start a new paragraph.  It prints a message in
the echo area if any mismatch is found.  `M-x validate-tex-region'
checks a region, paragraph by paragraph.  When it finds a paragraph that
contains a mismatch, it displays point at the beginning of the paragraph
for a few seconds and sets the mark at that spot.  Scanning continues
until the whole buffer has been checked or until you type another key.
Afterward, you can use the mark ring to find the last several paragraphs
that had mismatches (*note Mark Ring::.).

   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 last unended block for LaTeX (`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.


File: emacs,  Node: TeX Print,  Next: TeX Distrib,  Prev: LaTeX Editing,  Up: TeX Mode

TeX Printing Commands
---------------------

   You can invoke TeX as an inferior of Emacs on either the entire
contents of the buffer or just a region at a time.  Running TeX in this
way on just one chapter is a good way to see what your changes look
like without taking the time to format the entire file.

`C-c C-r'
     Invoke TeX on the current region, together with the buffer's header
     (`tex-region').

`C-c C-b'
     Invoke TeX on the entire current buffer (`tex-buffer').

`C-c TAB'
     Invoke BibTeX on the current file (`tex-bibtex-file').

`C-c C-f'
     Invoke TeX on the current file (`tex-file').

`C-c C-l'
     Recenter the window showing output from the inferior TeX so that
     the last line can be seen (`tex-recenter-output-buffer').

`C-c C-k'
     Kill the TeX subprocess (`tex-kill-job').

`C-c C-p'
     Print the output from the last `C-c C-r', `C-c C-b', or `C-c C-f'
     command (`tex-print').

`C-c C-v'
     Preview the output from the last `C-c C-r', `C-c C-b', or `C-c
     C-f' command (`tex-view').

`C-c C-q'
     Show the printer queue (`tex-show-print-queue').

   You can pass the current buffer through an inferior TeX by means of
`C-c C-b' (`tex-buffer').  The formatted output appears in a temporary
file; to print it, type `C-c C-p' (`tex-print').  Afterward, you can
use `C-c C-q' (`tex-show-print-queue') to view the progress of your
output towards being printed.  If your terminal has the ability to
display TeX output files, you can preview the output on the terminal
with `C-c C-v' (`tex-view').

   You can specify the directory to use for running TeX by setting the
variable `tex-directory'.  `"."' is the default value.  If your
environment variable `TEXINPUTS' contains relative directory names, or
if your files contains `\input' commands with relative file names, then
`tex-directory' *must* be `"."' or you will get the wrong results.
Otherwise, it is safe to specify some other directory, such as `"/tmp"'.

   If you want to specify which shell commands are used in the inferior
TeX, you can do so by setting the values of the variables
`tex-run-command', `latex-run-command', `slitex-run-command',
`tex-dvi-print-command', `tex-dvi-view-command', and
`tex-show-queue-command'.  You *must* set the value of
`tex-dvi-view-command' for your particular terminal; this variable has
no default value.  The other variables have default values that may (or
may not) be appropriate for your system.

   Normally, the file name given to these commands comes at the end of
the command string; for example, `latex FILENAME'.  In some cases,
however, the file name needs to be embedded in the command; an example
is when you need to provide the file name as an argument to one command
whose output is piped to another.  You can specify where to put the
file name with `*' in the command string.  For example,

     (setq tex-dvi-print-command "dvips -f * | lpr")

   The terminal output from TeX, including any error messages, appears
in a buffer called `*tex-shell*'.  If TeX gets an error, you can switch
to this buffer and feed it input (this works as in Shell mode; *note
Interactive Shell::.).  Without switching to this buffer you can scroll
it so that its last line is visible by typing `C-c C-l'.

   Type `C-c C-k' (`tex-kill-job') to kill the TeX process if you see
that its output is no longer useful.  Using `C-c C-b' or `C-c C-r' also
kills any TeX process still running.

   You can also pass an arbitrary region through an inferior TeX by
typing `C-c C-r' (`tex-region').  This is tricky, however, because most
files of TeX input contain commands at the beginning to set parameters
and define macros, without which no later part of the file will format
correctly.  To solve this problem, `C-c C-r' allows you to designate a
part of the file as containing essential commands; it is included before
the specified region as part of the input to TeX.  The designated part
of the file is called the "header".

   To indicate the bounds of the header in Plain TeX mode, you insert
two special strings in the file.  Insert `%**start of header' before the
header, and `%**end of header' after it.  Each string must appear
entirely on one line, but there may be other text on the line before or
after.  The lines containing the two strings are included in the header.
If `%**start of header' does not appear within the first 100 lines of
the buffer, `C-c C-r' assumes that there is no header.

   In LaTeX mode, the header begins with `\documentstyle' and ends with
`\begin{document}'.  These are commands that LaTeX requires you to use
in any case, so nothing special needs to be done to identify the header.

   The commands (`tex-buffer') and (`tex-region') do all of their work
in a temporary directory, and do not have available any of the auxiliary
files needed by TeX for cross-references; these commands are generally
not suitable for running the final copy in which all of the
cross-references need to be correct.  When you want the auxiliary
files, use `C-c C-f' (`tex-file') which runs TeX on the current
buffer's file, in that file's directory.  Before TeX runs, you will be
asked about saving any modified buffers.  Generally, you need to use
(`tex-file') twice to get cross-references correct.

   For LaTeX files, you can use BibTeX to process the auxiliary file
for the current buffer's file.  BibTeX looks up bibliographic citations
in a data base and prepares the cited references for the bibliography
section.  The command `C-c TAB' (`tex-bibtex-file') runs the shell
command (`tex-bibtex-command') to produce a `.bbl' file for the current
buffer's file.  Generally, you need to do `C-c C-f' (`tex-file') once
to generate the `.aux' file, then do `C-c TAB' (`tex-bibtex-file'), and
then repeat `C-c C-f' (`tex-file') twice more to get the
cross-references correct.

   Entering any kind of TeX mode runs the hooks `text-mode-hook' and
`tex-mode-hook'.  Then it runs either `plain-tex-mode-hook' or
`latex-mode-hook', whichever is appropriate.  For SliTeX files, it
calls `slitex-mode-hook'.  Starting the TeX shell runs the hook
`tex-shell-hook'.  *Note Hooks::.


File: emacs,  Node: TeX Distrib,  Prev: TeX Print,  Up: TeX Mode

Unix TeX Distribution
---------------------

   TeX for Unix systems can be obtained from the University of
Washington for a distribution fee.

   To order a full distribution, specify whether you prefer 1/4 inch
QIC-24 or 4mm DAT tape (9-track reel-to-reel is no longer available)
and send $210.00 for a (tar or cpio) cartridge, payable to the
University of Washington to:

     Pierre MacKay
     Department of Classics
     Denny Hall, Mail Stop DH-10
     University of Washington
     Seattle, Washington 98195

Purchase orders are acceptable, but there is an extra charge of $10.00,
to pay for processing charges.

For overseas orders please add $20.00 to the base cost for shipment via
air parcel post, or $30.00 for shipment via courier.

   The normal distribution is a tar tape, blocked 20, 1600 bpi, on an
industry standard 2400 foot half-inch reel.  The physical format for the
1/4 inch streamer cartridges is QIC-24.  System V tapes can be written
in cpio format, blocked 5120 bytes, with ASCII headers.


File: emacs,  Node: Nroff Mode,  Next: Formatted Text,  Prev: TeX Mode,  Up: Text

Nroff Mode
==========

   Nroff mode is a mode like Text mode but modified to handle nroff
commands present in the text.  Invoke `M-x nroff-mode' to enter this
mode.  It differs from Text mode in only a few ways.  All nroff command
lines are considered paragraph separators, so that filling will never
garble the nroff commands.  Pages are separated by `.bp' commands.
Comments start with backslash-doublequote.  Also, three special
commands are provided that are not in Text mode:

`M-n'
     Move to the beginning of the next line that isn't an nroff command
     (`forward-text-line').  An argument is a repeat count.

`M-p'
     Like `M-n' but move up (`backward-text-line').

`M-?'
     Prints in the echo area the number of text lines (lines that are
     not nroff commands) in the region (`count-text-lines').

   The other feature of Nroff mode is that you can turn on Electric
Nroff mode.  This is a minor mode that you can turn on or off with `M-x
electric-nroff-mode' (*note Minor Modes::.).  When the mode is on, each
time you use RET to end a line that contains an nroff command that
opens a kind of grouping, the matching nroff command to close that
grouping is automatically inserted on the following line.  For example,
if you are at the beginning of a line and type `. ( b RET', this
inserts the matching command `.)b' on a new line following point.

   If you use Outline minor mode with Nroff mode (*note Outline
Mode::.), heading lines are lines of the form `.H' followed by a number
(the header level).

   Entering Nroff mode runs the hook `text-mode-hook', followed by the
hook `nroff-mode-hook' (*note Hooks::.).


File: emacs,  Node: Formatted Text,  Prev: Nroff Mode,  Up: Text

Editing Formatted Text
======================

   "Enriched mode" is a minor mode for editing files that contain
formatted text in WYSIWYG fashion, as in a word processor.  Currently,
formatted text in Enriched mode can specify fonts, colors, underlining,
margins, and types of filling and justification.  In the future, we plan
to implement other formatting features as well.

   Enriched mode is a minor mode (*note Minor Modes::.).  Typically it
is used in conjunction with Text mode (*note Text Mode::.).  However,
you can also use it with other major modes such as Outline mode and
Indented Text mode.

   Potentially, Emacs can store formatted text files in various file
formats.  Currently, only one format is implemented: "text/enriched"
format, which is defined by the MIME protocol.  *Note Format
Conversion: (elisp)Format Conversion, for details of how Emacs
recognizes and converts file formats.

   The Emacs distribution contains a formatted text file that can serve
as an example.  Its name is `etc/enriched.doc'.  It contains samples
illustrating all the features described in this section.  It also
contains a list of ideas for future enhancements.

* Menu:

* Requesting Formatted Text::   Entering and exiting Enriched mode.
* Hard and Soft Newlines::      There are two different kinds of newlines.
* Editing Format Info::         How to edit text properties.
* Faces: Format Faces.          Bold, italic, underline, etc.
* Color: Format Colors.         Changing the color of text.
* Indent: Format Indentation.   Changing the left and right margins.
* Justification: Format Justification.
                                Centering, setting text flush with the
                                  left or right margin, etc.
* Other: Format Properties.     The "special" text properties submenu.
* Forcing Enriched Mode::       How to force use of Enriched mode.


File: emacs,  Node: Requesting Formatted Text,  Next: Hard and Soft Newlines,  Up: Formatted Text

Requesting to Edit Formatted Text
---------------------------------

   Whenever you visit a file that Emacs saved in the text/enriched
format, Emacs automatically converts the formatting information in the
file into Emacs's own internal format (text properties), and turns on
Enriched mode.

   To create a new file of formatted text, first visit the nonexistent
file, then type `M-x enriched-mode' before you start inserting text.
This command turns on Enriched mode.  Do this before you begin inserting
text, to ensure that the text you insert is handled properly.

   More generally, the command `enriched-mode' turns Enriched mode on
if it was off, and off if it was on.  With a prefix argument, this
command turns Enriched mode on if the argument is positive, and turns
the mode off otherwise.

   When you save a buffer while Enriched mode is enabled in it, Emacs
automatically converts the text to text/enriched format while writing it
into the file.  When you visit the file again, Emacs will automatically
recognize the format, reconvert the text, and turn on Enriched mode
again.

   Normally, after reading a file in text/enriched format, Emacs refills
each paragraph to fit the width of the window.  You can turn off this
refilling, to save time, by setting the variable
`enriched-fill-after-visiting' to `nil' or to `ask'.

   In any case, if the window width is the same as the width with which
the file was saved, Emacs trusts that the file is already properly
filled.

   You can add annotations for saving additional text properties, which
Emacs normally does not save, by adding to `enriched-translations'.
Note that the text/enriched standard requires any non-standard
annotations to have names starting with `x-', as in `x-read-only'.
This ensures that they will not conflict with standard annotations that
may be added later.


File: emacs,  Node: Hard and Soft Newlines,  Next: Editing Format Info,  Prev: Requesting Formatted Text,  Up: Formatted Text

Hard and Soft Newlines
----------------------

   In formatted text, Emacs distinguishes between two different kinds of
newlines, "hard" newlines and "soft" newlines.

   Hard newlines are used to separate paragraphs, or items in a list, or
anywhere that there should always be a line break regardless of the
margins.  The `RET' command (`newline') and `C-o' (`open-line') insert
hard newlines.

   Soft newlines are used to make text fit between the margins.  All the
fill commands, including Auto Fill, insert soft newlines--and they
delete only soft newlines.

   Although hard and soft newlines look the same, it is important to
bear the difference in mind.  Do not use RET to break lines in the
middle of filled paragraphs, or else you will get hard newlines that are
barriers to further filling.  Instead, let Auto Fill mode break lines,
so that if the text or the margins change, Emacs can refill the lines
properly.  *Note Auto Fill::.

   On the other hand, in tables and lists, where the lines should always
remain as you type them, you can use RET to end lines.  For these
lines, you may also want to set the justification style to `unfilled'.
*Note Format Justification::.


File: emacs,  Node: Editing Format Info,  Next: Format Faces,  Prev: Hard and Soft Newlines,  Up: Formatted Text

Editing Format Information
--------------------------

   There are two ways to alter the formatting information for a
formatted text file: with keyboard commands, and with the mouse.

   The easiest way to add properties to your document is by using the
Text Properties menu.  You can get to this menu in two ways: from the
Edit menu in the menu bar, or with `C-mouse-2' (hold the CTRL key and
press the middle mouse button).

   Most of the items in the Text Properties menu lead to other submenus.
These are described in the sections that follow.  Some items run
commands directly:

`Remove Properties'
     Delete from the region all the text properties that the Text
     Properties menu works with (`facemenu-remove-props').

`Remove All'
     Delete *all* text properties from the region
     (`facemenu-remove-all').

`List Properties'
     List all the text properties of the character following point
     (`list-text-properties-at').

`Display Faces'
     Display a list of all the defined faces.

`Display Colors'
     Display a list of all the defined colors.


File: emacs,  Node: Format Faces,  Next: Format Colors,  Prev: Editing Format Info,  Up: Formatted Text

Faces in Formatted Text
-----------------------

   The Faces submenu lists various Emacs faces including `bold',
`italic', and `underline'.  Selecting one of these adds the chosen face
to the region.  *Note Faces::.  You can also specify a face with these
keyboard commands:

`M-g d'
     Set the region, or the next inserted character, to the `default'
     face (`facemenu-set-default').

`M-g b'
     Set the region, or the next inserted character, to the `bold' face
     (`facemenu-set-bold').

`M-g i'
     Set the region, or the next inserted character, to the `italic'
     face (`facemenu-set-italic').

`M-g l'
     Set the region, or the next inserted character, to the
     `bold-italic' face (`facemenu-set-bold-italic').

`M-g u'
     Set the region, or the next inserted character, to the `underline'
     face (`facemenu-set-underline').

`M-g o FACE RET'
     Set the region, or the next inserted character, to the face FACE
     (`facemenu-set-face').

   If you use these commands with a prefix argument--or, in Transient
Mark mode, if the region is not active--then these commands specify a
face to use for your next self-inserting input.  *Note Transient
Mark::.  This applies to both the keyboard commands and the menu
commands.

   Enriched mode defines two additional faces: `excerpt' and `fixed'.
These correspond to codes used in the text/enriched file format.

   The `excerpt' face is intended for quotations.  This face is the
same as `italic' unless you customize it (*note Modifying Faces::.).

   The `fixed' face is meant to say, "Use a fixed-width font for this
part of the text."  Emacs currently supports only fixed-width fonts;
therefore, the `fixed' annotation is not necessary now.  However, we
plan to support variable width fonts in future Emacs versions, and
other systems that display text/enriched format may not use a
fixed-width font as the default.  So if you specifically want a certain
part of the text to use a fixed-width font, you should specify the
`fixed' face for that part.

   The `fixed' face is normally defined to use a different font from
the default.  However, systems have different fonts installed, you may
need to customize this.

   If your terminal cannot display different faces, you will not be able
to see them, but you can still edit documents containing faces.  You can
even add faces and colors to documents.  They will be visible when the
file is viewed on a terminal that can display them.


File: emacs,  Node: Format Colors,  Next: Format Indentation,  Prev: Format Faces,  Up: Formatted Text

Colors in Formatted Text
------------------------

   You can specify foreground and background colors for portions of the
text.  There is a menu for specifying the foreground color and a menu
for specifying the background color.  Each color menu lists all the
colors that you have used in Enriched mode in the current Emacs session.

   If you specify a color with a prefix argument--or, in Transient Mark
mode, if the region is not active--then it applies to your next
self-inserting input.  *Note Transient Mark::.  Otherwise, the command
applies to the region.

   Each color menu contains one additional item: `Other'.  You can use
this item to specify a color that is not listed in the menu; it reads
the color name with the minibuffer.  To display list of available colors
and their names, use the `Display Colors' menu item in the Text
Properties menu (*note Editing Format Info::.).

   Any color that you specify in this way, or that is mentioned in a
formatted text file that you read in, is added to both color menus for
the duration of the Emacs session.

   There are no key bindings for specifying colors, but you can do so
with the extended commands `M-x facemenu-set-foreground' and `M-x
facemenu-set-background'.  Both of these commands read the name of the
color with the minibuffer.


File: emacs,  Node: Format Indentation,  Next: Format Justification,  Prev: Format Colors,  Up: Formatted Text

Indentation in Formatted Text
-----------------------------

   When editing formatted text, you can specify different amounts of
indentation for the right or left margin of an entire paragraph or a
part of a paragraph.  The margins you specify automatically affect the
Emacs fill commands (*note Filling::.) and line-breaking commands.

   The Indentation submenu provides a convenient interface for
specifying these properties.  The submenu contains four items:

`Indent More'
     Indent the region by 4 columns (`increase-left-margin').  In
     Enriched mode, this command is also available on `C-x TAB'; if you
     supply a numeric argument, that says how many columns to add to the
     margin (a negative argument reduces the number of columns).

`Indent Less'
     Remove 4 columns of indentation from the region.

`Indent Right More'
     Make the text narrower by indenting 4 columns at the right margin.

`Indent Right Less'
     Remove 4 columns of indentation from the right margin.

   You can use these commands repeatedly to increase or decrease the
indentation.

   The most common way to use these commands is to change the
indentation of an entire paragraph.  However, that is not the only use.
You can change the margins at any point; the new values take effect at
the end of the line (for right margins) or the beginning of the next
line (for left margins).

   This makes it possible to format paragraphs with "hanging indents",
which means that the first line is indented less than subsequent lines.
To set up a hanging indent, increase the indentation of the region
starting after the first word of the paragraph and running until the end
of the paragraph.

   Indenting the first line of a paragraph is easier.  Set the margin
for the whole paragraph where you want it to be for the body of the
paragraph, then indent the first line by inserting extra spaces or tabs.

   Sometimes, as a result of editing, the filling of a paragraph becomes
messed up--parts of the paragraph may extend past the left or right
margins.  When this happens, use `M-q' (`fill-paragraph') to refill the
paragraph.

   The variable `standard-indent' specifies how many columns these
commands should add to or subtract from the indentation.  The default
value is 4.

   Enriched mode automatically sets the variable `fill-column' based on
the window width: it leaves a certain number of columns for the right
margin.  The variable `enriched-default-right-margin' says how many
columns.  The default value is 10.


File: emacs,  Node: Format Justification,  Next: Format Properties,  Prev: Format Indentation,  Up: Formatted Text

Justification in Formatted Text
-------------------------------

   When editing formatted text, you can specify various styles of
justification for a paragraph.  The style you specify automatically
affects the Emacs fill commands.

   The Justification submenu provides a convenient interface for
specifying the style.  The submenu contains five items:

`Flush Left'
     This is the most common style of justification (at least for
     English).  Lines are aligned at the left margin but left uneven at
     the right.

`Flush Right'
     This aligns each line with the right margin.  Spaces and tabs are
     added on the left, if necessary, to make lines line up on the
     right.

`Full'
     This justifies the text, aligning both edges of each line.
     Justified text looks very nice in a printed book, where the spaces
     can all be adjusted equally, but it does not look as nice with a
     fixed-width font on the screen.  Perhaps a future version of Emacs
     will be able to adjust the width of spaces in a line to achieve
     elegant justification.

`Center'
     This centers every line between the current margins.

`None'
     This turns off filling entirely.  Each line will remain as you
     wrote it; the fill and auto-fill functions will have no effect on
     text which has this setting.  You can, however, still indent the
     left margin.  In unfilled regions, all newlines are treated as
     hard newlines (*note Hard and Soft Newlines::.) .

   In Enriched mode, you can also specify justification from the
keyboard using the `M-j' prefix character:

`M-j l'
     Make the region left-filled (`set-justification-left').

`M-j r'
     Make the region right-filled (`set-justification-right').

`M-j f'
     Make the region fully-justified (`set-justification-full').

`M-j c'
`M-S'
     Make the region centered (`set-justification-center').

`M-j u'
     Make the region unfilled (`set-justification-none').

   Justification styles apply to entire paragraphs.  All the
justification-changing commands operate on the paragraph containing
point, or, if the region is active, on all paragraphs which overlap the
region.

   The default justification style is specified by the variable
`default-justification'.  Its value should be one of the symbols
`left', `right', `full', `center', or `none'.


File: emacs,  Node: Format Properties,  Next: Forcing Enriched Mode,  Prev: Format Justification,  Up: Formatted Text

Setting Other Text Properties
-----------------------------

   The Other Properties menu lets you add or remove three other useful
text properties: `read-only', `invisible' and `intangible'.  The
`intangible' property disallows moving point within the text, the
`invisible' text property hides text from display, and the `read-only'
property disallows alteration of the text.

   Each of these special properties has a menu item to add it to the
region.  The last menu item, `Remove Special', removes all of these
special properties from the text in the region.

   Currently, the `invisible' and `intangible' properties are *not*
saved in the text/enriched format.  The `read-only' property is saved,
but it is not a standard part of the text/enriched format, so other
editors may not respect it.


File: emacs,  Node: Forcing Enriched Mode,  Prev: Format Properties,  Up: Formatted Text

Forcing Enriched Mode
---------------------

   Normally, Emacs knows when you are editing formatted text because it
recognizes the special annotations used in the file that you visited.
However, there are situations in which you must take special actions to
convert file contents or turn on Enriched mode:

   * When you visit a file that was created with some other editor,
     Emacs may not recognize the file as being in the text/enriched
     format.  In this case, when you visit the file you will see the
     formatting commands rather than the formatted text.  Type `M-x
     format-decode-buffer' to translate it.

   * When you *insert* a file into a buffer, rather than visiting it.
     Emacs does the necessary conversions on the text which you insert,
     but it does not enable Enriched mode.  If you wish to do that,
     type `M-x enriched-mode'.

   The command `format-decode-buffer' translates text in various
formats into Emacs's internal format.  It asks you to specify the format
to translate from; however, normally you can type just RET, which tells
Emacs to guess the format.

   If you wish to look at a file in text/enriched format in its raw
form, as a sequence of characters with no formatting, use `M-x
format-find-file RET FILENAME RET RET'.  The empty second argument
means, "read without format conversion."

