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));
}
