void install_check_click_on_desktop (void) { Window desktop_window; GdkWindow *window; Atom user_time_window; Atom user_time; if (!get_desktop_window (&desktop_window)) { return; } /* Access the desktop window. desktop_window is the root window for the * default screen, so we know using gdk_display_get_default() is correct. */ window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), desktop_window); /* It may contain an atom to tell us which other window to monitor */ user_time_window = gdk_x11_get_xatom_by_name ("_NET_WM_USER_TIME_WINDOW"); user_time = gdk_x11_get_xatom_by_name ("_NET_WM_USER_TIME"); if (user_time != None && user_time_window != None) { /* Looks like the atoms are there */ Atom actual_type; int actual_format; gulong nitems; gulong bytes; Window *data; /* We only use this extra property if the actual user-time property's missing */ int status = XGetWindowProperty( GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)), desktop_window, user_time, 0, 4, False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes, (unsigned char **)&data ); if (actual_type == None) { /* No user-time property, so look for the user-time-window */ status = XGetWindowProperty( GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)), desktop_window, user_time_window, 0, 4, False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes, (unsigned char **)&data ); if (actual_type != None) { /* We have another window to monitor */ desktop_window = *data; window = gdk_x11_window_foreign_new_for_display (gdk_window_get_display (window), desktop_window); } } } gdk_window_set_events (window, GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter (window, desktop_window_event_filter, NULL); }
gboolean get_atom_value_by_name(Display* dsp, Window window_id, const char* name, gpointer res, CallbackFunc callback, gulong index) { Atom atom = gdk_x11_get_xatom_by_name(name); return get_atom_value_by_atom(dsp, window_id, atom, res, callback, index); }
static gboolean drw_selection_find_existing (DrwSelection *drw_selection) { Display *xdisplay = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); Window old; gdk_error_trap_push (); old = XGetSelectionOwner (xdisplay, gdk_x11_get_xatom_by_name (SELECTION_NAME)); if (old) { XSelectInput (xdisplay, old, StructureNotifyMask); drw_selection->owner_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), old); } XSync (xdisplay, False); if (gdk_error_trap_pop () == 0 && drw_selection->owner_window) { gdk_window_add_filter (drw_selection->owner_window, drw_selection_filter, drw_selection); XUngrabServer (xdisplay); return TRUE; } else { if (drw_selection->owner_window) { g_object_unref (drw_selection->owner_window); drw_selection->owner_window = NULL; } return FALSE; } }
static GdkFilterReturn avatar_image_filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer data) { XEvent *xevent = gdkxevent; Atom atom; EmpathyAvatarImagePriv *priv; priv = GET_PRIV (data); switch (xevent->type) { case PropertyNotify: atom = gdk_x11_get_xatom_by_name ("_NET_CURRENT_DESKTOP"); if (xevent->xproperty.atom == atom) { if (priv->popup) { gtk_widget_destroy (priv->popup); priv->popup = NULL; } } break; } return GDK_FILTER_CONTINUE; }
/* * detect_get_clipboard - try and get the CLIPBOARD_NAME clipboard * * Returns TRUE if successfully retrieved and FALSE otherwise. */ gboolean detect_get_clipboard() { static const GtkTargetEntry targets[] = { {CLIPBOARD_NAME, 0, 0} }; gboolean retval = FALSE; GtkClipboard *clipboard; Atom atom; atom = gdk_x11_get_xatom_by_name(CLIPBOARD_NAME); XGrabServer(GDK_DISPLAY()); if (XGetSelectionOwner(GDK_DISPLAY(), atom) != None) goto out; clipboard = gtk_clipboard_get(gdk_atom_intern(CLIPBOARD_NAME, FALSE)); if (gtk_clipboard_set_with_data( clipboard, targets, G_N_ELEMENTS (targets), clipboard_get_func, clipboard_clear_func, NULL)) retval = TRUE; out: XUngrabServer (GDK_DISPLAY ()); gdk_flush (); return retval; }
/* 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 (); }
static guint8 * xfce_randr_read_edid_data (Display *xdisplay, RROutput output) { unsigned char *prop; int actual_format; unsigned long nitems, bytes_after; Atom actual_type; Atom edid_atom; guint8 *result = NULL; edid_atom = gdk_x11_get_xatom_by_name (RR_PROPERTY_RANDR_EDID); if (edid_atom != None) { if (XRRGetOutputProperty (xdisplay, output, edid_atom, 0, 100, False, False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &prop) == Success) { if (actual_type == XA_INTEGER && actual_format == 8) result = g_memdup (prop, nitems); } XFree (prop); } return result; }
BGHash::BGHash() : transition_animator_(TRANSITION_DURATION) , override_color_(nux::color::Transparent) { COLORS_ATOM = gdk_x11_get_xatom_by_name("_GNOME_BACKGROUND_REPRESENTATIVE_COLORS"); transition_animator_.updated.connect(sigc::mem_fun(this, &BGHash::OnTransitionUpdated)); WindowManager::Default().average_color = unity::colors::Aubergine; RefreshColor(/* skip_animation */ true); }
int _is_maximized_window(Window win) { gulong items; Atom ATOM_WINDOW_NET_STATE = gdk_x11_get_xatom_by_name("_NET_WM_STATE"); Atom ATOM_WINDOW_MAXIMIZED_VERT = gdk_x11_get_xatom_by_name("_NET_WM_STATE_MAXIMIZED_VERT"); Display* _dsp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); long* data = get_window_property(_dsp, win, ATOM_WINDOW_NET_STATE, &items); if (data != NULL) { for (guint i=0; i<items; i++) { if ((Atom)X_FETCH_32(data, i) == ATOM_WINDOW_MAXIMIZED_VERT) { XFree(data); return 1; } } XFree(data); } return 0; }
/* This function queries the _XROOTPMAP_ID property from the root window * to determine the current root window background pixmap and returns a * surface to draw directly to it. * If _XROOTPMAP_ID is not set, then NULL returned. */ static cairo_surface_t * get_root_pixmap_id_surface (GdkDisplay *display) { GdkScreen *screen; Display *xdisplay; Visual *xvisual; Window xroot; Atom type; int format, result; unsigned long nitems, bytes_after; unsigned char *data; cairo_surface_t *surface = NULL; g_return_val_if_fail (display != NULL, NULL); screen = gdk_display_get_default_screen (display); xdisplay = GDK_DISPLAY_XDISPLAY (display); xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)); xroot = RootWindow (xdisplay, GDK_SCREEN_XNUMBER (screen)); result = XGetWindowProperty (xdisplay, xroot, gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), 0L, 1L, False, XA_PIXMAP, &type, &format, &nitems, &bytes_after, &data); if (result != Success || type != XA_PIXMAP || format != 32 || nitems != 1) { XFree (data); data = NULL; } if (data != NULL) { Pixmap pixmap = *(Pixmap *) data; Window root_ret; int x_ret, y_ret; unsigned int w_ret, h_ret, bw_ret, depth_ret; gdk_x11_display_error_trap_push (display); if (XGetGeometry (xdisplay, pixmap, &root_ret, &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret)) { surface = cairo_xlib_surface_create (xdisplay, pixmap, xvisual, w_ret, h_ret); } gdk_x11_display_error_trap_pop_ignored (display); XFree (data); } gdk_display_flush (display); return surface; }
/* * Called when the X server emits a root window change event. If the event is * about a new pixmap, update the global->root_pixmap actor. */ static GdkFilterReturn root_window_filter (GdkXEvent *native, GdkEvent *event, gpointer data) { XEvent *xevent = (XEvent *)native; if ((xevent->type == PropertyNotify) && (xevent->xproperty.window == gdk_x11_get_default_root_xwindow ()) && (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"))) update_root_window_pixmap (SHELL_GLOBAL (data)); return GDK_FILTER_CONTINUE; }
static GdkFilterReturn desktop_window_event_filter (GdkXEvent *xevent, GdkEvent *event, gpointer data) { gboolean desktop_hide = g_settings_get_boolean (stickynotes->settings, "desktop-hide"); if (desktop_hide && (((XEvent*)xevent)->xany.type == PropertyNotify) && (((XEvent*)xevent)->xproperty.atom == gdk_x11_get_xatom_by_name ("_NET_WM_USER_TIME"))) { stickynote_show_notes (FALSE); } return GDK_FILTER_CONTINUE; }
static int window_get_workspace (Screen *xscreen, Window win) { int number; if (!_wnck_get_cardinal (xscreen, win, gdk_x11_get_xatom_by_name ("_NET_WM_DESKTOP"), &number)) return -1; return number; }
static void keysynth_realize (GtkWidget *widget) { XWMHints wm_hints; Atom wm_window_protocols[2]; static gboolean initialized = FALSE; if (!initialized) { wm_window_protocols[0] = gdk_x11_get_xatom_by_name ("WM_DELETE_WINDOW"); wm_window_protocols[1] = gdk_x11_get_xatom_by_name ("_NET_WM_PING"); } wm_hints.flags = InputHint; wm_hints.input = False; XSetWMHints (GDK_WINDOW_XDISPLAY (gtk_widget_get_window(widget)), GDK_WINDOW_XWINDOW (gtk_widget_get_window(widget)), &wm_hints); XSetWMProtocols (GDK_WINDOW_XDISPLAY (gtk_widget_get_window(widget)), GDK_WINDOW_XWINDOW (gtk_widget_get_window(widget)), wm_window_protocols, 2); }
static void send_root_property_change_notification (GnomeBGCrossfade *fade) { long zero_length_pixmap; /* We do a zero length append to force a change notification, * without changing the value */ XChangeProperty (GDK_WINDOW_XDISPLAY (fade->priv->window), GDK_WINDOW_XID (fade->priv->window), gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), XA_PIXMAP, 32, PropModeAppend, (guchar *) &zero_length_pixmap, 0); }
bool wxTaskBarIconBase::IsAvailable() { #ifdef GDK_WINDOWING_X11 char name[32]; g_snprintf(name, sizeof(name), "_NET_SYSTEM_TRAY_S%d", gdk_x11_get_default_screen()); Atom atom = gdk_x11_get_xatom_by_name(name); Window manager = XGetSelectionOwner(gdk_x11_get_default_xdisplay(), atom); return manager != None; #else return true; #endif }
static gboolean is_running (void) { gboolean result = FALSE; Atom clipboard_atom = gdk_x11_get_xatom_by_name (SELECTION_NAME); XGrabServer (GDK_DISPLAY()); if (XGetSelectionOwner (GDK_DISPLAY(), clipboard_atom) != None) result = TRUE; XUngrabServer (GDK_DISPLAY()); gdk_flush(); return result; }
void setup_background(GtkWidget* container, GtkWidget* webview, const char* xatom_name) { _BG_ATOM = gdk_x11_get_xatom_by_name(xatom_name); BackgroundInfo* info = create_background_info(container, webview); background_info_set_background_by_drawable(info, get_blurred_background()); //TODO: //we shoul use xatom_name window to set events instead of root window //because the monitors changed signal will came before root window rect changed //so the Xroot window rect maybe keep old rect in update_bg function gdk_window_set_events(gdk_get_default_root_window(), GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(gdk_get_default_root_window(), (GdkFilterFunc)update_bg, info); }
/* This function will make sure that tilda window becomes active (gains * the focus) when it is called. * * This has to be the worst possible way of making this work, but it was the * only way to get metacity to play nicely. All the other WM's are so nice, * why oh why does metacity hate us so? */ void tilda_window_set_active (tilda_window *tw) { DEBUG_FUNCTION ("tilda_window_set_active"); DEBUG_ASSERT (tw != NULL); Display *x11_display = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (tw->window) ); Window x11_window = GDK_WINDOW_XID (gtk_widget_get_window (tw->window) ); Window x11_root_window = GDK_WINDOW_XID ( gtk_widget_get_root_window (tw->window) ); GdkScreen *screen = gtk_widget_get_screen (tw->window); XEvent event; long mask = SubstructureRedirectMask | SubstructureNotifyMask; gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos")); if (gdk_x11_screen_supports_net_wm_hint (screen, gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW"))) { guint32 timestamp = gtk_get_current_event_time (); if (timestamp == 0) { timestamp = gdk_x11_get_server_time(gdk_screen_get_root_window (screen)); } event.xclient.type = ClientMessage; event.xclient.serial = 0; event.xclient.send_event = True; event.xclient.display = x11_display; event.xclient.window = x11_window; event.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW"); event.xclient.format = 32; event.xclient.data.l[0] = 2; /* pager */ event.xclient.data.l[1] = timestamp; /* timestamp */ event.xclient.data.l[2] = 0; event.xclient.data.l[3] = 0; event.xclient.data.l[4] = 0; XSendEvent (x11_display, x11_root_window, False, mask, &event); } else { /* The WM doesn't support the EWMH standards. We'll print a warning and * try this, though it probably won't work... */ g_printerr (_("WARNING: Window manager (%s) does not support EWMH hints\n"), gdk_x11_screen_get_window_manager_name (screen)); XRaiseWindow (x11_display, x11_window); } }
/* this assumes you've already imported gtk and thus have a display */ static PyObject * getXatom(PyObject *s, PyObject *args) { char *atomname; Atom theatom; if (!PyArg_ParseTuple(args, "s", &atomname)) { return NULL; } theatom = gdk_x11_get_xatom_by_name(atomname); if (XGetSelectionOwner (GDK_DISPLAY(), theatom) != None) { Py_INCREF(Py_True); return Py_True; } Py_INCREF(Py_False); return Py_False; }
static GdkFilterReturn gdk_filter_func (GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) { XEvent *xevent = gdk_xevent; NemoDesktopManager *manager; manager = NEMO_DESKTOP_MANAGER (data); switch (xevent->type) { case PropertyNotify: if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name ("_NET_WORKAREA")) layout_changed (manager); break; default: break; } return GDK_FILTER_CONTINUE; }
void terminal_util_activate_window (GtkWindow *window) { #ifdef GDK_WINDOWING_X11 XClientMessageEvent event; terminal_return_if_fail (GTK_IS_WINDOW (window)); terminal_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (window))); /* leave if the window is already active */ if (gtk_window_is_active (window)) return; /* we need a slightly custom version of the call through Gtk+ to * properly focus the panel when a plugin calls * xfce_panel_plugin_focus_widget() */ event.type = ClientMessage; event.window = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (window))); event.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW"); event.format = 32; event.data.l[0] = 0; gdk_error_trap_push (); XSendEvent (gdk_x11_get_default_xdisplay (), gdk_x11_get_default_root_xwindow (), False, StructureNotifyMask, (XEvent *) &event); gdk_flush (); if (gdk_error_trap_pop () != 0) g_critical ("Failed to focus window"); #else /* our best guess on non-x11 clients */ gtk_window_present (window); #endif }
/* * Updates the global->root_pixmap actor with the root window's pixmap or fails * with a warning. */ static void update_root_window_pixmap (ShellGlobal *global) { Atom type; int format; gulong nitems; gulong bytes_after; guchar *data; Pixmap root_pixmap_id = None; if (!XGetWindowProperty (gdk_x11_get_default_xdisplay (), gdk_x11_get_default_root_xwindow (), gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), 0, LONG_MAX, False, AnyPropertyType, &type, &format, &nitems, &bytes_after, &data) && type != None) { /* Got a property. */ if (type == XA_PIXMAP && format == 32 && nitems == 1) { /* Was what we expected. */ root_pixmap_id = *(Pixmap *)data; } else { g_warning ("Could not get the root window pixmap"); } XFree(data); } clutter_x11_texture_pixmap_set_pixmap (CLUTTER_X11_TEXTURE_PIXMAP (global->root_pixmap), root_pixmap_id); }
gboolean dock_has_maximize_client() { Atom ATOM_CLIENT_LIST = gdk_x11_get_xatom_by_name("_NET_CLIENT_LIST"); Display* _dsp = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); gulong items; Window root = GDK_ROOT_WINDOW(); void* data = get_window_property(_dsp, root, ATOM_CLIENT_LIST, &items); gboolean has = FALSE; if (data == NULL) return has; for (guint i=0; i<items; i++) { Window xid = X_FETCH_32(data, i); if (_is_maximized_window(xid)) { has = TRUE; break; } } XFree(data); return has; }
static void activate_window(Display *display, Window window) { Window toplevel = window; Atom window_state_atom = gdk_x11_get_xatom_by_name("WM_STATE"); Atom active_window_atom = gdk_x11_get_xatom_by_name("_NET_ACTIVE_WINDOW"); Window root; XEvent xev; /* The window_id we have is the window ID of a child window. So, we first * need to walk up the window hierarachy until we find the WM_STATE window, * then activate that window. Lots of X roundtrips here, but we only do * this on a user click as an alternative to launching a new firefox * process, so it doesn't really matter. */ gdk_error_trap_push(); while (TRUE) { Window parent; Window *children; guint n_children; Atom type; int format; gulong n_items; gulong bytes_after; guchar *data; if (!XQueryTree(display, toplevel, &root, &parent, &children, &n_children)) { g_debug("XQueryTree failed\n"); goto out; } XFree(children); if (root == parent) /* No window manager or non-reparenting window manager */ break; if (XGetWindowProperty(display, toplevel, window_state_atom, 0, G_MAXLONG, False, AnyPropertyType, &type, &format, &n_items, &bytes_after, &data) != Success) { g_debug("XGetWindowProperty failed\n"); goto out; } if (type != None) { /* Found the real client toplevel */ XFree(data); break; } toplevel = parent; } xev.xclient.type = ClientMessage; xev.xclient.window = toplevel; xev.xclient.message_type = active_window_atom; xev.xclient.format = 32; xev.xclient.data.l[0] = 2; /* We're sort of like a pager ... we're activating a window * from a different app as a response to direct user action */ xev.xclient.data.l[1] = gtk_get_current_event_time(); xev.xclient.data.l[2] = None; /* We don't really have an active toplevel */ xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; XSendEvent(display, root, False, SubstructureNotifyMask | SubstructureRedirectMask, &xev); out: gdk_error_trap_pop(); }
void desktop_set_background (GtkWidget *desktop, gchar *wallpaper, FmWallpaperMode wallpaper_mode, GdkColor *color_background) { GdkPixbuf *pixbuf; GdkWindow *root = gdk_screen_get_root_window (gtk_widget_get_screen (desktop)); GdkWindow *window = gtk_widget_get_window (desktop); if (wallpaper_mode == FM_WP_COLOR || !wallpaper || !*wallpaper || !(pixbuf = gdk_pixbuf_new_from_file (wallpaper, NULL))) { //GdkColor bg = color_background; //gdk_rgb_find_color (gdk_drawable_get_colormap (window), &bg); //gdk_window_set_back_pixmap (window, NULL, FALSE); gdk_window_set_background (window, color_background); //gdk_window_set_back_pixmap (root, NULL, FALSE); gdk_window_set_background (root, color_background); //gdk_window_clear (root); //gdk_window_clear (window); gdk_window_invalidate_rect (window, NULL, TRUE); return; } // #if 0 int src_w = gdk_pixbuf_get_width (pixbuf); int src_h = gdk_pixbuf_get_height (pixbuf); cairo_surface_t *surface; int dest_w; int dest_h; if (wallpaper_mode == FM_WP_TILE) { dest_w = src_w; dest_h = src_h; //pixmap = gdk_pixmap_new (window, dest_w, dest_h, -1); surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR, dest_w, dest_h); } else { GdkScreen *screen = gtk_widget_get_screen (desktop); dest_w = gdk_screen_get_width (screen); dest_h = gdk_screen_get_height (screen); //pixmap = gdk_pixmap_new (window, dest_w, dest_h, -1); surface = gdk_window_create_similar_surface (window, CAIRO_CONTENT_COLOR, dest_w, dest_h); } //~ if (gdk_pixbuf_get_has_alpha (pixbuf) //~ || wallpaper_mode == FM_WP_CENTER //~ || wallpaper_mode == FM_WP_FIT) //~ { //~ gdk_gc_set_rgb_fg_color (desktop->gc, &color_background); //~ gdk_draw_rectangle (pixmap, desktop->gc, TRUE, 0, 0, dest_w, dest_h); //~ } // GdkPixbuf *scaled; cairo_t *cr; switch (wallpaper_mode) { case FM_WP_COLOR: break; case FM_WP_TILE: //gdk_draw_pixbuf (pixmap, desktop->gc, pixbuf, 0, 0, 0, 0, dest_w, dest_h, GDK_RGB_DITHER_NORMAL, 0, 0); cr = cairo_create (surface); gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); cairo_destroy (cr); break; case FM_WP_STRETCH: //~ if (dest_w == src_w && dest_h == src_h) //~ scaled = (GdkPixbuf*) g_object_ref (pixbuf); //~ else //~ scaled = gdk_pixbuf_scale_simple (pixbuf, dest_w, dest_h, GDK_INTERP_BILINEAR); //~ //~ gdk_draw_pixbuf (pixmap, desktop->gc, scaled, 0, 0, 0, 0, dest_w, dest_h, GDK_RGB_DITHER_NORMAL, 0, 0); //~ //~ g_object_unref (scaled); break; case FM_WP_FIT: //~ if (dest_w != src_w || dest_h != src_h) //~ { //~ gdouble w_ratio = (float) dest_w / src_w; //~ gdouble h_ratio = (float) dest_h / src_h; //~ gdouble ratio = MIN (w_ratio, h_ratio); //~ //~ if (ratio != 1.0) //~ { //~ src_w *= ratio; //~ src_h *= ratio; //~ //~ scaled = gdk_pixbuf_scale_simple (pixbuf, src_w, src_h, GDK_INTERP_BILINEAR); //~ //~ g_object_unref (pixbuf); //~ pixbuf = scaled; //~ } //~ } case FM_WP_CENTER: { //~ int x; //~ int y; //~ x = (dest_w - src_w) / 2; //~ y = (dest_h - src_h) / 2; //~ //~ gdk_draw_pixbuf (pixmap, desktop->gc, pixbuf, 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NORMAL, 0, 0); } break; } Display *xdisplay; Pixmap xpixmap = 0; Window xroot; cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface); //gdk_window_set_back_pixmap (root, pixmap, FALSE); gdk_window_set_background_pattern (root, pattern); //gdk_window_set_back_pixmap (window, NULL, TRUE); gdk_window_set_background_pattern (window, pattern); cairo_pattern_destroy (pattern); Pixmap pixmap_id = cairo_xlib_surface_get_drawable (surface); XChangeProperty (GDK_WINDOW_XDISPLAY (root), GDK_WINDOW_XID (root), gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), //XA_XROOTMAP_ID, XA_PIXMAP, 32, PropModeReplace, (guchar*) &pixmap_id, 1); // Set root map here... xdisplay = GDK_WINDOW_XDISPLAY (root); xroot = GDK_WINDOW_XID (root); XGrabServer (xdisplay); if (surface) { xpixmap = cairo_xlib_surface_get_drawable (surface); XChangeProperty (xdisplay, xroot, gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), XA_PIXMAP, 32, PropModeReplace, (guchar *) &xpixmap, 1); XSetWindowBackgroundPixmap (xdisplay, xroot, xpixmap); } else { // Anyone knows how to handle this correctly ? } XClearWindow (xdisplay, xroot); XUngrabServer (xdisplay); XFlush (xdisplay); cairo_surface_destroy (surface); if (pixbuf) g_object_unref (pixbuf); // gdk_window_clear (root); // gdk_window_clear (window); gdk_window_invalidate_rect (window, NULL, TRUE); // #endif }
static GdkFilterReturn filter_property_changed (GdkXEvent *xevent, GdkEvent *event, gpointer data) { HDDesktop *desktop = data; HDDesktopPrivate *priv = desktop->priv; XEvent *ev = (XEvent *) xevent; if (ev->type == PropertyNotify) { if (ev->xproperty.atom == gdk_x11_get_xatom_by_name ("_MB_CURRENT_APP_WINDOW")) { Atom actual_type; int actual_format; unsigned long nitems, bytes; unsigned char *atom_data = NULL; if (XGetWindowProperty (GDK_WINDOW_XDISPLAY (priv->root_window), GDK_WINDOW_XID (priv->root_window), gdk_x11_get_xatom_by_name ("_MB_CURRENT_APP_WINDOW"), 0, (~0L), False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes, &atom_data) == Success) { if (nitems == 1) { guint32 *new_value = (void *) atom_data; if (*new_value == 0xFFFFFFFF) { if (!priv->task_switcher_shown) { priv->task_switcher_shown = TRUE; g_signal_emit (desktop, desktop_signals [TASK_SWITCHER_SHOW], 0); } } else { if (priv->task_switcher_shown) { priv->task_switcher_shown = FALSE; g_signal_emit (desktop, desktop_signals [TASK_SWITCHER_HIDE], 0); } } } } if (atom_data) XFree (atom_data); } } return GDK_FILTER_CONTINUE; }
static __SOVPropArray * gdk_gl_overlay_get_sov_props (GdkScreen *screen) { __SOVPropArray *sov_props; GdkWindow *root_window; #ifdef GDKGLEXT_MULTIHEAD_SUPPORT GdkDisplay *display; #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ Display *xdisplay; Atom xa_sov; Status status; Atom actual_type; int actual_format; unsigned long nitems, bytes_after; unsigned char *prop = NULL; GDK_GL_NOTE_FUNC_PRIVATE (); #ifdef GDKGLEXT_MULTIHEAD_SUPPORT root_window = gdk_screen_get_root_window (screen); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ root_window = gdk_get_default_root_window (); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ if (quark_sov_props == 0) quark_sov_props = g_quark_from_static_string (quark_sov_props_string); sov_props = g_object_get_qdata (G_OBJECT (root_window), quark_sov_props); if (sov_props != NULL) return sov_props; sov_props = g_malloc (sizeof (__SOVPropArray)); #ifdef GDKGLEXT_MULTIHEAD_SUPPORT display = gdk_screen_get_display (screen); xdisplay = GDK_DISPLAY_XDISPLAY (display); xa_sov = gdk_x11_get_xatom_by_name_for_display (display, "SERVER_OVERLAY_VISUALS"); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ xdisplay = gdk_x11_get_default_xdisplay (); xa_sov = gdk_x11_get_xatom_by_name ("SERVER_OVERLAY_VISUALS"); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ status = XGetWindowProperty (xdisplay, GDK_WINDOW_XWINDOW (root_window), xa_sov, 0L, 1000000L, False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &prop); if (status != Success || actual_type == None || actual_format != 32 || nitems < 4) { GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: not supported")); if (prop != NULL) XFree (prop); sov_props->prop = NULL; sov_props->num = 0; } else { GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: supported")); sov_props->prop = (__SOVProp *) prop; sov_props->num = nitems / (sizeof (__SOVProp) / 4); } g_object_set_qdata_full (G_OBJECT (root_window), quark_sov_props, sov_props, (GDestroyNotify) sov_prop_array_destroy); #ifdef G_ENABLE_DEBUG if (gdk_gl_debug_flags & GDK_GL_DEBUG_MISC) { #ifdef GDKGLEXT_MULTIHEAD_SUPPORT int screen_num = GDK_SCREEN_XNUMBER (screen); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ int screen_num = gdk_x11_get_default_screen (); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ int i; g_message (" -- SERVER_OVERLAY_VISUALS: properties"); g_print ("screen\tvisual\ttype\tvalue\tlayer\n"); for (i = 0; i < sov_props->num; i++) { g_print ("%d\t0x%lx\t%lu\t%lu\t%ld\n", screen_num, (VisualID) (sov_props->prop[i].overlay_visual), (CARD32) (sov_props->prop[i].transparent_type), (CARD32) (sov_props->prop[i].value), (INT32) (sov_props->prop[i].layer)); } } #endif /* G_ENABLE_DEBUG */ return sov_props; }