util/gfx/wtk_basic_frame.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <membag.h>
#include <string.h>
#include <gfx/wtk.h>

struct wtk_basic_frame {
        struct win_window                 *win;
        wtk_basic_frame_command_handler_t frame_handler;
        void                              *custom_data;
        wtk_basic_frame_draw_handler_t    draw_handler;
};

struct win_window *wtk_basic_frame_as_child(struct wtk_basic_frame *basic_frame)
{
        assert(basic_frame);
        return basic_frame->win;
}

void *wtk_basic_frame_get_custom_data(const struct wtk_basic_frame *basic_frame)
{
        assert(basic_frame);
        return basic_frame->custom_data;
}

static bool wtk_basic_frame_handler(struct win_window *win,
                enum win_event_type type, const void *data)
{
        // Custom data for windows of a widget points back to the widget itself.
        struct wtk_basic_frame *frame;
        bool should_destroy;
        struct win_clip_region const *clip;

        frame = win_get_custom_data(win);

        switch (type) {
        case WIN_EVENT_DRAW:
                /* For DRAW events, the data parameter points to the
                 * clipping region.
                 */
                clip = (struct win_clip_region const *)data;

                if (win == frame->win) {
                        if (frame->draw_handler) {
                                // Call the draw handler
                                frame->draw_handler(win, clip);
                        }
                }
                /* Always accept DRAW events, as the return value is
                 * ignored anyway for that event type.
                 */
                return true;

        case WIN_EVENT_POINTER:
                /* Accept all POINTER events so that it does not
                 * propagate up the window tree to our parent in case
                 * we did not click anything useful inside the frame.
                 */
                return true;

        case WIN_EVENT_DESTROY:
                /* When the frame window is destroyed, also destroy
                 * the rest of the non-window frame allocations.
                 */
                if (win == frame->win) {
                        /* Memory allocated for windows will be
                         * automatically destroyed by the window
                         * system. We must destroy other allocations.
                         */
                        membag_free(frame);
                }

                /* Always accept DESTROY events, as the return value is
                 * ignored anyway for that event type.
                 */
                return true;

        case WIN_EVENT_COMMAND:
                /* When commands are received either directly or
                 * propagated from child widgets and windows, send it
                 * to the frame handler.
                 */
                if (win == frame->win) {
                        if (frame->frame_handler) {
                                /* If the frame handler returns true,
                                 * it wants us to destroy the frame.
                                 * This is normally used by CLOSE
                                 * buttons.
                                 */
                                should_destroy = frame->frame_handler(frame,
                                                (win_command_t)data);

                                /* It is safe to destroy it here, since
                                 * the event handling finished right
                                 * after this handler returns, and no
                                 * other references to this frame or
                                 * its contents will be done.
                                 */
                                if (should_destroy) {
                                        win_destroy(frame->win);
                                }

                                /* Accept the event if there was a
                                 * handler installed.
                                 */
                                return true;
                        }
                }

                /* Reject the event if there was no handler, or this
                 * was not the container window at all.
                 */
                return false;

        default:
                // Reject unknown event types.
                return false;

        }
}

struct wtk_basic_frame *wtk_basic_frame_create(struct win_window *parent,
                const struct win_area *area, struct gfx_bitmap *background,
                wtk_basic_frame_draw_handler_t draw_handler,
                wtk_basic_frame_command_handler_t frame_handler, void *custom_data)
{
        struct win_attributes   attr;
        struct wtk_basic_frame  *basic_frame;

        assert(area);
        assert(parent);

        // Allocate memory for frame control data.
        basic_frame = membag_alloc(sizeof(struct wtk_basic_frame));
        if (!basic_frame) {
                goto outofmem_basic_frame;
        }

        // Set window attributes
        basic_frame->frame_handler = frame_handler;
        basic_frame->custom_data = custom_data;
        basic_frame->draw_handler = draw_handler;

        // Copy area info
        attr.area = *area;
        attr.event_handler = wtk_basic_frame_handler;
        attr.custom = basic_frame;

        // Set background for window
        if (background) {
                attr.background = background;
                attr.behavior = 0;
        } else {
                attr.background = NULL;
                attr.behavior = WIN_BEHAVIOR_REDRAW_PARENT;
        }

        // Create the window
        basic_frame->win = win_create(parent, &attr);
        if (!basic_frame->win) {
                goto outofmem_win;
        }

        return basic_frame;

outofmem_win:
        membag_free(basic_frame);

outofmem_basic_frame:
        return NULL;
}

---