ioncore/region.c

   1 /*
   2  * ion/ioncore/region.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <string.h>
  10
  11 #include <X11/Xatom.h>
  12
  13 #include <libtu/objp.h>
  14 #include <libextl/extl.h>
  15 #include <libmainloop/defer.h>
  16
  17 #include "property.h"
  18 #include "common.h"
  19 #include "global.h"
  20 #include "region.h"
  21 #include "focus.h"
  22 #include "regbind.h"
  23 #include "names.h"
  24 #include "resize.h"
  25 #include "manage.h"
  26 #include "extlconv.h"
  27 #include "activity.h"
  28 #include "region-iter.h"
  29 #include "return.h"
  30 #include "key.h"
  31
  32
  33 #define D2(X)
  34
  35
  36 WHook *region_notify_hook=NULL;
  37
  38
  39 static void region_notify_change_(WRegion *reg, WRegionNotify how);
  40
  41
  42 /*{{{ Init & deinit */
  43
  44
  45 void region_init(WRegion *reg, WWindow *par, const WFitParams *fp)
  46 {
  47     if(fp->g.w<0 || fp->g.h<0)
  48         warn(TR("Creating region with negative width or height!"));
  49
  50     reg->geom=fp->g;
  51     reg->flags=0;
  52     reg->bindings=NULL;
  53     reg->rootwin=NULL;
  54
  55     reg->children=NULL;
  56     reg->parent=NULL;
  57     reg->p_next=NULL;
  58     reg->p_prev=NULL;
  59
  60     reg->active_sub=NULL;
  61     reg->active_prev=NULL;
  62     reg->active_next=NULL;
  63
  64     reg->ni.name=NULL;
  65     reg->ni.inst_off=0;
  66     reg->ni.node=NULL;
  67
  68     reg->manager=NULL;
  69
  70     reg->submapstat=NULL;
  71
  72     reg->mgd_activity=FALSE;
  73
  74     if(par!=NULL){
  75         reg->rootwin=((WRegion*)par)->rootwin;
  76         region_set_parent(reg, par);
  77     }else{
  78         assert(OBJ_IS(reg, WRootWin));
  79     }
  80 }
  81
  82
  83 static void destroy_children(WRegion *reg)
  84 {
  85     WRegion *sub, *prev=NULL;
  86     bool complained=FALSE;
  87
  88     /* destroy children */
  89     while(1){
  90         sub=reg->children;
  91         if(sub==NULL)
  92             break;
  93         assert(!OBJ_IS_BEING_DESTROYED(sub));
  94         assert(sub!=prev);
  95         if(ioncore_g.opmode!=IONCORE_OPMODE_DEINIT && !complained && OBJ_IS(reg, WClientWin)){
  96             warn(TR("Destroying object \"%s\" with client windows as "
  97                     "children."), region_name(reg));
  98             complained=TRUE;
  99         }
 100         prev=sub;
 101         destroy_obj((Obj*)sub);
 102     }
 103 }
 104
 105
 106 void region_deinit(WRegion *reg)
 107 {
 108     region_notify_change(reg, ioncore_g.notifies.deinit);
 109
 110     destroy_children(reg);
 111
 112     if(ioncore_g.focus_next==reg){
 113         D(warn("Region to be focused next destroyed[1]."));
 114         ioncore_g.focus_next=NULL;
 115     }
 116
 117     assert(reg->submapstat==NULL);
 118     /*region_free_submapstat(reg);*/
 119     region_detach_manager(reg);
 120     region_unset_return(reg);
 121     region_unset_parent(reg);
 122     region_remove_bindings(reg);
 123
 124     region_unregister(reg);
 125
 126     region_focuslist_deinit(reg);
 127
 128     if(ioncore_g.focus_next==reg){
 129         D(warn("Region to be focused next destroyed[2]."));
 130         ioncore_g.focus_next=NULL;
 131     }
 132 }
 133
 134
 135 /*}}}*/
 136
 137
 138 /*{{{ Dynfuns */
 139
 140
 141 bool region_fitrep(WRegion *reg, WWindow *par, const WFitParams *fp)
 142 {
 143     bool ret=FALSE;
 144     CALL_DYN_RET(ret, bool, region_fitrep, reg, (reg, par, fp));
 145     return ret;
 146 }
 147
 148
 149 void region_updategr(WRegion *reg)
 150 {
 151     CALL_DYN(region_updategr, reg, (reg));
 152 }
 153
 154
 155 void region_map(WRegion *reg)
 156 {
 157     CALL_DYN(region_map, reg, (reg));
 158     region_notify_change_(reg, ioncore_g.notifies.map);
 159 }
 160
 161
 162 void region_unmap(WRegion *reg)
 163 {
 164     CALL_DYN(region_unmap, reg, (reg));
 165     region_notify_change_(reg, ioncore_g.notifies.unmap);
 166 }
 167
 168
 169 void region_notify_rootpos(WRegion *reg, int x, int y)
 170 {
 171     CALL_DYN(region_notify_rootpos, reg, (reg, x, y));
 172 }
 173
 174
 175 Window region_xwindow(const WRegion *reg)
 176 {
 177     Window ret=None;
 178     CALL_DYN_RET(ret, Window, region_xwindow, reg, (reg));
 179     return ret;
 180 }
 181
 182
 183 void region_activated(WRegion *reg)
 184 {
 185     CALL_DYN(region_activated, reg, (reg));
 186 }
 187
 188
 189 void region_inactivated(WRegion *reg)
 190 {
 191     CALL_DYN(region_inactivated, reg, (reg));
 192 }
 193
 194
 195 void region_do_set_focus(WRegion *reg, bool warp)
 196 {
 197     CALL_DYN(region_do_set_focus, reg, (reg, warp));
 198 }
 199
 200
 201 /*{{{ Manager region dynfuns */
 202
 203
 204 static bool region_managed_prepare_focus_default(WRegion *mgr, WRegion *reg,
 205                                                  int flags,
 206                                                  WPrepareFocusResult *res)
 207 {
 208     if(!region_prepare_focus(mgr, flags, res))
 209         return FALSE;
 210
 211     res->reg=reg;
 212     res->flags=flags;
 213     return TRUE;
 214 }
 215
 216
 217 bool region_managed_prepare_focus(WRegion *mgr, WRegion *reg,
 218                                   int flags,
 219                                   WPrepareFocusResult *res)
 220 {
 221     bool ret=TRUE;
 222     CALL_DYN_RET(ret, bool, region_managed_prepare_focus, mgr,
 223                  (mgr, reg, flags, res));
 224     return ret;
 225 }
 226
 227
 228 void region_managed_notify(WRegion *mgr, WRegion *reg, WRegionNotify how)
 229 {
 230     CALL_DYN(region_managed_notify, mgr, (mgr, reg, how));
 231 }
 232
 233
 234 void region_managed_remove(WRegion *mgr, WRegion *reg)
 235 {
 236     CALL_DYN(region_managed_remove, mgr, (mgr, reg));
 237 }
 238
 239
 240 /*EXTL_DOC
 241  * Return the object, if any, that is considered ``currently active''
 242  * within the objects managed by \var{mplex}.
 243  */
 244 EXTL_SAFE
 245 EXTL_EXPORT_MEMBER
 246 WRegion *region_current(WRegion *mgr)
 247 {
 248     WRegion *ret=NULL;
 249     CALL_DYN_RET(ret, WRegion*, region_current, mgr, (mgr));
 250     return ret;
 251 }
 252
 253
 254 void region_child_removed(WRegion *reg, WRegion *sub)
 255 {
 256     CALL_DYN(region_child_removed, reg, (reg, sub));
 257 }
 258
 259
 260 /*}}}*/
 261
 262
 263 /*{{{ Dynfun defaults */
 264
 265
 266 void region_updategr_default(WRegion *reg)
 267 {
 268     WRegion *sub=NULL;
 269
 270     FOR_ALL_CHILDREN(reg, sub){
 271         region_updategr(sub);
 272     }
 273 }
 274
 275
 276 /*}}}*/
 277
 278
 279 /*}}}*/
 280
 281
 282 /*{{{ Goto */
 283
 284
 285 bool region_prepare_focus(WRegion *reg, int flags,
 286                           WPrepareFocusResult *res)
 287 {
 288
 289     if(TRUE /* !REGION_IS_ACTIVE(reg) ||
 290        !REGION_IS_MAPPED(reg) ||
 291        ioncore_g.focus_next!=NULL*/){
 292         WRegion *mgr=REGION_MANAGER(reg);
 293         WRegion *par=REGION_PARENT_REG(reg);
 294
 295         if(mgr!=NULL){
 296             return region_managed_prepare_focus(mgr, reg, flags, res);
 297         }else if(par!=NULL){
 298             if(!region_prepare_focus(par, flags, res))
 299                 return FALSE;
 300             /* Just focus reg, if it has no manager, and parent can be
 301              * focused.
 302              */
 303         }else if(!REGION_IS_MAPPED(reg)){
 304             region_map(reg);
 305         }
 306     }
 307
 308     res->reg=reg;
 309     res->flags=flags;
 310     return TRUE;
 311 }
 312
 313
 314 bool region_goto_flags(WRegion *reg, int flags)
 315 {
 316     WPrepareFocusResult res;
 317     bool ret;
 318
 319     ret=region_prepare_focus(reg, flags, &res);
 320
 321     if(res.reg!=NULL){
 322         if(res.flags&REGION_GOTO_FOCUS)
 323             region_maybewarp(res.reg, !(res.flags&REGION_GOTO_NOWARP));
 324     }
 325
 326     return ret;
 327 }
 328
 329
 330 /*EXTL_DOC
 331  * Attempt to display \var{reg}, save region activity status and then
 332  * warp to (or simply set focus to if warping is disabled) \var{reg}.
 333  *
 334  * Note that this function is asynchronous; the region will not
 335  * actually have received the focus when this function returns.
 336  */
 337 EXTL_EXPORT_MEMBER
 338 bool region_goto_focus(WRegion *reg)
 339 {
 340     return region_goto_flags(reg, REGION_GOTO_FOCUS);
 341 }
 342
 343 /*EXTL_DOC
 344  * Deprecated in favour of \fnref{WRegion.goto_focus} because 'goto' is a
 345  * keyword since Lua 5.2.
 346  */
 347 EXTL_EXPORT_MEMBER
 348 bool region_goto(WRegion *reg)
 349 {
 350     return region_goto_focus(reg);
 351 }
 352
 353 /*
 354  * Kept for backwards compatibility
 355  */
 356 EXTL_EXPORT_MEMBER
 357 bool region_goto_(WRegion *reg)
 358 {
 359     return region_goto_focus(reg);
 360 }
 361
 362 /*
 363  * Kept for backwards compatibility
 364  */
 365 EXTL_EXPORT_MEMBER
 366 bool region_display(WRegion *reg)
 367 {
 368     return region_goto_focus(reg);
 369 }
 370
 371
 372 /*}}}*/
 373
 374
 375 /*{{{ Fit/reparent */
 376
 377
 378 void region_fit(WRegion *reg, const WRectangle *geom, WRegionFitMode mode)
 379 {
 380     WFitParams fp;
 381     fp.g=*geom;
 382     fp.mode=mode&~REGION_FIT_GRAVITY;
 383     fp.gravity=ForgetGravity;
 384     region_fitrep(reg, NULL, &fp);
 385 }
 386
 387
 388 bool region_reparent(WRegion *reg, WWindow *par,
 389                      const WRectangle *geom, WRegionFitMode mode)
 390 {
 391     WFitParams fp;
 392     fp.g=*geom;
 393     fp.mode=mode;
 394     return region_fitrep(reg, par, &fp);
 395 }
 396
 397
 398 /*}}}*/
 399
 400
 401 /*{{{ Close */
 402
 403
 404 static void region_rqclose_default(WRegion *reg, bool relocate)
 405 {
 406     if(relocate || region_may_dispose(reg))
 407         region_defer_rqdispose(reg);
 408 }
 409
 410
 411 /*EXTL_DOC
 412  * Attempt to close/destroy \var{reg}. Whether this operation works
 413  * depends on whether the particular type of region in question has
 414  * implemented the feature and, in case of client windows, whether
 415  * the client supports the \code{WM_DELETE} protocol (see also
 416  * \fnref{WClientWin.kill}). The region will not be destroyed when
 417  * this function returns. To find out if and when it is destroyed,
 418  * use the \codestr{deinit} notification. If \var{relocate} is not set,
 419  * and \var{reg} manages other regions, it will not be closed. Otherwise
 420  * the managed regions will be attempted to be relocated.
 421  */
 422 EXTL_EXPORT_MEMBER
 423 void region_rqclose(WRegion *reg, bool relocate)
 424 {
 425     CALL_DYN(region_rqclose, reg, (reg, relocate));
 426 }
 427
 428
 429 static WRegion *region_rqclose_propagate_default(WRegion *reg,
 430                                                  WRegion *maybe_sub)
 431 {
 432     if(maybe_sub==NULL)
 433         maybe_sub=region_current(reg);
 434
 435     if(maybe_sub!=NULL){
 436         return region_rqclose_propagate(maybe_sub, NULL);
 437     }else{
 438         region_rqclose(reg, FALSE);
 439         return reg;
 440     }
 441 }
 442
 443
 444 /*EXTL_DOC
 445  * Recursively attempt to close a region or one of the regions managed by
 446  * it. If \var{sub} is set, it will be used as the managed region, otherwise
 447  * \fnref{WRegion.current}\code{(reg)}. The object to be closed is
 448  * returned, or NULL if nothing can be closed. For further details, see
 449  * notes for \fnref{WRegion.rqclose}.
 450  */
 451 EXTL_EXPORT_MEMBER
 452 WRegion *region_rqclose_propagate(WRegion *reg, WRegion *maybe_sub)
 453 {
 454     WRegion *ret=NULL;
 455     CALL_DYN_RET(ret, WRegion*, region_rqclose_propagate, reg,
 456                  (reg, maybe_sub));
 457     return ret;
 458 }
 459
 460
 461 bool region_may_dispose_default(WRegion *reg)
 462 {
 463     bool res=region_rescue_needed(reg);
 464
 465     if(res){
 466         const char *name=region_name(reg);
 467         warn(TR("Can not destroy %s: contains client windows."),
 468              (name!=NULL ? name : TR("(unknown)")));
 469     }
 470
 471     return !res;
 472 }
 473
 474
 475 bool region_may_dispose(WRegion *reg)
 476 {
 477     bool ret=TRUE;
 478     CALL_DYN_RET(ret, bool, region_may_dispose, reg, (reg));
 479     return ret;
 480 }
 481
 482
 483 static WRegion *region_managed_disposeroot_default(WRegion *mgr, WRegion *reg)
 484 {
 485     return reg;
 486 }
 487
 488
 489 WRegion *region_managed_disposeroot(WRegion *mgr, WRegion *reg)
 490 {
 491     WRegion *ret=NULL;
 492     CALL_DYN_RET(ret, WRegion*, region_managed_disposeroot, mgr, (mgr, reg));
 493     return ret;
 494 }
 495
 496
 497 WRegion *region_disposeroot(WRegion *reg)
 498 {
 499     WRegion *mgr=REGION_MANAGER(reg);
 500
 501     return (mgr!=NULL
 502             ? region_managed_disposeroot(mgr, reg)
 503             : reg);
 504 }
 505
 506
 507 bool region_rqdispose(WRegion *reg)
 508 {
 509     WRegion *root;
 510
 511     if(!region_may_dispose(reg))
 512         return FALSE;
 513
 514     root=region_disposeroot(reg);
 515
 516     if(root==NULL)
 517         return FALSE;
 518
 519     return region_dispose(root);
 520 }
 521
 522
 523 bool region_dispose_(WRegion *reg, bool not_simple)
 524 {
 525     bool rescue=not_simple;
 526     bool was_mcf=(not_simple && region_may_control_focus(reg));
 527     WPHolder *ph=NULL;
 528
 529     if(rescue){
 530         if(!region_rescue(reg, NULL, 0)){
 531             warn(TR("Failed to rescue some client windows - not closing."));
 532             return FALSE;
 533         }
 534     }
 535
 536     if(was_mcf)
 537         ph=region_unset_get_return(reg);
 538
 539     destroy_obj((Obj*)reg);
 540
 541     if(ph!=NULL){
 542         pholder_goto(ph);
 543         destroy_obj((Obj*)ph);
 544     }
 545
 546     return TRUE;
 547 }
 548
 549
 550 bool region_dispose(WRegion *reg)
 551 {
 552     return region_dispose_(reg, TRUE);
 553 }
 554
 555
 556 void region_defer_rqdispose(WRegion *reg)
 557 {
 558     mainloop_defer_action((Obj*)reg, (WDeferredAction*)region_rqdispose);
 559 }
 560
 561
 562 /*}}}*/
 563
 564
 565 /*{{{ Manager/parent stuff */
 566
 567
 568 /* Routine to call to unmanage a region */
 569 void region_detach_manager(WRegion *reg)
 570 {
 571     WRegion *mgr=REGION_MANAGER(reg);
 572
 573     if(mgr==NULL)
 574         return;
 575
 576     region_managed_remove(mgr, reg);
 577
 578     assert(REGION_MANAGER(reg)==NULL);
 579 }
 580
 581
 582 void region_unset_manager_pseudoactivity(WRegion *reg)
 583 {
 584     WRegion *mgr=reg->manager, *par=REGION_PARENT_REG(reg);
 585
 586     if(mgr==NULL || mgr==par || !REGION_IS_PSEUDOACTIVE(mgr))
 587         return;
 588
 589     mgr->flags&=~REGION_PSEUDOACTIVE;
 590
 591     region_notify_change(mgr, ioncore_g.notifies.pseudoinactivated);
 592
 593     region_unset_manager_pseudoactivity(mgr);
 594 }
 595
 596
 597 void region_set_manager_pseudoactivity(WRegion *reg)
 598 {
 599     WRegion *mgr=reg->manager, *par=REGION_PARENT_REG(reg);
 600
 601     if(!REGION_IS_ACTIVE(reg) && !REGION_IS_PSEUDOACTIVE(reg))
 602         return;
 603
 604     if(mgr==NULL || mgr==par || REGION_IS_PSEUDOACTIVE(mgr))
 605         return;
 606
 607     mgr->flags|=REGION_PSEUDOACTIVE;
 608
 609     region_notify_change(mgr, ioncore_g.notifies.pseudoactivated);
 610
 611     region_set_manager_pseudoactivity(mgr);
 612 }
 613
 614
 615 /* This should only be called within region_managed_remove,
 616  * _after_ any managed lists and other essential structures
 617  * of mgr have been broken.
 618  */
 619 void region_unset_manager(WRegion *reg, WRegion *mgr)
 620 {
 621     if(reg->manager!=mgr)
 622         return;
 623
 624     region_notify_change_(reg, ioncore_g.notifies.unset_manager);
 625
 626     region_unset_manager_pseudoactivity(reg);
 627
 628     reg->manager=NULL;
 629
 630     /* Reset status, as it is set by manager */
 631     reg->flags&=~REGION_SKIP_FOCUS;
 632
 633     if(region_is_activity_r(reg))
 634         region_clear_mgd_activity(mgr);
 635
 636     region_unset_return(reg);
 637 }
 638
 639
 640 /* This should be called within region attach routines,
 641  * _after_ any managed lists and other essential structures
 642  * of mgr have been set up.
 643  */
 644 void region_set_manager(WRegion *reg, WRegion *mgr)
 645 {
 646     assert(reg->manager==NULL);
 647
 648     reg->manager=mgr;
 649
 650     region_set_manager_pseudoactivity(reg);
 651
 652     if(region_is_activity_r(reg))
 653         region_mark_mgd_activity(mgr);
 654
 655     region_notify_change_(reg, ioncore_g.notifies.set_manager);
 656 }
 657
 658
 659 void region_set_parent(WRegion *reg, WWindow *parent)
 660 {
 661     assert(reg->parent==NULL && parent!=NULL);
 662     LINK_ITEM(((WRegion*)parent)->children, reg, p_next, p_prev);
 663     reg->parent=parent;
 664 }
 665
 666
 667 void region_unset_parent(WRegion *reg)
 668 {
 669     WRegion *p=REGION_PARENT_REG(reg);
 670
 671     if(p==NULL || p==reg)
 672         return;
 673
 674     UNLINK_ITEM(p->children, reg, p_next, p_prev);
 675     reg->parent=NULL;
 676
 677     if(p->active_sub==reg){
 678         p->active_sub=NULL;
 679         region_update_owned_grabs(p);
 680     }
 681
 682     region_child_removed(p, reg);
 683 }
 684
 685
 686 /*EXTL_DOC
 687  * Returns the region that manages \var{reg}.
 688  */
 689 EXTL_SAFE
 690 EXTL_EXPORT_MEMBER
 691 WRegion *region_manager(WRegion *reg)
 692 {
 693     return reg->manager;
 694 }
 695
 696
 697 /*EXTL_DOC
 698  * Returns the parent region of \var{reg}.
 699  */
 700 EXTL_SAFE
 701 EXTL_EXPORT_MEMBER
 702 WWindow *region_parent(WRegion *reg)
 703 {
 704     return reg->parent;
 705 }
 706
 707
 708 WRegion *region_manager_or_parent(WRegion *reg)
 709 {
 710     if(reg->manager!=NULL)
 711         return reg->manager;
 712     else
 713         return (WRegion*)(reg->parent);
 714 }
 715
 716
 717 WRegion *region_get_manager_chk(WRegion *p, const ClassDescr *descr)
 718 {
 719     WRegion *mgr=NULL;
 720
 721     if(p!=NULL){
 722         mgr=REGION_MANAGER(p);
 723         if(obj_is((Obj*)mgr, descr))
 724             return mgr;
 725     }
 726
 727     return NULL;
 728 }
 729
 730 /*}}}*/
 731
 732
 733 /*{{{ Stacking and ordering */
 734
 735
 736 static void region_stacking_default(WRegion *reg,
 737                                     Window *bottomret, Window *topret)
 738 {
 739     Window win=region_xwindow(reg);
 740     *bottomret=win;
 741     *topret=win;
 742 }
 743
 744
 745 void region_stacking(WRegion *reg, Window *bottomret, Window *topret)
 746 {
 747     CALL_DYN(region_stacking, reg, (reg, bottomret, topret));
 748 }
 749
 750
 751 void region_restack(WRegion *reg, Window other, int mode)
 752 {
 753     CALL_DYN(region_restack, reg, (reg, other, mode));
 754 }
 755
 756
 757
 758 bool region_managed_rqorder(WRegion *reg, WRegion *sub, WRegionOrder order)
 759 {
 760     bool ret=FALSE;
 761     CALL_DYN_RET(ret, bool, region_managed_rqorder, reg, (reg, sub, order));
 762     return ret;
 763 }
 764
 765
 766 bool region_rqorder(WRegion *reg, WRegionOrder order)
 767 {
 768     WRegion *mgr=REGION_MANAGER(reg);
 769
 770     if(mgr==NULL)
 771         return FALSE;
 772     else
 773         return region_managed_rqorder(mgr, reg, order);
 774 }
 775
 776
 777 /*EXTL_DOC
 778  * Request ordering. Currently supported values for \var{ord}
 779  * are \codestr{front} and \codestr{back}.
 780  */
 781 EXTL_EXPORT_AS(WRegion, rqorder)
 782 bool region_rqorder_extl(WRegion *reg, const char *ord)
 783 {
 784     WRegionOrder order;
 785
 786     if(strcmp(ord, "front")==0){
 787         order=REGION_ORDER_FRONT;
 788     }else if(strcmp(ord, "back")==0){
 789         order=REGION_ORDER_BACK;
 790     }else{
 791         return FALSE;
 792     }
 793
 794     return region_rqorder(reg, order);
 795 }
 796
 797
 798 /*}}}*/
 799
 800
 801 /*{{{ Misc. */
 802
 803
 804 /*EXTL_DOC
 805  * Returns the root window \var{reg} is on.
 806  */
 807 EXTL_SAFE
 808 EXTL_EXPORT_MEMBER
 809 WRootWin *region_rootwin_of(const WRegion *reg)
 810 {
 811     WRootWin *rw;
 812     assert(reg!=NULL); /* Lua interface should not pass NULL reg. */
 813     rw=(WRootWin*)(reg->rootwin);
 814     assert(rw!=NULL);
 815     return rw;
 816 }
 817
 818
 819 /*EXTL_DOC
 820  * Returns the screen \var{reg} is on.
 821  */
 822 EXTL_SAFE
 823 EXTL_EXPORT_MEMBER
 824 WScreen *region_screen_of(WRegion *reg)
 825 {
 826     while(reg!=NULL){
 827         if(OBJ_IS(reg, WScreen))
 828             return (WScreen*)reg;
 829         reg=REGION_PARENT_REG(reg);
 830     }
 831     return NULL;
 832 }
 833
 834
 835 Window region_root_of(const WRegion *reg)
 836 {
 837     return WROOTWIN_ROOT(region_rootwin_of(reg));
 838 }
 839
 840
 841 bool region_same_rootwin(const WRegion *reg1, const WRegion *reg2)
 842 {
 843     return (reg1->rootwin==reg2->rootwin);
 844 }
 845
 846
 847 /*EXTL_DOC
 848  * Is \var{reg} visible/is it and all it's ancestors mapped?
 849  */
 850 EXTL_SAFE
 851 EXTL_EXPORT_AS(WRegion, is_mapped)
 852 bool region_is_fully_mapped(WRegion *reg)
 853 {
 854     for(; reg!=NULL; reg=REGION_PARENT_REG(reg)){
 855         if(!REGION_IS_MAPPED(reg))
 856             return FALSE;
 857     }
 858
 859     return TRUE;
 860 }
 861
 862
 863 void region_rootpos(WRegion *reg, int *xret, int *yret)
 864 {
 865     WRegion *par;
 866
 867     par=REGION_PARENT_REG(reg);
 868
 869     if(par==NULL || par==reg){
 870         *xret=0;
 871         *yret=0;
 872         return;
 873     }
 874
 875     region_rootpos(par, xret, yret);
 876
 877     *xret+=REGION_GEOM(reg).x;
 878     *yret+=REGION_GEOM(reg).y;
 879 }
 880
 881
 882 typedef struct{
 883     WRegion *reg;
 884     WRegionNotify how;
 885 } MRSHP;
 886
 887
 888 static bool mrsh_notify_change(WHookDummy *fn, void *p_)
 889 {
 890     MRSHP *p=(MRSHP*)p_;
 891
 892     fn(p->reg, p->how);
 893
 894     return TRUE;
 895 }
 896
 897
 898 static bool mrshe_notify_change(ExtlFn fn, void *p_)
 899 {
 900     MRSHP *p=(MRSHP*)p_;
 901
 902     extl_call(fn, "os", NULL, p->reg, stringstore_get(p->how));
 903
 904     return TRUE;
 905 }
 906
 907
 908 static void region_notify_change_(WRegion *reg, WRegionNotify how)
 909 {
 910     MRSHP p;
 911
 912     p.reg=reg;
 913     p.how=how;
 914
 915     extl_protect(NULL);
 916     hook_call(region_notify_hook, &p, mrsh_notify_change, mrshe_notify_change),
 917     extl_unprotect(NULL);
 918 }
 919
 920
 921 void region_notify_change(WRegion *reg, WRegionNotify how)
 922 {
 923     WRegion *mgr=REGION_MANAGER(reg);
 924
 925     if(mgr!=NULL)
 926         region_managed_notify(mgr, reg, how);
 927
 928     region_notify_change_(reg, how);
 929 }
 930
 931
 932 /*EXTL_DOC
 933  * Returns the geometry of \var{reg} within its parent; a table with fields
 934  * \var{x}, \var{y}, \var{w} and \var{h}.
 935  */
 936 EXTL_SAFE
 937 EXTL_EXPORT_MEMBER
 938 ExtlTab region_geom(WRegion *reg)
 939 {
 940     return extl_table_from_rectangle(&REGION_GEOM(reg));
 941 }
 942
 943
 944 bool region_handle_drop(WRegion *reg, int x, int y, WRegion *dropped)
 945 {
 946     bool ret=FALSE;
 947     CALL_DYN_RET(ret, bool, region_handle_drop, reg, (reg, x, y, dropped));
 948     return ret;
 949 }
 950
 951
 952 WRegion *region_managed_within(WRegion *reg, WRegion *mgd)
 953 {
 954     while(mgd!=NULL &&
 955           (REGION_PARENT_REG(mgd)==reg ||
 956            REGION_PARENT_REG(mgd)==REGION_PARENT_REG(reg))){
 957
 958         if(REGION_MANAGER(mgd)==reg)
 959             return mgd;
 960         mgd=REGION_MANAGER(mgd);
 961     }
 962
 963     return NULL;
 964 }
 965
 966 void ioncore_region_notify(WRegion *reg, WRegionNotify how)
 967 {
 968     const char *p[1];
 969
 970     if(how==ioncore_g.notifies.name && obj_is((Obj*)reg, &CLASSDESCR(WWindow))){
 971         p[0] = region_name(reg);
 972         xwindow_set_text_property(((WWindow*)reg)->win, XA_WM_NAME, p, 1);
 973     }
 974 }
 975
 976 /*}}}*/
 977
 978
 979 /*{{{ Dynamic function table and class implementation */
 980
 981
 982 static DynFunTab region_dynfuntab[]={
 983     {region_managed_rqgeom,
 984      region_managed_rqgeom_allow},
 985
 986     {region_managed_rqgeom_absolute,
 987      region_managed_rqgeom_absolute_default},
 988
 989     {region_updategr,
 990      region_updategr_default},
 991
 992     {(DynFun*)region_rescue_clientwins,
 993      (DynFun*)region_rescue_child_clientwins},
 994
 995     {(DynFun*)region_may_dispose,
 996      (DynFun*)region_may_dispose_default},
 997
 998     {(DynFun*)region_prepare_manage,
 999      (DynFun*)region_prepare_manage_default},
1000
1001     {(DynFun*)region_prepare_manage_transient,
1002      (DynFun*)region_prepare_manage_transient_default},
1003
1004     {(DynFun*)region_managed_prepare_focus,
1005      (DynFun*)region_managed_prepare_focus_default},
1006
1007     {(DynFun*)region_managed_disposeroot,
1008      (DynFun*)region_managed_disposeroot_default},
1009
1010     {(DynFun*)region_rqclose_propagate,
1011      (DynFun*)region_rqclose_propagate_default},
1012
1013     {(DynFun*)region_rqclose,
1014      (DynFun*)region_rqclose_default},
1015
1016     {(DynFun*)region_displayname,
1017      (DynFun*)region_name},
1018
1019     {region_stacking,
1020      region_stacking_default},
1021
1022     END_DYNFUNTAB
1023 };
1024
1025
1026 EXTL_EXPORT
1027 IMPLCLASS(WRegion, Obj, region_deinit, region_dynfuntab);
1028
1029
1030 /*}}}*/
1031