X uses many common terms in unique ways. A good example is “chilldren.” While most, if not all, of these terms are defined where they are first used in this manual, you will undoubtedly find it easier to refresh your memory by looking for them here.
This glossary is an expanded version of the glossary from Volume One, Xlib Programming Manual (which in turn is based on the glossary in the Xlib-C Language X Interface, by Jim Gettys, Ron Newman, and Bob Scheifler). As such, it contains definitions of many Xlib terms not actually used in this book, but which you might come across in other reading, or in comments in code. In some cases, these Xlib terms may be used in the definitions of the Xt terms given in this glossary. Any term used in a definition, for which another entry exists in the glossary, is generally shown in italics.
An accelerator is a translation that maps events in one widget to actions in another. The name is based on the most frequent use for this feature, namely to provide keyboard shortcuts to invoke application or widget functions that would otherwise have only a pointer-driven interface.
The accept_focus method of a child is invoked when a parent offers the keyboard focus to a child by calling XtCallAcceptFocus(). This method is part of the Core widget class.
X maintains lists of hosts that are allowed access to each server controlling a display. By default, only the local host may use the display, plus any hosts specified in the access control list for that display. This access control list can be changed by clients on the local host. Some server implementations may implement other authorization mechanisms in addition to or instead of this one. The list can currently be found in /etc/X#.hosts where # is the number of the display, usually 0 (zero). The access control list is also known as the host access list.
An action is a function bound by a translation, to be invoked in response to a user event.
An actions table is an array of function pointers and corresponding strings by which actions can be referenced in a translation table. The use of actions requires a widget to define both an actions table and a translation table.
A grab is active when the pointer or keyboard is actually owned by a single grabbing client. See also grab.
If window W is an inferior of window A, then A is an ancestor of W. The parent window, the parent's parent window, and so on are all ancestors of the given window. The root window is the ancestor of all windows on a given screen.
An application context specifies a connection to a server. When an application program has connections to multiple servers, the application context coordinates events and their dispatching, so all connections get processed.
An argument list is used in a call to create a widget in order to “hardcode” the value of widget resources, and also in calls to XtSetValues() or XtGetValues(). It consists of an array of Arg structures, each consisting of a resource name and the value to which it should be set.
MIT distributes a set of widgets developed by MIT's Project Athena in the Athena Widget library, Xaw. The include files for Athena widgets usually reside in /usr/include/X11/Xaw.
An atom is a unique numeric ID corresponding to a string name. Atoms are used to identify properties, types, and selections in order to avoid the overhead of passing arbitrary-length strings over the network. See also property.
Windows may have a background, consisting of either a solid color or a tile pattern. If a window has a background, it will be repainted automatically by the server whenever there is an Expose event on the window. If a window does not have a background, it will be transparent. By default, a window has a background. See also foreground.
When a server maintains the contents of a window, the off-screen saved pixels are known as a backing store. This feature is not available on all servers. Even when available, the server will not maintain a backing store, unless told to do so with a window attribute. Use the DoesBackingStores Xlib macro to determine if this feature is supported.
When a window is resized, the contents of the window are not necessarily discarded. It is possible to request the server (though no guarantees are made) to relocate the previous contents to some region of the resized window. This attraction of window contents for some location of a window is known as bit gravity. For example, an application that draws a graph might request that the contents be moved into the lower-left corner, so that the origin of the graph will still appear in the lower-left corner. See also window gravity.
On a color or gray scale display, each pixel has more than one bit defined. Data in display memory can be thought of either as pixels (multiple bits per pixel) or as bit planes (one bit plane for each usable bit in the pixel). The bit plane is an array of bits the size of the screen.
A bitmap is a pixmap with a depth of one bit. There is no bitmap type in X11. Instead, use a pixmap of depth 1. See also pixmap.
A window can have a border that is zero or more pixels wide. If a window has a border, the border can have a solid color or a tile pattern, and it will be repainted automatically by the server whenever its color or pattern is changed or an Expose event occurs on the window.
A pointer grab that becomes active only when a specified set of keys and/or buttons are held down in a particular window is referred to as a button grab.
The order in which bytes of data are stored in memory is hardware-dependent. For pixmaps and bitmaps, byte order is defined by the server, and clients with different native byte ordering must swap bytes as necessary. For all other parts of the protocol, the byte order is defined by the client, and the server swaps bytes as necessary.
A callback is an application function registered with a widget by the application using either of the calls XtAddCallback() or XtAddCallbacks() or through an argument list. A widget declares one or more callback lists as resources; applications add functions to these lists in order to link widgets to applications code.
When a parent should change its managed widgets, the change_managed method is invoked, at which time a parent reorganizes its children. The change_managed method is part of the Composite widget class.
1) A widget created by XtCreateWidget() is a child of the widget specified as its parent. The parent controls the layout of its children. 2) The children of a window are its first-level subwindows. All of these windows were created with the same window as parent. A client creates its top-level window as a child of the root window.
1) (X Toolkit) A widget's class determines what methods will be called for it and what instance variables it has. For widget users, a widget's class is declared in the .h file for the widget. 2) (Xlib) There are two uses of the term class in X: window class and visual class. The window class specifies whether a window is InputOnly or InputOutput. The visual class specifies the color model that is used by a window. See the classes DirectColor, GrayScale, PseudoColor, StaticColor, StaticGray, and TrueColor. Both window class and visual class are set permanently when a window is created.
This method--part of the Core widget--is invoked when a widget class is initialized. That is, it is called when the first instance of a particular class is created.
An application program connects to the window system server by an interprocess communication (IPC) path, such as a TCP connection or a shared memory buffer. This program is referred to as a client of the window system server. More precisely, the client is the IPC path itself; a program with multiple paths open to one or more servers is viewed by the protocol as multiple clients. X Resources are available only as long as the connection remains intact, not as long as a program remains running. Normally the connection and the program terminate concurrently, but the client's resources may live on if XChangeCloseDownMode() has been called.
In many graphics routines, a bitmap or list of rectangles can be specified to restrict output to a particular region of the window. The image defined by the bitmap or rectangles is called a clipping region, or clip mask. Output to child windows is automatically clipped to the borders of the parent unless subwindow_mode of the GC is IncludeInferiors. Therefore the borders of the parent can be thought of as a clipping region.
An entry in a colormap is known as a colorcell. An entry contains three values specifying red, green, and blue intensities. These values are always 16-bit unsigned numbers, with zero being minimum intensity. The values are truncated or scaled by the server to match the display hardware. See also colormap.
A colormap consists of a set of colorcells. A pixel value indexes into the colormap to produce intensities of Red, Green, and Blue to be displayed. Depending on hardware limitations, one or more colormaps may be installed at one time, such that windows associated with those maps display with true colors. Regardless of the number of installable colormaps, any number of virtual colormaps can be created. When needed, a virtual colormap can be installed and the existing installed colormap might have to be uninstalled. The colormap on most systems is a limited resource that should be conserved by allocating read-only colorcells whenever possible, and by selecting RGB values from the predefined color database. Read-only cells may be shared between clients. See also colorcell, DirectColor, GrayScale, PseudoColor, StaticColor, StaticGray, and TrueColor.
A Composite widget is designed to manage the geometry of children; that is, a Composite widget instance can be passed in the parent argument to XtCreateWidget().
The communication path between the server and the client is known as a connection. A client usually (but not necessarily) has only one connection to the server over which requests and events are sent.
The Constraint widget is a subclass of Composite. A Constraint widget has more information about each child than a Composite widget.
A Constraint widget provides a list of resources, or constraints, for its children. The constraints give the Constraint widget information about how each child should be laid out.
A window contains the pointer if the window is viewable and if the hotspot of the cursor is within a visible region of the window or a visible region of one of its inferiors. The border of the window is included as part of the window for containment. The pointer is in a window if the window contains the pointer but no inferior contains the pointer.
The coordinate system has x horizontal and y vertical, with the origin (0, 0) at the upper-left. Coordinates are discrete, and in terms of pixels. Each window and pixmap has its own coordinate system. For a window, the origin is inside the border, if there is one. The position of a child window is measured from the origin of the parent to the outside corner of the child (not the child's origin).
The Core widget is the basic class in the Toolkit. All widgets that can be displayed are subclasses of Core.
A cursor is the visible shape of the pointer on a screen. It consists of a hotspot, a shape bitmap, a mask bitmap, and a pair of pixel values. The cursor defined for a window controls the visible appearance of the pointer when the pointer is in that window.
The delete_child method is invoked on a parent after its child is deleted. This method is part of the Composite widget and is usually inherited.
The depth of a window or pixmap is the number of bits per pixel.
To access the contents of a pointer, you must dereference it.
The destroy method is invoked when a widget has been destroyed. This method is part of the Core widget and is used to deallocate memory and GCs.
Keyboards, mice, tablets, track-balls, button boxes, etc. are all collectively known as input devices.
DirectColor is a visual class in which a pixel value is decomposed into three separate subfields for colormap indexing. One subfield indexes an array to produce red intensity values; the second subfield indexes a second array to produce blue intensity values; and the third subfield indexes a third array to produce green intensity values. The RGB (red, green, and blue) values in the colormap entry can be changed dynamically. This visual class is normally found on high-performance color workstations.
A display is a set of one or more screens that are driven by a single X server. The Xlib Display structure contains all information about the particular display and its screens as well as the state that Xlib needs to communicate with the display over a particular connection. In Xlib, a pointer to a Display Structure is returned by XOpenDisplay(). In most Xt applications, the Display is part of the application context, and need not be referenced directly. If necessary, a display can be opened directly with a call to XtOpenDisplay(), and a pointer to the currently open display can be returned by the XtDisplay() macro.
Both windows and pixmaps may be used as destinations in graphics operations. These are collectively known as drawables.
Encapsulation is a key concept in object-oriented programming. Objects are defined in such a way that their internals are hidden from the programs that use them; the only way to access an object should be through its published interfaces.
An X event is a data structure sent by the server that describes something that just happened that may be of interest to the application. There are two major categories of events: user input and window system side effects. For example, the user pressing a keyboard key or clicking a mouse button generates an event; a window being moved on the screen also generates events--possibly in other applications as well if the movement changes the visible portions of their windows. It is the server's job to distribute events to the various windows on the screen.
Event compression is an Xt feature that allows some events to be ignored or repackaged before they are given to a widget. This happens on the client side, rather than in the server.
An event handler is a function that is called by Xt when a particular event is received. Event handlers have the same purpose as translations and actions--to call a function in response to an event--but event handlers have lower overhead and are not user-configurable.
Events are requested relative to a window or widget. The set of event types a client requests relative to a window is described using an event mask, a bitwise OR of defined symbols specifying which events are desired. The event_mask is a window attribute, which can be set in Xlib with XSelectInput(), and is also specified in calls that grab the pointer or keyboard. The do_not_propagate_mask attribute is also an event mask, and it specifies which events should not be propagated to ancestor windows. In Xt, you never need to set a window's event_mask or do_not_propogate_mask directly. The translation manager automatically selects the required events.
Device-related events propagate from the source window to ancestor windows until a window that has selected that type of event is reached, or until the event is discarded explicitly in a do_not_propagate_mask attribute.
The smallest window containing the pointer is the source of a device-related event.
When Expose events are received, the Intrinsics invoke the expose method. A widget should perform its redisplay activities in this method. The expose method is part of the Core widget class.
Window exposure occurs when a window is first mapped, or when another window that obscures it is unmapped, resized, or moved. Servers do not guarantee to preserve the contents of windows when windows are obscured or reconfigured. Expose events are sent to clients to inform them when contents of regions of windows have been lost and need to be regenerated.
Named extensions to the core protocol can be defined to extend the system. Extension to output requests, resources, and event types are all possible, and expected. Extensions can perform at the same level as the core Xlib.
A font is an array of characters or other bitmap shapes such as cursors. The protocol does no translation or interpretation of character sets. The client simply indicates values used to index the font array. A font contains additional metric information to determine intercharacter and interline spacing.
The pixel value that will actually be used for drawing pictures or text is referred to as the foreground. The foreground is specified as a member of a graphics context. See also background.
Clients can freeze event processing while they change the screen, by grabbing the keyboard or pointer with a certain mode. These events are queued in the server (not in Xlib) until an XAllowEvents() call with a counteracting mode is given.
The term GC is used as a shorthand for graphics context. See graphics context.
A Composite parent controls its children through geometry management, thereby manipulating the size and placement of widgets within a window on the display.
The get_values_hook method is invoked by the Intrinsics when someone calls XtGetValues(). This method is part of the Core widget class. Its role is to get the resource values of a subpart using XtGetSubvalues().
A glyph is an image, usually of a character in a font, but also possibly of a cursor shape or some other shape.
Keyboard keys, the keyboard, pointer buttons, the pointer, and the server can be grabbed for exclusive use by a client, usually for a short time period. In general, these facilities help implement various styles of user interface. Popup widgets generally make a passive grab. Server grabs are generally used only by window managers.
Various information for interpreting graphics primitives is stored in a graphics context (GC), such as foreground pixel, background pixel, line width, clipping region, etc. Everything drawn to a window or pixmap is modified by the GC used in the drawing request.
A graphics primitive is an Xlib call that sends a protocol request to the server, instructing the server to draw a particular shape at a particular position. The graphics context specified with the primitive specifies how the server interprets the primitive.
GrayScale is a visual class in which the red, green, and blue values in any given colormap entry are equal, thus producing shades of gray. The gray values can be changed dynamically. GrayScale can be viewed as a degenerate case of PseudoColor.
Certain properties, such as the preferred size of a window, are referred to as hints, since the window manager makes no guarantee that it will honor them.
A cursor has an associated hotspot that defines the point in the cursor which corresponds to the coordinates reported for the pointer.
Each server resource has an identifier or ID, a unique value that clients use to name the resource. Any client can use a resource if it knows the resource ID.
The inferiors of a window are all of the subwindows nested below it: the children, the children's children, etc. The term descendants is a synonym.
Inheritance is the ability to obtain methods from a superclass. Multiple inheritance, which is not supported by Xt, would allow a class to obtain methods from multiple unrelated superclasses.
The initialize method is invoked when a widget is created. It initializes instance variables and checks resource values. This method is part of the Core widget class.
The initialize_hook method is called just after the initialize method, and is responsible for initializing subpart instance variables and checking subpart resource values. This method is part of the Core widget class.
A window that cannot be used for graphics requests is called an InputOnly window. InputOnly windows are invisible and can be used to control such things as cursors, input event distribution, and grabbing. InputOnly windows cannot have InputOutput windows as inferiors.
The normal kind of window that is used for both input and output is called an InputOutput window. It usually has a background. InputOutput windows can have both InputOutput and InputOnly windows as inferiors.
Control over keyboard input may be provided by an input manager client. This job is more often done by the window manager.
A widget's insert child method is invoked when someone specifies it as a parent in an XtCreateWidget() call. This method is part of the Composite widget class. This method is usually inherited.
An instance is a particular widget that has a class. An instance ID is returned by XtCreateWidget().
When you instantiate a class, you create an instance of it.
The X Toolkit defines functions and datatypes called Intrinsics.
A keyboard grab that occurs only when a certain key or key combination is pressed is called a key grab. This is analogous to button grabbing. Both are forms of passive grabs.
The keyboard focus is the window that receives main keyboard input. By default the focus is the root window, which has the effect of sending input to the window that is being pointed to by the mouse. It is possible to attach the keyboard input to a specific window with XSetInputFocus(). Events are then sent to the window independent of the pointer position.
All keyboard input is sent to a specific window (or client, depending on owner_events) when the keyboard is grabbed. This is analogous to mouse grabbing. This is very much like a temporary keyboard focus window.
A keycode is a code in the range 8-255 inclusive that represents a physical or logical key on the keyboard. The mapping between keys and keycodes cannot be changed, and varies between servers. A list of keysyms is associated with each keycode. Programs should use keysyms instead of keycodes to interpret key events.
A keysym is a #define'd symbol which is a portable representation of the symbol on the cap of a key. Each key may have several keysyms, corresponding to the key when various modifier keys are pressed. You should interpret key events according to the keysym returned by XLookupString() or XLookupKeysym(), since this translates server-dependent keycodes into portable keysyms.
A listener style window manager sets the keyboard focus to a particular window when that window is clicked on with a pointer button. This is the window manager style used with the Apple Macintosh. This style is also referred to as click-to-type.
The international environment of a computer program defining the “localized” behavior of that program at run-time. This information can be established from one or more sets of localization data. ANSI C defines locale-specific processing by C system library calls. See ANSI C and the X/Open Portability Guide specifications for more details. In this specification, on implementations that conform to the ANSI C library, the “current locale” is the current setting of the LC_CTYPE setlocale category. Associated with each locale is a text encoding. When text is processed in the context of a locale, the text must be in the encoding of the locale. See the glossary in Volume One, Xlib Programming Manual, for related terms.
A loose binding refers to the use of an asterisk (*) wildcard in a resource specification to indicate that the specification applies to zero or more hierarchy levels of widget instances or classes.
A window is said to be mapped if an XMapWindow() or XMapRaised() call has been performed on it. Unmapped windows are never viewable. Mapping makes a window eligible for display. The window will actually be displayed if the following conditions are also met: 1) All its ancestors are mapped. 2) It is not obscured by siblings. 3) The window manager has processed the request, if for a top-level window.
In object-oriented programming, a message is used to invoke an object's methods. In Xt, you can think of the Intrinsics functions used to create, destroy, and set resource values as sending messages to widget classes.
A method is a function internal to widget class that the Intrinsics invoke under specified conditions. Methods are provided as pointers to functions in widget class records.
A modal popup is a popup widget that grabs the pointer when a mouse button is pressed in a particular window.
A modeless popup is a popup widget that doesn't grab the pointer on a mouse button.
Shift, Control, Meta, Super, Hyper, Alt, Compose, Apple, Caps Lock, Shift Lock, and similar keys are called modifier keys.
A monochrome screen has only two colors: black and white. Monochrome is a special case of the StaticGray visual class, in which there are only two colormap entries.
A non-maskable event is an event that is not selected by the application or widget via an event mask, but is instead sent automatically by the X server. The non-maskable events are MappingNotify, ClientMessage, SelectionClear, SelectionNotify, and SelectionRequest.
In object-oriented programming, an object is a self-contained program unit containing both data and procedures.
Object-oriented programming is a way of defining classes and creating instances so that objects respond to messages with methods. One of its major benefits is the encapsulation of code.
Window A obscures window B if A is higher in the global stacking order, and the rectangle defined by the outside edges of A intersects the rectangle defined by the outside edges of B. See occlude.
Window A occludes window B if both are mapped, if A is higher in the global stacking order, and if the rectangle defined by the outside edges of A intersects the rectangle defined by the outside edges of B. The (fine) distinction between the terms obscures and occludes is that for obscures, the windows have to be mapped, while for occludes they don't. Also note that window borders are included in the calculation. Note that InputOnly windows never obscure other windows but can occlude other windows.
Some bytes are inserted in the data stream to maintain alignment of the protocol requests on natural boundaries. This padding increases ease of portability to some machine architectures.
A parent is a Composite widget instance specified as the parent argument in XtCreateWidget(). Parents control a child's layout.
Each new window is created with reference to another previously-created window. The new window is referred to as the child, and the reference window as the parent. If C is a child of P, then P is the parent of C. Only the portion of the child that overlaps the parent is viewable.
A passive grab is a grab that will become active only when a specific key or button is actually pressed in a particular window.
A pixel value is an N-bit value, where N is the number of bit planes used in a particular window or pixmap. For a window, a pixel value indexes a colormap to derive an actual color to be displayed. For a pixmap, a pixel value will be interpreted as a color in the same way when it has been copied into a window.
A pixmap is a three-dimensional array of bits. A pixmap is normally thought of as a two-dimensional array of pixels, where each pixel can be a value from 0 to 'br (2N-1), where N is the depth (z-axis) of the pixmap. A pixmap can also be thought of as a stack of N bitmaps. A pixmap may have only one plane. Such a pixmap is often referred to as a bitmap, even though there is no bitmap type in X11. See also bitmap.
When a pixmap or window is thought of as a stack of bitmaps, each bitmap is called a plane.
Graphics operations can be restricted to affect only a subset of bit planes in a drawable. A plane mask is a bit mask describing which planes are to be modified.
The pointer is the pointing device currently attached to the cursor, and tracked on the screens. This may be a mouse, tablet, track-ball, or joystick.
A client can actively grab control of the pointer, causing button and motion events to be sent to that client rather than to the client the pointer indicates.
A pointing device is typically a mouse or tablet, or some other device with effective two-dimensional motion, that usually has buttons. There is only one visible cursor defined by the core protocol, and it tracks whatever pointing device is currently attached as the pointer.
A popup is a widget outside the normal parental hierarchy of geometry management. It is a child window of the root window that is popped up temporarily to give the user a piece of information, or to get some information from the user.
When a tree structure is subject to post-order traversal, its root is visited last; for example, a function might process the left descendant, the right descendant, and then the root.
When a tree structure is subject to pre-order traversal, its root is visited first; for example, a function might process the root, and then the left and right descendant.
A private header file contains the internal class definitions of a widget. For example, the Label widget's internal class definitions are contained in the private header file LabelP.h. This file is included only in the widget .c file of this class and any subclasses, never in the application.
Windows may have associated properties, each consisting of a name, a type, a data format, and some data. The protocol places no interpretation on properties; they are intended as a general-purpose data storage and intercommunication mechanism for clients. There is, however, a list of predefined properties and property types so that clients might share information such as resize hints, program names, and icon formats with a window manager via properties. In order to avoid passing arbitrary-length property-name strings, each property name is associated with a corresponding integer value known as an atom. See also atom.
PseudoColor is a visual class in which a pixel value indexes the colormap entry to produce independent red, green, and blue values. That is, the colormap is viewed as an array of triples (RGB values). The RGB values can be changed dynamically.
A public header file contains the declarations (e.g., class widget pointer) necessary to use a widget. For example, labelWidgetClass declarations are contained in the public header file label.h. This header file is included in the widget .c file and in the application source file.
A quark is an integer ID that identifies a string. In the context of Xt, this string is usually a name, class, or type string for the resource manager. Like atoms and resource IDs, quarks eliminate the need to pass strings of arbitrary length over the network. The quark type is XrmQuark, and the types XrmName, XrmClass, and XrmRepresentation are also defined to be XrmQuark.
Parents call XtQueryGeometry() to invoke the child's query geometry method to find out a child's preferred geometry. This method is part of the Core widget class.
Changing the stacking order of a window so as to occlude all sibling windows is to raise that window.
The window management style characterized by the input being sent to whichever window the pointer is in is called real-estate-driven. This is the most common style of input management used in X.
The realize method creates a window on the display and is part of the Core widget class.
A rectangle specified by [x,y,w,h] has an (infinitely thin) outline path with corners at [x,y], [x+w,y], [x+w,y+h], and [x,y+h]. When a rectangle is filled, the lower-right edges are not drawn. For example, if w=h=0, nothing would be drawn when drawing the rectangle, but a single pixel when filling it. For w=h=1, a single pixel would be drawn when drawing the rectangle, four pixels when filling it.
Window managers (or other clients) may wish to enforce window layout policy in various ways. When a client attempts to change the size or position of a window, or to map one, the operation may be redirected to the window manager, rather than actually being performed. Then the window manager (or other client that redirected the input) is expected to decide whether to allow, modify, or deny the requested operation before making the call itself. See also window manager.
The window manager often reparents the top-level windows of each application in order to add a title bar and perhaps resize boxes. In other words, a window with a title bar is inserted between the root window and each top-level window. See also save-set.
Information requested from the server by a client is sent back to the client in a reply. Both events and replies are multiplexed on the same connection with the requests. Requests that require replies are known as round-trip requests, and, if possible, should be avoided since they introduce network delays. Most requests do not generate replies. Some requests generate multiple replies. Xt caches frequently-used data on the client side of the connection in order to minimize the need for round-trip requests. See Volume Zero, X Protocol Reference Manual, for a detailed discussion of the X Protocol.
A symbolic constant beginning with XtR, which is defined in <X11/StringDefs.h> or an application or widget header file, and which is used to define the data type of a resource. Xt automatically converts between resource settings, which are strings, and various representation types.
A command to the server is called a request. It is a single block of data sent over the connection to the server. See Volume Zero, X Protocol Reference Manual, for a detailed discussion of the X Protocol.
The resize method of a widget is called when the widget's parent has changed its size. This method is part of the Core widget class. In composite widgets, this method calculates a new layout for the children. In simple widgets, this method recalculates instance variables so that the expose method can redraw the widget properly.
1) A widget or application variable whose value can be set by the user or application programmer via the Resource Manager. 2) In the X Protocol and server documentation, windows, pixmaps, cursors, fonts, graphics contexts, and colormaps are known as resources. They all have unique identifiers (IDs) associated with them for naming purposes.
The resource database is the collection of possible places where resource specifications can be made. The most important of these are the app-defaults file, where the programmer specifies resource defaults, the RESOURCE_MANAGER server property, which the user can set with xrdb, and the .Xdefaults file in the user's home directory, where he or she specifies local resource preferences.
The Resource Manager is a part of Xlib that merges a database consisting of several ASCII files, a server property, and values hardcoded by the application, and determines a unique value for each resource of each widget. It resolves conflicts between multiple settings for the same resource according to its internal precedence rules, and provides the widget or application with the resulting value.
A resource setting is the actual value of a resource variable.
A resource specification describes a “pathname” to a widget resource, using widget class and/or instance names, resource class or instance names, and optional wildcards. For example, the resource specification: xbox.box.quit.label: Quit specifies that the label resource of the quit widget, which is contained in the box widget in the xbox application, should be set to “Quit.” The specification: *Command.background: blue which uses wildcards and widget classes, specifies that the background (color) resource of all Command widgets in any application should be set to “blue.” It is up to the Resource Manager to resolve differences between resource specifications, which may have varying levels of specificity in the various locations that make up the resource database.
See colorcell.
The root of a window, pixmap, or graphics context (GC) is the same as the root window of whatever drawable was specified in the call to create the window, pixmap, or GC. These resources can be used only on the screen indicated by this window. See root window.
Each screen has a root window covering it. It cannot be reconfigured or unmapped, but otherwise acts as a full-fledged window. A root window has no parent.
A request to the server that generates a reply is known as a round-trip request. See reply.
The save-set of a client is a list of other clients' windows which, if they are inferiors of one of the client's windows at connection close, should not be destroyed, and which should be reparented and remapped if the client is unmapped. Save-sets are typically used by window managers to avoid lost windows if the manager should terminate abnormally. See reparenting for more background information.
A scan line is a list of pixel or bit values viewed as a horizontal row (all values having the same y coordinate) of an image, with the values ordered by increasing x coordinate values.
An image represented in scan line order contains scan lines ordered by increasing y coordinate values.
A screen may not have physically independent monitors. For instance, it is possible to treat a color monitor as if it were two screens, one color and the other black and white or to have two separate color and monochrome screens controlled by one server. There is only a single keyboard and pointer shared among the screens. A Screen structure contains the information about each screen and the list is a member of the Display structure.
A scrollbar is an area on a window that allows a user to view different portions of a window's information by scrolling, or moving.
Selections are a means of communication between clients using properties and events. From the user's perspective, a selection is an item of data which can be highlighted in one instance of an application and pasted into another instance of the same or a different application. The client that highlights the data is the owner, and the client into which the data is pasted is the requestor. Properties are used to store the selection data and the type of the data, while events are used to synchronize the transaction and to allow the requestor to indicate the type it prefers for the data and to allow the owner to convert the data to the indicated type if possible.
The server provides the basic windowing mechanism. It handles IPC connections from clients, demultiplexes graphics requests onto the screens, and multiplexes input back to the appropriate clients. It controls a single keyboard and pointer and one or more screens that make up a single display.
The server can be grabbed by a single client for exclusive use. This prevents processing of any requests from other client connections until the grab is complete. This is typically a transient state for such tasks as rubber-banding, or to execute requests indivisibly.
The Intrinsics invoke a widget's set_values method when one of the widget's resource values is changed. This method should return TRUE or FALSE to indicate whether the widget's expose method should be invoked.
The set_values_almost method is invoked when a parent rejects a widget's geometry request, but the parent sends back a compromise. This method is part of the Core widget class.
A widget can provide a set_values_hook method to allow the application to set resources of subparts.
Children of the same parent window are known as sibling windows.
When a button press triggers a popup, the popup is called a spring-loaded popup.
Sibling windows may stack on top of each other, obscuring lower windows. This is similar to papers on a desk. The relationship between sibling windows is known as the stacking order. The first window in the stacking order is the window on top.
The StaticColor visual class represents a multiplane color screen with a predefined and read-only hardware colormap. It can be viewed as a degenerate case of PseudoColor. See PseudoColor.
The StaticGray visual class represents a multiplane monochrome screen with a predefined and read-only hardware colormap. It can be viewed as a degenerate case of GrayScale, in which the gray values are predefined and read-only. Typically, the values are linearly increasing ramps. See GrayScale.
A stipple is a single plane pixmap that is used to tile a region. Bits set to 1 in the stipple are drawn with a foreground pixel value; bits set to 0, with a background pixel value. The stipple and both pixel values are members of the GC.
Many Xlib functions return a status of TRUE or FALSE. If the function does not succeed, its return arguments are not disturbed.
A widget subclass has its own features plus many of the features of its superclasses. For example, since Composite is a subclass of Core, Composite has all the fields in Core plus its own unique fields. A subclass can inherit or replace most superclass features.
One widget is a superclass of a second widget when the second widget includes the first, or the Core widget is a superclass of the Composite widget because the Composite widget's definition depends on, or includes, the Core widget.
A tight binding refers to the use of a dot (.) in a resource specification to indicate that the widget class or instance on the right side of the dot is a child of the widget whose class or instance name is on the left side of it.
A pixmap can be replicated in two dimensions to tile a region. The pixmap itself is also known as a tile.
A time value in X is expressed in milliseconds, typically since the last server reset. Time values wrap around (after about 49.7 days). One time value, represented by the constant CurrentTime, is used by clients to represent the current server time.
A child of the root window is referred to as a top-level window.
A translation maps an event or event sequence into an action name. Once a translation is installed in a widget, the named action function will be invoked when the specified event sequence occurs in the widget. Translations are specified as ASCII strings.
The TrueColor visual class represents a high-performance multiplane display with predefined and read-only RGB values in its hardware colormap. It can be viewed as a degenerate case of DirectColor, in which the subfields in the pixel value directly encode the corresponding RGB values. Typically, the values are linearly increasing ramps. See DirectColor.
A type property is used to identify the interpretation of property data. Types are completely uninterpreted by the server; they are solely for the benefit of clients.
A window is viewable if it and all of its ancestors are mapped. This does not imply that any portion of the window is actually visible, since it may be obscured by other windows.
A region of a window is visible if someone looking at the screen can actually see it; that is, the window is viewable and the region is not obscured by any other window.
The specifications for color handling for a window, including visual class, depth, RGB/pixel, etc., are collectively referred to as a visual, and are stored in a structure of type Visual.
Visual class refers to DirectColor, GrayScale, PseudoColor, StaticColor, StaticGray, or TrueColor. It is a definition of the colormap type but not its depth.
The basic object in a toolkit, a widget includes both code and data, and can therefore serve as an input or output object.
When windows are resized, subwindows may be repositioned automatically by the server, relative to an edge, corner, or center of the window. This attraction of a subwindow to some part of its parent is known as window gravity. Window gravity is a window attribute. See also bit gravity.
The user manipulates windows on the screen using a window manager client. The window manager has authority over the arrangement of windows on the screen, and the user interface for selecting which window receives input. See also redirect.
The data for an image is said to be in XYPixmap format if it is organized as a set of bitmaps representing individual bit planes. This applies only to the server's internal data format for images. It does not affect normal programming with pixmaps.
The data for an image is said to be in ZPixmap format if it is organized as a set of pixel values in scan line order. This applies only to the server's internal data format for images. It does not affect normal programming with pixmaps.
Some applications have not only a normal size for their top-level window and an icon, but also a zoomed window size. This could be used in a painting program (similar to the MacPaint fat bits). The zoomed window size preferences can be specified in the window manager hints.