GdkAppLaunchContext is an implementation of GAppLaunchContext that handles launching an application in a graphical context. It provides startup notification and allows to launch applications on a specific screen or workspace.

A GdkCursor represents a cursor. Its contents are private.

The GdkDevice object represents a single input device, such as a keyboard, a mouse, a touchpad, etc.

In addition to a single pointer and keyboard for user interface input, GDK contains support for a variety of input devices, including graphics tablets, touchscreens and multiple pointers/keyboards interacting simultaneously with the user interface. Such input devices often have additional features, such as sub-pixel positioning information and additional device-dependent information.

GdkDisplay objects purpose are two fold:

The purpose of the GdkDisplayManager singleton object is to offer notification when displays appear or disappear or the default display changes.

GdkDrawingContext is an object that represents the current drawing state of a GdkWindow.

A GdkFrameClock tells the application when to update and repaint a window. This may be synced to the vertical refresh rate of the monitor, for example. Even when the frame clock uses a simple timer rather than a hardware-based vertical sync, the frame clock helps because it ensures everything paints at the same time (reducing the total number of frames). The frame clock can also automatically stop painting when it knows the frames will not be visible, or scale back animation framerates.

GdkGLContext is an object representing the platform-specific OpenGL drawing context.

A GdkKeymap defines the translation from keyboard state (including a hardware key, a modifier mask, and active keyboard group) to a keyval. This translation has two phases. The first phase is to determine the effective keyboard group and level for the keyboard state; the second phase is to look up the keycode/group/level triplet in the keymap and see what keyval it corresponds to.

GdkMonitor objects represent the individual outputs that are associated with a GdkDisplay. GdkDisplay has APIs to enumerate monitors with gdk_display_get_n_monitors() and gdk_display_get_monitor(), and to find particular monitors with gdk_display_get_primary_monitor() or gdk_display_get_monitor_at_window().

GdkScreen objects are the GDK representation of the screen on which windows can be displayed and on which the pointer moves. X originally identified screens with physical screens, but nowadays it is more common to have a single GdkScreen which combines several physical monitors (see gdk_screen_get_n_monitors()).

The GdkSeat object represents a collection of input devices that belong to a user.

A GdkVisual contains information about a particular visual.

GdkDevicePad is an interface implemented by devices of type GDK_SOURCE_TABLET_PAD, it allows querying the features provided by the pad device.

An opaque type representing a string as an index into a table of strings on the X server.

A GdkColor is used to describe a color, similar to the XColor struct used in the X11 drawing API.

deprecated: 3.14 

Contains the fields which are common to all event structs. Any event pointer can safely be cast to a pointer to a GdkEventAny to access these fields.

Used for button press and button release events. The type field will be one of GDK_BUTTON_PRESS, GDK_2BUTTON_PRESS, GDK_3BUTTON_PRESS or GDK_BUTTON_RELEASE,

Generated when a window size or position has changed.

Generated when the pointer enters or leaves a window.

Generated during DND operations.

Generated when all or part of a window becomes visible and needs to be redrawn.

Describes a change of keyboard focus.

Generated when a pointer or keyboard grab is broken. On X11, this happens when the grab window becomes unviewable (i.e. it or one of its ancestors is unmapped), or if the same application grabs the pointer or keyboard again. Note that implicit grabs (which are initiated by button presses) can also cause GdkEventGrabBroken events.

since: 2.8

Describes a key press or key release event.

Generated when the pointer moves.

Generated when the owner of a selection changes. On X11, this information is only available if the X server supports the XFIXES extension.

since: 2.6

Generated during GDK_SOURCE_TABLET_PAD interaction with tactile sensors.

since: 3.22

Generated during GDK_SOURCE_TABLET_PAD button presses and releases.

since: 3.22

Generated during GDK_SOURCE_TABLET_PAD mode switches in a group.

since: 3.22

Describes a property change on a window.

Proximity events are generated when using GDK’s wrapper for the XInput extension. The XInput extension is an add-on for standard X that allows you to use nonstandard devices such as graphics tablets. A proximity event indicates that the stylus has moved in or out of contact with the tablet, or perhaps that the user’s finger has moved in or out of contact with a touch screen.

Generated from button presses for the buttons 4 to 7. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned.

Generated when a selection is requested or ownership of a selection is taken over by another client application.

Generated when a setting is modified.

Used for touch events. type field will be one of GDK_TOUCH_BEGIN, GDK_TOUCH_UPDATE, GDK_TOUCH_END or GDK_TOUCH_CANCEL.

Generated during touchpad swipe gestures.

Generated during touchpad swipe gestures.

Generated when the window visibility status has changed.

deprecated: 3.12 

Generated when the state of a toplevel window changes.

A GdkFrameTimings object holds timing information for a single frame of the application’s displays. To retrieve GdkFrameTimings objects, use gdk_frame_clock_get_timings() or gdk_frame_clock_get_current_timings(). The information in GdkFrameTimings is useful for precise synchronization of video with the event or audio streams, and for measuring quality metrics for the application’s display, such as latency and jitter.

The GdkGeometry struct gives the window manager information about a window’s geometry constraints. Normally you would set these on the GTK+ level using gtk_window_set_geometry_hints(). GtkWindow then sets the hints on the GdkWindow it creates.

A GdkKeymapKey is a hardware key that can be mapped to a keyval.

Defines the x and y coordinates of a point.

Defines the position and size of a rectangle. It is identical to

cairo_rectangle_int_t.

A GdkRGBA is used to represent a (possibly translucent) color, in a way that is compatible with cairo’s notion of color.

A GdkTimeCoord stores a single event in a motion history.

Attributes to use for a newly-created window.

A GdkEvent contains a union of all of the event types, and allows access to the data fields in a number of ways.

Used to represent native events (XEvents for the X11 backend, MSGs for Win32).

An enumeration describing the way in which a device axis (valuator) maps onto the predefined valuator types that GTK+ understands.

A set of values describing the possible byte-orders for storing pixel values in memory.

Specifies the crossing mode for GdkEventCrossing.

Predefined cursors.

A pad feature.

Indicates the specific type of tool being used being a tablet. Such as an airbrush, pencil, etc.

since: 3.22

Indicates the device type. See [above][GdkDeviceManager.description] for more information about the meaning of these device types.

Used in GdkDragContext to the reason of a cancelled DND operation.

since: 3.20

Used in GdkDragContext to indicate the protocol according to which DND is done.

Specifies the type of the event.

Specifies the result of applying a GdkFilterFunc to a native event.

Indicates which monitor (in a multi-head setup) a window should span over when in fullscreen mode.

since: 3.8

Defines how device grabs interact with other devices.

Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to indicate success or the reason for the failure of the grab attempt.

Defines the reference point of a window and the meaning of coordinates passed to gtk_window_move(). See gtk_window_move() and the “implementation notes” section of the Extended Window Manager Hints specification for more details.

An enumeration that describes the mode of an input device.

An enumeration describing the type of an input device in general terms.

This enum is used with gdk_keymap_get_modifier_mask() in order to determine what modifiers the currently used windowing system backend uses for particular purposes. For example, on X11/Windows, the Control key is used for invoking menu shortcuts (accelerators), whereas on Apple computers it’s the Command key (which correspond to GDK_CONTROL_MASK and GDK_MOD2_MASK, respectively).

since: 3.4

Specifies the kind of crossing for GdkEventCrossing.

Specifies why a selection ownership was changed.

Specifies the type of a property change for a GdkEventProperty.

Describes how existing data is combined with new data when using gdk_property_change().

Specifies the direction for GdkEventScroll.

Specifies the kind of modification applied to a setting in a GdkEventSetting.

This enumeration describes how the red, green and blue components of physical pixels on an output device are laid out.

since: 3.22

Specifies the current state of a touchpad gesture. All gestures are guaranteed to begin with an event with phase GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events with phase GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.

Specifies the visiblity status of a window for a GdkEventVisibility.

A set of values that describe the manner in which the pixel values for a visual are converted into RGB values for display.

Determines a window edge or corner.

Describes the kind of window.

These are hints for the window manager that indicate what type of function the window has. The window manager can use this when determining decoration and behaviour of the window. The hint must be set before mapping the window.

GDK_INPUT_OUTPUT windows are the standard kind of window you might expect. Such windows receive events and are also displayed on screen. GDK_INPUT_ONLY windows are invisible; they are usually placed above other windows in order to trap or filter the events. You can’t draw on GDK_INPUT_ONLY windows.

Positioning hints for aligning a window relative to a rectangle.

since: 3.22

Flags describing the current capabilities of a device/tool.

since: 3.22

Used in GdkDragContext to indicate what the destination should do with the dropped data.

A set of bit-flags to indicate which events a window is to receive. Most of these masks map onto one or more of the GdkEventType event types above.

GdkFrameClockPhase is used to represent the different paint clock phases that can be requested. The elements of the enumeration correspond to the signals of GdkFrameClock.

since: 3.8

A set of bit-flags to indicate the state of modifier keys and mouse buttons in various event types. Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.

Flags describing the seat capabilities.

since: 3.20

Used to indicate which fields in the GdkWindowAttr struct should be honored. For example, if you filled in the “cursor” and “x” fields of GdkWindowAttr, pass “GDK_WA_X | GDK_WA_CURSOR” to gdk_window_new(). Fields in GdkWindowAttr not covered by a bit in this enum are required; for example, the width/height, wclass, and window_type fields are required, they have no corresponding flag in GdkWindowAttributesType.

Used to indicate which fields of a GdkGeometry struct should be paid attention to. Also, the presence/absence of GDK_HINT_POS, GDK_HINT_USER_POS, and GDK_HINT_USER_SIZE is significant, though they don’t directly refer to GdkGeometry fields. GDK_HINT_USER_POS will be set automatically by GtkWindow if you call gtk_window_move(). GDK_HINT_USER_POS and GDK_HINT_USER_SIZE should be set if the user specified a size/position using a —geometry command-line argument; gtk_window_parse_geometry() automatically sets these flags.

Specifies the state of a toplevel window.

These are hints originally defined by the Motif toolkit. The window manager can use them when determining how to decorate the window. The hint must be set before mapping the window.

These are hints originally defined by the Motif toolkit. The window manager can use them when determining the functions to offer for the window. The hint must be set before mapping the window.

Error enumeration for GdkGLContext.

since: 3.16

Specifies the type of function passed to gdk_event_handler_set() to handle all GDK events.

Specifies the type of function used to filter native events before they are converted to GDK events.

Type of the callback used to set up window so it can be grabbed. A typical action would be ensuring the window is visible, although there’s room for other initialization actions.

since: 3.20

A function of this type is passed to gdk_window_invalidate_maybe_recurse(). It gets called for each child of the window to determine whether to recursively invalidate it or now.

Whenever some area of the window is invalidated (directly in the window or in a child window) this gets called with region in the coordinate space of window. You can use region to just keep track of the dirty region, or you can actually change region in case you are doing display tricks like showing a child in multiple places.

since: 3.10

Appends gdk option entries to the passed in option group. This is not public API and must not be used by applications.

deprecated: 3.16 

Emits a short beep on the default display.

Creates a Cairo context for drawing to window.

deprecated: 3.22 since: 2.8

This is the main way to draw GL content in GTK+. It takes a render buffer ID (source_type == #GL_RENDERBUFFER) or a texture id (source_type == #GL_TEXTURE) and draws it onto cr with an OVER operation, respecting the current clip. The top left corner of the rectangle specified by x, y, width and height will be drawn at the current (0,0) position of the cairo_t.

since: 3.16

This is a convenience function around cairo_clip_extents(). It rounds the clip extents to integer coordinates and returns a boolean indicating if a clip area exists.

Retrieves the GdkDrawingContext that created the Cairo context cr.

since: 3.22

Adds the given rectangle to the current path of cr.

since: 2.8

Adds the given region to the current path of cr.

since: 2.8

Creates region that describes covers the area where the given surface is more than 50% opaque.

Sets the specified GdkColor as the source color of cr.

deprecated: 3.4 since: 2.8

Sets the given pixbuf as the source pattern for cr.

since: 2.8

Sets the specified GdkRGBA as the source color of cr.

since: 3.0

Sets the given window as the source pattern for cr.

since: 2.24

Creates an image surface with the same contents as the pixbuf.

since: 3.10

Disables multidevice support in GDK. This call must happen prior to gdk_display_open(), gtk_init(), gtk_init_with_args() or gtk_init_check() in order to take effect.

since: 3.0

Aborts a drag without dropping.

Starts a drag and creates a new drag context for it. This function assumes that the drag is controlled by the client pointer device, use gdk_drag_begin_for_device() to begin a drag with a different device.

Starts a drag and creates a new drag context for it.

Starts a drag and creates a new drag context for it.

since: 3.20

Drops on the current destination.

Inform GDK if the drop ended successfully. Passing FALSE for success may trigger a drag cancellation animation.

since: 3.20

Returns whether the dropped data has been successfully transferred. This function is intended to be used while handling a GDK_DROP_FINISHED event, its return value is meaningless at other times.

since: 2.6

Finds the destination window and DND protocol to use at the given pointer position.

since: 2.2

Returns the selection atom for the current source window.

Updates the drag context when the pointer moves or the set of actions changes.

Selects one of the actions offered by the drag source.

Ends the drag operation after a drop.

Accepts or rejects a drop.

Removes an error trap pushed with gdk_error_trap_push(). May block until an error has been definitively received or not received from the X server. gdk_error_trap_pop_ignored() is preferred if you don’t need to know whether an error occurred, because it never has to block. If you don’t need the return value of gdk_error_trap_pop(), use gdk_error_trap_pop_ignored().

Removes an error trap pushed with gdk_error_trap_push(), but without bothering to wait and see whether an error occurred. If an error arrives later asynchronously that was triggered while the trap was pushed, that error will be ignored.

since: 3.0

This function allows X errors to be trapped instead of the normal behavior of exiting the application. It should only be used if it is not possible to avoid the X error in any other way. Errors are ignored on all GdkDisplay currently known to the GdkDisplayManager. If you don’t care which error happens and just want to ignore everything, pop with gdk_error_trap_pop_ignored(). If you need the error code, use gdk_error_trap_pop() which may have to block and wait for the error to arrive from the X server.

If both events contain X/Y information, this function will return TRUE and return in angle the relative angle from event1 to event2. The rotation direction for positive angles is from the positive X axis towards the positive Y axis.

since: 3.0

If both events contain X/Y information, the center of both coordinates will be returned in x and y.

since: 3.0

If both events have X/Y information, the distance between both coordinates (as in a straight line going from event1 to event2) will be returned.

since: 3.0

Checks if any events are ready to be processed for any display.

Flushes the output buffers of all display connections and waits until all requests have been processed. This is rarely needed by applications.

Obtains the root window (parent all other windows are inside) for the default display and screen.

Gets the name of the display, which usually comes from the DISPLAY environment variable or the --display command line option.

deprecated: 3.8 

Gets the display name specified in the command line arguments passed to gdk_init() or gdk_parse_args(), if any.

since: 2.2

Gets the program class. Unless the program class has explicitly been set with gdk_set_program_class() or with the --class commandline option, the default value is the program name (determined with g_get_prgname()) with the first character converted to uppercase.

Gets whether event debugging output is enabled.

Initializes the GDK library and connects to the windowing system. If initialization fails, a warning message is output and the application terminates with a call to exit(1).

Initializes the GDK library and connects to the windowing system, returning TRUE on success.

Grabs the keyboard so that all events are passed to this application until the keyboard is ungrabbed with gdk_keyboard_ungrab(). This overrides any previous keyboard grab by this client.

deprecated: 3.0 

Ungrabs the keyboard on the default display, if it is grabbed by this application.

deprecated: 3.0 

Obtains the upper- and lower-case versions of the keyval symbol. Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.

Converts a key name to a key value.

Returns TRUE if the given key value is in lower case.

Returns TRUE if the given key value is in upper case.

Converts a key value into a symbolic name.

Converts a key value to lower case, if applicable.

Convert from a GDK key symbol to the corresponding ISO10646 (Unicode) character.

Converts a key value to upper case, if applicable.

Lists the available visuals for the default screen. (See gdk_screen_list_visuals()) A visual describes a hardware image data format. For example, a visual might support 24-bit color, or 8-bit color, and might expect pixels to be in a certain format.

deprecated: 3.22 

Indicates to the GUI environment that the application has finished loading. If the applications opens windows, this function is normally called after opening the application’s initial set of windows.

since: 2.2

Indicates to the GUI environment that the application has finished loading, using a given identifier.

since: 2.12

Gets the window that window is embedded in.

since: 2.18

Gets the offscreen surface that an offscreen window renders into. If you need to keep this around over window resizes, you need to add a reference to it.

Sets window to be embedded in embedder.

since: 2.18

Creates a PangoContext for the default GDK screen.

Creates a PangoContext for display.

since: 3.22

Creates a PangoContext for screen.

since: 2.2

Obtains a clip region which contains the areas where the given ranges of text would be drawn. x_origin and y_origin are the top left point to center the layout. index_ranges should contain ranges of bytes in the layout’s text.

Obtains a clip region which contains the areas where the given ranges of text would be drawn. x_origin and y_origin are the top left position of the layout. index_ranges should contain ranges of bytes in the layout’s text. The clip region will include space to the left or right of the line (to the layout bounding box) if you have indexes above or below the indexes contained inside the line. This is to draw the selection all the way to the side of the layout. However, the clip region is in line coordinates, not layout coordinates.

Parse command line arguments, and store for future use by calls to gdk_display_open().

since: 2.2

Transfers image data from a #cairo_surface_t and converts it to an RGB(A) representation inside a GdkPixbuf. This allows you to efficiently read individual pixels from cairo surfaces. For GdkWindows, use gdk_pixbuf_get_from_window() instead.

Transfers image data from a GdkWindow and converts it to an RGB(A) representation inside a GdkPixbuf. In other words, copies image data from a server-side drawable to a client-side RGB(A) buffer. This allows you to efficiently read individual pixels on the client side.

Grabs the pointer (usually a mouse) so that all events are passed to this application until the pointer is ungrabbed with gdk_pointer_ungrab(), or the grab window becomes unviewable. This overrides any previous pointer grab by this client.

deprecated: 3.0 

Returns TRUE if the pointer on the default display is currently grabbed by this application.

deprecated: 3.0 

Ungrabs the pointer on the default display, if it is grabbed by this application.

deprecated: 3.0 

Prepare for parsing command line arguments for GDK. This is not public API and should not be used in application code.

deprecated: 3.16 

Changes the contents of a property on a window.

Deletes a property from a window.

Retrieves a portion of the contents of a property. If the property does not exist, then the function returns FALSE, and GDK_NONE will be stored in actual_property_type.

This function returns the available bit depths for the default screen. It’s equivalent to listing the visuals (gdk_list_visuals()) and then looking at the depth field in each visual, removing duplicates.

deprecated: 3.22 

This function returns the available visual types for the default screen. It’s equivalent to listing the visuals (gdk_list_visuals()) and then looking at the type field in each visual, removing duplicates.

deprecated: 3.22 

Retrieves the contents of a selection in a given form.

Determines the owner of the given selection.

Determine the owner of the given selection.

since: 2.2

Sets the owner of the given selection.

Sets the GdkWindow owner as the current owner of the selection selection.

since: 2.2

Retrieves selection data that was stored by the selection data in response to a call to gdk_selection_convert(). This function will not be used by applications, who should use the GtkClipboard API instead.

Sends a response to SelectionRequest event.

Send a response to SelectionRequest event.

since: 2.2

Sets a list of backends that GDK should try to use.

since: 3.10

Set the double click time for the default display. See gdk_display_set_double_click_time(). See also gdk_display_set_double_click_distance(). Applications should not set this, it is a global user-configured setting.

Sets the program class. The X11 backend uses the program class to set the class name part of the WM_CLASS property on toplevel windows; see the ICCCM.

Sets whether a trace of received events is output. Note that GTK+ must be compiled with debugging (that is, configured using the --enable-debug option) to use this option.

Obtains a desktop-wide setting, such as the double-click time, for the default screen. See gdk_screen_get_setting().

Retrieves a pixel from window to force the windowing system to carry out any pending rendering commands.

since: 2.14

This function is intended to be used in GTK+ test programs. It will warp the mouse pointer to the given (x,y) coordinates within window and simulate a button press or release event. Because the mouse pointer needs to be warped to the target location, use of this function outside of test programs that run in their own virtual windowing system (e.g. Xvfb) is not recommended.

since: 2.14

This function is intended to be used in GTK+ test programs. If (x,y) are > (-1,-1), it will warp the mouse pointer to the given (x,y) coordinates within window and simulate a key press or release event.

since: 2.14

Converts a text property in the given encoding to a list of UTF-8 strings.

since: 2.2

A wrapper for the common usage of gdk_threads_add_idle_full() assigning the default priority, #G_PRIORITY_DEFAULT_IDLE.

since: 2.12

Adds a function to be called whenever there are no higher priority events pending. If the function returns FALSE it is automatically removed from the list of event sources and will not be called again.

since: 2.12

A wrapper for the common usage of gdk_threads_add_timeout_full() assigning the default priority, #G_PRIORITY_DEFAULT.

since: 2.12

Sets a function to be called at regular intervals holding the GDK lock, with the given priority. The function is called repeatedly until it returns FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The notify function is called when the timeout is destroyed. The first call to the function will be at the end of the first interval.

since: 2.12

A wrapper for the common usage of gdk_threads_add_timeout_seconds_full() assigning the default priority, #G_PRIORITY_DEFAULT.

since: 2.14

A variant of gdk_threads_add_timeout_full() with second-granularity. See g_timeout_add_seconds_full() for a discussion of why it is a good idea to use this function if you don’t need finer granularity.

since: 2.14

This function marks the beginning of a critical section in which GDK and GTK+ functions can be called safely and without causing race conditions. Only one thread at a time can be in such a critial section.

deprecated: 3.6 

Initializes GDK so that it can be used from multiple threads in conjunction with gdk_threads_enter() and gdk_threads_leave().

deprecated: 3.6 

Leaves a critical region begun with gdk_threads_enter().

deprecated: 3.6 

Allows the application to replace the standard method that GDK uses to protect its data structures. Normally, GDK creates a single GMutex that is locked by gdk_threads_enter(), and released by gdk_threads_leave(); using this function an application provides, instead, a function enter_fn that is called by gdk_threads_enter() and a function leave_fn that is called by gdk_threads_leave().

deprecated: 3.6 since: 2.4

Convert from a ISO10646 character to a key symbol.

Converts an UTF-8 string into the best possible representation as a STRING. The representation of characters not in STRING is not specified; it may be as pseudo-escape sequences \x{ABCD}, or it may be in some other form of approximation.

Converts a GdkAtom into a pointer type.

Extracts a GdkAtom from a pointer. The GdkAtom must have been stored in the pointer with GDK_ATOM_TO_POINTER().

The middle button.

The primary button. This is typically the left mouse button, or the right button in a left-handed setup.

The secondary button. This is typically the right mouse button, or the left button in a left-handed setup.

Represents the current time, and can be used anywhere a time is expected.

Use this macro as the return value for continuing the propagation of an event handler.

Use this macro as the return value for stopping the propagation of an event handler.