util/gfx/wtk_progress_bar.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_progress_bar {
        struct win_window       *container;
        uint8_t                 maximum;
        uint8_t                 value;
        uint8_t                 position;
        uint8_t                 option;
        gfx_color_t             fill_color;
        gfx_color_t             background_color;
};

struct win_window *wtk_progress_bar_as_child(struct wtk_progress_bar *bar)
{
        assert(bar);
        return bar->container;
}

bool wtk_progress_bar_set_value(struct wtk_progress_bar *bar, uint8_t value)
{
        uint8_t length;
        uint8_t option;
        uint8_t maximum;
        struct win_area const *area;

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

        if (value != bar->value) {
                bar->value = value;
                option = bar->option;
                maximum = bar->maximum;
                area = win_get_area(bar->container);

                // Get length of progress bar from window.
                if (option & WTK_PROGRESS_BAR_VERTICAL) {
                        length = area->size.y;
                } else {
                        length = area->size.x;
                }

                length -= 2;

                if (option & WTK_PROGRESS_BAR_INVERT) {
                        value = maximum - value;
                }

                bar->position = wtk_rescale_value(value, maximum, length);
                win_redraw(bar->container);

                return true;

        } else {
                return false;
        }
}

uint8_t wtk_progress_bar_get_value(struct wtk_progress_bar *bar)
{
        assert(bar);
        return bar->value;
}

void wtk_progress_bar_set_colors(struct wtk_progress_bar *bar,
                gfx_color_t fill_color, gfx_color_t background_color)
{
        assert(bar);

        if (bar->option & WTK_PROGRESS_BAR_INVERT) {
                bar->fill_color = background_color;
                bar->background_color = fill_color;
        } else {
                bar->fill_color = fill_color;
                bar->background_color = background_color;
        }
}

static bool wtk_progress_bar_handler(struct win_window *win,
                enum win_event_type type, void const *data)
{
        struct win_clip_region const    *clip;
        struct win_area const           *area;
        struct wtk_progress_bar         *bar;
        uint8_t                         position;
        uint8_t                         option;

        bar = (struct wtk_progress_bar *)win_get_custom_data(win);

        // Window receiving the event should be the widget's containing window.
        assert(win == bar->container);

        switch (type) {
        case WIN_EVENT_DRAW:
                /* For DRAW events, the data parameter points to the clipping
                 * region. The window area parameter is needed because it
                 * contains the size of the widget.
                 */
                clip = (struct win_clip_region const *)data;
                area = win_get_area(win);

                position = bar->position;
                option = bar->option;

                // Draw a window border.
                gfx_draw_rect(clip->origin.x, clip->origin.y, area->size.x,
                                area->size.y, WTK_PROGRESS_BAR_BORDER_COLOR);

                /* Draw progress bar interior according to orientation.
                 * An inverted progress bar is drawn in the same way as a
                 * non-inverted, as this option is handled in the functions
                 * for setting the bar's colors and value.
                 */
                if (option & WTK_PROGRESS_BAR_VERTICAL) {
                        // Draw the top section of the bar.
                        gfx_draw_filled_rect(clip->origin.x + 1,
                                        clip->origin.y + 1,
                                        area->size.x - 2,
                                        position, bar->fill_color);
                        // Draw the bottom section of the bar.
                        gfx_draw_filled_rect(clip->origin.x + 1,
                                        clip->origin.y + 1 + position,
                                        area->size.x - 2,
                                        area->size.y - 2 - position,
                                        bar->background_color);
                } else {
                        // Draw the left section of the bar.
                        gfx_draw_filled_rect(clip->origin.x + 1,
                                        clip->origin.y + 1,
                                        bar->position,
                                        area->size.y - 2, bar->fill_color);
                        // Draw the right section of the bar.
                        gfx_draw_filled_rect(clip->origin.x + 1 + position,
                                        clip->origin.y + 1,
                                        area->size.x - 2 - position,
                                        area->size.y - 2,
                                        bar->background_color);
                }

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

        case WIN_EVENT_DESTROY:
                /* Free up all memory allocated by widget.
                 * The window is freed by the window system
                 */
                membag_free(bar);
                return true;

        default:
                return false;
        }
}

struct wtk_progress_bar *wtk_progress_bar_create(struct win_window *parent,
                struct win_area const *area, uint8_t maximum, uint8_t value,
                gfx_color_t fill_color, gfx_color_t background_color,
                uint8_t option)
{
        uint8_t length;

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

        // Attributes scratchpad.
        struct win_attributes attr;

        // Allocate memory for the control data.
        struct wtk_progress_bar *bar =
                        membag_alloc(sizeof(struct wtk_progress_bar));
        if (!bar) {
                goto outofmem_bar;
        }

        // Initialize the progress bar data.
        bar->maximum = maximum;
        bar->value = value;
        bar->option = option;

        /* Set the progress bar's colors and prepare the value for computation
         * of the bar's end position according to the invert option.
         */
        if (option & WTK_PROGRESS_BAR_INVERT) {
                bar->fill_color = background_color;
                bar->background_color = fill_color;
                value = maximum - value;
        } else {
                bar->fill_color = fill_color;
                bar->background_color = background_color;
        }

        // Set up handling information.
        attr.event_handler = wtk_progress_bar_handler;
        attr.custom = bar;

        /* Do sanity check of specified window area parameters
         * according to the orientation of the progress bar.
         */
        attr.area = *area;
        assert(attr.area.size.x > 3);
        assert(attr.area.size.y > 3);

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

        length -= 2;

        // Set the progress bar's end position.
        bar->position = wtk_rescale_value(value, maximum, length);

        /* All drawing is done in wtk_progress_bar_handler() so no background is
         * needed.
         */
        attr.background = NULL;

        /* Since the widget has no transparent areas, the parent does not need
         * to be redrawn.
         */
        attr.behavior = 0;

        // Create a new window for the progress bar.
        bar->container = win_create(parent, &attr);
        if (!bar->container) {
                goto outofmem_container;
        }

        return bar;

outofmem_container:
        membag_free(bar);

outofmem_bar:
        return NULL;
}

---