static gboolean is_modifier(guint keycode)
{
gint i;
gint map_size;
XModifierKeymap* mod_keymap;
gboolean retval = FALSE;
mod_keymap = XGetModifierMapping(gdk_x11_display_get_xdisplay(gdk_display_get_default()));
map_size = 8 * mod_keymap->max_keypermod;
i = 0;
while (i < map_size)
{
if (keycode == mod_keymap->modifiermap[i])
{
retval = TRUE;
break;
}
++i;
}
XFreeModifiermap(mod_keymap);
return retval;
}
void
xfce_randr_reload (XfceRandr *randr)
{
Display *xdisplay;
GdkWindow *root_window;
xfce_randr_cleanup (randr);
/* get the x display */
xdisplay = gdk_x11_display_get_xdisplay (randr->priv->display);
/* get the root window */
root_window = gdk_get_default_root_window ();
/* get the screen resource */
#ifdef HAS_RANDR_ONE_POINT_THREE
/* xfce_randr_reload() is only called after a xrandr notification, which
means that X is aware of the new hardware already. So, if possible,
do not reprobe the hardware again. */
if (randr->priv->has_1_3)
randr->priv->resources = XRRGetScreenResourcesCurrent (xdisplay, GDK_WINDOW_XID (root_window));
else
#endif
randr->priv->resources = XRRGetScreenResources (xdisplay, GDK_WINDOW_XID (root_window));
/* repopulate */
xfce_randr_populate (randr, xdisplay, root_window);
}
static VkResult
gdk_x11_vulkan_context_create_surface (GdkVulkanContext *context,
VkSurfaceKHR *surface)
{
GdkSurface *window = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
/* This is necessary so that Vulkan sees the Window.
* Usually, vkCreateXlibSurfaceKHR() will not cause a problem to happen as
* it just creates resources, but futher calls with the resulting surface
* do cause issues.
*/
gdk_display_sync (display);
return GDK_VK_CHECK (vkCreateXlibSurfaceKHR, gdk_vulkan_context_get_instance (context),
&(VkXlibSurfaceCreateInfoKHR) {
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
NULL,
0,
gdk_x11_display_get_xdisplay (display),
gdk_x11_surface_get_xid (window)
},
NULL,
surface);
}
static void
run_dialog (GdkDisplay *display, GdkScreen *screen, guint32 timestamp)
{
Atom action_atom;
Atom atom;
Window root;
XClientMessageEvent ev;
if (!display)
display = gdk_display_get_default ();
if (!screen)
screen = gdk_display_get_default_screen (display);
root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
action_atom = gdk_x11_get_xatom_by_name_for_display (display, "_MATE_PANEL_ACTION");
atom = gdk_x11_get_xatom_by_name_for_display (display, "_MATE_PANEL_ACTION_RUN_DIALOG");
ev.type = ClientMessage;
ev.window = root;
ev.message_type = action_atom;
ev.format = 32;
ev.data.l[0] = atom;
ev.data.l[1] = timestamp;
gdk_error_trap_push ();
XSendEvent (gdk_x11_display_get_xdisplay (display),
root, False, StructureNotifyMask, (XEvent*) &ev);
gdk_flush ();
gdk_error_trap_pop ();
}
/* Based on a function found in wnck */
static void
set_icon_geometry (GdkWindow *window,
int x,
int y,
int width,
int height)
{
gulong data[4];
Display *dpy;
dpy = gdk_x11_display_get_xdisplay (gdk_window_get_display (window));
data[0] = x;
data[1] = y;
data[2] = width;
data[3] = height;
XChangeProperty (dpy,
GDK_WINDOW_XID (window),
gdk_x11_get_xatom_by_name_for_display (
gdk_window_get_display (window),
"_NET_WM_ICON_GEOMETRY"),
XA_CARDINAL, 32, PropModeReplace,
(guchar *)&data, 4);
}
static void ungrab_mouse()
{
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
XUngrabPointer(dpy, CurrentTime);
#endif
}
bool CStdGLCtx::Select(bool verbose)
{
// safety
if (!pGL || !ctx)
{
if (verbose) pGL->Error(" gl: pGL is zero");
return false;
}
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
// make context current
if (!pWindow->renderwnd || !glXMakeCurrent(dpy, pWindow->renderwnd, (GLXContext)ctx))
{
if (verbose) pGL->Error(" gl: glXMakeCurrent failed");
return false;
}
SelectCommon();
// update clipper - might have been done by UpdateSize
// however, the wrong size might have been assumed
if (!pGL->UpdateClipper())
{
if (verbose) pGL->Error(" gl: UpdateClipper failed");
return false;
}
// success
return true;
}
int XttHotkey::grab_key( int keysym, int modifier)
{
GdkDisplay *display = gdk_display_get_default();
int n_screens = gdk_display_get_n_screens( display);
Display *dp = gdk_x11_display_get_xdisplay( display);
int mode = GrabModeAsync;
int keycode = XKeysymToKeycode( dp, keysym);
if ( !keycode)
return 0;
gdk_error_trap_push();
for ( int i = 0; i < n_screens; i++) {
GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i));
Window w = gdk_x11_drawable_get_xid( root);
XGrabKey( dp, keycode, modifier, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode);
XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode);
}
gdk_flush();
gdk_error_trap_pop();
return 1;
}
bool C4AbstractApp::Init(int argc, char * argv[])
{
// Set locale
setlocale(LC_ALL,"");
gtk_init(&argc, &argv);
GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/org/openclonk/engine/oc.ico", NULL);
gtk_window_set_default_icon(icon);
g_object_unref(icon);
// Try to figure out the location of the executable
Priv->argc=argc; Priv->argv=argv;
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
int xrandr_error_base;
if (!XRRQueryExtension(dpy, &Priv->xrandr_event, &xrandr_error_base)
|| !XRRQueryVersion(dpy, &Priv->xrandr_major_version, &Priv->xrandr_minor_version))
{
Priv->xrandr_major_version = -1;
Priv->xrandr_minor_version = 0;
}
if (Priv->xrandr_major_version >= 0)
{
XRRSelectInput(dpy, DefaultRootWindow(dpy), RRScreenChangeNotifyMask);
}
else
Log("The Xrandr extension is missing. Resolution switching will not work.");
#endif
// Custom initialization
return DoInit (argc, argv);
}
void C4Window::EnumerateMultiSamples(std::vector<int>& samples) const
{
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
std::map<int, int> attribs = base_attrib_map;
attribs[GLX_SAMPLE_BUFFERS_ARB] = 1;
int config_count = 0;
GLXFBConfig *configs = glXChooseFBConfig(dpy, DefaultScreen(dpy), MakeGLXAttribList(attribs).get(), &config_count);
std::set<int> multisamples;
for(int i = 0; i < config_count; ++i)
{
int v_samples;
glXGetFBConfigAttrib(dpy, configs[i], GLX_SAMPLES, &v_samples);
multisamples.insert(v_samples);
}
XFree(configs);
samples.assign(multisamples.cbegin(), multisamples.cend());
#else
if(pGL && pGL->pMainCtx)
samples = pGL->pMainCtx->EnumerateMultiSamples();
#endif
}
static void
init_display (GdkDisplay *dpy,
XfceRc *rc,
gboolean disable_tcp)
{
const gchar *engine;
gint n;
xfce_rc_set_group (rc, "Splash Screen");
engine = xfce_rc_read_entry (rc, "Engine", NULL);
splash_screen = xfsm_splash_screen_new (dpy, engine);
xfsm_splash_screen_next (splash_screen, _("Loading desktop settings"));
gdk_flush ();
xfce_rc_set_group (rc, "General");
sm_init (rc, disable_tcp);
/* start a MCS manager process per screen (FIXME: parallel to loading logo) */
for (n = 0; n < gdk_display_get_n_screens (dpy); ++n)
{
mcs_client_check_manager (gdk_x11_display_get_xdisplay (dpy), n,
"xfce-mcs-manager");
}
/* gtk resource files may have changed */
gtk_rc_reparse_all ();
}
static gboolean on_screensaver_suppression_timer(gpointer unused) {
// The XScreenSaverSuspend method doesn't work with gnome-screensaver, so
// instead we synthesize a mouse mouse event (but with offset of 0x0, so it
// doesn't actually move).
Display *display = gdk_x11_display_get_xdisplay(gdk_display_get_default());
assert(display);
XWarpPointer(display, None, None, 0, 0, 0, 0, 0, 0);
return TRUE;
}
bool CStdGLCtx::PageFlip()
{
// flush GL buffer
glFlush();
if (!pWindow || !pWindow->renderwnd) return false;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXSwapBuffers(dpy, pWindow->renderwnd);
return true;
}
static GdkPixbuf *
remove_shaped_area (GdkPixbuf *pixbuf,
Window window)
{
Display *display;
GdkPixbuf *retval;
XRectangle *rectangles;
gint rectangle_count, rectangle_order;
gint i;
retval = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
gdk_pixbuf_fill (retval, 0);
display = gdk_x11_display_get_xdisplay (gdk_display_get_default ());
rectangles = XShapeGetRectangles (display, window, ShapeBounding,
&rectangle_count, &rectangle_order);
for (i = 0; i < rectangle_count; i++)
{
int y, x;
for (y = rectangles[i].y;
y < rectangles[i].y + rectangles[i].height;
y++)
{
const guchar *src_pixels;
guchar *dest_pixels;
src_pixels = gdk_pixbuf_get_pixels (pixbuf) +
y * gdk_pixbuf_get_rowstride (pixbuf) +
rectangles[i].x * (gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3);
dest_pixels = gdk_pixbuf_get_pixels (retval) +
y * gdk_pixbuf_get_rowstride (retval) +
rectangles[i].x * 4;
for (x = rectangles[i].x;
x < rectangles[i].x + rectangles[i].width;
x++)
{
*dest_pixels++ = *src_pixels ++;
*dest_pixels++ = *src_pixels ++;
*dest_pixels++ = *src_pixels ++;
*dest_pixels++ = 255;
if (gdk_pixbuf_get_has_alpha (pixbuf))
src_pixels++;
}
}
}
return retval;
}
static gboolean check_for_xwin(GdkDisplay *dpy)
{
char *vendor = ServerVendor(gdk_x11_display_get_xdisplay(dpy));
if (strstr(vendor, "Cygwin/X"))
return TRUE;
return FALSE;
}
void CStdGLCtx::Deselect()
{
if (pGL && pGL->pCurrCtx == this)
{
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXMakeCurrent(dpy, None, NULL);
pGL->pCurrCtx = 0;
pGL->RenderTarget = 0;
}
}
static gboolean
_vte_gl_check(struct _vte_draw *draw, GtkWidget *widget)
{
int attributes[] = {_vte_gl_attributes};
XVisualInfo *visual_info;
GLXContext context = NULL;
GdkDisplay *gdisplay;
Display *display;
GdkScreen *gscreen;
int screen;
int error, event;
gboolean direct;
gdisplay = gtk_widget_get_display (widget);
display = gdk_x11_display_get_xdisplay (gdisplay);
gscreen = gtk_widget_get_screen (widget);
screen = gdk_x11_screen_get_screen_number (gscreen);
/* Check for GLX. */
if (!glXQueryExtension(display, &error, &event)) {
#ifdef VTE_DEBUG
g_warning("Unable to use GLX.\n");
#endif
return FALSE;
}
/* See if a suitable visual exists. */
visual_info = glXChooseVisual(display, screen, attributes);
if (visual_info == NULL) {
#ifdef VTE_DEBUG
g_warning("Unable to find a suitable GLX visual.\n");
#endif
return FALSE;
}
/* Create a GLX context. */
context = glXCreateContext(display, visual_info, NULL, GL_TRUE);
if (context == NULL) {
#ifdef VTE_DEBUG
g_warning("Unable to create a GLX context.\n");
#endif
return FALSE;
}
/* Check if it's a direct rendering context. */
direct = glXIsDirect(display, context);
#ifdef VTE_DEBUG
if (!direct) {
g_warning("Unable to create a direct GLX context.\n");
}
#endif
glXDestroyContext(display, context);
return (direct == True) ? TRUE : FALSE;
}
void gtk_egl_init(DisplayGLMode mode)
{
GdkDisplay *gdk_display = gdk_display_get_default();
Display *x11_display = gdk_x11_display_get_xdisplay(gdk_display);
if (qemu_egl_init_dpy_x11(x11_display, mode) < 0) {
return;
}
display_opengl = 1;
}
bool C4Window::ReInit(C4AbstractApp* pApp)
{
// Check whether multisampling settings was changed. If not then we
// don't need to ReInit anything.
#ifdef GDK_WINDOWING_X11
int value;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXGetFBConfigAttrib(dpy, Info, GLX_SAMPLES, &value);
if(value == Config.Graphics.MultiSampling) return true;
// Check whether we have a visual with the requested number of samples
GLXFBConfig new_info;
if(!FindFBConfig(Config.Graphics.MultiSampling, &new_info)) return false;
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, new_info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
// Un- and re-realizing the render_widget does not work, the window
// remains hidden afterwards. So we re-create it from scratch.
gtk_widget_destroy(GTK_WIDGET(render_widget));
render_widget = gtk_drawing_area_new();
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
g_object_set(G_OBJECT(render_widget), "can-focus", TRUE, NULL);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
Info = new_info;
// Wait until window is mapped to get the window's XID
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
gtk_widget_show_now(GTK_WIDGET(render_widget));
if (GTK_IS_LAYOUT(render_widget))
{
GdkWindow* bin_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
renderwnd = GDK_WINDOW_XID(bin_wnd);
}
else
{
GdkWindow* render_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
renderwnd = GDK_WINDOW_XID(render_wnd);
}
gdk_flush();
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return true;
#endif
}
void gtk_egl_init(void)
{
GdkDisplay *gdk_display = gdk_display_get_default();
Display *x11_display = gdk_x11_display_get_xdisplay(gdk_display);
if (qemu_egl_init_dpy(x11_display, false, false) < 0) {
return;
}
display_opengl = 1;
}
S9xXVDisplayDriver::S9xXVDisplayDriver (Snes9xWindow *window,
Snes9xConfig *config)
{
this->window = window;
this->config = config;
this->drawing_area = GTK_WIDGET (window->drawing_area);
display =
gdk_x11_display_get_xdisplay (gtk_widget_get_display (drawing_area));
last_known_width = last_known_height = -1;
return;
}
bool C4Window::FindFBConfig(int samples, GLXFBConfig *info)
{
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
GLXFBConfig config = PickGLXFBConfig(dpy, samples);
if (info)
{
*info = config;
}
return config != NULL;
return false;
}
void gTrayIcon::setVisible(bool vl)
{
if (vl)
{
if (!plug)
{
_loopLevel = gApplication::loopLevel() + 1;
plug = gtk_status_icon_new();
updatePicture();
updateTooltip();
#ifdef GDK_WINDOWING_X11
// Needed, otherwise the icon does not appear in Gnome or XFCE notification area!
XSizeHints hints;
hints.flags = PMinSize;
hints.min_width = _iconw;
hints.min_height = _iconh;
XSetWMNormalHints(gdk_x11_display_get_xdisplay(gdk_display_get_default()), gtk_status_icon_get_x11_window_id(plug), &hints);
#endif
gtk_status_icon_set_visible(plug, TRUE);
//g_signal_connect(G_OBJECT(plug), "destroy", G_CALLBACK(cb_destroy),(gpointer)this);
g_signal_connect(G_OBJECT(plug), "button-press-event", G_CALLBACK(cb_button_press), (gpointer)this);
g_signal_connect(G_OBJECT(plug), "button-release-event", G_CALLBACK(cb_button_release),(gpointer)this);
//g_signal_connect(G_OBJECT(plug), "activate", G_CALLBACK(cb_activate),(gpointer)this);
//g_signal_connect(G_OBJECT(plug),"focus-in-event",G_CALLBACK(tray_focus_In),(gpointer)this);
//g_signal_connect(G_OBJECT(plug),"focus-out-event",G_CALLBACK(tray_focus_Out),(gpointer)this);
//g_signal_connect(G_OBJECT(plug),"enter-notify-event",G_CALLBACK(tray_enterleave),(gpointer)this);
//g_signal_connect(G_OBJECT(plug),"leave-notify-event",G_CALLBACK(tray_enterleave),(gpointer)this);
g_signal_connect(G_OBJECT(plug), "popup-menu", G_CALLBACK(cb_menu), (gpointer)this);
g_signal_connect(G_OBJECT(plug), "scroll-event", G_CALLBACK(cb_scroll), (gpointer)this);
//g_signal_connect(G_OBJECT(plug),"expose-event", G_CALLBACK(cb_expose), (gpointer)this);
_visible_count++;
usleep(10000); // BUG: Embedding too fast sometimes fails with GTK+
}
}
else
{
if (plug)
{
GB.Post((void (*)())hide_icon, (intptr_t)plug);
plug = NULL;
_visible_count--;
}
}
}
static bool grab_mouse(GtkWidget *widget)
{
// This should be possible with pure GTK code as well, using
// gdk_device_grab(). However, while gdk_device_grab() will prevent clicks
// outside of the game window, the mouse gets stuck near the edge of the
// window when trying to move outside.
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(widget));
int result = XGrabPointer(dpy, xwindow, true, 0, GrabModeAsync, GrabModeAsync, xwindow, None, CurrentTime);
return result == GrabSuccess;
#endif
return true;
}
XfceRandr *
xfce_randr_new (GdkDisplay *display,
GError **error)
{
XfceRandr *randr;
Display *xdisplay;
GdkWindow *root_window;
gint major, minor;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
/* get the x display */
xdisplay = gdk_x11_display_get_xdisplay (display);
/* check if the randr extension is available */
if (XRRQueryVersion (xdisplay, &major, &minor) == FALSE)
{
g_set_error (error, 0, 0, _("Unable to query the version of the RandR extension being used"));
return NULL;
}
/* we need atleast randr 1.2, 2.0 will probably break the api */
if (major < 1 || (major == 1 && minor < 2))
{
/* 1.2 is required */
g_set_error (error, 0, 0, _("This system is using RandR %d.%d. For the display settings to work "
"version 1.2 is required at least"), major, minor);
return NULL;
}
/* allocate the structure */
randr = g_slice_new0 (XfceRandr);
randr->priv = g_slice_new0 (XfceRandrPrivate);
randr->priv->has_1_3 = (major > 1 || (major == 1 && minor >= 3));
/* set display */
randr->priv->display = display;
/* get the root window */
root_window = gdk_get_default_root_window ();
/* get the screen resource */
randr->priv->resources = XRRGetScreenResources (xdisplay, GDK_WINDOW_XID (root_window));
xfce_randr_populate (randr, xdisplay, root_window);
return randr;
}
/**
* cs_screen_get_mouse_monitor:
* @screen: a #CsScreen
*
* Gets the index of the monitor that the mouse pointer currently
* occupies.
*
* Return value: the monitor index for the pointer
*/
gint
cs_screen_get_mouse_monitor (CsScreen *screen)
{
GdkDisplay *gdk_display;
Window xroot, root_return, child_return;
int root_x_return, root_y_return;
int win_x_return, win_y_return;
unsigned int mask_return;
gint scale_factor;
gint i;
gint ret = 0;
g_return_val_if_fail (CS_IS_SCREEN (screen), 0);
gdk_display = gdk_screen_get_display (screen->gdk_screen);
xroot = gdk_x11_window_get_xid (gdk_screen_get_root_window (screen->gdk_screen));
gdk_error_trap_push ();
XQueryPointer (gdk_x11_display_get_xdisplay (gdk_display),
xroot,
&root_return,
&child_return,
&root_x_return,
&root_y_return,
&win_x_return,
&win_y_return,
&mask_return);
gdk_error_trap_pop_ignored ();
scale_factor = gdk_screen_get_monitor_scale_factor (screen->gdk_screen, 0);
root_x_return /= scale_factor;
root_y_return /= scale_factor;
for (i = 0; i < screen->n_monitor_infos; i++)
{
GdkRectangle iter = screen->monitor_infos[i].rect;
if (root_x_return >= iter.x && root_x_return <= iter.x + iter.width &&
root_y_return >= iter.y && root_y_return <= iter.y + iter.height)
{
ret = i;
break;
}
}
return ret;
}
x11_hotkeys::x11_hotkeys(GtkWindow *win_) :
win(win_),
pressed(false),
def_hot_keys(new gtk_hotkeys(win_))
{
possb_combs=def_hot_keys->possible_combs();
possb_combs.push_back("Ctrl+e");
possb_combs.push_back("F1");
possb_combs.push_back("F2");
possb_combs.push_back("F3");
possb_combs.push_back("F4");
display=gdk_x11_display_get_xdisplay(gdk_screen_get_display(gtk_window_get_screen(win)));
get_offending_modifiers(display);
gdk_window_add_filter(NULL, GdkFilterFunc(key_filter), this);
}
static void *GLAPIENTRY glMPGetNativeDisplay(const gchar *name)
{
GdkDisplay *display = gdk_display_get_default();
#ifdef GDK_WINDOWING_WAYLAND
if(GDK_IS_WAYLAND_DISPLAY(display) && g_strcmp0(name, "wl") == 0)
return gdk_wayland_display_get_wl_display(display);
#endif
#ifdef GDK_WINDOWING_X11
if(GDK_IS_X11_DISPLAY(display) && g_strcmp0(name, "x11") == 0)
return gdk_x11_display_get_xdisplay(display);
#endif
return NULL;
}
static XKeyPressedEvent convert_event(GdkEventKey *event) {
XKeyPressedEvent result;
memset(&result, 0, sizeof (result));
result.type = (event->type == GDK_KEY_PRESS) ? KeyPress : KeyRelease;
result.send_event = event->send_event;
result.display = gdk_x11_display_get_xdisplay(glass_gdk_window_get_display(event->window));
result.window = result.subwindow = GDK_WINDOW_XID(event->window);
result.root = GDK_WINDOW_XID(gdk_screen_get_root_window(glass_gdk_window_get_screen(event->window)));
result.time = event->time;
result.state = event->state;
result.keycode = event->hardware_keycode;
result.same_screen = True;
return result;
}
bool C4AbstractApp::GetIndexedDisplayMode(int32_t iIndex, int32_t *piXRes, int32_t *piYRes, int32_t *piBitDepth, int32_t *piRefreshRate, uint32_t iMonitor)
{
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
int n;
XRRScreenSize * sizes = XRRSizes(dpy, XDefaultScreen(dpy), &n);
if (iIndex < n && iIndex >= 0)
{
*piXRes = sizes[iIndex].width;
*piYRes = sizes[iIndex].height;
*piBitDepth = 32;
return true;
}
return false;
#endif
}
