]> git.decadent.org.uk Git - ion3.git/blob - ioncore/group.c
Removed reversion of 'Full screen mode fixes and improvements'.
[ion3.git] / ioncore / group.c
1 /*
2  * ion/ioncore/group.c
3  *
4  * Copyright (c) Tuomo Valkonen 1999-2007. 
5  *
6  * Ion is free software; you can redistribute it and/or modify it under
7  * the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation; either version 2.1 of the License, or
9  * (at your option) any later version.
10  */
11
12 #include <string.h>
13
14 #include <libtu/minmax.h>
15 #include <libtu/objp.h>
16 #include <libmainloop/defer.h>
17
18 #include "common.h"
19 #include "rootwin.h"
20 #include "focus.h"
21 #include "global.h"
22 #include "region.h"
23 #include "manage.h"
24 #include "screen.h"
25 #include "names.h"
26 #include "saveload.h"
27 #include "attach.h"
28 #include "regbind.h"
29 #include "extlconv.h"
30 #include "xwindow.h"
31 #include "resize.h"
32 #include "stacking.h"
33 #include "sizepolicy.h"
34 #include "bindmaps.h"
35 #include "navi.h"
36 #include "sizehint.h"
37 #include "llist.h"
38 #include "mplex.h"
39 #include "group.h"
40 #include "grouppholder.h"
41 #include "frame.h"
42 #include "float-placement.h"
43 #include "return.h"
44
45
46 static void group_place_stdisp(WGroup *ws, WWindow *parent,
47                                  int pos, WRegion *stdisp);
48
49 static void group_remanage_stdisp(WGroup *ws);
50
51
52 /*{{{ Stacking list stuff */
53
54
55 WStacking *group_get_stacking(WGroup *ws)
56 {
57     WWindow *par=REGION_PARENT(ws);
58     
59     return (par==NULL 
60             ? NULL
61             : window_get_stacking(par));
62 }
63
64
65 WStacking **group_get_stackingp(WGroup *ws)
66 {
67     WWindow *par=REGION_PARENT(ws);
68     
69     return (par==NULL 
70             ? NULL
71             : window_get_stackingp(par));
72 }
73
74
75 static bool wsfilt(WStacking *st, void *ws)
76 {
77     return (st->reg!=NULL && REGION_MANAGER(st->reg)==(WRegion*)ws);
78 }
79
80
81 static bool wsfilt_nostdisp(WStacking *st, void *ws)
82 {
83     return (wsfilt(st, ws) && ((WGroup*)ws)->managed_stdisp!=st);
84 }
85
86
87 void group_iter_init(WGroupIterTmp *tmp, WGroup *ws)
88 {
89     stacking_iter_mgr_init(tmp, ws->managed_list, NULL, ws);
90 }
91
92
93 void group_iter_init_nostdisp(WGroupIterTmp *tmp, WGroup *ws)
94 {
95     stacking_iter_mgr_init(tmp, ws->managed_list, wsfilt_nostdisp, ws);
96 }
97
98
99 WRegion *group_iter(WGroupIterTmp *tmp)
100 {
101     return stacking_iter_mgr(tmp);
102 }
103
104
105 WStacking *group_iter_nodes(WGroupIterTmp *tmp)
106 {
107     return stacking_iter_mgr_nodes(tmp);
108 }
109
110
111 WGroupIterTmp group_iter_default_tmp;
112
113
114 /*}}}*/
115
116
117 /*{{{ region dynfun implementations */
118
119
120 static void group_fit(WGroup *ws, const WRectangle *geom)
121 {
122     REGION_GEOM(ws)=*geom;
123 }
124
125
126 bool group_fitrep(WGroup *ws, WWindow *par, const WFitParams *fp)
127 {
128     WGroupIterTmp tmp;
129     WStacking *unweaved=NULL;
130     int xdiff=0, ydiff=0;
131     WStacking *st;
132     WWindow *oldpar;
133     WRectangle g;
134     
135     oldpar=REGION_PARENT(ws);
136     
137     if(par==NULL){
138         if(fp->mode&REGION_FIT_WHATEVER)
139             return TRUE;
140         REGION_GEOM(ws)=fp->g;
141     }else{
142         if(!region_same_rootwin((WRegion*)ws, (WRegion*)par))
143             return FALSE;
144         
145         if(ws->managed_stdisp!=NULL && ws->managed_stdisp->reg!=NULL)
146             region_detach_manager(ws->managed_stdisp->reg);
147         
148         assert(ws->managed_stdisp==NULL);
149         
150         xdiff=fp->g.x-REGION_GEOM(ws).x;
151         ydiff=fp->g.y-REGION_GEOM(ws).y;
152     
153         region_unset_parent((WRegion*)ws);
154         XReparentWindow(ioncore_g.dpy, ws->dummywin, par->win, -1, -1);
155         region_set_parent((WRegion*)ws, par);
156
157         REGION_GEOM(ws).x=fp->g.x;
158         REGION_GEOM(ws).y=fp->g.y;
159         if(!(fp->mode&REGION_FIT_WHATEVER)){
160             REGION_GEOM(ws).w=fp->g.w;
161             REGION_GEOM(ws).h=fp->g.h;
162         }
163         
164         if(oldpar!=NULL)
165             unweaved=stacking_unweave(&oldpar->stacking, wsfilt, (void*)ws);
166     }
167
168     FOR_ALL_NODES_IN_GROUP(ws, st, tmp){
169         WFitParams fp2=*fp;
170         
171         if(st->reg==NULL)
172             continue;
173         
174         g=REGION_GEOM(st->reg);
175         g.x+=xdiff;
176         g.y+=ydiff;
177
178         if(fp->mode&REGION_FIT_WHATEVER){
179             fp2.g=g;
180         }else{
181             fp2.g=REGION_GEOM(ws);
182             sizepolicy(&st->szplcy, st->reg, &g, REGION_RQGEOM_WEAK_ALL, &fp2);
183         }
184         
185         if(!region_fitrep(st->reg, par, &fp2)){
186             warn(TR("Error reparenting %s."), region_name(st->reg));
187             region_detach_manager(st->reg);
188         }
189     }
190     
191     if(unweaved!=NULL)
192         stacking_weave(&par->stacking, &unweaved, FALSE);
193
194     return TRUE;
195 }
196
197
198 static void group_map(WGroup *ws)
199 {
200     WRegion *reg;
201     WGroupIterTmp tmp;
202
203     REGION_MARK_MAPPED(ws);
204     XMapWindow(ioncore_g.dpy, ws->dummywin);
205     
206     FOR_ALL_MANAGED_BY_GROUP(ws, reg, tmp){
207         region_map(reg);
208     }
209 }
210
211
212 static void group_unmap(WGroup *ws)
213 {
214     WRegion *reg;
215     WGroupIterTmp tmp;
216
217     REGION_MARK_UNMAPPED(ws);
218     XUnmapWindow(ioncore_g.dpy, ws->dummywin);
219
220     FOR_ALL_MANAGED_BY_GROUP(ws, reg, tmp){
221         region_unmap(reg);
222     }
223 }
224
225
226 static WStacking *find_to_focus(WGroup *ws, WStacking *st, bool group_only)
227 {
228     WStacking *stacking=group_get_stacking(ws);
229     
230     if(stacking==NULL)
231         return st;
232                                 
233     return stacking_find_to_focus_mapped(stacking, st, 
234                                          (group_only ? (WRegion*)ws : NULL));
235 }
236
237
238 static bool group_refocus_(WGroup *ws, WStacking *st)
239 {
240     if(st!=ws->current_managed && st->reg!=NULL){
241         if(region_may_control_focus((WRegion*)ws))
242             region_set_focus(st->reg);
243         else
244             ws->current_managed=st;
245         return TRUE;
246     }
247     
248     return FALSE;
249 }
250
251
252 static void group_do_set_focus(WGroup *ws, bool warp)
253 {
254     WStacking *st=ws->current_managed;
255     
256     if(st==NULL || st->reg==NULL)
257         st=find_to_focus(ws, NULL, TRUE);
258     
259     if(st!=NULL && st->reg!=NULL)
260         region_do_set_focus(st->reg, warp);
261     else
262         region_finalise_focusing((WRegion*)ws, ws->dummywin, warp);
263 }
264
265
266 static bool group_managed_prepare_focus(WGroup *ws, WRegion *reg, 
267                                         int flags, WPrepareFocusResult *res)
268 {
269     WMPlex *mplex=OBJ_CAST(REGION_MANAGER(ws), WMPlex);
270     WStacking *st=group_find_stacking(ws, reg);    
271     
272     if(st==NULL)
273         return FALSE;
274
275     if(mplex!=NULL){
276         WStacking *node=mplex_find_stacking(mplex, (WRegion*)ws);
277         
278         if(node==NULL)
279             return FALSE;
280         
281         return mplex_do_prepare_focus(mplex, node, st,
282                                       flags, res);
283     }else{
284         if(!region_prepare_focus((WRegion*)ws, flags, res))
285             return FALSE;
286
287         st=find_to_focus(ws, st, FALSE);
288         
289         if(st==NULL)
290             return FALSE;
291         
292         if(ioncore_g.autoraise && 
293            !(flags&REGION_GOTO_ENTERWINDOW) &&
294            st->level>STACKING_LEVEL_BOTTOM){
295             WStacking **stackingp=group_get_stackingp(ws);
296             stacking_restack(stackingp, st, None, NULL, NULL, FALSE);
297         }
298         
299         res->reg=st->reg;
300         res->flags=flags;
301         
302         return (res->reg==reg);
303     }
304 }
305
306
307 void group_managed_remove(WGroup *ws, WRegion *reg)
308 {
309     bool mcf=region_may_control_focus((WRegion*)ws);
310     WStacking *st, *next_st=NULL;
311     bool was_stdisp=FALSE, was_bottom=FALSE;
312     bool was_current=FALSE;
313     
314     st=group_find_stacking(ws, reg);
315
316     if(st!=NULL){
317         next_st=stacking_unstack(REGION_PARENT(ws), st);
318         
319         UNLINK_ITEM(ws->managed_list, st, mgr_next, mgr_prev);
320         
321         if(st==ws->managed_stdisp){
322             ws->managed_stdisp=NULL;
323             was_stdisp=TRUE;
324         }
325         
326         if(st==ws->bottom){
327             ws->bottom=NULL;
328             was_bottom=TRUE;
329         }
330             
331         if(st==ws->current_managed){
332             ws->current_managed=NULL;
333             was_current=TRUE;
334         }
335         
336         stacking_unassoc(st);
337         stacking_free(st);
338     }
339     
340     region_unset_manager(reg, (WRegion*)ws);
341     
342     if(!OBJ_IS_BEING_DESTROYED(ws)){
343         if(was_bottom && !was_stdisp && ws->managed_stdisp==NULL){
344             /* We should probably be managing any stdisp, that 'bottom' 
345              * was managing.
346              */
347             group_remanage_stdisp(ws);
348         }
349         
350         if(was_current){
351             /* This may still potentially cause problems when focus
352              * change is pending. Perhaps we should use region_await_focus,
353              * if it is pointing to our child (and region_may_control_focus 
354              * fail if it is pointing somewhere else).
355              */
356             WStacking *stf=find_to_focus(ws, next_st, TRUE);
357             if(stf!=NULL && mcf){
358                 region_maybewarp_now(stf->reg, FALSE);
359             }else{
360                 ws->current_managed=stf;
361             }
362         }
363     }
364 }
365
366
367 void group_managed_notify(WGroup *ws, WRegion *reg, WRegionNotify how)
368 {
369     if(how==ioncore_g.notifies.activated || 
370        how==ioncore_g.notifies.pseudoactivated){
371         ws->current_managed=group_find_stacking(ws, reg);
372     }
373 }
374
375
376 /*}}}*/
377
378
379 /*{{{ Create/destroy */
380
381
382 bool group_init(WGroup *ws, WWindow *par, const WFitParams *fp)
383 {
384     ws->current_managed=NULL;
385     ws->managed_stdisp=NULL;
386     ws->bottom=NULL;
387     ws->managed_list=NULL;
388     
389     ws->dummywin=XCreateWindow(ioncore_g.dpy, par->win,
390                                 fp->g.x, fp->g.y, 1, 1, 0,
391                                 CopyFromParent, InputOnly,
392                                 CopyFromParent, 0, NULL);
393     if(ws->dummywin==None)
394         return FALSE;
395
396     region_init(&ws->reg, par, fp);
397     region_register(&ws->reg);
398
399     XSelectInput(ioncore_g.dpy, ws->dummywin,
400                  FocusChangeMask|KeyPressMask|KeyReleaseMask|
401                  ButtonPressMask|ButtonReleaseMask);
402     XSaveContext(ioncore_g.dpy, ws->dummywin, ioncore_g.win_context,
403                  (XPointer)ws);
404     
405     ((WRegion*)ws)->flags|=REGION_GRAB_ON_PARENT;
406     
407     region_add_bindmap((WRegion*)ws, ioncore_group_bindmap);
408     
409     return TRUE;
410 }
411
412
413 WGroup *create_group(WWindow *par, const WFitParams *fp)
414 {
415     CREATEOBJ_IMPL(WGroup, group, (p, par, fp));
416 }
417
418
419 void group_deinit(WGroup *ws)
420 {
421     WGroupIterTmp tmp;
422     WRegion *reg;
423
424     if(ws->managed_stdisp!=NULL && ws->managed_stdisp->reg!=NULL){
425         group_managed_remove(ws, ws->managed_stdisp->reg);
426         assert(ws->managed_stdisp==NULL);
427     }
428
429     FOR_ALL_MANAGED_BY_GROUP(ws, reg, tmp){
430         destroy_obj((Obj*)reg);
431     }
432
433     assert(ws->managed_list==NULL);
434
435     XDeleteContext(ioncore_g.dpy, ws->dummywin, ioncore_g.win_context);
436     XDestroyWindow(ioncore_g.dpy, ws->dummywin);
437     ws->dummywin=None;
438
439     region_deinit(&ws->reg);
440 }
441
442
443     
444 bool group_rescue_clientwins(WGroup *ws, WRescueInfo *info)
445 {
446     WGroupIterTmp tmp;
447     
448     group_iter_init_nostdisp(&tmp, ws);
449     
450     return region_rescue_some_clientwins((WRegion*)ws, info,
451                                          (WRegionIterator*)group_iter,
452                                          &tmp);
453 }
454
455
456 static bool group_empty_for_bottom_stdisp(WGroup *ws)
457 {
458     WGroupIterTmp tmp;
459     WStacking *st;
460     
461     FOR_ALL_NODES_IN_GROUP(ws, st, tmp){
462         if(st!=ws->bottom && st!=ws->managed_stdisp)
463             return FALSE;
464     }
465     
466     return TRUE;
467 }
468
469
470 static WRegion *group_managed_disposeroot(WGroup *ws, WRegion *reg)
471 {
472     if(group_bottom(ws)==reg){
473         if(group_empty_for_bottom_stdisp(ws))
474             return region_disposeroot((WRegion*)ws);
475     }
476     
477     return reg;
478 }
479
480
481 /*}}}*/
482
483
484 /*{{{ Bottom */
485
486
487 static void group_do_set_bottom(WGroup *grp, WStacking *st)
488 {
489     WStacking *was=grp->bottom;
490     
491     grp->bottom=st;
492     
493     if(st!=was){
494         if(st==NULL || HAS_DYN(st->reg, region_manage_stdisp))
495             group_remanage_stdisp(grp);
496         
497     }
498 }
499
500
501 /*EXTL_DOC
502  * Sets the 'bottom' of \var{ws}. The region \var{reg} must already
503  * be managed by \var{ws}, unless \code{nil}.
504  */
505 EXTL_EXPORT_MEMBER
506 bool group_set_bottom(WGroup *ws, WRegion *reg)
507 {
508     WStacking *st=NULL;
509     
510     if(reg!=NULL){
511         st=group_find_stacking(ws, reg);
512         
513         if(st==NULL)
514             return FALSE;
515     }
516         
517     group_do_set_bottom(ws, st);
518     
519     return TRUE;
520 }
521
522
523 /*EXTL_DOC
524  * Returns the 'bottom' of \var{ws}.
525  */
526 EXTL_SAFE
527 EXTL_EXPORT_MEMBER
528 WRegion *group_bottom(WGroup *ws)
529 {
530     return (ws->bottom!=NULL ? ws->bottom->reg : NULL);
531 }
532
533
534 /*}}}*/
535
536
537 /*{{{ Attach */
538
539
540 WStacking *group_do_add_managed(WGroup *ws, WRegion *reg, int level,
541                                 WSizePolicy szplcy)
542 {
543     WStacking *st=NULL;
544     CALL_DYN_RET(st, WStacking*, group_do_add_managed, ws, 
545                  (ws, reg, level, szplcy));
546     return st;
547 }
548     
549
550 WStacking *group_do_add_managed_default(WGroup *ws, WRegion *reg, int level,
551                                         WSizePolicy szplcy)
552 {
553     WStacking *st=NULL, *tmp=NULL;
554     Window bottom=None, top=None;
555     WStacking **stackingp=group_get_stackingp(ws);
556     WFrame *frame;
557     
558     if(stackingp==NULL)
559         return NULL;
560     
561     st=create_stacking();
562     
563     if(st==NULL)
564         return NULL;
565     
566     if(!stacking_assoc(st, reg)){
567         stacking_free(st);
568         return  NULL;
569     }
570     
571     frame=OBJ_CAST(reg, WFrame);
572     if(frame!=NULL){
573         WFrameMode m=frame_mode(frame);
574         if(m!=FRAME_MODE_FLOATING && m!=FRAME_MODE_TRANSIENT)
575             frame_set_mode(frame, FRAME_MODE_FLOATING);
576     }
577
578     st->level=level;
579     st->szplcy=szplcy;
580
581     LINK_ITEM_FIRST(tmp, st, next, prev);
582     stacking_weave(stackingp, &tmp, FALSE);
583     assert(tmp==NULL);
584
585     LINK_ITEM(ws->managed_list, st, mgr_next, mgr_prev);
586     region_set_manager(reg, (WRegion*)ws);
587
588     if(region_is_fully_mapped((WRegion*)ws))
589         region_map(reg);
590
591     return st;
592 }
593
594
595 static void geom_group_to_parent(WGroup *ws, const WRectangle *g, 
596                                  WRectangle *wg)
597 {
598     wg->x=g->x+REGION_GEOM(ws).x;
599     wg->y=g->y+REGION_GEOM(ws).y;
600     wg->w=maxof(1, g->w);
601     wg->h=maxof(1, g->h);
602 }
603
604
605 bool group_do_attach_final(WGroup *ws, 
606                            WRegion *reg,
607                            const WGroupAttachParams *param)
608 {
609     WStacking *st, *stabove=NULL;
610     WSizePolicy szplcy;
611     WFitParams fp;
612     WRectangle g;
613     uint level;
614     int weak;
615     bool sw;
616     
617     /* Stacking  */
618     if(param->stack_above!=NULL)
619         stabove=group_find_stacking(ws, param->stack_above);
620
621     level=(stabove!=NULL
622            ? stabove->level
623            : (param->level_set 
624               ? param->level 
625               : STACKING_LEVEL_NORMAL));
626     
627     /* Fit */
628     szplcy=(param->szplcy_set
629             ? param->szplcy
630             : (param->bottom
631                ? SIZEPOLICY_FULL_EXACT
632                : SIZEPOLICY_UNCONSTRAINED));
633     
634     weak=(param->geom_weak_set
635           ? param->geom_weak
636           : (param->geom_set
637              ? 0
638              : REGION_RQGEOM_WEAK_ALL));
639     
640     if(param->geom_set)
641         geom_group_to_parent(ws, &param->geom, &g);
642     else
643         g=REGION_GEOM(reg);
644     
645     /* If the requested geometry does not overlap the workspaces's geometry, 
646      * position request is never honoured.
647      */
648     if((g.x+g.w<=REGION_GEOM(ws).x) ||
649        (g.x>=REGION_GEOM(ws).x+REGION_GEOM(ws).w)){
650         weak|=REGION_RQGEOM_WEAK_X;
651     }
652        
653     if((g.y+g.h<=REGION_GEOM(ws).y) ||
654        (g.y>=REGION_GEOM(ws).y+REGION_GEOM(ws).h)){
655         weak|=REGION_RQGEOM_WEAK_Y;
656     }
657
658     if(weak&(REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y) &&
659         (szplcy==SIZEPOLICY_UNCONSTRAINED ||
660          szplcy==SIZEPOLICY_FREE ||
661          szplcy==SIZEPOLICY_FREE_GLUE /* without flags */)){
662         /* TODO: use 'weak'? */
663         group_calc_placement(ws, level, &g);
664     }
665
666     fp.g=REGION_GEOM(ws);
667     fp.mode=REGION_FIT_EXACT;
668
669     sizepolicy(&szplcy, reg, &g, weak, &fp);
670
671     if(rectangle_compare(&fp.g, &REGION_GEOM(reg))!=RECTANGLE_SAME)
672         region_fitrep(reg, NULL, &fp);
673     
674     /* Add */
675     st=group_do_add_managed(ws, reg, level, szplcy);
676     
677     if(st==NULL)
678         return FALSE;
679     
680     if(stabove!=NULL)
681         st->above=stabove;
682
683     if(param->bottom)
684         group_do_set_bottom(ws, st);
685     
686     /* Focus */
687     sw=(param->switchto_set ? param->switchto : ioncore_g.switchto_new);
688     
689     if(sw || st->level>=STACKING_LEVEL_MODAL1){
690         WStacking *stf=find_to_focus(ws, st, FALSE);
691         
692         if(stf==st){
693             /* Ok, the new region can be focused */
694             group_refocus_(ws, stf);
695         }
696     }
697     
698     return TRUE;
699 }
700
701
702 WRegion *group_do_attach(WGroup *ws, 
703                          /*const*/ WGroupAttachParams *param,
704                          WRegionAttachData *data)
705 {
706     WFitParams fp;
707     WWindow *par;
708     WRegion *reg;
709     
710     if(ws->bottom!=NULL && param->bottom){
711         warn(TR("'bottom' already set."));
712         return NULL;
713     }
714     
715     par=REGION_PARENT(ws);
716     assert(par!=NULL);
717
718     if(param->geom_set){
719         geom_group_to_parent(ws, &param->geom, &fp.g);
720         fp.mode=REGION_FIT_EXACT;
721     }else{
722         fp.g=REGION_GEOM(ws);
723         fp.mode=REGION_FIT_BOUNDS|REGION_FIT_WHATEVER;
724     }
725     
726     return region_attach_helper((WRegion*) ws, par, &fp, 
727                                 (WRegionDoAttachFn*)group_do_attach_final,
728                                 /*(const WRegionAttachParams*)*/param, data);
729     /*                            ^^^^ doesn't seem to work. */
730 }
731
732
733 static void get_params(WGroup *ws, ExtlTab tab, WGroupAttachParams *par)
734 {
735     int tmp;
736     char *tmps;
737     ExtlTab g;
738     
739     par->switchto_set=0;
740     par->level_set=0;
741     par->szplcy_set=0;
742     par->geom_set=0;
743     par->bottom=0;
744     
745     if(extl_table_gets_i(tab, "level", &tmp)){
746         if(tmp>=0){
747             par->level_set=STACKING_LEVEL_NORMAL;
748             par->level=tmp;
749         }
750     }
751     
752     if(extl_table_is_bool_set(tab, "bottom")){
753         par->level=STACKING_LEVEL_BOTTOM;
754         par->level_set=1;
755         par->bottom=1;
756     }
757     
758     if(!par->level_set && extl_table_is_bool_set(tab, "modal")){
759         par->level=STACKING_LEVEL_MODAL1;
760         par->level_set=1;
761     }
762     
763     if(extl_table_is_bool_set(tab, "switchto"))
764         par->switchto=1;
765
766     if(extl_table_gets_i(tab, "sizepolicy", &tmp)){
767         par->szplcy_set=1;
768         par->szplcy=tmp;
769     }else if(extl_table_gets_s(tab, "sizepolicy", &tmps)){
770         if(string2sizepolicy(tmps, &par->szplcy))
771             par->szplcy_set=1;
772         free(tmps);
773     }
774     
775     if(extl_table_gets_t(tab, "geom", &g)){
776         int n=0;
777         
778         if(extl_table_gets_i(g, "x", &(par->geom.x)))
779             n++;
780         if(extl_table_gets_i(g, "y", &(par->geom.y)))
781             n++;
782         if(extl_table_gets_i(g, "w", &(par->geom.w)))
783             n++;
784         if(extl_table_gets_i(g, "h", &(par->geom.h)))
785             n++;
786         
787         if(n==4)
788             par->geom_set=1;
789         
790         extl_unref_table(g);
791     }
792 }
793
794
795
796 /*EXTL_DOC
797  * Attach and reparent existing region \var{reg} to \var{ws}.
798  * The table \var{param} may contain the fields \var{index} and
799  * \var{switchto} that are interpreted as for \fnref{WMPlex.attach_new}.
800  */
801 EXTL_EXPORT_MEMBER
802 WRegion *group_attach(WGroup *ws, WRegion *reg, ExtlTab param)
803 {
804     WGroupAttachParams par=GROUPATTACHPARAMS_INIT;
805     WRegionAttachData data;
806
807     if(reg==NULL)
808         return NULL;
809     
810     get_params(ws, param, &par);
811     
812     data.type=REGION_ATTACH_REPARENT;
813     data.u.reg=reg;
814     
815     return group_do_attach(ws, &par, &data);
816 }
817
818
819 /*EXTL_DOC
820  * Create a new region to be managed by \var{ws}. At least the following
821  * fields in \var{param} are understood:
822  * 
823  * \begin{tabularx}{\linewidth}{lX}
824  *  \tabhead{Field & Description}
825  *  \var{type} & Class name (a string) of the object to be created. Mandatory. \\
826  *  \var{name} & Name of the object to be created (a string). Optional. \\
827  *  \var{switchto} & Should the region be switched to (boolean)? Optional. \\
828  *  \var{level} & Stacking level; default is 1. \\
829  *  \var{modal} & Make object modal; ignored if level is set. \\
830  *  \var{sizepolicy} & Size policy. \\
831  * \end{tabularx}
832  * 
833  * In addition parameters to the region to be created are passed in this 
834  * same table.
835  */
836 EXTL_EXPORT_MEMBER
837 WRegion *group_attach_new(WGroup *ws, ExtlTab param)
838 {
839     WGroupAttachParams par=GROUPATTACHPARAMS_INIT;
840     WRegionAttachData data;
841
842     get_params(ws, param, &par);
843     
844     data.type=REGION_ATTACH_LOAD;
845     data.u.tab=param;
846     
847     return group_do_attach(ws, &par, &data);
848 }
849
850
851 /*}}}*/
852
853
854 /*{{{ Status display support */
855
856
857 static int stdisp_szplcy(const WMPlexSTDispInfo *di, WRegion *stdisp)
858 {
859     int pos=di->pos;
860     
861     if(di->fullsize){
862         if(region_orientation(stdisp)==REGION_ORIENTATION_VERTICAL){
863             if(pos==MPLEX_STDISP_TL || pos==MPLEX_STDISP_BL)
864                 return SIZEPOLICY_STRETCH_LEFT;
865             else
866                 return SIZEPOLICY_STRETCH_RIGHT;
867         }else{
868             if(pos==MPLEX_STDISP_TL || pos==MPLEX_STDISP_TR)
869                 return SIZEPOLICY_STRETCH_TOP;
870             else
871                 return SIZEPOLICY_STRETCH_BOTTOM;
872         }
873     }else{
874         if(pos==MPLEX_STDISP_TL)
875             return SIZEPOLICY_GRAVITY_NORTHWEST;
876         else if(pos==MPLEX_STDISP_BL)
877             return SIZEPOLICY_GRAVITY_SOUTHWEST;
878         else if(pos==MPLEX_STDISP_TR)
879             return SIZEPOLICY_GRAVITY_NORTHEAST;
880         else /*if(pos=MPLEX_STDISP_BR)*/
881             return SIZEPOLICY_GRAVITY_SOUTHEAST;
882     }
883 }
884
885
886 void group_manage_stdisp(WGroup *ws, WRegion *stdisp, 
887                          const WMPlexSTDispInfo *di)
888 {
889     WFitParams fp;
890     uint szplcy;
891     WRegion *b=(ws->bottom==NULL ? NULL : ws->bottom->reg);
892     
893     /* Check if 'bottom' wants to manage the stdisp. */
894     if(b!=NULL 
895        && !OBJ_IS_BEING_DESTROYED(b)
896        && HAS_DYN(b, region_manage_stdisp)){
897         region_manage_stdisp(b, stdisp, di);
898         if(REGION_MANAGER(stdisp)==b)
899             return;
900     }
901     
902     /* No. */
903     
904     szplcy=stdisp_szplcy(di, stdisp)|SIZEPOLICY_SHRUNK;
905     
906     if(ws->managed_stdisp!=NULL && ws->managed_stdisp->reg==stdisp){
907         if(ws->managed_stdisp->szplcy==szplcy)
908             return;
909         ws->managed_stdisp->szplcy=szplcy;
910     }else{
911         region_detach_manager(stdisp);
912         ws->managed_stdisp=group_do_add_managed(ws, stdisp, 
913                                                 STACKING_LEVEL_ON_TOP, 
914                                                 szplcy);
915     }
916
917     fp.g=REGION_GEOM(ws);
918     sizepolicy(&ws->managed_stdisp->szplcy, stdisp, NULL, 0, &fp);
919
920     region_fitrep(stdisp, NULL, &fp);
921 }
922
923
924 static void group_remanage_stdisp(WGroup *ws)
925 {
926     WMPlex *mplex=OBJ_CAST(REGION_MANAGER(ws), WMPlex);
927     
928     if(mplex!=NULL && 
929        mplex->mx_current!=NULL && 
930        mplex->mx_current->st->reg==(WRegion*)ws){
931         mplex_remanage_stdisp(mplex);
932     }
933 }
934
935
936 /*}}}*/
937
938
939 /*{{{ Geometry requests */
940
941
942 void group_managed_rqgeom(WGroup *ws, WRegion *reg,
943                           const WRQGeomParams *rq,
944                           WRectangle *geomret)
945 {
946     WFitParams fp;
947     WStacking *st;
948         
949     st=group_find_stacking(ws, reg);
950
951     if(st==NULL){
952         fp.g=rq->geom;
953         fp.mode=REGION_FIT_EXACT;
954     }else{
955         fp.g=REGION_GEOM(ws);
956         sizepolicy(&st->szplcy, reg, &rq->geom, rq->flags, &fp);
957     }
958     
959     if(geomret!=NULL)
960         *geomret=fp.g;
961     
962     if(!(rq->flags&REGION_RQGEOM_TRYONLY))
963         region_fitrep(reg, NULL, &fp);
964 }
965
966
967 void group_managed_rqgeom_absolute(WGroup *grp, WRegion *sub, 
968                                    const WRQGeomParams *rq,
969                                    WRectangle *geomret)
970 {
971     if(grp->bottom!=NULL && grp->bottom->reg==sub){
972         region_rqgeom((WRegion*)grp, rq, geomret);
973         if(!(rq->flags&REGION_RQGEOM_TRYONLY) && geomret!=NULL)
974             *geomret=REGION_GEOM(sub);
975     }else{
976         WRQGeomParams rq2=*rq;
977         rq2.flags&=~REGION_RQGEOM_ABSOLUTE;
978
979         region_managed_rqgeom((WRegion*)grp, sub, &rq2, geomret);
980     }
981 }
982
983
984 /*}}}*/
985
986
987 /*{{{ Navigation */
988
989
990 static WStacking *nxt(WGroup *ws, WStacking *st, bool wrap)
991 {
992     return (st->mgr_next!=NULL 
993             ? st->mgr_next 
994             : (wrap ? ws->managed_list : NULL));
995 }
996
997
998 static WStacking *prv(WGroup *ws, WStacking *st, bool wrap)
999 {
1000     return (st!=ws->managed_list 
1001             ? st->mgr_prev
1002             : (wrap ? st->mgr_prev : NULL));
1003 }
1004
1005
1006 typedef WStacking *NxtFn(WGroup *ws, WStacking *st, bool wrap);
1007
1008
1009 static bool mapped_filt(WStacking *st, void *unused)
1010 {
1011     return (st->reg!=NULL && REGION_IS_MAPPED(st->reg));
1012 }
1013
1014
1015 static bool focusable(WGroup *ws, WStacking *st, uint min_level)
1016 {
1017     return (st->reg!=NULL
1018             && REGION_IS_MAPPED(st->reg)
1019             && !(st->reg->flags&REGION_SKIP_FOCUS)
1020             && st->level>=min_level);
1021 }
1022
1023        
1024 static WStacking *do_get_next(WGroup *ws, WStacking *sti,
1025                               NxtFn *fn, bool wrap, bool sti_ok)
1026 {
1027     WStacking *st, *stacking;
1028     uint min_level=0;
1029     
1030     stacking=group_get_stacking(ws);
1031     
1032     if(stacking!=NULL)
1033         min_level=stacking_min_level(stacking, mapped_filt, NULL);
1034
1035     st=sti;
1036     while(1){
1037         st=fn(ws, st, wrap); 
1038         
1039         if(st==NULL || st==sti)
1040             break;
1041         
1042         if(focusable(ws, st, min_level))
1043             return st;
1044     }
1045
1046     if(sti_ok && focusable(ws, sti, min_level))
1047         return sti;
1048     
1049     return NULL;
1050 }
1051
1052
1053 static WStacking *group_do_navi_first(WGroup *ws, WRegionNavi nh)
1054 {
1055     WStacking *lst=ws->managed_list;
1056     
1057     if(lst==NULL)
1058         return NULL;
1059
1060     if(nh==REGION_NAVI_ANY && 
1061        ws->current_managed!=NULL &&
1062        ws->current_managed->reg!=NULL){
1063         return ws->current_managed;
1064     }
1065     
1066     if(nh==REGION_NAVI_ANY || nh==REGION_NAVI_END || 
1067        nh==REGION_NAVI_BOTTOM || nh==REGION_NAVI_RIGHT){
1068         return do_get_next(ws, lst, prv, TRUE, TRUE);
1069     }else{
1070         return do_get_next(ws, lst->mgr_prev, nxt, TRUE, TRUE);
1071     }
1072 }
1073
1074
1075 static WRegion *group_navi_first(WGroup *ws, WRegionNavi nh,
1076                                  WRegionNaviData *data)
1077 {
1078     WStacking *st=group_do_navi_first(ws, nh);
1079     
1080     return region_navi_cont(&ws->reg, (st!=NULL ? st->reg : NULL), data);
1081 }
1082
1083
1084 static WStacking *group_do_navi_next(WGroup *ws, WStacking *st, 
1085                                      WRegionNavi nh, bool wrap)
1086 {
1087     if(st==NULL)
1088         return group_do_navi_first(ws, nh);
1089     
1090     if(nh==REGION_NAVI_ANY || nh==REGION_NAVI_END || 
1091        nh==REGION_NAVI_BOTTOM || nh==REGION_NAVI_RIGHT){
1092         return do_get_next(ws, st, nxt, wrap, FALSE);
1093     }else{
1094         return do_get_next(ws, st, prv, wrap, FALSE);
1095     }
1096 }
1097
1098 static WRegion *group_navi_next(WGroup *ws, WRegion *reg, 
1099                                 WRegionNavi nh, WRegionNaviData *data)
1100 {
1101     WStacking *st=group_find_stacking(ws, reg);
1102     
1103     st=group_do_navi_next(ws, st, nh, FALSE);
1104     
1105     return region_navi_cont(&ws->reg, (st!=NULL ? st->reg : NULL), data);
1106 }
1107
1108
1109 /*}}}*/
1110
1111
1112 /*{{{ Stacking */
1113
1114
1115 /* 
1116  * Note: Managed objects are considered to be stacked separately from the
1117  * group, slightly violating expectations.
1118  */
1119
1120 void group_stacking(WGroup *ws, Window *bottomret, Window *topret)
1121 {
1122     Window win=region_xwindow((WRegion*)ws);
1123     
1124     *bottomret=win;
1125     *topret=win;
1126 }
1127
1128
1129 void group_restack(WGroup *ws, Window other, int mode)
1130 {
1131     Window win;
1132     
1133     win=region_xwindow((WRegion*)ws);
1134     if(win!=None){
1135         xwindow_restack(win, other, mode);
1136         other=win;
1137         mode=Above;
1138     }
1139 }
1140
1141
1142 WStacking *group_find_stacking(WGroup *ws, WRegion *r)
1143 {
1144     if(r==NULL || REGION_MANAGER(r)!=(WRegion*)ws)
1145         return NULL;
1146     
1147     return ioncore_find_stacking(r);
1148 }
1149
1150
1151 static WStacking *find_stacking_if_not_on_ws(WGroup *ws, Window w)
1152 {
1153     WRegion *r=xwindow_region_of(w);
1154     WStacking *st=NULL;
1155     
1156     while(r!=NULL){
1157         if(REGION_MANAGER(r)==(WRegion*)ws)
1158             break;
1159         st=group_find_stacking(ws, r);
1160         if(st!=NULL)
1161             break;
1162         r=REGION_MANAGER(r);
1163     }
1164     
1165     return st;
1166 }
1167
1168
1169 bool group_managed_rqorder(WGroup *grp, WRegion *reg, WRegionOrder order)
1170 {
1171     WStacking **stackingp=group_get_stackingp(grp);
1172     WStacking *st;
1173
1174     if(stackingp==NULL || *stackingp==NULL)
1175         return FALSE;
1176
1177     st=group_find_stacking(grp, reg);
1178     
1179     if(st==NULL)
1180         return FALSE;
1181     
1182     stacking_restack(stackingp, st, None, NULL, NULL,
1183                      (order!=REGION_ORDER_FRONT));
1184     
1185     return TRUE;
1186 }
1187
1188
1189 /*}}}*/
1190
1191
1192 /*{{{ Misc. */
1193
1194
1195 /*EXTL_DOC
1196  * Iterate over managed regions of \var{ws} until \var{iterfn} returns
1197  * \code{false}.
1198  * The function itself returns \code{true} if it reaches the end of list
1199  * without this happening.
1200  */
1201 EXTL_SAFE
1202 EXTL_EXPORT_MEMBER
1203 bool group_managed_i(WGroup *ws, ExtlFn iterfn)
1204 {
1205     WGroupIterTmp tmp;
1206     group_iter_init(&tmp, ws);
1207     
1208     return extl_iter_objlist_(iterfn, (ObjIterator*)group_iter, &tmp);
1209 }
1210
1211
1212 WRegion* group_current(WGroup *ws)
1213 {
1214     return (ws->current_managed!=NULL ? ws->current_managed->reg : NULL);
1215 }
1216
1217
1218 void group_size_hints(WGroup *ws, WSizeHints *hints_ret)
1219 {
1220     if(ws->bottom==NULL || ws->bottom->reg==NULL){
1221         sizehints_clear(hints_ret);
1222     }else{
1223         region_size_hints(ws->bottom->reg, hints_ret);
1224         hints_ret->no_constrain=TRUE;
1225     }
1226 }
1227
1228
1229 Window group_xwindow(const WGroup *ws)
1230 {
1231     return ws->dummywin;
1232 }
1233
1234
1235 /*EXTL_DOC
1236  * Returns the group of \var{reg}, if it is managed by one,
1237  * and \var{reg} itself otherwise.
1238  */
1239 /*EXTL_EXPORT_MEMBER
1240 WRegion *region_group_of(WRegion *reg)
1241 {
1242     WRegion *mgr=REGION_MANAGER(reg);
1243     
1244     return (OBJ_IS(mgr, WGroup) ? mgr : reg);
1245 }*/
1246
1247
1248 /*EXTL_DOC
1249  * Returns the group of \var{reg}, if \var{reg} is its bottom,
1250  * and \var{reg} itself otherwise.
1251  */
1252 EXTL_EXPORT_MEMBER
1253 WRegion *region_groupleader_of(WRegion *reg)
1254 {
1255     WGroup *grp=REGION_MANAGER_CHK(reg, WGroup);
1256     
1257     return ((grp!=NULL && group_bottom(grp)==reg)
1258             ? (WRegion*)grp
1259             : reg);
1260 }
1261
1262
1263 /*}}}*/
1264
1265
1266 /*{{{ Save/load */
1267
1268
1269 static ExtlTab group_get_configuration(WGroup *ws)
1270 {
1271     ExtlTab tab, mgds, subtab, g;
1272     WStacking *st;
1273     WGroupIterTmp tmp;
1274     WMPlex *par;
1275     int n=0;
1276     WRectangle tmpg;
1277     
1278     tab=region_get_base_configuration((WRegion*)ws);
1279     
1280     mgds=extl_create_table();
1281     
1282     extl_table_sets_t(tab, "managed", mgds);
1283     
1284     /* TODO: stacking order messed up */
1285     
1286     FOR_ALL_NODES_IN_GROUP(ws, st, tmp){
1287         if(st->reg==NULL)
1288             continue;
1289         
1290         subtab=region_get_configuration(st->reg);
1291
1292         if(subtab!=extl_table_none()){
1293             extl_table_sets_i(subtab, "sizepolicy", st->szplcy);
1294             extl_table_sets_i(subtab, "level", st->level);
1295         
1296             tmpg=REGION_GEOM(st->reg);
1297             tmpg.x-=REGION_GEOM(ws).x;
1298             tmpg.y-=REGION_GEOM(ws).y;
1299             
1300             g=extl_table_from_rectangle(&tmpg);
1301             extl_table_sets_t(subtab, "geom", g);
1302             extl_unref_table(g);
1303             
1304             if(ws->bottom==st)
1305                 extl_table_sets_b(subtab, "bottom", TRUE);
1306         
1307             extl_table_seti_t(mgds, ++n, subtab);
1308             extl_unref_table(subtab);
1309         }
1310     }
1311     
1312     extl_unref_table(mgds);
1313     
1314     return tab;
1315 }
1316
1317
1318 void group_do_load(WGroup *ws, ExtlTab tab)
1319 {
1320     ExtlTab substab, subtab;
1321     int i, n;
1322     
1323     if(extl_table_gets_t(tab, "managed", &substab)){
1324         n=extl_table_get_n(substab);
1325         for(i=1; i<=n; i++){
1326             if(extl_table_geti_t(substab, i, &subtab)){
1327                 group_attach_new(ws, subtab);
1328                 extl_unref_table(subtab);
1329             }
1330         }
1331         
1332         extl_unref_table(substab);
1333     }
1334 }
1335
1336
1337 WRegion *group_load(WWindow *par, const WFitParams *fp, ExtlTab tab)
1338 {
1339     WGroup *ws;
1340     
1341     ws=create_group(par, fp);
1342     
1343     if(ws==NULL)
1344         return NULL;
1345         
1346     group_do_load(ws, tab);
1347     
1348     return (WRegion*)ws;
1349 }
1350
1351
1352 /*}}}*/
1353
1354
1355 /*{{{ Dynamic function table and class implementation */
1356
1357
1358 static DynFunTab group_dynfuntab[]={
1359     {(DynFun*)region_fitrep,
1360      (DynFun*)group_fitrep},
1361
1362     {region_map, 
1363      group_map},
1364     
1365     {region_unmap, 
1366      group_unmap},
1367     
1368     {(DynFun*)region_managed_prepare_focus, 
1369      (DynFun*)group_managed_prepare_focus},
1370
1371     {region_do_set_focus, 
1372      group_do_set_focus},
1373     
1374     {region_managed_notify, 
1375      group_managed_notify},
1376     
1377     {region_managed_remove,
1378      group_managed_remove},
1379     
1380     {(DynFun*)region_get_configuration, 
1381      (DynFun*)group_get_configuration},
1382
1383     {(DynFun*)region_managed_disposeroot,
1384      (DynFun*)group_managed_disposeroot},
1385
1386     {(DynFun*)region_current,
1387      (DynFun*)group_current},
1388     
1389     {(DynFun*)region_rescue_clientwins,
1390      (DynFun*)group_rescue_clientwins},
1391     
1392     {region_restack,
1393      group_restack},
1394
1395     {region_stacking,
1396      group_stacking},
1397
1398     {(DynFun*)region_managed_get_pholder,
1399      (DynFun*)group_managed_get_pholder},
1400
1401     {region_managed_rqgeom,
1402      group_managed_rqgeom},
1403      
1404     {region_managed_rqgeom_absolute,
1405      group_managed_rqgeom_absolute},
1406     
1407     {(DynFun*)group_do_add_managed,
1408      (DynFun*)group_do_add_managed_default},
1409     
1410     {region_size_hints,
1411      group_size_hints},
1412     
1413     {(DynFun*)region_xwindow,
1414      (DynFun*)group_xwindow},
1415     
1416     {(DynFun*)region_navi_first,
1417      (DynFun*)group_navi_first},
1418     
1419     {(DynFun*)region_navi_next,
1420      (DynFun*)group_navi_next},
1421     
1422     {(DynFun*)region_managed_rqorder,
1423      (DynFun*)group_managed_rqorder},
1424     
1425     END_DYNFUNTAB
1426 };
1427
1428
1429 EXTL_EXPORT
1430 IMPLCLASS(WGroup, WRegion, group_deinit, group_dynfuntab);
1431
1432
1433 /*}}}*/
1434