util/gfx/wtk_slider.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>

enum wtk_slider_state {
        WTK_SLIDER_NORMAL,
        WTK_SLIDER_MOVING,
};

struct wtk_slider {
        struct win_window *container;
        struct win_point root_pos;
        enum wtk_slider_state state;
        uint8_t maximum;
        uint8_t value;
        uint8_t position;
        uint8_t option;
        win_command_t command;
};

struct win_window *wtk_slider_as_child(struct wtk_slider *slider)
{
        assert(slider);
        return slider->container;
}

bool wtk_slider_is_moving(struct wtk_slider const *slider)
{
        assert(slider);
        return slider->state == WTK_SLIDER_MOVING;
}

uint8_t wtk_slider_get_value(struct wtk_slider const *slider)
{
        assert(slider);

        if (slider->option & WTK_SLIDER_INVERT) {
                return slider->maximum - slider->value;
        } else {
                return slider->value;
        }
}

bool wtk_slider_set_value(struct wtk_slider *slider, uint8_t value)
{
        struct win_area const   *area;
        uint8_t                 length;
        uint8_t                 option;

        assert(slider);
        assert(value <= slider->maximum);

        option = slider->option;

        if (option & WTK_SLIDER_INVERT) {
                value = slider->maximum - value;
        }

        if (slider->value != value) {
                slider->value = value;
                area = win_get_area(slider->container);

                /* Get length of slider from window.
                 * wtk_slider_create() asserts that this is an 8-bit value.
                 */
                if (option & WTK_SLIDER_VERTICAL) {
                        length = area->size.y;
                } else {
                        length = area->size.x;
                }

                length -= WTK_SLIDER_KNOB_WIDTH;
                slider->position = wtk_rescale_value(value, slider->maximum,
                                length);

                win_redraw(slider->container);

                return true;
        } else {
                return false;
        }
}

static bool wtk_slider_handler(struct win_window *win, enum win_event_type type,
                void const *data)
{
        struct win_pointer_event const  *event;
        struct win_clip_region const    *clip;
        struct win_command_event        command;
        struct win_area const           *area;
        struct wtk_slider               *slider;
        struct win_point                origin;
        gfx_color_t                     knob_color;
        gfx_coord_t                     position;
        gfx_coord_t                     length;
        uint8_t                         option;
        uint8_t                         value;
        bool                            send_command;

        slider = (struct wtk_slider *)win_get_custom_data(win);

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

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

                if (slider->state == WTK_SLIDER_NORMAL) {
                        knob_color = WTK_SLIDER_KNOB_COLOR_NORMAL;
                } else {
                        knob_color = WTK_SLIDER_KNOB_COLOR_MOVING;
                }

                // Draw slider frame border.
                gfx_draw_rect(clip->origin.x,
                                clip->origin.y,
                                area->size.x,
                                area->size.y, WTK_SLIDER_BORDER_COLOR);

                // Draw slider frame background within frame.
                gfx_draw_filled_rect(clip->origin.x + 1,
                                clip->origin.y + 1,
                                area->size.x - 2,
                                area->size.y - 2, WTK_SLIDER_BACKGROUND_COLOR);

                // Draw the slider knob according to configured orientation.
                if (option & WTK_SLIDER_VERTICAL) {
                        // Draw slider knob border.
                        gfx_draw_rect(clip->origin.x,
                                        clip->origin.y + slider->position,
                                        area->size.x,
                                        WTK_SLIDER_KNOB_WIDTH,
                                        WTK_SLIDER_BORDER_COLOR);

                        // Draw slider knob.
                        gfx_draw_filled_rect(clip->origin.x + 1,
                                        clip->origin.y + slider->position + 1,
                                        area->size.x - 2,
                                        WTK_SLIDER_KNOB_WIDTH - 2, knob_color);
                } else {
                        gfx_draw_rect(clip->origin.x + slider->position,
                                        clip->origin.y,
                                        WTK_SLIDER_KNOB_WIDTH,
                                        area->size.y, WTK_SLIDER_BORDER_COLOR);

                        gfx_draw_filled_rect(clip->origin.x + slider->position
                                        + 1,
                                        clip->origin.y + 1,
                                        WTK_SLIDER_KNOB_WIDTH - 2,
                                        area->size.y - 2, knob_color);
                }

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


        case WIN_EVENT_POINTER:
                /* For POINTER events, the data parameter points to the pointer
                 * event information.
                 */
                event = (struct win_pointer_event const *)data;
                area = win_get_area(win);
                option = slider->option;
                send_command = false;
                origin = slider->root_pos;

                switch (event->type) {
                case WIN_POINTER_PRESS:
                        /* Grab the pointer and redraw a highlighted slider.
                         * Slider value is not updated yet.
                         */
                        if (slider->state == WTK_SLIDER_NORMAL) {
                                slider->state = WTK_SLIDER_MOVING;
                                win_grab_pointer(win);
                                win_redraw(win);
                        };

#if WTK_SLIDER_PARENT_MOVE_SUPPORT
                        // Update root position.
                        win_translate_win_to_root(win, &slider->root_pos);
#endif
                        break;

                case WIN_POINTER_MOVE:
                        /* The slider is only updated when the pointer moves
                         * and the window was previously pressed. The pointer
                         * does not need to remain within the window to control
                         * the knob as only the position along the slider's
                         * direction of orientation is used.
                         */
                        if (slider->state == WTK_SLIDER_MOVING) {
                                /* Get the position of the pointer relative to
                                 * slider knob's origin, and the length of the
                                 * slider itself.
                                 */
                                if (option & WTK_SLIDER_VERTICAL) {
                                        position = event->pos.y - origin.y;
                                        length = area->size.y;
                                } else {
                                        position = event->pos.x - origin.x;
                                        length = area->size.x;
                                }

                                // Subtract offsets due to slider knob size.
                                position -= WTK_SLIDER_KNOB_WIDTH / 2;
                                length -= WTK_SLIDER_KNOB_WIDTH;

                                /* Bound the value if pointer is outside window.
                                 * Otherwise, compute the slider value from the
                                 * knob position.
                                 */
                                if (position < 0) {
                                        value = 0;
                                } else if (position > length) {
                                        value = slider->maximum;
                                } else {
                                        value = wtk_rescale_value(position,
                                                        length,
                                                        slider->maximum);
                                }

                                // Update slider only if this is a new value.
                                if (slider->value != value) {
                                        slider->value = value;

                                        /* Compute knob position from value to
                                         * get correct positioning.
                                         */
                                        slider->position =
                                                        wtk_rescale_value(value,
                                                        slider->maximum,
                                                        length);

                                        if (option & WTK_SLIDER_CMD_MOVE) {
                                                send_command = true;
                                        }

                                        win_redraw(win);
                                }
                        }
                        break;

                case WIN_POINTER_RELEASE:
                        /* Release the pointer and redraw a normal slider.
                         * The slider's value is not updated. Hence, a pointer
                         * press directly followed by a release will leave the
                         * slider value unchanged.
                         */
                        if (slider->state == WTK_SLIDER_MOVING) {
                                slider->state = WTK_SLIDER_NORMAL;
                                win_grab_pointer(NULL);
                                win_redraw(win);

                                if (option & WTK_SLIDER_CMD_RELEASE) {
                                        send_command = true;
                                }
                        }
                        break;

                default:
                        break;
                }

                // Prepare and send command, if it was flagged.
                if (send_command) {
                        command.sender = slider->container;
                        command.recipient = slider->container;
                        command.data = slider->command;
                        win_queue_command_event(&command);
                }

                /* Accept all POINTER events since all acitivity inside the
                 * widget window is relevant.
                 */
                return true;

        case WIN_EVENT_DESTROY:
                /* Memory allocated for windows will be automatically destroyed
                 * by the window system. We must destroy other allocations.
                 */
                membag_free(slider);

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

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

struct wtk_slider *wtk_slider_create(struct win_window *parent,
                struct win_area const *area, uint8_t maximum, uint8_t value,
                uint8_t option, win_command_t command)
{
        struct win_attributes   attr;
        struct wtk_slider       *slider;
        uint8_t                 length;

        // Do sanity check on parameters.
        assert(maximum > 0);
        assert(area);
        assert(parent);

        // Allocate memory for the control data.
        slider = membag_alloc(sizeof(struct wtk_slider));
        if (!slider) {
                goto outofmem_slider;
        }

        // Initialize the slider data.
        slider->state = WTK_SLIDER_NORMAL;
        slider->maximum = maximum;
        slider->value = value;
        slider->option = option;

        // Invert the initial value if slider is inverted.
        if (option & WTK_SLIDER_INVERT) {
                value = maximum - value;
        }

        slider->value = value;

        // Enforce a non-zero command value, if these are enabled.
        if (option & (WTK_SLIDER_CMD_MOVE | WTK_SLIDER_CMD_RELEASE)) {
                assert(command > 0);
                slider->command = command;
        }

        // Set up event handling for the widget window.
        attr.event_handler = wtk_slider_handler;
        attr.custom = slider;

        // Do a sanity check of the specified window area parameters.
        attr.area = *area;
        assert(attr.area.size.x > 0);
        assert(attr.area.size.y > 0);

        if (option & WTK_SLIDER_VERTICAL) {
                assert(attr.area.size.x > 3);
                assert(attr.area.size.x <= (uint8_t) ~ 0);
                assert(attr.area.size.y > WTK_SLIDER_KNOB_WIDTH);
                length = attr.area.size.y;
        } else {
                assert(attr.area.size.x > WTK_SLIDER_KNOB_WIDTH);
                assert(attr.area.size.y <= (uint8_t) ~ 0);
                assert(attr.area.size.y > 3);
                length = attr.area.size.x;
        }

        // Set slider knob position according to initial value.
        length -= WTK_SLIDER_KNOB_WIDTH;
        slider->position = wtk_rescale_value(value, maximum, length);

        /* All drawing is done in wtk_slider_handler() to reduce overhead.
         * Slider has no transparent areas, so parent does not need redrawing.
         */
        attr.background = NULL;
        attr.behavior = 0;

        // Create the widget window.
        slider->container = win_create(parent, &attr);
        if (!slider->container) {
                goto outofmem_container;
        }

        // Store absolute position
        win_translate_win_to_root(slider->container, &slider->root_pos);
        return slider;

outofmem_container:
        membag_free(slider);

outofmem_slider:
        return NULL;
}

---