Changeset aa2b32c in mainline for uspace/lib
- Timestamp:
- 2013-04-29T12:44:05Z (12 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- a269d05
- Parents:
- 06b0211b (diff), 9e7898e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- uspace/lib
- Files:
-
- 3 added
- 12 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/io/con_srv.c
r06b0211b raa2b32c 35 35 */ 36 36 #include <errno.h> 37 #include <io/cons_event.h> 37 38 #include <ipc/console.h> 38 39 #include <stdlib.h> … … 40 41 41 42 #include <io/con_srv.h> 43 44 static int console_ev_encode(cons_event_t *event, ipc_call_t *call) 45 { 46 IPC_SET_ARG1(*call, event->type); 47 48 switch (event->type) { 49 case CEV_KEY: 50 IPC_SET_ARG2(*call, event->ev.key.type); 51 IPC_SET_ARG3(*call, event->ev.key.key); 52 IPC_SET_ARG4(*call, event->ev.key.mods); 53 IPC_SET_ARG5(*call, event->ev.key.c); 54 break; 55 case CEV_POS: 56 IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff)); 57 IPC_SET_ARG3(*call, event->ev.pos.btn_num); 58 IPC_SET_ARG4(*call, event->ev.pos.hpos); 59 IPC_SET_ARG5(*call, event->ev.pos.vpos); 60 break; 61 default: 62 return EIO; 63 } 64 65 return EOK; 66 } 42 67 43 68 static void con_read_srv(con_srv_t *srv, ipc_callid_t callid, … … 273 298 { 274 299 int rc; 275 kbd_event_t event; 300 cons_event_t event; 301 ipc_call_t result; 276 302 277 303 if (srv->srvs->ops->get_event == NULL) { … … 281 307 282 308 rc = srv->srvs->ops->get_event(srv, &event); 283 async_answer_4(callid, rc, event.type, event.key, event.mods, event.c); 309 if (rc != EOK) { 310 async_answer_0(callid, rc); 311 return; 312 } 313 314 rc = console_ev_encode(&event, &result); 315 if (rc != EOK) { 316 async_answer_0(callid, rc); 317 return; 318 } 319 320 async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result), 321 IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result)); 284 322 } 285 323 -
uspace/lib/c/generic/io/console.c
r06b0211b raa2b32c 154 154 } 155 155 156 bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event) 156 static int console_ev_decode(ipc_call_t *call, cons_event_t *event) 157 { 158 event->type = IPC_GET_ARG1(*call); 159 160 switch (event->type) { 161 case CEV_KEY: 162 event->ev.key.type = IPC_GET_ARG2(*call); 163 event->ev.key.key = IPC_GET_ARG3(*call); 164 event->ev.key.mods = IPC_GET_ARG4(*call); 165 event->ev.key.c = IPC_GET_ARG5(*call); 166 break; 167 case CEV_POS: 168 event->ev.pos.pos_id = IPC_GET_ARG2(*call) >> 16; 169 event->ev.pos.type = IPC_GET_ARG2(*call) & 0xffff; 170 event->ev.pos.btn_num = IPC_GET_ARG3(*call); 171 event->ev.pos.hpos = IPC_GET_ARG4(*call); 172 event->ev.pos.vpos = IPC_GET_ARG5(*call); 173 break; 174 default: 175 return EIO; 176 } 177 178 return EOK; 179 } 180 181 bool console_get_event(console_ctrl_t *ctrl, cons_event_t *event) 157 182 { 158 183 if (ctrl->input_aid == 0) { 159 sysarg_t type; 160 sysarg_t key; 161 sysarg_t mods; 162 sysarg_t c; 184 ipc_call_t result; 163 185 164 186 async_exch_t *exch = async_exchange_begin(ctrl->input_sess); 165 int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);187 aid_t aid = async_send_0(exch, CONSOLE_GET_EVENT, &result); 166 188 async_exchange_end(exch); 189 190 sysarg_t rc; 191 async_wait_for(aid, &rc); 167 192 168 193 if (rc != EOK) { … … 171 196 } 172 197 173 event->type = type; 174 event->key = key; 175 event->mods = mods; 176 event->c = c; 198 rc = console_ev_decode(&result, event); 199 if (rc != EOK) { 200 errno = rc; 201 return false; 202 } 177 203 } else { 178 204 sysarg_t retval; … … 186 212 } 187 213 188 event->type = IPC_GET_ARG1(ctrl->input_call); 189 event->key = IPC_GET_ARG2(ctrl->input_call); 190 event->mods = IPC_GET_ARG3(ctrl->input_call); 191 event->c = IPC_GET_ARG4(ctrl->input_call); 214 int rc = console_ev_decode(&ctrl->input_call, event); 215 if (rc != EOK) { 216 errno = rc; 217 return false; 218 } 192 219 } 193 220 … … 195 222 } 196 223 197 bool console_get_ kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,224 bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event, 198 225 suseconds_t *timeout) 199 226 { … … 223 250 } 224 251 225 event->type = IPC_GET_ARG1(ctrl->input_call); 226 event->key = IPC_GET_ARG2(ctrl->input_call); 227 event->mods = IPC_GET_ARG3(ctrl->input_call); 228 event->c = IPC_GET_ARG4(ctrl->input_call); 252 rc = console_ev_decode(&ctrl->input_call, event); 253 if (rc != EOK) { 254 errno = rc; 255 return false; 256 } 229 257 230 258 /* Update timeout */ -
uspace/lib/c/include/io/con_srv.h
r06b0211b raa2b32c 41 41 #include <io/color.h> 42 42 #include <io/concaps.h> 43 #include <io/ kbd_event.h>43 #include <io/cons_event.h> 44 44 #include <io/pixel.h> 45 45 #include <io/style.h> … … 82 82 void (*set_rgb_color)(con_srv_t *, pixel_t, pixel_t); 83 83 void (*set_cursor_visibility)(con_srv_t *, bool); 84 int (*get_event)(con_srv_t *, kbd_event_t *);84 int (*get_event)(con_srv_t *, cons_event_t *); 85 85 } con_ops_t; 86 86 -
uspace/lib/c/include/io/console.h
r06b0211b raa2b32c 39 39 #include <io/concaps.h> 40 40 #include <io/kbd_event.h> 41 #include <io/cons_event.h> 41 42 #include <io/keycode.h> 42 43 #include <async.h> … … 82 83 extern void console_cursor_visibility(console_ctrl_t *, bool); 83 84 extern int console_get_color_cap(console_ctrl_t *, sysarg_t *); 84 extern bool console_get_ kbd_event(console_ctrl_t *, kbd_event_t *);85 extern bool console_get_ kbd_event_timeout(console_ctrl_t *, kbd_event_t *,85 extern bool console_get_event(console_ctrl_t *, cons_event_t *); 86 extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *, 86 87 suseconds_t *); 87 88 -
uspace/lib/c/include/io/pos_event.h
r06b0211b raa2b32c 1 1 /* 2 * Copyright (c) 2008 Martin Decky 2 * Copyright (c) 2012 Petr Koupy 3 * Copyright (c) 2013 Jiri Svoboda 3 4 * All rights reserved. 4 5 * … … 27 28 */ 28 29 29 /** @addtogroup genarch30 /** @addtogroup libc 30 31 * @{ 31 32 */ … … 33 34 */ 34 35 35 #ifndef KERN_LOGO_196X66_H_36 #define KERN_LOGO_196X66_H_36 #ifndef LIBC_IO_POS_EVENT_H_ 37 #define LIBC_IO_POS_EVENT_H_ 37 38 38 #define LOGO_WIDTH 196 39 #define LOGO_HEIGHT 66 40 #define LOGO_COLOR 0xffffff 39 #include <sys/types.h> 41 40 42 #include <typedefs.h> 41 typedef enum { 42 POS_UPDATE, 43 POS_PRESS, 44 POS_RELEASE 45 } pos_event_type_t; 43 46 44 extern uint32_t fb_logo[LOGO_WIDTH * LOGO_HEIGHT]; 47 /** Positioning device event */ 48 typedef struct { 49 sysarg_t pos_id; 50 pos_event_type_t type; 51 sysarg_t btn_num; 52 sysarg_t hpos; 53 sysarg_t vpos; 54 } pos_event_t; 45 55 46 56 #endif -
uspace/lib/c/include/io/window.h
r06b0211b raa2b32c 40 40 #include <async.h> 41 41 #include <loc.h> 42 #include <io/console.h> 43 44 typedef enum { 45 POS_UPDATE, 46 POS_PRESS, 47 POS_RELEASE 48 } pos_event_type_t; 49 50 typedef struct { 51 sysarg_t pos_id; 52 pos_event_type_t type; 53 sysarg_t btn_num; 54 sysarg_t hpos; 55 sysarg_t vpos; 56 } pos_event_t; 42 #include <io/kbd_event.h> 43 #include <io/pos_event.h> 57 44 58 45 typedef struct { -
uspace/lib/clui/tinput.c
r06b0211b raa2b32c 45 45 #define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols)) 46 46 #define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols)) 47 #define LIN_POS(ti, col, row) ((col) + (row) * (ti)->con_cols) 47 48 48 49 /** Seek direction */ … … 383 384 } 384 385 386 static void tinput_seek_scrpos(tinput_t *ti, int col, int line, bool shift_held) 387 { 388 unsigned lpos; 389 tinput_pre_seek(ti, shift_held); 390 391 lpos = LIN_POS(ti, col, line); 392 393 if (lpos > ti->text_coord) 394 ti->pos = lpos - ti->text_coord; 395 else 396 ti->pos = 0; 397 if (ti->pos > ti->nc) 398 ti->pos = ti->nc; 399 400 tinput_post_seek(ti, shift_held); 401 } 402 385 403 static void tinput_seek_max(tinput_t *ti, seek_dir_t dir, bool shift_held) 386 404 { … … 787 805 } 788 806 807 /** Handle key press event. */ 808 static void tinput_key_press(tinput_t *ti, kbd_event_t *kev) 809 { 810 if (kev->key == KC_LSHIFT) 811 ti->lshift_held = true; 812 if (kev->key == KC_RSHIFT) 813 ti->rshift_held = true; 814 815 if (((kev->mods & KM_CTRL) != 0) && 816 ((kev->mods & (KM_ALT | KM_SHIFT)) == 0)) 817 tinput_key_ctrl(ti, kev); 818 819 if (((kev->mods & KM_SHIFT) != 0) && 820 ((kev->mods & (KM_CTRL | KM_ALT)) == 0)) 821 tinput_key_shift(ti, kev); 822 823 if (((kev->mods & KM_CTRL) != 0) && 824 ((kev->mods & KM_SHIFT) != 0) && 825 ((kev->mods & KM_ALT) == 0)) 826 tinput_key_ctrl_shift(ti, kev); 827 828 if ((kev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) 829 tinput_key_unmod(ti, kev); 830 831 if (kev->c >= ' ') { 832 tinput_sel_delete(ti); 833 tinput_insert_char(ti, kev->c); 834 } 835 } 836 837 /** Handle key release event. */ 838 static void tinput_key_release(tinput_t *ti, kbd_event_t *kev) 839 { 840 if (kev->key == KC_LSHIFT) 841 ti->lshift_held = false; 842 if (kev->key == KC_RSHIFT) 843 ti->rshift_held = false; 844 } 845 846 /** Position event */ 847 static void tinput_pos(tinput_t *ti, pos_event_t *ev) 848 { 849 if (ev->type == POS_PRESS) { 850 tinput_seek_scrpos(ti, ev->hpos, ev->vpos, 851 ti->lshift_held || ti->rshift_held); 852 } 853 } 854 789 855 /** Read in one line of input. 790 856 * … … 816 882 console_flush(ti->console); 817 883 818 kbd_event_t ev;819 if (!console_get_ kbd_event(ti->console, &ev))884 cons_event_t ev; 885 if (!console_get_event(ti->console, &ev)) 820 886 return EIO; 821 887 822 if (ev.type != KEY_PRESS) 823 continue; 824 825 if (((ev.mods & KM_CTRL) != 0) && 826 ((ev.mods & (KM_ALT | KM_SHIFT)) == 0)) 827 tinput_key_ctrl(ti, &ev); 828 829 if (((ev.mods & KM_SHIFT) != 0) && 830 ((ev.mods & (KM_CTRL | KM_ALT)) == 0)) 831 tinput_key_shift(ti, &ev); 832 833 if (((ev.mods & KM_CTRL) != 0) && 834 ((ev.mods & KM_SHIFT) != 0) && 835 ((ev.mods & KM_ALT) == 0)) 836 tinput_key_ctrl_shift(ti, &ev); 837 838 if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) 839 tinput_key_unmod(ti, &ev); 840 841 if (ev.c >= ' ') { 842 tinput_sel_delete(ti); 843 tinput_insert_char(ti, ev.c); 888 switch (ev.type) { 889 case CEV_KEY: 890 if (ev.ev.key.type == KEY_PRESS) 891 tinput_key_press(ti, &ev.ev.key); 892 else 893 tinput_key_release(ti, &ev.ev.key); 894 break; 895 case CEV_POS: 896 tinput_pos(ti, &ev.ev.pos); 897 break; 844 898 } 845 899 } -
uspace/lib/clui/tinput.h
r06b0211b raa2b32c 146 146 /** @c true if user requested to abort interactive loop */ 147 147 bool exit_clui; 148 149 /** @c true if left shift key is currently held */ 150 bool lshift_held; 151 152 /** @c true if right shift key is currently held */ 153 bool rshift_held; 148 154 } tinput_t; 149 155 -
uspace/lib/gui/Makefile
r06b0211b raa2b32c 35 35 SOURCES = \ 36 36 button.c \ 37 canvas.c \ 37 38 connection.c \ 38 39 grid.c \ -
uspace/lib/gui/grid.c
r06b0211b raa2b32c 1 1 /* 2 2 * Copyright (c) 2012 Petr Koupy 3 * Copyright (c) 2013 Martin Decky 3 4 * All rights reserved. 4 5 * … … 38 39 #include <malloc.h> 39 40 #include <surface.h> 40 41 41 #include "window.h" 42 42 #include "grid.h" 43 43 44 static void paint_internal(widget_t *w) 45 { 46 grid_t *grid = (grid_t *) w; 47 44 typedef struct { 45 sysarg_t min; 46 sysarg_t max; 47 sysarg_t val; 48 } constraints_t; 49 50 static void paint_internal(widget_t *widget) 51 { 52 grid_t *grid = (grid_t *) widget; 53 48 54 surface_t *surface = window_claim(grid->widget.window); 49 55 if (!surface) { 50 56 window_yield(grid->widget.window); 51 } 52 53 for (sysarg_t y = w->vpos; y < w->vpos + w->height; ++y) { 54 for (sysarg_t x = w->hpos; x < w->hpos + w->width; ++x) { 57 return; 58 } 59 60 // FIXME: Replace with (accelerated) rectangle fill 61 for (sysarg_t y = widget->vpos; y < widget->vpos + widget->height; y++) { 62 for (sysarg_t x = widget->hpos; x < widget->hpos + widget->width; x++) 55 63 surface_put_pixel(surface, x, y, grid->background); 56 } 57 } 58 64 } 65 59 66 window_yield(grid->widget.window); 60 67 } 61 68 62 static widget_t **widget_at(grid_t *grid, size_t row, size_t col)63 { 64 if ( row < grid->rows && col < grid->cols) {69 static grid_cell_t *grid_cell_at(grid_t *grid, size_t col, size_t row) 70 { 71 if ((col < grid->cols) && (row < grid->rows)) 65 72 return grid->layout + (row * grid->cols + col); 66 } else { 67 return NULL; 68 } 73 74 return NULL; 75 } 76 77 static grid_cell_t *grid_coords_at(grid_t *grid, sysarg_t hpos, sysarg_t vpos) 78 { 79 for (size_t c = 0; c < grid->cols; c++) { 80 for (size_t r = 0; r < grid->rows; r++) { 81 grid_cell_t *cell = grid_cell_at(grid, c, r); 82 if (cell) { 83 widget_t *widget = cell->widget; 84 85 if ((widget) && (hpos >= widget->hpos) && 86 (vpos >= widget->vpos) && 87 (hpos < widget->hpos + widget->width) && 88 (vpos < widget->vpos + widget->height)) 89 return cell; 90 } 91 } 92 } 93 94 return NULL; 69 95 } 70 96 … … 78 104 { 79 105 grid_t *grid = (grid_t *) widget; 80 106 81 107 deinit_grid(grid); 82 83 108 free(grid); 84 109 } … … 86 111 static void grid_reconfigure(widget_t *widget) 87 112 { 88 /* no-op */ 113 /* No-op */ 114 } 115 116 static void adjust_constraints(constraints_t *cons, size_t run, 117 sysarg_t dim_min, sysarg_t dim_max) 118 { 119 assert(run > 0); 120 121 sysarg_t dim_min_part = dim_min / run; 122 sysarg_t dim_min_rem = dim_min % run; 123 124 sysarg_t dim_max_part = dim_max / run; 125 sysarg_t dim_max_rem = dim_max % run; 126 127 for (size_t i = 0; i < run; i++) { 128 sysarg_t dim_min_cur = dim_min_part; 129 sysarg_t dim_max_cur = dim_max_part; 130 131 if (i == run - 1) { 132 dim_min_cur += dim_min_rem; 133 dim_max_cur += dim_max_rem; 134 } 135 136 /* 137 * We want the strongest constraint 138 * for the minimum. 139 */ 140 if (cons[i].min < dim_min_cur) 141 cons[i].min = dim_min_cur; 142 143 /* 144 * The comparison is correct, we want 145 * the weakest constraint for the 146 * maximum. 147 */ 148 if (cons[i].max < dim_max_cur) 149 cons[i].max = dim_max_cur; 150 } 151 } 152 153 static void solve_constraints(constraints_t *cons, size_t run, sysarg_t sum) 154 { 155 /* Initial solution */ 156 sysarg_t cur_sum = 0; 157 158 for (size_t i = 0; i < run; i++) { 159 cons[i].val = cons[i].min; 160 cur_sum += cons[i].val; 161 } 162 163 /* Iterative improvement */ 164 while (cur_sum < sum) { 165 sysarg_t delta = (sum - cur_sum) / run; 166 if (delta == 0) 167 break; 168 169 cur_sum = 0; 170 171 for (size_t i = 0; i < run; i++) { 172 if (cons[i].val + delta < cons[i].max) 173 cons[i].val += delta; 174 175 cur_sum += cons[i].val; 176 } 177 } 89 178 } 90 179 … … 93 182 { 94 183 grid_t *grid = (grid_t *) widget; 95 184 96 185 widget_modify(widget, hpos, vpos, width, height); 97 186 paint_internal(widget); 98 99 sysarg_t cell_width = width / grid->cols; 100 sysarg_t cell_height = height / grid->rows; 101 102 list_foreach(widget->children, link) { 103 widget_t *child = list_get_instance(link, widget_t, link); 104 105 sysarg_t widget_hpos = 0; 106 sysarg_t widget_vpos = 0; 107 sysarg_t widget_width = 0; 108 sysarg_t widget_height = 0; 109 110 size_t r = 0; 111 size_t c = 0; 112 for (r = 0; r < grid->rows; ++r) { 113 bool found = false; 114 for (c = 0; c < grid->cols; ++c) { 115 widget_t **cell = widget_at(grid, r, c); 116 if (cell && *cell == child) { 117 found = true; 118 break; 187 188 /* Compute column widths */ 189 constraints_t *widths = 190 (constraints_t *) calloc(grid->cols, sizeof(constraints_t)); 191 if (widths) { 192 /* Constrain widths */ 193 for (size_t c = 0; c < grid->cols; c++) { 194 widths[c].min = 0; 195 196 for (size_t r = 0; r < grid->rows; r++) { 197 grid_cell_t *cell = grid_cell_at(grid, c, r); 198 if (!cell) 199 continue; 200 201 widget_t *widget = cell->widget; 202 if (widget) 203 adjust_constraints(&widths[c], cell->cols, 204 widget->width_min, widget->width_max); 205 } 206 } 207 208 solve_constraints(widths, grid->cols, width); 209 } 210 211 /* Compute row heights */ 212 constraints_t *heights = 213 (constraints_t *) calloc(grid->rows, sizeof(constraints_t)); 214 if (heights) { 215 /* Constrain heights */ 216 for (size_t r = 0; r < grid->rows; r++) { 217 heights[r].min = 0; 218 219 for (size_t c = 0; c < grid->cols; c++) { 220 grid_cell_t *cell = grid_cell_at(grid, c, r); 221 if (!cell) 222 continue; 223 224 widget_t *widget = cell->widget; 225 if (widget) { 226 adjust_constraints(&heights[r], cell->rows, 227 widget->height_min, widget->height_max); 119 228 } 120 229 } 121 if (found) { 122 break; 230 } 231 232 solve_constraints(heights, grid->rows, height); 233 } 234 235 /* Rearrange widgets */ 236 if ((widths) && (heights)) { 237 sysarg_t cur_vpos = vpos; 238 239 for (size_t r = 0; r < grid->rows; r++) { 240 sysarg_t cur_hpos = hpos; 241 242 for (size_t c = 0; c < grid->cols; c++) { 243 grid_cell_t *cell = grid_cell_at(grid, c, r); 244 if (!cell) 245 continue; 246 247 widget_t *widget = cell->widget; 248 if (widget) { 249 sysarg_t cur_width = 0; 250 sysarg_t cur_height = 0; 251 252 for (size_t cd = 0; cd < cell->cols; cd++) 253 cur_width += widths[c + cd].val; 254 255 for (size_t rd = 0; rd < cell->rows; rd++) 256 cur_height += heights[r + rd].val; 257 258 if ((cur_width > 0) && (cur_height > 0)) { 259 sysarg_t wwidth = cur_width; 260 sysarg_t wheight = cur_height; 261 262 /* 263 * Make sure the widget is respects its 264 * maximal constrains. 265 */ 266 267 if ((widget->width_max > 0) && 268 (wwidth > widget->width_max)) 269 wwidth = widget->width_max; 270 271 if ((widget->height_max > 0) && 272 (wheight > widget->height_max)) 273 wheight = widget->height_max; 274 275 widget->rearrange(widget, cur_hpos, cur_vpos, 276 wwidth, wheight); 277 } 278 279 280 } 281 282 cur_hpos += widths[c].val; 123 283 } 124 } 125 126 widget_hpos = cell_width * c + hpos; 127 widget_vpos = cell_height * r + vpos; 128 129 for (size_t _c = c; _c < grid->cols; ++_c) { 130 widget_t **cell = widget_at(grid, r, _c); 131 if (cell && *cell == child) { 132 widget_width += cell_width; 133 } else { 134 break; 135 } 136 } 137 138 for (size_t _r = r; _r < grid->rows; ++_r) { 139 widget_t **cell = widget_at(grid, _r, c); 140 if (cell && *cell == child) { 141 widget_height += cell_height; 142 } else { 143 break; 144 } 145 } 146 147 if (widget_width > 0 && widget_height > 0) { 148 child->rearrange(child, 149 widget_hpos, widget_vpos, widget_width, widget_height); 150 } 151 } 284 285 cur_vpos += heights[r].val; 286 } 287 } 288 289 if (widths) 290 free(widths); 291 292 if (heights) 293 free(heights); 152 294 } 153 295 … … 155 297 { 156 298 paint_internal(widget); 299 157 300 list_foreach(widget->children, link) { 158 301 widget_t *child = list_get_instance(link, widget_t, link); 159 302 child->repaint(child); 160 303 } 304 161 305 window_damage(widget->window); 162 306 } … … 164 308 static void grid_handle_keyboard_event(widget_t *widget, kbd_event_t event) 165 309 { 166 /* no-op */310 /* No-op */ 167 311 } 168 312 … … 170 314 { 171 315 grid_t *grid = (grid_t *) widget; 172 173 if ((widget->height / grid->rows) == 0) { 174 return; 175 } 176 if ((widget->width / grid->cols) == 0) { 177 return; 178 } 179 180 sysarg_t row = (event.vpos - widget->vpos) / (widget->height / grid->rows); 181 sysarg_t col = (event.hpos - widget->hpos) / (widget->width / grid->cols); 182 183 widget_t **cell = widget_at(grid, row, col); 184 if (cell && *cell) { 185 (*cell)->handle_position_event(*cell, event); 186 } 187 } 188 189 static void grid_add(grid_t *grid, widget_t *widget, 190 size_t row, size_t col, size_t rows, size_t cols) 191 { 192 assert(row + rows <= grid->rows); 193 assert(col + cols <= grid->cols); 194 316 317 grid_cell_t *cell = grid_coords_at(grid, event.hpos, event.vpos); 318 if ((cell) && (cell->widget)) 319 cell->widget->handle_position_event(cell->widget, event); 320 } 321 322 static bool grid_add(struct grid *grid, widget_t *widget, size_t col, 323 size_t row, size_t cols, size_t rows) 324 { 325 if ((cols == 0) || (rows == 0) || (col + cols > grid->cols) || 326 (row + rows > grid->rows)) 327 return false; 328 329 grid_cell_t *cell = grid_cell_at(grid, col, row); 330 if (!cell) 331 return false; 332 333 /* 334 * Check whether the cell is not occupied by an 335 * extension of a different cell. 336 */ 337 if ((!cell->widget) && (cell->cols > 0) && (cell->rows > 0)) 338 return false; 339 195 340 widget->parent = (widget_t *) grid; 341 196 342 list_append(&widget->link, &grid->widget.children); 197 343 widget->window = grid->widget.window; 198 199 for (size_t r = row; r < row + rows; ++r) { 200 for (size_t c = col; c < col + cols; ++c) { 201 widget_t **cell = widget_at(grid, r, c); 202 if (cell) { 203 *cell = widget; 344 345 /* Mark cells in layout */ 346 for (size_t r = row; r < row + rows; r++) { 347 for (size_t c = col; c < col + cols; c++) { 348 if ((r == row) && (c == col)) { 349 cell->widget = widget; 350 cell->cols = cols; 351 cell->rows = rows; 352 } else { 353 grid_cell_t *extension = grid_cell_at(grid, c, r); 354 if (extension) { 355 extension->widget = NULL; 356 extension->cols = 1; 357 extension->rows = 1; 358 } 204 359 } 205 360 } 206 361 } 207 } 208 209 bool init_grid(grid_t *grid, 210 widget_t *parent, size_t rows, size_t cols, pixel_t background) 211 { 212 assert(rows > 0); 213 assert(cols > 0); 214 215 widget_t **layout = (widget_t **) malloc(rows * cols * sizeof(widget_t *)); 216 if (!layout) { 362 363 return true; 364 } 365 366 bool init_grid(grid_t *grid, widget_t *parent, size_t cols, size_t rows, 367 pixel_t background) 368 { 369 if ((cols == 0) || (rows == 0)) 217 370 return false; 218 } 219 memset(layout, 0, rows * cols * sizeof(widget_t *)); 220 371 372 grid->layout = 373 (grid_cell_t *) calloc(cols * rows, sizeof(grid_cell_t)); 374 if (!grid->layout) 375 return false; 376 377 memset(grid->layout, 0, cols * rows * sizeof(grid_cell_t)); 378 221 379 widget_init(&grid->widget, parent); 222 380 223 381 grid->widget.destroy = grid_destroy; 224 382 grid->widget.reconfigure = grid_reconfigure; … … 227 385 grid->widget.handle_keyboard_event = grid_handle_keyboard_event; 228 386 grid->widget.handle_position_event = grid_handle_position_event; 229 387 230 388 grid->add = grid_add; 231 389 grid->background = background; 390 grid->cols = cols; 232 391 grid->rows = rows; 233 grid->cols = cols; 234 grid->layout = layout; 235 392 236 393 return true; 237 394 } 238 395 239 grid_t *create_grid(widget_t *parent, size_t rows, size_t cols, pixel_t background)396 grid_t *create_grid(widget_t *parent, size_t cols, size_t rows, pixel_t background) 240 397 { 241 398 grid_t *grid = (grid_t *) malloc(sizeof(grid_t)); 242 if (!grid) {399 if (!grid) 243 400 return NULL; 244 } 245 246 if (init_grid(grid, parent, rows, cols, background)) { 401 402 if (init_grid(grid, parent, cols, rows, background)) 247 403 return grid; 248 } else { 249 free(grid); 250 return NULL; 251 } 404 405 free(grid); 406 return NULL; 252 407 } 253 408 -
uspace/lib/gui/grid.h
r06b0211b raa2b32c 39 39 #include <sys/types.h> 40 40 #include <io/pixel.h> 41 42 41 #include "widget.h" 43 42 44 struct grid; 45 typedef struct grid grid_t; 43 typedef struct { 44 widget_t *widget; 45 size_t cols; 46 size_t rows; 47 } grid_cell_t; 46 48 47 49 typedef struct grid { 48 50 widget_t widget; 49 51 pixel_t background; 52 size_t cols; 50 53 size_t rows; 51 size_t cols; 52 widget_t **layout; 53 void (*add)(grid_t *, widget_t *, size_t, size_t, size_t, size_t); 54 grid_cell_t *layout; 55 bool (*add)(struct grid *, widget_t *, size_t, size_t, size_t, size_t); 54 56 } grid_t; 55 57 -
uspace/lib/gui/terminal.c
r06b0211b raa2b32c 77 77 static void term_set_rgb_color(con_srv_t *, pixel_t, pixel_t); 78 78 static void term_set_cursor_visibility(con_srv_t *, bool); 79 static int term_get_event(con_srv_t *, kbd_event_t *);79 static int term_get_event(con_srv_t *, cons_event_t *); 80 80 81 81 static con_ops_t con_ops = { … … 420 420 if (pos < size) { 421 421 link_t *link = prodcons_consume(&term->input_pc); 422 kbd_event_t *event = list_get_instance(link, kbd_event_t, link);422 cons_event_t *event = list_get_instance(link, cons_event_t, link); 423 423 424 424 /* Accept key presses of printable chars only. */ 425 if ((event->type == KEY_PRESS) && (event->c != 0)) { 425 if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS && 426 event->ev.key.c != 0) { 426 427 wchar_t tmp[2] = { 427 event-> c,428 event->ev.key.c, 428 429 0 429 430 }; … … 579 580 } 580 581 581 static int term_get_event(con_srv_t *srv, kbd_event_t *event)582 static int term_get_event(con_srv_t *srv, cons_event_t *event) 582 583 { 583 584 terminal_t *term = srv_to_terminal(srv); 584 585 link_t *link = prodcons_consume(&term->input_pc); 585 kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);586 587 *event = * kevent;588 free( kevent);586 cons_event_t *ev = list_get_instance(link, cons_event_t, link); 587 588 *event = *ev; 589 free(ev); 589 590 return EOK; 590 591 } … … 634 635 } 635 636 637 static void terminal_queue_cons_event(terminal_t *term, cons_event_t *ev) 638 { 639 /* Got key press/release event */ 640 cons_event_t *event = 641 (cons_event_t *) malloc(sizeof(cons_event_t)); 642 if (event == NULL) 643 return; 644 645 *event = *ev; 646 link_initialize(&event->link); 647 648 prodcons_produce(&term->input_pc, &event->link); 649 } 650 651 /* Got key press/release event */ 636 652 static void terminal_handle_keyboard_event(widget_t *widget, 637 653 kbd_event_t kbd_event) 638 654 { 639 655 terminal_t *term = (terminal_t *) widget; 640 641 /* Got key press/release event */ 642 kbd_event_t *event = 643 (kbd_event_t *) malloc(sizeof(kbd_event_t)); 644 if (event == NULL) 645 return; 646 647 link_initialize(&event->link); 648 event->type = kbd_event.type; 649 event->key = kbd_event.key; 650 event->mods = kbd_event.mods; 651 event->c = kbd_event.c; 652 653 prodcons_produce(&term->input_pc, &event->link); 654 } 655 656 static void terminal_handle_position_event(widget_t *widget, pos_event_t event) 657 { 658 /* 659 * Mouse events are ignored so far. 660 * There is no consumer for it. 661 */ 656 cons_event_t event; 657 658 event.type = CEV_KEY; 659 event.ev.key = kbd_event; 660 661 terminal_queue_cons_event(term, &event); 662 } 663 664 static void terminal_handle_position_event(widget_t *widget, pos_event_t pos_event) 665 { 666 cons_event_t event; 667 terminal_t *term = (terminal_t *) widget; 668 sysarg_t sx = term->widget.hpos; 669 sysarg_t sy = term->widget.vpos; 670 671 if (pos_event.type == POS_PRESS) { 672 event.type = CEV_POS; 673 event.ev.pos.type = pos_event.type; 674 event.ev.pos.pos_id = pos_event.pos_id; 675 event.ev.pos.btn_num = pos_event.btn_num; 676 677 event.ev.pos.hpos = (pos_event.hpos - sx) / FONT_WIDTH; 678 event.ev.pos.vpos = (pos_event.vpos - sy) / FONT_SCANLINES; 679 terminal_queue_cons_event(term, &event); 680 } 662 681 } 663 682 -
uspace/lib/gui/window.c
r06b0211b raa2b32c 424 424 425 425 while (!list_empty(&win->events.list)) { 426 list_remove(list_first(&win->events.list)); 426 window_event_t *event = (window_event_t *) list_first(&win->events.list); 427 list_remove(&event->link); 428 free(event); 427 429 } 428 430
Note:
See TracChangeset
for help on using the changeset viewer.