util/gfx/win.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdlib.h>
#include "assert.h"
#include "gfx/win.h"
#include <membag.h>
#include <ring.h>
#include <workqueue.h>

#ifdef CONFIG_GFX_WIN_USE_TOUCH
# include <touch/touch.h>
#endif

struct win_window {
        struct win_attributes attributes;

        struct win_window *parent;
        struct win_window *prev_sibling;
        struct win_window *next_sibling;
        struct win_window *top_child;

        bool is_mapped;
};



struct win_event_queue {
        struct ring_head        ring;
        struct workqueue_task   task;
        struct win_event        buffer[WIN_EVENT_QUEUE_SIZE];
};



/*
 * Private prototypes are required due to circular references of the functions.
 */

static bool win_is_visible(const struct win_window *win);

static void win_draw(
                const struct win_window *win,
                const struct win_area *dirty_area);

static void win_draw_parent(
                const struct win_window *child,
                const struct win_area *dirty_area);

static void win_draw_contents(
                const struct win_window *win,
                const struct win_clip_region *clip);

static void win_draw_child(
                const struct win_window *child,
                const struct win_clip_region *parentClip);

static bool win_translate_area_to_parent(
                struct win_area *area,
                const struct win_window *parent);

static void win_destroy_children(struct win_window *win);

static void win_unlink(struct win_window *win);

static void win_add_top_child(
                struct win_window *parent,
                struct win_window *child);

static void win_process_pointer_event(struct win_pointer_event *event);

static bool win_handle_pointer_event(
                struct win_window *win,
                const struct win_pointer_event *event,
                const struct win_point *pos);

static bool win_handle_event(
                struct win_window *win,
                enum win_event_type type,
                const void *data);

#ifdef CONFIG_GFX_WIN_USE_TOUCH

static void win_queue_touch_event(const struct touch_event *event);
#endif

static void win_queue_event(const struct win_event *event);

static void win_event_worker(struct workqueue_task *task);




static struct win_window win_root;

static struct win_event_queue win_event_queue;

static uint32_t win_num_dropped_events;

static struct win_window *win_pointer_grabber;
static struct win_window *win_keyboard_focus;

static struct win_point win_last_pointer_pos;

static struct gfx_bitmap win_root_background = {
                .type = BITMAP_SOLID,
                .data.color = GFX_COLOR(0, 0, 0),
};


void win_init(void)
{
        // Setup root window attributes to fill entire screen, no event handler.
        win_root.attributes.area.size.x = gfx_get_width();
        win_root.attributes.area.size.y = gfx_get_height();
        win_root.attributes.background = &win_root_background;

        // Initialize the event queue
        build_assert(!(WIN_EVENT_QUEUE_SIZE & (WIN_EVENT_QUEUE_SIZE - 1)));
        workqueue_task_init(&win_event_queue.task, win_event_worker);

        // Global states.
        win_keyboard_focus = &win_root;
        win_last_pointer_pos.x = gfx_get_width() / 2;
        win_last_pointer_pos.y = gfx_get_height() / 2;

#ifdef CONFIG_GFX_WIN_USE_TOUCH
        // Hook into touch driver.
        touch_set_event_handler(win_queue_touch_event);
#endif
}


struct win_window *win_get_root(void)
{
        return &win_root;
}


struct win_window *win_get_parent(const struct win_window *win)
{
        return win->parent;
}


void win_reset_root_geometry(void)
{
        // Reset to new fullscreen size.
        win_root.attributes.area.size.x = gfx_get_width();
        win_root.attributes.area.size.y = gfx_get_height();

        // Send size change event.
        win_attribute_mask_t mask = WIN_ATTR_SIZE;
        win_handle_event(&win_root, WIN_EVENT_ATTRIBUTES, &mask);

        // Now, redraw everything, if it is visible.
        win_redraw(&win_root);
}


void win_set_attributes(struct win_window *win,
                const struct win_attributes *new_attributes,
                win_attribute_mask_t attribute_mask)
{
        // Don't need redraw until some attribute change calls for it.
        bool needs_redraw = false;
        struct win_area dirty_area;

        // Sanity check.
        assert(win != NULL);
        assert(new_attributes != NULL);

        // Keep track of which areas are updated. Start with an area equal to
        // to the window itself, possibly extending it on move or resize.
        dirty_area = win->attributes.area;

        // Change background if requested.
        if (attribute_mask & WIN_ATTR_BACKGROUND) {
                win->attributes.background = new_attributes->background;

                needs_redraw = true;
        }

        // Change event handler if requested.
        if (attribute_mask & WIN_ATTR_EVENTHANDLER)
                win->attributes.event_handler = new_attributes->event_handler;

        // Change behavor setting if requested.
        if (attribute_mask & WIN_ATTR_BEHAVIOR)
                win->attributes.behavior = new_attributes->behavior;

        // Change custom data if requested.
        if (attribute_mask & WIN_ATTR_CUSTOM)
                win->attributes.custom = new_attributes->custom;

        /*
         * If position and/or size change is requested, hand over
         * control to the win_set_area function, which will also take
         * care of events and redraw.
         */
        if (attribute_mask & (WIN_ATTR_POSITION | WIN_ATTR_SIZE)) {
                win_set_area(win, &(new_attributes->area), attribute_mask);
        } else {
                win_handle_event(win, WIN_EVENT_ATTRIBUTES, &attribute_mask);

                /*
                 * Redraw if one or more changes called for it, and it
                 * is visible.
                 */
                if (needs_redraw && win_is_visible(win))
                        win_draw(win, &dirty_area);
        }
}


void win_set_area(struct win_window *win,
                const struct win_area *new_area,
                win_attribute_mask_t attribute_mask)
{
        // Nothing underneath is exposed unless move or resize to smaller.
        bool exposed_areas = false;
        struct win_area dirty_area;

        // Sanity check.
        assert(win != NULL);
        assert(win != &win_root);
        assert(new_area != NULL);

        /*
         * Keep track of which areas are updated. Start with an area
         * equal to to the window itself, extending it on move or
         * resize.
         */
        dirty_area = win->attributes.area;

        // Change position if requested.
        if (attribute_mask & WIN_ATTR_POSITION) {
                win->attributes.area.pos = new_area->pos;
                win_compute_union(&dirty_area, new_area);
                exposed_areas = true;
        }

        // Change size if requested.
        if (attribute_mask & WIN_ATTR_SIZE) {
                // Exposed areas only if we shrink the size.
                if ((new_area->size.x < win->attributes.area.size.x) ||
                        (new_area->size.y < win->attributes.area.size.y)) {
                        exposed_areas = true;
                }

                win->attributes.area.size = new_area->size;
                win_compute_union(&dirty_area, new_area);
        }

        // Notify attribute change and redraw if it is visible.
        win_handle_event(win, WIN_EVENT_ATTRIBUTES, &attribute_mask);

        if (win_is_visible(win)) {
                /*
                 * If areas are exposed, we need to draw all siblings as
                 * well, to make sure everything is updated, therefore
                 * we ask our parent to draw itself.
                 */
                if (exposed_areas)
                        win_draw_parent(win, &dirty_area);
                else
                        win_draw(win, &dirty_area);
        }
}


const struct win_attributes *win_get_attributes(const struct win_window *win)
{
        // Sanity check.
        assert(win != NULL);

        // Return reference.
        return &win->attributes;
}


const struct win_area *win_get_area(const struct win_window *win)
{
        // Sanity check.
        assert(win != NULL);

        // Return reference.
        return &win->attributes.area;
}


void *win_get_custom_data(const struct win_window *win)
{
        return win->attributes.custom;
}


struct win_window *win_create(struct win_window *parent,
                const struct win_attributes *attributes)
{
        struct win_window *win;

        // Sanity check.
        assert(parent != NULL);
        assert(attributes != NULL);

        win = membag_alloc(sizeof(struct win_window));
        if (!win)
                return NULL;

        // Setup window attributes and start as invisible initially.
        win->attributes = *attributes;
        win->is_mapped = false;

        /*
         * Setup window structure and add to parent window.  The parent
         * window will set parent link and sibling pointers.
         */
        win->top_child = NULL;

        win_add_top_child(parent, win);

        return win;
}


void win_destroy(struct win_window *win)
{
        // Sanity check.
        assert(win != NULL);
        assert(win != &win_root);

        // Hide if still visible.
        if (win->is_mapped)
                win_hide(win);

        /*
         * Unlink from parent and destroy entire substructure without
         * bothering to hide and unlink each and every one on the way.
         */
        win_unlink(win);
        win_destroy_children(win);
        win_handle_event(win, WIN_EVENT_DESTROY, NULL);
        membag_free(win);
}


void win_reparent(struct win_window *child, struct win_window *new_parent)
{
        bool was_mapped;

        // Sanity check.
        assert(child != NULL);
        assert(child != &win_root);
        assert(new_parent != NULL);

        // Transfer to new parent and restore visibility.
        was_mapped = child->is_mapped;
        if (was_mapped)
                win_hide(child);

        win_unlink(child);
        win_add_top_child(new_parent, child);

        if (was_mapped)
                win_show(child);
}


void win_show(struct win_window *win)
{
        // Sanity check.
        assert(win != NULL);

        // Don't do anything if already visible.
        if (win->is_mapped)
                return;

        // Make visible and draw the window.
        win->is_mapped = true;
        win_redraw(win);
}


void win_redraw(const struct win_window *win)
{
        if (win_is_visible(win)) {
                const struct win_area *dirty_area = &win->attributes.area;
                win_draw(win, dirty_area);
        }
}


void win_hide(struct win_window *win)
{
        // Sanity check.
        assert(win != NULL);

        // Don't do anything if already hidden.
        if (!win->is_mapped)
                return;

        // If we want to hide the root window, clear the entire screen.
        if (win == &win_root) {
                win->is_mapped = false;
                gfx_set_clipping(0, 0, gfx_get_width(), gfx_get_height());
                gfx_draw_filled_rect(0, 0, gfx_get_width(), gfx_get_height(),
                        WIN_SCREEN_COLOR);
        } else {
                // Make invisible and refresh exposed areas.
                if (win_is_visible(win)) {
                        win->is_mapped = false;
                        win_draw_parent(win, &win->attributes.area);
                } else {
                        win->is_mapped = false;
                }
        }
}


void win_raise(struct win_window *win)
{
        struct win_window *parent;

        // Sanity check.
        assert(win != NULL);
        assert(win != &win_root);

        // No need to raise if already on top.
        if (win->parent->top_child == win)
                return;

        // Move window to beginning of child list and redraw.
        win_handle_event(win->top_child, WIN_EVENT_UNRAISE, NULL);

        parent = win->parent;
        win_unlink(win);
        win_add_top_child(parent, win);

        win_handle_event(win, WIN_EVENT_RAISE, NULL);

        if (win_is_visible(win)) {
                const struct win_area *dirty_area = &win->attributes.area;
                win_draw(win, dirty_area);
        }
}


void win_lower(struct win_window *win)
{
        struct win_window *parent;

        // Sanity check.
        assert(win != NULL);
        assert(win != &win_root);

        // No need to lower if already on bottom.
        if (win->parent->top_child->prev_sibling == win)
                return;

        /*
         * Move window to the end of child list and redraw exposed
         * areas.  Since the list wraps at the last window, its next
         * sibling is the top window.
         */
        win_handle_event(win->top_child, WIN_EVENT_UNRAISE, NULL);

        parent = win->parent;
        win_unlink(win);
        win_add_top_child(parent, win);
        parent->top_child = win->next_sibling;

        win_handle_event(win->top_child, WIN_EVENT_RAISE, NULL);

        if (win_is_visible(win)) {
                const struct win_area *dirty_area = &win->attributes.area;
                win_draw(win, dirty_area);
        }
}


void win_queue_pointer_event(const struct win_pointer_event *event)
{
        struct win_event w_event;

        w_event.type = WIN_EVENT_POINTER;
        w_event.pointer = *event;
        win_queue_event(&w_event);
}


void win_queue_keyboard_event(const struct win_keyboard_event *event)
{
        struct win_event w_event;

        w_event.type = WIN_EVENT_KEYBOARD;
        w_event.keyboard = *event;
        win_queue_event(&w_event);
}


void win_queue_command_event(const struct win_command_event *event)
{
        struct win_event w_event;

        w_event.type = WIN_EVENT_COMMAND;
        w_event.command = *event;
        win_queue_event(&w_event);
}

static void win_process_keyboard_event(struct win_keyboard_event *kevent)
{
        /*
         * Send event to current keyboard focus window, if any.  Ignore
         * return value, since nobody wants the event anyway if not
         * accepted by the focus window or its parents.
         */
        if (win_keyboard_focus) {
                struct win_window *win = win_keyboard_focus;

                do {
                        bool accepted = win_handle_event(win,
                                WIN_EVENT_KEYBOARD, kevent);

                        if (accepted)
                                break;

                        win = win->parent;
                } while (win != NULL);
        }
}

static void win_process_command_event(struct win_command_event *cevent)
{
        struct win_window *win = cevent->recipient;

        assert(win != NULL);

        do {
                bool accepted = win_handle_event(win, WIN_EVENT_COMMAND,
                        (win_command_t)cevent->data);

                if (accepted)
                        break;

                win = win->parent;
        } while (win != NULL);
}

static bool win_event_queue_is_empty(void)
{
        return ring_is_empty(&win_event_queue.ring);
}

static bool win_event_queue_is_full(void)
{
        return ring_is_full(&win_event_queue.ring, WIN_EVENT_QUEUE_SIZE);
}

static struct win_event *win_event_queue_get_tail(void)
{
        unsigned int tail;

        tail = ring_get_tail(&win_event_queue.ring, WIN_EVENT_QUEUE_SIZE);
        return &win_event_queue.buffer[tail];
}

static void win_event_queue_push(const struct win_event *event,
                clock_jiffy_t timestamp)
{
        unsigned int index;
        struct win_event *head;

        index = ring_get_head(&win_event_queue.ring, WIN_EVENT_QUEUE_SIZE);
        head = &win_event_queue.buffer[index];
        *head = *event;
        head->timestamp = timestamp;
        ring_insert_entries(&win_event_queue.ring, 1);
}

static void win_event_queue_pop(void)
{
        ring_extract_entries(&win_event_queue.ring, 1);
}

void win_process_events(void)
{
        // Process until no more events waiting.
        while (!win_event_queue_is_empty()) {
                // Process event depending on type.
                struct win_event *event = win_event_queue_get_tail();

                switch (event->type) {
                case WIN_EVENT_POINTER:
                        win_process_pointer_event(&event->pointer);
                        break;

                case WIN_EVENT_KEYBOARD:
                        win_process_keyboard_event(&event->keyboard);
                        break;

                case WIN_EVENT_COMMAND:
                        win_process_command_event(&event->command);
                        break;

                default:
                        // Error if any other events end up here.
                        unhandled_case(event->type);
                        break;
                }

                // We're done with the front event now, so remove it.
                win_event_queue_pop();
        }
}


void win_set_keyboard_focus(struct win_window *win)
{
        if (win_keyboard_focus != NULL)
                win_handle_event(win_keyboard_focus, WIN_EVENT_LOSEFOCUS, NULL);

        win_keyboard_focus = win;
        win_handle_event(win, WIN_EVENT_GETFOCUS, NULL);
}


void win_grab_pointer(struct win_window *win)
{
        win_pointer_grabber = win;
}


bool win_is_inside_clip(const struct win_clip_region *clip,
                const struct win_point *point)
{
        return (clip->NW.x <= point->x)
                && (clip->NW.y <= point->y)
                && (point->x <= clip->SE.x)
                && (point->y <= clip->SE.y);
}


bool win_is_inside_area(const struct win_area *area,
                const struct win_point *point)
{
        return (area->pos.x <= point->x)
                && (area->pos.y <= point->y)
                && (point->x < (area->pos.x + area->size.x))
                && (point->y < (area->pos.y + area->size.y));
}


bool win_is_inside_window(
                const struct win_window *win,
                const struct win_point *point)
{
        struct win_clip_region clip;

        win_compute_clipping(win, &win->attributes.area, &clip);

        return win_is_inside_clip(&clip, point);
}


void win_compute_union(struct win_area *area, const struct win_area *merge)
{
        gfx_coord_t expand_left;
        gfx_coord_t expand_top;
        gfx_coord_t expand_width;
        gfx_coord_t expand_height;

        // Expand leftwards if "merge" is left of "area".
        expand_left = area->pos.x - merge->pos.x;

        if (expand_left > 0) {
                area->pos.x -= expand_left;
                area->size.x += expand_left;
        }

        // Expand upwards if "merge" is above "area".
        expand_top = area->pos.y - merge->pos.y;
        if (expand_top > 0) {
                area->pos.y -= expand_top;
                area->size.y += expand_top;
        }

        // Expand width if right side of "merge" is to the right of "area"
        expand_width = (merge->pos.x + merge->size.x)
                - (area->pos.x + area->size.x);
        if (expand_width > 0)
                area->size.x += expand_width;

        // Expand height if bottom side of "merge" is below "area".
        expand_height = (merge->pos.y + merge->size.y)
                - (area->pos.y + area->size.y);
        if (expand_height > 0)
                area->size.y += expand_height;
}


bool win_compute_intersection(struct win_clip_region *clip,
                const struct win_area *area)
{
        // Shortcut calculation.
        const gfx_coord_t right_x = area->pos.x + area->size.x - 1;
        const gfx_coord_t bottom_y = area->pos.y + area->size.y - 1;

        /*
         * Invalid region if top-left of area is outside right and/or
         * bottom edge.
         */
        if (clip->SE.x < area->pos.x)
                return false;
        if (clip->SE.y < area->pos.y)
                return false;

        /*
         * Invalid region if bottom-right of area is outside left and/or
         * top edge.
         */
        if (clip->NW.x > right_x)
                return false;
        if (clip->NW.y > bottom_y)
                return false;

        // Shrink region if top-left of area is inside region.
        if (clip->NW.x < area->pos.x)
                clip->NW.x = area->pos.x;
        if (clip->NW.y < area->pos.y)
                clip->NW.y = area->pos.y;

        // Shrink region if bottom-right of area is inside region.
        if (clip->SE.x > right_x)
                clip->SE.x = right_x;
        if (clip->SE.y > bottom_y)
                clip->SE.y = bottom_y;

        // If we arrive here, the region is valid.
        return true;
}


bool win_compute_clipping(const struct win_window *win,
                const struct win_area *dirty_area,
                struct win_clip_region *clip)
{
        /*
         * Start with a clipping region equal to own window area. Values
         * given in parent window's coordinate system, which means (0,0)
         * is parent window's top-left corner.
         */
        clip->origin = win->attributes.area.pos;
        clip->NW = win->attributes.area.pos;
        clip->SE.x = win->attributes.area.pos.x
                + win->attributes.area.size.x - 1;
        clip->SE.y = win->attributes.area.pos.y
                + win->attributes.area.size.y - 1;

        // Intersect with dirty area, and return false if no intersection.
        if (!win_compute_intersection(clip, dirty_area))
                return false;

        /*
         * Translate origin and clip region using parent areas, until
         * root window.
         */
        while (win != &win_root) {
                // Move to parent window first.
                win = win->parent;

                // Clip region inside parent window extents.
                if (clip->NW.x < 0)
                        clip->NW.x = 0;
                if (clip->NW.y < 0)
                        clip->NW.y = 0;
                if (clip->SE.x >= win->attributes.area.size.x)
                        clip->SE.x = win->attributes.area.size.x - 1;
                if (clip->SE.y >= win->attributes.area.size.y)
                        clip->SE.y = win->attributes.area.size.y - 1;

                /*
                 * If we got clipped away altogether, return with false.
                 * This is the case if we have a negative area.
                 */
                if ((clip->NW.x > clip->SE.x) || (clip->NW.y > clip->SE.y))
                        return false;

                /*
                 * Translate to parent coordinate system, which means we
                 * will be in the same coordinate system _as_ the
                 * parent, not _in_ it.
                 */
                clip->origin.x += win->attributes.area.pos.x;
                clip->NW.x += win->attributes.area.pos.x;
                clip->SE.x += win->attributes.area.pos.x;

                clip->origin.y += win->attributes.area.pos.y;
                clip->NW.y += win->attributes.area.pos.y;
                clip->SE.y += win->attributes.area.pos.y;
        }

        /*
         * If we arrived here, the clipping region is still valid, ie.
         * positive.  The root window is always fullscreen, so there is
         * no reason to check that it is valid.
         */
        return true;
}


static bool win_is_visible(const struct win_window *win)
{
        // Move up the window tree, search for unmapped windows.
        do {
                // Return false once an unmapped window is found.
                if (!win->is_mapped)
                        return false;

                win = win->parent;
        } while (win != NULL);

        /*
         * If we arrived here, all windows were mapped, ergo visible on
         * screen, although maybe covered by other windows.
         */
        return true;
}


static void win_draw(const struct win_window *win,
                const struct win_area *dirty_area)
{
        struct win_clip_region clip;

        /*
         * Compute screen global origin and clipping region for this
         * window, using the provided dirty_area. Return if we are
         * clipped away altogether.
         */
        if (!win_compute_clipping(win, dirty_area, &clip))
                return;

        /*
         * If this window requires parent to redraw first, defer drawing
         * to parent.
         */
        if (win->parent && (win->attributes.behavior
                                & WIN_BEHAVIOR_REDRAW_PARENT)) {
                win_draw_parent(win, dirty_area);
                return;
        }

        // Draw this window first.
        win_draw_contents(win, &clip);

        /*
         * Move up the window tree, drawing all visible covering sibling
         * windows on the way. Stop when root window is reached.
         */
        while (win != &win_root) {
                /*
                 * We need the origin of our parent in order to provide
                 * proper clipping info to our covering siblings.
                 */
                clip.origin.x -= win->attributes.area.pos.x;
                clip.origin.y -= win->attributes.area.pos.y;

                // Draw all covering siblings.
                while (win != win->parent->top_child) {
                        win = win->prev_sibling;
                        if (win->is_mapped)
                                win_draw_child(win, &clip);
                }

                // Move to parent window, break when root window is reached.
                win = win->parent;
        }
}


static void win_draw_parent(const struct win_window *child,
                const struct win_area *dirty_area)
{
        struct win_area area = *dirty_area;

        if (win_translate_area_to_parent(&area, child->parent))
                win_draw(child->parent, &area);
}


static void win_draw_contents(const struct win_window *win,
                const struct win_clip_region *clip)
{
        const struct win_window *child;

        // Set screen clipping limits and draw background.
        gfx_set_clipping(clip->NW.x, clip->NW.y, clip->SE.x, clip->SE.y);

        if (win->attributes.background) {
                gfx_draw_bitmap_tiled(win->attributes.background, clip->NW.x,
                                clip->NW.y, clip->SE.x, clip->SE.y, clip->origin.x,
                                clip->origin.y);
        }

        win_handle_event((struct win_window *)win, WIN_EVENT_DRAW, clip);

        // Draw all visible children, if any.
        child = win->top_child;
        if (child != NULL) {
                do {
                        /*
                         * Move to previous first, which means the
                         * bottom child first, then the one above, and
                         * so on.
                         */
                        child = child->prev_sibling;

                        if (child->is_mapped)
                                win_draw_child(child, clip);
                } while (child != win->top_child);
        }
}

static void win_draw_child(const struct win_window *child,
                const struct win_clip_region *parent_clip)
{
        struct win_clip_region clip;

        /*
         * Start with a clipping region relative to parent window
         * coordinates, which means point (0,0) is parent window's
         * top-left corner.
         */
        clip.origin = child->attributes.area.pos;
        clip.NW = child->attributes.area.pos;
        clip.SE.x = child->attributes.area.pos.x
                + child->attributes.area.size.x - 1;
        clip.SE.y = child->attributes.area.pos.y
                + child->attributes.area.size.y - 1;

        /*
         * Translate to global coordinates using origin field of parent
         * clipping region, which equal the parent window's top left
         * corner in global coordinates.
         */
        clip.origin.x += parent_clip->origin.x;
        clip.NW.x += parent_clip->origin.x;
        clip.SE.x += parent_clip->origin.x;

        clip.origin.y += parent_clip->origin.y;
        clip.NW.y += parent_clip->origin.y;
        clip.SE.y += parent_clip->origin.y;

        // Clip child region using clipping region from parent.
        if (clip.NW.x < parent_clip->NW.x)
                clip.NW.x = parent_clip->NW.x;
        if (clip.NW.y < parent_clip->NW.y)
                clip.NW.y = parent_clip->NW.y;
        if (clip.SE.x > parent_clip->SE.x)
                clip.SE.x = parent_clip->SE.x;
        if (clip.SE.y > parent_clip->SE.y)
                clip.SE.y = parent_clip->SE.y;

        /*
         * Check if we got clipped away altogether, and return if so.
         * This is the case if we have a negative area.
         */
        if ((clip.NW.x > clip.SE.x) || (clip.NW.y > clip.SE.y))
                return;

        // Draw contents and children, if any.
        win_draw_contents(child, &clip);
}


void win_translate_win_to_root(struct win_window const *start_win,
                struct win_point *return_pos)
{
        struct win_window *win;

        assert(start_win);
        assert(return_pos);

        return_pos->x = start_win->attributes.area.pos.x;
        return_pos->y = start_win->attributes.area.pos.y;

        win = start_win->parent;
        while (win) {
                return_pos->x += win->attributes.area.pos.x;
                return_pos->y += win->attributes.area.pos.y;
                win = win->parent;
        }
}

static bool win_translate_area_to_parent(struct win_area *area,
                const struct win_window *parent)
{
        const struct win_area *parent_area = &parent->attributes.area;

        // Clip area inside parent window extents.
        if (area->pos.x < 0) {
                // pos.x is negative, so size shrinks.
                area->size.x += area->pos.x;
                area->pos.x = 0;
        }
        if (area->pos.y < 0) {
                // pos.y is negative, so size shrinks.
                area->size.y += area->pos.y;
                area->pos.y = 0;
        }

        if ((area->pos.x + area->size.x) > parent_area->size.x)
                area->size.x = parent_area->size.x - area->pos.x;
        if ((area->pos.y + area->size.y) > parent_area->size.y)
                area->size.y = parent_area->size.y - area->pos.y;

        // Check if area is still valid, i.e. not negative.
        if ((area->size.x <= 0) || (area->size.y <= 0))
                return false;

        // Translate to parent's coordinate system.
        area->pos.x += parent_area->pos.x;
        area->pos.y += parent_area->pos.y;

        return true;
}


static void win_destroy_children(struct win_window *win)
{
        struct win_window *next_sibling;
        struct win_window *child = win->top_child;

        if (child != NULL) {
                do {
                        win_destroy_children(child);
                        win_handle_event(child, WIN_EVENT_DESTROY, NULL);
                        next_sibling = child->next_sibling;
                        membag_free(child);

                        child = next_sibling;
                } while (child != win->top_child);

                win->top_child = NULL;
        }
}


static void win_unlink(struct win_window *win)
{
        // If we are the only child, slightly easier handling.
        if (win->next_sibling == win) {
                win->parent->top_child = NULL;
        } else {
                // If we are the top child, set the next child as new top.
                if (win->parent->top_child == win)
                        win->parent->top_child = win->next_sibling;

                // Remove ourselves from the linked list of children.
                win->next_sibling->prev_sibling = win->prev_sibling;
                win->prev_sibling->next_sibling = win->next_sibling;
        }

        // Clean up, for consistency.
        win->parent = NULL;
        win->next_sibling = NULL;
        win->prev_sibling = NULL;
}


static void win_add_top_child(struct win_window *parent,
                struct win_window *child)
{
        // If we are the first child, slightly easier handling.
        if (parent->top_child == NULL) {
                // We are the only child, so point to self.
                child->next_sibling = child;
                child->prev_sibling = child;
        } else {
                // Insert ourselves into the linked list at the top position.
                child->next_sibling = parent->top_child;
                child->prev_sibling = parent->top_child->prev_sibling;

                child->next_sibling->prev_sibling = child;
                child->prev_sibling->next_sibling = child;
        }

        // Parent-child link, putting child at top of Z stack.
        parent->top_child = child;
        child->parent = parent;
}


static void win_process_pointer_event(struct win_pointer_event *event)
{
        // Store last absolute pointer pos in event struct.
        event->last_pos = win_last_pointer_pos;

        // Compute new last pos from this event.
        if (event->is_relative) {
                event->pos.x += win_last_pointer_pos.x;
                event->pos.y += win_last_pointer_pos.y;

                event->is_relative = false;
        }

        // Track last absolute pointer pos.
        win_last_pointer_pos = event->pos;

        /*
         * If a window has grabbed the pointer, pass event to it, ignore
         * return value.  If no grabbing window, find window under
         * pointer and send event to it. Ignore return value, since root
         * window has no parent.
         */
        if (win_pointer_grabber != NULL) {
                win_handle_event(win_pointer_grabber,
                        WIN_EVENT_POINTER, event);
        } else {
                win_handle_pointer_event(&win_root,
                        event, &win_last_pointer_pos);
        }
}


static bool win_handle_pointer_event(struct win_window *win,
                const struct win_pointer_event *event,
                const struct win_point *pos)
{
        // Search from top down, find window under pointer.
        struct win_window *child = win->top_child;

        if (child != NULL) {
                // Translate pointer position relative to this window.
                struct win_point local_pos = *pos;

                local_pos.x -= win->attributes.area.pos.x;
                local_pos.y -= win->attributes.area.pos.y;

                do {
                        struct win_area *area;

                        /*
                         * Hand event to first child that is mapped and
                         * contains pointer.  If child accepts, return
                         * true, if not, break search and hope this
                         * parent window has an event handler.
                         */
                        area = &child->attributes.area;
                        if (child->is_mapped && win_is_inside_area(area, &local_pos)) {
                                bool accepted;

                                /*
                                 * Raise window if button pressed and
                                 * window wants to be raised on button
                                 * press. This is the mechanism that
                                 * raises windows to the top when
                                 * something inside them is clicked.
                                 */
                                if ((event->type == WIN_POINTER_PRESS)
                                                && (child->attributes.behavior
                                                        & WIN_BEHAVIOR_RAISE_ON_PRESS)) {
                                        win_raise(child);
                                }

                                // Now, hand event to child.
                                accepted = win_handle_pointer_event(child,
                                                event, &local_pos);

                                if (accepted)
                                        return true;
                                else
                                        break;
                        }

                        /*
                         * Move on to the next sibling, one step lower
                         * in the Z stack.
                         */
                        child = child->next_sibling;
                } while (child != win->top_child);
        }

        // If no child accepted the event, try our own handler.
        return win_handle_event(win, WIN_EVENT_POINTER, event);
}


static bool win_handle_event(struct win_window *win,
                enum win_event_type type, const void *data)
{
        win_event_handler_t handler = win->attributes.event_handler;

        if (handler)
                return handler(win, type, data);
        else
                return false;
}


#ifdef CONFIG_GFX_WIN_USE_TOUCH

static void win_queue_touch_event(const struct touch_event *event)
{
        struct win_pointer_event pointer_event;

        /*
         * A touch event is always the same button, either pressed,
         * released or moved/dragged. The only difference is the type,
         * set in the switch-case below.
         */
        pointer_event.buttons = WIN_TOUCH_BUTTON;
        pointer_event.pos.x = event->point.panel_x;
        pointer_event.pos.y = event->point.panel_y;
        pointer_event.is_relative = false;

        switch (event->type) {
        case TOUCH_PRESS:
                pointer_event.type = WIN_POINTER_PRESS;
                break;

        case TOUCH_MOVE:
                pointer_event.type = WIN_POINTER_MOVE;
                break;

        case TOUCH_RELEASE:
                pointer_event.type = WIN_POINTER_RELEASE;
                break;

        case TOUCH_NO_EVENT:
                // FIXME: pointer_event.type is not initialized
                break;
        }

        // Queue the event.
        win_queue_pointer_event(&pointer_event);
}
#endif


static void win_queue_event(const struct win_event *event)
{
        irqflags_t iflags;

        workqueue_add_task(&main_workqueue, &win_event_queue.task);

        /*
         * This is only necessary if this function may be called from
         * different contexts.
         */
        iflags = cpu_irq_save();

        // Drop event if queue is full.
        if (win_event_queue_is_full()) {
                ++win_num_dropped_events;
        } else {
                // Put element at the back of the queue and timestamp it.
                win_event_queue_push(event, 0);
        }

        cpu_irq_restore(iflags);
}


static void win_event_worker(struct workqueue_task *task)
{
        win_process_events();
}

---