Changes in / [ce60be1:69c1995] in mainline

Files:

• kernel/arch/amd64/src/fpu_context.c (modified) (1 diff)
• kernel/arch/ia32/src/fpu_context.c (modified) (3 diffs)
• uspace/app/vdemo/vdemo.c (modified) (1 diff)
• uspace/app/vlaunch/vlaunch.c (modified) (1 diff)
• uspace/app/vterm/vterm.c (modified) (1 diff)
• uspace/drv/fb/kfb/port.c (modified) (1 diff)
• uspace/lib/c/generic/io/window.c (modified) (1 diff)
• uspace/lib/c/generic/stdlib.c (modified) (1 diff)
• uspace/lib/c/include/io/pixel.h (modified) (1 diff)
• uspace/lib/c/include/io/pixelmap.h (modified) (1 diff)
• uspace/lib/c/include/io/window.h (modified) (2 diffs)
• uspace/lib/draw/drawctx.c (modified) (1 diff)
• uspace/lib/draw/source.c (modified) (1 diff)
• uspace/lib/draw/source.h (modified) (1 diff)
• uspace/lib/draw/surface.c (modified) (2 diffs)
• uspace/lib/draw/surface.h (modified) (1 diff)
• uspace/lib/gui/terminal.c (modified) (1 diff)
• uspace/lib/gui/window.c (modified) (8 diffs)
• uspace/lib/gui/window.h (modified) (2 diffs)
• uspace/lib/softrend/filter.c (modified) (1 diff)
• uspace/lib/softrend/transform.c (modified) (1 diff)
• uspace/lib/softrend/transform.h (modified) (2 diffs)
• uspace/srv/hid/compositor/compositor.c (modified) (44 diffs)
• uspace/srv/hid/compositor/compositor.h (modified) (1 diff)

kernel/arch/amd64/src/fpu_context.c

@@ -57 +57 @@
 {
         /* TODO: Zero all SSE, MMX etc. registers */
+        /* Default value of SCR register is 0x1f80,
+         * it masks all FPU exceptions*/
         asm volatile (
                 "fninit\n"

kernel/arch/ia32/src/fpu_context.c

@@ -37 +37 @@
 #include <arch.h>
 #include <cpu.h>
+
+
+/** x87 FPU scr values (P3+ MMX2) */
+enum {
+        X87_FLUSH_ZERO_FLAG = (1 << 15),
+        X87_ROUND_CONTROL_MASK = (0x3 << 13),
+        x87_ROUND_TO_NEAREST_EVEN = (0x0 << 13),
+        X87_ROUND_DOWN_TO_NEG_INF = (0x1 << 13),
+        X87_ROUND_UP_TO_POS_INF = (0x2 << 13),
+        X87_ROUND_TO_ZERO = (0x3 << 13),
+        X87_PRECISION_MASK = (1 << 12),
+        X87_UNDERFLOW_MASK = (1 << 11),
+        X87_OVERFLOW_MASK = (1 << 10),
+        X87_ZERO_DIV_MASK = (1 << 9),
+        X87_DENORMAL_OP_MASK = (1 << 8),
+        X87_INVALID_OP_MASK = (1 << 7),
+        X87_DENOM_ZERO_FLAG = (1 << 6),
+        X87_PRECISION_EXC_FLAG = (1 << 5),
+        X87_UNDERFLOW_EXC_FLAG = (1 << 4),
+        X87_OVERFLOW_EXC_FLAG = (1 << 3),
+        X87_ZERO_DIV_EXC_FLAG = (1 << 2),
+        X87_DENORMAL_EXC_FLAG = (1 << 1),
+        X87_INVALID_OP_EXC_FLAG = (1 << 0),
+
+        X87_ALL_MASK = X87_PRECISION_MASK | X87_UNDERFLOW_MASK | X87_OVERFLOW_MASK | X87_ZERO_DIV_MASK | X87_DENORMAL_OP_MASK | X87_INVALID_OP_MASK,
+};
+
 
 typedef void (*fpu_context_function)(fpu_context_t *fctx);
@@ -98 +125 @@
 }
 
+/** Initialize x87 FPU. Mask all exceptions. */
 void fpu_init()
 {
@@ -111 +139 @@
                 "ldmxcsr %[help0]\n"
                 : [help0] "+m" (help0), [help1] "+r" (help1)
-                : [magic] "i" (0x1f80)
+                : [magic] "i" (X87_ALL_MASK)
         );
 }

uspace/app/vdemo/vdemo.c

@@ -110 +110 @@
 {
         if (argc >= 2) {
-                window_t *main_window = window_open(argv[1], true, true, "vdemo");
+                window_t *main_window = window_open(argv[1], true, true, "vdemo", 0, 0);
                 if (!main_window) {
                         printf("Cannot open main window.\n");

uspace/app/vlaunch/vlaunch.c

@@ -98 +98 @@
         
         winreg = argv[1];
-        window_t *main_window = window_open(argv[1], true, true, "vlaunch");
+        window_t *main_window = window_open(argv[1], true, true, "vlaunch", 0, 0);
         if (!main_window) {
                 printf("Cannot open main window.\n");

uspace/app/vterm/vterm.c

@@ -49 +49 @@
         }
         
-        window_t *main_window = window_open(argv[1], true, true, "vterm");
+        window_t *main_window = window_open(argv[1], true, true, "vterm", 0, 0);
         if (!main_window) {
                 printf("%s: Cannot open main window.\n", NAME);

uspace/drv/fb/kfb/port.c

@@ -163 +163 @@
                 /* Faster damage routine ignoring offsets. */
                 for (sysarg_t y = y0; y < height + y0; ++y) {
+                        pixel_t *pixel = pixelmap_pixel_at(map, x0, y);
                         for (sysarg_t x = x0; x < width + x0; ++x) {
-                                kfb.pixel2visual(kfb.addr + FB_POS(x, y),
-                                    *pixelmap_pixel_at(map, x, y));
+                                kfb.pixel2visual(kfb.addr + FB_POS(x, y), *pixel++);
                         }
                 }

uspace/lib/c/generic/io/window.c

@@ -40 +40 @@
 #include <stdio.h>
 
-int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out)
+int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out, 
+    sysarg_t x_offset, sysarg_t y_offset)
 {
         async_exch_t *exch = async_exchange_begin(sess);
-        int ret = async_req_0_2(exch, WINDOW_REGISTER, in, out);
+        int ret = async_req_2_2(exch, WINDOW_REGISTER, x_offset, y_offset, in, out);
         async_exchange_end(exch);
 

uspace/lib/c/generic/stdlib.c

@@ -39 +39 @@
 long int random(void)
 {
-        return glbl_seed = ((1366*glbl_seed + 150889) % RAND_MAX);
+        return glbl_seed = ((1366 * glbl_seed + 150889) % RAND_MAX);
 }
 
 void srandom(unsigned int seed)
 {
-        glbl_seed = seed;
+        glbl_seed = seed % RAND_MAX;
 }
 

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

@@ -42 +42 @@
         ((channel) >> (8 - (bits)))
 
+#define INVERT(pixel) ((pixel) ^ 0x00ffffff)
+
 #define ALPHA(pixel)  ((pixel) >> 24)
 #define RED(pixel)    (((pixel) & 0x00ff0000) >> 16)

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

@@ -52 +52 @@
     sysarg_t y)
 {
-        size_t offset = y * pixelmap->width + x;
-        pixel_t *pixel = pixelmap->data + offset;
-        return pixel;
+        if (x < pixelmap->width && y < pixelmap->height) {
+                size_t offset = y * pixelmap->width + x;
+                pixel_t *pixel = pixelmap->data + offset;
+                return pixel;
+        } else {
+                return NULL;
+        }
 }
 

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

@@ -71 +71 @@
         ET_POSITION_EVENT,
         ET_SIGNAL_EVENT,
+        ET_WINDOW_FOCUS,
+        ET_WINDOW_UNFOCUS,
         ET_WINDOW_RESIZE,
         ET_WINDOW_REFRESH,
@@ -100 +102 @@
 } window_grab_flags_t;
 
-extern int win_register(async_sess_t *, service_id_t *, service_id_t *);
+extern int win_register(async_sess_t *, service_id_t *, service_id_t *, sysarg_t, sysarg_t);
 
 extern int win_get_event(async_sess_t *, window_event_t *);

uspace/lib/draw/drawctx.c

@@ -129 +129 @@
         }
 
-        bool clipped = false;
-        bool masked = false;
-
-        for (sysarg_t _y = y; _y < y + height; ++_y) {
-                for (sysarg_t _x = x; _x < x + width; ++_x) {
-                        if (context->shall_clip) {
-                                clipped = _x < context->clip_x && _x >= context->clip_width
-                                    && _y < context->clip_y && _y >= context->clip_height;
-                        }
-                        
-                        if (context->mask) {
-                                pixel_t p = surface_get_pixel(context->mask, _x, _y);
-                                masked = p > 0 ? false : true;
-                        }
-
-                        if (!clipped && !masked) {
-                                pixel_t p_src = source_determine_pixel(context->source, _x, _y);
-                                pixel_t p_dst = surface_get_pixel(context->surface, _x, _y);
-                                pixel_t p_res = context->compose(p_src, p_dst);
-                                surface_put_pixel(context->surface, _x, _y, p_res);
+        bool transfer_fast = source_is_fast(context->source)
+            && (context->shall_clip == false)
+            && (context->mask == NULL)
+            && (context->compose == compose_src || context->compose == compose_over);
+
+        if (transfer_fast) {
+
+                for (sysarg_t _y = y; _y < y + height; ++_y) {
+                        pixel_t *src = source_direct_access(context->source, x, _y);
+                        pixel_t *dst = pixelmap_pixel_at(surface_pixmap_access(context->surface), x, _y);
+                        if (src && dst) {
+                                sysarg_t count = width;
+                                while (count-- != 0) {
+                                        *dst++ = *src++;
+                                }
                         }
                 }
+                surface_add_damaged_region(context->surface, x, y, width, height);
+
+        } else {
+
+                bool clipped = false;
+                bool masked = false;
+                for (sysarg_t _y = y; _y < y + height; ++_y) {
+                        for (sysarg_t _x = x; _x < x + width; ++_x) {
+                                if (context->shall_clip) {
+                                        clipped = _x < context->clip_x && _x >= context->clip_width
+                                            && _y < context->clip_y && _y >= context->clip_height;
+                                }
+
+                                if (context->mask) {
+                                        pixel_t p = surface_get_pixel(context->mask, _x, _y);
+                                        masked = p > 0 ? false : true;
+                                }
+
+                                if (!clipped && !masked) {
+                                        pixel_t p_src = source_determine_pixel(context->source, _x, _y);
+                                        pixel_t p_dst = surface_get_pixel(context->surface, _x, _y);
+                                        pixel_t p_res = context->compose(p_src, p_dst);
+                                        surface_put_pixel(context->surface, _x, _y, p_res);
+                                }
+                        }
+                }
+
         }
 }

uspace/lib/draw/source.c

@@ -90 +90 @@
 }
 
+bool source_is_fast(source_t *source)
+{
+        return (source->mask == NULL)
+            && (source->alpha == (pixel_t) PIXEL(255, 0, 0, 0))
+            && (source->texture != NULL)
+            && (source->texture_tile == false)
+            && transform_is_fast(&source->transform);
+}
+
+pixel_t *source_direct_access(source_t *source, double x, double y)
+{
+        assert(source_is_fast(source));
+
+        long _x = (long) (x + source->transform.m[0][2]);
+        long _y = (long) (y + source->transform.m[1][2]);
+
+        return pixelmap_pixel_at(
+            surface_pixmap_access(source->texture), (sysarg_t) _x, (sysarg_t) _y);
+}
+
 pixel_t source_determine_pixel(source_t *source, double x, double y)
 {

uspace/lib/draw/source.h

@@ -71 +71 @@
 extern void source_set_mask(source_t *, surface_t *, bool);
 
+extern bool source_is_fast(source_t *);
+extern pixel_t *source_direct_access(source_t *, double, double);
 extern pixel_t source_determine_pixel(source_t *, double, double);
 

uspace/lib/draw/surface.c

@@ -143 +143 @@
 }
 
+void surface_add_damaged_region(surface_t *surface, surface_coord_t x, surface_coord_t y,
+    surface_coord_t width, surface_coord_t height)
+{
+        surface->dirty_x_lo = surface->dirty_x_lo > x ? x : surface->dirty_x_lo;
+        surface->dirty_y_lo = surface->dirty_y_lo > y ? y : surface->dirty_y_lo;
+
+        surface_coord_t x_hi = x + width - 1;
+        surface_coord_t y_hi = y + height - 1;
+
+        surface->dirty_x_hi = surface->dirty_x_hi < x_hi ? x_hi : surface->dirty_x_hi;
+        surface->dirty_y_hi = surface->dirty_y_hi < y_hi ? y_hi : surface->dirty_y_hi;
+}
+
 void surface_reset_damaged_region(surface_t *surface)
 {
@@ -158 +171 @@
         surface->dirty_y_hi = surface->dirty_y_hi < y ? y : surface->dirty_y_hi;
 
-        if (x < surface->pixmap.width && y < surface->pixmap.height) {
-                pixelmap_put_pixel(&surface->pixmap, x, y, pixel);
-        }
+        pixelmap_put_pixel(&surface->pixmap, x, y, pixel);
 }
 
 pixel_t surface_get_pixel(surface_t *surface, surface_coord_t x, surface_coord_t y)
 {
-        if (x < surface->pixmap.width && y < surface->pixmap.height) {
-                return pixelmap_get_pixel(&surface->pixmap, x, y);
-        } else {
-                return 0;
-        }
+        return pixelmap_get_pixel(&surface->pixmap, x, y);
 }
 

uspace/lib/draw/surface.h

@@ -61 +61 @@
 extern void surface_get_damaged_region(surface_t *, surface_coord_t *, surface_coord_t *,
     surface_coord_t *, surface_coord_t *);
+extern void surface_add_damaged_region(surface_t *, surface_coord_t , surface_coord_t ,
+    surface_coord_t , surface_coord_t );
 extern void surface_reset_damaged_region(surface_t *);
 

uspace/lib/gui/terminal.c

@@ -196 +196 @@
         uint16_t glyph = fb_font_glyph(field->ch);
         
-        // FIXME: This font drawing routine is shamelessly
-        //        suboptimal. It should be optimized for
-        //        aligned memory transfers, etc.
-        
         for (unsigned int y = 0; y < FONT_SCANLINES; y++) {
-                for (unsigned int x = 0; x < FONT_WIDTH; x++) {
-                        pixel_t pixel =
-                            (fb_font[glyph][y] & (1 << (7 - x))) ? fgcolor : bgcolor;
-                        surface_put_pixel(surface, bx + x, by + y, pixel);
+                pixel_t *dst = pixelmap_pixel_at(
+                    surface_pixmap_access(surface), bx, by + y);
+                pixel_t *dst_max = pixelmap_pixel_at(
+                    surface_pixmap_access(surface), bx + FONT_WIDTH - 1, by + y);
+                if (!dst || !dst_max) continue;
+                int count = FONT_WIDTH;
+                while (count-- != 0) {
+                        *dst++ = (fb_font[glyph][y] & (1 << count)) ? fgcolor : bgcolor;
                 }
         }
+        surface_add_damaged_region(surface, bx, by, FONT_WIDTH, FONT_SCANLINES);
 }
 

uspace/lib/gui/window.c

@@ -66 +66 @@
 
 static pixel_t border_color = PIXEL(255, 0, 0, 0);
-static pixel_t header_bgcolor = PIXEL(255, 25, 25, 112);
-static pixel_t header_fgcolor = PIXEL(255, 255, 255, 255);
+static pixel_t header_bg_focus_color = PIXEL(255, 25, 25, 112);
+static pixel_t header_fg_focus_color = PIXEL(255, 255, 255, 255);
+static pixel_t header_bg_unfocus_color = PIXEL(255, 70, 130, 180);
+static pixel_t header_fg_unfocus_color = PIXEL(255, 255, 255, 255);
 
 static void paint_internal(widget_t *w)
@@ -94 +96 @@
             w->vpos + w->height - border_thickness, w->width, border_thickness);
 
-        source_set_color(&source, header_bgcolor);
+        source_set_color(&source, 
+            w->window->is_focused ? header_bg_focus_color : header_bg_unfocus_color);
         drawctx_transfer(&drawctx,
             w->hpos + border_thickness, w->vpos + border_thickness,
@@ -106 +109 @@
         char cls_pict[] = "x";
         font_get_box(&font, cls_pict, &cls_width, &cls_height);
-        source_set_color(&source, header_fgcolor);
+        source_set_color(&source, 
+            w->window->is_focused ? header_fg_focus_color : header_fg_unfocus_color);
         sysarg_t cls_x = ((close_width - cls_width) / 2) + w->hpos + w->width -
             border_thickness - close_width;
@@ -447 +451 @@
                         break;
                 case ET_POSITION_EVENT:
+                        if (!win->is_focused) {
+                                win->is_focused = true;
+                                handle_refresh(win);
+                        }
                         deliver_position_event(win, event->data.pos);
                         break;
@@ -454 +462 @@
                 case ET_WINDOW_RESIZE:
                         handle_resize(win, event->data.rsz.width, event->data.rsz.height);
+                        break;
+                case ET_WINDOW_FOCUS:
+                        if (!win->is_focused) {
+                                win->is_focused = true;
+                                handle_refresh(win);
+                        }
+                        break;
+                case ET_WINDOW_UNFOCUS:
+                        if (win->is_focused) {
+                                win->is_focused = false;
+                                handle_refresh(win);
+                        }
                         break;
                 case ET_WINDOW_REFRESH:
@@ -514 +534 @@
 }
 
-window_t *window_open(char *winreg, bool is_main, bool is_decorated, const char *caption)
+window_t *window_open(char *winreg, bool is_main, bool is_decorated, 
+    const char *caption, sysarg_t x_offset, sysarg_t y_offset)
 {
         int rc;
@@ -525 +546 @@
         win->is_main = is_main;
         win->is_decorated = is_decorated;
+        win->is_focused = true;
         prodcons_initialize(&win->events);
         fibril_mutex_initialize(&win->guard);
@@ -557 +579 @@
         service_id_t out_dsid;
         
-        rc = win_register(reg_sess, &in_dsid, &out_dsid);
+        rc = win_register(reg_sess, &in_dsid, &out_dsid, x_offset, y_offset);
         async_hangup(reg_sess);
         if (rc != EOK) {

uspace/lib/gui/window.h

@@ -50 +50 @@
         bool is_main; /**< True for the main window of the application. */
         bool is_decorated; /**< True if the window decorations should be rendered. */
+        bool is_focused; /**< True for the top level window of the desktop. */
         char *caption; /**< Text title of the window header. */
         async_sess_t *isess; /**< Input events from compositor. */
@@ -65 +66 @@
  * If the window is declared as main, its closure causes termination of the
  * whole application. Note that opened window does not have any surface yet. */
-extern window_t *window_open(char *, bool, bool, const char *);
+extern window_t *window_open(char *, bool, bool, const char *, sysarg_t, sysarg_t);
 
 /**

uspace/lib/softrend/filter.c

@@ -44 +44 @@
                 _x %= pixmap->width;
                 _y %= pixmap->height;
-        } else if (_x < 0 || _x >= (long) pixmap->width || _y < 0 || _y >= (long) pixmap->height) {
-                return 0;
         }
 

uspace/lib/softrend/transform.c

@@ -136 +136 @@
 }
 
+bool transform_is_fast(transform_t *t)
+{
+        return (t->m[0][0] == 1) && (t->m[0][1] == 0)
+            && (t->m[1][0] == 0) && (t->m[1][1] == 1)
+            && ((t->m[0][2] - ((long) t->m[0][2])) == 0.0)
+            && ((t->m[1][2] - ((long) t->m[1][2])) == 0.0);
+}
+
 void transform_apply_linear(const transform_t *t, double *x, double *y)
 {

uspace/lib/softrend/transform.h

@@ -37 +37 @@
 #define SOFTREND_TRANSFORM_H_
 
+#include <bool.h>
+
 #ifndef PI
 #define PI 3.141592653589793
@@ -53 +55 @@
 extern void transform_rotate(transform_t *, double);
 
+extern bool transform_is_fast(transform_t *);
+
 extern void transform_apply_linear(const transform_t *, double *, double *);
 extern void transform_apply_affine(const transform_t *, double *, double *);

uspace/srv/hid/compositor/compositor.c

@@ -90 +90 @@
 typedef struct {
         link_t link;
-        sysarg_t id;
-        uint8_t state;
-        desktop_point_t pos;
-        sysarg_t btn_num;
-        desktop_point_t btn_pos;
-        desktop_vector_t accum;
-        sysarg_t grab_flags;
-        bool pressed;
-        cursor_t cursor;
-} pointer_t;
-
-static sysarg_t pointer_id = 0;
-static FIBRIL_MUTEX_INITIALIZE(pointer_list_mtx);
-static LIST_INITIALIZE(pointer_list);
-
-typedef struct {
-        link_t link;
         service_id_t in_dsid;
         service_id_t out_dsid;
@@ -129 +112 @@
 typedef struct {
         link_t link;
+        sysarg_t id;
+        uint8_t state;
+        desktop_point_t pos;
+        sysarg_t btn_num;
+        desktop_point_t btn_pos;
+        desktop_vector_t accum;
+        sysarg_t grab_flags;
+        bool pressed;
+        cursor_t cursor;
+        window_t ghost;
+        desktop_vector_t accum_ghost;
+} pointer_t;
+
+static sysarg_t pointer_id = 0;
+static FIBRIL_MUTEX_INITIALIZE(pointer_list_mtx);
+static LIST_INITIALIZE(pointer_list);
+
+typedef struct {
+        link_t link;
         service_id_t dsid;
         vslmode_t mode;
@@ -181 +183 @@
         cursor_init(&p->cursor, CURSOR_DECODER_EMBEDDED, NULL);
 
+        /* Ghost window for transformation animation. */
+        transform_identity(&p->ghost.transform);
+        transform_translate(&p->ghost.transform, coord_origin, coord_origin);
+        p->ghost.dx = coord_origin;
+        p->ghost.dy = coord_origin;
+        p->ghost.fx = 1;
+        p->ghost.fy = 1;
+        p->ghost.angle = 0;
+        p->ghost.opacity = 255;
+        p->ghost.surface = NULL;
+        p->accum_ghost.x = 0;
+        p->accum_ghost.y = 0;
+
         return p;
 }
@@ -192 +207 @@
 }
 
-static window_t *window_create()
+static window_t *window_create(sysarg_t x_offset, sysarg_t y_offset)
 {
         window_t *win = (window_t *) malloc(sizeof(window_t));
@@ -202 +217 @@
         prodcons_initialize(&win->queue);
         transform_identity(&win->transform);
-        transform_translate(&win->transform, coord_origin, coord_origin);
-        win->dx = coord_origin;
-        win->dy = coord_origin;
+        transform_translate(&win->transform, 
+            coord_origin + x_offset, coord_origin + y_offset);
+        win->dx = coord_origin + x_offset;
+        win->dy = coord_origin + y_offset;
         win->fx = 1;
         win->fy = 1;
@@ -267 +283 @@
     sysarg_t *x_out, sysarg_t *y_out, sysarg_t *w_out, sysarg_t *h_out)
 {
-        sysarg_t x[4];
-        sysarg_t y[4];
-        comp_coord_from_client(x_in, y_in, win_trans, &x[0], &y[0]);
-        comp_coord_from_client(x_in + w_in, y_in, win_trans, &x[1], &y[1]);
-        comp_coord_from_client(x_in + w_in, y_in + h_in, win_trans, &x[2], &y[2]);
-        comp_coord_from_client(x_in, y_in + h_in, win_trans, &x[3], &y[3]);
-        (*x_out) = x[0];
-        (*y_out) = y[0];
-        (*w_out) = x[0];
-        (*h_out) = y[0];
-        for (int i = 1; i < 4; ++i) {
-                (*x_out) = (x[i] < (*x_out)) ? x[i] : (*x_out);
-                (*y_out) = (y[i] < (*y_out)) ? y[i] : (*y_out);
-                (*w_out) = (x[i] > (*w_out)) ? x[i] : (*w_out);
-                (*h_out) = (y[i] > (*h_out)) ? y[i] : (*h_out);
-        }
-        (*w_out) -= (*x_out);
-        (*h_out) -= (*y_out);
+        if (w_in > 0 && h_in > 0) {
+                sysarg_t x[4];
+                sysarg_t y[4];
+                comp_coord_from_client(x_in, y_in, win_trans, &x[0], &y[0]);
+                comp_coord_from_client(x_in + w_in - 1, y_in, win_trans, &x[1], &y[1]);
+                comp_coord_from_client(x_in + w_in - 1, y_in + h_in - 1, win_trans, &x[2], &y[2]);
+                comp_coord_from_client(x_in, y_in + h_in - 1, win_trans, &x[3], &y[3]);
+                (*x_out) = x[0];
+                (*y_out) = y[0];
+                (*w_out) = x[0];
+                (*h_out) = y[0];
+                for (int i = 1; i < 4; ++i) {
+                        (*x_out) = (x[i] < (*x_out)) ? x[i] : (*x_out);
+                        (*y_out) = (y[i] < (*y_out)) ? y[i] : (*y_out);
+                        (*w_out) = (x[i] > (*w_out)) ? x[i] : (*w_out);
+                        (*h_out) = (y[i] > (*h_out)) ? y[i] : (*h_out);
+                }
+                (*w_out) = (*w_out) - (*x_out) + 1;
+                (*h_out) = (*h_out) - (*y_out) + 1;
+        } else {
+                (*w_out) = 0;
+                (*h_out) = 0;
+        }
 }
 
@@ -309 +330 @@
                         /* Paint background color. */
                         for (sysarg_t y = y_dmg_vp - vp->pos.y; y <  y_dmg_vp - vp->pos.y + h_dmg_vp; ++y) {
-                                for (sysarg_t x = x_dmg_vp - vp->pos.x; x < x_dmg_vp - vp->pos.x + w_dmg_vp; ++x) {
-                                        surface_put_pixel(vp->surface, x, y, bg_color);
+                                pixel_t *dst = pixelmap_pixel_at(
+                                    surface_pixmap_access(vp->surface), x_dmg_vp - vp->pos.x, y);
+                                sysarg_t count = w_dmg_vp;
+                                while (count-- != 0) {
+                                        *dst++ = bg_color;
                                 }
                         }
+                        surface_add_damaged_region(vp->surface,
+                            x_dmg_vp - vp->pos.x, y_dmg_vp - vp->pos.y, w_dmg_vp, h_dmg_vp);
 
                         transform_t transform;
@@ -363 +389 @@
                         list_foreach(pointer_list, link) {
 
+                                pointer_t *ptr = list_get_instance(link, pointer_t, link);
+                                if (ptr->ghost.surface) {
+
+                                        sysarg_t x_bnd_ghost, y_bnd_ghost, w_bnd_ghost, h_bnd_ghost;
+                                        sysarg_t x_dmg_ghost, y_dmg_ghost, w_dmg_ghost, h_dmg_ghost;
+                                        surface_get_resolution(ptr->ghost.surface, &w_bnd_ghost, &h_bnd_ghost);
+                                        comp_coord_bounding_rect(0, 0, w_bnd_ghost, h_bnd_ghost, ptr->ghost.transform,
+                                            &x_bnd_ghost, &y_bnd_ghost, &w_bnd_ghost, &h_bnd_ghost);
+                                        bool isec_ghost = rectangle_intersect(
+                                            x_dmg_vp, y_dmg_vp, w_dmg_vp, h_dmg_vp,
+                                            x_bnd_ghost, y_bnd_ghost, w_bnd_ghost, h_bnd_ghost,
+                                            &x_dmg_ghost, &y_dmg_ghost, &w_dmg_ghost, &h_dmg_ghost);
+
+                                        if (isec_ghost) {
+                                                /* FIXME: Ghost is currently drawn based on the bounding
+                                                 * rectangle of the window, which is sufficient as long
+                                                 * as the windows can be rotated only by 90 degrees. 
+                                                 * For ghost to be compatible with arbitrary-angle
+                                                 * rotation, it should be drawn as four lines adjusted
+                                                 * by the transformation matrix. That would however
+                                                 * require to equip libdraw with line drawing functionality. */
+
+                                                transform_t transform = ptr->ghost.transform;
+                                                double_point_t pos;
+                                                pos.x = vp->pos.x;
+                                                pos.y = vp->pos.y;
+                                                transform_translate(&transform, -pos.x, -pos.y);
+
+                                                pixel_t ghost_color;
+
+                                                if (y_bnd_ghost == y_dmg_ghost) {
+                                                        for (sysarg_t x = x_dmg_ghost - vp->pos.x;
+                                                                    x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
+                                                                ghost_color = surface_get_pixel(vp->surface,
+                                                                    x, y_dmg_ghost - vp->pos.y);
+                                                                surface_put_pixel(vp->surface,
+                                                                    x, y_dmg_ghost - vp->pos.y, INVERT(ghost_color));
+                                                        }
+                                                }
+
+                                                if (y_bnd_ghost + h_bnd_ghost == y_dmg_ghost + h_dmg_ghost) {
+                                                        for (sysarg_t x = x_dmg_ghost - vp->pos.x;
+                                                                    x < x_dmg_ghost - vp->pos.x + w_dmg_ghost; ++x) {
+                                                                ghost_color = surface_get_pixel(vp->surface,
+                                                                    x, y_dmg_ghost - vp->pos.y + h_dmg_ghost - 1);
+                                                                surface_put_pixel(vp->surface,
+                                                                    x, y_dmg_ghost - vp->pos.y + h_dmg_ghost - 1, INVERT(ghost_color));
+                                                        }
+                                                }
+
+                                                if (x_bnd_ghost == x_dmg_ghost) {
+                                                        for (sysarg_t y = y_dmg_ghost - vp->pos.y;
+                                                                    y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
+                                                                ghost_color = surface_get_pixel(vp->surface,
+                                                                    x_dmg_ghost - vp->pos.x, y);
+                                                                surface_put_pixel(vp->surface,
+                                                                    x_dmg_ghost - vp->pos.x, y, INVERT(ghost_color));
+                                                        }
+                                                }
+
+                                                if (x_bnd_ghost + w_bnd_ghost == x_dmg_ghost + w_dmg_ghost) {
+                                                        for (sysarg_t y = y_dmg_ghost - vp->pos.y;
+                                                                    y < y_dmg_ghost - vp->pos.y + h_dmg_ghost; ++y) {
+                                                                ghost_color = surface_get_pixel(vp->surface,
+                                                                    x_dmg_ghost - vp->pos.x + w_dmg_ghost - 1, y);
+                                                                surface_put_pixel(vp->surface,
+                                                                    x_dmg_ghost - vp->pos.x + w_dmg_ghost - 1, y, INVERT(ghost_color));
+                                                        }
+                                                }
+                                        }
+
+                                }
+                        }
+
+                        list_foreach(pointer_list, link) {
+
                                 /* Determine what part of the pointer intersects with the
                                  * updated area of the current viewport. */
@@ -376 +478 @@
                                 if (isec_ptr) {
                                         /* Pointer is currently painted directly by copying pixels.
-                                         * However, it is possible to draw the painter similarly
+                                         * However, it is possible to draw the pointer similarly
                                          * as window by using drawctx_transfer. It would allow
                                          * more sophisticated control over drawing, but would also
                                          * cost more regarding the performance. */
 
-                                        pixel_t pix = 0;
                                         sysarg_t x_vp = x_dmg_ptr - vp->pos.x;
                                         sysarg_t y_vp = y_dmg_ptr - vp->pos.y;
@@ -388 +489 @@
 
                                         for (sysarg_t y = 0; y < h_dmg_ptr; ++y) {
-                                                for (sysarg_t x = 0; x < w_dmg_ptr; ++x) {
-                                                        pix = surface_get_pixel(sf_ptr, x_ptr + x, y_ptr + y);
-                                                        if (ALPHA(pix) == 255) {
-                                                                surface_put_pixel(vp->surface, x_vp + x, y_vp + y, pix);
-                                                        }
+                                                pixel_t *src = pixelmap_pixel_at(
+                                                    surface_pixmap_access(sf_ptr), x_ptr, y_ptr + y);
+                                                pixel_t *dst = pixelmap_pixel_at(
+                                                    surface_pixmap_access(vp->surface), x_vp, y_vp + y);
+                                                sysarg_t count = w_dmg_ptr;
+                                                while (count-- != 0) {
+                                                        *dst = (*src & 0xff000000) ? *src : *dst;
+                                                        ++dst; ++src;
                                                 }
                                         }
+                                        surface_add_damaged_region(vp->surface, x_vp, y_vp, w_dmg_ptr, h_dmg_ptr);
                                 }
+
                         }
                 }
@@ -450 +556 @@
         } else {
                 fibril_mutex_lock(&window_list_mtx);
-                comp_coord_bounding_rect(x, y, width, height,
+                comp_coord_bounding_rect(x - 1, y - 1, width + 2, height + 2,
                     win->transform, &x, &y, &width, &height);
                 fibril_mutex_unlock(&window_list_mtx);
@@ -468 +574 @@
                 pointer_t *pointer = list_get_instance(link, pointer_t, link);
                 if (pointer->id == pos_id) {
-                        pointer->grab_flags = grab_flags;
+                        pointer->grab_flags = pointer->pressed ? grab_flags : GF_EMPTY;
                         // TODO change pointer->state according to grab_flags
                         break;
@@ -541 +647 @@
 }
 
+static void comp_post_event_win(window_event_t *event, window_t *target)
+{
+        fibril_mutex_lock(&window_list_mtx);
+        window_t *window = NULL;
+        list_foreach(window_list, link) {
+                window = list_get_instance(link, window_t, link);
+                if (window == target) {
+                        prodcons_produce(&window->queue, &event->link);
+                }
+        }
+        if (!window) {
+                free(event);
+        }
+        fibril_mutex_unlock(&window_list_mtx);
+}
+
+static void comp_post_event_top(window_event_t *event)
+{
+        fibril_mutex_lock(&window_list_mtx);
+        window_t *win = (window_t *) list_first(&window_list);
+        if (win) {
+                prodcons_produce(&win->queue, &event->link);
+        } else {
+                free(event);
+        }
+        fibril_mutex_unlock(&window_list_mtx);
+}
+
 static void comp_window_close(window_t *win, ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -546 +680 @@
         fibril_mutex_lock(&window_list_mtx);
         list_remove(&win->link);
+        window_t *win_focus = (window_t *) list_first(&window_list);
+        window_event_t *event_focus = (window_event_t *) malloc(sizeof(window_event_t));
+        if (event_focus) {
+                link_initialize(&event_focus->link);
+                event_focus->type = ET_WINDOW_FOCUS;
+        }
         fibril_mutex_unlock(&window_list_mtx);
+
+        if (event_focus && win_focus) {
+                comp_post_event_win(event_focus, win_focus);
+        }
 
         /* Calculate damage. */
@@ -601 +745 @@
                         fibril_mutex_lock(&window_list_mtx);
 
-                        window_t *win = window_create();
+                        window_t *win = window_create(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
                         if (!win) {
                                 async_answer_2(callid, ENOMEM, 0, 0);
@@ -630 +774 @@
                         }
 
+                        window_t *win_unfocus = (window_t *) list_first(&window_list);
                         list_prepend(&win->link, &window_list);
+
+                        window_event_t *event_unfocus = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event_unfocus) {
+                                link_initialize(&event_unfocus->link);
+                                event_unfocus->type = ET_WINDOW_UNFOCUS;
+                        }
                         
                         async_answer_2(callid, EOK, win->in_dsid, win->out_dsid);
                         fibril_mutex_unlock(&window_list_mtx);
+                        
+                        if (event_unfocus && win_unfocus) {
+                                comp_post_event_win(event_unfocus, win_unfocus);
+                        }
+
                         return;
                 } else {
@@ -953 +1109 @@
 }
 
-static void comp_post_event(window_event_t *event)
-{
-        fibril_mutex_lock(&window_list_mtx);
-        window_t *win = (window_t *) list_first(&window_list);
-        if (win) {
-                prodcons_produce(&win->queue, &event->link);
-        } else {
-                free(event);
-        }
-        fibril_mutex_unlock(&window_list_mtx);
-}
-
 static void comp_recalc_transform(window_t *win)
 {
@@ -973 +1117 @@
         transform_t scale;
         transform_identity(&scale);
-        transform_scale(&scale, win->fx, win->fy);
+        if (win->fx != 1 || win->fy != 1) {
+                transform_scale(&scale, win->fx, win->fy);
+        }
 
         transform_t rotate;
         transform_identity(&rotate);
-        transform_rotate(&rotate, win->angle);
+        if (win->angle != 0) {
+                transform_rotate(&rotate, win->angle);
+        }
 
         transform_t transform;
@@ -994 +1142 @@
 
 static void comp_window_animate(pointer_t *pointer, window_t *win,
-     sysarg_t *dmg_x, sysarg_t *dmg_y, sysarg_t *dmg_width, sysarg_t *dmg_height)
+    sysarg_t *dmg_x, sysarg_t *dmg_y, sysarg_t *dmg_width, sysarg_t *dmg_height)
 {
         /* window_list_mtx locked by caller */
+        /* pointer_list_mtx locked by caller */
 
         int dx = pointer->accum.x;
@@ -1020 +1169 @@
                 }
 
-                if (scale || resize) {
+                if ((scale || resize) && (win->angle != 0)) {
                         transform_t rotate;
                         transform_identity(&rotate);
@@ -1037 +1186 @@
                 double _dx = dx;
                 double _dy = dy;
-                transform_t unrotate;
-                transform_identity(&unrotate);
-                transform_rotate(&unrotate, -win->angle);
-                transform_apply_linear(&unrotate, &_dx, &_dy);
+                if (win->angle != 0) {
+                        transform_t unrotate;
+                        transform_identity(&unrotate);
+                        transform_rotate(&unrotate, -win->angle);
+                        transform_apply_linear(&unrotate, &_dx, &_dy);
+                }
                 _dx = (pointer->grab_flags & GF_MOVE_X) ? -_dx : _dx;
                 _dy = (pointer->grab_flags & GF_MOVE_Y) ? -_dy : _dy;
 
                 if ((pointer->grab_flags & GF_SCALE_X) || (pointer->grab_flags & GF_RESIZE_X)) {
-                        double fx = 1.0 + (_dx / (width * win->fx));
+                        double fx = 1.0 + (_dx / ((width - 1) * win->fx));
                         if (fx > 0) {
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+                                if (scale) win->fx *= fx;
+#endif
+#if ANIMATE_WINDOW_TRANSFORMS == 1
                                 win->fx *= fx;
+#endif
                                 scale_back_x *= fx;
                         }
@@ -1053 +1209 @@
 
                 if ((pointer->grab_flags & GF_SCALE_Y) || (pointer->grab_flags & GF_RESIZE_Y)) {
-                        double fy = 1.0 + (_dy / (height * win->fy));
+                        double fy = 1.0 + (_dy / ((height - 1) * win->fy));
                         if (fy > 0) {
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+                                if (scale) win->fy *= fy;
+#endif
+#if ANIMATE_WINDOW_TRANSFORMS == 1
                                 win->fy *= fy;
+#endif
                                 scale_back_y *= fy;
                         }
@@ -1071 +1232 @@
             dmg_x, dmg_y, dmg_width, dmg_height);
 }
+
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+static void comp_ghost_animate(pointer_t *pointer,
+    desktop_rect_t *rect1, desktop_rect_t *rect2, desktop_rect_t *rect3, desktop_rect_t *rect4)
+{
+        /* window_list_mtx locked by caller */
+        /* pointer_list_mtx locked by caller */
+
+        int dx = pointer->accum_ghost.x;
+        int dy = pointer->accum_ghost.y;
+        pointer->accum_ghost.x = 0;
+        pointer->accum_ghost.y = 0;
+
+        bool move = (pointer->grab_flags & GF_MOVE_X) || (pointer->grab_flags & GF_MOVE_Y);
+        bool scale = (pointer->grab_flags & GF_SCALE_X) || (pointer->grab_flags & GF_SCALE_Y);
+        bool resize = (pointer->grab_flags & GF_RESIZE_X) || (pointer->grab_flags & GF_RESIZE_Y);
+
+        sysarg_t width, height;
+        surface_get_resolution(pointer->ghost.surface, &width, &height);
+
+        if (move) {
+                double cx = 0;
+                double cy = 0;
+                if (pointer->grab_flags & GF_MOVE_X) {
+                        cx = 1;
+                }
+                if (pointer->grab_flags & GF_MOVE_Y) {
+                        cy = 1;
+                }
+
+                if (scale || resize) {
+                        transform_t rotate;
+                        transform_identity(&rotate);
+                        transform_rotate(&rotate, pointer->ghost.angle);
+                        transform_apply_linear(&rotate, &cx, &cy);
+                }
+
+                cx = (cx < 0) ? (-1 * cx) : cx;
+                cy = (cy < 0) ? (-1 * cy) : cy;
+
+                pointer->ghost.dx += (cx * dx);
+                pointer->ghost.dy += (cy * dy);
+        }
+
+        if (scale || resize) {
+                double _dx = dx;
+                double _dy = dy;
+                transform_t unrotate;
+                transform_identity(&unrotate);
+                transform_rotate(&unrotate, -pointer->ghost.angle);
+                transform_apply_linear(&unrotate, &_dx, &_dy);
+                _dx = (pointer->grab_flags & GF_MOVE_X) ? -_dx : _dx;
+                _dy = (pointer->grab_flags & GF_MOVE_Y) ? -_dy : _dy;
+
+                if ((pointer->grab_flags & GF_SCALE_X) || (pointer->grab_flags & GF_RESIZE_X)) {
+                        double fx = 1.0 + (_dx / ((width - 1) * pointer->ghost.fx));
+                        pointer->ghost.fx *= fx;
+                }
+
+                if ((pointer->grab_flags & GF_SCALE_Y) || (pointer->grab_flags & GF_RESIZE_Y)) {
+                        double fy = 1.0 + (_dy / ((height - 1) * pointer->ghost.fy));
+                        pointer->ghost.fy *= fy;
+                }
+        }
+
+        sysarg_t x1, y1, width1, height1;
+        sysarg_t x2, y2, width2, height2;
+        comp_coord_bounding_rect(0, 0, width, height, pointer->ghost.transform,
+            &x1, &y1, &width1, &height1);
+        comp_recalc_transform(&pointer->ghost);
+        comp_coord_bounding_rect(0, 0, width, height, pointer->ghost.transform,
+            &x2, &y2, &width2, &height2);
+
+        sysarg_t x_u, y_u, w_u, h_u;
+        rectangle_union(x1, y1, width1, height1, x2, y2, width2, height2,
+            &x_u, &y_u, &w_u, &h_u);
+
+        sysarg_t x_i, y_i, w_i, h_i;
+        rectangle_intersect(x1, y1, width1, height1, x2, y2, width2, height2,
+            &x_i, &y_i, &w_i, &h_i);
+
+        if (w_i == 0 || h_i == 0) {
+                rect1->x = x_u; rect2->x = 0; rect3->x = 0; rect4->x = 0;
+                rect1->y = y_u; rect2->y = 0; rect3->y = 0; rect4->y = 0;
+                rect1->w = w_u; rect2->w = 0; rect3->w = 0; rect4->w = 0;
+                rect1->h = h_u; rect2->h = 0; rect3->h = 0; rect4->h = 0;
+        } else {
+                rect1->x = x_u;
+                rect1->y = y_u;
+                rect1->w = x_i - x_u + 1;
+                rect1->h = h_u;
+
+                rect2->x = x_u;
+                rect2->y = y_u;
+                rect2->w = w_u;
+                rect2->h = y_i - y_u + 1;
+
+                rect3->x = x_i + w_i - 1;
+                rect3->y = y_u;
+                rect3->w = w_u - w_i - x_i + x_u + 1;
+                rect3->h = h_u;
+                
+                rect4->x = x_u;
+                rect4->y = y_i + h_i - 1;
+                rect4->w = w_u;
+                rect4->h = h_u - h_i - y_i + y_u + 1;
+        }
+}
+#endif
 
 static int comp_abs_move(input_t *input, unsigned x , unsigned y,
@@ -1125 +1395 @@
 
         fibril_mutex_lock(&window_list_mtx);
+        fibril_mutex_lock(&pointer_list_mtx);
         window_t *top = (window_t *) list_first(&window_list);
         if (top && top->surface) {
@@ -1136 +1407 @@
                         within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
                             top->transform, width, height, &point_x, &point_y);
-                        fibril_mutex_unlock(&window_list_mtx);
-
+
+                        window_event_t *event = NULL;
                         if (within_client) {
-                                window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
+                                event = (window_event_t *) malloc(sizeof(window_event_t));
                                 if (event) {
                                         link_initialize(&event->link);
@@ -1148 +1419 @@
                                         event->data.pos.hpos = point_x;
                                         event->data.pos.vpos = point_y;
-                                        comp_post_event(event);
                                 }
                         }
+
+                        fibril_mutex_unlock(&pointer_list_mtx);
+                        fibril_mutex_unlock(&window_list_mtx);
+
+                        if (event) {
+                                comp_post_event_top(event);
+                        }
+
                 } else {
                         /* Pointer is grabbed by top-level window action. */
                         pointer->accum.x += dx;
                         pointer->accum.y += dy;
+                        pointer->accum_ghost.x += dx;
+                        pointer->accum_ghost.y += dy;
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+                        if (pointer->ghost.surface == NULL) {
+                                pointer->ghost.surface = top->surface;
+                                pointer->ghost.dx = top->dx;
+                                pointer->ghost.dy = top->dy;
+                                pointer->ghost.fx = top->fx;
+                                pointer->ghost.fy = top->fy;
+                                pointer->ghost.angle = top->angle;
+                                pointer->ghost.transform = top->transform;
+                        }
+                        desktop_rect_t dmg_rect1, dmg_rect2, dmg_rect3, dmg_rect4;
+                        comp_ghost_animate(pointer, &dmg_rect1, &dmg_rect2, &dmg_rect3, &dmg_rect4);
+#endif
 #if ANIMATE_WINDOW_TRANSFORMS == 1
                         sysarg_t x, y, width, height;
                         comp_window_animate(pointer, top, &x, &y, &width, &height);
 #endif
+                        fibril_mutex_unlock(&pointer_list_mtx);
                         fibril_mutex_unlock(&window_list_mtx);
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+                        comp_damage(dmg_rect1.x, dmg_rect1.y, dmg_rect1.w, dmg_rect1.h);
+                        comp_damage(dmg_rect2.x, dmg_rect2.y, dmg_rect2.w, dmg_rect2.h);
+                        comp_damage(dmg_rect3.x, dmg_rect3.y, dmg_rect3.w, dmg_rect3.h);
+                        comp_damage(dmg_rect4.x, dmg_rect4.y, dmg_rect4.w, dmg_rect4.h);
+#endif
 #if ANIMATE_WINDOW_TRANSFORMS == 1
                         comp_damage(x, y, width, height);
@@ -1165 +1465 @@
                 }
         } else {
+                fibril_mutex_unlock(&pointer_list_mtx);
                 fibril_mutex_unlock(&window_list_mtx);
         }
@@ -1174 +1475 @@
 {
         pointer_t *pointer = input_pointer(input);
+
+        fibril_mutex_lock(&window_list_mtx);
+        fibril_mutex_lock(&pointer_list_mtx);
+        window_t *win = NULL;
+        sysarg_t point_x = 0;
+        sysarg_t point_y = 0;
+        sysarg_t width, height;
+        bool within_client = false;
+
+        /* Determine the window which the mouse click belongs to. */
+        list_foreach(window_list, link) {
+                win = list_get_instance(link, window_t, link);
+                if (win->surface) {
+                        surface_get_resolution(win->surface, &width, &height);
+                        within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
+                            win->transform, width, height, &point_x, &point_y);
+                }
+                if (within_client) {
+                        break;
+                }
+        }
+
+        /* Check whether the window is top-level window. */
+        window_t *top = (window_t *) list_first(&window_list);
+        if (!win || !top) {
+                fibril_mutex_unlock(&pointer_list_mtx);
+                fibril_mutex_unlock(&window_list_mtx);
+                return EOK;
+        }
+
+        window_event_t *event_top = NULL;
+        window_event_t *event_unfocus = NULL;
+        window_t *win_unfocus = NULL;
+        sysarg_t dmg_x, dmg_y;
+        sysarg_t dmg_width = 0;
+        sysarg_t dmg_height = 0;
+        
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+        desktop_rect_t dmg_rect1, dmg_rect2, dmg_rect3, dmg_rect4;
+#endif
 
         if (bpress) {
@@ -1180 +1521 @@
                 pointer->pressed = true;
 
-                /* Check whether mouse press belongs to the top-level window. */
-                fibril_mutex_lock(&window_list_mtx);
-                window_t *win = (window_t *) list_first(&window_list);
-                if (!win || !win->surface) {
-                        fibril_mutex_unlock(&window_list_mtx);
-                        return EOK;
-                }
-                sysarg_t x, y, width, height;
-                surface_get_resolution(win->surface, &width, &height);
-                bool within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
-                    win->transform, width, height, &x, &y);
-                fibril_mutex_unlock(&window_list_mtx);
-
-                /* Send mouse press to the top-level window. */
+                /* Bring the window to the foreground. */
+                if ((win != top) && within_client) {
+                        win_unfocus = (window_t *) list_first(&window_list);
+                        list_remove(&win->link);
+                        list_prepend(&win->link, &window_list);
+                        event_unfocus = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event_unfocus) {
+                                link_initialize(&event_unfocus->link);
+                                event_unfocus->type = ET_WINDOW_UNFOCUS;
+                        }
+                        comp_coord_bounding_rect(0, 0, width, height, win->transform,
+                            &dmg_x, &dmg_y, &dmg_width, &dmg_height);
+                }
+
+                /* Notify top-level window about mouse press. */
                 if (within_client) {
-                        window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
-                        if (event) {
-                                link_initialize(&event->link);
-                                event->type = ET_POSITION_EVENT;
-                                event->data.pos.pos_id = pointer->id;
-                                event->data.pos.type = POS_PRESS;
-                                event->data.pos.btn_num = bnum;
-                                event->data.pos.hpos = x;
-                                event->data.pos.vpos = y;
-                                comp_post_event(event);
-                        } else {
-                                return ENOMEM;
-                        }
-                }
+                        event_top = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event_top) {
+                                link_initialize(&event_top->link);
+                                event_top->type = ET_POSITION_EVENT;
+                                event_top->data.pos.pos_id = pointer->id;
+                                event_top->data.pos.type = POS_PRESS;
+                                event_top->data.pos.btn_num = bnum;
+                                event_top->data.pos.hpos = point_x;
+                                event_top->data.pos.vpos = point_y;
+                        }
+                        pointer->grab_flags = GF_EMPTY;
+                }
+
         } else if (pointer->pressed && pointer->btn_num == (unsigned)bnum) {
                 pointer->pressed = false;
 
-                fibril_mutex_lock(&window_list_mtx);
-                window_t *win = NULL;
-                sysarg_t point_x = 0;
-                sysarg_t point_y = 0;
-                sysarg_t width, height;
-                bool within_client = false;
-
-                /* Determine the window which the mouse release belongs to. */
-                list_foreach(window_list, link) {
-                        win = list_get_instance(link, window_t, link);
-                        if (win->surface) {
-                                surface_get_resolution(win->surface, &width, &height);
-                                within_client = comp_coord_to_client(pointer->pos.x, pointer->pos.y,
-                                    win->transform, width, height, &point_x, &point_y);
-                        }
-                        if (within_client) {
-                                break;
-                        }
-                }
-
-                /* Check whether the window is top-level window. */
-                window_t *top = (window_t *) list_first(&window_list);
-                if (!win || !top) {
-                        pointer->grab_flags = GF_EMPTY;
-                        fibril_mutex_unlock(&window_list_mtx);
-                        return EOK;
-                }
-
-                window_event_t *event = NULL;
-                sysarg_t dmg_x, dmg_y;
-                sysarg_t dmg_width = 0;
-                sysarg_t dmg_height = 0;
-
+#if ANIMATE_WINDOW_TRANSFORMS == 0
                 sysarg_t pre_x = 0; 
                 sysarg_t pre_y = 0;
@@ -1250 +1559 @@
                 sysarg_t pre_height = 0;
 
-#if ANIMATE_WINDOW_TRANSFORMS == 0
                 if (pointer->grab_flags != GF_EMPTY) {
+                        if (pointer->ghost.surface) {
+                                comp_ghost_animate(pointer, &dmg_rect1, &dmg_rect2, &dmg_rect3, &dmg_rect4);
+                                pointer->ghost.surface = NULL;
+                        }
                         comp_window_animate(pointer, top, &pre_x, &pre_y, &pre_width, &pre_height);
                         dmg_x = pre_x;
@@ -1263 +1575 @@
 
                         surface_get_resolution(top->surface, &width, &height);
+#if ANIMATE_WINDOW_TRANSFORMS == 1
                         top->fx *= (1.0 / scale_back_x);
                         top->fy *= (1.0 / scale_back_y);
                         comp_recalc_transform(top);
+#endif
 
                         /* Commit proper resize action. */
-                        event = (window_event_t *) malloc(sizeof(window_event_t));
-                        if (event) {
-                                link_initialize(&event->link);
-                                event->type = ET_WINDOW_RESIZE;
+                        event_top = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event_top) {
+                                link_initialize(&event_top->link);
+                                event_top->type = ET_WINDOW_RESIZE;
 
                                 int dx = (int) (((double) width) * (scale_back_x - 1.0));
@@ -1277 +1591 @@
 
                                 if (pointer->grab_flags & GF_RESIZE_X) {
-                                        event->data.rsz.width =
+                                        event_top->data.rsz.width =
                                                 ((((int) width) + dx) >= 0) ? (width + dx) : 0;
                                 } else {
-                                        event->data.rsz.width = width;
+                                        event_top->data.rsz.width = width;
                                 }
 
                                 if (pointer->grab_flags & GF_RESIZE_Y) {
-                                        event->data.rsz.height =
+                                        event_top->data.rsz.height =
                                                 ((((int) height) + dy) >= 0) ? (height + dy) : 0;
                                 } else {
-                                        event->data.rsz.height = height;
+                                        event_top->data.rsz.height = height;
                                 }
                         }
@@ -1296 +1610 @@
                         
                         /* Notify top-level window about mouse release. */
-                        event = (window_event_t *) malloc(sizeof(window_event_t));
-                        if (event) {
-                                link_initialize(&event->link);
-                                event->type = ET_POSITION_EVENT;
-                                event->data.pos.pos_id = pointer->id;
-                                event->data.pos.type = POS_RELEASE;
-                                event->data.pos.btn_num = bnum;
-                                event->data.pos.hpos = point_x;
-                                event->data.pos.vpos = point_y;
+                        event_top = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event_top) {
+                                link_initialize(&event_top->link);
+                                event_top->type = ET_POSITION_EVENT;
+                                event_top->data.pos.pos_id = pointer->id;
+                                event_top->data.pos.type = POS_RELEASE;
+                                event_top->data.pos.btn_num = bnum;
+                                event_top->data.pos.hpos = point_x;
+                                event_top->data.pos.vpos = point_y;
                         }
                         pointer->grab_flags = GF_EMPTY;
-                        
-                } else if (within_client && (pointer->grab_flags == GF_EMPTY) && (bnum == 1)) {
-
-                        /* Bring the window to the foreground. */
-                        list_remove(&win->link);
-                        list_prepend(&win->link, &window_list);
-                        comp_coord_bounding_rect(0, 0, width, height, win->transform,
-                            &dmg_x, &dmg_y, &dmg_width, &dmg_height);
                         
                 } else {
@@ -1320 +1626 @@
                 }
 
-                fibril_mutex_unlock(&window_list_mtx);
-
-                if (dmg_width > 0 && dmg_height > 0) {
-                        comp_damage(dmg_x, dmg_y, dmg_width, dmg_height);
-                }
-
-                if (event) {
-                        comp_post_event(event);
-                }
+        }
+
+        fibril_mutex_unlock(&pointer_list_mtx);
+        fibril_mutex_unlock(&window_list_mtx);
+
+#if ANIMATE_WINDOW_TRANSFORMS == 0
+                comp_damage(dmg_rect1.x, dmg_rect1.y, dmg_rect1.w, dmg_rect1.h);
+                comp_damage(dmg_rect2.x, dmg_rect2.y, dmg_rect2.w, dmg_rect2.h);
+                comp_damage(dmg_rect3.x, dmg_rect3.y, dmg_rect3.w, dmg_rect3.h);
+                comp_damage(dmg_rect4.x, dmg_rect4.y, dmg_rect4.w, dmg_rect4.h);
+#endif
+
+        if (dmg_width > 0 && dmg_height > 0) {
+                comp_damage(dmg_x, dmg_y, dmg_width, dmg_height);
+        }
+
+        if (event_unfocus && win_unfocus) {
+                comp_post_event_win(event_unfocus, win_unfocus);
+        }
+
+        if (event_top) {
+                comp_post_event_top(event_top);
         }
 
@@ -1452 +1771 @@
 
                         fibril_mutex_unlock(&window_list_mtx);
-                        comp_post_event(event);
+                        comp_post_event_top(event);
                 } else {
                         fibril_mutex_unlock(&window_list_mtx);
@@ -1494 +1813 @@
                 event->type = ET_WINDOW_CLOSE;
 
-                comp_post_event(event);
+                comp_post_event_top(event);
         } else if (win_switch) {
                 fibril_mutex_lock(&window_list_mtx);
@@ -1502 +1821 @@
                         list_append(&win1->link, &window_list);
                         window_t *win2 = (window_t *) list_first(&window_list);
+
+                        window_event_t *event1 = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event1) {
+                                link_initialize(&event1->link);
+                                event1->type = ET_WINDOW_UNFOCUS;
+                        }
+
+                        window_event_t *event2 = (window_event_t *) malloc(sizeof(window_event_t));
+                        if (event2) {
+                                link_initialize(&event2->link);
+                                event2->type = ET_WINDOW_FOCUS;
+                        }
 
                         sysarg_t x1 = 0;
@@ -1530 +1861 @@
 
                         fibril_mutex_unlock(&window_list_mtx);
+
+                        if (event1 && win1) {
+                                comp_post_event_win(event1, win1);
+                        }
+
+                        if (event2 && win2) {
+                                comp_post_event_win(event2, win2);
+                        }
+
                         comp_damage(x, y, width, height);
                 } else {
@@ -1600 +1940 @@
                 fibril_mutex_lock(&window_list_mtx);
 
-                window_t *red_win = window_create();
+                window_t *red_win = window_create(0, 0);
                 red_win->surface = surface_create(250, 150, NULL, 0);
                 pixel_t red_pix = PIXEL(255, 240, 0, 0);
@@ -1610 +1950 @@
                 list_prepend(&red_win->link, &window_list);
 
-                window_t *blue_win = window_create();
+                window_t *blue_win = window_create(0, 0);
                 blue_win->surface = surface_create(200, 100, NULL, 0);
                 pixel_t blue_pix = PIXEL(255, 0, 0, 240);
@@ -1620 +1960 @@
                 list_prepend(&blue_win->link, &window_list);
 
-                window_t *helenos_win = window_create();
+                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();
+                window_t *nameic_win = window_create(0, 0);
                 nameic_win->surface = decode_tga((void *) nameic_tga, nameic_tga_size, 0);
                 list_prepend(&nameic_win->link, &window_list);
@@ -1642 +1982 @@
                 event->data.kbd.c = c;
 
-                comp_post_event(event);
+                comp_post_event_top(event);
         }
 
@@ -1693 +2033 @@
 static void input_disconnect(void)
 {
-        pointer_t *pointer = input->user;
+        pointer_t *pointer = input->user;
         input_close(input);
         pointer_destroy(pointer);
@@ -1706 +2046 @@
 {
         /* Coordinates of the central pixel. */
-        coord_origin = UINT32_MAX / 2;
+        coord_origin = UINT32_MAX / 4;
         
         /* Color of the viewport background. Must be opaque. */

uspace/srv/hid/compositor/compositor.h

@@ -43 +43 @@
 typedef desktop_point_t desktop_vector_t;
 
+typedef struct {
+        desktop_coord_t x;
+        desktop_coord_t y;
+        desktop_coord_t w;
+        desktop_coord_t h;
+} desktop_rect_t;
+
 /* TODO remove? */
 typedef struct {