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