document the usage of libtoytoolkit

(krh: edited to follow window_create() API changes)

clients/.gitignore

@@ -1,4 +1,5 @@
 dnd
+eventdemo
 flower
 gears
 image

clients/Makefile.am

@@ -8,7 +8,8 @@ noinst_PROGRAMS =				\
 	dnd					\
 	smoke					\
 	resizor					\
-	simple-client
+	simple-client				\
+	eventdemo
 
 noinst_LTLIBRARIES = libtoytoolkit.la
 
@@ -60,6 +61,9 @@ simple_client_SOURCES = simple-client.c
 simple_client_LDADD = \
 	$(top_builddir)/wayland/libwayland-client.la -lm $(GLES2_LIBS)
 
+eventdemo_SOURCES = eventdemo.c
+eventdemo_LDADD = $(toolkit_libs)
+
 BUILT_SOURCES =					\
 	screenshooter-client-protocol.h		\
 	screenshooter-protocol.c

clients/eventdemo.c

@@ -0,0 +1,396 @@
+/*
+ * Copyright © 2011 Tim Wiederhake
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+/**
+ * \file eventdemo.c
+ * \brief Demonstrate the use of Wayland's toytoolkit.
+ *
+ * Heavily commented demo program that can report all events that are
+ * dispatched to the window. For other functionality, eg. opengl/egl,
+ * drag and drop, etc. have a look at the other demos.
+ * \author Tim Wiederhake
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <cairo.h>
+#include <glib.h>
+
+#include "window.h"
+
+/** window title */
+static char *title = "EventDemo";
+
+/** window width */
+static int width = 500;
+
+/** window height */
+static int height = 400;
+
+/** set if window has no borders */
+static int noborder = 0;
+
+/** if non-zero, maximum window width */
+static int width_max = 0;
+
+/** if non-zero, maximum window height */
+static int height_max = 0;
+
+/** set to log redrawing */
+static int log_redraw = 0;
+
+/** set to log resizing */
+static int log_resize = 0;
+
+/** set to log keyboard focus */
+static int log_focus = 0;
+
+/** set to log key events */
+static int log_key = 0;
+
+/** set to log button events */
+static int log_button = 0;
+
+/** set to log motion events */
+static int log_motion = 0;
+
+/**
+ * \struct eventdemo
+ * \brief Holds all data the program needs per window
+ *
+ * In this demo the struct holds the position of a
+ * red rectangle that is drawn in the window's area.
+ */
+struct eventdemo {
+	struct window *window;
+	struct display *display;
+
+	unsigned int x, y, w, h;
+};
+
+/**
+ * \brief Redraws the window
+ *
+ * Draws a red rectangle as demonstration of per-window data.
+ */
+static void
+eventdemo_draw(struct eventdemo *e) {
+	if (log_redraw)
+		printf("redraw\n");
+
+	cairo_surface_t *surface;
+	cairo_t *cr;
+	struct rectangle rect;
+
+	window_draw(e->window);
+	window_get_child_allocation(e->window, &rect);
+	surface = window_get_surface(e->window);
+
+	cr = cairo_create(surface);
+	cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+
+	cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
+	cairo_set_source_rgba(cr, 0, 0, 0, 0.8);
+	cairo_fill(cr);
+
+	cairo_rectangle(cr, e->x, e->y, e->w, e->h);
+	cairo_set_source_rgba(cr, 1.0, 0, 0, 1);
+	cairo_fill(cr);
+
+	cairo_destroy(cr);
+	cairo_surface_destroy(surface);
+	window_flush(e->window);
+}
+
+/**
+ * \brief CALLBACK function, Wayland requests the window to redraw.
+ * \param window window to be redrawn
+ * \param data user data associated to the window
+ */
+static void
+redraw_handler(struct window *window, void *data)
+{
+	struct eventdemo *e = data;
+	eventdemo_draw(e);
+}
+
+/**
+ * \brief CALLBACK function, Wayland requests the window to resize.
+ * \param window window to be resized
+ * \param width desired width
+ * \param height desired height
+ * \param data user data associated to the window
+ */
+
+static void
+resize_handler(struct window *window,
+	       int32_t width, int32_t height, void *data)
+{
+	struct eventdemo *e = data;
+	if (log_resize)
+		printf("resize width: %d, height: %d\n", width, height);
+
+	/* if a maximum width is set, constrain to it */
+	if (width_max && width_max < width)
+		width = width_max;
+
+	/* if a maximum height is set, constrain to it */
+	if (height_max && height_max < height)
+		height = height_max;
+
+	/* set the new window dimensions */
+	window_set_child_size(e->window, width, height);
+
+	/* inform Wayland that the window needs to be redrawn */
+	window_schedule_redraw(e->window);
+}
+
+/**
+ * \brief CALLBACK function, Wayland informs about keyboard focus change
+ * \param window window
+ * \param device device that caused the focus change
+ * \param data user data associated to the window
+ */
+static void
+keyboard_focus_handler(struct window *window,
+		       struct input *device, void *data)
+{
+	int32_t x, y;
+	struct eventdemo *e = data;
+
+	if(log_focus) {
+		if(device) {
+			input_get_position(device, &x, &y);
+			printf("focus x: %d, y: %d\n", x, y);
+		} else {
+			printf("focus lost\n");
+		}
+	}
+
+	window_schedule_redraw(e->window);
+}
+
+/**
+ * \brief CALLBACK function, Wayland informs about key event
+ * \param window window
+ * \param key keycode
+ * \param unicode associated character
+ * \param state pressed or released
+ * \param modifiers modifiers: ctrl, alt, meta etc.
+ * \param data user data associated to the window
+ */
+static void
+key_handler(struct window *window, struct input *input, uint32_t time,
+            uint32_t key, uint32_t unicode, uint32_t state, void *data)
+{
+	uint32_t modifiers = input_get_modifiers(input);
+
+	if(!log_key)
+		return;
+
+	printf("key key: %d, unicode: %d, state: %d, modifiers: %d\n",
+	       key, unicode, state, modifiers);
+}
+
+/**
+ * \brief CALLBACK function, Wayland informs about button event
+ * \param window window
+ * \param input input device that caused the button event
+ * \param time time the event happend
+ * \param button button
+ * \param state pressed or released
+ * \param data user data associated to the window
+ */
+static void
+button_handler(struct window *window, struct input *input, uint32_t time,
+	       int button, int state, void *data)
+{
+	int32_t x, y;
+
+	if (!log_button)
+		return;
+
+	input_get_position(input, &x, &y);
+	printf("button time: %d, button: %d, state: %d, x: %d, y: %d\n",
+	       time, button, state, x, y);
+}
+
+/**
+ * \brief CALLBACK function, Waylands informs about pointer motion
+ * \param window window
+ * \param input input device that caused the motion event
+ * \param time time the event happend
+ * \param x absolute x position
+ * \param y absolute y position
+ * \param sx x position relative to the window
+ * \param sy y position relative to the window
+ * \param data user data associated to the window
+ *
+ * Demonstrates the use of different cursors
+ */
+static int
+motion_handler(struct window *window, struct input *input, uint32_t time,
+	       int32_t x, int32_t y, int32_t sx, int32_t sy, void *data)
+{
+	struct eventdemo *e = data;
+
+	if (log_motion) {
+		printf("motion time: %d, x: %d, y: %d, sx: %d, sy: %d\n",
+		       time, x, y, sx, sy);
+	}
+
+	if(sx > e->x && sx < e->x + e->w)
+		if(sy > e->y && sy < e->y + e->h)
+			return POINTER_HAND1;
+
+	return POINTER_LEFT_PTR;
+}
+
+/**
+ * \brief Create and initialise a new eventdemo window.
+ * \param d associated display
+ */
+static struct eventdemo *
+eventdemo_create(struct display *d)
+{
+	struct eventdemo *e;
+
+	e = malloc(sizeof (struct eventdemo));
+	if(e == NULL)
+		return NULL;
+
+	/* Creates a new window with the given title, width and height.
+	 * To set the size of the window for a given usable areas width
+	 * and height in a window decoration agnostic way use:
+	 * 	window_set_child_size(struct window *window,
+	 *			      int32_t width, int32_t height);
+	 */
+	e->window = window_create(d, width, height);
+	window_set_title(e->window, title);
+	e->display = d;
+
+	/* The eventdemo window draws a red rectangle as a demonstration
+	 * of per-window data. The dimensions of that rectangle are set
+	 * here.
+	 */
+	e->x = width * 1.0 / 4.0;
+	e->w = width * 2.0 / 4.0;
+	e->y = height * 1.0 / 4.0;
+	e->h = height * 2.0 / 4.0;
+
+	/* Connect the user data to the window */
+	window_set_user_data(e->window, e);
+
+	/* Set the callback redraw handler for the window */
+	window_set_redraw_handler(e->window, redraw_handler);
+
+	/* Set the callback resize handler for the window */
+	window_set_resize_handler(e->window, resize_handler);
+
+	/* Set the callback focus handler for the window */
+	window_set_keyboard_focus_handler(e->window,
+					  keyboard_focus_handler);
+
+	/* Set the callback key handler for the window */
+	window_set_key_handler(e->window, key_handler);
+
+	/* Set the callback button handler for the window */
+	window_set_button_handler(e->window, button_handler);
+
+	/* Set the callback motion handler for the window */
+	window_set_motion_handler(e->window, motion_handler);
+
+	/* Demonstrate how to create a borderless window.
+	   Move windows with META + left mouse button.
+	 */
+	if(noborder) {
+		window_set_decoration(e->window, 0);
+	}
+
+	/* Initial drawing of the window */
+	eventdemo_draw(e);
+
+	return e;
+}
+/**
+ * \brief command line options for eventdemo
+ *
+ * see
+ * http://developer.gimp.org/api/2.0/glib/glib-Commandline-option-parser.html
+ */
+static const GOptionEntry option_entries[] = {
+	{"title", 0, 0, G_OPTION_ARG_STRING,
+	 &title, "Set the window title to TITLE", "TITLE"},
+	{"width", 'w', 0, G_OPTION_ARG_INT,
+	 &width, "Set the window's width to W", "W"},
+	{"height", 'h', 0, G_OPTION_ARG_INT,
+	 &height, "Set the window's height to H", "H"},
+	{"maxwidth", 0, 0, G_OPTION_ARG_INT,
+	 &width_max, "Set the window's maximum width to W", "W"},
+	{"maxheight", 0, 0, G_OPTION_ARG_INT,
+	 &height_max, "Set the window's maximum height to H", "H"},
+	{"noborder", 'b', 0, G_OPTION_ARG_NONE,
+	 &noborder, "Don't draw window borders", 0},
+	{"log-redraw", 0, 0, G_OPTION_ARG_NONE,
+	 &log_redraw, "Log redraw events to stdout", 0},
+	{"log-resize", 0, 0, G_OPTION_ARG_NONE,
+	 &log_resize, "Log resize events to stdout", 0},
+	{"log-focus", 0, 0, G_OPTION_ARG_NONE,
+	 &log_focus, "Log keyboard focus events to stdout", 0},
+	{"log-key", 0, 0, G_OPTION_ARG_NONE,
+	 &log_key, "Log key events to stdout", 0},
+	{"log-button", 0, 0, G_OPTION_ARG_NONE,
+	 &log_button, "Log button events to stdout", 0},
+	{"log-motion", 0, 0, G_OPTION_ARG_NONE,
+	 &log_motion, "Log motion events to stdout", 0},
+	{NULL}
+};
+
+/**
+ * \brief Connects to the display, creates the window and hands over
+ * to the main loop.
+ */
+int
+main(int argc, char *argv[])
+{
+	struct display *d;
+	struct eventdemo *e;
+
+	/* Connect to the display and have the arguments parsed */
+	d = display_create(&argc, &argv, option_entries);
+	if (d == NULL) {
+		fprintf(stderr, "failed to create display: %m\n");
+		return -1;
+	}
+
+	/* Create new eventdemo window */
+	e = eventdemo_create(d);
+	if (e == NULL) {
+		fprintf(stderr, "failed to create eventdemo: %m\n");
+		return -1;
+	}
+
+	display_run(d);
+
+	return 0;
+}