X-Git-Url: https://git.decadent.org.uk/gitweb/?a=blobdiff_plain;f=ioncore%2Fgroup.c;h=21db4bbb15608d11af2447a495a7ad8a39093895;hb=20080103;hp=9c67348fe2a26442a696def5b14523ec2c55bfd7;hpb=ae4260bb64817c11f9a7140324cd3e3ba113e297;p=ion3.git

diff --git a/ioncore/group.c b/ioncore/group.c
index 9c67348..21db4bb 100644
--- a/ioncore/group.c
+++ b/ioncore/group.c
@@ -1,7 +1,7 @@
 /*
  * ion/ioncore/group.c
  *
- * Copyright (c) Tuomo Valkonen 1999-2007. 
+ * Copyright (c) Tuomo Valkonen 1999-2008. 
  *
  * See the included file LICENSE for details.
  */
@@ -45,6 +45,8 @@ static void group_place_stdisp(WGroup *ws, WWindow *parent,
 
 static void group_remanage_stdisp(WGroup *ws);
 
+static void group_do_set_bottom(WGroup *grp, WStacking *st);
+
 
 /*{{{ Stacking list stuff */
 
@@ -232,26 +234,9 @@ static WStacking *find_to_focus(WGroup *ws, WStacking *st, bool group_only)
 }
 
 
-static bool group_refocus_(WGroup *ws, WStacking *st)
-{
-    if(st!=ws->current_managed && st->reg!=NULL){
-        if(region_may_control_focus((WRegion*)ws))
-            region_set_focus(st->reg);
-        else
-            ws->current_managed=st;
-        return TRUE;
-    }
-    
-    return FALSE;
-}
-
-
 static void group_do_set_focus(WGroup *ws, bool warp)
 {
-    WStacking *st=ws->current_managed;
-    
-    if(st==NULL || st->reg==NULL)
-        st=find_to_focus(ws, NULL, TRUE);
+    WStacking *st=find_to_focus(ws, ws->current_managed, FALSE);
     
     if(st!=NULL && st->reg!=NULL)
         region_do_set_focus(st->reg, warp);
@@ -311,51 +296,40 @@ void group_managed_remove(WGroup *ws, WRegion *reg)
     st=group_find_stacking(ws, reg);
 
     if(st!=NULL){
-        next_st=stacking_unstack(REGION_PARENT(ws), st);
-        
-        UNLINK_ITEM(ws->managed_list, st, mgr_next, mgr_prev);
+        if(st==ws->bottom){
+            was_bottom=TRUE;
+            group_do_set_bottom(ws, NULL);
+        }
         
         if(st==ws->managed_stdisp){
             ws->managed_stdisp=NULL;
             was_stdisp=TRUE;
         }
-        
-        if(st==ws->bottom){
-            ws->bottom=NULL;
-            was_bottom=TRUE;
-        }
             
         if(st==ws->current_managed){
             ws->current_managed=NULL;
             was_current=TRUE;
         }
         
+        next_st=stacking_unstack(REGION_PARENT(ws), st);
+        UNLINK_ITEM(ws->managed_list, st, mgr_next, mgr_prev);
         stacking_unassoc(st);
         stacking_free(st);
     }
     
     region_unset_manager(reg, (WRegion*)ws);
     
-    if(!OBJ_IS_BEING_DESTROYED(ws)){
-        if(was_bottom && !was_stdisp && ws->managed_stdisp==NULL){
-            /* We should probably be managing any stdisp, that 'bottom' 
-             * was managing.
-             */
-            group_remanage_stdisp(ws);
-        }
-        
-        if(was_current){
-            /* This may still potentially cause problems when focus
-             * change is pending. Perhaps we should use region_await_focus,
-             * if it is pointing to our child (and region_may_control_focus 
-             * fail if it is pointing somewhere else).
-             */
-            WStacking *stf=find_to_focus(ws, next_st, TRUE);
-            if(stf!=NULL && mcf){
-                region_maybewarp_now(stf->reg, FALSE);
-            }else{
-                ws->current_managed=stf;
-            }
+    if(!OBJ_IS_BEING_DESTROYED(ws) && was_current){
+        /* This may still potentially cause problems when focus
+         * change is pending. Perhaps we should use region_await_focus,
+         * if it is pointing to our child (and region_may_control_focus 
+         * fail if it is pointing somewhere else).
+         */
+        WStacking *stf=find_to_focus(ws, next_st, TRUE);
+        if(stf!=NULL && mcf){
+            region_maybewarp_now(stf->reg, FALSE);
+        }else{
+            ws->current_managed=stf;
         }
     }
 }
@@ -382,6 +356,7 @@ bool group_init(WGroup *ws, WWindow *par, const WFitParams *fp)
     ws->managed_stdisp=NULL;
     ws->bottom=NULL;
     ws->managed_list=NULL;
+    ws->phs=NULL;
     
     ws->dummywin=XCreateWindow(ioncore_g.dpy, par->win,
                                 fp->g.x, fp->g.y, 1, 1, 0,
@@ -432,12 +407,14 @@ void group_deinit(WGroup *ws)
     XDeleteContext(ioncore_g.dpy, ws->dummywin, ioncore_g.win_context);
     XDestroyWindow(ioncore_g.dpy, ws->dummywin);
     ws->dummywin=None;
-
+    
+    while(ws->phs!=NULL)
+        grouppholder_do_unlink(ws->phs);
+    
     region_deinit(&ws->reg);
 }
 
 
-    
 bool group_rescue_clientwins(WGroup *ws, WRescueInfo *info)
 {
     WGroupIterTmp tmp;
@@ -450,47 +427,70 @@ bool group_rescue_clientwins(WGroup *ws, WRescueInfo *info)
 }
 
 
-static bool group_empty_for_bottom_stdisp(WGroup *ws)
+WPHolder *group_get_rescue_pholder_for(WGroup *ws, 
+                                       WRegion *forwhat)
 {
-    WGroupIterTmp tmp;
-    WStacking *st;
+    WGroupAttachParams ap=GROUPATTACHPARAMS_INIT;
+    WFramedParam fp=FRAMEDPARAM_INIT;
+    WPHolder *ph;
     
-    FOR_ALL_NODES_IN_GROUP(ws, st, tmp){
-        if(st!=ws->bottom && st!=ws->managed_stdisp)
-            return FALSE;
-    }
-    
-    return TRUE;
-}
-
+    ap.geom_set=TRUE;
+    ap.geom=REGION_GEOM(forwhat);
 
-static WRegion *group_managed_disposeroot(WGroup *ws, WRegion *reg)
-{
-    if(group_bottom(ws)==reg){
-        if(group_empty_for_bottom_stdisp(ws))
-            return region_disposeroot((WRegion*)ws);
+    ap.geom_weak_set=1;
+    
+    if(REGION_PARENT(forwhat)==REGION_PARENT(ws)){
+        ap.geom.x-=REGION_GEOM(ws).x;
+        ap.geom.y-=REGION_GEOM(ws).y;
+    }else{
+        ap.geom_weak=REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y;
     }
     
-    return reg;
+    /* frame mode */
+    /*{
+        WFrame *frame=OBJ_CAST(forwhat, WFrame);
+        if(frame!=NULL)
+            fp.mode=frame->mode;
+    }*/
+    
+    ph=(WPHolder*)create_grouppholder(ws, NULL, &ap);
+    
+    return pholder_either((WPHolder*)create_framedpholder(ph, &fp), ph);
 }
 
 
+
 /*}}}*/
 
 
 /*{{{ Bottom */
 
 
+void group_bottom_set(WGroup *grp)
+{
+    CALL_DYN(group_bottom_set, grp, (grp));
+}
+
+
 static void group_do_set_bottom(WGroup *grp, WStacking *st)
 {
     WStacking *was=grp->bottom;
+    WStacking *std=grp->managed_stdisp;
     
     grp->bottom=st;
     
-    if(st!=was){
-        if(st==NULL || HAS_DYN(st->reg, region_manage_stdisp))
+    if(!OBJ_IS_BEING_DESTROYED(grp)){
+        bool noremanage=((was==st) ||
+                         (was==NULL && std==NULL) || 
+                         (st!=NULL && st==std) || 
+                         (st==NULL && was==std));
+        
+        if(!noremanage &&
+           (st==NULL || HAS_DYN(st->reg, region_manage_stdisp))){
             group_remanage_stdisp(grp);
+        }
         
+        group_bottom_set(grp);
     }
 }
 
@@ -567,8 +567,7 @@ WStacking *group_do_add_managed_default(WGroup *ws, WRegion *reg, int level,
     
     frame=OBJ_CAST(reg, WFrame);
     if(frame!=NULL){
-        WFrameMode m=frame_mode(frame);
-        if(m==FRAME_MODE_TILED || m==FRAME_MODE_TILED_ALT)
+        if(framemode_unalt(frame_mode(frame))==FRAME_MODE_TILED)
             frame_set_mode(frame, FRAME_MODE_FLOATING);
     }
 
@@ -599,6 +598,14 @@ static void geom_group_to_parent(WGroup *ws, const WRectangle *g,
 }
 
 
+static int group_must_focus(WGroup *ws, WStacking *st)
+{
+    WStacking *stacking=group_get_stacking(ws);
+    
+    return (stacking!=NULL && stacking_must_focus(stacking, st));
+}
+
+
 bool group_do_attach_final(WGroup *ws, 
                            WRegion *reg,
                            const WGroupAttachParams *param)
@@ -681,27 +688,41 @@ bool group_do_attach_final(WGroup *ws,
         group_do_set_bottom(ws, st);
     
     /* Focus */
-    sw=(param->switchto_set ? param->switchto : ioncore_g.switchto_new);
+    sw=((param->switchto_set ? param->switchto : ioncore_g.switchto_new)
+        ? st==find_to_focus(ws, st, FALSE)
+        : group_must_focus(ws, st));
     
-    if(sw || st->level>=STACKING_LEVEL_MODAL1){
-        WStacking *stf=find_to_focus(ws, st, FALSE);
-        
-        if(stf==st){
-            /* Ok, the new region can be focused */
-            group_refocus_(ws, stf);
-        }
+    if(sw){
+        if(region_may_control_focus((WRegion*)ws))
+            region_set_focus(st->reg);
+        else
+            ws->current_managed=st;
+    }else if(region_is_fully_mapped(reg)){
+        region_pointer_focus_hack(reg);
     }
-    
+
     return TRUE;
 }
 
 
+static void group_attach_fp(WGroup *ws, const WGroupAttachParams *param,
+                            WFitParams *fp)
+{
+    if(param->geom_set){
+        geom_group_to_parent(ws, &param->geom, &fp->g);
+        fp->mode=REGION_FIT_EXACT;
+    }else{
+        fp->g=REGION_GEOM(ws);
+        fp->mode=REGION_FIT_BOUNDS|REGION_FIT_WHATEVER;
+    }
+}
+
+
 WRegion *group_do_attach(WGroup *ws, 
                          /*const*/ WGroupAttachParams *param,
                          WRegionAttachData *data)
 {
     WFitParams fp;
-    WWindow *par;
     WRegion *reg;
     
     if(ws->bottom!=NULL && param->bottom){
@@ -709,27 +730,20 @@ WRegion *group_do_attach(WGroup *ws,
         return NULL;
     }
     
-    par=REGION_PARENT(ws);
-    assert(par!=NULL);
-
-    if(param->geom_set){
-        geom_group_to_parent(ws, &param->geom, &fp.g);
-        fp.mode=REGION_FIT_EXACT;
-    }else{
-        fp.g=REGION_GEOM(ws);
-        fp.mode=REGION_FIT_BOUNDS|REGION_FIT_WHATEVER;
-    }
+    group_attach_fp(ws, param, &fp);
     
-    return region_attach_helper((WRegion*) ws, par, &fp, 
+    return region_attach_helper((WRegion*) ws, REGION_PARENT(ws), &fp, 
                                 (WRegionDoAttachFn*)group_do_attach_final,
                                 /*(const WRegionAttachParams*)*/param, data);
     /*                            ^^^^ doesn't seem to work. */
 }
 
 
-static void get_params(WGroup *ws, ExtlTab tab, WGroupAttachParams *par)
+void group_get_attach_params(WGroup *ws, ExtlTab tab, 
+                             WGroupAttachParams *par)
 {
     int tmp;
+    bool tmpb;
     char *tmps;
     ExtlTab g;
     
@@ -747,7 +761,7 @@ static void get_params(WGroup *ws, ExtlTab tab, WGroupAttachParams *par)
     
     if(extl_table_gets_i(tab, "level", &tmp)){
         if(tmp>=0){
-            par->level_set=STACKING_LEVEL_NORMAL;
+            par->level_set=1;
             par->level=tmp;
         }
     }
@@ -757,9 +771,11 @@ static void get_params(WGroup *ws, ExtlTab tab, WGroupAttachParams *par)
         par->level_set=1;
     }
     
-    if(extl_table_is_bool_set(tab, "switchto"))
-        par->switchto=1;
-
+    if(extl_table_gets_b(tab, "switchto", &tmpb)){
+        par->switchto=(tmpb!=0);
+        par->switchto_set=1;
+    }
+    
     if(extl_table_gets_i(tab, "sizepolicy", &tmp)){
         par->szplcy_set=1;
         par->szplcy=tmp;
@@ -804,7 +820,7 @@ WRegion *group_attach(WGroup *ws, WRegion *reg, ExtlTab param)
     if(reg==NULL)
         return NULL;
     
-    get_params(ws, param, &par);
+    group_get_attach_params(ws, param, &par);
     
     data.type=REGION_ATTACH_REPARENT;
     data.u.reg=reg;
@@ -825,6 +841,8 @@ WRegion *group_attach(WGroup *ws, WRegion *reg, ExtlTab param)
  *  \var{level} & (integer) Stacking level; default is 1. \\
  *  \var{modal} & (boolean) Make object modal; ignored if level is set. \\
  *  \var{sizepolicy} & (string) Size policy; see Section \ref{sec:sizepolicies}. \\
+ *  \var{bottom} & (boolean) Mark the attached region as the
+ *                 ``bottom'' of \var{ws}. \\
  * \end{tabularx}
  * 
  * In addition parameters to the region to be created are passed in this 
@@ -836,7 +854,7 @@ WRegion *group_attach_new(WGroup *ws, ExtlTab param)
     WGroupAttachParams par=GROUPATTACHPARAMS_INIT;
     WRegionAttachData data;
 
-    get_params(ws, param, &par);
+    group_get_attach_params(ws, param, &par);
     
     data.type=REGION_ATTACH_LOAD;
     data.u.tab=param;
@@ -854,29 +872,34 @@ WRegion *group_attach_new(WGroup *ws, ExtlTab param)
 static int stdisp_szplcy(const WMPlexSTDispInfo *di, WRegion *stdisp)
 {
     int pos=di->pos;
+    int policy=0, gravity=0;
     
     if(di->fullsize){
         if(region_orientation(stdisp)==REGION_ORIENTATION_VERTICAL){
             if(pos==MPLEX_STDISP_TL || pos==MPLEX_STDISP_BL)
-                return SIZEPOLICY_STRETCH_LEFT;
+                policy=SIZEPOLICY_STRETCH_LEFT;
             else
-                return SIZEPOLICY_STRETCH_RIGHT;
+                policy=SIZEPOLICY_STRETCH_RIGHT;
         }else{
             if(pos==MPLEX_STDISP_TL || pos==MPLEX_STDISP_TR)
-                return SIZEPOLICY_STRETCH_TOP;
+                policy=SIZEPOLICY_STRETCH_TOP;
             else
-                return SIZEPOLICY_STRETCH_BOTTOM;
+                policy=SIZEPOLICY_STRETCH_BOTTOM;
         }
     }else{
-        if(pos==MPLEX_STDISP_TL)
-            return SIZEPOLICY_GRAVITY_NORTHWEST;
-        else if(pos==MPLEX_STDISP_BL)
-            return SIZEPOLICY_GRAVITY_SOUTHWEST;
-        else if(pos==MPLEX_STDISP_TR)
-            return SIZEPOLICY_GRAVITY_NORTHEAST;
-        else /*if(pos=MPLEX_STDISP_BR)*/
-            return SIZEPOLICY_GRAVITY_SOUTHEAST;
+        policy=SIZEPOLICY_GRAVITY;
     }
+    
+    if(pos==MPLEX_STDISP_TL)
+        gravity=SIZEPOLICY_VERT_TOP|SIZEPOLICY_HORIZ_LEFT;
+    else if(pos==MPLEX_STDISP_BL)
+        gravity=SIZEPOLICY_VERT_BOTTOM|SIZEPOLICY_HORIZ_LEFT;
+    else if(pos==MPLEX_STDISP_TR)
+        gravity=SIZEPOLICY_VERT_TOP|SIZEPOLICY_HORIZ_RIGHT;
+    else /*if(pos=MPLEX_STDISP_BR)*/
+        gravity=SIZEPOLICY_VERT_BOTTOM|SIZEPOLICY_HORIZ_RIGHT;
+    
+    return (policy|gravity);
 }
 
 
@@ -910,8 +933,12 @@ void group_manage_stdisp(WGroup *ws, WRegion *stdisp,
                                                 STACKING_LEVEL_ON_TOP, 
                                                 szplcy);
     }
-
+    
+    stdisp->flags|=REGION_SKIP_FOCUS;
+    
     fp.g=REGION_GEOM(ws);
+    fp.mode=0;
+    
     sizepolicy(&ws->managed_stdisp->szplcy, stdisp, NULL, 0, &fp);
 
     region_fitrep(stdisp, NULL, &fp);
@@ -950,6 +977,7 @@ void group_managed_rqgeom(WGroup *ws, WRegion *reg,
         fp.mode=REGION_FIT_EXACT;
     }else{
         fp.g=REGION_GEOM(ws);
+        fp.mode=0;
         sizepolicy(&st->szplcy, reg, &rq->geom, rq->flags, &fp);
     }
     
@@ -1186,7 +1214,8 @@ bool group_managed_rqorder(WGroup *grp, WRegion *reg, WRegionOrder order)
 /*EXTL_DOC
  * Iterate over managed regions of \var{ws} until \var{iterfn} returns
  * \code{false}.
- * The function itself returns \code{true} if it reaches the end of list
+ * The function is called in protected mode.
+ * This routine returns \code{true} if it reaches the end of list
  * without this happening.
  */
 EXTL_SAFE
@@ -1306,7 +1335,7 @@ static ExtlTab group_get_configuration(WGroup *ws)
     return tab;
 }
 
-
+    
 void group_do_load(WGroup *ws, ExtlTab tab)
 {
     ExtlTab substab, subtab;
@@ -1316,7 +1345,23 @@ void group_do_load(WGroup *ws, ExtlTab tab)
         n=extl_table_get_n(substab);
         for(i=1; i<=n; i++){
             if(extl_table_geti_t(substab, i, &subtab)){
-                group_attach_new(ws, subtab);
+                WGroupAttachParams par=GROUPATTACHPARAMS_INIT;
+                WRegionAttachData data;
+                WFitParams fp;
+                WPHolder *ph;
+                
+                group_get_attach_params(ws, subtab, &par);
+                group_attach_fp(ws, &par, &fp);
+                
+                ph=(WPHolder*)create_grouppholder(ws, NULL, &par);
+                
+                region_attach_load_helper((WRegion*)ws, REGION_PARENT(ws), &fp,
+                                          (WRegionDoAttachFn*)group_do_attach_final,
+                                          (void*)&par, subtab, &ph);
+                                              
+                if(ph!=NULL)
+                    destroy_obj((Obj*)ph);
+                
                 extl_unref_table(subtab);
             }
         }
@@ -1372,9 +1417,6 @@ static DynFunTab group_dynfuntab[]={
     {(DynFun*)region_get_configuration, 
      (DynFun*)group_get_configuration},
 
-    {(DynFun*)region_managed_disposeroot,
-     (DynFun*)group_managed_disposeroot},
-
     {(DynFun*)region_current,
      (DynFun*)group_current},
     
@@ -1413,6 +1455,9 @@ static DynFunTab group_dynfuntab[]={
     
     {(DynFun*)region_managed_rqorder,
      (DynFun*)group_managed_rqorder},
+     
+    {(DynFun*)region_get_rescue_pholder_for,
+     (DynFun*)group_get_rescue_pholder_for},
     
     END_DYNFUNTAB
 };