ioncore/screen.c

   1 /*
   2  * ion/ioncore/screen.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/objp.h>
  12 #include <libtu/minmax.h>
  13
  14 #include "common.h"
  15 #include "global.h"
  16 #include "screen.h"
  17 #include "region.h"
  18 #include "attach.h"
  19 #include "manage.h"
  20 #include "focus.h"
  21 #include "property.h"
  22 #include "names.h"
  23 #include "reginfo.h"
  24 #include "saveload.h"
  25 #include "resize.h"
  26 #include "event.h"
  27 #include "bindmaps.h"
  28 #include "regbind.h"
  29 #include "frame-pointer.h"
  30 #include "rectangle.h"
  31 #include "extlconv.h"
  32 #include "llist.h"
  33 #include "group-ws.h"
  34 #include "mplex.h"
  35 #include "conf.h"
  36 #include "activity.h"
  37 #include "screen-notify.h"
  38
  39
  40 WHook *screen_managed_changed_hook=NULL;
  41
  42
  43 /*{{{ Init/deinit */
  44
  45
  46 bool screen_init(WScreen *scr, WRootWin *parent,
  47                  const WFitParams *fp, int id, Window rootwin)
  48 {
  49     Window win;
  50     XSetWindowAttributes attr;
  51     ulong attrflags=0;
  52     bool is_root=FALSE;
  53
  54     scr->id=id;
  55     scr->atom_workspace=None;
  56     scr->managed_off.x=0;
  57     scr->managed_off.y=0;
  58     scr->managed_off.w=0;
  59     scr->managed_off.h=0;
  60     scr->next_scr=NULL;
  61     scr->prev_scr=NULL;
  62
  63     watch_init(&(scr->notifywin_watch));
  64     watch_init(&(scr->infowin_watch));
  65
  66     if(parent==NULL){
  67         win=rootwin;
  68         is_root=TRUE;
  69     }else{
  70         attr.background_pixmap=ParentRelative;
  71         attrflags=CWBackPixmap;
  72
  73         win=XCreateWindow(ioncore_g.dpy, WROOTWIN_ROOT(parent),
  74                           fp->g.x, fp->g.y, fp->g.w, fp->g.h, 0,
  75                           DefaultDepth(ioncore_g.dpy, parent->xscr),
  76                           InputOutput,
  77                           DefaultVisual(ioncore_g.dpy, parent->xscr),
  78                           attrflags, &attr);
  79         if(win==None)
  80             return FALSE;
  81     }
  82
  83     if(!mplex_do_init((WMPlex*)scr, (WWindow*)parent, fp, win, "WScreen")){
  84         if(!is_root)
  85             XDestroyWindow(ioncore_g.dpy, win);
  86         return FALSE;
  87     }
  88
  89     /*scr->mplex.win.region.rootwin=rootwin;
  90     region_set_parent((WRegion*)scr, (WRegion*)rootwin);*/
  91     scr->mplex.flags|=MPLEX_ADD_TO_END;
  92     scr->mplex.win.region.flags|=REGION_BINDINGS_ARE_GRABBED;
  93
  94     if(!is_root){
  95         scr->mplex.win.region.flags|=REGION_MAPPED;
  96         window_select_input((WWindow*)scr, IONCORE_EVENTMASK_SCREEN);
  97     }
  98
  99     if(id==0){
 100         scr->atom_workspace=XInternAtom(ioncore_g.dpy,
 101                                         "_ION_WORKSPACE", False);
 102     }else if(id>=0){
 103         char *str;
 104         libtu_asprintf(&str, "_ION_WORKSPACE%d", id);
 105         if(str!=NULL){
 106             scr->atom_workspace=XInternAtom(ioncore_g.dpy, str, False);
 107             free(str);
 108         }
 109     }
 110
 111     /* Add all the needed bindings here; mplex does nothing so that
 112      * frames don't have to remove extra bindings.
 113      */
 114     region_add_bindmap((WRegion*)scr, ioncore_screen_bindmap);
 115     region_add_bindmap((WRegion*)scr, ioncore_mplex_bindmap);
 116     region_add_bindmap((WRegion*)scr, ioncore_mplex_toplevel_bindmap);
 117
 118     LINK_ITEM(ioncore_g.screens, scr, next_scr, prev_scr);
 119
 120     return TRUE;
 121 }
 122
 123
 124 WScreen *create_screen(WRootWin *parent, const WFitParams *fp, int id)
 125 {
 126     CREATEOBJ_IMPL(WScreen, screen, (p, parent, fp, id, None));
 127 }
 128
 129
 130 void screen_deinit(WScreen *scr)
 131 {
 132     UNLINK_ITEM(ioncore_g.screens, scr, next_scr, prev_scr);
 133
 134     mplex_deinit((WMPlex*)scr);
 135 }
 136
 137
 138 /*}}}*/
 139
 140
 141 /*{{{ Attach/detach */
 142
 143
 144 void screen_managed_geom(WScreen *scr, WRectangle *geom)
 145 {
 146     geom->x=scr->managed_off.x;
 147     geom->y=scr->managed_off.y;
 148     geom->w=REGION_GEOM(scr).w+scr->managed_off.w;
 149     geom->h=REGION_GEOM(scr).h+scr->managed_off.h;
 150     geom->w=maxof(geom->w, 0);
 151     geom->h=maxof(geom->h, 0);
 152 }
 153
 154
 155 static bool screen_handle_drop(WScreen *scr, int x, int y, WRegion *dropped)
 156 {
 157     WRegion *curr=mplex_mx_current(&(scr->mplex));
 158
 159     /* This code should handle dropping tabs on floating workspaces. */
 160     if(curr && HAS_DYN(curr, region_handle_drop)){
 161         int rx, ry;
 162         region_rootpos(curr, &rx, &ry);
 163         if(rectangle_contains(&REGION_GEOM(curr), x-rx, y-ry)){
 164             if(region_handle_drop(curr, x, y, dropped))
 165                 return TRUE;
 166         }
 167     }
 168
 169     /* Do not attach to ourselves unlike generic WMPlex. */
 170     return FALSE;
 171 }
 172
 173
 174 /*}}}*/
 175
 176
 177 /*{{{ Region dynfun implementations */
 178
 179
 180 static void screen_managed_changed(WScreen *scr, int mode, bool sw,
 181                                    WRegion *reg_)
 182 {
 183     if(ioncore_g.opmode==IONCORE_OPMODE_DEINIT)
 184         return;
 185
 186     if(sw && scr->atom_workspace!=None){
 187         WRegion *reg=mplex_mx_current(&(scr->mplex));
 188         const char *n=NULL;
 189
 190         if(reg!=NULL)
 191             n=region_displayname(reg);
 192
 193         xwindow_set_string_property(region_root_of((WRegion*)scr),
 194                                     scr->atom_workspace,
 195                                     n==NULL ? "" : n);
 196     }
 197
 198     if(region_is_activity_r((WRegion*)scr))
 199         screen_update_notifywin(scr);
 200
 201     screen_update_infowin(scr);
 202
 203     mplex_call_changed_hook((WMPlex*)scr,
 204                             screen_managed_changed_hook,
 205                             mode, sw, reg_);
 206 }
 207
 208
 209 static void screen_map(WScreen *scr)
 210 {
 211     if(scr->uses_root)
 212         return;
 213     mplex_map((WMPlex*)scr);
 214 }
 215
 216
 217 static void screen_unmap(WScreen *scr)
 218 {
 219     if(scr->uses_root)
 220         return;
 221     mplex_unmap((WMPlex*)scr);
 222 }
 223
 224 void screen_inactivated(WScreen *scr)
 225 {
 226     screen_update_infowin(scr);
 227 }
 228
 229
 230 void screen_activated(WScreen *scr)
 231 {
 232     screen_update_infowin(scr);
 233 }
 234
 235
 236 /*}}}*/
 237
 238
 239 /*{{{ Misc. */
 240
 241
 242 /*EXTL_DOC
 243  * Find the screen with numerical id \var{id}.
 244  */
 245 EXTL_SAFE
 246 EXTL_EXPORT
 247 WScreen *ioncore_find_screen_id(int id)
 248 {
 249     WScreen *scr, *maxscr=NULL;
 250
 251     FOR_ALL_SCREENS(scr){
 252         if(id==-1){
 253             if(maxscr==NULL || scr->id>maxscr->id)
 254                 maxscr=scr;
 255         }
 256         if(scr->id==id)
 257             return scr;
 258     }
 259
 260     return maxscr;
 261 }
 262
 263
 264 /*EXTL_DOC
 265  * Switch focus to the screen with id \var{id} and return it.
 266  *
 267  * Note that this function is asynchronous; the screen will not
 268  * actually have received the focus when this function returns.
 269  */
 270 EXTL_EXPORT
 271 WScreen *ioncore_goto_nth_screen(int id)
 272 {
 273     WScreen *scr=ioncore_find_screen_id(id);
 274     if(scr!=NULL){
 275         if(!region_goto((WRegion*)scr))
 276             return NULL;
 277     }
 278     return scr;
 279 }
 280
 281
 282 static WScreen *current_screen()
 283 {
 284     if(ioncore_g.focus_current==NULL)
 285         return ioncore_g.screens;
 286     else
 287         return region_screen_of(ioncore_g.focus_current);
 288 }
 289
 290
 291 /*EXTL_DOC
 292  * Switch focus to the next screen and return it.
 293  *
 294  * Note that this function is asynchronous; the screen will not
 295  * actually have received the focus when this function returns.
 296  */
 297 EXTL_EXPORT
 298 WScreen *ioncore_goto_next_screen()
 299 {
 300     WScreen *scr=current_screen();
 301
 302     if(scr!=NULL)
 303         scr=scr->next_scr;
 304     if(scr==NULL)
 305         scr=ioncore_g.screens;
 306     if(scr!=NULL){
 307         if(!region_goto((WRegion*)scr))
 308             return NULL;
 309     }
 310     return scr;
 311 }
 312
 313
 314 /*EXTL_DOC
 315  * Switch focus to the previous screen and return it.
 316  *
 317  * Note that this function is asynchronous; the screen will not
 318  * actually have received the focus when this function returns.
 319  */
 320 EXTL_EXPORT
 321 WScreen *ioncore_goto_prev_screen()
 322 {
 323     WScreen *scr=current_screen();
 324
 325     if(scr!=NULL)
 326         scr=scr->prev_scr;
 327     else
 328         scr=ioncore_g.screens;
 329     if(scr!=NULL){
 330         if(!region_goto((WRegion*)scr))
 331             return NULL;
 332     }
 333     return scr;
 334 }
 335
 336
 337 /*EXTL_DOC
 338  * Return the numerical id for screen \var{scr}.
 339  */
 340 EXTL_SAFE
 341 EXTL_EXPORT_MEMBER
 342 int screen_id(WScreen *scr)
 343 {
 344     return scr->id;
 345 }
 346
 347
 348 static WRegion *screen_managed_disposeroot(WScreen *scr, WRegion *reg)
 349 {
 350     bool onmxlist=FALSE, others=FALSE;
 351     WLListNode *lnode;
 352     WLListIterTmp tmp;
 353
 354     if(OBJ_IS(reg, WGroupWS)){
 355         FOR_ALL_NODES_ON_LLIST(lnode, scr->mplex.mx_list, tmp){
 356             if(lnode->st->reg==reg){
 357                 onmxlist=TRUE;
 358             }else if(OBJ_IS(lnode->st->reg, WGroupWS)){
 359                 others=TRUE;
 360                 break;
 361             }
 362         }
 363
 364         if(onmxlist && !others){
 365             warn(TR("Only workspace may not be destroyed/detached."));
 366             return NULL;
 367         }
 368     }
 369
 370     return reg;
 371 }
 372
 373
 374 static bool screen_may_dispose(WScreen *scr)
 375 {
 376     warn(TR("Screens may not be destroyed."));
 377     return FALSE;
 378 }
 379
 380
 381
 382 void screen_set_managed_offset(WScreen *scr, const WRectangle *off)
 383 {
 384     scr->managed_off=*off;
 385     mplex_fit_managed((WMPlex*)scr);
 386 }
 387
 388
 389 /*EXTL_DOC
 390  * Set offset of objects managed by the screen from actual screen geometry.
 391  * The table \var{offset} should contain the entries \code{x}, \code{y},
 392  * \code{w} and \code{h} indicating offsets of that component of screen
 393  * geometry.
 394  */
 395 EXTL_EXPORT_AS(WScreen, set_managed_offset)
 396 bool screen_set_managed_offset_extl(WScreen *scr, ExtlTab offset)
 397 {
 398     WRectangle g;
 399
 400     if(!extl_table_to_rectangle(offset, &g))
 401         goto err;
 402
 403     if(-g.w>=REGION_GEOM(scr).w)
 404         goto err;
 405     if(-g.h>=REGION_GEOM(scr).h)
 406         goto err;
 407
 408     screen_set_managed_offset(scr, &g);
 409
 410     return TRUE;
 411 err:
 412     warn(TR("Invalid offset."));
 413     return FALSE;
 414 }
 415
 416
 417 /*}}}*/
 418
 419
 420 /*{{{ Save/load */
 421
 422
 423 ExtlTab screen_get_configuration(WScreen *scr)
 424 {
 425     return mplex_get_configuration(&scr->mplex);
 426 }
 427
 428
 429 static WRegion *do_create_initial(WWindow *parent, const WFitParams *fp,
 430                                   WRegionLoadCreateFn *fn)
 431 {
 432     return fn(parent, fp, extl_table_none());
 433 }
 434
 435
 436 static bool create_initial_ws(WScreen *scr)
 437 {
 438     WRegion *reg=NULL;
 439     WMPlexAttachParams par=MPLEXATTACHPARAMS_INIT;
 440     ExtlTab lo=ioncore_get_layout("default");
 441
 442     if(lo==extl_table_none()){
 443         reg=mplex_do_attach_new(&scr->mplex, &par,
 444                                 (WRegionCreateFn*)create_groupws, NULL);
 445     }else{
 446         reg=mplex_attach_new_(&scr->mplex, &par, 0, lo);
 447         extl_unref_table(lo);
 448     }
 449
 450     if(reg==NULL){
 451         warn(TR("Unable to create a workspace on screen %d."), scr->id);
 452         return FALSE;
 453     }
 454
 455     return TRUE;
 456 }
 457
 458
 459 bool screen_init_layout(WScreen *scr, ExtlTab tab)
 460 {
 461     char *name;
 462     ExtlTab substab, subtab;
 463     int n, i;
 464
 465     if(tab==extl_table_none())
 466         return create_initial_ws(scr);
 467
 468     mplex_load_contents(&scr->mplex, tab);
 469
 470     return TRUE;
 471 }
 472
 473 /*}}}*/
 474
 475
 476 /*{{{ Dynamic function table and class implementation */
 477
 478
 479 static DynFunTab screen_dynfuntab[]={
 480     {region_map,
 481      screen_map},
 482
 483     {region_unmap,
 484      screen_unmap},
 485
 486     {region_activated,
 487      screen_activated},
 488
 489     {region_inactivated,
 490      screen_inactivated},
 491
 492     {(DynFun*)region_managed_disposeroot,
 493      (DynFun*)screen_managed_disposeroot},
 494
 495     {(DynFun*)region_may_dispose,
 496      (DynFun*)screen_may_dispose},
 497
 498     {mplex_managed_changed,
 499      screen_managed_changed},
 500
 501     {region_managed_notify,
 502      screen_managed_notify},
 503
 504     {mplex_managed_geom,
 505      screen_managed_geom},
 506
 507     {(DynFun*)region_get_configuration,
 508      (DynFun*)screen_get_configuration},
 509
 510     {(DynFun*)region_handle_drop,
 511      (DynFun*)screen_handle_drop},
 512
 513     END_DYNFUNTAB
 514 };
 515
 516
 517 EXTL_EXPORT
 518 IMPLCLASS(WScreen, WMPlex, screen_deinit, screen_dynfuntab);
 519
 520
 521 /*}}}*/