ioncore/grouppholder.c

   1 /*
   2  * ion/ioncore/grouppholder.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 2005-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <libtu/objp.h>
  10 #include <libtu/obj.h>
  11 #include <libtu/pointer.h>
  12 #include <libmainloop/defer.h>
  13
  14 #include <ioncore/common.h>
  15 #include "group.h"
  16 #include "group-cw.h"
  17 #include "grouppholder.h"
  18
  19
  20 /*{{{ Primitives */
  21
  22
  23 void grouppholder_do_link(WGroupPHolder *ph, WGroup *group, WRegion *stack_above)
  24 {
  25     ph->group=group;
  26
  27     if(group!=NULL){
  28         LINK_ITEM_FIRST(group->phs, ph, next, prev);
  29     }else{
  30         /* This seems very crucial for detached pholders... */
  31         ph->next=NULL;
  32         ph->prev=ph;
  33     }
  34
  35     /* We must move stack_above pointer into a Watch. */
  36     if(stack_above!=NULL)
  37         watch_setup(&(ph->stack_above_watch), (Obj*)stack_above, NULL);
  38 }
  39
  40
  41 static WGroupPHolder *get_head(WGroupPHolder *ph)
  42 {
  43     while(1){
  44         /* ph->prev==NULL should not happen.. */
  45         if(ph->prev==NULL || ph->prev->next==NULL)
  46             break;
  47         ph=ph->prev;
  48     }
  49
  50     return ph;
  51 }
  52
  53
  54 void grouppholder_do_unlink(WGroupPHolder *ph)
  55 {
  56     WGroup *group=ph->group;
  57
  58     watch_reset(&(ph->stack_above_watch));
  59
  60     if(ph->recreate_pholder!=NULL){
  61         if(ph->next!=NULL){
  62             ph->next->recreate_pholder=ph->recreate_pholder;
  63         }else{
  64             /* It might be in use in attach chain! So defer. */
  65             mainloop_defer_destroy((Obj*)ph->recreate_pholder);
  66         }
  67         ph->recreate_pholder=NULL;
  68     }
  69
  70     if(group!=NULL){
  71         UNLINK_ITEM(group->phs, ph, next, prev);
  72     }else if(ph->prev!=NULL){
  73         WGroupPHolder *next=ph->next;
  74
  75         ph->prev->next=next;
  76
  77         if(next==NULL){
  78             next=get_head(ph);
  79             assert(next->prev==ph);
  80         }
  81         next->prev=ph->prev;
  82     }else{
  83         /* ph should not be on a list, if prev pointer is NULL (whereas
  84          * next alone can be NULL in our semi-doubly-linked lists).
  85          */
  86         assert(ph->next==NULL);
  87     }
  88
  89     ph->group=NULL;
  90     ph->next=NULL;
  91     ph->prev=NULL;
  92 }
  93
  94
  95 /*}}}*/
  96
  97
  98 /*{{{ Init/deinit */
  99
 100 static WGroupAttachParams dummy_param=GROUPATTACHPARAMS_INIT;
 101
 102
 103 bool grouppholder_init(WGroupPHolder *ph, WGroup *ws,
 104                        const WStacking *st,
 105                        const WGroupAttachParams *param)
 106 {
 107     WRegion *stack_above=NULL;
 108
 109     pholder_init(&(ph->ph));
 110
 111     watch_init(&(ph->stack_above_watch));
 112     ph->next=NULL;
 113     ph->prev=NULL;
 114     ph->group=NULL;
 115     ph->recreate_pholder=NULL;
 116     ph->param=(param==NULL ? dummy_param : *param);
 117
 118     if(st!=NULL){
 119         /* TODO? Just link to the stacking structure to remember
 120          * stacking order?
 121          */
 122
 123         ph->param.szplcy_set=TRUE;
 124         ph->param.szplcy=st->szplcy;
 125         ph->param.level_set=TRUE;
 126         ph->param.level=st->level;
 127
 128         if(st->reg!=NULL){
 129             ph->param.geom_set=TRUE;
 130             ph->param.geom=REGION_GEOM(st->reg);
 131         }
 132
 133         if(st->above!=NULL && st->above->reg!=NULL)
 134             ph->param.stack_above=st->above->reg;
 135
 136         ph->param.bottom=(st==ws->bottom);
 137     }
 138
 139     ph->param.switchto_set=FALSE;
 140
 141     stack_above=ph->param.stack_above;
 142     ph->param.stack_above=NULL;
 143
 144     grouppholder_do_link(ph, ws, stack_above);
 145
 146     return TRUE;
 147 }
 148
 149
 150 WGroupPHolder *create_grouppholder(WGroup *ws,
 151                                    const WStacking *st,
 152                                    const WGroupAttachParams *param)
 153 {
 154     CREATEOBJ_IMPL(WGroupPHolder, grouppholder, (p, ws, st, param));
 155 }
 156
 157
 158 void grouppholder_deinit(WGroupPHolder *ph)
 159 {
 160     grouppholder_do_unlink(ph);
 161
 162     pholder_deinit(&(ph->ph));
 163 }
 164
 165
 166 /*}}}*/
 167
 168
 169 /*{{{ Dynfuns */
 170
 171
 172 static WPHolder *get_recreate_ph(WGroupPHolder *ph)
 173 {
 174     return get_head(ph)->recreate_pholder;
 175 }
 176
 177
 178 typedef struct{
 179     WGroupPHolder *ph, *ph_head;
 180     WRegionAttachData *data;
 181     WRegion *reg_ret;
 182 } RP;
 183
 184
 185 static WRegion *recreate_handler(WWindow *par,
 186                                  const WFitParams *fp,
 187                                  void *rp_)
 188 {
 189     WGroupPHolder *phtmp;
 190     RP *rp=(RP*)rp_;
 191     WGroup *grp;
 192
 193     grp=(WGroup*)create_groupcw(par, fp);
 194
 195     if(grp==NULL)
 196         return NULL;
 197
 198     rp->ph->param.whatever=(fp->mode&REGION_FIT_WHATEVER ? 1 : 0);
 199
 200     rp->reg_ret=group_do_attach(grp, &rp->ph->param, rp->data);
 201
 202     rp->ph->param.whatever=0;
 203
 204     if(rp->reg_ret==NULL){
 205         destroy_obj((Obj*)grp);
 206         return NULL;
 207     }else{
 208         grp->phs=rp->ph_head;
 209
 210         for(phtmp=grp->phs; phtmp!=NULL; phtmp=phtmp->next)
 211             phtmp->group=grp;
 212     }
 213
 214     if(fp->mode&REGION_FIT_WHATEVER)
 215         REGION_GEOM(grp)=REGION_GEOM(rp->reg_ret);
 216
 217     return (WRegion*)grp;
 218 }
 219
 220
 221
 222 static WRegion *grouppholder_attach_recreate(WGroupPHolder *ph, int flags,
 223                                              WRegionAttachData *data)
 224 {
 225     WRegionAttachData data2;
 226     WPHolder *rph;
 227     WRegion *res;
 228     RP rp;
 229
 230     rp.ph_head=get_head(ph);
 231
 232     assert(rp.ph_head!=NULL);
 233
 234     rph=rp.ph_head->recreate_pholder;
 235
 236     if(rph==NULL)
 237         return NULL;
 238
 239     rp.ph=ph;
 240     rp.data=data;
 241     rp.reg_ret=NULL;
 242
 243     data2.type=REGION_ATTACH_NEW;
 244     data2.u.n.fn=recreate_handler;
 245     data2.u.n.param=&rp;
 246
 247     res=pholder_do_attach(rph, flags, &data2);
 248
 249     if(res!=NULL){
 250         rp.ph_head->recreate_pholder=NULL;
 251         /* It might be in use in attach chain! So defer. */
 252         mainloop_defer_destroy((Obj*)rph);
 253     }
 254
 255     return (flags&PHOLDER_ATTACH_RETURN_CREATEROOT
 256             ? (WRegion*)res
 257             : rp.reg_ret);
 258 }
 259
 260
 261 WRegion *grouppholder_do_attach(WGroupPHolder *ph, int flags,
 262                                 WRegionAttachData *data)
 263 {
 264     WGroup *ws=ph->group;
 265     WRegion *reg;
 266
 267     if(ws==NULL)
 268         return grouppholder_attach_recreate(ph, flags, data);
 269
 270     ph->param.switchto_set=1;
 271     ph->param.switchto=(flags&PHOLDER_ATTACH_SWITCHTO ? 1 : 0);
 272
 273     /* Get stack_above from Watch. */
 274     ph->param.stack_above=(WRegion*)ph->stack_above_watch.obj;
 275
 276     reg=group_do_attach(ws, &ph->param, data);
 277
 278     ph->param.stack_above=NULL;
 279
 280     return reg;
 281 }
 282
 283
 284 bool grouppholder_do_goto(WGroupPHolder *ph)
 285 {
 286     return (ph->group!=NULL
 287             ? region_goto((WRegion*)ph->group)
 288             : (ph->recreate_pholder!=NULL
 289                ? pholder_do_goto(ph->recreate_pholder)
 290                : FALSE));
 291 }
 292
 293
 294 WRegion *grouppholder_do_target(WGroupPHolder *ph)
 295 {
 296     return (ph->group!=NULL
 297             ? (WRegion*)ph->group
 298             : (ph->recreate_pholder!=NULL
 299                ? pholder_do_target(ph->recreate_pholder)
 300                : NULL));
 301 }
 302
 303
 304 /*}}}*/
 305
 306
 307 /*{{{ WGroup stuff */
 308
 309
 310 WGroupPHolder *group_managed_get_pholder(WGroup *ws, WRegion *mgd)
 311 {
 312     WStacking *st=group_find_stacking(ws, mgd);
 313
 314     if(mgd==NULL)
 315         return NULL;
 316     else
 317         return create_grouppholder(ws, st, NULL);
 318 }
 319
 320
 321 /*}}}*/
 322
 323
 324 /*{{{ Class information */
 325
 326
 327 static DynFunTab grouppholder_dynfuntab[]={
 328     {(DynFun*)pholder_do_attach,
 329      (DynFun*)grouppholder_do_attach},
 330
 331     {(DynFun*)pholder_do_goto,
 332      (DynFun*)grouppholder_do_goto},
 333
 334     {(DynFun*)pholder_do_target,
 335      (DynFun*)grouppholder_do_target},
 336
 337     END_DYNFUNTAB
 338 };
 339
 340 IMPLCLASS(WGroupPHolder, WPHolder, grouppholder_deinit,
 341           grouppholder_dynfuntab);
 342
 343
 344 /*}}}*/
 345