Changeset aa2b32c in mainline

Timestamp:

2013-04-29T12:44:05Z (11 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

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.

Message:

Merge mainline changes

Files:

• kernel/genarch/Makefile.inc (modified) (1 diff)
• kernel/genarch/src/fb/fb.c (modified) (10 diffs)
• kernel/genarch/src/fb/logo-196x66.c (deleted)
• uspace/app/bdsh/cmds/modules/cat/cat.c (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/cp/cp.c (modified) (1 diff)
• uspace/app/edit/edit.c (modified) (10 diffs)
• uspace/app/mkbd/main.c (modified) (2 diffs)
• uspace/app/msim/arch_helenos/input.c (modified) (1 diff)
• uspace/app/nterm/nterm.c (modified) (2 diffs)
• uspace/app/ping/ping.c (modified) (2 diffs)
• uspace/app/taskdump/symtab.c (modified) (1 diff)
• uspace/app/tester/ipc/starve.c (modified) (1 diff)
• uspace/app/tetris/scores.c (modified) (3 diffs)
• uspace/app/tetris/screen.c (modified) (3 diffs)
• uspace/app/top/screen.c (modified) (2 diffs)
• uspace/app/trace/trace.c (modified) (2 diffs)
• uspace/app/vdemo/vdemo.c (modified) (1 diff)
• uspace/app/vlaunch/Makefile (modified) (1 diff)
• uspace/app/vlaunch/gfx/helenos.tga (added)
• uspace/app/vlaunch/vlaunch.c (modified) (5 diffs)
• uspace/dist/src/c/demos/tetris/scores.c (modified) (3 diffs)
• uspace/dist/src/c/demos/top/screen.c (modified) (1 diff)
• uspace/drv/char/ns8250/ns8250.c (modified) (3 diffs)
• uspace/lib/c/generic/io/con_srv.c (modified) (4 diffs)
• uspace/lib/c/generic/io/console.c (modified) (5 diffs)
• uspace/lib/c/include/io/con_srv.h (modified) (2 diffs)
• uspace/lib/c/include/io/cons_event.h (added)
• uspace/lib/c/include/io/console.h (modified) (2 diffs)
• uspace/lib/c/include/io/pos_event.h (moved) (moved from kernel/genarch/include/genarch/fb/logo-196x66.h ) (3 diffs)
• uspace/lib/c/include/io/window.h (modified) (1 diff)
• uspace/lib/clui/tinput.c (modified) (4 diffs)
• uspace/lib/clui/tinput.h (modified) (1 diff)
• uspace/lib/gui/Makefile (modified) (1 diff)
• uspace/lib/gui/canvas.c (added)
• uspace/lib/gui/canvas.h (added)
• uspace/lib/gui/grid.c (modified) (9 diffs)
• uspace/lib/gui/grid.h (modified) (1 diff)
• uspace/lib/gui/terminal.c (modified) (4 diffs)
• uspace/lib/gui/window.c (modified) (1 diff)
• uspace/srv/hid/compositor/Makefile (modified) (1 diff)
• uspace/srv/hid/compositor/compositor.c (modified) (17 diffs)
• uspace/srv/hid/compositor/gfx/helenos.tga (deleted)
• uspace/srv/hid/console/console.c (modified) (3 diffs)
• uspace/srv/hid/remcons/remcons.c (modified) (3 diffs)
• uspace/srv/net/ethip/ethip.c (modified) (1 diff)
• uspace/srv/ns/task.c (modified) (3 diffs)

kernel/genarch/Makefile.inc

@@ -66 +66 @@
         GENARCH_SOURCES += \
                 genarch/src/fb/font-8x16.c \
-                genarch/src/fb/logo-196x66.c \
                 genarch/src/fb/fb.c \
                 genarch/src/fb/bfb.c

kernel/genarch/src/fb/fb.c

@@ -35 +35 @@
 
 #include <genarch/fb/font-8x16.h>
-#include <genarch/fb/logo-196x66.h>
 #include <genarch/fb/fb.h>
 #include <console/chardev.h>
@@ -53 +52 @@
 #include <byteorder.h>
 
-#define BG_COLOR     0x000080
-#define FG_COLOR     0xffff00
+#define BG_COLOR     0x001620
+#define FG_COLOR     0xf3cf65
 #define INV_COLOR    0xaaaaaa
 
@@ -93 +92 @@
         unsigned int yres;
         
-        unsigned int ylogo;
-        unsigned int ytrim;
         unsigned int rowtrim;
         
@@ -213 +210 @@
 }
 
-/** Hide logo and refresh screen
- *
- */
-static void logo_hide(fb_instance_t *instance)
-{
-        instance->ylogo = 0;
-        instance->ytrim = instance->yres;
-        instance->rowtrim = instance->rows;
-        
-        if ((!instance->parea.mapped) || (console_override))
-                fb_redraw_internal(instance);
-}
-
 /** Draw character at given position
  *
@@ -236 +220 @@
         unsigned int yd;
         
-        if (y >= instance->ytrim)
-                logo_hide(instance);
-        
         if (!overlay)
                 instance->backbuf[BB_POS(instance, col, row)] = glyph;
@@ -244 +225 @@
         if ((!instance->parea.mapped) || (console_override)) {
                 for (yd = 0; yd < FONT_SCANLINES; yd++)
-                        memcpy(&instance->addr[FB_POS(instance, x, y + yd + instance->ylogo)],
+                        memcpy(&instance->addr[FB_POS(instance, x, y + yd)],
                             &instance->glyphs[GLYPH_POS(instance, glyph, yd)],
                             instance->glyphscanline);
@@ -256 +237 @@
 static void screen_scroll(fb_instance_t *instance)
 {
-        if (instance->ylogo > 0) {
-                logo_hide(instance);
-                return;
-        }
-        
         if ((!instance->parea.mapped) || (console_override)) {
                 unsigned int row;
@@ -412 +388 @@
 static void fb_redraw_internal(fb_instance_t *instance)
 {
-        if (instance->ylogo > 0) {
-                unsigned int y;
-                
-                for (y = 0; y < LOGO_HEIGHT; y++) {
-                        unsigned int x;
-                        
-                        for (x = 0; x < instance->xres; x++)
-                                instance->rgb_conv(&instance->addr[FB_POS(instance, x, y)],
-                                    (x < LOGO_WIDTH) ?
-                                    fb_logo[y * LOGO_WIDTH + x] :
-                                    LOGO_COLOR);
-                }
-        }
-        
         unsigned int row;
         
         for (row = 0; row < instance->rowtrim; row++) {
-                unsigned int y = instance->ylogo + ROW2Y(row);
+                unsigned int y = ROW2Y(row);
                 unsigned int yd;
                 
@@ -452 +414 @@
                     (instance->xres - COL2X(instance->cols)) * instance->pixelbytes;
                 
-                for (y = instance->ylogo; y < instance->yres; y++)
+                for (y = 0; y < instance->yres; y++)
                         memcpy(&instance->addr[FB_POS(instance, COL2X(instance->cols), y)],
                             instance->bgscan, size);
         }
         
-        if (ROW2Y(instance->rowtrim) + instance->ylogo < instance->yres) {
+        if (ROW2Y(instance->rowtrim) < instance->yres) {
                 unsigned int y;
                 
-                for (y = ROW2Y(instance->rowtrim) + instance->ylogo;
-                    y < instance->yres; y++)
+                for (y = ROW2Y(instance->rowtrim); y < instance->yres; y++)
                         memcpy(&instance->addr[FB_POS(instance, 0, y)],
                             instance->bgscan, instance->bgscanbytes);
@@ -567 +528 @@
         instance->rows = Y2ROW(instance->yres);
         
-        if (instance->yres > LOGO_HEIGHT) {
-                instance->ylogo = LOGO_HEIGHT;
-                instance->rowtrim = instance->rows - Y2ROW(instance->ylogo);
-                if (instance->ylogo % FONT_SCANLINES > 0)
-                        instance->rowtrim--;
-                instance->ytrim = ROW2Y(instance->rowtrim);
-        } else {
-                instance->ylogo = 0;
-                instance->ytrim = instance->yres;
-                instance->rowtrim = instance->rows;
-        }
+        instance->rowtrim = instance->rows;
         
         instance->glyphscanline = FONT_WIDTH * instance->pixelbytes;

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

@@ -117 +117 @@
 static void waitkey()
 {
-        kbd_event_t ev;
+        cons_event_t ev;
+        kbd_event_t *kev;
         
         while (true) {
-                if (!console_get_kbd_event(console, &ev)) {
+                if (!console_get_event(console, &ev)) {
                         return;
                 }
-                if (ev.type == KEY_PRESS) {
-                        if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
+                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
+                        kev = &ev.ev.key;
+                        
+                        if (kev->key == KC_ESCAPE || kev->key == KC_Q) {
                                 should_quit = true;
                                 return;
                         }
-                        if (ev.key == KC_C) {
+                        if (kev->key == KC_C) {
                                 paging_enabled = false;
                                 return;
                         }
-                        if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
-                            ev.key == KC_PAGE_DOWN) {
+                        if (kev->key == KC_ENTER || kev->key == KC_SPACE ||
+                            kev->key == KC_PAGE_DOWN) {
                                 return;
                         }

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

@@ -152 +152 @@
 
         while (true) {
-                kbd_event_t ev;
+                cons_event_t ev;
                 console_flush(con);
-                console_get_kbd_event(con, &ev);
-                if ((ev.type != KEY_PRESS)
-                    || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
+                console_get_event(con, &ev);
+                if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS ||
+                    (ev.ev.key.mods & (KM_CTRL | KM_ALT)) != 0) {
                         continue;
                 }
 
-                switch(ev.key) {
+                switch(ev.ev.key.key) {
                 case KC_Y:
                         printf("y\n");

uspace/app/edit/edit.c

@@ -80 +80 @@
         tag_t sel_start;
 
+        /** Active keyboard modifiers */
+        keymod_t keymod;
+
         /** 
          * Ideal column where the caret should try to get. This is used
@@ -119 +122 @@
 static void cursor_setvis(bool visible);
 
+static void key_handle_press(kbd_event_t *ev);
 static void key_handle_unmod(kbd_event_t const *ev);
 static void key_handle_ctrl(kbd_event_t const *ev);
@@ -124 +128 @@
 static void key_handle_shift_ctrl(kbd_event_t const *ev);
 static void key_handle_movement(unsigned int key, bool shift);
+
+static void pos_handle(pos_event_t *ev);
 
 static int file_save(char const *fname);
@@ -182 +188 @@
 int main(int argc, char *argv[])
 {
-        kbd_event_t ev;
+        cons_event_t ev;
         bool new_file;
         int rc;
@@ -245 +251 @@
 
         while (!done) {
-                console_get_kbd_event(con, &ev);
+                console_get_event(con, &ev);
                 pane.rflags = 0;
 
-                if (ev.type == KEY_PRESS) {
-                        /* Handle key press. */
-                        if (((ev.mods & KM_ALT) == 0) &&
-                            ((ev.mods & KM_SHIFT) == 0) &&
-                             (ev.mods & KM_CTRL) != 0) {
-                                key_handle_ctrl(&ev);
-                        } else if (((ev.mods & KM_ALT) == 0) &&
-                            ((ev.mods & KM_CTRL) == 0) &&
-                             (ev.mods & KM_SHIFT) != 0) {
-                                key_handle_shift(&ev);
-                        } else if (((ev.mods & KM_ALT) == 0) &&
-                            ((ev.mods & KM_CTRL) != 0) &&
-                             (ev.mods & KM_SHIFT) != 0) {
-                                key_handle_shift_ctrl(&ev);
-                        } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
-                                key_handle_unmod(&ev);
-                        }
+                switch (ev.type) {
+                case CEV_KEY:
+                        pane.keymod = ev.ev.key.mods;
+                        if (ev.ev.key.type == KEY_PRESS)
+                                key_handle_press(&ev.ev.key);
+                        break;
+                case CEV_POS:
+                        pos_handle(&ev.ev.pos);
+                        break;
                 }
 
@@ -286 +284 @@
 
         return 0;
+}
+
+/* Handle key press. */
+static void key_handle_press(kbd_event_t *ev)
+{
+        if (((ev->mods & KM_ALT) == 0) &&
+            ((ev->mods & KM_SHIFT) == 0) &&
+             (ev->mods & KM_CTRL) != 0) {
+                key_handle_ctrl(ev);
+        } else if (((ev->mods & KM_ALT) == 0) &&
+            ((ev->mods & KM_CTRL) == 0) &&
+             (ev->mods & KM_SHIFT) != 0) {
+                key_handle_shift(ev);
+        } else if (((ev->mods & KM_ALT) == 0) &&
+            ((ev->mods & KM_CTRL) != 0) &&
+             (ev->mods & KM_SHIFT) != 0) {
+                key_handle_shift_ctrl(ev);
+        } else if ((ev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
+                key_handle_unmod(ev);
+        }
 }
 
@@ -462 +480 @@
 }
 
+static void pos_handle(pos_event_t *ev)
+{
+        coord_t bc;
+        spt_t pt;
+        bool select;
+
+        if (ev->type == POS_PRESS && ev->vpos < (unsigned)pane.rows) {
+                bc.row = pane.sh_row + ev->vpos;
+                bc.column = pane.sh_column + ev->hpos;
+                sheet_get_cell_pt(doc.sh, &bc, dir_before, &pt);
+
+                select = (pane.keymod & KM_SHIFT) != 0;
+
+                caret_move(pt, select, true);
+        }
+}
+
 /** Move caret while preserving or resetting selection. */
 static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
@@ -592 +627 @@
 static char *prompt(char const *prompt, char const *init_value)
 {
-        kbd_event_t ev;
+        cons_event_t ev;
+        kbd_event_t *kev;
         char *str;
         wchar_t buffer[INFNAME_MAX_LEN + 1];
@@ -612 +648 @@
 
         while (!done) {
-                console_get_kbd_event(con, &ev);
-
-                if (ev.type == KEY_PRESS) {
+                console_get_event(con, &ev);
+
+                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
+                        kev = &ev.ev.key;
+
                         /* Handle key press. */
-                        if (((ev.mods & KM_ALT) == 0) &&
-                             (ev.mods & KM_CTRL) != 0) {
+                        if (((kev->mods & KM_ALT) == 0) &&
+                             (kev->mods & KM_CTRL) != 0) {
                                 ;
-                        } else if ((ev.mods & (KM_CTRL | KM_ALT)) == 0) {
-                                switch (ev.key) {
+                        } else if ((kev->mods & (KM_CTRL | KM_ALT)) == 0) {
+                                switch (kev->key) {
                                 case KC_ESCAPE:
                                         return NULL;
@@ -634 +672 @@
                                         break;
                                 default:
-                                        if (ev.c >= 32 && nc < max_len) {
-                                                putchar(ev.c);
+                                        if (kev->c >= 32 && nc < max_len) {
+                                                putchar(kev->c);
                                                 console_flush(con);
-                                                buffer[nc++] = ev.c;
+                                                buffer[nc++] = kev->c;
                                         }
                                         break;

uspace/app/mkbd/main.c

@@ -178 +178 @@
 
         while (1) {
-                kbd_event_t ev;
-                bool ok = console_get_kbd_event(con, &ev);
+                cons_event_t ev;
+                bool ok = console_get_event(con, &ev);
                 if (!ok) {
                         printf("Connection with console broken: %s.\n",
@@ -186 +186 @@
                 }
 
-                if (ev.key == KC_ESCAPE) {
+                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
+                    ev.ev.key.key == KC_ESCAPE) {
                         break;
                 }

uspace/app/msim/arch_helenos/input.c

@@ -91 +91 @@
 bool stdin_poll(char *key)
 {
-        kbd_event_t ev;
+        cons_event_t ev;
         suseconds_t timeout = 0;
         errno = EOK;
         console_flush(input_prompt->console);
-        bool has_input = console_get_kbd_event_timeout(input_prompt->console, &ev, &timeout);
+        bool has_input = console_get_event_timeout(input_prompt->console, &ev, &timeout);
         if (!has_input) {
                 return false;
         }
 
-        if (ev.type != KEY_PRESS)
+        if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS)
                 return false;
 
-        *key = ev.c;
+        *key = ev.ev.key.c;
 
         return true;

uspace/app/nterm/nterm.c

@@ -109 +109 @@
 int main(int argc, char *argv[])
 {
-        kbd_event_t ev;
+        cons_event_t ev;
         int rc;
 
@@ -129 +129 @@
         done = false;
         while (!done) {
-                console_get_kbd_event(con, &ev);
-                if (ev.type == KEY_PRESS)
-                        key_handle(&ev);
+                console_get_event(con, &ev);
+                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS)
+                        key_handle(&ev.ev.key);
         }
 

uspace/app/ping/ping.c

@@ -188 +188 @@
 {
         console_ctrl_t *con;
-        kbd_event_t ev;
+        cons_event_t ev;
 
         con = console_init(stdin, stdout);
@@ -194 +194 @@
 
         while (true) {
-                if (!console_get_kbd_event(con, &ev))
+                if (!console_get_event(con, &ev))
                         break;
 
-                if (ev.type == KEY_PRESS && (ev.mods & (KM_ALT | KM_SHIFT)) ==
-                    0 && (ev.mods & KM_CTRL) != 0) {
+                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
+                    (ev.ev.key.mods & (KM_ALT | KM_SHIFT)) ==
+                    0 && (ev.ev.key.mods & KM_CTRL) != 0) {
                         /* Ctrl+key */
-                        if (ev.key == KC_Q) {
+                        if (ev.ev.key.key == KC_Q) {
                                 ping_signal_done();
                                 return 0;

uspace/app/taskdump/symtab.c

@@ -267 +267 @@
                         continue;
 
-                if (best_name == NULL || (saddr <= addr && saddr > best_addr)) {
+                if (saddr <= addr && (best_name == NULL || saddr > best_addr)) {
                         best_name = sname;
                         best_addr = saddr;

uspace/app/tester/ipc/starve.c

@@ -62 +62 @@
                         break;
                 
-                kbd_event_t ev;
+                cons_event_t ev;
                 suseconds_t timeout = 0;
-                bool has_event = console_get_kbd_event_timeout(console, &ev, &timeout);
-                if (has_event && (ev.type == KEY_PRESS)) {
-                        TPRINTF("Key %d pressed, terminating.\n", ev.key);
+                bool has_event = console_get_event_timeout(console, &ev, &timeout);
+                if (has_event && ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
+                        TPRINTF("Key %d pressed, terminating.\n", ev.ev.key.key);
                         break;
                 }

uspace/app/tetris/scores.c

@@ -125 +125 @@
         int j;
         size_t off;
-        kbd_event_t ev;
+        cons_event_t ev;
+        kbd_event_t *kev;
         
         clear_screen();
@@ -141 +142 @@
         while (1) {
                 console_flush(console);
-                if (!console_get_kbd_event(console, &ev))
+                if (!console_get_event(console, &ev))
                         exit(1);
                 
-                if (ev.type == KEY_RELEASE)
+                if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE)
                         continue;
                 
-                if (ev.key == KC_ENTER || ev.key == KC_NENTER)
+                kev = &ev.ev.key;
+                
+                if (kev->key == KC_ENTER || kev->key == KC_NENTER)
                         break;
                 
-                if (ev.key == KC_BACKSPACE) {
+                if (kev->key == KC_BACKSPACE) {
                         if (i > 0) {
                                 wchar_t uc;
@@ -166 +169 @@
                                 scores[NUMSPOTS - 1].hs_name[off] = '\0';
                         }
-                } else if (ev.c != '\0') {
+                } else if (kev->c != '\0') {
                         if (i < (MAXLOGNAME - 1)) {
-                                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
+                                if (chr_encode(kev->c, scores[NUMSPOTS - 1].hs_name,
                                     &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
                                         ++i;

uspace/app/tetris/screen.c

@@ -344 +344 @@
         
         while (timeout > 0) {
-                kbd_event_t event;
-                
-                if (!console_get_kbd_event_timeout(console, &event, &timeout))
+                cons_event_t event;
+                
+                if (!console_get_event_timeout(console, &event, &timeout))
                         break;
         }
@@ -376 +376 @@
         
         while (c == 0) {
-                kbd_event_t event;
-                
-                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
+                cons_event_t event;
+                
+                if (!console_get_event_timeout(console, &event, &timeleft)) {
                         timeleft = 0;
                         return -1;
                 }
                 
-                if (event.type == KEY_PRESS)
-                        c = event.c;
+                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
+                        c = event.ev.key.c;
         }
         
@@ -398 +398 @@
         
         while (c == 0) {
-                kbd_event_t event;
-                
-                if (!console_get_kbd_event(console, &event))
+                cons_event_t event;
+                
+                if (!console_get_event(console, &event))
                         return -1;
                 
-                if (event.type == KEY_PRESS)
-                        c = event.c;
+                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
+                        c = event.ev.key.c;
         }
         

uspace/app/top/screen.c

@@ -556 +556 @@
         
         while (c == 0) {
-                kbd_event_t event;
+                cons_event_t event;
                 
                 warning_timeleft -= timeleft;
-                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
+                if (!console_get_event_timeout(console, &event, &timeleft)) {
                         timeleft = 0;
                         return -1;
@@ -565 +565 @@
                 warning_timeleft += timeleft;
                 
-                if (event.type == KEY_PRESS)
-                        c = event.c;
+                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
+                        c = event.ev.key.c;
         }
         

uspace/app/trace/trace.c

@@ -565 +565 @@
 static int cev_fibril(void *arg)
 {
+        cons_event_t event;
+
         (void) arg;
         
@@ -575 +577 @@
                 fibril_mutex_unlock(&state_lock);
                 
-                if (!console_get_kbd_event(console, &cev))
+                if (!console_get_event(console, &event))
                         return -1;
                 
-                fibril_mutex_lock(&state_lock);
-                cev_valid = true;
-                fibril_condvar_broadcast(&state_cv);
-                fibril_mutex_unlock(&state_lock);
+                if (event.type == CEV_KEY) {
+                        fibril_mutex_lock(&state_lock);
+                        cev = event.ev.key;
+                        cev_valid = true;
+                        fibril_condvar_broadcast(&state_cv);
+                        fibril_mutex_unlock(&state_lock);
+                }
         }
 }

uspace/app/vdemo/vdemo.c

@@ -141 +141 @@
                     lbl_action->cancel);
 
-                grid->add(grid, &lbl_action->label.widget, 0, 0, 1, 2);
-                grid->add(grid, &btn_confirm->widget, 1, 0, 1, 1);
+                grid->add(grid, &lbl_action->label.widget, 0, 0, 2, 1);
+                grid->add(grid, &btn_confirm->widget, 0, 1, 1, 1);
                 grid->add(grid, &btn_cancel->widget, 1, 1, 1, 1);
-                window_resize(main_window, 200, 70);
+                window_resize(main_window, 200, 76);
 
                 window_exec(main_window);

uspace/app/vlaunch/Makefile

@@ -35 +35 @@
 
 SOURCES = \
-        vlaunch.c
+        vlaunch.c \
+        images.c
+
+IMAGES = \
+        gfx/helenos.tga
+
+PRE_DEPEND = images.c images.h
+EXTRA_CLEAN = images.c images.h
 
 include $(USPACE_PREFIX)/Makefile.common
+
+images.c images.h: $(IMAGES)
+        $(ROOT_PATH)/tools/mkarray.py images COMPOSITOR_IMAGES $^

uspace/app/vlaunch/vlaunch.c

@@ -46 +46 @@
 #include <button.h>
 #include <label.h>
+#include <canvas.h>
 
-#define NAME "vlaunch"
+#include <surface.h>
+#include <source.h>
+#include <drawctx.h>
+#include <codec/tga.h>
+
+#include "images.h"
+
+#define NAME  "vlaunch"
+
+#define LOGO_WIDTH   196
+#define LOGO_HEIGHT  66
 
 static char *winreg = NULL;
@@ -97 +108 @@
         }
         
+        surface_t *logo = decode_tga((void *) helenos_tga, helenos_tga_size, 0);
+        if (!logo) {
+                printf("Unable to decode logo.\n");
+                return 1;
+        }
+        
         winreg = argv[1];
         window_t *main_window = window_open(argv[1], true, true, "vlaunch", 0, 0);
@@ -104 +121 @@
         }
         
-        pixel_t grd_bg = PIXEL(255, 240, 240, 240);
+        pixel_t grd_bg = PIXEL(255, 255, 255, 255);
         pixel_t btn_bg = PIXEL(255, 0, 0, 0);
         pixel_t btn_fg = PIXEL(255, 240, 240, 240);
-        pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
+        pixel_t lbl_bg = PIXEL(255, 255, 255, 255);
         pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
         
+        canvas_t *logo_canvas = create_canvas(NULL, LOGO_WIDTH, LOGO_HEIGHT,
+            logo);
         label_t *lbl_caption = create_label(NULL, "Launch application:", 16,
             lbl_bg, lbl_fg);
@@ -118 +137 @@
         button_t *btn_vlaunch = create_button(NULL, "vlaunch", 16, btn_bg,
             btn_fg);
-        grid_t *grid = create_grid(window_root(main_window), 4, 1, grd_bg);
+        grid_t *grid = create_grid(window_root(main_window), 1, 5, grd_bg);
         
-        if ((!lbl_caption) || (!btn_vterm) || (!btn_vdemo) ||
-            (!btn_vlaunch) || (!grid)) {
+        if ((!logo_canvas) || (!lbl_caption) || (!btn_vterm) ||
+            (!btn_vdemo) || (!btn_vlaunch) || (!grid)) {
                 window_close(main_window);
                 printf("Cannot create widgets.\n");
@@ -131 +150 @@
         sig_connect(&btn_vlaunch->clicked, NULL, on_vlaunch);
         
-        grid->add(grid, &lbl_caption->widget, 0, 0, 1, 1);
-        grid->add(grid, &btn_vterm->widget, 1, 0, 1, 1);
-        grid->add(grid, &btn_vdemo->widget, 2, 0, 1, 1);
-        grid->add(grid, &btn_vlaunch->widget, 3, 0, 1, 1);
+        grid->add(grid, &logo_canvas->widget, 0, 0, 1, 1);
+        grid->add(grid, &lbl_caption->widget, 0, 1, 1, 1);
+        grid->add(grid, &btn_vterm->widget, 0, 2, 1, 1);
+        grid->add(grid, &btn_vdemo->widget, 0, 3, 1, 1);
+        grid->add(grid, &btn_vlaunch->widget, 0, 4, 1, 1);
         
-        window_resize(main_window, 180, 130);
+        window_resize(main_window, 210, 130 + LOGO_HEIGHT);
         window_exec(main_window);
+        
         task_retval(0);
         async_manager();

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

@@ -125 +125 @@
         int j;
         size_t off;
-        kbd_event_t ev;
+        cons_event_t ev;
+        kbd_event_t *kev;
         
         clear_screen();
@@ -141 +142 @@
         while (1) {
                 console_flush(console);
-                if (!console_get_kbd_event(console, &ev))
+                if (!console_get_event(console, &ev))
                         exit(1);
                 
-                if (ev.type == KEY_RELEASE)
+                if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE)
                         continue;
                 
-                if (ev.key == KC_ENTER || ev.key == KC_NENTER)
+                kev = &ev.ev.key;
+                
+                if (kev->key == KC_ENTER || kev->key == KC_NENTER)
                         break;
                 
-                if (ev.key == KC_BACKSPACE) {
+                if (kev->key == KC_BACKSPACE) {
                         if (i > 0) {
                                 wchar_t uc;
@@ -166 +169 @@
                                 scores[NUMSPOTS - 1].hs_name[off] = '\0';
                         }
-                } else if (ev.c != '\0') {
+                } else if (kev->c != '\0') {
                         if (i < (MAXLOGNAME - 1)) {
-                                if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
+                                if (chr_encode(kev->c, scores[NUMSPOTS - 1].hs_name,
                                     &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
                                         ++i;

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

@@ -553 +553 @@
         
         while (c == 0) {
-                kbd_event_t event;
-                
-                if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
+                cons_event_t event;
+                
+                if (!console_get_event_timeout(console, &event, &timeleft)) {
                         timeleft = 0;
                         return -1;
                 }
                 
-                if (event.type == KEY_PRESS)
-                        c = event.c;
+                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
+                        c = event.ev.key.c;
         }
         

uspace/drv/char/ns8250/ns8250.c

@@ -160 +160 @@
         /** I/O registers **/
         ns8250_regs_t *regs;
-        /** Is there any client conntected to the device? */
+        /** Is there any client connected to the device? */
         bool client_connected;
         /** The irq assigned to this device. */
@@ -168 +168 @@
         /** The i/o port used to access the serial ports registers. */
         ioport8_t *port;
-        /** The buffer for incomming data. */
+        /** The buffer for incoming data. */
         cyclic_buffer_t input_buffer;
         /** The fibril mutex for synchronizing the access to the device. */
@@ -190 +190 @@
 }
 
-/** Find out if there is some incomming data available on the serial port.
+/** Find out if there is some incoming data available on the serial port.
  *
  * @param port          The base address of the serial port device's ports.

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

@@ -35 +35 @@
  */
 #include <errno.h>
+#include <io/cons_event.h>
 #include <ipc/console.h>
 #include <stdlib.h>
@@ -40 +41 @@
 
 #include <io/con_srv.h>
+
+static int console_ev_encode(cons_event_t *event, ipc_call_t *call)
+{
+        IPC_SET_ARG1(*call, event->type);
+
+        switch (event->type) {
+        case CEV_KEY:
+                IPC_SET_ARG2(*call, event->ev.key.type);
+                IPC_SET_ARG3(*call, event->ev.key.key);
+                IPC_SET_ARG4(*call, event->ev.key.mods);
+                IPC_SET_ARG5(*call, event->ev.key.c);
+                break;
+        case CEV_POS:
+                IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
+                IPC_SET_ARG3(*call, event->ev.pos.btn_num);
+                IPC_SET_ARG4(*call, event->ev.pos.hpos);
+                IPC_SET_ARG5(*call, event->ev.pos.vpos);
+                break;
+        default:
+                return EIO;
+        }
+
+        return EOK;
+}
 
 static void con_read_srv(con_srv_t *srv, ipc_callid_t callid,
@@ -273 +298 @@
 {
         int rc;
-        kbd_event_t event;
+        cons_event_t event;
+        ipc_call_t result;
 
         if (srv->srvs->ops->get_event == NULL) {
@@ -281 +307 @@
 
         rc = srv->srvs->ops->get_event(srv, &event);
-        async_answer_4(callid, rc, event.type, event.key, event.mods, event.c);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        rc = console_ev_encode(&event, &result);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
+            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
 }
 

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

@@ -154 +154 @@
 }
 
-bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
+static int console_ev_decode(ipc_call_t *call, cons_event_t *event)
+{
+        event->type = IPC_GET_ARG1(*call);
+
+        switch (event->type) {
+        case CEV_KEY:
+                event->ev.key.type = IPC_GET_ARG2(*call);
+                event->ev.key.key = IPC_GET_ARG3(*call);
+                event->ev.key.mods = IPC_GET_ARG4(*call);
+                event->ev.key.c = IPC_GET_ARG5(*call);
+                break;
+        case CEV_POS:
+                event->ev.pos.pos_id = IPC_GET_ARG2(*call) >> 16;
+                event->ev.pos.type = IPC_GET_ARG2(*call) & 0xffff;
+                event->ev.pos.btn_num = IPC_GET_ARG3(*call);
+                event->ev.pos.hpos = IPC_GET_ARG4(*call);
+                event->ev.pos.vpos = IPC_GET_ARG5(*call);
+                break;
+        default:
+                return EIO;
+        }
+
+        return EOK;
+}
+
+bool console_get_event(console_ctrl_t *ctrl, cons_event_t *event)
 {
         if (ctrl->input_aid == 0) {
-                sysarg_t type;
-                sysarg_t key;
-                sysarg_t mods;
-                sysarg_t c;
+                ipc_call_t result;
                 
                 async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
-                int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
+                aid_t aid = async_send_0(exch, CONSOLE_GET_EVENT, &result);
                 async_exchange_end(exch);
+                
+                sysarg_t rc;
+                async_wait_for(aid, &rc);
                 
                 if (rc != EOK) {
@@ -171 +196 @@
                 }
                 
-                event->type = type;
-                event->key = key;
-                event->mods = mods;
-                event->c = c;
+                rc = console_ev_decode(&result, event);
+                if (rc != EOK) {
+                        errno = rc;
+                        return false;
+                }
         } else {
                 sysarg_t retval;
@@ -186 +212 @@
                 }
                 
-                event->type = IPC_GET_ARG1(ctrl->input_call);
-                event->key = IPC_GET_ARG2(ctrl->input_call);
-                event->mods = IPC_GET_ARG3(ctrl->input_call);
-                event->c = IPC_GET_ARG4(ctrl->input_call);
+                int rc = console_ev_decode(&ctrl->input_call, event);
+                if (rc != EOK) {
+                        errno = rc;
+                        return false;
+                }
         }
         
@@ -195 +222 @@
 }
 
-bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
+bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
     suseconds_t *timeout)
 {
@@ -223 +250 @@
         }
         
-        event->type = IPC_GET_ARG1(ctrl->input_call);
-        event->key = IPC_GET_ARG2(ctrl->input_call);
-        event->mods = IPC_GET_ARG3(ctrl->input_call);
-        event->c = IPC_GET_ARG4(ctrl->input_call);
+        rc = console_ev_decode(&ctrl->input_call, event);
+        if (rc != EOK) {
+                errno = rc;
+                return false;
+        }
         
         /* Update timeout */

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

@@ -41 +41 @@
 #include <io/color.h>
 #include <io/concaps.h>
-#include <io/kbd_event.h>
+#include <io/cons_event.h>
 #include <io/pixel.h>
 #include <io/style.h>
@@ -82 +82 @@
         void (*set_rgb_color)(con_srv_t *, pixel_t, pixel_t);
         void (*set_cursor_visibility)(con_srv_t *, bool);
-        int (*get_event)(con_srv_t *, kbd_event_t *);
+        int (*get_event)(con_srv_t *, cons_event_t *);
 } con_ops_t;
 

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

@@ -39 +39 @@
 #include <io/concaps.h>
 #include <io/kbd_event.h>
+#include <io/cons_event.h>
 #include <io/keycode.h>
 #include <async.h>
@@ -82 +83 @@
 extern void console_cursor_visibility(console_ctrl_t *, bool);
 extern int console_get_color_cap(console_ctrl_t *, sysarg_t *);
-extern bool console_get_kbd_event(console_ctrl_t *, kbd_event_t *);
-extern bool console_get_kbd_event_timeout(console_ctrl_t *, kbd_event_t *,
+extern bool console_get_event(console_ctrl_t *, cons_event_t *);
+extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *,
     suseconds_t *);
 

uspace/lib/c/include/io/pos_event.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2012 Petr Koupy
+ * Copyright (c) 2013 Jiri Svoboda
  * All rights reserved.
  *
@@ -27 +28 @@
  */
 
-/** @addtogroup genarch
+/** @addtogroup libc
  * @{
  */
@@ -33 +34 @@
  */
 
-#ifndef KERN_LOGO_196X66_H_
-#define KERN_LOGO_196X66_H_
+#ifndef LIBC_IO_POS_EVENT_H_
+#define LIBC_IO_POS_EVENT_H_
 
-#define LOGO_WIDTH   196
-#define LOGO_HEIGHT  66
-#define LOGO_COLOR   0xffffff
+#include <sys/types.h>
 
-#include <typedefs.h>
+typedef enum {
+        POS_UPDATE,
+        POS_PRESS,
+        POS_RELEASE
+} pos_event_type_t;
 
-extern uint32_t fb_logo[LOGO_WIDTH * LOGO_HEIGHT];
+/** Positioning device event */
+typedef struct {
+        sysarg_t pos_id;
+        pos_event_type_t type;
+        sysarg_t btn_num;
+        sysarg_t hpos;
+        sysarg_t vpos;
+} pos_event_t;
 
 #endif

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

@@ -40 +40 @@
 #include <async.h>
 #include <loc.h>
-#include <io/console.h>
-
-typedef enum {
-        POS_UPDATE,
-        POS_PRESS,
-        POS_RELEASE
-} pos_event_type_t;
-
-typedef struct {
-        sysarg_t pos_id;
-        pos_event_type_t type;
-        sysarg_t btn_num;
-        sysarg_t hpos;
-        sysarg_t vpos;
-} pos_event_t;
+#include <io/kbd_event.h>
+#include <io/pos_event.h>
 
 typedef struct {

uspace/lib/clui/tinput.c

@@ -45 +45 @@
 #define LIN_TO_COL(ti, lpos) ((lpos) % ((ti)->con_cols))
 #define LIN_TO_ROW(ti, lpos) ((lpos) / ((ti)->con_cols))
+#define LIN_POS(ti, col, row) ((col) + (row) * (ti)->con_cols)
 
 /** Seek direction */
@@ -383 +384 @@
 }
 
+static void tinput_seek_scrpos(tinput_t *ti, int col, int line, bool shift_held)
+{
+        unsigned lpos;
+        tinput_pre_seek(ti, shift_held);
+
+        lpos = LIN_POS(ti, col, line);
+
+        if (lpos > ti->text_coord)
+                ti->pos = lpos -  ti->text_coord;
+        else
+                ti->pos = 0;
+        if (ti->pos > ti->nc)
+                ti->pos = ti->nc;
+
+        tinput_post_seek(ti, shift_held);
+}
+
 static void tinput_seek_max(tinput_t *ti, seek_dir_t dir, bool shift_held)
 {
@@ -787 +805 @@
 }
 
+/** Handle key press event. */
+static void tinput_key_press(tinput_t *ti, kbd_event_t *kev)
+{
+        if (kev->key == KC_LSHIFT)
+                ti->lshift_held = true;
+        if (kev->key == KC_RSHIFT)
+                ti->rshift_held = true;
+
+        if (((kev->mods & KM_CTRL) != 0) &&
+            ((kev->mods & (KM_ALT | KM_SHIFT)) == 0))
+                tinput_key_ctrl(ti, kev);
+        
+        if (((kev->mods & KM_SHIFT) != 0) &&
+            ((kev->mods & (KM_CTRL | KM_ALT)) == 0))
+                tinput_key_shift(ti, kev);
+        
+        if (((kev->mods & KM_CTRL) != 0) &&
+            ((kev->mods & KM_SHIFT) != 0) &&
+            ((kev->mods & KM_ALT) == 0))
+                tinput_key_ctrl_shift(ti, kev);
+        
+        if ((kev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0)
+                tinput_key_unmod(ti, kev);
+        
+        if (kev->c >= ' ') {
+                tinput_sel_delete(ti);
+                tinput_insert_char(ti, kev->c);
+        }
+}
+
+/** Handle key release event. */
+static void tinput_key_release(tinput_t *ti, kbd_event_t *kev)
+{
+        if (kev->key == KC_LSHIFT)
+                ti->lshift_held = false;
+        if (kev->key == KC_RSHIFT)
+                ti->rshift_held = false;
+}
+
+/** Position event */
+static void tinput_pos(tinput_t *ti, pos_event_t *ev)
+{
+        if (ev->type == POS_PRESS) {
+                tinput_seek_scrpos(ti, ev->hpos, ev->vpos,
+                    ti->lshift_held || ti->rshift_held);
+        }
+}
+
 /** Read in one line of input.
  *
@@ -816 +882 @@
                 console_flush(ti->console);
                 
-                kbd_event_t ev;
-                if (!console_get_kbd_event(ti->console, &ev))
+                cons_event_t ev;
+                if (!console_get_event(ti->console, &ev))
                         return EIO;
                 
-                if (ev.type != KEY_PRESS)
-                        continue;
-                
-                if (((ev.mods & KM_CTRL) != 0) &&
-                    ((ev.mods & (KM_ALT | KM_SHIFT)) == 0))
-                        tinput_key_ctrl(ti, &ev);
-                
-                if (((ev.mods & KM_SHIFT) != 0) &&
-                    ((ev.mods & (KM_CTRL | KM_ALT)) == 0))
-                        tinput_key_shift(ti, &ev);
-                
-                if (((ev.mods & KM_CTRL) != 0) &&
-                    ((ev.mods & KM_SHIFT) != 0) &&
-                    ((ev.mods & KM_ALT) == 0))
-                        tinput_key_ctrl_shift(ti, &ev);
-                
-                if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0)
-                        tinput_key_unmod(ti, &ev);
-                
-                if (ev.c >= ' ') {
-                        tinput_sel_delete(ti);
-                        tinput_insert_char(ti, ev.c);
+                switch (ev.type) {
+                case CEV_KEY:
+                        if (ev.ev.key.type == KEY_PRESS)
+                                tinput_key_press(ti, &ev.ev.key);
+                        else
+                                tinput_key_release(ti, &ev.ev.key);
+                        break;
+                case CEV_POS:
+                        tinput_pos(ti, &ev.ev.pos);
+                        break;
                 }
         }

uspace/lib/clui/tinput.h

@@ -146 +146 @@
         /** @c true if user requested to abort interactive loop */
         bool exit_clui;
+
+        /** @c true if left shift key is currently held */
+        bool lshift_held;
+
+        /** @c true if right shift key is currently held */
+        bool rshift_held;
 } tinput_t;
 

uspace/lib/gui/Makefile

@@ -35 +35 @@
 SOURCES = \
         button.c \
+        canvas.c \
         connection.c \
         grid.c \

uspace/lib/gui/grid.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2012 Petr Koupy
+ * Copyright (c) 2013 Martin Decky
  * All rights reserved.
  *
@@ -38 +39 @@
 #include <malloc.h>
 #include <surface.h>
-
 #include "window.h"
 #include "grid.h"
 
-static void paint_internal(widget_t *w)
-{
-        grid_t *grid = (grid_t *) w;
-
+typedef struct {
+        sysarg_t min;
+        sysarg_t max;
+        sysarg_t val;
+} constraints_t;
+
+static void paint_internal(widget_t *widget)
+{
+        grid_t *grid = (grid_t *) widget;
+        
         surface_t *surface = window_claim(grid->widget.window);
         if (!surface) {
                 window_yield(grid->widget.window);
-        }
-
-        for (sysarg_t y = w->vpos; y <  w->vpos + w->height; ++y) {
-                for (sysarg_t x = w->hpos; x < w->hpos + w->width; ++x) {
+                return;
+        }
+        
+        // FIXME: Replace with (accelerated) rectangle fill
+        for (sysarg_t y = widget->vpos; y < widget->vpos + widget->height; y++) {
+                for (sysarg_t x = widget->hpos; x < widget->hpos + widget->width; x++)
                         surface_put_pixel(surface, x, y, grid->background);
-                }
-        }
-
+        }
+        
         window_yield(grid->widget.window);
 }
 
-static widget_t **widget_at(grid_t *grid, size_t row, size_t col)
-{
-        if (row < grid->rows && col < grid->cols) {
+static grid_cell_t *grid_cell_at(grid_t *grid, size_t col, size_t row)
+{
+        if ((col < grid->cols) && (row < grid->rows))
                 return grid->layout + (row * grid->cols + col);
-        } else {
-                return NULL;
-        }
+        
+        return NULL;
+}
+
+static grid_cell_t *grid_coords_at(grid_t *grid, sysarg_t hpos, sysarg_t vpos)
+{
+        for (size_t c = 0; c < grid->cols; c++) {
+                for (size_t r = 0; r < grid->rows; r++) {
+                        grid_cell_t *cell = grid_cell_at(grid, c, r);
+                        if (cell) {
+                                widget_t *widget = cell->widget;
+                                
+                                if ((widget) && (hpos >= widget->hpos) &&
+                                    (vpos >= widget->vpos) &&
+                                    (hpos < widget->hpos + widget->width) &&
+                                    (vpos < widget->vpos + widget->height))
+                                        return cell;
+                        }
+                }
+        }
+        
+        return NULL;
 }
 
@@ -78 +104 @@
 {
         grid_t *grid = (grid_t *) widget;
-
+        
         deinit_grid(grid);
-
         free(grid);
 }
@@ -86 +111 @@
 static void grid_reconfigure(widget_t *widget)
 {
-        /* no-op */
+        /* No-op */
+}
+
+static void adjust_constraints(constraints_t *cons, size_t run,
+    sysarg_t dim_min, sysarg_t dim_max)
+{
+        assert(run > 0);
+        
+        sysarg_t dim_min_part = dim_min / run;
+        sysarg_t dim_min_rem = dim_min % run;
+        
+        sysarg_t dim_max_part = dim_max / run;
+        sysarg_t dim_max_rem = dim_max % run;
+        
+        for (size_t i = 0; i < run; i++) {
+                sysarg_t dim_min_cur = dim_min_part;
+                sysarg_t dim_max_cur = dim_max_part;
+                
+                if (i == run - 1) {
+                        dim_min_cur += dim_min_rem;
+                        dim_max_cur += dim_max_rem;
+                }
+                
+                /*
+                 * We want the strongest constraint
+                 * for the minimum.
+                 */
+                if (cons[i].min < dim_min_cur)
+                        cons[i].min = dim_min_cur;
+                
+                /*
+                 * The comparison is correct, we want
+                 * the weakest constraint for the
+                 * maximum.
+                 */
+                if (cons[i].max < dim_max_cur)
+                        cons[i].max = dim_max_cur;
+        }
+}
+
+static void solve_constraints(constraints_t *cons, size_t run, sysarg_t sum)
+{
+        /* Initial solution */
+        sysarg_t cur_sum = 0;
+        
+        for (size_t i = 0; i < run; i++) {
+                cons[i].val = cons[i].min;
+                cur_sum += cons[i].val;
+        }
+        
+        /* Iterative improvement */
+        while (cur_sum < sum) {
+                sysarg_t delta = (sum - cur_sum) / run;
+                if (delta == 0)
+                        break;
+                
+                cur_sum = 0;
+                
+                for (size_t i = 0; i < run; i++) {
+                        if (cons[i].val + delta < cons[i].max)
+                                cons[i].val += delta;
+                        
+                        cur_sum += cons[i].val;
+                }
+        }
 }
 
@@ -93 +182 @@
 {
         grid_t *grid = (grid_t *) widget;
-
+        
         widget_modify(widget, hpos, vpos, width, height);
         paint_internal(widget);
-
-        sysarg_t cell_width = width / grid->cols;
-        sysarg_t cell_height = height / grid->rows;
-
-        list_foreach(widget->children, link) {
-                widget_t *child = list_get_instance(link, widget_t, link);
-
-                sysarg_t widget_hpos = 0;
-                sysarg_t widget_vpos = 0;
-                sysarg_t widget_width = 0;
-                sysarg_t widget_height = 0;
-
-                size_t r = 0;
-                size_t c = 0;
-                for (r = 0; r < grid->rows; ++r) {
-                        bool found = false;
-                        for (c = 0; c < grid->cols; ++c) {
-                                widget_t **cell = widget_at(grid, r, c);
-                                if (cell && *cell == child) {
-                                        found = true;
-                                        break;
+        
+        /* Compute column widths */
+        constraints_t *widths =
+            (constraints_t *) calloc(grid->cols, sizeof(constraints_t));
+        if (widths) {
+                /* Constrain widths */
+                for (size_t c = 0; c < grid->cols; c++) {
+                        widths[c].min = 0;
+                        
+                        for (size_t r = 0; r < grid->rows; r++) {
+                                grid_cell_t *cell = grid_cell_at(grid, c, r);
+                                if (!cell)
+                                        continue;
+                                
+                                widget_t *widget = cell->widget;
+                                if (widget)
+                                        adjust_constraints(&widths[c], cell->cols,
+                                            widget->width_min, widget->width_max);
+                        }
+                }
+                
+                solve_constraints(widths, grid->cols, width);
+        }
+        
+        /* Compute row heights */
+        constraints_t *heights =
+            (constraints_t *) calloc(grid->rows, sizeof(constraints_t));
+        if (heights) {
+                /* Constrain heights */
+                for (size_t r = 0; r < grid->rows; r++) {
+                        heights[r].min = 0;
+                        
+                        for (size_t c = 0; c < grid->cols; c++) {
+                                grid_cell_t *cell = grid_cell_at(grid, c, r);
+                                if (!cell)
+                                        continue;
+                                
+                                widget_t *widget = cell->widget;
+                                if (widget) {
+                                        adjust_constraints(&heights[r], cell->rows,
+                                            widget->height_min, widget->height_max);
                                 }
                         }
-                        if (found) {
-                                break;
+                }
+                
+                solve_constraints(heights, grid->rows, height);
+        }
+        
+        /* Rearrange widgets */
+        if ((widths) && (heights)) {
+                sysarg_t cur_vpos = vpos;
+                
+                for (size_t r = 0; r < grid->rows; r++) {
+                        sysarg_t cur_hpos = hpos;
+                        
+                        for (size_t c = 0; c < grid->cols; c++) {
+                                grid_cell_t *cell = grid_cell_at(grid, c, r);
+                                if (!cell)
+                                        continue;
+                                
+                                widget_t *widget = cell->widget;
+                                if (widget) {
+                                        sysarg_t cur_width = 0;
+                                        sysarg_t cur_height = 0;
+                                        
+                                        for (size_t cd = 0; cd < cell->cols; cd++)
+                                                cur_width += widths[c + cd].val;
+                                        
+                                        for (size_t rd = 0; rd < cell->rows; rd++)
+                                                cur_height += heights[r + rd].val;
+                                        
+                                        if ((cur_width > 0) && (cur_height > 0)) {
+                                                sysarg_t wwidth = cur_width;
+                                                sysarg_t wheight = cur_height;
+                                                
+                                                /*
+                                                 * Make sure the widget is respects its
+                                                 * maximal constrains.
+                                                 */
+                                                
+                                                if ((widget->width_max > 0) &&
+                                                    (wwidth > widget->width_max))
+                                                        wwidth = widget->width_max;
+                                                
+                                                if ((widget->height_max > 0) &&
+                                                    (wheight > widget->height_max))
+                                                        wheight = widget->height_max;
+                                                
+                                                widget->rearrange(widget, cur_hpos, cur_vpos,
+                                                    wwidth, wheight);
+                                        }
+                                        
+                                        
+                                }
+                                
+                                cur_hpos += widths[c].val;
                         }
-                }
-
-                widget_hpos = cell_width * c + hpos;
-                widget_vpos = cell_height * r + vpos;
-
-                for (size_t _c = c; _c < grid->cols; ++_c) {
-                        widget_t **cell = widget_at(grid, r, _c);
-                        if (cell && *cell == child) {
-                                widget_width += cell_width;
-                        } else {
-                                break;
-                        }
-                }
-
-                for (size_t _r = r; _r < grid->rows; ++_r) {
-                        widget_t **cell = widget_at(grid, _r, c);
-                        if (cell && *cell == child) {
-                                widget_height += cell_height;
-                        } else {
-                                break;
-                        }
-                }
-
-                if (widget_width > 0 && widget_height > 0) {
-                        child->rearrange(child,
-                            widget_hpos, widget_vpos, widget_width, widget_height);
-                }
-        }
+                        
+                        cur_vpos += heights[r].val;
+                }
+        }
+        
+        if (widths)
+                free(widths);
+        
+        if (heights)
+                free(heights);
 }
 
@@ -155 +297 @@
 {
         paint_internal(widget);
+        
         list_foreach(widget->children, link) {
                 widget_t *child = list_get_instance(link, widget_t, link);
                 child->repaint(child);
         }
+        
         window_damage(widget->window);
 }
@@ -164 +308 @@
 static void grid_handle_keyboard_event(widget_t *widget, kbd_event_t event)
 {
-        /* no-op */
+        /* No-op */
 }
 
@@ -170 +314 @@
 {
         grid_t *grid = (grid_t *) widget;
-
-        if ((widget->height / grid->rows) == 0) {
-                return;
-        }
-        if ((widget->width / grid->cols) == 0) {
-                return;
-        }
-
-        sysarg_t row = (event.vpos - widget->vpos) / (widget->height / grid->rows);
-        sysarg_t col = (event.hpos - widget->hpos) / (widget->width / grid->cols);
-
-        widget_t **cell = widget_at(grid, row, col);
-        if (cell && *cell) {
-                (*cell)->handle_position_event(*cell, event);
-        }
-}
-
-static void grid_add(grid_t *grid, widget_t *widget,
-    size_t row, size_t col, size_t rows, size_t cols)
-{
-        assert(row + rows <= grid->rows);
-        assert(col + cols <= grid->cols);
-
+        
+        grid_cell_t *cell = grid_coords_at(grid, event.hpos, event.vpos);
+        if ((cell) && (cell->widget))
+                cell->widget->handle_position_event(cell->widget, event);
+}
+
+static bool grid_add(struct grid *grid, widget_t *widget, size_t col,
+    size_t row, size_t cols, size_t rows)
+{
+        if ((cols == 0) || (rows == 0) || (col + cols > grid->cols) ||
+            (row + rows > grid->rows))
+                return false;
+        
+        grid_cell_t *cell = grid_cell_at(grid, col, row);
+        if (!cell)
+                return false;
+        
+        /*
+         * Check whether the cell is not occupied by an
+         * extension of a different cell.
+         */
+        if ((!cell->widget) && (cell->cols > 0) && (cell->rows > 0))
+                return false;
+        
         widget->parent = (widget_t *) grid;
+        
         list_append(&widget->link, &grid->widget.children);
         widget->window = grid->widget.window;
-
-        for (size_t r = row; r < row + rows; ++r) {
-                for (size_t c = col; c < col + cols; ++c) {
-                        widget_t **cell = widget_at(grid, r, c);
-                        if (cell) {
-                                *cell = widget;
+        
+        /* Mark cells in layout */
+        for (size_t r = row; r < row + rows; r++) {
+                for (size_t c = col; c < col + cols; c++) {
+                        if ((r == row) && (c == col)) {
+                                cell->widget = widget;
+                                cell->cols = cols;
+                                cell->rows = rows;
+                        } else {
+                                grid_cell_t *extension = grid_cell_at(grid, c, r);
+                                if (extension) {
+                                        extension->widget = NULL;
+                                        extension->cols = 1;
+                                        extension->rows = 1;
+                                }
                         }
                 }
         }
-}
-
-bool init_grid(grid_t *grid,
-    widget_t *parent, size_t rows, size_t cols, pixel_t background)
-{
-        assert(rows > 0);
-        assert(cols > 0);
-
-        widget_t **layout = (widget_t **) malloc(rows * cols * sizeof(widget_t *));
-        if (!layout) {
+        
+        return true;
+}
+
+bool init_grid(grid_t *grid, widget_t *parent, size_t cols, size_t rows,
+    pixel_t background)
+{
+        if ((cols == 0) || (rows == 0))
                 return false;
-        }
-        memset(layout, 0, rows * cols * sizeof(widget_t *));
-
+        
+        grid->layout =
+            (grid_cell_t *) calloc(cols * rows, sizeof(grid_cell_t));
+        if (!grid->layout)
+                return false;
+        
+        memset(grid->layout, 0, cols * rows * sizeof(grid_cell_t));
+        
         widget_init(&grid->widget, parent);
-
+        
         grid->widget.destroy = grid_destroy;
         grid->widget.reconfigure = grid_reconfigure;
@@ -227 +385 @@
         grid->widget.handle_keyboard_event = grid_handle_keyboard_event;
         grid->widget.handle_position_event = grid_handle_position_event;
-
+        
         grid->add = grid_add;
         grid->background = background;
+        grid->cols = cols;
         grid->rows = rows;
-        grid->cols = cols;
-        grid->layout = layout;
-
+        
         return true;
 }
 
-grid_t *create_grid(widget_t *parent, size_t rows, size_t cols, pixel_t background)
+grid_t *create_grid(widget_t *parent, size_t cols, size_t rows, pixel_t background)
 {
         grid_t *grid = (grid_t *) malloc(sizeof(grid_t));
-        if (!grid) {
+        if (!grid)
                 return NULL;
-        }
-
-        if (init_grid(grid, parent, rows, cols, background)) {
+        
+        if (init_grid(grid, parent, cols, rows, background))
                 return grid;
-        } else {
-                free(grid);
-                return NULL;
-        }
+        
+        free(grid);
+        return NULL;
 }
 

uspace/lib/gui/grid.h

@@ -39 +39 @@
 #include <sys/types.h>
 #include <io/pixel.h>
-
 #include "widget.h"
 
-struct grid;
-typedef struct grid grid_t;
+typedef struct {
+        widget_t *widget;
+        size_t cols;
+        size_t rows;
+} grid_cell_t;
 
 typedef struct grid {
         widget_t widget;
         pixel_t background;
+        size_t cols;
         size_t rows;
-        size_t cols;
-        widget_t **layout;
-        void (*add)(grid_t *, widget_t *, size_t, size_t, size_t, size_t);
+        grid_cell_t *layout;
+        bool (*add)(struct grid *, widget_t *, size_t, size_t, size_t, size_t);
 } grid_t;
 

uspace/lib/gui/terminal.c

@@ -77 +77 @@
 static void term_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
 static void term_set_cursor_visibility(con_srv_t *, bool);
-static int term_get_event(con_srv_t *, kbd_event_t *);
+static int term_get_event(con_srv_t *, cons_event_t *);
 
 static con_ops_t con_ops = {
@@ -420 +420 @@
                 if (pos < size) {
                         link_t *link = prodcons_consume(&term->input_pc);
-                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
+                        cons_event_t *event = list_get_instance(link, cons_event_t, link);
                         
                         /* Accept key presses of printable chars only. */
-                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
+                        if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
+                            event->ev.key.c != 0) {
                                 wchar_t tmp[2] = {
-                                        event->c,
+                                        event->ev.key.c,
                                         0
                                 };
@@ -579 +580 @@
 }
 
-static int term_get_event(con_srv_t *srv, kbd_event_t *event)
+static int term_get_event(con_srv_t *srv, cons_event_t *event)
 {
         terminal_t *term = srv_to_terminal(srv);
         link_t *link = prodcons_consume(&term->input_pc);
-        kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
-        
-        *event = *kevent;
-        free(kevent);
+        cons_event_t *ev = list_get_instance(link, cons_event_t, link);
+        
+        *event = *ev;
+        free(ev);
         return EOK;
 }
@@ -634 +635 @@
 }
 
+static void terminal_queue_cons_event(terminal_t *term, cons_event_t *ev)
+{
+        /* Got key press/release event */
+        cons_event_t *event =
+            (cons_event_t *) malloc(sizeof(cons_event_t));
+        if (event == NULL)
+                return;
+        
+        *event = *ev;
+        link_initialize(&event->link);
+        
+        prodcons_produce(&term->input_pc, &event->link);
+}
+
+/* Got key press/release event */
 static void terminal_handle_keyboard_event(widget_t *widget,
     kbd_event_t kbd_event)
 {
         terminal_t *term = (terminal_t *) widget;
-        
-        /* Got key press/release event */
-        kbd_event_t *event =
-            (kbd_event_t *) malloc(sizeof(kbd_event_t));
-        if (event == NULL)
-                return;
-        
-        link_initialize(&event->link);
-        event->type = kbd_event.type;
-        event->key = kbd_event.key;
-        event->mods = kbd_event.mods;
-        event->c = kbd_event.c;
-        
-        prodcons_produce(&term->input_pc, &event->link);
-}
-
-static void terminal_handle_position_event(widget_t *widget, pos_event_t event)
-{
-        /*
-         * Mouse events are ignored so far.
-         * There is no consumer for it.
-         */
+        cons_event_t event;
+        
+        event.type = CEV_KEY;
+        event.ev.key = kbd_event;
+        
+        terminal_queue_cons_event(term, &event);
+}
+
+static void terminal_handle_position_event(widget_t *widget, pos_event_t pos_event)
+{
+        cons_event_t event;
+        terminal_t *term = (terminal_t *) widget;
+        sysarg_t sx = term->widget.hpos;
+        sysarg_t sy = term->widget.vpos;
+
+        if (pos_event.type == POS_PRESS) {
+                event.type = CEV_POS;
+                event.ev.pos.type = pos_event.type;
+                event.ev.pos.pos_id = pos_event.pos_id;
+                event.ev.pos.btn_num = pos_event.btn_num;
+
+                event.ev.pos.hpos = (pos_event.hpos - sx) / FONT_WIDTH;
+                event.ev.pos.vpos = (pos_event.vpos - sy) / FONT_SCANLINES;
+                terminal_queue_cons_event(term, &event);
+        }
 }
 

uspace/lib/gui/window.c

@@ -424 +424 @@
 
         while (!list_empty(&win->events.list)) {
-                list_remove(list_first(&win->events.list));
+                window_event_t *event = (window_event_t *) list_first(&win->events.list);
+                list_remove(&event->link);
+                free(event);
         }
 

uspace/srv/hid/compositor/Makefile

@@ -38 +38 @@
 
 IMAGES = \
-        gfx/helenos.tga \
         gfx/nameic.tga
 

uspace/srv/hid/compositor/compositor.c

@@ -90 +90 @@
 typedef struct {
         link_t link;
+        atomic_t ref_cnt;
         service_id_t in_dsid;
         service_id_t out_dsid;
@@ -138 +139 @@
 } viewport_t;
 
+static desktop_rect_t viewport_bound_rect;
 static FIBRIL_MUTEX_INITIALIZE(viewport_list_mtx);
 static LIST_INITIALIZE(viewport_list);
@@ -215 +217 @@
 
         link_initialize(&win->link);
+        atomic_set(&win->ref_cnt, 0);
         prodcons_initialize(&win->queue);
         transform_identity(&win->transform);
@@ -232 +235 @@
 static void window_destroy(window_t *win)
 {
-        if (win) {
+        if (win && atomic_get(&win->ref_cnt) == 0) {
+                while (!list_empty(&win->queue.list)) {
+                        window_event_t *event = (window_event_t *) list_first(&win->queue.list);
+                        list_remove(&event->link);
+                        free(event);
+                }
+
                 if (win->surface) {
                         surface_destroy(win->surface);
@@ -310 +319 @@
 }
 
+static void comp_restrict_pointers(void)
+{
+        fibril_mutex_lock(&viewport_list_mtx);
+
+        sysarg_t x_res = coord_origin;
+        sysarg_t y_res = coord_origin;
+        sysarg_t w_res = 0;
+        sysarg_t h_res = 0;
+
+        if (!list_empty(&viewport_list)) {
+                viewport_t *vp = (viewport_t *) list_first(&viewport_list);
+                x_res = vp->pos.x;
+                y_res = vp->pos.y;
+                surface_get_resolution(vp->surface, &w_res, &h_res);
+        }
+
+        list_foreach(viewport_list, link) {
+                viewport_t *vp = list_get_instance(link, viewport_t, link);
+                sysarg_t w_vp, h_vp;
+                surface_get_resolution(vp->surface, &w_vp, &h_vp);
+                rectangle_union(
+                    x_res, y_res, w_res, h_res,
+                    vp->pos.x, vp->pos.y, w_vp, h_vp,
+                    &x_res, &y_res, &w_res, &h_res);
+        }
+
+        viewport_bound_rect.x = x_res;
+        viewport_bound_rect.y = y_res;
+        viewport_bound_rect.w = w_res;
+        viewport_bound_rect.h = h_res;
+
+        fibril_mutex_unlock(&viewport_list_mtx);
+
+        fibril_mutex_lock(&pointer_list_mtx);
+
+        list_foreach(pointer_list, link) {
+                pointer_t *ptr = list_get_instance(link, pointer_t, link);
+                ptr->pos.x = ptr->pos.x > viewport_bound_rect.x ? ptr->pos.x : viewport_bound_rect.x;
+                ptr->pos.y = ptr->pos.y > viewport_bound_rect.y ? ptr->pos.y : viewport_bound_rect.y;
+                ptr->pos.x = ptr->pos.x < viewport_bound_rect.x + viewport_bound_rect.w ?
+                    ptr->pos.x : viewport_bound_rect.x + viewport_bound_rect.w;
+                ptr->pos.y = ptr->pos.y < viewport_bound_rect.y + viewport_bound_rect.h ?
+                    ptr->pos.y : viewport_bound_rect.y + viewport_bound_rect.h;
+        }
+
+        fibril_mutex_unlock(&pointer_list_mtx);
+}
+
 static void comp_damage(sysarg_t x_dmg_glob, sysarg_t y_dmg_glob,
     sysarg_t w_dmg_glob, sysarg_t h_dmg_glob)
@@ -695 +752 @@
         }
 
+        loc_service_unregister(win->in_dsid);
+        loc_service_unregister(win->out_dsid);
+
+        /* In case the client was killed, input fibril of the window might be
+         * still blocked on the condition within comp_window_get_event. */
+        window_event_t *event_dummy = (window_event_t *) malloc(sizeof(window_event_t));
+        if (event_dummy) {
+                link_initialize(&event_dummy->link);
+                prodcons_produce(&win->queue, &event_dummy->link);
+        }
+
         /* Calculate damage. */
         sysarg_t x = 0;
@@ -706 +774 @@
         }
 
-        /* Release window resources. */
-        loc_service_unregister(win->in_dsid);
-        loc_service_unregister(win->out_dsid);
-        while (!list_empty(&win->queue.list)) {
-                list_remove(list_first(&win->queue.list));
-        }
-        window_destroy(win);
-
         comp_damage(x, y, width, height);
 
@@ -813 +873 @@
 
         if (win) {
+                atomic_inc(&win->ref_cnt);
                 async_answer_0(iid, EOK);
         } else {
@@ -825 +886 @@
 
                         if (!IPC_GET_IMETHOD(call)) {
-                                async_answer_0(callid, EINVAL);
+                                async_answer_0(callid, EOK);
+                                atomic_dec(&win->ref_cnt);
+                                window_destroy(win);
                                 return;
                         }
@@ -842 +905 @@
 
                         if (!IPC_GET_IMETHOD(call)) {
-                                async_answer_0(callid, EINVAL);
+                                comp_window_close(win, callid, &call);
+                                atomic_dec(&win->ref_cnt);
+                                window_destroy(win);
                                 return;
                         }
@@ -857 +922 @@
                                 break;
                         case WINDOW_CLOSE:
-                                comp_window_close(win, callid, &call);
+                                /* Postpone the closing until the phone is hung up to cover
+                                 * the case when the client is killed abruptly. */
+                                async_answer_0(callid, EOK);
                                 break;
                         case WINDOW_CLOSE_REQUEST:
@@ -911 +978 @@
         async_answer_0(iid, EOK);
 
+        comp_restrict_pointers();
         comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
 }
@@ -956 +1024 @@
                 fibril_mutex_unlock(&viewport_list_mtx);
                 async_answer_0(iid, EOK);
+
+                comp_restrict_pointers();
+                comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
         }
 }
@@ -1391 +1462 @@
         surface_get_resolution(pointer->cursor.states[pointer->state], 
              &cursor_width, &cursor_height);
+        if (pointer->pos.x + dx < viewport_bound_rect.x) {
+                dx = -1 * (pointer->pos.x - viewport_bound_rect.x);
+        }
+        if (pointer->pos.y + dy < viewport_bound_rect.y) {
+                dy = -1 * (pointer->pos.y - viewport_bound_rect.y);
+        }
+        if (pointer->pos.x + dx > viewport_bound_rect.x + viewport_bound_rect.w) {
+                dx = (viewport_bound_rect.x + viewport_bound_rect.w - pointer->pos.x);
+        }
+        if (pointer->pos.y + dy > viewport_bound_rect.y + viewport_bound_rect.h) {
+                dy = (viewport_bound_rect.y + viewport_bound_rect.h - pointer->pos.y);
+        }
         pointer->pos.x += dx;
         pointer->pos.y += dy;
@@ -1910 +1993 @@
                         fibril_mutex_unlock(&viewport_list_mtx);
 
+                        comp_restrict_pointers();
                         comp_damage(x, y, width, height);
                 } else {
@@ -1962 +2046 @@
                 }
                 list_prepend(&blue_win->link, &window_list);
-
-                window_t *helenos_win = window_create(0, 0);
-                helenos_win->surface = decode_tga((void *) helenos_tga, helenos_tga_size, 0);
-                list_prepend(&helenos_win->link, &window_list);
-
+                
                 window_t *nameic_win = window_create(0, 0);
                 nameic_win->surface = decode_tga((void *) nameic_tga, nameic_tga_size, 0);
@@ -2126 +2206 @@
                 return -1;
         }
-        
+
+        comp_restrict_pointers();
         comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
         

uspace/srv/hid/console/console.c

@@ -129 +129 @@
 static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
 static void cons_set_cursor_visibility(con_srv_t *, bool);
-static int cons_get_event(con_srv_t *, kbd_event_t *);
+static int cons_get_event(con_srv_t *, cons_event_t *);
 
 static con_ops_t con_ops = {
@@ -490 +490 @@
 }
 
-static int cons_get_event(con_srv_t *srv, kbd_event_t *event)
+static int cons_get_event(con_srv_t *srv, cons_event_t *event)
 {
         console_t *cons = srv_to_console(srv);
@@ -496 +496 @@
         kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
         
-        *event = *kevent;
+        event->type = CEV_KEY;
+        event->ev.key = *kevent;
         free(kevent);
         return EOK;

uspace/srv/hid/remcons/remcons.c

@@ -80 +80 @@
 static int remcons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
 static int remcons_get_color_cap(con_srv_t *, console_caps_t *);
-static int remcons_get_event(con_srv_t *, kbd_event_t *);
+static int remcons_get_event(con_srv_t *, cons_event_t *);
 
 static con_ops_t con_ops = {
@@ -185 +185 @@
 }
 
-static int remcons_get_event(con_srv_t *srv, kbd_event_t *event)
-{
-        telnet_user_t *user = srv_to_user(srv);
+static int remcons_get_event(con_srv_t *srv, cons_event_t *event)
+{
+        telnet_user_t *user = srv_to_user(srv);
+        kbd_event_t kevent;
         int rc;
 
-        rc = telnet_user_get_next_keyboard_event(user, event);
+        rc = telnet_user_get_next_keyboard_event(user, &kevent);
         if (rc != EOK) {
                 /* XXX What? */
@@ -196 +197 @@
                 return EOK;
         }
+
+        event->type = CEV_KEY;
+        event->ev.key = kevent;
 
         return EOK;

uspace/srv/net/ethip/ethip.c

@@ -221 +221 @@
         case ETYPE_IP:
                 log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
-                sdu.lsrc.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1;
-                sdu.ldest.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 4;
+                sdu.lsrc.ipv4 = 0;
+                sdu.ldest.ipv4 = 0;
                 sdu.data = frame.data;
                 sdu.size = frame.size;

uspace/srv/ns/task.c

@@ -208 +208 @@
         sysarg_t retval;
         task_exit_t texit;
+        bool remove = false;
         
         ht_link_t *link = hash_table_find(&task_hash_table, &id);
@@ -235 +236 @@
         }
         
-        hash_table_remove_item(&task_hash_table, link);
+        remove = true;
         retval = EOK;
         
@@ -243 +244 @@
                 ipc_answer_2(callid, retval, texit, ht->retval);
         }
+        if (remove)
+                hash_table_remove_item(&task_hash_table, link);
 }