source: mainline/uspace/lib/ui/src/scrollbar.c@ 174be87

/*
 * Copyright (c) 2022 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libui
 * @{
 */
/**
 * @file Scrollbar
 *
 * Anatomy of a horizontal scrollbar:
 *
 *       Up                Down
 *      through           through
 * +---+------+--------+---------+---+
 * | < |      |   |||  |         | > |
 * +---+------+--------+---------+---+
 *  Up           Thumb           Down
 * button                       button
 *
 *     +-------- Through --------+
 *
 * Scrollbar uses the same terminology whether it is running in horizontal
 * or vertical mode, in horizontal mode up means left, down means right
 * (i.e. lower and higher coordinates, respectively).
 *
 * The thumb can be dragged to a specific position, resulting in a move
 * event. The up/down buttons generate up/down events. Pressing a mouse
 * button on the up/down through generates page up / page down events.
 *
 * Pressing and holding down mouse button on up / down button or up / down
 * through will auto-scroll (using clickmatic).
 */

#include <errno.h>
#include <gfx/color.h>
#include <gfx/context.h>
#include <gfx/render.h>
#include <gfx/text.h>
#include <io/pos_event.h>
#include <stdlib.h>
#include <str.h>
#include <ui/clickmatic.h>
#include <ui/control.h>
#include <ui/paint.h>
#include <ui/pbutton.h>
#include <ui/scrollbar.h>
#include <ui/ui.h>
#include <ui/window.h>
#include "../private/pbutton.h"
#include "../private/resource.h"
#include "../private/scrollbar.h"

enum {
        /** Scrollbar button width */
        ui_scrollbar_btn_len = 21,
        /** Scrollbar button width in text mode */
        ui_scrollbar_btn_len_text = 1,
        /** Scrollbar thumb frame thickness */
        ui_scrollbar_thumb_frame_thickness = 1,
        /** Scrollbar thumb bevel width */
        ui_scrollbar_thumb_bevel_width = 2,
        /** Scrollbar default thumb length */
        ui_scrollbar_def_thumb_len = 21,
        /** Scrollbar default thumb length in text mode */
        ui_scrollbar_def_thumb_len_text = 1,
        /** Scrollbar minimum thumb length */
        ui_scrollbar_min_thumb_len = 10,
        /** Scrollbar minimum thumb length in text mode */
        ui_scrollbar_min_thumb_len_text = 1,
};

static void ui_scrollbar_up_btn_down(ui_pbutton_t *, void *);
static void ui_scrollbar_up_btn_up(ui_pbutton_t *, void *);
static errno_t ui_scrollbar_up_btn_decor_paint(ui_pbutton_t *, void *,
    gfx_coord2_t *);
static errno_t ui_scrollbar_down_btn_decor_paint(ui_pbutton_t *, void *,
    gfx_coord2_t *);
static void ui_scrollbar_down_btn_down(ui_pbutton_t *, void *);
static void ui_scrollbar_down_btn_up(ui_pbutton_t *, void *);
static void ui_scrollbar_ctl_destroy(void *);
static errno_t ui_scrollbar_ctl_paint(void *);
static ui_evclaim_t ui_scrollbar_ctl_pos_event(void *, pos_event_t *);

static ui_pbutton_cb_t ui_scrollbar_up_btn_cb = {
        .down = ui_scrollbar_up_btn_down,
        .up = ui_scrollbar_up_btn_up
};

static ui_pbutton_decor_ops_t ui_scrollbar_up_btn_decor_ops = {
        .paint = ui_scrollbar_up_btn_decor_paint
};

static ui_pbutton_cb_t ui_scrollbar_down_btn_cb = {
        .down = ui_scrollbar_down_btn_down,
        .up = ui_scrollbar_down_btn_up
};

static ui_pbutton_decor_ops_t ui_scrollbar_down_btn_decor_ops = {
        .paint = ui_scrollbar_down_btn_decor_paint
};

/** Scrollbar control ops */
static ui_control_ops_t ui_scrollbar_ops = {
        .destroy = ui_scrollbar_ctl_destroy,
        .paint = ui_scrollbar_ctl_paint,
        .pos_event = ui_scrollbar_ctl_pos_event
};

static void ui_scrollbar_cm_up(ui_clickmatic_t *, void *);
static void ui_scrollbar_cm_down(ui_clickmatic_t *, void *);
static void ui_scrollbar_cm_page_up(ui_clickmatic_t *, void *);
static void ui_scrollbar_cm_page_down(ui_clickmatic_t *, void *);

/** Scrollbar clickmatic up callbacks */
ui_clickmatic_cb_t ui_scrollbar_clickmatic_up_cb = {
        .clicked = ui_scrollbar_cm_up
};

/** Scrollbar clickmatic down callbacks */
ui_clickmatic_cb_t ui_scrollbar_clickmatic_down_cb = {
        .clicked = ui_scrollbar_cm_down
};

/** Scrollbar clickmatic page up callbacks */
ui_clickmatic_cb_t ui_scrollbar_clickmatic_page_up_cb = {
        .clicked = ui_scrollbar_cm_page_up
};

/** Scrollbar clickmatic page down callbacks */
ui_clickmatic_cb_t ui_scrollbar_clickmatic_page_down_cb = {
        .clicked = ui_scrollbar_cm_page_down
};

/** Create new scrollbar.
 *
 * @param ui UI
 * @param window Window containing scrollbar
 * @param dir Scrollbar direction
 * @param rscrollbar Place to store pointer to new scrollbar
 * @return EOK on success, ENOMEM if out of memory
 */
errno_t ui_scrollbar_create(ui_t *ui, ui_window_t *window,
    ui_scrollbar_dir_t dir, ui_scrollbar_t **rscrollbar)
{
        ui_scrollbar_t *scrollbar;
        ui_resource_t *resource;
        const char *up_text;
        const char *down_text;
        errno_t rc;

        resource = ui_window_get_res(window);

        scrollbar = calloc(1, sizeof(ui_scrollbar_t));
        if (scrollbar == NULL)
                return ENOMEM;

        rc = ui_control_new(&ui_scrollbar_ops, (void *) scrollbar,
            &scrollbar->control);
        if (rc != EOK) {
                free(scrollbar);
                return rc;
        }

        if (dir == ui_sbd_horiz) {
                up_text = resource->textmode ? "\u25c4" : "<";
                down_text = resource->textmode ? "\u25ba" : ">";
        } else {
                up_text = resource->textmode ? "\u25b2" : "^";
                down_text = resource->textmode ? "\u25bc" : "v";
        }

        rc = ui_pbutton_create(resource, up_text, &scrollbar->up_btn);
        if (rc != EOK)
                goto error;

        ui_pbutton_set_cb(scrollbar->up_btn, &ui_scrollbar_up_btn_cb,
            scrollbar);

        ui_pbutton_set_decor_ops(scrollbar->up_btn,
            &ui_scrollbar_up_btn_decor_ops, (void *) scrollbar);

        ui_pbutton_set_flags(scrollbar->up_btn, ui_pbf_no_text_depress);

        rc = ui_pbutton_create(resource, down_text, &scrollbar->down_btn);
        if (rc != EOK)
                goto error;

        ui_pbutton_set_cb(scrollbar->down_btn, &ui_scrollbar_down_btn_cb,
            (void *) scrollbar);

        ui_pbutton_set_decor_ops(scrollbar->down_btn,
            &ui_scrollbar_down_btn_decor_ops, (void *) scrollbar);

        ui_pbutton_set_flags(scrollbar->down_btn, ui_pbf_no_text_depress);

        scrollbar->thumb_len = resource->textmode ?
            ui_scrollbar_def_thumb_len_text :
            ui_scrollbar_def_thumb_len;

        scrollbar->ui = ui;
        scrollbar->window = window;
        scrollbar->dir = dir;
        *rscrollbar = scrollbar;
        return EOK;
error:
        ui_scrollbar_destroy(scrollbar);
        return rc;
}

/** Destroy scrollbar.
 *
 * @param scrollbar Scrollbar or @c NULL
 */
void ui_scrollbar_destroy(ui_scrollbar_t *scrollbar)
{
        if (scrollbar == NULL)
                return;

        ui_pbutton_destroy(scrollbar->up_btn);
        ui_pbutton_destroy(scrollbar->down_btn);
        ui_control_delete(scrollbar->control);
        free(scrollbar);
}

/** Get base control from scrollbar.
 *
 * @param scrollbar Scrollbar
 * @return Control
 */
ui_control_t *ui_scrollbar_ctl(ui_scrollbar_t *scrollbar)
{
        return scrollbar->control;
}

/** Set scrollbar callbacks.
 *
 * @param scrollbar Scrollbar
 * @param cb Scrollbar callbacks
 * @param arg Callback argument
 */
void ui_scrollbar_set_cb(ui_scrollbar_t *scrollbar, ui_scrollbar_cb_t *cb, void *arg)
{
        scrollbar->cb = cb;
        scrollbar->arg = arg;
}

/** Set scrollbar rectangle.
 *
 * @param scrollbar Scrollbar
 * @param rect New scrollbar rectangle
 */
void ui_scrollbar_set_rect(ui_scrollbar_t *scrollbar, gfx_rect_t *rect)
{
        ui_scrollbar_geom_t geom;

        scrollbar->rect = *rect;

        ui_scrollbar_get_geom(scrollbar, &geom);
        ui_pbutton_set_rect(scrollbar->up_btn, &geom.up_btn_rect);
        ui_pbutton_set_rect(scrollbar->down_btn, &geom.down_btn_rect);
}

/** Paint outer thumb frame.
 *
 * @param scrollbar Scrollbar
 * @return EOK on success or an error code
 */
static errno_t ui_scrollbar_paint_thumb_frame(ui_resource_t *res, gfx_rect_t *rect,
    gfx_coord_t thickness, gfx_rect_t *inside)
{
        gfx_rect_t drect;
        errno_t rc;

        rc = gfx_set_color(res->gc, res->btn_frame_color);
        if (rc != EOK)
                goto error;

        drect.p0.x = rect->p0.x + 1;
        drect.p0.y = rect->p0.y;
        drect.p1.x = rect->p1.x - 1;
        drect.p1.y = rect->p0.y + thickness;
        rc = gfx_fill_rect(res->gc, &drect);
        if (rc != EOK)
                goto error;

        drect.p0.x = rect->p0.x + 1;
        drect.p0.y = rect->p1.y - thickness;
        drect.p1.x = rect->p1.x - 1;
        drect.p1.y = rect->p1.y;
        rc = gfx_fill_rect(res->gc, &drect);
        if (rc != EOK)
                goto error;

        drect.p0.x = rect->p0.x;
        drect.p0.y = rect->p0.y + 1;
        drect.p1.x = rect->p0.x + thickness;
        drect.p1.y = rect->p1.y - 1;
        rc = gfx_fill_rect(res->gc, &drect);
        if (rc != EOK)
                goto error;

        drect.p0.x = rect->p1.x - thickness;
        drect.p0.y = rect->p0.y + 1;
        drect.p1.x = rect->p1.x;
        drect.p1.y = rect->p1.y - 1;
        rc = gfx_fill_rect(res->gc, &drect);
        if (rc != EOK)
                goto error;

        if (inside != NULL) {
                inside->p0.x = rect->p0.x + thickness;
                inside->p0.y = rect->p0.y + thickness;
                inside->p1.x = rect->p1.x - thickness;
                inside->p1.y = rect->p1.y - thickness;
        }

        return EOK;
error:
        return rc;
}

/** Paint outset scrollbar bevel.
 *
 * @param scrollbar Scrollbar
 * @return EOK on success or an error code
 */
static errno_t ui_scrollbar_paint_outset(ui_scrollbar_t *scrollbar,
    gfx_rect_t *rect, gfx_rect_t *inside)
{
        ui_resource_t *resource = ui_window_get_res(scrollbar->window);

        return ui_paint_bevel(resource->gc, rect,
            resource->btn_highlight_color,
            resource->btn_shadow_color, ui_scrollbar_thumb_bevel_width, inside);
}

/** Determine scrollbar through length.
 *
 * Return the size of the space within which the thumb can move
 * (without subtracting the length of the thumb).
 *
 * @param scrollbar Scrollbar
 * @return Scrollbar through length in pixels
 */
gfx_coord_t ui_scrollbar_through_length(ui_scrollbar_t *scrollbar)
{
        ui_resource_t *resource;
        gfx_coord2_t dims;
        gfx_coord_t len;
        gfx_coord_t sblen;

        resource = ui_window_get_res(scrollbar->window);

        gfx_rect_dims(&scrollbar->rect, &dims);
        sblen = scrollbar->dir == ui_sbd_horiz ?
            dims.x : dims.y;

        len = resource->textmode ? ui_scrollbar_btn_len_text :
            ui_scrollbar_btn_len;

        return sblen - 2 * len;
}

/** Determine scrollbar move length.
 *
 * Return the maximum distance the thumb can move.
 *
 * @param scrollbar Scrollbar
 * @return Scrollbar move length in pixels
 */
gfx_coord_t ui_scrollbar_move_length(ui_scrollbar_t *scrollbar)
{
        return ui_scrollbar_through_length(scrollbar) -
            scrollbar->thumb_len;
}

/** Set scrollbar thumb length.
 *
 * @param scrollbar Scrollbar
 * @param len Thumb length in pixels
 */
void ui_scrollbar_set_thumb_length(ui_scrollbar_t *scrollbar, gfx_coord_t len)
{
        ui_resource_t *resource;
        gfx_coord_t min_len;
        gfx_coord_t max_len;

        resource = ui_window_get_res(scrollbar->window);

        min_len = resource->textmode ?
            ui_scrollbar_min_thumb_len_text :
            ui_scrollbar_min_thumb_len;

        max_len = ui_scrollbar_through_length(scrollbar);
        if (len < min_len)
                len = min_len;
        if (len > max_len)
                len = max_len;

        if (len != scrollbar->thumb_len) {
                scrollbar->thumb_len = len;
                (void) ui_scrollbar_paint(scrollbar);
        }
}

/** Get scrollbar thumb position.
 *
 * @param scrollbar Scrollbar
 * @return Scrollbar thumb position in pixels
 */
gfx_coord_t ui_scrollbar_get_pos(ui_scrollbar_t *scrollbar)
{
        return scrollbar->pos;
}

/** Set scrollbar thumb position.
 *
 * The position is clipped to the allowed range.
 *
 * @param scrollbar Scrollbar
 * @parap pos       Scrollbar thumb position in pixels
 */
void ui_scrollbar_set_pos(ui_scrollbar_t *scrollbar, gfx_coord_t pos)
{
        gfx_coord_t length;

        length = ui_scrollbar_move_length(scrollbar);
        if (pos < 0)
                pos = 0;
        if (pos > length)
                pos = length;

        if (pos != scrollbar->pos) {
                scrollbar->pos = pos;
                (void) ui_scrollbar_paint(scrollbar);
                ui_scrollbar_throughs_update(scrollbar,
                    &scrollbar->last_curs_pos);
                ui_scrollbar_moved(scrollbar, pos);
        }
}

/** Paint scrollbar in graphics mode.
 *
 * @param scrollbar Scrollbar
 * @return EOK on success or an error code
 */
errno_t ui_scrollbar_paint_gfx(ui_scrollbar_t *scrollbar)
{
        ui_resource_t *resource;
        ui_scrollbar_geom_t geom;
        gfx_rect_t brect;
        gfx_rect_t irect;
        errno_t rc;

        resource = ui_window_get_res(scrollbar->window);

        ui_scrollbar_get_geom(scrollbar, &geom);

        /* Paint scrollbar frame */

        rc = ui_paint_inset_frame(resource, &scrollbar->rect, NULL);
        if (rc != EOK)
                goto error;

        /* Paint scrollbar up through */
        rc = gfx_set_color(resource->gc,
            scrollbar->up_through_held && scrollbar->up_through_inside ?
            resource->sbar_act_through_color :
            resource->sbar_through_color);
        if (rc != EOK)
                goto error;

        rc = gfx_fill_rect(resource->gc, &geom.up_through_rect);
        if (rc != EOK)
                goto error;

        /* Paint scrollbar down through */

        rc = gfx_set_color(resource->gc,
            scrollbar->down_through_held && scrollbar->down_through_inside ?
            resource->sbar_act_through_color :
            resource->sbar_through_color);
        if (rc != EOK)
                goto error;

        rc = gfx_fill_rect(resource->gc, &geom.down_through_rect);
        if (rc != EOK)
                goto error;

        /* Paint scrollbar thumb */
        rc = ui_scrollbar_paint_thumb_frame(resource, &geom.thumb_rect,
            ui_scrollbar_thumb_frame_thickness, &brect);
        if (rc != EOK)
                goto error;

        rc = ui_scrollbar_paint_outset(scrollbar, &brect, &irect);
        if (rc != EOK)
                goto error;

        rc = gfx_set_color(resource->gc, resource->btn_face_color);
        if (rc != EOK)
                goto error;

        rc = gfx_fill_rect(resource->gc, &irect);
        if (rc != EOK)
                goto error;

        rc = ui_pbutton_paint(scrollbar->up_btn);
        if (rc != EOK)
                goto error;

        rc = ui_pbutton_paint(scrollbar->down_btn);
        if (rc != EOK)
                goto error;

        rc = gfx_update(resource->gc);
        if (rc != EOK)
                goto error;

        return EOK;
error:
        return rc;
}

/** Paint scrollbar in text mode.
 *
 * @param scrollbar Scrollbar
 * @return EOK on success or an error code
 */
errno_t ui_scrollbar_paint_text(ui_scrollbar_t *scrollbar)
{
        ui_resource_t *resource;
        ui_scrollbar_geom_t geom;
        errno_t rc;

        resource = ui_window_get_res(scrollbar->window);
        ui_scrollbar_get_geom(scrollbar, &geom);

        /* Paint scrollbar through */

        rc = ui_paint_text_rect(resource, &geom.through_rect,
            resource->sbar_through_color, "\u2592");
        if (rc != EOK)
                goto error;

        /* Paint scrollbar thumb */

        rc = ui_paint_text_rect(resource, &geom.thumb_rect,
            resource->sbar_through_color, "\u25a0");
        if (rc != EOK)
                goto error;

        /* Paint buttons */

        rc = ui_pbutton_paint(scrollbar->up_btn);
        if (rc != EOK)
                goto error;

        rc = ui_pbutton_paint(scrollbar->down_btn);
        if (rc != EOK)
                goto error;

        rc = gfx_update(resource->gc);
        if (rc != EOK)
                goto error;

        return EOK;
error:
        return rc;
}

/** Paint scrollbar.
 *
 * @param scrollbar Scrollbar
 * @return EOK on success or an error code
 */
errno_t ui_scrollbar_paint(ui_scrollbar_t *scrollbar)
{
        ui_resource_t *resource = ui_window_get_res(scrollbar->window);

        if (resource->textmode) {
                return ui_scrollbar_paint_text(scrollbar);
        } else {
                return ui_scrollbar_paint_gfx(scrollbar);
        }
}

/** Get scrollbar geometry.
 *
 * @param scrollbar Scrollbar
 * @param geom Structure to fill in with computed geometry
 */
void ui_scrollbar_get_geom(ui_scrollbar_t *scrollbar, ui_scrollbar_geom_t *geom)
{
        ui_resource_t *resource;
        gfx_coord_t btn_len;
        gfx_rect_t orect;
        gfx_rect_t irect;

        resource = ui_window_get_res(scrollbar->window);

        if (resource->textmode) {
                btn_len = ui_scrollbar_btn_len_text;
        } else {
                btn_len = ui_scrollbar_btn_len;
        }

        if (resource->textmode) {
                irect = scrollbar->rect;
                orect = scrollbar->rect;
        } else {
                ui_paint_get_inset_frame_inside(resource,
                    &scrollbar->rect, &irect);
                ui_paint_get_bevel_inside(resource->gc,
                    &scrollbar->rect, 1, &orect);
        }

        if (scrollbar->dir == ui_sbd_horiz) {
                /* Up button */
                geom->up_btn_rect.p0.x = orect.p0.x;
                geom->up_btn_rect.p0.y = orect.p0.y;
                geom->up_btn_rect.p1.x = orect.p0.x + btn_len;
                geom->up_btn_rect.p1.y = orect.p1.y;

                /* Through */
                geom->through_rect.p0.x = geom->up_btn_rect.p1.x;
                geom->through_rect.p0.y = irect.p0.y;
                geom->through_rect.p1.x = orect.p1.x - btn_len;
                geom->through_rect.p1.y = irect.p1.y;

                /* Thumb */
                geom->thumb_rect.p0.x = geom->up_btn_rect.p1.x +
                    scrollbar->pos;
                geom->thumb_rect.p0.y = orect.p0.y;
                geom->thumb_rect.p1.x = geom->thumb_rect.p0.x +
                    scrollbar->thumb_len;
                geom->thumb_rect.p1.y = orect.p1.y;

                /* Up through */
                geom->up_through_rect.p0 = geom->through_rect.p0;
                geom->up_through_rect.p1.x = geom->thumb_rect.p0.x;
                geom->up_through_rect.p1.y = geom->through_rect.p1.y;

                /* Down through */
                geom->down_through_rect.p0.x = geom->thumb_rect.p1.x;
                geom->down_through_rect.p0.y = geom->through_rect.p0.y;
                geom->down_through_rect.p1 = geom->through_rect.p1;

                /* Down button */
                geom->down_btn_rect.p0.x = geom->through_rect.p1.x;
                geom->down_btn_rect.p0.y = orect.p0.y;
                geom->down_btn_rect.p1.x = orect.p1.x;
                geom->down_btn_rect.p1.y = orect.p1.y;
        } else {
                /* Up button */
                geom->up_btn_rect.p0.x = orect.p0.x;
                geom->up_btn_rect.p0.y = orect.p0.y;
                geom->up_btn_rect.p1.x = orect.p1.x;
                geom->up_btn_rect.p1.y = orect.p0.y + btn_len;

                /* Through */
                geom->through_rect.p0.x = irect.p0.x;
                geom->through_rect.p0.y = geom->up_btn_rect.p1.y;
                geom->through_rect.p1.x = irect.p1.x;
                geom->through_rect.p1.y = orect.p1.y - btn_len;

                /* Thumb */
                geom->thumb_rect.p0.x = orect.p0.x;
                geom->thumb_rect.p0.y = geom->up_btn_rect.p1.y +
                    scrollbar->pos;
                geom->thumb_rect.p1.x = orect.p1.x;
                geom->thumb_rect.p1.y = geom->thumb_rect.p0.y +
                    scrollbar->thumb_len;

                /* Up through */
                geom->up_through_rect.p0 = geom->through_rect.p0;
                geom->up_through_rect.p1.x = geom->through_rect.p1.x;
                geom->up_through_rect.p1.y = geom->thumb_rect.p0.y;

                /* Down through */
                geom->down_through_rect.p0.x = geom->through_rect.p0.x;
                geom->down_through_rect.p0.y = geom->thumb_rect.p1.y;
                geom->down_through_rect.p1 = geom->through_rect.p1;

                /* Down button */
                geom->down_btn_rect.p0.x = orect.p0.x;
                geom->down_btn_rect.p0.y = geom->through_rect.p1.y;
                geom->down_btn_rect.p1.x = orect.p1.x;
                geom->down_btn_rect.p1.y = orect.p1.y;
        }
}

/** Press down scrollbar thumb.
 *
 * @param scrollbar Scrollbar
 * @param pos Pointer position
 */
void ui_scrollbar_thumb_press(ui_scrollbar_t *scrollbar, gfx_coord2_t *pos)
{
        if (scrollbar->thumb_held)
                return;

        scrollbar->thumb_held = true;
        scrollbar->press_pos = *pos;
        scrollbar->last_pos = scrollbar->pos;

        (void) ui_scrollbar_paint(scrollbar);
}

/** Press down scrollbar up through.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_up_through_press(ui_scrollbar_t *scrollbar)
{
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        scrollbar->up_through_held = true;
        scrollbar->up_through_inside = true;

        ui_clickmatic_set_cb(clickmatic, &ui_scrollbar_clickmatic_page_up_cb,
            (void *) scrollbar);
        ui_clickmatic_press(clickmatic);
}

/** Press down scrollbar down through.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_down_through_press(ui_scrollbar_t *scrollbar)
{
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        scrollbar->down_through_held = true;
        scrollbar->down_through_inside = true;

        ui_clickmatic_set_cb(clickmatic, &ui_scrollbar_clickmatic_page_down_cb,
            (void *) scrollbar);
        ui_clickmatic_press(clickmatic);
}

/** Release scrollbar.
 *
 * @param scrollbar Scrollbar
 * @param pos Pointer position
 */
void ui_scrollbar_release(ui_scrollbar_t *scrollbar, gfx_coord2_t *pos)
{
        ui_clickmatic_t *clickmatic;

        if (scrollbar->thumb_held) {
                ui_scrollbar_update(scrollbar, pos);
                scrollbar->thumb_held = false;
        }

        if (scrollbar->up_through_held || scrollbar->down_through_held) {
                clickmatic = ui_get_clickmatic(scrollbar->ui);
                ui_clickmatic_release(clickmatic);
                ui_clickmatic_set_cb(clickmatic, NULL, NULL);

                scrollbar->up_through_held = false;
                scrollbar->down_through_held = false;
                (void) ui_scrollbar_paint(scrollbar);
        }
}

/** Update state of scrollbar throuhgs.
 *
 * Update state of scrollbar throughs after mouse cursor or thumb has moved.
 *
 * @param scrollbar Scrollbar
 * @param pos Mouse cursor position
 */
void ui_scrollbar_throughs_update(ui_scrollbar_t *scrollbar, gfx_coord2_t *pos)
{
        ui_scrollbar_geom_t geom;
        bool inside_up;
        bool inside_down;

        ui_scrollbar_get_geom(scrollbar, &geom);

        inside_up = gfx_pix_inside_rect(pos, &geom.up_through_rect);
        inside_down = gfx_pix_inside_rect(pos, &geom.down_through_rect);

        if (inside_up && !scrollbar->up_through_inside) {
                scrollbar->up_through_inside = true;
                (void) ui_scrollbar_paint(scrollbar);
        } else if (!inside_up && scrollbar->up_through_inside) {
                scrollbar->up_through_inside = false;
                (void) ui_scrollbar_paint(scrollbar);
        }

        if (inside_down && !scrollbar->down_through_inside) {
                scrollbar->down_through_inside = true;
                (void) ui_scrollbar_paint(scrollbar);
        } else if (!inside_down && scrollbar->down_through_inside) {
                scrollbar->down_through_inside = false;
                (void) ui_scrollbar_paint(scrollbar);
        }
}

/** Scrollbar handler for pointer movement.
 *
 * @param scrollbar Scrollbar
 * @param pos New pointer position
 */
void ui_scrollbar_update(ui_scrollbar_t *scrollbar, gfx_coord2_t *pos)
{
        gfx_coord_t spos;

        if (scrollbar->thumb_held) {
                if (scrollbar->dir == ui_sbd_horiz)
                        spos = scrollbar->last_pos + pos->x - scrollbar->press_pos.x;
                else
                        spos = scrollbar->last_pos + pos->y - scrollbar->press_pos.y;

                ui_scrollbar_set_pos(scrollbar, spos);
        }

        ui_scrollbar_throughs_update(scrollbar, pos);
}

/** Scrollbar up button was pressed.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_up(ui_scrollbar_t *scrollbar)
{
        if (scrollbar->cb != NULL && scrollbar->cb->up != NULL)
                scrollbar->cb->up(scrollbar, scrollbar->arg);
}

/** Scrollbar down button was pressed.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_down(ui_scrollbar_t *scrollbar)
{
        if (scrollbar->cb != NULL && scrollbar->cb->down != NULL)
                scrollbar->cb->down(scrollbar, scrollbar->arg);
}

/** Scrollbar up through was pressed.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_page_up(ui_scrollbar_t *scrollbar)
{
        if (scrollbar->cb != NULL && scrollbar->cb->page_up != NULL)
                scrollbar->cb->page_up(scrollbar, scrollbar->arg);
}

/** Scrollbar down through was pressed.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_page_down(ui_scrollbar_t *scrollbar)
{
        if (scrollbar->cb != NULL && scrollbar->cb->page_down != NULL)
                scrollbar->cb->page_down(scrollbar, scrollbar->arg);
}

/** Scrollbar was moved.
 *
 * @param scrollbar Scrollbar
 */
void ui_scrollbar_moved(ui_scrollbar_t *scrollbar, gfx_coord_t pos)
{
        if (scrollbar->cb != NULL && scrollbar->cb->moved != NULL)
                scrollbar->cb->moved(scrollbar, scrollbar->arg, pos);
}

/** Handle scrollbar position event.
 *
 * @param scrollbar Scrollbar
 * @param pos_event Position event
 * @return @c ui_claimed iff the event is claimed
 */
ui_evclaim_t ui_scrollbar_pos_event(ui_scrollbar_t *scrollbar, pos_event_t *event)
{
        gfx_coord2_t pos;
        ui_evclaim_t claimed;
        ui_scrollbar_geom_t geom;

        ui_scrollbar_get_geom(scrollbar, &geom);

        pos.x = event->hpos;
        pos.y = event->vpos;

        claimed = ui_pbutton_pos_event(scrollbar->up_btn, event);
        if (claimed == ui_claimed)
                return ui_claimed;

        claimed = ui_pbutton_pos_event(scrollbar->down_btn, event);
        if (claimed == ui_claimed)
                return ui_claimed;

        switch (event->type) {
        case POS_PRESS:
                if (gfx_pix_inside_rect(&pos, &geom.thumb_rect)) {
                        ui_scrollbar_thumb_press(scrollbar, &pos);
                        return ui_claimed;
                }
                if (gfx_pix_inside_rect(&pos, &geom.up_through_rect)) {
                        ui_scrollbar_up_through_press(scrollbar);
                        return ui_claimed;
                }
                if (gfx_pix_inside_rect(&pos, &geom.down_through_rect)) {
                        ui_scrollbar_down_through_press(scrollbar);
                        return ui_claimed;
                }
                break;
        case POS_RELEASE:
                if (scrollbar->thumb_held || scrollbar->up_through_held ||
                    scrollbar->down_through_held) {
                        ui_scrollbar_release(scrollbar, &pos);
                        return ui_claimed;
                }
                break;
        case POS_UPDATE:
                ui_scrollbar_update(scrollbar, &pos);
                scrollbar->last_curs_pos = pos;
                break;
        case POS_DCLICK:
                break;
        }

        return ui_unclaimed;
}

/** Scrollbar up button pressed.
 *
 * @param pbutton Up button
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_up_btn_down(ui_pbutton_t *pbutton, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        ui_clickmatic_set_cb(clickmatic, &ui_scrollbar_clickmatic_up_cb,
            (void *) scrollbar);
        ui_clickmatic_press(clickmatic);
}

/** Scrollbar up button released.
 *
 * @param pbutton Up button
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_up_btn_up(ui_pbutton_t *pbutton, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        ui_clickmatic_release(clickmatic);
        ui_clickmatic_set_cb(clickmatic, NULL, NULL);
}

/** Paint up button decoration.
 *
 * @param pbutton Push button
 * @param arg Argument (ui_scrollbar_t *)
 * @param pos Center position
 */
static errno_t ui_scrollbar_up_btn_decor_paint(ui_pbutton_t *pbutton,
    void *arg, gfx_coord2_t *pos)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        errno_t rc;

        rc = gfx_set_color(pbutton->res->gc, pbutton->res->btn_text_color);
        if (rc != EOK)
                return rc;

        if (scrollbar->dir == ui_sbd_horiz)
                return ui_paint_left_triangle(pbutton->res->gc, pos, 5);
        else
                return ui_paint_up_triangle(pbutton->res->gc, pos, 5);
}

/** Paint down button decoration.
 *
 * @param pbutton Push button
 * @param arg Argument (ui_scrollbar_t *)
 * @param pos Center position
 */
static errno_t ui_scrollbar_down_btn_decor_paint(ui_pbutton_t *pbutton,
    void *arg, gfx_coord2_t *pos)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        errno_t rc;

        rc = gfx_set_color(pbutton->res->gc, pbutton->res->btn_text_color);
        if (rc != EOK)
                return rc;

        if (scrollbar->dir == ui_sbd_horiz)
                return ui_paint_right_triangle(pbutton->res->gc, pos, 5);
        else
                return ui_paint_down_triangle(pbutton->res->gc, pos, 5);
}

/** Scrollbar down button pressed.
 *
 * @param pbutton Down button
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_down_btn_down(ui_pbutton_t *pbutton, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        ui_clickmatic_set_cb(clickmatic, &ui_scrollbar_clickmatic_down_cb,
            (void *) scrollbar);
        ui_clickmatic_press(clickmatic);
}

/** Scrollbar down button released.
 *
 * @param pbutton Down button
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_down_btn_up(ui_pbutton_t *pbutton, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;
        ui_clickmatic_t *clickmatic = ui_get_clickmatic(scrollbar->ui);

        ui_clickmatic_release(clickmatic);
        ui_clickmatic_set_cb(clickmatic, NULL, NULL);
}

/** Destroy scrollbar control.
 *
 * @param arg Argument (ui_scrollbar_t *)
 */
void ui_scrollbar_ctl_destroy(void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *) arg;

        ui_scrollbar_destroy(scrollbar);
}

/** Paint scrollbar control.
 *
 * @param arg Argument (ui_scrollbar_t *)
 * @return EOK on success or an error code
 */
errno_t ui_scrollbar_ctl_paint(void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *) arg;

        return ui_scrollbar_paint(scrollbar);
}

/** Handle scrollbar control position event.
 *
 * @param arg Argument (ui_scrollbar_t *)
 * @param pos_event Position event
 * @return @c ui_claimed iff the event is claimed
 */
ui_evclaim_t ui_scrollbar_ctl_pos_event(void *arg, pos_event_t *event)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;

        return ui_scrollbar_pos_event(scrollbar, event);
}

/** Scrollbar clickmatic up button click event.
 *
 * @param clickmatic Clickmatic
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_cm_up(ui_clickmatic_t *clickmatic, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;

        if (scrollbar->up_btn->inside)
                ui_scrollbar_up(scrollbar);
}

/** Scrollbar clickmatic down button click event.
 *
 * @param clickmatic Clickmatic
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_cm_down(ui_clickmatic_t *clickmatic, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;

        if (scrollbar->down_btn->inside)
                ui_scrollbar_down(scrollbar);
}

/** Scrollbar clickmatic up through click event.
 *
 * @param clickmatic Clickmatic
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_cm_page_up(ui_clickmatic_t *clickmatic, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;

        if (scrollbar->up_through_inside)
                ui_scrollbar_page_up(scrollbar);
}

/** Scrollbar clickmatic down through click event.
 *
 * @param clickmatic Clickmatic
 * @param arg Argument (ui_scrollbar_t *)
 */
static void ui_scrollbar_cm_page_down(ui_clickmatic_t *clickmatic, void *arg)
{
        ui_scrollbar_t *scrollbar = (ui_scrollbar_t *)arg;

        if (scrollbar->down_through_inside)
                ui_scrollbar_page_down(scrollbar);
}

/** @}
 */