--- /dev/null
+/*
+ * Copyright © 2010 Kristian Høgsberg
+ *
+ * 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.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <math.h>
+#include <sys/time.h>
+#include <cairo.h>
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "wayland-client.h"
+#include "wayland-glib.h"
+
+#include "window.h"
+
+static const char socket_name[] = "\0wayland";
+
+struct dnd {
+ struct window *window;
+ struct display *display;
+ uint32_t key;
+ struct item *items[16];
+};
+
+struct item {
+ cairo_surface_t *surface;
+ int x, y;
+};
+
+static const int item_width = 64;
+static const int item_height = 64;
+static const int item_padding = 16;
+
+static struct item *
+item_create(struct display *display, int x, int y)
+{
+ const int petal_count = 3 + random() % 5;
+ const double r1 = 20 + random() % 10;
+ const double r2 = 5 + random() % 12;
+ const double u = (10 + random() % 90) / 100.0;
+ const double v = (random() % 90) / 100.0;
+
+ cairo_t *cr;
+ int i;
+ double t, dt = 2 * M_PI / (petal_count * 2);
+ double x1, y1, x2, y2, x3, y3;
+ struct rectangle rect;
+ struct item *item;
+
+ item = malloc(sizeof *item);
+ if (item == NULL)
+ return NULL;
+
+ rect.width = item_width;
+ rect.height = item_height;
+ item->surface = display_create_surface(display, &rect);
+
+ item->x = x;
+ item->y = y;
+
+ cr = cairo_create(item->surface);
+ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+ cairo_set_source_rgba(cr, 0, 0, 0, 0);
+ cairo_paint(cr);
+
+ cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+ cairo_translate(cr, item_width / 2, item_height / 2);
+ t = random();
+ cairo_move_to(cr, cos(t) * r1, sin(t) * r1);
+ for (i = 0; i < petal_count; i++, t += dt * 2) {
+ x1 = cos(t) * r1;
+ y1 = sin(t) * r1;
+ x2 = cos(t + dt) * r2;
+ y2 = sin(t + dt) * r2;
+ x3 = cos(t + 2 * dt) * r1;
+ y3 = sin(t + 2 * dt) * r1;
+
+ cairo_curve_to(cr,
+ x1 - y1 * u, y1 + x1 * u,
+ x2 + y2 * v, y2 - x2 * v,
+ x2, y2);
+
+ cairo_curve_to(cr,
+ x2 - y2 * v, y2 + x2 * v,
+ x3 + y3 * u, y3 - x3 * u,
+ x3, y3);
+ }
+
+ cairo_close_path(cr);
+
+ cairo_set_source_rgba(cr,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 100) / 99.0);
+
+ cairo_fill_preserve(cr);
+
+ cairo_set_line_width(cr, 1);
+ cairo_set_source_rgba(cr,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 50) / 49.0,
+ 0.5 + (random() % 100) / 99.0);
+ cairo_stroke(cr);
+
+ cairo_destroy(cr);
+
+ return item;
+}
+
+static void
+dnd_draw(struct dnd *dnd)
+{
+ struct rectangle rectangle;
+ cairo_t *cr;
+ cairo_surface_t *wsurface, *surface;
+ int i;
+
+ window_draw(dnd->window);
+
+ window_get_child_rectangle(dnd->window, &rectangle);
+
+ wsurface = window_get_surface(dnd->window);
+ surface = cairo_surface_create_similar(wsurface,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ rectangle.width,
+ rectangle.height);
+
+ cr = cairo_create(surface);
+ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+ cairo_set_source_rgba(cr, 0, 0, 0, 0.8);
+ cairo_paint(cr);
+
+ cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+ for (i = 0; i < ARRAY_LENGTH(dnd->items); i++) {
+ if (!dnd->items[i])
+ continue;
+ cairo_set_source_surface(cr, dnd->items[i]->surface,
+ dnd->items[i]->x, dnd->items[i]->y);
+ cairo_paint(cr);
+ }
+
+ cairo_destroy(cr);
+
+ window_copy_surface(dnd->window, &rectangle, surface);
+ window_commit(dnd->window, dnd->key);
+ cairo_surface_destroy(surface);
+}
+
+static void
+redraw_handler(struct window *window, void *data)
+{
+ struct dnd *dnd = data;
+
+ dnd_draw(dnd);
+}
+
+static void
+keyboard_focus_handler(struct window *window,
+ struct input *device, void *data)
+{
+ struct dnd *dnd = data;
+
+ window_schedule_redraw(dnd->window);
+}
+
+static struct item *
+dnd_get_item(struct dnd *dnd, int32_t x, int32_t y)
+{
+ struct item *item;
+ int i;
+
+ for (i = 0; i < ARRAY_LENGTH(dnd->items); i++) {
+ item = dnd->items[i];
+ if (item &&
+ item->x <= x && x < item->x + item_width &&
+ item->y <= y && y < item->y + item_height)
+ return item;
+ }
+
+ return NULL;
+}
+
+static void
+dnd_button_handler(struct window *window,
+ struct input *input, uint32_t time,
+ int button, int state, void *data)
+{
+ struct dnd *dnd = data;
+ int32_t x, y, hotspot_x, hotspot_y, pointer_width, pointer_height;
+ struct rectangle rectangle;
+ struct item *item;
+ struct wl_buffer *buffer;
+ cairo_surface_t *surface, *pointer;
+ cairo_t *cr;
+
+ input_get_position(input, &x, &y);
+ window_get_child_rectangle(dnd->window, &rectangle);
+
+ x -= rectangle.x;
+ y -= rectangle.y;
+ item = dnd_get_item(dnd, x, y);
+
+ if (item && state == 1) {
+ fprintf(stderr, "start drag, item %p\n", item);
+
+ pointer = display_get_pointer_surface(dnd->display,
+ POINTER_DRAGGING,
+ &pointer_width,
+ &pointer_height,
+ &hotspot_x,
+ &hotspot_y);
+
+ rectangle.width = item_width + 2 * pointer_width;
+ rectangle.height = item_height + 2 * pointer_height;
+ surface = display_create_surface(dnd->display, &rectangle);
+
+ cr = cairo_create(surface);
+ cairo_translate(cr, pointer_width, pointer_height);
+
+ cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
+ cairo_set_source_rgba(cr, 0, 0, 0, 0);
+ cairo_paint(cr);
+
+ cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+ cairo_set_source_surface(cr, item->surface, 0, 0);
+ cairo_paint(cr);
+
+ cairo_set_source_surface(cr, pointer,
+ x - item->x - hotspot_x,
+ y - item->y - hotspot_y);
+ cairo_surface_destroy(pointer);
+ cairo_paint(cr);
+ cairo_destroy(cr);
+
+ buffer = display_get_buffer_for_surface(dnd->display,
+ surface);
+ window_start_drag(window, input, time,
+ buffer,
+ pointer_width + x - item->x,
+ pointer_height + y - item->y);
+
+ /* FIXME: We leak the surface because we can't free it
+ * until the server has referenced it. */
+ }
+}
+
+static int
+dnd_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 dnd *dnd = data;
+ struct item *item;
+ struct rectangle rectangle;
+
+ window_get_child_rectangle(dnd->window, &rectangle);
+ item = dnd_get_item(dnd, sx - rectangle.x, sy - rectangle.y);
+
+ if (item)
+ return POINTER_HAND1;
+ else
+ return POINTER_LEFT_PTR;
+}
+
+static struct dnd *
+dnd_create(struct display *display)
+{
+ struct dnd *dnd;
+ gchar *title;
+ int i, x, y;
+ struct rectangle rectangle;
+
+ dnd = malloc(sizeof *dnd);
+ if (dnd == NULL)
+ return dnd;
+ memset(dnd, 0, sizeof *dnd);
+
+ title = g_strdup_printf("Wayland Drag and Drop Demo");
+
+ dnd->window = window_create(display, title, 100, 100, 500, 400);
+ dnd->display = display;
+ dnd->key = 100;
+
+ for (i = 0; i < ARRAY_LENGTH(dnd->items); i++) {
+ x = (i % 4) * (item_width + item_padding) + item_padding;
+ y = (i / 4) * (item_height + item_padding) + item_padding;
+ if ((i ^ (i >> 2)) & 1)
+ dnd->items[i] = item_create(display, x, y);
+ else
+ dnd->items[i] = NULL;
+ }
+
+ window_set_user_data(dnd->window, dnd);
+ window_set_redraw_handler(dnd->window, redraw_handler);
+ window_set_keyboard_focus_handler(dnd->window,
+ keyboard_focus_handler);
+ window_set_button_handler(dnd->window,
+ dnd_button_handler);
+
+ window_set_motion_handler(dnd->window,
+ dnd_motion_handler);
+
+ rectangle.width = 4 * (item_width + item_padding) + item_padding;
+ rectangle.height = 4 * (item_height + item_padding) + item_padding;
+ window_set_child_size(dnd->window, &rectangle);
+
+ dnd_draw(dnd);
+
+ return dnd;
+}
+
+static const GOptionEntry option_entries[] = {
+ { NULL }
+};
+
+int
+main(int argc, char *argv[])
+{
+ struct display *d;
+ struct dnd *dnd;
+ struct timeval tv;
+
+ gettimeofday(&tv, NULL);
+ srandom(tv.tv_usec);
+
+ d = display_create(&argc, &argv, option_entries);
+
+ dnd = dnd_create (d);
+
+ display_run(d);
+
+ return 0;
+}
projects / platform / upstream / weston.git / commitdiff