Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 62fbb7e in mainline


Ignore:
Timestamp:
2014-01-16T20:43:22Z (8 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
6a3d0c7
Parents:
ba02baa
Message:

refactor window placement logic and introduce logical window placement flags

  • The original setup of window position during creation (window_open()) was quite useless, because the window had no surface yet.
  • Now the window position can be optinally set using window_resize() and various logical placement flags are available.
  • A separate window_move() routine could be introduced eventually if needed, but for the initial setup of the window the combination of window position and size works fine.
Location:
uspace
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/vdemo/vdemo.c

    rba02baa r62fbb7e  
    110110{
    111111        if (argc >= 2) {
    112                 window_t *main_window = window_open(argv[1], true, true, "vdemo", 0, 0);
     112                window_t *main_window = window_open(argv[1], true, true, "vdemo");
    113113                if (!main_window) {
    114114                        printf("Cannot open main window.\n");
     
    150150                grid->add(grid, &btn_confirm->widget, 0, 1, 1, 1);
    151151                grid->add(grid, &btn_cancel->widget, 1, 1, 1, 1);
    152                 window_resize(main_window, 200, 76);
     152                window_resize(main_window, 0, 0, 200, 76,
     153                    WINDOW_PLACEMENT_CENTER);
    153154
    154155                window_exec(main_window);
  • uspace/app/viewer/viewer.c

    rba02baa r62fbb7e  
    166166        }
    167167       
    168         main_window = window_open(argv[1], true, false, "viewer", 0, 0);
     168        main_window = window_open(argv[1], true, false, "viewer");
    169169        if (!main_window) {
    170170                printf("Cannot open main window.\n");
     
    192192        }
    193193       
    194         window_resize(main_window, WINDOW_WIDTH, WINDOW_HEIGHT);
     194        window_resize(main_window, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT,
     195            WINDOW_PLACEMENT_ABSOLUTE);
    195196        window_exec(main_window);
    196197       
  • uspace/app/vlaunch/vlaunch.c

    rba02baa r62fbb7e  
    115115       
    116116        winreg = argv[1];
    117         window_t *main_window = window_open(argv[1], true, true, "vlaunch", 0, 0);
     117        window_t *main_window = window_open(argv[1], true, true, "vlaunch");
    118118        if (!main_window) {
    119119                printf("Cannot open main window.\n");
     
    159159        grid->add(grid, &btn_vlaunch->widget, 0, 4, 1, 1);
    160160       
    161         window_resize(main_window, 210, 130 + LOGO_HEIGHT);
     161        window_resize(main_window, 0, 0, 210, 130 + LOGO_HEIGHT,
     162            WINDOW_PLACEMENT_RIGHT | WINDOW_PLACEMENT_TOP);
    162163        window_exec(main_window);
    163164       
  • uspace/app/vterm/vterm.c

    rba02baa r62fbb7e  
    4949        }
    5050       
    51         window_t *main_window = window_open(argv[1], true, true, "vterm", 0, 0);
     51        window_t *main_window = window_open(argv[1], true, true, "vterm");
    5252        if (!main_window) {
    5353                printf("%s: Cannot open main window.\n", NAME);
     
    5555        }
    5656       
    57         window_resize(main_window, 648, 510);
     57        window_resize(main_window, 0, 0, 648, 510, WINDOW_PLACEMENT_ANY);
    5858        terminal_t *terminal_widget =
    5959            create_terminal(window_root(main_window), 640, 480);
  • uspace/lib/c/generic/io/window.c

    rba02baa r62fbb7e  
    4040#include <stdio.h>
    4141
    42 int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out,
    43     sysarg_t x_offset, sysarg_t y_offset)
     42int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out)
    4443{
    4544        async_exch_t *exch = async_exchange_begin(sess);
    46         int ret = async_req_2_2(exch, WINDOW_REGISTER, x_offset, y_offset, in, out);
     45        int ret = async_req_0_2(exch, WINDOW_REGISTER, in, out);
    4746        async_exchange_end(exch);
    48 
     47       
    4948        return ret;
    5049}
     
    9291}
    9392
    94 int win_resize(async_sess_t *sess, sysarg_t width, sysarg_t height, void *cells)
     93int win_resize(async_sess_t *sess, sysarg_t x, sysarg_t y, sysarg_t width,
     94    sysarg_t height, window_placement_flags_t placement_flags, void *cells)
    9595{
    9696        async_exch_t *exch = async_exchange_begin(sess);
    97 
     97       
    9898        ipc_call_t answer;
    99         aid_t req = async_send_2(exch, WINDOW_RESIZE, width, height, &answer);
    100 
     99        aid_t req = async_send_5(exch, WINDOW_RESIZE, x, y, width, height,
     100            (sysarg_t) placement_flags, &answer);
     101       
    101102        int rc = async_share_out_start(exch, cells, AS_AREA_READ | AS_AREA_CACHEABLE);
    102 
     103       
    103104        async_exchange_end(exch);
    104 
     105       
    105106        sysarg_t ret;
    106107        async_wait_for(req, &ret);
    107 
    108         if (rc != EOK) {
     108       
     109        if (rc != EOK)
    109110                return rc;
    110         } else if (ret != EOK) {
     111        else if (ret != EOK)
    111112                return ret;
    112         } else {
    113                 return EOK;
    114         }
     113       
     114        return EOK;
    115115}
    116116
  • uspace/lib/c/include/io/window.h

    rba02baa r62fbb7e  
    4343#include <io/pos_event.h>
    4444
     45typedef enum {
     46        GF_EMPTY = 0,
     47        GF_MOVE_X = 1,
     48        GF_MOVE_Y = 2,
     49        GF_RESIZE_X = 4,
     50        GF_RESIZE_Y = 8,
     51        GF_SCALE_X = 16,
     52        GF_SCALE_Y = 32
     53} window_grab_flags_t;
     54
     55typedef enum {
     56        WINDOW_PLACEMENT_ANY = 0,
     57        WINDOW_PLACEMENT_CENTER_X = 1,
     58        WINDOW_PLACEMENT_CENTER_Y = 2,
     59        WINDOW_PLACEMENT_CENTER =
     60            WINDOW_PLACEMENT_CENTER_X | WINDOW_PLACEMENT_CENTER_Y,
     61        WINDOW_PLACEMENT_LEFT = 4,
     62        WINDOW_PLACEMENT_RIGHT = 8,
     63        WINDOW_PLACEMENT_TOP = 16,
     64        WINDOW_PLACEMENT_BOTTOM = 32,
     65        WINDOW_PLACEMENT_ABSOLUTE_X = 64,
     66        WINDOW_PLACEMENT_ABSOLUTE_Y = 128,
     67        WINDOW_PLACEMENT_ABSOLUTE =
     68            WINDOW_PLACEMENT_ABSOLUTE_X | WINDOW_PLACEMENT_ABSOLUTE_Y
     69} window_placement_flags_t;
     70
    4571typedef struct {
    4672        sysarg_t object;
    4773        sysarg_t slot;
    4874        sysarg_t argument;
    49 } sig_event_t;
     75} signal_event_t;
    5076
    5177typedef struct {
     78        sysarg_t offset_x;
     79        sysarg_t offset_y;
    5280        sysarg_t width;
    5381        sysarg_t height;
    54 } rsz_event_t;
     82        window_placement_flags_t placement_flags;
     83} resize_event_t;
    5584
    5685typedef enum {
     
    6998        kbd_event_t kbd;
    7099        pos_event_t pos;
    71         sig_event_t sig;
    72         rsz_event_t rsz;
     100        signal_event_t signal;
     101        resize_event_t resize;
    73102} window_event_data_t;
    74103
     
    79108} window_event_t;
    80109
    81 typedef enum {
    82         GF_EMPTY = 0,
    83         GF_MOVE_X = 1,
    84         GF_MOVE_Y = 2,
    85         GF_RESIZE_X = 4,
    86         GF_RESIZE_Y = 8,
    87         GF_SCALE_X = 16,
    88         GF_SCALE_Y = 32
    89 } window_grab_flags_t;
    90 
    91 extern int win_register(async_sess_t *, service_id_t *, service_id_t *, sysarg_t, sysarg_t);
     110extern int win_register(async_sess_t *, service_id_t *, service_id_t *);
    92111
    93112extern int win_get_event(async_sess_t *, window_event_t *);
     
    95114extern int win_damage(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
    96115extern int win_grab(async_sess_t *, sysarg_t, sysarg_t);
    97 extern int win_resize(async_sess_t *, sysarg_t, sysarg_t, void *);
     116extern int win_resize(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     117    window_placement_flags_t, void *);
    98118extern int win_close(async_sess_t *);
    99119extern int win_close_request(async_sess_t *);
  • uspace/lib/gui/connection.c

    rba02baa r62fbb7e  
    210210                        link_initialize(&event->link);
    211211                        event->type = ET_SIGNAL_EVENT;
    212                         event->data.sig.object = (sysarg_t) cur->widget;
    213                         event->data.sig.slot = (sysarg_t) cur->slot;
    214                         event->data.sig.argument = (sysarg_t) data_copy;
     212                        event->data.signal.object = (sysarg_t) cur->widget;
     213                        event->data.signal.slot = (sysarg_t) cur->slot;
     214                        event->data.signal.argument = (sysarg_t) data_copy;
    215215                        prodcons_produce(&cur->widget->window->events, &event->link);
    216216                } else {
  • uspace/lib/gui/window.c

    rba02baa r62fbb7e  
    352352}
    353353
    354 static void handle_signal_event(window_t *win, sig_event_t event)
     354static void handle_signal_event(window_t *win, signal_event_t event)
    355355{
    356356        widget_t *widget = (widget_t *) event.object;
     
    363363}
    364364
    365 static void handle_resize(window_t *win, sysarg_t width, sysarg_t height)
    366 {
    367         int rc;
    368         surface_t *old_surface;
    369         surface_t *new_surface;
    370 
     365static void handle_resize(window_t *win, sysarg_t offset_x, sysarg_t offset_y,
     366    sysarg_t width, sysarg_t height, window_placement_flags_t placement_flags)
     367{
    371368        if (width < 2 * border_thickness + header_min_width) {
    372369                win_damage(win->osess, 0, 0, 0, 0);
    373370                return;
    374371        }
    375 
     372       
    376373        if (height < 2 * border_thickness + header_height) {
    377374                win_damage(win->osess, 0, 0, 0, 0);
    378375                return;
    379376        }
    380 
     377       
    381378        /* Allocate resources for new surface. */
    382         new_surface = surface_create(width, height, NULL, SURFACE_FLAG_SHARED);
    383         if (!new_surface) {
     379        surface_t *new_surface = surface_create(width, height, NULL,
     380            SURFACE_FLAG_SHARED);
     381        if (!new_surface)
    384382                return;
    385         }
    386 
     383       
    387384        /* Switch new and old surface. */
    388385        fibril_mutex_lock(&win->guard);
    389         old_surface = win->surface;
     386        surface_t *old_surface = win->surface;
    390387        win->surface = new_surface;
    391388        fibril_mutex_unlock(&win->guard);
    392 
    393         /* Let all widgets in the tree alter their position and size. Widgets might
    394          * also paint themselves onto the new surface. */
     389       
     390        /*
     391         * Let all widgets in the tree alter their position and size.
     392         * Widgets might also paint themselves onto the new surface.
     393         */
    395394        win->root.rearrange(&win->root, 0, 0, width, height);
    396 
     395       
    397396        fibril_mutex_lock(&win->guard);
    398397        surface_reset_damaged_region(win->surface);
    399398        fibril_mutex_unlock(&win->guard);
    400 
     399       
    401400        /* Inform compositor about new surface. */
    402         rc = win_resize(win->osess,
    403                 width, height, surface_direct_access(new_surface));
    404 
     401        int rc = win_resize(win->osess, offset_x, offset_y, width, height,
     402            placement_flags, surface_direct_access(new_surface));
     403       
    405404        if (rc != EOK) {
    406405                /* Rollback to old surface. Reverse all changes. */
    407 
     406               
    408407                sysarg_t old_width = 0;
    409408                sysarg_t old_height = 0;
    410                 if (old_surface) {
     409                if (old_surface)
    411410                        surface_get_resolution(old_surface, &old_width, &old_height);
    412                 }
    413 
     411               
    414412                fibril_mutex_lock(&win->guard);
    415413                new_surface = win->surface;
    416414                win->surface = old_surface;
    417415                fibril_mutex_unlock(&win->guard);
    418 
     416               
    419417                win->root.rearrange(&win->root, 0, 0, old_width, old_height);
    420418               
     
    424422                        fibril_mutex_unlock(&win->guard);
    425423                }
    426 
     424               
    427425                surface_destroy(new_surface);
    428                 return;
    429         }
    430 
    431         /* Finally deallocate old surface. */
    432         if (old_surface) {
    433                 surface_destroy(old_surface);
     426        } else {
     427                /* Deallocate old surface. */
     428                if (old_surface)
     429                        surface_destroy(old_surface);
    434430        }
    435431}
     
    513509                        break;
    514510                case ET_SIGNAL_EVENT:
    515                         handle_signal_event(win, event->data.sig);
     511                        handle_signal_event(win, event->data.signal);
    516512                        break;
    517513                case ET_WINDOW_RESIZE:
    518                         handle_resize(win, event->data.rsz.width, event->data.rsz.height);
     514                        handle_resize(win, event->data.resize.offset_x,
     515                            event->data.resize.offset_y, event->data.resize.width,
     516                            event->data.resize.height, event->data.resize.placement_flags);
    519517                        break;
    520518                case ET_WINDOW_FOCUS:
     
    590588
    591589window_t *window_open(const char *winreg, bool is_main, bool is_decorated,
    592     const char *caption, sysarg_t x_offset, sysarg_t y_offset)
     590    const char *caption)
    593591{
    594592        window_t *win = (window_t *) malloc(sizeof(window_t));
     
    630628        service_id_t in_dsid;
    631629        service_id_t out_dsid;
    632         rc = win_register(reg_sess, &in_dsid, &out_dsid, x_offset, y_offset);
     630        rc = win_register(reg_sess, &in_dsid, &out_dsid);
    633631        async_hangup(reg_sess);
    634632        if (rc != EOK) {
     
    658656}
    659657
    660 void window_resize(window_t *win, sysarg_t width, sysarg_t height)
     658void window_resize(window_t *win, sysarg_t offset_x, sysarg_t offset_y,
     659    sysarg_t width, sysarg_t height, window_placement_flags_t placement_flags)
    661660{
    662661        window_event_t *event = (window_event_t *) malloc(sizeof(window_event_t));
     
    664663                link_initialize(&event->link);
    665664                event->type = ET_WINDOW_RESIZE;
    666                 event->data.rsz.width = width;
    667                 event->data.rsz.height = height;
     665                event->data.resize.offset_x = offset_x;
     666                event->data.resize.offset_y = offset_y;
     667                event->data.resize.width = width;
     668                event->data.resize.height = height;
     669                event->data.resize.placement_flags = placement_flags;
    668670                prodcons_produce(&win->events, &event->link);
    669671        }
  • uspace/lib/gui/window.h

    rba02baa r62fbb7e  
    6666 * If the window is declared as main, its closure causes termination of the
    6767 * whole application. Note that opened window does not have any surface yet. */
    68 extern window_t *window_open(const char *, bool, bool, const char *, sysarg_t,
    69     sysarg_t);
     68extern window_t *window_open(const char *, bool, bool, const char *);
    7069
    7170/**
     
    7473 * and to paint themselves on the new surface (top-bottom order). Should be
    7574 * called also after opening new window to obtain surface. */
    76 extern void window_resize(window_t *, sysarg_t, sysarg_t);
     75extern void window_resize(window_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     76    window_placement_flags_t);
    7777
    7878/**
  • uspace/srv/hid/compositor/compositor.c

    rba02baa r62fbb7e  
    166166}
    167167
    168 static pointer_t *pointer_create()
     168static pointer_t *pointer_create(void)
    169169{
    170170        pointer_t *p = (pointer_t *) malloc(sizeof(pointer_t));
     
    208208}
    209209
    210 static window_t *window_create(sysarg_t x_offset, sysarg_t y_offset)
     210static window_t *window_create(void)
    211211{
    212212        window_t *win = (window_t *) malloc(sizeof(window_t));
     
    218218        prodcons_initialize(&win->queue);
    219219        transform_identity(&win->transform);
    220         transform_translate(&win->transform,
    221             coord_origin + x_offset, coord_origin + y_offset);
    222         win->dx = coord_origin + x_offset;
    223         win->dy = coord_origin + y_offset;
     220        transform_translate(&win->transform, coord_origin, coord_origin);
     221        win->dx = coord_origin;
     222        win->dy = coord_origin;
    224223        win->fx = 1;
    225224        win->fy = 1;
     
    321320}
    322321
    323 static void comp_restrict_pointers(void)
     322static void comp_update_viewport_bound_rect(void)
    324323{
    325324        fibril_mutex_lock(&viewport_list_mtx);
    326 
     325       
    327326        sysarg_t x_res = coord_origin;
    328327        sysarg_t y_res = coord_origin;
    329328        sysarg_t w_res = 0;
    330329        sysarg_t h_res = 0;
    331 
     330       
    332331        if (!list_empty(&viewport_list)) {
    333332                viewport_t *vp = (viewport_t *) list_first(&viewport_list);
     
    336335                surface_get_resolution(vp->surface, &w_res, &h_res);
    337336        }
    338 
     337       
    339338        list_foreach(viewport_list, link, viewport_t, vp) {
    340339                sysarg_t w_vp, h_vp;
    341340                surface_get_resolution(vp->surface, &w_vp, &h_vp);
    342                 rectangle_union(
    343                     x_res, y_res, w_res, h_res,
     341                rectangle_union(x_res, y_res, w_res, h_res,
    344342                    vp->pos.x, vp->pos.y, w_vp, h_vp,
    345343                    &x_res, &y_res, &w_res, &h_res);
    346344        }
    347 
     345       
    348346        viewport_bound_rect.x = x_res;
    349347        viewport_bound_rect.y = y_res;
    350348        viewport_bound_rect.w = w_res;
    351349        viewport_bound_rect.h = h_res;
    352 
     350       
    353351        fibril_mutex_unlock(&viewport_list_mtx);
    354 
     352}
     353
     354static void comp_restrict_pointers(void)
     355{
     356        comp_update_viewport_bound_rect();
     357       
    355358        fibril_mutex_lock(&pointer_list_mtx);
    356 
     359       
    357360        list_foreach(pointer_list, link, pointer_t, ptr) {
    358361                ptr->pos.x = ptr->pos.x > viewport_bound_rect.x ? ptr->pos.x : viewport_bound_rect.x;
     
    363366                    ptr->pos.y : viewport_bound_rect.y + viewport_bound_rect.h;
    364367        }
    365 
     368       
    366369        fibril_mutex_unlock(&pointer_list_mtx);
    367370}
     
    642645}
    643646
     647static void comp_recalc_transform(window_t *win)
     648{
     649        transform_t translate;
     650        transform_identity(&translate);
     651        transform_translate(&translate, win->dx, win->dy);
     652       
     653        transform_t scale;
     654        transform_identity(&scale);
     655        if ((win->fx != 1) || (win->fy != 1))
     656                transform_scale(&scale, win->fx, win->fy);
     657       
     658        transform_t rotate;
     659        transform_identity(&rotate);
     660        if (win->angle != 0)
     661                transform_rotate(&rotate, win->angle);
     662       
     663        transform_t transform;
     664        transform_t temp;
     665        transform_identity(&transform);
     666        temp = transform;
     667        transform_multiply(&transform, &temp, &translate);
     668        temp = transform;
     669        transform_multiply(&transform, &temp, &rotate);
     670        temp = transform;
     671        transform_multiply(&transform, &temp, &scale);
     672       
     673        win->transform = transform;
     674}
     675
    644676static void comp_window_resize(window_t *win, ipc_callid_t iid, ipc_call_t *icall)
    645677{
     
    662694       
    663695        /* Create new surface for the resized window. */
    664         surface_t *new_surface = surface_create(IPC_GET_ARG1(*icall),
    665             IPC_GET_ARG2(*icall), new_cell_storage, SURFACE_FLAG_SHARED);
     696        surface_t *new_surface = surface_create(IPC_GET_ARG3(*icall),
     697            IPC_GET_ARG4(*icall), new_cell_storage, SURFACE_FLAG_SHARED);
    666698        if (!new_surface) {
    667699                as_area_destroy(new_cell_storage);
     
    670702        }
    671703       
     704        sysarg_t offset_x = IPC_GET_ARG1(*icall);
     705        sysarg_t offset_y = IPC_GET_ARG2(*icall);
     706        window_placement_flags_t placement_flags =
     707            (window_placement_flags_t) IPC_GET_ARG5(*icall);
     708       
     709        comp_update_viewport_bound_rect();
     710       
    672711        /* Switch new surface with old surface and calculate damage. */
    673712        fibril_mutex_lock(&window_list_mtx);
     
    687726        surface_get_resolution(win->surface, &new_width, &new_height);
    688727       
     728        if (placement_flags & WINDOW_PLACEMENT_CENTER_X)
     729                win->dx = viewport_bound_rect.x + viewport_bound_rect.w / 2 -
     730                    new_width / 2;
     731       
     732        if (placement_flags & WINDOW_PLACEMENT_CENTER_Y)
     733                win->dy = viewport_bound_rect.y + viewport_bound_rect.h / 2 -
     734                    new_height / 2;
     735       
     736        if (placement_flags & WINDOW_PLACEMENT_LEFT)
     737                win->dx = viewport_bound_rect.x;
     738       
     739        if (placement_flags & WINDOW_PLACEMENT_TOP)
     740                win->dy = viewport_bound_rect.y;
     741       
     742        if (placement_flags & WINDOW_PLACEMENT_RIGHT)
     743                win->dx = viewport_bound_rect.x + viewport_bound_rect.w -
     744                    new_width;
     745       
     746        if (placement_flags & WINDOW_PLACEMENT_BOTTOM)
     747                win->dy = viewport_bound_rect.y + viewport_bound_rect.h -
     748                    new_height;
     749       
     750        if (placement_flags & WINDOW_PLACEMENT_ABSOLUTE_X)
     751                win->dx = coord_origin + offset_x;
     752       
     753        if (placement_flags & WINDOW_PLACEMENT_ABSOLUTE_Y)
     754                win->dy = coord_origin + offset_y;
     755       
     756        /* Transform the window and calculate damage. */
     757        sysarg_t x1;
     758        sysarg_t y1;
     759        sysarg_t width1;
     760        sysarg_t height1;
     761       
     762        comp_coord_bounding_rect(0, 0, old_width, old_height, win->transform,
     763            &x1, &y1, &width1, &height1);
     764       
     765        comp_recalc_transform(win);
     766       
     767        sysarg_t x2;
     768        sysarg_t y2;
     769        sysarg_t width2;
     770        sysarg_t height2;
     771       
     772        comp_coord_bounding_rect(0, 0, new_width, new_height, win->transform,
     773            &x2, &y2, &width2, &height2);
     774       
    689775        sysarg_t x;
    690776        sysarg_t y;
    691         sysarg_t width = old_width > new_width ? old_width : new_width;
    692         sysarg_t height = old_height > new_height ? old_height : new_height;
    693         comp_coord_bounding_rect(0, 0, width, height, win->transform, &x, &y,
    694             &width, &height);
     777        sysarg_t width;
     778        sysarg_t height;
     779       
     780        rectangle_union(x1, y1, width1, height1, x2, y2, width2, height2,
     781            &x, &y, &width, &height);
    695782       
    696783        fibril_mutex_unlock(&window_list_mtx);
     
    803890                        fibril_mutex_lock(&window_list_mtx);
    804891
    805                         window_t *win = window_create(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     892                        window_t *win = window_create();
    806893                        if (!win) {
    807894                                async_answer_2(callid, ENOMEM, 0, 0);
     
    11731260
    11741261        return vp;
    1175 }
    1176 
    1177 static void comp_recalc_transform(window_t *win)
    1178 {
    1179         transform_t translate;
    1180         transform_identity(&translate);
    1181         transform_translate(&translate, win->dx, win->dy);
    1182        
    1183         transform_t scale;
    1184         transform_identity(&scale);
    1185         if ((win->fx != 1) || (win->fy != 1))
    1186                 transform_scale(&scale, win->fx, win->fy);
    1187        
    1188         transform_t rotate;
    1189         transform_identity(&rotate);
    1190         if (win->angle != 0)
    1191                 transform_rotate(&rotate, win->angle);
    1192        
    1193         transform_t transform;
    1194         transform_t temp;
    1195         transform_identity(&transform);
    1196         temp = transform;
    1197         transform_multiply(&transform, &temp, &translate);
    1198         temp = transform;
    1199         transform_multiply(&transform, &temp, &rotate);
    1200         temp = transform;
    1201         transform_multiply(&transform, &temp, &scale);
    1202        
    1203         win->transform = transform;
    12041262}
    12051263
     
    12471305        }
    12481306
    1249         if (scale || resize) {
     1307        if ((scale) || (resize)) {
    12501308                double _dx = dx;
    12511309                double _dy = dy;
     
    14451503{
    14461504        pointer_t *pointer = input_pointer(input);
    1447 
     1505       
     1506        comp_update_viewport_bound_rect();
     1507       
    14481508        /* Update pointer position. */
    14491509        fibril_mutex_lock(&pointer_list_mtx);
     1510       
    14501511        desktop_point_t old_pos = pointer->pos;
     1512       
    14511513        sysarg_t cursor_width;
    14521514        sysarg_t cursor_height;
    1453         surface_get_resolution(pointer->cursor.states[pointer->state], 
     1515        surface_get_resolution(pointer->cursor.states[pointer->state],
    14541516             &cursor_width, &cursor_height);
    1455         if (pointer->pos.x + dx < viewport_bound_rect.x) {
     1517       
     1518        if (pointer->pos.x + dx < viewport_bound_rect.x)
    14561519                dx = -1 * (pointer->pos.x - viewport_bound_rect.x);
    1457         }
    1458         if (pointer->pos.y + dy < viewport_bound_rect.y) {
     1520       
     1521        if (pointer->pos.y + dy < viewport_bound_rect.y)
    14591522                dy = -1 * (pointer->pos.y - viewport_bound_rect.y);
    1460         }
    1461         if (pointer->pos.x + dx > viewport_bound_rect.x + viewport_bound_rect.w) {
     1523       
     1524        if (pointer->pos.x + dx > viewport_bound_rect.x + viewport_bound_rect.w)
    14621525                dx = (viewport_bound_rect.x + viewport_bound_rect.w - pointer->pos.x);
    1463         }
    1464         if (pointer->pos.y + dy > viewport_bound_rect.y + viewport_bound_rect.h) {
     1526       
     1527        if (pointer->pos.y + dy > viewport_bound_rect.y + viewport_bound_rect.h)
    14651528                dy = (viewport_bound_rect.y + viewport_bound_rect.h - pointer->pos.y);
    1466         }
     1529       
    14671530        pointer->pos.x += dx;
    14681531        pointer->pos.y += dy;
     
    14701533        comp_damage(old_pos.x, old_pos.y, cursor_width, cursor_height);
    14711534        comp_damage(old_pos.x + dx, old_pos.y + dy, cursor_width, cursor_height);
    1472 
     1535       
    14731536        fibril_mutex_lock(&window_list_mtx);
    14741537        fibril_mutex_lock(&pointer_list_mtx);
     
    16311694
    16321695#if ANIMATE_WINDOW_TRANSFORMS == 0
    1633                 sysarg_t pre_x = 0; 
     1696                sysarg_t pre_x = 0;
    16341697                sysarg_t pre_y = 0;
    16351698                sysarg_t pre_width = 0;
     
    16631726                                link_initialize(&event_top->link);
    16641727                                event_top->type = ET_WINDOW_RESIZE;
    1665 
     1728                               
     1729                                event_top->data.resize.offset_x = 0;
     1730                                event_top->data.resize.offset_y = 0;
     1731                               
    16661732                                int dx = (int) (((double) width) * (scale_back_x - 1.0));
    16671733                                int dy = (int) (((double) height) * (scale_back_y - 1.0));
    1668 
    1669                                 if (pointer->grab_flags & GF_RESIZE_X) {
    1670                                         event_top->data.rsz.width =
    1671                                                 ((((int) width) + dx) >= 0) ? (width + dx) : 0;
    1672                                 } else {
    1673                                         event_top->data.rsz.width = width;
    1674                                 }
    1675 
    1676                                 if (pointer->grab_flags & GF_RESIZE_Y) {
    1677                                         event_top->data.rsz.height =
    1678                                                 ((((int) height) + dy) >= 0) ? (height + dy) : 0;
    1679                                 } else {
    1680                                         event_top->data.rsz.height = height;
    1681                                 }
     1734                               
     1735                                if (pointer->grab_flags & GF_RESIZE_X)
     1736                                        event_top->data.resize.width =
     1737                                            ((((int) width) + dx) >= 0) ? (width + dx) : 0;
     1738                                else
     1739                                        event_top->data.resize.width = width;
     1740                               
     1741                                if (pointer->grab_flags & GF_RESIZE_Y)
     1742                                        event_top->data.resize.height =
     1743                                            ((((int) height) + dy) >= 0) ? (height + dy) : 0;
     1744                                else
     1745                                        event_top->data.resize.height = height;
     1746                               
     1747                                event_top->data.resize.placement_flags =
     1748                                    WINDOW_PLACEMENT_ANY;
    16821749                        }
    16831750
     
    18161883                                return ENOMEM;
    18171884                        }
    1818 
     1885                       
    18191886                        sysarg_t width, height;
    18201887                        surface_get_resolution(win->surface, &width, &height);
    1821 
     1888                       
    18221889                        link_initialize(&event->link);
    18231890                        event->type = ET_WINDOW_RESIZE;
    1824 
     1891                       
     1892                        event->data.resize.offset_x = 0;
     1893                        event->data.resize.offset_y = 0;
     1894                       
    18251895                        switch (key) {
    18261896                        case KC_T:
    1827                                 event->data.rsz.width = width;
    1828                                 event->data.rsz.height = (height >= 20) ? height - 20 : 0;
     1897                                event->data.resize.width = width;
     1898                                event->data.resize.height = (height >= 20) ? height - 20 : 0;
    18291899                                break;
    18301900                        case KC_G:
    1831                                 event->data.rsz.width = width;
    1832                                 event->data.rsz.height = height + 20;
     1901                                event->data.resize.width = width;
     1902                                event->data.resize.height = height + 20;
    18331903                                break;
    18341904                        case KC_B:
    1835                                 event->data.rsz.width = (width >= 20) ? width - 20 : 0;;
    1836                                 event->data.rsz.height = height;
     1905                                event->data.resize.width = (width >= 20) ? width - 20 : 0;;
     1906                                event->data.resize.height = height;
    18371907                                break;
    18381908                        case KC_N:
    1839                                 event->data.rsz.width = width + 20;
    1840                                 event->data.rsz.height = height;
     1909                                event->data.resize.width = width + 20;
     1910                                event->data.resize.height = height;
    18411911                                break;
    18421912                        default:
    1843                                 event->data.rsz.width = 0;
    1844                                 event->data.rsz.height = 0;
    1845                                 break;
    1846                         }
    1847 
     1913                                event->data.resize.width = 0;
     1914                                event->data.resize.height = 0;
     1915                                break;
     1916                        }
     1917                       
     1918                        event->data.resize.placement_flags = WINDOW_PLACEMENT_ANY;
     1919                       
    18481920                        fibril_mutex_unlock(&window_list_mtx);
    18491921                        comp_post_event_top(event);
Note: See TracChangeset for help on using the changeset viewer.