sd_xutils.c - gscreendump - Screenshot taking application.

Source path: svn/ trunk/ src/ sd_xutils.c

‹r104

r134

/* gscreendump: sd_xutils.c
 * 
 * Copyright (c) Linux community repr. by <osmoma@online.no>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <string.h>
#include "sd_xutils.h"
#include "sd_capture.h"
#include "sd_support.h"
#include <X11/extensions/Xdamage.h>

static void argbdata_to_pixdata(long *argb_data, int len, guchar **pixdata);

char *get_window_name(Display *display, Window win, int max_len)
{
    static char buf[256];
    int len;
    *buf = '\0';

#ifdef NO_I18N
    char *win_name;
    if (XFetchName(display, win, &win_name)) 
    {
        if (win_name) 
        {
            len = MIN(strlen(win_name), 255);
            strncpy(buf, win_name, len);
            buf[len] = '\0';
            XFree(win_name);
        }
    }
#else
    XTextProperty tp;
	if (XGetWMName(display, win, &tp)) 
    { 
        if (tp.nitems > 0) 
        {
            int count = 0, ret;
            char **list = NULL;
            ret = XmbTextPropertyToTextList(display, &tp, &list, &count);
            if((ret == Success || ret > 0) && list != NULL)
            {
                len = MIN(strlen(list[0]), 255);
                strncpy(buf, list[0], len);
                buf[len] = '\0';
                XFreeStringList(list);
            } 
            else 
            {
                strncpy(buf, (const char *)tp.value, MIN(strlen((const char *)tp.value), 255));
            }
        }
	}
#endif

    len = strlen(buf);
    if (len > max_len && len > 4)
    {
        buf[max_len--] = '\0';
        buf[max_len--] = '.';
        buf[max_len--] = '.';
        buf[max_len]   = '.';
    }

	/* Do not free the returned value */
    return buf;
}


int screenshot_window_is_desktop(GdkWindow *window)
{
    /* Return TRUE if window is a desktop.
       Credits: This function is from gnome-utils / gnome-screenshot tool.
    */

    GdkWindow *root_window = gdk_get_default_root_window ();
    GdkWindowTypeHint window_type_hint;

    if (window == root_window)
    {
        return TRUE;
    }

    window_type_hint = gdk_window_get_type_hint (window);
    if (window_type_hint == GDK_WINDOW_TYPE_HINT_DESKTOP)
    {
        return TRUE;
    }
    return FALSE;
}

GdkPixbuf *get_window_icon(Display *display, Window w)
{
	/* Get icon data for window w from window manager. 
	   Create GdkPixbuf of found icon data and return pixbuf.
	Credits: Various sources on the internet (eg. the ROX Desktop) and 
	http://standards.freedesktop.org/wm-spec/1.3/ar01s05.html#id2523482
	*/
	Atom ret_type;
	gint format;
	gulong length, bytes_after;
	guchar *atom_data = NULL;

	Atom atom_NET_WM_ICON = XInternAtom(display, "_NET_WM_ICON", False);

	if (XGetWindowProperty(display, w, atom_NET_WM_ICON, 0, G_MAXLONG, FALSE, AnyPropertyType,  &ret_type, &format, 
		           &length, &bytes_after, (guchar **)&atom_data) != Success)
	{
		return NULL;
	}

	if (length < 3)
	{
		XFree(atom_data);
		return NULL;
	}

	guint width  = (guint)*atom_data;
	guint height = (guint)*(atom_data + sizeof(long));/* sizeof(long)=4 on 32bits OS,  8 on 64bits OS*/

	/* Convert argb to rgba (pixmap) format */
	guchar *pixdata;
	argbdata_to_pixdata((long*)atom_data, width*height, &pixdata);
	XFree(atom_data);

	GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data((const guchar *)pixdata, GDK_COLORSPACE_RGB, TRUE, 8, width, height, width * 4,  free_pixel_data/*free pixdata*/, NULL);

	return pixbuf;
} 

GdkPixbuf *copy_rectangles_to_pixbuf(GdkPixbuf *image, XRectangle *rectangles, gint rectangle_count)
{
	/*
	  Copy pixels from (shape) rectangles to the image.
	  Returns a new_image.
	  Credits: Original code copied and modified from gnome-utils / gnome-screenshot utility.
	*/
	if ((!GDK_IS_PIXBUF(image)) || (!rectangles) || rectangle_count < 1) return NULL;

	gint width  = gdk_pixbuf_get_width(image);
	gint height = gdk_pixbuf_get_height(image); 

	gboolean has_alpha = gdk_pixbuf_get_has_alpha(image);

	/* Create a new_image of the same size, but add also alpha channel */
	GdkPixbuf *new_image = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
	if (!GDK_IS_PIXBUF(new_image)) return NULL;

	/* Clear it */
	gdk_pixbuf_fill(new_image, 0x00000000/*transparent black (at least this works well with PNG mages) */);

	guchar *src_pixels = gdk_pixbuf_get_pixels(image);
	guchar *dest_pixels = gdk_pixbuf_get_pixels(new_image);

	gint src_rowstride = gdk_pixbuf_get_rowstride(image);
	gint dest_rowstride = gdk_pixbuf_get_rowstride(new_image);

	/* Safety limits */
	guchar *max_src = gdk_pixbuf_get_pixels(image) + (height-1) * gdk_pixbuf_get_rowstride(image) + (width-1) * (has_alpha ? 4 : 3);
	guchar *max_dest = gdk_pixbuf_get_pixels(new_image) + (height -1) * gdk_pixbuf_get_rowstride(new_image) + (width-1) * 4;

	gint rec_x, rec_y;
	gint rec_width, rec_height;

	/* Copy pixels from all shapes (rectangles) to the new_image */
	guint i;
	for (i = 0; i < rectangle_count; i++)
	{
		/* 0-based, relative to the window */
		rec_x = rectangles[i].x;
		rec_y = rectangles[i].y;

		rec_width = rectangles[i].width;
		rec_height = rectangles[i].height;

		if (rec_x + rec_width > width)
		{
			rec_width = width - rec_x;
		}

		if (rec_y + rec_height > height)
		{
			rec_height = height - rec_x;
		}

		gint y;
		for (y = rec_y; y < rec_y + rec_height; y++)
		{
			guchar *src, *dest;
			gint x;

			src = src_pixels + y * src_rowstride + rec_x * (has_alpha ? 4 : 3);
			dest = dest_pixels + y * dest_rowstride + rec_x * 4/*has alpha*/;

			for (x = 0; x < rec_width; x++)
			{
				/* Be safe ! */
				if (src > max_src) continue;
				if (dest > max_dest) continue; 

				*dest++ = *src++;
				*dest++ = *src++;
				*dest++ = *src++;

				if (has_alpha)
					*dest++ = *src++;
				else
					*dest++ = 255;

			}
       		}
	}

	/* Return the new image */
	return new_image;
}

gboolean has_composite_extension()
{
    int event_base, error_base;
    Display *display;

    display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());

    if (XCompositeQueryExtension(display, &event_base, &error_base ))
    {
        /* http://ktown.kde.org/~fredrik/composite_howto.html
           If we get here the server supports the extension
        */

        int major = 0, minor = 2; // The highest version we support
        XCompositeQueryVersion(display, &major, &minor );	

        /* major and minor will now contain the highest version the server supports.
           The protocol specifies that the returned version will never be higher
           then the one requested. Version 0.2 is the first version to have the
           XCompositeNameWindowPixmap() request.
        */
        if ( major > 0 || minor >= 2 )
        {
            /* Has pixmap support */
            return TRUE;
        }
    }

    return FALSE;
}

Window find_frame_window(Display *display, Window window)
{
    Window window_manager_win;

    /* Check first the (parent) window. Is it a frame?  */
    window_manager_win = find_window_manager_window(window);

    if (window_manager_win != None && window_manager_win != window)
    {
        return window_manager_win;
    }

    /* But eg. Compiz will fail to find the frame window, so we have to read the window's atom _NET_FRAME_WINDOW. */
    Atom atom_NET_FRAME_WINDOW = XInternAtom (display, "_NET_FRAME_WINDOW", FALSE);

    get_window_property(display, window , atom_NET_FRAME_WINDOW, &window_manager_win);

    /* Got it?  */
    if (window_manager_win != 0)
        return window_manager_win;

    return window;
}

Window find_window_manager_window(Window window)
{
    Window root, parent, *children;
    unsigned int num_children;

    do
    {
        if (XQueryTree (GDK_DISPLAY(), window, &root, &parent, &children, &num_children) == 0)
        {
          fprintf(stderr, _("Couldn't find the window manager (frame) window."));
          return None;
        }

        if (root == parent) return window;
        window = parent;
    }
    while (1);
}

gboolean get_window_property(Display *display, Window window, Atom atom, Window *ret_data)
{
    Atom ret_type;
    gint format;
    gulong nitems, bytes_after;
    guint32 *atom_data;

    *ret_data = 0;

    if (XGetWindowProperty(display, window, atom,	0, G_MAXLONG, False, XA_WINDOW, &ret_type, &format, &nitems, &bytes_after, (void*)&atom_data) != Success)
    {
        return FALSE;
    }

	if (ret_type != XA_WINDOW)
	{
        XFree (atom_data);
        return FALSE;
	}

	*ret_data = *atom_data;
    XFree(atom_data);
	return TRUE;
}

#if 0 
GdkPixbuf *get_cursor_pixbuf(int cursor_type)
{
    GdkCursor *cursor;
    GdkPixbuf *cursor_pixbuf;

    /* Possible pointer types are:
       http://library.gnome.org/devel/gdk/stable/gdk-Cursors.html#GdkCursorType
     */
    cursor = gdk_cursor_new_for_display(gdk_display_get_default (), cursor_type);
    cursor_pixbuf = gdk_cursor_get_image(cursor);
    gdk_cursor_unref(cursor);

    return cursor_pixbuf;
}
#endif

GdkPixbuf *get_gdk_cursor_pixbuf(int cursor_type)
{
    GdkCursor *cursor;
    GdkPixbuf *cursor_pixbuf;

    /* Possible pointer types are:
       http://library.gnome.org/devel/gdk/stable/gdk-Cursors.html#GdkCursorType
     */
    cursor = gdk_cursor_new_for_display(gdk_display_get_default (), cursor_type);
    cursor_pixbuf = gdk_cursor_get_image(cursor);
    gdk_cursor_unref(cursor);

    return cursor_pixbuf;
}

GdkPixbuf *get_cursor_pixbuf(Display *display, GdkWindow *gdk_win, gint *cursor_x, gint *cursor_y, gint *offset_x , gint *offset_y/*x-y hot spot */)
{
	GdkWindow *gdk_root = gdk_get_default_root_window();

	/* Cursor image */
	GdkPixbuf *cursor_pixbuf = NULL;

	/* Check if the XFIXES extension is present in the Xorg. */
	int event, error;
	if (XFixesQueryExtension(display, &event, &error))
	{
		XFixesCursorImage *cur = XFixesGetCursorImage(display);

		*cursor_x = cur->x;
		*cursor_y = cur->x;
		*offset_x = cur->xhot;
		*offset_y = cur->yhot;

		/* Convert root co-ordinate (x,y) to child window co-ordinate */
		Window child_w;	
		XTranslateCoordinates(display, GDK_WINDOW_XWINDOW(gdk_root), GDK_WINDOW_XWINDOW(gdk_win), cur->x, cur->y, cursor_x, cursor_y,  &child_w);

		/* DEBUG:
		   printf("Root W=%ld, Child W=%ld (Ret child W=%ld): Orig cursor X=%d  Orig cursor Y=%d  Child cursor X=%d  Child cursor Y=%d\n", GDK_WINDOW_XWINDOW(gdk_root), 
			                GDK_WINDOW_XWINDOW(gdk_win), child_w, cur->x, cur->y, cursor_x, cursor_y);
		*/

		/* Convert raw data to pixel data */
		guchar *pixdata;
		argbdata_to_pixdata((long*)cur->pixels, cur->width*cur->height, &pixdata);

		cursor_pixbuf = gdk_pixbuf_new_from_data((const guchar *)pixdata, GDK_COLORSPACE_RGB, TRUE, 8, cur->width, cur->height, cur->width * 4,  free_pixel_data, NULL);
		/* Note: pixdata is freed by free_my_data() function.
		   g_free(pixdata);
		*/	

		/* Free cur */
		XFree(cur);
	}
	else
	{
		/* Cannot query cursor. 
		   Create a picture of fixed GDK_LEFT_PTR cursor.
		*/
		cursor_pixbuf = get_gdk_cursor_pixbuf(GDK_LEFT_PTR);

		/* TODO: Do not use fixed values.
		   Calculate these offset. 
		*/ 
		#define OFFSET_X 6
		#define OFFSET_Y 4

		*offset_x = OFFSET_X;
		*offset_y = OFFSET_Y;

		gdk_window_get_pointer(gdk_win, cursor_x, cursor_y, NULL);
	}

	/* You should g_object_unref() the pixbuf after usage */
	return cursor_pixbuf;
}

int window_is_shaped(Display *display, Window window)
{
    int  bounding, clipping;
    gint  i1;
    guint i2;

    XShapeQueryExtents(display, window, &bounding, &i1, &i1, &i2, &i2, &clipping, &i1, &i1, &i2, &i2);
    return bounding;
}

int window_is_viewable(Display *display, Window window)
{
    XWindowAttributes attr;

    int stat = XGetWindowAttributes(display, window, &attr);
    /* stat == BadDrawable || stat == BadWindow) */
    if (!stat)
        return FALSE;

    return attr.map_state == IsViewable;
}

Window gtk_window_to_xwindow(GtkWidget *widget)
{
    return GDK_WINDOW_XWINDOW(GTK_WIDGET(widget)->window);
}

XColor create_xcolor_from_RGB(Display *display, short red, short green, short blue)
{
    XColor color;

    color.red = (red * 0xFFFF) / 0xFF;
    color.green = (green * 0xFFFF) / 0xFF;
    color.blue = (blue * 0xFFFF) / 0xFF;
    color.flags = DoRed | DoGreen | DoBlue;

    if (!XAllocColor(display, DefaultColormap(display, 0), &color))
    {
        fprintf(stderr, _("Error: Cannot create Xcolor\n"));
    }
    return color;
}

int is_inside_rect(XPoint *p, XRectangle *rect)
{
    return (p->x >= rect->x && p->x <= rect->x + rect->width) &&  
           (p->y >= rect->y && p->y <= rect->y + rect->height);
}

void millisleep(guint milliseconds)
{
	struct timespec ts;
	ts.tv_sec = milliseconds / 1000;
	ts.tv_nsec = (milliseconds - ts.tv_sec*1000) * 1000000;
	nanosleep(&ts, NULL);
}

Display *get_xdisplay()
{
	GdkDisplay *gdk_display = gdk_display_get_default();
	return GDK_DISPLAY_XDISPLAY(gdk_display);
}

gint get_desktop_for_window(GdkWindow *window)
{
	GdkAtom actual_type;
	gint actual_format;
	gint num_items;
	guchar *ret_data_ptr;

	GdkAtom atom_net_vm_desktop = gdk_atom_intern("_NET_WM_DESKTOP", FALSE);

	gint num = -1;
	if (gdk_property_get(window, atom_net_vm_desktop, gdk_atom_intern("CARDINAL", FALSE),  0L, 1L,FALSE, 
		          &actual_type, &actual_format, &num_items, (guchar**)&ret_data_ptr))
	{
	num = (int)*ret_data_ptr;
	g_free(ret_data_ptr);
	}

	return num;
}

GList *get_all_window_properties(GdkWindow *window)
{
	/* 
	  Return a list of all window's atoms (property names).
	*/
	Atom *all_atoms;
	gint atom_count;
	gchar *atom_name;
 
	GList *atom_list = NULL;

	Window w = GDK_WINDOW_XID(window);
	Display *display = GDK_DISPLAY();

	all_atoms = XListProperties(display, w, &atom_count);

	guint i;
	for (i=0; i < atom_count; i++)
	{
		atom_name = XGetAtomName(display, all_atoms[i]);
		atom_list = g_list_append(atom_list, g_strdup(atom_name));
		XFree(atom_name);
	}
	XFree(all_atoms);

	/* Notice: You should free the returned list after usage. Use the free_string_list() function */
	return atom_list;
}


void bring_window_to_top(GdkWindow *gdk_win, gboolean move_to_desktop)
{
	if (move_to_desktop)
	{
		guint desktop = get_desktop_for_window(gdk_win);
		if (desktop != get_active_desktop())
		{
			set_active_desktop(desktop);
		}
	}

	x11_bring_window_to_top(GDK_WINDOW_XID(gdk_win));
}

void x11_bring_window_to_top(Window window)
{
	XEvent xev;
	XWindowAttributes wattr;

    Display *display = get_xdisplay();

	XMapWindow(display, window);
	XRaiseWindow(display, window);

	memset(&xev, 0, sizeof(xev));
	xev.type = ClientMessage;
	xev.xclient.display = display;
	xev.xclient.window = window;
	xev.xclient.message_type = XInternAtom(display, "_NET_ACTIVE_WINDOW", False);
	xev.xclient.format = 32;
	xev.xclient.data.l[0] = 2L; /* 2 == Message from a window pager */
	xev.xclient.data.l[1] = CurrentTime;

	XGetWindowAttributes(display, window, &wattr);
	XSendEvent(display, wattr.screen->root, False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);

	XFlush(display);
	// XSync(display, False);
}

int is_compiz_wm()
{
	return !strcmp(get_window_manager_name(), "compiz");
}

gboolean get_property_data_long(gchar *atom_name, glong **ret_data, gint *ret_length)
{
	GdkAtom actual_type;
	gint actual_format;

	GdkAtom gatom = gdk_atom_intern(atom_name, FALSE);

	if (gdk_property_get(gdk_get_default_root_window(), gatom, gdk_atom_intern("CARDINAL", FALSE), 0L, (0xFF), FALSE, 
		&actual_type, &actual_format, ret_length, (guchar**)ret_data))
	{
		return TRUE;
	}

	*ret_data = NULL;
	*ret_length = 0;

	return FALSE;
}

const char *get_window_manager_name()
{
	/* Return name of the window manager.
	   Eg: "compiz" or "Metacity"
	*/
	GdkScreen *gdk_def_screen;
	gdk_def_screen = gdk_screen_get_default();

	return gdk_x11_screen_get_window_manager_name(gdk_def_screen);
}

guint get_number_of_desktops()
{
	if (is_compiz_wm())
		return compiz_get_number_of_viewports();

	return metacity_get_number_of_desktops();	

}

guint metacity_get_number_of_desktops()
{

    GdkAtom actual_type;
    gint actual_format;
    gint num_items;
    guchar *ret_data_ptr;

	GdkAtom atom_net_number_desktops = gdk_atom_intern("_NET_NUMBER_OF_DESKTOPS", FALSE);

    guint num = 0;
	if (gdk_property_get(gdk_get_default_root_window(), atom_net_number_desktops, gdk_atom_intern("CARDINAL", FALSE),  0L, 1L, FALSE, 
                          &actual_type, &actual_format, &num_items, (guchar**)&ret_data_ptr))
    {
        num = (int)*ret_data_ptr;
        g_free(ret_data_ptr);
    }

    return num;
}

guint compiz_get_number_of_viewports()
{
	guint num_viewports;

	/* if (is_compiz_wm())...   */

	guint viewport_width = 1;
	guint viewport_total_width = 0;

	glong *data;
	gint data_len;	

	/* An example: _NET_WORKAREA(CARDINAL) = 0, 25, 1680, 1000    */
	if (get_property_data_long("_NET_WORKAREA", &data, &data_len))
	{
		viewport_width = (int)data[2];
		g_free(data);
	}

	/* An example: _NET_DESKTOP_GEOMETRY(CARDINAL) = 8400, 1050   */
	if (get_property_data_long("_NET_DESKTOP_GEOMETRY", &data, &data_len))
	{
		viewport_total_width = data[0];
		g_free(data);
	}

	num_viewports = MAX(viewport_total_width / viewport_width, 1);

	return num_viewports;
}

GList *get_desktop_names()
{
	if (is_compiz_wm())
		return compiz_get_viewport_names();

	return metacity_get_desktop_names();
}

GList *metacity_get_desktop_names()
{
	GdkAtom actual_type;
	gint actual_format;
	gint num_items;
	guchar *ret_data_ptr = NULL;

	GList *list = NULL;

	/* Ask the names */
	GdkAtom atom_net_desktop_names = gdk_atom_intern("_NET_DESKTOP_NAMES", FALSE);

	if (gdk_property_get(gdk_get_default_root_window(),atom_net_desktop_names, 
	                     gdk_atom_intern("UTF8_STRING", FALSE), 0, 0xFFFFFF, FALSE, &actual_type, &actual_format, &num_items, &ret_data_ptr))
	{
		if (num_items > 0)
		{
			gchar *p = (gchar *)ret_data_ptr;
			list = g_list_append(list, g_strdup(p));
			guint i;
			for (i = 0; i < num_items-1; i++)
			{
				if (*(ret_data_ptr + i)	== '\0')	
				{
					p = (gchar*)ret_data_ptr + i + 1;
					list = g_list_append(list, g_strdup(p));
				}
			}
		}
		g_free(ret_data_ptr);
	}

	/* Notice: You should free the list->data values and the list after usage */
	return list;
}

GList *compiz_get_viewport_names()
{

	/* Compiz window manager will not give the viewports (ehm... desktops) any names, 
	   so we'll set the names to "Compiz viewport #".
	*/

	/* Number of viewports */
	guint num_viewports = compiz_get_number_of_viewports();

	GList *list = NULL;

	guint i;
	for (i=0; i < num_viewports; i++)
	{
		list = g_list_append(list,  g_strdup_printf(_("Compiz viewport %d"), i+1));
	}

	return list;
}

guint get_active_desktop()
{
	if (is_compiz_wm())
		return compiz_get_active_viewport();

	return metacity_get_active_desktop();
}

guint compiz_get_active_viewport()
{
	glong *data;
	gint data_len;	

	guint desktop_width = 0;
	guint desktop_viewport = 0;

	// Example: _NET_WORKAREA(CARDINAL) = 0, 25, 1680, 1000
	if (get_property_data_long("_NET_WORKAREA", &data, &data_len))
	{
		desktop_width = (int)data[2];
		g_free(data);
	}

	// Example: _NET_DESKTOP_VIEWPORT(CARDINAL) = 5040, 0  
	if (get_property_data_long("_NET_DESKTOP_VIEWPORT", &data, &data_len))
	{
		desktop_viewport = (int)data[0];
		g_free(data);
	}

	guint num = 0;

	if (desktop_width > 0)
		num = desktop_viewport / desktop_width;

	return num;
}

guint metacity_get_active_desktop()
{
	/* Get the current, active desktop.
	   The returned value is zero-based: 0, 1, 2...
	*/
	GdkAtom actual_type;
	gint actual_format;
	gint num_items;
	guchar *ret_data_ptr = NULL;

	/* Metacity or other standards respecting window manager */
	GdkAtom atom_net_current_desktop = gdk_atom_intern("_NET_CURRENT_DESKTOP", FALSE);

	gint num = 0;
	if (gdk_property_get(gdk_get_default_root_window(), atom_net_current_desktop, gdk_atom_intern("CARDINAL", FALSE),  0L, 1L, FALSE, 
		                  &actual_type, &actual_format, &num_items, (guchar**)&ret_data_ptr))
	{
		num = *((int*)ret_data_ptr);
		g_free(ret_data_ptr);
	}

	return num;
}

void set_active_desktop(guint desktop_num)
{
	/* Set active desktop.
	   The desktop_num is zero-based: 0, 1, 2...
	*/

	if (is_compiz_wm())
	{		
		compiz_set_active_viewport(desktop_num);
		return;
	}

	metacity_set_active_desktop(desktop_num);
}

void compiz_set_active_viewport(guint viewport_num)
{
	glong *data;
	gint data_len;	

	guint desktop_width = 0;

	/* Example: _NET_WORKAREA(CARDINAL) = 0, 25, 1680, 1000    */
	if (get_property_data_long("_NET_WORKAREA", &data, &data_len))
	{
		desktop_width = (int)data[2];
		g_free(data);
	}

	guint total_viewport_width = 0;

	/* Example: _NET_DESKTOP_VIEWPORT(CARDINAL) = 5040, 0     */
	if (get_property_data_long("_NET_DESKTOP_GEOMETRY", &data, &data_len))
	{
		total_viewport_width = (int)data[0];
		g_free(data);
	}

	guint new_viewport_width = viewport_num * desktop_width;
	if (new_viewport_width > total_viewport_width) return; 

	Display *display = GDK_DISPLAY();
	Window root_win = GDK_WINDOW_XWINDOW(gdk_get_default_root_window());

	/* Set _NET_DESKTOP_VIEWPORT(CARDINAL) = ####, 0   */
	Atom atom_net_current_desktop = XInternAtom(display, "_NET_DESKTOP_VIEWPORT", False);
	XEvent xevent;
	xevent.type              = ClientMessage;
	xevent.xclient.type      = ClientMessage; 
	xevent.xclient.display   = display;
	xevent.xclient.window    = root_win;
	xevent.xclient.message_type = atom_net_current_desktop;
	xevent.xclient.format    = 32;
	xevent.xclient.data.l[0] = new_viewport_width;
	xevent.xclient.data.l[1] = 0;
	xevent.xclient.data.l[2] = CurrentTime;
	xevent.xclient.data.l[3] = 0;
	xevent.xclient.data.l[4] = 0;
	XSendEvent(display, root_win, False, SubstructureNotifyMask | SubstructureRedirectMask, &xevent);

	XFlush(display);
	return;
}

void metacity_set_active_desktop(guint desktop_num)
{
	/* Set active desktop.
	   The desktop_num is zero-based: 0, 1, 2...
	*/

	/* Metacity or other standards respecting window manager */
	if (desktop_num+1 > get_number_of_desktops()) return;

	Display *display = GDK_DISPLAY();
	Window root_win = GDK_WINDOW_XWINDOW(gdk_get_default_root_window());

    Atom atom_net_current_desktop = XInternAtom(display, "_NET_CURRENT_DESKTOP", False);
    XEvent xevent;
    xevent.type              = ClientMessage;
    xevent.xclient.type      = ClientMessage; 
    xevent.xclient.display   = display;
    xevent.xclient.window    = root_win;
    xevent.xclient.message_type = atom_net_current_desktop;
    xevent.xclient.format    = 32;
    xevent.xclient.data.l[0] = desktop_num;
    xevent.xclient.data.l[1] = CurrentTime;
    xevent.xclient.data.l[2] = 0;
    xevent.xclient.data.l[3] = 0;
    xevent.xclient.data.l[4] = 0;
    XSendEvent(display, root_win, False, SubstructureNotifyMask | SubstructureRedirectMask, &xevent);

	XFlush(display);
}

Window try_children(Display *display, Window win, Atom WM_STATE)
{
    Window root, parent;
    Window *children;
    unsigned int nchildren;
    unsigned int i;
    Atom type = None;
    int format;
    unsigned long nitems, after;
    unsigned char *data;
    Window inf = 0;

    if (!XQueryTree(display, win, &root, &parent, &children, &nchildren)) return 0;

    for (i = 0; !inf && (i < nchildren); i++) 
	{
 		XGetWindowProperty(display, children[i], WM_STATE, 0, 0, False, AnyPropertyType, &type, &format, &nitems, &after, &data);

 		if (type) 
			inf = children[i];
    }

	/* Check children recursively */
    for (i = 0; !inf && (i < nchildren); i++)
 		inf = try_children(display, children[i], WM_STATE);

    if (children) XFree((char *)children);
    return inf;
}

Window find_WM_STATE_window(Display *display, Window win)
{
	/* Function finds a window, at or below the specified window (win), that has a WM_STATE property. 
	   If such a window is found, it is returned; otherwise the argument window is returned. 

	   This is a direct copy from Xfree86's XmuClientWindow() function.
	*/
	Atom wm_state;
	Atom type = None;
	int format;
	unsigned long nitems, after;
	unsigned char *data;
	Window inf;

	wm_state = XInternAtom(display, "WM_STATE", True);
	if (!wm_state) return win;

	XGetWindowProperty(display, win, wm_state, 0, 0, False, AnyPropertyType, &type, &format, &nitems, &after, &data);
	if (type) return win;

	inf = try_children(display, win, wm_state);

	if (!inf) inf = win;

	return inf;
}

void set_titlebar_height(GtkWindow *gtk_win, gint height)
{
#if 0 
	/* TODO: 
	   Something is wrong. Fix this. 
	*/
	gint actual_format, actual_length;
	gint *extents = NULL;
	GdkAtom atom_net_frame_extents = gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE);
	GdkAtom atom_cardinal = gdk_atom_intern("CARDINAL", FALSE);

	if (gdk_property_get (GTK_WIDGET(gtk_win)->window, atom_net_frame_extents, atom_cardinal, 0,32,  FALSE,	NULL, 
						  &actual_format,  &actual_length,  (guchar**)&extents)  && extents) 
	{
		extents[2] = height;

		gdk_property_change(GTK_WIDGET(gtk_win)->window, atom_net_frame_extents, atom_cardinal, 32, GDK_PROP_MODE_REPLACE, (guchar*)extents, 4);

		g_free(extents);
	}
#endif
}

static void argbdata_to_pixdata(long *argb_data, int len, guchar **pixdata)
{
	/* I have borrowsed this from GNOME's code base. 
	   Copyright (C) 2002 Havoc Pennington.

	   The size of long=4 is important here so the variable "i" runs correctly over argb_data.
	   Long is 4 bytes length on 32bits and 8 on 64bits Linux.
	*/
	guchar *p;
	int i;

	*pixdata = g_new(guchar, len * 4);
	p = *pixdata;

	i = 0;
	while (i < len)
	{
		guint argb;
		guint rgba;

		argb = argb_data[i];
		rgba = (argb << 8) | (argb >> 24);

		*p = rgba >> 24;
		++p;
		*p = (rgba >> 16) & 0xff;
		++p;
		*p = (rgba >> 8) & 0xff;
		++p;
		*p = rgba & 0xff;
		++p;

		i++;
	}
}

void free_pixel_data(guchar *pixels,  gpointer data)
{
	g_free(pixels);
}

guint get_best_delay_for_window_manager()
{
	guint delay;
	if (is_compiz_wm())
		delay = 700;
	else
		delay = 350;

	return delay;
}

Show details Hide details

Change log

r111 by osmoma on Jun 15, 2009 Diff

Variables are now feeded to the command by
inserting them in the command's header
section. Eg. if the command declaration
contains 2 variables var1 and var2, then
the final command line would look like
this: bash -c 'var1=xxx; var2=yyy; mogrify
...'. The old method used a simple textual
substitution in the command text which may
cause errors.

Go to:

Project members, sign in to write a code review

Older revisions

r104 by osmoma on Apr 13, 2009 Diff

Gscreendump should now compile and run
on Ubuntu 8.04. Ubuntu 8.04 has
GTK+/GDK version 2.12.9 while some
functions require GTK+ 2.14.0 or
later. Some issues remain unsolved:
...

r102 by osmoma on Apr 12, 2009 Diff

New import after accidental delete

All revisions of this file

File info

Size: 26498 bytes, 1027 lines

View raw file