display.texi 210 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,
Glenn Morris's avatar
Glenn Morris committed
4
@c   2002, 2003, 2004, 2005, 2006, 2007 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
This function forces some or all windows to be updated on next redisplay.
If @var{object} is a window, it forces redisplay of that window.  If
64
@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
@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.

97
@defvar redisplay-preemption-period
98 99 100 101 102 103 104
This variable specifies how many seconds Emacs waits between checks
for new input during redisplay.  (The default is 0.1 seconds.)  If
input has arrived when Emacs checks, it pre-empts redisplay and
processes the available input before trying again to redisplay.

If this variable is @code{nil}, Emacs does not check for input during
redisplay, and redisplay cannot be preempted by input.
105

106 107
This variable is only obeyed on graphical terminals.  For
text terminals, see @ref{Terminal Output}.
108 109
@end defvar

110 111 112
@defvar redisplay-dont-pause
If this variable is non-@code{nil}, pending input does not
prevent or halt redisplay; redisplay occurs, and finishes,
113
regardless of whether input is available.
114 115
@end defvar

116 117 118 119 120 121
@defun redisplay &optional force
This function performs an immediate redisplay provided there are no
pending input events.  This is equivalent to @code{(sit-for 0)}.

If the optional argument @var{force} is non-@code{nil}, it forces an
immediate and complete redisplay even if input is available.
122 123

Returns @code{t} if redisplay was performed, or @code{nil} otherwise.
124
@end defun
125

Richard M. Stallman's avatar
Richard M. Stallman committed
126 127 128
@node Truncation
@section Truncation
@cindex line wrapping
Eli Zaretskii's avatar
Eli Zaretskii committed
129
@cindex line truncation
Richard M. Stallman's avatar
Richard M. Stallman committed
130 131 132 133
@cindex continuation lines
@cindex @samp{$} in display
@cindex @samp{\} in display

134 135 136 137 138 139 140 141 142 143 144 145 146
  When a line of text extends beyond the right edge of a window, Emacs
can @dfn{continue} the line (make it ``wrap'' to the next screen
line), or @dfn{truncate} the line (limit it to one screen line).  The
additional screen lines used to display a long text line are called
@dfn{continuation} lines.  Continuation is not the same as 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}.

   On a graphical display, tiny arrow images in the window fringes
indicate truncated and continued lines (@pxref{Fringes}).  On a text
terminal, a @samp{$} in the rightmost column of the window indicates
truncation; a @samp{\} on the rightmost column indicates a line that
147
``wraps.''  (The display table can specify alternate characters to use
148
for this; @pxref{Display Tables}).
Richard M. Stallman's avatar
Richard M. Stallman committed
149 150 151 152 153 154 155 156 157 158 159 160

@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
161
@defopt default-truncate-lines
Richard M. Stallman's avatar
Richard M. Stallman committed
162
This variable is the default value for @code{truncate-lines}, for
163
buffers that do not have buffer-local values for it.
Karl Heuer's avatar
Karl Heuer committed
164
@end defopt
Richard M. Stallman's avatar
Richard M. Stallman committed
165 166 167 168 169 170 171 172

@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

173 174 175
  When horizontal scrolling (@pxref{Horizontal Scrolling}) is in use in
a window, that forces truncation.

176
  If your buffer contains @emph{very} long lines, and you use
Karl Heuer's avatar
Karl Heuer committed
177
continuation to display them, just thinking about them can make Emacs
Karl Heuer's avatar
Karl Heuer committed
178 179 180
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
181 182 183

@defvar cache-long-line-scans
If this variable is non-@code{nil}, various indentation and motion
Karl Heuer's avatar
Karl Heuer committed
184 185 186
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
187

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

190
This variable is automatically buffer-local in every buffer.
Karl Heuer's avatar
Karl Heuer committed
191 192
@end defvar

Richard M. Stallman's avatar
Richard M. Stallman committed
193 194 195 196 197
@node The Echo Area
@section The Echo Area
@cindex error display
@cindex echo area

198
  The @dfn{echo area} is used for displaying error messages
199 200 201 202 203 204 205
(@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
206

207 208 209 210 211 212
  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
213
* Progress::            Informing user about progress of a long operation.
214 215 216 217 218 219
* 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
Eli Zaretskii's avatar
Eli Zaretskii committed
220
@cindex display message in echo area
221 222 223

  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
224

225 226 227
@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
228
string.  See @code{format} in @ref{Formatting Strings}, for the details
Richard M. Stallman's avatar
Richard M. Stallman committed
229 230 231
on the conversion specifications.  @code{message} returns the
constructed string.

232 233 234
In batch mode, @code{message} prints the message text on the standard
error stream, followed by a newline.

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

Richard M. Stallman's avatar
Richard M. Stallman committed
238
@c Emacs 19 feature
239 240 241 242 243
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.
244

Richard M. Stallman's avatar
Richard M. Stallman committed
245 246 247 248 249 250 251 252 253 254 255 256 257 258
@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
259 260

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

264 265 266 267 268 269 270
@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

271
@defun message-or-box format-string &rest arguments
272 273 274 275 276 277 278 279 280 281 282 283 284
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

285
@defun message-box format-string &rest arguments
286
@anchor{message-box}
287 288 289 290 291 292 293
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

294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
@defun display-message-or-buffer message &optional buffer-name not-this-window frame
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

314 315 316 317 318
@defun current-message
This function returns the message currently being displayed in the
echo area, or @code{nil} if there is none.
@end defun

319 320 321
@node Progress
@subsection Reporting Operation Progress
@cindex progress reporting
322

323 324 325
  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.
326

327 328 329
  Functions listed in this section provide simple and efficient way of
reporting operation progress.  Here is a working example that does
nothing useful:
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 406 407 408 409 410 411 412 413 414 415 416 417 418
@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
419
@defmac dotimes-with-progress-reporter (var count [result]) message body@dots{}
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
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
443 444 445 446 447 448 449 450 451 452 453 454 455

@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

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 485 486 487 488 489 490 491 492 493 494 495 496 497
  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
498 499
@defvar echo-keystrokes
This variable determines how much time should elapse before command
Dave Love's avatar
Dave Love committed
500 501
characters echo.  Its value must be an integer or floating point number,
which specifies the
Karl Heuer's avatar
Karl Heuer committed
502 503
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
504 505 506
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
507 508 509 510

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

511 512 513 514 515 516 517
@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

518 519 520 521 522
  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}.

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 558 559 560 561 562 563 564 565 566 567 568 569 570
@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.)

571
@cindex warning type
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 614 615 616 617 618 619 620 621 622 623 624 625 626
  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
627
If non-@code{nil}, the value is a function to generate prefix text for
628 629 630 631 632 633 634 635
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
636
@code{warning-levels}).  By constructing this value, the function can
637 638 639 640 641 642 643 644 645 646 647
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
648
than keep moving it for each warning so that it appears on the last one.
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 698 699 700 701 702 703 704 705 706 707 708 709 710
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
711

Karl Heuer's avatar
Karl Heuer committed
712 713 714 715 716 717
@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
718
text property (@pxref{Text Properties}) or a property of an overlay
719 720 721
(@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
722 723 724 725

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
726 727 728
@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
729 730 731 732 733 734 735 736 737

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
738 739 740 741 742
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
743 744 745

@defvar buffer-invisibility-spec
This variable specifies which kinds of @code{invisible} properties
746 747
actually make a character invisible.  Setting this variable makes it
buffer-local.
Karl Heuer's avatar
Karl Heuer committed
748 749 750 751 752 753 754

@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
755 756 757
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
758 759 760

@table @code
@item @var{atom}
761
A character is invisible if its @code{invisible} property value
Karl Heuer's avatar
Karl Heuer committed
762 763 764
is @var{atom} or if it is a list with @var{atom} as a member.

@item (@var{atom} . t)
765 766 767
A character is invisible if its @code{invisible} property value is
@var{atom} or if it is a list with @var{atom} as a member.  Moreover,
a sequence of such characters displays as an ellipsis.
Karl Heuer's avatar
Karl Heuer committed
768 769 770 771
@end table
@end table
@end defvar

772 773 774 775
  Two functions are specifically provided for adding elements to
@code{buffer-invisibility-spec} and removing elements from it.

@defun add-to-invisibility-spec element
776
This function adds the element @var{element} to
777 778 779
@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.
780 781 782
@end defun

@defun remove-from-invisibility-spec element
Richard M. Stallman's avatar
Richard M. Stallman committed
783
This removes the element @var{element} from
784 785
@code{buffer-invisibility-spec}.  This does nothing if @var{element}
is not in the list.
786 787
@end defun

788 789 790 791
  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:
792 793

@example
794
;; @r{If you want to display an ellipsis:}
795
(add-to-invisibility-spec '(my-symbol . t))
796
;; @r{If you don't want ellipsis:}
797
(add-to-invisibility-spec 'my-symbol)
798 799 800 801

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

802
;; @r{When done with the overlays:}
803
(remove-from-invisibility-spec '(my-symbol . t))
804
;; @r{Or respectively:}
805 806 807
(remove-from-invisibility-spec 'my-symbol)
@end example

808
@vindex line-move-ignore-invisible
809
  Ordinarily, functions that operate on text or move point do not care
810 811
whether the text is invisible.  The user-level line motion commands
explicitly ignore invisible newlines if
812 813
@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
814

815
  However, if a command ends with point inside or immediately before
816 817 818 819
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
820 821 822 823
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.
824

825 826 827 828 829 830 831 832 833 834
  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
835
want this to be done differently for a certain overlay, give it an
836 837
@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
838
the second is @code{nil} to make the overlay visible, or @code{t} to
839
make it invisible again.
840

Richard M. Stallman's avatar
Richard M. Stallman committed
841 842
@node Selective Display
@section Selective Display
843
@c @cindex selective display   Duplicates selective-display
Richard M. Stallman's avatar
Richard M. Stallman committed
844

845 846
  @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
847

848 849 850 851 852
  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
853 854

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

  The way you control explicit selective display is by replacing a
Richard M. Stallman's avatar
Richard M. Stallman committed
859
newline (control-j) with a carriage return (control-m).  The text that
860 861 862
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
863 864

  Selective display does not directly affect editing commands.  For
865 866 867 868 869 870 871
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
872 873 874

  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
875
in the file, it looks OK, with nothing hidden.  The selective display
Richard M. Stallman's avatar
Richard M. Stallman committed
876 877 878 879
effect is seen only within Emacs.

@defvar selective-display
This buffer-local variable enables selective display.  This means that
880
lines, or portions of lines, may be made hidden.
Richard M. Stallman's avatar
Richard M. Stallman committed
881 882 883

@itemize @bullet
@item
Phillip Rulon's avatar
Phillip Rulon committed
884
If the value of @code{selective-display} is @code{t}, then the character
885
control-m marks the start of hidden text; the control-m, and the rest
Phillip Rulon's avatar
Phillip Rulon committed
886 887
of the line following it, are not displayed.  This is explicit selective
display.
Richard M. Stallman's avatar
Richard M. Stallman committed
888 889 890 891 892 893 894

@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

895
When some portion of a buffer is hidden, the vertical movement
Richard M. Stallman's avatar
Richard M. Stallman committed
896
commands operate as if that portion did not exist, allowing a single
897
@code{next-line} command to skip any number of hidden lines.
Richard M. Stallman's avatar
Richard M. Stallman committed
898
However, character movement commands (such as @code{forward-char}) do
899 900
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
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 926 927 928 929 930 931 932 933 934 935 936 937

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
938
@samp{@dots{}} at the end of a line that is followed by hidden text.
Richard M. Stallman's avatar
Richard M. Stallman committed
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
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

962 963 964
  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
965 966

@defspec with-output-to-temp-buffer buffer-name forms@dots{}
967 968 969 970 971
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.

972 973
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
974
@code{with-output-to-temp-buffer} makes this buffer read-only at the
975
end, and also scans it for function and variable names to make them
Luc Teirlinck's avatar
Luc Teirlinck committed
976 977 978
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
979 980 981 982 983 984 985 986 987 988 989 990 991

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

992 993 994
Several hooks are available for customizing the behavior
of this construct; they are listed below.

Richard M. Stallman's avatar
Richard M. Stallman committed
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
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
1021
If this variable is non-@code{nil}, @code{with-output-to-temp-buffer}
Richard M. Stallman's avatar
Richard M. Stallman committed
1022 1023
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.
1024 1025 1026

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
1027
@code{save-selected-window} and with the chosen window and buffer
1028 1029 1030
selected.
@end defvar

1031 1032
@defvar 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
1033 1034 1035
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.
1036 1037
@end defvar

1038 1039
@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
1040 1041 1042 1043 1044
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
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
@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
1062
If the string @var{string} does not contain control characters, you can
1063 1064 1065
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
1066

Richard M. Stallman's avatar
Richard M. Stallman committed
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 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
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
1108 1109 1110 1111
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
1112

Eli Zaretskii's avatar
Eli Zaretskii committed
1113
An overlay uses markers to record its beginning and end; thus,
Richard M. Stallman's avatar
Richard M. Stallman committed
1114 1115 1116 1117 1118
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
1119
@menu
1120
* Managing Overlays::   Creating and moving overlays.
1121
* Overlay Properties::  How to read and set properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
1122
			What properties do to the screen display.
1123
* Finding Overlays::    Searching for overlays.
Richard M. Stallman's avatar
Richard M. Stallman committed
1124 1125
@end menu

1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
@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
1146 1147 1148 1149 1150 1151 1152 1153
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.
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 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
@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
1195
``lost.''
1196 1197 1198 1199 1200 1201 1202
@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
1203
If @var{name} is omitted or @code{nil}, it means to delete all overlays in
1204
the specified region.  If @var{start} and/or @var{end} are omitted or
Luc Teirlinck's avatar
Luc Teirlinck committed
1205
@code{nil}, that means the beginning and end of the buffer respectively.
1206 1207
Therefore, @code{(remove-overlays)} removes all the overlays in the
current buffer.
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 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
@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

1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
  Emacs stores the overlays of each buffer in two lists, divided
around an arbitrary ``center position.''  One list extends backwards
through the buffer from that center position, and the other extends
forwards from that center position.  The center position can be anywhere
in the buffer.

@defun overlay-recenter pos
This function recenters the overlays of the current buffer around
position @var{pos}.  That makes overlay lookup faster for positions
near @var{pos}, but slower for positions far away from @var{pos}.
@end defun

  A loop that scans the buffer forwards, creating overlays, can run
faster if you do @code{(overlay-recenter (point-max))} first.

Richard M. Stallman's avatar
Richard M. Stallman committed
1278 1279 1280
@node Overlay Properties
@subsection Overlay Properties

1281
  Overlay properties are like text properties in that the properties that
1282
alter how a character is displayed can come from either source.  But in
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
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:
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306

@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}.
1307 1308 1309 1310
@end defun

@defun overlay-properties overlay
This returns a copy of the property list of @var{overlay}.
1311 1312 1313 1314 1315 1316 1317 1318 1319
@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
1320 1321 1322
@table @code
@item priority
@kindex priority @r{(overlay property)}
1323 1324 1325 1326 1327 1328 1329 1330
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
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340

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
1341 1342 1343
@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
1344
@dfn{category} of the overlay.  It should be a symbol.  The properties
Karl Heuer's avatar
Karl Heuer committed
1345 1346
of the symbol serve as defaults for the properties of the overlay.

Richard M. Stallman's avatar
Richard M. Stallman committed
1347 1348
@item face
@kindex face @r{(overlay property)}
1349
This property controls the way text is displayed---for example, which
1350
font and which colors.  @xref{Faces}, for more information.
1351

1352
In the simplest case, the value is a face name.  It can also be a list;
Phillip Rulon's avatar
Phillip Rulon committed
1353
then each element can be any of these possibilities:
1354 1355 1356 1357 1358 1359

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

@item
1360 1361 1362 1363 1364 1365
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}.
1366 1367

@item
Karl Berry's avatar
Karl Berry committed
1368
A cons cell, either of the form @code{(foreground-color . @var{color-name})} or
1369 1370 1371
@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
1372 1373
@code{(foreground-color . @var{color-name})} has the same effect as
@code{(:foreground @var{color-name})}; likewise for the background.
1374
@end itemize
Richard M. Stallman's avatar
Richard M. Stallman committed
1375 1376 1377 1378

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

1381 1382 1383 1384
@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
1385
or shorter, higher or lower, wider or narrower, or replaced with an image.
1386 1387 1388
@xref{Display Property}.

@item help-echo
1389
@kindex help-echo @r{(overlay property)}
1390 1391 1392
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
1393
help-echo}.
1394

Richard M. Stallman's avatar
Richard M. Stallman committed
1395 1396 1397 1398
@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
1399 1400 1401 1402 1403 1404 1405 1406 1407
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
1408
modified.
Richard M. Stallman's avatar
Richard M. Stallman committed
1409

Karl Heuer's avatar
Karl Heuer committed
1410 1411 1412 1413 1414
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
1415
beginning and end are equal.)
Karl Heuer's avatar
Karl Heuer committed
1416

1417 1418 1419 1420
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.

1421 1422 1423
Text properties also support the @code{modification-hooks} property,
but the details are somewhat different (@pxref{Special Properties}).