conky/cairo.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* Small example demonstrating emulating knockout-groups as in PDF-1.4
 * using cairo_set_operator().
 *
 * Owen Taylor,

 * v0.1  30 November  2002
 * v0.2   1 December  2002 - typo fixes from Keith Packard
 * v0.3  17 April     2003 - Tracking changes in Xr, (Removal of Xr{Push,Pop}Group)
 * v0.4  29 September 2003 - Use cairo_rectangle rather than private rect_path
 *			     Use cairo_arc for oval_path
 * Keeping log of changes in ChangeLog/CVS now. (2003-11-19) Carl Worth
 */
#include "conky.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <cairo.h>
#include <cairo-xlib.h>
#include <math.h>
#include <stdio.h>

/* Fill the given area with checks in the standard style
 * for showing compositing effects.
 */
static void fill_checks(cairo_t * cr, int x, int y, int width, int height)
{
	cairo_surface_t *check;
	cairo_pattern_t *check_pattern;

	cairo_save(cr);

#define CHECK_SIZE 32

	check =
	    cairo_surface_create_similar(cairo_current_target_surface(cr),
					 CAIRO_FORMAT_RGB24,
					 2 * CHECK_SIZE, 2 * CHECK_SIZE);
	cairo_surface_set_repeat(check, 1);

	/* Draw the check */
	{
		cairo_save(cr);

		cairo_set_target_surface(cr, check);

		cairo_set_operator(cr, CAIRO_OPERATOR_SRC);

		cairo_set_rgb_color(cr, 0.4, 0.4, 0.4);

		cairo_rectangle(cr, 0, 0, 2 * CHECK_SIZE, 2 * CHECK_SIZE);
		cairo_fill(cr);

		cairo_set_rgb_color(cr, 0.7, 0.7, 0.7);

		cairo_rectangle(cr, x, y, CHECK_SIZE, CHECK_SIZE);
		cairo_fill(cr);
		cairo_rectangle(cr, x + CHECK_SIZE, y + CHECK_SIZE,
				CHECK_SIZE, CHECK_SIZE);
		cairo_fill(cr);

		cairo_restore(cr);
	}

	/* Fill the whole surface with the check */

	check_pattern = cairo_pattern_create_for_surface(check);
	cairo_set_pattern(cr, check_pattern);
	cairo_rectangle(cr, 0, 0, width, height);
	cairo_fill(cr);

	cairo_pattern_destroy(check_pattern);
	cairo_surface_destroy(check);

	cairo_restore(cr);
}

static void draw_pee(cairo_t * cr, double xc, double yc)
{
	cairo_set_rgb_color(cr, 0, 0, 0);
	cairo_show_text(cr, "Conky");
}

static void draw(cairo_t * cr, int width, int height)
{
	cairo_surface_t *overlay;

	/* Fill the background */
	double xc = width / 2.;
	double yc = height / 2.;

	overlay =
	    cairo_surface_create_similar(cairo_current_target_surface(cr),
					 CAIRO_FORMAT_ARGB32, width,
					 height);
	if (overlay == NULL)
		return;

	fill_checks(cr, 0, 0, width, height);

	cairo_save(cr);
	cairo_set_target_surface(cr, overlay);

	cairo_set_alpha(cr, 0.5);
	cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
	draw_pee(cr, xc, yc);

	cairo_restore(cr);

	cairo_show_surface(cr, overlay, width, height);

	cairo_surface_destroy(overlay);
}

int do_it(void)
{
	Display *dpy;
	int screen;
	Window w;
	Pixmap pixmap;
	char *title = "cairo: Knockout Groups";
	unsigned int quit_keycode;
	int needs_redraw;
	GC gc;
	XWMHints *wmhints;
	XSizeHints *normalhints;
	XClassHint *classhint;

	int width = 400;
	int height = 400;

	dpy = XOpenDisplay(NULL);
	screen = DefaultScreen(dpy);

	w = XCreateSimpleWindow(dpy, RootWindow(dpy, screen),
				0, 0, width, height, 0,
				BlackPixel(dpy, screen), WhitePixel(dpy,
								    screen));

	normalhints = XAllocSizeHints();
	normalhints->flags = 0;
	normalhints->x = 0;
	normalhints->y = 0;
	normalhints->width = width;
	normalhints->height = height;

	classhint = XAllocClassHint();
	classhint->res_name = "cairo-knockout";
	classhint->res_class = "Cairo-knockout";

	wmhints = XAllocWMHints();
	wmhints->flags = InputHint;
	wmhints->input = True;

	XmbSetWMProperties(dpy, w, title, "cairo-knockout", 0, 0,
			   normalhints, wmhints, classhint);
	XFree(wmhints);
	XFree(classhint);
	XFree(normalhints);

	pixmap =
	    XCreatePixmap(dpy, w, width, height,
			  DefaultDepth(dpy, screen));
	gc = XCreateGC(dpy, pixmap, 0, NULL);

	quit_keycode = XKeysymToKeycode(dpy, XStringToKeysym("Q"));

	XSelectInput(dpy, w,
		     ExposureMask | StructureNotifyMask | ButtonPressMask |
		     KeyPressMask);
	XMapWindow(dpy, w);

	needs_redraw = 1;

	while (1) {
		XEvent xev;

		/* Only do the redraw if there are no events pending.  This
		 * avoids us getting behind doing several redraws for several
		 * consecutive resize events for example.
		 */
		if (!XPending(dpy) && needs_redraw) {
			cairo_t *cr = cairo_create();

			cairo_set_target_drawable(cr, dpy, pixmap);

			draw(cr, width, height);

			cairo_destroy(cr);

			XCopyArea(dpy, pixmap, w, gc,
				  0, 0, width, height, 0, 0);

			needs_redraw = 0;
		}

		XNextEvent(dpy, &xev);

		switch (xev.xany.type) {
		case ButtonPress:
			/* A click on the canvas ends the program */
			goto DONE;
		case KeyPress:
			if (xev.xkey.keycode == quit_keycode)
				goto DONE;
			break;
		case ConfigureNotify:
			/* Note new size and create new pixmap. */
			width = xev.xconfigure.width;
			height = xev.xconfigure.height;
			XFreePixmap(dpy, pixmap);
			pixmap =
			    XCreatePixmap(dpy, w, width, height,
					  DefaultDepth(dpy, screen));
			needs_redraw = 1;
			break;
		case Expose:
			XCopyArea(dpy, pixmap, w, gc,
				  xev.xexpose.x, xev.xexpose.y,
				  xev.xexpose.width, xev.xexpose.height,
				  xev.xexpose.x, xev.xexpose.y);
			break;
		}
	}
      DONE:

	XFreeGC(dpy, gc);
	XCloseDisplay(dpy);

	return 0;
}