Screen library reference

Two important aspects to note when using Screen are function safety and function execution types.

Function safety

Function safety refers to the situations under which it is safe to use the Screen API functions.

Function execution types

Function execution refers to the execution timeliness of the Screen API functions. See Function execution types for more information.

Function safety
Function safety refers to whether or not it's safe to use the Screen API functions in certain situations.
Function types
The tables in this section list the type of each function, where the type indicates the expected timeliness of each function call.
General (screen.h)
Constants and Datatypes that are applicable to multiple Screen API objects.
Blits (screen.h)
Blit APIs are native rendering APIs that use the hardware blitter to move data from one area of memory to another without involving the CPU.
Buffers (screen.h)
A buffer is an area of memory that stores pixel data. Although a buffer can be created in the scope of a context, it can't be used by Screen unless it's attached to a window, stream, or pixmap. Multiple buffers can be associated with a window or stream, but only one buffer can be associated with a pixmap.
Contexts (screen.h)
A context provides the setting for graphics operations within Screen. All Screen API objects, with the exception of events, are created within the scope of a context and access to these objects is always with respect to the context associated with the object. Through using a handle to a context, you can identify and gain access to the certain Screen API objects (e.g., windows, groups, displays, pixmaps) to set or change their properties.
Debugging (screen.h)
Screen provides statistics that can be enabled to facilitate debugging your applications.
Devices (screen.h)
A device refers to an input device (e.g., keyboard, mouse, joystick, multi-touch display).
Displays (screen.h)
A display refers to a physical device, such as a touchscreen, that presents images to viewers. Use this handle to gain access to display properties (e.g., brightness, DPI, video mode).
Events (screen.h)
A Screen event notifies applications of actions such as window creations, properties changing values, and keyboard events. The Screen API manages one event queue per context. However, you can also create an event that's independent of any association with a context.
Groups (screen.h)
A group is used to organize and manage multiple windows in your applications. Groups establish relationships between properties of the windows belonging to the same group; therefore applying changes to some properties of the group has an effect on all windows belonging to that group.
Pixmaps (screen.h)
A pixmap is an off-screen rendering target. Its contents can be made visible by association with a window.
Sessions (screen.h)
An input session (session) receives one specific type of input events. Unlike windows, sessions don't produce any graphical content and can't be placed into groups. The only grouping that could be considered for a session is the one that's been established for the window that the session is associated with.
Streams (screen.h)
A stream allows graphical content to be produced and processed by components. With streams, it's not necessary to associate their content to a display. The content can be consumed by components other than Screen. However, these components can still use Screen to display the content.
Windows (screen.h)
A window represents a drawing surface whose content is targeted to a display. There are multiple types of windows (e.g, application, child, embedded) to accommodate the organization of the content for display.