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

Changeset 6af4b4f in mainline


Ignore:
Timestamp:
2019-10-05T08:45:25Z (13 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
bef51cf
Parents:
c8cf261
git-author:
Jiri Svoboda <jiri@…> (2019-10-04 17:52:54)
git-committer:
Jiri Svoboda <jiri@…> (2019-10-05 08:45:25)
Message:

Introduce ds_display_t, ds_window_t

Location:
uspace/srv/hid/display
Files:
3 added
4 edited
3 moved

Legend:

Unmodified
Added
Removed
  • uspace/srv/hid/display/display.c

    rc8cf261 r6af4b4f  
    3737#include <errno.h>
    3838#include <io/log.h>
     39#include <stdlib.h>
     40#include "display.h"
     41#include "window.h"
    3942
    4043static errno_t disp_window_create(void *, sysarg_t *);
     
    4851static errno_t disp_window_create(void *arg, sysarg_t *rwnd_id)
    4952{
     53        errno_t rc;
     54        ds_display_t *disp = (ds_display_t *) arg;
     55        ds_window_t *wnd;
     56
    5057        log_msg(LOG_DEFAULT, LVL_DEBUG, "disp_window_create()");
    51         *rwnd_id = 42;
     58
     59        rc = ds_window_create(disp, &wnd);
     60        log_msg(LOG_DEFAULT, LVL_DEBUG, "disp_window_create() - ds_window_create -> %d", rc);
     61        if (rc != EOK)
     62                return rc;
     63
     64        log_msg(LOG_DEFAULT, LVL_DEBUG, "disp_window_create() -> EOK, id=%zu",
     65            wnd->id);
     66        *rwnd_id = wnd->id;
    5267        return EOK;
    5368}
     
    5570static errno_t disp_window_destroy(void *arg, sysarg_t wnd_id)
    5671{
     72        ds_display_t *disp = (ds_display_t *) arg;
     73        ds_window_t *wnd;
     74
     75        wnd = ds_display_find_window(disp, wnd_id);
     76        if (wnd == NULL)
     77                return ENOENT;
     78
    5779        log_msg(LOG_DEFAULT, LVL_DEBUG, "disp_window_destroy()");
     80        ds_display_remove_window(wnd);
     81        ds_window_delete(wnd);
    5882        return EOK;
     83}
     84
     85/** Create display.
     86 *
     87 * @param rdisp Place to store pointer to new display.
     88 * @return EOK on success, ENOMEM if out of memory
     89 */
     90errno_t ds_display_create(ds_display_t **rdisp)
     91{
     92        ds_display_t *disp;
     93
     94        disp = calloc(1, sizeof(ds_display_t));
     95        if (disp == NULL)
     96                return ENOMEM;
     97
     98        list_initialize(&disp->windows);
     99        disp->next_wnd_id = 1;
     100        *rdisp = disp;
     101        return EOK;
     102}
     103
     104/** Destroy display.
     105 *
     106 * @param disp Display
     107 */
     108void ds_display_destroy(ds_display_t *disp)
     109{
     110        assert(list_empty(&disp->windows));
     111        free(disp);
     112}
     113
     114/** Add window to display.
     115 *
     116 * @param disp Display
     117 * @param wnd Window
     118 * @return EOK on success, ENOMEM if there are no free window identifiers
     119 */
     120errno_t ds_display_add_window(ds_display_t *disp, ds_window_t *wnd)
     121{
     122        assert(wnd->display == NULL);
     123        assert(!link_used(&wnd->lwindows));
     124
     125        wnd->display = disp;
     126        wnd->id = disp->next_wnd_id++;
     127        list_append(&wnd->lwindows, &disp->windows);
     128
     129        return EOK;
     130}
     131
     132/** Remove window from display.
     133 *
     134 * @param wnd Window
     135 */
     136void ds_display_remove_window(ds_window_t *wnd)
     137{
     138        list_remove(&wnd->lwindows);
     139        wnd->display = NULL;
     140}
     141
     142/** Find window by ID.
     143 *
     144 * @param disp Display
     145 * @param id Window ID
     146 */
     147ds_window_t *ds_display_find_window(ds_display_t *disp, ds_wnd_id_t id)
     148{
     149        ds_window_t *wnd;
     150
     151        // TODO Make this faster
     152        wnd = ds_display_first_window(disp);
     153        while (wnd != NULL) {
     154                if (wnd->id == id)
     155                        return wnd;
     156                wnd = ds_display_next_window(wnd);
     157        }
     158
     159        return NULL;
     160}
     161
     162/** Get first window in display.
     163 *
     164 * @param disp Display
     165 * @return First window or @c NULL if there is none
     166 */
     167ds_window_t *ds_display_first_window(ds_display_t *disp)
     168{
     169        link_t *link = list_first(&disp->windows);
     170
     171        if (link == NULL)
     172                return NULL;
     173
     174        return list_get_instance(link, ds_window_t, lwindows);
     175}
     176
     177/** Get next window in display.
     178 *
     179 * @param wnd Current window
     180 * @return Next window or @c NULL if there is none
     181 */
     182ds_window_t *ds_display_next_window(ds_window_t *wnd)
     183{
     184        link_t *link = list_next(&wnd->lwindows, &wnd->display->windows);
     185
     186        if (link == NULL)
     187                return NULL;
     188
     189        return list_get_instance(link, ds_window_t, lwindows);
    59190}
    60191
  • uspace/srv/hid/display/display.h

    rc8cf261 r6af4b4f  
    3939
    4040#include <disp_srv.h>
     41#include <errno.h>
     42#include "types/display/display.h"
     43#include "types/display/window.h"
    4144
    4245extern display_ops_t display_srv_ops;
     46
     47extern errno_t ds_display_create(ds_display_t **);
     48extern void ds_display_destroy(ds_display_t *);
     49extern errno_t ds_display_add_window(ds_display_t *, ds_window_t *);
     50extern void ds_display_remove_window(ds_window_t *);
     51extern ds_window_t *ds_display_find_window(ds_display_t *, ds_wnd_id_t);
     52extern ds_window_t *ds_display_first_window(ds_display_t *);
     53extern ds_window_t *ds_display_next_window(ds_window_t *);
    4354
    4455#endif
  • uspace/srv/hid/display/main.c

    rc8cf261 r6af4b4f  
    4646#include <task.h>
    4747#include "display.h"
    48 #include "wingc.h"
     48#include "window.h"
    4949
    5050#define NAME  "display"
     
    5555static errno_t display_srv_init(void)
    5656{
     57        ds_display_t *disp = NULL;
    5758        errno_t rc;
     59
     60        rc = ds_display_create(&disp);
     61        if (rc != EOK)
     62                goto error;
    5863
    5964        log_msg(LOG_DEFAULT, LVL_DEBUG, "display_srv_init()");
    6065
    61         async_set_fallback_port_handler(display_client_conn, NULL/*parts*/);
     66        async_set_fallback_port_handler(display_client_conn, disp);
    6267
    6368        rc = loc_server_register(NAME);
     
    7782        return EOK;
    7883error:
     84        if (disp != NULL)
     85                ds_display_destroy(disp);
    7986        return rc;
    8087}
     
    8693        sysarg_t wnd_id;
    8794        sysarg_t svc_id;
    88         win_gc_t *wgc = NULL;
     95        ds_window_t *wnd;
     96        ds_display_t *disp = (ds_display_t *) arg;
    8997        gfx_context_t *gc;
    90         errno_t rc;
    9198
    9299        log_msg(LOG_DEFAULT, LVL_NOTE, "display_client_conn arg1=%zu arg2=%zu arg3=%zu arg4=%zu.",
     
    103110                /* Display management */
    104111                srv.ops = &display_srv_ops;
    105                 srv.arg = NULL;
     112                srv.arg = disp;
    106113
    107114                display_conn(icall, &srv);
    108115        } else {
    109                 (void) wnd_id;
    110116                /* Window GC */
    111                 rc = win_gc_create(&wgc);
    112                 if (rc != EOK) {
    113                         async_answer_0(icall, ENOMEM);
     117                wnd = ds_display_find_window(disp, wnd_id);
     118                if (wnd == NULL) {
     119                        async_answer_0(icall, ENOENT);
    114120                        return;
    115121                }
    116122
    117                 gc = win_gc_get_ctx(wgc);
     123                gc = ds_window_get_ctx(wnd);
    118124                gc_conn(icall, gc);
    119 
    120                 win_gc_delete(wgc);
    121125        }
    122126}
  • uspace/srv/hid/display/meson.build

    rc8cf261 r6af4b4f  
    2727#
    2828
    29 deps = [ 'ipcgfx', 'display' ]
     29deps = [ 'ipcgfx', 'display', 'guigfx' ]
    3030
    3131src = files(
    3232        'display.c',
    3333        'main.c',
    34         'wingc.c'
     34        'window.c',
    3535)
     36
     37test_src = files(
     38        'display.c',
     39        'window.c',
     40        'test/main.c',
     41        'test/display.c',
     42)
  • uspace/srv/hid/display/test/main.c

    rc8cf261 r6af4b4f  
    2727 */
    2828
    29 /** @addtogroup libipcgfx
    30  * @{
    31  */
    32 /**
    33  * @file GFX IPC backend
    34  */
     29#include <pcut/pcut.h>
    3530
    36 #ifndef TYPES_WINGC_H
    37 #define TYPES_WINGC_H
     31PCUT_INIT;
    3832
    39 #include <gfx/context.h>
     33PCUT_IMPORT(display);
    4034
    41 typedef struct win_gc {
    42         /** Base graphic context */
    43         gfx_context_t *gc;
    44 } win_gc_t;
    45 
    46 #endif
    47 
    48 /** @}
    49  */
     35PCUT_MAIN();
  • uspace/srv/hid/display/window.c

    rc8cf261 r6af4b4f  
    4141#include <io/log.h>
    4242#include <stdlib.h>
    43 #include "wingc.h"
     43#include "display.h"
     44#include "window.h"
    4445
    45 static errno_t win_gc_set_color(void *, gfx_color_t *);
    46 static errno_t win_gc_fill_rect(void *, gfx_rect_t *);
     46static errno_t ds_window_set_color(void *, gfx_color_t *);
     47static errno_t ds_window_fill_rect(void *, gfx_rect_t *);
    4748
    48 gfx_context_ops_t win_gc_ops = {
    49         .set_color = win_gc_set_color,
    50         .fill_rect = win_gc_fill_rect
     49gfx_context_ops_t ds_window_ops = {
     50        .set_color = ds_window_set_color,
     51        .fill_rect = ds_window_fill_rect
    5152};
    5253
     
    6061 * @return EOK on success or an error code
    6162 */
    62 static errno_t win_gc_set_color(void *arg, gfx_color_t *color)
     63static errno_t ds_window_set_color(void *arg, gfx_color_t *color)
    6364{
    64         win_gc_t *wgc = (win_gc_t *) arg;
     65        ds_window_t *wnd = (ds_window_t *) arg;
    6566
    66         (void) wgc;
     67        (void) wnd;
    6768        log_msg(LOG_DEFAULT, LVL_NOTE, "gc_set_color");
    6869        return EOK;
     
    7172/** Fill rectangle on window GC.
    7273 *
    73  * @param arg Console GC
     74 * @param arg Window GC
    7475 * @param rect Rectangle
    7576 *
    7677 * @return EOK on success or an error code
    7778 */
    78 static errno_t win_gc_fill_rect(void *arg, gfx_rect_t *rect)
     79static errno_t ds_window_fill_rect(void *arg, gfx_rect_t *rect)
    7980{
    80         win_gc_t *wgc = (win_gc_t *) arg;
     81        ds_window_t *wnd = (ds_window_t *) arg;
    8182
    82         (void) wgc;
     83        (void) wnd;
    8384        log_msg(LOG_DEFAULT, LVL_NOTE, "gc_fill_rect");
    8485        return EOK;
    8586}
    8687
    87 /** Create window GC.
     88/** Create window.
    8889 *
    8990 * Create graphics context for rendering into a window.
    9091 *
     92 * @param disp Display to create window on
    9193 * @param rgc Place to store pointer to new GC.
    9294 *
    9395 * @return EOK on success or an error code
    9496 */
    95 errno_t win_gc_create(win_gc_t **rgc)
     97errno_t ds_window_create(ds_display_t *disp, ds_window_t **rgc)
    9698{
    97         win_gc_t *wgc = NULL;
     99        ds_window_t *wnd = NULL;
    98100        gfx_context_t *gc = NULL;
    99101        errno_t rc;
    100102
    101         wgc = calloc(1, sizeof(win_gc_t));
    102         if (wgc == NULL) {
     103        wnd = calloc(1, sizeof(ds_window_t));
     104        if (wnd == NULL) {
    103105                rc = ENOMEM;
    104106                goto error;
    105107        }
    106108
    107         rc = gfx_context_new(&win_gc_ops, wgc, &gc);
     109        rc = gfx_context_new(&ds_window_ops, wnd, &gc);
    108110        if (rc != EOK)
    109111                goto error;
    110112
    111         wgc->gc = gc;
    112         *rgc = wgc;
     113        ds_display_add_window(disp, wnd);
     114
     115        wnd->gc = gc;
     116        *rgc = wnd;
    113117        return EOK;
    114118error:
    115         if (wgc != NULL)
    116                 free(wgc);
     119        if (wnd != NULL)
     120                free(wnd);
    117121        gfx_context_delete(gc);
    118122        return rc;
     
    121125/** Delete window GC.
    122126 *
    123  * @param wgc Console GC
     127 * @param wnd Window GC
    124128 */
    125 errno_t win_gc_delete(win_gc_t *wgc)
     129errno_t ds_window_delete(ds_window_t *wnd)
    126130{
    127131        errno_t rc;
    128132
    129         rc = gfx_context_delete(wgc->gc);
     133        rc = gfx_context_delete(wnd->gc);
    130134        if (rc != EOK)
    131135                return rc;
    132136
    133         free(wgc);
     137        free(wnd);
    134138        return EOK;
    135139}
    136140
    137 /** Get generic graphic context from window GC.
     141/** Get generic graphic context from window.
    138142 *
    139  * @param wgc Console GC
     143 * @param wnd Window
    140144 * @return Graphic context
    141145 */
    142 gfx_context_t *win_gc_get_ctx(win_gc_t *wgc)
     146gfx_context_t *ds_window_get_ctx(ds_window_t *wnd)
    143147{
    144         return wgc->gc;
     148        return wnd->gc;
    145149}
    146150
  • uspace/srv/hid/display/window.h

    rc8cf261 r6af4b4f  
    3131 */
    3232/**
    33  * @file Window graphics context
     33 * @file Display server window
    3434 */
    3535
    36 #ifndef WINGC_H
    37 #define WINGC_H
     36#ifndef WINDOW_H
     37#define WINDOW_H
    3838
     39#include <errno.h>
    3940#include <types/gfx/context.h>
    4041#include <types/gfx/ops/context.h>
    41 #include "types/wingc.h"
     42#include "types/display/display.h"
     43#include "types/display/window.h"
    4244
    43 extern gfx_context_ops_t win_gc_ops;
     45extern gfx_context_ops_t window_gc_ops;
    4446
    45 extern errno_t win_gc_create(win_gc_t **);
    46 extern errno_t win_gc_delete(win_gc_t *);
    47 extern gfx_context_t *win_gc_get_ctx(win_gc_t *);
     47extern errno_t ds_window_create(ds_display_t *, ds_window_t **);
     48extern errno_t ds_window_delete(ds_window_t *);
     49extern gfx_context_t *ds_window_get_ctx(ds_window_t *);
    4850
    4951#endif
Note: See TracChangeset for help on using the changeset viewer.