Changes in / [aa2b32c:06b0211b] in mainline


Ignore:
Files:
3 added
5 deleted
39 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/Makefile.inc

    raa2b32c r06b0211b  
    6666        GENARCH_SOURCES += \
    6767                genarch/src/fb/font-8x16.c \
     68                genarch/src/fb/logo-196x66.c \
    6869                genarch/src/fb/fb.c \
    6970                genarch/src/fb/bfb.c

  • kernel/genarch/src/fb/fb.c

    raa2b32c r06b0211b  
    3535
    3636#include <genarch/fb/font-8x16.h>
     37#include <genarch/fb/logo-196x66.h>
    3738#include <genarch/fb/fb.h>
    3839#include <console/chardev.h>
    … …  
    5253#include <byteorder.h>
    5354
    54 #define BG_COLOR     0x001620
    55 #define FG_COLOR     0xf3cf65
     55#define BG_COLOR     0x000080
     56#define FG_COLOR     0xffff00
    5657#define INV_COLOR    0xaaaaaa
    5758
    … …  
    9293        unsigned int yres;
    9394       
     95        unsigned int ylogo;
     96        unsigned int ytrim;
    9497        unsigned int rowtrim;
    9598       
    … …  
    210213}
    211214
     215/** Hide logo and refresh screen
     216 *
     217 */
     218static void logo_hide(fb_instance_t *instance)
     219{
     220        instance->ylogo = 0;
     221        instance->ytrim = instance->yres;
     222        instance->rowtrim = instance->rows;
     223       
     224        if ((!instance->parea.mapped) || (console_override))
     225                fb_redraw_internal(instance);
     226}
     227
    212228/** Draw character at given position
    213229 *
    … …  
    220236        unsigned int yd;
    221237       
     238        if (y >= instance->ytrim)
     239                logo_hide(instance);
     240       
    222241        if (!overlay)
    223242                instance->backbuf[BB_POS(instance, col, row)] = glyph;
    … …  
    225244        if ((!instance->parea.mapped) || (console_override)) {
    226245                for (yd = 0; yd < FONT_SCANLINES; yd++)
    227                         memcpy(&instance->addr[FB_POS(instance, x, y + yd)],
     246                        memcpy(&instance->addr[FB_POS(instance, x, y + yd + instance->ylogo)],
    228247                            &instance->glyphs[GLYPH_POS(instance, glyph, yd)],
    229248                            instance->glyphscanline);
    … …  
    237256static void screen_scroll(fb_instance_t *instance)
    238257{
     258        if (instance->ylogo > 0) {
     259                logo_hide(instance);
     260                return;
     261        }
     262       
    239263        if ((!instance->parea.mapped) || (console_override)) {
    240264                unsigned int row;
    … …  
    388412static void fb_redraw_internal(fb_instance_t *instance)
    389413{
     414        if (instance->ylogo > 0) {
     415                unsigned int y;
     416               
     417                for (y = 0; y < LOGO_HEIGHT; y++) {
     418                        unsigned int x;
     419                       
     420                        for (x = 0; x < instance->xres; x++)
     421                                instance->rgb_conv(&instance->addr[FB_POS(instance, x, y)],
     422                                    (x < LOGO_WIDTH) ?
     423                                    fb_logo[y * LOGO_WIDTH + x] :
     424                                    LOGO_COLOR);
     425                }
     426        }
     427       
    390428        unsigned int row;
    391429       
    392430        for (row = 0; row < instance->rowtrim; row++) {
    393                 unsigned int y = ROW2Y(row);
     431                unsigned int y = instance->ylogo + ROW2Y(row);
    394432                unsigned int yd;
    395433               
    … …  
    414452                    (instance->xres - COL2X(instance->cols)) * instance->pixelbytes;
    415453               
    416                 for (y = 0; y < instance->yres; y++)
     454                for (y = instance->ylogo; y < instance->yres; y++)
    417455                        memcpy(&instance->addr[FB_POS(instance, COL2X(instance->cols), y)],
    418456                            instance->bgscan, size);
    419457        }
    420458       
    421         if (ROW2Y(instance->rowtrim) < instance->yres) {
     459        if (ROW2Y(instance->rowtrim) + instance->ylogo < instance->yres) {
    422460                unsigned int y;
    423461               
    424                 for (y = ROW2Y(instance->rowtrim); y < instance->yres; y++)
     462                for (y = ROW2Y(instance->rowtrim) + instance->ylogo;
     463                    y < instance->yres; y++)
    425464                        memcpy(&instance->addr[FB_POS(instance, 0, y)],
    426465                            instance->bgscan, instance->bgscanbytes);
    … …  
    528567        instance->rows = Y2ROW(instance->yres);
    529568       
    530         instance->rowtrim = instance->rows;
     569        if (instance->yres > LOGO_HEIGHT) {
     570                instance->ylogo = LOGO_HEIGHT;
     571                instance->rowtrim = instance->rows - Y2ROW(instance->ylogo);
     572                if (instance->ylogo % FONT_SCANLINES > 0)
     573                        instance->rowtrim--;
     574                instance->ytrim = ROW2Y(instance->rowtrim);
     575        } else {
     576                instance->ylogo = 0;
     577                instance->ytrim = instance->yres;
     578                instance->rowtrim = instance->rows;
     579        }
    531580       
    532581        instance->glyphscanline = FONT_WIDTH * instance->pixelbytes;

  • uspace/app/bdsh/cmds/modules/cat/cat.c

    raa2b32c r06b0211b  
    117117static void waitkey()
    118118{
    119         cons_event_t ev;
    120         kbd_event_t *kev;
     119        kbd_event_t ev;
    121120       
    122121        while (true) {
    123                 if (!console_get_event(console, &ev)) {
     122                if (!console_get_kbd_event(console, &ev)) {
    124123                        return;
    125124                }
    126                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
    127                         kev = &ev.ev.key;
    128                        
    129                         if (kev->key == KC_ESCAPE || kev->key == KC_Q) {
     125                if (ev.type == KEY_PRESS) {
     126                        if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
    130127                                should_quit = true;
    131128                                return;
    132129                        }
    133                         if (kev->key == KC_C) {
     130                        if (ev.key == KC_C) {
    134131                                paging_enabled = false;
    135132                                return;
    136133                        }
    137                         if (kev->key == KC_ENTER || kev->key == KC_SPACE ||
    138                             kev->key == KC_PAGE_DOWN) {
     134                        if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
     135                            ev.key == KC_PAGE_DOWN) {
    139136                                return;
    140137                        }

  • uspace/app/bdsh/cmds/modules/cp/cp.c

    raa2b32c r06b0211b  
    152152
    153153        while (true) {
    154                 cons_event_t ev;
     154                kbd_event_t ev;
    155155                console_flush(con);
    156                 console_get_event(con, &ev);
    157                 if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS ||
    158                     (ev.ev.key.mods & (KM_CTRL | KM_ALT)) != 0) {
     156                console_get_kbd_event(con, &ev);
     157                if ((ev.type != KEY_PRESS)
     158                    || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
    159159                        continue;
    160160                }
    161161
    162                 switch(ev.ev.key.key) {
     162                switch(ev.key) {
    163163                case KC_Y:
    164164                        printf("y\n");

  • uspace/app/edit/edit.c

    raa2b32c r06b0211b  
    8080        tag_t sel_start;
    8181
    82         /** Active keyboard modifiers */
    83         keymod_t keymod;
    84 
    8582        /**
    8683         * Ideal column where the caret should try to get. This is used
    … …  
    122119static void cursor_setvis(bool visible);
    123120
    124 static void key_handle_press(kbd_event_t *ev);
    125121static void key_handle_unmod(kbd_event_t const *ev);
    126122static void key_handle_ctrl(kbd_event_t const *ev);
    … …  
    128124static void key_handle_shift_ctrl(kbd_event_t const *ev);
    129125static void key_handle_movement(unsigned int key, bool shift);
    130 
    131 static void pos_handle(pos_event_t *ev);
    132126
    133127static int file_save(char const *fname);
    … …  
    188182int main(int argc, char *argv[])
    189183{
    190         cons_event_t ev;
     184        kbd_event_t ev;
    191185        bool new_file;
    192186        int rc;
    … …  
    251245
    252246        while (!done) {
    253                 console_get_event(con, &ev);
     247                console_get_kbd_event(con, &ev);
    254248                pane.rflags = 0;
    255249
    256                 switch (ev.type) {
    257                 case CEV_KEY:
    258                         pane.keymod = ev.ev.key.mods;
    259                         if (ev.ev.key.type == KEY_PRESS)
    260                                 key_handle_press(&ev.ev.key);
    261                         break;
    262                 case CEV_POS:
    263                         pos_handle(&ev.ev.pos);
    264                         break;
     250                if (ev.type == KEY_PRESS) {
     251                        /* Handle key press. */
     252                        if (((ev.mods & KM_ALT) == 0) &&
     253                            ((ev.mods & KM_SHIFT) == 0) &&
     254                             (ev.mods & KM_CTRL) != 0) {
     255                                key_handle_ctrl(&ev);
     256                        } else if (((ev.mods & KM_ALT) == 0) &&
     257                            ((ev.mods & KM_CTRL) == 0) &&
     258                             (ev.mods & KM_SHIFT) != 0) {
     259                                key_handle_shift(&ev);
     260                        } else if (((ev.mods & KM_ALT) == 0) &&
     261                            ((ev.mods & KM_CTRL) != 0) &&
     262                             (ev.mods & KM_SHIFT) != 0) {
     263                                key_handle_shift_ctrl(&ev);
     264                        } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
     265                                key_handle_unmod(&ev);
     266                        }
    265267                }
    266268
    … …  
    284286
    285287        return 0;
    286 }
    287 
    288 /* Handle key press. */
    289 static void key_handle_press(kbd_event_t *ev)
    290 {
    291         if (((ev->mods & KM_ALT) == 0) &&
    292             ((ev->mods & KM_SHIFT) == 0) &&
    293              (ev->mods & KM_CTRL) != 0) {
    294                 key_handle_ctrl(ev);
    295         } else if (((ev->mods & KM_ALT) == 0) &&
    296             ((ev->mods & KM_CTRL) == 0) &&
    297              (ev->mods & KM_SHIFT) != 0) {
    298                 key_handle_shift(ev);
    299         } else if (((ev->mods & KM_ALT) == 0) &&
    300             ((ev->mods & KM_CTRL) != 0) &&
    301              (ev->mods & KM_SHIFT) != 0) {
    302                 key_handle_shift_ctrl(ev);
    303         } else if ((ev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
    304                 key_handle_unmod(ev);
    305         }
    306288}
    307289
    … …  
    480462}
    481463
    482 static void pos_handle(pos_event_t *ev)
    483 {
    484         coord_t bc;
    485         spt_t pt;
    486         bool select;
    487 
    488         if (ev->type == POS_PRESS && ev->vpos < (unsigned)pane.rows) {
    489                 bc.row = pane.sh_row + ev->vpos;
    490                 bc.column = pane.sh_column + ev->hpos;
    491                 sheet_get_cell_pt(doc.sh, &bc, dir_before, &pt);
    492 
    493                 select = (pane.keymod & KM_SHIFT) != 0;
    494 
    495                 caret_move(pt, select, true);
    496         }
    497 }
    498 
    499464/** Move caret while preserving or resetting selection. */
    500465static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
    … …  
    627592static char *prompt(char const *prompt, char const *init_value)
    628593{
    629         cons_event_t ev;
    630         kbd_event_t *kev;
     594        kbd_event_t ev;
    631595        char *str;
    632596        wchar_t buffer[INFNAME_MAX_LEN + 1];
    … …  
    648612
    649613        while (!done) {
    650                 console_get_event(con, &ev);
    651 
    652                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
    653                         kev = &ev.ev.key;
    654 
     614                console_get_kbd_event(con, &ev);
     615
     616                if (ev.type == KEY_PRESS) {
    655617                        /* Handle key press. */
    656                         if (((kev->mods & KM_ALT) == 0) &&
    657                              (kev->mods & KM_CTRL) != 0) {
     618                        if (((ev.mods & KM_ALT) == 0) &&
     619                             (ev.mods & KM_CTRL) != 0) {
    658620                                ;
    659                         } else if ((kev->mods & (KM_CTRL | KM_ALT)) == 0) {
    660                                 switch (kev->key) {
     621                        } else if ((ev.mods & (KM_CTRL | KM_ALT)) == 0) {
     622                                switch (ev.key) {
    661623                                case KC_ESCAPE:
    662624                                        return NULL;
    … …  
    672634                                        break;
    673635                                default:
    674                                         if (kev->c >= 32 && nc < max_len) {
    675                                                 putchar(kev->c);
     636                                        if (ev.c >= 32 && nc < max_len) {
     637                                                putchar(ev.c);
    676638                                                console_flush(con);
    677                                                 buffer[nc++] = kev->c;
     639                                                buffer[nc++] = ev.c;
    678640                                        }
    679641                                        break;

  • uspace/app/mkbd/main.c

    raa2b32c r06b0211b  
    178178
    179179        while (1) {
    180                 cons_event_t ev;
    181                 bool ok = console_get_event(con, &ev);
     180                kbd_event_t ev;
     181                bool ok = console_get_kbd_event(con, &ev);
    182182                if (!ok) {
    183183                        printf("Connection with console broken: %s.\n",
    … …  
    186186                }
    187187
    188                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
    189                     ev.ev.key.key == KC_ESCAPE) {
     188                if (ev.key == KC_ESCAPE) {
    190189                        break;
    191190                }

  • uspace/app/msim/arch_helenos/input.c

    raa2b32c r06b0211b  
    9191bool stdin_poll(char *key)
    9292{
    93         cons_event_t ev;
     93        kbd_event_t ev;
    9494        suseconds_t timeout = 0;
    9595        errno = EOK;
    9696        console_flush(input_prompt->console);
    97         bool has_input = console_get_event_timeout(input_prompt->console, &ev, &timeout);
     97        bool has_input = console_get_kbd_event_timeout(input_prompt->console, &ev, &timeout);
    9898        if (!has_input) {
    9999                return false;
    100100        }
    101101
    102         if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS)
     102        if (ev.type != KEY_PRESS)
    103103                return false;
    104104
    105         *key = ev.ev.key.c;
     105        *key = ev.c;
    106106
    107107        return true;

  • uspace/app/nterm/nterm.c

    raa2b32c r06b0211b  
    109109int main(int argc, char *argv[])
    110110{
    111         cons_event_t ev;
     111        kbd_event_t ev;
    112112        int rc;
    113113
    … …  
    129129        done = false;
    130130        while (!done) {
    131                 console_get_event(con, &ev);
    132                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS)
    133                         key_handle(&ev.ev.key);
     131                console_get_kbd_event(con, &ev);
     132                if (ev.type == KEY_PRESS)
     133                        key_handle(&ev);
    134134        }
    135135

  • uspace/app/ping/ping.c

    raa2b32c r06b0211b  
    188188{
    189189        console_ctrl_t *con;
    190         cons_event_t ev;
     190        kbd_event_t ev;
    191191
    192192        con = console_init(stdin, stdout);
    … …  
    194194
    195195        while (true) {
    196                 if (!console_get_event(con, &ev))
     196                if (!console_get_kbd_event(con, &ev))
    197197                        break;
    198198
    199                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
    200                     (ev.ev.key.mods & (KM_ALT | KM_SHIFT)) ==
    201                     0 && (ev.ev.key.mods & KM_CTRL) != 0) {
     199                if (ev.type == KEY_PRESS && (ev.mods & (KM_ALT | KM_SHIFT)) ==
     200                    0 && (ev.mods & KM_CTRL) != 0) {
    202201                        /* Ctrl+key */
    203                         if (ev.ev.key.key == KC_Q) {
     202                        if (ev.key == KC_Q) {
    204203                                ping_signal_done();
    205204                                return 0;

  • uspace/app/taskdump/symtab.c

    raa2b32c r06b0211b  
    267267                        continue;
    268268
    269                 if (saddr <= addr && (best_name == NULL || saddr > best_addr)) {
     269                if (best_name == NULL || (saddr <= addr && saddr > best_addr)) {
    270270                        best_name = sname;
    271271                        best_addr = saddr;

  • uspace/app/tester/ipc/starve.c

    raa2b32c r06b0211b  
    6262                        break;
    6363               
    64                 cons_event_t ev;
     64                kbd_event_t ev;
    6565                suseconds_t timeout = 0;
    66                 bool has_event = console_get_event_timeout(console, &ev, &timeout);
    67                 if (has_event && ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
    68                         TPRINTF("Key %d pressed, terminating.\n", ev.ev.key.key);
     66                bool has_event = console_get_kbd_event_timeout(console, &ev, &timeout);
     67                if (has_event && (ev.type == KEY_PRESS)) {
     68                        TPRINTF("Key %d pressed, terminating.\n", ev.key);
    6969                        break;
    7070                }

  • uspace/app/tetris/scores.c

    raa2b32c r06b0211b  
    125125        int j;
    126126        size_t off;
    127         cons_event_t ev;
    128         kbd_event_t *kev;
     127        kbd_event_t ev;
    129128       
    130129        clear_screen();
    … …  
    142141        while (1) {
    143142                console_flush(console);
    144                 if (!console_get_event(console, &ev))
     143                if (!console_get_kbd_event(console, &ev))
    145144                        exit(1);
    146145               
    147                 if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE)
     146                if (ev.type == KEY_RELEASE)
    148147                        continue;
    149148               
    150                 kev = &ev.ev.key;
    151                
    152                 if (kev->key == KC_ENTER || kev->key == KC_NENTER)
     149                if (ev.key == KC_ENTER || ev.key == KC_NENTER)
    153150                        break;
    154151               
    155                 if (kev->key == KC_BACKSPACE) {
     152                if (ev.key == KC_BACKSPACE) {
    156153                        if (i > 0) {
    157154                                wchar_t uc;
    … …  
    169166                                scores[NUMSPOTS - 1].hs_name[off] = '\0';
    170167                        }
    171                 } else if (kev->c != '\0') {
     168                } else if (ev.c != '\0') {
    172169                        if (i < (MAXLOGNAME - 1)) {
    173                                 if (chr_encode(kev->c, scores[NUMSPOTS - 1].hs_name,
     170                                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
    174171                                    &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
    175172                                        ++i;

  • uspace/app/tetris/screen.c

    raa2b32c r06b0211b  
    344344       
    345345        while (timeout > 0) {
    346                 cons_event_t event;
    347                
    348                 if (!console_get_event_timeout(console, &event, &timeout))
     346                kbd_event_t event;
     347               
     348                if (!console_get_kbd_event_timeout(console, &event, &timeout))
    349349                        break;
    350350        }
    … …  
    376376       
    377377        while (c == 0) {
    378                 cons_event_t event;
    379                
    380                 if (!console_get_event_timeout(console, &event, &timeleft)) {
     378                kbd_event_t event;
     379               
     380                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
    381381                        timeleft = 0;
    382382                        return -1;
    383383                }
    384384               
    385                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
    386                         c = event.ev.key.c;
     385                if (event.type == KEY_PRESS)
     386                        c = event.c;
    387387        }
    388388       
    … …  
    398398       
    399399        while (c == 0) {
    400                 cons_event_t event;
    401                
    402                 if (!console_get_event(console, &event))
     400                kbd_event_t event;
     401               
     402                if (!console_get_kbd_event(console, &event))
    403403                        return -1;
    404404               
    405                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
    406                         c = event.ev.key.c;
     405                if (event.type == KEY_PRESS)
     406                        c = event.c;
    407407        }
    408408       

  • uspace/app/top/screen.c

    raa2b32c r06b0211b  
    556556       
    557557        while (c == 0) {
    558                 cons_event_t event;
     558                kbd_event_t event;
    559559               
    560560                warning_timeleft -= timeleft;
    561                 if (!console_get_event_timeout(console, &event, &timeleft)) {
     561                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
    562562                        timeleft = 0;
    563563                        return -1;
    … …  
    565565                warning_timeleft += timeleft;
    566566               
    567                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
    568                         c = event.ev.key.c;
     567                if (event.type == KEY_PRESS)
     568                        c = event.c;
    569569        }
    570570       

  • uspace/app/trace/trace.c

    raa2b32c r06b0211b  
    565565static int cev_fibril(void *arg)
    566566{
    567         cons_event_t event;
    568 
    569567        (void) arg;
    570568       
    … …  
    577575                fibril_mutex_unlock(&state_lock);
    578576               
    579                 if (!console_get_event(console, &event))
     577                if (!console_get_kbd_event(console, &cev))
    580578                        return -1;
    581579               
    582                 if (event.type == CEV_KEY) {
    583                         fibril_mutex_lock(&state_lock);
    584                         cev = event.ev.key;
    585                         cev_valid = true;
    586                         fibril_condvar_broadcast(&state_cv);
    587                         fibril_mutex_unlock(&state_lock);
    588                 }
     580                fibril_mutex_lock(&state_lock);
     581                cev_valid = true;
     582                fibril_condvar_broadcast(&state_cv);
     583                fibril_mutex_unlock(&state_lock);
    589584        }
    590585}

  • uspace/app/vdemo/vdemo.c

    raa2b32c r06b0211b  
    141141                    lbl_action->cancel);
    142142
    143                 grid->add(grid, &lbl_action->label.widget, 0, 0, 2, 1);
    144                 grid->add(grid, &btn_confirm->widget, 0, 1, 1, 1);
     143                grid->add(grid, &lbl_action->label.widget, 0, 0, 1, 2);
     144                grid->add(grid, &btn_confirm->widget, 1, 0, 1, 1);
    145145                grid->add(grid, &btn_cancel->widget, 1, 1, 1, 1);
    146                 window_resize(main_window, 200, 76);
     146                window_resize(main_window, 200, 70);
    147147
    148148                window_exec(main_window);

  • uspace/app/vlaunch/Makefile

    raa2b32c r06b0211b  
    3535
    3636SOURCES = \
    37         vlaunch.c \
    38         images.c
    39 
    40 IMAGES = \
    41         gfx/helenos.tga
    42 
    43 PRE_DEPEND = images.c images.h
    44 EXTRA_CLEAN = images.c images.h
     37        vlaunch.c
    4538
    4639include $(USPACE_PREFIX)/Makefile.common
    47 
    48 images.c images.h: $(IMAGES)
    49         $(ROOT_PATH)/tools/mkarray.py images COMPOSITOR_IMAGES $^

  • uspace/app/vlaunch/vlaunch.c

    raa2b32c r06b0211b  
    4646#include <button.h>
    4747#include <label.h>
    48 #include <canvas.h>
    4948
    50 #include <surface.h>
    51 #include <source.h>
    52 #include <drawctx.h>
    53 #include <codec/tga.h>
    54 
    55 #include "images.h"
    56 
    57 #define NAME  "vlaunch"
    58 
    59 #define LOGO_WIDTH   196
    60 #define LOGO_HEIGHT  66
     49#define NAME "vlaunch"
    6150
    6251static char *winreg = NULL;
    … …  
    10897        }
    10998       
    110         surface_t *logo = decode_tga((void *) helenos_tga, helenos_tga_size, 0);
    111         if (!logo) {
    112                 printf("Unable to decode logo.\n");
    113                 return 1;
    114         }
    115        
    11699        winreg = argv[1];
    117100        window_t *main_window = window_open(argv[1], true, true, "vlaunch", 0, 0);
    … …  
    121104        }
    122105       
    123         pixel_t grd_bg = PIXEL(255, 255, 255, 255);
     106        pixel_t grd_bg = PIXEL(255, 240, 240, 240);
    124107        pixel_t btn_bg = PIXEL(255, 0, 0, 0);
    125108        pixel_t btn_fg = PIXEL(255, 240, 240, 240);
    126         pixel_t lbl_bg = PIXEL(255, 255, 255, 255);
     109        pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
    127110        pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
    128111       
    129         canvas_t *logo_canvas = create_canvas(NULL, LOGO_WIDTH, LOGO_HEIGHT,
    130             logo);
    131112        label_t *lbl_caption = create_label(NULL, "Launch application:", 16,
    132113            lbl_bg, lbl_fg);
    … …  
    137118        button_t *btn_vlaunch = create_button(NULL, "vlaunch", 16, btn_bg,
    138119            btn_fg);
    139         grid_t *grid = create_grid(window_root(main_window), 1, 5, grd_bg);
     120        grid_t *grid = create_grid(window_root(main_window), 4, 1, grd_bg);
    140121       
    141         if ((!logo_canvas) || (!lbl_caption) || (!btn_vterm) ||
    142             (!btn_vdemo) || (!btn_vlaunch) || (!grid)) {
     122        if ((!lbl_caption) || (!btn_vterm) || (!btn_vdemo) ||
     123            (!btn_vlaunch) || (!grid)) {
    143124                window_close(main_window);
    144125                printf("Cannot create widgets.\n");
    … …  
    150131        sig_connect(&btn_vlaunch->clicked, NULL, on_vlaunch);
    151132       
    152         grid->add(grid, &logo_canvas->widget, 0, 0, 1, 1);
    153         grid->add(grid, &lbl_caption->widget, 0, 1, 1, 1);
    154         grid->add(grid, &btn_vterm->widget, 0, 2, 1, 1);
    155         grid->add(grid, &btn_vdemo->widget, 0, 3, 1, 1);
    156         grid->add(grid, &btn_vlaunch->widget, 0, 4, 1, 1);
     133        grid->add(grid, &lbl_caption->widget, 0, 0, 1, 1);
     134        grid->add(grid, &btn_vterm->widget, 1, 0, 1, 1);
     135        grid->add(grid, &btn_vdemo->widget, 2, 0, 1, 1);
     136        grid->add(grid, &btn_vlaunch->widget, 3, 0, 1, 1);
    157137       
    158         window_resize(main_window, 210, 130 + LOGO_HEIGHT);
     138        window_resize(main_window, 180, 130);
    159139        window_exec(main_window);
    160        
    161140        task_retval(0);
    162141        async_manager();

  • uspace/dist/src/c/demos/tetris/scores.c

    raa2b32c r06b0211b  
    125125        int j;
    126126        size_t off;
    127         cons_event_t ev;
    128         kbd_event_t *kev;
     127        kbd_event_t ev;
    129128       
    130129        clear_screen();
    … …  
    142141        while (1) {
    143142                console_flush(console);
    144                 if (!console_get_event(console, &ev))
     143                if (!console_get_kbd_event(console, &ev))
    145144                        exit(1);
    146145               
    147                 if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE)
     146                if (ev.type == KEY_RELEASE)
    148147                        continue;
    149148               
    150                 kev = &ev.ev.key;
    151                
    152                 if (kev->key == KC_ENTER || kev->key == KC_NENTER)
     149                if (ev.key == KC_ENTER || ev.key == KC_NENTER)
    153150                        break;
    154151               
    155                 if (kev->key == KC_BACKSPACE) {
     152                if (ev.key == KC_BACKSPACE) {
    156153                        if (i > 0) {
    157154                                wchar_t uc;
    … …  
    169166                                scores[NUMSPOTS - 1].hs_name[off] = '\0';
    170167                        }
    171                 } else if (kev->c != '\0') {
     168                } else if (ev.c != '\0') {
    172169                        if (i < (MAXLOGNAME - 1)) {
    173                                 if (chr_encode(kev->c, scores[NUMSPOTS - 1].hs_name,
     170                                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
    174171                                    &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
    175172                                        ++i;

  • uspace/dist/src/c/demos/top/screen.c

    raa2b32c r06b0211b  
    553553       
    554554        while (c == 0) {
    555                 cons_event_t event;
    556                
    557                 if (!console_get_event_timeout(console, &event, &timeleft)) {
     555                kbd_event_t event;
     556               
     557                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
    558558                        timeleft = 0;
    559559                        return -1;
    560560                }
    561561               
    562                 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
    563                         c = event.ev.key.c;
     562                if (event.type == KEY_PRESS)
     563                        c = event.c;
    564564        }
    565565       

  • uspace/drv/char/ns8250/ns8250.c

    raa2b32c r06b0211b  
    160160        /** I/O registers **/
    161161        ns8250_regs_t *regs;
    162         /** Is there any client connected to the device? */
     162        /** Is there any client conntected to the device? */
    163163        bool client_connected;
    164164        /** The irq assigned to this device. */
    … …  
    168168        /** The i/o port used to access the serial ports registers. */
    169169        ioport8_t *port;
    170         /** The buffer for incoming data. */
     170        /** The buffer for incomming data. */
    171171        cyclic_buffer_t input_buffer;
    172172        /** The fibril mutex for synchronizing the access to the device. */
    … …  
    190190}
    191191
    192 /** Find out if there is some incoming data available on the serial port.
     192/** Find out if there is some incomming data available on the serial port.
    193193 *
    194194 * @param port          The base address of the serial port device's ports.

  • uspace/lib/c/generic/io/con_srv.c

    raa2b32c r06b0211b  
    3535 */
    3636#include <errno.h>
    37 #include <io/cons_event.h>
    3837#include <ipc/console.h>
    3938#include <stdlib.h>
    … …  
    4140
    4241#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 }
    6742
    6843static void con_read_srv(con_srv_t *srv, ipc_callid_t callid,
    … …  
    298273{
    299274        int rc;
    300         cons_event_t event;
    301         ipc_call_t result;
     275        kbd_event_t event;
    302276
    303277        if (srv->srvs->ops->get_event == NULL) {
    … …  
    307281
    308282        rc = srv->srvs->ops->get_event(srv, &event);
    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));
     283        async_answer_4(callid, rc, event.type, event.key, event.mods, event.c);
    322284}
    323285

  • uspace/lib/c/generic/io/console.c

    raa2b32c r06b0211b  
    154154}
    155155
    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)
     156bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
    182157{
    183158        if (ctrl->input_aid == 0) {
    184                 ipc_call_t result;
     159                sysarg_t type;
     160                sysarg_t key;
     161                sysarg_t mods;
     162                sysarg_t c;
    185163               
    186164                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
    187                 aid_t aid = async_send_0(exch, CONSOLE_GET_EVENT, &result);
     165                int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
    188166                async_exchange_end(exch);
    189                
    190                 sysarg_t rc;
    191                 async_wait_for(aid, &rc);
    192167               
    193168                if (rc != EOK) {
    … …  
    196171                }
    197172               
    198                 rc = console_ev_decode(&result, event);
    199                 if (rc != EOK) {
    200                         errno = rc;
    201                         return false;
    202                 }
     173                event->type = type;
     174                event->key = key;
     175                event->mods = mods;
     176                event->c = c;
    203177        } else {
    204178                sysarg_t retval;
    … …  
    212186                }
    213187               
    214                 int rc = console_ev_decode(&ctrl->input_call, event);
    215                 if (rc != EOK) {
    216                         errno = rc;
    217                         return false;
    218                 }
     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);
    219192        }
    220193       
    … …  
    222195}
    223196
    224 bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
     197bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
    225198    suseconds_t *timeout)
    226199{
    … …  
    250223        }
    251224       
    252         rc = console_ev_decode(&ctrl->input_call, event);
    253         if (rc != EOK) {
    254                 errno = rc;
    255                 return false;
    256         }
     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);
    257229       
    258230        /* Update timeout */

  • uspace/lib/c/include/io/con_srv.h

    raa2b32c r06b0211b  
    4141#include <io/color.h>
    4242#include <io/concaps.h>
    43 #include <io/cons_event.h>
     43#include <io/kbd_event.h>
    4444#include <io/pixel.h>
    4545#include <io/style.h>
    … …  
    8282        void (*set_rgb_color)(con_srv_t *, pixel_t, pixel_t);
    8383        void (*set_cursor_visibility)(con_srv_t *, bool);
    84         int (*get_event)(con_srv_t *, cons_event_t *);
     84        int (*get_event)(con_srv_t *, kbd_event_t *);
    8585} con_ops_t;
    8686

  • uspace/lib/c/include/io/console.h

    raa2b32c r06b0211b  
    3939#include <io/concaps.h>
    4040#include <io/kbd_event.h>
    41 #include <io/cons_event.h>
    4241#include <io/keycode.h>
    4342#include <async.h>
    … …  
    8382extern void console_cursor_visibility(console_ctrl_t *, bool);
    8483extern int console_get_color_cap(console_ctrl_t *, sysarg_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 *,
     84extern bool console_get_kbd_event(console_ctrl_t *, kbd_event_t *);
     85extern bool console_get_kbd_event_timeout(console_ctrl_t *, kbd_event_t *,
    8786    suseconds_t *);
    8887

  • uspace/lib/c/include/io/window.h

    raa2b32c r06b0211b  
    4040#include <async.h>
    4141#include <loc.h>
    42 #include <io/kbd_event.h>
    43 #include <io/pos_event.h>
     42#include <io/console.h>
     43
     44typedef enum {
     45        POS_UPDATE,
     46        POS_PRESS,
     47        POS_RELEASE
     48} pos_event_type_t;
     49
     50typedef 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;
    4457
    4558typedef struct {

  • uspace/lib/clui/tinput.c

    raa2b32c r06b0211b  
    4545#define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols))
    4646#define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols))
    47 #define LIN_POS(ti, col, row) ((col) + (row) * (ti)->con_cols)
    4847
    4948/** Seek direction */
    … …  
    381380        }
    382381       
    383         tinput_post_seek(ti, shift_held);
    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 
    400382        tinput_post_seek(ti, shift_held);
    401383}
    … …  
    805787}
    806788
    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 
    855789/** Read in one line of input.
    856790 *
    … …  
    882816                console_flush(ti->console);
    883817               
    884                 cons_event_t ev;
    885                 if (!console_get_event(ti->console, &ev))
     818                kbd_event_t ev;
     819                if (!console_get_kbd_event(ti->console, &ev))
    886820                        return EIO;
    887821               
    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;
     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);
    898844                }
    899845        }

  • uspace/lib/clui/tinput.h

    raa2b32c r06b0211b  
    146146        /** @c true if user requested to abort interactive loop */
    147147        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;
    154148} tinput_t;
    155149

  • uspace/lib/gui/Makefile

    raa2b32c r06b0211b  
    3535SOURCES = \
    3636        button.c \
    37         canvas.c \
    3837        connection.c \
    3938        grid.c \

  • uspace/lib/gui/grid.c

    raa2b32c r06b0211b  
    11/*
    22 * Copyright (c) 2012 Petr Koupy
    3  * Copyright (c) 2013 Martin Decky
    43 * All rights reserved.
    54 *
    … …  
    3938#include <malloc.h>
    4039#include <surface.h>
     40
    4141#include "window.h"
    4242#include "grid.h"
    4343
    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        
     44static void paint_internal(widget_t *w)
     45{
     46        grid_t *grid = (grid_t *) w;
     47
    5448        surface_t *surface = window_claim(grid->widget.window);
    5549        if (!surface) {
    5650                window_yield(grid->widget.window);
    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++)
     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) {
    6355                        surface_put_pixel(surface, x, y, grid->background);
    64         }
    65        
     56                }
     57        }
     58
    6659        window_yield(grid->widget.window);
    6760}
    6861
    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))
     62static widget_t **widget_at(grid_t *grid, size_t row, size_t col)
     63{
     64        if (row < grid->rows && col < grid->cols) {
    7265                return grid->layout + (row * grid->cols + col);
    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;
     66        } else {
     67                return NULL;
     68        }
    9569}
    9670
    … …  
    10478{
    10579        grid_t *grid = (grid_t *) widget;
    106        
     80
    10781        deinit_grid(grid);
     82
    10883        free(grid);
    10984}
    … …  
    11186static void grid_reconfigure(widget_t *widget)
    11287{
    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         }
     88        /* no-op */
    17889}
    17990
    … …  
    18293{
    18394        grid_t *grid = (grid_t *) widget;
    184        
     95
    18596        widget_modify(widget, hpos, vpos, width, height);
    18697        paint_internal(widget);
    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);
     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;
    228119                                }
    229120                        }
    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;
    283                         }
    284                        
    285                         cur_vpos += heights[r].val;
    286                 }
    287         }
    288        
    289         if (widths)
    290                 free(widths);
    291        
    292         if (heights)
    293                 free(heights);
     121                        if (found) {
     122                                break;
     123                        }
     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        }
    294152}
    295153
    … …  
    297155{
    298156        paint_internal(widget);
    299        
    300157        list_foreach(widget->children, link) {
    301158                widget_t *child = list_get_instance(link, widget_t, link);
    302159                child->repaint(child);
    303160        }
    304        
    305161        window_damage(widget->window);
    306162}
    … …  
    308164static void grid_handle_keyboard_event(widget_t *widget, kbd_event_t event)
    309165{
    310         /* No-op */
     166        /* no-op */
    311167}
    312168
    … …  
    314170{
    315171        grid_t *grid = (grid_t *) widget;
    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        
     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
     189static 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
    340195        widget->parent = (widget_t *) grid;
    341        
    342196        list_append(&widget->link, &grid->widget.children);
    343197        widget->window = grid->widget.window;
    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                                 }
    359                         }
    360                 }
    361         }
    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))
     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;
     204                        }
     205                }
     206        }
     207}
     208
     209bool 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) {
    370217                return false;
    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        
     218        }
     219        memset(layout, 0, rows * cols * sizeof(widget_t *));
     220
    379221        widget_init(&grid->widget, parent);
    380        
     222
    381223        grid->widget.destroy = grid_destroy;
    382224        grid->widget.reconfigure = grid_reconfigure;
    … …  
    385227        grid->widget.handle_keyboard_event = grid_handle_keyboard_event;
    386228        grid->widget.handle_position_event = grid_handle_position_event;
    387        
     229
    388230        grid->add = grid_add;
    389231        grid->background = background;
     232        grid->rows = rows;
    390233        grid->cols = cols;
    391         grid->rows = rows;
    392        
     234        grid->layout = layout;
     235
    393236        return true;
    394237}
    395238
    396 grid_t *create_grid(widget_t *parent, size_t cols, size_t rows, pixel_t background)
     239grid_t *create_grid(widget_t *parent, size_t rows, size_t cols, pixel_t background)
    397240{
    398241        grid_t *grid = (grid_t *) malloc(sizeof(grid_t));
    399         if (!grid)
     242        if (!grid) {
    400243                return NULL;
    401        
    402         if (init_grid(grid, parent, cols, rows, background))
     244        }
     245
     246        if (init_grid(grid, parent, rows, cols, background)) {
    403247                return grid;
    404        
    405         free(grid);
    406         return NULL;
     248        } else {
     249                free(grid);
     250                return NULL;
     251        }
    407252}
    408253

  • uspace/lib/gui/grid.h

    raa2b32c r06b0211b  
    3939#include <sys/types.h>
    4040#include <io/pixel.h>
     41
    4142#include "widget.h"
    4243
    43 typedef struct {
    44         widget_t *widget;
    45         size_t cols;
    46         size_t rows;
    47 } grid_cell_t;
     44struct grid;
     45typedef struct grid grid_t;
    4846
    4947typedef struct grid {
    5048        widget_t widget;
    5149        pixel_t background;
     50        size_t rows;
    5251        size_t cols;
    53         size_t rows;
    54         grid_cell_t *layout;
    55         bool (*add)(struct grid *, widget_t *, size_t, size_t, size_t, size_t);
     52        widget_t **layout;
     53        void (*add)(grid_t *, widget_t *, size_t, size_t, size_t, size_t);
    5654} grid_t;
    5755

  • uspace/lib/gui/terminal.c

    raa2b32c r06b0211b  
    7777static void term_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
    7878static void term_set_cursor_visibility(con_srv_t *, bool);
    79 static int term_get_event(con_srv_t *, cons_event_t *);
     79static int term_get_event(con_srv_t *, kbd_event_t *);
    8080
    8181static con_ops_t con_ops = {
    … …  
    420420                if (pos < size) {
    421421                        link_t *link = prodcons_consume(&term->input_pc);
    422                         cons_event_t *event = list_get_instance(link, cons_event_t, link);
     422                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
    423423                       
    424424                        /* Accept key presses of printable chars only. */
    425                         if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
    426                             event->ev.key.c != 0) {
     425                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
    427426                                wchar_t tmp[2] = {
    428                                         event->ev.key.c,
     427                                        event->c,
    429428                                        0
    430429                                };
    … …  
    580579}
    581580
    582 static int term_get_event(con_srv_t *srv, cons_event_t *event)
     581static int term_get_event(con_srv_t *srv, kbd_event_t *event)
    583582{
    584583        terminal_t *term = srv_to_terminal(srv);
    585584        link_t *link = prodcons_consume(&term->input_pc);
    586         cons_event_t *ev = list_get_instance(link, cons_event_t, link);
    587        
    588         *event = *ev;
    589         free(ev);
     585        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
     586       
     587        *event = *kevent;
     588        free(kevent);
    590589        return EOK;
    591590}
    … …  
    635634}
    636635
    637 static void terminal_queue_cons_event(terminal_t *term, cons_event_t *ev)
    638 {
     636static void terminal_handle_keyboard_event(widget_t *widget,
     637    kbd_event_t kbd_event)
     638{
     639        terminal_t *term = (terminal_t *) widget;
     640       
    639641        /* Got key press/release event */
    640         cons_event_t *event =
    641             (cons_event_t *) malloc(sizeof(cons_event_t));
     642        kbd_event_t *event =
     643            (kbd_event_t *) malloc(sizeof(kbd_event_t));
    642644        if (event == NULL)
    643645                return;
    644646       
    645         *event = *ev;
    646647        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;
    647652       
    648653        prodcons_produce(&term->input_pc, &event->link);
    649654}
    650655
    651 /* Got key press/release event */
    652 static void terminal_handle_keyboard_event(widget_t *widget,
    653     kbd_event_t kbd_event)
    654 {
    655         terminal_t *term = (terminal_t *) widget;
    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         }
     656static 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         */
    681662}
    682663

  • uspace/lib/gui/window.c

    raa2b32c r06b0211b  
    424424
    425425        while (!list_empty(&win->events.list)) {
    426                 window_event_t *event = (window_event_t *) list_first(&win->events.list);
    427                 list_remove(&event->link);
    428                 free(event);
     426                list_remove(list_first(&win->events.list));
    429427        }
    430428

  • uspace/srv/hid/compositor/Makefile

    raa2b32c r06b0211b  
    3838
    3939IMAGES = \
     40        gfx/helenos.tga \
    4041        gfx/nameic.tga
    4142

  • uspace/srv/hid/compositor/compositor.c

    raa2b32c r06b0211b  
    9090typedef struct {
    9191        link_t link;
    92         atomic_t ref_cnt;
    9392        service_id_t in_dsid;
    9493        service_id_t out_dsid;
    … …  
    139138} viewport_t;
    140139
    141 static desktop_rect_t viewport_bound_rect;
    142140static FIBRIL_MUTEX_INITIALIZE(viewport_list_mtx);
    143141static LIST_INITIALIZE(viewport_list);
    … …  
    217215
    218216        link_initialize(&win->link);
    219         atomic_set(&win->ref_cnt, 0);
    220217        prodcons_initialize(&win->queue);
    221218        transform_identity(&win->transform);
    … …  
    235232static void window_destroy(window_t *win)
    236233{
    237         if (win && atomic_get(&win->ref_cnt) == 0) {
    238                 while (!list_empty(&win->queue.list)) {
    239                         window_event_t *event = (window_event_t *) list_first(&win->queue.list);
    240                         list_remove(&event->link);
    241                         free(event);
    242                 }
    243 
     234        if (win) {
    244235                if (win->surface) {
    245236                        surface_destroy(win->surface);
    … …  
    319310}
    320311
    321 static void comp_restrict_pointers(void)
    322 {
    323         fibril_mutex_lock(&viewport_list_mtx);
    324 
    325         sysarg_t x_res = coord_origin;
    326         sysarg_t y_res = coord_origin;
    327         sysarg_t w_res = 0;
    328         sysarg_t h_res = 0;
    329 
    330         if (!list_empty(&viewport_list)) {
    331                 viewport_t *vp = (viewport_t *) list_first(&viewport_list);
    332                 x_res = vp->pos.x;
    333                 y_res = vp->pos.y;
    334                 surface_get_resolution(vp->surface, &w_res, &h_res);
    335         }
    336 
    337         list_foreach(viewport_list, link) {
    338                 viewport_t *vp = list_get_instance(link, viewport_t, link);
    339                 sysarg_t w_vp, h_vp;
    340                 surface_get_resolution(vp->surface, &w_vp, &h_vp);
    341                 rectangle_union(
    342                     x_res, y_res, w_res, h_res,
    343                     vp->pos.x, vp->pos.y, w_vp, h_vp,
    344                     &x_res, &y_res, &w_res, &h_res);
    345         }
    346 
    347         viewport_bound_rect.x = x_res;
    348         viewport_bound_rect.y = y_res;
    349         viewport_bound_rect.w = w_res;
    350         viewport_bound_rect.h = h_res;
    351 
    352         fibril_mutex_unlock(&viewport_list_mtx);
    353 
    354         fibril_mutex_lock(&pointer_list_mtx);
    355 
    356         list_foreach(pointer_list, link) {
    357                 pointer_t *ptr = list_get_instance(link, pointer_t, link);
    358                 ptr->pos.x = ptr->pos.x > viewport_bound_rect.x ? ptr->pos.x : viewport_bound_rect.x;
    359                 ptr->pos.y = ptr->pos.y > viewport_bound_rect.y ? ptr->pos.y : viewport_bound_rect.y;
    360                 ptr->pos.x = ptr->pos.x < viewport_bound_rect.x + viewport_bound_rect.w ?
    361                     ptr->pos.x : viewport_bound_rect.x + viewport_bound_rect.w;
    362                 ptr->pos.y = ptr->pos.y < viewport_bound_rect.y + viewport_bound_rect.h ?
    363                     ptr->pos.y : viewport_bound_rect.y + viewport_bound_rect.h;
    364         }
    365 
    366         fibril_mutex_unlock(&pointer_list_mtx);
    367 }
    368 
    369312static void comp_damage(sysarg_t x_dmg_glob, sysarg_t y_dmg_glob,
    370313    sysarg_t w_dmg_glob, sysarg_t h_dmg_glob)
    … …  
    752695        }
    753696
    754         loc_service_unregister(win->in_dsid);
    755         loc_service_unregister(win->out_dsid);
    756 
    757         /* In case the client was killed, input fibril of the window might be
    758          * still blocked on the condition within comp_window_get_event. */
    759         window_event_t *event_dummy = (window_event_t *) malloc(sizeof(window_event_t));
    760         if (event_dummy) {
    761                 link_initialize(&event_dummy->link);
    762                 prodcons_produce(&win->queue, &event_dummy->link);
    763         }
    764 
    765697        /* Calculate damage. */
    766698        sysarg_t x = 0;
    … …  
    774706        }
    775707
     708        /* Release window resources. */
     709        loc_service_unregister(win->in_dsid);
     710        loc_service_unregister(win->out_dsid);
     711        while (!list_empty(&win->queue.list)) {
     712                list_remove(list_first(&win->queue.list));
     713        }
     714        window_destroy(win);
     715
    776716        comp_damage(x, y, width, height);
    777717
    … …  
    873813
    874814        if (win) {
    875                 atomic_inc(&win->ref_cnt);
    876815                async_answer_0(iid, EOK);
    877816        } else {
    … …  
    886825
    887826                        if (!IPC_GET_IMETHOD(call)) {
    888                                 async_answer_0(callid, EOK);
    889                                 atomic_dec(&win->ref_cnt);
    890                                 window_destroy(win);
     827                                async_answer_0(callid, EINVAL);
    891828                                return;
    892829                        }
    … …  
    905842
    906843                        if (!IPC_GET_IMETHOD(call)) {
    907                                 comp_window_close(win, callid, &call);
    908                                 atomic_dec(&win->ref_cnt);
    909                                 window_destroy(win);
     844                                async_answer_0(callid, EINVAL);
    910845                                return;
    911846                        }
    … …  
    922857                                break;
    923858                        case WINDOW_CLOSE:
    924                                 /* Postpone the closing until the phone is hung up to cover
    925                                  * the case when the client is killed abruptly. */
    926                                 async_answer_0(callid, EOK);
     859                                comp_window_close(win, callid, &call);
    927860                                break;
    928861                        case WINDOW_CLOSE_REQUEST:
    … …  
    978911        async_answer_0(iid, EOK);
    979912
    980         comp_restrict_pointers();
    981913        comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    982914}
    … …  
    1024956                fibril_mutex_unlock(&viewport_list_mtx);
    1025957                async_answer_0(iid, EOK);
    1026 
    1027                 comp_restrict_pointers();
    1028                 comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    1029958        }
    1030959}
    … …  
    14621391        surface_get_resolution(pointer->cursor.states[pointer->state],
    14631392             &cursor_width, &cursor_height);
    1464         if (pointer->pos.x + dx < viewport_bound_rect.x) {
    1465                 dx = -1 * (pointer->pos.x - viewport_bound_rect.x);
    1466         }
    1467         if (pointer->pos.y + dy < viewport_bound_rect.y) {
    1468                 dy = -1 * (pointer->pos.y - viewport_bound_rect.y);
    1469         }
    1470         if (pointer->pos.x + dx > viewport_bound_rect.x + viewport_bound_rect.w) {
    1471                 dx = (viewport_bound_rect.x + viewport_bound_rect.w - pointer->pos.x);
    1472         }
    1473         if (pointer->pos.y + dy > viewport_bound_rect.y + viewport_bound_rect.h) {
    1474                 dy = (viewport_bound_rect.y + viewport_bound_rect.h - pointer->pos.y);
    1475         }
    14761393        pointer->pos.x += dx;
    14771394        pointer->pos.y += dy;
    … …  
    19931910                        fibril_mutex_unlock(&viewport_list_mtx);
    19941911
    1995                         comp_restrict_pointers();
    19961912                        comp_damage(x, y, width, height);
    19971913                } else {
    … …  
    20461962                }
    20471963                list_prepend(&blue_win->link, &window_list);
    2048                
     1964
     1965                window_t *helenos_win = window_create(0, 0);
     1966                helenos_win->surface = decode_tga((void *) helenos_tga, helenos_tga_size, 0);
     1967                list_prepend(&helenos_win->link, &window_list);
     1968
    20491969                window_t *nameic_win = window_create(0, 0);
    20501970                nameic_win->surface = decode_tga((void *) nameic_tga, nameic_tga_size, 0);
    … …  
    22062126                return -1;
    22072127        }
    2208 
    2209         comp_restrict_pointers();
     2128       
    22102129        comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    22112130       

  • uspace/srv/hid/console/console.c

    raa2b32c r06b0211b  
    129129static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
    130130static void cons_set_cursor_visibility(con_srv_t *, bool);
    131 static int cons_get_event(con_srv_t *, cons_event_t *);
     131static int cons_get_event(con_srv_t *, kbd_event_t *);
    132132
    133133static con_ops_t con_ops = {
    … …  
    490490}
    491491
    492 static int cons_get_event(con_srv_t *srv, cons_event_t *event)
     492static int cons_get_event(con_srv_t *srv, kbd_event_t *event)
    493493{
    494494        console_t *cons = srv_to_console(srv);
    … …  
    496496        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
    497497       
    498         event->type = CEV_KEY;
    499         event->ev.key = *kevent;
     498        *event = *kevent;
    500499        free(kevent);
    501500        return EOK;

  • uspace/srv/hid/remcons/remcons.c

    raa2b32c r06b0211b  
    8080static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
    8181static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
    82 static int remcons_get_event(con_srv_t *, cons_event_t *);
     82static int remcons_get_event(con_srv_t *, kbd_event_t *);
    8383
    8484static con_ops_t con_ops = {
    … …  
    185185}
    186186
    187 static int remcons_get_event(con_srv_t *srv, cons_event_t *event)
    188 {
    189         telnet_user_t *user = srv_to_user(srv);
    190         kbd_event_t kevent;
     187static int remcons_get_event(con_srv_t *srv, kbd_event_t *event)
     188{
     189        telnet_user_t *user = srv_to_user(srv);
    191190        int rc;
    192191
    193         rc = telnet_user_get_next_keyboard_event(user, &kevent);
     192        rc = telnet_user_get_next_keyboard_event(user, event);
    194193        if (rc != EOK) {
    195194                /* XXX What? */
    … …  
    197196                return EOK;
    198197        }
    199 
    200         event->type = CEV_KEY;
    201         event->ev.key = kevent;
    202198
    203199        return EOK;

  • uspace/srv/net/ethip/ethip.c

    raa2b32c r06b0211b  
    221221        case ETYPE_IP:
    222222                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
    223                 sdu.lsrc.ipv4 = 0;
    224                 sdu.ldest.ipv4 = 0;
     223                sdu.lsrc.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1;
     224                sdu.ldest.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 4;
    225225                sdu.data = frame.data;
    226226                sdu.size = frame.size;

  • uspace/srv/ns/task.c

    raa2b32c r06b0211b  
    208208        sysarg_t retval;
    209209        task_exit_t texit;
    210         bool remove = false;
    211210       
    212211        ht_link_t *link = hash_table_find(&task_hash_table, &id);
    … …  
    236235        }
    237236       
    238         remove = true;
     237        hash_table_remove_item(&task_hash_table, link);
    239238        retval = EOK;
    240239       
    … …  
    244243                ipc_answer_2(callid, retval, texit, ht->retval);
    245244        }
    246         if (remove)
    247                 hash_table_remove_item(&task_hash_table, link);
    248245}
    249246
Note: See TracChangeset for help on using the changeset viewer.