Ignore:
Timestamp:
2014-01-16T20:43:22Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.