Index: uspace/lib/ui/include/types/ui/entry.h =================================================================== --- uspace/lib/ui/include/types/ui/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) +++ uspace/lib/ui/include/types/ui/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2020 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 Text entry + */ + +#ifndef _UI_TYPES_ENTRY_H +#define _UI_TYPES_ENTRY_H + +struct ui_entry; +typedef struct ui_entry ui_entry_t; + +#endif + +/** @} + */ Index: uspace/lib/ui/include/ui/entry.h =================================================================== --- uspace/lib/ui/include/ui/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) +++ uspace/lib/ui/include/ui/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2020 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 Text entry + */ + +#ifndef _UI_ENTRY_H +#define _UI_ENTRY_H + +#include +#include +#include +#include +#include +#include + +extern errno_t ui_entry_create(ui_resource_t *, const char *, + ui_entry_t **); +extern void ui_entry_destroy(ui_entry_t *); +extern ui_control_t *ui_entry_ctl(ui_entry_t *); +extern void ui_entry_set_rect(ui_entry_t *, gfx_rect_t *); +extern void ui_entry_set_halign(ui_entry_t *, gfx_halign_t); +extern errno_t ui_entry_set_text(ui_entry_t *, const char *); +extern errno_t ui_entry_paint(ui_entry_t *); + +#endif + +/** @} + */ Index: uspace/lib/ui/meson.build =================================================================== --- uspace/lib/ui/meson.build (revision 0d71fd6fb826667181acc317bb2e664fd2c9b10d) +++ uspace/lib/ui/meson.build (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -31,4 +31,5 @@ 'src/control.c', 'src/dummygc.c', + 'src/entry.c', 'src/fixed.c', 'src/image.c', @@ -44,4 +45,5 @@ test_src = files( 'test/control.c', + 'test/entry.c', 'test/fixed.c', 'test/image.c', Index: uspace/lib/ui/private/entry.h =================================================================== --- uspace/lib/ui/private/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) +++ uspace/lib/ui/private/entry.h (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2020 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 Text entry structure + * + */ + +#ifndef _UI_PRIVATE_ENTRY_H +#define _UI_PRIVATE_ENTRY_H + +#include +#include + +/** Actual structure of text entry. + * + * This is private to libui. + */ +struct ui_entry { + /** Base control object */ + struct ui_control *control; + /** UI resource */ + struct ui_resource *res; + /** Entry rectangle */ + gfx_rect_t rect; + /** Horizontal alignment */ + gfx_halign_t halign; + /** Text */ + char *text; +}; + +#endif + +/** @} + */ Index: uspace/lib/ui/private/resource.h =================================================================== --- uspace/lib/ui/private/resource.h (revision 0d71fd6fb826667181acc317bb2e664fd2c9b10d) +++ uspace/lib/ui/private/resource.h (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -87,4 +87,9 @@ /** Inactive titlebar text color */ gfx_color_t *tbar_inact_text_color; + + /** Entry (text entry, checkbox, radio button) foreground color */ + gfx_color_t *entry_fg_color; + /** Entry (text entry, checkbox, raido button) background color */ + gfx_color_t *entry_bg_color; }; Index: uspace/lib/ui/src/entry.c =================================================================== --- uspace/lib/ui/src/entry.c (revision d942ca434442952e508031582931d7a5f5f20b3a) +++ uspace/lib/ui/src/entry.c (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -0,0 +1,273 @@ +/* + * Copyright (c) 2020 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 Text entry. + * + * Currentry text entry is always read-only. It differs from label mostly + * by its looks. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../private/entry.h" +#include "../private/resource.h" + +static void ui_entry_ctl_destroy(void *); +static errno_t ui_entry_ctl_paint(void *); +static ui_evclaim_t ui_entry_ctl_pos_event(void *, pos_event_t *); + +enum { + ui_entry_hpad = 4, + ui_entry_vpad = 4 +}; + +/** Text entry control ops */ +ui_control_ops_t ui_entry_ops = { + .destroy = ui_entry_ctl_destroy, + .paint = ui_entry_ctl_paint, + .pos_event = ui_entry_ctl_pos_event +}; + +/** Create new text entry. + * + * @param resource UI resource + * @param text Text + * @param rentry Place to store pointer to new text entry + * @return EOK on success, ENOMEM if out of memory + */ +errno_t ui_entry_create(ui_resource_t *resource, const char *text, + ui_entry_t **rentry) +{ + ui_entry_t *entry; + errno_t rc; + + entry = calloc(1, sizeof(ui_entry_t)); + if (entry == NULL) + return ENOMEM; + + rc = ui_control_new(&ui_entry_ops, (void *) entry, &entry->control); + if (rc != EOK) { + free(entry); + return rc; + } + + entry->text = str_dup(text); + if (entry->text == NULL) { + ui_control_delete(entry->control); + free(entry); + return ENOMEM; + } + + entry->res = resource; + entry->halign = gfx_halign_left; + *rentry = entry; + return EOK; +} + +/** Destroy text entry. + * + * @param entry Text entry or @c NULL + */ +void ui_entry_destroy(ui_entry_t *entry) +{ + if (entry == NULL) + return; + + ui_control_delete(entry->control); + free(entry); +} + +/** Get base control from text entry. + * + * @param entry Text entry + * @return Control + */ +ui_control_t *ui_entry_ctl(ui_entry_t *entry) +{ + return entry->control; +} + +/** Set text entry rectangle. + * + * @param entry Text entry + * @param rect New text entry rectangle + */ +void ui_entry_set_rect(ui_entry_t *entry, gfx_rect_t *rect) +{ + entry->rect = *rect; +} + +/** Set text entry horizontal text alignment. + * + * @param entry Text entry + * @param halign Horizontal alignment + */ +void ui_entry_set_halign(ui_entry_t *entry, gfx_halign_t halign) +{ + entry->halign = halign; +} + +/** Set entry text. + * + * @param entry Text entry + * @param text New entry text + * @return EOK on success, ENOMEM if out of memory + */ +errno_t ui_entry_set_text(ui_entry_t *entry, const char *text) +{ + char *tcopy; + + tcopy = str_dup(text); + if (tcopy == NULL) + return ENOMEM; + + free(entry->text); + entry->text = tcopy; + + return EOK; +} + +/** Paint text entry. + * + * @param entry Text entry + * @return EOK on success or an error code + */ +errno_t ui_entry_paint(ui_entry_t *entry) +{ + gfx_text_fmt_t fmt; + gfx_coord2_t pos; + gfx_rect_t frame; + gfx_rect_t inside; + errno_t rc; + + /* Paint inset frame */ + + rc = ui_paint_bevel(entry->res->gc, &entry->rect, + entry->res->wnd_shadow_color, entry->res->wnd_highlight_color, + 1, &frame); + if (rc != EOK) + goto error; + + rc = ui_paint_bevel(entry->res->gc, &frame, + entry->res->wnd_frame_sh_color, entry->res->wnd_frame_hi_color, + 1, &inside); + if (rc != EOK) + goto error; + + /* Paint entry background */ + + rc = gfx_set_color(entry->res->gc, entry->res->entry_bg_color); + if (rc != EOK) + goto error; + + rc = gfx_fill_rect(entry->res->gc, &inside); + if (rc != EOK) + goto error; + + switch (entry->halign) { + case gfx_halign_left: + case gfx_halign_justify: + pos.x = inside.p0.x + ui_entry_hpad; + break; + case gfx_halign_center: + pos.x = (inside.p0.x + inside.p1.x) / 2; + break; + case gfx_halign_right: + pos.x = inside.p1.x - ui_entry_hpad; + break; + } + + pos.y = inside.p0.y + ui_entry_vpad; + + gfx_text_fmt_init(&fmt); + fmt.halign = entry->halign; + fmt.valign = gfx_valign_top; + + rc = gfx_set_color(entry->res->gc, entry->res->entry_fg_color); + if (rc != EOK) + goto error; + + rc = gfx_puttext(entry->res->font, &pos, &fmt, entry->text); + if (rc != EOK) + goto error; + + return EOK; +error: + return rc; +} + +/** Destroy text entry control. + * + * @param arg Argument (ui_entry_t *) + */ +void ui_entry_ctl_destroy(void *arg) +{ + ui_entry_t *entry = (ui_entry_t *) arg; + + ui_entry_destroy(entry); +} + +/** Paint text entry control. + * + * @param arg Argument (ui_entry_t *) + * @return EOK on success or an error code + */ +errno_t ui_entry_ctl_paint(void *arg) +{ + ui_entry_t *entry = (ui_entry_t *) arg; + + return ui_entry_paint(entry); +} + +/** Handle text entry control position event. + * + * @param arg Argument (ui_entry_t *) + * @param pos_event Position event + * @return @c ui_claimed iff the event is claimed + */ +ui_evclaim_t ui_entry_ctl_pos_event(void *arg, pos_event_t *event) +{ + ui_entry_t *entry = (ui_entry_t *) arg; + + (void) entry; + return ui_unclaimed; +} + +/** @} + */ Index: uspace/lib/ui/src/resource.c =================================================================== --- uspace/lib/ui/src/resource.c (revision 0d71fd6fb826667181acc317bb2e664fd2c9b10d) +++ uspace/lib/ui/src/resource.c (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -74,4 +74,6 @@ gfx_color_t *tbar_act_text_color = NULL; gfx_color_t *tbar_inact_text_color = NULL; + gfx_color_t *entry_fg_color = NULL; + gfx_color_t *entry_bg_color = NULL; errno_t rc; @@ -156,4 +158,12 @@ rc = gfx_color_new_rgb_i16(0x5858, 0x5858, 0x5858, &tbar_inact_text_color); + if (rc != EOK) + goto error; + + rc = gfx_color_new_rgb_i16(0, 0, 0, &entry_fg_color); + if (rc != EOK) + goto error; + + rc = gfx_color_new_rgb_i16(0xffff, 0xffff, 0xffff, &entry_bg_color); if (rc != EOK) goto error; @@ -180,4 +190,7 @@ resource->tbar_inact_bg_color = tbar_inact_bg_color; resource->tbar_inact_text_color = tbar_inact_text_color; + + resource->entry_fg_color = entry_fg_color; + resource->entry_bg_color = entry_bg_color; *rresource = resource; @@ -217,4 +230,9 @@ gfx_color_delete(tbar_inact_text_color); + if (entry_fg_color != NULL) + gfx_color_delete(entry_fg_color); + if (entry_bg_color != NULL) + gfx_color_delete(entry_bg_color); + if (tface != NULL) gfx_typeface_destroy(tface); @@ -250,4 +268,7 @@ gfx_color_delete(resource->tbar_inact_text_color); + gfx_color_delete(resource->entry_fg_color); + gfx_color_delete(resource->entry_bg_color); + gfx_font_close(resource->font); gfx_typeface_destroy(resource->tface); Index: uspace/lib/ui/test/entry.c =================================================================== --- uspace/lib/ui/test/entry.c (revision d942ca434442952e508031582931d7a5f5f20b3a) +++ uspace/lib/ui/test/entry.c (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -0,0 +1,287 @@ +/* + * Copyright (c) 2020 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/entry.h" + +PCUT_INIT; + +PCUT_TEST_SUITE(entry); + +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 +}; + +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 clicked; +} test_cb_resp_t; + +/** Create and destroy text entry */ +PCUT_TEST(create_destroy) +{ + ui_entry_t *entry = NULL; + errno_t rc; + + rc = ui_entry_create(NULL, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + PCUT_ASSERT_NOT_NULL(entry); + + ui_entry_destroy(entry); +} + +/** ui_entry_destroy() can take NULL argument (no-op) */ +PCUT_TEST(destroy_null) +{ + ui_entry_destroy(NULL); +} + +/** ui_entry_ctl() returns control that has a working virtual destructor */ +PCUT_TEST(ctl) +{ + ui_entry_t *entry; + ui_control_t *control; + errno_t rc; + + rc = ui_entry_create(NULL, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + control = ui_entry_ctl(entry); + PCUT_ASSERT_NOT_NULL(control); + + ui_control_destroy(control); +} + +/** Set text entry rectangle sets internal field */ +PCUT_TEST(set_rect) +{ + ui_entry_t *entry; + gfx_rect_t rect; + errno_t rc; + + rc = ui_entry_create(NULL, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rect.p0.x = 1; + rect.p0.y = 2; + rect.p1.x = 3; + rect.p1.y = 4; + + ui_entry_set_rect(entry, &rect); + PCUT_ASSERT_INT_EQUALS(rect.p0.x, entry->rect.p0.x); + PCUT_ASSERT_INT_EQUALS(rect.p0.y, entry->rect.p0.y); + PCUT_ASSERT_INT_EQUALS(rect.p1.x, entry->rect.p1.x); + PCUT_ASSERT_INT_EQUALS(rect.p1.y, entry->rect.p1.y); + + ui_entry_destroy(entry); +} + +/** Set entry text horizontal alignment sets internal field */ +PCUT_TEST(set_halign) +{ + ui_entry_t *entry; + errno_t rc; + + rc = ui_entry_create(NULL, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + ui_entry_set_halign(entry, gfx_halign_left); + PCUT_ASSERT_EQUALS(gfx_halign_left, entry->halign); + ui_entry_set_halign(entry, gfx_halign_center); + PCUT_ASSERT_EQUALS(gfx_halign_center, entry->halign); + + ui_entry_destroy(entry); +} + +/** Set text entry rectangle sets internal field */ +PCUT_TEST(set_text) +{ + ui_entry_t *entry; + gfx_rect_t rect; + errno_t rc; + + rc = ui_entry_create(NULL, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rect.p0.x = 1; + rect.p0.y = 2; + rect.p1.x = 3; + rect.p1.y = 4; + + ui_entry_set_rect(entry, &rect); + PCUT_ASSERT_INT_EQUALS(rect.p0.x, entry->rect.p0.x); + PCUT_ASSERT_INT_EQUALS(rect.p0.y, entry->rect.p0.y); + PCUT_ASSERT_INT_EQUALS(rect.p1.x, entry->rect.p1.x); + PCUT_ASSERT_INT_EQUALS(rect.p1.y, entry->rect.p1.y); + + ui_entry_destroy(entry); +} + +/** Paint text entry */ +PCUT_TEST(paint) +{ + errno_t rc; + gfx_context_t *gc = NULL; + test_gc_t tgc; + ui_resource_t *resource = NULL; + ui_entry_t *entry; + + 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_entry_create(resource, "Hello", &entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + rc = ui_entry_paint(entry); + PCUT_ASSERT_ERRNO_VAL(EOK, rc); + + ui_entry_destroy(entry); + 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; +} + +PCUT_EXPORT(entry); Index: uspace/lib/ui/test/main.c =================================================================== --- uspace/lib/ui/test/main.c (revision 0d71fd6fb826667181acc317bb2e664fd2c9b10d) +++ uspace/lib/ui/test/main.c (revision d942ca434442952e508031582931d7a5f5f20b3a) @@ -32,4 +32,5 @@ PCUT_IMPORT(control); +PCUT_IMPORT(entry); PCUT_IMPORT(fixed); PCUT_IMPORT(image);