ioncore/group-ws.c

   1 /*
   2  * ion/ioncore/group-ws.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 <libtu/minmax.h>
  12 #include <libtu/objp.h>
  13
  14 #include "common.h"
  15 #include "global.h"
  16 #include "region.h"
  17 #include "focus.h"
  18 #include "group.h"
  19 #include "regbind.h"
  20 #include "bindmaps.h"
  21 #include "xwindow.h"
  22 #include "group-ws.h"
  23 #include "group-cw.h"
  24 #include "grouppholder.h"
  25 #include "framedpholder.h"
  26 #include "float-placement.h"
  27 #include "resize.h"
  28 #include "conf.h"
  29 #include "saveload.h"
  30 #include "screen-notify.h"
  31
  32
  33 /*{{{ Settings */
  34
  35
  36 void ioncore_groupws_set(ExtlTab tab)
  37 {
  38     char *method=NULL;
  39     int fpp;
  40
  41     if(extl_table_gets_s(tab, "float_placement_method", &method)){
  42         if(strcmp(method, "udlr")==0)
  43             ioncore_placement_method=PLACEMENT_UDLR;
  44         else if(strcmp(method, "lrud")==0)
  45             ioncore_placement_method=PLACEMENT_LRUD;
  46         else if(strcmp(method, "random")==0)
  47             ioncore_placement_method=PLACEMENT_RANDOM;
  48         else
  49             warn(TR("Unknown placement method \"%s\"."), method);
  50         free(method);
  51     }
  52     if(extl_table_gets_i(tab, "float_placement_padding", &fpp))
  53         ioncore_placement_padding=maxof(0, fpp);
  54 }
  55
  56
  57 void ioncore_groupws_get(ExtlTab t)
  58 {
  59     extl_table_sets_s(t, "float_placement_method",
  60                       (ioncore_placement_method==PLACEMENT_UDLR
  61                        ? "udlr"
  62                        : (ioncore_placement_method==PLACEMENT_LRUD
  63                           ? "lrud"
  64                           : "random")));
  65     extl_table_sets_i(t, "float_placement_padding", ioncore_placement_padding);
  66 }
  67
  68
  69 /*}}}*/
  70
  71
  72 /*{{{ Attach stuff */
  73
  74
  75 static bool groupws_attach_framed(WGroupWS *ws,
  76                                   WGroupAttachParams *ap,
  77                                   WFramedParam *fp,
  78                                   WRegion *reg)
  79 {
  80     WRegionAttachData data;
  81
  82     data.type=REGION_ATTACH_REPARENT;
  83     data.u.reg=reg;
  84
  85     return (region_attach_framed((WRegion*)ws, fp,
  86                                  (WRegionAttachFn*)group_do_attach,
  87                                  ap, &data)!=NULL);
  88 }
  89
  90
  91 bool groupws_handle_drop(WGroupWS *ws, int x, int y,
  92                          WRegion *dropped)
  93 {
  94     WGroupAttachParams ap=GROUPATTACHPARAMS_INIT;
  95     WFramedParam fp=FRAMEDPARAM_INIT;
  96
  97     ap.switchto_set=TRUE;
  98     ap.switchto=TRUE;
  99
 100     fp.inner_geom_gravity_set=TRUE;
 101     fp.inner_geom.x=x;
 102     fp.inner_geom.y=y;
 103     fp.inner_geom.w=REGION_GEOM(dropped).w;
 104     fp.inner_geom.h=REGION_GEOM(dropped).h;
 105     fp.gravity=NorthWestGravity;
 106
 107     return groupws_attach_framed(ws, &ap, &fp, dropped);
 108 }
 109
 110
 111 /*EXTL_DOC
 112  * Attach region \var{reg} on \var{ws}.
 113  * At least the following fields in \var{t} are supported:
 114  *
 115  * \begin{tabularx}{\linewidth}{lX}
 116  *  \tabhead{Field & Description}
 117  *  \var{switchto} & Should the region be switched to (boolean)? Optional. \\
 118  *  \var{geom} & Geometry; \var{x} and \var{y}, if set, indicates top-left of
 119  *   the frame to be created while \var{width} and \var{height}, if set, indicate
 120  *   the size of the client window within that frame. Optional.
 121  * \end{tabularx}
 122  */
 123 EXTL_EXPORT_AS(WGroupWS, attach_framed)
 124 bool groupws_attach_framed_extl(WGroupWS *ws, WRegion *reg, ExtlTab t)
 125 {
 126     WGroupAttachParams ap=GROUPATTACHPARAMS_INIT;
 127     WFramedParam frp=FRAMEDPARAM_INIT;
 128
 129     if(reg==NULL)
 130         return FALSE;
 131
 132     groupattachparams_get(&ap, t, NULL);
 133
 134     /* Sensible size is given in framedparams */
 135     if(ap.geom_set){
 136         ap.geom_set=0;
 137         ap.geom_weak_set=1;
 138         ap.geom_weak=0;
 139
 140         frp.inner_geom_gravity_set=1;
 141         frp.inner_geom=ap.geom;
 142         frp.gravity=NorthWestGravity;
 143         extl_table_gets_i(t, "gravity", &frp.gravity);
 144     }
 145
 146     return groupws_attach_framed(ws, &ap, &frp, reg);
 147 }
 148
 149
 150 /*}}}*/
 151
 152
 153 /*{{{ groupws_prepare_manage */
 154
 155
 156 static WPHolder *groupws_do_prepare_manage(WGroupWS *ws,
 157                                            const WClientWin *cwin,
 158                                            const WManageParams *param)
 159 {
 160     WGroupAttachParams ap=GROUPATTACHPARAMS_INIT;
 161     WFramedParam fp=FRAMEDPARAM_INIT;
 162     WPHolder *ph;
 163
 164
 165     fp.inner_geom_gravity_set=TRUE;
 166     fp.inner_geom=param->geom;
 167     fp.gravity=param->gravity;
 168
 169     groupattachparams_get(&ap, cwin->proptab, "attach_params");
 170
 171     if(param->userpos ||
 172        !param->maprq || ioncore_g.opmode==IONCORE_OPMODE_INIT){
 173         ap.geom_weak_set=1;
 174         ap.geom_weak=0;
 175     }else if(!ap.geom_weak_set){
 176         ap.geom_weak_set=1;
 177         ap.geom_weak=REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y;
 178     }
 179
 180     ph=(WPHolder*)create_grouppholder(&ws->grp, NULL, &ap);
 181
 182     if(ph!=NULL)
 183         ph=pholder_either((WPHolder*)create_framedpholder(ph, &fp), ph);
 184
 185     if(ph!=NULL){
 186         WGroupPHolder *gph;
 187         WGroupAttachParams gp=GROUPATTACHPARAMS_INIT;
 188
 189         gp.switchto_set=1;
 190         gp.switchto=1;
 191         gp.bottom=1;
 192
 193         gph=create_grouppholder(NULL, NULL, &gp);
 194
 195         if(gph!=NULL){
 196             gph->recreate_pholder=ph;
 197             return (WPHolder*)gph;
 198         }
 199     }
 200
 201     return ph;
 202 }
 203
 204
 205 WPHolder *groupws_prepare_manage(WGroupWS *ws, const WClientWin *cwin,
 206                                  const WManageParams *param,
 207                                  int priority)
 208 {
 209     int cpriority=MANAGE_PRIORITY_SUB(priority, MANAGE_PRIORITY_GROUP);
 210     int bpriority=MANAGE_PRIORITY_SUBX(priority, MANAGE_PRIORITY_GROUP);
 211     WRegion *b=(ws->grp.bottom!=NULL ? ws->grp.bottom->reg : NULL);
 212     WPHolder *ph=NULL;
 213     bool act_b=(ws->grp.bottom==ws->grp.current_managed);
 214     bool use_bottom;
 215
 216     if(b!=NULL && !HAS_DYN(b, region_prepare_manage))
 217         b=NULL;
 218
 219     use_bottom=(act_b
 220                 ? !extl_table_is_bool_set(cwin->proptab, "float")
 221                 : act_b);
 222
 223     if(b!=NULL && use_bottom)
 224         ph=region_prepare_manage(b, cwin, param, bpriority);
 225
 226     if(ph==NULL){
 227         /* Check current */
 228         WRegion *r=(ws->grp.current_managed!=NULL
 229                     ? ws->grp.current_managed->reg
 230                     : NULL);
 231
 232         if(r!=NULL && r!=b)
 233             ph=region_prepare_manage(r, cwin, param, cpriority);
 234     }
 235
 236     if(ph==NULL && MANAGE_PRIORITY_OK(priority, MANAGE_PRIORITY_GROUP))
 237         ph=groupws_do_prepare_manage(ws, cwin, param);
 238
 239     if(ph==NULL && b!=NULL && !use_bottom)
 240         ph=region_prepare_manage(b, cwin, param, cpriority);
 241
 242     return ph;
 243 }
 244
 245
 246 WPHolder *groupws_prepare_manage_transient(WGroupWS *ws, const WClientWin *cwin,
 247                                            const WManageParams *param,
 248                                            int UNUSED(unused))
 249 {
 250     WGroupAttachParams ap=GROUPATTACHPARAMS_INIT;
 251     WFramedParam fp=FRAMEDPARAM_INIT;
 252     WPHolder *ph;
 253
 254     ap.stack_above=OBJ_CAST(REGION_PARENT(param->tfor), WRegion);
 255     if(ap.stack_above==NULL)
 256         return NULL;
 257
 258     fp.inner_geom_gravity_set=TRUE;
 259     fp.inner_geom=param->geom;
 260     fp.gravity=param->gravity;
 261     fp.mode=FRAME_MODE_TRANSIENT;
 262
 263     groupattachparams_get(&ap, cwin->proptab, "attach_params");
 264
 265     if(!ap.geom_weak_set || param->userpos ||
 266        !param->maprq || ioncore_g.opmode==IONCORE_OPMODE_INIT){
 267         ap.geom_weak_set=1;
 268         ap.geom_weak=0;
 269     }
 270
 271     ph=(WPHolder*)create_grouppholder(&ws->grp, NULL, &ap);
 272
 273     return pholder_either((WPHolder*)create_framedpholder(ph, &fp), ph);
 274 }
 275
 276
 277 static bool group_empty_for_bottom_stdisp(WGroup *ws)
 278 {
 279     WGroupIterTmp tmp;
 280     WStacking *st;
 281
 282     FOR_ALL_NODES_IN_GROUP(ws, st, tmp){
 283         if(st!=ws->bottom && st!=ws->managed_stdisp)
 284             return FALSE;
 285     }
 286
 287     return TRUE;
 288 }
 289
 290
 291 static WRegion *groupws_managed_disposeroot(WGroupWS *ws, WRegion *reg)
 292 {
 293     if(group_bottom(&ws->grp)==reg){
 294         if(group_empty_for_bottom_stdisp(&ws->grp))
 295             return region_disposeroot((WRegion*)ws);
 296     }
 297
 298     return reg;
 299 }
 300
 301
 302 /*}}}*/
 303
 304
 305 /*{{{ WGroupWS class */
 306
 307
 308 bool groupws_init(WGroupWS *ws, WWindow *parent, const WFitParams *fp)
 309 {
 310     if(!group_init(&(ws->grp), parent, fp, "Notion GroupWS"))
 311         return FALSE;
 312
 313     ws->initial_outputs=extl_create_table();
 314
 315     ((WRegion*)ws)->flags|=REGION_GRAB_ON_PARENT;
 316
 317     region_add_bindmap((WRegion*)ws, ioncore_groupws_bindmap);
 318
 319     return TRUE;
 320 }
 321
 322
 323 WGroupWS *create_groupws(WWindow *parent, const WFitParams *fp)
 324 {
 325     CREATEOBJ_IMPL(WGroupWS, groupws, (p, parent, fp));
 326 }
 327
 328
 329 void groupws_deinit(WGroupWS *ws)
 330 {
 331     extl_unref_table(ws->initial_outputs);
 332
 333     screen_unnotify_if_workspace(ws);
 334
 335     group_deinit(&(ws->grp));
 336 }
 337
 338
 339 WRegion *groupws_load(WWindow *par, const WFitParams *fp,
 340                       ExtlTab tab)
 341 {
 342     WGroupWS *ws;
 343     ExtlTab io;
 344
 345     ws=create_groupws(par, fp);
 346
 347     if(ws==NULL)
 348         return NULL;
 349
 350     group_do_load(&ws->grp, tab);
 351
 352     if(extl_table_gets_t(tab, "initial_outputs", &io))
 353         ws->initial_outputs=io;
 354
 355     return (WRegion*)ws;
 356 }
 357
 358 ExtlTab groupws_get_configuration(WGroupWS *ws)
 359 {
 360
 361     ExtlTab tab;
 362
 363     tab=group_get_configuration(&ws->grp);
 364     extl_table_sets_t(tab, "initial_outputs", ws->initial_outputs);
 365     return tab;
 366 }
 367
 368 EXTL_SAFE
 369 EXTL_EXPORT_MEMBER
 370 ExtlTab groupws_get_initial_outputs(WGroupWS *ws)
 371 {
 372     return extl_ref_table(ws->initial_outputs);
 373 }
 374
 375 EXTL_SAFE
 376 EXTL_EXPORT_MEMBER
 377 void groupws_set_initial_outputs(WGroupWS *ws, ExtlTab tab)
 378 {
 379     extl_unref_table(ws->initial_outputs);
 380     ws->initial_outputs=extl_ref_table(tab);
 381 }
 382
 383
 384 static DynFunTab groupws_dynfuntab[]={
 385     {(DynFun*)region_prepare_manage,
 386      (DynFun*)groupws_prepare_manage},
 387
 388     {(DynFun*)region_prepare_manage_transient,
 389      (DynFun*)groupws_prepare_manage_transient},
 390
 391     {(DynFun*)region_managed_disposeroot,
 392      (DynFun*)groupws_managed_disposeroot},
 393
 394     {(DynFun*)region_handle_drop,
 395      (DynFun*)groupws_handle_drop},
 396
 397     {region_manage_stdisp,
 398      group_manage_stdisp},
 399
 400     {(DynFun*)region_get_configuration,
 401      (DynFun*)groupws_get_configuration},
 402
 403     END_DYNFUNTAB
 404 };
 405
 406
 407 EXTL_EXPORT
 408 IMPLCLASS(WGroupWS, WGroup, groupws_deinit, groupws_dynfuntab);
 409
 410
 411 /*}}}*/
 412