gboolean supports_xinput2_devices (int *opcode) { int major, minor; if (supports_xinput_devices_with_opcode (opcode) == FALSE) return FALSE; gdk_error_trap_push (); major = 2; minor = 0; if (XIQueryVersion (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &major, &minor) != Success) { gdk_error_trap_pop_ignored (); /* try for 2.2, maybe gtk has already announced 2.2 support */ gdk_error_trap_push (); major = 2; minor = 2; if (XIQueryVersion (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &major, &minor) != Success) { gdk_error_trap_pop_ignored (); return FALSE; } } gdk_error_trap_pop_ignored (); if ((major * 1000 + minor) < (2000)) return FALSE; return TRUE; }
gint main (gint argc, gchar *argv[]) { GdkDisplay *extra_display; gtk_init (&argc, &argv); test_error_trapping (gdk_display_get_default ()); extra_display = gdk_display_open (NULL); test_error_trapping (extra_display); gdk_display_close (extra_display); test_error_trapping (gdk_display_get_default ()); /* open a display with a trap pushed and see if we * get confused */ gdk_error_trap_push (); gdk_error_trap_push (); extra_display = gdk_display_open (NULL); test_error_trapping (extra_display); gdk_display_close (extra_display); gdk_error_trap_pop_ignored (); gdk_error_trap_pop_ignored (); test_error_trapping (gdk_display_get_default ()); /* reassure us that the tests ran. */ g_print("All errors properly trapped.\n"); return 0; }
gboolean device_is_touchpad (XDevice *xdevice) { Atom realtype, prop; int realformat; unsigned long nitems, bytes_after; unsigned char *data; /* we don't check on the type being XI_TOUCHPAD here, * but having a "Synaptics Off" property should be enough */ prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Off", False); if (!prop) return FALSE; gdk_error_trap_push (); if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, 0, 1, False, XA_INTEGER, &realtype, &realformat, &nitems, &bytes_after, &data) == Success) && (realtype != None)) { gdk_error_trap_pop_ignored (); XFree (data); return TRUE; } gdk_error_trap_pop_ignored (); return FALSE; }
static void kill_window (WnckWindow *win) { WnckApplication *app; app = wnck_window_get_application (win); if (app) { gchar buf[257], *client_machine; int pid; pid = wnck_application_get_pid (app); client_machine = get_client_machine (wnck_application_get_xid (app)); if (client_machine && pid > 0) { if (gethostname (buf, sizeof (buf) - 1) == 0) { if (strcmp (buf, client_machine) == 0) kill (pid, 9); } } if (client_machine) g_free (client_machine); } gdk_error_trap_push (); XKillClient (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), wnck_window_get_xid (win)); gdk_display_sync (gdk_display_get_default ()); gdk_error_trap_pop_ignored (); }
static gboolean is_shift_pressed (void) { gboolean ret; XkbStateRec state; Bool status; ret = FALSE; gdk_error_trap_push (); status = XkbGetState (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), XkbUseCoreKbd, &state); #if GTK_CHECK_VERSION(3,0,0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif if (status == Success) { ret = state.mods & ShiftMask; } return ret; }
/** * g_paste_keybinding_activate: * @self: a #GPasteKeybinding instance * * Activate the keybinding * * Returns: */ G_PASTE_VISIBLE void g_paste_keybinding_activate (GPasteKeybinding *self) { g_return_if_fail (G_PASTE_IS_KEYBINDING (self)); GPasteKeybindingPrivate *priv = self->priv; g_return_if_fail (!priv->active); GPasteXcbWrapper *xcb_wrapper = priv->xcb_wrapper; xcb_connection_t *connection = (xcb_connection_t *) g_paste_xcb_wrapper_get_connection (xcb_wrapper); xcb_screen_t *screen = (xcb_screen_t *) g_paste_xcb_wrapper_get_screen (xcb_wrapper); guint keysym; g_return_if_fail (screen); /* This should never happen */ gtk_accelerator_parse (priv->binding, &keysym, (GdkModifierType *) &priv->modifiers); priv->keycodes = xcb_key_symbols_get_keycode ((xcb_key_symbols_t *) g_paste_xcb_wrapper_get_keysyms (xcb_wrapper), keysym); gdk_error_trap_push (); for (xcb_keycode_t *keycode = priv->keycodes; *keycode; ++keycode) { xcb_grab_key (connection, FALSE, screen->root, priv->modifiers, *keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } xcb_flush (connection); gdk_error_trap_pop_ignored (); priv->active = TRUE; }
static void avatar_image_add_filter (EmpathyAvatarImage *avatar_image) { Display *display; Window window; gint mask; XWindowAttributes attrs; if (!running_in_x11 ()) return; mask = PropertyChangeMask; window = gdk_x11_get_default_root_xwindow (); display = gdk_x11_get_default_xdisplay (); gdk_error_trap_push (); XGetWindowAttributes (display, window, &attrs); mask |= attrs.your_event_mask; XSelectInput (display, window, mask); gdk_error_trap_pop_ignored (); gdk_window_add_filter (NULL, avatar_image_filter_func, avatar_image); }
/* Most of the workspace manipulation code has been copied from libwnck * Copyright (C) 2001 Havoc Pennington * Copyright (C) 2005-2007 Vincent Untz */ static void _wnck_activate_workspace (Screen *screen, int new_active_space, Time timestamp) { Display *display; Window root; XEvent xev; display = DisplayOfScreen (screen); root = RootWindowOfScreen (screen); xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.display = display; xev.xclient.window = root; xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_CURRENT_DESKTOP"); xev.xclient.format = 32; xev.xclient.data.l[0] = new_active_space; xev.xclient.data.l[1] = timestamp; xev.xclient.data.l[2] = 0; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; gdk_error_trap_push (); XSendEvent (display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); XSync (display, False); gdk_error_trap_pop_ignored (); }
int xdevice_get_last_tool_id (int deviceid) { Atom prop; Atom act_type; int act_format; unsigned long nitems, bytes_after; unsigned char *data, *ptr; int id; id = 0x0; gdk_display_sync (gdk_display_get_default ()); prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), WACOM_SERIAL_IDS_PROP, False); if (!prop) return id; gdk_error_trap_push (); if (!XIGetProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), deviceid, prop, 0, 1000, False, AnyPropertyType, &act_type, &act_format, &nitems, &bytes_after, &data) == Success) { gdk_error_trap_pop_ignored (); return 0x0; } if (gdk_error_trap_pop ()) goto out; if (nitems != 4) goto out; if (act_type != XA_INTEGER) goto out; if (act_format != 32) goto out; /* item 0 = tablet ID * item 1 = old device serial number (== last tool in proximity) * item 2 = old hardware serial number (including tool ID) * item 3 = current serial number (0 if no tool in proximity) */ ptr = data; ptr += act_format/8 * 2; id = *((int32_t*)ptr); id = id & 0xfffff; /* That means that no tool was set down yet */ if (id == STYLUS_DEVICE_ID || id == ERASER_DEVICE_ID) return 0x0; out: XFree (data); return id; }
void grab_button (int deviceid, gboolean grab, GdkScreen *screen) { GdkWindow *root; XIGrabModifiers mods; root = gdk_screen_get_root_window (screen); mods.modifiers = XIAnyModifier; if (grab) { XIEventMask evmask; unsigned char mask[(XI_LASTEVENT + 7)/8]; memset (mask, 0, sizeof (mask)); XISetMask (mask, XI_ButtonRelease); XISetMask (mask, XI_ButtonPress); evmask.deviceid = deviceid; evmask.mask_len = sizeof (mask); evmask.mask = mask; gdk_error_trap_push(); XIGrabButton (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), deviceid, XIAnyButton, GDK_WINDOW_XID (root), None, GrabModeAsync, GrabModeAsync, False, &evmask, 1, &mods); gdk_error_trap_pop_ignored (); } else { gdk_error_trap_push(); XIUngrabButton (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), deviceid, XIAnyButton, GDK_WINDOW_XID (root), 1, &mods); gdk_error_trap_pop_ignored (); } }
void panel_xutils_set_strut (GdkWindow *gdk_window, PanelOrientation orientation, guint32 strut, guint32 strut_start, guint32 strut_end) { Display *display; Window window; gulong struts [12] = { 0, }; g_return_if_fail (GDK_IS_WINDOW (gdk_window)); display = GDK_WINDOW_XDISPLAY (gdk_window); window = GDK_WINDOW_XID (gdk_window); if (net_wm_strut == None) net_wm_strut = XInternAtom (display, "_NET_WM_STRUT", False); if (net_wm_strut_partial == None) net_wm_strut_partial = XInternAtom (display, "_NET_WM_STRUT_PARTIAL", False); switch (orientation) { case PANEL_ORIENTATION_LEFT: struts [STRUT_LEFT] = strut; struts [STRUT_LEFT_START] = strut_start; struts [STRUT_LEFT_END] = strut_end; break; case PANEL_ORIENTATION_RIGHT: struts [STRUT_RIGHT] = strut; struts [STRUT_RIGHT_START] = strut_start; struts [STRUT_RIGHT_END] = strut_end; break; case PANEL_ORIENTATION_TOP: struts [STRUT_TOP] = strut; struts [STRUT_TOP_START] = strut_start; struts [STRUT_TOP_END] = strut_end; break; case PANEL_ORIENTATION_BOTTOM: struts [STRUT_BOTTOM] = strut; struts [STRUT_BOTTOM_START] = strut_start; struts [STRUT_BOTTOM_END] = strut_end; break; } gdk_error_trap_push (); XChangeProperty (display, window, net_wm_strut, XA_CARDINAL, 32, PropModeReplace, (guchar *) &struts, 4); XChangeProperty (display, window, net_wm_strut_partial, XA_CARDINAL, 32, PropModeReplace, (guchar *) &struts, 12); #if GTK_CHECK_VERSION (3, 0, 0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif }
gboolean device_set_property (XDevice *xdevice, const char *device_name, PropertyHelper *property) { int rc, i; Atom prop; Atom realtype; int realformat; unsigned long nitems, bytes_after; unsigned char *data; prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), property->name, False); if (!prop) return FALSE; gdk_error_trap_push (); rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, 0, property->nitems, False, AnyPropertyType, &realtype, &realformat, &nitems, &bytes_after, &data); if (rc != Success || realtype != property->type || realformat != property->format || nitems < property->nitems) { gdk_error_trap_pop_ignored (); g_warning ("Error reading property \"%s\" for \"%s\"", property->name, device_name); return FALSE; } for (i = 0; i < nitems; i++) { switch (property->format) { case 8: data[i] = property->data.c[i]; break; case 32: ((long*)data)[i] = property->data.i[i]; break; } } XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, realtype, realformat, PropModeReplace, data, nitems); XFree (data); if (gdk_error_trap_pop ()) { g_warning ("Error in setting \"%s\" for \"%s\"", property->name, device_name); return FALSE; } return TRUE; }
/* If we are faking transparency with a window-relative background, force a * redraw of the icon. This should be called if the background changes or if * the child is shifted with respect to the background. */ void na_tray_child_force_redraw (NaTrayChild *child) { GtkWidget *widget = GTK_WIDGET (child); if (gtk_widget_get_mapped (widget) && child->parent_relative_bg) { #if 1 /* Sending an ExposeEvent might cause redraw problems if the * icon is expecting the server to clear-to-background before * the redraw. It should be ok for GtkStatusIcon or EggTrayIcon. */ Display *xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)); XEvent xev; GdkWindow *plug_window; GtkAllocation allocation; plug_window = gtk_socket_get_plug_window (GTK_SOCKET (child)); gtk_widget_get_allocation (widget, &allocation); xev.xexpose.type = Expose; #if GTK_CHECK_VERSION (3, 0, 0) xev.xexpose.window = GDK_WINDOW_XID (plug_window); #else xev.xexpose.window = GDK_WINDOW_XWINDOW (plug_window); #endif xev.xexpose.x = 0; xev.xexpose.y = 0; xev.xexpose.width = allocation.width; xev.xexpose.height = allocation.height; xev.xexpose.count = 0; gdk_error_trap_push (); XSendEvent (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)), xev.xexpose.window, False, ExposureMask, &xev); /* We have to sync to reliably catch errors from the XSendEvent(), * since that is asynchronous. */ XSync (xdisplay, False); #if GTK_CHECK_VERSION (3, 0, 0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif #else /* Hiding and showing is the safe way to do it, but can result in more * flickering. */ gdk_window_hide (widget->window); gdk_window_show (widget->window); #endif } }
GtkWidget * na_tray_child_new (GdkScreen *screen, Window icon_window) { XWindowAttributes window_attributes; Display *xdisplay; NaTrayChild *child; GdkVisual *visual; gboolean visual_has_alpha; int red_prec, green_prec, blue_prec, depth; int result; g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); g_return_val_if_fail (icon_window != None, NULL); xdisplay = GDK_SCREEN_XDISPLAY (screen); /* We need to determine the visual of the window we are embedding and create * the socket in the same visual. */ gdk_error_trap_push (); result = XGetWindowAttributes (xdisplay, icon_window, &window_attributes); gdk_error_trap_pop_ignored (); if (!result) /* Window already gone */ return NULL; visual = gdk_x11_screen_lookup_visual (screen, window_attributes.visual->visualid); if (!visual) /* Icon window is on another screen? */ return NULL; child = g_object_new (NA_TYPE_TRAY_CHILD, NULL); child->icon_window = icon_window; gtk_widget_set_visual (GTK_WIDGET (child), visual); /* We have alpha if the visual has something other than red, green, * and blue */ gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec); gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec); gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec); depth = gdk_visual_get_depth (visual); visual_has_alpha = red_prec + blue_prec + green_prec < depth; child->has_alpha = (visual_has_alpha && gdk_display_supports_composite (gdk_screen_get_display (screen))); child->composited = child->has_alpha; return GTK_WIDGET (child); }
static void force_quit_dialog_realize (GtkWidget *dialog, void *data) { WnckWindow *win = data; gdk_error_trap_push (); XSetTransientForHint (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), GDK_WINDOW_XID (gtk_widget_get_window (dialog)), wnck_window_get_xid (win)); gdk_display_sync (gdk_display_get_default ()); gdk_error_trap_pop_ignored (); }
void decor_update_switcher_property (decor_t *d) { long *data; Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); gint nQuad; decor_quad_t quads[N_QUADS_MAX]; unsigned int nOffset = 1; unsigned int frame_type = populate_frame_type (d); unsigned int frame_state = populate_frame_state (d); unsigned int frame_actions = populate_frame_actions (d); GtkStyleContext *context; GdkRGBA fg; long fgColor[4]; nQuad = decor_set_lSrStSbX_window_quads (quads, &d->frame->window_context_active, &d->border_layout, d->border_layout.top.x2 - d->border_layout.top.x1 - d->frame->window_context_active.extents.left - d->frame->window_context_active.extents.right - 32); data = decor_alloc_property (nOffset, WINDOW_DECORATION_TYPE_PIXMAP); decor_quads_to_property (data, nOffset - 1, cairo_xlib_surface_get_drawable (d->surface), &d->frame->win_extents, &d->frame->win_extents, &d->frame->win_extents, &d->frame->win_extents, 0, 0, quads, nQuad, frame_type, frame_state, frame_actions); context = gtk_widget_get_style_context (d->frame->style_window_rgba); gtk_style_context_get_color (context, GTK_STATE_FLAG_NORMAL, &fg); fgColor[0] = fg.red; fgColor[1] = fg.green; fgColor[2] = fg.blue; fgColor[3] = SWITCHER_ALPHA; gdk_error_trap_push (); XChangeProperty (xdisplay, d->prop_xid, win_decor_atom, XA_INTEGER, 32, PropModeReplace, (guchar *) data, PROP_HEADER_SIZE + BASE_PROP_SIZE + QUAD_PROP_SIZE * N_QUADS_MAX); XChangeProperty (xdisplay, d->prop_xid, switcher_fg_atom, XA_INTEGER, 32, PropModeReplace, (guchar *) fgColor, 4); gdk_display_sync (gdk_display_get_default ()); gdk_error_trap_pop_ignored (); free (data); }
gboolean dnd_is_xscreensaver_active () { GdkDisplay *display = gdk_display_get_default (); Atom XA_BLANK = gdk_x11_get_xatom_by_name_for_display(display, "BLANK"); Atom XA_LOCK = gdk_x11_get_xatom_by_name_for_display(display, "BLANK"); Atom XA_SCREENSAVER_STATUS = gdk_x11_get_xatom_by_name_for_display(display, "_SCREENSAVER_STATUS"); gboolean active = FALSE; Atom type; int format; int status; unsigned long nitems, bytesafter; unsigned char* data = NULL; Display *dpy = gdk_x11_get_default_xdisplay (); Window win = gdk_x11_get_default_root_xwindow (); gdk_error_trap_push (); status = XGetWindowProperty (dpy, win, XA_SCREENSAVER_STATUS, 0, 999, False, XA_INTEGER, &type, &format, &nitems, &bytesafter, (unsigned char **) &data); gdk_flush (); gdk_error_trap_pop_ignored (); if (status == Success && type == XA_INTEGER && nitems >= 3 && data != NULL) { CARD32* tmp_data = (CARD32*) data; active = (tmp_data[0] == XA_BLANK || tmp_data[0] == XA_LOCK) && ((time_t)tmp_data[1] > (time_t)666000000L); g_debug ("Screensaver is currently active"); } if (data != NULL) free (data); return active; }
/** * 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; }
void cs_screen_nuke_focus (void) { Window focus = 0; int rev = 0; DEBUG ("Nuking focus\n"); gdk_error_trap_push (); XGetInputFocus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &focus, &rev); XSetInputFocus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), PointerRoot, RevertToNone, CurrentTime); gdk_error_trap_pop_ignored (); }
void set_desktop_background(GdkWindow *window) { Pixmap xpm = get_pixmap_prop(GDK_WINDOW_XWINDOW(window), "_XROOTPMAP_ID"); #ifdef HAVE_GTK3 if (xpm != None) { GdkScreen *screen = gdk_window_get_screen(window); Window root_return; int x, y; unsigned int width, height, bw, depth_ret; cairo_surface_t *surface = NULL; gdk_error_trap_push(); if (XGetGeometry(GDK_SCREEN_XDISPLAY(screen), xpm, &root_return, &x, &y, &width, &height, &bw, &depth_ret)) { surface = cairo_xlib_surface_create(GDK_SCREEN_XDISPLAY (screen), xpm, GDK_VISUAL_XVISUAL(gdk_screen_get_system_visual(screen)), width, height); } gdk_error_trap_pop_ignored (); cairo_pattern_t *pattern = cairo_pattern_create_for_surface(surface); gdk_window_set_background_pattern(window, pattern); cairo_surface_destroy(surface); // cairo_pattern_destroy ??? } else { GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 }; gdk_window_set_background_rgba(window, &black); } #else if (xpm != None) { GDKPIXMAP *gpm = gdk_pixmap_foreign_new(xpm); gdk_window_set_back_pixmap (window, gpm, FALSE); g_object_unref (gpm); } #endif }
static void synaptics_check_capabilities (GtkBuilder *dialog) { int numdevices, i; XDeviceInfo *devicelist; Atom realtype, prop; int realformat; unsigned long nitems, bytes_after; unsigned char *data; prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Capabilities", True); if (!prop) return; devicelist = XListInputDevices (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &numdevices); for (i = 0; i < numdevices; i++) { if (devicelist[i].use != IsXExtensionPointer) continue; gdk_error_trap_push (); XDevice *device = XOpenDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), devicelist[i].id); if (gdk_error_trap_pop ()) continue; gdk_error_trap_push (); if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device, prop, 0, 2, False, XA_INTEGER, &realtype, &realformat, &nitems, &bytes_after, &data) == Success) && (realtype != None)) { /* Property data is booleans for has_left, has_middle, has_right, has_double, has_triple. * Newer drivers (X.org/kerrnel) will also include has_pressure and has_width. */ if (!data[0]) { gtk_widget_set_sensitive (WID ("tap_to_click_toggle"), FALSE); } /* Disable two finger scrolling unless the hardware supports * double touch */ if (!(data[3])) gtk_widget_set_sensitive (WID ("two_finger_scroll_toggle"), FALSE); XFree (data); } gdk_error_trap_pop_ignored (); XCloseDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device); } XFreeDeviceList (devicelist); }
static void gs_grab_nuke_focus (void) { Window focus = 0; int rev = 0; gs_debug ("Nuking focus"); gdk_error_trap_push (); XGetInputFocus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &focus, &rev); XSetInputFocus (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), None, RevertToNone, CurrentTime); gdk_error_trap_pop_ignored (); }
static void select_popup_events (void) { XWindowAttributes attr; unsigned long events; gdk_error_trap_push (); memset (&attr, 0, sizeof (attr)); XGetWindowAttributes (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), GDK_ROOT_WINDOW (), &attr); events = SubstructureNotifyMask | attr.your_event_mask; XSelectInput (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), GDK_ROOT_WINDOW (), events); gdk_error_trap_pop_ignored (); }
char * xdevice_get_device_node (int deviceid) { Atom prop; Atom act_type; int act_format; unsigned long nitems, bytes_after; unsigned char *data; char *ret; gdk_display_sync (gdk_display_get_default ()); prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Device Node", False); if (!prop) return NULL; gdk_error_trap_push (); if (!XIGetProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), deviceid, prop, 0, 1000, False, AnyPropertyType, &act_type, &act_format, &nitems, &bytes_after, &data) == Success) { gdk_error_trap_pop_ignored (); return NULL; } if (gdk_error_trap_pop ()) goto out; if (nitems == 0) goto out; if (act_type != XA_STRING) goto out; /* Unknown string format */ if (act_format != 8) goto out; ret = g_strdup ((char *) data); XFree (data); return ret; out: XFree (data); return NULL; }
void panel_warp_pointer (GdkWindow *gdk_window, int x, int y) { Display *display; Window window; g_return_if_fail (GDK_IS_WINDOW (gdk_window)); display = GDK_WINDOW_XDISPLAY (gdk_window); window = GDK_WINDOW_XID (gdk_window); gdk_error_trap_push (); XWarpPointer (display, None, window, 0, 0, 0, 0, x, y); gdk_error_trap_pop_ignored (); }
static void msm_compat_gnome_smproxy_shutdown (void) { gdk_error_trap_push (); if (gnome_smproxy_window != None) { XDestroyWindow (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), gnome_smproxy_window); XSync (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), False); gnome_smproxy_window = None; } #if GTK_CHECK_VERSION (3, 0, 0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif }
void BGHash::RefreshColor(bool skip_animation) { if (override_color_.alpha > 0.0f) { TransitionToNewColor(override_color_, skip_animation); return; } // XXX: move this part to PluginAdapter Atom real_type; gint result; gint real_format; gulong items_read; gulong items_left; gchar* colors; Display* display; GdkRGBA color_gdk; colors = nullptr; display = gdk_x11_display_get_xdisplay(gdk_display_get_default()); gdk_error_trap_push(); result = XGetWindowProperty (display, GDK_ROOT_WINDOW(), COLORS_ATOM, 0L, G_MAXLONG, False, XA_STRING, &real_type, &real_format, &items_read, &items_left, (guchar **) &colors); gdk_flush (); gdk_error_trap_pop_ignored (); if (result == Success && items_read) { gdk_rgba_parse(&color_gdk, colors); nux::Color new_color(color_gdk.red, color_gdk.green, color_gdk.blue, 1.0f); TransitionToNewColor(MatchColor(new_color), skip_animation); } XFree(colors); }
void set_strut (GtkWindow *gtk_window, guint32 left_size, guint32 left_start, guint32 left_end, guint32 top_size, guint32 top_start, guint32 top_end) { Display *display; Window window; GdkWindow *gdk_window; gulong struts [12] = { 0, }; g_return_if_fail (GTK_IS_WINDOW (gtk_window)); if (!left_size) return; gdk_window = gtk_widget_get_window (GTK_WIDGET (gtk_window)); display = GDK_WINDOW_XDISPLAY (gdk_window); window = GDK_WINDOW_XID (gdk_window); if (net_wm_strut == None) net_wm_strut = XInternAtom (display, "_NET_WM_STRUT", False); if (net_wm_strut_partial == None) net_wm_strut_partial = XInternAtom (display, "_NET_WM_STRUT_PARTIAL",False); struts [STRUT_LEFT] = left_size; struts [STRUT_LEFT_START] = left_start; struts [STRUT_LEFT_END] = left_end; struts [STRUT_TOP] = top_size; struts [STRUT_TOP_START] = top_start; struts [STRUT_TOP_END] = top_end; gdk_error_trap_push (); XChangeProperty (display, window, net_wm_strut, XA_CARDINAL, 32, PropModeReplace, (guchar *) &struts, 4); XChangeProperty (display, window, net_wm_strut_partial, XA_CARDINAL, 32, PropModeReplace, (guchar *) &struts, 12); gdk_error_trap_pop_ignored (); }
void panel_xutils_set_window_type (GdkWindow *gdk_window, PanelXUtilsWindowType type) { Display *display; Window window; Atom atoms [2]; int i = 0; g_return_if_fail (GDK_IS_WINDOW (gdk_window)); display = GDK_WINDOW_XDISPLAY (gdk_window); window = GDK_WINDOW_XID (gdk_window); if (net_wm_window_type == None) net_wm_window_type = XInternAtom (display, "_NET_WM_WINDOW_TYPE", False); switch (type) { case PANEL_XUTILS_TYPE_DOCK: if (net_wm_window_type_dock == None) net_wm_window_type_dock = XInternAtom (display, "_NET_WM_WINDOW_TYPE_DOCK", False); atoms [i++] = net_wm_window_type_dock; break; case PANEL_XUTILS_TYPE_NORMAL: if (net_wm_window_type_normal == None) net_wm_window_type_normal = XInternAtom (display, "_NET_WM_WINDOW_TYPE_NORMAL", False); atoms [i++] = net_wm_window_type_normal; break; default: g_assert_not_reached (); break; } gdk_error_trap_push (); XChangeProperty (display, window, net_wm_window_type, XA_ATOM, 32, PropModeReplace, (guchar *) &atoms, i); gdk_error_trap_pop_ignored (); }
static void kill_window_response (GtkDialog *dialog, gint response_id, gpointer user_data) { if (response_id == GTK_RESPONSE_ACCEPT) { Display *display; Window window = (Window) user_data; display = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (dialog))); gdk_error_trap_push (); XKillClient (display, window); gdk_flush (); gdk_error_trap_pop_ignored (); } gtk_widget_destroy (GTK_WIDGET (dialog)); }