An opaque type representing a string as an index into a table of strings on the X server.
Used to represent native events (XEvents for the X11 backend, MSGs for Win32).
Positioning hints for aligning a window relative to a rectangle.
Flags describing the current capabilities of a device/tool.
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.
Indicates the device type. See aboveGdkDeviceManager.description for more information about the meaning of these device types.
Used in #GdkDragContext to indicate what the destination should do with the dropped data.
Used in #GdkDragContext to the reason of a cancelled DND operation.
Used in #GdkDragContext to indicate the protocol according to which DND is done.
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.
Specifies the type of the event.
Specifies the result of applying a #GdkFilterFunc to a native event.
#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.
Indicates which monitor (in a multi-head setup) a window should span over when in fullscreen mode.
Error enumeration for #GdkGLContext.
Defines how device grabs interact with other devices.
Returned by gdk.device.Device.grab, gdk.global.pointerGrab and gdk.global.keyboardGrab 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.Window.move. See gtk.window.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.Keymap.getModifierMask 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.types.ModifierType.ControlMask and gdk.types.ModifierType.Mod2Mask, respectively).
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.
Specifies the kind of crossing for #GdkEventCrossing.
Specifies why a selection ownership was changed.
Describes how existing data is combined with new data when using gdk.global.propertyChange.
Specifies the type of a property change for a #GdkEventProperty.
Specifies the direction for #GdkEventScroll.
Flags describing the seat capabilities.
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.
Specifies the current state of a touchpad gesture. All gestures are guaranteed to begin with an event with phase gdk.types.TouchpadGesturePhase.Begin, followed by 0 or several events with phase gdk.types.TouchpadGesturePhase.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.
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.
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.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.
Determines a window edge or corner.
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.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.Window.parseGeometry automatically sets these flags.
Specifies the state of a toplevel window.
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.
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 #GdkColor is used to describe a color, similar to the XColor struct used in the X11 drawing API.
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.
#GdkDevicePad is an interface implemented by devices of type gdk.types.InputSource.TabletPad, it allows querying the features provided by the pad device.
#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.
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.types.EventType.ButtonPress, gdk.types.EventType._2buttonPress, gdk.types.EventType._3buttonPress or gdk.types.EventType.ButtonRelease,
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.
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.
Generated during gdk.types.InputSource.TabletPad interaction with tactile sensors.
Generated during gdk.types.InputSource.TabletPad button presses and releases.
Generated during gdk.types.InputSource.TabletPad mode switches in a group.
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.types.EventType.TouchBegin, gdk.types.EventType.TouchUpdate, gdk.types.EventType.TouchEnd or gdk.types.EventType.TouchCancel.
Generated during touchpad swipe gestures.
Generated during touchpad swipe gestures.
Generated when the window visibility status has changed.
Generated when the state of a toplevel window changes.
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.
A #GdkFrameTimings object holds timing information for a single frame of the application’s displays. To retrieve #GdkFrameTimings objects, use gdk.frame_clock.FrameClock.getTimings or gdk.frame_clock.FrameClock.getCurrentTimings. 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.
#GdkGLContext is an object representing the platform-specific OpenGL drawing context.
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.Window.setGeometryHints. #GtkWindow then sets the hints on the #GdkWindow it creates.
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.
A #GdkKeymapKey is a hardware key that can be mapped to a keyval.
GdkMonitor objects represent the individual outputs that are associated with a #GdkDisplay. GdkDisplay has APIs to enumerate monitors with gdk.display.Display.getNMonitors and gdk.display.Display.getMonitor, and to find particular monitors with gdk.display.Display.getPrimaryMonitor or gdk.display.Display.getMonitorAtWindow.
Defines the x and y coordinates of a point.
A #GdkRGBA is used to represent a (possibly translucent) color, in a way that is compatible with cairo’s notion of color.
Defines the position and size of a rectangle. It is identical to #cairo_rectangle_int_t.
#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.Screen.getNMonitors).
The #GdkSeat object represents a collection of input devices that belong to a user.
A #GdkTimeCoord stores a single event in a motion history.
A #GdkVisual contains information about a particular visual.
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.
C types for gdk3 library