Fsun-window-init
One time setup for using Sun Windows with mouse.
Unless optional argument FORCE is non-nil, is a noop after its first call.
Returns a number representing the file descriptor of the open Sun Window,
or -1 if can not open it.

(sun-window-init &optional FORCE)Fsit-for-millisecs
Like sit-for, but ARG is milliseconds. 
Perform redisplay, then wait for ARG milliseconds or until
input is available.  Returns t if wait completed with no input.
Redisplay does not happen if input is available before it starts.

(sit-for-millisecs N)Fsleep-for-millisecs
Pause, without updating display, for ARG milliseconds.

(sleep-for-millisecs N)Fupdate-display
Perform redisplay.

(update-display)Fsun-change-cursor-icon
Change the Sun mouse cursor icon.  ICON is a lisp vector whose 1st element
is the X offset of the cursor hot-point, whose 2nd element is the Y offset
of the cursor hot-point and whose 3rd element is the cursor pixel data
expressed as a string.  If ICON is nil then the original arrow cursor is used

(sun-change-cursor-icon ICON)Fsun-set-selection
Set the current sunwindow selection to STRING.

(sun-set-selection STR)Fsun-get-selection
Return the current sunwindows selection as a string.

(sun-get-selection)Fsun-menu-internal
Set up a SunView pop-up menu and return the user's choice.
Arguments WINDOW, X, Y, BUTTON, and MENU.
*** User code should generally use sun-menu-evaluate ***

Arguments WINDOW, X, Y, BUTTON, and MENU.
Put MENU up in WINDOW at position X, Y.
The BUTTON argument specifies the button to be released that selects an item:
   1 = LEFT BUTTON
   2 = MIDDLE BUTTON
   4 = RIGHT BUTTON
The MENU argument is a vector containing (STRING . VALUE) pairs.
The VALUE of the selected item is returned.
If the VALUE of the first pair is nil, then the first STRING will be used
as a menu label.

(sun-menu-internal WINDOW X-POSITION Y-POSITION BUTTON MENU)Fint86
Call specific MSDOS interrupt number INTERRUPT with REGISTERS.
Return the updated REGISTER vector.

INTERRUPT should be an integer in the range 0 to 255.
REGISTERS should be a vector produced by `make-register' and
`set-register-value'.

(int86 INTERRUPT REGISTERS)Fmsdos-memget
Read DOS memory at offset ADDRESS into VECTOR.
Return the updated VECTOR.

(msdos-memget ADDRESS VECTOR)Fmsdos-memput
Write DOS memory at offset ADDRESS from VECTOR.

(msdos-memput ADDRESS VECTOR)Fmsdos-set-keyboard
Set keyboard layout according to COUNTRY-CODE.
If the optional argument ALLKEYS is non-nil, the keyboard is mapped for
all keys; otherwise it is only used when the ALT key is pressed.
The current keyboard layout is available in dos-keyboard-code.

(msdos-set-keyboard COUNTRY-CODE &optional ALLKEYS)Fmsdos-mouse-p
Report whether a mouse is present.

(msdos-mouse-p)Fmsdos-mouse-init
Initialize and enable mouse if available.

(msdos-mouse-init)Fmsdos-mouse-enable
Enable mouse if available.

(msdos-mouse-enable)Fmsdos-mouse-disable
Disable mouse if available.

(msdos-mouse-disable)Finsert-startup-screen
Insert copy of screen contents prior to starting emacs.
Return nil if startup screen is not available.

(insert-startup-screen)Ffile-system-info
Return storage information about the file system FILENAME is on.
Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
storage of the file system, FREE is the free storage, and AVAIL is the
storage available to a non-superuser.  All 3 numbers are in bytes.
If the underlying system call fails, value is nil.

(file-system-info FILENAME)Vdos-country-code
The country code returned by Dos when Emacs was started.
Usually this is the international telephone prefix.Vdos-codepage
The codepage active when Emacs was started.
The following are known:
	437	United States
	850	Multilingual (Latin I)
	852	Slavic (Latin II)
	857	Turkish
	860	Portugal
	861	Iceland
	863	Canada (French)
	865	Norway/DenmarkVdos-timezone-offset
The current timezone offset to UTC in minutes.
Implicitly modified when the TZ variable is changed.Vdos-version
The (MAJOR . MINOR) Dos version (subject to modification with setver).Vdos-windows-version
The (MAJOR . MINOR) Windows version for DOS session on MS-Windows.Vdos-display-scancodes
*When non-nil, the keyboard scan-codes are displayed at the bottom right
corner of the display (typically at the end of the mode line).
The output format is: scan code:char code*modifiers.Vdos-hyper-key
*If set to 1, use right ALT key as hyper key.
If set to 2, use right CTRL key as hyper key.Vdos-super-key
*If set to 1, use right ALT key as super key.
If set to 2, use right CTRL key as super key.Vdos-keypad-mode
*Controls what key code is returned by a key in the numeric keypad.
The `numlock ON' action is only taken if no modifier keys are pressed.
The value is an integer constructed by adding the following bits together:
 
  0x00	Digit key returns digit    (if numlock ON)
  0x01	Digit key returns kp-digit (if numlock ON)
  0x02	Digit key returns M-digit  (if numlock ON)
  0x03	Digit key returns edit key (if numlock ON)
 
  0x00	Grey key returns char      (if numlock ON)
  0x04	Grey key returns kp-key    (if numlock ON)
 
  0x00	Digit key returns digit    (if numlock OFF)
  0x10	Digit key returns kp-digit (if numlock OFF)
  0x20	Digit key returns M-digit  (if numlock OFF)
  0x30	Digit key returns edit key (if numlock OFF)
 
  0x00	Grey key returns char      (if numlock OFF)
  0x40	Grey key returns kp-key    (if numlock OFF)
 
  0x200	ALT-0..ALT-9 in top-row produces shifted codes.Vdos-keyboard-layout
Contains the country code for the current keyboard layout.
Use msdos-set-keyboard to select another keyboard layout.Vdos-decimal-point
If non-zero, it contains the character to be returned when the
decimal point key in the numeric keypad is pressed when Num Lock is on.
If zero, the decimal point key returns the country code specific value.Fmsdos-set-mouse-buttons
Set the number of mouse buttons to use by Emacs.
This is useful with mice that report the number of buttons inconsistently,
e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of
them.  This happens with wheeled mice on Windows 9X, for example.

(msdos-set-mouse-buttons NBUTTONS)Fmsdos-remember-default-colors
Remember the screen colors of the current frame.

(msdos-remember-default-colors FRAME)Frecent-doskeys
Return vector of last 100 keyboard input values seen in dos_rawgetc.
Each input key receives two values in this vector: first the ASCII code,
and then the scan code.

(recent-doskeys)Fmsdos-long-file-names
Return non-nil if long file names are supported on MSDOS.

(msdos-long-file-names)Fmsdos-downcase-filename
Convert alphabetic characters in FILENAME to lower case and return that.
When long filenames are supported, doesn't change FILENAME.
If FILENAME is not a string, returns nil.
The argument object is never altered--the value is a copy.

(msdos-downcase-filename FILENAME)Vx-bitmap-file-path
List of directories to search for bitmap files for X.Vx-stretch-cursor
*Non-nil means draw block cursor as wide as the glyph under it.
For example, if a block cursor is over a tab, it will be drawn as
wide as that tab on the display.  (No effect on MS-DOS.)Vdos-unsupported-char-glyph
*Glyph to display instead of chars not supported by current codepage.

This variable is used only by MSDOS terminals.Vdelete-exited-processes
*Non-nil means delete processes immediately when they exit.
nil means don't delete them until `list-processes' is run.Vx-stretch-cursor
*Non-nil means draw block cursor as wide as the glyph under it.
For example, if a block cursor is over a tab, it will be drawn as
wide as that tab on the display.Vx-use-underline-position-properties
*Non-nil means make use of UNDERLINE_POSITION font properties.
Nil means ignore them.  If you encounter fonts with bogus
UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
to 4.1, set this to nil.Vx-toolkit-scroll-bars
What X toolkit scroll bars Emacs uses.
A value of nil means Emacs doesn't use X toolkit scroll bars.
Otherwise, value is a symbol describing the X toolkit.Fx-get-resource
Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
class, where INSTANCE is the name under which Emacs was invoked, or
the name specified by the `-name' or `-rn' command-line arguments.

The optional arguments COMPONENT and SUBCLASS add to the key and the
class, respectively.  You must specify both of them or neither.
If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
and the class is `Emacs.CLASS.SUBCLASS'.

(x-get-resource ATTRIBUTE CLASS &optional COMPONENT SUBCLASS)Fx-parse-geometry
Parse an X-style geometry string STRING.
Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
The properties returned may include `top', `left', `height', and `width'.
The value of `left' or `top' may be an integer,
or a list (+ N) meaning N pixels relative to top/left corner,
or a list (- N) meaning -N pixels relative to bottom/right corner.

(x-parse-geometry STRING)Fx-create-frame
Make a new X window, which is called a "frame" in Emacs terms.
Returns an Emacs frame object.
ALIST is an alist of frame parameters.
If the parameters specify that the frame should not have a minibuffer,
and do not specify a specific minibuffer window to use,
then `default-minibuffer-frame' must be a frame whose minibuffer can
be shared by the new frame.

This function is an internal primitive--use `make-frame' instead.

(x-create-frame PARMS)Fx-focus-frame
Set the input focus to FRAME.
FRAME nil means use the selected frame.

(x-focus-frame FRAME)Fxw-color-defined-p
Internal function called by `color-defined-p', which see.

(xw-color-defined-p COLOR &optional FRAME)Fxw-color-values
Internal function called by `color-values', which see.

(xw-color-values COLOR &optional FRAME)Fxw-display-color-p
Internal function called by `display-color-p', which see.

(xw-display-color-p &optional DISPLAY)Fx-display-grayscale-p
Return t if the X display supports shades of gray.
Note that color displays do support shades of gray.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-grayscale-p &optional DISPLAY)Fx-display-pixel-width
Returns the width in pixels of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-pixel-width &optional DISPLAY)Fx-display-pixel-height
Returns the height in pixels of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-pixel-height &optional DISPLAY)Fx-display-planes
Returns the number of bitplanes of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-planes &optional DISPLAY)Fx-display-color-cells
Returns the number of color cells of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-color-cells &optional DISPLAY)Fx-server-max-request-size
Returns the maximum request size of the X server of display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-server-max-request-size &optional DISPLAY)Fx-server-vendor
Returns the vendor ID string of the X server of display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-server-vendor &optional DISPLAY)Fx-server-version
Returns the version numbers of the X server of display DISPLAY.
The value is a list of three integers: the major and minor
version numbers of the X Protocol in use, and the vendor-specific release
number.  See also the function `x-server-vendor'.

The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-server-version &optional DISPLAY)Fx-display-screens
Returns the number of screens on the X server of display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-screens &optional DISPLAY)Fx-display-mm-height
Returns the height in millimeters of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-mm-height &optional DISPLAY)Fx-display-mm-width
Returns the width in millimeters of the X display DISPLAY.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-mm-width &optional DISPLAY)Fx-display-backing-store
Returns an indication of whether X display DISPLAY does backing store.
The value may be `always', `when-mapped', or `not-useful'.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-backing-store &optional DISPLAY)Fx-display-visual-class
Returns the visual class of the X display DISPLAY.
The value is one of the symbols `static-gray', `gray-scale',
`static-color', `pseudo-color', `true-color', or `direct-color'.

The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-visual-class &optional DISPLAY)Fx-display-save-under
Returns t if the X display DISPLAY supports the save-under feature.
The optional argument DISPLAY specifies which display to ask about.
DISPLAY should be either a frame or a display name (a string).
If omitted or nil, that stands for the selected frame's display.

(x-display-save-under &optional DISPLAY)Fx-open-connection
Open a connection to an X server.
DISPLAY is the name of the display to connect to.
Optional second arg XRM-STRING is a string of resources in xrdb format.
If the optional third arg MUST-SUCCEED is non-nil,
terminate Emacs if we can't open the connection.

(x-open-connection DISPLAY &optional XRM-STRING MUST-SUCCEED)Fx-close-connection
Close the connection to DISPLAY's X server.
For DISPLAY, specify either a frame or a display name (a string).
If DISPLAY is nil, that stands for the selected frame's display.

(x-close-connection DISPLAY)Fx-display-list
Return the list of display names that Emacs has connections to.

(x-display-list)Fx-synchronize
If ON is non-nil, report X errors as soon as the erring request is made.
If ON is nil, allow buffering of requests.
Turning on synchronization prohibits the Xlib routines from buffering
requests and seriously degrades performance, but makes debugging much
easier.
The optional second argument DISPLAY specifies which display to act on.
DISPLAY should be either a frame or a display name (a string).
If DISPLAY is omitted or nil, that stands for the selected frame's display.

(x-synchronize ON &optional DISPLAY)Fimage-size
Return the size of image SPEC as pair (WIDTH . HEIGHT).
PIXELS non-nil means return the size in pixels, otherwise return the
size in canonical character units.
FRAME is the frame on which the image will be displayed.  FRAME nil
or omitted means use the selected frame.

(image-size SPEC &optional PIXELS FRAME)Fimage-mask-p
Return t if image SPEC has a mask bitmap.
FRAME is the frame on which the image will be displayed.  FRAME nil
or omitted means use the selected frame.

(image-mask-p SPEC &optional FRAME)Fclear-image-cache
Clear the image cache of FRAME.
FRAME nil or omitted means use the selected frame.
FRAME t means clear the image caches of all frames.

(clear-image-cache &optional FRAME)Fx-change-window-property
Change window property PROP to VALUE on the X window of FRAME.
PROP and VALUE must be strings.  FRAME nil or omitted means use the
selected frame.  Value is VALUE.

(x-change-window-property PROP VALUE &optional FRAME)Fx-delete-window-property
Remove window property PROP from X window of FRAME.
FRAME nil or omitted means use the selected frame.  Value is PROP.

(x-delete-window-property PROP &optional FRAME)Fx-window-property
Value is the value of window property PROP on FRAME.
If FRAME is nil or omitted, use the selected frame.  Value is nil
if FRAME hasn't a property with name PROP or if PROP has no string
value.

(x-window-property PROP &optional FRAME)Fx-show-tip
Show STRING in a "tooltip" window on frame FRAME.
A tooltip window is a small X window displaying a string.

FRAME nil or omitted means use the selected frame.

PARMS is an optional list of frame parameters which can be
used to change the tooltip's appearance.

Automatically hide the tooltip after TIMEOUT seconds.
TIMEOUT nil means use the default timeout of 5 seconds.

If the list of frame parameters PARAMS contains a `left' parameters,
the tooltip is displayed at that x-position.  Otherwise it is
displayed at the mouse position, with offset DX added (default is 5 if
DX isn't specified).  Likewise for the y-position; if a `top' frame
parameter is specified, it determines the y-position of the tooltip
window, otherwise it is displayed at the mouse position, with offset
DY added (default is -10).

A tooltip's maximum size is specified by `x-max-tooltip-size'.
Text larger than the specified size is clipped.

(x-show-tip STRING &optional FRAME PARMS TIMEOUT DX DY)Fx-hide-tip
Hide the current tooltip window, if there is any.
Value is t is tooltip was open, nil otherwise.

(x-hide-tip)Fx-file-dialog
Read file name, prompting with PROMPT in directory DIR.
Use a file selection dialog.
Select DEFAULT-FILENAME in the dialog's file selection box, if
specified.  Don't let the user enter a file name in the file
selection dialog's entry field, if MUSTMATCH is non-nil.

(x-file-dialog PROMPT DIR &optional DEFAULT-FILENAME MUSTMATCH)Fx-backspace-delete-keys-p
Check if both Backspace and Delete keys are on the keyboard of FRAME.
FRAME nil means use the selected frame.
Value is t if we know that both keys are present, and are mapped to the
usual X keysyms.

(x-backspace-delete-keys-p &optional FRAME)Vcross-disabled-images
Non-nil means always draw a cross over disabled images.
Disabled images are those having an `:conversion disabled' property.
A cross is always drawn on black & white displays.Vx-bitmap-file-path
List of directories to search for bitmap files for X.Vx-pointer-shape
The shape of the pointer when over text.
Changing the value does not affect existing frames
unless you set the mouse color.Vx-resource-name
The name Emacs uses to look up X resources.
`x-get-resource' uses this as the first component of the instance name
when requesting resource values.
Emacs initially sets `x-resource-name' to the name under which Emacs
was invoked, or to the value specified with the `-name' or `-rn'
switches, if present.

It may be useful to bind this variable locally around a call
to `x-get-resource'.  See also the variable `x-resource-class'.Vx-resource-class
The class Emacs uses to look up X resources.
`x-get-resource' uses this as the first component of the instance class
when requesting resource values.
Emacs initially sets `x-resource-class' to "Emacs".

Setting this variable permanently is not a reasonable thing to do,
but binding this variable locally around a call to `x-get-resource'
is a reasonable practice.  See also the variable `x-resource-name'.Vx-nontext-pointer-shape
The shape of the pointer when not over text.
This variable takes effect when you create a new frame
or when you set the mouse color.Vx-hourglass-pointer-shape
The shape of the pointer when Emacs is busy.
This variable takes effect when you create a new frame
or when you set the mouse color.Vdisplay-hourglass
Non-zero means Emacs displays an hourglass pointer on window systems.Vhourglass-delay
*Seconds to wait before displaying an hourglass pointer.
Value must be an integer or float.Vx-mode-pointer-shape
The shape of the pointer when over the mode line.
This variable takes effect when you create a new frame
or when you set the mouse color.Vx-sensitive-text-pointer-shape
The shape of the pointer when over mouse-sensitive text.
This variable takes effect when you create a new frame
or when you set the mouse color.Vx-window-horizontal-drag-cursor
Pointer shape to use for indicating a window can be dragged horizontally.
This variable takes effect when you create a new frame
or when you set the mouse color.Vx-cursor-fore-pixel
A string indicating the foreground color of the cursor box.Vx-max-tooltip-size
Maximum size for tooltips.  Value is a pair (COLUMNS . ROWS).
Text larger than this is clipped.Vx-no-window-manager
Non-nil if no X window manager is in use.
Emacs doesn't try to figure this out; this is always nil
unless you set it to something else.Vx-pixel-size-width-font-regexp
Regexp matching a font name whose width is the same as `PIXEL_SIZE'.

Since Emacs gets width of a font matching with this regexp from
PIXEL_SIZE field of the name, font finding mechanism gets faster for
such a font.  This is especially effective for such large fonts as
Chinese, Japanese, and Korean.Vimage-cache-eviction-delay
Time after which cached images are removed from the cache.
When an image has not been displayed this many seconds, remove it
from the image cache.  Value must be an integer or nil with nil
meaning don't clear the cache.Vmotif-version-string
Version info for LessTif/Motif.Fx-popup-menu
Pop up a deck-of-cards menu and return user's selection.
POSITION is a position specification.  This is either a mouse button event
or a list ((XOFFSET YOFFSET) WINDOW)
where XOFFSET and YOFFSET are positions in pixels from the top left
corner of WINDOW's frame.  (WINDOW may be a frame object instead of a window.)
This controls the position of the center of the first line
in the first pane of the menu, not the top left of the menu as a whole.
If POSITION is t, it means to use the current mouse position.

MENU is a specifier for a menu.  For the simplest case, MENU is a keymap.
The menu items come from key bindings that have a menu string as well as
a definition; actually, the "definition" in such a key binding looks like
(STRING . REAL-DEFINITION).  To give the menu a title, put a string into
the keymap as a top-level element.

If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
Otherwise, REAL-DEFINITION should be a valid key binding definition.

You can also use a list of keymaps as MENU.
  Then each keymap makes a separate pane.
When MENU is a keymap or a list of keymaps, the return value
is a list of events.


Alternatively, you can specify a menu of multiple panes
  with a list of the form (TITLE PANE1 PANE2...),
where each pane is a list of form (TITLE ITEM1 ITEM2...).
Each ITEM is normally a cons cell (STRING . VALUE);
but a string can appear as an item--that makes a nonselectable line
in the menu.
With this form of menu, the return value is VALUE from the chosen item.

If POSITION is nil, don't display the menu at all, just precalculate the
cached information about equivalent key sequences.

(x-popup-menu POSITION MENU)Fx-popup-dialog
Pop up a dialog box and return user's selection.
POSITION specifies which frame to use.
This is normally a mouse button event or a window or frame.
If POSITION is t, it means to use the frame the mouse is on.
The dialog box appears in the middle of the specified frame.

CONTENTS specifies the alternatives to display in the dialog box.
It is a list of the form (TITLE ITEM1 ITEM2...).
Each ITEM is a cons cell (STRING . VALUE).
The return value is VALUE from the chosen item.

An ITEM may also be just a string--that makes a nonselectable item.
An ITEM may also be nil--that means to put all preceding items
on the left of the dialog box and all following items on the right.
(By default, approximately half appear on each side.)

(x-popup-dialog POSITION CONTENTS)Vmenu-updating-frame
Frame for which we are updating a menu.
The enable predicate for a menu command should check this variable.Fx-own-selection-internal
Assert an X selection of the given TYPE with the given VALUE.
TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
VALUE is typically a string, or a cons of two markers, but may be
anything that the functions on `selection-converter-alist' know about.

(x-own-selection-internal SELECTION-NAME SELECTION-VALUE)Fx-get-selection-internal
Return text selected from some X window.
SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
TYPE is the type of data desired, typically `STRING'.

(x-get-selection-internal SELECTION-SYMBOL TARGET-TYPE)Fx-disown-selection-internal
If we own the selection SELECTION, disown it.
Disowning it means there is no such selection.

(x-disown-selection-internal SELECTION &optional TIME)Fx-selection-owner-p
Whether the current Emacs process owns the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
For convenience, the symbol nil is the same as `PRIMARY',
and t is the same as `SECONDARY'.)

(x-selection-owner-p &optional SELECTION)Fx-selection-exists-p
Whether there is an owner for the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
(Those are literal upper-case symbol names, since that's what X expects.)
For convenience, the symbol nil is the same as `PRIMARY',
and t is the same as `SECONDARY'.)

(x-selection-exists-p &optional SELECTION)Fx-get-cut-buffer-internal
Returns the value of the named cut buffer (typically CUT_BUFFER0).

(x-get-cut-buffer-internal BUFFER)Fx-store-cut-buffer-internal
Sets the value of the named cut buffer (typically CUT_BUFFER0).

(x-store-cut-buffer-internal BUFFER STRING)Fx-rotate-cut-buffers-internal
Rotate the values of the cut buffers by the given number of step.
Positive means shift the values forward, negative means backward.

(x-rotate-cut-buffers-internal N)Vselection-converter-alist
An alist associating X Windows selection-types with functions.
These functions are called to convert the selection, with three args:
the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
a desired type to which the selection should be converted;
and the local selection value (whatever was given to `x-own-selection').

The function should return the value to send to the X server
(typically a string).  A return value of nil
means that the conversion could not be done.
A return value which is the symbol `NULL'
means that a side-effect was executed,
and there is no meaningful selection value.Vx-lost-selection-hooks
A list of functions to be called when Emacs loses an X selection.
(This happens when some other X client makes its own selection
or when a Lisp program explicitly clears the selection.)
The functions are called with one argument, the selection type
(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').Vx-sent-selection-hooks
A list of functions to be called when Emacs answers a selection request.
The functions are called with four arguments:
  - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
  - the selection-type which Emacs was asked to convert the
    selection into before sending (for example, `STRING' or `LENGTH');
  - a flag indicating success or failure for responding to the request.
We might have failed (and declined the request) for any number of reasons,
including being asked for a selection that we no longer own, or being asked
to convert into a type that we don't know about or that is inappropriate.
This hook doesn't let you change the behavior of Emacs's selection replies,
it merely informs you that they have happened.Vselection-coding-system
Coding system for communicating with other X clients.
When sending or receiving text via cut_buffer, selection, and clipboard,
the text is encoded or decoded by this coding system.
The default value is `compound-text'.Vnext-selection-coding-system
Coding system for the next communication with other X clients.
Usually, `selection-coding-system' is used for communicating with
other X clients.   But, if this variable is set, it is used for the
next communication only.   After the communication, this variable is
set to nil.Vx-selection-timeout
Number of milliseconds to wait for a selection reply.
If the selection owner doesn't reply in this time, we give up.
A value of 0 means wait as long as necessary.  This is initialized from the
"*selectionTimeout" resource.Fdump-redisplay-history
Dump redisplay history to stderr.

(dump-redisplay-history)Fredraw-frame
Clear frame FRAME and output again what is supposed to appear on it.

(redraw-frame FRAME)Fredraw-display
Clear and redisplay all visible frames.

(redraw-display)Fopen-termscript
Start writing all terminal output to FILE as well as the terminal.
FILE = nil means just close any termscript file currently open.

(open-termscript FILE)Fsend-string-to-terminal
Send STRING to the terminal without alteration.
Control characters in STRING will have terminal-dependent effects.

(send-string-to-terminal STRING)Fding
Beep, or flash the screen.
Also, unless an argument is given,
terminate any keyboard macro currently executing.

(ding &optional ARG)Fsleep-for
Pause, without updating display, for SECONDS seconds.
SECONDS may be a floating-point value, meaning that you can wait for a
fraction of a second.  Optional second arg MILLISECONDS specifies an
additional wait period, in milliseconds; this may be useful if your
Emacs was built without floating point support.
(Not all operating systems support waiting for a fraction of a second.)

(sleep-for SECONDS &optional MILLISECONDS)Fsit-for
Perform redisplay, then wait for SECONDS seconds or until input is available.
SECONDS may be a floating-point value, meaning that you can wait for a
fraction of a second.  Optional second arg MILLISECONDS specifies an
additional wait period, in milliseconds; this may be useful if your
Emacs was built without floating point support.
(Not all operating systems support waiting for a fraction of a second.)
Optional third arg NODISP non-nil means don't redisplay, just wait for input.
Redisplay is preempted as always if input arrives, and does not happen
if input is available before it starts.
Value is t if waited the full time with no input arriving.

(sit-for SECONDS &optional MILLISECONDS NODISP)Fframe-or-buffer-changed-p
Return non-nil if the frame and buffer state appears to have changed.
The state variable is an internal vector containing all frames and buffers,
aside from buffers whose names start with space,
along with the buffers' read-only and modified flags, which allows a fast
check to see whether the menu bars might need to be recomputed.
If this function returns non-nil, it updates the internal vector to reflect
the current state.


(frame-or-buffer-changed-p)Finternal-show-cursor
Set the cursor-visibility flag of WINDOW to SHOW.
WINDOW nil means use the selected window.  SHOW non-nil means
show a cursor in WINDOW in the next redisplay.  SHOW nil means
don't show a cursor.

(internal-show-cursor WINDOW SHOW)Finternal-show-cursor-p
Value is non-nil if next redisplay will display a cursor in WINDOW.
WINDOW nil or omitted means report on the selected window.

(internal-show-cursor-p &optional WINDOW)Vbaud-rate
*The output baud rate of the terminal.
On most systems, changing this value will affect the amount of padding
and the other strategic decisions made during redisplay.Vinverse-video
*Non-nil means invert the entire frame display.
This means everything is in inverse video which otherwise would not be.Vvisible-bell
*Non-nil means try to flash the frame to represent a bell.

See also `ring-bell-function'.Vno-redraw-on-reenter
*Non-nil means no need to redraw entire frame after suspending.
A non-nil value is useful if the terminal can automatically preserve
Emacs's frame display when you reenter Emacs.
It is up to you to set this variable if your terminal can do that.Vwindow-system
A symbol naming the window-system under which Emacs is running
(such as `x'), or nil if emacs is running on an ordinary terminal.Vwindow-system-version
The version number of the window system in use.
For X windows, this is 10 or 11.Vcursor-in-echo-area
Non-nil means put cursor in minibuffer, at end of any message there.Vglyph-table
Table defining how to output a glyph code to the frame.
If not nil, this is a vector indexed by glyph code to define the glyph.
Each element can be:
 integer: a glyph code which this glyph is an alias for.
 string: output this glyph using that string (not impl. in X windows).
 nil: this glyph mod 524288 is the code of a character to output,
    and this glyph / 524288 is the face number (see `face-id') to use
    while outputting it.Vstandard-display-table
Display table to use for buffers that specify none.
See `buffer-display-table' for more information.Vredisplay-dont-pause
*Non-nil means update isn't paused when input is detected.Fframep
Return non-nil if OBJECT is a frame.
Value is t for a termcap frame (a character-only terminal),
`x' for an Emacs frame that is really an X window,
`w32' for an Emacs frame that is a window on MS-Windows display,
`mac' for an Emacs frame on a Macintosh display,
`pc' for a direct-write MS-DOS frame.
See also `frame-live-p'.

(framep OBJECT)Fframe-live-p
Return non-nil if OBJECT is a frame which has not been deleted.
Value is nil if OBJECT is not a live frame.  If object is a live
frame, the return value indicates what sort of output device it is
displayed on.  Value is t for a termcap frame (a character-only
terminal), `x' for an Emacs frame being displayed in an X window.

(frame-live-p OBJECT)Fmake-terminal-frame
Create an additional terminal frame.
You can create multiple frames on a text-only terminal in this way.
Only the selected terminal frame is actually displayed.
This function takes one argument, an alist specifying frame parameters.
In practice, generally you don't need to specify any parameters.
Note that changing the size of one terminal frame automatically affects all.

(make-terminal-frame PARMS)Fselect-frame
Select the frame FRAME.
Subsequent editing commands apply to its selected window.
The selection of FRAME lasts until the next time the user does
something to select a different frame, or until the next time this
function is called.

(select-frame FRAME &optional NO-ENTER)Fhandle-switch-frame
Handle a switch-frame event EVENT.
Switch-frame events are usually bound to this function.
A switch-frame event tells Emacs that the window manager has requested
that the user's events be directed to the frame mentioned in the event.
This function selects the selected window of the frame of EVENT.

If EVENT is frame object, handle it as if it were a switch-frame event
to that frame.

(handle-switch-frame EVENT &optional NO-ENTER)Fignore-event
Do nothing, but preserve any prefix argument already specified.
This is a suitable binding for iconify-frame and make-frame-visible.

(ignore-event)Fselected-frame
Return the frame that is now selected.

(selected-frame)Fwindow-frame
Return the frame object that window WINDOW is on.

(window-frame WINDOW)Fframe-first-window
Returns the topmost, leftmost window of FRAME.
If omitted, FRAME defaults to the currently selected frame.

(frame-first-window &optional FRAME)Factive-minibuffer-window
Return the currently active minibuffer window, or nil if none.

(active-minibuffer-window)Fframe-root-window
Returns the root-window of FRAME.
If omitted, FRAME defaults to the currently selected frame.

(frame-root-window &optional FRAME)Fframe-selected-window
Return the selected window of frame object FRAME.
If omitted, FRAME defaults to the currently selected frame.

(frame-selected-window &optional FRAME)Fset-frame-selected-window
Set the selected window of frame object FRAME to WINDOW.
If FRAME is nil, the selected frame is used.
If FRAME is the selected frame, this makes WINDOW the selected window.

(set-frame-selected-window FRAME WINDOW)Fframe-list
Return a list of all frames.

(frame-list)Fnext-frame
Return the next frame in the frame list after FRAME.
It considers only frames on the same terminal as FRAME.
By default, skip minibuffer-only frames.
If omitted, FRAME defaults to the selected frame.
If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
If MINIFRAME is a window, include only its own frame
and any frame now using that window as the minibuffer.
If MINIFRAME is `visible', include all visible frames.
If MINIFRAME is 0, include all visible and iconified frames.
Otherwise, include all frames.

(next-frame &optional FRAME MINIFRAME)Fprevious-frame
Return the previous frame in the frame list before FRAME.
It considers only frames on the same terminal as FRAME.
By default, skip minibuffer-only frames.
If omitted, FRAME defaults to the selected frame.
If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
If MINIFRAME is a window, include only its own frame
and any frame now using that window as the minibuffer.
If MINIFRAME is `visible', include all visible frames.
If MINIFRAME is 0, include all visible and iconified frames.
Otherwise, include all frames.

(previous-frame &optional FRAME MINIFRAME)Fdelete-frame
Delete FRAME, permanently eliminating it from use.
If omitted, FRAME defaults to the selected frame.
A frame may not be deleted if its minibuffer is used by other frames.
Normally, you may not delete a frame if all other frames are invisible,
but if the second optional argument FORCE is non-nil, you may do so.

This function runs `delete-frame-hook' before actually deleting the
frame.  The hook is called with one argument FRAME.

(delete-frame &optional FRAME FORCE)Fmouse-position
Return a list (FRAME X . Y) giving the current mouse frame and position.
The position is given in character cells, where (0, 0) is the
upper-left corner.
If Emacs is running on a mouseless terminal or hasn't been programmed
to read the mouse position, it returns the selected frame for FRAME
and nil for X and Y.
If `mouse-position-function' is non-nil, `mouse-position' calls it,
passing the normal return value to that function as an argument,
and returns whatever that function returns.

(mouse-position)Fmouse-pixel-position
Return a list (FRAME X . Y) giving the current mouse frame and position.
The position is given in pixel units, where (0, 0) is the
upper-left corner.
If Emacs is running on a mouseless terminal or hasn't been programmed
to read the mouse position, it returns the selected frame for FRAME
and nil for X and Y.

(mouse-pixel-position)Fset-mouse-position
Move the mouse pointer to the center of character cell (X,Y) in FRAME.
Coordinates are relative to the frame, not a window,
so the coordinates of the top left character in the frame
may be nonzero due to left-hand scroll bars or the menu bar.

This function is a no-op for an X frame that is not visible.
If you have just created a frame, you must wait for it to become visible
before calling this function on it, like this.
  (while (not (frame-visible-p frame)) (sleep-for .5))

(set-mouse-position FRAME X Y)Fset-mouse-pixel-position
Move the mouse pointer to pixel position (X,Y) in FRAME.
Note, this is a no-op for an X frame that is not visible.
If you have just created a frame, you must wait for it to become visible
before calling this function on it, like this.
  (while (not (frame-visible-p frame)) (sleep-for .5))

(set-mouse-pixel-position FRAME X Y)Fmake-frame-visible
Make the frame FRAME visible (assuming it is an X-window).
If omitted, FRAME defaults to the currently selected frame.

(make-frame-visible &optional FRAME)Fmake-frame-invisible
Make the frame FRAME invisible (assuming it is an X-window).
If omitted, FRAME defaults to the currently selected frame.
Normally you may not make FRAME invisible if all other frames are invisible,
but if the second optional argument FORCE is non-nil, you may do so.

(make-frame-invisible &optional FRAME FORCE)Ficonify-frame
Make the frame FRAME into an icon.
If omitted, FRAME defaults to the currently selected frame.

(iconify-frame &optional FRAME)Fframe-visible-p
Return t if FRAME is now "visible" (actually in use for display).
A frame that is not "visible" is not updated and, if it works through
a window system, it may not show at all.
Return the symbol `icon' if frame is visible only as an icon.

(frame-visible-p FRAME)Fvisible-frame-list
Return a list of all frames now "visible" (being updated).

(visible-frame-list)Fraise-frame
Bring FRAME to the front, so it occludes any frames it overlaps.
If FRAME is invisible, make it visible.
If you don't specify a frame, the selected frame is used.
If Emacs is displaying on an ordinary terminal or some other device which
doesn't support multiple overlapping frames, this function does nothing.

(raise-frame &optional FRAME)Flower-frame
Send FRAME to the back, so it is occluded by any frames that overlap it.
If you don't specify a frame, the selected frame is used.
If Emacs is displaying on an ordinary terminal or some other device which
doesn't support multiple overlapping frames, this function does nothing.

(lower-frame &optional FRAME)Fredirect-frame-focus
Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
In other words, switch-frame events caused by events in FRAME will
request a switch to FOCUS-FRAME, and `last-event-frame' will be
FOCUS-FRAME after reading an event typed at FRAME.

If FOCUS-FRAME is omitted or nil, any existing redirection is
cancelled, and the frame again receives its own keystrokes.

Focus redirection is useful for temporarily redirecting keystrokes to
a surrogate minibuffer frame when a frame doesn't have its own
minibuffer window.

A frame's focus redirection can be changed by select-frame.  If frame
FOO is selected, and then a different frame BAR is selected, any
frames redirecting their focus to FOO are shifted to redirect their
focus to BAR.  This allows focus redirection to work properly when the
user switches from one frame to another using `select-window'.

This means that a frame whose focus is redirected to itself is treated
differently from a frame whose focus is redirected to nil; the former
is affected by select-frame, while the latter is not.

The redirection lasts until `redirect-frame-focus' is called to change it.

(redirect-frame-focus FRAME &optional FOCUS-FRAME)Fframe-focus
Return the frame to which FRAME's keystrokes are currently being sent.
This returns nil if FRAME's focus is not redirected.
See `redirect-frame-focus'.

(frame-focus FRAME)Fframe-parameters
Return the parameters-alist of frame FRAME.
It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame.
If FRAME is omitted, return information on the currently selected frame.

(frame-parameters &optional FRAME)Fframe-parameter
Return FRAME's value for parameter PARAMETER.
If FRAME is nil, describe the currently selected frame.

(frame-parameter FRAME PARAMETER)Fmodify-frame-parameters
Modify the parameters of frame FRAME according to ALIST.
If FRAME is nil, it defaults to the selected frame.
ALIST is an alist of parameters to change and their new values.
Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of frame.
Undefined PARMs are ignored, but stored in the frame's parameter list
so that `frame-parameters' will return them.

The value of frame parameter FOO can also be accessed
as a frame-local binding for the variable FOO, if you have
enabled such bindings for that variable with `make-variable-frame-local'.

(modify-frame-parameters FRAME ALIST)Fframe-char-height
Height in pixels of a line in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
For a terminal frame, the value is always 1.

(frame-char-height &optional FRAME)Fframe-char-width
Width in pixels of characters in the font in frame FRAME.
If FRAME is omitted, the selected frame is used.
The width is the same for all characters, because
currently Emacs supports only fixed-width fonts.
For a terminal screen, the value is always 1.

(frame-char-width &optional FRAME)Fframe-pixel-height
Return a FRAME's height in pixels.
This counts only the height available for text lines,
not menu bars on window-system Emacs frames.
For a terminal frame, the result really gives the height in characters.
If FRAME is omitted, the selected frame is used.

(frame-pixel-height &optional FRAME)Fframe-pixel-width
Return FRAME's width in pixels.
For a terminal frame, the result really gives the width in characters.
If FRAME is omitted, the selected frame is used.

(frame-pixel-width &optional FRAME)Fset-frame-height
Specify that the frame FRAME has LINES lines.
Optional third arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the frame should not be changed.

(set-frame-height FRAME LINES &optional PRETEND)Fset-frame-width
Specify that the frame FRAME has COLS columns.
Optional third arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the frame should not be changed.

(set-frame-width FRAME COLS &optional PRETEND)Fset-frame-size
Sets size of FRAME to COLS by ROWS, measured in characters.

(set-frame-size FRAME COLS ROWS)Fset-frame-position
Sets position of FRAME in pixels to XOFFSET by YOFFSET.
This is actually the position of the upper left corner of the frame.
Negative values for XOFFSET or YOFFSET are interpreted relative to
the rightmost or bottommost possible position (that stays within the screen).

(set-frame-position FRAME XOFFSET YOFFSET)Vdefault-frame-alist
Alist of default values for frame creation.
These may be set in your init file, like this:
  (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1))
These override values given in window system configuration data,
 including X Windows' defaults database.
For values specific to the first Emacs frame, see `initial-frame-alist'.
For values specific to the separate minibuffer frame, see
 `minibuffer-frame-alist'.
The `menu-bar-lines' element of the list controls whether new frames
 have menu bars; `menu-bar-mode' works by altering this element.Vterminal-frame
The initial frame-object, which represents Emacs's stdout.Vemacs-iconified
Non-nil if all of emacs is iconified and frame updates are not needed.Vmouse-position-function
If non-nil, function to transform normal value of `mouse-position'.
`mouse-position' calls this function, passing its usual return value as
argument, and returns whatever this function returns.
This abnormal hook exists for the benefit of packages like `xt-mouse.el'
which need to do mouse handling at the Lisp level.Vdefault-minibuffer-frame
Minibufferless frames use this frame's minibuffer.

Emacs cannot create minibufferless frames unless this is set to an
appropriate surrogate.

Emacs consults this variable only when creating minibufferless
frames; once the frame is created, it sticks with its assigned
minibuffer, no matter what this variable is set to.  This means that
this variable doesn't necessarily say anything meaningful about the
current set of frames, or where the minibuffer is currently being
displayed.

This variable is local to the current terminal and cannot be buffer-local.Ftool-bar-lines-needed
Return the number of lines occupied by the tool bar of FRAME.

(tool-bar-lines-needed &optional FRAME)Fdump-glyph-matrix
Dump the current matrix of the selected window to stderr.
Shows contents of glyph row structures.  With non-nil
parameter GLYPHS, dump glyphs as well.  If GLYPHS is 1 show
glyphs in short form, otherwise show glyphs in long form.

(dump-glyph-matrix &optional GLYPHS)Fdump-glyph-row
Dump glyph row ROW to stderr.
GLYPH 0 means don't dump glyphs.
GLYPH 1 means dump glyphs in short form.
GLYPH > 1 or omitted means dump glyphs in long form.

(dump-glyph-row ROW &optional GLYPHS)Fdump-tool-bar-row
Dump glyph row ROW of the tool-bar of the current frame to stderr.
GLYPH 0 means don't dump glyphs.
GLYPH 1 means dump glyphs in short form.
GLYPH > 1 or omitted means dump glyphs in long form.

(dump-tool-bar-row ROW &optional GLYPHS)Ftrace-redisplay
Toggle tracing of redisplay.
With ARG, turn tracing on if and only if ARG is positive.

(trace-redisplay &optional ARG)Ftrace-to-stderr
Like `format', but print result to stderr.Vshow-trailing-whitespace
Non-nil means highlight trailing whitespace.
The face used for trailing whitespace is `trailing-whitespace'.Vinhibit-redisplay
Non-nil means don't actually do any redisplay.
This is used for internal purposes.Vglobal-mode-string
String (or mode line construct) included (normally) in `mode-line-format'.Voverlay-arrow-position
Marker for where to display an arrow on top of the buffer text.
This must be the beginning of a line in order to work.
See also `overlay-arrow-string'.Voverlay-arrow-string
String to display as an arrow.  See also `overlay-arrow-position'.Vscroll-step
*The number of lines to try scrolling a window by when point moves out.
If that fails to bring point back on frame, point is centered instead.
If this is zero, point is always centered after it moves off frame.
If you want scrolling to always be a line at a time, you should set
  `scroll-conservatively' to a large value rather than set this to 1.Vscroll-conservatively
*Scroll up to this many lines, to bring point back on screen.
A value of zero means to scroll the text to center point vertically
in the window.Vscroll-margin
*Number of lines of margin at the top and bottom of a window.
Recenter the window whenever point gets within this many lines
of the top or bottom of the window.Vdebug-end-pos
Don't askVtruncate-partial-width-windows
*Non-nil means truncate lines in all windows less than full frame wide.Vmode-line-inverse-video
nil means display the mode-line/header-line/menu-bar in the default face.
Any other value means to use the appropriate face, `mode-line',
`header-line', or `menu' respectively.

This variable is deprecated; please change the above faces instead.Vline-number-display-limit
*Maximum buffer size for which line number should be displayed.
If the buffer is bigger than this, the line number does not appear
in the mode line.  A value of nil means no limit.Vline-number-display-limit-width
*Maximum line width (in characters) for line number display.
If the average length of the lines near point is bigger than this, then the
line number may be omitted from the mode line.Vhighlight-nonselected-windows
*Non-nil means highlight region even in nonselected windows.Vmultiple-frames
Non-nil if more than one frame is visible on this display.
Minibuffer-only frames don't count, but iconified frames do.
This variable is not guaranteed to be accurate except while processing
`frame-title-format' and `icon-title-format'.Vframe-title-format
Template for displaying the title bar of visible frames.
(Assuming the window manager supports this feature.)
This variable has the same structure as `mode-line-format' (which see),
and is used only on frames for which no explicit name has been set
(see `modify-frame-parameters').Vicon-title-format
Template for displaying the title bar of an iconified frame.
(Assuming the window manager supports this feature.)
This variable has the same structure as `mode-line-format' (which see),
and is used only on frames for which no explicit name has been set
(see `modify-frame-parameters').Vmessage-log-max
Maximum number of lines to keep in the message log buffer.
If nil, disable message logging.  If t, log messages but don't truncate
the buffer when it becomes large.Vwindow-size-change-functions
Functions called before redisplay, if window sizes have changed.
The value should be a list of functions that take one argument.
Just before redisplay, for each frame, if any of its windows have changed
size since the last redisplay, or have been split or deleted,
all the functions in the list are called, with the frame as argument.Vwindow-scroll-functions
List of Functions to call before redisplaying a window with scrolling.
Each function is called with two arguments, the window
and its new display-start position.  Note that the value of `window-end'
is not valid when these functions are called.Vauto-resize-tool-bars
*Non-nil means automatically resize tool-bars.
This increases a tool-bar's height if not all tool-bar items are visible.
It decreases a tool-bar's height when it would display blank lines
otherwise.Vauto-raise-tool-bar-buttons
*Non-nil means raise tool-bar buttons when the mouse moves over them.Vtool-bar-button-margin
*Margin around tool-bar buttons in pixels.
If an integer, use that for both horizontal and vertical margins.
Otherwise, value should be a pair of integers `(HORZ : VERT)' with
HORZ specifying the horizontal margin, and VERT specifying the
vertical margin.Vtool-bar-button-relief
Relief thickness of tool-bar buttons.Vfontification-functions
List of functions to call to fontify regions of text.
Each function is called with one argument POS.  Functions must
fontify a region starting at POS in the current buffer, and give
fontified regions the property `fontified'.
This variable automatically becomes buffer-local when set.Vunibyte-display-via-language-environment
*Non-nil means display unibyte text according to language environment.
Specifically this means that unibyte non-ASCII characters
are displayed by converting them to the equivalent multibyte characters
according to the current language environment.  As a result, they are
displayed according to the current fontset.Vmax-mini-window-height
*Maximum height for resizing mini-windows.
If a float, it specifies a fraction of the mini-window frame's height.
If an integer, it specifies a number of lines.Vresize-mini-windows
*How to resize mini-windows.
A value of nil means don't automatically resize mini-windows.
A value of t means resize them to fit the text displayed in them.
A value of `grow-only', the default, means let mini-windows grow
only, until their display becomes empty, at which point the windows
go back to their normal size.Vcursor-in-non-selected-windows
*Non-nil means display a hollow cursor in non-selected windows.
Nil means don't display a cursor there.Vautomatic-hscrolling
*Non-nil means scroll the display automatically to make point visible.Vimage-types
List of supported image types.
Each element of the list is a symbol for a supported image type.Vmessage-truncate-lines
If non-nil, messages are truncated instead of resizing the echo area.
Bind this around calls to `message' to let it take effect.Vmenu-bar-update-hook
Normal hook run for clicks on menu bar, before displaying a submenu.
Can be used to update submenus whose contents should vary.Vinhibit-menubar-update
Non-nil means don't update menu bars.  Internal use only.Vinhibit-eval-during-redisplay
Non-nil means don't eval Lisp during redisplay.Vinhibit-try-window-id
Inhibit try_window_id display optimization.Vinhibit-try-window-reusing
Inhibit try_window_reusing display optimization.Vinhibit-try-cursor-movement
Inhibit try_cursor_movement display optimization.Fwindowp
Returns t if OBJECT is a window.

(windowp OBJECT)Fwindow-live-p
Returns t if OBJECT is a window which is currently visible.

(window-live-p OBJECT)Fselected-window
Return the window that the cursor now appears in and commands apply to.

(selected-window)Fminibuffer-window
Return the window used now for minibuffers.
If the optional argument FRAME is specified, return the minibuffer window
used by that frame.

(minibuffer-window &optional FRAME)Fwindow-minibuffer-p
Returns non-nil if WINDOW is a minibuffer window.

(window-minibuffer-p &optional WINDOW)Fpos-visible-in-window-p
Return t if position POS is currently on the frame in WINDOW.
Return nil if that position is scrolled vertically out of view.
If a character is only partially visible, nil is returned, unless the
optional argument PARTIALLY is non-nil.
POS defaults to point in WINDOW; WINDOW defaults to the selected window.

(pos-visible-in-window-p &optional POS WINDOW PARTIALLY)Fwindow-buffer
Return the buffer that WINDOW is displaying.

(window-buffer &optional WINDOW)Fwindow-height
Return the number of lines in WINDOW (including its mode line).

(window-height &optional WINDOW)Fwindow-width
Return the number of display columns in WINDOW.
This is the width that is usable columns available for text in WINDOW.
If you want to find out how many columns WINDOW takes up,
use  (let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))).

(window-width &optional WINDOW)Fwindow-hscroll
Return the number of columns by which WINDOW is scrolled from left margin.

(window-hscroll &optional WINDOW)Fset-window-hscroll
Set number of columns WINDOW is scrolled from left margin to NCOL.
NCOL should be zero or positive.

(set-window-hscroll WINDOW NCOL)Fwindow-redisplay-end-trigger
Return WINDOW's redisplay end trigger value.
See `set-window-redisplay-end-trigger' for more information.

(window-redisplay-end-trigger &optional WINDOW)Fset-window-redisplay-end-trigger
Set WINDOW's redisplay end trigger value to VALUE.
VALUE should be a buffer position (typically a marker) or nil.
If it is a buffer position, then if redisplay in WINDOW reaches a position
beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
with two arguments: WINDOW, and the end trigger value.
Afterwards the end-trigger value is reset to nil.

(set-window-redisplay-end-trigger WINDOW VALUE)Fwindow-edges
Return a list of the edge coordinates of WINDOW.
(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
RIGHT is one more than the rightmost column used by WINDOW,
and BOTTOM is one more than the bottommost row used by WINDOW
 and its mode-line.

(window-edges &optional WINDOW)Fcoordinates-in-window-p
Return non-nil if COORDINATES are in WINDOW.
COORDINATES is a cons of the form (X . Y), X and Y being distances
measured in characters from the upper-left corner of the frame.
(0 .  0) denotes the character in the upper left corner of the
frame.
If COORDINATES are in the text portion of WINDOW,
   the coordinates relative to the window are returned.
If they are in the mode line of WINDOW, `mode-line' is returned.
If they are in the top mode line of WINDOW, `header-line' is returned.
If they are in the fringe to the left of the window,
   `left-fringe' is returned, if they are in the area on the right of
   the window, `right-fringe' is returned.
If they are on the border between WINDOW and its right sibling,
   `vertical-line' is returned.

(coordinates-in-window-p COORDINATES WINDOW)Fwindow-at
Return window containing coordinates X and Y on FRAME.
If omitted, FRAME defaults to the currently selected frame.
The top left corner of the frame is considered to be row 0,
column 0.

(window-at X Y &optional FRAME)Fwindow-point
Return current value of point in WINDOW.
For a nonselected window, this is the value point would have
if that window were selected.

Note that, when WINDOW is the selected window and its buffer
is also currently selected, the value returned is the same as (point).
It would be more strictly correct to return the `top-level' value
of point, outside of any save-excursion forms.
But that is hard to define.

(window-point &optional WINDOW)Fwindow-start
Return position at which display currently starts in WINDOW.
This is updated by redisplay or by calling `set-window-start'.

(window-start &optional WINDOW)Fwindow-end
Return position at which display currently ends in WINDOW.
This is updated by redisplay, when it runs to completion.
Simply changing the buffer text or setting `window-start'
does not update this value.
If UPDATE is non-nil, compute the up-to-date position
if it isn't already recorded.

(window-end &optional WINDOW UPDATE)Fset-window-point
Make point value in WINDOW be at position POS in WINDOW's buffer.

(set-window-point WINDOW POS)Fset-window-start
Make display in WINDOW start at position POS in WINDOW's buffer.
Optional third arg NOFORCE non-nil inhibits next redisplay
from overriding motion of point in order to display at this exact start.

(set-window-start WINDOW POS &optional NOFORCE)Fwindow-dedicated-p
Return WINDOW's dedicated object, usually t or nil.
See also `set-window-dedicated-p'.

(window-dedicated-p WINDOW)Fset-window-dedicated-p
Control whether WINDOW is dedicated to the buffer it displays.
If it is dedicated, Emacs will not automatically change
which buffer appears in it.
The second argument is the new value for the dedication flag;
non-nil means yes.

(set-window-dedicated-p WINDOW ARG)Fwindow-display-table
Return the display-table that WINDOW is using.

(window-display-table &optional WINDOW)Fset-window-display-table
Set WINDOW's display-table to TABLE.

(set-window-display-table WINDOW TABLE)Fdelete-window
Remove WINDOW from the display.  Default is selected window.

(delete-window &optional WINDOW)Fnext-window
Return next window after WINDOW in canonical ordering of windows.
If omitted, WINDOW defaults to the selected window.

Optional second arg MINIBUF t means count the minibuffer window even
if not active.  MINIBUF nil or omitted means count the minibuffer iff
it is active.  MINIBUF neither t nor nil means not to count the
minibuffer even if it is active.

Several frames may share a single minibuffer; if the minibuffer
counts, all windows on all frames that share that minibuffer count
too.  Therefore, `next-window' can be used to iterate through the
set of windows even when the minibuffer is on another frame.  If the
minibuffer does not count, only windows from WINDOW's frame count.

Optional third arg ALL-FRAMES t means include windows on all frames.
ALL-FRAMES nil or omitted means cycle within the frames as specified
above.  ALL-FRAMES = `visible' means include windows on all visible frames.
ALL-FRAMES = 0 means include windows on all visible and iconified frames.
If ALL-FRAMES is a frame, restrict search to windows on that frame.
Anything else means restrict to WINDOW's frame.

If you use consistent values for MINIBUF and ALL-FRAMES, you can use
`next-window' to iterate through the entire cycle of acceptable
windows, eventually ending up back at the window you started with.
`previous-window' traverses the same cycle, in the reverse order.

(next-window &optional WINDOW MINIBUF ALL-FRAMES)Fprevious-window
Return the window preceding WINDOW in canonical ordering of windows.
If omitted, WINDOW defaults to the selected window.

Optional second arg MINIBUF t means count the minibuffer window even
if not active.  MINIBUF nil or omitted means count the minibuffer iff
it is active.  MINIBUF neither t nor nil means not to count the
minibuffer even if it is active.

Several frames may share a single minibuffer; if the minibuffer
counts, all windows on all frames that share that minibuffer count
too.  Therefore, `previous-window' can be used to iterate through
the set of windows even when the minibuffer is on another frame.  If
the minibuffer does not count, only windows from WINDOW's frame count

Optional third arg ALL-FRAMES t means include windows on all frames.
ALL-FRAMES nil or omitted means cycle within the frames as specified
above.  ALL-FRAMES = `visible' means include windows on all visible frames.
ALL-FRAMES = 0 means include windows on all visible and iconified frames.
If ALL-FRAMES is a frame, restrict search to windows on that frame.
Anything else means restrict to WINDOW's frame.

If you use consistent values for MINIBUF and ALL-FRAMES, you can use
`previous-window' to iterate through the entire cycle of acceptable
windows, eventually ending up back at the window you started with.
`next-window' traverses the same cycle, in the reverse order.

(previous-window &optional WINDOW MINIBUF ALL-FRAMES)Fother-window
Select the ARG'th different window on this frame.
All windows on current frame are arranged in a cyclic order.
This command selects the window ARG steps away in that order.
A negative ARG moves in the opposite order.  If the optional second
argument ALL_FRAMES is non-nil, cycle through all frames.

(other-window ARG &optional ALL-FRAMES)Fwindow-list
Return a list of windows on FRAME, starting with WINDOW.
FRAME nil or omitted means use the selected frame.
WINDOW nil or omitted means use the selected window.
MINIBUF t means include the minibuffer window, even if it isn't active.
MINIBUF nil or omitted means include the minibuffer window only
if it's active.
MINIBUF neither nil nor t means never include the minibuffer window.

(window-list &optional FRAME MINIBUF WINDOW)Fget-lru-window
Return the window least recently selected or used for display.
If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
If FRAME is t, search all frames.
If FRAME is nil, search only the selected frame.
If FRAME is a frame, search only that frame.

(get-lru-window &optional FRAME)Fget-largest-window
Return the largest window in area.
If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
If FRAME is t, search all frames.
If FRAME is nil, search only the selected frame.
If FRAME is a frame, search only that frame.

(get-largest-window &optional FRAME)Fget-buffer-window
Return a window currently displaying BUFFER, or nil if none.
If optional argument FRAME is `visible', search all visible frames.
If optional argument FRAME is 0, search all visible and iconified frames.
If FRAME is t, search all frames.
If FRAME is nil, search only the selected frame.
If FRAME is a frame, search only that frame.

(get-buffer-window BUFFER &optional FRAME)Fdelete-other-windows
Make WINDOW (or the selected window) fill its frame.
Only the frame WINDOW is on is affected.
This function tries to reduce display jumps
by keeping the text previously visible in WINDOW
in the same place on the frame.  Doing this depends on
the value of (window-start WINDOW), so if calling this function
in a program gives strange scrolling, make sure the window-start
value is reasonable when this function is called.

(delete-other-windows &optional WINDOW)Fdelete-windows-on
Delete all windows showing BUFFER.
Optional second argument FRAME controls which frames are affected.
If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
If FRAME is nil, search all frames.
If FRAME is t, search only the selected frame.
If FRAME is a frame, search only that frame.

(delete-windows-on BUFFER &optional FRAME)Freplace-buffer-in-windows
Replace BUFFER with some other buffer in all windows showing it.

(replace-buffer-in-windows BUFFER)Fset-window-buffer
Make WINDOW display BUFFER as its contents.
BUFFER can be a buffer or buffer name.

(set-window-buffer WINDOW BUFFER)Fselect-window
Select WINDOW.  Most editing will apply to WINDOW's buffer.
If WINDOW is not already selected, also make WINDOW's buffer current.
Note that the main editor command loop
selects the buffer of the selected window before each command.

(select-window WINDOW)Fspecial-display-p
Returns non-nil if a buffer named BUFFER-NAME would be created specially.
The value is actually t if the frame should be called with default frame
parameters, and a list of frame parameters if they were specified.
See `special-display-buffer-names', and `special-display-regexps'.

(special-display-p BUFFER-NAME)Fsame-window-p
Returns non-nil if a new buffer named BUFFER-NAME would use the same window.
See `same-window-buffer-names' and `same-window-regexps'.

(same-window-p BUFFER-NAME)Fdisplay-buffer
Make BUFFER appear in some window but don't select it.
BUFFER can be a buffer or a buffer name.
If BUFFER is shown already in some window, just use that one,
unless the window is the selected window and the optional second
argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).
If `pop-up-frames' is non-nil, make a new frame if no window shows BUFFER.
Returns the window displaying BUFFER.
If `display-reuse-frames' is non-nil, and another frame is currently
displaying BUFFER, then simply raise that frame.

The variables `special-display-buffer-names', `special-display-regexps',
`same-window-buffer-names', and `same-window-regexps' customize how certain
buffer names are handled.

If optional argument FRAME is `visible', search all visible frames.
If FRAME is 0, search all visible and iconified frames.
If FRAME is t, search all frames.
If FRAME is a frame, search only that frame.
If FRAME is nil, search only the selected frame
 (actually the last nonminibuffer frame),
 unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
 which means search visible and iconified frames.

If `even-window-heights' is non-nil, window heights will be evened out
if displaying the buffer causes two vertically adjacent windows to be
displayed.

(display-buffer BUFFER &optional NOT-THIS-WINDOW FRAME)Fsplit-window
Split WINDOW, putting SIZE lines in the first of the pair.
WINDOW defaults to selected one and SIZE to half its size.
If optional third arg HORFLAG is non-nil, split side by side
and put SIZE columns in the first of the pair.  In that case,
SIZE includes that window's scroll bar, or the divider column to its right.

(split-window &optional WINDOW SIZE HORFLAG)Fenlarge-window
Make current window ARG lines bigger.
From program, optional second arg non-nil means grow sideways ARG columns.
Interactively, if an argument is not given, make the window one line bigger.

(enlarge-window ARG &optional SIDE)Fshrink-window
Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways arg columns.
Interactively, if an argument is not given, make the window one line smaller.

(shrink-window ARG &optional SIDE)Fscroll-up
Scroll text of current window upward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
Negative ARG means scroll downward.
If ARG is the atom `-', scroll downward by nearly full screen.
When calling from a program, supply as argument a number, nil, or `-'.

(scroll-up &optional ARG)Fscroll-down
Scroll text of current window down ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
Negative ARG means scroll upward.
If ARG is the atom `-', scroll upward by nearly full screen.
When calling from a program, supply as argument a number, nil, or `-'.

(scroll-down &optional ARG)Fother-window-for-scrolling
Return the other window for "other window scroll" commands.
If in the minibuffer, `minibuffer-scroll-window' if non-nil
specifies the window.
If `other-window-scroll-buffer' is non-nil, a window
showing that buffer is used.

(other-window-for-scrolling)Fscroll-other-window
Scroll next window upward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
The next window is the one below the current one; or the one at the top
if the current one is at the bottom.  Negative ARG means scroll downward.
If ARG is the atom `-', scroll downward by nearly full screen.
When calling from a program, supply as argument a number, nil, or `-'.

If in the minibuffer, `minibuffer-scroll-window' if non-nil
specifies the window to scroll.
If `other-window-scroll-buffer' is non-nil, scroll the window
showing that buffer, popping the buffer up if necessary.

(scroll-other-window &optional ARG)Fscroll-left
Scroll selected window display ARG columns left.
Default for ARG is window width minus 2.
Value is the total amount of leftward horizontal scrolling in
effect after the change.
If `automatic-hscrolling' is non-nil, the argument ARG modifies
a lower bound for automatic scrolling, i.e. automatic scrolling
will not scroll a window to a column less than the value returned
by this function.

(scroll-left &optional ARG)Fscroll-right
Scroll selected window display ARG columns right.
Default for ARG is window width minus 2.
Value is the total amount of leftward horizontal scrolling in
effect after the change.
If `automatic-hscrolling' is non-nil, the argument ARG modifies
a lower bound for automatic scrolling, i.e. automatic scrolling
will not scroll a window to a column less than the value returned
by this function.

(scroll-right &optional ARG)Frecenter
Center point in window and redisplay frame.
With prefix argument ARG, recenter putting point on screen line ARG
relative to the current window.  If ARG is negative, it counts up from the
bottom of the window.  (ARG should be less than the height of the window.)

If ARG is omitted or nil, erase the entire frame and then
redraw with point in the center of the current window.
Just C-u as prefix means put point in the center of the window
and redisplay normally--don't erase and redraw the frame.

(recenter &optional ARG)Fwindow-text-height
Return the height in lines of the text display area of WINDOW.
This doesn't include the mode-line (or header-line if any) or any
partial-height lines in the text display area.

(window-text-height &optional WINDOW)Fmove-to-window-line
Position point relative to window.
With no argument, position point at center of window.
An argument specifies vertical position within the window;
zero means top of window, negative means relative to bottom of window.

(move-to-window-line ARG)Fwindow-configuration-p
Return t if OBJECT is a window-configuration object.

(window-configuration-p OBJECT)Fwindow-configuration-frame
Return the frame that CONFIG, a window-configuration object, is about.

(window-configuration-frame CONFIG)Fset-window-configuration
Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
by `current-window-configuration' (which see).
If CONFIGURATION was made from a frame that is now deleted,
only frame-independent values can be restored.  In this case,
the return value is nil.  Otherwise the value is t.

(set-window-configuration CONFIGURATION)Fcurrent-window-configuration
Return an object representing the current window configuration of FRAME.
If FRAME is nil or omitted, use the selected frame.
This describes the number of windows, their sizes and current buffers,
and for each displayed buffer, where display starts, and the positions of
point and mark.  An exception is made for point in the current buffer:
its value is -not- saved.
This also records the currently selected frame, and FRAME's focus
redirection (see `redirect-frame-focus').

(current-window-configuration &optional FRAME)Fsave-window-excursion
Execute body, preserving window sizes and contents.
Restore which buffer appears in which window, where display starts,
and the value of point and mark for each window.
Also restore the choice of selected window.
Also restore which buffer is current.
Does not restore the value of point in current buffer.Fset-window-margins
Set width of marginal areas of window WINDOW.
If window is nil, set margins of the currently selected window.
First parameter LEFT-WIDTH specifies the number of character
cells to reserve for the left marginal area.  Second parameter
RIGHT-WIDTH does the same for the right marginal area.
A nil width parameter means no margin.

(set-window-margins WINDOW LEFT &optional RIGHT)Fwindow-margins
Get width of marginal areas of window WINDOW.
If WINDOW is omitted or nil, use the currently selected window.
Value is a cons of the form (LEFT-WIDTH . RIGHT-WIDTH).
If a marginal area does not exist, its width will be returned
as nil.

(window-margins &optional WINDOW)Fwindow-vscroll
Return the amount by which WINDOW is scrolled vertically.
Use the selected window if WINDOW is nil or omitted.
Value is a multiple of the canonical character height of WINDOW.

(window-vscroll &optional WINDOW)Fset-window-vscroll
Set amount by which WINDOW should be scrolled vertically to VSCROLL.
WINDOW nil means use the selected window.  VSCROLL is a non-negative
multiple of the canonical character height of WINDOW.

(set-window-vscroll WINDOW VSCROLL)Fcompare-window-configurations
Compare two window configurations as regards the structure of windows.
This function ignores details such as the values of point and mark
and scrolling positions.

(compare-window-configurations X Y)Vtemp-buffer-show-function
Non-nil means call as function to display a help buffer.
The function is called with one argument, the buffer to be displayed.
Used by `with-output-to-temp-buffer'.
If this function is used, then it must do the entire job of showing
the buffer; `temp-buffer-show-hook' is not run unless this function runs it.Vdisplay-buffer-function
If non-nil, function to call to handle `display-buffer'.
It will receive two args, the buffer and a flag which if non-nil means
 that the currently selected window is not acceptable.
Commands such as `switch-to-buffer-other-window' and `find-file-other-window'
work using this function.Veven-window-heights
*If non-nil, `display-buffer' should even the window heights.
If nil, `display-buffer' will leave the window configuration alone.Vminibuffer-scroll-window
Non-nil means it is the window that C-M-v in minibuffer should scroll.Vother-window-scroll-buffer
If non-nil, this is a buffer and \[scroll-other-window] should scroll its window.Vpop-up-frames
*Non-nil means `display-buffer' should make a separate frame.Vdisplay-buffer-reuse-frames
*Non-nil means `display-buffer' should reuse frames.
If the buffer in question is already displayed in a frame, raise that frame.Vpop-up-frame-function
Function to call to handle automatic new frame creation.
It is called with no arguments and should return a newly created frame.

A typical value might be `(lambda () (new-frame pop-up-frame-alist))'
where `pop-up-frame-alist' would hold the default frame parameters.Vspecial-display-buffer-names
*List of buffer names that should have their own special frames.
Displaying a buffer whose name is in this list makes a special frame for it
using `special-display-function'.  See also `special-display-regexps'.

An element of the list can be a list instead of just a string.
There are two ways to use a list as an element:
  (BUFFER FRAME-PARAMETERS...)   (BUFFER FUNCTION OTHER-ARGS...)
In the first case, FRAME-PARAMETERS are used to create the frame.
In the latter case, FUNCTION is called with BUFFER as the first argument,
followed by OTHER-ARGS--it can display BUFFER in any way it likes.
All this is done by the function found in `special-display-function'.

If this variable appears "not to work", because you add a name to it
but that buffer still appears in the selected window, look at the
values of `same-window-buffer-names' and `same-window-regexps'.
Those variables take precedence over this one.Vspecial-display-regexps
*List of regexps saying which buffers should have their own special frames.
If a buffer name matches one of these regexps, it gets its own frame.
Displaying a buffer whose name is in this list makes a special frame for it
using `special-display-function'.

An element of the list can be a list instead of just a string.
There are two ways to use a list as an element:
  (REGEXP FRAME-PARAMETERS...)   (REGEXP FUNCTION OTHER-ARGS...)
In the first case, FRAME-PARAMETERS are used to create the frame.
In the latter case, FUNCTION is called with the buffer as first argument,
followed by OTHER-ARGS--it can display the buffer in any way it likes.
All this is done by the function found in `special-display-function'.

If this variable appears "not to work", because you add a regexp to it
but the matching buffers still appear in the selected window, look at the
values of `same-window-buffer-names' and `same-window-regexps'.
Those variables take precedence over this one.Vspecial-display-function
Function to call to make a new frame for a special buffer.
It is called with two arguments, the buffer and optional buffer specific
data, and should return a window displaying that buffer.
The default value makes a separate frame for the buffer,
using `special-display-frame-alist' to specify the frame parameters.

A buffer is special if its is listed in `special-display-buffer-names'
or matches a regexp in `special-display-regexps'.Vsame-window-buffer-names
*List of buffer names that should appear in the selected window.
Displaying one of these buffers using `display-buffer' or `pop-to-buffer'
switches to it in the selected window, rather than making it appear
in some other window.

An element of the list can be a cons cell instead of just a string.
Then the car must be a string, which specifies the buffer name.
This is for compatibility with `special-display-buffer-names';
the cdr of the cons cell is ignored.

See also `same-window-regexps'.Vsame-window-regexps
*List of regexps saying which buffers should appear in the selected window.
If a buffer name matches one of these regexps, then displaying it
using `display-buffer' or `pop-to-buffer' switches to it
in the selected window, rather than making it appear in some other window.

An element of the list can be a cons cell instead of just a string.
Then the car must be a string, which specifies the buffer name.
This is for compatibility with `special-display-buffer-names';
the cdr of the cons cell is ignored.

See also `same-window-buffer-names'.Vpop-up-windows
*Non-nil means display-buffer should make new windows.Vnext-screen-context-lines
*Number of lines of continuity when scrolling by screenfuls.Vsplit-height-threshold
*display-buffer would prefer to split the largest window if this large.
If there is only one window, it is split regardless of this value.Vwindow-min-height
*Delete any window less than this tall (including its mode line).Vwindow-min-width
*Delete any window less than this wide.Vscroll-preserve-screen-position
*Non-nil means scroll commands move point to keep its screen line unchanged.Vwindow-configuration-change-hook
Functions to call when window configuration changes.
The selected frame is the one whose configuration has changed.Vwindow-size-fixed
Non-nil in a buffer means windows displaying the buffer are fixed-size.
Emacs won't change the size of any window displaying that buffer,
unless you explicitly change the size, or Emacs has no other choice.
This variable automatically becomes buffer-local when set.Fdefine-charset
Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.
If CHARSET-ID is nil, it is decided automatically, which means CHARSET is
 treated as a private charset.
INFO-VECTOR is a vector of the format:
   [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE
    SHORT-NAME LONG-NAME DESCRIPTION]
The meanings of each elements is as follows:
DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
CHARS (integer) is the number of characters in a dimension: 94 or 96.
WIDTH (integer) is the number of columns a character in the charset
occupies on the screen: one of 0, 1, and 2.

DIRECTION (integer) is the rendering direction of characters in the
charset when rendering.  If 0, render from left to right, else
render from right to left.

ISO-FINAL-CHAR (character) is the final character of the
corresponding ISO 2022 charset.
It may be -1 if the charset is internal use only.

ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
while encoding to variants of ISO 2022 coding system, one of the
following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
It may be -1 if the charset is internal use only.

SHORT-NAME (string) is the short name to refer to the charset.

LONG-NAME (string) is the long name to refer to the charset.

DESCRIPTION (string) is the description string of the charset.

(define-charset CHARSET-ID CHARSET-SYMBOL INFO-VECTOR)Fgeneric-character-list
Return a list of all possible generic characters.
It includes a generic character for a charset not yet defined.

(generic-character-list)Fget-unused-iso-final-char
Return an unsed ISO's final char for a charset of DIMENISION and CHARS.
DIMENSION is the number of bytes to represent a character: 1 or 2.
CHARS is the number of characters in a dimension: 94 or 96.

This final char is for private use, thus the range is `0' (48) .. `?' (63).
If there's no unused final char for the specified kind of charset,
return nil.

(get-unused-iso-final-char DIMENSION CHARS)Fdeclare-equiv-charset
Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.
CHARSET should be defined by `defined-charset' in advance.

(declare-equiv-charset DIMENSION CHARS FINAL-CHAR CHARSET-SYMBOL)Ffind-charset-region
Return a list of charsets in the region between BEG and END.
BEG and END are buffer positions.
Optional arg TABLE if non-nil is a translation table to look up.

If the region contains invalid multibyte characters,
`unknown' is included in the returned list.

If the current buffer is unibyte, the returned list may contain
only `ascii', `eight-bit-control', and `eight-bit-graphic'.

(find-charset-region BEG END &optional TABLE)Ffind-charset-string
Return a list of charsets in STR.
Optional arg TABLE if non-nil is a translation table to look up.

If the string contains invalid multibyte characters,
`unknown' is included in the returned list.

If STR is unibyte, the returned list may contain
only `ascii', `eight-bit-control', and `eight-bit-graphic'.

(find-charset-string STR &optional TABLE)Fmake-char-internal


(make-char-internal CHARSET &optional CODE1 CODE2)Fsplit-char
Return list of charset and one or two position-codes of CHAR.
If CHAR is invalid as a character code,
return a list of symbol `unknown' and CHAR.

(split-char CH)Fchar-charset
Return charset of CHAR.

(char-charset CH)Fcharset-after
Return charset of a character in the current buffer at position POS.
If POS is nil, it defauls to the current point.
If POS is out of range, the value is nil.

(charset-after &optional POS)Fiso-charset
Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.

ISO 2022's designation sequence (escape sequence) distinguishes charsets
by their DIMENSION, CHARS, and FINAL-CHAR,
where as Emacs distinguishes them by charset symbol.
See the documentation of the function `charset-info' for the meanings of
DIMENSION, CHARS, and FINAL-CHAR.

(iso-charset DIMENSION CHARS FINAL-CHAR)Fchar-valid-p
Return t if OBJECT is a valid normal character.
If optional arg GENERICP is non-nil, also return t if OBJECT is
a valid generic character.

(char-valid-p OBJECT &optional GENERICP)Funibyte-char-to-multibyte
Convert the unibyte character CH to multibyte character.
The conversion is done based on `nonascii-translation-table' (which see)
 or `nonascii-insert-offset' (which see).

(unibyte-char-to-multibyte CH)Fmultibyte-char-to-unibyte
Convert the multibyte character CH to unibyte character.
The conversion is done based on `nonascii-translation-table' (which see)
 or `nonascii-insert-offset' (which see).

(multibyte-char-to-unibyte CH)Fchar-bytes
Return 1 regardless of the argument CHAR.
This is now an obsolete function.  We keep it just for backward compatibility.

(char-bytes CH)Fchar-width
Return width of CHAR when displayed in the current buffer.
The width is measured by how many columns it occupies on the screen.
Tab is taken to occupy `tab-width' columns.

(char-width CH)Fstring-width
Return width of STRING when displayed in the current buffer.
Width is measured by how many columns it occupies on the screen.
When calculating width of a multibyte character in STRING,
only the base leading-code is considered; the validity of
the following bytes is not checked.  Tabs in STRING are always
taken to occupy `tab-width' columns.

(string-width STR)Fchar-direction
Return the direction of CHAR.
The returned value is 0 for left-to-right and 1 for right-to-left.

(char-direction CH)Fchars-in-region
Return number of characters between BEG and END.

(chars-in-region BEG END)Fstring
Concatenate all the argument characters and make the result a string.Fsetup-special-charsets
Internal use only.

(setup-special-charsets)Vcharset-list
List of charsets ever defined.Vtranslation-table-vector
Vector of cons cell of a symbol and translation table ever defined.
An ID of a translation table is an index of this vector.Vleading-code-private-11
Leading-code of private TYPE9N charset of column-width 1.Vleading-code-private-12
Leading-code of private TYPE9N charset of column-width 2.Vleading-code-private-21
Leading-code of private TYPE9Nx9N charset of column-width 1.Vleading-code-private-22
Leading-code of private TYPE9Nx9N charset of column-width 2.Vnonascii-insert-offset
Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.
This is used for converting unibyte text to multibyte,
and for inserting character codes specified by number.

This serves to convert a Latin-1 or similar 8-bit character code
to the corresponding Emacs multibyte character code.
Typically the value should be (- (make-char CHARSET 0) 128),
for your choice of character set.
If `nonascii-translation-table' is non-nil, it overrides this variable.Vnonascii-translation-table
Translation table to convert non-ASCII unibyte codes to multibyte.
This is used for converting unibyte text to multibyte,
and for inserting character codes specified by number.

Conversion is performed only when multibyte characters are enabled,
and it serves to convert a Latin-1 or similar 8-bit character code
to the corresponding Emacs character code.

If this is nil, `nonascii-insert-offset' is used instead.
See also the docstring of `make-translation-table'.Vauto-fill-chars
A char-table for characters which invoke auto-filling.
Such characters have value t in this table.Fcoding-system-p
Return t if OBJECT is nil or a coding-system.
See the documentation of `make-coding-system' for information
about coding-system objects.

(coding-system-p OBJ)Fread-non-nil-coding-system
Read a coding system from the minibuffer, prompting with string PROMPT.

(read-non-nil-coding-system PROMPT)Fread-coding-system
Read a coding system from the minibuffer, prompting with string PROMPT.
If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.

(read-coding-system PROMPT &optional DEFAULT-CODING-SYSTEM)Fcheck-coding-system
Check validity of CODING-SYSTEM.
If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
It is valid if it is a symbol with a non-nil `coding-system' property.
The value of property should be a vector of length 5.

(check-coding-system CODING-SYSTEM)Fdetect-coding-region
Detect coding system of the text in the region between START and END.
Return a list of possible coding systems ordered by priority.

If only ASCII characters are found, it returns a list of single element
`undecided' or its subsidiary coding system according to a detected
end-of-line format.

If optional argument HIGHEST is non-nil, return the coding system of
highest priority.

(detect-coding-region START END &optional HIGHEST)Fdetect-coding-string
Detect coding system of the text in STRING.
Return a list of possible coding systems ordered by priority.

If only ASCII characters are found, it returns a list of single element
`undecided' or its subsidiary coding system according to a detected
end-of-line format.

If optional argument HIGHEST is non-nil, return the coding system of
highest priority.

(detect-coding-string STRING &optional HIGHEST)Ffind-coding-systems-region-internal
Internal use only.

(find-coding-systems-region-internal START END)Fdecode-coding-region
Decode the current region from the specified coding system.
When called from a program, takes three arguments:
START, END, and CODING-SYSTEM.  START and END are buffer positions.
This function sets `last-coding-system-used' to the precise coding system
used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
not fully specified.)
It returns the length of the decoded text.

(decode-coding-region START END CODING-SYSTEM)Fencode-coding-region
Encode the current region into the specified coding system.
When called from a program, takes three arguments:
START, END, and CODING-SYSTEM.  START and END are buffer positions.
This function sets `last-coding-system-used' to the precise coding system
used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
not fully specified.)
It returns the length of the encoded text.

(encode-coding-region START END CODING-SYSTEM)Fdecode-coding-string
Decode STRING which is encoded in CODING-SYSTEM, and return the result.
Optional arg NOCOPY non-nil means it is OK to return STRING itself
if the decoding operation is trivial.
This function sets `last-coding-system-used' to the precise coding system
used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
not fully specified.)

(decode-coding-string STRING CODING-SYSTEM &optional NOCOPY)Fencode-coding-string
Encode STRING to CODING-SYSTEM, and return the result.
Optional arg NOCOPY non-nil means it is OK to return STRING itself
if the encoding operation is trivial.
This function sets `last-coding-system-used' to the precise coding system
used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
not fully specified.)

(encode-coding-string STRING CODING-SYSTEM &optional NOCOPY)Fdecode-sjis-char
Decode a Japanese character which has CODE in shift_jis encoding.
Return the corresponding character.

(decode-sjis-char CODE)Fencode-sjis-char
Encode a Japanese character CHAR to shift_jis encoding.
Return the corresponding code in SJIS.

(encode-sjis-char CH)Fdecode-big5-char
Decode a Big5 character which has CODE in BIG5 coding system.
Return the corresponding character.

(decode-big5-char CODE)Fencode-big5-char
Encode the Big5 character CHAR to BIG5 coding system.
Return the corresponding character code in Big5.

(encode-big5-char CH)Fset-terminal-coding-system-internal


(set-terminal-coding-system-internal CODING-SYSTEM)Fset-safe-terminal-coding-system-internal


(set-safe-terminal-coding-system-internal CODING-SYSTEM)Fterminal-coding-system
Return coding system specified for terminal output.

(terminal-coding-system)Fset-keyboard-coding-system-internal


(set-keyboard-coding-system-internal CODING-SYSTEM)Fkeyboard-coding-system
Return coding system specified for decoding keyboard input.

(keyboard-coding-system)Ffind-operation-coding-system
Choose a coding system for an operation based on the target name.
The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
DECODING-SYSTEM is the coding system to use for decoding
(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
for encoding (in case OPERATION does encoding).

The first argument OPERATION specifies an I/O primitive:
  For file I/O, `insert-file-contents' or `write-region'.
  For process I/O, `call-process', `call-process-region', or `start-process'.
  For network I/O, `open-network-stream'.

The remaining arguments should be the same arguments that were passed
to the primitive.  Depending on which primitive, one of those arguments
is selected as the TARGET.  For example, if OPERATION does file I/O,
whichever argument specifies the file name is TARGET.

TARGET has a meaning which depends on OPERATION:
  For file I/O, TARGET is a file name.
  For process I/O, TARGET is a process name.
  For network I/O, TARGET is a service name or a port number

This function looks up what specified for TARGET in,
`file-coding-system-alist', `process-coding-system-alist',
or `network-coding-system-alist' depending on OPERATION.
They may specify a coding system, a cons of coding systems,
or a function symbol to call.
In the last case, we call the function with one argument,
which is a list of all the arguments given to this function.Fupdate-coding-systems-internal
Update internal database for ISO2022 and CCL based coding systems.
When values of any coding categories are changed, you must
call this function

(update-coding-systems-internal)Fset-coding-priority-internal
Update internal database for the current value of `coding-category-list'.
This function is internal use only.

(set-coding-priority-internal)Vcoding-system-list
List of coding systems.

Do not alter the value of this variable manually.  This variable should be
updated by the functions `make-coding-system' and
`define-coding-system-alias'.Vcoding-system-alist
Alist of coding system names.
Each element is one element list of coding system name.
This variable is given to `completing-read' as TABLE argument.

Do not alter the value of this variable manually.  This variable should be
updated by the functions `make-coding-system' and
`define-coding-system-alias'.Vcoding-category-list
List of coding-categories (symbols) ordered by priority.

On detecting a coding system, Emacs tries code detection algorithms
associated with each coding-category one by one in this order.  When
one algorithm agrees with a byte sequence of source text, the coding
system bound to the corresponding coding-category is selected.Vcoding-system-for-read
Specify the coding system for read operations.
It is useful to bind this variable with `let', but do not set it globally.
If the value is a coding system, it is used for decoding on read operation.
If not, an appropriate element is used from one of the coding system alists:
There are three such tables, `file-coding-system-alist',
`process-coding-system-alist', and `network-coding-system-alist'.Vcoding-system-for-write
Specify the coding system for write operations.
Programs bind this variable with `let', but you should not set it globally.
If the value is a coding system, it is used for encoding of output,
when writing it to a file and when sending it to a file or subprocess.

If this does not specify a coding system, an appropriate element
is used from one of the coding system alists:
There are three such tables, `file-coding-system-alist',
`process-coding-system-alist', and `network-coding-system-alist'.
For output to files, if the above procedure does not specify a coding system,
the value of `buffer-file-coding-system' is used.Vlast-coding-system-used
Coding system used in the latest file or process I/O.Vinhibit-eol-conversion
*Non-nil means always inhibit code conversion of end-of-line format.
See info node `Coding Systems' and info node `Text and Binary' concerning
such conversion.Vinherit-process-coding-system
Non-nil means process buffer inherits coding system of process output.
Bind it to t if the process output is to be treated as if it were a file
read from some filesystem.Vfile-coding-system-alist
Alist to decide a coding system to use for a file I/O operation.
The format is ((PATTERN . VAL) ...),
where PATTERN is a regular expression matching a file name,
VAL is a coding system, a cons of coding systems, or a function symbol.
If VAL is a coding system, it is used for both decoding and encoding
the file contents.
If VAL is a cons of coding systems, the car part is used for decoding,
and the cdr part is used for encoding.
If VAL is a function symbol, the function must return a coding system
or a cons of coding systems which are used as above.

See also the function `find-operation-coding-system'
and the variable `auto-coding-alist'.Vprocess-coding-system-alist
Alist to decide a coding system to use for a process I/O operation.
The format is ((PATTERN . VAL) ...),
where PATTERN is a regular expression matching a program name,
VAL is a coding system, a cons of coding systems, or a function symbol.
If VAL is a coding system, it is used for both decoding what received
from the program and encoding what sent to the program.
If VAL is a cons of coding systems, the car part is used for decoding,
and the cdr part is used for encoding.
If VAL is a function symbol, the function must return a coding system
or a cons of coding systems which are used as above.

See also the function `find-operation-coding-system'.Vnetwork-coding-system-alist
Alist to decide a coding system to use for a network I/O operation.
The format is ((PATTERN . VAL) ...),
where PATTERN is a regular expression matching a network service name
or is a port number to connect to,
VAL is a coding system, a cons of coding systems, or a function symbol.
If VAL is a coding system, it is used for both decoding what received
from the network stream and encoding what sent to the network stream.
If VAL is a cons of coding systems, the car part is used for decoding,
and the cdr part is used for encoding.
If VAL is a function symbol, the function must return a coding system
or a cons of coding systems which are used as above.

See also the function `find-operation-coding-system'.Vlocale-coding-system
Coding system to use with system messages.  Also used for decoding
keyboard input on X Window system.Veol-mnemonic-unix
*String displayed in mode line for UNIX-like (LF) end-of-line format.Veol-mnemonic-dos
*String displayed in mode line for DOS-like (CRLF) end-of-line format.Veol-mnemonic-mac
*String displayed in mode line for MAC-like (CR) end-of-line format.Veol-mnemonic-undecided
*String displayed in mode line when end-of-line format is not yet determined.Venable-character-translation
*Non-nil enables character translation while encoding and decoding.Vstandard-translation-table-for-decode
Table for translating characters while decoding.Vstandard-translation-table-for-encode
Table for translating characters while encoding.Vcharset-revision-table
Alist of charsets vs revision numbers.
While encoding, if a charset (car part of an element) is found,
designate it with the escape sequence identifying revision (cdr part of the element).Vdefault-process-coding-system
Cons of coding systems used for process I/O by default.
The car part is used for decoding a process output,
the cdr part is used for encoding a text to be sent to a process.Vlatin-extra-code-table
Table of extra Latin codes in the range 128..159 (inclusive).
This is a vector of length 256.
If Nth element is non-nil, the existence of code N in a file
(or output of subprocess) doesn't prevent it to be detected as
a coding system of ISO 2022 variant which has a flag
`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
or reading output of a subprocess.
Only 128th through 159th elements has a meaning.Vselect-safe-coding-system-function
Function to call to select safe coding system for encoding a text.

If set, this function is called to force a user to select a proper
coding system which can encode the text in the case that a default
coding system used in each operation can't encode the text.

The default value is `select-safe-coding-system' (which see).Vchar-coding-system-table
Char-table containing safe coding systems of each characters.
Each element doesn't include such generic coding systems that can
encode any characters.   They are in the first extra slot.Vinhibit-iso-escape-detection
If non-nil, Emacs ignores ISO2022's escape sequence on code detection.

By default, on reading a file, Emacs tries to detect how the text is
encoded.  This code detection is sensitive to escape sequences.  If
the sequence is valid as ISO2022, the code is determined as one of
the ISO2022 encodings, and the file is decoded by the corresponding
coding system (e.g. `iso-2022-7bit').

However, there may be a case that you want to read escape sequences in
a file as is.  In such a case, you can set this variable to non-nil.
Then, as the code detection ignores any escape sequences, no file is
detected as encoded in some ISO2022 encoding.  The result is that all
escape sequences become visible in a buffer.

The default value is nil, and it is strongly recommended not to change
it.  That is because many Emacs Lisp source files that contain
non-ASCII characters are encoded by the coding system `iso-2022-7bit'
in Emacs's distribution, and they won't be decoded correctly on
reading if you suppress escape sequence detection.

The other way to read escape sequences in a file without decoding is
to explicitly specify some coding system that doesn't use ISO2022's
escape sequence (e.g `latin-1') on reading by \[universal-coding-system-argument].Fmake-category-set
Return a newly created category-set which contains CATEGORIES.
CATEGORIES is a string of category mnemonics.
The value is a bool-vector which has t at the indices corresponding to
those categories.

(make-category-set CATEGORIES)Fdefine-category
Define CHAR as a category which is described by DOCSTRING.
CHAR should be an ASCII printing character in the range ` ' to `~'.
DOCSTRING is a documentation string of the category.
The category is defined only in category table TABLE, which defaults to
 the current buffer's category table.

(define-category CATEGORY DOCSTRING &optional TABLE)Fcategory-docstring
Return the documentation string of CATEGORY, as defined in CATEGORY-TABLE.

(category-docstring CATEGORY &optional TABLE)Fget-unused-category
Return a category which is not yet defined in CATEGORY-TABLE.
If no category remains available, return nil.
The optional argument CATEGORY-TABLE specifies which category table
to modify; it defaults to the current buffer's category table.

(get-unused-category &optional TABLE)Fcategory-table-p
Return t if ARG is a category table.

(category-table-p ARG)Fcategory-table
Return the current category table.
This is the one specified by the current buffer.

(category-table)Fstandard-category-table
Return the standard category table.
This is the one used for new buffers.

(standard-category-table)Fcopy-category-table
Construct a new category table and return it.
It is a copy of the TABLE, which defaults to the standard category table.

(copy-category-table &optional TABLE)Fmake-category-table
Construct a new and empty category table and return it.

(make-category-table)Fset-category-table
Specify TABLE as the category table for the current buffer.

(set-category-table TABLE)Fchar-category-set
Return the category set of CHAR.

(char-category-set CH)Fcategory-set-mnemonics
Return a string containing mnemonics of the categories in CATEGORY-SET.
CATEGORY-SET is a bool-vector, and the categories "in" it are those
that are indexes where t occurs the bool-vector.
The return value is a string containing those same categories.

(category-set-mnemonics CATEGORY-SET)Fmodify-category-entry
Modify the category set of CHARACTER by adding CATEGORY to it.
The category is changed only for table TABLE, which defaults to
 the current buffer's category table.
If optional fourth argument RESET is non-nil,
 then delete CATEGORY from the category set instead of adding it.

(modify-category-entry CHARACTER CATEGORY &optional TABLE RESET)Fdescribe-categories
Describe the category specifications in the current category table.
The descriptions are inserted in a buffer, which is then displayed.

(describe-categories)Vword-combining-categories
List of pair (cons) of categories to determine word boundary.

Emacs treats a sequence of word constituent characters as a single
word (i.e. finds no word boundary between them) iff they belongs to
the same charset.  But, exceptions are allowed in the following cases.

(1) The case that characters are in different charsets is controlled
by the variable `word-combining-categories'.

Emacs finds no word boundary between characters of different charsets
if they have categories matching some element of this list.

More precisely, if an element of this list is a cons of category CAT1
and CAT2, and a multibyte character C1 which has CAT1 is followed by
C2 which has CAT2, there's no word boundary between C1 and C2.

For instance, to tell that ASCII characters and Latin-1 characters can
form a single word, the element `(?l . ?l)' should be in this list
because both characters have the category `l' (Latin characters).

(2) The case that character are in the same charset is controlled by
the variable `word-separating-categories'.

Emacs find a word boundary between characters of the same charset
if they have categories matching some element of this list.

More precisely, if an element of this list is a cons of category CAT1
and CAT2, and a multibyte character C1 which has CAT1 is followed by
C2 which has CAT2, there's a word boundary between C1 and C2.

For instance, to tell that there's a word boundary between Japanese
Hiragana and Japanese Kanji (both are in the same charset), the
element `(?H . ?C) should be in this list.Vword-separating-categories
List of pair (cons) of categories to determine word boundary.
See the documentation of the variable `word-combining-categories'.Fccl-program-p
Return t if OBJECT is a CCL program name or a compiled CCL program code.
See the documentation of  `define-ccl-program' for the detail of CCL program.

(ccl-program-p OBJECT)Fccl-execute
Execute CCL-PROGRAM with registers initialized by REGISTERS.

CCL-PROGRAM is a CCL program name (symbol)
or compiled code generated by `ccl-compile' (for backward compatibility.
In the latter case, the execution overhead is bigger than in the former).
No I/O commands should appear in CCL-PROGRAM.

REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value
for the Nth register.

As side effect, each element of REGISTERS holds the value of
the corresponding register after the execution.

See the documentation of `define-ccl-program' for a definition of CCL
programs.

(ccl-execute CCL-PROG REG)Fccl-execute-on-string
Execute CCL-PROGRAM with initial STATUS on STRING.

CCL-PROGRAM is a symbol registered by register-ccl-program,
or a compiled code generated by `ccl-compile' (for backward compatibility,
in this case, the execution is slower).

Read buffer is set to STRING, and write buffer is allocated automatically.

STATUS is a vector of [R0 R1 ... R7 IC], where
 R0..R7 are initial values of corresponding registers,
 IC is the instruction counter specifying from where to start the program.
If R0..R7 are nil, they are initialized to 0.
If IC is nil, it is initialized to head of the CCL program.

If optional 4th arg CONTINUE is non-nil, keep IC on read operation
when read buffer is exausted, else, IC is always set to the end of
CCL-PROGRAM on exit.

It returns the contents of write buffer as a string,
 and as side effect, STATUS is updated.
If the optional 5th arg UNIBYTE-P is non-nil, the returned string
is a unibyte string.  By default it is a multibyte string.

See the documentation of `define-ccl-program' for the detail of CCL program.

(ccl-execute-on-string CCL-PROG STATUS STR &optional CONTIN UNIBYTE-P)Fregister-ccl-program
Register CCL program CCL_PROG as NAME in `ccl-program-table'.
CCL_PROG should be a compiled CCL program (vector), or nil.
If it is nil, just reserve NAME as a CCL program name.
Return index number of the registered CCL program.

(register-ccl-program NAME CCL-PROG)Fregister-code-conversion-map
Register SYMBOL as code conversion map MAP.
Return index number of the registered map.

(register-code-conversion-map SYMBOL MAP)Vcode-conversion-map-vector
Vector of code conversion maps.Vfont-ccl-encoder-alist
Alist of fontname patterns vs corresponding CCL program.
Each element looks like (REGEXP . CCL-CODE),
 where CCL-CODE is a compiled CCL program.
When a font whose name matches REGEXP is used for displaying a character,
 CCL-CODE is executed to calculate the code point in the font
 from the charset number and position code(s) of the character which are set
 in CCL registers R0, R1, and R2 before the execution.
The code point in the font is set in CCL registers R1 and R2
 when the execution terminated.
If the font is single-byte font, the register R2 is not used.Ftty-display-color-p
Return non-nil if TTY can display colors on FRAME.

(tty-display-color-p &optional FRAME)Vsystem-uses-terminfo
Non-nil means the system uses terminfo rather than termcap.
This variable can be used by terminal emulator packages.Vring-bell-function
Non-nil means call this function to ring the bell.
The function should accept no arguments.Fdump-colors
Dump currently allocated colors and their reference counts to stderr.

(dump-colors)Fclear-face-cache
Clear face caches on all frames.
Optional THOROUGHLY non-nil means try to free unused fonts, too.

(clear-face-cache &optional THOROUGHLY)Fbitmap-spec-p
Value is non-nil if OBJECT is a valid bitmap specification.
A bitmap specification is either a string, a file name, or a list
(WIDTH HEIGHT DATA) where WIDTH is the pixel width of the bitmap,
HEIGHT is its height, and DATA is a string containing the bits of
the pixmap.  Bits are stored row by row, each row occupies
(WIDTH + 7)/8 bytes.

(bitmap-spec-p OBJECT)Fcolor-gray-p
Return non-nil if COLOR is a shade of gray (or white or black).
FRAME specifies the frame and thus the display for interpreting COLOR.
If FRAME is nil or omitted, use the selected frame.

(color-gray-p COLOR &optional FRAME)Fcolor-supported-p
Return non-nil if COLOR can be displayed on FRAME.
BACKGROUND-P non-nil means COLOR is used as a background.
If FRAME is nil or omitted, use the selected frame.
COLOR must be a valid color name.

(color-supported-p COLOR FRAME &optional BACKGROUND-P)Fx-family-fonts
Return a list of available fonts of family FAMILY on FRAME.
If FAMILY is omitted or nil, list all families.
Otherwise, FAMILY must be a string, possibly containing wildcards
`?' and `*'.
If FRAME is omitted or nil, use the selected frame.
Each element of the result is a vector [FAMILY WIDTH POINT-SIZE WEIGHT
SLANT FIXED-P FULL REGISTRY-AND-ENCODING].
FAMILY is the font family name.  POINT-SIZE is the size of the
font in 1/10 pt.  WIDTH, WEIGHT, and SLANT are symbols describing the
width, weight and slant of the font.  These symbols are the same as for
face attributes.  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.
The result list is sorted according to the current setting of
the face font sort order.

(x-family-fonts &optional FAMILY FRAME)Fx-font-family-list
Return a list of available font families on FRAME.
If FRAME is omitted or nil, use the selected frame.
Value is a list of conses (FAMILY . FIXED-P) where FAMILY
is a font family, and FIXED-P is non-nil if fonts of that family
are fixed-pitch.

(x-font-family-list &optional FRAME)Fx-list-fonts
Return a list of the names of available fonts matching PATTERN.
If optional arguments FACE and FRAME are specified, return only fonts
the same size as FACE on FRAME.
PATTERN is a string, perhaps with wildcard characters;
  the * character matches any substring, and
  the ? character matches any single character.
  PATTERN is case-insensitive.
FACE is a face name--a symbol.

The return value is a list of strings, suitable as arguments to
set-face-font.

Fonts Emacs can't use may or may not be excluded
even if they match PATTERN and FACE.
The optional fourth argument MAXIMUM sets a limit on how many
fonts to match.  The first MAXIMUM fonts are reported.
The optional fifth argument WIDTH, if specified, is a number of columns
occupied by a character of a font.  In that case, return only fonts
the WIDTH times as wide as FACE on FRAME.

(x-list-fonts PATTERN &optional FACE FRAME MAXIMUM WIDTH)Finternal-make-lisp-face
Make FACE, a symbol, a Lisp face with all attributes nil.
If FACE was not known as a face before, create a new one.
If optional argument FRAME is specified, make a frame-local face
for that frame.  Otherwise operate on the global face definition.
Value is a vector of face attributes.

(internal-make-lisp-face FACE &optional FRAME)Finternal-lisp-face-p
Return non-nil if FACE names a face.
If optional second parameter FRAME is non-nil, check for the
existence of a frame-local face with name FACE on that frame.
Otherwise check for the existence of a global face.

(internal-lisp-face-p FACE &optional FRAME)Finternal-copy-lisp-face
Copy face FROM to TO.
If FRAME it t, copy the global face definition of FROM to the
global face definition of TO.  Otherwise, copy the frame-local
definition of FROM on FRAME to the frame-local definition of TO
on NEW-FRAME, or FRAME if NEW-FRAME is nil.

Value is TO.

(internal-copy-lisp-face FROM TO FRAME NEW-FRAME)Finternal-set-lisp-face-attribute
Set attribute ATTR of FACE to VALUE.
FRAME being a frame means change the face on that frame.
FRAME nil means change the face of the selected frame.
FRAME t means change the default for new frames.
FRAME 0 means change the face on all frames, and change the default
  for new frames.

(internal-set-lisp-face-attribute FACE ATTR VALUE &optional FRAME)Finternal-face-x-get-resource


(internal-face-x-get-resource RESOURCE CLASS FRAME)Finternal-set-lisp-face-attribute-from-resource


(internal-set-lisp-face-attribute-from-resource FACE ATTR VALUE &optional FRAME)Finternal-get-lisp-face-attribute
Return face attribute KEYWORD of face SYMBOL.
If SYMBOL does not name a valid Lisp face or KEYWORD isn't a valid
face attribute name, signal an error.
If the optional argument FRAME is given, report on face FACE in that
frame.  If FRAME is t, report on the defaults for face FACE (for new
frames).  If FRAME is omitted or nil, use the selected frame.

(internal-get-lisp-face-attribute SYMBOL KEYWORD &optional FRAME)Finternal-lisp-face-attribute-values
Return a list of valid discrete values for face attribute ATTR.
Value is nil if ATTR doesn't have a discrete set of valid values.

(internal-lisp-face-attribute-values ATTR)Finternal-merge-in-global-face
Add attributes from frame-default definition of FACE to FACE on FRAME.
Default face attributes override any local face attributes.

(internal-merge-in-global-face FACE FRAME)Fface-font
Return the font name of face FACE, or nil if it is unspecified.
If the optional argument FRAME is given, report on face FACE in that frame.
If FRAME is t, report on the defaults for face FACE (for new frames).
  The font default for a face is either nil, or a list
  of the form (bold), (italic) or (bold italic).
If FRAME is omitted or nil, use the selected frame.

(face-font FACE &optional FRAME)Finternal-lisp-face-equal-p
True if FACE1 and FACE2 are equal.
If the optional argument FRAME is given, report on face FACE in that frame.
If FRAME is t, report on the defaults for face FACE (for new frames).
If FRAME is omitted or nil, use the selected frame.

(internal-lisp-face-equal-p FACE1 FACE2 &optional FRAME)Finternal-lisp-face-empty-p
True if FACE has no attribute specified.
If the optional argument FRAME is given, report on face FACE in that frame.
If FRAME is t, report on the defaults for face FACE (for new frames).
If FRAME is omitted or nil, use the selected frame.

(internal-lisp-face-empty-p FACE &optional FRAME)Fframe-face-alist
Return an alist of frame-local faces defined on FRAME.
For internal use only.

(frame-face-alist &optional FRAME)Finternal-set-font-selection-order
Set font selection order for face font selection to ORDER.
ORDER must be a list of length 4 containing the symbols `:width',
`:height', `:weight', and `:slant'.  Face attributes appearing
first in ORDER are matched first, e.g. if `:height' appears before
`:weight' in ORDER, font selection first tries to find a font with
a suitable height, and then tries to match the font weight.
Value is ORDER.

(internal-set-font-selection-order ORDER)Finternal-set-alternative-font-family-alist
Define alternative font families to try in face font selection.
ALIST is an alist of (FAMILY ALTERNATIVE1 ALTERNATIVE2 ...) entries.
Each ALTERNATIVE is tried in order if no fonts of font family FAMILY can
be found.  Value is ALIST.

(internal-set-alternative-font-family-alist ALIST)Finternal-set-alternative-font-registry-alist
Define alternative font registries to try in face font selection.
ALIST is an alist of (REGISTRY ALTERNATIVE1 ALTERNATIVE2 ...) entries.
Each ALTERNATIVE is tried in order if no fonts of font registry REGISTRY can
be found.  Value is ALIST.

(internal-set-alternative-font-registry-alist ALIST)Ftty-suppress-bold-inverse-default-colors
Suppress/allow boldness of faces with inverse default colors.
SUPPRESS non-nil means suppress it.
This affects bold faces on TTYs whose foreground is the default background
color of the display and whose background is the default foreground color.
For such faces, the bold face attribute is ignored if this variable
is non-nil.

(tty-suppress-bold-inverse-default-colors SUPPRESS)Fdump-face


(dump-face &optional N)Fshow-face-resources


(show-face-resources)Vfont-list-limit
*Limit for font matching.
If an integer > 0, font matching functions won't load more than
that number of fonts when searching for a matching font.Vface-new-frame-defaults
List of global face definitions (for internal use only.)Vface-default-stipple
*Default stipple pattern used on monochrome displays.
This stipple pattern is used on monochrome displays
instead of shades of gray for a face background color.
See `set-face-stipple' for possible values for this variable.Vtty-defined-color-alist
An alist of defined terminal colors and their RGB values.Vscalable-fonts-allowed
Allowed scalable fonts.
A value of nil means don't allow any scalable fonts.
A value of t means allow any scalable font.
Otherwise, value must be a list of regular expressions.  A font may be
scaled if its name matches a regular expression in the list.
Note that if value is nil, a scalable font might still be used, if no
other font of the appropriate family and registry is available.Vface-ignored-fonts
List of ignored fonts.
Each element is a regular expression that matches names of fonts to ignore.Finvocation-name
Return the program name that was used to run Emacs.
Any directory names are omitted.

(invocation-name)Finvocation-directory
Return the directory name in which the Emacs executable was located.

(invocation-directory)Fkill-emacs
Exit the Emacs job and kill it.
If ARG is an integer, return ARG as the exit program code.
If ARG is a  string, stuff it as keyboard input.

The value of `kill-emacs-hook', if not void,
is a list of functions (of no args),
all of which are called before Emacs is actually killed.

(kill-emacs &optional ARG)Fdump-emacs-data
Dump current state of Emacs into data file FILENAME.
This function exists on systems that use HAVE_SHM.

(dump-emacs-data FILENAME)Fdump-emacs
Dump current state of Emacs into executable file FILENAME.
Take symbols from SYMFILE (presumably the file you executed to run Emacs).
This is used in the file `loadup.el' when building Emacs.

You must run Emacs in batch mode in order to dump it.

(dump-emacs FILENAME SYMFILE)Vcommand-line-args
Args passed by shell to Emacs, as a list of strings.Vsystem-type
Value is symbol indicating type of operating system you are using.Vsystem-configuration
Value is string indicating configuration Emacs was built for.
On MS-Windows, the value reflects the OS flavor and version on which
Emacs is running.Vsystem-configuration-options
String containing the configuration options Emacs was built with.Vnoninteractive
Non-nil means Emacs is running without interactive terminal.Vkill-emacs-hook
Hook to be run whenever kill-emacs is called.
Since kill-emacs may be invoked when the terminal is disconnected (or
in other similar situations), functions placed on this hook should not
expect to be able to interact with the user.  To ask for confirmation,
see `kill-emacs-query-functions' instead.Vsignal-USR1-hook
Hook to be run whenever emacs receives a USR1 signalVsignal-USR2-hook
Hook to be run whenever emacs receives a USR2 signalVemacs-priority
Priority for Emacs to run at.
This value is effective only if set before Emacs is dumped,
and only if the Emacs executable is installed with setuid to permit
it to change priority.  (Emacs sets its uid back to the real uid.)
Currently, you need to define SET_EMACS_PRIORITY in `config.h'
before you compile Emacs, to enable the code for this feature.Vpath-separator
The directory separator in search paths, as a string.Vinvocation-name
The program name that was used to run Emacs.
Any directory names are omitted.Vinvocation-directory
The directory in which the Emacs executable was found, to run it.
The value is nil if that directory's name is not known.Vinstallation-directory
A directory within which to look for the `lib-src' and `etc' directories.
This is non-nil when we can't find those directories in their standard
installed locations, but we can find them
near where the Emacs executable was found.Vsystem-messages-locale
System locale for messages.Vprevious-system-messages-locale
Most recently used system locale for messages.Vsystem-time-locale
System locale for time.Vprevious-system-time-locale
Most recently used system locale for time.Frecursive-edit
Invoke the editor command loop recursively.
To get out of the recursive edit, a command can do `(throw 'exit nil)';
that tells this function to return.
Alternately, `(throw 'exit t)' makes this function signal an error.
This function is called by the editor initialization to begin editing.

(recursive-edit)Ftop-level
Exit all recursive editing levels.

(top-level)Fexit-recursive-edit
Exit from the innermost recursive edit or minibuffer.

(exit-recursive-edit)Fabort-recursive-edit
Abort the command that requested this recursive edit or minibuffer input.

(abort-recursive-edit)Ftrack-mouse
Evaluate BODY with mouse movement events enabled.
Within a `track-mouse' form, mouse motion generates input events that
you can read with `read-event'.
Normally, mouse motion is ignored.Fevent-convert-list
Convert the event description list EVENT-DESC to an event type.
EVENT-DESC should contain one base event type (a character or symbol)
and zero or more modifier names (control, meta, hyper, super, shift, alt,
drag, down, double or triple).  The base must be last.
The return value is an event type (a character or symbol) which
has the same base event type and all the specified modifiers.

(event-convert-list EVENT-DESC)Fread-key-sequence
Read a sequence of keystrokes and return as a string or vector.
The sequence is sufficient to specify a non-prefix command in the
current local and global maps.

First arg PROMPT is a prompt string.  If nil, do not prompt specially.
Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
as a continuation of the previous key.

The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
convert the last event to lower case.  (Normally any upper case event
is converted to lower case if the original event is undefined and the lower
case equivalent is defined.)  A non-nil value is appropriate for reading
a key sequence to be defined.

A C-g typed while in this function is treated like any other character,
and `quit-flag' is not set.

If the key sequence starts with a mouse click, then the sequence is read
using the keymaps of the buffer of the window clicked in, not the buffer
of the selected window as normal.

`read-key-sequence' drops unbound button-down events, since you normally
only care about the click or drag events which follow them.  If a drag
or multi-click event is unbound, but the corresponding click event would
be bound, `read-key-sequence' turns the event into a click event at the
drag's starting position.  This means that you don't have to distinguish
between click and drag, double, or triple events unless you want to.

`read-key-sequence' prefixes mouse events on mode lines, the vertical
lines separating windows, and scroll bars with imaginary keys
`mode-line', `vertical-line', and `vertical-scroll-bar'.

Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
function will process a switch-frame event if the user switches frames
before typing anything.  If the user switches frames in the middle of a
key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
is nil, then the event will be put off until after the current key sequence.

`read-key-sequence' checks `function-key-map' for function key
sequences, where they wouldn't conflict with ordinary bindings.  See
`function-key-map' for more details.

The optional fifth argument COMMAND-LOOP, if non-nil, means
that this key sequence is being read by something that will
read commands one after another.  It should be nil if the caller
will read just one key sequence.

(read-key-sequence PROMPT &optional CONTINUE-ECHO DONT-DOWNCASE-LAST CAN-RETURN-SWITCH-FRAME COMMAND-LOOP)Fread-key-sequence-vector
Like `read-key-sequence' but always return a vector.

(read-key-sequence-vector PROMPT &optional CONTINUE-ECHO DONT-DOWNCASE-LAST CAN-RETURN-SWITCH-FRAME COMMAND-LOOP)Fcommand-execute
Execute CMD as an editor command.
CMD must be a symbol that satisfies the `commandp' predicate.
Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in `command-history'.
Otherwise, that is done only if an arg is read using the minibuffer.
The argument KEYS specifies the value to use instead of (this-command-keys)
when reading the arguments; if it is nil, (this-command-keys) is used.
The argumen