Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b36ebb42 in mainline


Ignore:
Timestamp:
2021-10-25T00:32:45Z (3 months ago)
Author:
jxsvoboda <5887334+jxsvoboda@…>
Branches:
master
Children:
61784ed
Parents:
6aa85c1
git-author:
Jiri Svoboda <jiri@…> (2021-10-04 20:39:24)
git-committer:
jxsvoboda <5887334+jxsvoboda@…> (2021-10-25 00:32:45)
Message:

Create, position panels and paint boxes around them

Location:
uspace/app/nav
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/nav/nav.c

    r6aa85c1 rb36ebb42  
    4545#include "menu.h"
    4646#include "nav.h"
     47#include "panel.h"
    4748
    4849static void wnd_close(ui_window_t *, void *);
     
    7576        navigator_t *navigator;
    7677        ui_wnd_params_t params;
     78        gfx_rect_t rect;
     79        unsigned i;
    7780        errno_t rc;
    7881
     
    118121        }
    119122
     123        for (i = 0; i < 2; i++) {
     124                rc = panel_create(navigator->window, &navigator->panel[i]);
     125                if (rc != EOK)
     126                        goto error;
     127
     128                rect.p0.x = 40 * i;
     129                rect.p0.y = 1;
     130                rect.p1.x = 40 * (i + 1);
     131                rect.p1.y = 24;
     132                panel_set_rect(navigator->panel[i], &rect);
     133
     134                rc = ui_fixed_add(navigator->fixed,
     135                    panel_ctl(navigator->panel[i]));
     136                if (rc != EOK) {
     137                        printf("Error adding control to layout.\n");
     138                        return rc;
     139                }
     140        }
     141
    120142        rc = ui_window_paint(navigator->window);
    121143        if (rc != EOK) {
     
    133155void navigator_destroy(navigator_t *navigator)
    134156{
     157        unsigned i;
     158
     159        for (i = 0; i < 2; i++) {
     160                ui_fixed_remove(navigator->fixed,
     161                    panel_ctl(navigator->panel[i]));
     162                panel_destroy(navigator->panel[i]);
     163        }
     164
    135165        ui_fixed_remove(navigator->fixed, nav_menu_ctl(navigator->menu));
    136166
  • uspace/app/nav/nav.h

    r6aa85c1 rb36ebb42  
    5353        /** Menu */
    5454        struct nav_menu *menu;
     55        /** Panels */
     56        struct panel *panel[2];
    5557} navigator_t;
    5658
     
    5961extern errno_t navigator_run(const char *);
    6062
    61 
    6263#endif
    6364
  • uspace/app/nav/panel.c

    r6aa85c1 rb36ebb42  
    3636
    3737#include <errno.h>
     38#include <gfx/render.h>
    3839#include <stdlib.h>
     40#include <ui/control.h>
     41#include <ui/paint.h>
    3942#include "panel.h"
    4043#include "nav.h"
    4144
     45static void panel_ctl_destroy(void *);
     46static errno_t panel_ctl_paint(void *);
     47static ui_evclaim_t panel_ctl_pos_event(void *, pos_event_t *);
     48
     49/** Panel control ops */
     50ui_control_ops_t panel_ctl_ops = {
     51        .destroy = panel_ctl_destroy,
     52        .paint = panel_ctl_paint,
     53        .pos_event = panel_ctl_pos_event
     54};
     55
    4256/** Create panel.
    4357 *
     58 * @param window Containing window
    4459 * @param rpanel Place to store pointer to new panel
    4560 * @return EOK on success or an error code
    4661 */
    47 errno_t panel_create(panel_t **rpanel)
     62errno_t panel_create(ui_window_t *window, panel_t **rpanel)
    4863{
    4964        panel_t *panel;
     65        errno_t rc;
    5066
    5167        panel = calloc(1, sizeof(panel_t));
     
    5369                return ENOMEM;
    5470
     71        rc = ui_control_new(&panel_ctl_ops, (void *)panel,
     72            &panel->control);
     73        if (rc != EOK) {
     74                free(panel);
     75                return rc;
     76        }
     77
     78        rc = gfx_color_new_ega(0x07, &panel->color);
     79        if (rc != EOK)
     80                goto error;
     81
     82        panel->window = window;
    5583        *rpanel = panel;
    5684        return EOK;
     85error:
     86        ui_control_delete(panel->control);
     87        free(panel);
     88        return rc;
    5789}
    5890
     
    6395void panel_destroy(panel_t *panel)
    6496{
     97        ui_control_delete(panel->control);
    6598        free(panel);
    6699}
    67100
     101/** Paint panel.
     102 *
     103 * @param panel Panel
     104 */
     105errno_t panel_paint(panel_t *panel)
     106{
     107        gfx_context_t *gc = ui_window_get_gc(panel->window);
     108        ui_resource_t *res = ui_window_get_res(panel->window);
     109        errno_t rc;
     110
     111        rc = gfx_set_color(gc, panel->color);
     112        if (rc != EOK)
     113                return rc;
     114
     115        rc = gfx_fill_rect(gc, &panel->rect);
     116        if (rc != EOK)
     117                return rc;
     118
     119        rc = ui_paint_text_box(res, &panel->rect, ui_box_single,
     120            panel->color);
     121        if (rc != EOK)
     122                return rc;
     123
     124        rc = gfx_update(gc);
     125        if (rc != EOK)
     126                return rc;
     127
     128        return EOK;
     129}
     130
     131/** Handle panel position event.
     132 *
     133 * @param panel Panel
     134 * @param event Position event
     135 * @return ui_claimed iff event was claimed
     136 */
     137ui_evclaim_t panel_pos_event(panel_t *panel, pos_event_t *event)
     138{
     139        return ui_unclaimed;
     140}
     141
     142/** Get base control for panel.
     143 *
     144 * @param panel Panel
     145 * @return Base UI control
     146 */
     147ui_control_t *panel_ctl(panel_t *panel)
     148{
     149        return panel->control;
     150}
     151
     152/** Set panel rectangle.
     153 *
     154 * @param panel Panel
     155 * @param rect Rectangle
     156 */
     157void panel_set_rect(panel_t *panel, gfx_rect_t *rect)
     158{
     159        panel->rect = *rect;
     160}
     161
     162/** Destroy panel control.
     163 *
     164 * @param arg Argument (panel_t *)
     165 */
     166void panel_ctl_destroy(void *arg)
     167{
     168        panel_t *panel = (panel_t *) arg;
     169
     170        panel_destroy(panel);
     171}
     172
     173/** Paint panel control.
     174 *
     175 * @param arg Argument (panel_t *)
     176 * @return EOK on success or an error code
     177 */
     178errno_t panel_ctl_paint(void *arg)
     179{
     180        panel_t *panel = (panel_t *) arg;
     181
     182        return panel_paint(panel);
     183}
     184
     185/** Handle panel control position event.
     186 *
     187 * @param arg Argument (panel_t *)
     188 * @param pos_event Position event
     189 * @return @c ui_claimed iff the event is claimed
     190 */
     191ui_evclaim_t panel_ctl_pos_event(void *arg, pos_event_t *event)
     192{
     193        panel_t *panel = (panel_t *) arg;
     194
     195        return panel_pos_event(panel, event);
     196}
     197
     198
    68199/** @}
    69200 */
  • uspace/app/nav/panel.h

    r6aa85c1 rb36ebb42  
    4040#include <gfx/color.h>
    4141#include <gfx/coord.h>
     42#include <io/pos_event.h>
    4243#include <ui/control.h>
     44#include <ui/window.h>
    4345#include "nav.h"
    4446#include "panel.h"
     
    4850 * This is a custom UI control.
    4951 */
    50 typedef struct {
     52typedef struct panel {
    5153        /** Base control object */
    5254        struct ui_control *control;
     55
     56        /** Containing window */
     57        ui_window_t *window;
    5358
    5459        /** Panel rectangle */
     
    5964} panel_t;
    6065
    61 extern errno_t panel_create(panel_t **);
     66extern errno_t panel_create(ui_window_t *, panel_t **);
    6267extern void panel_destroy(panel_t *);
     68extern errno_t panel_paint(panel_t *);
     69extern ui_evclaim_t panel_pos_event(panel_t *, pos_event_t *);
     70extern ui_control_t *panel_ctl(panel_t *);
     71extern void panel_set_rect(panel_t *, gfx_rect_t *);
    6372
    6473#endif
  • uspace/app/nav/test/menu.c

    r6aa85c1 rb36ebb42  
    5757
    5858        nav_menu_destroy(menu);
     59        ui_window_destroy(window);
     60        ui_destroy(ui);
    5961}
    6062
  • uspace/app/nav/test/panel.c

    r6aa85c1 rb36ebb42  
    4141        errno_t rc;
    4242
    43         rc = panel_create(&panel);
     43        rc = panel_create(NULL, &panel);
    4444        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    4545
     
    4747}
    4848
     49
     50/** Test panel_paint() */
     51PCUT_TEST(paint)
     52{
     53        ui_t *ui;
     54        ui_window_t *window;
     55        ui_wnd_params_t params;
     56        panel_t *panel;
     57        errno_t rc;
     58
     59        rc = ui_create_disp(NULL, &ui);
     60        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     61
     62        ui_wnd_params_init(&params);
     63        params.caption = "Test";
     64
     65        rc = ui_window_create(ui, &params, &window);
     66        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     67
     68        rc = panel_create(window, &panel);
     69        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     70
     71        rc = panel_paint(panel);
     72        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     73
     74        panel_destroy(panel);
     75        ui_window_destroy(window);
     76        ui_destroy(ui);
     77}
     78
     79/** panel_ctl() returns a valid UI control */
     80PCUT_TEST(ctl)
     81{
     82        panel_t *panel;
     83        ui_control_t *control;
     84        errno_t rc;
     85
     86        rc = panel_create(NULL, &panel);
     87        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     88
     89        control = panel_ctl(panel);
     90        PCUT_ASSERT_NOT_NULL(control);
     91
     92        panel_destroy(panel);
     93}
     94
     95/** Test panel_pos_event() */
     96PCUT_TEST(pos_event)
     97{
     98        panel_t *panel;
     99        ui_control_t *control;
     100        ui_evclaim_t claimed;
     101        pos_event_t event;
     102        errno_t rc;
     103
     104        rc = panel_create(NULL, &panel);
     105        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     106
     107        control = panel_ctl(panel);
     108        PCUT_ASSERT_NOT_NULL(control);
     109
     110        claimed = panel_pos_event(panel, &event);
     111        PCUT_ASSERT_EQUALS(ui_unclaimed, claimed);
     112
     113        panel_destroy(panel);
     114}
     115
     116/** panel_set_rect() sets internal field */
     117PCUT_TEST(set_rect)
     118{
     119        panel_t *panel;
     120        ui_control_t *control;
     121        gfx_rect_t rect;
     122        errno_t rc;
     123
     124        rc = panel_create(NULL, &panel);
     125        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     126
     127        control = panel_ctl(panel);
     128        PCUT_ASSERT_NOT_NULL(control);
     129
     130        rect.p0.x = 1;
     131        rect.p0.y = 2;
     132        rect.p1.x = 3;
     133        rect.p1.y = 4;
     134
     135        panel_set_rect(panel, &rect);
     136        PCUT_ASSERT_INT_EQUALS(rect.p0.x, panel->rect.p0.x);
     137        PCUT_ASSERT_INT_EQUALS(rect.p0.y, panel->rect.p0.y);
     138        PCUT_ASSERT_INT_EQUALS(rect.p1.x, panel->rect.p1.x);
     139        PCUT_ASSERT_INT_EQUALS(rect.p1.y, panel->rect.p1.y);
     140
     141        panel_destroy(panel);
     142}
     143
    49144PCUT_EXPORT(panel);
Note: See TracChangeset for help on using the changeset viewer.