| Top | |
|
|
|
| void | after-paint | Run Last |
| void | before-paint | Run Last |
| void | flush-events | Run Last |
| void | layout | Run Last |
| void | paint | Run Last |
| void | resume-events | Run Last |
| void | update | Run Last |
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.
GdkFrameClock is designed to be compatible with an OpenGL-based implementation or with mozRequestAnimationFrame in Firefox, for example.
A frame clock is idle until someone requests a frame with
gdk_frame_clock_request_phase(). At some later point that makes
sense for the synchronization being implemented, the clock will
process a frame and emit signals for each phase that has been
requested. (See the signals of the GdkFrameClock class for
documentation of the phases. GDK_FRAME_CLOCK_PHASE_UPDATE and the
“update” signal are most interesting for application
writers, and are used to update the animations, using the frame time
given by gdk_frame_clock_get_frame_time().
The frame time is reported in microseconds and generally in the same
timescale as g_get_monotonic_time(), however, it is not the same
as g_get_monotonic_time(). The frame time does not advance during
the time a frame is being painted, and outside of a frame, an attempt
is made so that all calls to gdk_frame_clock_get_frame_time() that
are called at a “similar” time get the same value. This means that
if different animations are timed by looking at the difference in
time between an initial value from gdk_frame_clock_get_frame_time()
and the value inside the “update” signal of the clock,
they will stay exactly synchronized.
gint64
gdk_frame_clock_get_frame_time (GdkFrameClock *frame_clock);
Gets the time that should currently be used for animations. Inside the processing of a frame, it’s the time used to compute the animation position of everything in a frame. Outside of a frame, it's the time of the conceptual “previous frame,” which may be either the actual previous frame time, or if that’s too old, an updated time.
Since: 3.8
void gdk_frame_clock_request_phase (GdkFrameClock *frame_clock,GdkFrameClockPhase phase);
Asks the frame clock to run a particular phase. The signal
corresponding the requested phase will be emitted the next
time the frame clock processes. Multiple calls to
gdk_frame_clock_request_phase() will be combined together
and only one frame processed. If you are displaying animated
content and want to continually request the
GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time,
you should use gdk_frame_clock_begin_updating() instead, since
this allows GTK+ to adjust system parameters to get maximally
smooth animations.
Since: 3.8
void
gdk_frame_clock_begin_updating (GdkFrameClock *frame_clock);
Starts updates for an animation. Until a matching call to
gdk_frame_clock_end_updating() is made, the frame clock will continually
request a new frame with the GDK_FRAME_CLOCK_PHASE_UPDATE phase.
This function may be called multiple times and frames will be
requested until gdk_frame_clock_end_updating() is called the same
number of times.
Since: 3.8
void
gdk_frame_clock_end_updating (GdkFrameClock *frame_clock);
Stops updates for an animation. See the documentation for
gdk_frame_clock_begin_updating().
Since: 3.8
gint64
gdk_frame_clock_get_frame_counter (GdkFrameClock *frame_clock);
A GdkFrameClock maintains a 64-bit counter that increments for each frame drawn.
inside frame processing, the value of the frame counter for the current frame. Outside of frame processing, the frame counter for the last frame.
Since: 3.8
gint64
gdk_frame_clock_get_history_start (GdkFrameClock *frame_clock);
GdkFrameClock internally keeps a history of GdkFrameTimings
objects for recent frames that can be retrieved with
gdk_frame_clock_get_timings(). The set of stored frames
is the set from the counter values given by
gdk_frame_clock_get_history_start() and
gdk_frame_clock_get_frame_counter(), inclusive.
the frame counter value for the oldest frame that is available in the internal frame history of the GdkFrameClock.
Since: 3.8
GdkFrameTimings * gdk_frame_clock_get_timings (GdkFrameClock *frame_clock,gint64 frame_counter);
Retrieves a GdkFrameTimings object holding timing information
for the current frame or a recent frame. The GdkFrameTimings
object may not yet be complete: see gdk_frame_timings_get_complete().
the GdkFrameTimings object for the specified
frame, or NULL if it is not available. See
gdk_frame_clock_get_history_start().
[nullable]
Since: 3.8
GdkFrameTimings *
gdk_frame_clock_get_current_timings (GdkFrameClock *frame_clock);
Gets the frame timings for the current frame.
the GdkFrameTimings for the frame currently
being processed, or even no frame is being processed, for the
previous frame. Before any frames have been processed, returns
NULL.
[nullable]
Since: 3.8
void gdk_frame_clock_get_refresh_info (GdkFrameClock *frame_clock,gint64 base_time,gint64 *refresh_interval_return,gint64 *presentation_time_return);
Using the frame history stored in the frame clock, finds the last
known presentation time and refresh interval, and assuming that
presentation times are separated by the refresh interval,
predicts a presentation time that is a multiple of the refresh
interval after the last presentation time, and later than base_time
.
frame_clock |
||
base_time |
base time for determining a presentaton time |
|
refresh_interval_return |
a location to store the determined refresh
interval, or |
|
presentation_time_return |
a location to store the next candidate presentation time after the given base time. 0 will be will be stored if no history is present. |
Since: 3.8
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.
|
no phase |
||
|
corresponds to GdkFrameClock::flush-events. Should not be handled by applications. |
||
|
corresponds to GdkFrameClock::before-paint. Should not be handled by applications. |
||
|
corresponds to GdkFrameClock::update. |
||
|
corresponds to GdkFrameClock::layout. |
||
|
corresponds to GdkFrameClock::paint. |
||
|
corresponds to GdkFrameClock::resume-events. Should not be handled by applications. |
||
|
corresponds to GdkFrameClock::after-paint. Should not be handled by applications. |
Since: 3.8
“after-paint” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal ends processing of the frame. Applications should generally not handle this signal.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“before-paint” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal begins processing of the frame. Applications should generally not handle this signal.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“flush-events” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal is used to flush pending motion events that are being batched up and compressed together. Applications should not handle this signal.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“layout” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal is emitted as the second step of toolkit and application processing of the frame. Any work to update sizes and positions of application elements should be performed. GTK+ normally handles this internally.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“paint” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal is emitted as the third step of toolkit and application processing of the frame. The frame is repainted. GDK normally handles this internally and produces expose events, which are turned into GTK+ “draw” signals.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“resume-events” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal is emitted after processing of the frame is finished, and is handled internally by GTK+ to resume normal event processing. Applications should not handle this signal.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“update” signalvoid user_function (GdkFrameClock *clock, gpointer user_data)
This signal is emitted as the first step of toolkit and
application processing of the frame. Animations should
be updated using gdk_frame_clock_get_frame_time().
Applications can connect directly to this signal, or
use gtk_widget_add_tick_callback() as a more convenient
interface.
clock |
the frame clock emitting the signal |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
| Top | |
|
|
|
The functions in this section are specific to the GDK X11 backend.
To use them, you need to include the <gdk/gdkx.h> header and use
the X11-specific pkg-config files to build your application (either
gdk-x11-3.0 or gtk+-x11-3.0).
To make your code compile with other GDK backends, guard backend-specific
calls by an ifdef as follows. Since GDK may be built with multiple
backends, you should also check for the backend that is in use (e.g. by
using the GDK_IS_X11_DISPLAY() macro).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (display)) { // make X11-specific calls here } else #endif #ifdef GDK_WINDOWING_QUARTZ if (GDK_IS_QUARTZ_DISPLAY (display)) { // make Quartz-specific calls here } else #endif g_error ("Unsupported GDK backend"); |
#define GDK_POINTER_TO_XID(pointer) GPOINTER_TO_UINT(pointer)
Converts a gpointer
back to an XID that was previously converted
using GDK_XID_TO_POINTER().
#define GDK_XID_TO_POINTER(xid) GUINT_TO_POINTER(xid)
Converts an XID into a gpointer
. This is useful with data structures
that use pointer arguments such as GHashTable. Use GDK_POINTER_TO_XID()
to convert the argument back to an XID.
GdkDisplay *
gdk_x11_lookup_xdisplay (Display *xdisplay);
Find the GdkDisplay corresponding to xdisplay
, if any exists.
Since: 2.2
guint32
gdk_x11_get_server_time (GdkWindow *window);
Routine to get the current X server time stamp.
window |
a GdkWindow, used for communication with the server. The window must have GDK_PROPERTY_CHANGE_MASK in its events mask or a hang will result. |
[type GdkX11Window] |
gint
gdk_x11_device_get_id (GdkDevice *device);
Returns the device ID as seen by XInput2.
If
gdk_disable_multidevice()has been called, this function will respectively return 2/3 for the core pointer and keyboard, (matching the IDs for the Virtual Core Pointer and Keyboard in XInput 2), but calling this function on any slave devices (i.e. those managed via XInput 1.x), will return 0.
Since: 3.2
GdkDevice * gdk_x11_device_manager_lookup (GdkX11DeviceManagerCore *device_manager,gint device_id);
Returns the GdkDevice that wraps the given device ID.
device_manager |
a GdkDeviceManager. |
[type GdkX11DeviceManagerCore] |
device_id |
a device ID, as understood by the XInput2 protocol |
The GdkDevice wrapping the device ID,
or NULL if the given ID doesn’t currently represent a device.
[transfer none][allow-none][type GdkX11DeviceCore]
Since: 3.2
void
gdk_disable_multidevice (void);
Disables multidevice support in GDKs X11 backend. This call must happen prior
to gdk_display_open(), gtk_init() or gtk_init_check() in order to
take effect.
Most common GTK+ applications won’t ever need to call this. Only applications that do mixed GDK/Xlib calls could want to disable multidevice support if such Xlib code deals with input devices in any way and doesn’t observe the presence of XInput 2.
Since: 3.0
GdkDisplay *
gdk_x11_display_open (const char *display_name);
Tries to open a new display to the X server given by
display_name
. If opening the display fails, NULL is
returned.
void gdk_x11_display_set_program_class (GdkDisplay *display,const char *program_class);
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.
Since: 3.94
guint32
gdk_x11_display_get_user_time (GdkDisplay *display);
Returns the timestamp of the last user interaction on
display
. The timestamp is taken from events caused
by user interaction such as key presses or pointer
movements. See gdk_x11_window_set_user_time().
Since: 2.8
void gdk_x11_display_broadcast_startup_message (GdkDisplay *display,const char *message_type,...);
Sends a startup notification message of type message_type
to
display
.
This is a convenience function for use by code that implements the freedesktop startup notification specification. Applications should not normally need to call it directly. See the Startup Notification Protocol specification for definitions of the message types and keys that can be used.
display |
a GdkDisplay. |
[type GdkX11Display] |
message_type |
startup notification message type ("new", "change", or "remove") |
|
... |
a list of key/value pairs (as strings), terminated by a
|
Since: 2.12
const gchar *
gdk_x11_display_get_startup_notification_id
(GdkDisplay *display);
Gets the startup notification ID for a display.
Since: 2.12
void gdk_x11_display_set_startup_notification_id (GdkDisplay *display,const gchar *startup_id);
Sets the startup notification ID for a display.
This is usually taken from the value of the DESKTOP_STARTUP_ID
environment variable, but in some cases (such as the application not
being launched using exec()) it can come from other sources.
If the ID contains the string "_TIME" then the portion following that string is taken to be the X11 timestamp of the event that triggered the application to be launched and the GDK current event time is set accordingly.
The startup ID is also what is used to signal that the startup is
complete (for example, when opening a window or when calling
gdk_notify_startup_complete()).
display |
a GdkDisplay. |
[type GdkX11Display] |
startup_id |
the startup notification ID (must be valid utf8) |
Since: 3.0
Display *
gdk_x11_display_get_xdisplay (GdkDisplay *display);
Returns the X display of a GdkDisplay.
Since: 2.2
Screen *
gdk_x11_display_get_xscreen (GdkDisplay *display);
Returns the X Screen used by GdkDisplay.
Since: 3.94
Window
gdk_x11_display_get_xrootwindow (GdkDisplay *display);
Returns the root X window used by GdkDisplay.
Since: 3.94
Cursor gdk_x11_display_get_xcursor (GdkDisplay *display,GdkCursor *cursor);
Returns the X cursor belonging to a GdkCursor, potentially creating the cursor.
Be aware that the returned cursor may not be unique to cursor
.
It may for example be shared with its fallback cursor. On old
X servers that don't support the XCursor extension, all cursors
may even fall back to a few default cursors.
void
gdk_x11_display_grab (GdkDisplay *display);
Call XGrabServer() on display
.
To ungrab the display again, use gdk_x11_display_ungrab().
gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
Since: 2.2
void
gdk_x11_display_ungrab (GdkDisplay *display);
Ungrab display
after it has been grabbed with
gdk_x11_display_grab().
Since: 2.2
void
gdk_x11_display_error_trap_push (GdkDisplay *display);
Begins a range of X requests on display
for which X error events
will be ignored. Unignored errors (when no trap is pushed) will abort
the application. Use gdk_x11_display_error_trap_pop() or
gdk_x11_display_error_trap_pop_ignored()to lift a trap pushed
with this function.
See also gdk_error_trap_push() to push a trap on all displays.
Since: 3.0
gint
gdk_x11_display_error_trap_pop (GdkDisplay *display);
Pops the error trap pushed by gdk_x11_display_error_trap_push().
Will XSync() if necessary and will always block until
the error is known to have occurred or not occurred,
so the error code can be returned.
If you don’t need to use the return value,
gdk_x11_display_error_trap_pop_ignored() would be more efficient.
See gdk_error_trap_pop() for the all-displays-at-once
equivalent.
Since: 3.0
void
gdk_x11_display_error_trap_pop_ignored
(GdkDisplay *display);
Pops the error trap pushed by gdk_x11_display_error_trap_push().
Does not block to see if an error occurred; merely records the
range of requests to ignore errors for, and ignores those errors
if they arrive asynchronously.
See gdk_error_trap_pop_ignored() for the all-displays-at-once
equivalent.
Since: 3.0
void gdk_x11_display_set_cursor_theme (GdkDisplay *display,const gchar *theme,const gint size);
Sets the cursor theme from which the images for cursor should be taken.
If the windowing system supports it, existing cursors created
with gdk_cursor_new(), gdk_cursor_new_for_display() and
gdk_cursor_new_from_name() are updated to reflect the theme
change. Custom cursors constructed with
gdk_cursor_new_from_texture() will have to be handled
by the application (GTK+ applications can learn about
cursor theme changes by listening for change notification
for the corresponding GtkSetting).
display |
a GdkDisplay. |
[type GdkX11Display] |
theme |
the name of the cursor theme to use, or |
|
size |
the cursor size to use, or 0 to keep the previous size |
Since: 2.8
void gdk_x11_display_set_window_scale (GdkDisplay *display,gint scale);
Forces a specific window scale for all windows on this display,
instead of using the default or user configured scale. This
is can be used to disable scaling support by setting scale
to
1, or to programmatically set the window scale.
Once the scale is set by this call it will not change in response to later user configuration changes.
Since: 3.10
gboolean gdk_x11_display_get_glx_version (GdkDisplay *display,gint *major,gint *minor);
Retrieves the version of the GLX implementation.
display |
||
major |
return location for the GLX major version. |
[out] |
minor |
return location for the GLX minor version. |
[out] |
Since: 3.16
void gdk_x11_register_standard_event_type (GdkDisplay *display,gint event_base,gint n_events);
Registers interest in receiving extension events with type codes
between event_base
and event_base + n_events - 1.
The registered events must have the window field in the same place
as core X events (this is not the case for e.g. XKB extension events).
If an event type is registered, events of this type will go through
global and window-specific filters (see gdk_window_add_filter()).
Unregistered events will only go through global filters.
GDK may register the events of some X extensions on its own.
This function should only be needed in unusual circumstances, e.g. when filtering XInput extension events on the root window.
display |
a GdkDisplay. |
[type GdkX11Display] |
event_base |
first event type code to register |
|
n_events |
number of event type codes to register |
Since: 2.4
int
gdk_x11_screen_get_screen_number (GdkX11Screen *screen);
Returns the index of a GdkX11Screen.
Since: 2.2
Screen *
gdk_x11_screen_get_xscreen (GdkX11Screen *screen);
Returns the screen of a GdkX11Screen.
Since: 2.2
const char *
gdk_x11_screen_get_window_manager_name
(GdkX11Screen *screen);
Returns the name of the window manager for screen
.
the name of the window manager screen screen
, or
"unknown" if the window manager is unknown. The string is owned by GDK
and should not be freed.
Since: 2.2
XID gdk_x11_screen_get_monitor_output (GdkX11Screen *screen,gint monitor_num);
Gets the XID of the specified output/monitor. If the X server does not support version 1.2 of the RANDR extension, 0 is returned.
screen |
a GdkX11Screen |
|
monitor_num |
number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) |
Since: 2.14
GdkX11Visual * gdk_x11_screen_lookup_visual (GdkX11Screen *screen,VisualID xvisualid);
Looks up the GdkVisual for a particular screen and X Visual ID.
the GdkVisual (owned by the screen
object), or NULL if the visual ID wasn’t found.
[transfer none][type GdkX11Visual]
Since: 2.2
gboolean gdk_x11_screen_supports_net_wm_hint (GdkX11Screen *screen,GdkAtom property);
This function is specific to the X11 backend of GDK, and indicates whether the window manager supports a certain hint from the Extended Window Manager Hints specification.
When using this function, keep in mind that the window manager
can change over time; so you shouldn’t use this function in
a way that impacts persistent application state. A common bug
is that your application can start up before the window manager
does when the user logs in, and before the window manager starts
gdk_x11_screen_supports_net_wm_hint() will return FALSE for every property.
You can monitor the window_manager_changed signal on GdkX11Screen to detect
a window manager change.
Since: 2.2
guint32
gdk_x11_screen_get_number_of_desktops (GdkX11Screen *screen);
Returns the number of workspaces for screen
when running under a
window manager that supports multiple workspaces, as described
in the
Extended Window Manager Hints specification.
Since: 3.10
guint32
gdk_x11_screen_get_current_desktop (GdkX11Screen *screen);
Returns the current workspace for screen
when running under a
window manager that supports multiple workspaces, as described
in the
Extended Window Manager Hints specification.
Since: 3.10
GdkWindow * gdk_x11_window_foreign_new_for_display (GdkDisplay *display,Window window);
Wraps a native window in a GdkWindow. The function will try to
look up the window using gdk_x11_window_lookup_for_display() first.
If it does not find it there, it will create a new window.
This may fail if the window has been destroyed. If the window was already known to GDK, a new reference to the existing GdkWindow is returned.
display |
the GdkDisplay where the window handle comes from. |
[type GdkX11Display] |
window |
an Xlib Window |
a GdkWindow wrapper for the native
window, or NULL if the window has been destroyed. The wrapper
will be newly created, if one doesn’t exist already.
[transfer full]
Since: 2.24
GdkWindow * gdk_x11_window_lookup_for_display (GdkDisplay *display,Window window);
Looks up the GdkWindow that wraps the given native window handle.
display |
the GdkDisplay corresponding to the window handle. |
[type GdkX11Display] |
window |
an Xlib Window |
the GdkWindow wrapper for the native
window, or NULL if there is none.
[transfer none][type GdkX11Window]
Since: 2.24
Window
gdk_x11_window_get_xid (GdkWindow *window);
Returns the X resource (window) belonging to a GdkWindow.
void gdk_x11_window_set_theme_variant (GdkWindow *window,const char *variant);
GTK+ applications can request a dark theme variant. In order to make other applications - namely window managers using GTK+ for themeing - aware of this choice, GTK+ uses this function to export the requested theme variant as _GTK_THEME_VARIANT property on toplevel windows.
Note that this property is automatically updated by GTK+, so this function should only be used by applications which do not use GTK+ to create toplevel windows.
Since: 3.2
void gdk_x11_window_set_user_time (GdkWindow *window,guint32 timestamp);
The application can use this call to update the _NET_WM_USER_TIME property on a toplevel window. This property stores an Xserver time which represents the time of the last user input event received for this window. This property may be used by the window manager to alter the focus, stacking, and/or placement behavior of windows when they are mapped depending on whether the new window was created by a user action or is a "pop-up" window activated by a timer or some other event.
Note that this property is automatically updated by GDK, so this function should only be used by applications which handle input events bypassing GDK.
window |
A toplevel GdkWindow. |
[type GdkX11Window] |
timestamp |
An XServer timestamp to which the property should be set |
Since: 2.6
void
gdk_x11_window_move_to_current_desktop
(GdkWindow *window);
Moves the window to the correct workspace when running under a window manager that supports multiple workspaces, as described in the Extended Window Manager Hints specification. Will not do anything if the window is already on all workspaces.
Since: 2.8
void gdk_x11_window_move_to_desktop (GdkWindow *window,guint32 desktop);
Moves the window to the given workspace when running unde a window manager that supports multiple workspaces, as described in the Extended Window Manager Hints specification.
window |
a GdkWindow. |
[type GdkX11Window] |
desktop |
the number of the workspace to move the window to |
Since: 3.10
guint32
gdk_x11_window_get_desktop (GdkWindow *window);
Gets the number of the workspace window
is on.
Since: 3.10
void gdk_x11_window_set_utf8_property (GdkWindow *window,const gchar *name,const gchar *value);
This function modifies or removes an arbitrary X11 window
property of type UTF8_STRING. If the given window
is
not a toplevel window, it is ignored.
Since: 3.4
void gdk_x11_window_set_frame_extents (GdkWindow *window,int left,int right,int top,int bottom);
gdk_x11_window_set_frame_extents has been deprecated since version 3.12 and should not be used in newly-written code.
Use gdk_window_set_shadow_width() instead.
This is the same as gdk_window_set_shadow_width() but it only works
on GdkX11Window.
window |
a GdkWindow. |
[type GdkX11Window] |
left |
The left extent |
|
right |
The right extent |
|
top |
The top extent |
|
bottom |
The bottom extent |
Since: 3.10
void gdk_x11_window_set_frame_sync_enabled (GdkWindow *window,gboolean frame_sync_enabled);
This function can be used to disable frame synchronization for a window. Normally frame synchronziation will be enabled or disabled based on whether the system has a compositor that supports frame synchronization, but if the window is not directly managed by the window manager, then frame synchronziation may need to be disabled. This is the case for a window embedded via the XEMBED protocol.
window |
a native GdkWindow. |
[type GdkX11Window] |
frame_sync_enabled |
whether frame-synchronization should be enabled |
Since: 3.8
gint gdk_x11_keymap_get_group_for_state (GdkKeymap *keymap,guint state);
Extracts the group from the state field sent in an X Key event. This is only needed for code processing raw X events, since GdkEventKey directly includes an is_modifier field.
Since: 3.6
gboolean gdk_x11_keymap_key_is_modifier (GdkKeymap *keymap,guint keycode);
Determines whether a particular key code represents a key that is a modifier. That is, it’s a key that normally just affects the keyboard state and the behavior of other keys rather than producing a direct effect itself. This is only needed for code processing raw X events, since GdkEventKey directly includes an is_modifier field.
Since: 3.6
Visual *
gdk_x11_visual_get_xvisual (GdkX11Visual *visual);
Returns the X visual belonging to a GdkVisual.
Atom gdk_x11_atom_to_xatom_for_display (GdkDisplay *display,GdkAtom atom);
Converts from a GdkAtom to the X atom for a GdkDisplay
with the same string value. The special value NULL
is converted to None.
Since: 2.2
GdkAtom gdk_x11_xatom_to_atom_for_display (GdkDisplay *display,Atom xatom);
Convert from an X atom for a GdkDisplay to the corresponding GdkAtom.
Since: 2.2
Atom gdk_x11_get_xatom_by_name_for_display (GdkDisplay *display,const gchar *atom_name);
Returns the X atom for a GdkDisplay corresponding to atom_name
.
This function caches the result, so if called repeatedly it is much
faster than XInternAtom(), which is a round trip to the server each time.
Since: 2.2
const gchar * gdk_x11_get_xatom_name_for_display (GdkDisplay *display,Atom xatom);
Returns the name of an X atom for its display. This
function is meant mainly for debugging, so for convenience, unlike
XAtomName() and the result doesn’t need to
be freed.
Since: 2.2
void
gdk_x11_set_sm_client_id (const gchar *sm_client_id);
Sets the SM_CLIENT_ID property on the application’s leader window so that
the window manager can save the application’s state using the X11R6 ICCCM
session management protocol.
See the X Session Management Library documentation for more information on session management and the Inter-Client Communication Conventions Manual
sm_client_id |
the client id assigned by the session manager when the
connection was opened, or |
Since: 2.24
gint gdk_x11_display_text_property_to_text_list (GdkDisplay *display,GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
Convert a text string from the encoding as it is stored in a property into an array of strings in the encoding of the current locale. (The elements of the array represent the nul-separated elements of the original text string.)
display |
The GdkDisplay where the encoding is defined. |
[type GdkX11Display] |
encoding |
an atom representing the encoding. The most common values for this are STRING, or COMPOUND_TEXT. This is value used as the type for the property |
|
format |
the format of the property |
|
text |
The text data |
|
length |
The number of items to transform |
|
list |
location to store an array of strings in
the encoding of the current locale. This array should be
freed using |
Since: 2.24
void
gdk_x11_free_text_list (gchar **list);
Frees the array of strings created by
gdk_x11_display_text_property_to_text_list().
list |
the value stored in the |
Since: 2.24
gint gdk_x11_display_string_to_compound_text (GdkDisplay *display,const gchar *str,GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
Convert a string from the encoding of the current locale into a form suitable for storing in a window property.
display |
the GdkDisplay where the encoding is defined. |
[type GdkX11Display] |
str |
a nul-terminated string |
|
encoding |
location to store the encoding atom (to be used as the type for the property). |
[out][transfer none] |
format |
location to store the format of the property. |
[out] |
ctext |
location to store newly allocated data for the property. |
[out][array length=length] |
length |
the length of |
Since: 2.24
gboolean gdk_x11_display_utf8_to_compound_text (GdkDisplay *display,const gchar *str,GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
Converts from UTF-8 to compound text.
display |
a GdkDisplay. |
[type GdkX11Display] |
str |
a UTF-8 string |
|
encoding |
location to store resulting encoding. |
[out] |
format |
location to store format of the result. |
[out] |
ctext |
location to store the data of the result. |
[out][array length=length] |
length |
location to store the length of the data
stored in |
Since: 2.24
void
gdk_x11_free_compound_text (guchar *ctext);
Frees the data returned from gdk_x11_display_string_to_compound_text().
ctext |
The pointer stored in |
Since: 2.24
|
 |
|
 |
NULL is OK, both for passing and for returning.
Parameter points to an array of items.
This parameter is a 'user_data', for callbacks; many bindings can pass NULL here.
This symbol is a constructor, not a static method.
Generics and defining elements of containers and arrays.
Parameter for input and for returning results. Default is transfer full.
NULL may be passed as the value in, out, in-out; or as a return value.
NULL may be passed instead of a pointer to a location.
Parameter for returning results. Default is transfer full.
Out parameter, where caller must allocate storage.
An interface that can be used within the GNOME stack itself, but that is not documented for end-users. Such functions should only be used in specified and documented ways.
Rename the original symbol's name to SYMBOL.
The callback is valid until first called.
The callback is valid only during the call to the method.
Exposed in C code, not necessarily available in other languages.
Free data container after the code is done.
Free data after the code is done.
Don't free data after the code is done.
Override the parsed C type with given type.
Unstable interfaces are experimental or transitional. They are typically used to give outside developers early access to new or rapidly changing technology, or to provide an interim solution to a problem where a more general solution is anticipated. No claims are made about either source or binary compatibility from one minor release to the next. The Unstable interface level is a warning that these interfaces are subject to change without warning and should not be used in unbundled products. Given such caveats, customer impact need not be a factor when considering incompatible changes to an Unstable interface in a major or minor release. Nonetheless, when such changes are introduced, the changes should still be mentioned in the release notes for the affected release.
| Top | |
|
|
|
A GdkContentSerializer is used to serialize content for inter-application data transfers.
void
(*GdkContentSerializeFunc) (GdkContentSerializer *serializer);
The type of a function that can be registered with gdk_content_register_serializer().
When the function gets called to operate on content, it can call functions on the
serializer
object to obtain the mime type, output stream, user data, etc. for its
operation.
const char *
gdk_content_serializer_get_mime_type (GdkContentSerializer *serializer);
Gets the mime type to serialize to.
GType
gdk_content_serializer_get_gtype (GdkContentSerializer *serializer);
Gets the GType to of the object to serialize.
const GValue *
gdk_content_serializer_get_value (GdkContentSerializer *serializer);
Gets the GValue to read the object to serialize from.
GOutputStream *
gdk_content_serializer_get_output_stream
(GdkContentSerializer *serializer);
Gets the output stream that was passed to gdk_content_serialize_async().
int
gdk_content_serializer_get_priority (GdkContentSerializer *serializer);
Gets the io priority that was passed to gdk_content_serialize_async().
GCancellable *
gdk_content_serializer_get_cancellable
(GdkContentSerializer *serializer);
Gets the cancellable that was passed to gdk_content_serialize_async().
gpointer
gdk_content_serializer_get_user_data (GdkContentSerializer *serializer);
Gets the user data that was passed when the serializer was registered.
void gdk_content_serializer_set_task_data (GdkContentSerializer *serializer,gpointer data,GDestroyNotify notify);
Associate data with the current serialization operation.
gpointer
gdk_content_serializer_get_task_data (GdkContentSerializer *serializer);
Gets the data that was associated with serializer
via gdk_content_serializer_set_task_data().
void
gdk_content_serializer_return_success (GdkContentSerializer *serializer);
Indicate that the serialization has been successfully completed.
void gdk_content_serializer_return_error (GdkContentSerializer *serializer,GError *error);
Indicate that the serialization has ended with an error.
This function consumes error
.
void gdk_content_register_serializer (GType type,const char *mime_type,GdkContentSerializeFunc serialize,gpointer data,GDestroyNotify notify);
Registers a function to convert objects of the given type
to
a serialized representation with the given mime type.
void gdk_content_serialize_async (GOutputStream *stream,const char *mime_type,const GValue *value,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Serialize content and write it to the given output stream, asynchronously.
When the operation is finished, callback
will be called. You can then
call gdk_content_serialize_finish() to get the result of the operation.
stream |
a GOutputStream to write the serialized content to |
|
mime_type |
the mime type to serialize to |
|
value |
the content to serialize |
|
io_priority |
the io priority of the operation |
|
cancellable |
optional GCancellable object. |
[nullable] |
callback |
callback to call when the operation is done. |
[scope async] |
user_data |
data to pass to the callback function. |
[closure] |
gboolean gdk_content_serialize_finish (GAsyncResult *result,GError **error);
Finishes a content serialization operation.
| Top | |
|
|
|
| GdkDisplay * | gdk_monitor_get_display () |
| void | gdk_monitor_get_geometry () |
| void | gdk_monitor_get_workarea () |
| int | gdk_monitor_get_width_mm () |
| int | gdk_monitor_get_height_mm () |
| const char * | gdk_monitor_get_manufacturer () |
| const char * | gdk_monitor_get_model () |
| int | gdk_monitor_get_scale_factor () |
| int | gdk_monitor_get_refresh_rate () |
| GdkSubpixelLayout | gdk_monitor_get_subpixel_layout () |
| gboolean | gdk_monitor_is_primary () |
| gboolean | gdk_monitor_is_valid () |
| GdkDisplay * | display | Read / Write / Construct Only |
| GdkRectangle * | geometry | Read |
| gint | height-mm | Read |
| gchar * | manufacturer | Read |
| gchar * | model | Read |
| gint | refresh-rate | Read |
| gint | scale-factor | Read |
| GdkSubpixelLayout | subpixel-layout | Read |
| gboolean | valid | Read |
| gint | width-mm | Read |
| GdkRectangle * | workarea | Read |
GdkMonitor objects represent the individual outputs that are
associated with a GdkDisplay. GdkDisplay has APIs to enumerate
monitors with gdk_display_get_monitors() and to find particular
monitors with gdk_display_get_primary_monitor() or
gdk_display_get_monitor_at_window().
GdkDisplay *
gdk_monitor_get_display (GdkMonitor *monitor);
Gets the display that this monitor belongs to.
Since: 3.22
void gdk_monitor_get_geometry (GdkMonitor *monitor,GdkRectangle *geometry);
Retrieves the size and position of an individual monitor within the
display coordinate space. The returned geometry is in ”application pixels”,
not in ”device pixels” (see gdk_monitor_get_scale_factor()).
Since: 3.22
void gdk_monitor_get_workarea (GdkMonitor *monitor,GdkRectangle *workarea);
Retrieves the size and position of the “work area” on a monitor
within the display coordinate space. The returned geometry is in
”application pixels”, not in ”device pixels” (see
gdk_monitor_get_scale_factor()).
The work area should be considered when positioning menus and similar popups, to avoid placing them below panels, docks or other desktop components.
Note that not all backends may have a concept of workarea. This function will return the monitor geometry if a workarea is not available, or does not apply.
Since: 3.22
int
gdk_monitor_get_width_mm (GdkMonitor *monitor);
Gets the width in millimeters of the monitor.
Since: 3.22
int
gdk_monitor_get_height_mm (GdkMonitor *monitor);
Gets the height in millimeters of the monitor.
Since: 3.22
const char *
gdk_monitor_get_manufacturer (GdkMonitor *monitor);
Gets the name of the monitor's manufacturer, if available.
const char *
gdk_monitor_get_model (GdkMonitor *monitor);
Gets the a string identifying the monitor model, if available.
int
gdk_monitor_get_scale_factor (GdkMonitor *monitor);
Gets the internal scale factor that maps from monitor coordinates to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2).
This can be used if you want to create pixel based data for a
particular monitor, but most of the time you’re drawing to a window
where it is better to use gdk_window_get_scale_factor() instead.
Since: 3.22
int
gdk_monitor_get_refresh_rate (GdkMonitor *monitor);
Gets the refresh rate of the monitor, if available.
The value is in milli-Hertz, so a refresh rate of 60Hz is returned as 60000.
Since: 3.22
GdkSubpixelLayout
gdk_monitor_get_subpixel_layout (GdkMonitor *monitor);
Gets information about the layout of red, green and blue primaries for each pixel in this monitor, if available.
Since: 3.22
gboolean
gdk_monitor_is_primary (GdkMonitor *monitor);
Gets whether this monitor should be considered primary
(see gdk_display_get_primary_monitor()).
Since: 3.22
gboolean
gdk_monitor_is_valid (GdkMonitor *monitor);
Returns TRUE if the monitor
object corresponds to a
physical monitor. The monitor
becomes invalid when the
physical monitor is unplugged or removed.
Since: 3.94
typedef struct _GdkMonitor GdkMonitor;
The GdkMonitor struct contains only private fields and should not be accessed directly.
This enumeration describes how the red, green and blue components of physical pixels on an output device are laid out.
|
The layout is not known |
||
|
Not organized in this way |
||
|
The layout is horizontal, the order is RGB |
||
|
The layout is horizontal, the order is BGR |
||
|
The layout is vertical, the order is RGB |
||
|
The layout is vertical, the order is BGR |
Since: 3.22
“display” property“display” GdkDisplay *
The display of the monitor.
Flags: Read / Write / Construct Only
“height-mm” property“height-mm” gint
The height of the monitor, in millimeters.
Flags: Read
Allowed values: >= 0
Default value: 0
“manufacturer” property“manufacturer” gchar *
The manufacturer name.
Flags: Read
Default value: NULL
“refresh-rate” property“refresh-rate” gint
The refresh rate, in millihertz.
Flags: Read
Allowed values: >= 0
Default value: 0
“scale-factor” property“scale-factor” gint
The scale factor.
Flags: Read
Allowed values: >= 0
Default value: 1
“subpixel-layout” property“subpixel-layout” GdkSubpixelLayout
The subpixel layout.
Flags: Read
Default value: GDK_SUBPIXEL_LAYOUT_UNKNOWN
“valid” property“valid” gboolean
Whether the monitor is still valid.
Flags: Read
Default value: TRUE
“width-mm” property“width-mm” gint
The width of the monitor, in millimeters.
Flags: Read
Allowed values: >= 0
Default value: 0
“invalidate” signalvoid user_function (GdkMonitor *monitor, gpointer user_data)
The ::invalidate signal gets emitted when the output represented
by monitor
gets disconnected.
monitor |
the object on which this signal was emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run First
| Top | |
|
|
|
| GdkRGBA * | gdk_rgba_copy () |
| void | gdk_rgba_free () |
| gboolean | gdk_rgba_is_clear () |
| gboolean | gdk_rgba_is_opaque () |
| gboolean | gdk_rgba_parse () |
| gboolean | gdk_rgba_equal () |
| guint | gdk_rgba_hash () |
| gchar * | gdk_rgba_to_string () |
GdkRGBA is a convenient way to pass rgba colors around. It’s based on cairo’s way to deal with colors and mirrors its behavior. All values are in the range from 0.0 to 1.0 inclusive. So the color (0.0, 0.0, 0.0, 0.0) represents transparent black and (1.0, 1.0, 1.0, 1.0) is opaque white. Other values will be clamped to this range when drawing.
GdkRGBA *
gdk_rgba_copy (const GdkRGBA *rgba);
Makes a copy of a GdkRGBA.
The result must be freed through gdk_rgba_free().
Since: 3.0
void
gdk_rgba_free (GdkRGBA *rgba);
Frees a GdkRGBA created with gdk_rgba_copy()
Since: 3.0
gboolean
gdk_rgba_is_clear (const GdkRGBA *rgba);
Checks if an rgba
value is transparent. That is, drawing with the value
would not produce any change.
Since: 3.90
gboolean
gdk_rgba_is_opaque (const GdkRGBA *rgba);
Checks if an rgba
value is opaque. That is, drawing with the value
will not retain any results from previous contents.
Since: 3.90
gboolean gdk_rgba_parse (GdkRGBA *rgba,const gchar *spec);
Parses a textual representation of a color, filling in
the red
, green
, blue
and alpha
fields of the rgba
GdkRGBA.
The string can be either one of:
A standard name (Taken from the X11 rgb.txt file).
A hexadecimal value in the form “#rgb”, “#rrggbb”, “#rrrgggbbb” or ”#rrrrggggbbbb”
A RGB color in the form “rgb(r,g,b)” (In this case the color will have full opacity)
A RGBA color in the form “rgba(r,g,b,a)”
Where “r”, “g”, “b” and “a” are respectively the red, green, blue and alpha color values. In the last two cases, r g and b are either integers in the range 0 to 255 or percentage values in the range 0% to 100%, and a is a floating point value in the range 0 to 1.
Since: 3.0
gboolean gdk_rgba_equal (gconstpointer p1,gconstpointer p2);
Compares two RGBA colors.
Since: 3.0
guint
gdk_rgba_hash (gconstpointer p);
A hash function suitable for using for a hash table that stores GdkRGBAs.
Since: 3.0
gchar *
gdk_rgba_to_string (const GdkRGBA *rgba);
Returns a textual specification of rgba
in the form
rgb (r, g, b) or
rgba (r, g, b, a),
where “r”, “g”, “b” and “a” represent the red, green,
blue and alpha values respectively. r, g, and b are
represented as integers in the range 0 to 255, and a
is represented as floating point value in the range 0 to 1.
These string forms are string forms those supported by
the CSS3 colors module, and can be parsed by gdk_rgba_parse().
Note that this string representation may lose some precision, since r, g and b are represented as 8-bit integers. If this is a concern, you should use a different representation.
Since: 3.0
typedef struct {
gdouble red;
gdouble green;
gdouble blue;
gdouble alpha;
} GdkRGBA;
A GdkRGBA is used to represent a (possibly translucent) color, in a way that is compatible with cairos notion of color.
gdouble |
The intensity of the red channel from 0.0 to 1.0 inclusive |
|
gdouble |
The intensity of the green channel from 0.0 to 1.0 inclusive |
|
gdouble |
The intensity of the blue channel from 0.0 to 1.0 inclusive |
|
gdouble |
The opacity of the color from 0.0 for completely translucent to 1.0 for opaque |
| Top | |
|
|
|
The purpose of the GdkDisplayManager singleton object is to offer notification when displays appear or disappear or the default display changes.
You can use gdk_display_manager_get() to obtain the GdkDisplayManager
singleton, but that should be rarely necessary. Typically, initializing
GTK+ opens a display that you can work with without ever accessing the
GdkDisplayManager.
The GDK library can be built with support for multiple backends. The GdkDisplayManager object determines which backend is used at runtime.
When writing backend-specific code that is supposed to work with
multiple GDK backends, you have to consider both compile time and
runtime. At compile time, use the GDK_WINDOWING_X11, GDK_WINDOWING_WIN32
macros, etc. to find out which backends are present in the GDK library
you are building your application against. At runtime, use type-check
macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (display)) { // make X11-specific calls here } else #endif #ifdef GDK_WINDOWING_QUARTZ if (GDK_IS_QUARTZ_DISPLAY (display)) { // make Quartz-specific calls here } else #endif g_error ("Unsupported GDK backend"); |
GdkDisplayManager *
gdk_display_manager_get (void);
Gets the singleton GdkDisplayManager object.
When called for the first time, this function consults the
GDK_BACKEND environment variable to find out which
of the supported GDK backends to use (in case GDK has been compiled
with multiple backends). Applications can use gdk_set_allowed_backends()
to limit what backends can be used.
The global GdkDisplayManager singleton;
gdk_parse_args(), gdk_init(), or gdk_init_check() must have
been called first.
[transfer none]
Since: 2.2
GdkDisplay *
gdk_display_manager_get_default_display
(GdkDisplayManager *manager);
Gets the default GdkDisplay.
Since: 2.2
void gdk_display_manager_set_default_display (GdkDisplayManager *manager,GdkDisplay *display);
Sets display
as the default display.
Since: 2.2
GSList *
gdk_display_manager_list_displays (GdkDisplayManager *manager);
List all currently open displays.
a newly
allocated GSList of GdkDisplay objects. Free with g_slist_free()
when you are done with it.
[transfer container][element-type GdkDisplay]
Since: 2.2
GdkDisplay * gdk_display_manager_open_display (GdkDisplayManager *manager,const gchar *name);
Opens a display.
Since: 3.0
void
gdk_set_allowed_backends (const gchar *backends);
Sets a list of backends that GDK should try to use.
This can be be useful if your application does not work with certain GDK backends.
By default, GDK tries all included backends.
For example,
1 |
gdk_set_allowed_backends ("wayland,quartz,*"); |
instructs GDK to try the Wayland backend first, followed by the Quartz backend, and then all others.
If the GDK_BACKEND environment variable
is set, it determines what backends are tried in what
order, while still respecting the set of allowed backends
that are specified by this function.
The possible backend names are x11, win32, quartz, broadway, wayland. You can also include a * in the list to try all remaining backends.
This call must happen prior to gdk_display_open(),
gtk_init(), or gtk_init_check()
in order to take effect.
Since: 3.10
“default-display” property“default-display” GdkDisplay *
The default display for GDK.
Flags: Read / Write
“display-opened” signalvoid user_function (GdkDisplayManager *manager, GdkDisplay *display, gpointer user_data)
The ::display-opened signal is emitted when a display is opened.
manager |
the object on which the signal is emitted |
|
display |
the opened display |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.2
| Top | |
|
|
|
This section describes the GdkContentFormats structure that is used to advertise and negotiate the format of content passed between different widgets, windows or applications using for example the clipboard or drag'n'drop.
GDK supports content in 2 forms: GType and mime type. Using GTypes is meant only for in-process content transfers. Mime types are meant to be used for data passing both in-process and out-of-process. The details of how data is passed is described in the documentation of the actual implementations.
A GdkContentFormats describes a set of possible formats content can be
exchanged in. It is assumed that this set is ordered. GTypes are more
important than mime types. Order between different Gtypes or mime types
is the order they were added in, most important first. Functions that
care about order, such as gdk_content_formats_union() will describe in
their documentation how they interpret that order, though in general the
order of the first argument is considered the primary order of the result,
followed by the order of further arguments.
For debugging purposes, the function gdk_content_formats_to_string() exists.
It will print a comma-seperated formats of formats from most important to least
important.
GdkContentFormats is an immutable struct. After creation, you cannot change the types it represents. Instead, new GdkContentFormats have to be created. The GdkContentFormatsBuilder structure is meant to help in this endeavor.
const char *
gdk_intern_mime_type (const char *string);
Canonicalizes the given mime type and interns the result.
If string
is not a valid mime type, NULL is returned instead.
See RFC 2048 for the syntax if mime types.
An interned string for the canonicalized mime type
or NULL if the string wasn't a valid mime type
GdkContentFormats * gdk_content_formats_new (const char **mime_types,guint n_mime_types);
Creates a new GdkContentFormats from an array of mime types.
The mime types must be valid and different from each other or the behavior of the return value is undefined. If you cannot guarantee this, use GdkContentFormatsBuilder instead.
GdkContentFormats *
gdk_content_formats_new_for_gtype (GType type);
Creates a new GdkContentFormats for a given GType.
GdkContentFormats *
gdk_content_formats_ref (GdkContentFormats *formats);
Increases the reference count of a GdkContentFormats by one.
void
gdk_content_formats_unref (GdkContentFormats *formats);
Decreases the reference count of a GdkContentFormats by one. If the resulting reference count is zero, frees the formats.
void gdk_content_formats_print (GdkContentFormats *formats,GString *string);
Prints the given formats
into a string for human consumption.
This is meant for debugging and logging.
The form of the representation may change at any time and is not guranteed to stay identical.
char *
gdk_content_formats_to_string (GdkContentFormats *formats);
Prints the given formats
into a human-readable string.
This is a small wrapper around gdk_content_formats_print() to help
when debugging.
const GType * gdk_content_formats_get_gtypes (GdkContentFormats *formats,gsize *n_gtypes);
Gets the GTypes included in formats
. Note that formats
may not
contain any GTypes, in particular when they are empty. In that
case NULL will be returned.
formats |
||
n_gtypes |
optional pointer to take the number of GTypes contained in the return value. |
[out][allow-none] |
G_TYPE_INVALID-terminated array of
types included in formats
or NULL if none.
[transfer none][nullable]
const char * const * gdk_content_formats_get_mime_types (GdkContentFormats *formats,gsize *n_mime_types);
Gets the mime types included in formats
. Note that formats
may not
contain any mime types, in particular when they are empty. In that
case NULL will be returned.
GdkContentFormats * gdk_content_formats_union (GdkContentFormats *first,const GdkContentFormats *second);
Append all missing types from second
to first
, in the order
they had in second
.
first |
the GdkContentFormats to merge into. |
[transfer full] |
second |
the GdkContentFormats to merge from. |
[transfer none] |
gboolean gdk_content_formats_match (const GdkContentFormats *first,const GdkContentFormats *second);
Checks if first
and second
have any matching formats.
first |
the primary GdkContentFormats to intersect |
|
second |
the GdkContentFormats to intersect with |
GType gdk_content_formats_match_gtype (const GdkContentFormats *first,const GdkContentFormats *second);
Finds the first GType from first
that is also contained
in second
. If no matching GType is found, G_TYPE_INVALID
is returned.
first |
the primary GdkContentFormats to intersect |
|
second |
the GdkContentFormats to intersect with |
const char * gdk_content_formats_match_mime_type (const GdkContentFormats *first,const GdkContentFormats *second);
Finds the first mime type from first
that is also contained
in second
. If no matching mime type is found, NULL is
returned.
first |
the primary GdkContentFormats to intersect |
|
second |
the GdkContentFormats to intersect with |
gboolean gdk_content_formats_contain_gtype (const GdkContentFormats *formats,GType type);
Checks if a given GType is part of the given formats
.
gboolean gdk_content_formats_contain_mime_type (const GdkContentFormats *formats,const char *mime_type);
Checks if a given mime type is part of the given formats
.
GdkContentFormats *
gdk_content_formats_union_serialize_gtypes
(GdkContentFormats *formats);
Add GTypes for the mime types in formats
for which serializers are
registered.
Return: a new GdkContentFormats
GdkContentFormats *
gdk_content_formats_union_deserialize_gtypes
(GdkContentFormats *formats);
Add GTypes for mime types in formats
for which deserializers are
registered.
Return: a new GdkContentFormats
GdkContentFormats *
gdk_content_formats_union_serialize_mime_types
(GdkContentFormats *formats);
Add mime types for GTypes in formats
for which serializers are
registered.
Return: a new GdkContentFormats
GdkContentFormats *
gdk_content_formats_union_deserialize_mime_types
(GdkContentFormats *formats);
Add mime types for GTypes in formats
for which deserializers are
registered.
Return: a new GdkContentFormats
GdkContentFormatsBuilder *
gdk_content_formats_builder_new (void);
Create a new GdkContentFormatsBuilder object. The resulting builder would create an empty GdkContentFormats. Use addition functions to add types to it.
GdkContentFormats *
gdk_content_formats_builder_free (GdkContentFormatsBuilder *builder);
Frees builder
and creates a new GdkContentFormats from it.
void gdk_content_formats_builder_add_formats (GdkContentFormatsBuilder *builder,const GdkContentFormats *formats);
Appends all formats from formats
to builder
, skipping those that
already exist.
void gdk_content_formats_builder_add_gtype (GdkContentFormatsBuilder *builder,GType type);
Appends gtype
to builder
if it has not already been added.
void gdk_content_formats_builder_add_mime_type (GdkContentFormatsBuilder *builder,const char *mime_type);
Appends mime_type
to builder
if it has not already been added.
typedef struct _GdkContentFormats GdkContentFormats;
A GdkContentFormats struct is a reference counted struct and should be treated as opaque.
typedef struct _GdkContentFormatsBuilder GdkContentFormatsBuilder;
A GdkContentFormatsBuilder struct is an opaque struct. It is meant to not be kept around and only be used to create new GdkContentFormats objects.
| Top | |
|
|
|
| GdkTexture * | gdk_texture_new_for_data () |
| GdkTexture * | gdk_texture_new_for_pixbuf () |
| GdkTexture * | gdk_texture_new_from_resource () |
| GdkTexture * | gdk_texture_new_from_file () |
| int | gdk_texture_get_width () |
| int | gdk_texture_get_height () |
| void | gdk_texture_download () |
GdkTexture is the basic element used to refer to pixel data. It is primarily mean for pixel data that will not change over multiple frames, and will be used for a long time.
You cannot get your pixel data back once you've uploaded it.
GdkTexture is an immutable object: That means you cannot change
anything about it other than increasing the reference count via
g_object_ref().
GdkTexture * gdk_texture_new_for_data (const guchar *data,int width,int height,int stride);
Creates a new texture object holding the given data. The data is assumed to be in CAIRO_FORMAT_ARGB32 format.
data |
the pixel data. |
[array] |
width |
the number of pixels in each row |
|
height |
the number of rows |
|
stride |
the distance from the beginning of one row to the next, in bytes |
Since: 3.94
GdkTexture *
gdk_texture_new_for_pixbuf (GdkPixbuf *pixbuf);
Creates a new texture object representing the GdkPixbuf.
Since: 3.94
GdkTexture *
gdk_texture_new_from_resource (const char *resource_path);
Creates a new texture by loading an image from a resource. The file format is detected automatically.
It is a fatal error if resource_path
does not specify a valid
image resource and the program will abort if that happens.
If you are unsure about the validity of a resource, use
gdk_texture_new_from_file() to load it.
Since: 3.94
GdkTexture * gdk_texture_new_from_file (GFile *file,GError **error);
Creates a new texture by loading an image from a file. The file format is
detected automatically. If NULL is returned, then error
will be set.
Since: 3.94
int
gdk_texture_get_width (GdkTexture *texture);
Returns the width of texture
.
Since: 3.94
int
gdk_texture_get_height (GdkTexture *texture);
Returns the height of the texture
.
Since: 3.94
void gdk_texture_download (GdkTexture *texture,guchar *data,gsize stride);
Downloads the texture
into local memory. This may be
an expensive operation, as the actual texture data may
reside on a GPU or on a remote display server.
The data format of the downloaded data is equivalent to
CAIRO_FORMAT_ARGB32, so every downloaded pixel requires
4 bytes of memory.
Downloading a texture into a Cairo image surface:
1 2 3 4 5 6 7 |
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, gdk_texture_get_width (texture), gdk_texture_get_height (texture)); gdk_texture_download (texture, cairo_image_surface_get_data (surface), cairo_image_surface_get_stride (surface)); cairo_surface_mark_dirty (surface); |
texture |
||
data |
pointer to enough memory to be filled with the
downloaded data of |
[array] |
stride |
rowstride in bytes |
Since: 3.94
| Top | |
|
|
|
GdkGLContext is an object representing the platform-specific OpenGL draw context.
GdkGLContexts are created for a GdkWindow using
gdk_window_create_gl_context(), and the context will match the
the characteristics of the window.
A GdkGLContext is not tied to any particular normal framebuffer.
For instance, it cannot draw to the GdkWindow back buffer. The GDK
repaint system is in full control of the painting to that. Instead,
you can create render buffers or textures and use gdk_cairo_draw_from_gl()
in the draw function of your widget to draw them. Then GDK will handle
the integration of your rendering with that of other widgets.
Support for GdkGLContext is platform-specific, context creation
can fail, returning NULL context.
A GdkGLContext has to be made "current" in order to start using it, otherwise any OpenGL call will be ignored.
In order to create a new GdkGLContext instance you need a GdkWindow, which you typically get during the realize call of a widget.
A GdkGLContext is not realized until either gdk_gl_context_make_current(),
or until it is realized using gdk_gl_context_realize(). It is possible to
specify details of the GL context like the OpenGL version to be used, or
whether the GL context should have extra state validation enabled after
calling gdk_window_create_gl_context() by calling gdk_gl_context_realize().
If the realization fails you have the option to change the settings of the
GdkGLContext and try again.
You will need to make the GdkGLContext the current context before issuing OpenGL calls; the system sends OpenGL commands to whichever context is current. It is possible to have multiple contexts, so you always need to ensure that the one which you want to draw with is the current one before issuing commands:
1 |
gdk_gl_context_make_current (context); |
You can now perform your drawing using OpenGL commands.
You can check which GdkGLContext is the current one by using
gdk_gl_context_get_current(); you can also unset any GdkGLContext
that is currently set by calling gdk_gl_context_clear_current().
GdkDisplay *
gdk_gl_context_get_display (GdkGLContext *context);
Retrieves the GdkDisplay the context
is created for
Since: 3.16
GdkWindow *
gdk_gl_context_get_window (GdkGLContext *context);
Retrieves the GdkWindow used by the context
.
Since: 3.16
GdkGLContext *
gdk_gl_context_get_shared_context (GdkGLContext *context);
Retrieves the GdkGLContext that this context
share data with.
Since: 3.16
void gdk_gl_context_get_version (GdkGLContext *context,int *major,int *minor);
Retrieves the OpenGL version of the context
.
The context
must be realized prior to calling this function.
context |
||
major |
return location for the major version. |
[out] |
minor |
return location for the minor version. |
[out] |
Since: 3.16
void gdk_gl_context_set_required_version (GdkGLContext *context,int major,int minor);
Sets the major and minor version of OpenGL to request.
Setting major
and minor
to zero will use the default values.
The GdkGLContext must not be realized or made current prior to calling this function.
Since: 3.16
void gdk_gl_context_get_required_version (GdkGLContext *context,int *major,int *minor);
Retrieves the major and minor version requested by calling
gdk_gl_context_set_required_version().
context |
||
major |
return location for the major version to request. |
[out][nullable] |
minor |
return location for the minor version to request. |
[out][nullable] |
Since: 3.16
void gdk_gl_context_set_debug_enabled (GdkGLContext *context,gboolean enabled);
Sets whether the GdkGLContext should perform extra validations and run time checking. This is useful during development, but has additional overhead.
The GdkGLContext must not be realized or made current prior to calling this function.
Since: 3.16
gboolean
gdk_gl_context_get_debug_enabled (GdkGLContext *context);
Retrieves the value set using gdk_gl_context_set_debug_enabled().
Since: 3.16
void gdk_gl_context_set_forward_compatible (GdkGLContext *context,gboolean compatible);
Sets whether the GdkGLContext should be forward compatible.
Forward compatibile contexts must not support OpenGL functionality that has been marked as deprecated in the requested version; non-forward compatible contexts, on the other hand, must support both deprecated and non deprecated functionality.
The GdkGLContext must not be realized or made current prior to calling this function.
Since: 3.16
gboolean
gdk_gl_context_get_forward_compatible (GdkGLContext *context);
Retrieves the value set using gdk_gl_context_set_forward_compatible().
Since: 3.16
void gdk_gl_context_set_use_es (GdkGLContext *context,int use_es);
Requests that GDK create a OpenGL ES context instead of an OpenGL one, if the platform and windowing system allows it.
The context
must not have been realized.
By default, GDK will attempt to automatically detect whether the
underlying GL implementation is OpenGL or OpenGL ES once the context
is realized.
You should check the return value of gdk_gl_context_get_use_es() after
calling gdk_gl_context_realize() to decide whether to use the OpenGL or
OpenGL ES API, extensions, or shaders.
context |
a GdkGLContext: |
|
use_es |
whether the context should use OpenGL ES instead of OpenGL, or -1 to allow auto-detection |
Since: 3.22
gboolean
gdk_gl_context_get_use_es (GdkGLContext *context);
Checks whether the context
is using an OpenGL or OpenGL ES profile.
Since: 3.22
gboolean
gdk_gl_context_is_legacy (GdkGLContext *context);
Whether the GdkGLContext is in legacy mode or not.
The GdkGLContext must be realized before calling this function.
When realizing a GL context, GDK will try to use the OpenGL 3.2 core
profile; this profile removes all the OpenGL API that was deprecated
prior to the 3.2 version of the specification. If the realization is
successful, this function will return FALSE.
If the underlying OpenGL implementation does not support core profiles,
GDK will fall back to a pre-3.2 compatibility profile, and this function
will return TRUE.
You can use the value returned by this function to decide which kind of OpenGL API to use, or whether to do extension discovery, or what kind of shader programs to load.
Since: 3.20
gboolean gdk_gl_context_realize (GdkGLContext *context,GError **error);
Realizes the given GdkGLContext.
It is safe to call this function on a realized GdkGLContext.
Since: 3.16
cairo_region_t *
gdk_gl_context_get_damage (GdkGLContext *context);
Returns the part of the backbuffer that is known to be damaged and would need to be redrawn. This is the area that needs to be respected in addition to areas invalidated by GTK or the windowing system itself.
void
gdk_gl_context_make_current (GdkGLContext *context);
Makes the context
the current one.
Since: 3.16
GdkGLContext *
gdk_gl_context_get_current (void);
Retrieves the current GdkGLContext.
Since: 3.16
void
gdk_gl_context_clear_current (void);
Clears the current GdkGLContext.
Any OpenGL call after this function returns will be ignored
until gdk_gl_context_make_current() is called.
Since: 3.16
typedef struct _GdkGLContext GdkGLContext;
The GdkGLContext struct contains only private fields and should not be accessed directly.
Error enumeration for GdkGLContext.
|
OpenGL support is not available |
||
|
The requested visual format is not supported |
||
|
The requested profile is not supported |
||
|
The shader compilation failed (available since 3.22) |
||
|
The shader linking failed (available since 3.22) |
Since: 3.16
“shared-context” property“shared-context” GdkGLContext *
The GdkGLContext that this context is sharing data with, or NULL
Flags: Read / Write / Construct Only
Since: 3.16
| Top | |
|
|
|
Pango is the text layout system used by GDK and GTK+. The functions and types in this section are used to obtain clip regions for PangoLayouts, and to get PangoContexts that can be used with GDK.
Creating a PangoLayout object is the first step in rendering text,
and requires getting a handle to a PangoContext. For GTK+ programs,
you’ll usually want to use gtk_widget_get_pango_context(), or
gtk_widget_create_pango_layout(). Once you have a PangoLayout,
you can set the text and attributes of it with Pango functions like
pango_layout_set_text() and get its size with pango_layout_get_size().
(Note that Pango uses a fixed point system internally, so converting
between Pango units and pixels using PANGO_SCALE
or the PANGO_PIXELS() macro.)
Rendering a Pango layout is done most simply with pango_cairo_show_layout();
you can also draw pieces of the layout with pango_cairo_show_layout_line().
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
#define RADIUS 100 #define N_WORDS 10 #define FONT "Sans Bold 18" PangoContext *context; PangoLayout *layout; PangoFontDescription *desc; double radius; int width, height; int i; // Set up a transformation matrix so that the user space coordinates for // where we are drawing are [-RADIUS, RADIUS], [-RADIUS, RADIUS] // We first center, then change the scale width = gdk_window_get_width (window); height = gdk_window_get_height (window); radius = MIN (width, height) / 2.; cairo_translate (cr, radius + (width - 2 * radius) / 2, radius + (height - 2 * radius) / 2); cairo_scale (cr, radius / RADIUS, radius / RADIUS); // Create a PangoLayout, set the font and text context = gdk_pango_context_get_for_display (display); layout = pango_layout_new (context); pango_layout_set_text (layout, "Text", -1); desc = pango_font_description_from_string (FONT); pango_layout_set_font_description (layout, desc); pango_font_description_free (desc); // Draw the layout N_WORDS times in a circle for (i = 0; i < N_WORDS; i++) { double red, green, blue; double angle = 2 * G_PI * i / n_words; cairo_save (cr); // Gradient from red at angle == 60 to blue at angle == 300 red = (1 + cos (angle - 60)) / 2; green = 0; blue = 1 - red; cairo_set_source_rgb (cr, red, green, blue); cairo_rotate (cr, angle); // Inform Pango to re-layout the text with the new transformation matrix pango_cairo_update_layout (cr, layout); pango_layout_get_size (layout, &width, &height); cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS); pango_cairo_show_layout (cr, layout); cairo_restore (cr); } g_object_unref (layout); g_object_unref (context); |
cairo_region_t * gdk_pango_layout_get_clip_region (PangoLayout *layout,gint x_origin,gint y_origin,const gint *index_ranges,gint n_ranges);
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.
Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn layout may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected.
[skip]
layout |
||
x_origin |
X pixel where you intend to draw the layout with this clip |
|
y_origin |
Y pixel where you intend to draw the layout with this clip |
|
index_ranges |
array of byte indexes into the layout, where even members of array are start indexes and odd elements are end indexes |
|
n_ranges |
number of ranges in |
cairo_region_t * gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,gint x_origin,gint y_origin,const gint *index_ranges,gint n_ranges);
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.
Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn line may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected.
[skip]
line |
||
x_origin |
X pixel where you intend to draw the layout line with this clip |
|
y_origin |
baseline pixel where you intend to draw the layout line with this clip |
|
index_ranges |
array of byte indexes into the layout, where even members of array are start indexes and odd elements are end indexes. |
[array] |
n_ranges |
number of ranges in |
| Top | |
|
|
|
GdkDrawContext is the base object used by contexts implementing different rendering methods, such as GdkGLContext or GdkVulkanContext. It provides shared functionality between those contexts.
You will always interact with one of those s.ubclasses.
A GdkDrawContext is always associated with a single toplevel window.
GdkDisplay *
gdk_draw_context_get_display (GdkDrawContext *context);
Retrieves the GdkDisplay the context
is created for
Since: 3.90
GdkWindow *
gdk_draw_context_get_window (GdkDrawContext *context);
Retrieves the GdkWindow used by the context
.
Since: 3.90
| Top | |
|
|
|
Key values are the codes which are sent whenever a key is pressed or released.
They appear in the GdkEventKey.keyval field of the
GdkEventKey structure, which is passed to signal handlers for the
“key-press-event” and “key-release-event” signals.
The complete list of key values can be found in the
gdk/gdkkeysyms.h header file.
Key values are regularly updated from the upstream X.org X11 implementation, so new values are added regularly. They will be prefixed with GDK_KEY_ rather than XF86XK_ or XK_ (for older symbols).
Key values can be converted into a string representation using
gdk_keyval_name(). The reverse function, converting a string to a key value,
is provided by gdk_keyval_from_name().
The case of key values can be determined using gdk_keyval_is_upper() and
gdk_keyval_is_lower(). Key values can be converted to upper or lower case
using gdk_keyval_to_upper() and gdk_keyval_to_lower().
When it makes sense, key values can be converted to and from
Unicode characters with gdk_keyval_to_unicode() and gdk_unicode_to_keyval().
One GdkKeymap object exists for each user display. To obtain keymaps for
a display, use gdk_display_get_keymap(). A keymap is a mapping from
GdkKeymapKey to key values. You can think of a GdkKeymapKey as a
representation of a symbol printed on a physical keyboard key. That is, it
contains three pieces of information. First, it contains the hardware keycode;
this is an identifying number for a physical key. Second, it contains the
“level” of the key. The level indicates which symbol on the
key will be used, in a vertical direction. So on a standard US keyboard, the key
with the number “1“ on it also has the exclamation point (”!”) character on
it. The level indicates whether to use the “1” or the “!” symbol. The letter
keys are considered to have a lowercase letter at level 0, and an uppercase
letter at level 1, though only the uppercase letter is printed. Third, the
GdkKeymapKey contains a group; groups are not used on standard US keyboards,
but are used in many other countries. On a keyboard with groups, there can be 3
or 4 symbols printed on a single key. The group indicates movement in a
horizontal direction. Usually groups are used for two different languages. In
group 0, a key might have two English characters, and in group 1 it might have
two Hebrew characters. The Hebrew characters will be printed on the key next to
the English characters.
In order to use a keymap to interpret a key event, it’s necessary to first
convert the keyboard state into an effective group and level. This is done via a
set of rules that varies widely according to type of keyboard and user
configuration. The function gdk_keymap_translate_keyboard_state() accepts a
keyboard state -- consisting of hardware keycode pressed, active modifiers, and
active group -- applies the appropriate rules, and returns the group/level to be
used to index the keymap, along with the modifiers which did not affect the
group and level. i.e. it returns “unconsumed modifiers.” The keyboard group may
differ from the effective group used for keymap lookups because some keys don't
have multiple groups - e.g. the Enter key is always in group 0 regardless of
keyboard state.
Note that gdk_keymap_translate_keyboard_state() also returns the keyval, i.e. it
goes ahead and performs the keymap lookup in addition to telling you which
effective group/level values were used for the lookup. GdkEventKey already
contains this keyval, however, so you don’t normally need to call
gdk_keymap_translate_keyboard_state() just to get the keyval.
guint gdk_keymap_lookup_key (GdkKeymap *keymap,const GdkKeymapKey *key);
Looks up the keyval mapped to a keycode/group/level triplet.
If no keyval is bound to key
, returns 0. For normal user input,
you want to use gdk_keymap_translate_keyboard_state() instead of
this function, since the effective group/level may not be
the same as the current keyboard state.
gboolean gdk_keymap_translate_keyboard_state (GdkKeymap *keymap,guint hardware_keycode,GdkModifierType state,gint group,guint *keyval,gint *effective_group,gint *level,GdkModifierType *consumed_modifiers);
Translates the contents of a GdkEventKey into a keyval, effective
group, and level. Modifiers that affected the translation and
are thus unavailable for application use are returned in
consumed_modifiers
.
See Groups for an explanation of
groups and levels. The effective_group
is the group that was
actually used for the translation; some keys such as Enter are not
affected by the active keyboard group. The level
is derived from
state
. For convenience, GdkEventKey already contains the translated
keyval, so this function isn’t as useful as you might think.
consumed_modifiers
gives modifiers that should be masked outfrom state
when comparing this key press to a hot key. For instance, on a US keyboard,
the plus symbol is shifted, so when comparing a key press to a
<Control>plus accelerator <Shift> should be masked out.
1 2 3 4 5 6 7 8 |
// We want to ignore irrelevant modifiers like ScrollLock #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK) gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode, event->state, event->group, &keyval, NULL, NULL, &consumed); if (keyval == GDK_PLUS && (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK) // Control was pressed |
An older interpretation consumed_modifiers
was that it contained
all modifiers that might affect the translation of the key;
this allowed accelerators to be stored with irrelevant consumed
modifiers, by doing:
1 2 3 4 |
// XXX Don’t do this XXX if (keyval == accel_keyval && (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed)) // Accelerator was pressed |
However, this did not work if multi-modifier combinations were
used in the keymap, since, for instance, <Control> would be
masked out even if only <Control><Alt> was used in the keymap.
To support this usage as well as well as possible, all single
modifier combinations that could affect the key for any combination
of modifiers will be returned in consumed_modifiers
; multi-modifier
combinations are returned only when actually found in state
. When
you store accelerators, you should always store them with consumed
modifiers removed. Store <Control>plus, not <Control><Shift>plus,
keymap |
||
hardware_keycode |
a keycode |
|
state |
a modifier state |
|
group |
active keyboard group |
|
keyval |
return location for keyval, or |
[out][allow-none] |
effective_group |
return location for effective
group, or |
[out][allow-none] |
level |
return location for level, or |
[out][allow-none] |
consumed_modifiers |
return location for modifiers
that were used to determine the group or level, or |
[out][allow-none] |
gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap,guint keyval,GdkKeymapKey **keys,gint *n_keys);
Obtains a list of keycode/group/level combinations that will
generate keyval
. Groups and levels are two kinds of keyboard mode;
in general, the level determines whether the top or bottom symbol
on a key is used, and the group determines whether the left or
right symbol is used. On US keyboards, the shift key changes the
keyboard level, and there are no groups. A group switch key might
convert a keyboard between Hebrew to English modes, for example.
GdkEventKey contains a group field that indicates the active
keyboard group. The level is computed from the modifier mask.
The returned array should be freed
with g_free().
keymap |
||
keyval |
a keyval, such as |
|
keys |
return location for an array of GdkKeymapKey. |
[out][array length=n_keys][transfer full] |
n_keys |
return location for number of elements in returned array |
gboolean gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap,guint hardware_keycode,GdkKeymapKey **keys,guint **keyvals,gint *n_entries);
Returns the keyvals bound to hardware_keycode
.
The Nth GdkKeymapKey in keys
is bound to the Nth
keyval in keyvals
. Free the returned arrays with g_free().
When a keycode is pressed by the user, the keyval from
this list of entries is selected by considering the effective
keyboard group and level. See gdk_keymap_translate_keyboard_state().
keymap |
||
hardware_keycode |
a keycode |
|
keys |
return
location for array of GdkKeymapKey, or |
[out][array length=n_entries][transfer full][optional] |
keyvals |
return
location for array of keyvals, or |
[out][array length=n_entries][transfer full][optional] |
n_entries |
length of |
PangoDirection
gdk_keymap_get_direction (GdkKeymap *keymap);
Returns the direction of effective layout of the keymap.
PANGO_DIRECTION_LTR or PANGO_DIRECTION_RTL
if it can determine the direction. PANGO_DIRECTION_NEUTRAL
otherwise.
gboolean
gdk_keymap_have_bidi_layouts (GdkKeymap *keymap);
Determines if keyboard layouts for both right-to-left and left-to-right languages are in use.
Since: 2.12
gboolean
gdk_keymap_get_caps_lock_state (GdkKeymap *keymap);
Returns whether the Caps Lock modifer is locked.
Since: 2.16
gboolean
gdk_keymap_get_num_lock_state (GdkKeymap *keymap);
Returns whether the Num Lock modifer is locked.
Since: 3.0
gboolean
gdk_keymap_get_scroll_lock_state (GdkKeymap *keymap);
Returns whether the Scroll Lock modifer is locked.
Since: 3.18
guint
gdk_keymap_get_modifier_state (GdkKeymap *keymap);
Returns the current modifier state.
Since: 3.4
void gdk_keymap_add_virtual_modifiers (GdkKeymap *keymap,GdkModifierType *state);
Maps the non-virtual modifiers (i.e Mod2, Mod3, ...) which are set
in state
to the virtual modifiers (i.e. Super, Hyper and Meta) and
set the corresponding bits in state
.
GDK already does this before delivering key events, but for compatibility reasons, it only sets the first virtual modifier it finds, whereas this function sets all matching virtual modifiers.
This function is useful when matching key events against accelerators.
Since: 2.20
gboolean gdk_keymap_map_virtual_modifiers (GdkKeymap *keymap,GdkModifierType *state);
Maps the virtual modifiers (i.e. Super, Hyper and Meta) which
are set in state
to their non-virtual counterparts (i.e. Mod2,
Mod3,...) and set the corresponding bits in state
.
This function is useful when matching key events against accelerators.
FALSE if two virtual modifiers were mapped to the
same non-virtual modifier. Note that FALSE is also returned
if a virtual modifier is mapped to a non-virtual modifier that
was already set in state
.
Since: 2.20
GdkModifierType gdk_keymap_get_modifier_mask (GdkKeymap *keymap,GdkModifierIntent intent);
Returns the modifier mask the keymap
’s windowing system backend
uses for a particular purpose.
Note that this function always returns real hardware modifiers, not
virtual ones (e.g. it will return GDK_MOD1_MASK rather than
GDK_META_MASK if the backend maps MOD1 to META), so there are use
cases where the return value of this function has to be transformed
by gdk_keymap_add_virtual_modifiers() in order to contain the
expected result.
Since: 3.4
gchar *
gdk_keyval_name (guint keyval);
Converts a key value into a symbolic name.
The names are the same as those in the
gdk/gdkkeysyms.h header file
but without the leading “GDK_KEY_”.
a string containing the name
of the key, or NULL if keyval
is not a valid key. The string
should not be modified.
[nullable][transfer none]
guint
gdk_keyval_from_name (const gchar *keyval_name);
Converts a key name to a key value.
The names are the same as those in the
gdk/gdkkeysyms.h header file
but without the leading “GDK_KEY_”.
void gdk_keyval_convert_case (guint symbol,guint *lower,guint *upper);
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.
guint
gdk_keyval_to_upper (guint keyval);
Converts a key value to upper case, if applicable.
guint
gdk_keyval_to_lower (guint keyval);
Converts a key value to lower case, if applicable.
gboolean
gdk_keyval_is_upper (guint keyval);
Returns TRUE if the given key value is in upper case.
gboolean
gdk_keyval_is_lower (guint keyval);
Returns TRUE if the given key value is in lower case.
guint32
gdk_keyval_to_unicode (guint keyval);
Convert from a GDK key symbol to the corresponding ISO10646 (Unicode) character.
typedef struct _GdkKeymap GdkKeymap;
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.
struct GdkKeymapKey {
guint keycode;
gint group;
gint level;
};
A GdkKeymapKey is a hardware key that can be mapped to a keyval.
guint |
the hardware keycode. This is an identifying number for a physical key. |
|
gint |
indicates movement in a horizontal direction. Usually groups are used for two different languages. In group 0, a key might have two English characters, and in group 1 it might have two Hebrew characters. The Hebrew characters will be printed on the key next to the English characters. |
|
gint |
indicates which symbol on the key will be used, in a vertical direction. So on a standard US keyboard, the key with the number “1” on it also has the exclamation point ("!") character on it. The level indicates whether to use the “1” or the “!” symbol. The letter keys are considered to have a lowercase letter at level 0, and an uppercase letter at level 1, though only the uppercase letter is printed. |
“display” property“display” GdkDisplay *
The display of the keymap.
Flags: Read / Write / Construct Only
“direction-changed” signalvoid user_function (GdkKeymap *keymap, gpointer user_data)
The ::direction-changed signal gets emitted when the direction of the keymap changes.
keymap |
the object on which the signal is emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.0
“keys-changed” signalvoid user_function (GdkKeymap *keymap, gpointer user_data)
The ::keys-changed signal is emitted when the mapping represented by
keymap
changes.
keymap |
the object on which the signal is emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.2
“state-changed” signalvoid user_function (GdkKeymap *keymap, gpointer user_data)
The ::state-changed signal is emitted when the state of the
keyboard changes, e.g when Caps Lock is turned on or off.
See gdk_keymap_get_caps_lock_state().
keymap |
the object on which the signal is emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.16
| Top | |
|
|
|
| CairoRegion * | clip | Read / Write / Construct Only |
| GdkDrawContext * | paint-context | Read / Write / Construct Only |
| GdkWindow * | window | Read / Write / Construct Only |
GdkDrawingContext is an object that represents the current drawing state of a GdkWindow.
It's possible to use a GdkDrawingContext to draw on a GdkWindow via rendering API like Cairo or OpenGL.
A GdkDrawingContext can only be created by calling gdk_window_begin_draw_frame()
and will be valid until a call to gdk_window_end_draw_frame().
GdkDrawingContext is available since GDK 3.22
GdkWindow *
gdk_drawing_context_get_window (GdkDrawingContext *context);
Retrieves the window that created the drawing context
.
Since: 3.22
cairo_region_t *
gdk_drawing_context_get_clip (GdkDrawingContext *context);
Retrieves a copy of the clip region used when creating the context
.
Since: 3.22
cairo_t *
gdk_drawing_context_get_cairo_context (GdkDrawingContext *context);
Retrieves a Cairo context to be used to draw on the GdkWindow
that created the GdkDrawingContext. The context
must have been
created without a GdkDrawContext for this function to work. If
gdk_drawing_context_get_paint_context() does not return NULL,
then this function will.
The returned context is guaranteed to be valid as long as the
GdkDrawingContext is valid, that is between a call to
gdk_window_begin_draw_frame() and gdk_window_end_draw_frame().
a Cairo context to be used to draw
the contents of the GdkWindow. The context is owned by the
GdkDrawingContext and should not be destroyed. NULL is
returned when a paint context is in used.
[transfer none][nullable]
Since: 3.22
gboolean
gdk_drawing_context_is_valid (GdkDrawingContext *context);
Checks whether the given GdkDrawingContext is valid.
Since: 3.22
GdkDrawContext *
gdk_drawing_context_get_paint_context (GdkDrawingContext *context);
Retrieves the paint context used to draw with.
Since: 3.90
“clip” property “clip” CairoRegion *
The clip region applied to the drawing context.
Flags: Read / Write / Construct Only
Since: 3.22
“paint-context” property“paint-context” GdkDrawContext *
The GdkDrawContext used to draw or NULL if Cairo is used.
Flags: Read / Write / Construct Only
Since: 3.90
| Top | |
|
|
|
| VkDevice | gdk_vulkan_context_get_device () |
| uint32_t | gdk_vulkan_context_get_draw_index () |
| VkSemaphore | gdk_vulkan_context_get_draw_semaphore () |
| VkImage | gdk_vulkan_context_get_image () |
| VkFormat | gdk_vulkan_context_get_image_format () |
| VkInstance | gdk_vulkan_context_get_instance () |
| uint32_t | gdk_vulkan_context_get_n_images () |
| VkPhysicalDevice | gdk_vulkan_context_get_physical_device () |
| VkQueue | gdk_vulkan_context_get_queue () |
| uint32_t | gdk_vulkan_context_get_queue_family_index () |
GdkVulkanContext is an object representing the platform-specific Vulkan draw context.
GdkVulkanContexts are created for a GdkWindow using
gdk_window_create_vulkan_context(), and the context will match the
the characteristics of the window.
Support for GdkVulkanContext is platform-specific, context creation
can fail, returning NULL context.
VkDevice
gdk_vulkan_context_get_device (GdkVulkanContext *context);
Gets the Vulkan device that this context is using.
uint32_t
gdk_vulkan_context_get_draw_index (GdkVulkanContext *context);
Gets the index of the image that is currently being drawn.
This function can only be used between gdk_window_begin_draw_frame() and
gdk_window_end_draw_frame() calls for the toplevel window that the
context
is associated with.
VkSemaphore
gdk_vulkan_context_get_draw_semaphore (GdkVulkanContext *context);
Gets the Vulkan semaphore that protects access to the image that is currently being drawn.
This function can only be used between gdk_window_begin_draw_frame() and
gdk_window_end_draw_frame() calls for the toplevel window that the
context
is associated with.
VkImage gdk_vulkan_context_get_image (GdkVulkanContext *context,guint id);
Gets the image with index id
that this context is using.
VkFormat
gdk_vulkan_context_get_image_format (GdkVulkanContext *context);
Gets the image format that this context is using.
VkInstance
gdk_vulkan_context_get_instance (GdkVulkanContext *context);
Gets the Vulkan instance that is associated with context
.
uint32_t
gdk_vulkan_context_get_n_images (GdkVulkanContext *context);
Gets the number of images that this context is using in its swap chain.
VkPhysicalDevice
gdk_vulkan_context_get_physical_device
(GdkVulkanContext *context);
Gets the Vulkan physical device that this context is using.
VkQueue
gdk_vulkan_context_get_queue (GdkVulkanContext *context);
Gets the Vulkan queue that this context is using.
uint32_t
gdk_vulkan_context_get_queue_family_index
(GdkVulkanContext *context);
Gets the family index for the queue that this context is using.
See vkGetPhysicalDeviceQueueFamilyProperties().
typedef struct _GdkVulkanContext GdkVulkanContext;
The GdkVulkanContext struct contains only private fields and should not be accessed directly.
| Top | |
|
|
|
| #define | GDK_WINDOWING_X11 |
| #define | GDK_WINDOWING_WIN32 |
| #define | GDK_WINDOWING_QUARTZ |
| #define | GDK_WINDOWING_WAYLAND |
| #define | GDK_VERSION_3_0 |
| #define | GDK_VERSION_3_2 |
| #define | GDK_VERSION_3_4 |
| #define | GDK_VERSION_3_6 |
| #define | GDK_VERSION_3_8 |
| #define | GDK_VERSION_3_10 |
| #define | GDK_VERSION_3_12 |
| #define | GDK_VERSION_3_14 |
| #define | GDK_VERSION_3_16 |
| #define | GDK_VERSION_3_18 |
| #define | GDK_VERSION_3_20 |
| #define | GDK_VERSION_3_22 |
| #define | GDK_VERSION_3_90 |
| #define | GDK_VERSION_3_92 |
| #define | GDK_VERSION_3_94 |
| #define | GDK_VERSION_MIN_REQUIRED |
| #define | GDK_VERSION_MAX_ALLOWED |
| #define | GDK_DISABLE_DEPRECATION_WARNINGS |
This section describes the GDK initialization functions and miscellaneous utility functions, as well as deprecation facilities.
The GDK and GTK+ headers annotate deprecated APIs in a way that produces
compiler warnings if these deprecated APIs are used. The warnings
can be turned off by defining the macro GDK_DISABLE_DEPRECATION_WARNINGS
before including the glib.h header.
GDK and GTK+ also provide support for building applications against
defined subsets of deprecated or new APIs. Define the macro
GDK_VERSION_MIN_REQUIRED to specify up to what version
you want to receive warnings about deprecated APIs. Define the
macro GDK_VERSION_MAX_ALLOWED to specify the newest version
whose API you want to use.
#define GDK_WINDOWING_X11
The GDK_WINDOWING_X11 macro is defined if the X11 backend is supported.
Use this macro to guard code that is specific to the X11 backend.
#define GDK_WINDOWING_WIN32
The GDK_WINDOWING_WIN32 macro is defined if the Win32 backend is supported.
Use this macro to guard code that is specific to the Win32 backend.
#define GDK_WINDOWING_QUARTZ
The GDK_WINDOWING_QUARTZ macro is defined if the Quartz backend is supported.
Use this macro to guard code that is specific to the Quartz backend.
#define GDK_WINDOWING_WAYLAND
The GDK_WINDOWING_WAYLAND macro is defined if the Wayland backend is supported.
Use this macro to guard code that is specific to the Wayland backend.
#define GDK_VERSION_3_0 (G_ENCODE_VERSION (3, 0))
A macro that evaluates to the 3.0 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.4
#define GDK_VERSION_3_2 (G_ENCODE_VERSION (3, 2))
A macro that evaluates to the 3.2 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.4
#define GDK_VERSION_3_4 (G_ENCODE_VERSION (3, 4))
A macro that evaluates to the 3.4 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.4
#define GDK_VERSION_3_6 (G_ENCODE_VERSION (3, 6))
A macro that evaluates to the 3.6 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.6
#define GDK_VERSION_3_8 (G_ENCODE_VERSION (3, 8))
A macro that evaluates to the 3.8 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.8
#define GDK_VERSION_3_10 (G_ENCODE_VERSION (3, 10))
A macro that evaluates to the 3.10 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.10
#define GDK_VERSION_3_12 (G_ENCODE_VERSION (3, 12))
A macro that evaluates to the 3.12 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.12
#define GDK_VERSION_3_14 (G_ENCODE_VERSION (3, 14))
A macro that evaluates to the 3.14 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.14
#define GDK_VERSION_3_16 (G_ENCODE_VERSION (3, 16))
A macro that evaluates to the 3.16 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.16
#define GDK_VERSION_3_18 (G_ENCODE_VERSION (3, 18))
A macro that evaluates to the 3.18 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.18
#define GDK_VERSION_3_20 (G_ENCODE_VERSION (3, 20))
A macro that evaluates to the 3.20 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.18
#define GDK_VERSION_3_22 (G_ENCODE_VERSION (3, 22))
A macro that evaluates to the 3.22 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.20
#define GDK_VERSION_3_90 (G_ENCODE_VERSION (3, 90))
A macro that evaluates to the 3.90 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.90
#define GDK_VERSION_3_92 (G_ENCODE_VERSION (3, 92))
A macro that evaluates to the 3.92 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.92
#define GDK_VERSION_3_94 (G_ENCODE_VERSION (3, 94))
A macro that evaluates to the 3.94 version of GDK, in a format that can be used by the C pre-processor.
Since: 3.94
# define GDK_VERSION_MIN_REQUIRED (GDK_VERSION_CUR_STABLE)
A macro that should be defined by the user prior to including
the gdk.h header.
The definition should be one of the predefined GDK version
macros: GDK_VERSION_3_0, GDK_VERSION_3_2,...
This macro defines the lower bound for the GDK API to use.
If a function has been deprecated in a newer version of GDK, it is possible to use this symbol to avoid the compiler warnings without disabling warning for every deprecated function.
Since: 3.4
# define GDK_VERSION_MAX_ALLOWED GDK_VERSION_MIN_REQUIRED
A macro that should be defined by the user prior to including
the gdk.h header.
The definition should be one of the predefined GDK version
macros: GDK_VERSION_3_0, GDK_VERSION_3_2,...
This macro defines the upper bound for the GDK API to use.
If a function has been introduced in a newer version of GDK, it is possible to use this symbol to get compiler warnings when trying to use that function.
Since: 3.4
GDK 4 Reference Manual |
|---|
This document is for the GDK 4 library, version 3.93.0 . The latest versions can be found online at https://developer.gnome.org/gdk4/. If you are looking for the older GDK 3 series of libraries, see https://developer.gnome.org/gdk3/.
| Top | |
|
|
|
| #define | GDK_THREADS_ENTER |
| #define | GDK_THREADS_LEAVE |
| void | gdk_threads_init () |
| void | gdk_threads_enter () |
| void | gdk_threads_leave () |
| guint | gdk_threads_add_idle () |
| guint | gdk_threads_add_idle_full () |
| guint | gdk_threads_add_timeout () |
| guint | gdk_threads_add_timeout_full () |
| guint | gdk_threads_add_timeout_seconds () |
| guint | gdk_threads_add_timeout_seconds_full () |
For thread safety, GDK relies on the thread primitives in GLib, and on the thread-safe GLib main loop.
GLib is completely thread safe (all global data is automatically locked), but individual data structure instances are not automatically locked for performance reasons. So e.g. you must coordinate accesses to the same GHashTable from multiple threads.
GTK+, however, is not thread safe. You should only use GTK+ and GDK
from the thread gtk_init() and gtk_main() were called on.
This is usually referred to as the “main thread”.
Signals on GTK+ and GDK types, as well as non-signal callbacks, are emitted in the main thread.
You can schedule work in the main thread safely from other threads
by using gdk_threads_add_idle() and gdk_threads_add_timeout():
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
static void worker_thread (void) { ExpensiveData *expensive_data = do_expensive_computation (); gdk_threads_add_idle (got_value, expensive_data); } static gboolean got_value (gpointer user_data) { ExpensiveData *expensive_data = user_data; my_app->expensive_data = expensive_data; gtk_button_set_sensitive (my_app->button, TRUE); gtk_button_set_label (my_app->button, expensive_data->result_label); return G_SOURCE_REMOVE; } |
You should use gdk_threads_add_idle() and gdk_threads_add_timeout()
instead of g_idle_add() and g_timeout_add() since libraries not under
your control might be using the deprecated GDK locking mechanism.
If you are sure that none of the code in your application and libraries
use the deprecated gdk_threads_enter() or gdk_threads_leave() methods,
then you can safely use g_idle_add() and g_timeout_add().
For more information on this "worker thread" pattern, you should also look at GTask, which gives you high-level tools to perform expensive tasks from worker threads, and will handle thread management for you.
#define GDK_THREADS_ENTER() gdk_threads_enter()
GDK_THREADS_ENTER has been deprecated since version 3.6 and should not be used in newly-written code.
Use g_main_context_invoke(), g_idle_add() and related
functions if you need to schedule GTK+ calls from other threads.
This macro 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. The macro expands to a no-op if G_THREADS_ENABLED has not
been defined. Typically gdk_threads_enter() should be used instead of
this macro.
#define GDK_THREADS_LEAVE() gdk_threads_leave()
GDK_THREADS_LEAVE has been deprecated since version 3.6 and should not be used in newly-written code.
Deprecated in 3.6.
This macro marks the end of a critical section begun with GDK_THREADS_ENTER.
void
gdk_threads_init (void);
gdk_threads_init has been deprecated since version 3.6 and should not be used in newly-written code.
All GDK and GTK+ calls should be made from the main thread
Initializes GDK so that it can be used from multiple threads
in conjunction with gdk_threads_enter() and gdk_threads_leave().
This call must be made before any use of the main loop from
GTK+; to be safe, call it before gtk_init().
void
gdk_threads_enter (void);
gdk_threads_enter has been deprecated since version 3.6 and should not be used in newly-written code.
All GDK and GTK+ calls should be made from the main thread
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.
void
gdk_threads_leave (void);
gdk_threads_leave has been deprecated since version 3.6 and should not be used in newly-written code.
All GDK and GTK+ calls should be made from the main thread
Leaves a critical region begun with gdk_threads_enter().
guint gdk_threads_add_idle (GSourceFunc function,gpointer data);
A wrapper for the common usage of gdk_threads_add_idle_full()
assigning the default priority, G_PRIORITY_DEFAULT_IDLE.
See gdk_threads_add_idle_full().
[skip]
Since: 2.12
guint gdk_threads_add_idle_full (gint priority,GSourceFunc function,gpointer data,GDestroyNotify notify);
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.
This variant of g_idle_add_full() calls function
with the GDK lock
held. It can be thought of a MT-safe version for GTK+ widgets for the
following use case, where you have to worry about idle_callback()
running in thread A and accessing self
after it has been finalized
in thread B:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
static gboolean idle_callback (gpointer data) { // gdk_threads_enter(); would be needed for g_idle_add() SomeWidget *self = data; // do stuff with self self->idle_id = 0; // gdk_threads_leave(); would be needed for g_idle_add() return FALSE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->idle_id = gdk_threads_add_idle (idle_callback, self) // using g_idle_add() here would require thread protection in the callback } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->idle_id) g_source_remove (self->idle_id); G_OBJECT_CLASS (parent_class)->finalize (object); } |
[rename-to gdk_threads_add_idle]
priority |
the priority of the idle source. Typically this will be in the range between G_PRIORITY_DEFAULT_IDLE and G_PRIORITY_HIGH_IDLE |
|
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the idle is removed, or |
[allow-none] |
Since: 2.12
guint gdk_threads_add_timeout (guint interval,GSourceFunc function,gpointer data);
A wrapper for the common usage of gdk_threads_add_timeout_full()
assigning the default priority, G_PRIORITY_DEFAULT.
See gdk_threads_add_timeout_full().
[skip]
interval |
the time between calls to the function, in milliseconds (1/1000ths of a second) |
|
function |
function to call |
|
data |
data to pass to |
Since: 2.12
guint gdk_threads_add_timeout_full (gint priority,guint interval,GSourceFunc function,gpointer data,GDestroyNotify notify);
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
.
Note that timeout functions may be delayed, due to the processing of other event sources. Thus they should not be relied on for precise timing. After each call to the timeout function, the time of the next timeout is recalculated based on the current time and the given interval (it does not try to “catch up” time lost in delays).
This variant of g_timeout_add_full() can be thought of a MT-safe version
for GTK+ widgets for the following use case:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
static gboolean timeout_callback (gpointer data) { SomeWidget *self = data; // do stuff with self self->timeout_id = 0; return G_SOURCE_REMOVE; } static void some_widget_do_stuff_later (SomeWidget *self) { self->timeout_id = g_timeout_add (timeout_callback, self) } static void some_widget_finalize (GObject *object) { SomeWidget *self = SOME_WIDGET (object); if (self->timeout_id) g_source_remove (self->timeout_id); G_OBJECT_CLASS (parent_class)->finalize (object); } |
[rename-to gdk_threads_add_timeout]
priority |
the priority of the timeout source. Typically this will be in the range between G_PRIORITY_DEFAULT_IDLE and G_PRIORITY_HIGH_IDLE. |
|
interval |
the time between calls to the function, in milliseconds (1/1000ths of a second) |
|
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed, or |
[allow-none] |
Since: 2.12
guint gdk_threads_add_timeout_seconds (guint interval,GSourceFunc function,gpointer data);
A wrapper for the common usage of gdk_threads_add_timeout_seconds_full()
assigning the default priority, G_PRIORITY_DEFAULT.
For details, see gdk_threads_add_timeout_full().
[skip]
interval |
the time between calls to the function, in seconds |
|
function |
function to call |
|
data |
data to pass to |
Since: 2.14
guint gdk_threads_add_timeout_seconds_full (gint priority,guint interval,GSourceFunc function,gpointer data,GDestroyNotify notify);
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.
[rename-to gdk_threads_add_timeout_seconds]
priority |
the priority of the timeout source. Typically this will be in the range between G_PRIORITY_DEFAULT_IDLE and G_PRIORITY_HIGH_IDLE. |
|
interval |
the time between calls to the function, in seconds |
|
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed, or |
[allow-none] |
Since: 2.14
| Top | |
|
|
|
Pixbufs are client-side images. For details on how to create and manipulate pixbufs, see the GdkPixbuf API documentation.
The functions described here allow to obtain pixbufs from GdkWindows and cairo surfaces.
GdkPixbuf * gdk_pixbuf_get_from_surface (cairo_surface_t *surface,gint src_x,gint src_y,gint width,gint height);
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.
This function will create an RGB pixbuf with 8 bits per channel.
The pixbuf will contain an alpha channel if the surface
contains one.
surface |
surface to copy from |
|
src_x |
Source X coordinate within |
|
src_y |
Source Y coordinate within |
|
width |
Width in pixels of region to get |
|
height |
Height in pixels of region to get |
A newly-created pixbuf with a
reference count of 1, or NULL on error.
[nullable][transfer full]
| Top | |
|
|
|
| GdkDevice * | associated-device | Read |
| GdkAxisFlags | axes | Read |
| GdkDisplay * | display | Read / Write / Construct Only |
| gboolean | has-cursor | Read / Write / Construct Only |
| GdkInputMode | input-mode | Read / Write |
| GdkInputSource | input-source | Read / Write / Construct Only |
| guint | n-axes | Read |
| gchar * | name | Read / Write / Construct Only |
| guint | num-touches | Read / Write / Construct Only |
| gchar * | product-id | Read / Write / Construct Only |
| GdkSeat * | seat | Read / Write |
| GdkDeviceTool * | tool | Read |
| GdkDeviceType | type | Read / Write / Construct Only |
| gchar * | vendor-id | Read / Write / Construct Only |
| GdkDevice | |
| enum | GdkInputSource |
| enum | GdkInputMode |
| enum | GdkAxisUse |
| enum | GdkAxisFlags |
| enum | GdkDeviceToolType |
| enum | GdkDeviceType |
| enum | GdkGrabOwnership |
| struct | GdkTimeCoord |
The GdkDevice object represents a single input device, such as a keyboard, a mouse, a touchpad, etc.
See the GdkSeat documentation for more information about the various kinds of master and slave devices, and their relationships.
const gchar *
gdk_device_get_name (GdkDevice *device);
Determines the name of the device.
Since: 2.20
const gchar *
gdk_device_get_vendor_id (GdkDevice *device);
Returns the vendor ID of this device, or NULL if this information couldn't
be obtained. This ID is retrieved from the device, and is thus constant for
it.
This function, together with gdk_device_get_product_id(), can be used to eg.
compose GSettings paths to store settings for this device.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
static GSettings * get_device_settings (GdkDevice *device) { const gchar *vendor, *product; GSettings *settings; GdkDevice *device; gchar *path; vendor = gdk_device_get_vendor_id (device); product = gdk_device_get_product_id (device); path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product); settings = g_settings_new_with_path (DEVICE_SCHEMA, path); g_free (path); return settings; } |
Since: 3.16
const gchar *
gdk_device_get_product_id (GdkDevice *device);
Returns the product ID of this device, or NULL if this information couldn't
be obtained. This ID is retrieved from the device, and is thus constant for
it. See gdk_device_get_vendor_id() for more information.
Since: 3.16
GdkInputSource
gdk_device_get_source (GdkDevice *device);
Determines the type of the device.
Since: 2.20
gboolean gdk_device_set_mode (GdkDevice *device,GdkInputMode mode);
Sets a the mode of an input device. The mode controls if the device is active and whether the device’s range is mapped to the entire screen or to a single window.
Note: This is only meaningful for floating devices, master devices (and slaves connected to these) drive the pointer cursor, which is not limited by the input mode.
GdkInputMode
gdk_device_get_mode (GdkDevice *device);
Determines the mode of the device.
Since: 2.20
void gdk_device_set_key (GdkDevice *device,guint index_,guint keyval,GdkModifierType modifiers);
Specifies the X key event to generate when a macro button of a device is pressed.
gboolean gdk_device_get_key (GdkDevice *device,guint index_,guint *keyval,GdkModifierType *modifiers);
If index_
has a valid keyval, this function will return TRUE
and fill in keyval
and modifiers
with the keyval settings.
device |
a GdkDevice. |
|
index_ |
the index of the macro button to get. |
|
keyval |
return value for the keyval. |
[out] |
modifiers |
return value for modifiers. |
[out] |
Since: 2.20
void gdk_device_set_axis_use (GdkDevice *device,guint index_,GdkAxisUse use);
Specifies how an axis of a device is used.
device |
a pointer GdkDevice |
|
index_ |
the index of the axis |
|
use |
specifies how the axis is used |
GdkAxisUse gdk_device_get_axis_use (GdkDevice *device,guint index_);
Returns the axis use for index_
.
Since: 2.20
GdkDevice *
gdk_device_get_associated_device (GdkDevice *device);
Returns the associated device to device
, if device
is of type
GDK_DEVICE_TYPE_MASTER, it will return the paired pointer or
keyboard.
If device
is of type GDK_DEVICE_TYPE_SLAVE, it will return
the master device to which device
is attached to.
If device
is of type GDK_DEVICE_TYPE_FLOATING, NULL will be
returned, as there is no associated device.
Since: 3.0
GList *
gdk_device_list_slave_devices (GdkDevice *device);
If the device if of type GDK_DEVICE_TYPE_MASTER, it will return
the list of slave devices attached to it, otherwise it will return
NULL
the list of slave devices, or NULL. The list must be
freed with g_list_free(), the contents of the list are
owned by GTK+ and should not be freed.
[nullable][transfer container][element-type GdkDevice]
GdkDeviceType
gdk_device_get_device_type (GdkDevice *device);
Returns the device type for device
.
Since: 3.0
GdkDisplay *
gdk_device_get_display (GdkDevice *device);
Returns the GdkDisplay to which device
pertains.
a GdkDisplay. This memory is owned by GTK+, and must not be freed or unreffed.
[transfer none]
Since: 3.0
gboolean
gdk_device_get_has_cursor (GdkDevice *device);
Determines whether the pointer follows device motion. This is not meaningful for keyboard devices, which don't have a pointer.
Since: 2.20
gint
gdk_device_get_n_axes (GdkDevice *device);
Returns the number of axes the device currently has.
Since: 3.0
gint
gdk_device_get_n_keys (GdkDevice *device);
Returns the number of keys the device currently has.
Since: 2.24
GdkAxisFlags
gdk_device_get_axes (GdkDevice *device);
Returns the axes currently available on the device.
Since: 3.22
void gdk_device_warp (GdkDevice *device,gint x,gint y);
Warps device
in display
to the point x
,y
,
unless the device is confined to a window by a grab,
in which case it will be moved
as far as allowed by the grab. Warping the pointer
creates events as if the user had moved the mouse
instantaneously to the destination.
Note that the pointer should normally be under the control of the user. This function was added to cover some rare use cases like keyboard navigation support for the color picker in the GtkColorSelectionDialog.
device |
the device to warp. |
|
x |
the X coordinate of the destination. |
|
y |
the Y coordinate of the destination. |
Since: 3.0
GdkSeat *
gdk_device_get_seat (GdkDevice *device);
Returns the GdkSeat the device belongs to.
Since: 3.20
GdkGrabStatus gdk_device_grab (GdkDevice *device,GdkWindow *window,GdkGrabOwnership grab_ownership,gboolean owner_events,GdkEventMask event_mask,GdkCursor *cursor,guint32 time_);
gdk_device_grab has been deprecated since version 3.20. and should not be used in newly-written code.
Use gdk_seat_grab() instead.
Grabs the device so that all events coming from this device are passed to
this application until the device is ungrabbed with gdk_device_ungrab(),
or the window becomes unviewable. This overrides any previous grab on the device
by this client.
Note that device
and window
need to be on the same display.
Device grabs are used for operations which need complete control over the given device events (either pointer or keyboard). For example in GTK+ this is used for Drag and Drop operations, popup menus and such.
Note that if the event mask of an X window has selected both button press
and button release events, then a button press event will cause an automatic
pointer grab until the button is released. X does this automatically since
most applications expect to receive button press and release events in pairs.
It is equivalent to a pointer grab on the window with owner_events
set to
TRUE.
If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily.
device |
a GdkDevice. To get the device you can use |
|
window |
the GdkWindow which will own the grab (the grab window) |
|
grab_ownership |
specifies the grab ownership. |
|
owner_events |
if |
|
event_mask |
specifies the event mask, which is used in accordance with
|
|
cursor |
the cursor to display while the grab is active if the device is
a pointer. If this is |
[allow-none] |
time_ |
the timestamp of the event which led to this pointer grab. This
usually comes from the GdkEvent struct, though |
Since: 3.0
void gdk_device_ungrab (GdkDevice *device,guint32 time_);
gdk_device_ungrab has been deprecated since version 3.20. and should not be used in newly-written code.
Use gdk_seat_ungrab() instead.
Release any grab on device
.
Since: 3.0
void gdk_device_get_state (GdkDevice *device,GdkWindow *window,gdouble *axes,GdkModifierType *mask);
Gets the current state of a pointer device relative to window
. As a slave
device’s coordinates are those of its master pointer, this
function may not be called on devices of type GDK_DEVICE_TYPE_SLAVE,
unless there is an ongoing grab on them. See gdk_device_grab().
[skip]
void gdk_device_get_position (GdkDevice *device,gint *x,gint *y);
Gets the current location of device
. As a slave device
coordinates are those of its master pointer, This function
may not be called on devices of type GDK_DEVICE_TYPE_SLAVE,
unless there is an ongoing grab on them, see gdk_device_grab().
Since: 3.0
void gdk_device_get_position_double (GdkDevice *device,gdouble *x,gdouble *y);
Gets the current location of device
in double precision. As a slave device's
coordinates are those of its master pointer, this function
may not be called on devices of type GDK_DEVICE_TYPE_SLAVE,
unless there is an ongoing grab on them. See gdk_device_grab().
Since: 3.10
GdkWindow * gdk_device_get_window_at_position (GdkDevice *device,gint *win_x,gint *win_y);
Obtains the window underneath device
, returning the location of the device in win_x
and win_y
. Returns
NULL if the window tree under device
is not known to GDK (for example, belongs to another application).
As a slave device coordinates are those of its master pointer, This
function may not be called on devices of type GDK_DEVICE_TYPE_SLAVE,
unless there is an ongoing grab on them, see gdk_device_grab().
Since: 3.0
GdkWindow * gdk_device_get_window_at_position_double (GdkDevice *device,gdouble *win_x,gdouble *win_y);
Obtains the window underneath device
, returning the location of the device in win_x
and win_y
in
double precision. Returns NULL if the window tree under device
is not known to GDK (for example,
belongs to another application).
As a slave device coordinates are those of its master pointer, This
function may not be called on devices of type GDK_DEVICE_TYPE_SLAVE,
unless there is an ongoing grab on them, see gdk_device_grab().
Since: 3.0
gboolean gdk_device_get_history (GdkDevice *device,GdkWindow *window,guint32 start,guint32 stop,GdkTimeCoord ***events,gint *n_events);
Obtains the motion history for a pointer device; given a starting and
ending timestamp, return all events in the motion history for
the device in the given range of time. Some windowing systems
do not support motion history, in which case, FALSE will
be returned. (This is not distinguishable from the case where
motion history is supported and no events were found.)
Note that there is also gdk_window_set_event_compression() to get
more motion events delivered directly, independent of the windowing
system.
[skip]
device |
||
window |
the window with respect to which which the event coordinates will be reported |
|
start |
starting timestamp for range of events to return |
|
stop |
ending timestamp for the range of events to return |
|
events |
location to store a newly-allocated array of GdkTimeCoord, or
|
[array length=n_events][out][transfer full][optional] |
n_events |
location to store the length of
|
[out][optional] |
void gdk_device_free_history (GdkTimeCoord **events,gint n_events);
Frees an array of GdkTimeCoord that was returned by gdk_device_get_history().
[skip]
events |
an array of GdkTimeCoord. |
[array length=n_events] |
n_events |
the length of the array. |
gboolean gdk_device_get_axis (GdkDevice *device,gdouble *axes,GdkAxisUse use,gdouble *value);
Interprets an array of double as axis values for a given device, and locates the value in the array for a given axis use.
[skip]
GList *
gdk_device_list_axes (GdkDevice *device);
Returns a GList of GdkAtoms, containing the labels for
the axes that device
currently has.
Since: 3.0
gboolean gdk_device_get_axis_value (GdkDevice *device,gdouble *axes,GdkAtom axis_label,gdouble *value);
Interprets an array of double as axis values for a given device,
and locates the value in the array for a given axis label, as returned
by gdk_device_list_axes()
[skip]
device |
a pointer GdkDevice. |
|
axes |
pointer to an array of axes. |
[array] |
axis_label |
name of the label |
|
value |
location to store the found value. |
[out] |
Since: 3.0
GdkWindow *
gdk_device_get_last_event_window (GdkDevice *device);
Gets information about which window the given pointer device is in, based on events
that have been received so far from the display server. If another application
has a pointer grab, or this application has a grab with owner_events = FALSE,
NULL may be returned even if the pointer is physically over one of this
application's windows.
Since: 3.12
guint64
gdk_device_tool_get_serial (GdkDeviceTool *tool);
Gets the serial of this tool, this value can be used to identify a physical tool (eg. a tablet pen) across program executions.
Since: 3.22
GdkDeviceToolType
gdk_device_tool_get_tool_type (GdkDeviceTool *tool);
Gets the GdkDeviceToolType of the tool.
The physical type for this tool. This can be used to figure out what sort of pen is being used, such as an airbrush or a pencil.
Since: 3.22
guint64
gdk_device_tool_get_hardware_id (GdkDeviceTool *tool);
Gets the hardware ID of this tool, or 0 if it's not known. When
non-zero, the identificator is unique for the given tool model,
meaning that two identical tools will share the same hardware_id
,
but will have different serial numbers (see gdk_device_tool_get_serial()).
This is a more concrete (and device specific) method to identify
a GdkDeviceTool than gdk_device_tool_get_tool_type(), as a tablet
may support multiple devices with the same GdkDeviceToolType,
but having different hardware identificators.
Since: 3.22
typedef struct _GdkDevice GdkDevice;
The GdkDevice struct contains only private fields and should not be accessed directly.
An enumeration describing the type of an input device in general terms.
|
the device is a mouse. (This will be reported for the core pointer, even if it is something else, such as a trackball.) |
||
|
the device is a stylus of a graphics tablet or similar device. |
||
|
the device is an eraser. Typically, this would be the other end of a stylus on a graphics tablet. |
||
|
the device is a graphics tablet “puck” or similar device. |
||
|
the device is a keyboard. |
||
|
the device is a direct-input touch device, such as a touchscreen or tablet. This device type has been added in 3.4. |
||
|
the device is an indirect touch device, such as a touchpad. This device type has been added in 3.4. |
||
|
the device is a trackpoint. This device type has been added in 3.22 |
||
|
the device is a "pad", a collection of buttons, rings and strips found in drawing tablets. This device type has been added in 3.22. |
An enumeration that describes the mode of an input device.
|
the device is disabled and will not report any events. |
||
|
the device is enabled. The device’s coordinate space maps to the entire screen. |
||
|
the device is enabled. The device’s coordinate space is mapped to a single window. The manner in which this window is chosen is undefined, but it will typically be the same way in which the focus window for key events is determined. |
An enumeration describing the way in which a device axis (valuator) maps onto the predefined valuator types that GTK+ understands.
Note that the X and Y axes are not really needed; pointer devices report their location via the x/y members of events regardless. Whether X and Y are present as axes depends on the GDK backend.
|
the axis is ignored. |
||
|
the axis is used as the x axis. |
||
|
the axis is used as the y axis. |
||
|
the axis is used for pressure information. |
||
|
the axis is used for x tilt information. |
||
|
the axis is used for y tilt information. |
||
|
the axis is used for wheel information. |
||
|
the axis is used for pen/tablet distance information. (Since: 3.22) |
||
|
the axis is used for pen rotation information. (Since: 3.22) |
||
|
the axis is used for pen slider information. (Since: 3.22) |
||
|
a constant equal to the numerically highest axis value. |
Flags describing the current capabilities of a device/tool.
|
X axis is present |
||
|
Y axis is present |
||
|
Pressure axis is present |
||
|
X tilt axis is present |
||
|
Y tilt axis is present |
||
|
Wheel axis is present |
||
|
Distance axis is present |
||
|
Z-axis rotation is present |
||
|
Slider axis is present |
Since: 3.22
Indicates the specific type of tool being used being a tablet. Such as an airbrush, pencil, etc.
|
Tool is of an unknown type. |
||
|
Tool is a standard tablet stylus. |
||
|
Tool is standard tablet eraser. |
||
|
Tool is a brush stylus. |
||
|
Tool is a pencil stylus. |
||
|
Tool is an airbrush stylus. |
||
|
Tool is a mouse. |
||
|
Tool is a lens cursor. |
Since: 3.22
struct GdkTimeCoord {
guint32 time;
gdouble axes[GDK_MAX_TIMECOORD_AXES];
};
A GdkTimeCoord stores a single event in a motion history.
“associated-device” property“associated-device” GdkDevice *
Associated pointer or keyboard with this device, if any. Devices of type GDK_DEVICE_TYPE_MASTER
always come in keyboard/pointer pairs. Other device types will have a NULL associated device.
Flags: Read
Since: 3.0
“axes” property“axes” GdkAxisFlags
The axes currently available for this device.
Flags: Read
Since: 3.22
“display” property“display” GdkDisplay *
The GdkDisplay the GdkDevice pertains to.
Flags: Read / Write / Construct Only
Since: 3.0
“has-cursor” property“has-cursor” gboolean
Whether the device is represented by a cursor on the screen. Devices of type
GDK_DEVICE_TYPE_MASTER will have TRUE here.
Flags: Read / Write / Construct Only
Default value: FALSE
Since: 3.0
“input-mode” property“input-mode” GdkInputMode
Input mode for the device.
Flags: Read / Write
Default value: GDK_MODE_DISABLED
“input-source” property“input-source” GdkInputSource
Source type for the device.
Flags: Read / Write / Construct Only
Default value: GDK_SOURCE_MOUSE
Since: 3.0
“n-axes” property“n-axes” guint
Number of axes in the device.
Flags: Read
Default value: 0
Since: 3.0
“name” property“name” gchar *
The device name.
Flags: Read / Write / Construct Only
Default value: NULL
Since: 3.0
“num-touches” property“num-touches” guint
The maximal number of concurrent touches on a touch device. Will be 0 if the device is not a touch device or if the number of touches is unknown.
Flags: Read / Write / Construct Only
Default value: 0
Since: 3.20
“product-id” property“product-id” gchar *
Product ID of this device, see gdk_device_get_product_id().
Flags: Read / Write / Construct Only
Default value: NULL
Since: 3.16
“tool” property “tool” GdkDeviceTool *
The tool that is currently used with this device.
Flags: Read
“type” property“type” GdkDeviceType
Device role in the device manager.
Flags: Read / Write / Construct Only
Default value: GDK_DEVICE_TYPE_MASTER
Since: 3.0
“vendor-id” property“vendor-id” gchar *
Vendor ID of this device, see gdk_device_get_vendor_id().
Flags: Read / Write / Construct Only
Default value: NULL
Since: 3.16
“changed” signalvoid user_function (GdkDevice *device, gpointer user_data)
The ::changed signal is emitted either when the GdkDevice has changed the number of either axes or keys. For example In X this will normally happen when the slave device routing events through the master device changes (for example, user switches from the USB mouse to a tablet), in that case the master device will change to reflect the new slave device axes and keys.
device |
the GdkDevice that changed. |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“tool-changed” signalvoid user_function (GdkDevice *device, GdkDeviceTool *tool, gpointer user_data)
The ::tool-changed signal is emitted on pen/eraser GdkDevices whenever tools enter or leave proximity.
device |
the GdkDevice that changed. |
|
tool |
The new current tool |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.22
|
|
|
|
| Top | |
|
|
|
| void | (*GdkSeatGrabPrepareFunc) () |
| GdkDisplay * | gdk_seat_get_display () |
| GdkGrabStatus | gdk_seat_grab () |
| void | gdk_seat_ungrab () |
| GdkSeatCapabilities | gdk_seat_get_capabilities () |
| GdkDevice * | gdk_seat_get_pointer () |
| GdkDevice * | gdk_seat_get_keyboard () |
| GList * | gdk_seat_get_slaves () |
| GList * | gdk_seat_get_master_pointers () |
| void | device-added | Run Last |
| void | device-removed | Run Last |
| void | tool-added | Run Last |
| void | tool-removed | Run Last |
void (*GdkSeatGrabPrepareFunc) (GdkSeat *seat,GdkWindow *window,gpointer user_data);
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.
seat |
the GdkSeat being grabbed |
|
window |
the GdkWindow being grabbed |
|
user_data |
user data passed in |
Since: 3.20
GdkDisplay *
gdk_seat_get_display (GdkSeat *seat);
Returns the GdkDisplay this seat belongs to.
GdkGrabStatus gdk_seat_grab (GdkSeat *seat,GdkWindow *window,GdkSeatCapabilities capabilities,gboolean owner_events,GdkCursor *cursor,const GdkEvent *event,GdkSeatGrabPrepareFunc prepare_func,gpointer prepare_func_data);
Grabs the seat so that all events corresponding to the given capabilities
are passed to this application until the seat is ungrabbed with gdk_seat_ungrab(),
or the window becomes hidden. This overrides any previous grab on the
seat by this client.
As a rule of thumb, if a grab is desired over GDK_SEAT_CAPABILITY_POINTER,
all other "pointing" capabilities (eg. GDK_SEAT_CAPABILITY_TOUCH) should
be grabbed too, so the user is able to interact with all of those while
the grab holds, you should thus use GDK_SEAT_CAPABILITY_ALL_POINTING most
commonly.
Grabs are used for operations which need complete control over the events corresponding to the given capabilities. For example in GTK+ this is used for Drag and Drop operations, popup menus and such.
Note that if the event mask of a GdkWindow has selected both button press
and button release events, or touch begin and touch end, then a press event
will cause an automatic grab until the button is released, equivalent to a
grab on the window with owner_events
set to TRUE. This is done because most
applications expect to receive paired press and release events.
If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily.
seat |
a GdkSeat |
|
window |
the GdkWindow which will own the grab |
|
capabilities |
capabilities that will be grabbed |
|
owner_events |
if |
|
cursor |
the cursor to display while the grab is active. If
this is |
[nullable] |
event |
the event that is triggering the grab, or |
[nullable] |
prepare_func |
function to
prepare the window to be grabbed, it can be |
[nullable][scope call][closure prepare_func_data] |
prepare_func_data |
user data to pass to |
Since: 3.20
void
gdk_seat_ungrab (GdkSeat *seat);
Releases a grab added through gdk_seat_grab().
Since: 3.20
GdkSeatCapabilities
gdk_seat_get_capabilities (GdkSeat *seat);
Returns the capabilities this GdkSeat currently has.
Since: 3.20
GdkDevice *
gdk_seat_get_pointer (GdkSeat *seat);
Returns the master device that routes pointer events.
a master GdkDevice with pointer capabilities. This object is owned by GTK+ and must not be freed.
[transfer none][nullable]
Since: 3.20
GdkDevice *
gdk_seat_get_keyboard (GdkSeat *seat);
Returns the master device that routes keyboard events.
a master GdkDevice with keyboard capabilities. This object is owned by GTK+ and must not be freed.
[transfer none][nullable]
Since: 3.20
GList * gdk_seat_get_slaves (GdkSeat *seat,GdkSeatCapabilities capabilities);
Returns the slave devices that match the given capabilities.
A list of GdkDevices.
The list must be freed with g_list_free(), the elements are owned
by GDK and must not be freed.
[transfer container][element-type GdkDevice]
Since: 3.20
GList * gdk_seat_get_master_pointers (GdkSeat *seat,GdkSeatCapabilities capabilities);
Returns all master pointers with the given capabilities driven by this seat
.
On most backends this function will return a list with a single element (meaning
that all input devices drive the same onscreen cursor).
In other backends where there can possibly be multiple foci (eg. wayland), this function will return all master GdkDevices that represent these.
Since: 3.93.
typedef struct _GdkSeat GdkSeat;
The GdkSeat struct contains only private fields and should not be accessed directly.
Flags describing the seat capabilities.
|
No input capabilities |
||
|
The seat has a pointer (e.g. mouse) |
||
|
The seat has touchscreen(s) attached |
||
|
The seat has drawing tablet(s) attached |
||
|
The seat has keyboard(s) attached |
||
|
The seat has drawing tablet pad(s) attached |
||
|
The union of all pointing capabilities |
||
|
The union of all capabilities |
Since: 3.20
Returned by gdk_device_grab() to indicate success or the reason for the
failure of the grab attempt.
|
the resource was successfully grabbed. |
||
|
the resource is actively grabbed by another client. |
||
|
the resource was grabbed more recently than the specified time. |
||
|
the grab window or the |
||
|
the resource is frozen by an active grab of another client. |
||
|
the grab failed for some other reason. Since 3.16 |
“display” property“display” GdkDisplay *
GdkDisplay of this seat.
Flags: Read / Write / Construct Only
Since: 3.20
“device-added” signalvoid user_function (GdkSeat *seat, GdkDevice *device, gpointer user_data)
The ::device-added signal is emitted when a new input device is related to this seat.
seat |
the object on which the signal is emitted |
|
device |
the newly added GdkDevice. |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“device-removed” signalvoid user_function (GdkSeat *seat, GdkDevice *device, gpointer user_data)
The ::device-removed signal is emitted when an input device is removed (e.g. unplugged).
seat |
the object on which the signal is emitted |
|
device |
the just removed GdkDevice. |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“tool-added” signalvoid user_function (GdkSeat *seat, GdkDeviceTool *tool, gpointer user_data)
The ::tool-added signal is emitted whenever a new tool is made known to the seat. The tool may later be assigned to a device (i.e. on proximity with a tablet). The device will emit the “tool-changed” signal accordingly.
A same tool may be used by several devices.
seat |
the object on which the signal is emitted |
|
tool |
the new GdkDeviceTool known to the seat |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.22
“tool-removed” signalvoid user_function (GdkSeat *seat, GdkDeviceTool *tool, gpointer user_data)
This signal is emitted whenever a tool is no longer known
to this seat
.
seat |
the object on which the signal is emitted |
|
tool |
the just removed GdkDeviceTool |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.22
| Top | |
|
|
|
GdkDevicePad is an interface implemented by devices of type
GDK_SOURCE_TABLET_PAD, it allows querying the features provided
by the pad device.
Tablet pads may contain one or more groups, each containing a subset
of the buttons/rings/strips available. gdk_device_pad_get_n_groups()
can be used to obtain the number of groups, gdk_device_pad_get_n_features()
and gdk_device_pad_get_feature_group() can be combined to find out the
number of buttons/rings/strips the device has, and how are they grouped.
Each of those groups have different modes, which may be used to map
each individual pad feature to multiple actions. Only one mode is
effective (current) for each given group, different groups may have
different current modes. The number of available modes in a group can
be found out through gdk_device_pad_get_group_n_modes(), and the current
mode for a given group will be notified through the GdkEventPadGroupMode
event.
gint
gdk_device_pad_get_n_groups (GdkDevicePad *pad);
Returns the number of groups this pad device has. Pads have at least one group. A pad group is a subcollection of buttons/strip/rings that is affected collectively by a same current mode.
Since: 3.22
gint gdk_device_pad_get_group_n_modes (GdkDevicePad *pad,gint group_idx);
Returns the number of modes that group
may have.
Since: 3.22
gint gdk_device_pad_get_n_features (GdkDevicePad *pad,GdkDevicePadFeature feature);
Returns the number of features a tablet pad has.
Since: 3.22
gint gdk_device_pad_get_feature_group (GdkDevicePad *pad,GdkDevicePadFeature feature,gint feature_idx);
Returns the group the given feature
and idx
belong to,
or -1 if feature/index do not exist in pad
.
pad |
||
feature |
the feature type to get the group from |
|
feature_idx |
the index of the feature to get the group from |
Since: 3.22
| Top | |
|
|
|
| GdkDisplay * | gdk_clipboard_get_display () |
| GdkContentFormats * | gdk_clipboard_get_formats () |
| gboolean | gdk_clipboard_is_local () |
| GdkContentProvider * | gdk_clipboard_get_content () |
| void | gdk_clipboard_store_async () |
| gboolean | gdk_clipboard_store_finish () |
| void | gdk_clipboard_read_async () |
| GInputStream * | gdk_clipboard_read_finish () |
| void | gdk_clipboard_read_value_async () |
| const GValue * | gdk_clipboard_read_value_finish () |
| void | gdk_clipboard_read_texture_async () |
| GdkTexture * | gdk_clipboard_read_texture_finish () |
| void | gdk_clipboard_read_text_async () |
| char * | gdk_clipboard_read_text_finish () |
| gboolean | gdk_clipboard_set_content () |
| void | gdk_clipboard_set () |
| void | gdk_clipboard_set_valist () |
| void | gdk_clipboard_set_value () |
| void | gdk_clipboard_set_text () |
| void | gdk_clipboard_set_texture () |
| GdkContentProvider * | content | Read |
| GdkDisplay * | display | Read / Write / Construct Only |
| GdkContentFormats * | formats | Read |
| gboolean | local | Read |
The GdkClipboard object represents a clipboard of data shared between different applications or between different parts of the same application.
To get a GdkClipboard object, use gdk_display_get_clipboard() or
gdk_display_get_primary_clipboard(). You can find out about the data that
is currently available in a clipboard using gdk_clipboard_get_formats().
To make text or image data available in a clipboard, use gdk_clipboard_set_text() or
gdk_clipboard_set_texture(). For other data, you can use gdk_clipboard_set_content(),
which takes a GdkContentProvider object.
To read textual or image data from a clipboard, use gdk_clipboard_read_text_async() or
gdk_clipboard_read_texture_async(). For other data, use gdk_clipboard_read_async(),
which provides a GInputStream object.
GdkDisplay *
gdk_clipboard_get_display (GdkClipboard *clipboard);
Gets the GdkDisplay that the clipboard was created for.
GdkContentFormats *
gdk_clipboard_get_formats (GdkClipboard *clipboard);
Gets the formats that the clipboard can provide its current contents in.
gboolean
gdk_clipboard_is_local (GdkClipboard *clipboard);
Returns if the clipboard is local. A clipboard is considered local if it was last claimed by the running application.
Note that gdk_clipboard_get_content() may return NULL even on a local
clipboard. In this case the clipboard is empty.
GdkContentProvider *
gdk_clipboard_get_content (GdkClipboard *clipboard);
Returns the GdkContentProvider currently set on clipboard
. If the
clipboard
is empty or its contents are not owned by the current process,
NULL will be returned.
The content of a clipboard or NULL
if the clipboard does not maintain any content.
[transfer none][nullable]
void gdk_clipboard_store_async (GdkClipboard *clipboard,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously instructs the clipboard
to store its contents remotely to
preserve them for later usage. If the clipboard is not local, this function
does nothing but report success.
This function is called automatically when gtk_main() or GtkApplication
exit, so you likely don't need to call it.
clipboard |
||
io_priority |
the I/O priority of the request. |
|
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
gboolean gdk_clipboard_store_finish (GdkClipboard *clipboard,GAsyncResult *result,GError **error);
Finishes an asynchronous clipboard store started with gdk_clipboard_store_async().
void gdk_clipboard_read_async (GdkClipboard *clipboard,const char **mime_types,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously requests an input stream to read the clipboard
's
contents from. When the operation is finished callback
will be called.
You can then call gdk_clipboard_read_finish() to get the result of the
operation.
The clipboard will choose the most suitable mime type from the given list to fulfill the request, preferring the ones listed first.
clipboard |
||
mime_types |
a |
|
io_priority |
the I/O priority of the request. |
|
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
GInputStream * gdk_clipboard_read_finish (GdkClipboard *clipboard,const char **out_mime_type,GAsyncResult *result,GError **error);
Finishes an asynchronous clipboard read started with gdk_clipboard_read_async().
void gdk_clipboard_read_value_async (GdkClipboard *clipboard,GType type,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously request the clipboard
contents converted to the given
type
. When the operation is finished callback
will be called.
You can then call gdk_clipboard_read_value_finish() to get the resulting
GValue.
For local clipboard contents that are available in the given GType, the
value will be copied directly. Otherwise, GDK will try to use
gdk_content_deserialize_async() to convert the clipboard's data.
clipboard |
||
type |
a GType to read |
|
io_priority |
the I/O priority of the request. |
|
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
const GValue * gdk_clipboard_read_value_finish (GdkClipboard *clipboard,GAsyncResult *result,GError **error);
Finishes an asynchronous clipboard read started with
gdk_clipboard_read_value_async().
void gdk_clipboard_read_texture_async (GdkClipboard *clipboard,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously request the clipboard
contents converted to a GdkPixbuf.
When the operation is finished callback
will be called. You can then
call gdk_clipboard_read_texture_finish() to get the result.
This is a simple wrapper around gdk_clipboard_read_value_async(). Use
that function or gdk_clipboard_read_async() directly if you need more
control over the operation.
clipboard |
||
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
GdkTexture * gdk_clipboard_read_texture_finish (GdkClipboard *clipboard,GAsyncResult *result,GError **error);
Finishes an asynchronous clipboard read started with
gdk_clipboard_read_texture_async().
void gdk_clipboard_read_text_async (GdkClipboard *clipboard,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously request the clipboard
contents converted to a string.
When the operation is finished callback
will be called. You can then
call gdk_clipboard_read_text_finish() to get the result.
This is a simple wrapper around gdk_clipboard_read_value_async(). Use
that function or gdk_clipboard_read_async() directly if you need more
control over the operation.
clipboard |
||
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
char * gdk_clipboard_read_text_finish (GdkClipboard *clipboard,GAsyncResult *result,GError **error);
Finishes an asynchronous clipboard read started with
gdk_clipboard_read_text_async().
gboolean gdk_clipboard_set_content (GdkClipboard *clipboard,GdkContentProvider *provider);
Sets a new content provider on clipboard
. The clipboard will claim the
GdkDisplay's resources and advertise these new contents to other
applications.
In the rare case of a failure, this function will return FALSE. The
clipboard will then continue reporting its old contents and ignore
provider
.
If the contents are read by either an external application or the
clipboard
's read functions, clipboard
will select the best format to
transfer the contents and then request that format from provider
.
clipboard |
||
provider |
the new contents of |
[transfer none][allow-none] |
void gdk_clipboard_set (GdkClipboard *clipboard,GType type,...);
Sets the clipboard to contain the value collected from the given varargs.
void gdk_clipboard_set_valist (GdkClipboard *clipboard,GType type,va_list args);
Sets the clipboard to contain the value collected from the given
args
.
[skip]
void gdk_clipboard_set_value (GdkClipboard *clipboard,const GValue *value);
Sets the clipboard
to contain the given value
.
[rename-to gdk_clipboard_set]
void gdk_clipboard_set_text (GdkClipboard *clipboard,const char *text);
Puts the given text
into the clipboard.
[skip]
void gdk_clipboard_set_texture (GdkClipboard *clipboard,GdkTexture *texture);
Puts the given texture
into the clipboard.
[skip]
“content” property“content” GdkContentProvider *
The GdkContentProvider or NULL if the clipboard is empty or contents are
provided otherwise.
Flags: Read
Since: 3.94
“display” property“display” GdkDisplay *
The GdkDisplay that the clipboard belongs to.
Flags: Read / Write / Construct Only
Since: 3.94
“formats” property“formats” GdkContentFormats *
The possible formats that the clipboard can provide its data in.
Flags: Read
Since: 3.94
“changed” signalvoid user_function (GdkClipboard *clipboard, gpointer user_data)
The ::changed signal is emitted when the clipboard changes ownership.
clipboard |
the object on which the signal was emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
| Top | |
|
|
|
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.
GdkFrameTimings *
gdk_frame_timings_ref (GdkFrameTimings *timings);
Increases the reference count of timings
.
Since: 3.8
void
gdk_frame_timings_unref (GdkFrameTimings *timings);
Decreases the reference count of timings
. If timings
is no longer referenced, it will be freed.
Since: 3.8
gint64
gdk_frame_timings_get_frame_counter (GdkFrameTimings *timings);
Gets the frame counter value of the GdkFrameClock when this this frame was drawn.
Since: 3.8
gboolean
gdk_frame_timings_get_complete (GdkFrameTimings *timings);
The timing information in a GdkFrameTimings is filled in
incrementally as the frame as drawn and passed off to the
window system for processing and display to the user. The
accessor functions for GdkFrameTimings can return 0 to
indicate an unavailable value for two reasons: either because
the information is not yet available, or because it isn't
available at all. Once gdk_frame_timings_get_complete() returns
TRUE for a frame, you can be certain that no further values
will become available and be stored in the GdkFrameTimings.
Since: 3.8
gint64
gdk_frame_timings_get_frame_time (GdkFrameTimings *timings);
Returns the frame time for the frame. This is the time value
that is typically used to time animations for the frame. See
gdk_frame_clock_get_frame_time().
gint64
gdk_frame_timings_get_presentation_time
(GdkFrameTimings *timings);
Reurns the presentation time. This is the time at which the frame became visible to the user.
the time the frame was displayed to the user, in the
timescale of g_get_monotonic_time(), or 0 if no presentation
time is available. See gdk_frame_timings_get_complete()
Since: 3.8
gint64
gdk_frame_timings_get_refresh_interval
(GdkFrameTimings *timings);
Gets the natural interval between presentation times for the display that this frame was displayed on. Frame presentation usually happens during the “vertical blanking interval”.
the refresh interval of the display, in microseconds,
or 0 if the refresh interval is not available.
See gdk_frame_timings_get_complete().
Since: 3.8
gint64
gdk_frame_timings_get_predicted_presentation_time
(GdkFrameTimings *timings);
Gets the predicted time at which this frame will be displayed. Although
no predicted time may be available, if one is available, it will
be available while the frame is being generated, in contrast to
gdk_frame_timings_get_presentation_time(), which is only available
after the frame has been presented. In general, if you are simply
animating, you should use gdk_frame_clock_get_frame_time() rather
than this function, but this function is useful for applications
that want exact control over latency. For example, a movie player
may want this information for Audio/Video synchronization.
The predicted time at which the frame will be presented,
in the timescale of g_get_monotonic_time(), or 0 if no predicted
presentation time is available.
Since: 3.8
| Top | |
|
|
|
| GdkCursor * | cursor | Read / Write |
| GdkDisplay * | display | Read / Write / Construct Only |
| GdkWindowState | state | Read |
| GdkWindow | |
| enum | GdkWindowType |
| struct | GdkWindowClass |
| enum | GdkWindowHints |
| struct | GdkGeometry |
| enum | GdkGravity |
| enum | GdkAnchorHints |
| enum | GdkWindowEdge |
| enum | GdkWindowTypeHint |
| enum | GdkWindowState |
| enum | GdkFullscreenMode |
| enum | GdkFilterReturn |
| typedef | GdkXEvent |
| #define | GDK_PARENT_RELATIVE |
| enum | GdkModifierType |
| enum | GdkModifierIntent |
| enum | GdkWMDecoration |
| enum | GdkWMFunction |
A GdkWindow is a (usually) rectangular region on the screen. It’s a low-level object, used to implement high-level objects such as GtkWidget and GtkWindow on the GTK+ level. A GtkWindow is a toplevel window, the thing a user might think of as a “window” with a titlebar and so on; a GtkWindow may contain many sub-GdkWindows.
GdkWindow * gdk_window_new_toplevel (GdkDisplay *display,int width,int height);
Creates a new toplevel window. The window will be managed by the window manager.
[constructor]
display |
the display to create the window on |
|
width |
width of new window |
|
height |
height of new window |
Since: 3.90
GdkWindow * gdk_window_new_popup (GdkDisplay *display,const GdkRectangle *position);
Creates a new toplevel popup window. The window will bypass window management.
[constructor]
Since: 3.90
GdkWindow *
gdk_window_new_temp (GdkDisplay *display);
Creates a new toplevel temporary window. The window will be situated off-screen and not handle output.
You most likely do not want to use this function.
[constructor]
Since: 3.90
GdkWindow * gdk_window_new_child (GdkWindow *parent,const GdkRectangle *position);
Creates a new client-side child window.
[constructor]
Since: 3.90
void
gdk_window_destroy (GdkWindow *window);
Destroys the window system resources associated with window
and decrements window
's
reference count. The window system resources for all children of window
are also
destroyed, but the children’s reference counts are not decremented.
Note that a window will not be destroyed automatically when its reference count reaches zero. You must call this function yourself before that happens.
GdkWindowType
gdk_window_get_window_type (GdkWindow *window);
Gets the type of the window. See GdkWindowType.
GdkDisplay *
gdk_window_get_display (GdkWindow *window);
Gets the GdkDisplay associated with a GdkWindow.
Since: 2.24
void
gdk_window_show (GdkWindow *window);
Like gdk_window_show_unraised(), but also raises the window to the
top of the window stack (moves the window to the front of the
Z-order).
This function maps a window so it’s visible onscreen. Its opposite
is gdk_window_hide().
When implementing a GtkWidget, you should call this function on the widget's GdkWindow as part of the “map” method.
void
gdk_window_show_unraised (GdkWindow *window);
Shows a GdkWindow onscreen, but does not modify its stacking
order. In contrast, gdk_window_show() will raise the window
to the top of the window stack.
On the X11 platform, in Xlib terms, this function calls
XMapWindow() (it also updates some internal GDK state, which means
that you can’t really use XMapWindow() directly on a GDK window).
void
gdk_window_hide (GdkWindow *window);
For toplevel windows, withdraws them, so they will no longer be
known to the window manager; for all windows, unmaps them, so
they won’t be displayed. Normally done automatically as
part of gtk_widget_hide().
gboolean
gdk_window_is_destroyed (GdkWindow *window);
Check to see if a window is destroyed..
Since: 2.18
gboolean
gdk_window_is_visible (GdkWindow *window);
Checks whether the window has been mapped (with gdk_window_show() or
gdk_window_show_unraised()).
gboolean
gdk_window_is_viewable (GdkWindow *window);
Check if the window and all ancestors of the window are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have GDK window parents, not to the root window.)
gboolean
gdk_window_is_input_only (GdkWindow *window);
Determines whether or not the window is an input only window.
Since: 2.22
gboolean
gdk_window_is_shaped (GdkWindow *window);
Determines whether or not the window is shaped.
Since: 2.22
GdkWindowState
gdk_window_get_state (GdkWindow *window);
Gets the bitwise OR of the currently active window state flags, from the GdkWindowState enumeration.
void
gdk_window_withdraw (GdkWindow *window);
Withdraws a window (unmaps it and asks the window manager to forget about it).
This function is not really useful as gdk_window_hide() automatically
withdraws toplevel windows before hiding them.
void
gdk_window_iconify (GdkWindow *window);
Asks to iconify (minimize) window
. The window manager may choose
to ignore the request, but normally will honor it. Using
gtk_window_iconify() is preferred, if you have a GtkWindow widget.
This function only makes sense when window
is a toplevel window.
void
gdk_window_deiconify (GdkWindow *window);
Attempt to deiconify (unminimize) window
. On X11 the window manager may
choose to ignore the request to deiconify. When using GTK+,
use gtk_window_deiconify() instead of the GdkWindow variant. Or better yet,
you probably want to use gtk_window_present(), which raises the window, focuses it,
unminimizes it, and puts it on the current desktop.
void
gdk_window_stick (GdkWindow *window);
“Pins” a window such that it’s on all workspaces and does not scroll
with viewports, for window managers that have scrollable viewports.
(When using GtkWindow, gtk_window_stick() may be more useful.)
On the X11 platform, this function depends on window manager support, so may have no effect with many window managers. However, GDK will do the best it can to convince the window manager to stick the window. For window managers that don’t support this operation, there’s nothing you can do to force it to happen.
void
gdk_window_unstick (GdkWindow *window);
Reverse operation for gdk_window_stick(); see gdk_window_stick(),
and gtk_window_unstick().
void
gdk_window_maximize (GdkWindow *window);
Maximizes the window. If the window was already maximized, then this function does nothing.
On X11, asks the window manager to maximize window
, if the window
manager supports this operation. Not all window managers support
this, and some deliberately ignore it or don’t have a concept of
“maximized”; so you can’t rely on the maximization actually
happening. But it will happen with most standard window managers,
and GDK makes a best effort to get it to happen.
On Windows, reliably maximizes the window.
void
gdk_window_unmaximize (GdkWindow *window);
Unmaximizes the window. If the window wasn’t maximized, then this function does nothing.
On X11, asks the window manager to unmaximize window
, if the
window manager supports this operation. Not all window managers
support this, and some deliberately ignore it or don’t have a
concept of “maximized”; so you can’t rely on the unmaximization
actually happening. But it will happen with most standard window
managers, and GDK makes a best effort to get it to happen.
On Windows, reliably unmaximizes the window.
void
gdk_window_fullscreen (GdkWindow *window);
Moves the window into fullscreen mode. This means the window covers the entire screen and is above any panels or task bars.
If the window was already fullscreen, then this function does nothing.
On X11, asks the window manager to put window
in a fullscreen
state, if the window manager supports this operation. Not all
window managers support this, and some deliberately ignore it or
don’t have a concept of “fullscreen”; so you can’t rely on the
fullscreenification actually happening. But it will happen with
most standard window managers, and GDK makes a best effort to get
it to happen.
Since: 2.2
void gdk_window_fullscreen_on_monitor (GdkWindow *window,GdkMonitor *monitor);
Moves the window into fullscreen mode on the given monitor. This means the window covers the entire screen and is above any panels or task bars.
If the window was already fullscreen, then this function does nothing.
Since: UNRELEASED
void
gdk_window_unfullscreen (GdkWindow *window);
Moves the window out of fullscreen mode. If the window was not fullscreen, does nothing.
On X11, asks the window manager to move window
out of the fullscreen
state, if the window manager supports this operation. Not all
window managers support this, and some deliberately ignore it or
don’t have a concept of “fullscreen”; so you can’t rely on the
unfullscreenification actually happening. But it will happen with
most standard window managers, and GDK makes a best effort to get
it to happen.
Since: 2.2
GdkFullscreenMode
gdk_window_get_fullscreen_mode (GdkWindow *window);
Obtains the GdkFullscreenMode of the window
.
Since: 3.8
void gdk_window_set_fullscreen_mode (GdkWindow *window,GdkFullscreenMode mode);
Specifies whether the window
should span over all monitors (in a multi-head
setup) or only the current monitor when in fullscreen mode.
The mode
argument is from the GdkFullscreenMode enumeration.
If GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen window
will
span over all monitors of the display.
On X11, searches through the list of monitors display the ones
which delimit the 4 edges of the entire display and will ask the window
manager to span the window
over these monitors.
If the XINERAMA extension is not available or not usable, this function has no effect.
Not all window managers support this, so you can’t rely on the fullscreen window to span over the multiple monitors when GDK_FULLSCREEN_ON_ALL_MONITORS is specified.
Since: 3.8
void gdk_window_set_keep_above (GdkWindow *window,gboolean setting);
Set if window
must be kept above other windows. If the
window was already above, then this function does nothing.
On X11, asks the window manager to keep window
above, if the window
manager supports this operation. Not all window managers support
this, and some deliberately ignore it or don’t have a concept of
“keep above”; so you can’t rely on the window being kept above.
But it will happen with most standard window managers,
and GDK makes a best effort to get it to happen.
Since: 2.4
void gdk_window_set_keep_below (GdkWindow *window,gboolean setting);
Set if window
must be kept below other windows. If the
window was already below, then this function does nothing.
On X11, asks the window manager to keep window
below, if the window
manager supports this operation. Not all window managers support
this, and some deliberately ignore it or don’t have a concept of
“keep below”; so you can’t rely on the window being kept below.
But it will happen with most standard window managers,
and GDK makes a best effort to get it to happen.
Since: 2.4
void gdk_window_set_opacity (GdkWindow *window,gdouble opacity);
Set window
to render as partially transparent,
with opacity 0 being fully transparent and 1 fully opaque. (Values
of the opacity parameter are clamped to the [0,1] range.)
For toplevel windows this depends on support from the windowing system
that may not always be there. For instance, On X11, this works only on
X screens with a compositing manager running. On Wayland, there is no
per-window opacity value that the compositor would apply. Instead, use
gdk_window_set_opaque_region (window, NULL) to tell the compositor
that the entire window is (potentially) non-opaque, and draw your content
with alpha, or use gtk_widget_set_opacity() to set an overall opacity
for your widgets.
Support for non-toplevel windows was added in 3.8.
Since: 2.12
void gdk_window_set_pass_through (GdkWindow *window,gboolean pass_through);
Sets whether input to the window is passed through to the window below.
The default value of this is FALSE, which means that pointer
events that happen inside the window are send first to the window,
but if the event is not selected by the event mask then the event
is sent to the parent window, and so on up the hierarchy.
If pass_through
is TRUE then such pointer events happen as if the
window wasn't there at all, and thus will be sent first to any
windows below window
. This is useful if the window is used in a
transparent fashion. In the terminology of the web this would be called
"pointer-events: none".
Note that a window with pass_through
TRUE can still have a subwindow
without pass through, so you can get events on a subset of a window. And in
that cases you would get the in-between related events such as the pointer
enter/leave events on its way to the destination window.
Since: 3.18
gboolean
gdk_window_get_pass_through (GdkWindow *window);
Returns whether input to the window is passed through to the window below.
See gdk_window_set_pass_through() for details
Since: 3.18
void gdk_window_move (GdkWindow *window,gint x,gint y);
Repositions a window relative to its parent window.
For toplevel windows, window managers may ignore or modify the move;
you should probably use gtk_window_move() on a GtkWindow widget
anyway, instead of using GDK functions. For child windows,
the move will reliably succeed.
If you’re also planning to resize the window, use gdk_window_move_resize()
to both move and resize simultaneously, for a nicer visual effect.
void gdk_window_resize (GdkWindow *window,gint width,gint height);
Resizes window
; for toplevel windows, asks the window manager to resize
the window. The window manager may not allow the resize. When using GTK+,
use gtk_window_resize() instead of this low-level GDK function.
Windows may not be resized below 1x1.
If you’re also planning to move the window, use gdk_window_move_resize()
to both move and resize simultaneously, for a nicer visual effect.
void gdk_window_move_resize (GdkWindow *window,gint x,gint y,gint width,gint height);
Equivalent to calling gdk_window_move() and gdk_window_resize(),
except that both operations are performed at once, avoiding strange
visual effects. (i.e. the user may be able to see the window first
move, then resize, if you don’t use gdk_window_move_resize().)
void gdk_window_scroll (GdkWindow *window,gint dx,gint dy);
Scroll the contents of window
, both pixels and children, by the
given amount. window
itself does not move. Portions of the window
that the scroll operation brings in from offscreen areas are
invalidated. The invalidated region may be bigger than what would
strictly be necessary.
For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window’s parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations.
void gdk_window_move_region (GdkWindow *window,const cairo_region_t *region,gint dx,gint dy);
Move the part of window
indicated by region
by dy
pixels in the Y
direction and dx
pixels in the X direction. The portions of region
that not covered by the new position of region
are invalidated.
Child windows are not moved.
window |
||
region |
The cairo_region_t to move |
|
dx |
Amount to move in the X direction |
|
dy |
Amount to move in the Y direction |
Since: 2.8
gboolean
gdk_window_has_native (GdkWindow *window);
Checks whether the window has a native window or not.
Since: 2.22
void
gdk_window_raise (GdkWindow *window);
Raises window
to the top of the Z-order (stacking order), so that
other windows with the same parent window appear below window
.
This is true whether or not the windows are visible.
If window
is a toplevel, the window manager may choose to deny the
request to move the window in the Z-order, gdk_window_raise() only
requests the restack, does not guarantee it.
void
gdk_window_lower (GdkWindow *window);
Lowers window
to the bottom of the Z-order (stacking order), so that
other windows with the same parent window appear above window
.
This is true whether or not the other windows are visible.
If window
is a toplevel, the window manager may choose to deny the
request to move the window in the Z-order, gdk_window_lower() only
requests the restack, does not guarantee it.
Note that gdk_window_show() raises the window again, so don’t call this
function before gdk_window_show(). (Try gdk_window_show_unraised().)
void gdk_window_restack (GdkWindow *window,GdkWindow *sibling,gboolean above);
Changes the position of window
in the Z-order (stacking order), so that
it is above sibling
(if above
is TRUE) or below sibling
(if above
is
FALSE).
If sibling
is NULL, then this either raises (if above
is TRUE) or
lowers the window.
If window
is a toplevel, the window manager may choose to deny the
request to move the window in the Z-order, gdk_window_restack() only
requests the restack, does not guarantee it.
Since: 2.18
void gdk_window_focus (GdkWindow *window,guint32 timestamp);
Sets keyboard focus to window
. In most cases, gtk_window_present()
should be used on a GtkWindow, rather than calling this function.
void
gdk_window_register_dnd (GdkWindow *window);
Registers a window as a potential drop destination.
void gdk_window_begin_resize_drag (GdkWindow *window,GdkWindowEdge edge,gint button,gint root_x,gint root_y,guint32 timestamp);
Begins a window resize operation (for a toplevel window).
This function assumes that the drag is controlled by the
client pointer device, use gdk_window_begin_resize_drag_for_device()
to begin a drag with a different device.
window |
a toplevel GdkWindow |
|
edge |
the edge or corner from which the drag is started |
|
button |
the button being used to drag, or 0 for a keyboard-initiated drag |
|
root_x |
root window X coordinate of mouse click that began the drag |
|
root_y |
root window Y coordinate of mouse click that began the drag |
|
timestamp |
timestamp of mouse click that began the drag (use |
void gdk_window_begin_resize_drag_for_device (GdkWindow *window,GdkWindowEdge edge,GdkDevice *device,gint button,gint root_x,gint root_y,guint32 timestamp);
Begins a window resize operation (for a toplevel window). You might use this function to implement a “window resize grip,” for example; in fact GtkStatusbar uses it. The function works best with window managers that support the Extended Window Manager Hints but has a fallback implementation for other window managers.
window |
a toplevel GdkWindow |
|
edge |
the edge or corner from which the drag is started |
|
device |
the device used for the operation |
|
button |
the button being used to drag, or 0 for a keyboard-initiated drag |
|
root_x |
root window X coordinate of mouse click that began the drag |
|
root_y |
root window Y coordinate of mouse click that began the drag |
|
timestamp |
timestamp of mouse click that began the drag (use |
Since: 3.4
void gdk_window_begin_move_drag (GdkWindow *window,gint button,gint root_x,gint root_y,guint32 timestamp);
Begins a window move operation (for a toplevel window).
This function assumes that the drag is controlled by the
client pointer device, use gdk_window_begin_move_drag_for_device()
to begin a drag with a different device.
window |
a toplevel GdkWindow |
|
button |
the button being used to drag, or 0 for a keyboard-initiated drag |
|
root_x |
root window X coordinate of mouse click that began the drag |
|
root_y |
root window Y coordinate of mouse click that began the drag |
|
timestamp |
timestamp of mouse click that began the drag |
void gdk_window_begin_move_drag_for_device (GdkWindow *window,GdkDevice *device,gint button,gint root_x,gint root_y,guint32 timestamp);
Begins a window move operation (for a toplevel window). You might use this function to implement a “window move grip,” for example. The function works best with window managers that support the Extended Window Manager Hints but has a fallback implementation for other window managers.
window |
a toplevel GdkWindow |
|
device |
the device used for the operation |
|
button |
the button being used to drag, or 0 for a keyboard-initiated drag |
|
root_x |
root window X coordinate of mouse click that began the drag |
|
root_y |
root window Y coordinate of mouse click that began the drag |
|
timestamp |
timestamp of mouse click that began the drag |
Since: 3.4
gboolean gdk_window_show_window_menu (GdkWindow *window,GdkEvent *event);
Asks the windowing system to show the window menu. The window menu is the menu shown when right-clicking the titlebar on traditional windows managed by the window manager. This is useful for windows using client-side decorations, activating it with a right-click on the window decorations.
Since: 3.14
void gdk_window_constrain_size (GdkGeometry *geometry,GdkWindowHints flags,gint width,gint height,gint *new_width,gint *new_height);
Constrains a desired width and height according to a set of geometry hints (such as minimum and maximum size).
geometry |
a GdkGeometry structure |
|
flags |
a mask indicating what portions of |
|
width |
desired width of window |
|
height |
desired height of the window |
|
new_width |
location to store resulting width. |
[out] |
new_height |
location to store resulting height. |
[out] |
void
gdk_window_beep (GdkWindow *window);
Emits a short beep associated to window
in the appropriate
display, if supported. Otherwise, emits a short beep on
the display just as gdk_display_beep().
Since: 2.12
gint
gdk_window_get_scale_factor (GdkWindow *window);
Returns the internal scale factor that maps from window coordiantes to the actual device pixels. On traditional systems this is 1, but on very high density outputs this can be a higher value (often 2).
A higher value means that drawing is automatically scaled up to a higher resolution, so any code doing drawing will automatically look nicer. However, if you are supplying pixel-based data the scale value can be used to determine whether to use a pixel resource with higher resolution data.
The scale of a window may change during runtime, if this happens a configure event will be sent to the toplevel window.
Since: 3.10
void gdk_window_set_opaque_region (GdkWindow *window,cairo_region_t *region);
For optimisation purposes, compositing window managers may like to not draw obscured regions of windows, or turn off blending during for these regions. With RGB windows with no transparency, this is just the shape of the window, but with ARGB32 windows, the compositor does not know what regions of the window are transparent or not.
This function only works for toplevel windows.
GTK+ will update this property automatically if
the window
background is opaque, as we know where the opaque regions
are. If your window background is not opaque, please update this
property in your “style-updated” handler.
Since: 3.10
GdkGLContext * gdk_window_create_gl_context (GdkWindow *window,GError **error);
Creates a new GdkGLContext matching the framebuffer format to the visual of the GdkWindow. The context is disconnected from any particular window or surface.
If the creation of the GdkGLContext failed, error
will be set.
Before using the returned GdkGLContext, you will need to
call gdk_gl_context_make_current() or gdk_gl_context_realize().
Since: 3.16
GdkVulkanContext * gdk_window_create_vulkan_context (GdkWindow *window,GError **error);
Creates a new GdkVulkanContext for rendering on window
.
If the creation of the GdkVulkanContext failed, error
will be set.
Since: 3.90
cairo_region_t *
gdk_window_get_clip_region (GdkWindow *window);
Computes the region of a window that potentially can be written to by drawing primitives. This region may not take into account other factors such as if the window is obscured by other windows, but no area outside of this region will be affected by drawing primitives.
GdkDrawingContext * gdk_window_begin_draw_frame (GdkWindow *window,GdkDrawContext *context,const cairo_region_t *region);
Indicates that you are beginning the process of redrawing region
on window
, and provides you with a GdkDrawingContext.
If window
is a top level GdkWindow, backed by a native window
implementation, a backing store (offscreen buffer) large enough to
contain region
will be created. The backing store will be initialized
with the background color or background surface for window
. Then, all
drawing operations performed on window
will be diverted to the
backing store. When you call gdk_window_end_frame(), the contents of
the backing store will be copied to window
, making it visible
on screen. Only the part of window
contained in region
will be
modified; that is, drawing operations are clipped to region
.
The net result of all this is to remove flicker, because the user
sees the finished product appear all at once when you call
gdk_window_end_draw_frame(). If you draw to window
directly without
calling gdk_window_begin_draw_frame(), the user may see flicker
as individual drawing operations are performed in sequence.
When using GTK+, the widget system automatically places calls to
gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() around
emissions of the GtkWidget::draw signal. That is, if you’re
drawing the contents of the widget yourself, you can assume that the
widget has a cleared background, is already set as the clip region,
and already has a backing store. Therefore in most cases, application
code in GTK does not need to call gdk_window_begin_draw_frame()
explicitly.
a GdkDrawingContext context that should be used to draw the contents of the window; the returned context is owned by GDK.
[transfer none]
Since: 3.22
void gdk_window_end_draw_frame (GdkWindow *window,GdkDrawingContext *context);
Indicates that the drawing of the contents of window
started with
gdk_window_begin_frame() has been completed.
This function will take care of destroying the GdkDrawingContext.
It is an error to call this function without a matching
gdk_window_begin_frame() first.
Since: 3.22
cairo_region_t *
gdk_window_get_visible_region (GdkWindow *window);
Computes the region of the window
that is potentially visible.
This does not necessarily take into account if the window is
obscured by other windows, but no area outside of this region
is visible.
void gdk_window_invalidate_rect (GdkWindow *window,const GdkRectangle *rect,gboolean invalidate_children);
A convenience wrapper around gdk_window_invalidate_region() which
invalidates a rectangular region. See
gdk_window_invalidate_region() for details.
void gdk_window_invalidate_region (GdkWindow *window,const cairo_region_t *region,gboolean invalidate_children);
Adds region
to the update area for window
. The update area is the
region that needs to be redrawn, or “dirty region.”
GDK will process all updates whenever the frame clock schedules a redraw, so there’s no need to do forces redraws manually, you just need to invalidate regions that you know should be redrawn.
The invalidate_children
parameter controls whether the region of
each child window that intersects region
will also be invalidated.
If FALSE, then the update area for child windows will remain
unaffected. See gdk_window_invalidate_maybe_recurse if you need
fine grained control over which children are invalidated.
gboolean (*GdkWindowChildFunc) (GdkWindow *window,gpointer user_data);
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.
void gdk_window_invalidate_maybe_recurse (GdkWindow *window,const cairo_region_t *region,GdkWindowChildFunc child_func,gpointer user_data);
Adds region
to the update area for window
. The update area is the
region that needs to be redrawn, or “dirty region.”
GDK will process all updates whenever the frame clock schedules a redraw, so there’s no need to do forces redraws manually, you just need to invalidate regions that you know should be redrawn.
The child_func
parameter controls whether the region of
each child window that intersects region
will also be invalidated.
Only children for which child_func
returns TRUE will have the area
invalidated.
window |
||
region |
||
child_func |
function to use to decide if to
recurse to a child, |
[scope call][allow-none] |
user_data |
data passed to |
cairo_region_t *
gdk_window_get_update_area (GdkWindow *window);
Transfers ownership of the update area from window
to the caller
of the function. That is, after calling this function, window
will
no longer have an invalid/dirty region; the update area is removed
from window
and handed to you. If a window has no update area,
gdk_window_get_update_area() returns NULL. You are responsible for
calling cairo_region_destroy() on the returned region if it’s non-NULL.
void
gdk_window_freeze_updates (GdkWindow *window);
Temporarily freezes a window such that it won’t receive expose
events. The window will begin receiving expose events again when
gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
has been called more than once, gdk_window_thaw_updates() must be called
an equal number of times to begin processing exposes.
void
gdk_window_thaw_updates (GdkWindow *window);
Thaws a window frozen with gdk_window_freeze_updates().
GdkFrameClock *
gdk_window_get_frame_clock (GdkWindow *window);
Gets the frame clock for the window. The frame clock for a window never changes unless the window is reparented to a new toplevel window.
Since: 3.8
void gdk_window_set_user_data (GdkWindow *window,gpointer user_data);
For most purposes this function is deprecated in favor of
g_object_set_data(). However, for historical reasons GTK+ stores
the GtkWidget that owns a GdkWindow as user data on the
GdkWindow. So, custom widget implementations should use
this function for that. If GTK+ receives an event for a GdkWindow,
and the user data for the window is non-NULL, GTK+ will assume the
user data is a GtkWidget, and forward the event to that widget.
void gdk_window_set_accept_focus (GdkWindow *window,gboolean accept_focus);
Setting accept_focus
to FALSE hints the desktop environment that the
window doesn’t want to receive input focus.
On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it.
Since: 2.4
gboolean
gdk_window_get_accept_focus (GdkWindow *window);
Determines whether or not the desktop environment shuld be hinted that the window does not want to receive input focus.
Since: 2.22
void gdk_window_set_focus_on_map (GdkWindow *window,gboolean focus_on_map);
Setting focus_on_map
to FALSE hints the desktop environment that the
window doesn’t want to receive input focus when it is mapped.
focus_on_map should be turned off for windows that aren’t triggered
interactively (such as popups from network activity).
On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it.
Since: 2.6
gboolean
gdk_window_get_focus_on_map (GdkWindow *window);
Determines whether or not the desktop environment should be hinted that the window does not want to receive input focus when it is mapped.
Since: 2.22
void gdk_window_add_filter (GdkWindow *window,GdkFilterFunc function,gpointer data);
Adds an event filter to window
, allowing you to intercept events
before they reach GDK. This is a low-level operation and makes it
easy to break GDK and/or GTK+, so you have to know what you're
doing. Pass NULL for window
to get all events for all windows,
instead of events for a specific window.
If you are interested in X GenericEvents, bear in mind that
XGetEventData() has been already called on the event, and
XFreeEventData() must not be called within function
.
[skip]
window |
a GdkWindow. |
[allow-none] |
function |
filter callback |
|
data |
data to pass to filter callback |
void gdk_window_remove_filter (GdkWindow *window,GdkFilterFunc function,gpointer data);
Remove a filter previously added with gdk_window_add_filter().
[skip]
GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent,GdkEvent *event,gpointer data);
Specifies the type of function used to filter native events before they are converted to GDK events.
When a filter is called, event
is unpopulated, except for
event->window. The filter may translate the native
event to a GDK event and store the result in event
, or handle it without
translation. If the filter translates the event and processing should
continue, it should return GDK_FILTER_TRANSLATE.
void gdk_window_shape_combine_region (GdkWindow *window,const cairo_region_t *shape_region,gint offset_x,gint offset_y);
Makes pixels in window
outside shape_region
be transparent,
so that the window may be nonrectangular.
If shape_region
is NULL, the shape will be unset, so the whole
window will be opaque again. offset_x
and offset_y
are ignored
if shape_region
is NULL.
On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this function will do nothing.
This function works on both toplevel and child windows.
void
gdk_window_set_child_shapes (GdkWindow *window);
Sets the shape mask of window
to the union of shape masks
for all children of window
, ignoring the shape mask of window
itself. Contrast with gdk_window_merge_child_shapes() which includes
the shape mask of window
in the masks to be merged.
void
gdk_window_merge_child_shapes (GdkWindow *window);
Merges the shape masks for any child windows into the
shape mask for window
. i.e. the union of all masks
for window
and its children will become the new mask
for window
. See gdk_window_shape_combine_region().
This function is distinct from gdk_window_set_child_shapes()
because it includes window
’s shape mask in the set of shapes to
be merged.
void gdk_window_input_shape_combine_region (GdkWindow *window,const cairo_region_t *shape_region,gint offset_x,gint offset_y);
Like gdk_window_shape_combine_region(), but the shape applies
only to event handling. Mouse events which happen while
the pointer position corresponds to an unset bit in the
mask will be passed on the window below window
.
An input shape is typically used with RGBA windows. The alpha channel of the window defines which pixels are invisible and allows for nicely antialiased borders, and the input shape controls where the window is “clickable”.
On the X11 platform, this requires version 1.1 of the shape extension.
On the Win32 platform, this functionality is not present and the function does nothing.
window |
||
shape_region |
region of window to be non-transparent |
|
offset_x |
X position of |
|
offset_y |
Y position of |
Since: 2.10
void
gdk_window_set_child_input_shapes (GdkWindow *window);
Sets the input shape mask of window
to the union of input shape masks
for all children of window
, ignoring the input shape mask of window
itself. Contrast with gdk_window_merge_child_input_shapes() which includes
the input shape mask of window
in the masks to be merged.
Since: 2.10
void
gdk_window_merge_child_input_shapes (GdkWindow *window);
Merges the input shape masks for any child windows into the
input shape mask for window
. i.e. the union of all input masks
for window
and its children will become the new input mask
for window
. See gdk_window_input_shape_combine_region().
This function is distinct from gdk_window_set_child_input_shapes()
because it includes window
’s input shape mask in the set of
shapes to be merged.
Since: 2.10
void gdk_window_set_title (GdkWindow *window,const gchar *title);
Sets the title of a toplevel window, to be displayed in the titlebar.
If you haven’t explicitly set the icon name for the window
(using gdk_window_set_icon_name()), the icon name will be set to
title
as well. title
must be in UTF-8 encoding (as with all
user-readable strings in GDK/GTK+). title
may not be NULL.
void gdk_window_set_cursor (GdkWindow *window,GdkCursor *cursor);
Sets the default mouse pointer for a GdkWindow.
Note that cursor
must be for the same display as window
.
Use gdk_cursor_new_for_display() or gdk_cursor_new_from_texture() to
create the cursor. To make the cursor invisible, use GDK_BLANK_CURSOR.
Passing NULL for the cursor
argument to gdk_window_set_cursor() means
that window
will use the cursor of its parent window. Most windows
should use this default.
GdkCursor *
gdk_window_get_cursor (GdkWindow *window);
Retrieves a GdkCursor pointer for the cursor currently set on the
specified GdkWindow, or NULL. If the return value is NULL then
there is no custom cursor set on the specified window, and it is
using the cursor for its parent window.
a GdkCursor, or NULL. The
returned object is owned by the GdkWindow and should not be
unreferenced directly. Use gdk_window_set_cursor() to unset the
cursor of the window.
[nullable][transfer none]
Since: 2.18
void gdk_window_get_user_data (GdkWindow *window,gpointer *data);
Retrieves the user data for window
, which is normally the widget
that window
belongs to. See gdk_window_set_user_data().
void gdk_window_get_geometry (GdkWindow *window,gint *x,gint *y,gint *width,gint *height);
Any of the return location arguments to this function may be NULL,
if you aren’t interested in getting the value of that field.
The X and Y coordinates returned are relative to the parent window
of window
, which for toplevels usually means relative to the
window decorations (titlebar, etc.) rather than relative to the
root window (screen-size background window).
On the X11 platform, the geometry is obtained from the X server,
so reflects the latest position of window
; this may be out-of-sync
with the position of window
delivered in the most-recently-processed
GdkEventConfigure. gdk_window_get_position() in contrast gets the
position from the most recent configure event.
Note: If window
is not a toplevel, it is much better
to call gdk_window_get_position(), gdk_window_get_width() and
gdk_window_get_height() instead, because it avoids the roundtrip to
the X server and because these functions support the full 32-bit
coordinate space, whereas gdk_window_get_geometry() is restricted to
the 16-bit coordinates of X11.
window |
||
x |
return location for X coordinate of window (relative to its parent). |
[out][allow-none] |
y |
return location for Y coordinate of window (relative to its parent). |
[out][allow-none] |
width |
return location for width of window. |
[out][allow-none] |
height |
return location for height of window. |
[out][allow-none] |
void gdk_window_set_geometry_hints (GdkWindow *window,const GdkGeometry *geometry,GdkWindowHints geom_mask);
Sets the geometry hints for window
. Hints flagged in geom_mask
are set, hints not flagged in geom_mask
are unset.
To unset all hints, use a geom_mask
of 0 and a geometry
of NULL.
This function provides hints to the windowing system about
acceptable sizes for a toplevel window. The purpose of
this is to constrain user resizing, but the windowing system
will typically (but is not required to) also constrain the
current size of the window to the provided values and
constrain programatic resizing via gdk_window_resize() or
gdk_window_move_resize().
Note that on X11, this effect has no effect on windows
of type GDK_WINDOW_TEMP since these windows are not resizable
by the user.
Since you can’t count on the windowing system doing the
constraints for programmatic resizes, you should generally
call gdk_window_constrain_size() yourself to determine
appropriate sizes.
window |
a toplevel GdkWindow |
|
geometry |
geometry hints |
|
geom_mask |
bitmask indicating fields of |
int
gdk_window_get_width (GdkWindow *window);
Returns the width of the given window
.
On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.
Since: 2.24
int
gdk_window_get_height (GdkWindow *window);
Returns the height of the given window
.
On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.
Since: 2.24
void gdk_window_set_icon_list (GdkWindow *window,GList *surfaces);
Sets a list of icons for the window. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all.
Note that some platforms don't support window icons.
window |
The GdkWindow toplevel window to set the icon of. |
|
surfaces |
A list of image surfaces, of different sizes. |
[transfer none][element-type GdkTexture] |
void gdk_window_set_modal_hint (GdkWindow *window,gboolean modal);
The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way.
You should only use this on windows for which you have
previously called gdk_window_set_transient_for()
gboolean
gdk_window_get_modal_hint (GdkWindow *window);
Determines whether or not the window manager is hinted that window
has modal behaviour.
Since: 2.22
void gdk_window_set_type_hint (GdkWindow *window,GdkWindowTypeHint hint);
The application can use this call to provide a hint to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behaviour of the window.
The hint must be set before the window is mapped.
GdkWindowTypeHint
gdk_window_get_type_hint (GdkWindow *window);
This function returns the type hint set for a window.
Since: 2.10
void gdk_window_set_shadow_width (GdkWindow *window,gint left,gint right,gint top,gint bottom);
Newer GTK+ windows using client-side decorations use extra geometry around their frames for effects like shadows and invisible borders. Window managers that want to maximize windows or snap to edges need to know where the extents of the actual frame lie, so that users don’t feel like windows are snapping against random invisible edges.
Note that this property is automatically updated by GTK+, so this function should only be used by applications which do not use GTK+ to create toplevel windows.
window |
||
left |
The left extent |
|
right |
The right extent |
|
top |
The top extent |
|
bottom |
The bottom extent |
Since: 3.12
void gdk_window_set_skip_taskbar_hint (GdkWindow *window,gboolean skips_taskbar);
Toggles whether a window should appear in a task list or window
list. If a window’s semantic type as specified with
gdk_window_set_type_hint() already fully describes the window, this
function should not be called in addition,
instead you should allow the window to be treated according to
standard policy for its semantic type.
Since: 2.2
void gdk_window_set_skip_pager_hint (GdkWindow *window,gboolean skips_pager);
Toggles whether a window should appear in a pager (workspace
switcher, or other desktop utility program that displays a small
thumbnail representation of the windows on the desktop). If a
window’s semantic type as specified with gdk_window_set_type_hint()
already fully describes the window, this function should
not be called in addition, instead you should
allow the window to be treated according to standard policy for
its semantic type.
Since: 2.2
void gdk_window_set_urgency_hint (GdkWindow *window,gboolean urgent);
Toggles whether a window needs the user's urgent attention.
Since: 2.8
void gdk_window_get_position (GdkWindow *window,gint *x,gint *y);
Obtains the position of the window as reported in the
most-recently-processed GdkEventConfigure. Contrast with
gdk_window_get_geometry() which queries the X server for the
current window position, regardless of which events have been
received or processed.
The position coordinates are relative to the window’s parent window.
void gdk_window_get_root_origin (GdkWindow *window,gint *x,gint *y);
Obtains the top-left corner of the window manager frame in root window coordinates.
window |
a toplevel GdkWindow |
|
x |
return location for X position of window frame. |
[out] |
y |
return location for Y position of window frame. |
[out] |
void gdk_window_get_frame_extents (GdkWindow *window,GdkRectangle *rect);
Obtains the bounding box of the window, including window manager
titlebar/borders if any. The frame position is given in root window
coordinates. To get the position of the window itself (rather than
the frame) in root window coordinates, use gdk_window_get_origin().
window |
a toplevel GdkWindow |
|
rect |
rectangle to fill with bounding box of the window frame. |
[out] |
gint gdk_window_get_origin (GdkWindow *window,gint *x,gint *y);
Obtains the position of a window in root window coordinates.
(Compare with gdk_window_get_position() and
gdk_window_get_geometry() which return the position of a window
relative to its parent window.)
void gdk_window_get_root_coords (GdkWindow *window,gint x,gint y,gint *root_x,gint *root_y);
Obtains the position of a window position in root
window coordinates. This is similar to
gdk_window_get_origin() but allows you to pass
in any position in the window, not just the origin.
window |
||
x |
X coordinate in window |
|
y |
Y coordinate in window |
|
root_x |
return location for X coordinate. |
[out] |
root_y |
return location for Y coordinate. |
[out] |
Since: 2.18
GdkWindow * gdk_window_get_device_position (GdkWindow *window,GdkDevice *device,gint *x,gint *y,GdkModifierType *mask);
Obtains the current device position and modifier state.
The position is given in coordinates relative to the upper left
corner of window
.
Use gdk_window_get_device_position_double() if you need subpixel precision.
The window underneath device
(as with gdk_device_get_window_at_position()), or NULL if the
window is not known to GDK.
[nullable][transfer none]
Since: 3.0
GdkWindow * gdk_window_get_device_position_double (GdkWindow *window,GdkDevice *device,gdouble *x,gdouble *y,GdkModifierType *mask);
Obtains the current device position in doubles and modifier state.
The position is given in coordinates relative to the upper left
corner of window
.
The window underneath device
(as with gdk_device_get_window_at_position()), or NULL if the
window is not known to GDK.
[nullable][transfer none]
Since: 3.10
GdkWindow *
gdk_window_get_parent (GdkWindow *window);
Obtains the parent of window
, as known to GDK. Does not query the
X server; thus this returns the parent as passed to gdk_window_new(),
not the actual parent. This should never matter unless you’re using
Xlib calls mixed with GDK calls on the X11 platform. It may also
matter for toplevel windows, because the window manager may choose
to reparent them.
GdkWindow *
gdk_window_get_toplevel (GdkWindow *window);
Gets the toplevel window that’s an ancestor of window
.
Any window type but GDK_WINDOW_CHILD is considered a
toplevel window, as is a GDK_WINDOW_CHILD window that
has a root window as parent.
GList *
gdk_window_get_children (GdkWindow *window);
Gets the list of children of window
known to GDK.
This function only returns children created via GDK,
so for example it’s useless when used with the root window;
it only returns windows an application created itself.
The returned list must be freed, but the elements in the list need not be.
GList * gdk_window_get_children_with_user_data (GdkWindow *window,gpointer user_data);
Gets the list of children of window
known to GDK with a
particular user_data
set on it.
The returned list must be freed, but the elements in the list need not be.
The list is returned in (relative) stacking order, i.e. the lowest window is first.
Since: 3.10
GList *
gdk_window_peek_children (GdkWindow *window);
Like gdk_window_get_children(), but does not copy the list of
children, so the list does not need to be freed.
GdkEventMask
gdk_window_get_events (GdkWindow *window);
Gets the event mask for window
for all master input devices. See
gdk_window_set_events().
void gdk_window_set_events (GdkWindow *window,GdkEventMask event_mask);
The event mask for a window determines which events will be reported for that window from all master input devices. For example, an event mask including GDK_BUTTON_PRESS_MASK means the window should report button press events. The event mask is the bitwise OR of values from the GdkEventMask enumeration.
See the input handling overview for details.
void gdk_window_set_icon_name (GdkWindow *window,const gchar *name);
Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this function, if you like.
After calling this with a non-NULL name
, calls to gdk_window_set_title()
will not update the icon title.
Using NULL for name
unsets the icon title; further calls to
gdk_window_set_title() will again update the icon title as well.
Note that some platforms don't support window icons.
window |
a toplevel GdkWindow |
|
name |
name of window while iconified (minimized). |
[allow-none] |
void gdk_window_set_transient_for (GdkWindow *window,GdkWindow *parent);
Indicates to the window manager that window
is a transient dialog
associated with the application window parent
. This allows the
window manager to do things like center window
on parent
and
keep window
above parent
.
See gtk_window_set_transient_for() if you’re using GtkWindow or
GtkDialog.
void gdk_window_set_role (GdkWindow *window,const gchar *role);
When using GTK+, typically you should use gtk_window_set_role() instead
of this low-level function.
The window manager and session manager use a window’s role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn’t matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window.
void gdk_window_set_startup_id (GdkWindow *window,const gchar *startup_id);
When using GTK+, typically you should use gtk_window_set_startup_id()
instead of this low-level function.
Since: 2.12
void gdk_window_set_group (GdkWindow *window,GdkWindow *leader);
Sets the group leader window for window
. By default,
GDK sets the group leader for all toplevel windows
to a global window implicitly created by GDK. With this function
you can override this default.
The group leader window allows the window manager to distinguish all windows that belong to a single application. It may for example allow users to minimize/unminimize all windows belonging to an application at once. You should only set a non-default group window if your application pretends to be multiple applications.
GdkWindow *
gdk_window_get_group (GdkWindow *window);
Returns the group leader window for window
. See gdk_window_set_group().
Since: 2.4
void gdk_window_set_decorations (GdkWindow *window,GdkWMDecoration decorations);
“Decorations” are the features the window manager adds to a toplevel GdkWindow.
This function sets the traditional Motif window manager hints that tell the
window manager which decorations you would like your window to have.
Usually you should use gtk_window_set_decorated() on a GtkWindow instead of
using the GDK function directly.
The decorations
argument is the logical OR of the fields in
the GdkWMDecoration enumeration. If GDK_DECOR_ALL is included in the
mask, the other bits indicate which decorations should be turned off.
If GDK_DECOR_ALL is not included, then the other bits indicate
which decorations should be turned on.
Most window managers honor a decorations hint of 0 to disable all decorations, but very few honor all possible combinations of bits.
gboolean gdk_window_get_decorations (GdkWindow *window,GdkWMDecoration *decorations);
Returns the decorations set on the GdkWindow with
gdk_window_set_decorations().
window |
The toplevel GdkWindow to get the decorations from |
|
decorations |
The window decorations will be written here. |
[out] |
void gdk_window_set_functions (GdkWindow *window,GdkWMFunction functions);
Sets hints about the window management functions to make available via buttons on the window frame.
On the X backend, this function sets the traditional Motif window manager hint for this purpose. However, few window managers do anything reliable or interesting with this hint. Many ignore it entirely.
The functions
argument is the logical OR of values from the
GdkWMFunction enumeration. If the bitmask includes GDK_FUNC_ALL,
then the other bits indicate which functions to disable; if
it doesn’t include GDK_FUNC_ALL, it indicates which functions to
enable.
gboolean
gdk_window_get_support_multidevice (GdkWindow *window);
Returns TRUE if the window is aware of the existence of multiple
devices.
Since: 3.0
void gdk_window_set_support_multidevice (GdkWindow *window,gboolean support_multidevice);
This function will enable multidevice features in window
.
Multidevice aware windows will need to handle properly multiple, per device enter/leave events, device grabs and grab ownerships.
Since: 3.0
GdkCursor * gdk_window_get_device_cursor (GdkWindow *window,GdkDevice *device);
Retrieves a GdkCursor pointer for the device
currently set on the
specified GdkWindow, or NULL. If the return value is NULL then
there is no custom cursor set on the specified window, and it is
using the cursor for its parent window.
a GdkCursor, or NULL. The
returned object is owned by the GdkWindow and should not be
unreferenced directly. Use gdk_window_set_cursor() to unset the
cursor of the window.
[nullable][transfer none]
Since: 3.0
void gdk_window_set_device_cursor (GdkWindow *window,GdkDevice *device,GdkCursor *cursor);
Sets a specific GdkCursor for a given device when it gets inside window
.
Use gdk_cursor_new_for_display() or gdk_cursor_new_from_texture() to create
the cursor. To make the cursor invisible, use GDK_BLANK_CURSOR. Passing
NULL for the cursor
argument to gdk_window_set_cursor() means that
window
will use the cursor of its parent window. Most windows should
use this default.
Since: 3.0
GdkEventMask gdk_window_get_device_events (GdkWindow *window,GdkDevice *device);
Returns the event mask for window
corresponding to an specific device.
Since: 3.0
void gdk_window_set_device_events (GdkWindow *window,GdkDevice *device,GdkEventMask event_mask);
Sets the event mask for a given device (Normally a floating device, not
attached to any visible pointer) to window
. For example, an event mask
including GDK_BUTTON_PRESS_MASK means the window should report button
press events. The event mask is the bitwise OR of values from the
GdkEventMask enumeration.
See the input handling overview for details.
Since: 3.0
void gdk_window_coords_from_parent (GdkWindow *window,gdouble parent_x,gdouble parent_y,gdouble *x,gdouble *y);
Transforms window coordinates from a parent window to a child window.
Calling this function is equivalent to subtracting the return
values of gdk_window_get_position() from the parent coordinates.
See also: gdk_window_coords_to_parent()
window |
a child window |
|
parent_x |
X coordinate in parent’s coordinate system |
|
parent_y |
Y coordinate in parent’s coordinate system |
|
x |
return location for X coordinate in child’s coordinate system. |
[out][allow-none] |
y |
return location for Y coordinate in child’s coordinate system. |
[out][allow-none] |
Since: 2.22
void gdk_window_coords_to_parent (GdkWindow *window,gdouble x,gdouble y,gdouble *parent_x,gdouble *parent_y);
Transforms window coordinates from a child window to its parent
window. Calling this function is equivalent to adding the return
values of gdk_window_get_position() to the child coordinates.
See also: gdk_window_coords_from_parent()
window |
a child window |
|
x |
X coordinate in child’s coordinate system |
|
y |
Y coordinate in child’s coordinate system |
|
parent_x |
return location for X coordinate
in parent’s coordinate system, or |
[out][allow-none] |
parent_y |
return location for Y coordinate
in parent’s coordinate system, or |
[out][allow-none] |
Since: 2.22
typedef struct _GdkWindow GdkWindow;
The GdkWindow struct contains only private fields and should not be accessed directly.
Describes the kind of window.
|
root window; this window has no parent, covers the entire screen, and is created by the window system |
||
|
toplevel window (used to implement GtkWindow) |
||
|
child window (used to implement e.g. GtkEntry) |
||
|
override redirect temporary window (used to implement GtkMenu) |
||
|
foreign window (see |
||
|
subsurface-based window; This window is visually tied to a toplevel, and is moved/stacked with it. Currently this window type is only implemented in Wayland. Since 3.14 |
struct GdkWindowClass {
GObjectClass parent_class;
/* Padding for future expansion */
void (*_gdk_reserved1) (void);
void (*_gdk_reserved2) (void);
void (*_gdk_reserved3) (void);
void (*_gdk_reserved4) (void);
void (*_gdk_reserved5) (void);
void (*_gdk_reserved6) (void);
void (*_gdk_reserved7) (void);
void (*_gdk_reserved8) (void);
};
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.
|
indicates that the program has positioned the window |
||
|
min size fields are set |
||
|
max size fields are set |
||
|
base size fields are set |
||
|
aspect ratio fields are set |
||
|
resize increment fields are set |
||
|
window gravity field is set |
||
|
indicates that the window’s position was explicitly set by the user |
||
|
indicates that the window’s size was explicitly set by the user |
struct GdkGeometry {
gint min_width;
gint min_height;
gint max_width;
gint max_height;
gint base_width;
gint base_height;
gint width_inc;
gint height_inc;
gdouble min_aspect;
gdouble max_aspect;
GdkGravity win_gravity;
};
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.
gdk_window_set_geometry_hints() expects the hints to be fully valid already
and simply passes them to the window manager; in contrast,
gtk_window_set_geometry_hints() performs some interpretation. For example,
GtkWindow will apply the hints to the geometry widget instead of the
toplevel window, if you set a geometry widget. Also, the
min_width
/min_height
/max_width
/max_height
fields may be set to -1, and
GtkWindow will substitute the size request of the window or geometry widget.
If the minimum size hint is not provided, GtkWindow will use its requisition
as the minimum size. If the minimum size is provided and a geometry widget is
set, GtkWindow will take the minimum size as the minimum size of the
geometry widget rather than the entire window. The base size is treated
similarly.
The canonical use-case for gtk_window_set_geometry_hints() is to get a
terminal widget to resize properly. Here, the terminal text area should be
the geometry widget; GtkWindow will then automatically set the base size to
the size of other widgets in the terminal window, such as the menubar and
scrollbar. Then, the width_inc
and height_inc
fields should be set to the
size of one character in the terminal. Finally, the base size should be set
to the size of one character. The net effect is that the minimum size of the
terminal will have a 1x1 character terminal area, and only terminal sizes on
the “character grid” will be allowed.
Here’s an example of how the terminal example would be implemented, assuming a terminal area widget called “terminal” and a toplevel window “toplevel”:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
GdkGeometry hints; hints.base_width = terminal->char_width; hints.base_height = terminal->char_height; hints.min_width = terminal->char_width; hints.min_height = terminal->char_height; hints.width_inc = terminal->char_width; hints.height_inc = terminal->char_height; gtk_window_set_geometry_hints (GTK_WINDOW (toplevel), GTK_WIDGET (terminal), &hints, GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE); |
The other useful fields are the min_aspect
and max_aspect
fields; these
contain a width/height ratio as a floating point number. If a geometry widget
is set, the aspect applies to the geometry widget rather than the entire
window. The most common use of these hints is probably to set min_aspect
and
max_aspect
to the same value, thus forcing the window to keep a constant
aspect ratio.
gint |
minimum width of window (or -1 to use requisition, with GtkWindow only) |
|
gint |
minimum height of window (or -1 to use requisition, with GtkWindow only) |
|
gint |
maximum width of window (or -1 to use requisition, with GtkWindow only) |
|
gint |
maximum height of window (or -1 to use requisition, with GtkWindow only) |
|
gint |
allowed window widths are |
|
gint |
allowed window widths are |
|
gint |
width resize increment |
|
gint |
height resize increment |
|
gdouble |
minimum width/height ratio |
|
gdouble |
maximum width/height ratio |
|
GdkGravity |
window gravity, see |
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.
|
the reference point is at the top left corner. |
||
|
the reference point is in the middle of the top edge. |
||
|
the reference point is at the top right corner. |
||
|
the reference point is at the middle of the left edge. |
||
|
the reference point is at the center of the window. |
||
|
the reference point is at the middle of the right edge. |
||
|
the reference point is at the lower left corner. |
||
|
the reference point is at the middle of the lower edge. |
||
|
the reference point is at the lower right corner. |
||
|
the reference point is at the top left corner of the window itself, ignoring window manager decorations. |
Positioning hints for aligning a window relative to a rectangle.
These hints determine how the window should be positioned in the case that the window would fall off-screen if placed in its ideal position.
For example, GDK_ANCHOR_FLIP_X will replace GDK_GRAVITY_NORTH_WEST with
GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left
or right edges of the monitor.
If GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit
on-screen. If GDK_ANCHOR_RESIZE_X is set, the window can be shrunken
horizontally to fit.
In general, when multiple flags are set, flipping should take precedence over sliding, which should take precedence over resizing.
|
allow flipping anchors horizontally |
||
|
allow flipping anchors vertically |
||
|
allow sliding window horizontally |
||
|
allow sliding window vertically |
||
|
allow resizing window horizontally |
||
|
allow resizing window vertically |
||
|
allow flipping anchors on both axes |
||
|
allow sliding window on both axes |
||
|
allow resizing window on both axes |
Since: 3.22
Stability Level: Unstable
Determines a window edge or corner.
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.
See the Extended Window Manager Hints specification for more details about window types.
|
Normal toplevel window. |
||
|
Dialog window. |
||
|
Window used to implement a menu; GTK+ uses this hint only for torn-off menus, see GtkTearoffMenuItem. |
||
|
Window used to implement toolbars. |
||
|
Window used to display a splash screen during application startup. |
||
|
Utility windows which are not detached toolbars or dialogs. |
||
|
Used for creating dock or panel windows. |
||
|
Used for creating the desktop background window. |
||
|
A menu that belongs to a menubar. |
||
|
A menu that does not belong to a menubar, e.g. a context menu. |
||
|
A tooltip. |
||
|
A notification - typically a “bubble” that belongs to a status icon. |
||
|
A popup from a combo box. |
||
|
A window that is used to implement a DND cursor. |
Specifies the state of a toplevel window.
|
the window is not shown. |
||
|
the window is minimized. |
||
|
the window is maximized. |
||
|
the window is sticky. |
||
|
the window is maximized without decorations. |
||
|
the window is kept above other windows. |
||
|
the window is kept below other windows. |
||
|
the window is presented as focused (with active decorations). |
||
|
the window is in a tiled state, Since 3.10. Since 3.91.2, this is deprecated in favor of per-edge information. |
||
|
whether the top edge is tiled, Since 3.91.2 |
||
|
whether the top edge is resizable, Since 3.91.2 |
||
|
whether the right edge is tiled, Since 3.91.2 |
||
|
whether the right edge is resizable, Since 3.91.2 |
||
|
whether the bottom edge is tiled, Since 3.91.2 |
||
|
whether the bottom edge is resizable, Since 3.91.2 |
||
|
whether the left edge is tiled, Since 3.91.2 |
||
|
whether the left edge is resizable, Since 3.91.2 |
Indicates which monitor (in a multi-head setup) a window should span over when in fullscreen mode.
Since: 3.8
typedef void GdkXEvent; /* Can be cast to window system specific
Used to represent native events (XEvents for the X11 backend, MSGs for Win32).
#define GDK_PARENT_RELATIVE 1L
A special value, indicating that the background for a window should be inherited from the parent window.
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.
Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
to Mod2 - Mod5, and indicates this by setting GDK_SUPER_MASK,
GDK_HYPER_MASK or GDK_META_MASK in the state field of key events.
Note that GDK may add internal values to events which include
reserved values such as GDK_MODIFIER_RESERVED_13_MASK. Your code
should preserve and ignore them. You can use GDK_MODIFIER_MASK to
remove all reserved values.
Also note that the GDK X backend interprets button press events for button
4-7 as scroll events, so GDK_BUTTON4_MASK and GDK_BUTTON5_MASK will never
be set.
|
the Shift key. |
||
|
a Lock key (depending on the modifier mapping of the X server this may either be CapsLock or ShiftLock). |
||
|
the Control key. |
||
|
the fourth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier, but normally it is the Alt key). |
||
|
the fifth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). |
||
|
the sixth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). |
||
|
the seventh modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). |
||
|
the eighth modifier key (it depends on the modifier mapping of the X server which key is interpreted as this modifier). |
||
|
the first mouse button. |
||
|
the second mouse button. |
||
|
the third mouse button. |
||
|
the fourth mouse button. |
||
|
the fifth mouse button. |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
A reserved bit flag; do not use in your own code |
||
|
the Super modifier. Since 2.10 |
||
|
the Hyper modifier. Since 2.10 |
||
|
the Meta modifier. Since 2.10 |
||
|
A reserved bit flag; do not use in your own code |
||
|
not used in GDK itself. GTK+ uses it to differentiate between (keyval, modifiers) pairs from key press and release events. |
||
|
a mask covering all modifier types. |
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).
|
the primary modifier used to invoke menu accelerators. |
||
|
the modifier used to invoke context menus. Note that mouse button 3 always triggers context menus. When this modifier is not 0, it additionally triggers context menus when used with mouse button 1. |
||
|
the modifier used to extend selections
using |
||
|
the modifier used to modify selections, which in most cases means toggling the clicked item into or out of the selection. |
||
|
when any of these modifiers is pressed, the key event cannot produce a symbol directly. This is meant to be used for input methods, and for use cases like typeahead search. |
||
|
the modifier that switches between keyboard groups (AltGr on X11/Windows and Option/Alt on OS X). |
||
|
The set of modifier masks accepted as modifiers in accelerators. Needed because Command is mapped to MOD2 on OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a mod key is problematic at best. Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125. |
Since: 3.4
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.
“cursor” property“cursor” GdkCursor *
The mouse pointer for a GdkWindow. See gdk_window_set_cursor() and
gdk_window_get_cursor() for details.
Flags: Read / Write
Since: 2.18
“display” property“display” GdkDisplay *
The GdkDisplay connection of the window. See gdk_window_get_display()
for details.
Flags: Read / Write / Construct Only
Since: 3.90
“state” property“state” GdkWindowState
State.
Flags: Read
Default value: GDK_WINDOW_STATE_WITHDRAWN
“moved-to-rect” signalvoid user_function (GdkWindow *window, gpointer flipped_rect, gpointer final_rect, gboolean flipped_x, gboolean flipped_y, gpointer user_data)
Emitted when the position of window
is finalized after being moved to a
destination rectangle.
window
might be flipped over the destination rectangle in order to keep
it on-screen, in which case flipped_x
and flipped_y
will be set to TRUE
accordingly.
flipped_rect
is the ideal position of window
after any possible
flipping, but before any possible sliding. final_rect
is flipped_rect
,
but possibly translated in the case that flipping is still ineffective in
keeping window
on-screen.
window |
the GdkWindow that moved |
|
flipped_rect |
the position of |
[nullable] |
final_rect |
the final position of |
[nullable] |
flipped_x |
|
|
flipped_y |
|
|
user_data |
user data set when the signal handler was connected. |
Flags: Run First
Since: 3.22
Stability Level: Private
|
|
|
|
Table of Contents
| Top | |
|
|
|
A GdkContentDeserializer is used to deserialize content received via inter-application data transfers.
void
(*GdkContentDeserializeFunc) (GdkContentDeserializer *deserializer);
The type of a function that can be registered with gdk_content_register_deserializer().
When the function gets called to operate on content, it can call functions on the
deserializer
object to obtain the mime type, input stream, user data, etc. for its
operation.
const char *
gdk_content_deserializer_get_mime_type
(GdkContentDeserializer *deserializer);
Gets the mime type to deserialize from.
GType
gdk_content_deserializer_get_gtype (GdkContentDeserializer *deserializer);
Gets the GType to create an instance of.
GValue *
gdk_content_deserializer_get_value (GdkContentDeserializer *deserializer);
Gets the GValue to store the deserialized object in.
GInputStream *
gdk_content_deserializer_get_input_stream
(GdkContentDeserializer *deserializer);
Gets the input stream that was passed to gdk_content_deserialize_async().
int
gdk_content_deserializer_get_priority (GdkContentDeserializer *deserializer);
Gets the io priority that was passed to gdk_content_deserialize_async().
GCancellable *
gdk_content_deserializer_get_cancellable
(GdkContentDeserializer *deserializer);
Gets the cancellable that was passed to gdk_content_deserialize_async().
gpointer
gdk_content_deserializer_get_user_data
(GdkContentDeserializer *deserializer);
Gets the user data that was passed when the deserializer was registered.
void gdk_content_deserializer_set_task_data (GdkContentDeserializer *deserializer,gpointer data,GDestroyNotify notify);
Associate data with the current deserialization operation.
gpointer
gdk_content_deserializer_get_task_data
(GdkContentDeserializer *deserializer);
Gets the data that was associated with deserializer
via gdk_content_deserializer_set_task_data().
void
gdk_content_deserializer_return_success
(GdkContentDeserializer *deserializer);
Indicate that the deserialization has been successfully completed.
void gdk_content_deserializer_return_error (GdkContentDeserializer *deserializer,GError *error);
Indicate that the deserialization has ended with an error.
This function consumes error
.
void gdk_content_register_deserializer (const char *mime_type,GType type,GdkContentDeserializeFunc deserialize,gpointer data,GDestroyNotify notify);
Registers a function to create objects of a given type
from
a serialized representation with the given mime type.
void gdk_content_deserialize_async (GInputStream *stream,const char *mime_type,GType type,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Read content from the given input stream and deserialize it, asynchronously.
When the operation is finished, callback
will be called. You can then
call gdk_content_deserialize_finish() to get the result of the operation.
stream |
a GInputStream to read the serialized content from |
|
mime_type |
the mime type to deserialize from |
|
type |
the GType to deserialize from |
|
io_priority |
the io priority of the operation |
|
cancellable |
optional GCancellable object. |
[nullable] |
callback |
callback to call when the operation is done. |
[scope async] |
user_data |
data to pass to the callback function. |
[closure] |
gboolean gdk_content_deserialize_finish (GAsyncResult *result,GValue *value,GError **error);
Finishes a content deserialization operation.
result |
the GAsyncResult |
|
value |
return location for the result of the operation |
|
error |
return location for an error |
| Top | |
|
|
|
Each window under X can have any number of associated “properties” attached to it. Properties are arbitrary chunks of data identified by “atom”s. (An “atom” is a numeric index into a string table on the X server. They are used to transfer strings efficiently between clients without having to transfer the entire string.) A property has an associated type, which is also identified using an atom.
A property has an associated “format”, an integer describing how many bits are in each unit of data inside the property. It must be 8, 16, or 32. When data is transferred between the server and client, if they are of different endianesses it will be byteswapped as necessary according to the format of the property. Note that on the client side, properties of format 32 will be stored with one unit per long, even if a long integer has more than 32 bits on the platform. (This decision was apparently made for Xlib to maintain compatibility with programs that assumed longs were 32 bits, at the expense of programs that knew better.)
The functions in this section are used to add, remove and change properties on windows, to convert atoms to and from strings and to manipulate some types of data commonly stored in X window properties.
gint gdk_text_property_to_utf8_list_for_display (GdkDisplay *display,GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
Converts a text property in the given encoding to a list of UTF-8 strings.
display |
||
encoding |
an atom representing the encoding of the text |
|
format |
the format of the property |
|
text |
the text to convert. |
[array length=length] |
length |
the length of |
|
list |
location to store the list
of strings or |
[out][array zero-terminated=1] |
Since: 2.2
gchar *
gdk_utf8_to_string_target (const gchar *str);
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.
the newly-allocated string, or NULL if the
conversion failed. (It should not fail for any properly
formed UTF-8 string unless system limits like memory or
file descriptors are exceeded.).
[nullable]
| Top | |
|
|
|
| GdkEvent | |
| enum | GdkEventType |
| enum | GdkEventMask |
| enum | GdkScrollDirection |
| enum | GdkCrossingMode |
| enum | GdkNotifyType |
| #define | GDK_CURRENT_TIME |
| #define | GDK_PRIORITY_EVENTS |
| #define | GDK_PRIORITY_REDRAW |
| #define | GDK_EVENT_PROPAGATE |
| #define | GDK_EVENT_STOP |
| #define | GDK_BUTTON_PRIMARY |
| #define | GDK_BUTTON_MIDDLE |
| #define | GDK_BUTTON_SECONDARY |
| GdkEventSequence |
This section describes functions dealing with events from the window system.
In GTK+ applications the events are handled automatically in
gtk_main_do_event() and passed on to the appropriate widgets,
so these functions are rarely needed.
GdkEvent *
gdk_event_new (GdkEventType type);
Creates a new event of the given type. All fields are set to 0.
Since: 2.2
GdkEvent *
gdk_event_copy (const GdkEvent *event);
Copies a GdkEvent, copying or incrementing the reference count of the resources associated with it (e.g. GdkWindow’s and strings).
void
gdk_event_free (GdkEvent *event);
Frees a GdkEvent, freeing or decrementing any resources associated with it.
This is equivalent to g_object_unref().
gboolean gdk_event_get_axes (GdkEvent *event,gdouble **axes,guint *n_axes);
Extracts all axis values from an event.
event |
a GdkEvent |
|
axes |
the array of values for all axes. |
[transfer none][out][array length=n_axes] |
n_axes |
the length of array. |
[out] |
gboolean gdk_event_get_button (const GdkEvent *event,guint *button);
Extract the button number from an event.
Since: 3.2
gboolean gdk_event_get_click_count (const GdkEvent *event,guint *click_count);
Extracts the click count from an event.
Since: 3.2
gboolean gdk_event_get_coords (const GdkEvent *event,gdouble *x_win,gdouble *y_win);
Extract the event window relative x/y coordinates from an event.
event |
a GdkEvent |
|
x_win |
location to put event window x coordinate. |
[out][optional] |
y_win |
location to put event window y coordinate. |
[out][optional] |
gboolean gdk_event_get_keycode (const GdkEvent *event,guint16 *keycode);
Extracts the hardware keycode from an event.
Also see gdk_event_get_scancode().
Since: 3.2
gboolean gdk_event_get_keyval (const GdkEvent *event,guint *keyval);
Extracts the keyval from an event.
Since: 3.2
gboolean gdk_event_get_root_coords (const GdkEvent *event,gdouble *x_root,gdouble *y_root);
Extract the root window relative x/y coordinates from an event.
event |
a GdkEvent |
|
x_root |
location to put root window x coordinate. |
[out][optional] |
y_root |
location to put root window y coordinate. |
[out][optional] |
gboolean gdk_event_get_scroll_direction (const GdkEvent *event,GdkScrollDirection *direction);
Extracts the scroll direction from an event.
Since: 3.2
gboolean gdk_event_get_scroll_deltas (const GdkEvent *event,gdouble *delta_x,gdouble *delta_y);
Retrieves the scroll deltas from a GdkEvent
event |
a GdkEvent |
|
delta_x |
return location for X delta. |
[out] |
delta_y |
return location for Y delta. |
[out] |
Since: 3.4
gboolean
gdk_event_is_scroll_stop_event (const GdkEvent *event);
Check whether a scroll event is a stop scroll event. Scroll sequences with smooth scroll information may provide a stop scroll event once the interaction with the device finishes, e.g. by lifting a finger. This stop scroll event is the signal that a widget may trigger kinetic scrolling based on the current velocity.
Stop scroll events always have a a delta of 0/0.
Since: 3.20
gboolean gdk_event_get_state (const GdkEvent *event,GdkModifierType *state);
If the event contains a “state” field, puts that field in state
.
Otherwise stores an empty state (0).
event
may be NULL, in which case it’s treated
as if the event had no state field.
guint32
gdk_event_get_time (const GdkEvent *event);
Returns the time stamp from event
, if there is one; otherwise
returns GDK_CURRENT_TIME. If event
is NULL, returns GDK_CURRENT_TIME.
GdkWindow *
gdk_event_get_window (const GdkEvent *event);
Extracts the GdkWindow associated with an event.
Since: 3.10
GdkEventType
gdk_event_get_event_type (const GdkEvent *event);
Retrieves the type of the event.
Since: 3.10
GdkEventSequence *
gdk_event_get_event_sequence (const GdkEvent *event);
If event
if of type GDK_TOUCH_BEGIN, GDK_TOUCH_UPDATE,
GDK_TOUCH_END or GDK_TOUCH_CANCEL, returns the GdkEventSequence
to which the event belongs. Otherwise, return NULL.
Since: 3.4
gboolean gdk_events_get_angle (GdkEvent *event1,GdkEvent *event2,gdouble *angle);
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
gboolean gdk_events_get_center (GdkEvent *event1,GdkEvent *event2,gdouble *x,gdouble *y);
If both events contain X/Y information, the center of both coordinates
will be returned in x
and y
.
Since: 3.0
gboolean gdk_events_get_distance (GdkEvent *event1,GdkEvent *event2,gdouble *distance);
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
gboolean
gdk_event_triggers_context_menu (const GdkEvent *event);
This function returns whether a GdkEventButton should trigger a
context menu, according to platform conventions. The right mouse
button always triggers context menus. Additionally, if
gdk_keymap_get_modifier_mask() returns a non-0 mask for
GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will
also trigger a context menu if this modifier is pressed.
This function should always be used instead of simply checking for
event->button == GDK_BUTTON_SECONDARY.
Since: 3.4
GdkSeat *
gdk_event_get_seat (const GdkEvent *event);
Returns the GdkSeat this event was generated for.
Since: 3.20
int
gdk_event_get_scancode (GdkEvent *event);
Gets the keyboard low-level scancode of a key event.
This is usually hardware_keycode. On Windows this is the high word of WM_KEY{DOWN,UP} lParam which contains the scancode and some extended flags.
Since: 3.22
gboolean
gdk_event_get_pointer_emulated (GdkEvent *event);
Returns whether this event is an 'emulated' pointer event (typically from a touch event), as opposed to a real one.
Since: 3.22
gboolean gdk_event_get_crossing_detail (const GdkEvent *event,GdkNotifyType *detail);
Extracts the crossing detail from an event.
gboolean gdk_event_get_crossing_mode (const GdkEvent *event,GdkCrossingMode *mode);
Extracts the crossing mode from an event.
gboolean gdk_event_get_drag_context (const GdkEvent *event,GdkDragContext **context);
Gets the drag context from a DND event.
gboolean gdk_event_get_focus_in (const GdkEvent *event,gboolean *focus_in);
Extracts whether this is a focus-in or focus-out event.
gboolean gdk_event_get_grab_window (const GdkEvent *event,GdkWindow **window);
Extracts the grab window from a grab broken event.
GList *
gdk_event_get_history (const GdkEvent *event);
Retrieves the history of the event
motion, as a list of time and
coordinates.
gboolean gdk_event_get_key_group (const GdkEvent *event,guint *group);
Extracts the key group from an event.
gboolean gdk_event_get_key_is_modifier (const GdkEvent *event,gboolean *is_modifier);
Extracts whether the event is a key event for a modifier key.
gboolean gdk_event_get_pad_axis_value (const GdkEvent *event,guint *index,gdouble *value);
Extracts the information from a pad event.
event |
a GdkEvent |
|
index |
Return location for the axis index. |
[out] |
value |
Return location for the axis value. |
[out] |
gboolean gdk_event_get_pad_button (const GdkEvent *event,guint *button);
Extracts information about the pressed button from a pad event.
gboolean gdk_event_get_pad_group_mode (const GdkEvent *event,guint *group,guint *mode);
Extracts group and mode information from a pad event.
event |
a GdkEvent |
|
group |
return location for the group. |
[out] |
mode |
return location for the mode. |
[out] |
gboolean gdk_event_get_string (const GdkEvent *event,const char **string);
Extracts a string from an event. The string is an approximation of the keyval in a key event.
gboolean gdk_event_get_touch_emulating_pointer (const GdkEvent *event,gboolean *emulating);
Extracts whether a touch event is emulating a pointer event.
gboolean gdk_event_get_touchpad_angle_delta (const GdkEvent *event,double *delta);
Extracts the angle from a touchpad event.
gboolean gdk_event_get_touchpad_deltas (const GdkEvent *event,double *dx,double *dy);
Extracts delta information from a touchpad event.
gboolean gdk_event_get_touchpad_gesture_n_fingers (const GdkEvent *event,guint *n_fingers);
Extracts the number of fingers from a touchpad event.
gboolean gdk_event_get_touchpad_gesture_phase (const GdkEvent *event,GdkTouchpadGesturePhase *phase);
Extracts the touchpad gesture phase from a touchpad event.
gboolean gdk_event_get_touchpad_scale (const GdkEvent *event,double *scale);
Extracts the scale from a touchpad event.
gboolean
gdk_event_is_sent (const GdkEvent *event);
Returns whether the event was sent explicitly.
void gdk_event_handler_set (GdkEventFunc func,gpointer data,GDestroyNotify notify);
Sets the function to call to handle all events from GDK.
Note that GTK+ uses this to install its own event handler, so it is
usually not useful for GTK+ applications. (Although an application
can call this function then call gtk_main_do_event() to pass
events to GTK+.)
func |
the function to call to handle events from GDK. |
|
data |
user data to pass to the function. |
|
notify |
the function to call when the handler function is removed, i.e. when
|
void (*GdkEventFunc) (GdkEvent *event,gpointer data);
Specifies the type of function passed to gdk_event_handler_set() to
handle all GDK events.
event |
the GdkEvent to process. |
|
data |
user data set when the event handler was installed with
|
[closure] |
gboolean
gdk_get_show_events (void);
Gets whether event debugging output is enabled.
void
gdk_set_show_events (gboolean show_events);
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.
void gdk_event_set_display (GdkEvent *event,GdkDisplay *display);
Sets the display that an event is associated with.
GdkDisplay *
gdk_event_get_display (const GdkEvent *event);
Retrieves the GdkDisplay associated to the event
.
GdkDevice *
gdk_event_get_device (const GdkEvent *event);
If the event contains a “device” field, this function will return
it, else it will return NULL.
Since: 3.0
void gdk_event_set_device (GdkEvent *event,GdkDevice *device);
Sets the device for event
to device
. The event must
have been allocated by GTK+, for instance, by
gdk_event_copy().
Since: 3.0
GdkDevice *
gdk_event_get_source_device (const GdkEvent *event);
This function returns the hardware (slave) GdkDevice that has
triggered the event, falling back to the virtual (master) device
(as in gdk_event_get_device()) if the event wasn’t caused by
interaction with a hardware device. This may happen for example
in synthesized crossing events after a GdkWindow updates its
geometry or a grab is acquired/released.
If the event does not contain a device field, this function will
return NULL.
Since: 3.0
void gdk_event_set_source_device (GdkEvent *event,GdkDevice *device);
Sets the slave device for event
to device
.
The event must have been allocated by GTK+,
for instance by gdk_event_copy().
Since: 3.0
GdkDeviceTool *
gdk_event_get_device_tool (const GdkEvent *event);
If the event was generated by a device that supports
different tools (eg. a tablet), this function will
return a GdkDeviceTool representing the tool that
caused the event. Otherwise, NULL will be returned.
Note: the GdkDeviceTool<!-- -->s will be constant during
the application lifetime, if settings must be stored
persistently across runs, see gdk_device_tool_get_serial()
Since: 3.22
Specifies the type of the event.
Do not confuse these events with the signals that GTK+ widgets emit. Although many of these events result in corresponding signals being emitted, the events are often transformed or filtered along the way.
|
a special code to indicate a null event. |
||
|
the window manager has requested that the toplevel window be hidden or destroyed, usually when the user clicks on a special icon in the title bar. |
||
|
the window has been destroyed. |
||
|
all or part of the window has become visible and needs to be redrawn. |
||
|
the pointer (usually a mouse) has moved. |
||
|
a mouse button has been pressed. |
||
|
a mouse button has been released. |
||
|
a key has been pressed. |
||
|
a key has been released. |
||
|
the pointer has entered the window. |
||
|
the pointer has left the window. |
||
|
the keyboard focus has entered or left the window. |
||
|
the size, position or stacking order of the window has changed.
Note that GTK+ discards these events for |
||
|
the window has been mapped. |
||
|
the window has been unmapped. |
||
|
an input device has moved into contact with a sensing surface (e.g. a touchscreen or graphics tablet). |
||
|
an input device has moved out of contact with a sensing surface. |
||
|
the mouse has entered the window while a drag is in progress. |
||
|
the mouse has left the window while a drag is in progress. |
||
|
the mouse has moved in the window while a drag is in progress. |
||
|
a drop operation onto the window has started. |
||
|
the scroll wheel was turned |
||
|
a pointer or keyboard grab was broken. This event type was added in 2.8. |
||
|
A new touch event sequence has just started. This event type was added in 3.4. |
||
|
A touch event sequence has been updated. This event type was added in 3.4. |
||
|
A touch event sequence has finished. This event type was added in 3.4. |
||
|
A touch event sequence has been canceled. This event type was added in 3.4. |
||
|
A touchpad swipe gesture event, the current state is determined by its phase field. This event type was added in 3.18. |
||
|
A touchpad pinch gesture event, the current state is determined by its phase field. This event type was added in 3.18. |
||
|
A tablet pad button press event. This event type was added in 3.22. |
||
|
A tablet pad button release event. This event type was added in 3.22. |
||
|
A tablet pad axis event from a "ring". This event type was added in 3.22. |
||
|
A tablet pad axis event from a "strip". This event type was added in 3.22. |
||
|
A tablet pad group mode change. This event type was added in 3.22. |
||
|
marks the end of the GdkEventType enumeration. Added in 2.18 |
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.
See the input handling overview for details of event masks and event propagation.
Since GTK 3.8, motion events are already compressed by default, independent
of this mechanism. This compression can be disabled with
gdk_window_set_event_compression(). See the documentation of that function
for details.
If GDK_TOUCH_MASK is enabled, the window will receive touch events
from touch-enabled devices. Those will come as sequences of GdkEventTouch
with type GDK_TOUCH_UPDATE, enclosed by two events with
type GDK_TOUCH_BEGIN and GDK_TOUCH_END (or GDK_TOUCH_CANCEL).
gdk_event_get_event_sequence() returns the event sequence for these
events, so different sequences may be distinguished.
|
receive expose events |
||
|
receive all pointer motion events |
||
|
receive pointer motion events while any button is pressed |
||
|
receive pointer motion events while 1 button is pressed |
||
|
receive pointer motion events while 2 button is pressed |
||
|
receive pointer motion events while 3 button is pressed |
||
|
receive button press events |
||
|
receive button release events |
||
|
receive key press events |
||
|
receive key release events |
||
|
receive window enter events |
||
|
receive window leave events |
||
|
receive focus change events |
||
|
receive events about window configuration change |
||
|
receive property change events |
||
|
receive proximity in events |
||
|
receive proximity out events |
||
|
receive events about window configuration changes of child windows |
||
|
receive scroll events |
||
|
receive touch events. Since 3.4 |
||
|
receive smooth scrolling events. Since 3.4 |
||
|
receive touchpad gesture events. Since 3.18 |
||
|
receive tablet pad events. Since 3.22 |
||
|
the combination of all the above event masks. |
Specifies the direction for scroll events.
|
the window is scrolled up. |
||
|
the window is scrolled down. |
||
|
the window is scrolled to the left. |
||
|
the window is scrolled to the right. |
||
|
the scrolling is determined by the delta values
in scroll events. See |
Specifies the crossing mode for enter and leave events.
|
crossing because of pointer motion. |
||
|
crossing because a grab is activated. |
||
|
crossing because a grab is deactivated. |
||
|
crossing because a GTK+ grab is activated. |
||
|
crossing because a GTK+ grab is deactivated. |
||
|
crossing because a GTK+ widget changed state (e.g. sensitivity). |
||
|
crossing because a touch sequence has begun, this event is synthetic as the pointer might have not left the window. |
||
|
crossing because a touch sequence has ended, this event is synthetic as the pointer might have not left the window. |
||
|
crossing because of a device switch (i.e. a mouse taking control of the pointer after a touch device), this event is synthetic as the pointer didn’t leave the window. |
Specifies the kind of crossing for enter and leave events.
See the X11 protocol specification of LeaveNotify for full details of crossing event generation.
|
the window is entered from an ancestor or left towards an ancestor. |
||
|
the pointer moves between an ancestor and an inferior of the window. |
||
|
the window is entered from an inferior or left towards an inferior. |
||
|
the window is entered from or left towards a window which is neither an ancestor nor an inferior. |
||
|
the pointer moves between two windows which are not ancestors of each other and the window is part of the ancestor chain between one of these windows and their least common ancestor. |
||
|
an unknown type of enter/leave event occurred. |
#define GDK_CURRENT_TIME 0L
Represents the current time, and can be used anywhere a time is expected.
#define GDK_PRIORITY_EVENTS (G_PRIORITY_DEFAULT)
This is the priority that events from the X server are given in the GLib Main Loop.
#define GDK_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 20)
This is the priority that the idle handler processing window updates is given in the GLib Main Loop.
#define GDK_EVENT_PROPAGATE (FALSE)
Use this macro as the return value for continuing the propagation of an event handler.
Since: 3.4
#define GDK_EVENT_STOP (TRUE)
Use this macro as the return value for stopping the propagation of an event handler.
Since: 3.4
#define GDK_BUTTON_PRIMARY (1)
The primary button. This is typically the left mouse button, or the right button in a left-handed setup.
Since: 3.4
#define GDK_BUTTON_SECONDARY (3)
The secondary button. This is typically the right mouse button, or the left button in a left-handed setup.
Since: 3.4
| Top | |
|
|
|
| struct wl_seat * | gdk_wayland_seat_get_wl_seat () |
| struct wl_keyboard * | gdk_wayland_device_get_wl_keyboard () |
| struct wl_pointer * | gdk_wayland_device_get_wl_pointer () |
| struct wl_seat * | gdk_wayland_device_get_wl_seat () |
| struct wl_compositor * | gdk_wayland_display_get_wl_compositor () |
| struct wl_display * | gdk_wayland_display_get_wl_display () |
| GdkWindow * | gdk_wayland_window_new_subsurface () |
| struct wl_surface * | gdk_wayland_window_get_wl_surface () |
| void | gdk_wayland_window_set_use_custom_surface () |
| void | (*GdkWaylandWindowExported) () |
| gboolean | gdk_wayland_window_export_handle () |
| void | gdk_wayland_window_unexport_handle () |
| gboolean | gdk_wayland_window_set_transient_for_exported () |
The functions in this section are specific to the GDK Wayland backend.
To use them, you need to include the <gdk/gdkwayland.h> header and use
the Wayland-specific pkg-config files to build your application (either
gdk-wayland-3.0 or gtk+-wayland-3.0).
To make your code compile with other GDK backends, guard backend-specific
calls by an ifdef as follows. Since GDK may be built with multiple
backends, you should also check for the backend that is in use (e.g. by
using the GDK_IS_WAYLAND_DISPLAY() macro).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#ifdef GDK_WINDOWING_WAYLAND if (GDK_IS_WAYLAND_DISPLAY (display)) { // make Wayland-specific calls here } else #endif #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (display)) { // make X11-specific calls here } else #endif g_error ("Unsupported GDK backend"); |
struct wl_seat *
gdk_wayland_seat_get_wl_seat (GdkSeat *seat);
Returns the Wayland wl_seat of a GdkSeat.
Since: 3.20
struct wl_keyboard *
gdk_wayland_device_get_wl_keyboard (GdkDevice *device);
Returns the Wayland wl_keyboard of a GdkDevice.
Since: 3.10
struct wl_pointer *
gdk_wayland_device_get_wl_pointer (GdkDevice *device);
Returns the Wayland wl_pointer of a GdkDevice.
Since: 3.10
struct wl_seat *
gdk_wayland_device_get_wl_seat (GdkDevice *device);
Returns the Wayland wl_seat of a GdkDevice.
Since: 3.10
struct wl_compositor *
gdk_wayland_display_get_wl_compositor (GdkDisplay *display);
Returns the Wayland global singleton compositor of a GdkDisplay.
Since: 3.8
struct wl_display *
gdk_wayland_display_get_wl_display (GdkDisplay *display);
Returns the Wayland wl_display of a GdkDisplay.
Since: 3.8
GdkWindow * gdk_wayland_window_new_subsurface (GdkDisplay *display,const GdkRectangle *position);
Creates a new subsurface window.
[constructor]
display |
the display to create the window on |
|
position |
position relative to the transient window |
Since: 3.90
struct wl_surface *
gdk_wayland_window_get_wl_surface (GdkWindow *window);
Returns the Wayland surface of a GdkWindow.
Since: 3.8
void
gdk_wayland_window_set_use_custom_surface
(GdkWindow *window);
Marks a GdkWindow as a custom Wayland surface. The application is expected to register the surface as some type of surface using some Wayland interface.
A good example would be writing a panel or on-screen-keyboard as an out-of-process helper - as opposed to having those in the compositor process. In this case the underlying surface isn’t an xdg_shell surface and the panel or OSK client need to identify the wl_surface as a panel or OSK to the compositor. The assumption is that the compositor will expose a private interface to the special client that lets the client identify the wl_surface as a panel or such.
This function should be called before a GdkWindow is shown. This is best done by connecting to the “realize” signal:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
static void widget_realize_cb (GtkWidget *widget) { GdkWindow *window; struct wl_surface *surface; struct input_panel_surface *ip_surface; window = gtk_widget_get_window (widget); gdk_wayland_window_set_custom_surface (window); surface = gdk_wayland_window_get_wl_surface (window); ip_surface = input_panel_get_input_panel_surface (input_panel, surface); input_panel_surface_set_panel (ip_surface); } static void setup_window (GtkWindow *window) { g_signal_connect (window, "realize", G_CALLBACK (widget_realize_cb), NULL); } |
Since: 3.10
void (*GdkWaylandWindowExported) (GdkWindow *window,const char *handle,gpointer user_data);
Callback that gets called when the handle for a window has been obtained from the Wayland compositor. The handle can be passed to other processes, for the purpose of marking windows as transient for out-of-process surfaces.
window |
the GdkWindow that is exported |
|
handle |
the handle |
|
user_data |
user data that was passed to |
Since: 3.22
gboolean gdk_wayland_window_export_handle (GdkWindow *window,GdkWaylandWindowExported callback,gpointer user_data,GDestroyNotify destroy_func);
Asynchronously obtains a handle for a surface that can be passed
to other processes. When the handle has been obtained, callback
will be called.
It is an error to call this function on a window that is already exported.
When the handle is no longer needed, gdk_wayland_window_unexport_handle()
should be called to clean up resources.
The main purpose for obtaining a handle is to mark a surface
from another window as transient for this one, see
gdk_wayland_window_set_transient_for_exported().
Note that this API depends on an unstable Wayland protocol, and thus may require changes in the future.
window |
the GdkWindow to obtain a handle for |
|
callback |
callback to call with the handle |
|
user_data |
user data for |
|
destroy_func |
destroy notify for |
Since: 3.22
void
gdk_wayland_window_unexport_handle (GdkWindow *window);
Destroys the handle that was obtained with
gdk_wayland_window_export_handle().
It is an error to call this function on a window that does not have a handle.
Note that this API depends on an unstable Wayland protocol, and thus may require changes in the future.
Since: 3.22
gboolean gdk_wayland_window_set_transient_for_exported (GdkWindow *window,char *parent_handle_str);
Marks window
as transient for the surface to which the given
parent_handle_str
refers. Typically, the handle will originate
from a gdk_wayland_window_export_handle() call in another process.
Note that this API depends on an unstable Wayland protocol, and thus may require changes in the future.
window |
the GdkWindow to make as transient |
|
parent_handle_str |
an exported handle for a surface |
Since: 3.22
| Top | |
|
|
|
| void | closed | Run Last |
| void | monitor-added | Run Last |
| void | monitor-removed | Run Last |
| void | opened | Run Last |
| void | seat-added | Run Last |
| void | seat-removed | Run Last |
| void | setting-changed | Run Last |
GdkDisplay objects are the GDK representation of a workstation.
Their purpose are two-fold:
To manage and provide information about input devices (pointers, keyboards, etc)
To manage and provide information about output devices (monitors, projectors, etc)
Most of the input device handling has been factored out into separate GdkSeat
objects. Every display has a one or more seats, which can be accessed with
gdk_display_get_default_seat() and gdk_display_list_seats().
Output devices are represented by GdkMonitor objects, which can be accessed
with gdk_display_get_monitor() and similar APIs.
GdkDisplay *
gdk_display_open (const gchar *display_name);
Opens a display.
Since: 2.2
GdkDisplay *
gdk_display_get_default (void);
Gets the default GdkDisplay. This is a convenience
function for:
gdk_display_manager_get_default_display (.gdk_display_manager_get())
Since: 2.2
const gchar *
gdk_display_get_name (GdkDisplay *display);
Gets the name of the display.
a string representing the display name. This string is owned by GDK and should not be modified or freed.
Since: 2.2
gboolean gdk_display_device_is_grabbed (GdkDisplay *display,GdkDevice *device);
Returns TRUE if there is an ongoing grab on device
for display
.
void
gdk_display_beep (GdkDisplay *display);
Emits a short beep on display
Since: 2.2
void
gdk_display_sync (GdkDisplay *display);
Flushes any requests queued for the windowing system and waits until all
requests have been handled. This is often used for making sure that the
display is synchronized with the current state of the program. Calling
gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
generated from earlier requests are handled before the error trap is
removed.
This is most useful for X11. On windowing systems where requests are handled synchronously, this function will do nothing.
Since: 2.2
void
gdk_display_flush (GdkDisplay *display);
Flushes any requests queued for the windowing system; this happens automatically when the main loop blocks waiting for new events, but if your application is drawing without returning control to the main loop, you may need to call this function explicitly. A common case where this function needs to be called is when an application is executing drawing commands from a thread other than the thread where the main loop is running.
This is most useful for X11. On windowing systems where requests are handled synchronously, this function will do nothing.
Since: 2.4
void
gdk_display_close (GdkDisplay *display);
Closes the connection to the windowing system for the given display, and cleans up associated resources.
Since: 2.2
gboolean
gdk_display_is_closed (GdkDisplay *display);
Finds out if the display has been closed.
Since: 2.22
GdkEvent *
gdk_display_get_event (GdkDisplay *display);
Gets the next GdkEvent to be processed for display
, fetching events from the
windowing system if necessary.
the next GdkEvent to be processed,
or NULL if no events are pending.
[nullable][transfer full]
Since: 2.2
GdkEvent *
gdk_display_peek_event (GdkDisplay *display);
Gets a copy of the first GdkEvent in the display
’s event queue, without
removing the event from the queue. (Note that this function will
not get more events from the windowing system. It only checks the events
that have already been moved to the GDK event queue.)
Since: 2.2
void gdk_display_put_event (GdkDisplay *display,const GdkEvent *event);
Appends a copy of the given event onto the front of the event
queue for display
.
Since: 2.2
gboolean
gdk_display_has_pending (GdkDisplay *display);
Returns whether the display has events that are waiting to be processed.
Since: 3.0
gboolean
gdk_display_is_rgba (GdkDisplay *display);
Returns wether windows on this display
are created with an
alpha channel.
Even if a TRUE is returned, it is possible that the
window’s alpha channel won’t be honored when displaying the
window on the screen: in particular, for X an appropriate
windowing manager and compositing manager must be running to
provide appropriate display. Use gdk_display_is_composited()
to check if that is the case.
For setting an overall opacity for a top-level window, see
gdk_window_set_opacity().
On modern displays, this value is always TRUE.
TRUE if windows are created with an alpha channel or
FALSE if the display does not support this functionality.
Since: 3.90
gboolean
gdk_display_is_composited (GdkDisplay *display);
Returns whether windows can reasonably be expected to have
their alpha channel drawn correctly on the screen. Check
gdk_display_is_rgba() for wether the display supports an
alpha channel.
On X11 this function returns whether a compositing manager is
compositing on display
.
On modern displays, this value is always TRUE.
Whether windows with RGBA visuals can reasonably be expected to have their alpha channels drawn correctly on the screen.
Since: 3.90
gboolean
gdk_display_supports_cursor_color (GdkDisplay *display);
Returns TRUE if multicolored cursors are supported
on display
. Otherwise, cursors have only a forground
and a background color.
Since: 2.4
gboolean
gdk_display_supports_cursor_alpha (GdkDisplay *display);
Returns TRUE if cursors can use an 8bit alpha channel
on display
. Otherwise, cursors are restricted to bilevel
alpha (i.e. a mask).
Since: 2.4
guint
gdk_display_get_default_cursor_size (GdkDisplay *display);
Returns the default size to use for cursors on display
.
Since: 2.4
void gdk_display_get_maximal_cursor_size (GdkDisplay *display,guint *width,guint *height);
Gets the maximal size to use for cursors on display
.
display |
||
width |
the return location for the maximal cursor width. |
[out] |
height |
the return location for the maximal cursor height. |
[out] |
Since: 2.4
GdkWindow *
gdk_display_get_default_group (GdkDisplay *display);
Returns the default group leader window for all toplevel windows
on display
. This window is implicitly created by GDK.
See gdk_window_set_group().
Since: 2.4
gboolean
gdk_display_supports_shapes (GdkDisplay *display);
Returns TRUE if gdk_window_shape_combine_mask() can
be used to create shaped windows on display
.
Since: 2.10
gboolean
gdk_display_supports_input_shapes (GdkDisplay *display);
Returns TRUE if gdk_window_input_shape_combine_mask() can
be used to modify the input shape of windows on display
.
Since: 2.10
GdkAppLaunchContext *
gdk_display_get_app_launch_context (GdkDisplay *display);
Returns a GdkAppLaunchContext suitable for launching applications on the given display.
a new GdkAppLaunchContext for display
.
Free with g_object_unref() when done.
[transfer full]
Since: 3.0
void gdk_display_notify_startup_complete (GdkDisplay *display,const gchar *startup_id);
Indicates to the GUI environment that the application has finished loading, using a given identifier.
GTK+ will call this function automatically for GtkWindow
with custom startup-notification identifier unless
gtk_window_set_auto_startup_notification() is called to
disable that feature.
display |
||
startup_id |
a startup-notification identifier, for which notification process should be completed |
Since: 3.0
GdkSeat *
gdk_display_get_default_seat (GdkDisplay *display);
Returns the default GdkSeat for this display.
Since: 3.20
GList *
gdk_display_list_seats (GdkDisplay *display);
Returns the list of seats known to display
.
Since: 3.20
int
gdk_display_get_n_monitors (GdkDisplay *display);
Gets the number of monitors that belong to display
.
The returned number is valid until the next emission of the “monitor-added” or “monitor-removed” signal.
Since: 3.22
GdkMonitor * gdk_display_get_monitor (GdkDisplay *display,int monitor_num);
Gets a monitor associated with this display.
the GdkMonitor, or NULL if
monitor_num
is not a valid monitor number.
[nullable][transfer none]
Since: 3.22
GdkMonitor *
gdk_display_get_primary_monitor (GdkDisplay *display);
Gets the primary monitor for the display.
The primary monitor is considered the monitor where the “main desktop” lives. While normal application windows typically allow the window manager to place the windows, specialized desktop applications such as panels should place themselves on the primary monitor.
If no monitor is the designated primary monitor, any monitor
(usually the first) may be returned. To make sure there is a dedicated
primary monitor, use gdk_monitor_is_primary() on the returned monitor.
the primary monitor, or any monitor if no primary monitor is configured by the user.
[transfer none]
Since: 3.22
GdkMonitor * gdk_display_get_monitor_at_point (GdkDisplay *display,int x,int y);
Gets the monitor in which the point (x
, y
) is located,
or a nearby monitor if the point is not in any monitor.
Since: 3.22
GdkMonitor * gdk_display_get_monitor_at_window (GdkDisplay *display,GdkWindow *window);
Gets the monitor in which the largest area of window
resides, or a monitor close to window
if it is outside
of all monitors.
Since: 3.22
GdkClipboard *
gdk_display_get_clipboard (GdkDisplay *display);
Gets the clipboard used for copy/paste operations.
GdkClipboard *
gdk_display_get_primary_clipboard (GdkDisplay *display);
Gets the clipboard used for the primary selection. On backends where the primary clipboard is not supported natively, GDK emulates this clipboard locally.
gboolean gdk_display_get_setting (GdkDisplay *display,const char *name,GValue *value);
Retrieves a desktop-wide setting such as double-click time
for the display
.
Since: 3.94
GdkKeymap *
gdk_display_get_keymap (GdkDisplay *display);
Returns the GdkKeymap attached to display
.
Since: 3.94
“composited” property“composited” gboolean
TRUE if the display properly composits the alpha channel.
See gdk_display_is_composited() for details.
Flags: Read
Default value: TRUE
Since: 3.90
“rgba” property“rgba” gboolean
TRUE if the display supports an alpha channel. See gdk_display_is_rgba()
for details.
Flags: Read
Default value: TRUE
Since: 3.90
“closed” signalvoid user_function (GdkDisplay *display, gboolean is_error, gpointer user_data)
The ::closed signal is emitted when the connection to the windowing
system for display
is closed.
display |
the object on which the signal is emitted |
|
is_error |
|
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.2
“monitor-added” signalvoid user_function (GdkDisplay *display, GdkMonitor *monitor, gpointer user_data)
The ::monitor-added signal is emitted whenever a monitor is added.
display |
the objedct on which the signal is emitted |
|
monitor |
the monitor that was just added |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.22
“monitor-removed” signalvoid user_function (GdkDisplay *display, GdkMonitor *monitor, gpointer user_data)
The ::monitor-removed signal is emitted whenever a monitor is removed.
display |
the object on which the signal is emitted |
|
monitor |
the monitor that was just removed |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.22
“opened” signalvoid user_function (GdkDisplay *display, gpointer user_data)
The ::opened signal is emitted when the connection to the windowing
system for display
is opened.
display |
the object on which the signal is emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
“seat-added” signalvoid user_function (GdkDisplay *display, GdkSeat *seat, gpointer user_data)
The ::seat-added signal is emitted whenever a new seat is made known to the windowing system.
display |
the object on which the signal is emitted |
|
seat |
the seat that was just added |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“seat-removed” signalvoid user_function (GdkDisplay *display, GdkSeat *seat, gpointer user_data)
The ::seat-removed signal is emitted whenever a seat is removed by the windowing system.
display |
the object on which the signal is emitted |
|
seat |
the seat that was just removed |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“setting-changed” signalvoid user_function (GdkDisplay *display, gchar *setting, gpointer user_data)
The ::setting-changed signal is emitted whenever a setting changes its value.
display |
the object on which the signal is emitted |
|
setting |
the name of the setting that changed |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.94
| Top | |
|
|
|
| void | gdk_app_launch_context_set_desktop () |
| void | gdk_app_launch_context_set_timestamp () |
| void | gdk_app_launch_context_set_icon () |
| void | gdk_app_launch_context_set_icon_name () |
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.
1 2 3 4 5 6 7 8 9 10 11 |
GdkAppLaunchContext *context; context = gdk_display_get_app_launch_context (display); gdk_app_launch_context_set_display (display); gdk_app_launch_context_set_timestamp (event->time); if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error)) g_warning ("Launching failed: %s\n", error->message); g_object_unref (context); |
void gdk_app_launch_context_set_desktop (GdkAppLaunchContext *context,gint desktop);
Sets the workspace on which applications will be launched when using this context when running under a window manager that supports multiple workspaces, as described in the Extended Window Manager Hints.
When the workspace is not specified or desktop
is set to -1,
it is up to the window manager to pick one, typically it will
be the current workspace.
Since: 2.14
void gdk_app_launch_context_set_timestamp (GdkAppLaunchContext *context,guint32 timestamp);
Sets the timestamp of context
. The timestamp should ideally
be taken from the event that triggered the launch.
Window managers can use this information to avoid moving the focus to the newly launched application when the user is busy typing in another window. This is also known as 'focus stealing prevention'.
Since: 2.14
void gdk_app_launch_context_set_icon (GdkAppLaunchContext *context,GIcon *icon);
Sets the icon for applications that are launched with this context.
Window Managers can use this information when displaying startup notification.
See also gdk_app_launch_context_set_icon_name().
Since: 2.14
void gdk_app_launch_context_set_icon_name (GdkAppLaunchContext *context,const char *icon_name);
Sets the icon for applications that are launched with this context.
The icon_name
will be interpreted in the same way as the Icon field
in desktop files. See also gdk_app_launch_context_set_icon().
If both icon
and icon_name
are set, the icon_name
takes priority.
If neither icon
or icon_name
is set, the icon is taken from either
the file that is passed to launched application or from the GAppInfo
for the launched application itself.
Since: 2.14
| Top | |
|
|
|
Cairo is a graphics library that supports vector graphics and image compositing that can be used with GDK. GTK+ does all of its drawing using cairo.
GDK does not wrap the cairo API, instead it allows to create cairo contexts which can be used to draw on GdkWindows. Additional functions allow use GdkRectangles with cairo and to use GdkRGBAs, GdkPixbufs and GdkWindows as sources for drawing operations.
cairo_surface_t * gdk_window_create_similar_surface (GdkWindow *window,cairo_content_t content,int width,int height);
Create a new surface that is as compatible as possible with the
given window
. For example the new surface will have the same
fallback resolution and font options as window
. Generally, the new
surface will also use the same backend as window
, unless that is
not possible for some reason. The type of the returned surface may
be examined with cairo_surface_get_type().
Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.)
window |
window to make new surface similar to |
|
content |
the content for the new surface |
|
width |
width of the new surface |
|
height |
height of the new surface |
a pointer to the newly allocated surface. The caller
owns the surface and should call cairo_surface_destroy() when done
with it.
This function always returns a valid pointer, but it will return a
pointer to a “nil” surface if other
is already in an error state
or any other error occurs.
Since: 2.22
cairo_surface_t * gdk_window_create_similar_image_surface (GdkWindow *window,cairo_format_t format,int width,int height,int scale);
Create a new image surface that is efficient to draw on the
given window
.
Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.)
The width
and height
of the new surface are not affected by
the scaling factor of the window
, or by the scale
argument; they
are the size of the surface in device pixels. If you wish to create
an image surface capable of holding the contents of window
you can
use:
1 2 3 4 5 6 7 8 9 10 |
int scale = gdk_window_get_scale_factor (window); int width = gdk_window_get_width (window) * scale; int height = gdk_window_get_height (window) * scale; // format is set elsewhere cairo_surface_t *surface = gdk_window_create_similar_image_surface (window, format, width, height, scale); |
Note that unlike cairo_surface_create_similar_image(), the new
surface's device scale is set to scale
, or to the scale factor of
window
if scale
is 0.
window |
window to make new surface similar to, or
|
[nullable] |
format |
the format for the new surface. |
[type int] |
width |
width of the new surface |
|
height |
height of the new surface |
|
scale |
the scale of the new surface, or 0 to use same as |
a pointer to the newly allocated surface. The caller
owns the surface and should call cairo_surface_destroy() when done
with it.
This function always returns a valid pointer, but it will return a
pointer to a “nil” surface if other
is already in an error state
or any other error occurs.
Since: 3.10
gboolean gdk_cairo_get_clip_rectangle (cairo_t *cr,GdkRectangle *rect);
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.
GdkDrawingContext *
gdk_cairo_get_drawing_context (cairo_t *cr);
Retrieves the GdkDrawingContext that created the Cairo
context cr
.
Since: 3.22
void gdk_cairo_set_source_rgba (cairo_t *cr,const GdkRGBA *rgba);
Sets the specified GdkRGBA as the source color of cr
.
Since: 3.0
void gdk_cairo_set_source_pixbuf (cairo_t *cr,const GdkPixbuf *pixbuf,gdouble pixbuf_x,gdouble pixbuf_y);
Sets the given pixbuf as the source pattern for cr
.
The pattern has an extend mode of CAIRO_EXTEND_NONE and is aligned
so that the origin of pixbuf
is pixbuf_x
, pixbuf_y
.
cr |
a cairo context |
|
pixbuf |
||
pixbuf_x |
X coordinate of location to place upper left corner of |
|
pixbuf_y |
Y coordinate of location to place upper left corner of |
Since: 2.8
void gdk_cairo_rectangle (cairo_t *cr,const GdkRectangle *rectangle);
Adds the given rectangle to the current path of cr
.
Since: 2.8
void gdk_cairo_region (cairo_t *cr,const cairo_region_t *region);
Adds the given region to the current path of cr
.
Since: 2.8
cairo_region_t *
gdk_cairo_region_create_from_surface (cairo_surface_t *surface);
Creates region that describes covers the area where the given
surface
is more than 50% opaque.
This function takes into account device offsets that might be
set with cairo_surface_set_device_offset().
cairo_surface_t * gdk_cairo_surface_create_from_pixbuf (const GdkPixbuf *pixbuf,int scale,GdkWindow *for_window);
Creates an image surface with the same contents as the pixbuf.
Since: 3.10
void gdk_cairo_draw_from_gl (cairo_t *cr,GdkWindow *window,int source,int source_type,int buffer_scale,int x,int y,int width,int height);
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.
This will work for *all* cairo_t, as long as window
is realized, but the
fallback implementation that reads back the pixels from the buffer may be
used in the general case. In the case of direct drawing to a window with
no special effects applied to cr
it will however use a more efficient
approach.
For GL_RENDERBUFFER the code will always fall back to software for buffers with alpha components, so make sure you use GL_TEXTURE if using alpha.
Calling this may change the current GL context.
cr |
a cairo context |
|
window |
The window we're rendering for (not necessarily into) |
|
source |
The GL ID of the source buffer |
|
source_type |
The type of the |
|
buffer_scale |
The scale-factor that the |
|
x |
The source x position in |
|
y |
The source y position in |
|
width |
The width of the region to draw |
|
height |
The height of the region to draw |
Since: 3.16
void gdk_cairo_surface_upload_to_gl (cairo_surface_t *surface,int target,int width,int height,GdkGLContext *context);
Uploads the contents of a Cairo surface
to a GL texture target
.
surface |
a Cairo surface |
|
target |
a GL texture target |
|
width |
the width of the texture |
|
height |
the height of the texture |
|
context |
a GdkGLContext, or |
[nullable] |
Since: 3.90
| Top | |
|
|
|
| GdkCursor * | gdk_cursor_new_from_texture () |
| GdkCursor * | gdk_cursor_new_from_name () |
| GdkCursor * | gdk_cursor_get_fallback () |
| const char * | gdk_cursor_get_name () |
| GdkTexture * | gdk_cursor_get_texture () |
| int | gdk_cursor_get_hotspot_x () |
| int | gdk_cursor_get_hotspot_y () |
These functions are used to create and destroy cursors. Cursors are immutable objects, so once you created them, there is no way to modify them later. Create a new cursor, when you want to change something about it.
Cursors by themselves are not very interesting, they must be
bound to a window for users to see them. This is done with
gdk_window_set_cursor() or gdk_window_set_device_cursor().
Applications will typically use higher-level GTK+ functions such
as gtk_widget_set_cursor() instead.
Cursors are not bound to a given GdkDisplay, so they can be shared. However, the appearance of cursors may vary when used on different platforms.
There are multiple ways to create cursors. The platform's own cursors
can be created with gdk_cursor_new_from_name(). That function lists
the commonly available names that are shared with the CSS specification.
Other names may be available, depending on the platform in use.
Another option to create a cursor is to use gdk_cursor_new_from_texture()
and provide an image to use for the cursor. Depending on the GdkDisplay
in use, the type of supported images may be limited. See
gdk_display_supports_cursor_alpha(),
gdk_display_supports_cursor_color(),
gdk_display_get_default_cursor_size() and
gdk_display_get_maximal_cursor_size() for the limitations that might apply.
To ease work with unsupported cursors, a fallback cursor can be provided. If a GdkWindow cannot use a cursor because of the reasons mentioned above, it will try the fallback cursor. Of course, fallback cursors can themselves have fallback cursors again, so it is possible to provide a chain of progressively easier to support cursors. If none of the provided cursors can be supported, the default cursor will be the ultimate fallback.
GdkCursor * gdk_cursor_new_from_texture (GdkTexture *texture,int hotspot_x,int hotspot_y,GdkCursor *fallback);
Creates a new cursor from a GdkTexture.
Not all GDK backends support RGBA cursors. If they are not
supported, a monochrome approximation will be displayed.
The functions gdk_display_supports_cursor_alpha() and
gdk_display_supports_cursor_color() can be used to determine
whether RGBA cursors are supported;
gdk_display_get_default_cursor_size() and
gdk_display_get_maximal_cursor_size() give information about
cursor sizes.
On the X backend, support for RGBA cursors requires a sufficently new version of the X Render extension.
Since: 3.94
GdkCursor * gdk_cursor_new_from_name (const gchar *name,GdkCursor *fallback);
Creates a new cursor by looking up name
in the current cursor
theme.
A recommended set of cursor names that will work across different platforms can be found in the CSS specification:
"none"
"default"
"help"
"pointer"
"context-menu"
"progress"
"wait"
"cell"
"crosshair"
"text"
"vertical-text"
"alias"
"copy"
"no-drop"
"move"
"not-allowed"
"grab"
"grabbing"
"all-scroll"
"col-resize"
"row-resize"
"n-resize"
"e-resize"
"s-resize"
"w-resize"
"ne-resize"
"nw-resize"
"sw-resize"
"se-resize"
"ew-resize"
"ns-resize"
"nesw-resize"
"nwse-resize"
"zoom-in"
"zoom-out"
Since: 2.8
GdkCursor *
gdk_cursor_get_fallback (GdkCursor *cursor);
Returns the fallback for this cursor
. The fallback will be used if this
cursor is not available on a given GdkDisplay.
For named cursors, this can happen when using nonstandard names or when using an incomplete cursor theme. For textured cursors, this can happen when the texture is too large or when the GdkDisplay it is used on does not support textured cursors.
Since: 3.94
const char *
gdk_cursor_get_name (GdkCursor *cursor);
Returns the name of the cursor. If the cursor is not a named cursor, NULL
will be returned and the GdkCursor::texture property will be set.
Since: 3.94
GdkTexture *
gdk_cursor_get_texture (GdkCursor *cursor);
Returns the texture for the cursor. If the cursor is a named cursor, NULL
will be returned and the GdkCursor::name property will be set.
Since: 3.94
int
gdk_cursor_get_hotspot_x (GdkCursor *cursor);
Returns the horizontal offset of the hotspot. The hotspot indicates the pixel that will be directly above the cursor.
Since: 3.94
int
gdk_cursor_get_hotspot_y (GdkCursor *cursor);
Returns the vertical offset of the hotspot. The hotspot indicates the pixel that will be directly above the cursor.
Since: 3.94
typedef struct _GdkCursor GdkCursor;
A GdkCursor represents a cursor. Its contents are private.
Cursors are immutable objects, so they can not change after they have been constructed.
“fallback” property“fallback” GdkCursor *
Cursor image to fall back to if this cursor cannot be displayed.
Flags: Read / Write / Construct Only
“hotspot-x” property“hotspot-x” gint
Horizontal offset of the cursor hotspot.
Flags: Read / Write / Construct Only
Allowed values: >= 0
Default value: 0
“hotspot-y” property“hotspot-y” gint
Vertical offset of the cursor hotspot.
Flags: Read / Write / Construct Only
Allowed values: >= 0
Default value: 0
“name” property“name” gchar *
Name of this cursor.
Flags: Read / Write / Construct Only
Default value: NULL
“texture” property“texture” GdkTexture *
The texture displayed by this cursor.
Flags: Read / Write / Construct Only
| Top | |
|
|
|
GDK provides the GdkPoint and GdkRectangle data types for representing pixels and sets of pixels on the screen. Together with Cairo’s cairo_region_t data type, they make up the central types for representing graphical data.
A GdkPoint represents an x and y coordinate of a point.
A GdkRectangle represents the position and size of a rectangle.
The intersection of two rectangles can be computed with
gdk_rectangle_intersect(). To find the union of two rectangles use
gdk_rectangle_union().
cairo_region_t is usually used for managing clipping of graphical operations.
gboolean gdk_rectangle_intersect (const GdkRectangle *src1,const GdkRectangle *src2,GdkRectangle *dest);
Calculates the intersection of two rectangles. It is allowed for
dest
to be the same as either src1
or src2
. If the rectangles
do not intersect, dest
’s width and height is set to 0 and its x
and y values are undefined. If you are only interested in whether
the rectangles intersect, but not in the intersecting area itself,
pass NULL for dest
.
src1 |
||
src2 |
||
dest |
return location for the
intersection of |
[out caller-allocates][allow-none] |
void gdk_rectangle_union (const GdkRectangle *src1,const GdkRectangle *src2,GdkRectangle *dest);
Calculates the union of two rectangles.
The union of rectangles src1
and src2
is the smallest rectangle which
includes both src1
and src2
within it.
It is allowed for dest
to be the same as either src1
or src2
.
Note that this function does not ignore 'empty' rectangles (ie. with zero width or height).
gboolean gdk_rectangle_equal (const GdkRectangle *rect1,const GdkRectangle *rect2);
Checks if the two given rectangles are equal.
Since: 3.20
gboolean gdk_rectangle_contains_point (const GdkRectangle *rect,int x,int y);
Returns TRUE if rect
contains the point described by x
and y
.
Since: 3.92
typedef struct {
int x, y;
int width, height;
} GdkRectangle;
Defines the position and size of a rectangle. It is identical to cairo_rectangle_int_t.
| Top | |
|
|
|
A GdkContentProvider is used to provide content for the clipboard in a number of formats.
To create a GdkContentProvider, use gdk_content_provider_new_for_value() or
gdk_content_provider_new_for_bytes().
GDK knows how to handle common text and image formats out-of-the-box. See GdkContentSerializer and GdkContentDeserializer if you want to add support for application-specific data formats.
GdkContentProvider *
gdk_content_provider_new_for_value (const GValue *value);
Create a content provider that provides the given value
.
GdkContentProvider * gdk_content_provider_new_for_bytes (const char *mime_type,GBytes *bytes);
Create a content provider that provides the given bytes
as data for
the given mime_type
.
GdkContentFormats *
gdk_content_provider_ref_formats (GdkContentProvider *provider);
Gets the formats that the provider can provide its current contents in.
GdkContentFormats *
gdk_content_provider_ref_storable_formats
(GdkContentProvider *provider);
Gets the formats that the provider suggests other applications to store the data in. An example of such an application would be a clipboard manager.
This can be assumed to be a subset of gdk_content_provider_ref_formats().
void
gdk_content_provider_content_changed (GdkContentProvider *provider);
Emits the “contents-changed” signal.
void gdk_content_provider_write_mime_type_async (GdkContentProvider *provider,const char *mime_type,GOutputStream *stream,int io_priority,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data);
Asynchronously writes the contents of provider
to stream
in the given
mime_type
. When the operation is finished callback
will be called. You
can then call gdk_content_provider_write_mime_type_finish() to get the
result of the operation.
The given mime type does not need to be listed in the formats returned by
gdk_content_provider_ref_formats(). However, if the given GType is not
supported, G_IO_ERROR_NOT_SUPPORTED will be reported.
The given stream
will not be closed.
provider |
||
mime_type |
the mime type to provide the data in |
|
stream |
the GOutputStream to write to |
|
io_priority |
the I/O priority of the request. |
|
cancellable |
optional GCancellable object, |
[nullable] |
callback |
callback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
gboolean gdk_content_provider_write_mime_type_finish (GdkContentProvider *provider,GAsyncResult *result,GError **error);
Finishes an asynchronous write operation started with
gdk_content_provider_write_mime_type_async().
TRUE if the operation was completed successfully. Otherwise
error
will be set to describe the failure.
gboolean gdk_content_provider_get_value (GdkContentProvider *provider,GValue *value,GError **error);
Gets the convtents of provider
stored in value
.
The value
will have been initialized to the GType the value should be
provided in. This given GType does not need to be listed in the formats
returned by gdk_content_provider_ref_formats(). However, if the given
GType is not supported, this operation can fail and
G_IO_ERROR_NOT_SUPPORTED will be reported.
TRUE if the value was set successfully. Otherwise
error
will be set to describe the failure.
| Top | |
|
|
|
| GdkContentProvider * | content | Read / Write / Construct Only |
| GdkDisplay * | display | Read / Write / Construct Only |
| GdkContentFormats * | formats | Read |
| void | action-changed | Run Last |
| void | cancel | Run Last |
| void | dnd-finished | Run Last |
| void | drop-performed | Run Last |
These functions provide a low level interface for drag and drop. The X backend of GDK supports both the Xdnd and Motif drag and drop protocols transparently, the Win32 backend supports the WM_DROPFILES protocol.
GTK+ provides a higher level abstraction based on top of these functions, and so they are not normally needed in GTK+ applications. See the Drag and Drop section of the GTK+ documentation for more information.
void gdk_drop_reply (GdkDragContext *context,gboolean accepted,guint32 time_);
Accepts or rejects a drop.
This function is called by the drag destination in response to a drop initiated by the drag source.
void gdk_drag_drop_done (GdkDragContext *context,gboolean success);
Inform GDK if the drop ended successfully. Passing FALSE
for success
may trigger a drag cancellation animation.
This function is called by the drag source, and should
be the last call before dropping the reference to the
context
.
The GdkDragContext will only take the first gdk_drag_drop_done()
call as effective, if this function is called multiple times,
all subsequent calls will be ignored.
Since: 3.20
GdkDragContext * gdk_drag_begin (GdkWindow *window,GdkDevice *device,GdkContentProvider *content,GdkDragAction actions,gint dx,gint dy);
Starts a drag and creates a new drag context for it.
This function is called by the drag source.
window |
the source window for this drag |
|
device |
the device that controls this drag |
|
content |
the offered content. |
[transfer none] |
actions |
the actions supported by this drag |
|
dx |
the x offset to |
|
dy |
the y offset to |
void gdk_drop_finish (GdkDragContext *context,gboolean success,guint32 time_);
Ends the drag operation after a drop.
This function is called by the drag destination.
context |
||
success |
|
|
time_ |
the timestamp for this operation |
void gdk_drag_status (GdkDragContext *context,GdkDragAction action,guint32 time_);
Selects one of the actions offered by the drag source.
This function is called by the drag destination in response to
gdk_drag_motion() called by the drag source.
gboolean
gdk_drag_drop_succeeded (GdkDragContext *context);
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
GdkDisplay *
gdk_drag_context_get_display (GdkDragContext *context);
Gets the GdkDisplay that the drag context was created for.
GdkDragAction
gdk_drag_context_get_actions (GdkDragContext *context);
Determines the bitmask of actions proposed by the source if
gdk_drag_context_get_suggested_action() returns GDK_ACTION_ASK.
Since: 2.22
GdkDragAction
gdk_drag_context_get_suggested_action (GdkDragContext *context);
Determines the suggested drag action of the context.
Since: 2.22
GdkDragAction
gdk_drag_context_get_selected_action (GdkDragContext *context);
Determines the action chosen by the drag destination.
Since: 2.22
GdkContentFormats *
gdk_drag_context_get_formats (GdkDragContext *context);
Retrieves the formats supported by this context.
Since: 3.94
GdkDevice *
gdk_drag_context_get_device (GdkDragContext *context);
Returns the GdkDevice associated to the drag context.
GdkWindow *
gdk_drag_context_get_source_window (GdkDragContext *context);
Returns the GdkWindow where the DND operation started.
Since: 2.22
GdkWindow *
gdk_drag_context_get_dest_window (GdkDragContext *context);
Returns the destination window for the DND operation.
Since: 3.0
GdkWindow *
gdk_drag_context_get_drag_window (GdkDragContext *context);
Returns the window on which the drag icon should be rendered
during the drag operation. Note that the window may not be
available until the drag operation has begun. GDK will move
the window in accordance with the ongoing drag operation.
The window is owned by context
and will be destroyed when
the drag operation is over.
Since: 3.20
void gdk_drag_context_set_hotspot (GdkDragContext *context,gint hot_x,gint hot_y);
Sets the position of the drag window that will be kept under the cursor hotspot. Initially, the hotspot is at the top left corner of the drag window.
context |
||
hot_x |
x coordinate of the drag window hotspot |
|
hot_y |
y coordinate of the drag window hotspot |
Since: 3.20
typedef struct _GdkDragContext GdkDragContext;
The GdkDragContext struct contains only private fields and should not be accessed directly.
Used in GdkDragContext to the reason of a cancelled DND operation.
Since: 3.20
Used in GdkDragContext to indicate what the destination should do with the dropped data.
|
Means nothing, and should not be used. |
||
|
Copy the data. |
||
|
Move the data, i.e. first copy it, then delete it from the source using the DELETE target of the X selection protocol. |
||
|
Add a link to the data. Note that this is only useful if source and destination agree on what it means. |
||
|
Special action which tells the source that the destination will do something that the source doesn’t understand. |
||
|
Ask the user what to do with the data. |
“content” property“content” GdkContentProvider *
The GdkContentProvider or NULL if the context is not a source-side
context.
Flags: Read / Write / Construct Only
Since: 3.94
“display” property“display” GdkDisplay *
The GdkDisplay that the drag context belongs to.
Flags: Read / Write / Construct Only
Since: 3.94
“formats” property“formats” GdkContentFormats *
The possible formats that the context can provide its data in.
Flags: Read
Since: 3.94
“action-changed” signalvoid user_function (GdkDragContext *context, GdkDragAction action, gpointer user_data)
A new action is being chosen for the drag and drop operation.
context |
The object on which the signal is emitted |
|
action |
The action currently chosen |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“cancel” signalvoid user_function (GdkDragContext *context, GdkDragCancelReason reason, gpointer user_data)
The drag and drop operation was cancelled.
context |
The object on which the signal is emitted |
|
reason |
The reason the context was cancelled |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“dnd-finished” signalvoid user_function (GdkDragContext *context, gpointer user_data)
The drag and drop operation was finished, the drag destination finished reading all data. The drag source can now free all miscellaneous data.
context |
The object on which the signal is emitted |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
“drop-performed” signalvoid user_function (GdkDragContext *context, gint time, gpointer user_data)
The drag and drop operation was performed on an accepting client.
context |
The object on which the signal is emitted |
|
time |
the time at which the drop happened. |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 3.20
If gdk_disable_multidevice() has been called, this function will respectively return 2/3 for the core pointer and keyboard, (matching the IDs for the Virtual Core Pointer and Keyboard in XInput 2), but calling this function on any slave devices (i.e. those managed via XInput 1.x), will return 0.