Index: uspace/app/uidemo/uidemo.c =================================================================== --- uspace/app/uidemo/uidemo.c (revision 5a6879171b349b93efa71242447fc637fe2ceedd) +++ uspace/app/uidemo/uidemo.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -37,4 +37,5 @@ #include #include +#include #include #include @@ -74,4 +75,10 @@ }; +static void slider_moved(ui_slider_t *, void *, gfx_coord_t); + +static ui_slider_cb_t slider_cb = { + .moved = slider_moved +}; + /** Window close button was clicked. * @@ -150,4 +157,32 @@ } +/** Slider was moved. + * + * @param slider Slider + * @param arg Argument (demo) + * @param pos Position + */ +static void slider_moved(ui_slider_t *slider, void *arg, gfx_coord_t pos) +{ + ui_demo_t *demo = (ui_demo_t *) arg; + char *str; + errno_t rc; + int rv; + + rv = asprintf(&str, "Slider at %d of %d", (int) pos, + ui_slider_length(slider)); + if (rv < 0) { + printf("Out of memory.\n"); + return; + } + + rc = ui_entry_set_text(demo->entry, str); + if (rc != EOK) + printf("Error changing entry text.\n"); + (void) ui_entry_paint(demo->entry); + + free(str); +} + /** Run UI demo on display server. */ static errno_t ui_demo(const char *display_spec) @@ -177,5 +212,5 @@ params.rect.p0.y = 0; params.rect.p1.x = 220; - params.rect.p1.y = 330; + params.rect.p1.y = 340; memset((void *) &demo, 0, sizeof(demo)); @@ -397,4 +432,24 @@ rc = ui_fixed_add(demo.fixed, ui_rbutton_ctl(demo.rb3)); + if (rc != EOK) { + printf("Error adding control to layout.\n"); + return rc; + } + + rc = ui_slider_create(ui_res, "Slide!", &demo.slider); + if (rc != EOK) { + printf("Error creating button.\n"); + return rc; + } + + ui_slider_set_cb(demo.slider, &slider_cb, (void *) &demo); + + rect.p0.x = 15; + rect.p0.y = 300; + rect.p1.x = 130; + rect.p1.y = 320; + ui_slider_set_rect(demo.slider, &rect); + + rc = ui_fixed_add(demo.fixed, ui_slider_ctl(demo.slider)); if (rc != EOK) { printf("Error adding control to layout.\n"); Index: uspace/app/uidemo/uidemo.h =================================================================== --- uspace/app/uidemo/uidemo.h (revision 5a6879171b349b93efa71242447fc637fe2ceedd) +++ uspace/app/uidemo/uidemo.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -44,4 +44,5 @@ #include #include +#include #include #include @@ -62,4 +63,5 @@ ui_rbutton_t *rb2; ui_rbutton_t *rb3; + ui_slider_t *slider; } ui_demo_t; Index: uspace/lib/ui/include/types/ui/slider.h =================================================================== --- uspace/lib/ui/include/types/ui/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) +++ uspace/lib/ui/include/types/ui/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2021 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 Slider + */ + +#ifndef _UI_TYPES_SLIDER_H +#define _UI_TYPES_SLIDER_H + +#include + +struct ui_slider; +typedef struct ui_slider ui_slider_t; + +/** Slider callbacks */ +typedef struct ui_slider_cb { + void (*moved)(ui_slider_t *, void *, gfx_coord_t); +} ui_slider_cb_t; + +#endif + +/** @} + */ Index: uspace/lib/ui/include/ui/slider.h =================================================================== --- uspace/lib/ui/include/ui/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) +++ uspace/lib/ui/include/ui/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021 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 Slider + */ + +#ifndef _UI_SLIDER_H +#define _UI_SLIDER_H + +#include +#include +#include +#include +#include +#include +#include +#include + +extern errno_t ui_slider_create(ui_resource_t *, const char *, + ui_slider_t **); +extern void ui_slider_destroy(ui_slider_t *); +extern ui_control_t *ui_slider_ctl(ui_slider_t *); +extern void ui_slider_set_cb(ui_slider_t *, ui_slider_cb_t *, void *); +extern void ui_slider_set_rect(ui_slider_t *, gfx_rect_t *); +extern errno_t ui_slider_paint(ui_slider_t *); +extern errno_t ui_slider_btn_clear(ui_slider_t *); +extern gfx_coord_t ui_slider_length(ui_slider_t *); +extern void ui_slider_press(ui_slider_t *, gfx_coord2_t *); +extern void ui_slider_release(ui_slider_t *, gfx_coord2_t *); +extern void ui_slider_update(ui_slider_t *, gfx_coord2_t *); +extern void ui_slider_moved(ui_slider_t *, gfx_coord_t); +extern ui_evclaim_t ui_slider_pos_event(ui_slider_t *, pos_event_t *); + +#endif + +/** @} + */ Index: uspace/lib/ui/meson.build =================================================================== --- uspace/lib/ui/meson.build (revision 5a6879171b349b93efa71242447fc637fe2ceedd) +++ uspace/lib/ui/meson.build (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -40,4 +40,5 @@ 'src/rbutton.c', 'src/resource.c', + 'src/slider.c', 'src/ui.c', 'src/wdecor.c', @@ -57,4 +58,5 @@ 'test/rbutton.c', 'test/resource.c', + 'test/slider.c', 'test/ui.c', 'test/wdecor.c', Index: uspace/lib/ui/private/slider.h =================================================================== --- uspace/lib/ui/private/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) +++ uspace/lib/ui/private/slider.h (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2021 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 Slider structure + * + */ + +#ifndef _UI_PRIVATE_SLIDER_H +#define _UI_PRIVATE_SLIDER_H + +#include +#include + +/** Actual structure of slider. + * + * This is private to libui. + */ +struct ui_slider { + /** Base control object */ + struct ui_control *control; + /** UI resource */ + struct ui_resource *res; + /** Callbacks */ + struct ui_slider_cb *cb; + /** Callback argument */ + void *arg; + /** Slider rectangle */ + gfx_rect_t rect; + /** Slider is currently held down */ + bool held; + /** Position where button was pressed */ + gfx_coord2_t press_pos; + /** Last slider position */ + gfx_coord_t last_pos; + /** Slider position */ + gfx_coord_t pos; +}; + +#endif + +/** @} + */ Index: uspace/lib/ui/src/slider.c =================================================================== --- uspace/lib/ui/src/slider.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) +++ uspace/lib/ui/src/slider.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -0,0 +1,480 @@ +/* + * Copyright (c) 2021 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 Slider + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../private/resource.h" +#include "../private/slider.h" + +/* + * The kind reader will appreciate that slider button dimensions 23:15 + * are chosen such that, after subtracting the frame width (2 times 1), + * we get 21:13, which is a good approximation of the golden ratio. + */ +enum { + /** Slider button width */ + ui_slider_btn_w = 15, + /** Slider button height */ + ui_slider_btn_h = 23, + /** Slider button frame thickness */ + ui_slider_btn_frame_thickness = 1, + /** Slider button bevel width */ + ui_slider_btn_bevel_width = 2, + /** Slider groove width (total) */ + ui_slider_groove_width = 4, + /** Amount by which slider groove bevel extendeds on each side + * beyond nominal groove length. + */ + ui_slider_groove_margin = 2 +}; + +static void ui_slider_ctl_destroy(void *); +static errno_t ui_slider_ctl_paint(void *); +static ui_evclaim_t ui_slider_ctl_pos_event(void *, pos_event_t *); + +/** Slider control ops */ +ui_control_ops_t ui_slider_ops = { + .destroy = ui_slider_ctl_destroy, + .paint = ui_slider_ctl_paint, + .pos_event = ui_slider_ctl_pos_event +}; + +/** Create new slider. + * + * @param resource UI resource + * @param caption Caption + * @param rslider Place to store pointer to new slider + * @return EOK on success, ENOMEM if out of memory + */ +errno_t ui_slider_create(ui_resource_t *resource, const char *caption, + ui_slider_t **rslider) +{ + ui_slider_t *slider; + errno_t rc; + + slider = calloc(1, sizeof(ui_slider_t)); + if (slider == NULL) + return ENOMEM; + + rc = ui_control_new(&ui_slider_ops, (void *) slider, + &slider->control); + if (rc != EOK) { + free(slider); + return rc; + } + + slider->res = resource; + *rslider = slider; + return EOK; +} + +/** Destroy slider. + * + * @param slider Slider or @c NULL + */ +void ui_slider_destroy(ui_slider_t *slider) +{ + if (slider == NULL) + return; + + ui_control_delete(slider->control); + free(slider); +} + +/** Get base control from slider. + * + * @param slider Slider + * @return Control + */ +ui_control_t *ui_slider_ctl(ui_slider_t *slider) +{ + return slider->control; +} + +/** Set slider callbacks. + * + * @param slider Slider + * @param cb Slider callbacks + * @param arg Callback argument + */ +void ui_slider_set_cb(ui_slider_t *slider, ui_slider_cb_t *cb, void *arg) +{ + slider->cb = cb; + slider->arg = arg; +} + +/** Set slider rectangle. + * + * @param slider Slider + * @param rect New slider rectangle + */ +void ui_slider_set_rect(ui_slider_t *slider, gfx_rect_t *rect) +{ + slider->rect = *rect; +} + +/** Paint outer slider frame. + * + * @param slider Slider + * @return EOK on success or an error code + */ +static errno_t ui_slider_paint_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 slider bevel. + * + * @param slider Slider + * @return EOK on success or an error code + */ +static errno_t ui_slider_paint_outset(ui_slider_t *slider, + gfx_rect_t *rect, gfx_rect_t *inside) +{ + return ui_paint_bevel(slider->res->gc, rect, + slider->res->btn_highlight_color, + slider->res->btn_shadow_color, ui_slider_btn_bevel_width, inside); +} + +/** Determine slider button rectagle. + * + * @param slider Slider + */ +static void ui_slider_btn_rect(ui_slider_t *slider, gfx_rect_t *rect) +{ + gfx_coord2_t pos; + + pos.x = slider->rect.p0.x + slider->pos; + pos.y = slider->rect.p0.y; + + rect->p0.x = pos.x; + rect->p0.y = pos.y; + rect->p1.x = pos.x + ui_slider_btn_w; + rect->p1.y = pos.y + ui_slider_btn_h; +} + +/** Determine slider length. + * + * @param slider Slider + * @return Slider length in pixels + */ +gfx_coord_t ui_slider_length(ui_slider_t *slider) +{ + gfx_coord2_t dims; + + gfx_rect_dims(&slider->rect, &dims); + return dims.x - ui_slider_btn_w; +} + +/** Paint slider. + * + * @param slider Slider + * @return EOK on success or an error code + */ +errno_t ui_slider_paint(ui_slider_t *slider) +{ + gfx_coord2_t pos; + gfx_coord_t length; + gfx_rect_t rect; + gfx_rect_t brect; + gfx_rect_t irect; + errno_t rc; + + /* Paint slider groove */ + + pos = slider->rect.p0; + length = ui_slider_length(slider); + + rect.p0.x = pos.x + ui_slider_btn_w / 2 - ui_slider_groove_margin; + rect.p0.y = pos.y + ui_slider_btn_h / 2 - ui_slider_groove_width / 2; + rect.p1.x = pos.x + ui_slider_btn_w / 2 + length + + ui_slider_groove_margin; + rect.p1.y = pos.y + ui_slider_btn_h / 2 + ui_slider_groove_width / 2; + + rc = ui_paint_inset_frame(slider->res, &rect, NULL); + if (rc != EOK) + goto error; + + /* Paint slider button */ + + ui_slider_btn_rect(slider, &rect); + + rc = ui_slider_paint_frame(slider->res, &rect, + ui_slider_btn_frame_thickness, &brect); + if (rc != EOK) + goto error; + + rc = ui_slider_paint_outset(slider, &brect, &irect); + if (rc != EOK) + goto error; + + rc = gfx_set_color(slider->res->gc, slider->res->btn_face_color); + if (rc != EOK) + goto error; + + rc = gfx_fill_rect(slider->res->gc, &irect); + if (rc != EOK) + goto error; + + return EOK; +error: + return rc; +} + +/** Clear slider button. + * + * @param slider Slider + * @return EOK on success or an error code + */ +errno_t ui_slider_btn_clear(ui_slider_t *slider) +{ + gfx_rect_t rect; + errno_t rc; + + ui_slider_btn_rect(slider, &rect); + + rc = gfx_set_color(slider->res->gc, slider->res->wnd_face_color); + if (rc != EOK) + goto error; + + rc = gfx_fill_rect(slider->res->gc, &rect); + if (rc != EOK) + goto error; + + return EOK; +error: + return rc; +} + +/** Press down slider. + * + * @param slider Slider + * @param pos Pointer position + */ +void ui_slider_press(ui_slider_t *slider, gfx_coord2_t *pos) +{ + if (slider->held) + return; + + slider->held = true; + slider->press_pos = *pos; + slider->last_pos = slider->pos; + + (void) ui_slider_paint(slider); +} + +/** Release slider. + * + * @param slider Slider + * @param pos Pointer position + */ +void ui_slider_release(ui_slider_t *slider, gfx_coord2_t *pos) +{ + if (!slider->held) + return; + + ui_slider_update(slider, pos); + slider->held = false; +} + +/** Pointer moved. + * + * @param slider Slider + * @param pos New pointer position + */ +void ui_slider_update(ui_slider_t *slider, gfx_coord2_t *pos) +{ + gfx_coord_t spos; + gfx_coord_t length; + + if (slider->held) { + spos = slider->last_pos + pos->x - slider->press_pos.x; + length = ui_slider_length(slider); + if (spos < 0) + spos = 0; + if (spos > length) + spos = length; + + if (spos != slider->pos) { + (void) ui_slider_btn_clear(slider); + slider->pos = spos; + (void) ui_slider_paint(slider); + ui_slider_moved(slider, spos); + } + } +} + +/** Slider was moved. + * + * @param slider Slider + */ +void ui_slider_moved(ui_slider_t *slider, gfx_coord_t pos) +{ + if (slider->cb != NULL && slider->cb->moved != NULL) + slider->cb->moved(slider, slider->arg, pos); +} + +/** Handle slider position event. + * + * @param slider Slider + * @param pos_event Position event + * @return @c ui_claimed iff the event is claimed + */ +ui_evclaim_t ui_slider_pos_event(ui_slider_t *slider, pos_event_t *event) +{ + gfx_coord2_t pos; + gfx_rect_t rect; + + pos.x = event->hpos; + pos.y = event->vpos; + + switch (event->type) { + case POS_PRESS: + ui_slider_btn_rect(slider, &rect); + if (gfx_pix_inside_rect(&pos, &rect)) { + ui_slider_press(slider, &pos); + slider->press_pos = pos; + return ui_claimed; + } + break; + case POS_RELEASE: + if (slider->held) { + ui_slider_release(slider, &pos); + return ui_claimed; + } + break; + case POS_UPDATE: + ui_slider_update(slider, &pos); + break; + } + + return ui_unclaimed; +} + +/** Destroy slider control. + * + * @param arg Argument (ui_slider_t *) + */ +void ui_slider_ctl_destroy(void *arg) +{ + ui_slider_t *slider = (ui_slider_t *) arg; + + ui_slider_destroy(slider); +} + +/** Paint slider control. + * + * @param arg Argument (ui_slider_t *) + * @return EOK on success or an error code + */ +errno_t ui_slider_ctl_paint(void *arg) +{ + ui_slider_t *slider = (ui_slider_t *) arg; + + return ui_slider_paint(slider); +} + +/** Handle slider control position event. + * + * @param arg Argument (ui_slider_t *) + * @param pos_event Position event + * @return @c ui_claimed iff the event is claimed + */ +ui_evclaim_t ui_slider_ctl_pos_event(void *arg, pos_event_t *event) +{ + ui_slider_t *slider = (ui_slider_t *) arg; + + return ui_slider_pos_event(slider, event); +} + +/** @} + */ Index: uspace/lib/ui/test/main.c =================================================================== --- uspace/lib/ui/test/main.c (revision 5a6879171b349b93efa71242447fc637fe2ceedd) +++ uspace/lib/ui/test/main.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -41,4 +41,5 @@ PCUT_IMPORT(rbutton); PCUT_IMPORT(resource); +PCUT_IMPORT(slider); PCUT_IMPORT(ui); PCUT_IMPORT(wdecor); Index: uspace/lib/ui/test/slider.c =================================================================== --- uspace/lib/ui/test/slider.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) +++ uspace/lib/ui/test/slider.c (revision ef734b78b1ad5a89163b14e6f38f206aa9b6e636) @@ -0,0 +1,514 @@ +/* + * Copyright (c) 2021 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "../private/slider.h" + +PCUT_INIT; + +PCUT_TEST_SUITE(slider); + +static errno_t testgc_set_color(void *, gfx_color_t *); +static errno_t testgc_fill_rect(void *, gfx_rect_t *); +static errno_t testgc_bitmap_create(void *, gfx_bitmap_params_t *, + gfx_bitmap_alloc_t *, void **); +static errno_t testgc_bitmap_destroy(void *); +static errno_t testgc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *); +static errno_t testgc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *); + +static gfx_context_ops_t ops = { + .set_color = testgc_set_color, + .fill_rect = testgc_fill_rect, + .bitmap_create = testgc_bitmap_create, + .bitmap_destroy = testgc_bitmap_destroy, + .bitmap_render = testgc_bitmap_render, + .bitmap_get_alloc = testgc_bitmap_get_alloc +}; + +static void test_slider_moved(ui_slider_t *, void *, gfx_coord_t); + +static ui_slider_cb_t test_slider_cb = { + .moved = test_slider_moved +}; + +static ui_slider_cb_t dummy_slider_cb = { +}; + +typedef struct { + bool bm_created; + bool bm_destroyed; + gfx_bitmap_params_t bm_params; + void *bm_pixels; + gfx_rect_t bm_srect; + gfx_coord2_t bm_offs; + bool bm_rendered; + bool bm_got_alloc; +} test_gc_t; + +typedef struct { + test_gc_t *tgc; + gfx_bitmap_alloc_t alloc; + bool myalloc; +} testgc_bitmap_t; + +typedef struct { + bool moved; + gfx_coord_t pos; +} test_cb_resp_t; + +/** Create and destroy slider */ +PCUT_TEST(create_destroy) +{ + ui_slider_t *slider = NULL; + errno_t rc; + + rc = ui_slider_create(NULL, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(slider); + + ui_slider_destroy(slider); +} + +/** ui_slider_destroy() can take NULL argument (no-op) */ +PCUT_TEST(destroy_null) +{ + ui_slider_destroy(NULL); +} + +/** ui_slider_ctl() returns control that has a working virtual destructor */ +PCUT_TEST(ctl) +{ + ui_slider_t *slider; + ui_control_t *control; + errno_t rc; + + rc = ui_slider_create(NULL, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + control = ui_slider_ctl(slider); + PCUT_ASSERT_NOT_NULL(control); + + ui_control_destroy(control); +} + +/** Set slider rectangle sets internal field */ +PCUT_TEST(set_rect) +{ + ui_slider_t *slider; + gfx_rect_t rect; + errno_t rc; + + rc = ui_slider_create(NULL, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rect.p0.x = 1; + rect.p0.y = 2; + rect.p1.x = 3; + rect.p1.y = 4; + + ui_slider_set_rect(slider, &rect); + PCUT_ASSERT_INT_EQUALS(rect.p0.x, slider->rect.p0.x); + PCUT_ASSERT_INT_EQUALS(rect.p0.y, slider->rect.p0.y); + PCUT_ASSERT_INT_EQUALS(rect.p1.x, slider->rect.p1.x); + PCUT_ASSERT_INT_EQUALS(rect.p1.y, slider->rect.p1.y); + + ui_slider_destroy(slider); +} + +/** Paint slider */ +PCUT_TEST(paint) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + ui_slider_t *slider; + + memset(&tgc, 0, sizeof(tgc)); + rc = gfx_context_new(&ops, &tgc, &gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_resource_create(gc, &resource); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(resource); + + rc = ui_slider_create(resource, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_slider_paint(slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + ui_slider_destroy(slider); + ui_resource_destroy(resource); + + rc = gfx_context_delete(gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); +} + +/** Test ui_slider_moved() */ +PCUT_TEST(moved) +{ + errno_t rc; + ui_slider_t *slider; + test_cb_resp_t resp; + + rc = ui_slider_create(NULL, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + /* Moved with no callbacks set */ + ui_slider_moved(slider, 42); + + /* Moved with callback not implementing clicked */ + ui_slider_set_cb(slider, &dummy_slider_cb, NULL); + ui_slider_moved(slider, 42); + + /* Moved with real callback set */ + resp.moved = false; + resp.pos = 0; + ui_slider_set_cb(slider, &test_slider_cb, &resp); + ui_slider_moved(slider, 42); + PCUT_ASSERT_TRUE(resp.moved); + PCUT_ASSERT_INT_EQUALS(42, resp.pos); + + ui_slider_destroy(slider); +} + +/** Press and release slider */ +PCUT_TEST(press_release) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + gfx_coord2_t pos; + gfx_rect_t rect; + ui_slider_t *slider; + test_cb_resp_t resp; + + memset(&tgc, 0, sizeof(tgc)); + rc = gfx_context_new(&ops, &tgc, &gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_resource_create(gc, &resource); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(resource); + + rc = ui_slider_create(resource, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rect.p0.x = 10; + rect.p0.y = 20; + rect.p1.x = 110; + rect.p1.y = 120; + ui_slider_set_rect(slider, &rect); + + resp.moved = false; + ui_slider_set_cb(slider, &test_slider_cb, &resp); + + PCUT_ASSERT_FALSE(slider->held); + + pos.x = 11; + pos.y = 22; + + ui_slider_press(slider, &pos); + PCUT_ASSERT_TRUE(slider->held); + PCUT_ASSERT_FALSE(resp.moved); + + pos.x = 21; + pos.y = 32; + + ui_slider_release(slider, &pos); + PCUT_ASSERT_FALSE(slider->held); + PCUT_ASSERT_TRUE(resp.moved); + PCUT_ASSERT_INT_EQUALS(10, slider->pos); + + ui_slider_destroy(slider); + ui_resource_destroy(resource); + + rc = gfx_context_delete(gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); +} + +/** Press, update and release slider */ +PCUT_TEST(press_uodate_release) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + gfx_coord2_t pos; + gfx_rect_t rect; + ui_slider_t *slider; + test_cb_resp_t resp; + + memset(&tgc, 0, sizeof(tgc)); + rc = gfx_context_new(&ops, &tgc, &gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_resource_create(gc, &resource); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(resource); + + rc = ui_slider_create(resource, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rect.p0.x = 10; + rect.p0.y = 20; + rect.p1.x = 110; + rect.p1.y = 120; + ui_slider_set_rect(slider, &rect); + + resp.moved = false; + ui_slider_set_cb(slider, &test_slider_cb, &resp); + + PCUT_ASSERT_FALSE(slider->held); + + pos.x = 11; + pos.y = 22; + + ui_slider_press(slider, &pos); + PCUT_ASSERT_TRUE(slider->held); + PCUT_ASSERT_FALSE(resp.moved); + + pos.x = 21; + pos.y = 32; + + ui_slider_update(slider, &pos); + PCUT_ASSERT_TRUE(slider->held); + PCUT_ASSERT_TRUE(resp.moved); + PCUT_ASSERT_INT_EQUALS(10, slider->pos); + + pos.x = 31; + pos.y = 42; + + ui_slider_release(slider, &pos); + PCUT_ASSERT_FALSE(slider->held); + PCUT_ASSERT_TRUE(resp.moved); + PCUT_ASSERT_INT_EQUALS(20, slider->pos); + + ui_slider_destroy(slider); + ui_resource_destroy(resource); + + rc = gfx_context_delete(gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); +} + +/** ui_pos_event() correctly translates POS_PRESS/POS_RELEASE */ +PCUT_TEST(pos_event_press_release) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + ui_slider_t *slider; + ui_evclaim_t claim; + pos_event_t event; + gfx_rect_t rect; + + memset(&tgc, 0, sizeof(tgc)); + rc = gfx_context_new(&ops, &tgc, &gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_resource_create(gc, &resource); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(resource); + + rc = ui_slider_create(resource, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + PCUT_ASSERT_FALSE(slider->held); + + rect.p0.x = 10; + rect.p0.y = 20; + rect.p1.x = 30; + rect.p1.y = 40; + ui_slider_set_rect(slider, &rect); + + /* Press outside is not claimed and does nothing */ + event.type = POS_PRESS; + event.hpos = 1; + event.vpos = 2; + claim = ui_slider_pos_event(slider, &event); + PCUT_ASSERT_FALSE(slider->held); + PCUT_ASSERT_EQUALS(ui_unclaimed, claim); + + /* Press inside is claimed and depresses slider */ + event.type = POS_PRESS; + event.hpos = 11; + event.vpos = 22; + claim = ui_slider_pos_event(slider, &event); + PCUT_ASSERT_TRUE(slider->held); + PCUT_ASSERT_EQUALS(ui_claimed, claim); + + /* Release outside (or anywhere) is claimed and relases slider */ + event.type = POS_RELEASE; + event.hpos = 41; + event.vpos = 32; + claim = ui_slider_pos_event(slider, &event); + PCUT_ASSERT_FALSE(slider->held); + PCUT_ASSERT_EQUALS(ui_claimed, claim); + + ui_slider_destroy(slider); + ui_resource_destroy(resource); + + rc = gfx_context_delete(gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); +} + +/** ui_slider_length() correctly determines slider length */ +PCUT_TEST(length) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + ui_slider_t *slider; + gfx_coord_t length; + gfx_rect_t rect; + + memset(&tgc, 0, sizeof(tgc)); + rc = gfx_context_new(&ops, &tgc, &gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_resource_create(gc, &resource); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(resource); + + rc = ui_slider_create(resource, "Hello", &slider); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + PCUT_ASSERT_FALSE(slider->held); + + rect.p0.x = 10; + rect.p0.y = 20; + rect.p1.x = 110; + rect.p1.y = 120; + ui_slider_set_rect(slider, &rect); + + length = ui_slider_length(slider); + PCUT_ASSERT_INT_EQUALS(110 - 10 - 15, length); + + ui_slider_destroy(slider); + ui_resource_destroy(resource); + + rc = gfx_context_delete(gc); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); +} + +static errno_t testgc_set_color(void *arg, gfx_color_t *color) +{ + (void) arg; + (void) color; + return EOK; +} + +static errno_t testgc_fill_rect(void *arg, gfx_rect_t *rect) +{ + (void) arg; + (void) rect; + return EOK; +} + +static errno_t testgc_bitmap_create(void *arg, gfx_bitmap_params_t *params, + gfx_bitmap_alloc_t *alloc, void **rbm) +{ + test_gc_t *tgc = (test_gc_t *) arg; + testgc_bitmap_t *tbm; + + tbm = calloc(1, sizeof(testgc_bitmap_t)); + if (tbm == NULL) + return ENOMEM; + + if (alloc == NULL) { + tbm->alloc.pitch = (params->rect.p1.x - params->rect.p0.x) * + sizeof(uint32_t); + tbm->alloc.off0 = 0; + tbm->alloc.pixels = calloc(sizeof(uint32_t), + (params->rect.p1.x - params->rect.p0.x) * + (params->rect.p1.y - params->rect.p0.y)); + tbm->myalloc = true; + if (tbm->alloc.pixels == NULL) { + free(tbm); + return ENOMEM; + } + } else { + tbm->alloc = *alloc; + } + + tbm->tgc = tgc; + tgc->bm_created = true; + tgc->bm_params = *params; + tgc->bm_pixels = tbm->alloc.pixels; + *rbm = (void *)tbm; + return EOK; +} + +static errno_t testgc_bitmap_destroy(void *bm) +{ + testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm; + if (tbm->myalloc) + free(tbm->alloc.pixels); + tbm->tgc->bm_destroyed = true; + free(tbm); + return EOK; +} + +static errno_t testgc_bitmap_render(void *bm, gfx_rect_t *srect, + gfx_coord2_t *offs) +{ + testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm; + tbm->tgc->bm_rendered = true; + tbm->tgc->bm_srect = *srect; + tbm->tgc->bm_offs = *offs; + return EOK; +} + +static errno_t testgc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc) +{ + testgc_bitmap_t *tbm = (testgc_bitmap_t *)bm; + *alloc = tbm->alloc; + tbm->tgc->bm_got_alloc = true; + return EOK; +} + +static void test_slider_moved(ui_slider_t *slider, void *arg, gfx_coord_t pos) +{ + test_cb_resp_t *resp = (test_cb_resp_t *) arg; + + resp->moved = true; + resp->pos = pos; +} + +PCUT_EXPORT(slider);