Changeset e1c6d5df in mainline

Timestamp:

2012-11-29T07:44:58Z (11 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

3194d83

Parents:

ff98ce8 (diff), 82edef2 (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 from lp:~petr-koupy/helenos/gui-optim.

The main improvements are:

• significantly faster rendering (making qemu/non-KVM usable) if user limits himself just to window movement and resizing (i.e. avoiding rotation, scaling and transparency)

• preview of the result of window transformation is depicted by a "ghost" frame following the mouse pointer

• changing of window focus feels more natural and intuitive (mouse click handler behaves more like in mainstream operating systems, window titles changes color to reflect whether they have focus or not)

Location:

uspace

Files:

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

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/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 {