util/gfx/wtk_check_box.c

Go to the documentation of this file.

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

enum wtk_check_box_state {
        WTK_CHECKBOX_NORMAL,
        WTK_CHECKBOX_PRESSED,
};

struct wtk_check_box {
        struct win_window               *container;
        char                            *caption;
        bool                            selected;
        enum wtk_check_box_state        state;
        win_command_t                   command;
};

struct win_window *wtk_check_box_as_child(struct wtk_check_box *check_box)
{
        assert(check_box);
        return check_box->container;
}

void wtk_check_box_toggle(struct wtk_check_box *check_box)
{
        assert(check_box);
        check_box->selected = !check_box->selected;
        win_redraw(check_box->container);
}

void wtk_check_box_set(struct wtk_check_box *check_box, bool selected)
{
        assert(check_box);
        check_box->selected = selected;
        win_redraw(check_box->container);
}

bool wtk_check_box_is_selected(struct wtk_check_box const *check_box)
{
        assert(check_box);
        return check_box->selected;
}

static bool wtk_check_box_handler(struct win_window *win,
                enum win_event_type type, void const *data)
{
        struct win_command_event command;

        // Custom data for windows of a widget points back to the widget itself.
        struct wtk_check_box *check_box =
                        (struct wtk_check_box *)win_get_custom_data(win);

        switch (type) {
        case WIN_EVENT_DRAW:
                {
                        // There should not be other windows in this widget.
                        assert(win == check_box->container);

                        /* For DRAW events, the data parameter points to the
                         * clipping region.
                         */
                        struct win_clip_region const *clip =
                                        (struct win_clip_region const *)data;

                        // Check check box square.
                        gfx_draw_rect(clip->origin.x + WTK_CHECKBOX_BOX_X,
                                        clip->origin.y + WTK_CHECKBOX_BOX_Y,
                                        WTK_CHECKBOX_BOX_SIZE,
                                        WTK_CHECKBOX_BOX_SIZE,
                                        WTK_CHECKBOX_BOX_COLOR);

                        // Draw check box select marker if selected.
                        if (check_box->selected) {
                                gfx_draw_filled_rect(clip->origin.x +
                                                WTK_CHECKBOX_BOX_X + 2,
                                                clip->origin.y +
                                                WTK_CHECKBOX_BOX_Y + 2,
                                                WTK_CHECKBOX_BOX_SIZE - 4,
                                                WTK_CHECKBOX_BOX_SIZE - 4,
                                                WTK_CHECKBOX_SELECT_COLOR);
                        }

                        // Draw caption.
                        gfx_draw_string(check_box->caption,
                                        clip->origin.x + WTK_CHECKBOX_CAPTION_X,
                                        clip->origin.y + WTK_CHECKBOX_CAPTION_Y,
                                        &sysfont,
                                        WTK_CHECKBOX_CAPTION_COLOR,
                                        GFX_COLOR_TRANSPARENT);

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

        case WIN_EVENT_POINTER:
                {
                        // There should not be other windows in this widget.
                        assert(win == check_box->container);

                        /* For POINTER events, the data parameter points to the
                         * pointer event information.
                         */
                        struct win_pointer_event const *event =
                                        (struct win_pointer_event const *)data;

                        switch (event->type) {
                        case WIN_POINTER_PRESS:
                                /* When check box pressed, grab pointer and
                                 * wait for release inside widget borders.
                                 * Other widgets won't get pointer events
                                 * before it is released, and the pointer
                                 * ungrabbed by us.
                                 */
                                if (check_box->state == WTK_CHECKBOX_NORMAL) {
                                        win_grab_pointer(check_box->container);
                                        check_box->state = WTK_CHECKBOX_PRESSED;
                                        win_redraw(check_box->container);
                                }
                                break;

                        case WIN_POINTER_RELEASE:
                                /* When check box released, take action only if
                                 * released inside widget extents.
                                 */
                                if (check_box->state == WTK_CHECKBOX_PRESSED) {
                                        bool is_inside;

                                        // Ungrab pointer.
                                        win_grab_pointer(NULL);
                                        check_box->state = WTK_CHECKBOX_NORMAL;
                                        win_redraw(check_box->container);

                                        // Check release position.
                                        is_inside = win_is_inside_window
                                                        (check_box->container,
                                                        &(event->pos));

                                        // Toggle check box if inside.
                                        if (is_inside) {
                                                wtk_check_box_toggle(check_box);

                                                // Send non-zero command.
                                                if (check_box->command) {
                                                        command.sender =
                                                                check_box->container;
                                                        command.recipient =
                                                                check_box->container;
                                                        command.data =
                                                                check_box->command;
                                                        win_queue_command_event
                                                                        (&command);
                                                }
                                        }
                                }
                                break;

                        default:
                                break;
                        }

                        /* Accept all POINTER events since all acitivity inside
                         * the widget extents is relevant to us.
                         */
                        return true;
                }

        case WIN_EVENT_DESTROY:
                // There should not be other windows in this widget.
                assert(win == check_box->container);

                /* Memory allocated for windows will be automatically destroyed
                 * by the window system. We must destroy other allocations.
                 */
                membag_free(check_box->caption);
                membag_free(check_box);

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

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


void wtk_check_box_size_hint(struct win_point *size, const char *caption)
{
        assert(size);
        assert(caption);

        gfx_get_string_bounding_box(caption, &sysfont, &size->x, &size->y);
        size->x += WTK_CHECKBOX_CAPTION_X;
        size->y += max_s(WTK_CHECKBOX_CAPTION_Y + sysfont.height * sysfont.scale,
                        WTK_CHECKBOX_BOX_SIZE);
}

struct wtk_check_box *wtk_check_box_create(struct win_window *parent,
                struct win_area const *area,
                char const *caption, bool selected, win_command_t command)
{
        struct win_attributes   attr;
        struct wtk_check_box    *check_box;

        assert(area);
        assert(caption);
        assert(parent);

        // Allocate memory for check box control data.
        check_box = membag_alloc(sizeof(struct wtk_check_box));
        if (!check_box) {
                goto outofmem_check_box;
        }

        check_box->state = WTK_CHECKBOX_NORMAL;
        check_box->selected = selected;
        check_box->command = command;

        // Allocate memory for caption string, and copy text.
        check_box->caption = membag_alloc((strlen(caption) + 1) * sizeof(char));
        if (!check_box->caption) {
                goto outofmem_caption;
        }

        wtk_copy_string(check_box->caption, caption);

        // Handling information.
        attr.event_handler = wtk_check_box_handler;
        attr.custom = check_box;

        // Prepare container frame.
        attr.area = *area;
        attr.background = NULL;
        attr.behavior = WIN_BEHAVIOR_REDRAW_PARENT;

        check_box->container = win_create(parent, &attr);
        if (!check_box->container) {
                goto outofmem_container;
        }

        return check_box;

outofmem_container:
        membag_free(check_box->caption);

outofmem_caption:
        membag_free(check_box);

outofmem_check_box:
        return NULL;
}

---