This version of this document is no longer maintained. For the latest documentation, see http://www.qnx.com/developers/docs.

Glossary

accelerator: See hotkey.
activate: A widget is usually activated when you release a mouse button while pointing at an armed widget.
active window: The window that currently has focus.
anchor offset: The distance between the edges of a widget and the parent widget it's anchored to.
anchor: A constraint mechanism used to manage what happens to a widget when its parent is expanded or contracted. For example, a pane that's anchored to the sides of a window expands or contracts as the window's size is changed.
application region: A region that belongs to a Photon application (as opposed to a Photon system process, such as the window manager, graphics drivers, etc.). An application region is usually placed behind the device region. Also called a window region.
argument list: An array of type PtArg_t used when setting and getting widget resources.
arm: A widget is usually armed when you press a mouse button while pointing at it.
backdrop: An image that's displayed as a background on your screen.
backdrop region: A region placed behind all windows to display a background image.
balloon: A small box that pops up to define or explain part of the user interface. A balloon is displayed when the pointer pauses over a widget.
bitmap: A color picture consisting of one or more bitplanes.
bitplane: An array of bits representing pixels of a single color in a bitmap.
blit: An operation that moves an area of a graphics context (e.g. the screen) to another area on the same or a different context.
callback: A callback function or a callback resource.
callback function: Code connecting an application's user interface to its code. For example, a callback is invoked when you press a button.
callback resource: A resource that specifies a list of functions and their client data to be called when a certain action occurs.
canvas: The part of a widget that's used for drawing. For PtWidget, this is the area inside the widget's borders. For PtBasic and its descendants, the canvas is the area inside the widget's border and margins. Other widgets, such as PtLabel, may define additional margins.
class: See widget class.
class hierarchy: The relationships between all of the widget classes.
client data: Any arbitrary data the application may need to provide to a callback function.
clipping list: An array of rectangles used to restrict output to a particular area.
clipping rectangle: A rectangle used to restrict output to a particular area.
CMY value: A color expressed as levels of cyan, magenta, and yellow.
CMYK value: A color expressed as levels of cyan, magenta, yellow, and black.
code-type link callback: In a PhAB application, an application function that's called when a widget's callback list is invoked.
color depth: The number of bits per pixel for a screen or pixmap.
Common User Access: See CUA.
compose sequence: A sequence of key presses that can be used to type a character that might not appear on the keyboard.
console: One of nine virtual screens on the desktop. Also called a workspace.
consume: When a widget has processed an event and prevents another widget from interacting with the event, the first widget is said to have consumed the event.
container: A widget that can have other widgets as children. For example, PtWindow, PtGroup, and PtOSContainer.
cooked event: A key or pointer event that has been assigned a location in the Photon event space. Also called a focused event.
CUA: Common User Access -- a standard that defines how you can change focus by using the keyboard.
current item: The item in a list or tree widget that will be selected (or perhaps unselected) when you press Enter or Space. It's typically drawn with a blue dotted line around it when its widget has focus.
cursor: An indicator of a position on a screen, such as a pointer or an insertion point in a text field.
damaged: Whenever a widget needs to be redisplayed due to a change in the window (e.g. the widget is changed, moved, or realized), it's said to be damaged.
dead key: A key that, when pressed, doesn't produce a symbol, but initiates a compose sequence.
default placement: The placement of a region when no siblings are specified. The opposite of specific placement.
desktop: The virtual screen, consisting of nine consoles or workspaces.
device region: The region located in the middle of the event space, with application regions behind it and driver regions in front of it (from the user's point of view).
dialog module: A PhAB module similar to a window module, except that a dialog module can have only one instance per process.
direct-color: A color scheme in which each pixel is represented by an RGB value. Contrast palette-based.
disjoint parent: A disjoint widget that's the ancestor of another widget.
disjoint widget: A widget that can exist without a parent. If a disjoint widget has a parent, it can exist outside its parent's canvas. For example, PtWindow, PtMenu, and PtRegion are disjoint widgets, but PtButton, PtBkgd, and PtRect aren't.
A disjoint widget owns regions that aren't children of its parent's regions. Any clipping set by the parent of a disjoint widget isn't applied to the disjoint widget. The regions of disjoint widgets are sensitive and opaque to expose events.
dithering: A process whereby pixels of two colors are combined to create a texture or a blended color.
draw context: A structure that defines the flow of the draw stream. The default draw context emits draw events to graphics drivers. Print contexts and memory contexts are types of draw contexts.
draw stream: A series of tokens that are dispatched via draw events and can be collected by a rendering engine such as a graphics driver.
driver region: A region created by a driver, usually placed in front of the device region.
encapsulation driver: A program that displays Photon graphical output inside another windowing system such as the X Window System.
event: A data structure that represents an interaction between you and an application or between applications. Events travel through the event space either toward you or away (i.e. toward the root region).
event compression: The merging of events such that the application sees only their latest values. The application doesn't have to process many unnecessary events.
event handler: A callback function that lets an application respond directly to Photon events, such as dragging events.
event mask: A set of event types that are of interest to an event handler. When one of these events occurs, the event handler is invoked.
event space: An abstract, three-dimensional space that contains regions -- from the root region at the back to the graphics region at the front. You sit outside the event space, looking in from the front. Events travel through the event space either toward the root region or toward you.
exported subordinate child: A widget created by a container widget (as opposed to an application) whose resources you can access only through the parent.
exposure: Typically occurs when a region is destroyed, resized, or moved. Expose events are sent to applications to inform them when the contents of their regions need to be redisplayed.
extent: A rectangle that describes the outermost edges of a widget.
File Manager: The Photon File Manager (PFM), an application used to maintain and organize files and directories.
focus: A widget that has focus will receive any key events collected by its window.
focus region: A region placed just behind the device region by the Photon Window Manager that lets it intercept key events and direct them to the active window.
focused event: A key or pointer event that has been assigned a location in the Photon event space. Also called a cooked event.
folder: In the Photon File Manager, a metaphor for a directory.
GC: See graphics context.
geometry negotiation: The process of determining the layout for a widget and its descendants, which depends on the widget's layout policy, any size set for the widget, and the dimensions and desired positions of each of the widget's children.
global header file: A header file that's included in all code generated by PhAB for an application. The global header file is specified in PhAB's Application Startup Information dialog.
graphics driver: A program that places a region that's sensitive to draw events on the user's side of the device region, collects draw events, and renders the graphical information on the screen.
graphics context (GC): A data structure that defines the characteristics of primitives, including foreground color, background color, line width, clipping, etc.
Helpviewer: A Photon application for viewing online documentation.
hotkey: A special key or keychord that invokes an action (such as a menu item) without actually selecting a widget. Also called an accelerator. Contrast keyboard shortcut.
hotspot: The part of the pointer that corresponds to the coordinates reported for the pointer (e.g. the intersection of crosshairs, or the tip of the arrow of the basic pointer).
HSB: Hue-Saturation-Brightness color model.
HSV: Hue-Saturation-Value color model.
icon module: A PhAB module that associates icons with an application.
image: A rectangular array of color values, where each element represents a single pixel. See also direct-color and palette-based.
initialization function: In a PhAB application, a function that's called before any widgets are created.
input driver: A program that emits, and is the source of, key and/or pointer events.
input group: A set of input and output devices. There's typically one input group per user.
input handler (or input-handling function): A function that's hooked into Photon's main event-processing loop to handle messages and pulses sent to the application by other processes.
instance: A concrete example of an abstract class; for example, "Lassie" is an instance of the class "dog." In Photon, an instance is usually a widget instance; for example, a pushbutton is an instance of the PtButton widget class. When an instance of a widget is created, the initial values of its resources are assigned.
instance name: In PhAB, a string that identifies a particular instance of a widget so that you can access the instance in your application's code.
instantiation: The action of creating an instance of a widget class in an application.
internal link: A PhAB mechanism that lets a developer access a PhAB module directly from an application's code.
Image Viewer: A Photon application (pv) that displays images.
key modifier: A flag in a key event that indicates the state of the corresponding modifier key when another key was pressed.
keyboard driver: A program that gets information from the keyboard hardware, builds Photon key events, and emits them towards the root region.
keyboard shortcut: A key that selects a menu item. The shortcut works only if the menu is displayed. Contrast hotkey.
language database: A file that contains the text strings used in a PhAB application; a language database makes it easier to create multilingual applications with PhAB's language editor.
link callback: A mechanism that connects different parts of a PhAB application. For example, a link callback can be invoked to display a dialog when a button is pressed.
margin: The area between a widget's border and canvas.
memory context: A draw context in which Photon draw events are directed to memory for future displaying on the screen, as opposed to a printer (print context) or to the screen directly (the default draw context).
menu module: A PhAB module used to create a menu.
method: A function that's internal to a widget class and invoked under specific conditions (e.g. to draw the widget). Methods are provided as pointers to functions in widget class records.
modifier key: A key (such as Shift, Alt, or Ctrl) used to change the meaning of another key.
module: An object in PhAB that holds an application's widgets. PhAB modules include windows, menus, icons, pictures, and dialogs.
module-type link callback: A link callback that displays a PhAB module.
mouse driver: A program that gets information from the pointer hardware, builds Photon raw pointer events, and emits them towards the root region.
opaque: The state of a region with regard to events. If a region is opaque to an event type, any event of that type that intersects with the region has its rectangle set adjusted to clip out the intersecting area. The region prevents the event from passing through.
palette: An array of colors. A hard palette is in hardware; a soft palette is in software.
palette-based: A color scheme in which each pixel is represented by an index into a palette. Contrast direct-color.
PDR: See Press-drag-release.
PFM: See Photon File Manager.
PhAB: Photon Application Builder. Visual design tool that generates the code required to implement a user interface.
phditto: A utility that accesses the Photon workspace on a remote node. See also ditto.
Phindows: Photon in Windows. An application that accesses a Photon session from a Microsoft Windows environment.
Photon File Manager (PFM): An application used to maintain and organize files and directories.
Photon Manager or server: The program that maintains the Photon event space by managing regions and events.
Photon Terminal: An application (pterm) that emulates a character-mode terminal in a Photon window.
Photon Window Manager (PWM): An application that manages the appearance of window frames and other objects on the screen. For example, the window manager adds the resize bars, title bar, and various buttons to an application's window. The window manager also provides a method of focusing keyboard events.
picture module: A PhAB module that contains an arrangement of widgets that can be displayed in another widget or used as a widget database.
pixmap: A bitmap or image.
plane mask: A mask used to restrict graphics operations to affect only a subset of color bits.
point source: A single-point rectangle set used as the source of an event.
pointer: An object on the screen that tracks the position of a pointing device (e.g. a mouse, tablet, track-ball, or joystick). Photon has several pointers indicating various states: Basic, Busy, Help, Move, Resize, I-beam, No-input.
Press-drag-release (PDR): A method of selecting a menu item by pressing down a mouse button while pointing to a menu button, dragging until the desired item is highlighted, and releasing the mouse button.
print context: A draw context in which Photon draw events are directed to a file, as opposed to the screen (the default draw context) or to memory (memory context).
printer driver: A program that converts Photon draw stream format into a format suitable for a printer, including PostScript, Hewlett-Packard PCL, and Canon.
procreated widget: A widget created by another widget (as opposed to an application), such as the PtList and PtText created by a PtComboBox. Also known as a subordinate child.
pterm: A Photon Terminal; an application that emulates a character-mode terminal in a Photon window.
pulse: A small message that doesn't require a reply; used for asynchronous communication with a Photon application.
pv: See Image Viewer.
PWM: See Photon Window Manager.
raw event: An input event that hasn't been assigned a location in the Photon event space. Also called an unfocused event.
raw callback: A function that lets an application respond directly to Photon events such as dragging events. Also called an event handler.
realize: To display a widget and its descendants, possibly making them interactive.
rectangle set: An array of nonoverlapping rectangles associated with an event.
region: A rectangular area within the Photon event space that's used by an application for collecting and emitting events.
resize policy: A rule that governs how a widget resizes itself when its contents change.
resource: An attribute of a widget, such as fill color, dimensions, or a callback list.
root region: The region at the very back of the Photon event space.
sensitive: The state of a region with regard to events. If a region is sensitive to a particular type of event, the region's owner collects a copy of any such event that intersects with the region.
setup function: A function that's called after a PhAB module is created.
shelf: An application that attaches areas to the outside edge of the screen. You can add plugins to customize these areas, such as a taskbar, launcher, clock, and magnifier.
Snapshot: A Photon application for capturing images of the screen.
specific placement: The placement of a region when one or more siblings are specified. The opposite of default placement.
subordinate child: A widget created by another widget (as opposed to an application), such as the PtList and PtText created by a PtComboBox. Also known as a procreated widget.
table-of-contents (TOC) file: In the Photon Helpviewer, a file that describes a hierarchy of help topics.
taskbar: A shelf plugin that displays icons representing the applications that are currently running.
tile: A data structure used to build linked lists of rectangles, such as a list of the damaged parts of an interface.
topic path: Help information identified by a string of titles that are separated by slashes.
topic root: A topic path that's used as a starting point for locating help topics.
topic tree: A hierarchy of help information.
translation file: A file containing translated strings for a PhAB application. There's one translation file per language supported by the application.
unfocused event: See raw event.
Unicode: The ISO/IEC 10646 16-bit encoding scheme for representing the characters used in most languages.
UTF-8: The encoding for Unicode characters, where each character is represented by one, two, or three bytes.
widget: A component (e.g. a pushbutton) in a graphical user interface.
widget class: A template for widgets that perform similar functions and provide the same public interface. For example, PtButton is a widget class.
widget database: In PhAB, a module containing widgets that can be copied at any time into a window, dialog, or other container.
widget family: A hierarchy of widget instances. For example, a window and the widgets it contains.
widget instance: See instance.
window frame region: A region that PWM adds to a window. It lets you move, resize, iconify, and close the window.
Window Manager: See Photon Window Manager.
window module: A PhAB module that's instantiated as a PtWindow widget.
window region: A region that belongs to an application window.
work procedure: A function that's invoked when there are no Photon events pending for an application.
workspace: See console.
workspace menu: A configurable menu that's displayed when you press or click the right mouse button while pointing at the background of the desktop.