AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
dd3c3b683f
gtk2/gdk/gdkdisplayprivate.h

343 lines
18 KiB
C
Raw Normal View History

Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
/* GDK - The GIMP Drawing Kit
* Copyright (C) 2010 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
*/
#ifndef __GDK_DISPLAY_PRIVATE_H__
#define __GDK_DISPLAY_PRIVATE_H__
#include "gdkdisplay.h"
Add a vfunc for _gdk_window_impl_new
2010-12-16 00:07:36 +00:00
#include "gdkwindow.h"
Add vfuncs for a bunch of cursor functionality to GdkDisplay
2010-12-13 17:36:35 +00:00
#include "gdkcursor.h"
display: Add new monitor apis This follows our general direction of moving functionality from GdkScreen to GdkDisplay.
2016-04-01 03:10:37 +00:00
#include "gdkmonitor.h"
Move rendering mode into GdkDisplay This is in preparation for making it runtime-settable in the inspector.
2014-11-10 19:28:43 +00:00
#include "gdkinternals.h"
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
G_BEGIN_DECLS
Consistently hide class structs And, since we've decided to keep the structs private, there is no point in having the standard GObject clas macros anymore either.
2010-12-24 20:54:12 +00:00
#define GDK_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY, GdkDisplayClass))
#define GDK_IS_DISPLAY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY))
#define GDK_DISPLAY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY, GdkDisplayClass))
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
typedef struct _GdkDisplayClass GdkDisplayClass;
GdkDisplay: Remove unused GdkKeyboardGrabInfo struct I can't find anything that uses this struct and it seems to be replaced by GdkDeviceGrabInfo
2014-06-09 02:17:39 +00:00
/* Tracks information about the device grab on this display */
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
typedef struct
{
GdkWindow *window;
GdkWindow *native_window;
gulong serial_start;
gulong serial_end; /* exclusive, i.e. not active on serial_end */
guint event_mask;
guint32 time;
GdkGrabOwnership ownership;
guint activated : 1;
guint implicit_ungrab : 1;
GdkDisplay: Struct packing improvements
2011-04-12 14:34:55 +00:00
guint owner_events : 1;
guint implicit : 1;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
} GdkDeviceGrabInfo;
gdk: Add internal API to deal with touch implicit grabs The necessary information about a touch implicit grab is stored in GdkTouchGrabInfo structs, these are meant to be transient to the touch sequence.
2011-12-28 01:14:18 +00:00
/* Tracks information about a touch implicit grab on this display */
typedef struct
{
GdkDevice *device;
GdkEventSequence *sequence;
GdkWindow *window;
GdkWindow *native_window;
gulong serial;
guint event_mask;
guint32 time;
} GdkTouchGrabInfo;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
/* Tracks information about which window and position the pointer last was in.
* This is useful when we need to synthesize events later.
* Note that we track toplevel_under_pointer using enter/leave events,
* so in the case of a grab, either with owner_events==FALSE or with the
* pointer in no clients window the x/y coordinates may actually be outside
* the window.
*/
typedef struct
{
GdkWindow *toplevel_under_pointer; /* toplevel window containing the pointer, */
/* tracked via native events */
GdkWindow *window_under_pointer; /* window that last got a normal enter event */
gdouble toplevel_x, toplevel_y;
guint32 state;
guint32 button;
gdk: Keep track of the last slave device used This last slave device (stored per master) is used to fill in the missing slave device in synthesized crossing events that are not directly caused by a device event (ie due to configure events or grabs).
2011-12-03 14:04:19 +00:00
GdkDevice *last_slave;
gdk: Generate crossing events around touch devices' press/release Anytime a touch device interacts, the crossing events generation will change to a touch mode where only events with mode GDK_CROSSING_TOUCH_BEGIN/END are handled, and those are sent around touch begin/end. Those are virtual as the master device may still stay on the window. Whenever there is a switch of slave device (the user starts using another non-touch device), a crossing event with mode GDK_CROSSING_DEVICE_SWITCH may generated if needed, and the normal crossing event handling is resumed.
2011-12-03 14:11:08 +00:00
guint need_touch_press_enter : 1;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
} GdkPointerWindowInfo;
typedef struct
{
guint32 button_click_time[2]; /* last 2 button click times */
GdkWindow *button_window[2]; /* last 2 windows to receive button presses */
gint button_number[2]; /* last 2 buttons to be pressed */
gint button_x[2]; /* last 2 button click positions */
gint button_y[2];
gdk: Avoid 2/3BUTTON event generation if the source device changes Remember the last source device we're generating multiple clicks for, just so we can bail out if the device changed. That will just reset the counting. https://bugzilla.gnome.org/show_bug.cgi?id=723659
2016-02-22 21:40:50 +00:00
GdkDevice *last_slave;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
} GdkMultipleClickInfo;
struct _GdkDisplay
{
GObject parent_instance;
GList *queued_events;
GList *queued_tail;
/* Information for determining if the latest button click
* is part of a double-click or triple-click
*/
GHashTable *multiple_click_info;
GdkDisplay: handle multiple calls to _gdk_display_pause_events() Since events can be paused independently for each window during processing, make _gdk_display_pause_events() count how many times it is called and only unpause when unpause_events() is called the same number of times. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-10-07 18:13:56 +00:00
guint event_pause_count; /* How many times events are blocked */
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
guint closed : 1; /* Whether this display has been closed */
gdk: Add internal API to deal with touch implicit grabs The necessary information about a touch implicit grab is stored in GdkTouchGrabInfo structs, these are meant to be transient to the touch sequence.
2011-12-28 01:14:18 +00:00
GArray *touch_implicit_grabs;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GHashTable *device_grabs;
GHashTable *motion_hint_info;
GdkDisplay: Struct packing improvements
2011-04-12 14:34:55 +00:00
GdkDeviceManager *device_manager;
gdk: remove the display->list_devices vfunc gdk_display_list_devices is deprecated and all the backends implement the same fallback by delegating to the device manager and caching the list (caching it is needed since the method does not transfer ownership of the container). The compat code can be shared among all backends and we can initialize the list lazily only in the case someone calls the deprecated method. https://bugzilla.gnome.org/show_bug.cgi?id=762891
2016-02-29 19:59:36 +00:00
GList *input_devices; /* Deprecated, only used to keep gdk_display_list_devices working */
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GHashTable *pointers_info; /* GdkPointerWindowInfo for each device */
guint32 last_event_time; /* Last reported event time from server */
Some struct repacking Save a few bytes here and there.
2014-01-12 14:39:23 +00:00
guint double_click_time; /* Maximum time between clicks in msecs */
GdkDisplay: Struct packing improvements
2011-04-12 14:34:55 +00:00
guint double_click_distance; /* Maximum distance between clicks in pixels */
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
guint has_gl_extension_texture_non_power_of_two : 1;
guint has_gl_extension_texture_rectangle : 1;
Move rendering mode into GdkDisplay This is in preparation for making it runtime-settable in the inspector.
2014-11-10 19:28:43 +00:00
GdkRenderingMode rendering_mode;
GdkDisplay: Add GdkSeat getters https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-11-26 18:52:23 +00:00
GList *seats;
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
};
struct _GdkDisplayClass
{
GObjectClass parent_class;
gdk: Allow display subclasses to override the type used for windows We want to have different window types for different displays, so we can write code like this: #if GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW (window)) { /* do x11 stuff */ } else #endif #if GDK_WINDOWING_WAYLAND if (GDK_IS_WAYLAND_WINDOW (window)) { /* do wayland stuff */ } else #endif { /* do stuff for unsupported system */ } This requires different GdkWindow types and we currently don't have that, as only the GdkWindowImpl differs. With this method, every backend defines a custom type that's just a simple subclass of GdkWindow. This way GdkWindow behaves like all the other types (visuals, screens, displays) and we can write code like the above.
2010-12-21 02:13:55 +00:00
GType window_type; /* type for native windows for this display, set in class_init */
gdk: Use const instead G_CONST_RETURN
2011-06-06 18:05:18 +00:00
const gchar * (*get_name) (GdkDisplay *display);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GdkScreen * (*get_default_screen) (GdkDisplay *display);
void (*beep) (GdkDisplay *display);
void (*sync) (GdkDisplay *display);
void (*flush) (GdkDisplay *display);
gboolean (*has_pending) (GdkDisplay *display);
void (*queue_events) (GdkDisplay *display);
displaymanager: Move set_default_display vfunc ... to GdkDisplayClass.make_default. It's only implemented by X11 anyway.
2013-04-09 11:32:03 +00:00
void (*make_default) (GdkDisplay *display);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GdkWindow * (*get_default_group) (GdkDisplay *display);
gboolean (*supports_selection_notification) (GdkDisplay *display);
gboolean (*request_selection_notification) (GdkDisplay *display,
GdkAtom selection);
Add vfuncs for a bunch of cursor functionality to GdkDisplay
2010-12-13 17:36:35 +00:00
gboolean (*supports_shapes) (GdkDisplay *display);
gboolean (*supports_input_shapes) (GdkDisplay *display);
gboolean (*supports_cursor_alpha) (GdkDisplay *display);
gboolean (*supports_cursor_color) (GdkDisplay *display);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
gboolean (*supports_clipboard_persistence) (GdkDisplay *display);
void (*store_clipboard) (GdkDisplay *display,
GdkWindow *clipboard_window,
guint32 time_,
const GdkAtom *targets,
gint n_targets);
Add vfuncs for a bunch of cursor functionality to GdkDisplay
2010-12-13 17:36:35 +00:00
void (*get_default_cursor_size) (GdkDisplay *display,
guint *width,
guint *height);
void (*get_maximal_cursor_size) (GdkDisplay *display,
guint *width,
guint *height);
GdkCursor * (*get_cursor_for_type) (GdkDisplay *display,
GdkCursorType type);
GdkCursor * (*get_cursor_for_name) (GdkDisplay *display,
const gchar *name);
gdk: Add gdk_cursor_new_from_surface We need this to be able to handle scaled cursor images. We implement the new _from_pixbuf by converting to a surface and assuming the scale was 1.
2013-08-07 10:18:38 +00:00
GdkCursor * (*get_cursor_for_surface) (GdkDisplay *display,
cairo_surface_t *surface,
gdouble x,
gdouble y);
Add vfuncs for a bunch of cursor functionality to GdkDisplay
2010-12-13 17:36:35 +00:00
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GdkAppLaunchContext * (*get_app_launch_context) (GdkDisplay *display);
Add vfuncs for process_updates_recurse and the before and after hooks
2010-12-13 18:30:05 +00:00
void (*before_process_all_updates) (GdkDisplay *display);
void (*after_process_all_updates) (GdkDisplay *display);
Add a vfunc for _gdk_windowing_window_get_next_serial
2010-12-13 19:05:59 +00:00
gulong (*get_next_serial) (GdkDisplay *display);
Add a vfunc for gdk_notify_startup_complete At the same time, add a display api for this, since it really is per-display.
2010-12-14 01:46:00 +00:00
void (*notify_startup_complete) (GdkDisplay *display,
const gchar *startup_id);
Add vfuncs for _gdk_windowing_event_data_{copy,free}
2010-12-15 05:37:40 +00:00
void (*event_data_copy) (GdkDisplay *display,
const GdkEvent *event,
GdkEvent *new_event);
void (*event_data_free) (GdkDisplay *display,
GdkEvent *event);
Add a vfunc for _gdk_window_impl_new
2010-12-16 00:07:36 +00:00
void (*create_window_impl) (GdkDisplay *display,
GdkWindow *window,
GdkWindow *real_parent,
GdkScreen *screen,
GdkEventMask event_mask,
GdkWindowAttr *attributes,
gint attributes_mask);
Add a vfunc for gdk_notify_startup_complete At the same time, add a display api for this, since it really is per-display.
2010-12-14 01:46:00 +00:00
Add a vfunc for gdk_keymap_get_for_display
2010-12-16 05:08:42 +00:00
GdkKeymap * (*get_keymap) (GdkDisplay *display);
Add vfuncs for gdk_test apis
2010-12-16 06:21:49 +00:00
void (*push_error_trap) (GdkDisplay *display);
gint (*pop_error_trap) (GdkDisplay *display,
gboolean ignore);
Add a vfunc for gdk_keymap_get_for_display
2010-12-16 05:08:42 +00:00
Add vfuncs for get/set_selection_owner
2010-12-17 00:22:44 +00:00
GdkWindow * (*get_selection_owner) (GdkDisplay *display,
GdkAtom selection);
gboolean (*set_selection_owner) (GdkDisplay *display,
GdkWindow *owner,
GdkAtom selection,
guint32 time,
gboolean send_event);
Add a vfunc for gdk_selection_send_notify_for_display
2010-12-17 00:58:07 +00:00
void (*send_selection_notify) (GdkDisplay *dispay,
API: gdk: Make GdkEventSelection.requestor a GdkWindow instead of a GdkNativeWindow. Also change gdk_selection_notify() API to take a GdkWindow to match this change.
2011-02-01 16:22:04 +00:00
GdkWindow *requestor,
Add a vfunc for gdk_selection_send_notify_for_display
2010-12-17 00:58:07 +00:00
GdkAtom selection,
GdkAtom target,
GdkAtom property,
Add a vfunc for gdk_selection_convert
2010-12-17 01:25:32 +00:00
guint32 time);
Add a vfunc for gdk_selection_property_get
2010-12-17 01:10:11 +00:00
gint (*get_selection_property) (GdkDisplay *display,
GdkWindow *requestor,
guchar **data,
GdkAtom *type,
gint *format);
Add a vfunc for gdk_selection_convert
2010-12-17 01:25:32 +00:00
void (*convert_selection) (GdkDisplay *display,
GdkWindow *requestor,
GdkAtom selection,
GdkAtom target,
guint32 time);
Add vfuncs for get/set_selection_owner
2010-12-17 00:22:44 +00:00
Deal with property encoding functions Move everything dealing with compound text to be X11 specific Only gdk_text_property_to_utf8_list and gdk_utf8_to_string_target are kept across backends, so add vfuncs for these. Also, remove the non-multihead-safe variants of all these.
2010-12-17 04:44:50 +00:00
gint (*text_property_to_utf8_list) (GdkDisplay *display,
GdkAtom encoding,
gint format,
const guchar *text,
gint length,
gchar ***list);
gchar * (*utf8_to_string_target) (GdkDisplay *display,
const gchar *text);
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
gboolean (*make_gl_context_current) (GdkDisplay *display,
GdkGLContext *context);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
GdkDisplay: Add GdkSeat getters https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-11-26 18:52:23 +00:00
GdkSeat * (*get_default_seat) (GdkDisplay *display);
display: Add new monitor apis This follows our general direction of moving functionality from GdkScreen to GdkDisplay.
2016-04-01 03:10:37 +00:00
int (*get_n_monitors) (GdkDisplay *display);
GdkMonitor * (*get_monitor) (GdkDisplay *display,
int index);
GdkMonitor * (*get_primary_monitor) (GdkDisplay *display);
display: Add vfunc for get_monitor_at_window Some backends (namely Wayland) do not support global coordinates so using the window position to determine the monitor will always fail on such backends. In such cases, the backend itself might be better suited to identify the monitor a given window resides on. Add a vfunc get_monitor_at_window() to the display class so that we can use the backend to retrieve the monitor, if the backend implements it. https://bugzilla.gnome.org/show_bug.cgi?id=766566
2016-05-17 11:09:23 +00:00
GdkMonitor * (*get_monitor_at_window) (GdkDisplay *display,
GdkWindow *window);
display: Add new monitor apis This follows our general direction of moving functionality from GdkScreen to GdkDisplay.
2016-04-01 03:10:37 +00:00
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
/* Signals */
display: Make opened signal have a vfunc ... instead of g_signal_connect()ing in every init function.
2013-04-17 21:53:42 +00:00
void (*opened) (GdkDisplay *display);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
void (*closed) (GdkDisplay *display,
gboolean is_error);
};
typedef void (* GdkDisplayPointerInfoForeach) (GdkDisplay *display,
GdkDevice *device,
GdkPointerWindowInfo *device_info,
gpointer user_data);
gdkwindow: cleanup, avoid direct access to display members
2016-02-28 15:22:31 +00:00
void _gdk_display_update_last_event (GdkDisplay *display,
const GdkEvent *event);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
void _gdk_display_device_grab_update (GdkDisplay *display,
GdkDevice *device,
GdkDevice *source_device,
gulong current_serial);
GdkDeviceGrabInfo * _gdk_display_get_last_device_grab (GdkDisplay *display,
GdkDevice *device);
GdkDeviceGrabInfo * _gdk_display_add_device_grab (GdkDisplay *display,
GdkDevice *device,
GdkWindow *window,
GdkWindow *native_window,
GdkGrabOwnership grab_ownership,
gboolean owner_events,
GdkEventMask event_mask,
gulong serial_start,
guint32 time,
gboolean implicit);
GdkDeviceGrabInfo * _gdk_display_has_device_grab (GdkDisplay *display,
GdkDevice *device,
gulong serial);
gboolean _gdk_display_end_device_grab (GdkDisplay *display,
GdkDevice *device,
gulong serial,
GdkWindow *if_child,
gboolean implicit);
gboolean _gdk_display_check_grab_ownership (GdkDisplay *display,
GdkDevice *device,
gulong serial);
gdk: Add internal API to deal with touch implicit grabs The necessary information about a touch implicit grab is stored in GdkTouchGrabInfo structs, these are meant to be transient to the touch sequence.
2011-12-28 01:14:18 +00:00
void _gdk_display_add_touch_grab (GdkDisplay *display,
GdkDevice *device,
GdkEventSequence *sequence,
GdkWindow *window,
GdkWindow *native_window,
GdkEventMask event_mask,
unsigned long serial_start,
guint32 time);
GdkTouchGrabInfo * _gdk_display_has_touch_grab (GdkDisplay *display,
GdkDevice *device,
GdkEventSequence *sequence,
gulong serial);
gboolean _gdk_display_end_touch_grab (GdkDisplay *display,
GdkDevice *device,
GdkEventSequence *sequence);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
void _gdk_display_enable_motion_hints (GdkDisplay *display,
GdkDevice *device);
GdkPointerWindowInfo * _gdk_display_get_pointer_info (GdkDisplay *display,
GdkDevice *device);
void _gdk_display_pointer_info_foreach (GdkDisplay *display,
GdkDisplayPointerInfoForeach func,
gpointer user_data);
Add a vfunc for _gdk_windowing_window_get_next_serial
2010-12-13 19:05:59 +00:00
gulong _gdk_display_get_next_serial (GdkDisplay *display);
GdkDisplay: handle multiple calls to _gdk_display_pause_events() Since events can be paused independently for each window during processing, make _gdk_display_pause_events() count how many times it is called and only unpause when unpause_events() is called the same number of times. https://bugzilla.gnome.org/show_bug.cgi?id=685460
2012-10-07 18:13:56 +00:00
void _gdk_display_pause_events (GdkDisplay *display);
void _gdk_display_unpause_events (GdkDisplay *display);
Add vfuncs for _gdk_windowing_event_data_{copy,free}
2010-12-15 05:37:40 +00:00
void _gdk_display_event_data_copy (GdkDisplay *display,
const GdkEvent *event,
GdkEvent *new_event);
void _gdk_display_event_data_free (GdkDisplay *display,
GdkEvent *event);
Add a vfunc for _gdk_window_impl_new
2010-12-16 00:07:36 +00:00
void _gdk_display_create_window_impl (GdkDisplay *display,
GdkWindow *window,
GdkWindow *real_parent,
GdkScreen *screen,
GdkEventMask event_mask,
GdkWindowAttr *attributes,
gint attributes_mask);
gdk: Create windows via _gdk_display_create_window() THe use of this function will become visible in the next commits. But wrapping g_object_new() is a generally a good idea anyway.
2010-12-21 02:06:59 +00:00
GdkWindow * _gdk_display_create_window (GdkDisplay *display);
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
gboolean gdk_display_make_gl_context_current (GdkDisplay *display,
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
GdkGLContext *context);
GdkDisplay: Add GdkSeat getters https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-11-26 18:52:23 +00:00
void gdk_display_add_seat (GdkDisplay *display,
GdkSeat *seat);
void gdk_display_remove_seat (GdkDisplay *display,
GdkSeat *seat);
display: Add new monitor apis This follows our general direction of moving functionality from GdkScreen to GdkDisplay.
2016-04-01 03:10:37 +00:00
void gdk_display_monitor_added (GdkDisplay *display,
GdkMonitor *monitor);
void gdk_display_monitor_removed (GdkDisplay *display,
GdkMonitor *monitor);
GdkDisplay: Add GdkSeat getters https://bugzilla.gnome.org/show_bug.cgi?id=759309
2015-11-26 18:52:23 +00:00
Explode gdkinternals.h into per-class private headers At the same time, move some more class and instance structs out of public headers.
2010-12-11 05:14:53 +00:00
G_END_DECLS
#endif /* __GDK_DISPLAY_PRIVATE_H__ */
Reference in New Issue Copy Permalink