This section describes the standard functions for displaying messages in the echo area.

message

This function displays a message in the echo area. format-string is a format string, and arguments are the objects for its format specifications, like in the format-message function (Formatting Strings). The resulting formatted string is displayed in the echo area; if it contains face text properties, it is displayed with the specified faces (Faces). The string is also added to the *Messages* buffer, but without text properties (Logging Messages). Typically grave accent and apostrophe in the format translate to matching curved quotes, e.g., "Missing `%s'" might result in "Missing ‘foo’". Text Quoting Style, for how to influence or inhibit this translation. In batch mode, the message is printed to the standard error stream, followed by a newline. When inhibit-message is non-nil, no message will be displayed in the echo area, it will only be logged to *Messages*. If format-string is nil or the empty string, 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.

(message "Reverting `%s'..." (buffer-name))
 -| Reverting ‘subr.el’...
=> "Reverting ‘subr.el’..."

---------- Echo Area ----------
Reverting ‘subr.el’...
---------- Echo Area ----------

To automatically display a message in the echo area or in a pop-buffer, depending on its size, use display-message-or-buffer (see below). Warning: If you want to use your own string as a message verbatim, don't just write (message STRING). If string contains %, `, or ' it may be reformatted, with undesirable results. Instead, use (message "%s" STRING). The following facilities allow users and Lisp programs to control how echo-area messages are displayed.

set-message-function

If this variable is non-nil, it should be a function of one argument, the text of a message to display in the echo area. That function will be called by message and related functions. If the function returns nil, the message is displayed in the echo area as usual. If the function returns a string, that string is displayed in the echo area instead of the original message. If the function returns any other non-nil value, that means the message was already handled, so message will not display anything in the echo area. The default value calls set-minibuffer-message, described below.

clear-message-function

If this variable is non-nil, it should be a function of no arguments; message and related functions call it when their argument message is nil or the empty string, to clear the echo area. Usually this function is called when the next input event arrives after displaying an echo-area message. The function is expected to clear the message displayed by its counterpart function specified by set-message-function, but doesn't have to. If the function wants the echo area to remain uncleared, it should return the symbol dont-clear-message; any other value will result in the echo area being cleared. The default value is the function that clears the message displayed in an active minibuffer.

set-message-functions

The value of this user option is a list of functions to be called for handling display of echo-area messages. Each function is called with one argument, the text of the message to display. If the function returns a string, that string replaces the original message, and the next function in the list is called with the new message text. If the function returns nil, the next function in the list is called with the same text; if the last function in the list returns nil, the message text is displayed in the echo area. If the function returns a non-nil value that is not a string, the message is considered to be handled, and no further functions in the list are called. The three useful functions to be put in the list that is the value of this option are described below.

set-minibuffer-message

This function displays message in the echo-area when the minibuffer is not active, and at the end of the minibuffer when the minibuffer is active. However, if the text shown in the active minibuffer has the minibuffer-message text property (Special Properties) on some character, the message will be displayed before the first character having that property. This function is by default the only member of the list in set-message-functions.

inhibit-message

If an echo-area message matches any regexp in the list that is the value of the user option inhibit-message-regexps, this function suppresses the display of that message and returns a non-nil value that is not a string. Thus, if this function is in the list set-message-functions, the rest of the functions in the list will not be called when message matches the regexps in inhibit-message-regexps. To ensure a matching message will never be displayed, make this function be the first element of the list in set-message-functions.

set-multi-message

This function accumulates several echo-area messages emitted one after another, and returns them as a single string in which individual messages are separated by newlines. Up to multi-message-max recent messages can be accumulated. The accumulated messages are discarded when more than multi-message-timeout seconds have elapsed since the time the first message was emitted.

inhibit-message

When this variable is non-nil, message and related functions will not display any messages in the Echo Area. Echo-area messages are still logged in the *Messages* buffer, though.

with-temp-message

This construct displays a message in the echo area temporarily, during the execution of body. It displays message, executes body, then returns the value of the last body form while restoring the previous echo area contents.

message-or-box

This function displays a message like 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 last-nonmenu-event (Command Loop Info) is either 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 y-or-n-p uses to make a similar decision; see Yes-or-No Queries.) You can force use of the mouse or of the echo area by binding last-nonmenu-event to a suitable value around the call.

message-box

This function displays a message like 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 message-box uses the echo area, like message.

display-message-or-buffer

This function displays the message 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 max-mini-window-height, it is displayed in the echo area, using message. Otherwise, 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 message is a string, then the optional argument buffer-name is the name of the buffer used to display it when a pop-up buffer is used, defaulting to *Message*. In the case where 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 action and frame are as for display-buffer, and only used if a buffer is displayed.

current-message

This function returns the message currently being displayed in the echo area, or nil if there is none.

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. A convenient way to do this is to use a progress reporter. Here is a working example that does nothing useful:

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

make-progress-reporter

This function creates and returns a progress reporter object, which you will use as an argument for the other functions listed below. 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 message in the echo area, followed by progress percentage. message is treated as a simple string. If you need it to depend on a filename, for instance, use format-message before calling this function. The arguments min-value and max-value should be numbers standing for the starting and final states of the operation. For instance, an operation that scans a buffer should set these to the results of point-min and point-max correspondingly. max-value should be greater than min-value. Alternatively, you can set min-value and max-value to nil. In that case, the progress reporter does not report process percentages; it instead displays a "spinner" that rotates a notch each time you update the progress reporter. If min-value and max-value are numbers, you can give the argument current-value a numerical value specifying the initial progress; if omitted, this defaults to min-value. The remaining arguments control the rate of echo area updates. The progress reporter will wait for at least min-change more percents of the operation to be completed before printing next message; the default is one percent. min-time specifies the minimum time in seconds to pass between successive prints; the default is 0.2 seconds. (On some operating systems, the progress reporter may handle fractions of seconds with varying precision). This function calls progress-reporter-update, so the first message is printed immediately.

progress-reporter-update

This function does the main work of reporting progress of your operation. It displays the message of reporter, followed by progress percentage determined by value. If percentage is zero, or close enough according to the min-change and min-time arguments, then it is omitted from the output. reporter must be the result of a call to make-progress-reporter. value specifies the current state of your operation and must be between min-value and max-value (inclusive) as passed to make-progress-reporter. For instance, if you scan a buffer, then value should be the result of a call to point. Optional argument suffix is a string to be displayed after reporter's main message and progress text. If reporter is a non-numerical reporter, then value should be nil, or a string to use instead of suffix. This function respects min-change and min-time as passed to 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.

progress-reporter-force-update

This function is similar to progress-reporter-update except that it prints a message in the echo area unconditionally. reporter, value, and suffix have the same meaning as for progress-reporter-update. Optional new-message allows you to change the message of the reporter. Since this function always updates the echo area, such a change will be immediately presented to the user.

progress-reporter-done

This function should be called when the operation is finished. It prints the message of reporter followed by word done in the echo area. You should always call this function and not hope for 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.

dotimes-with-progress-reporter

This is a convenience macro that works the same way as dotimes does, but also reports loop progress using the functions described above. It allows you to save some typing. The argument reporter-or-message can be either a string or a progress reporter object. You can rewrite the example in the beginning of this subsection using this macro as follows:

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

Using a reporter object as the reporter-or-message argument is useful if you want to specify the optional arguments in make-progress-reporter. For instance, you can write the previous example as follows:

(dotimes-with-progress-reporter
    (k 500)
    (make-progress-reporter "Collecting some mana for Emacs..." 0 500 0 1 1.5)
  (sit-for 0.01))

dolist-with-progress-reporter

This is another convenience macro that works the same way as dolist does, but also reports loop progress using the functions described above. As in dotimes-with-progress-reporter, reporter-or-message can be a progress reporter or a string. You can rewrite the previous example with this macro as follows:

(dolist-with-progress-reporter
    (k (number-sequence 0 500))
    "Collecting some mana for Emacs..."
  (sit-for 0.01))

with-delayed-message

Sometimes it's unclear whether an operation will take a long time to execute or not, or it can be inconvenient to implement a progress reporter. This macro can be used in those situations.

(with-delayed-message (2 (format "Gathering data for %s" entry))
  (setq data (gather-data entry)))

In this example, if the body takes more than two seconds to execute, the message will be displayed. If it takes a shorter time than that, the message won't be displayed. In either case, the body is evaluated as normally, and the return value of the final element in the body is the return value of the macro. The message element is evaluated before body, and is always evaluated, whether the message is displayed or not.

Almost all the messages displayed in the echo area are also recorded in the *Messages* buffer so that the user can refer back to them. This includes all the messages that are output with message. By default, this buffer is read-only and uses the major mode messages-buffer-mode. Nothing prevents the user from killing the *Messages* buffer, but the next display of a message recreates it. Any Lisp code that needs to access the *Messages* buffer directly and wants to ensure that it exists should use the function messages-buffer.

messages-buffer

This function returns the *Messages* buffer. If it does not exist, it creates it, and switches it to messages-buffer-mode.

message-log-max

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

(let (message-log-max)
  (message ...))

messages-buffer-name

This variable has the name of the buffer where messages should be logged to, and defaults to *Messages*. Some packages may find it useful to temporarily redirect the output to a different buffer (perhaps to write the buffer out to a log file later), and they can bind this variable to a different buffer name. (Note that this buffer (if it doesn't exist already), will be created and put into messages-buffer-mode.)

To make *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 has two messages like the ones produced by y-or-n-p: the first is QUESTION, and the second is QUESTION...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 has successive messages like those produced by make-progress-reporter. They have the form BASE...HOW-FAR, where base is the same each time, while how-far varies. Logging each message in the series discards the previous one, provided they are consecutive. The functions make-progress-reporter and 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 ....

These variables control details of how the echo area works.

cursor-in-echo-area

This variable controls where the cursor appears when a message is displayed in the echo area. If it is non-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 nil; Lisp programs bind it to t for brief periods of time.

echo-area-clear-hook

This normal hook is run whenever the echo area is cleared—either by (message nil) or for any other reason.

echo-keystrokes

This variable determines how much time should elapse before command characters echo. Its value must be a number, and specifies the number of seconds to wait before echoing. If the user types a prefix key (such as C-x) and then delays this many seconds before 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.) If the value is zero, then command input is not echoed.

message-truncate-lines

Normally, displaying a long message resizes the echo area to display the entire message, wrapping long line as needed. But if the variable message-truncate-lines is non-nil, long lines of echo-area message are instead truncated to fit the mini-window width.

The variable 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; Minibuffer Windows).

Every warning is a textual message, which explains the problem for the user, with the associated severity level which is a symbol. Here are the supported severity levels, in order of decreasing severity, and their meanings:

:emergency

A problem that will seriously impair Emacs operation soon if the user does not attend to it promptly.

:error

A report about data or circumstances that are inherently wrong.

:warning

A report about data or circumstances that are not inherently wrong, but raise suspicion of a possible problem.

:debug

A report of information that may be useful if the user is currently debugging the Lisp program which issues the warning.

When your program encounters invalid input data, it can either signal a Lisp error by calling error or signal (Signaling Errors) or report a warning with severity :error. Signaling a Lisp error is the easiest thing to do, but it means the signaling program cannot continue execution. If you want to take the trouble of implementing a way to continue processing despite the invalid data, then reporting a warning of severity :error is the right way of informing 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 condition-case, the user won't see the error message; reporting that as a warning instead avoids that problem.) In addition to severity level, each warning has a warning type to classify it. The warning type is either a symbol or a list of symbols. If it is a symbol, it should be the custom group that you use for the program's user options; if it is a list, the first element of the list should be that custom group. For example, byte compiler warnings use the warning type (bytecomp). If the warning type is a list, the elements of the list after the first one, which should be arbitrary symbols, represent subcategories of the warning: they will be displayed to the user to better explain the nature of the warning.

display-warning

This function reports a warning, using the string message as the warning text and type as the warning type. level should be the severity level, and defaults to :warning if omitted or nil. buffer-name, if non-nil, specifies the name of the buffer for logging the warning message. By default, it is *Warnings*.

lwarn

This function reports a warning using the value returned by (format-message MESSAGE ARGS...) as the message text in the *Warnings* buffer. In other respects it is equivalent to display-warning.

warn

This function reports a warning using the value returned by (format-message MESSAGE ARGS...) as the message text, emacs as the warning type, and :warning as the severity level. It exists for compatibility only; we recommend not using it, because you should specify a specific warning type.

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

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 (LEVEL STRING [FUNCTION]), where level is the severity level it defines. string specifies the textual description of this level. string should use %s to specify where to put the warning type information, or it can omit the %s so as not to include that information. The optional function, if non-nil, is a function to call with no arguments, to get the user's attention. A notable example is ding (Beeping). Normally you should not change the value of this variable.

warning-prefix-function

If non-nil, the value is a function to generate prefix text for warnings. Programs can bind the variable to a suitable function. display-warning calls this function with the warnings buffer the current buffer, and the function can insert text into it. That text becomes the beginning of the warning message. The function is called with two arguments, the severity level and its entry in warning-levels. It should return a list to use instead of that entry (the value need not be an actual member of warning-levels, but it must have the same structure). By constructing this value, the function can change the severity of the warning, or specify different handling for a given severity level. If the variable's value is nil, there's no prefix text, before the warning is displayed, starting with the string part of the entry in warning-levels corresponding to the warning's level.

warning-series

Programs can bind this variable to 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 than keep moving it for each warning so that it appears on the last one. The series ends when the local binding of this variable is unbound and warning-series becomes nil again. The value can also be a symbol with a function definition. That is equivalent to t, except that the next warning will also call the function with no arguments with the warnings buffer the current buffer. The function can, for example, insert text which will serve as a header for the series of warnings. Once a series has begun, the value of this variable 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 nil, which means to handle each warning separately.

warning-fill-prefix

When this variable is non-nil, it specifies a fill prefix to use for filling the text of each warning.

warning-fill-column

The column at which to fill warnings.

warning-type-format

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

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

warning-minimum-level

This user option specifies the minimum severity level that should be shown immediately to the user, by popping the warnings buffer in some window. The default is :warning, which means to show the warning buffer for any warning severity except :debug. The warnings of lower severity levels will still be written into the warnings buffer, but the buffer will not be forced onto display.

warning-minimum-log-level

This user option specifies the minimum severity level that should be logged in the warnings buffer. Warnings of lower severity will be completely ignored: not written to the warnings buffer and not displayed. The default is :warning, which means to log warnings of any severity except :debug.

warning-suppress-types

This list specifies which warning types should not be displayed immediately when they occur. Each element of the list should be a list of symbols. If an element of this list has the same elements as the first elements in a warning type, then the warning of that type will not be shown on display by popping the warnings buffer in some window (the warning will still be logged in the warnings buffer). For example, if the value of this variable is a list like this:

((foo) (bar subtype))

then warnings whose types are foo or (foo) or (foo something) or (bar subtype other) will not be shown to the user.

warning-suppress-log-types

This list specifies which warning types should be ignored: not logged in the warnings buffer and not shown to the user. The structure and the matching of warning types are the same as for warning-suppress-types above.

During startup, Emacs delays showing any warnings until after it loads and processes the site-wide and user's init files (Startup Summary). Let-binding (Local Variables) the values of these options around some code in your init files which might emit a warning will therefore not work, because it will not be in effect by the time the warning is actually processed. Thus, if you want to suppress some warnings during startup, change the values of the above options in your init file early enough, or put those let-binding forms in your after-init-hook or emacs-startup-hook functions. Init File.

Sometimes, you may wish to avoid showing a warning while a command is running, and only show it only after the end of the command. You can use the function delay-warning for this. Emacs automatically delays any warnings emitted during the early stages of startup, and shows them only after the init files are processed.

delay-warning

This function is the delayed counterpart to display-warning (Warning Basics), and it is called with the same arguments. The warning message is queued into delayed-warnings-list.

delayed-warnings-list

The value of this variable is a list of warnings to be displayed after the current command has finished. Each element must be a list

(TYPE MESSAGE [LEVEL [BUFFER-NAME]])

with the same form, and the same meanings, as the argument list of display-warning. Immediately after running post-command-hook (Command Overview), the Emacs command loop displays all the warnings specified by this variable, then resets the variable to nil. Programs which need to further customize the delayed warnings mechanism can change the variable delayed-warnings-hook:

delayed-warnings-hook

This is a normal hook which is run by the Emacs command loop, after post-command-hook, in order to process and display delayed warnings. Emacs also runs this hook during startup, after loading the site-start and user init files (Startup Summary), because warnings emitted before that are automatically delayed. Its default value is a list of two functions:

(collapse-delayed-warnings display-delayed-warnings)

The function collapse-delayed-warnings removes repeated entries from delayed-warnings-list. The function display-delayed-warnings calls display-warning on each of the entries in delayed-warnings-list, in turn, and then sets delayed-warnings-list to nil.

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 considered part of the buffer's contents.

overlayp

This function returns t if object is an overlay.

make-overlay

This function creates and returns an overlay that belongs to buffer and ranges from start to end. Both start and end must specify buffer positions; they may be integers or markers. If buffer is omitted, the overlay is created in the current buffer. An overlay whose start and end specify the same buffer position is known as empty. A non-empty overlay can become empty if the text between its start and end is deleted. When that happens, the overlay is by default not deleted, but you can cause it to be deleted by giving it the evaporate property (evaporate property). The arguments front-advance and rear-advance specify what happens when text is inserted at the beginning (i.e., before start) and at the end. If they are both nil, the default, then the overlay extends to include any text inserted at the beginning, but not text inserted at the end. If front-advance is non-nil, text inserted at the beginning of the overlay is excluded from the overlay. If rear-advance is non-nil, text inserted at the end of the overlay is included in the overlay.

overlay-start

This function returns the position at which overlay starts, as an integer.

overlay-end

This function returns the position at which overlay ends, as an integer.

overlay-buffer

This function returns the buffer that overlay belongs to. It returns nil if overlay has been deleted.

delete-overlay

This function deletes the specified 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 move-overlay.

move-overlay

This function moves overlay to buffer, and places its bounds at start and end in that buffer. Both arguments start and end must specify buffer positions; they may be integers or markers. If buffer is omitted, overlay stays in the same buffer it was already associated with; if overlay was previously deleted (and thus isn't associated with any buffer), it goes into the current buffer. The return value is overlay. This function is the only valid way to change the endpoints of an overlay.

remove-overlays

This function removes all the overlays between start and end whose property name has the specified value. It can move the endpoints of the overlays in the region, or split them. If name is omitted or nil, it means to delete all overlays in the specified region. If start and/or end are omitted or nil, that means the beginning and end of the buffer respectively. Therefore, (remove-overlays) removes all the overlays in the current buffer.

copy-overlay

This function returns a copy of overlay. The copy has the same endpoints and properties as overlay. However, the text insertion type for the start of the overlay and for the end of the overlay are set to their default values.

Here are some examples:

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

Overlay properties are like text properties in that the properties that alter how a character is displayed can come from either source. But in most respects they are different. 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. Since more than one overlay can specify a property value for the same character, Emacs lets you specify a priority value of each overlay. The priority value is used to decide which of the overlapping overlays will "win". These functions read and set the properties of an overlay:

overlay-get

This function returns the value of property prop recorded in overlay, if any. If overlay does not record any value for that property, but it does have a category property which is a symbol, that symbol's prop property is used. Otherwise, the value is nil.

overlay-put

This function sets the value of property prop recorded in overlay to value. It returns value.

overlay-properties

This returns a copy of the property list of overlay.

See also the function get-char-property which checks both overlay properties and text properties for a given character. Examining Properties. Many overlay properties have special meanings; here is a table of them:

priority

This property's value determines the priority of the overlay. If you want to specify a priority value, use either nil (or zero), or a positive integer, or a cons of two values. Any other value triggers undefined behavior. The priority matters when two or more overlays cover the same character and both specify the same property with different values; the one whose priority value is higher overrides the other. (For the face property, the higher priority overlay's value does not completely override the other value; instead, its individual face attributes override the corresponding face attributes of the face property whose priority is lower.) If two overlays have the same priority value, and one is "nested" in the other (i.e., covers fewer buffer or string positions), then the inner one will prevail over the outer one. If neither is nested in the other then you should not make assumptions about which overlay will prevail. When a Lisp program puts overlays with defined priorities on text that might have overlays without priorities, this could cause undesirable results, because any overlay with a positive priority value will override all the overlays without a priority. Since most Emacs features that use overlays don't specify priorities for their overlays, integer priorities should be used with care. Instead of using integer priorities and risk overriding other overlays, you can use priority values of the form (PRIMARY . SECONDARY), where the primary value is used as described above, and secondary is the fallback value used when primary and the nesting considerations fail to resolve the precedence between overlays. In particular, priority value (nil . N), with n a positive integer, allows to have the overlays ordered by priority when necessary without completely overriding other overlays. Currently, all overlays take priority over text properties. If you need to put overlays in priority order, use the sorted argument of overlays-at. Finding Overlays.

window

If the window property is non-nil, then the overlay applies only on that window.

category

If an overlay has a category property, we call it the category of the overlay. It should be a symbol. The properties of the symbol serve as defaults for the properties of the overlay.

face

This property controls the appearance of the text (Faces). The value of the property can be the following:

?

:: A face name (a symbol or string).

?

:: An anonymous face: a property list of the form (/keyword/ /value/ ...), where each keyword is a face attribute name and value is a value for that attribute.

?

:: A list of faces. Each list element should be either a face name or an anonymous face. This specifies a face which is an aggregate of the attributes of each of the listed faces. Faces occurring earlier in the list have higher priority.

?

:: A cons cell of the form (foreground-color . COLOR-NAME) or (background-color . COLOR-NAME). This specifies the foreground or background color, similar to (:foreground /color-name/) or (:background COLOR-NAME). This form is supported for backward compatibility only, and should be avoided.

mouse-face

This property is used instead of face when the mouse is within the range of the overlay. However, Emacs ignores all face attributes from this property that alter the text size (e.g., :height, :weight, and :slant); those attributes are always the same as in the unhighlighted text.

display

This property activates various features that change the way text is displayed. For example, it can make text appear taller or shorter, higher or lower, wider or narrower, or replaced with an image. Display Property.

help-echo

If an overlay has a 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 as a tooltip. For details see Text help-echo.

field

Consecutive characters with the same field property constitute a field. Some motion functions including forward-word and beginning-of-line stop moving at a field boundary. Fields.

modification-hooks

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 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, nil, and the beginning and end of the text range to be modified. When called after a change, each function receives five arguments: the overlay, 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 beginning and end are equal.) When these functions are called, inhibit-modification-hooks is bound to non-nil. If the functions modify the buffer, you might want to bind inhibit-modification-hooks to nil, so as to cause the change hooks to run for these modifications. However, doing this may call your own change hook recursively, so be sure to prepare for that. Change Hooks. Text properties also support the modification-hooks property, but the details are somewhat different (Special Properties).

insert-in-front-hooks

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 modification-hooks functions.

insert-behind-hooks

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 modification-hooks functions.

invisible

The invisible property can make the text in the overlay invisible, which means that it does not appear on the screen. Invisible Text, for details.

intangible

The intangible property on an overlay works just like the intangible text property. It is obsolete. Special Properties, for details.

isearch-open-invisible

This property tells incremental search (Incremental Search) how to make an invisible overlay visible, permanently, if the final match overlaps it. Invisible Text.

isearch-open-invisible-temporary

This property tells incremental search how to make an invisible overlay visible, temporarily, during the search. Invisible Text.

before-string

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 sense—only on the screen. Note that if the text at the beginning of the overlay is made invisible, the string will not be displayed.

after-string

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 sense—only on the screen. Note that if the text at the end of the overlay is made invisible, the string will not be displayed.

line-prefix

This property specifies a display spec to prepend to each non-continuation line at display-time. Truncation.

wrap-prefix

This property specifies a display spec to prepend to each continuation line at display-time. Truncation.

evaporate

If this property is non-nil, the overlay is deleted automatically if it becomes empty (i.e., if its length becomes zero). If you give an empty overlay (empty overlay) a non-nil evaporate property, that deletes it immediately. Note that, unless an overlay has this property, it will not be deleted when the text between its starting and ending positions is deleted from the buffer.

keymap

If this property is non-nil, it specifies a keymap for a portion of the text. This keymap takes precedence over most other keymaps (Active Keymaps), and it is used when point is within the overlay, where the front- and rear-advance properties define whether the boundaries are considered as being within or not.

local-map

The local-map property is similar to keymap but replaces the buffer's local map rather than augmenting existing keymaps. This also means it has lower precedence than minor mode keymaps.

The keymap and local-map properties do not affect a string displayed by the before-string, after-string, or display properties. This is only relevant for mouse clicks and other mouse events that fall on the string, since point is never on the string. To bind special mouse events for the string, assign it a keymap or local-map text property. Special Properties.

overlays-at

This function returns a list of all the overlays that cover the character at position pos in the current buffer. If sorted is non-nil, the list is in decreasing order of priority, otherwise it is in no particular order. An overlay contains position pos if it begins at or before pos, and ends after pos. To illustrate usage, here is a Lisp function that returns a list of the overlays that specify property prop for the character at point:

(defun find-overlays-specifying (prop)
  (let ((overlays (overlays-at (point)))
        found)
    (while overlays
      (let ((overlay (car overlays)))
        (if (overlay-get overlay prop)
            (setq found (cons overlay found))))
      (setq overlays (cdr overlays)))
    found))

overlays-in

This function returns a list of the overlays that overlap the region beg through end. An overlay overlaps with a region if it contains one or more characters in the region; empty overlays (empty overlay) overlap if they are at beg, strictly between beg and end, or at end when end denotes the position at the end of the accessible part of the buffer.

next-overlay-change

This function returns the buffer position of the next beginning or end of an overlay, after pos. If there is none, it returns (point-max).

previous-overlay-change

This function returns the buffer position of the previous beginning or end of an overlay, before pos. If there is none, it returns (point-min).

As an example, here's a simplified (and inefficient) version of the primitive function next-single-char-property-change (Property Search). It searches forward from position pos for the next position where the value of a given property prop, as obtained from either overlays or text properties, changes.

(defun next-single-char-property-change (position prop)
  (save-excursion
    (goto-char position)
    (let ((propval (get-char-property (point) prop)))
      (while (and (not (eobp))
                  (eq (get-char-property (point) prop) propval))
        (goto-char (min (next-overlay-change (point))
                        (next-single-property-change (point) prop)))))
    (point)))

Face attributes determine the visual appearance of a face. The following table lists all the face attributes, their possible values, and their effects. Apart from the values given below, each face attribute can have the value unspecified. This special value means that the face doesn't specify that attribute directly. An unspecified attribute tells Emacs to refer instead to a parent face (see the description :inherit attribute below); or, failing that, to an underlying face (Displaying Faces). (However, unspecified is not a valid value in defface.) A face attribute can also have the value reset. This special value stands for the value of the corresponding attribute of the default face. The default face must explicitly specify all attributes, and cannot use the special value reset. Some of these attributes are meaningful only on certain kinds of displays. If your display cannot handle a certain attribute, the attribute is ignored.

:family

Font family name (a string). Fonts, for more information about font families. The function font-family-list (see below) returns a list of available family names.

:foundry

The name of the font foundry for the font family specified by the :family attribute (a string). Fonts.

:width

Relative character width. This should be one of the symbols ultra-condensed, extra-condensed, condensed, semi-condensed, normal, regular, medium, semi-expanded, expanded, extra-expanded, or ultra-expanded.

:height

The height of the font. In the simplest case, this is an integer in units of 1/10 point. The value can also be floating point or a function, which specifies the height relative to an underlying face (Displaying Faces). A floating-point value specifies the amount by which to scale the height of the underlying face. A function value is called with one argument, the height of the underlying face, and returns the height of the new face. If the function is passed an integer argument, it must return an integer. The height of the default face must be specified using an integer; floating point and function values are not allowed.

:weight

Font weight—one of the symbols (from densest to faintest) ultra-bold, extra-bold, bold, semi-bold, normal, semi-light, light, extra-light, or ultra-light. On text terminals which support variable-brightness text, any weight greater than normal is displayed as extra bright, and any weight less than normal is displayed as half-bright.

:slant

Font slant—one of the symbols italic, oblique, normal, reverse-italic, or reverse-oblique. On text terminals that support variable-brightness text, slanted text is displayed as half-bright.

:foreground

Foreground color, a string. The value can be a system-defined color name, or a hexadecimal color specification. Color Names. On black-and-white displays, certain shades of gray are implemented by stipple patterns.

:distant-foreground

Alternative foreground color, a string. This is like :foreground but the color is only used as a foreground when the background color is near to the foreground that would have been used. This is useful for example when marking text (i.e., the region face). If the text has a foreground that is visible with the region face, that foreground is used. If the foreground is near the region face background, :distant-foreground is used instead so the text is readable.

:background

Background color, a string. The value can be a system-defined color name, or a hexadecimal color specification. Color Names.

:underline

Whether or not characters should be underlined, and in what way. The possible values of the :underline attribute are:

nil

Don't underline.

t

Underline with the foreground color of the face.

COLOR

Underline in color color, a string specifying a color.

(:color COLOR :style STYLE :position POSITION)

color is either a string, or the symbol foreground-color, meaning the foreground color of the face. Omitting the attribute :color means to use the foreground color of the face. style should be a symbol line or wave, meaning to use a straight or wavy line. Omitting the attribute :style means to use a straight line. position, if non-nil, means to display the underline at the descent of the text, instead of at the baseline level. If it is a number, then it specifies the amount of pixels above the descent to display the underline.

:overline

Whether or not characters should be overlined, and in what color. If the value is t, overlining uses the foreground color of the face. If the value is a string, overlining uses that color. The value nil means do not overline.

:strike-through

Whether or not characters should be strike-through, and in what color. The value is used like that of :overline.

:box

Whether or not a box should be drawn around characters, its color, the width of the box lines, and 3D appearance. Here are the possible values of the :box attribute, and what they mean:

nil

Don't draw a box.

t

Draw a box with lines of width 1, in the foreground color.

COLOR

Draw a box with lines of width 1, in color color.

(:line-width (VWIDTH . HWIDTH) :color COLOR :style STYLE)

You can explicitly specify all aspects of the box with a plist on this form. Any element in this plist can be omitted. The values of vwidth and hwidth specify respectively the width of the vertical and horizontal lines to draw; they default to (1 . 1). A negative horizontal or vertical width −/n/ means to draw a line of width n that occupies the space of the underlying text, thus avoiding any increase in the character height or width. For simplification the width could be specified with only a single number n instead of a list, such case is equivalent to ((abs N) . N). The value of color specifies the color to draw with. The default is the background color of the face for 3D boxes and flat-button, and the foreground color of the face for other boxes. The value of style specifies whether to draw a 3D box. If it is released-button, the box looks like a 3D button that is not being pressed. If it is pressed-button, the box looks like a 3D button that is being pressed. If it is nil, flat-button or omitted, a plain 2D box is used. If you use the :box face attribute on strings displayed instead of buffer text via the display text property, special considerations might apply if the surrounding buffer text also has the :box face attribute. Replacing Specs.

:inverse-video

Whether or not characters should be displayed in inverse video. The value should be t (yes) or nil (no).

:stipple

The background stipple, a bitmap. The value can be a string; that should be the name of a file containing external-format X bitmap data. The file is found in the directories listed in the variable x-bitmap-file-path. Alternatively, the value can specify the bitmap directly, with a list of the form (WIDTH HEIGHT DATA). Here, width and height specify the size in pixels, and data is a string containing the raw bits of the bitmap, row by row. Each row occupies (width + 7) / 8 consecutive bytes in the string (which should be a unibyte string for best results). This means that each row always occupies at least one whole byte. If the value is nil, that means use no stipple pattern. Normally you do not need to set the stipple attribute, because it is used automatically to handle certain shades of gray.

:font

The font used to display the face. Its value should be a font object or a fontset. If it is a font object, it specifies the font to be used by the face for displaying ASCII characters. Low-Level Font, for information about font objects, font specs, and font entities. Fontsets, for information about fontsets. When specifying this attribute using set-face-attribute or set-face-font (Attribute Functions), you may also supply a font spec, a font entity, or a string. Emacs converts such values to an appropriate font object, and stores that font object as the actual attribute value. If you specify a string, the contents of the string should be a font name (Fonts); if the font name is an XLFD containing wildcards, Emacs chooses the first font matching those wildcards. Specifying this attribute also changes the values of the :family, :foundry, :width, :height, :weight, and :slant attributes.

:inherit

The name of a face from which to inherit attributes, or a list of face names. Attributes from inherited faces are merged into the face like an underlying face would be, with higher priority than underlying faces (Displaying Faces). If the face to inherit from is unspecified, it is treated the same as nil, since Emacs never merges :inherit attributes. If a list of faces is used, attributes from faces earlier in the list override those from later faces.

:extend

Whether or not this face will be extended beyond end of line and will affect the display of the empty space between the end of line and the edge of the window. The value should be t to display the empty space between end of line and edge of the window using this face, or nil to not use this face for the space between the end of the line and the edge of the window. When Emacs merges several faces for displaying the empty space beyond end of line, only those faces with :extend non-nil will be merged. By default, only a small number of faces, notably, region, have this attribute set. This attribute is different from the others in that when a theme doesn't specify an explicit value for a face, the value from the original face definition by defface is inherited (Defining Faces). Some modes, like hl-line-mode, use a face with an :extend property to mark the entire current line. Note, however, that Emacs will always allow you to move point after the final character in a buffer, and if the buffer ends with a newline character, point can be placed on what is seemingly a line at the end of the buffer—but Emacs can't highlight that "line", because it doesn't really exist.

font-family-list

This function returns a list of available font family names. The optional argument frame specifies the frame on which the text is to be displayed; if it is nil, the selected frame is used.

underline-minimum-offset

This variable specifies the minimum distance between the baseline and the underline, in pixels, when displaying underlined text.

x-bitmap-file-path

This variable specifies a list of directories for searching for bitmap files, for the :stipple attribute.

bitmap-spec-p

This returns t if object is a valid bitmap specification, suitable for use with :stipple (see above). It returns nil otherwise.

The usual way to define a face is through the defface macro. This macro associates a face name (a symbol) with a default face spec. A face spec is a construct which specifies what attributes a face should have on any given terminal; for example, a face spec might specify one foreground color on high-color terminals, and a different foreground color on low-color terminals. People are sometimes tempted to create a variable whose value is a face name. In the vast majority of cases, this is not necessary; the usual procedure is to define a face with defface, and then use its name directly. Note that once you have defined a face (usually with defface), you cannot later undefine this face safely, except by restarting Emacs.

defface

This macro declares face as a named face whose default face spec is given by spec. You should not quote the symbol face, and it should not end in -face (that would be redundant). The argument doc is a documentation string for the face. The additional keyword arguments have the same meanings as in defgroup and defcustom (Common Keywords). If face already has a default face spec, this macro does nothing. The default face spec determines face's appearance when no customizations are in effect (Customization). If face has already been customized (via Custom themes or via customizations read from the init file), its appearance is determined by the custom face spec(s), which override the default face spec spec. However, if the customizations are subsequently removed, the appearance of face will again be determined by its default face spec. As an exception, if you evaluate a defface form with C-M-x (eval-defun) or with C-x C-e (eval-last-sexp) in Emacs Lisp mode, a special feature of these commands overrides any custom face specs on the face, causing the face to reflect exactly what the defface says. The spec argument is a face spec, which states how the face should appear on different kinds of terminals. It should be an alist whose elements each have the form

(DISPLAY . PLIST)

display specifies a class of terminals (see below). plist is a property list of face attributes and their values, specifying how the face appears on such terminals. For backward compatibility, you can also write an element as (DISPLAY PLIST). The display part of an element of spec determines which terminals the element matches. If more than one element of spec matches a given terminal, the first element that matches is the one used for that terminal. There are three possibilities for display:

default

This element of spec doesn't match any terminal; instead, it specifies defaults that apply to all terminals. This element, if used, must be the first element of spec. Each of the following elements can override any or all of these defaults.

t

This element of spec matches all terminals. Therefore, any subsequent elements of spec are never used. Normally t is used in the last (or only) element of spec.

a list

If display is a list, each element should have the form (CHARACTERISTIC VALUE...). Here characteristic specifies a way of classifying terminals, and the value/s are possible classifications which /display should apply to. Here are the possible values of characteristic:

type

The kind of window system the terminal uses—either graphic (any graphics-capable display), x, pc (for the MS-DOS console), w32 (for MS Windows 9X/NT/2K/XP), haiku (for Haiku), pgtk (for pure GTK), or tty (a non-graphics-capable display). window-system.

class

What kinds of colors the terminal supports—either color, grayscale, or mono.

background

The kind of background—either light or dark.

min-colors

An integer that represents the minimum number of colors the terminal should support. This matches a terminal if its display-color-cells value is at least the specified integer.

supports

Whether or not the terminal can display the face attributes given in value… (Face Attributes). Display Face Attribute Testing, for more information on exactly how this testing is done. If an element of display specifies more than one value for a given characteristic, any of those values is acceptable. If display has more than one element, each element should specify a different characteristic; then each characteristic of the terminal must match one of the value/s specified for it in /display.

For example, here's the definition of the standard face highlight:

(defface highlight
  '((((class color) (min-colors 88) (background light))
     :background "darkseagreen2")
    (((class color) (min-colors 88) (background dark))
     :background "darkolivegreen")
    (((class color) (min-colors 16) (background light))
     :background "darkseagreen2")
    (((class color) (min-colors 16) (background dark))
     :background "darkolivegreen")
    (((class color) (min-colors 8))
     :background "green" :foreground "black")
    (t :inverse-video t))
  "Basic face for highlighting."
  :group 'basic-faces)

Internally, Emacs stores each face's default spec in its face-defface-spec symbol property (Symbol Properties). The saved-face property stores any face spec saved by the user using the customization buffer; the customized-face property stores the face spec customized for the current session, but not saved; and the theme-face property stores an alist associating the active customization settings and Custom themes with the face specs for that face. The face's documentation string is stored in the face-documentation property. Normally, a face is declared just once, using defface, and any further changes to its appearance are applied using the Customize framework (e.g., via the Customize user interface or via the custom-set-faces function; Applying Customizations), or by face remapping (Face Remapping). In the rare event that you need to change a face spec directly from Lisp, you can use the face-spec-set function.

face-spec-set

This function applies spec as a face spec for face. spec should be a face spec, as described in the above documentation for defface. This function also defines face as a valid face name if it is not already one, and (re)calculates its attributes on existing frames. The optional argument spec-type determines which spec to set. If it is omitted or nil or face-override-spec, this function sets the override spec, which overrides face specs on face of all the other types mentioned below. This is useful when calling this function outside of Custom code. If spec-type is customized-face or saved-face, this function sets the customized spec or the saved custom spec, respectively. If it is face-defface-spec, this function sets the default face spec (the same one set by defface). If it is reset, this function clears out all customization specs and override specs from face (in this case, the value of spec is ignored). The effect of any other value of spec-type on the face specs is reserved for internal use, but the function will still define face itself and recalculate its attributes, as described above.

This section describes functions for directly accessing and modifying the attributes of a named face.

face-attribute

This function returns the value of the attribute attribute for face on frame. Face Attributes, for the supported attributes. If frame is omitted or nil, that means the selected frame (Input Focus). If frame is t, this function returns the value of the specified attribute for newly-created frames, i.e. the value of the attribute before applying the face spec in the face's defface definition (Defining Faces) or the spec set by face-spec-set. This default value of attribute is normally unspecified, unless you have specified some other value using set-face-attribute; see below. If inherit is nil, only attributes directly defined by face are considered, so the return value may be unspecified, or a relative value. If inherit is non-nil, face's definition of attribute is merged with the faces specified by its :inherit attribute; however the return value may still be unspecified or relative. If inherit is a face or a list of faces, then the result is further merged with that face (or faces), until it becomes specified and absolute. To ensure that the return value is always specified and absolute, use a value of default for inherit; this will resolve any unspecified or relative values by merging with the default face (which is always completely specified). For example,

(face-attribute 'bold :weight)
     => bold

face-attribute-relative-p

This function returns non-nil if value, when used as the value of the face attribute attribute, is relative. This means it would modify, rather than completely override, any value that comes from a subsequent face in the face list or that is inherited from another face. unspecified is a relative value for all attributes. For :height, floating point and function values are also relative. For example:

(face-attribute-relative-p :height 2.0)
     => t

face-all-attributes

This function returns an alist of attributes of face. The elements of the result are name-value pairs of the form (ATTR-NAME . ATTR-VALUE). Optional argument frame specifies the frame whose definition of face to return; if omitted or nil, the returned value describes the default attributes of face for newly created frames, i.e. the values these attributes have before applying the face spec in the face's defface definition or the spec set by face-spec-set. These default values of the attributes are normally unspecified, unless you have specified some other value using set-face-attribute; see below.

merge-face-attribute

If value1 is a relative value for the face attribute attribute, returns it merged with the underlying value value2; otherwise, if value1 is an absolute value for the face attribute attribute, returns value1 unchanged.

Normally, Emacs uses the face specs of each face to automatically calculate its attributes on each frame (Defining Faces). The function set-face-attribute can override this calculation by directly assigning attributes to a face, either on a specific frame or for all frames. This function is mostly intended for internal usage.

set-face-attribute

This function sets one or more attributes of face for frame. The attributes specified in this way override the face spec(s) belonging to face. Face Attributes, for the supported attributes. The extra arguments arguments specify the attributes to set, and the values for them. They should consist of alternating attribute names (such as :family or :underline) and values. Thus,

(set-face-attribute 'foo nil :weight 'bold :slant 'italic)

sets the attribute :weight to bold and the attribute :slant to italic. If frame is t, this function sets the default attributes for newly created frames; they will effectively override the attribute values specified by defface. If frame is nil, this function sets the attributes for all existing frames, as well as for newly created frames. To reset the value of an attribute, that is, to indicate that the face doesn't by itself specify a value for the attribute, use the special value unspecified (not nil!) for the attribute, and set the frame argument to t, in addition to the call with frame set to nil. This is because the default attributes for newly created frames are merged with the face's spec in defface when a new frame is created, and so having unspecified in the default attributes for new frames will be unable to override defface; the special call to this function as described above will arrange for defface to be overridden. Note that the attribute-value pairs are evaluated in the order they are specified, with the exception of the :family and :foundry attributes, which are evaluated first. This means that if a certain attribute is specified more than once, only the last value will be used. It also means that in some cases a different order of attributes will produce different results. For example, when :weight is placed before :font, the weight value is applied to the current font of the face, and might be rounded to the closest available weight of that font, whereas when :font is placed before :weight the weight value is applied to the specified font. The following commands and functions mostly provide compatibility with old versions of Emacs. They work by calling set-face-attribute. Values of t and nil (or omitted) for their frame argument are handled just like set-face-attribute and face-attribute. The commands read their arguments using the minibuffer, if called interactively.

Command set-face-foreground

@deffnx Command set-face-background face color &optional frame These set the :foreground attribute (or :background attribute, respectively) of face to color.

Command set-face-stipple

This sets the :stipple attribute of face to pattern.

Command set-face-font

Change the font-related attributes of face to those of font (a string or a font object). face-font-attribute, for the supported formats of the font argument. This function sets the attribute :font of the face, and indirectly also the :family, :foundry, :width, :height, :weight, and :slant attributes, as defined by the font. If frame is non-nil, only change the attributes on the specified frame.

set-face-bold

This sets the :weight attribute of face to normal if bold-p is nil, and to bold otherwise.

set-face-italic

This sets the :slant attribute of face to normal if italic-p is nil, and to italic otherwise.

Command set-face-underline

This sets the :underline attribute of face to underline.

Command set-face-inverse-video

This sets the :inverse-video attribute of face to inverse-video-p.

Command invert-face

This swaps the foreground and background colors of face face.

Command set-face-extend

This sets the :extend attribute of face to extend.

The following functions examine the attributes of a face. They mostly provide compatibility with old versions of Emacs. If you don't specify frame, they refer to the selected frame; t refers to the default data for new frames. They return unspecified if the face doesn't define any value for that attribute. If inherit is nil, only an attribute directly defined by the face is returned. If inherit is non-nil, any faces specified by its :inherit attribute are considered as well, and if inherit is a face or a list of faces, then they are also considered, until a specified attribute is found. To ensure that the return value is always specified, use a value of default for inherit.

face-font

This function returns the name of the font used by the specified face. If the optional argument frame is specified, it returns the name of the font of face for that frame; frame defaults to the selected frame if it is nil or omitted. If frame is t, the function reports on the font defaults for face to be used for new frames. By default, the returned font is for displaying ASCII characters, but if frame is anything but t, and the optional third argument character is supplied, the function returns the font name used by face for that character.

face-foreground

@defunx face-background face &optional frame inherit These functions return the foreground color (or background color, respectively) of face face, as a string. If the color is unspecified, they return nil.

face-stipple

This function returns the name of the background stipple pattern of face face, or nil if it doesn't have one.

face-bold-p

This function returns a non-nil value if the :weight attribute of face is bolder than normal (i.e., one of semi-bold, bold, extra-bold, or ultra-bold). Otherwise, it returns nil.

face-italic-p

This function returns a non-nil value if the :slant attribute of face is italic or oblique, and nil otherwise.

face-underline-p

This function returns non-nil if face face specifies a non-nil :underline attribute.

face-inverse-video-p

This function returns non-nil if face face specifies a non-nil :inverse-video attribute.

face-extend-p

This function returns non-nil if face face specifies a non-nil :extend attribute. The inherit argument is passed to face-attribute.

When Emacs displays a given piece of text, the visual appearance of the text may be determined by faces drawn from different sources. If these various sources together specify more than one face for a particular character, Emacs merges the attributes of the various faces. Here is the order in which Emacs merges the faces, from highest to lowest priority:

• If the text consists of a special glyph, the glyph can specify a particular face. Glyphs.
• If the text lies within an active region, Emacs highlights it using the region face. Standard Faces.
• If the text lies within an overlay with a non-nil face property, Emacs applies the face(s) specified by that property. If the overlay has a mouse-face property and the mouse is near enough to the overlay, Emacs applies the face or face attributes specified by the mouse-face property instead. Overlay Properties. When multiple overlays cover the same character, an overlay with higher priority overrides those with lower priority. Overlays.
• If the text contains a face or mouse-face property, Emacs applies the specified faces and face attributes. Special Properties. (This is how Font Lock mode faces are applied. Font Lock Mode.)
• If the text lies within the mode line of the selected window, Emacs applies the mode-line face. For the mode line of a non-selected window, Emacs applies the mode-line-inactive face. For a header line, Emacs applies the header-line face. For a tab line, Emacs applies the tab-line face.
• If the text comes from an overlay string via before-string or after-string properties (Overlay Properties), or from a display string (Other Display Specs), and the string doesn't contain a face or mouse-face property, or these properties leave some face attributes undefined, but the buffer text affected by the overlay/display property does define a face or those attributes, Emacs applies the face attributes of the "underlying" buffer text. Note that this is so even if the overlay or display string is displayed in the display margins (Display Margins).
• If any given attribute has not been specified during the preceding steps, Emacs applies the attribute of the default face.

At each stage, if a face has a valid :inherit attribute, Emacs treats any attribute with an unspecified value as having the corresponding value drawn from the parent face(s). Face Attributes. Note that the parent face(s) may also leave the attribute unspecified; in that case, the attribute remains unspecified at the next level of face merging.

The variable face-remapping-alist is used for buffer-local or global changes in the appearance of a face. For instance, it is used to implement the text-scale-adjust command (Text Scale).

face-remapping-alist

The value of this variable is an alist whose elements have the form (FACE . REMAPPING). This causes Emacs to display any text having the face face with remapping, rather than the ordinary definition of face. remapping may be any face spec suitable for a face text property: either a face (i.e., a face name or a property list of attribute/value pairs), or a list of faces. For details, see the description of the face text property in Special Properties. remapping serves as the complete specification for the remapped face—it replaces the normal definition of face, instead of modifying it. If face-remapping-alist is buffer-local, its local value takes effect only within that buffer. If face-remapping-alist includes faces applicable only to certain windows, by using the (:filtered (:window PARAM VAL) SPEC), that face takes effect only in windows that match the filter conditions (Special Properties). To turn off face filtering temporarily, bind face-filters-always-match to a non-nil value, then all face filters will match any window. Note: face remapping is non-recursive. If remapping references the same face name face, either directly or via the :inherit attribute of some other face in remapping, that reference uses the normal definition of face. For instance, if the mode-line face is remapped using this entry in face-remapping-alist:

(mode-line italic mode-line)

then the new definition of the mode-line face inherits from the italic face, and the normal (non-remapped) definition of mode-line face. The following functions implement a higher-level interface to face-remapping-alist. Most Lisp code should use these functions instead of setting face-remapping-alist directly, to avoid trampling on remappings applied elsewhere. These functions are intended for buffer-local remappings, so they all make face-remapping-alist buffer-local as a side-effect. They manage face-remapping-alist entries of the form

(FACE RELATIVE-SPEC-1 RELATIVE-SPEC-2 ... BASE-SPEC)

where, as explained above, each of the relative-spec-N and base-spec is either a face name, or a property list of attribute/value pairs. Each of the relative remapping entries, relative-spec-N, is managed by the face-remap-add-relative and face-remap-remove-relative functions; these are intended for simple modifications like changing the text size. The base remapping entry, base-spec, has the lowest priority and is managed by the face-remap-set-base and face-remap-reset-base functions; it is intended for major modes to remap faces in the buffers they control.

face-remap-add-relative

This function adds specs as relative remappings for face face in the current buffer. specs should be a list where each element is either a face name, or a property list of attribute/value pairs. The return value is a Lisp object that serves as a cookie; you can pass this object as an argument to face-remap-remove-relative if you need to remove the remapping later.

;; Remap the 'escape-glyph' face into a combination
;; of the 'highlight' and 'italic' faces:
(face-remap-add-relative 'escape-glyph 'highlight 'italic)

;; Increase the size of the 'default' face by 50%:
(face-remap-add-relative 'default :height 1.5)

Note that buffer-local face remapping does not work reliably for parent faces of basic faces (Basic Faces). (These are the faces that are used in mode lines, header lines, and other basic decorations of windows and frames.) For instance, mode-line-inactive inherits from mode-line, but remapping mode-line won't normally have the desired effect on mode-line-inactive, especially if done locally for some buffers. Instead you have to remap mode-line-inactive directly.

face-remap-remove-relative

This function removes a relative remapping previously added by face-remap-add-relative. cookie should be the Lisp object returned by face-remap-add-relative when the remapping was added.

face-remap-set-base

This function sets the base remapping of face in the current buffer to specs. If specs is empty, the default base remapping is restored, similar to calling face-remap-reset-base (see below); note that this is different from specs containing a single value nil, which has the opposite result (the global definition of face is ignored). This overwrites the default base-spec, which inherits the global face definition, so it is up to the caller to add such inheritance if so desired.

face-remap-reset-base

This function sets the base remapping of face to its default value, which inherits from face's global definition.

Here are additional functions for creating and working with faces.

face-list

This function returns a list of all defined face names.

face-id

This function returns the face number of face face. This is a number that uniquely identifies a face at low levels within Emacs. It is seldom necessary to refer to a face by its face number. However, functions that manipulate glyphs, such as make-glyph-code and glyph-face (Glyphs) access the face numbers internally. Note that the face number is stored as the value of the face property of the face symbol, so we recommend not to set that property of a face to any value of your own.

face-documentation

This function returns the documentation string of face face, or nil if none was specified for it.

face-equal

This returns t if the faces face1 and face2 have the same attributes for display.

face-differs-from-default-p

This returns non-nil if the face face displays differently from the default face.

A face alias provides an equivalent name for a face. You can define a face alias by giving the alias symbol the face-alias property, with a value of the target face name. The following example makes modeline an alias for the mode-line face.

(put 'modeline 'face-alias 'mode-line)

define-obsolete-face-alias

This macro defines obsolete-face as an alias for current-face, and also marks it as obsolete, indicating that it may be removed in future. when should be a string indicating when obsolete-face was made obsolete (usually a version number string).

This hook is used for automatically assigning faces to text in the buffer. It is part of the implementation of Jit-Lock mode, used by Font-Lock.

fontification-functions

This variable holds a list of functions that are called by Emacs redisplay as needed, just before doing redisplay. They are called even when Font Lock Mode isn't enabled. When Font Lock Mode is enabled, this variable usually holds just one function, jit-lock-function. The functions are called in the order listed, with one argument, a buffer position pos. Collectively they should attempt to assign faces to the text in the current buffer starting at pos. The functions should record the faces they assign by setting the face property. They should also add a non-nil fontified property to all the text they have assigned faces to. That property tells redisplay that faces have been assigned to that text already. It is probably a good idea for the functions to do nothing if the character after pos already has a non-nil fontified property, but this is not required. If one function overrides the assignments made by a previous one, the properties after the last function finishes are the ones that really matter. For efficiency, we recommend writing these functions so that they usually assign faces to around 400 to 600 characters at each call. Note that, when the buffer text includes very long lines, these functions are called as if they were in a with-restriction form (Narrowing), with a long-line-optimizations-in-fontification-functions label and with the buffer narrowed to a portion around pos.

If your Emacs Lisp program needs to assign some faces to text, it is often a good idea to use certain existing faces or inherit from them, rather than defining entirely new faces. This way, if other users have customized those existing faces to give Emacs a certain look, your program will fit in without additional customization. Some of the basic faces defined in Emacs are listed below. In addition to these, you might want to make use of the Font Lock faces for syntactic highlighting, if highlighting is not already handled by Font Lock mode, or if some Font Lock faces are not in use. Faces for Font Lock.

default

The default face, whose attributes are all specified. All other faces implicitly inherit from it: any unspecified attribute defaults to the attribute on this face (Face Attributes).

mode-line-active, mode-line-inactive, header-line, tab-line

Basic faces used for the mode line, header line, and tab line.

tool-bar, tab-bar, fringe, scroll-bar, window-divider, border, child-frame-border

Basic faces used for the corresponding decorations of GUI frames.

cursor

The basic face used for the text cursor.

mouse

The basic face used for displaying mouse-sensitive text when the mouse pointer is on that text.

bold, italic, bold-italic, underline, fixed-pitch, fixed-pitch-serif, variable-pitch

These have the attributes indicated by their names (e.g., bold has a bold :weight attribute), with all other attributes unspecified (and so given by default).

shadow

For dimmed-out text. For example, it is used for the ignored part of a filename in the minibuffer (Minibuffers for File Names).

link, link-visited

For clickable text buttons that send the user to a different buffer or location.

highlight

For stretches of text that should temporarily stand out. For example, it is commonly assigned to the mouse-face property for cursor highlighting (Special Properties).

match, isearch, lazy-highlight

For text matching (respectively) permanent search matches, interactive search matches, and lazy highlighting other matches than the current interactive one.

error, warning, success

For text concerning errors, warnings, or successes. For example, these are used for messages in *Compilation* buffers.

Before Emacs can draw a character on a graphical display, it must select a font for that character(In this context). Fonts. Normally, Emacs automatically chooses a font based on the faces assigned to that character—specifically, the face attributes :family, :weight, :slant, and :width (Face Attributes). The choice of font also depends on the character to be displayed; some fonts can only display a limited set of characters. If no available font exactly fits the requirements, Emacs looks for the closest matching font. The variables in this section control how Emacs makes this selection.

face-font-family-alternatives

If a given family is specified but does not exist, this variable specifies alternative font families to try. Each element should have this form:

(FAMILY ALTERNATE-FAMILIES...)

If family is specified but not available, Emacs will try the other families given in alternate-families, one by one, until it finds a family that does exist.

face-font-selection-order

If there is no font that exactly matches all desired face attributes (:width, :height, :weight, and :slant), this variable specifies the order in which these attributes should be considered when selecting the closest matching font. The value should be a list containing those four attribute symbols, in order of decreasing importance. The default is (:width :height :weight :slant). Font selection first finds the best available matches for the first attribute in the list; then, among the fonts which are best in that way, it searches for the best matches in the second attribute, and so on. The attributes :weight and :width have symbolic values in a range centered around normal. Matches that are more extreme (farther from normal) are somewhat preferred to matches that are less extreme (closer to normal); this is designed to ensure that non-normal faces contrast with normal ones, whenever possible. One example of a case where this variable makes a difference is when the default font has no italic equivalent. With the default ordering, the italic face will use a non-italic font that is similar to the default one. But if you put :slant before :height, the italic face will use an italic font, even if its height is not quite right.

face-font-registry-alternatives

This variable lets you specify alternative font registries to try, if a given registry is specified and doesn't exist. Each element should have this form:

(REGISTRY ALTERNATE-REGISTRIES...)

If registry is specified but not available, Emacs will try the other registries given in alternate-registries, one by one, until it finds a registry that does exist. Emacs can make use of scalable fonts, but by default it does not use them.

scalable-fonts-allowed

This variable controls which scalable fonts to use. A value of nil, the default, means do not use scalable fonts. t means to use any scalable font that seems appropriate for the text. Otherwise, the value must be a list of regular expressions. Then a scalable font is enabled for use if its name matches any regular expression in the list. For example,

(setq scalable-fonts-allowed '("iso10646-1$"))

allows the use of scalable fonts with registry iso10646-1.

face-font-rescale-alist

This variable specifies scaling for certain faces. Its value should be a list of elements of the form

(FONTNAME-REGEXP . SCALE-FACTOR)

If fontname-regexp matches the font name that is about to be used, this says to choose a larger similar font according to the factor scale-factor. You would use this feature to normalize the font size if certain fonts are bigger or smaller than their nominal heights and widths would suggest.

x-list-fonts

This function returns a list of available font names that match name. name should be a string containing a font name in either the Fontconfig, GTK+, or XLFD format (Fonts). Within an XLFD string, wildcard characters may be used: the * character matches any substring, and the ? character matches any single character. Case is ignored when matching font names. If the optional arguments reference-face and frame are specified, the returned list includes only fonts that are the same size as reference-face (a face name) currently is on the frame frame. The optional argument maximum sets a limit on how many fonts to return. If it is non-nil, then the return value is truncated after the first maximum matching fonts. Specifying a small value for maximum can make this function much faster, in cases where many fonts match the pattern. The optional argument width specifies a desired font width. If it is non-nil, the function only returns those fonts whose characters are (on average) width times as wide as reference-face.

x-family-fonts

This function returns a list describing the available fonts for family family on frame. If family is omitted or nil, this list applies to all families, and therefore, it contains all available fonts. Otherwise, family must be a string; it may contain the wildcards ? and *. The list describes the display that frame is on; if frame is omitted or nil, it applies to the selected frame's display (Input Focus). Each element in the list is a vector of the following form:

[FAMILY WIDTH POINT-SIZE WEIGHT SLANT
 FIXED-P FULL REGISTRY-AND-ENCODING]

The first five elements correspond to face attributes; if you specify these attributes for a face, it will use this font. The last three elements give additional information about the font. fixed-p is non-nil if the font is fixed-pitch. full is the full name of the font, and registry-and-encoding is a string giving the registry and encoding of the font.

A fontset is a list of fonts, each assigned to a range of character codes. An individual font cannot display the whole range of characters that Emacs supports, but a fontset can. Fontsets have names, just as fonts do, and you can use a fontset name in place of a font name when you specify the font for a frame or a face. Here is information about defining a fontset under Lisp program control.

create-fontset-from-fontset-spec

This function defines a new fontset according to the specification string fontset-spec. The string should have this format:

FONTPATTERN, [CHARSET:FONT]...

Whitespace characters before and after the commas are ignored. The first part of the string, fontpattern, should have the form of a standard X font name, except that the last two fields should be fontset-ALIAS. The new fontset has two names, one long and one short. The long name is fontpattern in its entirety. The short name is fontset-ALIAS. You can refer to the fontset by either name. If a fontset with the same name already exists, an error is signaled, unless noerror is non-nil, in which case this function does nothing. If optional argument style-variant-p is non-nil, that says to create bold, italic and bold-italic variants of the fontset as well. These variant fontsets do not have a short name, only a long one, which is made by altering fontpattern to indicate the bold and/or italic status. The specification string also says which fonts to use in the fontset. See below for the details. The construct CHARSET:FONT specifies which font to use (in this fontset) for one particular character set. Here, charset is the name of a character set, and font is the font to use for that character set. You can use this construct any number of times in the specification string. For the remaining character sets, those that you don't specify explicitly, Emacs chooses a font based on fontpattern: it replaces fontset-ALIAS with a value that names one character set. For the ASCII character set, fontset-ALIAS is replaced with ISO8859-1. In addition, when several consecutive fields are wildcards, Emacs collapses them into a single wildcard. This is to prevent use of auto-scaled fonts. Fonts made by scaling larger fonts are not usable for editing, and scaling a smaller font is not useful because it is better to use the smaller font in its own size, which Emacs does. Thus if fontpattern is this,

-*-fixed-medium-r-normal-*-24-*-*-*-*-*-fontset-24

the font specification for ASCII characters would be this:

-*-fixed-medium-r-normal-*-24-*-ISO8859-1

and the font specification for Chinese GB2312 characters would be this:

-*-fixed-medium-r-normal-*-24-*-gb2312*-*

You may not have any Chinese font matching the above font specification. Most X distributions include only Chinese fonts that have song ti or fangsong ti in the family field. In such a case, Fontset-N can be specified as below:

Emacs.Fontset-0: -*-fixed-medium-r-normal-*-24-*-*-*-*-*-fontset-24,\
        chinese-gb2312:-*-*-medium-r-normal-*-24-*-gb2312*-*

Then, the font specifications for all but Chinese GB2312 characters have fixed in the family field, and the font specification for Chinese GB2312 characters has a wild card * in the family field.

set-fontset-font

This function modifies the existing fontset to use the font specified by font-spec for displaying the specified characters. If fontset is nil, this function modifies the fontset of the selected frame or that of frame if frame is not nil. If fontset is t, this function modifies the default fontset, whose short name as a string is fontset-default. The characters argument can be a single character which should be displayed using font-spec. It can also be a cons cell (FROM . TO), where from and to are characters. In that case, use font-spec for all the characters in the range from and to (inclusive). characters may be a charset symbol (Character Sets). In that case, use font-spec for all the characters in the charset. characters may be a script symbol (char-script-table). In that case, use font-spec for all the characters belonging to the script. characters may be nil, which means to use font-spec for any character in fontset for which no font-spec is specified. font-spec may be a font-spec object created by the function font-spec (Low-Level Font). font-spec may be a cons cell (FAMILY . REGISTRY), where family is a family name of a font (possibly including a foundry name at the head), and registry is a registry name of a font (possibly including an encoding name at the tail). font-spec may be a font name, a string. font-spec may be nil, which explicitly specifies that there's no font for the specified characters. This is useful, for example, to avoid expensive system-wide search for fonts for characters that have no glyphs, like those from the Unicode Private Use Area (PUA). The optional argument add, if non-nil, specifies how to add font-spec to the font specifications previously set for characters. If it is prepend, font-spec is prepended to the existing specs. If it is append, font-spec is appended. By default, font-spec overwrites the previously set font specs. For instance, this changes the default fontset to use a font whose family name is Kochi Gothic for all characters belonging to the charset japanese-jisx0208:

(set-fontset-font t 'japanese-jisx0208
                  (font-spec :family "Kochi Gothic"))

Note that this function should generally be called from the user's init files, and more generally before any of characters were displayed in the current Emacs session. That's because for some scripts, Emacs caches the way they are displayed, and the cached information includes the font used for them – once these characters are displayed once, the cached font will continue to be used regardless of changes in the fontsets.

char-displayable-p

This function returns non-nil if Emacs ought to be able to display char. Or more precisely, if the selected frame's fontset has a font to display the character set that char belongs to. Fontsets can specify a font on a per-character basis; when the fontset does that, this function's value may not be accurate. This function may return non-nil even when there is no font available, since it also checks whether the coding system for the text terminal can encode the character (Terminal I/O Encoding).

Normally, it is not necessary to manipulate fonts directly. In case you need to do so, this section explains how. In Emacs Lisp, fonts are represented using three different Lisp object types: font objects, font specs, and font entities.

fontp

Return t if object is a font object, font spec, or font entity. Otherwise, return nil. The optional argument type, if non-nil, determines the exact type of Lisp object to check for. In that case, type should be one of font-object, font-spec, or font-entity.

A font object is a Lisp object that represents a font that Emacs has opened. Font objects cannot be modified in Lisp, but they can be inspected.

font-at

Return the font object that is being used to display the character at position position in the window window. If window is nil, it defaults to the selected window. If string is nil, position specifies a position in the current buffer; otherwise, string should be a string, and position specifies a position in that string.

A font spec is a Lisp object that contains a set of specifications that can be used to find a font. More than one font may match the specifications in a font spec.

font-spec

Return a new font spec using the specifications in arguments, which should come in property-value pairs. The possible specifications are as follows:

:name

The font name (a string), in either XLFD, Fontconfig, or GTK+ format. Fonts.

:family, :foundry, :weight, :slant, :width

These have the same meanings as the face attributes of the same name. Face Attributes. :family and :foundry are strings, while the other three are symbols. As example values, :slant may be italic, :weight may be bold and :width may be normal.

:size

The font size—either a non-negative integer that specifies the pixel size, or a floating-point number that specifies the point size.

:adstyle

Additional typographic style information for the font, such as sans. The value should be a string or a symbol.

:registry

The charset registry and encoding of the font, such as iso8859-1. The value should be a string or a symbol.

:dpi

The resolution in dots per inch for which the font is designed. The value must be a non-negative number.

:spacing

The spacing of the font: proportional, dual, mono, or charcell. The value should be either an integer (0 for proportional, 90 for dual, 100 for mono, 110 for charcell) or a one-letter symbol (one of P, D, M, or C).

:avgwidth

The average width of the font in 1/10 pixel units. The value should be a non-negative number.

:script

The script that the font must support (a symbol).

:lang

The language that the font should support. The value should be a symbol whose name is a two-letter ISO-639 language name. On X, the value is matched against the "Additional Style" field of the XLFD name of a font, if it is non-empty. On MS-Windows, fonts matching the spec are required to support codepages needed for the language. Currently, only a small set of CJK languages is supported with this property: ja, ko, and zh.

:otf

The font must be an OpenType font that supports these OpenType features, provided Emacs is compiled with a library, such as libotf on GNU/Linux, that supports complex text layout for scripts which need that. The value must be a list of the form (SCRIPT-TAG LANGSYS-TAG GSUB GPOS) where script-tag is the OpenType script tag symbol; langsys-tag is the OpenType language system tag symbol, or nil to use the default language system; gsub is a list of OpenType GSUB feature tag symbols, or nil if none is required; and gpos is a list of OpenType GPOS feature tag symbols, or nil if none is required. If gsub or gpos is a list, a nil element in that list means that the font must not match any of the remaining tag symbols. The gpos element may be omitted. For the list of OpenType script, language, and feature tags, see the list of registered OTF tags.

:type

The symbol that specifies the font backend used to draw the characters. The possible values depend on the platform and on how Emacs was configured at build time. Typical values include ftcrhb and xfthb on X, harfbuzz on MS-Windows, ns on GNUstep, etc. It can also be nil if left unspecified, typically in a font-spec.

font-put

Set the font property property in the font-spec font-spec to value. The property can any of the ones described above.

A font entity is a reference to a font that need not be open. Its properties are intermediate between a font object and a font spec: like a font object, and unlike a font spec, it refers to a single, specific font. Unlike a font object, creating a font entity does not load the contents of that font into computer memory. Emacs may open multiple font objects of different sizes from a single font entity referring to a scalable font.

find-font

This function returns a font entity that best matches the font spec font-spec on frame frame. If frame is nil, it defaults to the selected frame.

list-fonts

This function returns a list of all font entities that match the font spec font-spec. The optional argument frame, if non-nil, specifies the frame on which the fonts are to be displayed. The optional argument num, if non-nil, should be an integer that specifies the maximum length of the returned list. The optional argument prefer, if non-nil, should be another font spec, which is used to control the order of the returned list; the returned font entities are sorted in order of decreasing closeness to that font spec.

If you call set-face-attribute and pass a font spec, font entity, or font name string as the value of the :font attribute, Emacs opens the best matching font that is available for display. It then stores the corresponding font object as the actual value of the :font attribute for that face. The following functions can be used to obtain information about a font. For these functions, the font argument can be a font object, a font entity, or a font spec.

font-get

This function returns the value of the font property property for font. The property can any of the ones that font-spec supports. If font is a font spec and the font spec does not specify property, the return value is nil. If font is a font object or font entity, the value for the :script property may be a list of scripts supported by the font, and the value of the :otf property is a cons of the form (GSUB . GPOS), where gsub and gpos are lists representing OpenType features supported by the font, of the form

((SCRIPT-TAG (LANGSYS-TAG FEATURE...) ...) ...)

where script-tag, langsys-tag, and feature are symbols representing OpenType layout tags. If font is a font object, the special property :combining-capability is non-nil if the font backend of font supports rendering of combining characters for non-OpenType fonts.

font-face-attributes

This function returns a list of face attributes corresponding to font. The optional argument frame specifies the frame on which the font is to be displayed. If it is nil, the selected frame is used. The return value has the form

(:family FAMILY :height HEIGHT :weight WEIGHT
   :slant SLANT :width WIDTH)

where the values of family, height, weight, slant, and width are face attribute values. Some of these key-attribute pairs may be omitted from the list if they are not specified by font.

font-xlfd-name

This function returns the XLFD (X Logical Font Descriptor), a string, matching font. Fonts, for information about XLFDs. If the name is too long for an XLFD (which can contain at most 255 characters), the function returns nil. If the optional argument fold-wildcards is non-nil, consecutive wildcards in the XLFD are folded into one.

The following two functions return important information about a font.

font-info

This function returns information about a font specified by its name, a string, as it is used on frame. If frame is omitted or nil, it defaults to the selected frame. The value returned by the function is a vector of the form [OPENED-NAME FULL-NAME SIZE HEIGHT BASELINE-OFFSET RELATIVE-COMPOSE DEFAULT-ASCENT MAX-WIDTH ASCENT DESCENT SPACE-WIDTH AVERAGE-WIDTH FILENAME CAPABILITY]. Here's the description of each components of this vector:

opened-name

The name used to open the font, a string.

full-name

The full name of the font, a string.

size

The pixel size of the font.

height

The height of the font in pixels.

baseline-offset

The offset in pixels from the ASCII baseline, positive upward.

relative-compose, default-ascent

Numbers controlling how to compose characters.

max-width

The maximum advance width of the font.

ascent, descent

The ascent and descent of this font. The sum of these two numbers should be equal to the value of height above.

space-width

The width, in pixels, of the font's space character.

average-width

The average width of the font characters. If this is zero, Emacs uses the value of space-width instead, when it calculates text layout on display.

filename

The file name of the font as a string. This can be nil if the font back-end does not provide a way to find out the font's file name.

capability

A list whose first element is a symbol representing the font type, one of x, opentype, truetype, type1, pcf, or bdf. For OpenType fonts, the list includes 2 additional elements describing the GSUB and GPOS features supported by the font. Each of these elements is a list of the form ((/script/ (/langsys/ /feature/ ...) ...) ...), where script is a symbol representing an OpenType script tag, langsys is a symbol representing an OpenType langsys tag (or nil, which stands for the default langsys), and each feature is a symbol representing an OpenType feature tag.

query-font

This function returns information about a font-object. (This is in contrast to font-info, which takes the font name, a string, as its argument.) The value returned by the function is a vector of the form [NAME FILENAME PIXEL-SIZE MAX-WIDTH ASCENT DESCENT SPACE-WIDTH AVERAGE-WIDTH CAPABILITY]. Here's the description of each components of this vector:

name

The font name, a string.

filename

The file name of the font as a string. This can be nil if the font back-end does not provide a way to find out the font's file name.

pixel-size

The pixel size of the font used to open the font.

max-width

The maximum advance width of the font.

ascent, descent

The ascent and descent of this font. The sum of these two numbers gives the font height.

space-width

The width, in pixels, of the font's space character.

average-width

The average width of the font characters. If this is zero, Emacs uses the value of space-width instead, when it calculates text layout on display.

capability

A list whose first element is a symbol representing the font type, one of x, opentype, truetype, type1, pcf, or bdf. For OpenType fonts, the list includes 2 additional elements describing the GSUB and GPOS features supported by the font. Each of these elements is a list of the form ((/script/ (/langsys/ /feature/ ...) ...) ...), where script is a symbol representing an OpenType script tag, langsys is a symbol representing an OpenType langsys tag (or nil, which stands for the default langsys), and each feature is a symbol representing an OpenType feature tag.

The following four functions return size information about fonts used by various faces, allowing various layout considerations in Lisp programs. These functions take face remapping into consideration, returning information about the remapped face, if the face in question was remapped. Face Remapping.

default-font-width

This function returns the average width in pixels of the font used by the current buffer's default face, as that face is defined for the selected frame.

default-font-height

This function returns the height in pixels of the font used by the current buffer's default face, as that face is defined for the selected frame.

window-font-width

This function returns the average width in pixels for the font used by face in window. The specified window must be a live window. If nil or omitted, window defaults to the selected window, and face defaults to the default face in window.

window-font-height

This function returns the height in pixels for the font used by face in window. The specified window must be a live window. If nil or omitted, window defaults to the selected window, and face defaults to the default face in window.

The following buffer-local variables control the position and width of fringes in windows showing that buffer.

fringes-outside-margins

The fringes normally appear between the display margins and the window text. If the value is non-nil, they appear outside the display margins. Display Margins.

left-fringe-width

This variable, if non-nil, specifies the width of the left fringe in pixels. A value of nil means to use the left fringe width from the window's frame.

right-fringe-width

This variable, if non-nil, specifies the width of the right fringe in pixels. A value of nil means to use the right fringe width from the window's frame.

Any buffer which does not specify values for these variables uses the values specified by the left-fringe and right-fringe frame parameters (Layout Parameters). The above variables actually take effect via the function set-window-buffer (Buffers and Windows), which calls set-window-fringes as a subroutine. If you change one of these variables, the fringe display is not updated in existing windows showing the buffer, unless you call set-window-buffer again in each affected window. You can also use set-window-fringes to control the fringe display in individual windows.

set-window-fringes

This function sets the fringe widths of window window. If window is nil, the selected window is used. The argument left specifies the width in pixels of the left fringe, and likewise right for the right fringe. A value of nil for either one stands for the default width. If outside-margins is non-nil, that specifies that fringes should appear outside of the display margins. If window is not large enough to accommodate fringes of the desired width, this leaves the fringes of window unchanged. The values specified here may be later overridden by invoking set-window-buffer (Buffers and Windows) on window with its keep-margins argument nil or omitted. However, if the optional fifth argument persistent is non-nil and the other arguments are processed successfully, the values specified here unconditionally survive subsequent invocations of set-window-buffer. This can be used to permanently turn off fringes in the minibuffer window, consult the description of set-window-scroll-bars for an example (Scroll Bars).

window-fringes

This function returns information about the fringes of a window window. If window is omitted or nil, the selected window is used. The value has the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS PERSISTENT).

Fringe indicators are tiny icons displayed in the window fringe to indicate truncated or continued lines, buffer boundaries, etc.

indicate-empty-lines

When this is non-nil, Emacs displays a special glyph in the fringe of each empty line at the end of the buffer, on graphical displays. Fringes. This variable is automatically buffer-local in every buffer.

indicate-buffer-boundaries

This buffer-local variable controls how the buffer boundaries and window scrolling are indicated in the window fringes. Emacs can indicate the buffer boundaries—that is, the first and last line in the buffer—with angle icons when they appear on the screen. In addition, Emacs can display an up-arrow in the fringe to show that there is text above the screen, and a down-arrow to show there is text below the screen. There are three kinds of basic values:

nil

Don't display any of these fringe icons.

left

Display the angle icons and arrows in the left fringe.

right

Display the angle icons and arrows in the right fringe.

any non-alist

Display the angle icons in the left fringe and don't display the arrows.

Otherwise the value should be an alist that specifies which fringe indicators to display and where. Each element of the alist should have the form (INDICATOR . POSITION). Here, indicator is one of top, bottom, up, down, and t (which covers all the icons not yet specified), while position is one of left, right and nil. For example, ((top . left) (t . right)) places the top angle bitmap in left fringe, and the bottom angle bitmap as well as both arrow bitmaps in right fringe. To show the angle bitmaps in the left fringe, and no arrow bitmaps, use ((top . left) (bottom . left)).

fringe-indicator-alist

This buffer-local variable specifies the mapping from logical fringe indicators to the actual bitmaps displayed in the window fringes. The value is an alist of elements (INDICATOR . BITMAPS), where indicator specifies a logical indicator type and bitmaps specifies the fringe bitmaps to use for that indicator. Each indicator should be one of the following symbols:

truncation, continuation.

Used for truncation and continuation lines.

up, down, top, bottom, top-bottom

Used when indicate-buffer-boundaries is non-nil: up and down indicate a buffer boundary lying above or below the window edge; top and bottom indicate the topmost and bottommost buffer text line; and top-bottom indicates where there is just one line of text in the buffer.

empty-line

Used to indicate empty lines after the buffer end when indicate-empty-lines is non-nil.

overlay-arrow

Used for overlay arrows (Overlay Arrow).

Each bitmaps value may be a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]). The left and right symbols specify the bitmaps shown in the left and/or right fringe, for the specific indicator. left1 and right1 are specific to the bottom and top-bottom indicators, and are used to indicate that the last text line has no final newline. Alternatively, bitmaps may be a single symbol which is used in both left and right fringes. Fringe Bitmaps, for a list of standard bitmap symbols and how to define your own. In addition, nil represents the empty bitmap (i.e., an indicator that is not shown). When fringe-indicator-alist has a buffer-local value, and there is no bitmap defined for a logical indicator, or the bitmap is t, the corresponding value from the default value of fringe-indicator-alist is used.

When a line is exactly as wide as the window, Emacs displays the cursor in the right fringe instead of using two lines. Different bitmaps are used to represent the cursor in the fringe depending on the current buffer's cursor type.

overflow-newline-into-fringe

If this is non-nil, lines exactly as wide as the window (not counting the final newline character) are not continued. Instead, when point is at the end of the line, the cursor appears in the right fringe.

fringe-cursor-alist

This variable specifies the mapping from logical cursor type to the actual fringe bitmaps displayed in the right fringe. The value is an alist where each element has the form (CURSOR-TYPE . BITMAP), which means to use the fringe bitmap bitmap to display cursors of type cursor-type. Each cursor-type should be one of box, hollow, bar, hbar, or hollow-small. The first four have the same meanings as in the cursor-type frame parameter (Cursor Parameters). The hollow-small type is used instead of hollow when the normal hollow-rectangle bitmap is too tall to fit on a specific display line. Each bitmap should be a symbol specifying the fringe bitmap to be displayed for that logical cursor type. Fringe Bitmaps. When fringe-cursor-alist has a buffer-local value, and there is no bitmap defined for a cursor type, the corresponding value from the default value of fringes-indicator-alist is used.

The fringe bitmaps are the actual bitmaps which represent the logical fringe indicators for truncated or continued lines, buffer boundaries, overlay arrows, etc. Each bitmap is represented by a symbol. These symbols are referred to by the variable fringe-indicator-alist, which maps fringe indicators to bitmaps (Fringe Indicators), and the variable fringe-cursor-alist, which maps fringe cursors to bitmaps (Fringe Cursors). Lisp programs can also directly display a bitmap in the left or right fringe, by using a display property for one of the characters appearing in the line (Other Display Specs). Such a display specification has the form

(FRINGE BITMAP [FACE])

fringe is either the symbol left-fringe or right-fringe. bitmap is a symbol identifying the bitmap to display. The optional face names a face whose foreground and background colors are to be used to display the bitmap, using the attributes of the fringe face for colors that face didn't specify. If face is omitted, that means to use the attributes of the default face for the colors which the fringe face didn't specify. For predictable results that don't depend on the attributes of the default and fringe faces, we recommend you never omit face, but always provide a specific face. In particular, if you want the bitmap to be always displayed in the fringe face, use fringe as face. For instance, to display an arrow in the left fringe, using the warning face, you could say something like:

(overlay-put
 (make-overlay (point) (point))
 'before-string (propertize
                 "x" 'display
                 `(left-fringe right-arrow warning)))

Here is a list of the standard fringe bitmaps defined in Emacs, and how they are currently used in Emacs (via fringe-indicator-alist and fringe-cursor-alist):

left-arrow, right-arrow

Used to indicate truncated lines.

left-curly-arrow, right-curly-arrow

Used to indicate continued lines.

right-triangle, left-triangle

The former is used by overlay arrows. The latter is unused.

up-arrow, down-arrow, bottom-left-angle, bottom-right-angle, top-left-angle, top-right-angle, left-bracket, right-bracket, empty-line

Used to indicate buffer boundaries.

filled-rectangle, hollow-rectangle, filled-square, hollow-square, vertical-bar, horizontal-bar

Used for different types of fringe cursors.

exclamation-mark, question-mark, large-circle

Not used by core Emacs features.

The next subsection describes how to define your own fringe bitmaps.

fringe-bitmaps-at-pos

This function returns the fringe bitmaps of the display line containing position pos in window window. The return value has the form (LEFT RIGHT OV), where left is the symbol for the fringe bitmap in the left fringe (or nil if no bitmap), right is similar for the right fringe, and ov is non-nil if there is an overlay arrow in the left fringe. The value is nil if pos is not visible in window. If window is nil, that stands for the selected window. If pos is nil, that stands for the value of point in window.

define-fringe-bitmap

This function defines the symbol bitmap as a new fringe bitmap, or replaces an existing bitmap with that name. The argument bits specifies the image to use. It should be either a string or a vector of integers, where each element (an integer) corresponds to one row of the bitmap. Each bit of an integer corresponds to one pixel of the bitmap, where the low bit corresponds to the rightmost pixel of the bitmap. (Note that this order of bits is opposite of the order in XBM images; XBM Images.) The height is normally the length of bits. However, you can specify a different height with non-nil height. The width is normally 8, but you can specify a different width with non-nil width. The width must be an integer between 1 and 16. The argument align specifies the positioning of the bitmap relative to the range of rows where it is used; the default is to center the bitmap. The allowed values are top, center, or bottom. The align argument may also be a list (ALIGN PERIODIC) where align is interpreted as described above. If periodic is non-nil, it specifies that the rows in bits should be repeated enough times to reach the specified height.

destroy-fringe-bitmap

This function destroys the fringe bitmap identified by bitmap. If bitmap identifies a standard fringe bitmap, it actually restores the standard definition of that bitmap, instead of eliminating it entirely.

set-fringe-bitmap-face

This sets the face for the fringe bitmap bitmap to face. If face is nil, it selects the fringe face. The bitmap's face controls the color to draw it in. face is merged with the fringe face, so normally face should specify only the foreground color.

The overlay arrow is useful for directing the user's attention to a particular line in a buffer. For example, in the modes used for interface to debuggers, the overlay arrow indicates the line of code about to be executed. This feature has nothing to do with overlays (Overlays).

overlay-arrow-string

This variable holds the string to display to call attention to a particular line, or nil if the arrow feature is not in use. On a graphical display the contents of the string are ignored if the left fringe is shown; instead a glyph is displayed in the fringe area to the left of the display area.

overlay-arrow-position

This variable holds a marker that indicates where to display the overlay arrow. It should point at the beginning of a line. On a non-graphical display, or when the left fringe is not shown, the arrow text appears at the beginning of that line, overlaying any text that would otherwise appear. Since the arrow is usually short, and the line usually begins with indentation, normally nothing significant is overwritten. The overlay-arrow string is displayed in any given buffer if the value of overlay-arrow-position in that buffer points into that buffer. Thus, it is possible to display multiple overlay arrow strings by creating buffer-local bindings of overlay-arrow-position. However, it is usually cleaner to use overlay-arrow-variable-list to achieve this result.

You can do a similar job by creating an overlay with a before-string property. Overlay Properties. You can define multiple overlay arrows via the variable overlay-arrow-variable-list.

overlay-arrow-variable-list

This variable's value is a list of variables, each of which specifies the position of an overlay arrow. The variable overlay-arrow-position has its normal meaning because it is on this list.

Each variable on this list can have properties overlay-arrow-string and overlay-arrow-bitmap that specify an overlay arrow string (for text terminals or graphical terminals without the left fringe shown) or fringe bitmap (for graphical terminals with a left fringe) to display at the corresponding overlay arrow position. If either property is not set, the default overlay-arrow-string or overlay-arrow fringe indicator is used.

Some kinds of display specifications specify something to display instead of the text that has the property. These are called replacing display specifications. Emacs does not allow the user to interactively move point into the middle of buffer text that is replaced in this way. If a list of display specifications includes more than one replacing display specification, the first overrides the rest. Replacing display specifications make most other display specifications irrelevant, since those don't apply to the replacement. For replacing display specifications, the text that has the property means all the consecutive characters that have the same Lisp object as their display property; these characters are replaced as a single unit. If two characters have different Lisp objects as their display properties (i.e., objects which are not eq), they are handled separately. Here is an example which illustrates this point. A string serves as a replacing display specification, which replaces the text that has the property with the specified string (Other Display Specs). Consider the following function:

(defun foo ()
  (dotimes (i 5)
    (let ((string (concat "A"))
          (start (+ i i (point-min))))
      (put-text-property start (1+ start) 'display string)
      (put-text-property start (+ 2 start) 'display string))))

This function gives each of the first ten characters in the buffer a display property which is a string "A", but they don't all get the same string object. The first two characters get the same string object, so they are replaced with one A; the fact that the display property was assigned in two separate calls to put-text-property is irrelevant. Similarly, the next two characters get a second string (concat creates a new string object), so they are replaced with one A; and so on. Thus, the ten characters appear as five A's. Note: Using :box face attribute (Face Attributes) on a replacing display string that is adjacent to normal text with the same :box style can lead to display artifacts when moving the cursor across the text with this face attribute. These can be avoided by applying the :box attribute directly to the text being replaced, rather than (or in addition to) the display string itself. Here's an example:

;; Causes display artifacts when moving the cursor across text
(progn
  (put-text-property 1 2 'display (propertize "  [" 'face '(:box t)))
  (put-text-property 2 3 'face '(:box t))
  (put-text-property 3 4 'display (propertize "]  " 'face '(:box t))))

;; No display artifacts due to `:box'
(progn
  (add-text-properties 1 2 '(face (:box t) display "  ["))
  (put-text-property 2 3 'face '(:box t))
  (add-text-properties 3 4 '(face (:box t) display "]  ")))

To display a space of specified width and/or height, use a display specification of the form (space . PROPS), where props is a property list (a list of alternating properties and values). You can put this property on one or more consecutive characters; a space of the specified height and width is displayed in place of all of those characters. These are the properties you can use in props to specify the weight of the space:

:width WIDTH

If width is a number, it specifies that the space width should be width times the normal character width. width can also be a pixel width specification (Pixel Specification).

:relative-width FACTOR

Specifies that the width of the stretch should be computed from the first character in the group of consecutive characters that have the same display property. The space width is the pixel width of that character, multiplied by factor. (On text-mode terminals, the "pixel width" of a character is usually 1, but it could be more for TABs and double-width CJK characters.)

:align-to HPOS

Specifies that the space should be wide enough to reach the column hpos. If hpos is a number, it is a column number, and is measured in units of the canonical character width (Frame Font). hpos can also be a pixel width specification (Pixel Specification). When the current line is wider than the window, and is either displayed by one or more continuation lines, or is truncated and possibly scrolled horizontally (Horizontal Scrolling), hpos is measured from the beginning of the logical line, not from the visual beginning of the screen line. This way, alignment produced by :align-to is consistent with functions that count columns, such as current-column and move-to-column (Columns).

You should use one and only one of the above properties. You can also specify the height of the space, with these properties:

:height HEIGHT

Specifies the height of the space. If height is a number, it specifies that the space height should be height times the normal character height. The height may also be a pixel height specification (Pixel Specification).

:relative-height FACTOR

Specifies the height of the space, multiplying the ordinary height of the text having this display specification by factor.

:ascent ASCENT

If the value of ascent is a non-negative number no greater than 100, it specifies that ascent percent of the height of the space should be considered as the ascent of the space—that is, the part above the baseline. The ascent may also be specified in pixel units with a pixel ascent specification (Pixel Specification).

Don't use both :height and :relative-height together. The :width and :align-to properties are supported on non-graphic terminals, but the other space properties in this section are not. Note that space properties are treated as paragraph separators for the purposes of reordering bidirectional text for display. Bidirectional Display, for the details.

The value of the :width, :align-to, :height, and :ascent properties can be a special kind of expression that is evaluated during redisplay. The result of the evaluation is used as an absolute number of pixels. The following expressions are supported:

EXPR ::= NUM | (NUM) | UNIT | ELEM | POS | IMAGE | XWIDGET | FORM
  NUM  ::= INTEGER | FLOAT | SYMBOL
  UNIT ::= in | mm | cm | width | height
  ELEM ::= left-fringe | right-fringe | left-margin | right-margin
        |  scroll-bar | text
  POS  ::= left | center | right
  FORM ::= (NUM . EXPR) | (OP EXPR ...)
  OP   ::= + | -

The form num specifies a fraction of the default frame font height or width. The form (NUM) specifies an absolute number of pixels. If num is a symbol, symbol, its buffer-local variable binding is used; that binding can be either a number or a cons cell of the forms shown above (including yet another cons cell whose car is a symbol that has a buffer-local binding). The in, mm, and cm units specify the number of pixels per inch, millimeter, and centimeter, respectively. The width and height units correspond to the default width and height of the current face. An image specification of the form (image . PROPS) (Image Descriptors) corresponds to the width or height of the specified image. Similarly, an xwidget specification of the form (xwidget . PROPS) stands for the width or height of the specified xwidget. Xwidgets. The elements left-fringe, right-fringe, left-margin, right-margin, scroll-bar, and text specify the width of the corresponding area of the window. When the window displays line numbers (Size of Displayed Text), the width of the text area is decreased by the screen space taken by the line-number display. The left, center, and right positions can be used with :align-to to specify a position relative to the left edge, center, or right edge of the text area. When the window displays line numbers, and :align-to is used in display properties of buffer text (as opposed to header line, see below), the left and the center positions are offset to account for the screen space taken by the line-number display. Any of the above window elements (except text) can also be used with :align-to to specify that the position is relative to the left edge of the given area. Once the base offset for a relative position has been set (by the first occurrence of one of these symbols), further occurrences of these symbols are interpreted as the width of the specified area. For example, to align to the center of the left-margin, use

:align-to (+ left-margin (0.5 . left-margin))

If no specific base offset is set for alignment, it is always relative to the left edge of the text area. For example, :align-to 0 aligns with the first text column in the text area. When the window displays line numbers, the text is considered to start where the space used for line-number display ends. A value of the form (NUM . EXPR) stands for the product of the values of num and expr. For example, (2 . in) specifies a width of 2 inches, while (0.5 . IMAGE) specifies half the width (or height) of the specified image (which should be given by its image spec). The form (+ EXPR ...) adds up the value of the expressions. The form (- EXPR ...) negates or subtracts the value of the expressions. Text shown in the header line that uses :align-to display specifications is not automatically realigned when display-line-numbers-mode is turned on and off, or when the width of line numbers on display changes. To arrange for the header-line text alignment to be updated, thus keeping the header-line text aligned with the buffer text, turn on the header-line-indent-mode in the buffer and use its two variables, header-line-indent and header-line-indent-width, in the display specification. Header Lines. Here's a simple example:

(setq header-line-format
      (concat (propertize " "
                          'display
                          '(space :align-to
                                  (+ header-line-indent-width 10)))
              "Column"))

This will keep the text Column on the header line aligned with column 10 of buffer text, regardless of whether display-line-numbers-mode is on or off, and also when line-number display changes its width.

Here are the other sorts of display specifications that you can use in the display text property.

STRING

Display string instead of the text that has this property. Recursive display specifications are not supported—string's display properties, if any, are not used.

(image . IMAGE-PROPS)

This kind of display specification is an image descriptor (Image Descriptors). When used as a display specification, it means to display the image instead of the text that has the display specification.

(slice X Y WIDTH HEIGHT)

This specification together with image specifies a slice (a partial area) of the image to display. The elements y and x specify the top left corner of the slice, within the image; width and height specify the width and height of the slice. Integers are numbers of pixels. A floating-point number in the range 0.0–1.0 stands for that fraction of the width or height of the entire image.

((margin nil) STRING)

A display specification of this form means to display string instead of the text that has the display specification, at the same position as that text. It is equivalent to using just string, but it is done as a special case of marginal display (Display Margins).

(left-fringe BITMAP [ FACE ] ), (right-fringe BITMAP [ FACE ] )

This display specification on any character of a line of text causes the specified bitmap be displayed in the left or right fringes for that line, instead of the characters that have the display specification. The optional face specifies the face whose colors are to be used for the bitmap display. Fringe Bitmaps, for the details.

(space-width FACTOR)

This display specification affects all the space characters within the text that has the specification. It displays all of these spaces factor times as wide as normal. The element factor should be an integer or float. Characters other than spaces are not affected at all; in particular, this has no effect on tab characters.

(min-width (WIDTH))

This display specification ensures the text that has it takes at least width space on display, by adding a stretch of white space to the end of the text if the text is shorter than width. The text is partitioned using the identity of the parameter, which is why the parameter is a list with one element. For instance: (insert (propertize "foo" 'display '(min-width (6.0)))) This will add padding after foo bringing the total width up to the width of six normal characters. Note that the affected characters are identified by the (6.0) list in the display property, compared with eq. The element width can be either an integer or a float specifying the required minimum width of the text (Pixel Specification).

(height HEIGHT)

This display specification makes the text taller or shorter. Here are the possibilities for height:

(+ N)

This means to use a font that is n steps larger. A step is defined by the set of available fonts—specifically, those that match what was otherwise specified for this text, in all attributes except height. Each size for which a suitable font is available counts as another step. n should be an integer.

(- N)

This means to use a font that is n steps smaller.

a number, FACTOR

A number, factor, means to use a font that is factor times as tall as the default font.

a symbol, FUNCTION

A symbol is a function to compute the height. It is called with the current height as argument, and should return the new height to use.

anything else, FORM

If the height value doesn't fit the previous possibilities, it is a form. Emacs evaluates it to get the new height, with the symbol height bound to the current specified font height.

(raise FACTOR)

This kind of display specification raises or lowers the text it applies to, relative to the baseline of the line. It is mainly meant to support display of subscripts and superscripts. The factor must be a number, which is interpreted as a multiple of the height of the affected text. If it is positive, that means to display the characters raised. If it is negative, that means to display them lower down. Note that if the text also has a height display specification, which was specified before (i.e. to the left of) raise, the latter will affect the amount of raising or lowering in pixels, because that is based on the height of the text being raised. Therefore, if you want to display a sub- or superscript that is smaller than the normal text height, consider specifying raise before height.

You can make any display specification conditional. To do that, package it in another list of the form (when CONDITION . SPEC). Then the specification spec applies only when condition evaluates to a non-nil value. During the evaluation, object is bound to the string or buffer having the conditional display property. position and buffer-position are bound to the position within object and the buffer position where the display property was found, respectively. Both positions can be different when object is a string. Note that condition will only be evaluated when redisplay examines the text where this display spec is located, so this feature is best suited for conditions that are relatively stable, i.e. yield, for each particular buffer position, the same results on every evaluation. If the results change for the same text location, e.g., if the result depends on the position of point, then the conditional specification might not do what you want, because redisplay examines only those parts of buffer text where it has reasons to assume that something changed since the last display cycle.

A buffer can have blank areas called display margins on the left and on the right. Ordinary text never appears in these areas, but you can put things into the display margins using the display property. There is currently no way to make text or images in the margin mouse-sensitive. The way to display something in the margins is to specify it in a margin display specification in the display property of some text. This is a replacing display specification, meaning that the text you put it on does not get displayed; the margin display appears, but that text does not. A margin display specification looks like ((margin right-margin) SPEC) or ((margin left-margin) SPEC). Here, spec is another display specification that says what to display in the margin. Typically it is a string of text to display, or an image descriptor. To display something in the margin in association with certain buffer text, without altering or preventing the display of that text, put on that text an overlay with a before-string property, and put the margin display specification on the contents of the before-string. Note that if the string to be displayed in the margin doesn't specify a face, its face is determined using the same rules and priorities as it is for strings displayed in the text area (Displaying Faces). If this results in undesirable "leaking" of faces into the margin, make sure the string has an explicit face specified for it. Before the display margins can display anything, you must give them a nonzero width. The usual way to do that is to set these variables:

left-margin-width

This variable specifies the width of the left margin, in character cell (a.k.a. "column") units. It is buffer-local in all buffers. A value of nil means no left marginal area.

right-margin-width

This variable specifies the width of the right margin, in character cell units. It is buffer-local in all buffers. A value of nil means no right marginal area.

Setting these variables does not immediately affect the window. These variables are checked when a new buffer is displayed in the window. Thus, you can make changes take effect by calling set-window-buffer. Do not use these variables to try to determine the current width of the left or right margin. Instead, use the function window-margins. You can also set the margin widths immediately.

set-window-margins

This function specifies the margin widths for window window, in character cell units. The argument left controls the left margin, and right controls the right margin (default 0). If window is not large enough to accommodate margins of the desired width, this leaves the margins of window unchanged. The values specified here may be later overridden by invoking set-window-buffer (Buffers and Windows) on window with its keep-margins argument nil or omitted.

window-margins

This function returns the width of the left and right margins of window as a cons cell of the form (LEFT . RIGHT). If one of the two marginal areas does not exist, its width is returned as nil; if neither of the two margins exist, the function returns (nil). If window is nil, the selected window is used.

Emacs can display a number of different image formats. Some of these image formats are supported only if particular support libraries are installed. On some platforms, Emacs can load support libraries on demand; if so, the variable dynamic-library-alist can be used to modify the set of known names for these dynamic libraries. Dynamic Libraries. Supported image formats (and the required support libraries) include PBM and XBM (which do not depend on support libraries and are always available), XPM (libXpm), GIF (libgif or libungif), JPEG (libjpeg), TIFF (libtiff), PNG (libpng), SVG (librsvg), and WebP (libwebp). Each of these image formats is associated with an image type symbol. The symbols for the above formats are, respectively, pbm, xbm, xpm, gif, jpeg, tiff, png, svg, and webp. On some platforms, the built-in image support that doesn't require any optional libraries includes BMP images.(On MS-Windows) Furthermore, if you build Emacs with ImageMagick (libMagickWand) support, Emacs can display any image format that ImageMagick can. ImageMagick Images. All images displayed via ImageMagick have type symbol imagemagick.

image-types

This variable contains a list of type symbols for image formats which are potentially supported in the current configuration. "Potentially" means that Emacs knows about the image types, not necessarily that they can be used (for example, they could depend on unavailable dynamic libraries). To know which image types are really available, use image-type-available-p.

image-type-available-p

This function returns non-nil if images of type type can be loaded and displayed. type must be an image type symbol. For image types whose support libraries are statically linked, this function always returns t. For image types whose support libraries are dynamically loaded, it returns t if the library could be loaded and nil otherwise.

An image descriptor is a list which specifies the underlying data for an image, and how to display it. It is typically used as the value of a display overlay or text property (Other Display Specs); but Showing Images, for convenient helper functions to insert images into buffers. Each image descriptor has the form (image . PROPS), where props is a property list of alternating keyword symbols and values, including at least the pair :type TYPE that specifies the image type. Image descriptors which define image dimensions, :width, :height, :max-width and :max-height, may take either an integer, which represents the dimension in pixels, or a pair (VALUE . em), where value is the dimension's length in ems/(In typography an em is a distance equivalent to the height of the type. For example when using 12 point type 1 em is equal to 12 points. Its use ensures distances and type remain proportional.). One em is equivalent to the height of the font and /value may be an integer or a float. The following is a list of properties that are meaningful for all image types (there are also properties which are meaningful only for certain image types, as documented in the following subsections):

:type TYPE

The image type. Image Formats. Every image descriptor must include this property.

:file FILE

This says to load the image from file file. If file is not an absolute file name, it is expanded relative to each of the directories mentioned by image-load-path (Defining Images).

:data DATA

This specifies the raw image data. Each image descriptor must have either :data or :file, but not both. For most image types, the value of a :data property should be a string containing the image data. Some image types do not support :data; for some others, :data alone is not enough, so you need to use other image properties along with :data. See the following subsections for details.

:margin MARGIN

This specifies how many pixels to add as an extra margin around the image. The value, margin, must be a non-negative number, or a pair (X . Y) of such numbers. If it is a pair, x specifies how many pixels to add horizontally, and y specifies how many pixels to add vertically. If :margin is not specified, the default is zero.

:ascent ASCENT

This specifies the amount of the image's height to use for its ascent—that is, the part above the baseline. The value, ascent, must be a number in the range 0 to 100, or the symbol center. If ascent is a number, that percentage of the image's height is used for its ascent. If ascent is center, the image is vertically centered around a centerline which would be the vertical centerline of text drawn at the position of the image, in the manner specified by the text properties and overlays that apply to the image. If this property is omitted, it defaults to 50.

:relief RELIEF

This adds a shadow rectangle around the image. The value, relief, specifies the width of the shadow lines, in pixels. If relief is negative, shadows are drawn so that the image appears as a pressed button; otherwise, it appears as an unpressed button.

:width WIDTH, :height HEIGHT

The :width and :height keywords are used for scaling the image. If only one of them is specified, the other one will be calculated so as to preserve the aspect ratio. If both are specified, aspect ratio may not be preserved.

:max-width MAX-WIDTH, :max-height MAX-HEIGHT

The :max-width and :max-height keywords are used for scaling if the size of the image exceeds these values. If :width is set, it will have precedence over max-width, and if :height is set, it will have precedence over max-height, but you can otherwise mix these keywords as you wish. If both :max-width and :height are specified, but :width is not, preserving the aspect ratio might require that width exceeds :max-width. If this happens, scaling will use a smaller value for the height so as to preserve the aspect ratio while not exceeding :max-width. Similarly when both :max-height and :width are specified, but :height is not. For example, if you have a 200x100 image and specify that :width should be 400 and :max-height should be 150, you'll end up with an image that is 300x150: Preserving the aspect ratio and not exceeding the "max" setting. This combination of parameters is a useful way of saying "display this image as large as possible, but no larger than the available display area".

:scale SCALE

This should be a number, where values higher than 1 means to increase the size, and lower means to decrease the size, by multiplying both the width and height. For instance, a value of 0.25 will make the image a quarter size of what it originally was. If the scaling makes the image larger than specified by :max-width or :max-height, the resulting size will not exceed those two values. If both :scale and :height=/:width= are specified, the height/width will be adjusted by the specified scaling factor.

:rotation ANGLE

Specifies a rotation angle in degrees. Only multiples of 90 degrees are supported, unless the image type is imagemagick. Positive values rotate clockwise, negative values counter-clockwise. Rotation is performed after scaling and cropping.

:flip FLIP

If this is t, the image will be horizontally flipped. Currently it has no effect if the image type is imagemagick. Vertical flipping can be achieved by rotating the image 180 degrees and toggling this value.

:transform-smoothing SMOOTH

If this is t, any image transform will have smoothing applied; if nil, no smoothing will be applied. The exact algorithm used is platform dependent, but should be equivalent to bilinear filtering. Disabling smoothing will use the nearest neighbor algorithm. If this property is not specified, create-image will use the image-transform-smoothing user option to say whether scaling should be done or not. This option can be nil (no smoothing), t (use smoothing) or a predicate function that's called with the image object as the only parameter, and should return either nil or t. The default is for down-scaling to apply smoothing, and for large up-scaling to not apply smoothing.

:index FRAME

Multi-Frame Images.

:conversion ALGORITHM

This specifies a conversion algorithm that should be applied to the image before it is displayed; the value, algorithm, specifies which algorithm.

laplace, emboss

Specifies the Laplace edge detection algorithm, which blurs out small differences in color while highlighting larger differences. People sometimes consider this useful for displaying the image for a disabled button.

(edge-detection :matrix MATRIX :color-adjust ADJUST)

Specifies a general edge-detection algorithm. matrix must be either a nine-element list or a nine-element vector of numbers. A pixel at position x/y in the transformed image is computed from original pixels around that position. matrix specifies, for each pixel in the neighborhood of x/y, a factor with which that pixel will influence the transformed pixel; element 0 specifies the factor for the pixel at x-1/y-1, element 1 the factor for the pixel at x/y-1 etc., as shown below: @display (x-1/y-1 x/y-1 x+1/y-1 x-1/y x/y x+1/y x-1/y+1 x/y+1 x+1/y+1) @end display The resulting pixel is computed from the color intensity of the color resulting from summing up the RGB values of surrounding pixels, multiplied by the specified factors, and dividing that sum by the sum of the factors' absolute values. Laplace edge-detection currently uses a matrix of @display (1 0 0 0 0 0 0 0 -1) @end display Emboss edge-detection uses a matrix of @display ( 2 -1 0 -1 0 1 0 1 -2) @end display

disabled

Specifies transforming the image so that it looks disabled.

:mask MASK

If mask is heuristic or (heuristic BG), build a clipping mask for the image, so that the background of a frame is visible behind the image. If bg is not specified, or if bg is t, determine the background color of the image by looking at the four corners of the image, assuming the most frequently occurring color from the corners is the background color of the image. Otherwise, bg must be a list (RED GREEN BLUE) specifying the color to assume for the background of the image. If mask is nil, remove a mask from the image, if it has one. Images in some formats include a mask which can be removed by specifying :mask nil.

:pointer SHAPE

This specifies the pointer shape when the mouse pointer is over this image. Pointer Shape, for available pointer shapes.

:map MAP

This associates an image map of hot spots with this image. An image map is an alist where each element has the format (AREA ID PLIST). An area is specified as either a rectangle, a circle, or a polygon. A rectangle is a cons (rect . ((X0 . Y0) . (X1 . Y1))) which specifies the pixel coordinates of the upper left and bottom right corners of the rectangle area. A circle is a cons (circle . ((X0 . Y0) . R)) which specifies the center and the radius of the circle; r may be a float or integer. A polygon is a cons (poly . [X0 Y0 X1 Y1 ...]) where each pair in the vector describes one corner in the polygon. When the mouse pointer lies on a hot-spot area of an image, the plist of that hot-spot is consulted; if it contains a help-echo property, that defines a tool-tip for the hot-spot, and if it contains a pointer property, that defines the shape of the mouse cursor when it is on the hot-spot. Pointer Shape, for available pointer shapes. When you click the mouse when the mouse pointer is over a hot-spot, an event is composed by combining the id of the hot-spot with the mouse event; for instance, [area4 mouse-1] if the hot-spot's id is area4. Note that the map's coordinates should reflect the displayed image after all transforms have been done (rotation, scaling and so on), and also note that Emacs (by default) performs auto-scaling of images, so to make things match up, you should either specify :scale 1.0 when creating the image, or use the result of image-compute-scaling-factor to compute the elements of the map.

image-mask-p

This function returns t if image spec has a mask bitmap. frame is the frame on which the image will be displayed. frame nil or omitted means to use the selected frame (Input Focus).

image-transforms-p

This function returns non-nil if frame supports image scaling and rotation. frame nil or omitted means to use the selected frame (Input Focus). The returned list includes symbols that indicate which image transform operations are supported:

scale

Image scaling is supported by frame via the :scale, :width, :height, :max-width, and :max-height properties.

rotate90

Image rotation is supported by frame if the rotation angle is an integral multiple of 90 degrees.

If image transforms are not supported, :rotation, :crop, :width, :height, :scale, :max-width and :max-height will only be usable through ImageMagick, if available (ImageMagick Images).

To use XBM format, specify xbm as the image type. This image format doesn't require an external library, so images of this type are always supported. Additional image properties supported for the xbm image type are:

:foreground FOREGROUND

The value, foreground, should be a string specifying the image foreground color, or nil for the default color. This color is used for each pixel in the XBM that is 1. The default is the frame's foreground color.

:background BACKGROUND

The value, background, should be a string specifying the image background color, or nil for the default color. This color is used for each pixel in the XBM that is 0. The default is the frame's background color.

If you specify an XBM image using data within Emacs instead of an external file, use the following three properties:

:data DATA

The value, data, specifies the contents of the image. There are three formats you can use for data:

?

:: A vector of strings or bool-vectors, each specifying one line of the image. Do specify :data-height and :data-width.

?

:: A string containing the same byte sequence as an XBM file would contain.

?

:: A string or a bool-vector containing the bits of the image (plus perhaps some extra bits at the end that will not be used). It should contain at least STRIDE * HEIGHT bits, where stride is the smallest multiple of 8 greater than or equal to the width of the image. In this case, you should specify :data-height, :data-width and :stride, both to indicate that the string contains just the bits rather than a whole XBM file, and to specify the size of the image.

:stride STRIDE

The number of bool vector entries stored for each row; the smallest multiple of 8 greater than or equal to width.

To use XPM format, specify xpm as the image type. The additional image property :color-symbols is also meaningful with the xpm image type:

:color-symbols SYMBOLS

The value, symbols, should be an alist whose elements have the form (NAME . COLOR). In each element, name is the name of a color as it appears in the image file, and color specifies the actual color to use for displaying that name.

If your Emacs build has ImageMagick support, you can use the ImageMagick library to load many image formats (File Conveniences). The image type symbol for images loaded via ImageMagick is imagemagick, regardless of the actual underlying image format. To check for ImageMagick support, use the following:

(image-type-available-p 'imagemagick)

imagemagick-types

This function returns a list of image file extensions supported by the current ImageMagick installation. Each list element is a symbol representing an internal ImageMagick name for an image type, such as BMP for .bmp images.

imagemagick-enabled-types

The value of this variable is a list of ImageMagick image types which Emacs may attempt to render using ImageMagick. Each list element should be one of the symbols in the list returned by imagemagick-types, or an equivalent string. Alternatively, a value of t enables ImageMagick for all possible image types. Regardless of the value of this variable, imagemagick-types-inhibit (see below) takes precedence.

imagemagick-types-inhibit

The value of this variable lists the ImageMagick image types which should never be rendered using ImageMagick, regardless of the value of imagemagick-enabled-types. A value of t disables ImageMagick entirely.

image-format-suffixes

This variable is an alist mapping image types to file name extensions. Emacs uses this in conjunction with the :format image property (see below) to give a hint to the ImageMagick library as to the type of an image. Each element has the form (TYPE EXTENSION), where type is a symbol specifying an image content-type, and extension is a string that specifies the associated file name extension.

Images loaded with ImageMagick support the following additional image descriptor properties:

:background BACKGROUND

background, if non-nil, should be a string specifying a color, which is used as the image's background color if the image supports transparency. If the value is nil, it defaults to the frame's background color.

:format TYPE

The value, type, should be a symbol specifying the type of the image data, as found in image-format-suffixes. This is used when the image does not have an associated file name, to provide a hint to ImageMagick to help it detect the image type.

:crop GEOMETRY

The value of geometry should be a list of the form (WIDTH HEIGHT X Y). width and height specify the width and height of the cropped image. If x is a positive number it specifies the offset of the cropped area from the left of the original image, and if negative the offset from the right. If y is a positive number it specifies the offset from the top of the original image, and if negative from the bottom. If x or y are nil or unspecified the crop area will be centered on the original image. If the crop area is outside or overlaps the edge of the image it will be reduced to exclude any areas outside of the image. This means it is not possible to use :crop to increase the size of the image by entering large width or height values. Cropping is performed after scaling but before rotation.

SVG (Scalable Vector Graphics) is an XML format for specifying images. SVG images support the following additional image descriptor properties:

:foreground FOREGROUND

foreground, if non-nil, should be a string specifying a color, which is used as the image's foreground color. If the value is nil, it defaults to the current face's foreground color.

:background BACKGROUND

background, if non-nil, should be a string specifying a color, which is used as the image's background color if the image supports transparency. If the value is nil, it defaults to the current face's background color.

:css CSS

css, if non-nil, should be a string specifying the CSS to override the default CSS used when generating the image.

@subsubheading SVG library If your Emacs build has SVG support, you can create and manipulate these images with the following functions from the svg.el library.

svg-create

Create a new, empty SVG image with the specified dimensions. args is an argument plist with you can specify following:

:stroke-width

The default width (in pixels) of any lines created.

:stroke

The default stroke color on any lines created.

This function returns an SVG object, a Lisp data structure that specifies an SVG image, and all the following functions work on that structure. The argument svg in the following functions specifies such an SVG object.

svg-gradient

Create a gradient in svg with identifier id. type specifies the gradient type, and can be either linear or radial. stops is a list of percentage/color pairs. The following will create a linear gradient that goes from red at the start, to green 25% of the way, to blue at the end:

(svg-gradient svg "gradient1" 'linear
              '((0 . "red") (25 . "green") (100 . "blue")))

The gradient created (and inserted into the SVG object) can later be used by all functions that create shapes. All the following functions take an optional list of keyword parameters that alter the various attributes from their default values. Valid attributes include:

:stroke-width

The width (in pixels) of lines drawn, and outlines around solid shapes.

:stroke-color

The color of lines drawn, and outlines around solid shapes.

:fill-color

The color used for solid shapes.

:id

The identified of the shape.

:gradient

If given, this should be the identifier of a previously defined gradient object.

:clip-path

Identifier of a clip path.

svg-rectangle

Add to svg a rectangle whose upper left corner is at position x///y and whose size is width///height.

(svg-rectangle svg 100 100 500 500 :gradient "gradient1")

svg-circle

Add to svg a circle whose center is at x///y and whose radius is radius.

svg-ellipse

Add to svg an ellipse whose center is at x///y, and whose horizontal radius is x-radius and the vertical radius is y-radius.

svg-line

Add to svg a line that starts at x1///y1 and extends to x2///y2.

svg-polyline

Add to svg a multiple-segment line (a.k.a. "polyline") that goes through points, which is a list of X/Y position pairs.

(svg-polyline svg '((200 . 100) (500 . 450) (80 . 100))
              :stroke-color "green")

svg-polygon

Add a polygon to svg where points is a list of X/Y pairs that describe the outer circumference of the polygon.

(svg-polygon svg '((100 . 100) (200 . 150) (150 . 90))
             :stroke-color "blue" :fill-color "red")

svg-path

Add the outline of a shape to svg according to commands, see SVG Path Commands. Coordinates by default are absolute. To use coordinates relative to the last position, or – initially – to the origin, set the attribute :relative to t. This attribute can be specified for the function or for individual commands. If specified for the function, then all commands use relative coordinates by default. To make an individual command use absolute coordinates, set :relative to nil.

(svg-path svg
	  '((moveto ((100 . 100)))
	    (lineto ((200 . 0) (0 . 200) (-200 . 0)))
	    (lineto ((100 . 100)) :relative nil))
	  :stroke-color "blue"
	  :fill-color "lightblue"
	  :relative t)

svg-text

Add the specified text to svg.

(svg-text
 svg "This is a text"
 :font-size "40"
 :font-weight "bold"
 :stroke "black"
 :fill "white"
 :font-family "impact"
 :letter-spacing "4pt"
 :x 300
 :y 400
 :stroke-width 1)

svg-embed

Add an embedded (raster) image to svg. If datap is nil, image should be a file name; otherwise it should be a string containing the image data as raw bytes. image-type should be a MIME image type, for instance "image/jpeg".

(svg-embed svg "~/rms.jpg" "image/jpeg" nil
           :width "100px" :height "100px"
           :x "50px" :y "75px")

svg-embed-base-uri-image

To svg add an embedded (raster) image placed at relative-filename. relative-filename is searched inside file-name-directory of the :base-uri svg image property. :base-uri specifies a (possibly non-existing) file name of the svg image to be created, thus all the embedded files are searched relatively to the :base-uri filename's directory. If :base-uri is omitted, then filename from where svg image is loaded is used. Using :base-uri improves the performance of embedding large images, comparing to svg-embed, because all the work is done directly by librsvg.

;; Embedding /tmp/subdir/rms.jpg and /tmp/another/rms.jpg
(svg-embed-base-uri-image svg "subdir/rms.jpg"
           :width "100px" :height "100px"
           :x "50px" :y "75px")
(svg-embed-base-uri-image svg "another/rms.jpg"
           :width "100px" :height "100px"
           :x "75px" :y "50px")
(svg-image svg :scale 1.0
           :base-uri "/tmp/dummy"
           :width 175 :height 175)

svg-clip-path

Add a clipping path to svg. If applied to a shape via the :clip-path property, parts of that shape which lie outside of the clipping path are not drawn.

(let ((clip-path (svg-clip-path svg :id "foo")))
  (svg-circle clip-path 200 200 175))
(svg-rectangle svg 50 50 300 300
               :fill-color "red"
               :clip-path "url(#foo)")

svg-node

Add the custom node tag to svg.

(svg-node svg
          'rect
          :width 300 :height 200 :x 50 :y 100 :fill-color "green")

svg-remove

Remove the element with identifier id from the svg.

svg-image

Finally, the svg-image takes an SVG object as its argument and returns an image object suitable for use in functions like insert-image.

Here's a complete example that creates and inserts an image with a circle:

(let ((svg (svg-create 400 400 :stroke-width 10)))
  (svg-gradient svg "gradient1" 'linear '((0 . "red") (100 . "blue")))
  (svg-circle svg 200 200 100 :gradient "gradient1"
                  :stroke-color "green")
  (insert-image (svg-image svg)))

@subsubheading SVG Path Commands SVG paths allow creation of complex images by combining lines, curves, arcs, and other basic shapes. The functions described below allow invoking SVG path commands from a Lisp program.

Command moveto

Move the pen to the first point in points. Additional points are connected with lines. points is a list of X/Y coordinate pairs. Subsequent moveto commands represent the start of a new subpath.

(svg-path svg '((moveto ((200 . 100) (100 . 200) (0 . 100))))
          :fill "white" :stroke "black")

Command closepath

End the current subpath by connecting it back to its initial point. A line is drawn along the connection.

(svg-path svg '((moveto ((200 . 100) (100 . 200) (0 . 100)))
                (closepath)
                (moveto ((75 . 125) (100 . 150) (125 . 125)))
                (closepath))
          :fill "red" :stroke "black")

Command lineto

Draw a line from the current point to the first element in points, a list of X/Y position pairs. If more than one point is specified, draw a polyline.

(svg-path svg '((moveto ((200 . 100)))
                (lineto ((100 . 200) (0 . 100))))
          :fill "yellow" :stroke "red")

Command horizontal-lineto

Draw a horizontal line from the current point to the first element in x-coordinates. Specifying multiple coordinates is possible, although this usually doesn't make sense.

(svg-path svg '((moveto ((100 . 200)))
                (horizontal-lineto (300)))
          :stroke "green")

Command vertical-lineto

Draw vertical lines.

(svg-path svg '((moveto ((200 . 100)))
                (vertical-lineto (300)))
          :stroke "green")

Command curveto

Using the first element in coordinate-sets, draw a cubic Bézier curve from the current point. If there are multiple coordinate sets, draw a polybezier. Each coordinate set is a list of the form (X1 Y1 X2 Y2 X Y), where (x is the curve's end point. (x1 and (x2 are control points at the beginning and at the end, respectively.

(svg-path svg '((moveto ((100 . 100)))
                (curveto ((200 100 100 200 200 200)
                          (300 200 0 100 100 100))))
          :fill "transparent" :stroke "red")

Command smooth-curveto

Using the first element in coordinate-sets, draw a cubic Bézier curve from the current point. If there are multiple coordinate sets, draw a polybezier. Each coordinate set is a list of the form (X2 Y2 X Y), where (x is the curve's end point and (x2 is the corresponding control point. The first control point is the reflection of the second control point of the previous command relative to the current point, if that command was curveto or smooth-curveto. Otherwise the first control point coincides with the current point.

(svg-path svg '((moveto ((100 . 100)))
                (curveto ((200 100 100 200 200 200)))
                (smooth-curveto ((0 100 100 100))))
          :fill "transparent" :stroke "blue")

Command quadratic-bezier-curveto

Using the first element in coordinate-sets, draw a quadratic Bézier curve from the current point. If there are multiple coordinate sets, draw a polybezier. Each coordinate set is a list of the form (X1 Y1 X Y), where (x is the curve's end point and (x1 is the control point.

(svg-path svg '((moveto ((200 . 100)))
                (quadratic-bezier-curveto ((300 100 300 200)))
                (quadratic-bezier-curveto ((300 300 200 300)))
                (quadratic-bezier-curveto ((100 300 100 200)))
                (quadratic-bezier-curveto ((100 100 200 100))))
          :fill "transparent" :stroke "pink")

Command smooth-quadratic-bezier-curveto

Using the first element in coordinate-sets, draw a quadratic Bézier curve from the current point. If there are multiple coordinate sets, draw a polybezier. Each coordinate set is a list of the form (X Y), where (x is the curve's end point. The control point is the reflection of the control point of the previous command relative to the current point, if that command was quadratic-bezier-curveto or smooth-quadratic-bezier-curveto. Otherwise the control point coincides with the current point.

(svg-path svg '((moveto ((200 . 100)))
                (quadratic-bezier-curveto ((300 100 300 200)))
                (smooth-quadratic-bezier-curveto ((200 300)))
                (smooth-quadratic-bezier-curveto ((100 200)))
                (smooth-quadratic-bezier-curveto ((200 100))))
          :fill "transparent" :stroke "lightblue")

Command elliptical-arc

Using the first element in coordinate-sets, draw an elliptical arc from the current point. If there are multiple coordinate sets, draw a sequence of elliptical arcs. Each coordinate set is a list of the form (RX RY X Y), where (x is the end point of the ellipse, and (rx are its radii. Attributes may be appended to the list:

:x-axis-rotation

The angle in degrees by which the x-axis of the ellipse is rotated relative to the x-axis of the current coordinate system.

:large-arc

If set to t, draw an arc sweep greater than or equal to 180 degrees. Otherwise, draw an arc sweep smaller than or equal to 180 degrees.

:sweep

If set to t, draw an arc in positive angle direction. Otherwise, draw it in negative angle direction.

(svg-path svg '((moveto ((200 . 250)))
                (elliptical-arc ((75 75 200 350))))
          :fill "transparent" :stroke "red")
(svg-path svg '((moveto ((200 . 250)))
                (elliptical-arc ((75 75 200 350 :large-arc t))))
          :fill "transparent" :stroke "green")
(svg-path svg '((moveto ((200 . 250)))
                (elliptical-arc ((75 75 200 350 :sweep t))))
          :fill "transparent" :stroke "blue")
(svg-path svg '((moveto ((200 . 250)))
                (elliptical-arc ((75 75 200 350 :large-arc t
                                     :sweep t))))
          :fill "transparent" :stroke "gray")
(svg-path svg '((moveto ((160 . 100)))
                (elliptical-arc ((40 100 80 0)))
                (elliptical-arc ((40 100 -40 -70
                                     :x-axis-rotation -120)))
                (elliptical-arc ((40 100 -40 70
                                     :x-axis-rotation -240))))
          :stroke "pink" :fill "lightblue"
          :relative t)

For PBM images, specify image type pbm. Color, gray-scale and monochromatic images are supported. For mono PBM images, two additional image properties are supported.

:foreground FOREGROUND

The value, foreground, should be a string specifying the image foreground color, or nil for the default color. This color is used for each pixel in the PBM that is 1. The default is the frame's foreground color.

:background BACKGROUND

The value, background, should be a string specifying the image background color, or nil for the default color. This color is used for each pixel in the PBM that is 0. The default is the frame's background color.

The remaining image types that Emacs can support are:

GIF

Image type gif. Supports the :index property. Multi-Frame Images.

JPEG

Image type jpeg.

PNG

Image type png.

TIFF

Image type tiff. Supports the :index property. Multi-Frame Images.

WebP

Image type webp.

The functions create-image, defimage and find-image provide convenient ways to create image descriptors.

create-image

This function creates and returns an image descriptor which uses the data in file-or-data. file-or-data can be a file name or a string containing the image data; data-p should be nil for the former case, non-nil for the latter case. If file-or-data is a relative file name, the function will search for it in directories mentioned in image-load-path. The optional argument type is a symbol specifying the image type. If type is omitted or nil, create-image tries to determine the image type from the file's first few bytes, or else from the file's name. The remaining arguments, props, specify additional image properties—for example,

(create-image "foo.xpm" 'xpm nil :mask 'heuristic)

Image Descriptors, for the list of supported properties. Some properties are specific to certain image types, and are described in subsections specific to those types. The function returns nil if images of this type are not supported. Otherwise it returns an image descriptor.

defimage

This macro defines symbol as an image name. The arguments specs is a list which specifies how to display the image. The third argument, doc, is an optional documentation string. Each argument in specs has the form of a property list, and each one should specify at least the :type property and either the :file or the :data property. The value of :type should be a symbol specifying the image type, the value of :file is the file to load the image from, and the value of :data is a string containing the actual image data. Here is an example:

(defimage test-image
  ((:type xpm :file "~/test1.xpm")
   (:type xbm :file "~/test1.xbm")))

defimage tests each argument, one by one, to see if it is usable—that is, if the type is supported and the file exists. The first usable argument is used to make an image descriptor which is stored in symbol. If none of the alternatives will work, then symbol is defined as nil.

image-property

Return the value of property in image. Properties can be set by using setf. Setting a property to nil will remove the property from the image.

find-image

This function provides a convenient way to find an image satisfying one of a list of image specifications specs. Each specification in specs is a property list with contents depending on image type. All specifications must at least contain the properties :type TYPE and either :file FILE or :data DATA, where type is a symbol specifying the image type, e.g., xbm, file is the file to load the image from, and data is a string containing the actual image data. The first specification in the list whose type is supported, and file exists, is used to construct the image specification to be returned. If no specification is satisfied, nil is returned. The image is looked for in image-load-path.

image-load-path

This variable's value is a list of locations in which to search for image files. If an element is a string or a variable symbol whose value is a string, the string is taken to be the name of a directory to search. If an element is a variable symbol whose value is a list, that is taken to be a list of directories to search. The default is to search in the images subdirectory of the directory specified by data-directory, then the directory specified by data-directory, and finally in the directories in load-path. Subdirectories are not automatically included in the search, so if you put an image file in a subdirectory, you have to supply the subdirectory explicitly. For example, to find the image images/foo/bar.xpm within data-directory, you should specify the image as follows:

(defimage foo-image '((:type xpm :file "foo/bar.xpm")))

image-load-path-for-library

This function returns a suitable search path for images used by the Lisp package library. The function searches for image first using image-load-path, excluding =data-directory=/images, and then in load-path, followed by a path suitable for library, which includes ../../etc/images and ../etc/images relative to the library file itself, and finally in =data-directory=/images. Then this function returns a list of directories which contains first the directory in which image was found, followed by the value of load-path. If path is given, it is used instead of load-path. If no-error is non-nil and a suitable path can't be found, don't signal an error. Instead, return a list of directories as before, except that nil appears in place of the image directory. Here is an example of using image-load-path-for-library:

(defvar image-load-path) ; shush compiler
(let* ((load-path (image-load-path-for-library
                    "mh-e" "mh-logo.xpm"))
       (image-load-path (cons (car load-path)
                              image-load-path)))
  (mh-tool-bar-folder-buttons-init))

Images are automatically scaled when created based on the image-scaling-factor variable. The value is either a floating point number (where numbers higher than 1 means to increase the size and lower means to shrink the size), or the symbol auto, which will compute a scaling factor based on the font pixel size.

You can use an image descriptor by setting up the display property yourself, but it is easier to use the functions in this section.

insert-image

This function inserts image in the current buffer at point. The value image should be an image descriptor; it could be a value returned by create-image, or the value of a symbol defined with defimage. The argument string specifies the text to put in the buffer to hold the image. If it is omitted or nil, insert-image uses " " by default. The argument area specifies whether to put the image in a margin. If it is left-margin, the image appears in the left margin; right-margin specifies the right margin. If area is nil or omitted, the image is displayed at point within the buffer's text. The argument slice specifies a slice of the image to insert. If slice is nil or omitted the whole image is inserted. (However, note that images are chopped on display at the window's right edge, because wrapping images is not supported.) Otherwise, slice is a list (X Y WIDTH HEIGHT) which specifies the x and y positions and width and height of the image area to insert. Integer values are in units of pixels. A floating-point number in the range 0.0–1.0 stands for that fraction of the width or height of the entire image. Internally, this function inserts string in the buffer, and gives it a display property which specifies image. Display Property. By default, doing interactive searches in the buffer will consider string when searching. If inhibit-isearch is non-nil, this is inhibited.

insert-sliced-image

This function inserts image in the current buffer at point, like insert-image, but splits the image into rows/x/cols equally sized slices. Emacs displays each slice as a separate image, and allows more intuitive scrolling up/down, instead of jumping up/down the entire image when paging through a buffer that displays (large) images.

put-image

This function puts image image in front of pos in the current buffer. The argument pos should be an integer or a marker. It specifies the buffer position where the image should appear. The argument string specifies the text that should hold the image as an alternative to the default x. The argument image must be an image descriptor, perhaps returned by create-image or stored by defimage. The argument area specifies whether to put the image in a margin. If it is left-margin, the image appears in the left margin; right-margin specifies the right margin. If area is nil or omitted, the image is displayed at point within the buffer's text. Internally, this function creates an overlay, and gives it a before-string property containing text that has a display property whose value is the image. (Whew! that was a mouthful…)

remove-images

This function removes images in buffer between positions start and end. If buffer is omitted or nil, images are removed from the current buffer. This removes only images that were put into buffer the way put-image does it, not images that were inserted with insert-image or in other ways.

image-size

This function returns the size of an image as a pair (WIDTH . HEIGHT). spec is an image specification. pixels non-nil means return sizes measured in pixels, otherwise return sizes measured in the default character size of frame (Frame Font). frame is the frame on which the image will be displayed. frame nil or omitted means use the selected frame (Input Focus).

max-image-size

This variable is used to define the maximum size of image that Emacs will load. Emacs will refuse to load (and display) any image that is larger than this limit. If the value is an integer, it directly specifies the maximum image height and width, measured in pixels. If it is floating point, it specifies the maximum image height and width as a ratio to the frame height and width. If the value is non-numeric, there is no explicit limit on the size of images. The purpose of this variable is to prevent unreasonably large images from accidentally being loaded into Emacs. It only takes effect the first time an image is loaded. Once an image is placed in the image cache, it can always be displayed, even if the value of max-image-size is subsequently changed (Image Cache).

image-at-point-p

This function returns t if point is on an image, and nil otherwise.

Images inserted with the insertion functions above also get a local keymap installed in the text properties (or overlays) that span the displayed image. This keymap defines the following commands:

i +

Increase the image size (image-increase-size)

i -

Decrease the image size (image-decrease-size).

i r

Rotate the image (image-rotate).

i h

Flip the image horizontally (image-flip-horizontally).

i v

Flip the image vertically (image-flip-vertically).

i o

Save the image to a file (image-save).

i c

Interactively crop the image (image-crop).

i x

Interactively cut a rectangle from the image (image-cut).

Image Mode, for more details about these image-specific key bindings.

Some image files can contain more than one image. We say that there are multiple "frames" in the image. At present, Emacs supports multiple frames for GIF, TIFF, and certain ImageMagick formats such as DJVM. The frames can be used either to represent multiple pages (this is usually the case with multi-frame TIFF files, for example), or to create animation (usually the case with multi-frame GIF files). A multi-frame image has a property :index, whose value is an integer (counting from 0) that specifies which frame is being displayed.

image-multi-frame-p

This function returns non-nil if image contains more than one frame. The actual return value is a cons (NIMAGES . DELAY), where nimages is the number of frames and delay is the delay in seconds between them, or nil if the image does not specify a delay. Images that are intended to be animated usually specify a frame delay, whereas ones that are intended to be treated as multiple pages do not.

image-current-frame

This function returns the index of the current frame number for image, counting from 0.

image-show-frame

This function switches image to frame number n. It replaces a frame number outside the valid range with that of the end of the range, unless nocheck is non-nil. If image does not contain a frame with the specified number, the image displays as a hollow box.

image-animate

This function animates image. The optional integer index specifies the frame from which to start (default 0). The optional argument limit controls the length of the animation. If omitted or nil, the image animates once only; if t it loops forever; if a number animation stops after that many seconds.

Animation operates by means of a timer. Note that Emacs imposes a minimum frame delay of 0.01 (image-minimum-frame-delay) seconds. If the image itself does not specify a delay, Emacs uses image-default-frame-delay.

image-animate-timer

This function returns the timer responsible for animating image, if there is one.

Emacs caches images so that it can display them again more efficiently. When Emacs displays an image, it searches the image cache for an existing image specification equal to the desired specification. If a match is found, the image is displayed from the cache. Otherwise, Emacs loads the image normally.

image-flush

This function removes the image with specification spec from the image cache of frame frame. Image specifications are compared using equal. If frame is nil, it defaults to the selected frame. If frame is t, the image is flushed on all existing frames. In Emacs's current implementation, each graphical terminal possesses an image cache, which is shared by all the frames on that terminal (Multiple Terminals). Thus, refreshing an image in one frame also refreshes it in all other frames on the same terminal.

One use for image-flush is to tell Emacs about a change in an image file. If an image specification contains a :file property, the image is cached based on the file's contents when the image is first displayed. Even if the file subsequently changes, Emacs continues displaying the old version of the image. Calling image-flush flushes the image from the cache, forcing Emacs to re-read the file the next time it needs to display that image. Another use for image-flush is for memory conservation. If your Lisp program creates a large number of temporary images over a period much shorter than image-cache-eviction-delay (see below), you can opt to flush unused images yourself, instead of waiting for Emacs to do it automatically.

clear-image-cache

This function clears an image cache, removing all the images stored in it. If filter is omitted or nil, it clears the cache for the selected frame. If filter is a frame, it clears the cache for that frame. If filter is t, all image caches are cleared. Otherwise, filter is taken to be a file name, and all images associated with that file name are removed from all image caches.

If an image in the image cache has not been displayed for a specified period of time, Emacs removes it from the cache and frees the associated memory.

image-cache-eviction-delay

This variable specifies the number of seconds an image can remain in the cache without being displayed. When an image is not displayed for this length of time, Emacs removes it from the image cache. Under some circumstances, if the number of images in the cache grows too large, the actual eviction delay may be shorter than this. If the value is nil, Emacs does not remove images from the cache except when you explicitly clear it. This mode can be useful for debugging.

image-cache-size

This function returns the total size of the current image cache, in bytes. An image of size 200x100 with 24 bits per color will have a cache size of 60000 bytes, for instance.

Each button has an associated list of properties defining its appearance and behavior, and other arbitrary properties may be used for application specific purposes. The following properties have special meaning to the Button package:

action

The function to call when the user invokes the button, which is passed the single argument button. By default this is ignore, which does nothing.

mouse-action

This is similar to action, and when present, will be used instead of action for button invocations resulting from mouse-clicks (instead of the user hitting RET). If not present, mouse-clicks use action instead.

face

This is an Emacs face controlling how buttons of this type are displayed; by default this is the button face.

mouse-face

This is an additional face which controls appearance during mouse-overs (merged with the usual button face); by default this is the usual Emacs highlight face.

keymap

The button's keymap, defining bindings active within the button region. By default this is the usual button region keymap, stored in the variable button-map, which defines RET and mouse-2 to invoke the button.

type

The button type. Button Types.

help-echo

A string displayed by the Emacs tooltip help system; by default, "mouse-2. Alternatively, a function that returns, or a form that evaluates to, a string to be displayed or nil. For details see Text help-echo. The function is called with three arguments, window, object, and pos. The second argument, object, is either the overlay that had the property (for overlay buttons), or the buffer containing the button (for text property buttons). The other arguments have the same meaning as for the special text property help-echo.

follow-link

The follow-link property, defining how a mouse-1 click behaves on this button, Clickable Text.

button

All buttons have a non-nil button property, which may be useful in finding regions of text that comprise buttons (which is what the standard button functions do).

There are other properties defined for the regions of text in a button, but these are not generally interesting for typical uses.

Every button has a button type, which defines default values for the button's properties. Button types are arranged in a hierarchy, with specialized types inheriting from more general types, so that it's easy to define special-purpose types of buttons for specific tasks.

define-button-type

Define a button type called name (a symbol). The remaining arguments form a sequence of property value pairs, specifying default property values for buttons with this type (a button's type may be set by giving it a type property when creating the button, using the :type keyword argument). In addition, the keyword argument :supertype may be used to specify a button-type from which name inherits its default property values. Note that this inheritance happens only when name is defined; subsequent changes to a supertype are not reflected in its subtypes.

Using define-button-type to define default properties for buttons is not necessary—buttons without any specified type use the built-in button-type button—but it is encouraged, since doing so usually makes the resulting code clearer and more efficient.

Buttons are associated with a region of text, using an overlay or text properties to hold button-specific information, all of which are initialized from the button's type (which defaults to the built-in button type button). Like all Emacs text, the appearance of the button is governed by the face property; by default (via the face property inherited from the button button-type) this is a simple underline, like a typical web-page link. For convenience, there are two sorts of button-creation functions, those that add button properties to an existing region of a buffer, called make-...button, and those that also insert the button text, called insert-...button. The button-creation functions all take the &rest argument properties, which should be a sequence of property value pairs, specifying properties to add to the button; see Button Properties. In addition, the keyword argument :type may be used to specify a button-type from which to inherit other properties; see Button Types. Any properties not explicitly specified during creation will be inherited from the button's type (if the type defines such a property). The following functions add a button using an overlay (Overlays) to hold the button properties:

make-button

This makes a button from beg to end in the current buffer, and returns it.

insert-button

This inserts a button with the label label at point, and returns it.

The following functions are similar, but using text properties (Text Properties) to hold the button properties. Such buttons do not add markers to the buffer, so editing in the buffer does not slow down if there is an extremely large numbers of buttons. However, if there is an existing face text property on the text (e.g., a face assigned by Font Lock mode), the button face may not be visible. Both of these functions return the starting position of the new button.

make-text-button

This makes a button from beg to end in the current buffer, using text properties.

insert-text-button

This inserts a button with the label label at point, using text properties.

buttonize

Sometimes it's more convenient to make a string into a button without inserting it into a buffer immediately, for instance when creating data structures that may then, later, be inserted into a buffer. This function makes string into such a string, and callback will be called when the user clicks on the button. The optional data parameter will be used as the parameter when callback is called. If nil, the button is used as the parameter instead.

These are functions for getting and setting properties of buttons. Often these are used by a button's invocation function to determine what to do. Where a button parameter is specified, it means an object referring to a specific button, either an overlay (for overlay buttons), or a buffer-position or marker (for text property buttons). Such an object is passed as the first argument to a button's invocation function when it is invoked.

button-start

Return the position at which button starts.

button-end

Return the position at which button ends.

button-get

Get the property of button button named prop.

button-put

Set button's prop property to val.

button-activate

Call button's action property (i.e., invoke the function that is the value of that property, passing it the single argument button). If use-mouse-action is non-nil, try to invoke the button's mouse-action property instead of action; if the button has no mouse-action property, use action as normal. If the button-data property is present in button, use that as the argument for the action function instead of button.

button-label

Return button's text label.

button-type

Return button's button-type.

button-has-type-p

Return t if button has button-type type, or one of type's subtypes.

button-at

Return the button at position pos in the current buffer, or nil. If the button at pos is a text property button, the return value is a marker pointing to pos.

button-type-put

Set the button-type type's prop property to val.

button-type-get

Get the property of button-type type named prop.

button-type-subtype-p

Return t if button-type type is a subtype of supertype.

These are commands and functions for locating and operating on buttons in an Emacs buffer. push-button is the command that a user uses to actually push a button, and is bound by default in the button itself to RET and to mouse-2 using a local keymap in the button's overlay or text properties. Commands that are useful outside the buttons itself, such as forward-button and backward-button are additionally available in the keymap stored in button-buffer-map; a mode which uses buttons may want to use button-buffer-map as a parent keymap for its keymap. Alternatively, the button-mode can be switched on for much the same effect: It's a minor mode that does nothing else than install button-buffer-map as a minor mode keymap. If the button has a non-nil follow-link property, and mouse-1-click-follows-link is set, a quick mouse-1 click will also activate the push-button command. Clickable Text.

Command push-button

Perform the action specified by a button at location pos. pos may be either a buffer position or a mouse-event. If use-mouse-action is non-nil, or pos is a mouse-event (Mouse Events), try to invoke the button's mouse-action property instead of action; if the button has no mouse-action property, use action as normal. pos defaults to point, except when push-button is invoked interactively as the result of a mouse-event, in which case, the mouse event's position is used. If there's no button at pos, do nothing and return nil, otherwise return t.

Command forward-button

Move to the n/th next button, or /n/th previous button if /n is negative. If n is zero, move to the start of any button at point. If wrap is non-nil, moving past either end of the buffer continues from the other end. If display-message is non-nil, the button's help-echo string is displayed. Any button with a non-nil skip property is skipped over. Returns the button found, and signals an error if no buttons can be found. If no-error is non-nil, return nil instead of signaling the error.

Command backward-button

Move to the n/th previous button, or /n/th next button if /n is negative. If n is zero, move to the start of any button at point. If wrap is non-nil, moving past either end of the buffer continues from the other end. If display-message is non-nil, the button's help-echo string is displayed. Any button with a non-nil skip property is skipped over. Returns the button found, and signals an error if no buttons can be found. If no-error is non-nil, return nil instead of signaling the error.

next-button

@defunx previous-button pos &optional count-current Return the next button after (for next-button) or before (for previous-button) position pos in the current buffer. If count-current is non-nil, count any button at pos in the search, instead of starting at the next button.

In this subsection, ewoc and node stand for the structures described above (Abstract Display), while data stands for an arbitrary Lisp object used as a data element.

ewoc-create

This constructs and returns a new ewoc, with no nodes (and thus no data elements). pretty-printer should be a function that takes one argument, a data element of the sort you plan to use in this ewoc, and inserts its textual description at point using insert (and never insert-before-markers, because that would interfere with the Ewoc package's internal mechanisms). Normally, a newline is automatically inserted after the header, the footer and every node's textual description. If nosep is non-nil, no newline is inserted. This may be useful for displaying an entire ewoc on a single line, for example, or for making nodes invisible by arranging for pretty-printer to do nothing for those nodes. An ewoc maintains its text in the buffer that is current when you create it, so switch to the intended buffer before calling ewoc-create.

ewoc-buffer

This returns the buffer where ewoc maintains its text.

ewoc-get-hf

This returns a cons cell (HEADER . FOOTER) made from ewoc's header and footer.

ewoc-set-hf

This sets the header and footer of ewoc to the strings header and footer, respectively.

ewoc-enter-first

@defunx ewoc-enter-last ewoc data These add a new node encapsulating data, putting it, respectively, at the beginning or end of ewoc's chain of nodes.

ewoc-enter-before

@defunx ewoc-enter-after ewoc node data These add a new node encapsulating data, adding it to ewoc before or after node, respectively.

ewoc-prev

@defunx ewoc-next ewoc node These return, respectively, the previous node and the next node of node in ewoc.

ewoc-nth

This returns the node in ewoc found at zero-based index n. A negative n means count from the end. ewoc-nth returns nil if n is out of range.

ewoc-data

This extracts the data encapsulated by node and returns it.

ewoc-set-data

This sets the data encapsulated by node to data.

ewoc-locate

This determines the node in ewoc which contains point (or pos if specified), and returns that node. If ewoc has no nodes, it returns nil. If pos is before the first node, it returns the first node; if pos is after the last node, it returns the last node. The optional third arg guess should be a node that is likely to be near pos; this doesn't alter the result, but makes the function run faster.

ewoc-location

This returns the start position of node.

ewoc-goto-prev

@defunx ewoc-goto-next ewoc arg These move point to the previous or next, respectively, arg/th node in /ewoc. ewoc-goto-prev does not move if it is already at the first node or if ewoc is empty, whereas ewoc-goto-next moves past the last node, returning nil. Excepting this special case, these functions return the node moved to.

ewoc-goto-node

This moves point to the start of node in ewoc.

ewoc-refresh

This function regenerates the text of ewoc. It works by deleting the text between the header and the footer, i.e., all the data elements' representations, and then calling the pretty-printer function for each node, one by one, in order.

ewoc-invalidate

This is similar to ewoc-refresh, except that only nodes in ewoc are updated instead of the entire set.

ewoc-delete

This deletes each node in nodes from ewoc.

ewoc-filter

This calls predicate for each data element in ewoc and deletes those nodes for which predicate returns nil. Any args are passed to predicate.

ewoc-collect

This calls predicate for each data element in ewoc and returns a list of those elements for which predicate returns non-nil. The elements in the list are ordered as in the buffer. Any args are passed to predicate.

ewoc-map

This calls map-function for each data element in ewoc and updates those nodes for which map-function returns non-nil. Any args are passed to map-function.

Here is a simple example using functions of the ewoc package to implement a color components display, an area in a buffer that represents a vector of three integers (itself representing a 24-bit RGB value) in various ways.

(setq colorcomp-ewoc nil
      colorcomp-data nil
      colorcomp-mode-map nil
      colorcomp-labels ["Red" "Green" "Blue"])

(defun colorcomp-pp (data)
  (if data
      (let ((comp (aref colorcomp-data data)))
        (insert (aref colorcomp-labels data) "\t: #x"
                (format "%02X" comp) " "
                (make-string (ash comp -2) ?#) "\n"))
    (let ((cstr (format "#%02X%02X%02X"
                        (aref colorcomp-data 0)
                        (aref colorcomp-data 1)
                        (aref colorcomp-data 2)))
          (samp " (sample text) "))
      (insert "Color\t: "
              (propertize samp 'face
                          `(foreground-color . ,cstr))
              (propertize samp 'face
                          `(background-color . ,cstr))
              "\n"))))

(defun colorcomp (color)
  "Allow fiddling with COLOR in a new buffer.
The buffer is in Color Components mode."
  (interactive "sColor (name or #RGB or #RRGGBB): ")
  (when (string= "" color)
    (setq color "green"))
  (unless (color-values color)
    (error "No such color: %S" color))
  (switch-to-buffer
   (generate-new-buffer (format "originally: %s" color)))
  (kill-all-local-variables)
  (setq major-mode 'colorcomp-mode
        mode-name "Color Components")
  (use-local-map colorcomp-mode-map)
  (erase-buffer)
  (buffer-disable-undo)
  (let ((data (apply 'vector (mapcar (lambda (n) (ash n -8))
                                     (color-values color))))
        (ewoc (ewoc-create 'colorcomp-pp
                           "\nColor Components\n\n"
                           (substitute-command-keys
                            "\n\\{colorcomp-mode-map}"))))
    (set (make-local-variable 'colorcomp-data) data)
    (set (make-local-variable 'colorcomp-ewoc) ewoc)
    (ewoc-enter-last ewoc 0)
    (ewoc-enter-last ewoc 1)
    (ewoc-enter-last ewoc 2)
    (ewoc-enter-last ewoc nil)))

This example can be extended to be a color selection widget (in other words, the "controller" part of the "model–view–controller" design paradigm) by defining commands to modify colorcomp-data and to finish the selection process, and a keymap to tie it all together conveniently.

(defun colorcomp-mod (index limit delta)
  (let ((cur (aref colorcomp-data index)))
    (unless (= limit cur)
      (aset colorcomp-data index (+ cur delta)))
    (ewoc-invalidate
     colorcomp-ewoc
     (ewoc-nth colorcomp-ewoc index)
     (ewoc-nth colorcomp-ewoc -1))))

(defun colorcomp-R-more () (interactive) (colorcomp-mod 0 255 1))
(defun colorcomp-G-more () (interactive) (colorcomp-mod 1 255 1))
(defun colorcomp-B-more () (interactive) (colorcomp-mod 2 255 1))
(defun colorcomp-R-less () (interactive) (colorcomp-mod 0 0 -1))
(defun colorcomp-G-less () (interactive) (colorcomp-mod 1 0 -1))
(defun colorcomp-B-less () (interactive) (colorcomp-mod 2 0 -1))

(defun colorcomp-copy-as-kill-and-exit ()
  "Copy the color components into the kill ring and kill the buffer.
The string is formatted #RRGGBB (hash followed by six hex digits)."
  (interactive)
  (kill-new (format "#%02X%02X%02X"
                    (aref colorcomp-data 0)
                    (aref colorcomp-data 1)
                    (aref colorcomp-data 2)))
  (kill-buffer nil))

(setq colorcomp-mode-map
      (define-keymap :suppress t
        "i" 'colorcomp-R-less
        "o" 'colorcomp-R-more
        "k" 'colorcomp-G-less
        "l" 'colorcomp-G-more
        "," 'colorcomp-B-less
        "." 'colorcomp-B-more
        "SPC" 'colorcomp-copy-as-kill-and-exit))

Note that we never modify the data in each node, which is fixed when the ewoc is created to be either nil or an index into the vector colorcomp-data, the actual color components.

Here are the conventions for displaying each character code (in the absence of a display table, which can override these conventions; Display Tables).

• The printable ASCII characters, character codes 32 through 126 (consisting of numerals, English letters, and symbols like #) are displayed literally.
• The tab character (character code 9) displays as whitespace stretching up to the next tab stop column. Text Display. The variable tab-width controls the number of spaces per tab stop (see below).
• The newline character (character code 10) has a special effect: it ends the preceding line and starts a new line.
• The non-printable ASCII control characters—character codes 0 through 31, as well as the DEL character (character code 127)—display in one of two ways according to the variable ctl-arrow. If this variable is non-nil (the default), these characters are displayed as sequences of two glyphs, where the first glyph is ^ (a display table can specify a glyph to use instead of ^); e.g., the DEL character is displayed as ^?. If ctl-arrow is nil, these characters are displayed as octal escapes (see below). This rule also applies to carriage return (character code 13), if that character appears in the buffer. But carriage returns usually do not appear in buffer text; they are eliminated as part of end-of-line conversion (Coding System Basics).
• Raw bytes are non-ASCII characters with codes 128 through 255 (Text Representations). These characters display as octal escapes: sequences of four glyphs, where the first glyph is the ASCII code for \, and the others are digit characters representing the character code in octal. (A display table can specify a glyph to use instead of \.)
• Each non-ASCII character with code above 255 is displayed literally, if the terminal supports it. If the terminal does not support it, the character is said to be glyphless, and it is usually displayed using a placeholder glyph. For example, if a graphical terminal has no font for a character, Emacs usually displays a box containing the character code in hexadecimal. Glyphless Chars.

The above display conventions apply even when there is a display table, for any character whose entry in the active display table is nil. Thus, when you set up a display table, you need only specify the characters for which you want special display behavior. The following variables affect how certain characters are displayed on the screen. Since they change the number of columns the characters occupy, they also affect the indentation functions. They also affect how the mode line is displayed; if you want to force redisplay of the mode line using the new values, call the function force-mode-line-update (Mode Line Format).

ctl-arrow

This buffer-local variable controls how control characters are displayed. If it is non-nil, they are displayed as a caret followed by the character: ^A. If it is nil, they are displayed as octal escapes: a backslash followed by three octal digits, as in \001.

tab-width

The value of this buffer-local variable is the spacing between tab stops used for displaying tab characters in Emacs buffers. The value is in units of columns, and the default is 8. Note that this feature is completely independent of the user-settable tab stops used by the command tab-to-tab-stop. Indent Tabs.

A display table is a special-purpose char-table (Char-Tables), with display-table as its subtype, which is used to override the usual character display conventions. This section describes how to make, inspect, and assign elements to a display table object. The next section (Active Display Table) describes the various standard display tables and their precedence.

make-display-table

This creates and returns a display table. The table initially has nil in all elements.

The ordinary elements of the display table are indexed by character codes; the element at index c says how to display the character code c. The value should be nil (which means to display the character c according to the usual display conventions; Usual Display), or a vector of glyph codes (which means to display the character c as those glyphs; Glyphs). Warning: if you use the display table to change the display of newline characters, the whole buffer will be displayed as one long line. The display table also has six extra slots which serve special purposes. Here is a table of their meanings; nil in any slot means to use the default for that slot, as stated below.

0

The glyph for the end of a truncated screen line (the default for this is $). Glyphs. On graphical terminals, Emacs by default uses arrows in the fringes to indicate truncation, so the display table has no effect, unless you disable the fringes (Window Fringes).

1

The glyph for the end of a continued line (the default is \). On graphical terminals, Emacs by default uses curved arrows in the fringes to indicate continuation, so the display table has no effect, unless you disable the fringes.

2

The glyph for indicating a character displayed as an octal character code (the default is \).

3

The glyph for indicating a control character (the default is ^).

4

A vector of glyphs for indicating the presence of invisible lines (the default is ...). Selective Display.

5

The glyph used to draw the border between side-by-side windows (the default is |). Splitting Windows. This currently has effect only on text terminals; on graphical terminals, if vertical scroll bars are supported and in use, a scroll bar separates the two windows, and if there are no vertical scroll bars and no dividers (Window Dividers), Emacs uses a thin line to indicate the border.

For example, here is how to construct a display table that mimics the effect of setting ctl-arrow to a non-nil value (Glyphs, for the function make-glyph-code):

(setq disptab (make-display-table))
(dotimes (i 32)
  (or (= i ?\t)
      (= i ?\n)
      (aset disptab i
            (vector (make-glyph-code ?^ 'escape-glyph)
                    (make-glyph-code (+ i 64) 'escape-glyph)))))
(aset disptab 127
      (vector (make-glyph-code ?^ 'escape-glyph)
              (make-glyph-code ?? 'escape-glyph)))

display-table-slot

This function returns the value of the extra slot slot of display-table. The argument slot may be a number from 0 to 5 inclusive, or a slot name (symbol). Valid symbols are truncation, wrap, escape, control, selective-display, and vertical-border.

set-display-table-slot

This function stores value in the extra slot slot of display-table. The argument slot may be a number from 0 to 5 inclusive, or a slot name (symbol). Valid symbols are truncation, wrap, escape, control, selective-display, and vertical-border.

describe-display-table

This function displays a description of the display table display-table in a help buffer.

Command describe-current-display-table

This command displays a description of the current display table in a help buffer.

Each window can specify a display table, and so can each buffer. The window's display table, if there is one, takes precedence over the buffer's display table. If neither exists, Emacs tries to use the standard display table; if that is nil, Emacs uses the usual character display conventions (Usual Display). (Emacs does not "merge" display tables: For instance, if the window has a display table, the buffer's display table and the standard display table are completely ignored.) Note that display tables affect how the mode line is displayed, so if you want to force redisplay of the mode line using a new display table, call force-mode-line-update (Mode Line Format).

window-display-table

This function returns window's display table, or nil if there is none. The default for window is the selected window.

set-window-display-table

This function sets the display table of window to table. The argument table should be either a display table or nil.

buffer-display-table

This variable is automatically buffer-local in all buffers; its value specifies the buffer's display table. If it is nil, there is no buffer display table.

standard-display-table

The value of this variable is the standard display table, which is used when Emacs is displaying a buffer in a window with neither a window display table nor a buffer display table defined, or when Emacs is outputting text to the standard output or error streams. Although its default is typically nil, in an interactive session if the terminal cannot display curved quotes, its default maps curved quotes to ASCII approximations. Text Quoting Style.

The disp-table library defines several functions for changing the standard display table.

A glyph is a graphical symbol which occupies a single character position on the screen. Each glyph is represented in Lisp as a glyph code, which specifies a character and optionally a face to display it in (Faces). The main use of glyph codes is as the entries of display tables (Display Tables). The following functions are used to manipulate glyph codes:

make-glyph-code

This function returns a glyph code representing char char with face face. If face is omitted or nil, the glyph uses the default face; in that case, the glyph code is an integer. If face is non-nil, the glyph code is not necessarily an integer object.

glyph-char

This function returns the character of glyph code glyph.

glyph-face

This function returns face of glyph code glyph, or nil if glyph uses the default face.

You can set up a glyph table to change how glyph codes are actually displayed on text terminals. This feature is semi-obsolete; use glyphless-char-display instead (Glyphless Chars).

glyph-table

The value of this variable, if non-nil, is the current glyph table. It takes effect only on character terminals; on graphical displays, all glyphs are displayed literally. The glyph table should be a vector whose g/th element specifies how to display glyph code /g, where g is the glyph code for a glyph whose face is unspecified. Each element should be one of the following:

nil

Display this glyph literally.

a string

Display this glyph by sending the specified string to the terminal.

a glyph code

Display the specified glyph code instead.

Any integer glyph code greater than or equal to the length of the glyph table is displayed literally.

Glyphless characters are characters which are displayed in a special way, e.g., as a box containing a hexadecimal code, instead of being displayed literally. These include characters which are explicitly defined to be glyphless, as well as characters for which there is no available font (on a graphical display), and characters which cannot be encoded by the terminal's coding system (on a text terminal). The glyphless-display-mode minor mode can be used to toggle displaying glyphless characters in a convenient manner in the current buffer. If this mode is enabled, all the glyphless characters are displayed as boxes that display acronyms of their character names.

glyphless-char-display

For more fine-grained (and global) control, this variable can be used. The value of this variable is a char-table which defines glyphless characters and how they are displayed. Each entry must be one of the following display methods:

nil

Display the character in the usual way.

zero-width

Don't display the character.

thin-space

Display a thin space, 1-pixel wide on graphical displays, or 1-character wide on text terminals.

empty-box

Display an empty box.

hex-code

Display a box containing the Unicode codepoint of the character, in hexadecimal notation.

an ASCII string

Display a box containing that string. The string should contain at most 6 ASCII characters. As an exception, if the string includes just one character, on text-mode terminals that character will be displayed without a box; this allows to handle such "acronyms" as a replacement character for characters that cannot be displayed by the terminal.

a cons cell (GRAPHICAL . TEXT)

Display with graphical on graphical displays, and with text on text terminals. Both graphical and text must be one of the display methods described above.

The thin-space, empty-box, hex-code, and ASCII string display methods are drawn with the glyphless-char face. On text terminals, a box is emulated by square brackets, []. The char-table has one extra slot, which determines how to display any character that cannot be displayed with any available font, or cannot be encoded by the terminal's coding system. Its value should be one of the above display methods, except zero-width. If a character has a non-nil entry in an active display table, the display table takes effect; in this case, Emacs does not consult glyphless-char-display at all.

glyphless-char-display-control

This user option provides a convenient way to set glyphless-char-display for groups of similar characters. Do not set its value directly from Lisp code; the value takes effect only via a custom :set function (Variable Definitions), which updates glyphless-char-display. Its value should be an alist of elements (GROUP . METHOD), where group is a symbol specifying a group of characters, and method is a symbol specifying how to display them. group should be one of the following:

c0-control

ASCII control characters U+0000 to U+001F, excluding the newline and tab characters (normally displayed as escape sequences like ^A; How Text Is Displayed).

c1-control

Non-ASCII, non-printing characters U+0080 to U+009F (normally displayed as octal escape sequences like \230).

format-control

Characters of Unicode General Category [Cf], such as U+200E LEFT-TO-RIGHT MARK, but excluding characters that have graphic images, such as U+00AD SOFT HYPHEN.

bidi-control

This is a subset of format-control, but only includes characters that are related to bidirectional formatting control, like U+2069 POP DIRECTIONAL ISOLATE and U+202A LEFT-TO-RIGHT EMBEDDING. Bidirectional Display. Characters of Unicode General Category [Cf], such as U+200E LEFT-TO-RIGHT MARK, but excluding characters that have graphic images, such as U+00AD SOFT HYPHEN.

variation-selectors

Unicode VS-1 through VS-256 (U+FE00 through U+FE0F and U+E0100 through U+E01EF), which are used to select between different glyphs for the same codepoints (typically emojis).

no-font

Characters for which there is no suitable font, or which cannot be encoded by the terminal's coding system, or those for which the text-mode terminal has no glyphs.

The method symbol should be one of zero-width, thin-space, empty-box, or hex-code. These have the same meanings as in glyphless-char-display, above.