ioncore/stacking.c

   1 /*
   2  * ion/ioncore/stacking.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <libtu/rb.h>
  10 #include <libtu/minmax.h>
  11
  12 #include "common.h"
  13 #include "region.h"
  14 #include "stacking.h"
  15 #include "window.h"
  16 #include "sizepolicy.h"
  17
  18
  19 /*{{{ Alloc */
  20
  21
  22 WStacking *create_stacking()
  23 {
  24     WStacking *st=ALLOC(WStacking);
  25
  26     if(st!=NULL){
  27         st->reg=NULL;
  28         st->above=NULL;
  29         st->level=0;
  30         st->szplcy=SIZEPOLICY_DEFAULT;
  31         st->hidden=FALSE;
  32         st->lnode=NULL;
  33         st->pseudomodal=FALSE;
  34     }
  35
  36     return st;
  37 }
  38
  39
  40 void stacking_free(WStacking *st)
  41 {
  42     assert(st->mgr_next==NULL && st->mgr_prev==NULL &&
  43            st->next==NULL && st->prev==NULL &&
  44            /*st->above==NULL &&*/
  45            st->lnode==NULL &&
  46            st->reg==NULL);
  47
  48     free(st);
  49 }
  50
  51
  52 /*}}}*/
  53
  54
  55 /*{{{ Lookup */
  56
  57
  58 static Rb_node stacking_of_reg=NULL;
  59
  60
  61 WStacking *ioncore_find_stacking(WRegion *reg)
  62 {
  63     Rb_node node=NULL;
  64     int found=0;
  65
  66     if(stacking_of_reg!=NULL)
  67         node=rb_find_pkey_n(stacking_of_reg, reg, &found);
  68
  69     return (found ? (WStacking*)node->v.val : NULL);
  70 }
  71
  72
  73 void stacking_unassoc(WStacking *st)
  74 {
  75     Rb_node node=NULL;
  76     int found=0;
  77
  78     if(st->reg==NULL)
  79         return;
  80
  81     if(stacking_of_reg!=NULL)
  82         node=rb_find_pkey_n(stacking_of_reg, st->reg, &found);
  83
  84     if(node!=NULL)
  85         rb_delete_node(node);
  86
  87     st->reg=NULL;
  88 }
  89
  90
  91 bool stacking_assoc(WStacking *st, WRegion *reg)
  92 {
  93     assert(st->reg==NULL);
  94
  95     if(stacking_of_reg==NULL){
  96         stacking_of_reg=make_rb();
  97         if(stacking_of_reg==NULL)
  98             return FALSE;
  99     }
 100
 101     if(rb_insertp(stacking_of_reg, reg, st)==NULL)
 102         return FALSE;
 103
 104     st->reg=reg;
 105     return TRUE;
 106 }
 107
 108
 109 /*}}}*/
 110
 111
 112
 113 /*{{{ List processing */
 114
 115
 116 static WStacking *link_lists(WStacking *l1, WStacking *l2)
 117 {
 118     /* As everywhere, doubly-linked lists without the forward
 119      * link in last item!
 120      */
 121     WStacking *tmp=l2->prev;
 122     l1->prev->next=l2;
 123     l2->prev=l1->prev;
 124     l1->prev=tmp;
 125     return l1;
 126 }
 127
 128
 129 static WStacking *link_list_before(WStacking *l1,
 130                                    WStacking *i1,
 131                                    WStacking *l2)
 132 {
 133     WStacking *tmp;
 134
 135     if(i1==l1)
 136         return link_lists(l2, l1);
 137
 138     l2->prev->next=i1;
 139     i1->prev->next=l2;
 140     tmp=i1->prev;
 141     i1->prev=l2->prev;
 142     l2->prev=tmp;
 143
 144     return l1;
 145 }
 146
 147
 148 static WStacking *link_list_after(WStacking *l1,
 149                                   WStacking *i1,
 150                                   WStacking *l2)
 151 {
 152     if(i1==l1->prev)
 153         return link_lists(l1, l2);
 154
 155     i1->next->prev=l2->prev;
 156     l2->prev->next=i1->next;
 157     i1->next=l2;
 158     l2->prev=i1;
 159
 160     return l1;
 161 }
 162
 163
 164 WStacking *stacking_unstack(WWindow *par, WStacking *regst)
 165 {
 166     WStacking *nxt=NULL, *st;
 167
 168     /*st=regst->next;*/
 169
 170     UNLINK_ITEM(par->stacking, regst, next, prev);
 171
 172     /*while(st!=NULL){*/
 173     for(st=par->stacking; st!=NULL; st=st->next){
 174         if(st->above==regst){
 175             st->above=NULL;
 176             nxt=st;
 177         }
 178         /*st=st->next;*/
 179     }
 180
 181     if(nxt==NULL)
 182         nxt=regst->above;
 183
 184     if(regst->above==NULL)
 185         regst->above=NULL;
 186
 187     return nxt;
 188 }
 189
 190
 191 static bool cf(WStackingFilter *filt, void *filt_data, WStacking *st)
 192 {
 193     return (filt==NULL || filt(st, filt_data));
 194 }
 195
 196
 197 static bool check_unweave(WStacking *st)
 198 {
 199     /* 2: unknown, 1: yes, 0: no */
 200
 201     if(st->to_unweave==2){
 202         if(st->above!=NULL)
 203             st->to_unweave=check_unweave(st->above);
 204         else
 205             st->to_unweave=0;
 206     }
 207
 208     return st->to_unweave;
 209 }
 210
 211
 212 WStacking *stacking_unweave(WStacking **stacking,
 213                             WStackingFilter *filt, void *filt_data)
 214 {
 215     WStacking *np=NULL;
 216     WStacking *st, *next;
 217
 218     for(st=*stacking; st!=NULL; st=st->next){
 219         st->to_unweave=2;
 220         if(st->above==NULL && cf(filt, filt_data, st))
 221             st->to_unweave=1;
 222     }
 223
 224     for(st=*stacking; st!=NULL; st=st->next)
 225         check_unweave(st);
 226
 227     for(st=*stacking; st!=NULL; st=next){
 228         next=st->next;
 229         if(st->to_unweave==1){
 230             UNLINK_ITEM(*stacking, st, next, prev);
 231             LINK_ITEM(np, st, next, prev);
 232         }
 233     }
 234
 235     return np;
 236 }
 237
 238
 239 static int check_above_lvl(WStacking *st)
 240 {
 241     if(st->above==NULL)
 242         return st->level;
 243     st->level=check_above_lvl(st->above);
 244     return st->level;
 245 }
 246
 247
 248 static void enforce_level_sanity(WStacking **np)
 249 {
 250     WStacking *st;
 251
 252     /* Make sure that the levels of stuff stacked 'above' match
 253      * the level of the thing stacked above.
 254      */
 255     for(st=*np; st!=NULL; st=st->next)
 256         check_above_lvl(st);
 257
 258     /* And now make sure things are ordered by levels. */
 259     st=*np;
 260     while(st->next!=NULL){
 261         if(st->next->level < st->level){
 262             WStacking *st2=st->next;
 263             UNLINK_ITEM(*np, st2, next, prev);
 264             LINK_ITEM_BEFORE(*np, st2, st, next, prev);
 265             if(st2->prev!=NULL)
 266                 st=st2->prev;
 267         }else{
 268             st=st->next;
 269         }
 270     }
 271 }
 272
 273
 274 static void get_bottom(WStacking *st, Window fb_win,
 275                        Window *other, int *mode)
 276 {
 277     Window bottom=None, top=None;
 278
 279     while(st!=NULL){
 280         if(st->reg!=NULL){
 281             region_stacking(st->reg, &bottom, &top);
 282             if(bottom!=None){
 283                 *other=bottom;
 284                 *mode=Below;
 285                 return;
 286             }
 287         }
 288         st=st->next;
 289     }
 290
 291     *other=fb_win;
 292     *mode=Above;
 293 }
 294
 295
 296 static void stacking_do_weave(WStacking **stacking, WStacking **np,
 297                               bool below, Window fb_win)
 298 {
 299     WStacking *st, *ab;
 300     uint lvl;
 301     Window other;
 302     int mode;
 303
 304     if(*np==NULL)
 305         return;
 306
 307     /* Should do nothing.. */
 308     enforce_level_sanity(np);
 309
 310     ab=*stacking;
 311
 312     while(*np!=NULL){
 313         lvl=(*np)->level;
 314
 315         while(ab!=NULL){
 316             if(ab->level>lvl || (below && ab->level==lvl))
 317                 break;
 318             ab=ab->next;
 319         }
 320         get_bottom(ab, fb_win, &other, &mode);
 321
 322         st=*np;
 323
 324         UNLINK_ITEM(*np, st, next, prev);
 325
 326         region_restack(st->reg, other, mode);
 327
 328         if(ab!=NULL){
 329             LINK_ITEM_BEFORE(*stacking, ab, st, next, prev);
 330         }else{
 331             LINK_ITEM_LAST(*stacking, st, next, prev);
 332         }
 333     }
 334 }
 335
 336
 337 void stacking_weave(WStacking **stacking, WStacking **np, bool below)
 338 {
 339     stacking_do_weave(stacking, np, below, None);
 340 }
 341
 342
 343 /*}}}*/
 344
 345
 346 /*{{{ Raise/lower */
 347
 348
 349 static bool is_above(WStacking *st, WStacking *p)
 350 {
 351     if(st->above==NULL)
 352         return FALSE;
 353     else if(st->above==p)
 354         return TRUE;
 355     else
 356         return is_above(st->above, p);
 357 }
 358
 359
 360 static void collect_first(WStacking **dst, WStacking **src, WStacking *st)
 361 {
 362     UNLINK_ITEM(*src, st, next, prev);
 363     LINK_ITEM_FIRST(*dst, st, next, prev);
 364 }
 365
 366
 367 static void collect_last(WStacking **dst, WStacking **src, WStacking *st)
 368 {
 369     UNLINK_ITEM(*src, st, next, prev);
 370     LINK_ITEM_LAST(*dst, st, next, prev);
 371 }
 372
 373
 374 static void collect_above(WStacking **dst, WStacking **src, WStacking *regst)
 375 {
 376     WStacking *stabove, *stnext;
 377
 378     for(stabove=*src; stabove!=NULL; stabove=stnext){
 379         stnext=stabove->next;
 380
 381         if(is_above(stabove, regst))
 382             collect_last(dst, src, stabove);
 383     }
 384 }
 385
 386
 387 static WStacking *unweave_subtree(WStacking **stacking, WStacking *regst,
 388                                   bool parents)
 389 {
 390     WStacking *tmp=NULL;
 391
 392     if(parents){
 393         WStacking *st=regst;
 394         while(st!=NULL){
 395             collect_first(&tmp, stacking, st);
 396             st=st->above;
 397         }
 398     }else{
 399         collect_first(&tmp, stacking, regst);
 400     }
 401
 402     collect_above(&tmp, stacking, regst);
 403
 404     return tmp;
 405 }
 406
 407
 408 void stacking_restack(WStacking **stacking, WStacking *st, Window fb_win,
 409                       WStackingFilter *filt, void *filt_data, bool lower)
 410 {
 411     WStacking *tmp=unweave_subtree(stacking, st, lower);
 412
 413     stacking_do_weave(stacking, &tmp, lower, fb_win);
 414
 415     assert(tmp==NULL);
 416 }
 417
 418
 419 /*}}}*/
 420
 421
 422 /*{{{ Stacking lists */
 423
 424
 425 WStacking **window_get_stackingp(WWindow *wwin)
 426 {
 427     return &(wwin->stacking);
 428 }
 429
 430
 431 WStacking *window_get_stacking(WWindow *wwin)
 432 {
 433     return wwin->stacking;
 434 }
 435
 436
 437 /*}}}*/
 438
 439
 440 /*{{{ Stacking list iteration */
 441
 442
 443 void stacking_iter_init(WStackingIterTmp *tmp,
 444                         WStacking *st,
 445                         WStackingFilter *filt,
 446                         void *filt_data)
 447 {
 448     tmp->st=st;
 449     tmp->filt=filt;
 450     tmp->filt_data=filt_data;
 451 }
 452
 453
 454 WStacking *stacking_iter_nodes(WStackingIterTmp *tmp)
 455 {
 456     WStacking *next=NULL;
 457
 458     while(tmp->st!=NULL){
 459         next=tmp->st;
 460         tmp->st=tmp->st->next;
 461         if(cf(tmp->filt, tmp->filt_data, next))
 462             break;
 463         next=NULL;
 464     }
 465
 466     return next;
 467 }
 468
 469
 470 WRegion *stacking_iter(WStackingIterTmp *tmp)
 471 {
 472     WStacking *st=stacking_iter_nodes(tmp);
 473     return (st!=NULL ? st->reg : NULL);
 474 }
 475
 476
 477 void stacking_iter_mgr_init(WStackingIterTmp *tmp,
 478                             WStacking *st,
 479                             WStackingFilter *filt,
 480                             void *filt_data)
 481 {
 482     tmp->st=st;
 483     tmp->filt=filt;
 484     tmp->filt_data=filt_data;
 485 }
 486
 487
 488 WStacking *stacking_iter_mgr_nodes(WStackingIterTmp *tmp)
 489 {
 490     WStacking *next=NULL;
 491
 492     while(tmp->st!=NULL){
 493         next=tmp->st;
 494         tmp->st=tmp->st->mgr_next;
 495         if(cf(tmp->filt, tmp->filt_data, next))
 496             break;
 497         next=NULL;
 498     }
 499
 500     return next;
 501 }
 502
 503
 504 WRegion *stacking_iter_mgr(WStackingIterTmp *tmp)
 505 {
 506     WStacking *st=stacking_iter_mgr_nodes(tmp);
 507     return (st!=NULL ? st->reg : NULL);
 508 }
 509
 510
 511 /*}}}*/
 512
 513
 514 /*{{{ Focus */
 515
 516
 517 uint stacking_min_level(WStacking *stacking,
 518                         WStackingFilter *include_filt,
 519                         void *filt_data)
 520 {
 521     uint min_level=STACKING_LEVEL_BOTTOM;
 522     WStacking *st=NULL;
 523
 524     if(stacking==NULL)
 525         return STACKING_LEVEL_BOTTOM;
 526
 527     st=stacking;
 528     do{
 529         st=st->prev;
 530
 531         if(st->reg!=NULL
 532            && !(st->reg->flags&REGION_SKIP_FOCUS)
 533            && cf(include_filt, filt_data, st)){
 534
 535             if(st->level>=STACKING_LEVEL_MODAL1)
 536                 min_level=st->level;
 537
 538             break;
 539         }
 540     }while(st!=stacking);
 541
 542     return min_level;
 543 }
 544
 545
 546 WStacking *stacking_find_to_focus(WStacking *stacking,
 547                                   WStacking *to_try,
 548                                   WStackingFilter *include_filt,
 549                                   WStackingFilter *approve_filt,
 550                                   void *filt_data)
 551 {
 552     uint min_level=STACKING_LEVEL_BOTTOM;
 553     WStacking *st=NULL, *found=NULL;
 554
 555     if(stacking==NULL)
 556         return NULL;
 557
 558     st=stacking;
 559     do{
 560         st=st->prev;
 561
 562         if(st->reg==NULL)
 563             continue;
 564
 565         if(st!=to_try && (st->reg->flags&REGION_SKIP_FOCUS ||
 566                           !cf(include_filt, filt_data, st))){
 567             /* skip */
 568             continue;
 569         }
 570
 571         if(st->level<min_level)
 572             break; /* no luck */
 573
 574         if(st==to_try)
 575             return st;
 576
 577         if(found==NULL && cf(approve_filt, filt_data, st)){
 578             found=st;
 579             if(to_try==NULL)
 580                 break;
 581         }
 582
 583         if(st->level>=STACKING_LEVEL_MODAL1)
 584             min_level=maxof(min_level, st->level);
 585     }while(st!=stacking);
 586
 587     return found;
 588 }
 589
 590
 591 static bool mapped_filt(WStacking *st, void *UNUSED(unused))
 592 {
 593     return (st->reg!=NULL && REGION_IS_MAPPED(st->reg));
 594 }
 595
 596
 597 static bool mapped_filt_neq(WStacking *st, void *st_neq)
 598 {
 599     return (st!=(WStacking*)st_neq && mapped_filt(st, NULL));
 600 }
 601
 602
 603 static bool mgr_filt(WStacking *st, void *mgr_)
 604 {
 605     return (st->reg!=NULL && REGION_MANAGER(st->reg)==(WRegion*)mgr_);
 606 }
 607
 608
 609 WStacking *stacking_find_to_focus_mapped(WStacking *stacking,
 610                                          WStacking *to_try,
 611                                          WRegion *mgr)
 612 {
 613     if(mgr==NULL){
 614         return stacking_find_to_focus(stacking, to_try, mapped_filt,
 615                                       NULL, NULL);
 616     }else{
 617         return stacking_find_to_focus(stacking, to_try, mapped_filt,
 618                                       mgr_filt, mgr);
 619     }
 620 }
 621
 622
 623 uint stacking_min_level_mapped(WStacking *stacking)
 624 {
 625     return stacking_min_level(stacking, mapped_filt, NULL);
 626 }
 627
 628
 629 bool stacking_must_focus(WStacking *stacking, WStacking *st)
 630 {
 631     WStacking *stf=stacking_find_to_focus(stacking, NULL,
 632                                           mapped_filt_neq, NULL, st);
 633
 634     return (stf==NULL ||
 635             (st->level>stf->level &&
 636              st->level>=STACKING_LEVEL_MODAL1));
 637 }
 638
 639
 640 /*}}}*/
 641