util/gfx/wtk_radio_button.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_radio_button_state {
        WTK_RADIOBUTTON_NORMAL,
        WTK_RADIOBUTTON_PRESSED,
};

struct wtk_radio_group {
        wtk_radio_group_size_t          num_references;
        struct wtk_radio_button         *selected;
};

struct wtk_radio_button {
        struct win_window               *container;
        char                            *caption;
        struct wtk_radio_group          *group;
        enum wtk_radio_button_state     state;
        win_command_t                   command;
};

struct win_window *wtk_radio_button_as_child(struct wtk_radio_button
                *radio_button)
{
        assert(radio_button);
        return radio_button->container;
}

void wtk_radio_button_select(struct wtk_radio_button *radio_button)
{
        struct wtk_radio_button *old_selected;

        assert(radio_button);

        // Nothing to do if already selected.
        if (radio_button->group->selected == radio_button) {
                return;
        }

        // Change selection and redraw both.
        old_selected = radio_button->group->selected;
        radio_button->group->selected = radio_button;
        if (old_selected) {
                win_redraw(old_selected->container);
        }

        win_redraw(radio_button->container);
}

bool wtk_radio_button_is_selected(struct wtk_radio_button const *radio_button)
{
        assert(radio_button);
        return (radio_button->group->selected == radio_button);
}

static bool wtk_radio_button_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_radio_button *radio_button =
                        (struct wtk_radio_button *)win_get_custom_data(win);

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

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

                        // Draw radio button circle.
                        gfx_draw_circle(clip->origin.x +
                                        WTK_RADIOBUTTON_BUTTON_X,
                                        clip->origin.y +
                                        WTK_RADIOBUTTON_BUTTON_Y,
                                        WTK_RADIOBUTTON_RADIUS,
                                        WTK_RADIOBUTTON_BUTTON_COLOR,
                                        GFX_WHOLE);

                        // Draw radio button select marker if selected.
                        if (radio_button->group->selected == radio_button) {
                                gfx_draw_filled_circle(clip->origin.x +
                                                WTK_RADIOBUTTON_BUTTON_X,
                                                clip->origin.y +
                                                WTK_RADIOBUTTON_BUTTON_Y,
                                                WTK_RADIOBUTTON_RADIUS - 2,
                                                WTK_RADIOBUTTON_SELECT_COLOR,
                                                GFX_WHOLE);
                        }

                        // Draw caption.
                        gfx_draw_string(radio_button->caption,
                                        clip->origin.x +
                                        WTK_RADIOBUTTON_CAPTION_X,
                                        clip->origin.y +
                                        WTK_RADIOBUTTON_CAPTION_Y, &sysfont,
                                        WTK_RADIOBUTTON_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 == radio_button->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 radio button 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 (radio_button->state ==
                                                WTK_RADIOBUTTON_NORMAL) {
                                        win_grab_pointer(radio_button->
                                                        container);
                                        radio_button->state =
                                                        WTK_RADIOBUTTON_PRESSED;
                                        win_redraw(radio_button->container);
                                }
                                break;

                        case WIN_POINTER_RELEASE:
                                /* When button released, take action only if
                                 * released inside widget extents.
                                 */
                                if (radio_button->state ==
                                                WTK_RADIOBUTTON_PRESSED) {
                                        bool is_inside;

                                        // Ungrab pointer.
                                        win_grab_pointer(NULL);
                                        radio_button->state =
                                                        WTK_RADIOBUTTON_NORMAL;
                                        win_redraw(radio_button->container);

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

                                        // Select this radio button if inside.
                                        if (is_inside) {
                                                wtk_radio_button_select
                                                                (radio_button);

                                                // Send non-zero command.
                                                if (radio_button->command) {
                                                        command.sender =
                                                                radio_button->container;
                                                        command.recipient =
                                                                radio_button->container;
                                                        command.data =
                                                                radio_button->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 == radio_button->container);

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

                /* Destroy radio group as well if we are the last one in the
                 * group. If not, remove ourselves from the group.
                 */
                --(radio_button->group->num_references);
                if (!radio_button->group->num_references) {
                        membag_free(radio_button->group);
                } else {
                        if (radio_button->group->selected == radio_button) {
                                radio_button->group->selected = NULL;
                        }
                }

                membag_free(radio_button);

                /* 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_radio_button_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_RADIOBUTTON_CAPTION_X;
        size->y += max_s(WTK_RADIOBUTTON_CAPTION_Y + sysfont.height * sysfont.scale,
                        WTK_RADIOBUTTON_BUTTON_Y + WTK_RADIOBUTTON_RADIUS);
}


struct wtk_radio_button *wtk_radio_button_create(struct win_window *parent,
                struct win_area const *area,
                char const *caption,
                bool selected,
                struct wtk_radio_group *group, win_command_t command)
{
        struct wtk_radio_button         *radio_button;
        struct win_attributes           attr;

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

        // Allocate memory for check box control data.
        radio_button = membag_alloc(sizeof(struct wtk_radio_button));
        if (!radio_button) {
                goto outofmem_radio_button;
        }

        radio_button->state = WTK_RADIOBUTTON_NORMAL;
        radio_button->group = group;
        radio_button->command = command;

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

        wtk_copy_string(radio_button->caption, caption);

        // Handling information.
        attr.event_handler = wtk_radio_button_handler;
        attr.custom = radio_button;

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

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

        // Add ourselves to the radio group, take over selection if required.
        if (selected) {
                struct wtk_radio_button *old_selected = group->selected;
                group->selected = radio_button;
                if (old_selected) {
                        win_redraw(old_selected->container);
                }
        }

        // Make sure we haven't filled up the group reference count, and increment.
        assert(group->num_references < (wtk_radio_group_size_t) - 1L);
        ++(group->num_references);

        return radio_button;

outofmem_container:
        membag_free(radio_button->caption);

outofmem_caption:
        membag_free(radio_button);

outofmem_radio_button:
        return NULL;
}

struct wtk_radio_group *wtk_radio_group_create(void)
{
        // Allocate memory for radio group data.
        struct wtk_radio_group *radio_group =
                        membag_alloc(sizeof(struct wtk_radio_group));
        if (!radio_group) {
                goto outofmem_radio_group;
        }

        // Initialize.
        radio_group->num_references = 0;
        radio_group->selected = NULL;

        return radio_group;

outofmem_radio_group:
        return NULL;
}

---