display.texi 207 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1
@c -*-texinfo-*-
Richard M. Stallman's avatar
Richard M. Stallman committed
2
@c This is part of the GNU Emacs Lisp Reference Manual.
3
@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001,
4
@c   2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
5 6
@c See the file elisp.texi for copying conditions.
@setfilename ../info/display
7
@node Display, System Interface, Processes, Top
Richard M. Stallman's avatar
Richard M. Stallman committed
8 9 10 11 12 13 14
@chapter Emacs Display

  This chapter describes a number of features related to the display
that Emacs presents to the user.

@menu
* Refresh Screen::      Clearing the screen and redrawing everything on it.
15
* Forcing Redisplay::   Forcing redisplay.
Richard M. Stallman's avatar
Richard M. Stallman committed
16
* Truncation::          Folding or wrapping long text lines.
17
* The Echo Area::       Displaying messages at the bottom of the screen.
18
* Warnings::            Displaying warning messages for the user.
Karl Heuer's avatar
Karl Heuer committed
19 20
* Invisible Text::      Hiding part of the buffer text.
* Selective Display::   Hiding part of the buffer text (the old way).
Richard M. Stallman's avatar
Richard M. Stallman committed
21
* Temporary Displays::  Displays that go away automatically.
22
* Overlays::            Use overlays to highlight parts of the buffer.
Phillip Rulon's avatar
Phillip Rulon committed
23
* Width::               How wide a character or string is on the screen.
24
* Line Height::         Controlling the height of lines.
25
* Faces::               A face defines a graphics style for text characters:
Phillip Rulon's avatar
Phillip Rulon committed
26
                          font, colors, etc.
27
* Fringes::             Controlling window fringes.
28
* Scroll Bars::         Controlling vertical scroll bars.
29 30
* Display Property::    Enabling special display features.
* Images::              Displaying images in Emacs buffers.
31
* Buttons::             Adding clickable buttons to Emacs buffers.
32
* Abstract Display::    Emacs' Widget for Object Collections.
Richard M. Stallman's avatar
Richard M. Stallman committed
33
* Blinking::            How Emacs shows the matching open parenthesis.
34 35
* Usual Display::       The usual conventions for displaying nonprinting chars.
* Display Tables::      How to specify other conventions.
Richard M. Stallman's avatar
Richard M. Stallman committed
36 37 38 39 40 41 42
* Beeping::             Audible signal to the user.
* Window Systems::      Which window system is being used.
@end menu

@node Refresh Screen
@section Refreshing the Screen

43 44 45
  The function @code{redraw-frame} clears and redisplays the entire
contents of a given frame (@pxref{Frames}).  This is useful if the
screen is corrupted.
Richard M. Stallman's avatar
Richard M. Stallman committed
46 47 48 49 50 51

@c Emacs 19 feature
@defun redraw-frame frame
This function clears and redisplays frame @var{frame}.
@end defun

52
  Even more powerful is @code{redraw-display}:
Richard M. Stallman's avatar
Richard M. Stallman committed
53 54 55 56 57

@deffn Command redraw-display
This function clears and redisplays all visible frames.
@end deffn

58 59
  This function calls for redisplay of certain windows, the next time
redisplay is done, but does not clear them first.
60

61
@defun force-window-update &optional object
62 63 64
This function forces redisplay of some or all windows.  If
@var{object} is a window, it forces redisplay of that window.  If
@var{object} is a buffer or buffer name, it forces redisplay of all
65 66
windows displaying that buffer.  If @var{object} is @code{nil} (or
omitted), it forces redisplay of all windows.
67 68
@end defun

Karl Heuer's avatar
Karl Heuer committed
69 70 71 72 73
  Processing user input takes absolute priority over redisplay.  If you
call these functions when input is available, they do nothing
immediately, but a full redisplay does happen eventually---after all the
input has been processed.

Richard M. Stallman's avatar
Richard M. Stallman committed
74 75 76 77
  Normally, suspending and resuming Emacs also refreshes the screen.
Some terminal emulators record separate contents for display-oriented
programs such as Emacs and for ordinary sequential display.  If you are
using such a terminal, you might want to inhibit the redisplay on
Richard M. Stallman's avatar
Richard M. Stallman committed
78
resumption.
Richard M. Stallman's avatar
Richard M. Stallman committed
79 80 81 82 83

@defvar no-redraw-on-reenter
@cindex suspend (cf. @code{no-redraw-on-reenter})
@cindex resume (cf. @code{no-redraw-on-reenter})
This variable controls whether Emacs redraws the entire screen after it
84
has been suspended and resumed.  Non-@code{nil} means there is no need
85
to redraw, @code{nil} means redrawing is needed.  The default is @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
86 87
@end defvar

88 89 90 91 92 93 94 95 96 97 98 99 100
@node Forcing Redisplay
@section Forcing Redisplay
@cindex forcing redisplay

  Emacs redisplay normally stops if input arrives, and does not happen
at all if input is available before it starts.  Most of the time, this
is exactly what you want.  However, you can prevent preemption by
binding @code{redisplay-dont-pause} to a non-@code{nil} value.

@tindex redisplay-dont-pause
@defvar redisplay-dont-pause
If this variable is non-@code{nil}, pending input does not
prevent or halt redisplay; redisplay occurs, and finishes,
101
regardless of whether input is available.
102 103 104 105 106 107 108 109 110 111 112
@end defvar

  You can request a display update, but only if no input is pending,
with @code{(sit-for 0)}.  To force a display update even when input is
pending, do this:

@example
(let ((redisplay-dont-pause t))
  (sit-for 0))
@end example

Richard M. Stallman's avatar
Richard M. Stallman committed
113 114 115 116 117 118 119 120 121 122 123 124
@node Truncation
@section Truncation
@cindex line wrapping
@cindex continuation lines
@cindex @samp{$} in display
@cindex @samp{\} in display

  When a line of text extends beyond the right edge of a window, the
line can either be continued on the next screen line, or truncated to
one screen line.  The additional screen lines used to display a long
text line are called @dfn{continuation} lines.  Normally, a @samp{$} in
the rightmost column of the window indicates truncation; a @samp{\} on
125 126 127
the rightmost column indicates a line that ``wraps'' onto the next line,
which is also called @dfn{continuing} the line.  (The display table can
specify alternative indicators; see @ref{Display Tables}.)
Richard M. Stallman's avatar
Richard M. Stallman committed
128

129
  On a graphical display, the @samp{$} and @samp{\} indicators are
130
replaced with arrow images displayed in the window fringes
131
(@pxref{Fringes}).
132

Richard M. Stallman's avatar
Richard M. Stallman committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
  Note that continuation is different from filling; continuation happens
on the screen only, not in the buffer contents, and it breaks a line
precisely at the right margin, not at a word boundary.  @xref{Filling}.

@defopt truncate-lines
This buffer-local variable controls how Emacs displays lines that extend
beyond the right edge of the window.  The default is @code{nil}, which
specifies continuation.  If the value is non-@code{nil}, then these
lines are truncated.

If the variable @code{truncate-partial-width-windows} is non-@code{nil},
then truncation is always used for side-by-side windows (within one
frame) regardless of the value of @code{truncate-lines}.
@end defopt

Karl Heuer's avatar
Karl Heuer committed
148
@defopt default-truncate-lines
Richard M. Stallman's avatar
Richard M. Stallman committed
149
This variable is the default value for @code{truncate-lines}, for
150
buffers that do not have buffer-local values for it.
Karl Heuer's avatar
Karl Heuer committed
151
@end defopt
Richard M. Stallman's avatar
Richard M. Stallman committed
152 153 154 155 156 157 158 159

@defopt truncate-partial-width-windows
This variable controls display of lines that extend beyond the right
edge of the window, in side-by-side windows (@pxref{Splitting Windows}).
If it is non-@code{nil}, these lines are truncated; otherwise,
@code{truncate-lines} says what to do with them.
@end defopt

160 161 162
  When horizontal scrolling (@pxref{Horizontal Scrolling}) is in use in
a window, that forces truncation.

163
  If your buffer contains @emph{very} long lines, and you use
Karl Heuer's avatar
Karl Heuer committed
164
continuation to display them, just thinking about them can make Emacs
Karl Heuer's avatar
Karl Heuer committed
165 166 167
redisplay slow.  The column computation and indentation functions also
become slow.  Then you might find it advisable to set
@code{cache-long-line-scans} to @code{t}.
Karl Heuer's avatar
Karl Heuer committed
168 169 170

@defvar cache-long-line-scans
If this variable is non-@code{nil}, various indentation and motion
Karl Heuer's avatar
Karl Heuer committed
171 172 173
functions, and Emacs redisplay, cache the results of scanning the
buffer, and consult the cache to avoid rescanning regions of the buffer
unless they are modified.
Karl Heuer's avatar
Karl Heuer committed
174

Karl Heuer's avatar
Karl Heuer committed
175
Turning on the cache slows down processing of short lines somewhat.
Karl Heuer's avatar
Karl Heuer committed
176

177
This variable is automatically buffer-local in every buffer.
Karl Heuer's avatar
Karl Heuer committed
178 179
@end defvar

Richard M. Stallman's avatar
Richard M. Stallman committed
180 181 182 183 184
@node The Echo Area
@section The Echo Area
@cindex error display
@cindex echo area

185
  The @dfn{echo area} is used for displaying error messages
186 187 188 189 190 191 192
(@pxref{Errors}), for messages made with the @code{message} primitive,
and for echoing keystrokes.  It is not the same as the minibuffer,
despite the fact that the minibuffer appears (when active) in the same
place on the screen as the echo area.  The @cite{GNU Emacs Manual}
specifies the rules for resolving conflicts between the echo area and
the minibuffer for use of that screen space (@pxref{Minibuffer,, The
Minibuffer, emacs, The GNU Emacs Manual}).
Richard M. Stallman's avatar
Richard M. Stallman committed
193

194 195 196 197 198 199
  You can write output in the echo area by using the Lisp printing
functions with @code{t} as the stream (@pxref{Output Functions}), or
explicitly.

@menu
* Displaying Messages:: Explicitly displaying text in the echo area.
Luc Teirlinck's avatar
Luc Teirlinck committed
200
* Progress::            Informing user about progress of a long operation.
201 202 203 204 205 206 207 208 209
* Logging Messages::    Echo area messages are logged for the user.
* Echo Area Customization:: Controlling the echo area.
@end menu

@node Displaying Messages
@subsection Displaying Messages in the Echo Area

  This section describes the functions for explicitly producing echo
area messages.  Many other Emacs features display messages there, too.
Richard M. Stallman's avatar
Richard M. Stallman committed
210

211 212 213
@defun message format-string &rest arguments
This function displays a message in the echo area.  The argument
@var{format-string} is similar to a C language @code{printf} format
214
string.  See @code{format} in @ref{Formatting Strings}, for the details
Richard M. Stallman's avatar
Richard M. Stallman committed
215 216 217
on the conversion specifications.  @code{message} returns the
constructed string.

218 219 220
In batch mode, @code{message} prints the message text on the standard
error stream, followed by a newline.

221 222
If @var{format-string}, or strings among the @var{arguments}, have
@code{face} text properties, these affect the way the message is displayed.
223

Richard M. Stallman's avatar
Richard M. Stallman committed
224
@c Emacs 19 feature
225 226 227 228 229
If @var{format-string} is @code{nil} or the empty string,
@code{message} clears the echo area; if the echo area has been
expanded automatically, this brings it back to its normal size.
If the minibuffer is active, this brings the minibuffer contents back
onto the screen immediately.
230

Richard M. Stallman's avatar
Richard M. Stallman committed
231 232 233 234 235 236 237 238 239 240 241 242 243 244
@example
@group
(message "Minibuffer depth is %d."
         (minibuffer-depth))
 @print{} Minibuffer depth is 0.
@result{} "Minibuffer depth is 0."
@end group

@group
---------- Echo Area ----------
Minibuffer depth is 0.
---------- Echo Area ----------
@end group
@end example
245 246

To automatically display a message in the echo area or in a pop-buffer,
247
depending on its size, use @code{display-message-or-buffer} (see below).
Richard M. Stallman's avatar
Richard M. Stallman committed
248 249
@end defun

250 251 252 253 254 255 256 257
@tindex with-temp-message
@defmac with-temp-message message &rest body
This construct displays a message in the echo area temporarily, during
the execution of @var{body}.  It displays @var{message}, executes
@var{body}, then returns the value of the last body form while restoring
the previous echo area contents.
@end defmac

258
@defun message-or-box format-string &rest arguments
259 260 261 262 263 264 265 266 267 268 269 270 271
This function displays a message like @code{message}, but may display it
in a dialog box instead of the echo area.  If this function is called in
a command that was invoked using the mouse---more precisely, if
@code{last-nonmenu-event} (@pxref{Command Loop Info}) is either
@code{nil} or a list---then it uses a dialog box or pop-up menu to
display the message.  Otherwise, it uses the echo area.  (This is the
same criterion that @code{y-or-n-p} uses to make a similar decision; see
@ref{Yes-or-No Queries}.)

You can force use of the mouse or of the echo area by binding
@code{last-nonmenu-event} to a suitable value around the call.
@end defun

272
@defun message-box format-string &rest arguments
273 274 275 276 277 278 279
This function displays a message like @code{message}, but uses a dialog
box (or a pop-up menu) whenever that is possible.  If it is impossible
to use a dialog box or pop-up menu, because the terminal does not
support them, then @code{message-box} uses the echo area, like
@code{message}.
@end defun

280
@defun display-message-or-buffer message &optional buffer-name not-this-window frame
Dave Love's avatar
Dave Love committed
281
@tindex display-message-or-buffer
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
This function displays the message @var{message}, which may be either a
string or a buffer.  If it is shorter than the maximum height of the
echo area, as defined by @code{max-mini-window-height}, it is displayed
in the echo area, using @code{message}.  Otherwise,
@code{display-buffer} is used to show it in a pop-up buffer.

Returns either the string shown in the echo area, or when a pop-up
buffer is used, the window used to display it.

If @var{message} is a string, then the optional argument
@var{buffer-name} is the name of the buffer used to display it when a
pop-up buffer is used, defaulting to @samp{*Message*}.  In the case
where @var{message} is a string and displayed in the echo area, it is
not specified whether the contents are inserted into the buffer anyway.

The optional arguments @var{not-this-window} and @var{frame} are as for
@code{display-buffer}, and only used if a buffer is displayed.
@end defun

301 302 303 304 305
@defun current-message
This function returns the message currently being displayed in the
echo area, or @code{nil} if there is none.
@end defun

306 307 308
@node Progress
@subsection Reporting Operation Progress
@cindex progress reporting
309

310 311 312
  When an operation can take a while to finish, you should inform the
user about the progress it makes.  This way the user can estimate
remaining time and clearly see that Emacs is busy working, not hung.
313

314 315 316
  Functions listed in this section provide simple and efficient way of
reporting operation progress.  Here is a working example that does
nothing useful:
317

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
@smallexample
(let ((progress-reporter
       (make-progress-reporter "Collecting mana for Emacs..."
                               0  500)))
  (dotimes (k 500)
    (sit-for 0.01)
    (progress-reporter-update progress-reporter k))
  (progress-reporter-done progress-reporter))
@end smallexample

@defun make-progress-reporter message min-value max-value &optional current-value min-change min-time
This function creates and returns a @dfn{progress reporter}---an
object you will use as an argument for all other functions listed
here.  The idea is to precompute as much data as possible to make
progress reporting very fast.

When this progress reporter is subsequently used, it will display
@var{message} in the echo area, followed by progress percentage.
@var{message} is treated as a simple string.  If you need it to depend
on a filename, for instance, use @code{format} before calling this
function.

@var{min-value} and @var{max-value} arguments stand for starting and
final states of your operation.  For instance, if you scan a buffer,
they should be the results of @code{point-min} and @code{point-max}
correspondingly.  It is required that @var{max-value} is greater than
@var{min-value}.  If you create progress reporter when some part of
the operation has already been completed, then specify
@var{current-value} argument.  But normally you should omit it or set
it to @code{nil}---it will default to @var{min-value} then.

Remaining arguments control the rate of echo area updates.  Progress
reporter will wait for at least @var{min-change} more percents of the
operation to be completed before printing next message.
@var{min-time} specifies the minimum time in seconds to pass between
successive prints.  It can be fractional.  Depending on Emacs and
system capabilities, progress reporter may or may not respect this
last argument or do it with varying precision.  Default value for
@var{min-change} is 1 (one percent), for @var{min-time}---0.2
(seconds.)

This function calls @code{progress-reporter-update}, so the first
message is printed immediately.
@end defun

@defun progress-reporter-update reporter value
This function does the main work of reporting progress of your
operation.  It displays the message of @var{reporter}, followed by
progress percentage determined by @var{value}.  If percentage is zero,
or close enough according to the @var{min-change} and @var{min-time}
arguments, then it is omitted from the output.

@var{reporter} must be the result of a call to
@code{make-progress-reporter}.  @var{value} specifies the current
state of your operation and must be between @var{min-value} and
@var{max-value} (inclusive) as passed to
@code{make-progress-reporter}.  For instance, if you scan a buffer,
then @var{value} should be the result of a call to @code{point}.

This function respects @var{min-change} and @var{min-time} as passed
to @code{make-progress-reporter} and so does not output new messages
on every invocation.  It is thus very fast and normally you should not
try to reduce the number of calls to it: resulting overhead will most
likely negate your effort.
@end defun

@defun progress-reporter-force-update reporter value &optional new-message
This function is similar to @code{progress-reporter-update} except
that it prints a message in the echo area unconditionally.

The first two arguments have the same meaning as for
@code{progress-reporter-update}.  Optional @var{new-message} allows
you to change the message of the @var{reporter}.  Since this functions
always updates the echo area, such a change will be immediately
presented to the user.
@end defun

@defun progress-reporter-done reporter
This function should be called when the operation is finished.  It
prints the message of @var{reporter} followed by word ``done'' in the
echo area.

You should always call this function and not hope for
@code{progress-reporter-update} to print ``100%.''  Firstly, it may
never print it, there are many good reasons for this not to happen.
Secondly, ``done'' is more explicit.
@end defun

Juri Linkov's avatar
Juri Linkov committed
406
@defmac dotimes-with-progress-reporter (var count [result]) message body@dots{}
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
This is a convenience macro that works the same way as @code{dotimes}
does, but also reports loop progress using the functions described
above.  It allows you to save some typing.

You can rewrite the example in the beginning of this node using
this macro this way:

@example
(dotimes-with-progress-reporter
    (k 500)
    "Collecting some mana for Emacs..."
  (sit-for 0.01))
@end example
@end defmac

@node Logging Messages
@subsection Logging Messages in @samp{*Messages*}
@cindex logging echo-area messages

  Almost all the messages displayed in the echo area are also recorded
in the @samp{*Messages*} buffer so that the user can refer back to
them.  This includes all the messages that are output with
@code{message}.
Karl Heuer's avatar
Karl Heuer committed
430 431 432 433 434 435 436 437 438 439 440 441 442

@defopt message-log-max
This variable specifies how many lines to keep in the @samp{*Messages*}
buffer.  The value @code{t} means there is no limit on how many lines to
keep.  The value @code{nil} disables message logging entirely.  Here's
how to display a message and prevent it from being logged:

@example
(let (message-log-max)
  (message @dots{}))
@end example
@end defopt

443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
  To make @samp{*Messages*} more convenient for the user, the logging
facility combines successive identical messages.  It also combines
successive related messages for the sake of two cases: question
followed by answer, and a series of progress messages.

  A ``question followed by an answer'' means two messages like the
ones produced by @code{y-or-n-p}: the first is @samp{@var{question}},
and the second is @samp{@var{question}...@var{answer}}.  The first
message conveys no additional information beyond what's in the second,
so logging the second message discards the first from the log.

  A ``series of progress messages'' means successive messages like
those produced by @code{make-progress-reporter}.  They have the form
@samp{@var{base}...@var{how-far}}, where @var{base} is the same each
time, while @var{how-far} varies.  Logging each message in the series
discards the previous one, provided they are consecutive.

  The functions @code{make-progress-reporter} and @code{y-or-n-p}
don't have to do anything special to activate the message log
combination feature.  It operates whenever two consecutive messages
are logged that share a common prefix ending in @samp{...}.

@node Echo Area Customization
@subsection Echo Area Customization

  These variables control details of how the echo area works.

@defvar cursor-in-echo-area
This variable controls where the cursor appears when a message is
displayed in the echo area.  If it is non-@code{nil}, then the cursor
appears at the end of the message.  Otherwise, the cursor appears at
point---not in the echo area at all.

The value is normally @code{nil}; Lisp programs bind it to @code{t}
for brief periods of time.
@end defvar

@defvar echo-area-clear-hook
This normal hook is run whenever the echo area is cleared---either by
@code{(message nil)} or for any other reason.
@end defvar

Karl Heuer's avatar
Karl Heuer committed
485 486
@defvar echo-keystrokes
This variable determines how much time should elapse before command
Dave Love's avatar
Dave Love committed
487 488
characters echo.  Its value must be an integer or floating point number,
which specifies the
Karl Heuer's avatar
Karl Heuer committed
489 490
number of seconds to wait before echoing.  If the user types a prefix
key (such as @kbd{C-x}) and then delays this many seconds before
491 492 493
continuing, the prefix key is echoed in the echo area.  (Once echoing
begins in a key sequence, all subsequent characters in the same key
sequence are echoed immediately.)
Karl Heuer's avatar
Karl Heuer committed
494 495 496 497

If the value is zero, then command input is not echoed.
@end defvar

498 499 500 501 502 503 504
@defvar message-truncate-lines
Normally, displaying a long message resizes the echo area to display
the entire message.  But if the variable @code{message-truncate-lines}
is non-@code{nil}, the echo area does not resize, and the message is
truncated to fit it, as in Emacs 20 and before.
@end defvar

505 506 507 508 509
  The variable @code{max-mini-window-height}, which specifies the
maximum height for resizing minibuffer windows, also applies to the
echo area (which is really a special use of the minibuffer window.
@xref{Minibuffer Misc}.

510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
@node Warnings
@section Reporting Warnings
@cindex warnings

  @dfn{Warnings} are a facility for a program to inform the user of a
possible problem, but continue running.

@menu
* Warning Basics::      Warnings concepts and functions to report them.
* Warning Variables::   Variables programs bind to customize their warnings.
* Warning Options::     Variables users set to control display of warnings.
@end menu

@node Warning Basics
@subsection Warning Basics
@cindex severity level

  Every warning has a textual message, which explains the problem for
the user, and a @dfn{severity level} which is a symbol.  Here are the
possible severity levels, in order of decreasing severity, and their
meanings:

@table @code
@item :emergency
A problem that will seriously impair Emacs operation soon
if you do not attend to it promptly.
@item :error
A report of data or circumstances that are inherently wrong.
@item :warning
A report of data or circumstances that are not inherently wrong, but
raise suspicion of a possible problem.
@item :debug
A report of information that may be useful if you are debugging.
@end table

  When your program encounters invalid input data, it can either
signal a Lisp error by calling @code{error} or @code{signal} or report
a warning with severity @code{:error}.  Signaling a Lisp error is the
easiest thing to do, but it means the program cannot continue
processing.  If you want to take the trouble to implement a way to
continue processing despite the bad data, then reporting a warning of
severity @code{:error} is the right way to inform the user of the
problem.  For instance, the Emacs Lisp byte compiler can report an
error that way and continue compiling other functions.  (If the
program signals a Lisp error and then handles it with
@code{condition-case}, the user won't see the error message; it could
show the message to the user by reporting it as a warning.)

558
@cindex warning type
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
  Each warning has a @dfn{warning type} to classify it.  The type is a
list of symbols.  The first symbol should be the custom group that you
use for the program's user options.  For example, byte compiler
warnings use the warning type @code{(bytecomp)}.  You can also
subcategorize the warnings, if you wish, by using more symbols in the
list.

@defun display-warning type message &optional level buffer-name
This function reports a warning, using @var{message} as the message
and @var{type} as the warning type.  @var{level} should be the
severity level, with @code{:warning} being the default.

@var{buffer-name}, if non-@code{nil}, specifies the name of the buffer
for logging the warning.  By default, it is @samp{*Warnings*}.
@end defun

@defun lwarn type level message &rest args
This function reports a warning using the value of @code{(format
@var{message} @var{args}...)} as the message.  In other respects it is
equivalent to @code{display-warning}.
@end defun

@defun warn message &rest args
This function reports a warning using the value of @code{(format
@var{message} @var{args}...)} as the message, @code{(emacs)} as the
type, and @code{:warning} as the severity level.  It exists for
compatibility only; we recommend not using it, because you should
specify a specific warning type.
@end defun

@node Warning Variables
@subsection Warning Variables

  Programs can customize how their warnings appear by binding
the variables described in this section.

@defvar warning-levels
This list defines the meaning and severity order of the warning
severity levels.  Each element defines one severity level,
and they are arranged in order of decreasing severity.

Each element has the form @code{(@var{level} @var{string}
@var{function})}, where @var{level} is the severity level it defines.
@var{string} specifies the textual description of this level.
@var{string} should use @samp{%s} to specify where to put the warning
type information, or it can omit the @samp{%s} so as not to include
that information.

The optional @var{function}, if non-@code{nil}, is a function to call
with no arguments, to get the user's attention.

Normally you should not change the value of this variable.
@end defvar

@defvar warning-prefix-function
Richard M. Stallman's avatar
Richard M. Stallman committed
614
If non-@code{nil}, the value is a function to generate prefix text for
615 616 617 618 619 620 621 622
warnings.  Programs can bind the variable to a suitable function.
@code{display-warning} calls this function with the warnings buffer
current, and the function can insert text in it.  That text becomes
the beginning of the warning message.

The function is called with two arguments, the severity level and its
entry in @code{warning-levels}.  It should return a list to use as the
entry (this value need not be an actual member of
Richard M. Stallman's avatar
Richard M. Stallman committed
623
@code{warning-levels}).  By constructing this value, the function can
624 625 626 627 628 629 630 631 632 633 634
change the severity of the warning, or specify different handling for
a given severity level.

If the variable's value is @code{nil} then there is no function
to call.
@end defvar

@defvar warning-series
Programs can bind this variable to @code{t} to say that the next
warning should begin a series.  When several warnings form a series,
that means to leave point on the first warning of the series, rather
Richard M. Stallman's avatar
Richard M. Stallman committed
635
than keep moving it for each warning so that it appears on the last one.
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
The series ends when the local binding is unbound and
@code{warning-series} becomes @code{nil} again.

The value can also be a symbol with a function definition.  That is
equivalent to @code{t}, except that the next warning will also call
the function with no arguments with the warnings buffer current.  The
function can insert text which will serve as a header for the series
of warnings.

Once a series has begun, the value is a marker which points to the
buffer position in the warnings buffer of the start of the series.

The variable's normal value is @code{nil}, which means to handle
each warning separately.
@end defvar

@defvar warning-fill-prefix
When this variable is non-@code{nil}, it specifies a fill prefix to
use for filling each warning's text.
@end defvar

@defvar warning-type-format
This variable specifies the format for displaying the warning type
in the warning message.  The result of formatting the type this way
gets included in the message under the control of the string in the
entry in @code{warning-levels}.  The default value is @code{" (%s)"}.
If you bind it to @code{""} then the warning type won't appear at
all.
@end defvar

@node Warning Options
@subsection Warning Options

  These variables are used by users to control what happens
when a Lisp program reports a warning.

@defopt warning-minimum-level
This user option specifies the minimum severity level that should be
shown immediately to the user.  The default is @code{:warning}, which
means to immediately display all warnings except @code{:debug}
warnings.
@end defopt

@defopt warning-minimum-log-level
This user option specifies the minimum severity level that should be
logged in the warnings buffer.  The default is @code{:warning}, which
means to log all warnings except @code{:debug} warnings.
@end defopt

@defopt warning-suppress-types
This list specifies which warning types should not be displayed
immediately for the user.  Each element of the list should be a list
of symbols.  If its elements match the first elements in a warning
type, then that warning is not displayed immediately.
@end defopt

@defopt warning-suppress-log-types
This list specifies which warning types should not be logged in the
warnings buffer.  Each element of the list should be a list of
symbols.  If it matches the first few elements in a warning type, then
that warning is not logged.
@end defopt
698

Karl Heuer's avatar
Karl Heuer committed
699 700 701 702 703 704
@node Invisible Text
@section Invisible Text

@cindex invisible text
You can make characters @dfn{invisible}, so that they do not appear on
the screen, with the @code{invisible} property.  This can be either a
705
text property (@pxref{Text Properties}) or a property of an overlay
706 707 708
(@pxref{Overlays}).  Cursor motion also partly ignores these
characters; if the command loop finds point within them, it moves
point to the other side of them.
Karl Heuer's avatar
Karl Heuer committed
709 710 711 712

In the simplest case, any non-@code{nil} @code{invisible} property makes
a character invisible.  This is the default case---if you don't alter
the default value of @code{buffer-invisibility-spec}, this is how the
713 714 715
@code{invisible} property works.  You should normally use @code{t}
as the value of the @code{invisible} property if you don't plan
to set @code{buffer-invisibility-spec} yourself.
Karl Heuer's avatar
Karl Heuer committed
716 717 718 719 720 721 722 723 724

More generally, you can use the variable @code{buffer-invisibility-spec}
to control which values of the @code{invisible} property make text
invisible.  This permits you to classify the text into different subsets
in advance, by giving them different @code{invisible} values, and
subsequently make various subsets visible or invisible by changing the
value of @code{buffer-invisibility-spec}.

Controlling visibility with @code{buffer-invisibility-spec} is
Phillip Rulon's avatar
Phillip Rulon committed
725 726 727 728 729
especially useful in a program to display the list of entries in a
database.  It permits the implementation of convenient filtering
commands to view just a part of the entries in the database.  Setting
this variable is very fast, much faster than scanning all the text in
the buffer looking for properties to change.
Karl Heuer's avatar
Karl Heuer committed
730 731 732

@defvar buffer-invisibility-spec
This variable specifies which kinds of @code{invisible} properties
733 734
actually make a character invisible.  Setting this variable makes it
buffer-local.
Karl Heuer's avatar
Karl Heuer committed
735 736 737 738 739 740 741

@table @asis
@item @code{t}
A character is invisible if its @code{invisible} property is
non-@code{nil}.  This is the default.

@item a list
742 743 744
Each element of the list specifies a criterion for invisibility; if a
character's @code{invisible} property fits any one of these criteria,
the character is invisible.  The list can have two kinds of elements:
Karl Heuer's avatar
Karl Heuer committed
745 746 747

@table @code
@item @var{atom}
748
A character is invisible if its @code{invisible} property value
Karl Heuer's avatar
Karl Heuer committed
749 750 751
is @var{atom} or if it is a list with @var{atom} as a member.

@item (@var{atom} . t)
752
A character is invisible if its @code{invisible} property value
Karl Heuer's avatar
Karl Heuer committed
753 754 755 756 757 758 759
is @var{atom} or if it is a list with @var{atom} as a member.
Moreover, if this character is at the end of a line and is followed
by a visible newline, it displays an ellipsis.
@end table
@end table
@end defvar

760 761 762 763
  Two functions are specifically provided for adding elements to
@code{buffer-invisibility-spec} and removing elements from it.

@defun add-to-invisibility-spec element
764
This function adds the element @var{element} to
765 766 767
@code{buffer-invisibility-spec}.  If @code{buffer-invisibility-spec}
was @code{t}, it changes to a list, @code{(t)}, so that text whose
@code{invisible} property is @code{t} remains invisible.
768 769 770
@end defun

@defun remove-from-invisibility-spec element
Richard M. Stallman's avatar
Richard M. Stallman committed
771
This removes the element @var{element} from
772 773
@code{buffer-invisibility-spec}.  This does nothing if @var{element}
is not in the list.
774 775
@end defun

776 777 778 779
  A convention for use of @code{buffer-invisibility-spec} is that a
major mode should use the mode's own name as an element of
@code{buffer-invisibility-spec} and as the value of the
@code{invisible} property:
780 781

@example
782
;; @r{If you want to display an ellipsis:}
783
(add-to-invisibility-spec '(my-symbol . t))
784
;; @r{If you don't want ellipsis:}
785
(add-to-invisibility-spec 'my-symbol)
786 787 788 789

(overlay-put (make-overlay beginning end)
             'invisible 'my-symbol)

790
;; @r{When done with the overlays:}
791
(remove-from-invisibility-spec '(my-symbol . t))
792
;; @r{Or respectively:}
793 794 795
(remove-from-invisibility-spec 'my-symbol)
@end example

796
@vindex line-move-ignore-invisible
797
  Ordinarily, functions that operate on text or move point do not care
798 799
whether the text is invisible.  The user-level line motion commands
explicitly ignore invisible newlines if
800 801
@code{line-move-ignore-invisible} is non-@code{nil} (the default), but
only because they are explicitly programmed to do so.
Karl Heuer's avatar
Karl Heuer committed
802

803
  However, if a command ends with point inside or immediately before
804 805 806 807
invisible text, the main editing loop moves point further forward or
further backward (in the same direction that the command already moved
it) until that condition is no longer true.  Thus, if the command
moved point back into an invisible range, Emacs moves point back to
808 809 810 811
the beginning of that range, and then back one more character.  If the
command moved point forward into an invisible range, Emacs moves point
forward up to the first visible character that follows the invisible
text.
812

813 814 815 816 817 818 819 820 821 822
  Incremental search can make invisible overlays visible temporarily
and/or permanently when a match includes invisible text.  To enable
this, the overlay should have a non-@code{nil}
@code{isearch-open-invisible} property.  The property value should be a
function to be called with the overlay as an argument.  This function
should make the overlay visible permanently; it is used when the match
overlaps the overlay on exit from the search.

  During the search, such overlays are made temporarily visible by
temporarily modifying their invisible and intangible properties.  If you
823
want this to be done differently for a certain overlay, give it an
824 825
@code{isearch-open-invisible-temporary} property which is a function.
The function is called with two arguments: the first is the overlay, and
Gerd Moellmann's avatar
Gerd Moellmann committed
826
the second is @code{nil} to make the overlay visible, or @code{t} to
827
make it invisible again.
828

Richard M. Stallman's avatar
Richard M. Stallman committed
829 830 831 832
@node Selective Display
@section Selective Display
@cindex selective display

833 834
  @dfn{Selective display} refers to a pair of related features for
hiding certain lines on the screen.
Richard M. Stallman's avatar
Richard M. Stallman committed
835

836 837 838 839 840
  The first variant, explicit selective display, is designed for use
in a Lisp program: it controls which lines are hidden by altering the
text.  This kind of hiding in some ways resembles the effect of the
@code{invisible} property (@pxref{Invisible Text}), but the two
features are different and do not work the same way.
Karl Heuer's avatar
Karl Heuer committed
841 842

  In the second variant, the choice of lines to hide is made
Karl Heuer's avatar
Karl Heuer committed
843
automatically based on indentation.  This variant is designed to be a
Karl Heuer's avatar
Karl Heuer committed
844
user-level feature.
Richard M. Stallman's avatar
Richard M. Stallman committed
845 846

  The way you control explicit selective display is by replacing a
Richard M. Stallman's avatar
Richard M. Stallman committed
847
newline (control-j) with a carriage return (control-m).  The text that
848 849 850
was formerly a line following that newline is now hidden.  Strictly
speaking, it is temporarily no longer a line at all, since only
newlines can separate lines; it is now part of the previous line.
Richard M. Stallman's avatar
Richard M. Stallman committed
851 852

  Selective display does not directly affect editing commands.  For
853 854 855 856 857 858 859
example, @kbd{C-f} (@code{forward-char}) moves point unhesitatingly
into hidden text.  However, the replacement of newline characters with
carriage return characters affects some editing commands.  For
example, @code{next-line} skips hidden lines, since it searches only
for newlines.  Modes that use selective display can also define
commands that take account of the newlines, or that control which
parts of the text are hidden.
Richard M. Stallman's avatar
Richard M. Stallman committed
860 861 862

  When you write a selectively displayed buffer into a file, all the
control-m's are output as newlines.  This means that when you next read
863
in the file, it looks OK, with nothing hidden.  The selective display
Richard M. Stallman's avatar
Richard M. Stallman committed
864 865 866 867
effect is seen only within Emacs.

@defvar selective-display
This buffer-local variable enables selective display.  This means that
868
lines, or portions of lines, may be made hidden.
Richard M. Stallman's avatar
Richard M. Stallman committed
869 870 871

@itemize @bullet
@item
Phillip Rulon's avatar
Phillip Rulon committed
872
If the value of @code{selective-display} is @code{t}, then the character
873
control-m marks the start of hidden text; the control-m, and the rest
Phillip Rulon's avatar
Phillip Rulon committed
874 875
of the line following it, are not displayed.  This is explicit selective
display.
Richard M. Stallman's avatar
Richard M. Stallman committed
876 877 878 879 880 881 882

@item
If the value of @code{selective-display} is a positive integer, then
lines that start with more than that many columns of indentation are not
displayed.
@end itemize

883
When some portion of a buffer is hidden, the vertical movement
Richard M. Stallman's avatar
Richard M. Stallman committed
884
commands operate as if that portion did not exist, allowing a single
885
@code{next-line} command to skip any number of hidden lines.
Richard M. Stallman's avatar
Richard M. Stallman committed
886
However, character movement commands (such as @code{forward-char}) do
887 888
not skip the hidden portion, and it is possible (if tricky) to insert
or delete text in an hidden portion.
Richard M. Stallman's avatar
Richard M. Stallman committed
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925

In the examples below, we show the @emph{display appearance} of the
buffer @code{foo}, which changes with the value of
@code{selective-display}.  The @emph{contents} of the buffer do not
change.

@example
@group
(setq selective-display nil)
     @result{} nil

---------- Buffer: foo ----------
1 on this column
 2on this column
  3n this column
  3n this column
 2on this column
1 on this column
---------- Buffer: foo ----------
@end group

@group
(setq selective-display 2)
     @result{} 2

---------- Buffer: foo ----------
1 on this column
 2on this column
 2on this column
1 on this column
---------- Buffer: foo ----------
@end group
@end example
@end defvar

@defvar selective-display-ellipses
If this buffer-local variable is non-@code{nil}, then Emacs displays
926
@samp{@dots{}} at the end of a line that is followed by hidden text.
Richard M. Stallman's avatar
Richard M. Stallman committed
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
This example is a continuation of the previous one.

@example
@group
(setq selective-display-ellipses t)
     @result{} t

---------- Buffer: foo ----------
1 on this column
 2on this column ...
 2on this column
1 on this column
---------- Buffer: foo ----------
@end group
@end example

You can use a display table to substitute other text for the ellipsis
(@samp{@dots{}}).  @xref{Display Tables}.
@end defvar

@node Temporary Displays
@section Temporary Displays

950 951 952
  Temporary displays are used by Lisp programs to put output into a
buffer and then present it to the user for perusal rather than for
editing.  Many help commands use this feature.
Richard M. Stallman's avatar
Richard M. Stallman committed
953 954

@defspec with-output-to-temp-buffer buffer-name forms@dots{}
955 956 957 958 959
This function executes @var{forms} while arranging to insert any output
they print into the buffer named @var{buffer-name}, which is first
created if necessary, and put into Help mode.  Finally, the buffer is
displayed in some window, but not selected.

960 961
If the @var{forms} do not change the major mode in the output buffer,
so that it is still Help mode at the end of their execution, then
962
@code{with-output-to-temp-buffer} makes this buffer read-only at the
963
end, and also scans it for function and variable names to make them
Luc Teirlinck's avatar
Luc Teirlinck committed
964 965 966
into clickable cross-references.  @xref{Docstring hyperlinks, , Tips
for Documentation Strings}, in particular the item on hyperlinks in
documentation strings, for more details.
Richard M. Stallman's avatar
Richard M. Stallman committed
967 968 969 970 971 972 973 974 975 976 977 978 979

The string @var{buffer-name} specifies the temporary buffer, which
need not already exist.  The argument must be a string, not a buffer.
The buffer is erased initially (with no questions asked), and it is
marked as unmodified after @code{with-output-to-temp-buffer} exits.

@code{with-output-to-temp-buffer} binds @code{standard-output} to the
temporary buffer, then it evaluates the forms in @var{forms}.  Output
using the Lisp output functions within @var{forms} goes by default to
that buffer (but screen display and messages in the echo area, although
they are ``output'' in the general sense of the word, are not affected).
@xref{Output Functions}.

980 981 982
Several hooks are available for customizing the behavior
of this construct; they are listed below.

Richard M. Stallman's avatar
Richard M. Stallman committed
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
The value of the last form in @var{forms} is returned.

@example
@group
---------- Buffer: foo ----------
 This is the contents of foo.
---------- Buffer: foo ----------
@end group

@group
(with-output-to-temp-buffer "foo"
    (print 20)
    (print standard-output))
@result{} #<buffer foo>

---------- Buffer: foo ----------
20

#<buffer foo>

---------- Buffer: foo ----------
@end group
@end example
@end defspec

@defvar temp-buffer-show-function
Richard M. Stallman's avatar
Richard M. Stallman committed
1009
If this variable is non-@code{nil}, @code{with-output-to-temp-buffer}
Richard M. Stallman's avatar
Richard M. Stallman committed
1010 1011
calls it as a function to do the job of displaying a help buffer.  The
function gets one argument, which is the buffer it should display.
1012 1013 1014

It is a good idea for this function to run @code{temp-buffer-show-hook}
just as @code{with-output-to-temp-buffer} normally would, inside of
1015
@code{save-selected-window} and with the chosen window and buffer
1016 1017 1018
selected.
@end defvar

1019 1020 1021
@defvar temp-buffer-setup-hook
@tindex temp-buffer-setup-hook
This normal hook is run by @code{with-output-to-temp-buffer} before
Richard M. Stallman's avatar
Richard M. Stallman committed
1022 1023 1024
evaluating @var{body}.  When the hook runs, the temporary buffer is
current.  This hook is normally set up with a function to put the
buffer in Help mode.
1025 1026
@end defvar

1027 1028
@defvar temp-buffer-show-hook
This normal hook is run by @code{with-output-to-temp-buffer} after
Richard M. Stallman's avatar
Richard M. Stallman committed
1029 1030 1031 1032 1033
displaying the temporary buffer.  When the hook runs, the temporary buffer
is current, and the window it was displayed in is selected.  This hook
is normally set up with a function to make the buffer read only, and
find function names and variable names in it, provided the major mode
is Help mode.
Richard M. Stallman's avatar
Richard M. Stallman committed
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
@end defvar

@defun momentary-string-display string position &optional char message
This function momentarily displays @var{string} in the current buffer at
@var{position}.  It has no effect on the undo list or on the buffer's
modification status.

The momentary display remains until the next input event.  If the next
input event is @var{char}, @code{momentary-string-display} ignores it
and returns.  Otherwise, that event remains buffered for subsequent use
as input.  Thus, typing @var{char} will simply remove the string from
the display, while typing (say) @kbd{C-f} will remove the string from
the display and later (presumably) move point forward.  The argument
@var{char} is a space by default.

The return value of @code{momentary-string-display} is not meaningful.

Karl Heuer's avatar
Karl Heuer committed
1051
If the string @var{string} does not contain control characters, you can
1052 1053 1054
do the same job in a more general way by creating (and then subsequently
deleting) an overlay with a @code{before-string} property.
@xref{Overlay Properties}.
Karl Heuer's avatar
Karl Heuer committed
1055

Richard M. Stallman's avatar
Richard M. Stallman committed
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
If @var{message} is non-@code{nil}, it is displayed in the echo area
while @var{string} is displayed in the buffer.  If it is @code{nil}, a
default message says to type @var{char} to continue.

In this example, point is initially located at the beginning of the
second line:

@example
@group
---------- Buffer: foo ----------
This is the contents of foo.
@point{}Second line.
---------- Buffer: foo ----------
@end group

@group
(momentary-string-display
  "**** Important Message! ****"
  (point) ?\r
  "Type RET when done reading")
@result{} t
@end group

@group
---------- Buffer: foo ----------
This is the contents of foo.
**** Important Message! ****Second line.
---------- Buffer: foo ----------

---------- Echo Area ----------
Type RET when done reading
---------- Echo Area ----------
@end group
@end example
@end defun

@node Overlays
@section Overlays
@cindex overlays

You can use @dfn{overlays} to alter the appearance of a buffer's text on
Karl Heuer's avatar
Karl Heuer committed
1097 1098 1099 1100
the screen, for the sake of presentation features.  An overlay is an
object that belongs to a particular buffer, and has a specified
beginning and end.  It also has properties that you can examine and set;
these affect the display of the text within the overlay.
Richard M. Stallman's avatar
Richard M. Stallman committed
1101

Eli Zaretskii's avatar
Eli Zaretskii committed
1102
An overlay uses markers to record its beginning and end; thus,
Richard M. Stallman's avatar
Richard M. Stallman committed
1103 1104 1105 1106 1107
editing the text of the buffer adjusts the beginning and end of each
overlay so that it stays with the text.  When you create the overlay,
you can specify whether text inserted at the beginning should be
inside the overlay or outside, and likewise for the end of the overlay.

Richard M. Stallman's avatar
Richard M. Stallman committed
1108
@menu
1109
* Managing Overlays::   Creating and moving overlays.
1110
* Overlay Properties::  How to read and set properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
1111
			What properties do to the screen display.
1112
* Finding Overlays::    Searching for overlays.
Richard M. Stallman's avatar
Richard M. Stallman committed
1113 1114
@end menu

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
@node Managing Overlays
@subsection Managing Overlays

  This section describes the functions to create, delete and move
overlays, and to examine their contents.  Overlay changes are not
recorded in the buffer's undo list, since the overlays are not
part of the buffer's contents.

@defun overlayp object
This function returns @code{t} if @var{object} is an overlay.
@end defun

@defun make-overlay start end &optional buffer front-advance rear-advance
This function creates and returns an overlay that belongs to
@var{buffer} and ranges from @var{start} to @var{end}.  Both @var{start}
and @var{end} must specify buffer positions; they may be integers or
markers.  If @var{buffer} is omitted, the overlay is created in the
current buffer.

The arguments @var{front-advance} and @var{rear-advance} specify the
1135 1136 1137 1138 1139 1140 1141 1142
marker insertion type for the start of the overlay and for the end of
the overlay, respectively.  @xref{Marker Insertion Types}.  If they
are both @code{nil}, the default, then the overlay extends to include
any text inserted at the beginning, but not text inserted at the end.
If @var{front-advance} is non-@code{nil}, text inserted at the
beginning of the overlay is excluded from the overlay.  If
@var{rear-advance} is non-@code{nil}, text inserted at the end of the
overlay is included in the overlay.
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
@end defun

@defun overlay-start overlay
This function returns the position at which @var{overlay} starts,
as an integer.
@end defun

@defun overlay-end overlay
This function returns the position at which @var{overlay} ends,
as an integer.
@end defun

@defun overlay-buffer overlay
This function returns the buffer that @var{overlay} belongs to.  It
returns @code{nil} if @var{overlay} has been deleted.
@end defun

@defun delete-overlay overlay
This function deletes @var{overlay}.  The overlay continues to exist as
a Lisp object, and its property list is unchanged, but it ceases to be
attached to the buffer it belonged to, and ceases to have any effect on
display.

A deleted overlay is not permanently disconnected.  You can give it a
position in a buffer again by calling @code{move-overlay}.
@end defun

@defun move-overlay overlay start end &optional buffer
This function moves @var{overlay} to @var{buffer}, and places its bounds
at @var{start} and @var{end}.  Both arguments @var{start} and @var{end}
must specify buffer positions; they may be integers or markers.

If @var{buffer} is omitted, @var{overlay} stays in the same buffer it
was already associated with; if @var{overlay} was deleted, it goes into
the current buffer.

The return value is @var{overlay}.

This is the only valid way to change the endpoints of an overlay.  Do
not try modifying the markers in the overlay by hand, as that fails to
update other vital data structures and can cause some overlays to be
``lost''.
1185 1186 1187 1188 1189 1190 1191
@end defun

@defun remove-overlays &optional start end name value
This function removes all the overlays between @var{start} and
@var{end} whose property @var{name} has the value @var{value}.  It can
move the endpoints of the overlays in the region, or split them.

Luc Teirlinck's avatar
Luc Teirlinck committed
1192
If @var{name} is omitted or @code{nil}, it means to delete all overlays in
1193
the specified region.  If @var{start} and/or @var{end} are omitted or
Luc Teirlinck's avatar
Luc Teirlinck committed
1194
@code{nil}, that means the beginning and end of the buffer respectively.
1195 1196
Therefore, @code{(remove-overlays)} removes all the overlays in the
current buffer.
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
@end defun

  Here are some examples:

@example
;; @r{Create an overlay.}
(setq foo (make-overlay 1 10))
     @result{} #<overlay from 1 to 10 in display.texi>
(overlay-start foo)
     @result{} 1
(overlay-end foo)
     @result{} 10
(overlay-buffer foo)
     @result{} #<buffer display.texi>
;; @r{Give it a property we can check later.}
(overlay-put foo 'happy t)
     @result{} t
;; @r{Verify the property is present.}
(overlay-get foo 'happy)
     @result{} t
;; @r{Move the overlay.}
(move-overlay foo 5 20)
     @result{} #<overlay from 5 to 20 in display.texi>
(overlay-start foo)
     @result{} 5
(overlay-end foo)
     @result{} 20
;; @r{Delete the overlay.}
(delete-overlay foo)
     @result{} nil
;; @r{Verify it is deleted.}
foo
     @result{} #<overlay in no buffer>
;; @r{A deleted overlay has no position.}
(overlay-start foo)
     @result{} nil
(overlay-end foo)
     @result{} nil
(overlay-buffer foo)
     @result{} nil
;; @r{Undelete the overlay.}
(move-overlay foo 1 20)
     @result{} #<overlay from 1 to 20 in display.texi>
;; @r{Verify the results.}
(overlay-start foo)
     @result{} 1
(overlay-end foo)
     @result{} 20
(overlay-buffer foo)
     @result{} #<buffer display.texi>
;; @r{Moving and deleting the overlay does not change its properties.}
(overlay-get foo 'happy)
     @result{} t
@end example

Richard M. Stallman's avatar
Richard M. Stallman committed
1252 1253 1254
@node Overlay Properties
@subsection Overlay Properties

1255
  Overlay properties are like text properties in that the properties that
1256
alter how a character is displayed can come from either source.  But in
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
most respects they are different.  @xref{Text Properties}, for comparison.

  Text properties are considered a part of the text; overlays and
their properties are specifically considered not to be part of the
text.  Thus, copying text between various buffers and strings
preserves text properties, but does not try to preserve overlays.
Changing a buffer's text properties marks the buffer as modified,
while moving an overlay or changing its properties does not.  Unlike
text property changes, overlay property changes are not recorded in
the buffer's undo list.

  These functions read and set the properties of an overlay:
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280

@defun overlay-get overlay prop
This function returns the value of property @var{prop} recorded in
@var{overlay}, if any.  If @var{overlay} does not record any value for
that property, but it does have a @code{category} property which is a
symbol, that symbol's @var{prop} property is used.  Otherwise, the value
is @code{nil}.
@end defun

@defun overlay-put overlay prop value
This function sets the value of property @var{prop} recorded in
@var{overlay} to @var{value}.  It returns @var{value}.
1281 1282 1283 1284
@end defun

@defun overlay-properties overlay
This returns a copy of the property list of @var{overlay}.
1285 1286 1287 1288 1289 1290 1291 1292 1293
@end defun

  See also the function @code{get-char-property} which checks both
overlay properties and text properties for a given character.
@xref{Examining Properties}.

  Many overlay properties have special meanings; here is a table
of them:

Richard M. Stallman's avatar
Richard M. Stallman committed
1294 1295 1296
@table @code
@item priority
@kindex priority @r{(overlay property)}
1297 1298 1299 1300 1301 1302 1303 1304
This property's value (which should be a nonnegative integer number)
determines the priority of the overlay.  The priority matters when two
or more overlays cover the same character and both specify the same
property; the one whose @code{priority} value is larger takes priority
over the other.  For the @code{face} property, the higher priority
value does not completely replace the other; instead, its face
attributes override the face attributes of the lower priority
@code{face} property.
Richard M. Stallman's avatar
Richard M. Stallman committed
1305 1306 1307 1308 1309 1310 1311 1312 1313 1314

Currently, all overlays take priority over text properties.  Please
avoid using negative priority values, as we have not yet decided just
what they should mean.

@item window
@kindex window @r{(overlay property)}
If the @code{window} property is non-@code{nil}, then the overlay
applies only on that window.

Karl Heuer's avatar
Karl Heuer committed
1315 1316 1317
@item category
@kindex category @r{(overlay property)}
If an overlay has a @code{category} property, we call it the
Karl Heuer's avatar
Karl Heuer committed
1318
@dfn{category} of the overlay.  It should be a symbol.  The properties
Karl Heuer's avatar
Karl Heuer committed
1319 1320
of the symbol serve as defaults for the properties of the overlay.

Richard M. Stallman's avatar
Richard M. Stallman committed
1321 1322
@item face
@kindex face @r{(overlay property)}
1323
This property controls the way text is displayed---for example, which
1324
font and which colors.  @xref{Faces}, for more information.
1325

1326
In the simplest case, the value is a face name.  It can also be a list;
Phillip Rulon's avatar
Phillip Rulon committed
1327
then each element can be any of these possibilities:
1328 1329 1330 1331 1332 1333

@itemize @bullet
@item
A face name (a symbol or string).

@item
1334 1335 1336 1337 1338 1339
A property list of face attributes.  This has the form (@var{keyword}
@var{value} @dots{}), where each @var{keyword} is a face attribute
name and @var{value} is a meaningful value for that attribute.  With
this feature, you do not need to create a face each time you want to
specify a particular attribute for certain text.  @xref{Face
Attributes}.
1340 1341 1342 1343 1344 1345

@item
A cons cell of the form @code{(foreground-color . @var{color-name})} or
@code{(background-color . @var{color-name})}.  These elements specify
just the foreground color or just the background color.

Richard M. Stallman's avatar
Richard M. Stallman committed
1346 1347
@code{(foreground-color . @var{color-name})} has the same effect as
@code{(:foreground @var{color-name})}; likewise for the background.
1348
@end itemize
Richard M. Stallman's avatar
Richard M. Stallman committed
1349 1350 1351 1352

@item mouse-face
@kindex mouse-face @r{(overlay property)}
This property is used instead of @code{face} when the mouse is within
1353
the range of the overlay.
Richard M. Stallman's avatar
Richard M. Stallman committed
1354

1355 1356 1357 1358
@item display
@kindex display @r{(overlay property)}
This property activates various features that change the
way text is displayed.  For example, it can make text appear taller
Gerd Moellmann's avatar
Gerd Moellmann committed
1359
or shorter, higher or lower, wider or narrower, or replaced with an image.
1360 1361 1362
@xref{Display Property}.

@item help-echo
1363
@kindex help-echo @r{(overlay property)}
1364 1365 1366
If an overlay has a @code{help-echo} property, then when you move the
mouse onto the text in the overlay, Emacs displays a help string in the
echo area, or in the tooltip window.  For details see @ref{Text
1367
help-echo}.
1368

Richard M. Stallman's avatar
Richard M. Stallman committed
1369 1370 1371 1372
@item modification-hooks
@kindex modification-hooks @r{(overlay property)}
This property's value is a list of functions to be called if any
character within the overlay is changed or if text is inserted strictly
Karl Heuer's avatar
Karl Heuer committed
1373 1374 1375 1376 1377 1378 1379 1380 1381
within the overlay.

The hook functions are called both before and after each change.
If the functions save the information they receive, and compare notes
between calls, they can determine exactly what change has been made
in the buffer text.

When called before a change, each function receives four arguments: the
overlay, @code{nil}, and the beginning and end of the text range to be
1382
modified.
Richard M. Stallman's avatar
Richard M. Stallman committed
1383

Karl Heuer's avatar
Karl Heuer committed
1384 1385 1386 1387 1388
When called after a change, each function receives five arguments: the
overlay, @code{t}, the beginning and end of the text range just
modified, and the length of the pre-change text replaced by that range.
(For an insertion, the pre-change length is zero; for a deletion, that
length is the number of characters deleted, and the post-change
Karl Heuer's avatar
Karl Heuer committed
1389
beginning and end are equal.)
Karl Heuer's avatar
Karl Heuer committed
1390

1391 1392 1393 1394
If these functions modify the buffer, they should bind
@code{inhibit-modification-hooks} to @code{t} around doing so, to
avoid confusing the internal mechanism that calls these hooks.

Richard M. Stallman's avatar
Richard M. Stallman committed
1395 1396
@item insert-in-front-hooks
@kindex insert-in-front-hooks @r{(overlay property)}
Karl Heuer's avatar
Karl Heuer committed
1397 1398 1399
This property's value is a list of functions to be called before and
after inserting text right at the beginning of the overlay.  The calling
conventions are the same as for the @code{modification-hooks} functions.
Richard M. Stallman's avatar
Richard M. Stallman committed
1400 1401 1402

@item insert-behind-hooks
@kindex insert-behind-hooks @r{(overlay property)}
Karl Heuer's avatar
Karl Heuer committed
1403 1404 1405
This property's value is a list of functions to be called before and
after inserting text right at the end of the overlay.  The calling
conventions are the same as for the @code{modification-hooks} functions.
Richard M. Stallman's avatar
Richard M. Stallman committed
1406 1407 1408

@item invisible
@kindex invisible @r{(overlay property)}
Karl Heuer's avatar
Karl Heuer committed
1409 1410 1411 1412 1413 1414 1415
The @code{invisible} property can make the text in the overlay
invisible, which means that it does not appear on the screen.
@xref{Invisible Text}, for details.

@item intangible
@kindex intangible @r{(overlay property)}
The @code{intangible} property on an overlay works just like the
Karl Heuer's avatar
Karl Heuer committed
1416
@code{intangible} text property.  @xref{Special Properties}, for details.
1417 1418

@item isearch-open-invisible
1419 1420
This property tells incremental search how to make an invisible overlay
visible, permanently, if the final match overlaps it.  @xref{Invisible
1421
Text}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1422

1423 1424 1425 1426
@item isearch-open-invisible-temporary
This property tells incremental search how to make an invisible overlay
visible, temporarily, during the search.  @xref{Invisible Text}.

Richard M. Stallman's avatar
Richard M. Stallman committed
1427 1428 1429 1430
@item before-string
@kindex before-string @r{(overlay property)}
This property's value is a string to add to the display at the beginning
of the overlay.  The string does not appear in the buffer in any
Phillip Rulon's avatar
Phillip Rulon committed
1431
sense---only on the screen.
Richard M. Stallman's avatar
Richard M. Stallman committed
1432 1433 1434 1435 1436

@item after-string
@kindex after-string @r{(overlay property)}
This property's value is a string to add to the display at the end of
the overlay.  The string does not appear in the buffer in any