2008-07-01 22:57:50 +00:00
|
|
|
|
/* GDK - The GIMP Drawing Kit
|
2002-04-25 22:29:14 +00:00
|
|
|
|
* gdkdisplay.c
|
|
|
|
|
*
|
|
|
|
|
* Copyright 2001 Sun Microsystems Inc.
|
|
|
|
|
*
|
|
|
|
|
* Erwann Chenede <erwann.chenede@sun.com>
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Library 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
|
|
|
|
|
* Library General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
2012-02-27 13:01:10 +00:00
|
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2002-04-25 22:29:14 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2008-06-22 14:28:52 +00:00
|
|
|
|
#include "config.h"
|
2010-10-15 02:05:51 +00:00
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
#include "gdkdisplay.h"
|
2010-12-11 05:14:53 +00:00
|
|
|
|
#include "gdkdisplayprivate.h"
|
2010-10-15 02:05:51 +00:00
|
|
|
|
|
2022-09-24 03:33:42 +00:00
|
|
|
|
#include <glib/gi18n-lib.h>
|
2022-09-24 03:23:27 +00:00
|
|
|
|
#include "gdkprivate.h"
|
2014-11-07 13:40:22 +00:00
|
|
|
|
|
2021-09-24 18:14:16 +00:00
|
|
|
|
#include "gdkapplaunchcontext.h"
|
2014-05-29 03:55:53 +00:00
|
|
|
|
#include "gdkclipboardprivate.h"
|
2010-12-13 18:53:34 +00:00
|
|
|
|
#include "gdkdeviceprivate.h"
|
2013-04-10 21:11:52 +00:00
|
|
|
|
#include "gdkdisplaymanagerprivate.h"
|
2019-04-22 01:14:46 +00:00
|
|
|
|
#include "gdkframeclockidleprivate.h"
|
2021-09-24 19:11:00 +00:00
|
|
|
|
#include "gdkeventsprivate.h"
|
|
|
|
|
#include "gdkglcontextprivate.h"
|
|
|
|
|
#include "gdkmonitorprivate.h"
|
2010-07-09 00:34:45 +00:00
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
#include <epoxy/egl.h>
|
|
|
|
|
#endif
|
2013-07-03 09:52:58 +00:00
|
|
|
|
#include <math.h>
|
2021-10-07 07:04:18 +00:00
|
|
|
|
#include <stdlib.h>
|
2002-04-25 22:29:14 +00:00
|
|
|
|
|
2010-11-15 02:37:21 +00:00
|
|
|
|
/**
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* GdkDisplay:
|
2010-11-15 02:37:21 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* `GdkDisplay` objects are the GDK representation of a workstation.
|
2014-02-02 06:07:39 +00:00
|
|
|
|
*
|
2017-12-26 19:05:00 +00:00
|
|
|
|
* Their purpose are two-fold:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
*
|
2017-12-26 19:05:00 +00:00
|
|
|
|
* - To manage and provide information about input devices (pointers, keyboards, etc)
|
|
|
|
|
* - To manage and provide information about output devices (monitors, projectors, etc)
|
2011-02-09 06:32:24 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Most of the input device handling has been factored out into separate
|
|
|
|
|
* [class@Gdk.Seat] objects. Every display has a one or more seats, which
|
|
|
|
|
* can be accessed with [method@Gdk.Display.get_default_seat] and
|
|
|
|
|
* [method@Gdk.Display.list_seats].
|
2017-11-23 21:23:41 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Output devices are represented by [class@Gdk.Monitor] objects, which can
|
|
|
|
|
* be accessed with [method@Gdk.Display.get_monitor_at_surface] and similar APIs.
|
2010-11-15 02:37:21 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
PROP_0,
|
|
|
|
|
PROP_COMPOSITED,
|
|
|
|
|
PROP_RGBA,
|
2020-05-18 02:05:24 +00:00
|
|
|
|
PROP_INPUT_SHAPES,
|
2016-10-28 21:38:16 +00:00
|
|
|
|
LAST_PROP
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static GParamSpec *props[LAST_PROP] = { NULL, };
|
2010-11-15 02:37:21 +00:00
|
|
|
|
|
2002-08-01 23:43:13 +00:00
|
|
|
|
enum {
|
2010-05-25 22:38:44 +00:00
|
|
|
|
OPENED,
|
2002-08-01 23:43:13 +00:00
|
|
|
|
CLOSED,
|
2015-12-09 11:25:10 +00:00
|
|
|
|
SEAT_ADDED,
|
|
|
|
|
SEAT_REMOVED,
|
2017-10-30 13:00:49 +00:00
|
|
|
|
SETTING_CHANGED,
|
2002-08-01 23:43:13 +00:00
|
|
|
|
LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
typedef struct _GdkDisplayPrivate GdkDisplayPrivate;
|
|
|
|
|
|
|
|
|
|
struct _GdkDisplayPrivate {
|
2021-07-04 23:57:03 +00:00
|
|
|
|
/* The base context that all other contexts inherit from.
|
|
|
|
|
* This context is never exposed to public API and is
|
|
|
|
|
* allowed to have a %NULL surface.
|
|
|
|
|
*/
|
|
|
|
|
GdkGLContext *gl_context;
|
|
|
|
|
GError *gl_error;
|
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
EGLDisplay egl_display;
|
|
|
|
|
EGLConfig egl_config;
|
2021-10-06 16:25:30 +00:00
|
|
|
|
EGLConfig egl_config_high_depth;
|
2021-10-03 04:22:21 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
guint rgba : 1;
|
|
|
|
|
guint composited : 1;
|
|
|
|
|
guint input_shapes : 1;
|
|
|
|
|
|
|
|
|
|
GdkDebugFlags debug_flags;
|
|
|
|
|
};
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
static void gdk_display_dispose (GObject *object);
|
|
|
|
|
static void gdk_display_finalize (GObject *object);
|
|
|
|
|
|
2002-10-07 19:42:49 +00:00
|
|
|
|
|
2010-12-09 06:08:05 +00:00
|
|
|
|
static GdkAppLaunchContext *gdk_display_real_get_app_launch_context (GdkDisplay *display);
|
2002-10-07 19:42:49 +00:00
|
|
|
|
|
2002-08-01 23:43:13 +00:00
|
|
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (GdkDisplay, gdk_display, G_TYPE_OBJECT)
|
2002-04-25 22:29:14 +00:00
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_get_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplay *display = GDK_DISPLAY (object);
|
|
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_COMPOSITED:
|
|
|
|
|
g_value_set_boolean (value, gdk_display_is_composited (display));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PROP_RGBA:
|
|
|
|
|
g_value_set_boolean (value, gdk_display_is_rgba (display));
|
|
|
|
|
break;
|
|
|
|
|
|
2020-05-18 02:05:24 +00:00
|
|
|
|
case PROP_INPUT_SHAPES:
|
|
|
|
|
g_value_set_boolean (value, gdk_display_supports_input_shapes (display));
|
|
|
|
|
break;
|
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-09 11:32:03 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_real_make_default (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
static GdkGLContext *
|
|
|
|
|
gdk_display_default_init_gl (GdkDisplay *display,
|
|
|
|
|
GError **error)
|
2013-04-17 21:53:42 +00:00
|
|
|
|
{
|
2021-07-04 23:57:03 +00:00
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("The current backend does not support OpenGL"));
|
|
|
|
|
|
|
|
|
|
return NULL;
|
2013-04-17 21:53:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
static guint
|
|
|
|
|
gdk_display_default_rate_egl_config (GdkDisplay *display,
|
|
|
|
|
gpointer egl_display,
|
|
|
|
|
gpointer config)
|
|
|
|
|
{
|
|
|
|
|
guint distance = 0;
|
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
|
|
if (!eglGetConfigAttrib (egl_display, config, EGL_SAMPLE_BUFFERS, &tmp) || tmp != 0)
|
|
|
|
|
distance += 0x20000;
|
|
|
|
|
|
|
|
|
|
if (!eglGetConfigAttrib (egl_display, config, EGL_DEPTH_SIZE, &tmp) || tmp != 0 ||
|
|
|
|
|
!eglGetConfigAttrib (egl_display, config, EGL_STENCIL_SIZE, &tmp) || tmp != 0)
|
|
|
|
|
distance += 0x10000;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return distance;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-26 18:52:23 +00:00
|
|
|
|
static GdkSeat *
|
|
|
|
|
gdk_display_real_get_default_seat (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
if (!display->seats)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return display->seats->data;
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_real_opened (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
_gdk_display_manager_add_display (gdk_display_manager_get (), display);
|
|
|
|
|
}
|
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_class_init (GdkDisplayClass *class)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
object_class->finalize = gdk_display_finalize;
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
object_class->dispose = gdk_display_dispose;
|
2016-10-28 21:38:16 +00:00
|
|
|
|
object_class->get_property = gdk_display_get_property;
|
2002-08-01 23:43:13 +00:00
|
|
|
|
|
2013-04-09 11:32:03 +00:00
|
|
|
|
class->make_default = gdk_display_real_make_default;
|
2021-07-04 23:57:03 +00:00
|
|
|
|
class->get_app_launch_context = gdk_display_real_get_app_launch_context;
|
|
|
|
|
class->init_gl = gdk_display_default_init_gl;
|
2021-10-03 04:22:21 +00:00
|
|
|
|
class->rate_egl_config = gdk_display_default_rate_egl_config;
|
2015-11-26 18:52:23 +00:00
|
|
|
|
class->get_default_seat = gdk_display_real_get_default_seat;
|
2021-07-04 23:57:03 +00:00
|
|
|
|
class->opened = gdk_display_real_opened;
|
2013-04-09 11:32:03 +00:00
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* GdkDisplay:composited: (attributes org.gtk.Property.get=gdk_display_is_composited)
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*
|
2020-05-28 08:00:03 +00:00
|
|
|
|
* %TRUE if the display properly composites the alpha channel.
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*/
|
|
|
|
|
props[PROP_COMPOSITED] =
|
2022-05-11 12:19:39 +00:00
|
|
|
|
g_param_spec_boolean ("composited", NULL, NULL,
|
2016-10-28 21:38:16 +00:00
|
|
|
|
TRUE,
|
2017-11-18 02:38:08 +00:00
|
|
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
|
2016-10-28 21:38:16 +00:00
|
|
|
|
|
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* GdkDisplay:rgba: (attributes org.gtk.Property.get=gdk_display_is_rgba)
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* %TRUE if the display supports an alpha channel.
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*/
|
|
|
|
|
props[PROP_RGBA] =
|
2022-05-11 12:19:39 +00:00
|
|
|
|
g_param_spec_boolean ("rgba", NULL, NULL,
|
2016-10-28 21:38:16 +00:00
|
|
|
|
TRUE,
|
2017-11-18 02:38:08 +00:00
|
|
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
|
2016-10-28 21:38:16 +00:00
|
|
|
|
|
2020-05-18 02:05:24 +00:00
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* GdkDisplay:input-shapes: (attributes org.gtk.Property.get=gdk_display_supports_input_shapes)
|
2020-05-18 02:05:24 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* %TRUE if the display supports input shapes.
|
2020-05-18 02:05:24 +00:00
|
|
|
|
*/
|
|
|
|
|
props[PROP_INPUT_SHAPES] =
|
2022-05-11 12:19:39 +00:00
|
|
|
|
g_param_spec_boolean ("input-shapes", NULL, NULL,
|
2020-05-18 02:05:24 +00:00
|
|
|
|
TRUE,
|
|
|
|
|
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
|
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
g_object_class_install_properties (object_class, LAST_PROP, props);
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
/**
|
2010-05-25 23:27:42 +00:00
|
|
|
|
* GdkDisplay::opened:
|
2010-05-25 22:38:44 +00:00
|
|
|
|
* @display: the object on which the signal is emitted
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Emitted when the connection to the windowing system for @display is opened.
|
2010-05-25 22:38:44 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[OPENED] =
|
|
|
|
|
g_signal_new (g_intern_static_string ("opened"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
2013-04-17 21:53:42 +00:00
|
|
|
|
G_STRUCT_OFFSET (GdkDisplayClass, opened),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:05:19 +00:00
|
|
|
|
NULL,
|
2010-05-25 22:38:44 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2003-09-30 00:36:29 +00:00
|
|
|
|
/**
|
|
|
|
|
* GdkDisplay::closed:
|
|
|
|
|
* @display: the object on which the signal is emitted
|
|
|
|
|
* @is_error: %TRUE if the display was closed due to an error
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Emitted when the connection to the windowing system for @display is closed.
|
|
|
|
|
*/
|
2002-08-01 23:43:13 +00:00
|
|
|
|
signals[CLOSED] =
|
2005-09-01 05:11:46 +00:00
|
|
|
|
g_signal_new (g_intern_static_string ("closed"),
|
2002-08-01 23:43:13 +00:00
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GdkDisplayClass, closed),
|
|
|
|
|
NULL, NULL,
|
2019-05-31 03:56:50 +00:00
|
|
|
|
NULL,
|
2002-08-01 23:43:13 +00:00
|
|
|
|
G_TYPE_NONE,
|
|
|
|
|
1,
|
|
|
|
|
G_TYPE_BOOLEAN);
|
2015-12-09 11:25:10 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GdkDisplay::seat-added:
|
|
|
|
|
* @display: the object on which the signal is emitted
|
|
|
|
|
* @seat: the seat that was just added
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Emitted whenever a new seat is made known to the windowing system.
|
2015-12-09 11:25:10 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[SEAT_ADDED] =
|
|
|
|
|
g_signal_new (g_intern_static_string ("seat-added"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
0, NULL, NULL,
|
2019-05-31 03:56:50 +00:00
|
|
|
|
NULL,
|
2015-12-09 11:25:10 +00:00
|
|
|
|
G_TYPE_NONE, 1, GDK_TYPE_SEAT);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GdkDisplay::seat-removed:
|
|
|
|
|
* @display: the object on which the signal is emitted
|
2016-02-26 01:12:53 +00:00
|
|
|
|
* @seat: the seat that was just removed
|
2015-12-09 11:25:10 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Emitted whenever a seat is removed by the windowing system.
|
2015-12-09 11:25:10 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[SEAT_REMOVED] =
|
|
|
|
|
g_signal_new (g_intern_static_string ("seat-removed"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
0, NULL, NULL,
|
2019-05-31 03:56:50 +00:00
|
|
|
|
NULL,
|
2015-12-09 11:25:10 +00:00
|
|
|
|
G_TYPE_NONE, 1, GDK_TYPE_SEAT);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
|
2017-12-26 14:30:44 +00:00
|
|
|
|
/**
|
|
|
|
|
* GdkDisplay::setting-changed:
|
|
|
|
|
* @display: the object on which the signal is emitted
|
|
|
|
|
* @setting: the name of the setting that changed
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Emitted whenever a setting changes its value.
|
2017-12-26 14:30:44 +00:00
|
|
|
|
*/
|
2017-10-30 13:00:49 +00:00
|
|
|
|
signals[SETTING_CHANGED] =
|
|
|
|
|
g_signal_new (g_intern_static_string ("setting-changed"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
0, NULL, NULL,
|
|
|
|
|
NULL,
|
|
|
|
|
G_TYPE_NONE, 1, G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
static void
|
2018-03-20 10:40:08 +00:00
|
|
|
|
free_pointer_info (GdkPointerSurfaceInfo *info)
|
2010-05-25 22:38:44 +00:00
|
|
|
|
{
|
2018-03-20 11:05:26 +00:00
|
|
|
|
g_clear_object (&info->surface_under_pointer);
|
2018-03-20 10:40:08 +00:00
|
|
|
|
g_slice_free (GdkPointerSurfaceInfo, info);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
free_device_grab (GdkDeviceGrabInfo *info)
|
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
g_object_unref (info->surface);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_free (info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
free_device_grabs_foreach (gpointer key,
|
|
|
|
|
gpointer value,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GList *list = value;
|
|
|
|
|
|
2012-01-03 01:18:50 +00:00
|
|
|
|
g_list_free_full (list, (GDestroyNotify) free_device_grab);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_init (GdkDisplay *display)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
display->double_click_time = 250;
|
2003-12-16 00:56:48 +00:00
|
|
|
|
display->double_click_distance = 5;
|
2002-10-07 19:42:49 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
display->device_grabs = g_hash_table_new (NULL, NULL);
|
|
|
|
|
|
|
|
|
|
display->pointers_info = g_hash_table_new_full (NULL, NULL, NULL,
|
|
|
|
|
(GDestroyNotify) free_pointer_info);
|
|
|
|
|
|
2019-02-05 15:05:06 +00:00
|
|
|
|
g_queue_init (&display->queued_events);
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
priv->debug_flags = _gdk_debug_flags;
|
2016-10-29 16:06:24 +00:00
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
priv->composited = TRUE;
|
|
|
|
|
priv->rgba = TRUE;
|
|
|
|
|
priv->input_shapes = TRUE;
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_dispose (GObject *object)
|
|
|
|
|
{
|
2010-12-20 16:11:00 +00:00
|
|
|
|
GdkDisplay *display = GDK_DISPLAY (object);
|
2021-07-04 23:57:03 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
2002-08-01 23:43:13 +00:00
|
|
|
|
|
2013-04-10 21:11:52 +00:00
|
|
|
|
_gdk_display_manager_remove_display (gdk_display_manager_get (), display);
|
|
|
|
|
|
2019-02-05 15:05:06 +00:00
|
|
|
|
g_queue_clear (&display->queued_events);
|
2002-08-01 23:43:13 +00:00
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
g_clear_object (&priv->gl_context);
|
2021-10-03 04:22:21 +00:00
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
g_clear_pointer (&priv->egl_display, eglTerminate);
|
|
|
|
|
#endif
|
2021-07-04 23:57:03 +00:00
|
|
|
|
g_clear_error (&priv->gl_error);
|
|
|
|
|
|
2006-04-04 14:02:03 +00:00
|
|
|
|
G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-04-25 22:29:14 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_finalize (GObject *object)
|
|
|
|
|
{
|
2010-12-20 16:11:00 +00:00
|
|
|
|
GdkDisplay *display = GDK_DISPLAY (object);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
|
|
|
|
g_hash_table_foreach_remove (display->device_grabs,
|
|
|
|
|
free_device_grabs_foreach,
|
|
|
|
|
NULL);
|
|
|
|
|
g_hash_table_destroy (display->device_grabs);
|
|
|
|
|
|
|
|
|
|
g_hash_table_destroy (display->pointers_info);
|
|
|
|
|
|
2016-09-08 09:18:16 +00:00
|
|
|
|
g_list_free_full (display->seats, g_object_unref);
|
2016-02-29 19:59:36 +00:00
|
|
|
|
|
2006-04-04 14:02:03 +00:00
|
|
|
|
G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_close:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
|
|
|
|
*
|
|
|
|
|
* Closes the connection to the windowing system for the given display.
|
2002-04-25 22:29:14 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* This cleans up associated resources.
|
2002-04-25 22:29:14 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gdk_display_close (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
|
|
|
|
|
if (!display->closed)
|
|
|
|
|
{
|
|
|
|
|
display->closed = TRUE;
|
2002-08-01 23:43:13 +00:00
|
|
|
|
|
|
|
|
|
g_signal_emit (display, signals[CLOSED], 0, FALSE);
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
g_object_run_dispose (G_OBJECT (display));
|
|
|
|
|
|
2002-09-25 07:23:55 +00:00
|
|
|
|
g_object_unref (display);
|
Start implementing display/screen closing scheme; keep a flag for whether
Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
* gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
Start implementing display/screen closing scheme; keep a
flag for whether displays and screens are closed,
call g_object_run_dispose(). Remove public gdk_screen_close().
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
dispose() methods; move appropriate parts of the finalize
there.
* gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
Start of making everything correctly ignore operations
when a display has been closed.
* gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
Handle decorations == NULL.
* gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
Remove unnecessary hash table creation.
* gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
Fix up gdk_device_get_history - handle events, n_events == NULL,
etc.
* gdk/x11/gdkproperty-x11.c (gdk_property_get):
Handle failure better.
* gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
Handle failure better, handle data == NULL, move docs
here, remove an excess round trip by asking for
all selection data at once.
* gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
gdk_display_set_sm_client_id() to display-independent part of GDK.
* gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
into the right place.
2002-08-01 15:28:40 +00:00
|
|
|
|
}
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-07-14 08:48:54 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_is_closed:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-07-14 08:48:54 +00:00
|
|
|
|
*
|
2010-08-17 03:52:03 +00:00
|
|
|
|
* Finds out if the display has been closed.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the display is closed.
|
2010-07-14 08:48:54 +00:00
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_is_closed (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
|
|
|
|
|
|
|
|
|
return display->closed;
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-07 23:36:07 +00:00
|
|
|
|
/*<private>
|
2002-04-25 22:29:14 +00:00
|
|
|
|
* gdk_display_get_event:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2020-10-07 23:36:07 +00:00
|
|
|
|
*
|
2021-06-05 21:36:02 +00:00
|
|
|
|
* Gets the next `GdkEvent` to be processed for @display,
|
|
|
|
|
* fetching events from the windowing system if necessary.
|
2020-10-07 23:36:07 +00:00
|
|
|
|
*
|
2021-06-05 21:36:02 +00:00
|
|
|
|
* Returns: (nullable) (transfer full): the next `GdkEvent`
|
|
|
|
|
* to be processed
|
2017-12-21 19:13:28 +00:00
|
|
|
|
*/
|
|
|
|
|
GdkEvent *
|
2002-04-25 22:29:14 +00:00
|
|
|
|
gdk_display_get_event (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
2010-12-11 01:46:42 +00:00
|
|
|
|
|
2013-11-11 23:04:34 +00:00
|
|
|
|
if (display->event_pause_count == 0)
|
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->queue_events (display);
|
2012-10-07 15:47:49 +00:00
|
|
|
|
|
|
|
|
|
return _gdk_event_unqueue (display);
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_put_event:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
|
|
|
|
* @event: (transfer none): a `GdkEvent`
|
2002-04-25 22:29:14 +00:00
|
|
|
|
*
|
2020-02-15 19:19:50 +00:00
|
|
|
|
* Appends the given event onto the front of the event
|
2002-04-25 22:29:14 +00:00
|
|
|
|
* queue for @display.
|
2020-05-29 13:25:17 +00:00
|
|
|
|
*
|
|
|
|
|
* This function is only useful in very special situations
|
|
|
|
|
* and should not be used by applications.
|
2002-04-25 22:29:14 +00:00
|
|
|
|
**/
|
|
|
|
|
void
|
2020-05-29 13:25:17 +00:00
|
|
|
|
gdk_display_put_event (GdkDisplay *display,
|
|
|
|
|
GdkEvent *event)
|
2002-04-25 22:29:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
g_return_if_fail (event != NULL);
|
|
|
|
|
|
2020-02-15 20:07:24 +00:00
|
|
|
|
_gdk_event_queue_append (display, gdk_event_ref ((GdkEvent *)event));
|
2002-04-25 22:29:14 +00:00
|
|
|
|
}
|
Changes multihead reorganizing code for win32 support, mostly from a patch
Wed Jun 5 18:34:47 2002 Owen Taylor <otaylor@redhat.com>
Changes multihead reorganizing code for win32 support,
mostly from a patch by Hans Breuer.
* gdk/gdkcolor.c gdk/x11/gdkcolor-x11.c gdk/gdkcursor.c
gdk/x11/gdkcursor-x11.c gdk/gdkevents.c gdk/x11/gdkevents-x11.c
gdk/gdkfont.c gdk/x11/gdkfont-x11.c gdk/gdkkeys.c
gdk/x11/gdkkeys-x11.c gdk/gdkimage.c gdk/x11/gdkimage-x11.c
gdk/gdkscreen.c gdk/x11/gdkmain-x11.c
gdk/gdkdisplay.c gdk/gdkevents-x11.c gdk/gdkpango.c
gdk/x11/gdkpango-x11.c gdk/gdkselection.c
gdk/x11/gdkselection-x11.c gdk/gdkwindow.c
gdk/x11/gdkwindow-x11.c gdk/gdkvisual.c gdk/x11/gdkvisual-x11.c:
Move port-independent singlehead wrapper functions into
port-independent part of GDK. (#80009)
* gdk/win32/gdkcolor-win32.c gdk/win32/gdkcursor-win32.c
gdk/win32/gdkevents-win32.c gdk/win32/gdkfont-win32.c
gdk/win32/gdkimage-win32.c gdk/win32/gdkkeys-win32.c
gdk/win32/gdkmain-win32.c gdk/win32/gdkproperty-win32.c
gdk/win32/gdkselection-win32.c gdk/win32/gkwindow-win32.c:
Turn singlehead functions into "multihead" functions that ignore
their GdkDisplay or GdkScreen arguments.
* gdk/win32/gdkdrawable-win32.c gdk/win32/gdkevents-win32.c
gdk/win32/gdkinput-win32.c gdk/win32/gdkprivate-win32.h:
Misc multihead-compatibility changes.
* gtk/gtk.def gdk/gdk.def: Update for multihead functions.
* gdk/gdkcolormap.h gdk/gdkvisual.h gdk/x11/gdkcolormap-x11.c
gdk/x11/gdkvisual-x11.c: Remove the screen fields
from the public parts of the colormap/visual structures, add accessors
instead.
* gdk/gdkpixbuf-render.c gdk/gdkpixmap.c gdk/gdkrgb.c
gdk/x11/gdkcolormap-x11.c gdk/x11/gdkimage-x11.c
gdk/x11/gdkimage-x11.c gdk/x11/gdkprivate-x11.h gtk/gtkgc.c
gtk/gtkstyle.c gtk/gtkwidget.c: Use accessors to get the screen
for colormaps, visuals; move the fields into the private
structures for the x11 backend.
* gdk/gdkdisplay.[ch] gdk/x11/gdkdisplay-x11.[ch]
gdk/gdkscreen.[ch] gdk/x11/gdkscreen-x11.c:
Remove virtualization of screen and display functions.
(#79990, patch from Erwann Chenede)
* gdk/win32/gdkdisplay-x11.c gdk/win32/gdkscreen-win32.c
gdk/win32/{Makefile.am, makefile.msc, makefile.mingw}:
New files containing stub implementations of Display,
Screen functions.
* gdk/x11/gdkscreen-x11.[ch] gdk/x11/gdkdisplay-x11.[ch]
gdk/x11/gdkx.h: Clean up function exports and what
headers they are in. (#79954)
* gdk/x11/gdkx.h: Fix macro that was referring to a non-existant
screen->screen_num. (In the patch for #79972, Erwann Chenede)
* gdk/gdkscreen.c gdk/gdkwindow.c gdk/x11/gdkinternals.h
gdk/x11/gdkscreen-x11.c: Fix gdk_screen_get_window_at_pointer()
to use window hooks. (#79972, patch partly from Erwann Chenede)
* gdk/x11/gdkdisplay-x11.c gdk/x11/gdkevents-x11.c: Fix
some warnings.
2002-06-06 00:26:42 +00:00
|
|
|
|
|
2008-07-18 13:03:42 +00:00
|
|
|
|
static void
|
2016-05-01 17:18:55 +00:00
|
|
|
|
generate_grab_broken_event (GdkDisplay *display,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface *surface,
|
2016-05-01 17:18:55 +00:00
|
|
|
|
GdkDevice *device,
|
|
|
|
|
gboolean implicit,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface *grab_surface)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
g_return_if_fail (surface != NULL);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
2018-03-20 14:14:10 +00:00
|
|
|
|
if (!GDK_SURFACE_DESTROYED (surface))
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkEvent *event;
|
|
|
|
|
|
Restructure the GdkEvent type hierarchy
GdkEvent has been a "I-can't-believe-this-is-not-OOP" type for ages,
using a union of sub-types. This has always been problematic when it
comes to implementing accessor functions: either you get generic API
that takes a GdkEvent and uses a massive switch() to determine which
event types have the data you're looking for; or you create namespaced
accessors, but break language bindings horribly, as boxed types cannot
have derived types.
The recent conversion of GskRenderNode (which had similar issues) to
GTypeInstance, and the fact that GdkEvent is now a completely opaque
type, provide us with the chance of moving GdkEvent to GTypeInstance,
and have sub-types for GdkEvent.
The change from boxed type to GTypeInstance is pretty small, all things
considered, but ends up cascading to a larger commit, as we still have
backends and code in GTK trying to access GdkEvent structures directly.
Additionally, the naming of the public getter functions requires
renaming all the data structures to conform to the namespace/type-name
pattern.
2020-04-16 16:23:36 +00:00
|
|
|
|
event = gdk_grab_broken_event_new (surface,
|
2020-02-15 18:19:48 +00:00
|
|
|
|
device,
|
|
|
|
|
grab_surface,
|
|
|
|
|
implicit);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2020-02-15 19:19:50 +00:00
|
|
|
|
_gdk_event_queue_append (display, event);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *
|
|
|
|
|
_gdk_display_get_last_device_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
|
|
|
|
GList *l;
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
l = g_hash_table_lookup (display->device_grabs, device);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
if (l)
|
|
|
|
|
{
|
|
|
|
|
l = g_list_last (l);
|
|
|
|
|
return l->data;
|
|
|
|
|
}
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *
|
|
|
|
|
_gdk_display_add_device_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface *surface,
|
2010-05-25 22:38:44 +00:00
|
|
|
|
gboolean owner_events,
|
|
|
|
|
GdkEventMask event_mask,
|
|
|
|
|
unsigned long serial_start,
|
|
|
|
|
guint32 time,
|
|
|
|
|
gboolean implicit)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *info, *other_info;
|
|
|
|
|
GList *grabs, *l;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
info = g_new0 (GdkDeviceGrabInfo, 1);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2018-03-20 14:14:10 +00:00
|
|
|
|
info->surface = g_object_ref (surface);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
info->serial_start = serial_start;
|
|
|
|
|
info->serial_end = G_MAXULONG;
|
|
|
|
|
info->owner_events = owner_events;
|
|
|
|
|
info->event_mask = event_mask;
|
|
|
|
|
info->time = time;
|
|
|
|
|
info->implicit = implicit;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
|
|
|
|
grabs = g_hash_table_lookup (display->device_grabs, device);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
|
|
|
|
/* Find the first grab that has a larger start time (if any) and insert
|
|
|
|
|
* before that. I.E we insert after already existing grabs with same
|
|
|
|
|
* start time */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
for (l = grabs; l != NULL; l = l->next)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2009-01-31 18:42:44 +00:00
|
|
|
|
other_info = l->data;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (info->serial_start < other_info->serial_start)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
|
|
|
|
grabs = g_list_insert_before (grabs, l, info);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
|
|
|
|
/* Make sure the new grab end before next grab */
|
|
|
|
|
if (l)
|
|
|
|
|
{
|
|
|
|
|
other_info = l->data;
|
|
|
|
|
info->serial_end = other_info->serial_start;
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
/* Find any previous grab and update its end time */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
l = g_list_find (grabs, info);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
l = l->prev;
|
|
|
|
|
if (l)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2009-01-31 18:42:44 +00:00
|
|
|
|
other_info = l->data;
|
|
|
|
|
other_info->serial_end = serial_start;
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_hash_table_insert (display->device_grabs, device, grabs);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
return info;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
|
static GdkSurface *
|
2010-05-25 22:38:44 +00:00
|
|
|
|
get_current_toplevel (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
int *x_out,
|
|
|
|
|
int *y_out,
|
2009-07-10 15:30:42 +00:00
|
|
|
|
GdkModifierType *state_out)
|
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface *pointer_surface;
|
2020-07-24 20:32:16 +00:00
|
|
|
|
double x, y;
|
2009-07-10 15:30:42 +00:00
|
|
|
|
GdkModifierType state;
|
|
|
|
|
|
2020-05-19 19:00:32 +00:00
|
|
|
|
pointer_surface = _gdk_device_surface_at_position (device, &x, &y, &state);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2018-03-20 14:14:10 +00:00
|
|
|
|
if (pointer_surface != NULL &&
|
2018-06-25 22:47:40 +00:00
|
|
|
|
GDK_SURFACE_DESTROYED (pointer_surface))
|
2018-03-20 14:14:10 +00:00
|
|
|
|
pointer_surface = NULL;
|
2009-07-10 15:30:42 +00:00
|
|
|
|
|
2013-07-03 09:52:58 +00:00
|
|
|
|
*x_out = round (x);
|
|
|
|
|
*y_out = round (y);
|
2009-07-10 15:30:42 +00:00
|
|
|
|
*state_out = state;
|
2010-12-13 22:43:10 +00:00
|
|
|
|
|
2018-03-20 14:14:10 +00:00
|
|
|
|
return pointer_surface;
|
2009-07-10 15:30:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
static void
|
2010-05-25 22:38:44 +00:00
|
|
|
|
switch_to_pointer_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
GdkDeviceGrabInfo *grab,
|
|
|
|
|
GdkDeviceGrabInfo *last_grab,
|
|
|
|
|
guint32 time,
|
|
|
|
|
gulong serial)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkSurface *new_toplevel;
|
|
|
|
|
GdkPointerSurfaceInfo *info;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
GList *old_grabs;
|
|
|
|
|
GdkModifierType state;
|
2011-01-24 01:32:50 +00:00
|
|
|
|
int x = 0, y = 0;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
|
|
|
|
/* Temporarily unset pointer to make sure we send the crossing events below */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
old_grabs = g_hash_table_lookup (display->device_grabs, device);
|
|
|
|
|
g_hash_table_steal (display->device_grabs, device);
|
|
|
|
|
info = _gdk_display_get_pointer_info (display, device);
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (grab)
|
|
|
|
|
{
|
|
|
|
|
/* New grab is in effect */
|
|
|
|
|
if (!grab->implicit)
|
2008-12-15 09:24:54 +00:00
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
/* !owner_event Grabbing a surface that we're not inside, current status is
|
|
|
|
|
now NULL (i.e. outside grabbed surface) */
|
|
|
|
|
if (!grab->owner_events && info->surface_under_pointer != grab->surface)
|
2018-03-20 11:05:26 +00:00
|
|
|
|
_gdk_display_set_surface_under_pointer (display, device, NULL);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
}
|
2009-07-10 15:30:42 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
grab->activated = TRUE;
|
|
|
|
|
}
|
2009-07-10 15:30:42 +00:00
|
|
|
|
|
|
|
|
|
if (last_grab)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2009-07-10 15:30:42 +00:00
|
|
|
|
new_toplevel = NULL;
|
|
|
|
|
|
|
|
|
|
if (grab == NULL /* ungrab */ ||
|
|
|
|
|
(!last_grab->owner_events && grab->owner_events) /* switched to owner_events */ )
|
|
|
|
|
{
|
2020-07-31 16:46:47 +00:00
|
|
|
|
new_toplevel = get_current_toplevel (display, device, &x, &y, &state);
|
2011-01-24 01:32:50 +00:00
|
|
|
|
|
2009-07-10 15:30:42 +00:00
|
|
|
|
if (new_toplevel)
|
|
|
|
|
{
|
|
|
|
|
/* w is now toplevel and x,y in toplevel coords */
|
2018-03-20 11:05:26 +00:00
|
|
|
|
_gdk_display_set_surface_under_pointer (display, device, new_toplevel);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
info->toplevel_x = x;
|
|
|
|
|
info->toplevel_y = y;
|
|
|
|
|
info->state = state;
|
2009-07-10 15:30:42 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (grab == NULL) /* Ungrabbed, send events */
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2018-03-20 11:05:26 +00:00
|
|
|
|
/* We're now ungrabbed, update the surface_under_pointer */
|
|
|
|
|
_gdk_display_set_surface_under_pointer (display, device, new_toplevel);
|
2009-07-10 15:30:42 +00:00
|
|
|
|
}
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_hash_table_insert (display->device_grabs, device, old_grabs);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-28 15:22:31 +00:00
|
|
|
|
void
|
|
|
|
|
_gdk_display_update_last_event (GdkDisplay *display,
|
2020-02-16 16:09:02 +00:00
|
|
|
|
GdkEvent *event)
|
2016-02-28 15:22:31 +00:00
|
|
|
|
{
|
|
|
|
|
if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
|
|
|
|
|
display->last_event_time = gdk_event_get_time (event);
|
|
|
|
|
}
|
|
|
|
|
|
2008-07-18 13:03:42 +00:00
|
|
|
|
void
|
2010-05-25 22:38:44 +00:00
|
|
|
|
_gdk_display_device_grab_update (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
gulong current_serial)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *current_grab, *next_grab;
|
|
|
|
|
GList *grabs;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
guint32 time;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
time = display->last_event_time;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
grabs = g_hash_table_lookup (display->device_grabs, device);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
while (grabs != NULL)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
current_grab = grabs->data;
|
2008-12-15 12:38:41 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (current_grab->serial_start > current_serial)
|
|
|
|
|
return; /* Hasn't started yet */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-09-28 13:26:19 +00:00
|
|
|
|
if (current_grab->serial_end > current_serial)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
|
|
|
|
/* This one hasn't ended yet.
|
|
|
|
|
its the currently active one or scheduled to be active */
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (!current_grab->activated)
|
2010-05-25 22:38:44 +00:00
|
|
|
|
{
|
2010-11-23 19:25:13 +00:00
|
|
|
|
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
|
2020-07-28 21:00:02 +00:00
|
|
|
|
switch_to_pointer_grab (display, device, current_grab, NULL, time, current_serial);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
next_grab = NULL;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
if (grabs->next)
|
2008-12-15 09:24:54 +00:00
|
|
|
|
{
|
2009-01-31 18:42:44 +00:00
|
|
|
|
/* This is the next active grab */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
next_grab = grabs->next->data;
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (next_grab->serial_start > current_serial)
|
|
|
|
|
next_grab = NULL; /* Actually its not yet active */
|
2008-12-15 09:24:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-08-27 11:11:04 +00:00
|
|
|
|
if ((next_grab == NULL && current_grab->implicit_ungrab) ||
|
2018-03-20 14:14:10 +00:00
|
|
|
|
(next_grab != NULL && current_grab->surface != next_grab->surface))
|
|
|
|
|
generate_grab_broken_event (display, GDK_SURFACE (current_grab->surface),
|
2010-05-25 22:38:44 +00:00
|
|
|
|
device,
|
2011-12-28 23:06:45 +00:00
|
|
|
|
current_grab->implicit,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
next_grab? next_grab->surface : NULL);
|
2008-12-15 09:24:54 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
/* Remove old grab */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
grabs = g_list_delete_link (grabs, grabs);
|
|
|
|
|
g_hash_table_insert (display->device_grabs, device, grabs);
|
|
|
|
|
|
2010-11-23 19:25:13 +00:00
|
|
|
|
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
|
2020-07-28 21:00:02 +00:00
|
|
|
|
switch_to_pointer_grab (display, device,
|
2010-05-25 22:38:44 +00:00
|
|
|
|
next_grab, current_grab,
|
|
|
|
|
time, current_serial);
|
|
|
|
|
|
|
|
|
|
free_device_grab (current_grab);
|
2008-12-15 09:24:54 +00:00
|
|
|
|
}
|
2009-01-31 18:42:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GList *
|
2010-05-25 22:38:44 +00:00
|
|
|
|
grab_list_find (GList *grabs,
|
|
|
|
|
gulong serial)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *grab;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
while (grabs)
|
2008-12-15 09:24:54 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
grab = grabs->data;
|
2008-12-15 09:24:54 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (serial >= grab->serial_start && serial < grab->serial_end)
|
2010-05-25 22:38:44 +00:00
|
|
|
|
return grabs;
|
|
|
|
|
|
|
|
|
|
grabs = grabs->next;
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
static GList *
|
|
|
|
|
find_device_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
gulong serial)
|
|
|
|
|
{
|
|
|
|
|
GList *l;
|
2008-12-15 09:24:54 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
l = g_hash_table_lookup (display->device_grabs, device);
|
|
|
|
|
return grab_list_find (l, serial);
|
|
|
|
|
}
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *
|
|
|
|
|
_gdk_display_has_device_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
gulong serial)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
|
|
|
|
GList *l;
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
l = find_device_grab (display, device, serial);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (l)
|
|
|
|
|
return l->data;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-27 11:30:20 +00:00
|
|
|
|
/* Returns true if last grab was ended
|
|
|
|
|
* If if_child is non-NULL, end the grab only if the grabbed
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* surface is the same as if_child or a descendant of it */
|
2009-01-31 18:42:44 +00:00
|
|
|
|
gboolean
|
2010-05-25 22:38:44 +00:00
|
|
|
|
_gdk_display_end_device_grab (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
gulong serial,
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkSurface *if_child,
|
2010-05-25 22:38:44 +00:00
|
|
|
|
gboolean implicit)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *grab;
|
2009-01-31 18:42:44 +00:00
|
|
|
|
GList *l;
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
l = find_device_grab (display, device, serial);
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (l == NULL)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
grab = l->data;
|
2019-03-23 13:13:37 +00:00
|
|
|
|
if (grab && (if_child == NULL || if_child == grab->surface))
|
2009-01-31 18:42:44 +00:00
|
|
|
|
{
|
|
|
|
|
grab->serial_end = serial;
|
|
|
|
|
grab->implicit_ungrab = implicit;
|
|
|
|
|
return l->next == NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
2009-01-23 14:23:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkPointerSurfaceInfo *
|
2010-05-25 22:38:44 +00:00
|
|
|
|
_gdk_display_get_pointer_info (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device)
|
2009-01-23 14:23:19 +00:00
|
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkPointerSurfaceInfo *info;
|
2020-07-30 12:26:51 +00:00
|
|
|
|
GdkSeat *seat;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
|
2020-07-30 12:26:51 +00:00
|
|
|
|
if (device)
|
|
|
|
|
{
|
|
|
|
|
seat = gdk_device_get_seat (device);
|
|
|
|
|
|
|
|
|
|
if (device == gdk_seat_get_keyboard (seat))
|
|
|
|
|
device = gdk_seat_get_pointer (seat);
|
|
|
|
|
}
|
2011-12-06 19:29:22 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
if (G_UNLIKELY (!device))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
info = g_hash_table_lookup (display->pointers_info, device);
|
|
|
|
|
|
|
|
|
|
if (G_UNLIKELY (!info))
|
|
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
|
info = g_slice_new0 (GdkPointerSurfaceInfo);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_hash_table_insert (display->pointers_info, device, info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return info;
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
void
|
|
|
|
|
_gdk_display_pointer_info_foreach (GdkDisplay *display,
|
|
|
|
|
GdkDisplayPointerInfoForeach func,
|
|
|
|
|
gpointer user_data)
|
2009-01-23 14:23:19 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GHashTableIter iter;
|
|
|
|
|
gpointer key, value;
|
2009-01-23 14:23:19 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_hash_table_iter_init (&iter, display->pointers_info);
|
|
|
|
|
|
|
|
|
|
while (g_hash_table_iter_next (&iter, &key, &value))
|
2009-01-23 14:23:19 +00:00
|
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkPointerSurfaceInfo *info = value;
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDevice *device = key;
|
2009-01-23 14:23:19 +00:00
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
(func) (display, device, info, user_data);
|
2009-01-23 14:23:19 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
2014-11-07 13:40:22 +00:00
|
|
|
|
/*< private >
|
|
|
|
|
* gdk_device_grab_info:
|
2010-05-25 22:38:44 +00:00
|
|
|
|
* @display: the display for which to get the grab information
|
|
|
|
|
* @device: device to get the grab information from
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* @grab_surface: (out) (transfer none): location to store current grab surface
|
2010-12-07 18:03:55 +00:00
|
|
|
|
* @owner_events: (out): location to store boolean indicating whether
|
2016-10-24 08:13:14 +00:00
|
|
|
|
* the @owner_events flag to gdk_device_grab() was %TRUE.
|
2010-05-25 22:38:44 +00:00
|
|
|
|
*
|
|
|
|
|
* Determines information about the current keyboard grab.
|
2008-07-18 13:03:42 +00:00
|
|
|
|
* This is not public API and must not be used by applications.
|
2010-05-25 22:38:44 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: %TRUE if this application currently has the
|
2010-05-25 22:38:44 +00:00
|
|
|
|
* keyboard grabbed.
|
2014-11-07 13:40:22 +00:00
|
|
|
|
*/
|
2008-07-18 13:03:42 +00:00
|
|
|
|
gboolean
|
2014-11-07 13:40:22 +00:00
|
|
|
|
gdk_device_grab_info (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface **grab_surface,
|
2014-11-07 13:40:22 +00:00
|
|
|
|
gboolean *owner_events)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2010-05-25 22:38:44 +00:00
|
|
|
|
GdkDeviceGrabInfo *info;
|
|
|
|
|
|
2008-07-18 13:03:42 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
|
|
|
|
|
|
|
|
|
|
info = _gdk_display_get_last_device_grab (display, device);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
if (info)
|
2008-07-18 13:03:42 +00:00
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
if (grab_surface)
|
|
|
|
|
*grab_surface = info->surface;
|
2008-07-18 13:03:42 +00:00
|
|
|
|
if (owner_events)
|
2009-01-31 18:42:44 +00:00
|
|
|
|
*owner_events = info->owner_events;
|
2008-07-18 13:03:42 +00:00
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-25 22:38:44 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_device_is_grabbed:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
|
|
|
|
* @device: a `GdkDevice`
|
2010-05-25 22:38:44 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns %TRUE if there is an ongoing grab on @device for @display.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if there is a grab in effect for @device.
|
2021-02-21 14:19:37 +00:00
|
|
|
|
*/
|
2010-05-25 22:38:44 +00:00
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_device_is_grabbed (GdkDisplay *display,
|
|
|
|
|
GdkDevice *device)
|
|
|
|
|
{
|
|
|
|
|
GdkDeviceGrabInfo *info;
|
|
|
|
|
|
2008-07-18 13:03:42 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
|
2010-05-25 22:38:44 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DEVICE (device), TRUE);
|
2009-01-31 18:42:44 +00:00
|
|
|
|
|
2009-02-02 14:37:02 +00:00
|
|
|
|
/* What we're interested in is the steady state (ie last grab),
|
|
|
|
|
because we're interested e.g. if we grabbed so that we
|
|
|
|
|
can ungrab, even if our grab is not active just yet. */
|
2010-05-25 22:38:44 +00:00
|
|
|
|
info = _gdk_display_get_last_device_grab (display, device);
|
|
|
|
|
|
2009-01-31 18:42:44 +00:00
|
|
|
|
return (info && !info->implicit);
|
2008-07-18 13:03:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-12-05 21:37:03 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_name:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the name of the display.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a string representing the display name. This string is owned
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* by GDK and should not be modified or freed.
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*/
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *
|
2010-12-05 21:37:03 +00:00
|
|
|
|
gdk_display_get_name (GdkDisplay *display)
|
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_name (display);
|
2010-12-05 21:37:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_beep:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Emits a short beep on @display
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gdk_display_beep (GdkDisplay *display)
|
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->beep (display);
|
2010-12-05 21:37:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_sync:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
|
|
|
|
* Flushes any requests queued for the windowing system and waits until all
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* requests have been handled.
|
|
|
|
|
*
|
|
|
|
|
* This is often used for making sure that the display is synchronized
|
|
|
|
|
* with the current state of the program. Calling [method@Gdk.Display.sync]
|
|
|
|
|
* before [method@GdkX11.Display.error_trap_pop] makes sure that any errors
|
|
|
|
|
* generated from earlier requests are handled before the error trap is removed.
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
|
|
|
|
* This is most useful for X11. On windowing systems where requests are
|
|
|
|
|
* handled synchronously, this function will do nothing.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gdk_display_sync (GdkDisplay *display)
|
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->sync (display);
|
2010-12-05 21:37:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_flush:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* 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
|
2010-12-05 21:37:03 +00:00
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gdk_display_flush (GdkDisplay *display)
|
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->flush (display);
|
2010-12-05 21:37:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-05-29 03:55:53 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_clipboard:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2014-05-29 03:55:53 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the clipboard used for copy/paste operations.
|
|
|
|
|
*
|
2017-12-21 19:13:28 +00:00
|
|
|
|
* Returns: (transfer none): the display's clipboard
|
|
|
|
|
*/
|
2014-05-29 03:55:53 +00:00
|
|
|
|
GdkClipboard *
|
|
|
|
|
gdk_display_get_clipboard (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
if (display->clipboard == NULL)
|
|
|
|
|
display->clipboard = gdk_clipboard_new (display);
|
|
|
|
|
|
|
|
|
|
return display->clipboard;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_primary_clipboard:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2014-05-29 03:55:53 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Gets the clipboard used for the primary selection.
|
|
|
|
|
*
|
|
|
|
|
* On backends where the primary clipboard is not supported natively,
|
|
|
|
|
* GDK emulates this clipboard locally.
|
2014-05-29 03:55:53 +00:00
|
|
|
|
*
|
2017-12-21 19:13:28 +00:00
|
|
|
|
* Returns: (transfer none): the primary clipboard
|
|
|
|
|
*/
|
2014-05-29 03:55:53 +00:00
|
|
|
|
GdkClipboard *
|
|
|
|
|
gdk_display_get_primary_clipboard (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
if (display->primary_clipboard == NULL)
|
|
|
|
|
display->primary_clipboard = gdk_clipboard_new (display);
|
|
|
|
|
|
|
|
|
|
return display->primary_clipboard;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-05 21:37:03 +00:00
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* gdk_display_supports_input_shapes: (attributes org.gtk.Method.get_property=input-shapes)
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns %TRUE if the display supports input shapes.
|
|
|
|
|
*
|
|
|
|
|
* This means that [method@Gdk.Surface.set_input_region] can
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* be used to modify the input shape of surfaces on @display.
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*
|
2020-07-30 03:00:57 +00:00
|
|
|
|
* On modern displays, this value is always %TRUE.
|
|
|
|
|
*
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* Returns: %TRUE if surfaces with modified input shape are supported
|
2010-12-05 21:37:03 +00:00
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_supports_input_shapes (GdkDisplay *display)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
return priv->input_shapes;
|
2020-05-18 02:05:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_set_input_shapes (GdkDisplay *display,
|
|
|
|
|
gboolean input_shapes)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2020-05-18 02:05:24 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
if (priv->input_shapes == input_shapes)
|
2020-05-18 02:05:24 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
priv->input_shapes = input_shapes;
|
2020-05-18 02:05:24 +00:00
|
|
|
|
|
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (display), props[PROP_INPUT_SHAPES]);
|
2010-12-05 21:37:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-12-09 06:08:05 +00:00
|
|
|
|
static GdkAppLaunchContext *
|
|
|
|
|
gdk_display_real_get_app_launch_context (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
GdkAppLaunchContext *ctx;
|
|
|
|
|
|
2010-12-24 22:37:00 +00:00
|
|
|
|
ctx = g_object_new (GDK_TYPE_APP_LAUNCH_CONTEXT,
|
|
|
|
|
"display", display,
|
|
|
|
|
NULL);
|
2010-12-09 06:08:05 +00:00
|
|
|
|
|
|
|
|
|
return ctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_app_launch_context:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-09 06:08:05 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns a `GdkAppLaunchContext` suitable for launching
|
2010-12-09 06:08:05 +00:00
|
|
|
|
* applications on the given display.
|
|
|
|
|
*
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* Returns: (transfer full): a new `GdkAppLaunchContext` for @display
|
2010-12-09 06:08:05 +00:00
|
|
|
|
*/
|
|
|
|
|
GdkAppLaunchContext *
|
|
|
|
|
gdk_display_get_app_launch_context (GdkDisplay *display)
|
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_app_launch_context (display);
|
2010-12-09 06:08:05 +00:00
|
|
|
|
}
|
2010-12-10 06:27:10 +00:00
|
|
|
|
|
2010-12-11 00:42:09 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_open:
|
|
|
|
|
* @display_name: the name of the display to open
|
|
|
|
|
*
|
|
|
|
|
* Opens a display.
|
|
|
|
|
*
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* If opening the display fails, `NULL` is returned.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (nullable) (transfer none): a `GdkDisplay`
|
2010-12-11 00:42:09 +00:00
|
|
|
|
*/
|
|
|
|
|
GdkDisplay *
|
2020-07-24 18:40:36 +00:00
|
|
|
|
gdk_display_open (const char *display_name)
|
2010-12-11 00:42:09 +00:00
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
return gdk_display_manager_open_display (gdk_display_manager_get (),
|
|
|
|
|
display_name);
|
2010-12-11 00:42:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 19:05:59 +00:00
|
|
|
|
gulong
|
|
|
|
|
_gdk_display_get_next_serial (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_next_serial (display);
|
|
|
|
|
}
|
2010-12-14 01:46:00 +00:00
|
|
|
|
|
2010-12-25 05:02:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_notify_startup_complete:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2010-12-25 05:02:39 +00:00
|
|
|
|
* @startup_id: a startup-notification identifier, for which
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* notification process should be completed
|
2010-12-25 05:02:39 +00:00
|
|
|
|
*
|
|
|
|
|
* Indicates to the GUI environment that the application has
|
|
|
|
|
* finished loading, using a given identifier.
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* GTK will call this function automatically for [class@Gtk.Window]
|
2010-12-25 05:02:39 +00:00
|
|
|
|
* with custom startup-notification identifier unless
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* [method@Gtk.Window.set_auto_startup_notification]
|
|
|
|
|
* is called to disable that feature.
|
2010-12-25 05:02:39 +00:00
|
|
|
|
*/
|
2010-12-14 01:46:00 +00:00
|
|
|
|
void
|
|
|
|
|
gdk_display_notify_startup_complete (GdkDisplay *display,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *startup_id)
|
2010-12-14 01:46:00 +00:00
|
|
|
|
{
|
2011-02-28 16:34:52 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
2010-12-14 01:46:00 +00:00
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->notify_startup_complete (display, startup_id);
|
|
|
|
|
}
|
2010-12-15 05:37:40 +00:00
|
|
|
|
|
2018-06-04 16:27:36 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_startup_notification_id:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2018-06-04 16:27:36 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the startup notification ID for a Wayland display, or %NULL
|
|
|
|
|
* if no ID has been defined.
|
|
|
|
|
*
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* Returns: (nullable): the startup notification ID for @display
|
2018-06-04 16:27:36 +00:00
|
|
|
|
*/
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *
|
2018-06-04 16:27:36 +00:00
|
|
|
|
gdk_display_get_startup_notification_id (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
if (GDK_DISPLAY_GET_CLASS (display)->get_startup_notification_id == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_startup_notification_id (display);
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-26 14:28:06 +00:00
|
|
|
|
void
|
2012-10-07 18:13:56 +00:00
|
|
|
|
_gdk_display_pause_events (GdkDisplay *display)
|
2012-09-26 14:28:06 +00:00
|
|
|
|
{
|
2012-10-07 18:13:56 +00:00
|
|
|
|
display->event_pause_count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_gdk_display_unpause_events (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (display->event_pause_count > 0);
|
|
|
|
|
|
|
|
|
|
display->event_pause_count--;
|
2012-09-26 14:28:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
|
GdkSurface *
|
2019-04-22 01:14:46 +00:00
|
|
|
|
gdk_display_create_surface (GdkDisplay *display,
|
|
|
|
|
GdkSurfaceType surface_type,
|
|
|
|
|
GdkSurface *parent,
|
|
|
|
|
int x,
|
|
|
|
|
int y,
|
|
|
|
|
int width,
|
|
|
|
|
int height)
|
2010-12-21 02:06:59 +00:00
|
|
|
|
{
|
2019-04-22 01:14:46 +00:00
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->create_surface (display,
|
|
|
|
|
surface_type,
|
|
|
|
|
parent,
|
|
|
|
|
x, y, width, height);
|
2010-12-21 02:06:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-20 03:39:18 +00:00
|
|
|
|
/*< private >
|
2017-12-15 11:53:13 +00:00
|
|
|
|
* gdk_display_get_keymap:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: the `GdkDisplay`
|
2017-12-15 11:53:13 +00:00
|
|
|
|
*
|
2021-05-20 03:39:18 +00:00
|
|
|
|
* Returns the `GdkKeymap` attached to @display.
|
2017-12-15 11:53:13 +00:00
|
|
|
|
*
|
2021-05-20 03:39:18 +00:00
|
|
|
|
* Returns: (transfer none): the `GdkKeymap` attached to @display.
|
2017-12-15 11:53:13 +00:00
|
|
|
|
*/
|
|
|
|
|
GdkKeymap *
|
|
|
|
|
gdk_display_get_keymap (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_keymap (display);
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
static void
|
|
|
|
|
gdk_display_init_gl (GdkDisplay *self)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
GdkGLContext *context;
|
2021-07-22 15:36:29 +00:00
|
|
|
|
gint64 before G_GNUC_UNUSED;
|
|
|
|
|
gint64 before2 G_GNUC_UNUSED;
|
|
|
|
|
|
|
|
|
|
before = GDK_PROFILER_CURRENT_TIME;
|
2021-07-04 23:57:03 +00:00
|
|
|
|
|
2022-09-22 00:57:22 +00:00
|
|
|
|
if (gdk_display_get_debug_flags (self) & GDK_DEBUG_GL_DISABLE)
|
2021-07-04 23:57:03 +00:00
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (&priv->gl_error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("GL support disabled via GDK_DEBUG"));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
context = GDK_DISPLAY_GET_CLASS (self)->init_gl (self, &priv->gl_error);
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2021-07-22 15:36:29 +00:00
|
|
|
|
before2 = GDK_PROFILER_CURRENT_TIME;
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
if (!gdk_gl_context_realize (context, &priv->gl_error))
|
|
|
|
|
{
|
|
|
|
|
g_object_unref (context);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-22 15:36:29 +00:00
|
|
|
|
gdk_profiler_end_mark (before2, "realize OpenGL context", NULL);
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
/* Only assign after realize, so GdkGLContext::realize() can use
|
|
|
|
|
* gdk_display_get_gl_context() == NULL to differentiate between
|
|
|
|
|
* the display's context and any other context.
|
|
|
|
|
*/
|
|
|
|
|
priv->gl_context = context;
|
2021-07-22 15:36:29 +00:00
|
|
|
|
|
2021-09-23 23:47:03 +00:00
|
|
|
|
gdk_gl_backend_use (GDK_GL_CONTEXT_GET_CLASS (context)->backend_type);
|
|
|
|
|
|
2021-07-22 15:36:29 +00:00
|
|
|
|
gdk_profiler_end_mark (before, "initialize OpenGL", NULL);
|
2021-07-04 23:57:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_prepare_gl:
|
|
|
|
|
* @self: a `GdkDisplay`
|
|
|
|
|
* @error: return location for a `GError`
|
|
|
|
|
*
|
|
|
|
|
* Checks that OpenGL is available for @self and ensures that it is
|
|
|
|
|
* properly initialized.
|
|
|
|
|
* When this fails, an @error will be set describing the error and this
|
|
|
|
|
* function returns %FALSE.
|
|
|
|
|
*
|
|
|
|
|
* Note that even if this function succeeds, creating a `GdkGLContext`
|
|
|
|
|
* may still fail.
|
|
|
|
|
*
|
|
|
|
|
* This function is idempotent. Calling it multiple times will just
|
|
|
|
|
* return the same value or error.
|
|
|
|
|
*
|
|
|
|
|
* You never need to call this function, GDK will call it automatically
|
|
|
|
|
* as needed. But you can use it as a check when setting up code that
|
|
|
|
|
* might make use of OpenGL.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the display supports OpenGL
|
|
|
|
|
*
|
|
|
|
|
* Since: 4.4
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_prepare_gl (GdkDisplay *self,
|
|
|
|
|
GError **error)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (self), FALSE);
|
|
|
|
|
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
|
{
|
|
|
|
|
if (priv->gl_context)
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
if (priv->gl_error != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (error)
|
|
|
|
|
*error = g_error_copy (priv->gl_error);
|
2021-07-22 15:36:29 +00:00
|
|
|
|
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gdk_display_init_gl (self);
|
|
|
|
|
|
|
|
|
|
/* try again */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-20 18:03:00 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_create_gl_context:
|
|
|
|
|
* @self: a `GdkDisplay`
|
|
|
|
|
* @error: return location for an error
|
|
|
|
|
*
|
|
|
|
|
* Creates a new `GdkGLContext` for the `GdkDisplay`.
|
|
|
|
|
*
|
|
|
|
|
* The context is disconnected from any particular surface or surface
|
|
|
|
|
* and cannot be used to draw to any surface. It can only be used to
|
|
|
|
|
* draw to non-surface framebuffers like textures.
|
|
|
|
|
*
|
|
|
|
|
* If the creation of the `GdkGLContext` failed, @error will be set.
|
|
|
|
|
* Before using the returned `GdkGLContext`, you will need to
|
|
|
|
|
* call [method@Gdk.GLContext.make_current] or [method@Gdk.GLContext.realize].
|
|
|
|
|
*
|
2021-10-25 15:40:40 +00:00
|
|
|
|
* Returns: (transfer full): the newly created `GdkGLContext`
|
2021-10-20 18:03:00 +00:00
|
|
|
|
*
|
|
|
|
|
* Since: 4.6
|
|
|
|
|
*/
|
|
|
|
|
GdkGLContext *
|
|
|
|
|
gdk_display_create_gl_context (GdkDisplay *self,
|
|
|
|
|
GError **error)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL);
|
|
|
|
|
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
|
|
|
|
|
|
|
|
|
|
if (!gdk_display_prepare_gl (self, error))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return gdk_gl_context_new (self, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-04 23:57:03 +00:00
|
|
|
|
/*< private >
|
|
|
|
|
* gdk_display_get_gl_context:
|
|
|
|
|
* @self: the `GdkDisplay`
|
|
|
|
|
*
|
|
|
|
|
* Gets the GL context returned from [vfunc@Gdk.Display.init_gl]
|
|
|
|
|
* previously.
|
|
|
|
|
*
|
|
|
|
|
* If that function has not been called yet or did fail, %NULL is
|
|
|
|
|
* returned.
|
|
|
|
|
* Call [method@Gdk.Display.prepare_gl] to avoid this.
|
|
|
|
|
*
|
|
|
|
|
* Returns: The `GdkGLContext`
|
|
|
|
|
*/
|
|
|
|
|
GdkGLContext *
|
|
|
|
|
gdk_display_get_gl_context (GdkDisplay *self)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
|
|
|
|
|
return priv->gl_context;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
|
static int
|
|
|
|
|
strvcmp (gconstpointer p1,
|
|
|
|
|
gconstpointer p2)
|
|
|
|
|
{
|
|
|
|
|
const char * const *s1 = p1;
|
|
|
|
|
const char * const *s2 = p2;
|
|
|
|
|
|
|
|
|
|
return strcmp (*s1, *s2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
describe_extensions (EGLDisplay egl_display)
|
|
|
|
|
{
|
|
|
|
|
const char *extensions;
|
|
|
|
|
char **exts;
|
|
|
|
|
char *ext;
|
|
|
|
|
|
|
|
|
|
extensions = eglQueryString (egl_display, EGL_EXTENSIONS);
|
|
|
|
|
|
|
|
|
|
exts = g_strsplit (extensions, " ", -1);
|
|
|
|
|
qsort (exts, g_strv_length (exts), sizeof (char *), strvcmp);
|
|
|
|
|
|
|
|
|
|
ext = g_strjoinv ("\n\t", exts);
|
|
|
|
|
if (ext[0] == '\n')
|
|
|
|
|
ext[0] = ' ';
|
|
|
|
|
|
|
|
|
|
g_strfreev (exts);
|
|
|
|
|
|
|
|
|
|
return g_strstrip (ext);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
describe_egl_config (EGLDisplay egl_display,
|
|
|
|
|
EGLConfig egl_config)
|
|
|
|
|
{
|
|
|
|
|
EGLint red, green, blue, alpha, type;
|
|
|
|
|
|
|
|
|
|
if (egl_config == NULL)
|
|
|
|
|
return g_strdup ("-");
|
|
|
|
|
|
|
|
|
|
if (!eglGetConfigAttrib (egl_display, egl_config, EGL_RED_SIZE, &red) ||
|
|
|
|
|
!eglGetConfigAttrib (egl_display, egl_config, EGL_GREEN_SIZE, &green) ||
|
|
|
|
|
!eglGetConfigAttrib (egl_display, egl_config, EGL_BLUE_SIZE, &blue) ||
|
|
|
|
|
!eglGetConfigAttrib (egl_display, egl_config, EGL_ALPHA_SIZE, &alpha))
|
|
|
|
|
return g_strdup ("Unknown");
|
|
|
|
|
|
|
|
|
|
if (epoxy_has_egl_extension (egl_display, "EGL_EXT_pixel_format_float"))
|
|
|
|
|
{
|
|
|
|
|
if (!eglGetConfigAttrib (egl_display, egl_config, EGL_COLOR_COMPONENT_TYPE_EXT, &type))
|
|
|
|
|
type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
|
|
|
|
|
|
|
|
|
|
return g_strdup_printf ("R%dG%dB%dA%d%s", red, green, blue, alpha, type == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT ? "" : " float");
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
gpointer
|
|
|
|
|
gdk_display_get_egl_config (GdkDisplay *self)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
|
|
|
|
|
return priv->egl_config;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-06 01:33:24 +00:00
|
|
|
|
gpointer
|
2021-10-06 16:25:30 +00:00
|
|
|
|
gdk_display_get_egl_config_high_depth (GdkDisplay *self)
|
2021-10-06 01:33:24 +00:00
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
|
2021-10-06 16:25:30 +00:00
|
|
|
|
return priv->egl_config_high_depth;
|
2021-10-06 01:33:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
static EGLDisplay
|
|
|
|
|
gdk_display_create_egl_display (EGLenum platform,
|
|
|
|
|
gpointer native_display)
|
|
|
|
|
{
|
|
|
|
|
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
|
|
|
|
|
EGLDisplay egl_display = NULL;
|
|
|
|
|
|
|
|
|
|
if (epoxy_has_egl_extension (NULL, "EGL_KHR_platform_base"))
|
|
|
|
|
{
|
|
|
|
|
PFNEGLGETPLATFORMDISPLAYPROC getPlatformDisplay =
|
|
|
|
|
(void *) eglGetProcAddress ("eglGetPlatformDisplay");
|
|
|
|
|
|
|
|
|
|
if (getPlatformDisplay != NULL)
|
|
|
|
|
egl_display = getPlatformDisplay (platform, native_display, NULL);
|
|
|
|
|
if (egl_display != NULL)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (epoxy_has_egl_extension (NULL, "EGL_EXT_platform_base"))
|
|
|
|
|
{
|
|
|
|
|
PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay =
|
|
|
|
|
(void *) eglGetProcAddress ("eglGetPlatformDisplayEXT");
|
|
|
|
|
|
|
|
|
|
if (getPlatformDisplay != NULL)
|
|
|
|
|
egl_display = getPlatformDisplay (platform, native_display, NULL);
|
|
|
|
|
if (egl_display != NULL)
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
egl_display = eglGetDisplay ((EGLNativeDisplayType) native_display);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
gdk_profiler_end_mark (start_time, "Create EGL display", NULL);
|
|
|
|
|
|
|
|
|
|
return egl_display;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define MAX_EGL_ATTRS 30
|
|
|
|
|
|
|
|
|
|
typedef enum {
|
2021-10-06 01:33:24 +00:00
|
|
|
|
GDK_EGL_CONFIG_PERFECT = (1 << 0),
|
|
|
|
|
GDK_EGL_CONFIG_HDR = (1 << 1),
|
2021-10-03 04:22:21 +00:00
|
|
|
|
} GdkEGLConfigCreateFlags;
|
|
|
|
|
|
|
|
|
|
static EGLConfig
|
|
|
|
|
gdk_display_create_egl_config (GdkDisplay *self,
|
|
|
|
|
GdkEGLConfigCreateFlags flags,
|
|
|
|
|
GError **error)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
|
|
|
|
|
EGLint attrs[MAX_EGL_ATTRS];
|
|
|
|
|
EGLConfig *configs;
|
|
|
|
|
EGLint count, alloced;
|
|
|
|
|
EGLConfig best_config;
|
|
|
|
|
guint best_score;
|
|
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
|
|
attrs[i++] = EGL_SURFACE_TYPE;
|
|
|
|
|
attrs[i++] = EGL_WINDOW_BIT;
|
|
|
|
|
|
|
|
|
|
attrs[i++] = EGL_COLOR_BUFFER_TYPE;
|
|
|
|
|
attrs[i++] = EGL_RGB_BUFFER;
|
|
|
|
|
|
|
|
|
|
attrs[i++] = EGL_RED_SIZE;
|
2021-10-06 01:33:24 +00:00
|
|
|
|
attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8;
|
2021-10-03 04:22:21 +00:00
|
|
|
|
attrs[i++] = EGL_GREEN_SIZE;
|
2021-10-06 01:33:24 +00:00
|
|
|
|
attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8;
|
2021-10-03 04:22:21 +00:00
|
|
|
|
attrs[i++] = EGL_BLUE_SIZE;
|
2021-10-06 01:33:24 +00:00
|
|
|
|
attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8;
|
2021-10-03 04:22:21 +00:00
|
|
|
|
attrs[i++] = EGL_ALPHA_SIZE;
|
|
|
|
|
attrs[i++] = 8;
|
|
|
|
|
|
2021-10-06 01:33:24 +00:00
|
|
|
|
if (flags & GDK_EGL_CONFIG_HDR &&
|
|
|
|
|
self->have_egl_pixel_format_float)
|
|
|
|
|
{
|
|
|
|
|
attrs[i++] = EGL_COLOR_COMPONENT_TYPE_EXT;
|
|
|
|
|
attrs[i++] = EGL_DONT_CARE;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-03 04:22:21 +00:00
|
|
|
|
attrs[i++] = EGL_NONE;
|
|
|
|
|
g_assert (i < MAX_EGL_ATTRS);
|
|
|
|
|
|
|
|
|
|
if (!eglChooseConfig (priv->egl_display, attrs, NULL, -1, &alloced) || alloced == 0)
|
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("No EGL configuration available"));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
configs = g_new (EGLConfig, alloced);
|
|
|
|
|
if (!eglChooseConfig (priv->egl_display, attrs, configs, alloced, &count))
|
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("Failed to get EGL configurations"));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
g_warn_if_fail (alloced == count);
|
|
|
|
|
|
|
|
|
|
best_score = G_MAXUINT;
|
|
|
|
|
best_config = NULL;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
|
{
|
|
|
|
|
guint score = GDK_DISPLAY_GET_CLASS (self)->rate_egl_config (self, priv->egl_display, configs[i]);
|
|
|
|
|
|
|
|
|
|
if (score < best_score)
|
|
|
|
|
{
|
|
|
|
|
best_score = score;
|
|
|
|
|
best_config = configs[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (score == 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_free (configs);
|
|
|
|
|
|
|
|
|
|
gdk_profiler_end_mark (start_time, "Create EGL config", NULL);
|
|
|
|
|
|
|
|
|
|
if (best_score == G_MAXUINT)
|
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("No EGL configuration with required features found"));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
else if ((flags & GDK_EGL_CONFIG_PERFECT) && best_score != 0)
|
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("No perfect EGL configuration found"));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return best_config;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#undef MAX_EGL_ATTRS
|
|
|
|
|
|
2021-10-03 15:40:09 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gdk_display_check_egl_extensions (EGLDisplay egl_display,
|
|
|
|
|
const char **extensions,
|
|
|
|
|
GError **error)
|
|
|
|
|
{
|
|
|
|
|
GString *missing = NULL;
|
|
|
|
|
gsize i, n_missing;
|
|
|
|
|
|
|
|
|
|
n_missing = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; extensions[i] != NULL; i++)
|
|
|
|
|
{
|
|
|
|
|
if (!epoxy_has_egl_extension (egl_display, extensions[i]))
|
|
|
|
|
{
|
|
|
|
|
if (missing == NULL)
|
|
|
|
|
{
|
|
|
|
|
missing = g_string_new (extensions[i]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
g_string_append (missing, ", ");
|
|
|
|
|
g_string_append (missing, extensions[i]);
|
|
|
|
|
}
|
|
|
|
|
n_missing++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (n_missing)
|
|
|
|
|
{
|
|
|
|
|
g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_UNSUPPORTED_PROFILE,
|
|
|
|
|
/* translators: Arguments are the number of missing extensions
|
|
|
|
|
* followed by a comma-separated list of their names */
|
|
|
|
|
g_dngettext (GETTEXT_PACKAGE,
|
2022-05-11 19:43:04 +00:00
|
|
|
|
"EGL implementation is missing extension %s",
|
|
|
|
|
"EGL implementation is missing %2$d extensions: %1$s",
|
2021-10-03 15:40:09 +00:00
|
|
|
|
n_missing),
|
2022-05-11 19:43:04 +00:00
|
|
|
|
missing->str, (int) n_missing);
|
2021-10-03 15:40:09 +00:00
|
|
|
|
|
|
|
|
|
g_string_free (missing, TRUE);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
2021-10-03 04:22:21 +00:00
|
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_init_egl (GdkDisplay *self,
|
|
|
|
|
int platform,
|
|
|
|
|
gpointer native_display,
|
|
|
|
|
gboolean allow_any,
|
|
|
|
|
GError **error)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
|
|
|
|
|
G_GNUC_UNUSED gint64 start_time2;
|
|
|
|
|
int major, minor;
|
|
|
|
|
|
|
|
|
|
if (!gdk_gl_backend_can_be_used (GDK_GL_EGL, error))
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
if (!epoxy_has_egl ())
|
|
|
|
|
{
|
|
|
|
|
gboolean sandboxed = gdk_running_in_sandbox ();
|
|
|
|
|
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
sandboxed ? _("libEGL not available in this sandbox")
|
|
|
|
|
: _("libEGL not available"));
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
priv->egl_display = gdk_display_create_egl_display (platform, native_display);
|
|
|
|
|
|
|
|
|
|
if (priv->egl_display == NULL)
|
|
|
|
|
{
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("Failed to create EGL display"));
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
start_time2 = GDK_PROFILER_CURRENT_TIME;
|
|
|
|
|
if (!eglInitialize (priv->egl_display, &major, &minor))
|
|
|
|
|
{
|
|
|
|
|
priv->egl_display = NULL;
|
|
|
|
|
g_set_error_literal (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("Could not initialize EGL display"));
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
gdk_profiler_end_mark (start_time2, "eglInitialize", NULL);
|
|
|
|
|
|
|
|
|
|
if (major < GDK_EGL_MIN_VERSION_MAJOR ||
|
|
|
|
|
(major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
|
|
|
|
|
{
|
|
|
|
|
g_clear_pointer (&priv->egl_display, eglTerminate);
|
|
|
|
|
g_set_error (error, GDK_GL_ERROR,
|
|
|
|
|
GDK_GL_ERROR_NOT_AVAILABLE,
|
|
|
|
|
_("EGL version %d.%d is too old. GTK requires %d.%d"),
|
|
|
|
|
major, minor, GDK_EGL_MIN_VERSION_MAJOR, GDK_EGL_MIN_VERSION_MINOR);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-03 15:40:09 +00:00
|
|
|
|
if (!gdk_display_check_egl_extensions (priv->egl_display,
|
|
|
|
|
(const char *[]) {
|
2021-10-03 19:58:57 +00:00
|
|
|
|
"EGL_KHR_create_context",
|
2021-10-03 15:40:09 +00:00
|
|
|
|
"EGL_KHR_surfaceless_context",
|
|
|
|
|
NULL
|
|
|
|
|
},
|
|
|
|
|
error))
|
2021-10-03 04:22:21 +00:00
|
|
|
|
{
|
|
|
|
|
g_clear_pointer (&priv->egl_display, eglTerminate);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
priv->egl_config = gdk_display_create_egl_config (self,
|
|
|
|
|
allow_any ? 0 : GDK_EGL_CONFIG_PERFECT,
|
|
|
|
|
error);
|
|
|
|
|
if (priv->egl_config == NULL)
|
|
|
|
|
{
|
|
|
|
|
g_clear_pointer (&priv->egl_display, eglTerminate);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-05 22:48:33 +00:00
|
|
|
|
self->have_egl_buffer_age =
|
|
|
|
|
epoxy_has_egl_extension (priv->egl_display, "EGL_EXT_buffer_age");
|
2021-10-06 00:41:31 +00:00
|
|
|
|
self->have_egl_no_config_context =
|
|
|
|
|
epoxy_has_egl_extension (priv->egl_display, "EGL_KHR_no_config_context");
|
2021-10-06 01:33:24 +00:00
|
|
|
|
self->have_egl_pixel_format_float =
|
|
|
|
|
epoxy_has_egl_extension (priv->egl_display, "EGL_EXT_pixel_format_float");
|
2022-01-18 16:16:11 +00:00
|
|
|
|
self->have_egl_win32_libangle =
|
|
|
|
|
epoxy_has_egl_extension (priv->egl_display, "EGL_ANGLE_d3d_share_handle_client_buffer");
|
2021-10-06 01:33:24 +00:00
|
|
|
|
|
|
|
|
|
if (self->have_egl_no_config_context)
|
2021-10-06 16:25:30 +00:00
|
|
|
|
priv->egl_config_high_depth = gdk_display_create_egl_config (self,
|
2021-10-06 01:33:24 +00:00
|
|
|
|
GDK_EGL_CONFIG_HDR,
|
|
|
|
|
error);
|
2021-10-06 16:25:30 +00:00
|
|
|
|
if (priv->egl_config_high_depth == NULL)
|
|
|
|
|
priv->egl_config_high_depth = priv->egl_config;
|
2021-10-05 22:48:33 +00:00
|
|
|
|
|
2022-09-23 00:48:58 +00:00
|
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
|
if (GDK_DISPLAY_DEBUG_CHECK (self, OPENGL))
|
|
|
|
|
{
|
2021-10-03 04:22:21 +00:00
|
|
|
|
char *ext = describe_extensions (priv->egl_display);
|
2021-10-06 16:25:30 +00:00
|
|
|
|
char *std_cfg = describe_egl_config (priv->egl_display, priv->egl_config);
|
|
|
|
|
char *hd_cfg = describe_egl_config (priv->egl_display, priv->egl_config_high_depth);
|
2022-09-23 00:48:58 +00:00
|
|
|
|
gdk_debug_message ("EGL API version %d.%d found\n"
|
|
|
|
|
" - Vendor: %s\n"
|
|
|
|
|
" - Version: %s\n"
|
|
|
|
|
" - Client APIs: %s\n"
|
|
|
|
|
" - Extensions:\n"
|
|
|
|
|
"\t%s\n"
|
|
|
|
|
" - Selected fbconfig: %s\n"
|
|
|
|
|
" high depth: %s",
|
|
|
|
|
major, minor,
|
|
|
|
|
eglQueryString (priv->egl_display, EGL_VENDOR),
|
|
|
|
|
eglQueryString (priv->egl_display, EGL_VERSION),
|
|
|
|
|
eglQueryString (priv->egl_display, EGL_CLIENT_APIS),
|
|
|
|
|
ext, std_cfg,
|
|
|
|
|
priv->egl_config_high_depth == priv->egl_config ? "none" : hd_cfg);
|
2021-10-06 16:25:30 +00:00
|
|
|
|
g_free (hd_cfg);
|
|
|
|
|
g_free (std_cfg);
|
2021-10-03 04:22:21 +00:00
|
|
|
|
g_free (ext);
|
2022-09-23 00:48:58 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
2021-10-03 04:22:21 +00:00
|
|
|
|
|
|
|
|
|
gdk_profiler_end_mark (start_time, "init EGL", NULL);
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-10-07 14:59:37 +00:00
|
|
|
|
/*<private>
|
|
|
|
|
* gdk_display_get_egl_display:
|
|
|
|
|
* @self: a display
|
|
|
|
|
*
|
|
|
|
|
* Retrieves the EGL display connection object for the given GDK display.
|
|
|
|
|
*
|
|
|
|
|
* This function returns `NULL` if GL is not supported or GDK is using
|
|
|
|
|
* a different OpenGL framework than EGL.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (nullable): the EGL display object
|
|
|
|
|
*/
|
|
|
|
|
gpointer
|
|
|
|
|
gdk_display_get_egl_display (GdkDisplay *self)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL);
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_EGL
|
|
|
|
|
if (!priv->egl_display &&
|
|
|
|
|
!gdk_display_prepare_gl (self, NULL))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return priv->egl_display;
|
|
|
|
|
#else
|
|
|
|
|
return NULL;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-11 13:53:57 +00:00
|
|
|
|
GdkDebugFlags
|
|
|
|
|
gdk_display_get_debug_flags (GdkDisplay *display)
|
2014-11-10 19:39:57 +00:00
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
|
|
|
|
return display ? priv->debug_flags : _gdk_debug_flags;
|
2014-11-10 19:39:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2018-01-11 13:53:57 +00:00
|
|
|
|
gdk_display_set_debug_flags (GdkDisplay *display,
|
|
|
|
|
GdkDebugFlags flags)
|
2014-11-10 19:39:57 +00:00
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
|
|
|
|
priv->debug_flags = flags;
|
2014-11-10 19:39:57 +00:00
|
|
|
|
}
|
2014-11-10 20:23:14 +00:00
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* gdk_display_is_composited: (attributes org.gtk.Method.get_property=composited)
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* Returns whether surfaces can reasonably be expected to have
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* their alpha channel drawn correctly on the screen.
|
|
|
|
|
*
|
|
|
|
|
* Check [method@Gdk.Display.is_rgba] for whether the display
|
|
|
|
|
* supports an alpha channel.
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*
|
|
|
|
|
* On X11 this function returns whether a compositing manager is
|
|
|
|
|
* compositing on @display.
|
|
|
|
|
*
|
|
|
|
|
* On modern displays, this value is always %TRUE.
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns: Whether surfaces with RGBA visuals can reasonably
|
|
|
|
|
* be expected to have their alpha channels drawn correctly
|
|
|
|
|
* on the screen.
|
|
|
|
|
*/
|
2016-10-28 21:38:16 +00:00
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_is_composited (GdkDisplay *display)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
return priv->composited;
|
2016-10-29 02:37:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_set_composited (GdkDisplay *display,
|
|
|
|
|
gboolean composited)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2016-10-29 02:37:20 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
if (priv->composited == composited)
|
2016-10-29 02:37:20 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
priv->composited = composited;
|
2016-10-29 02:37:20 +00:00
|
|
|
|
|
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (display), props[PROP_COMPOSITED]);
|
2016-10-28 21:38:16 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2021-02-25 01:02:57 +00:00
|
|
|
|
* gdk_display_is_rgba: (attributes org.gtk.Method.get_property=rgba)
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2016-10-28 21:38:16 +00:00
|
|
|
|
*
|
2020-08-21 12:41:13 +00:00
|
|
|
|
* Returns whether surfaces on this @display are created with an
|
2016-10-28 21:38:16 +00:00
|
|
|
|
* alpha channel.
|
|
|
|
|
*
|
|
|
|
|
* Even if a %TRUE is returned, it is possible that the
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* surface’s alpha channel won’t be honored when displaying the
|
|
|
|
|
* surface on the screen: in particular, for X an appropriate
|
2016-10-28 21:38:16 +00:00
|
|
|
|
* windowing manager and compositing manager must be running to
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* provide appropriate display. Use [method@Gdk.Display.is_composited]
|
2016-10-28 21:38:16 +00:00
|
|
|
|
* to check if that is the case.
|
|
|
|
|
*
|
|
|
|
|
* On modern displays, this value is always %TRUE.
|
|
|
|
|
*
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* Returns: %TRUE if surfaces are created with an alpha channel or
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* %FALSE if the display does not support this functionality.
|
2021-02-21 14:19:37 +00:00
|
|
|
|
*/
|
2016-10-28 21:38:16 +00:00
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_is_rgba (GdkDisplay *display)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2016-10-28 21:38:16 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
return priv->rgba;
|
2016-10-29 02:37:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_set_rgba (GdkDisplay *display,
|
|
|
|
|
gboolean rgba)
|
|
|
|
|
{
|
2021-07-03 23:43:16 +00:00
|
|
|
|
GdkDisplayPrivate *priv = gdk_display_get_instance_private (display);
|
|
|
|
|
|
2016-10-29 02:37:20 +00:00
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
if (priv->rgba == rgba)
|
2016-10-29 02:37:20 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2021-07-03 23:43:16 +00:00
|
|
|
|
priv->rgba = rgba;
|
2016-10-29 02:37:20 +00:00
|
|
|
|
|
|
|
|
|
g_object_notify_by_pspec (G_OBJECT (display), props[PROP_RGBA]);
|
2016-10-28 21:38:16 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-24 16:31:18 +00:00
|
|
|
|
static void
|
|
|
|
|
device_removed_cb (GdkSeat *seat,
|
|
|
|
|
GdkDevice *device,
|
|
|
|
|
GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_hash_table_remove (display->device_grabs, device);
|
|
|
|
|
g_hash_table_remove (display->pointers_info, device);
|
|
|
|
|
|
|
|
|
|
/* FIXME: change core pointer and remove from device list */
|
|
|
|
|
}
|
2016-10-28 21:38:16 +00:00
|
|
|
|
|
2015-11-26 18:52:23 +00:00
|
|
|
|
void
|
|
|
|
|
gdk_display_add_seat (GdkDisplay *display,
|
|
|
|
|
GdkSeat *seat)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
g_return_if_fail (GDK_IS_SEAT (seat));
|
|
|
|
|
|
2016-02-28 17:31:20 +00:00
|
|
|
|
display->seats = g_list_append (display->seats, g_object_ref (seat));
|
2015-12-09 11:25:10 +00:00
|
|
|
|
g_signal_emit (display, signals[SEAT_ADDED], 0, seat);
|
2017-11-24 16:31:18 +00:00
|
|
|
|
|
|
|
|
|
g_signal_connect (seat, "device-removed", G_CALLBACK (device_removed_cb), display);
|
2015-11-26 18:52:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_remove_seat (GdkDisplay *display,
|
|
|
|
|
GdkSeat *seat)
|
|
|
|
|
{
|
|
|
|
|
GList *link;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GDK_IS_DISPLAY (display));
|
|
|
|
|
g_return_if_fail (GDK_IS_SEAT (seat));
|
|
|
|
|
|
2017-11-24 16:31:18 +00:00
|
|
|
|
g_signal_handlers_disconnect_by_func (seat, G_CALLBACK (device_removed_cb), display);
|
|
|
|
|
|
2015-11-26 18:52:23 +00:00
|
|
|
|
link = g_list_find (display->seats, seat);
|
|
|
|
|
|
|
|
|
|
if (link)
|
|
|
|
|
{
|
|
|
|
|
display->seats = g_list_remove_link (display->seats, link);
|
2015-12-09 11:25:10 +00:00
|
|
|
|
g_signal_emit (display, signals[SEAT_REMOVED], 0, seat);
|
2015-11-26 18:52:23 +00:00
|
|
|
|
g_object_unref (link->data);
|
|
|
|
|
g_list_free (link);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_default_seat:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2015-11-26 18:52:23 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns the default `GdkSeat` for this display.
|
2015-11-26 18:52:23 +00:00
|
|
|
|
*
|
2020-05-15 03:14:04 +00:00
|
|
|
|
* Note that a display may not have a seat. In this case,
|
|
|
|
|
* this function will return %NULL.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none) (nullable): the default seat.
|
2015-11-26 18:52:23 +00:00
|
|
|
|
**/
|
|
|
|
|
GdkSeat *
|
|
|
|
|
gdk_display_get_default_seat (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
GdkDisplayClass *display_class;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
display_class = GDK_DISPLAY_GET_CLASS (display);
|
|
|
|
|
|
|
|
|
|
return display_class->get_default_seat (display);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_list_seats:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2015-11-26 18:52:23 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns the list of seats known to @display.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer container) (element-type GdkSeat): the
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* list of seats known to the `GdkDisplay`
|
|
|
|
|
*/
|
2015-11-26 18:52:23 +00:00
|
|
|
|
GList *
|
|
|
|
|
gdk_display_list_seats (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
|
|
|
|
return g_list_copy (display->seats);
|
|
|
|
|
}
|
2016-04-01 03:10:37 +00:00
|
|
|
|
|
|
|
|
|
/**
|
2020-05-13 05:00:35 +00:00
|
|
|
|
* gdk_display_get_monitors:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @self: a `GdkDisplay`
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*
|
2020-05-13 05:00:35 +00:00
|
|
|
|
* Gets the list of monitors associated with this display.
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Subsequent calls to this function will always return the
|
|
|
|
|
* same list for the same display.
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* You can listen to the GListModel::items-changed signal on
|
|
|
|
|
* this list to monitor changes to the monitor of this display.
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*
|
2021-05-20 03:39:18 +00:00
|
|
|
|
* Returns: (transfer none): a `GListModel` of `GdkMonitor`
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*/
|
2020-05-13 05:00:35 +00:00
|
|
|
|
GListModel *
|
|
|
|
|
gdk_display_get_monitors (GdkDisplay *self)
|
2016-04-01 03:10:37 +00:00
|
|
|
|
{
|
2020-05-13 05:00:35 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
|
2020-05-13 05:00:35 +00:00
|
|
|
|
return GDK_DISPLAY_GET_CLASS (self)->get_monitors (self);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2018-03-20 11:05:26 +00:00
|
|
|
|
* gdk_display_get_monitor_at_surface:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
|
|
|
|
* @surface: a `GdkSurface`
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*
|
2018-03-20 14:14:10 +00:00
|
|
|
|
* Gets the monitor in which the largest area of @surface
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* resides.
|
|
|
|
|
*
|
|
|
|
|
* Returns a monitor close to @surface if it is outside
|
2016-04-01 03:10:37 +00:00
|
|
|
|
* of all monitors.
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns: (transfer none): the monitor with the largest
|
|
|
|
|
* overlap with @surface
|
2016-04-01 03:10:37 +00:00
|
|
|
|
*/
|
|
|
|
|
GdkMonitor *
|
2018-03-20 11:05:26 +00:00
|
|
|
|
gdk_display_get_monitor_at_surface (GdkDisplay *display,
|
2018-03-20 14:14:10 +00:00
|
|
|
|
GdkSurface *surface)
|
2016-04-01 03:10:37 +00:00
|
|
|
|
{
|
|
|
|
|
GdkRectangle win;
|
2020-05-17 03:58:20 +00:00
|
|
|
|
GListModel *monitors;
|
|
|
|
|
guint i;
|
2016-04-01 03:10:37 +00:00
|
|
|
|
int area = 0;
|
|
|
|
|
GdkMonitor *best = NULL;
|
2016-05-17 11:09:23 +00:00
|
|
|
|
GdkDisplayClass *class;
|
2016-04-01 03:10:37 +00:00
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
|
|
2016-05-17 11:09:23 +00:00
|
|
|
|
class = GDK_DISPLAY_GET_CLASS (display);
|
2018-03-20 11:05:26 +00:00
|
|
|
|
if (class->get_monitor_at_surface)
|
2016-05-17 11:09:23 +00:00
|
|
|
|
{
|
2018-03-20 14:14:10 +00:00
|
|
|
|
best = class->get_monitor_at_surface (display, surface);
|
2016-05-17 11:09:23 +00:00
|
|
|
|
|
|
|
|
|
if (best)
|
|
|
|
|
return best;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-29 06:05:40 +00:00
|
|
|
|
/* the fallback implementation requires global coordinates */
|
2018-03-20 14:14:10 +00:00
|
|
|
|
gdk_surface_get_geometry (surface, &win.x, &win.y, &win.width, &win.height);
|
|
|
|
|
gdk_surface_get_origin (surface, &win.x, &win.y);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
|
2020-05-17 03:58:20 +00:00
|
|
|
|
monitors = gdk_display_get_monitors (display);
|
|
|
|
|
for (i = 0; i < g_list_model_get_n_items (monitors); i++)
|
2016-04-01 03:10:37 +00:00
|
|
|
|
{
|
|
|
|
|
GdkMonitor *monitor;
|
|
|
|
|
GdkRectangle mon, intersect;
|
|
|
|
|
int overlap;
|
|
|
|
|
|
2020-05-17 03:58:20 +00:00
|
|
|
|
monitor = g_list_model_get_item (monitors, i);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
gdk_monitor_get_geometry (monitor, &mon);
|
|
|
|
|
gdk_rectangle_intersect (&win, &mon, &intersect);
|
|
|
|
|
overlap = intersect.width *intersect.height;
|
|
|
|
|
if (overlap > area)
|
|
|
|
|
{
|
|
|
|
|
area = overlap;
|
|
|
|
|
best = monitor;
|
|
|
|
|
}
|
2020-05-17 03:58:20 +00:00
|
|
|
|
g_object_unref (monitor);
|
2016-04-01 03:10:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-05-29 05:50:48 +00:00
|
|
|
|
return best;
|
2016-04-01 03:10:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-08 15:38:38 +00:00
|
|
|
|
void
|
|
|
|
|
gdk_display_emit_opened (GdkDisplay *display)
|
|
|
|
|
{
|
|
|
|
|
g_signal_emit (display, signals[OPENED], 0);
|
|
|
|
|
}
|
2017-10-30 13:00:49 +00:00
|
|
|
|
|
2017-12-26 15:21:45 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_get_setting:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2017-12-26 15:21:45 +00:00
|
|
|
|
* @name: the name of the setting
|
|
|
|
|
* @value: location to store the value of the setting
|
|
|
|
|
*
|
|
|
|
|
* Retrieves a desktop-wide setting such as double-click time
|
|
|
|
|
* for the @display.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the setting existed and a value was stored
|
|
|
|
|
* in @value, %FALSE otherwise
|
|
|
|
|
*/
|
2017-10-30 13:00:49 +00:00
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_get_setting (GdkDisplay *display,
|
|
|
|
|
const char *name,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
2017-10-30 20:44:47 +00:00
|
|
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
|
|
|
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
return GDK_DISPLAY_GET_CLASS (display)->get_setting (display, name, value);
|
2017-10-30 13:00:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_setting_changed (GdkDisplay *display,
|
|
|
|
|
const char *name)
|
|
|
|
|
{
|
|
|
|
|
g_signal_emit (display, signals[SETTING_CHANGED], 0, name);
|
|
|
|
|
}
|
2017-11-17 20:39:08 +00:00
|
|
|
|
|
2017-11-17 21:22:21 +00:00
|
|
|
|
void
|
|
|
|
|
gdk_display_set_double_click_time (GdkDisplay *display,
|
|
|
|
|
guint msec)
|
|
|
|
|
{
|
|
|
|
|
display->double_click_time = msec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_set_double_click_distance (GdkDisplay *display,
|
|
|
|
|
guint distance)
|
|
|
|
|
{
|
|
|
|
|
display->double_click_distance = distance;
|
|
|
|
|
}
|
2017-11-17 22:42:12 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
gdk_display_set_cursor_theme (GdkDisplay *display,
|
|
|
|
|
const char *name,
|
|
|
|
|
int size)
|
|
|
|
|
{
|
|
|
|
|
if (GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme)
|
|
|
|
|
GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme (display, name, size);
|
|
|
|
|
}
|
2020-04-05 04:37:23 +00:00
|
|
|
|
|
2020-04-05 15:02:50 +00:00
|
|
|
|
/**
|
|
|
|
|
* gdk_display_map_keyval:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* @keyval: a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
|
|
|
|
|
* @keys: (out) (array length=n_keys) (transfer full): return location
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* for an array of `GdkKeymapKey`
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* @n_keys: return location for number of elements in returned array
|
|
|
|
|
*
|
|
|
|
|
* Obtains a list of keycode/group/level combinations that will
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* 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.
|
2020-04-05 15:02:50 +00:00
|
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* `GdkEventKey` contains a %group field that indicates the active
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* keyboard group. The level is computed from the modifier mask.
|
|
|
|
|
*
|
|
|
|
|
* The returned array should be freed with g_free().
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if keys were found and returned
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_map_keyval (GdkDisplay *display,
|
|
|
|
|
guint keyval,
|
|
|
|
|
GdkKeymapKey **keys,
|
|
|
|
|
int *n_keys)
|
|
|
|
|
{
|
|
|
|
|
return gdk_keymap_get_entries_for_keyval (gdk_display_get_keymap (display),
|
|
|
|
|
keyval,
|
|
|
|
|
keys,
|
|
|
|
|
n_keys);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_map_keycode:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* @keycode: a keycode
|
|
|
|
|
* @keys: (out) (array length=n_entries) (transfer full) (optional): return
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* location for array of `GdkKeymapKey`
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* @keyvals: (out) (array length=n_entries) (transfer full) (optional): return
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* location for array of keyvals
|
2020-04-05 15:02:50 +00:00
|
|
|
|
* @n_entries: length of @keys and @keyvals
|
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* Returns the keyvals bound to @keycode.
|
|
|
|
|
*
|
|
|
|
|
* The Nth `GdkKeymapKey` in @keys is bound to the Nth keyval in @keyvals.
|
2020-04-05 15:02:50 +00:00
|
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
|
|
|
|
* Free the returned arrays with g_free().
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if there were any entries
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_map_keycode (GdkDisplay *display,
|
|
|
|
|
guint keycode,
|
|
|
|
|
GdkKeymapKey **keys,
|
|
|
|
|
guint **keyvals,
|
|
|
|
|
int *n_entries)
|
|
|
|
|
{
|
|
|
|
|
return gdk_keymap_get_entries_for_keycode (gdk_display_get_keymap (display),
|
|
|
|
|
keycode,
|
|
|
|
|
keys,
|
|
|
|
|
keyvals,
|
|
|
|
|
n_entries);
|
|
|
|
|
}
|
2020-05-28 19:15:53 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gdk_display_translate_key:
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @display: a `GdkDisplay`
|
2020-05-28 19:15:53 +00:00
|
|
|
|
* @keycode: a keycode
|
|
|
|
|
* @state: a modifier state
|
|
|
|
|
* @group: active keyboard group
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* @keyval: (out) (optional): return location for keyval
|
|
|
|
|
* @effective_group: (out) (optional): return location for effective group
|
|
|
|
|
* @level: (out) (optional): return location for level
|
|
|
|
|
* @consumed: (out) (optional): return location for modifiers that were used
|
|
|
|
|
* to determine the group or level
|
2020-05-28 19:15:53 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* 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.
|
2020-05-28 19:15:53 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* 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.
|
2020-05-28 19:15:53 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* @consumed_modifiers gives modifiers that should be masked out
|
|
|
|
|
* from @state when comparing this key press to a keyboard shortcut.
|
|
|
|
|
* 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.
|
2020-05-28 19:15:53 +00:00
|
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
|
* This function should rarely be needed, since `GdkEventKey` already
|
|
|
|
|
* contains the translated keyval. It is exported for the benefit of
|
|
|
|
|
* virtualized test environments.
|
2020-05-28 19:15:53 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if there was a keyval bound to keycode/state/group.
|
|
|
|
|
*/
|
|
|
|
|
gboolean
|
|
|
|
|
gdk_display_translate_key (GdkDisplay *display,
|
|
|
|
|
guint keycode,
|
|
|
|
|
GdkModifierType state,
|
|
|
|
|
int group,
|
|
|
|
|
guint *keyval,
|
|
|
|
|
int *effective_group,
|
|
|
|
|
int *level,
|
|
|
|
|
GdkModifierType *consumed)
|
|
|
|
|
{
|
|
|
|
|
return gdk_keymap_translate_keyboard_state (gdk_display_get_keymap (display),
|
|
|
|
|
keycode, state, group,
|
|
|
|
|
keyval,
|
|
|
|
|
effective_group,
|
|
|
|
|
level,
|
|
|
|
|
consumed);
|
|
|
|
|
}
|