path: root/src/window.c

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "Xlib-wayland.h"

#include "private.h"

struct csx_window *
csx_window_create(struct csx_display *display, struct csx_window *parent)
{
	struct csx_window *window;

	window = malloc(sizeof *window);
	if (window == NULL)
		return 0; /* FIXME: BadAlloc */ 

	memset(window, 0, sizeof *window);
	window->id = csx_display_add_resource(display, window);
	window->parent = parent;

	window->display = display;
	wl_list_init(&window->child_list);
	if (parent) 
		wl_list_insert(&parent->child_list, &window->link);
	pixman_region32_init(&window->output_clip);

	return window;
}

struct csx_window *
csx_window_pick(struct csx_window *window,
		int x, int y, int *local_x, int *local_y)
{
	struct csx_window *w;

	wl_list_for_each(w, &window->child_list, link) {
		if (w->mapped && w->x <= x & w->y <= y &&
		    x < w->x + w->width && y < w->y + w->height)
			return csx_window_pick(w, x - w->x, y - w->y,
					       local_x, local_y);
	}

	*local_x = x;
	*local_y = y;

	return window;
}

void
csx_window_send_create_notify(struct csx_window *window)
{
	struct csx_display *display = window->display;
	struct csx_event *event;

	event = malloc(sizeof *event);

	event->xevent.xcreatewindow.type = CreateNotify;
	event->xevent.xcreatewindow.serial = display->serial;
	event->xevent.xcreatewindow.send_event = False;
	event->xevent.xcreatewindow.display = display->xdisplay;
	event->xevent.xcreatewindow.parent = window->parent->id;
	event->xevent.xcreatewindow.window = window->id;
	event->xevent.xcreatewindow.x = window->x;
	event->xevent.xcreatewindow.y = window->y;
	event->xevent.xcreatewindow.width = window->width;
	event->xevent.xcreatewindow.height = window->height;
	event->xevent.xcreatewindow.border_width = window->border_width;
	event->xevent.xcreatewindow.override_redirect = False;

	wl_list_insert(display->event_list.prev, &event->link);
}

WL_EXPORT Window
XCreateWindow(Display *xdisplay, Window xparent, int x, int y,
	      unsigned int width, unsigned int height,
	      unsigned int border_width, int depth,
	      unsigned int class, Visual *visual,
	      unsigned long valuemask,
	      XSetWindowAttributes *attributes)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window, *parent;
	int i;

	parent = csx_display_lookup_resource(display, xparent);
	if (parent == NULL)
		/* do something, really */;

	window = csx_window_create(display, parent);
	if (window == NULL) {
		csx_display_bad_alloc(display);
		return None;
	}

	window->x = x;
	window->y = y;
	window->width = width;
	window->height = height;
	window->border_width = border_width;
	window->depth = depth;
	window->class = class;
	window->visual = visual;

	for (i = 0; i < 15; i++) {
		switch (valuemask & (1 << i)) {
		case CWBackPixmap:
		case CWBackPixel:
		case CWBorderPixmap:
		case CWBorderPixel:
		case CWBitGravity:
		case CWWinGravity:
		case CWBackingStore:
		case CWBackingPlanes:
		case CWBackingPixel:
		case CWOverrideRedirect:
		case CWSaveUnder:
			break;
		case CWEventMask:
			window->event_mask = attributes->event_mask;
			break;
		case CWDontPropagate:
		case CWColormap:
		case CWCursor:
			break;
		}
	}

	if (parent->event_mask & SubstructureNotifyMask)
		csx_window_send_create_notify(window);

	return window->id;
}

WL_EXPORT Window
XCreateSimpleWindow(Display *xdisplay, Window parent, int x, int y,
		    unsigned int width, unsigned int height,
		    unsigned int border_width, unsigned long border,
		    unsigned long background)
{
	unsigned long valuemask;
	XSetWindowAttributes attributes;

	attributes.background_pixel = background;
	attributes.border_pixel = border;
	return XCreateWindow(xdisplay, parent, x, y, width, height,
			     border_width, 0, CopyFromParent, CopyFromParent,
			     CWBackPixel | CWBorderPixel, &attributes);
}

static void
handle_ping(void *data, struct wl_shell_surface *shell_surface,
	    uint32_t serial)
{
	wl_shell_surface_pong(shell_surface, serial);
}

static void
handle_configure(void *data, struct wl_shell_surface *shell_surface,
		 uint32_t edges, int32_t width, int32_t height)
{
}

static void
handle_popup_done(void *data, struct wl_shell_surface *shell_surface)
{
}

static const struct wl_shell_surface_listener shell_surface_listener = {
	handle_ping,
	handle_configure,
	handle_popup_done
};

void
csx_display_send_map_notify(struct csx_display *display,
			    struct csx_window *window)
{
	struct csx_event *event;

	if (!(window->event_mask & StructureNotifyMask))
		return;

	event = malloc(sizeof *event);
	event->xevent.type = MapNotify;

	event->xevent.xmap.type = MapNotify;
	event->xevent.xmap.serial = display->serial;
	event->xevent.xmap.send_event = False;
	event->xevent.xmap.display = display->xdisplay;
	event->xevent.xmap.event = window->id;
	event->xevent.xmap.window = window->id;
	event->xevent.xmap.override_redirect = False;

	wl_list_insert(display->event_list.prev, &event->link);
}

void
csx_window_map_tree(struct csx_window *window, struct csx_pixmap *pixmap)
{
	struct csx_window *child;

	wl_list_for_each(child, &window->child_list, link)
		csx_window_map_tree(child, pixmap);

	window->pixmap = pixmap;
	csx_display_send_map_notify(window->display, window);
}

void
csx_window_map_toplevel(struct csx_window *window)
{
	struct csx_display *display = window->display;
	struct csx_pixmap *pixmap;

	pixmap = csx_pixmap_create(window->display,
				   window->width, window->height, 32);
	csx_window_map_tree(window, pixmap);

	window->surface = wl_compositor_create_surface(display->compositor);
	wl_surface_set_user_data(window->surface, window);
	wl_surface_attach(window->surface, window->pixmap->buffer, 0, 0);
	window->shell_surface =
		wl_shell_get_shell_surface(display->shell, window->surface);
	wl_shell_surface_add_listener(window->shell_surface,
				      &shell_surface_listener, window);
	wl_shell_surface_set_toplevel(window->shell_surface);
	wl_surface_commit(window->surface);
}

WL_EXPORT int
XMapWindow(Display *xdisplay, Window xwindow)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;
	struct csx_pixmap *pixmap;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}
	
	if (window->mapped)
		/* Already mapped */
		return 0;

	window->mapped = 1;
	if (window->parent == display->root) {
		csx_window_map_toplevel(window);
	} else if (window->parent->mapped) {
		window->pixmap = window->parent->pixmap;
		csx_display_send_map_notify(display, window);
	}

}

WL_EXPORT int
XMapSubwindows(Display *display, Window xwindow)
{
}

WL_EXPORT int
XChangeWindowAttributes(Display *xdisplay, Window xwindow,
			unsigned long mask, XSetWindowAttributes *attributes)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}
}

WL_EXPORT int
XConfigureWindow(Display *xdisplay, Window xwindow,
		 unsigned int mask, XWindowChanges *values)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}

	if (mask & CWX)
		window->x = values->x;
	if (mask & CWY)
		window->y = values->y;
	if (mask & CWWidth)
		window->width = values->width;
	if (mask & CWHeight)
		window->height = values->height;

	/* Send out events as necessary: exposures, configure notify etc */
}

WL_EXPORT int
XReparentWindow(Display *xdisplay, Window xwindow,
		Window xparent, int x, int y)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window, *parent;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}

	parent = csx_display_lookup_resource(display, xparent);
	if (parent == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}

	/* FIXME: Lot more to do here... */
	wl_list_remove(&window->link);
	wl_list_insert(&parent->child_list, &window->link);
}

WL_EXPORT int
XResizeWindow(Display *xdisplay, Window xwindow,
	      unsigned int width, unsigned int height)
{
	XWindowChanges values;

	values.width = width;
	values.height = height;

	return XConfigureWindow(xdisplay, xwindow,
				CWWidth | CWHeight, &values);
}

WL_EXPORT int
XMoveResizeWindow(Display *xdisplay, Window xwindow,
		  int x, int y, unsigned int width, unsigned int height)
{
	XWindowChanges values;

	values.x = x;
	values.y = y;
	values.width = width;
	values.height = height;

	return XConfigureWindow(xdisplay, xwindow,
				CWX | CWY | CWWidth | CWHeight, &values);
}

WL_EXPORT int
XMoveWindow(Display *xdisplay, Window xwindow, int x, int y)
{
	XWindowChanges values;

	values.x = x;
	values.y = y;

	return XConfigureWindow(xdisplay, xwindow, CWX | CWY, &values);
}

WL_EXPORT int
XLowerWindow(Display *xdisplay, Window xwindow)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}
}

WL_EXPORT int
XRaiseWindow(Display *display, Window xwindow)
{
}

WL_EXPORT int
XMapRaised(Display *xdisplay, Window xwindow)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL) {
		csx_display_bad_window(display);
		return 0; /* what's the return value? */
	}
}

void
csx_window_destroy(struct csx_window *window)
{
	struct csx_window *child, *next;
	struct csx_event *event;

	wl_list_for_each_safe(child, next, &window->child_list, link)
		csx_window_destroy(child);

#if 0
	event = csx_display_create_event(display);
	event->xevent.type = DestroyNotify;
#endif

	csx_display_remove_resource(window->display, window->id);
	wl_list_remove(&window->link);
	free(window);
}

WL_EXPORT int
XDestroyWindow(Display *xdisplay, Window xwindow)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL)
		/* BadWindow */;
	if (window == display->root)
		return;

	csx_window_destroy(window);

	return 0; /* return what? */
}

WL_EXPORT int
XDestroySubwindows(Display *xdisplay, Window xwindow)
{
	struct csx_display *display = csx_display(xdisplay);
	struct csx_window *window, *child, *next;

	window = csx_display_lookup_resource(display, xwindow);
	if (window == NULL)
		/* BadWindow */;

	wl_list_for_each_reverse_safe(child, next, &window->child_list, link)
		csx_window_destroy(child);
}