mod_dock/dock.c

   1 /*
   2  * Ion dock module
   3  * Copyright (C) 2003 Tom Payne
   4  * Copyright (C) 2003 Per Olofsson
   5  * Copyright (C) 2004-2007 Tuomo Valkonen
   6  *
   7  * by Tom Payne <ion@tompayne.org>
   8  * based on code by Per Olofsson <pelle@dsv.su.se>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  * $Header: /home/twp/cvsroot/twp/ion/ion-devel-dock/dock.c,v 1.17 2003/12/21 11:59:48 twp Exp $
  25  *
  26  */
  27
  28
  29 /*{{{ Includes */
  30
  31 #include <limits.h>
  32 #include <string.h>
  33 #include <X11/Xlib.h>
  34 #include <X11/Xatom.h>
  35 #include <X11/Xutil.h>
  36 #include <X11/extensions/shape.h>
  37 #include <X11/extensions/Xext.h>
  38
  39 #include <libtu/objp.h>
  40 #include <libtu/map.h>
  41 #include <libtu/minmax.h>
  42 #include <libextl/extl.h>
  43 #include <libextl/readconfig.h>
  44 #include <libmainloop/defer.h>
  45
  46 #include <ioncore/common.h>
  47 #include <ioncore/clientwin.h>
  48 #include <ioncore/eventh.h>
  49 #include <ioncore/global.h>
  50 #include <ioncore/manage.h>
  51 #include <ioncore/names.h>
  52 #include <ioncore/property.h>
  53 #include <ioncore/resize.h>
  54 #include <ioncore/window.h>
  55 #include <ioncore/mplex.h>
  56 #include <ioncore/saveload.h>
  57 #include <ioncore/bindmaps.h>
  58 #include <ioncore/regbind.h>
  59 #include <ioncore/extlconv.h>
  60 #include <ioncore/event.h>
  61 #include <ioncore/resize.h>
  62 #include <ioncore/sizehint.h>
  63 #include <ioncore/basicpholder.h>
  64
  65 #include "exports.h"
  66
  67 /*}}}*/
  68
  69
  70 /*{{{ Macros */
  71
  72 #ifdef __GNUC__
  73 #define UNUSED __attribute__ ((unused))
  74 #else
  75 #define UNUSED
  76 #endif
  77
  78 /*}}}*/
  79
  80
  81 /*{{{ Variables */
  82
  83 #include "../version.h"
  84
  85 static const char *modname="dock";
  86 const char mod_dock_ion_api_version[]=ION_API_VERSION;
  87
  88 static bool shape_extension=FALSE;
  89 static int shape_event_basep=0;
  90 static int shape_error_basep=0;
  91
  92 static WBindmap *dock_bindmap=NULL;
  93
  94 /*}}}*/
  95
  96
  97 /*{{{ Classes */
  98
  99 INTRSTRUCT(WDockParam);
 100 INTRSTRUCT(WDockApp);
 101 INTRCLASS(WDock);
 102
 103 DECLSTRUCT(WDockParam){
 104     const char *key;
 105     const char *desc;
 106     const StringIntMap *map;
 107     int dflt;
 108 };
 109
 110 DECLSTRUCT(WDockApp){
 111     WDockApp *next, *prev;
 112     WRegion *reg;
 113     int pos;
 114     bool draw_border;
 115     bool tile;
 116     WRectangle geom;
 117     WRectangle tile_geom;
 118     WRectangle border_geom;
 119 };
 120
 121 DECLCLASS(WDock){
 122     WWindow win;
 123     WDock *dock_next, *dock_prev;
 124     int pos, grow;
 125     bool is_auto;
 126     GrBrush *brush;
 127     WDockApp *dockapps;
 128
 129     int min_w, min_h;
 130     int max_w, max_h;
 131
 132     bool arrange_called;
 133     bool save;
 134 };
 135
 136 static WDock *docks=NULL;
 137
 138 /*}}}*/
 139
 140
 141 /*{{{ Parameter conversion */
 142
 143 static void dock_param_extl_table_get(const WDockParam *param,
 144                                       ExtlTab conftab, int value)
 145 {
 146     const char *s;
 147
 148     s=stringintmap_key(param->map, value, NULL);
 149     if(s){
 150         extl_table_sets_s(conftab, param->key, s);
 151     }
 152
 153 }
 154
 155
 156 static bool dock_param_do_set(const WDockParam *param, char *s,
 157                               int *ret)
 158 {
 159     bool changed=FALSE;
 160     int i=stringintmap_value(param->map, s, -1);
 161     if(i<0){
 162         warn_obj(modname, "Invalid %s \"%s\"", param->desc, s);
 163     }else{
 164         if(*ret!=i){
 165             changed=TRUE;
 166         }
 167         *ret=i;
 168     }
 169     free(s);
 170
 171     return changed;
 172
 173 }
 174
 175
 176 static bool dock_param_extl_table_set(const WDockParam *param, ExtlTab conftab,
 177                                       int *ret)
 178 {
 179     char *s;
 180
 181     if(extl_table_gets_s(conftab, param->key, &s))
 182         return dock_param_do_set(param, s, ret);
 183
 184     return FALSE;
 185
 186 }
 187
 188
 189 static bool dock_param_brush_set(const WDockParam *param, GrBrush *brush,
 190                                  int *ret)
 191 {
 192     char *s;
 193
 194     if(grbrush_get_extra(brush, param->key, 's', &s))
 195         return dock_param_do_set(param, s, ret);
 196
 197     return FALSE;
 198
 199 }
 200
 201 /*}}}*/
 202
 203
 204 /*{{{ Parameter descriptions */
 205
 206 static const WDockParam dock_param_name={
 207     "name",
 208     "name",
 209     NULL,
 210     0
 211 };
 212
 213
 214 #define DOCK_HPOS_MASK   0x000f
 215 #define DOCK_HPOS_LEFT   0x0000
 216 #define DOCK_HPOS_CENTER 0x0001
 217 #define DOCK_HPOS_RIGHT  0x0002
 218 #define DOCK_VPOS_MASK   0x00f0
 219 #define DOCK_VPOS_TOP    0x0000
 220 #define DOCK_VPOS_MIDDLE 0x0010
 221 #define DOCK_VPOS_BOTTOM 0x0020
 222
 223
 224 static StringIntMap dock_pos_map[]={
 225     {"tl", DOCK_VPOS_TOP|DOCK_HPOS_LEFT},
 226     {"tc", DOCK_VPOS_TOP|DOCK_HPOS_CENTER},
 227     {"tr", DOCK_VPOS_TOP|DOCK_HPOS_RIGHT},
 228     {"ml", DOCK_VPOS_MIDDLE|DOCK_HPOS_LEFT},
 229     {"mc", DOCK_VPOS_MIDDLE|DOCK_HPOS_CENTER},
 230     {"mr", DOCK_VPOS_MIDDLE|DOCK_HPOS_RIGHT},
 231     {"bl", DOCK_VPOS_BOTTOM|DOCK_HPOS_LEFT},
 232     {"bc", DOCK_VPOS_BOTTOM|DOCK_HPOS_CENTER},
 233     {"br", DOCK_VPOS_BOTTOM|DOCK_HPOS_RIGHT},
 234     END_STRINGINTMAP
 235 };
 236
 237 static WDockParam dock_param_pos={
 238     "pos",
 239     "dock position",
 240     dock_pos_map,
 241     DOCK_HPOS_LEFT|DOCK_VPOS_BOTTOM
 242 };
 243
 244
 245 enum WDockGrow{
 246     DOCK_GROW_UP,
 247     DOCK_GROW_DOWN,
 248     DOCK_GROW_LEFT,
 249     DOCK_GROW_RIGHT
 250 };
 251
 252 static StringIntMap dock_grow_map[]={
 253     {"up", DOCK_GROW_UP},
 254     {"down", DOCK_GROW_DOWN},
 255     {"left", DOCK_GROW_LEFT},
 256     {"right", DOCK_GROW_RIGHT},
 257     END_STRINGINTMAP
 258 };
 259
 260 WDockParam dock_param_grow={
 261     "grow",
 262     "growth direction",
 263     dock_grow_map,
 264     DOCK_GROW_RIGHT
 265 };
 266
 267
 268 static const WDockParam dock_param_is_auto={
 269     "is_auto",
 270     "is automatic",
 271     NULL,
 272     TRUE
 273 };
 274
 275
 276 enum WDockOutlineStyle{
 277     DOCK_OUTLINE_STYLE_NONE,
 278     DOCK_OUTLINE_STYLE_ALL,
 279     DOCK_OUTLINE_STYLE_EACH
 280 };
 281
 282 static StringIntMap dock_outline_style_map[]={
 283     {"none", DOCK_OUTLINE_STYLE_NONE},
 284     {"all", DOCK_OUTLINE_STYLE_ALL},
 285     {"each", DOCK_OUTLINE_STYLE_EACH},
 286     END_STRINGINTMAP
 287 };
 288
 289 WDockParam dock_param_outline_style={
 290     "outline_style",
 291     "outline style",
 292     dock_outline_style_map,
 293     DOCK_OUTLINE_STYLE_ALL
 294 };
 295
 296
 297 static const WDockParam dock_param_tile_width={
 298     "width",
 299     "tile width",
 300     NULL,
 301     64
 302 };
 303
 304 static const WDockParam dock_param_tile_height={
 305     "height",
 306     "tile height",
 307     NULL,
 308     64
 309 };
 310
 311
 312 /*}}}*/
 313
 314
 315 /*{{{ Misc. */
 316
 317 #define CLIENTWIN_WINPROP_POSITION "dockposition"
 318 #define CLIENTWIN_WINPROP_BORDER "dockborder"
 319
 320 static WDockApp *dock_find_dockapp(WDock *dock, WRegion *reg)
 321 {
 322     WDockApp *dockapp;
 323
 324     for(dockapp=dock->dockapps; dockapp!=NULL; dockapp=dockapp->next){
 325         if(dockapp->reg==reg){
 326             return dockapp;
 327         }
 328     }
 329
 330     return NULL;
 331
 332 }
 333
 334
 335 static void dock_get_outline_style(WDock *dock, int *ret)
 336 {
 337
 338     *ret=dock_param_outline_style.dflt;
 339     if(dock->brush!=NULL)
 340         dock_param_brush_set(&dock_param_outline_style, dock->brush, ret);
 341
 342 }
 343
 344 /*}}}*/
 345
 346
 347 /*{{{ Size calculation */
 348
 349
 350 static void dock_get_tile_size(WDock *dock, WRectangle *ret)
 351 {
 352     ExtlTab tile_size_table;
 353
 354     ret->x=0;
 355     ret->y=0;
 356     ret->w=dock_param_tile_width.dflt;
 357     ret->h=dock_param_tile_height.dflt;
 358     if(dock->brush==NULL)
 359         return;
 360     if(grbrush_get_extra(dock->brush, "tile_size", 't', &tile_size_table)){
 361         extl_table_gets_i(tile_size_table, dock_param_tile_width.key, &ret->w);
 362         extl_table_gets_i(tile_size_table, dock_param_tile_height.key, &ret->h);
 363         extl_unref_table(tile_size_table);
 364     }
 365
 366 }
 367
 368
 369 static void dock_get_pos_grow(WDock *dock, int *pos, int *grow)
 370 {
 371     WMPlex *mplex=OBJ_CAST(REGION_PARENT(dock), WMPlex);
 372     WRegion *mplex_stdisp;
 373     WMPlexSTDispInfo din;
 374
 375     if(mplex!=NULL){
 376         mplex_get_stdisp(mplex, &mplex_stdisp, &din);
 377         if(mplex_stdisp==(WRegion*)dock){
 378             /* Ok, we're assigned as a status display for mplex, so
 379              * get parameters from there.
 380              */
 381             *pos=((din.pos==MPLEX_STDISP_TL || din.pos==MPLEX_STDISP_BL)
 382                   ? DOCK_HPOS_LEFT
 383                   : DOCK_HPOS_RIGHT)
 384                 | ((din.pos==MPLEX_STDISP_TL || din.pos==MPLEX_STDISP_TR)
 385                    ? DOCK_VPOS_TOP
 386                    : DOCK_VPOS_BOTTOM);
 387             *grow=dock->grow;
 388             return;
 389         }
 390     }
 391
 392     *grow=dock->grow;
 393     *pos=dock->pos;
 394 }
 395
 396
 397
 398 static void dock_reshape(WDock *dock)
 399 {
 400     int outline_style;
 401
 402     if(!shape_extension){
 403         return;
 404     }
 405
 406     dock_get_outline_style(dock, &outline_style);
 407
 408     switch(outline_style){
 409     case DOCK_OUTLINE_STYLE_NONE:
 410     case DOCK_OUTLINE_STYLE_EACH:
 411         {
 412             WDockApp *dockapp;
 413
 414             /* Start with an empty set */
 415             XShapeCombineRectangles(ioncore_g.dpy, ((WWindow*)dock)->win,
 416                                     ShapeBounding, 0, 0, NULL, 0, ShapeSet, 0);
 417
 418             /* Union with dockapp shapes */
 419             for(dockapp=dock->dockapps; dockapp!=NULL; dockapp=dockapp->next){
 420                 WClientWin *cwin=OBJ_CAST(dockapp->reg, WClientWin);
 421                 if(outline_style==DOCK_OUTLINE_STYLE_EACH
 422                    && dockapp->draw_border){
 423                     /* Union with border shape */
 424                     XRectangle tile_rect;
 425
 426                     tile_rect.x=dockapp->border_geom.x;
 427                     tile_rect.y=dockapp->border_geom.y;
 428                     tile_rect.width=dockapp->border_geom.w;
 429                     tile_rect.height=dockapp->border_geom.h;
 430                     XShapeCombineRectangles(ioncore_g.dpy, ((WWindow*)dock)->win,
 431                                             ShapeBounding, 0, 0, &tile_rect, 1,
 432                                             ShapeUnion, 0);
 433                 }else if(cwin!=NULL){
 434                     /* Union with dockapp shape */
 435                     int count;
 436                     int ordering;
 437
 438                     XRectangle *rects=XShapeGetRectangles(ioncore_g.dpy, cwin->win,
 439                                                           ShapeBounding, &count,
 440                                                           &ordering);
 441                     if(rects!=NULL){
 442                         WRectangle dockapp_geom=REGION_GEOM(cwin);
 443                         XShapeCombineRectangles(ioncore_g.dpy, ((WWindow*)dock)->win,
 444                                                 ShapeBounding,
 445                                                 dockapp_geom.x, dockapp_geom.y,
 446                                                 rects, count, ShapeUnion, ordering);
 447                         XFree(rects);
 448                     }
 449                 }
 450             }
 451         }
 452         break;
 453
 454     case DOCK_OUTLINE_STYLE_ALL:
 455         {
 456             WRectangle geom;
 457             XRectangle rect;
 458
 459             geom=REGION_GEOM(dock);
 460             rect.x=0;
 461             rect.y=0;
 462             rect.width=geom.w;
 463             rect.height=geom.h;
 464             XShapeCombineRectangles(ioncore_g.dpy, ((WWindow*)dock)->win,
 465                                     ShapeBounding, 0, 0, &rect, 1, ShapeSet, 0);
 466         }
 467         break;
 468     }
 469
 470 }
 471
 472
 473 static void dock_arrange_dockapps(WDock *dock, const WRectangle *bd_dockg,
 474                                   const WDockApp *replace_this,
 475                                   WDockApp *with_this)
 476 {
 477     GrBorderWidths dock_bdw, dockapp_bdw;
 478     WDockApp dummy_copy, *dockapp;
 479     int pos, grow, cur_coord=0;
 480     WRectangle dock_geom;
 481
 482     dock->arrange_called=TRUE;
 483
 484     dock_get_pos_grow(dock, &pos, &grow);
 485
 486     /* Determine dock and dockapp border widths */
 487     memset(&dock_bdw, 0, sizeof(GrBorderWidths));
 488     memset(&dockapp_bdw, 0, sizeof(GrBorderWidths));
 489
 490     if(dock->brush){
 491         int outline_style;
 492
 493         dock_get_outline_style(dock, &outline_style);
 494         switch(outline_style){
 495         case DOCK_OUTLINE_STYLE_NONE:
 496             break;
 497         case DOCK_OUTLINE_STYLE_ALL:
 498             grbrush_get_border_widths(dock->brush, &dock_bdw);
 499             dockapp_bdw.spacing=dock_bdw.spacing;
 500             break;
 501         case DOCK_OUTLINE_STYLE_EACH:
 502             grbrush_get_border_widths(dock->brush, &dockapp_bdw);
 503             break;
 504         }
 505     }
 506
 507     dock_geom.w=bd_dockg->w-dock_bdw.left-dock_bdw.right;
 508     dock_geom.h=bd_dockg->h-dock_bdw.top-dock_bdw.bottom;
 509
 510     /* Calculate initial co-ordinate for layout algorithm */
 511     switch(grow){
 512     case DOCK_GROW_UP:
 513         cur_coord=dock_bdw.top+dock_geom.h;
 514         break;
 515     case DOCK_GROW_DOWN:
 516         cur_coord=dock_bdw.top;
 517         break;
 518     case DOCK_GROW_LEFT:
 519         cur_coord=dock_bdw.left+dock_geom.w;
 520         break;
 521     case DOCK_GROW_RIGHT:
 522         cur_coord=dock_bdw.left;
 523         break;
 524     }
 525
 526     /* Arrange dockapps */
 527     for(dockapp=dock->dockapps; dockapp!=NULL; dockapp=dockapp->next){
 528         WDockApp *da=dockapp;
 529
 530         if(replace_this!=NULL){
 531             if(replace_this==dockapp){
 532                 da=with_this;
 533             }else{
 534                 dummy_copy=*dockapp;
 535                 da=&dummy_copy;
 536             }
 537         }
 538
 539         /* Calculate first co-ordinate */
 540         switch(grow){
 541         case DOCK_GROW_UP:
 542         case DOCK_GROW_DOWN:
 543             switch(pos&DOCK_HPOS_MASK){
 544             case DOCK_HPOS_LEFT:
 545                 da->border_geom.x=0;
 546                 break;
 547             case DOCK_HPOS_CENTER:
 548                 da->border_geom.x=(dock_geom.w-da->border_geom.w)/2;
 549                 break;
 550             case DOCK_HPOS_RIGHT:
 551                 da->border_geom.x=dock_geom.w-da->border_geom.w;
 552                 break;
 553             }
 554             da->border_geom.x+=dock_bdw.left;
 555             break;
 556         case DOCK_GROW_LEFT:
 557         case DOCK_GROW_RIGHT:
 558             switch(pos&DOCK_VPOS_MASK){
 559             case DOCK_VPOS_TOP:
 560                 da->border_geom.y=0;
 561                 break;
 562             case DOCK_VPOS_MIDDLE:
 563                 da->border_geom.y=(dock_geom.h-da->border_geom.h)/2;
 564                 break;
 565             case DOCK_VPOS_BOTTOM:
 566                 da->border_geom.y=dock_geom.h-da->border_geom.h;
 567                 break;
 568             }
 569             da->border_geom.y+=dock_bdw.top;
 570             break;
 571         }
 572
 573         /* Calculate second co-ordinate */
 574         switch(grow){
 575         case DOCK_GROW_UP:
 576             cur_coord-=da->border_geom.h;
 577             da->border_geom.y=cur_coord;
 578             cur_coord-=dockapp_bdw.spacing;
 579             break;
 580         case DOCK_GROW_DOWN:
 581             da->border_geom.y=cur_coord;
 582             cur_coord+=da->border_geom.h+dockapp_bdw.spacing;
 583             break;
 584         case DOCK_GROW_LEFT:
 585             cur_coord-=da->border_geom.w;
 586             da->border_geom.x=cur_coord;
 587             cur_coord-=dockapp_bdw.spacing;
 588             break;
 589         case DOCK_GROW_RIGHT:
 590             da->border_geom.x=cur_coord;
 591             cur_coord+=da->border_geom.w+dockapp_bdw.spacing;
 592             break;
 593         }
 594
 595         /* Calculate tile geom */
 596         da->tile_geom.x=da->border_geom.x+dockapp_bdw.left;
 597         da->tile_geom.y=da->border_geom.y+dockapp_bdw.top;
 598
 599         /* Calculate dockapp geom */
 600         if(da->tile){
 601             da->geom.x=da->tile_geom.x+(da->tile_geom.w-da->geom.w)/2;
 602             da->geom.y=da->tile_geom.y+(da->tile_geom.h-da->geom.h)/2;
 603         }else{
 604             da->geom.x=da->tile_geom.x;
 605             da->geom.y=da->tile_geom.y;
 606         }
 607
 608         if(replace_this==NULL)
 609             region_fit(da->reg, &(da->geom), REGION_FIT_BOUNDS);
 610     }
 611 }
 612
 613
 614 static void calc_dock_pos(WRectangle *dg, const WRectangle *pg, int pos)
 615 {
 616     switch(pos&DOCK_HPOS_MASK){
 617     case DOCK_HPOS_LEFT:
 618         dg->x=pg->x;
 619         break;
 620     case DOCK_HPOS_CENTER:
 621         dg->x=pg->x+(pg->w-dg->w)/2;
 622         break;
 623     case DOCK_HPOS_RIGHT:
 624         dg->x=pg->x+(pg->w-dg->w);
 625         break;
 626     }
 627
 628     switch(pos&DOCK_VPOS_MASK){
 629     case DOCK_VPOS_TOP:
 630         dg->y=pg->y;
 631         break;
 632     case DOCK_VPOS_MIDDLE:
 633         dg->y=pg->y+(pg->h-dg->h)/2;
 634         break;
 635     case DOCK_VPOS_BOTTOM:
 636         dg->y=pg->y+(pg->h-dg->h);
 637         break;
 638     }
 639 }
 640
 641
 642 static void dock_set_minmax(WDock *dock, int grow, const WRectangle *g)
 643 {
 644     dock->min_w=g->w;
 645     dock->min_h=g->h;
 646     if(grow==DOCK_GROW_UP || grow==DOCK_GROW_DOWN){
 647         dock->max_w=g->w;
 648         dock->max_h=INT_MAX;
 649     }else{
 650         dock->max_w=INT_MAX;
 651         dock->max_h=g->h;
 652     }
 653 }
 654
 655
 656 static void dockapp_calc_preferred_size(WDock *dock, int grow,
 657                                         const WRectangle *tile_size,
 658                                         WDockApp *da)
 659 {
 660     int w=da->geom.w, h=da->geom.h;
 661
 662     if(grow==DOCK_GROW_UP || grow==DOCK_GROW_DOWN){
 663         da->geom.w=minof(w, tile_size->w);
 664         da->geom.h=h;
 665     }else{
 666         da->geom.w=w;
 667         da->geom.h=minof(h, tile_size->h);
 668     }
 669
 670     region_size_hints_correct(da->reg, &(da->geom.w), &(da->geom.h), TRUE);
 671 }
 672
 673
 674
 675 static void dock_managed_rqgeom_(WDock *dock, WRegion *reg, int flags,
 676                                  const WRectangle *geom, WRectangle *geomret,
 677                                  bool just_update_minmax)
 678 {
 679     WDockApp *dockapp=NULL, *thisdockapp=NULL, thisdockapp_copy;
 680     WRectangle parent_geom, dock_geom, border_dock_geom;
 681     GrBorderWidths dock_bdw, dockapp_bdw;
 682     int n_dockapps=0, max_w=1, max_h=1, total_w=0, total_h=0;
 683     int pos, grow;
 684     WRectangle tile_size;
 685     WWindow *par=REGION_PARENT(dock);
 686
 687     /* dock_resize calls with NULL parameters. */
 688     assert(reg!=NULL || (geomret==NULL && !(flags&REGION_RQGEOM_TRYONLY)));
 689
 690     dock_get_pos_grow(dock, &pos, &grow);
 691
 692     /* Determine parent and tile geoms */
 693     parent_geom.x=0;
 694     parent_geom.y=0;
 695     if(par!=NULL){
 696         parent_geom.w=REGION_GEOM(par).w;
 697         parent_geom.h=REGION_GEOM(par).h;
 698     }else{
 699         /* Should not happen in normal operation. */
 700         parent_geom.w=1;
 701         parent_geom.h=1;
 702     }
 703
 704     dock_get_tile_size(dock, &tile_size);
 705
 706     /* Determine dock and dockapp border widths */
 707     memset(&dock_bdw, 0, sizeof(GrBorderWidths));
 708     memset(&dockapp_bdw, 0, sizeof(GrBorderWidths));
 709
 710     if(dock->brush){
 711         int outline_style;
 712
 713         dock_get_outline_style(dock, &outline_style);
 714         switch(outline_style){
 715         case DOCK_OUTLINE_STYLE_NONE:
 716             break;
 717         case DOCK_OUTLINE_STYLE_ALL:
 718             grbrush_get_border_widths(dock->brush, &dock_bdw);
 719             dockapp_bdw.spacing=dock_bdw.spacing;
 720             break;
 721         case DOCK_OUTLINE_STYLE_EACH:
 722             grbrush_get_border_widths(dock->brush, &dockapp_bdw);
 723             break;
 724         }
 725     }
 726
 727     /* Calculate widths and heights */
 728     for(dockapp=dock->dockapps; dockapp!=NULL; dockapp=dockapp->next){
 729         WDockApp *da=dockapp;
 730         bool update=!(flags&REGION_RQGEOM_TRYONLY);
 731         if(dockapp->reg==reg){
 732             thisdockapp=dockapp;
 733             if(flags&REGION_RQGEOM_TRYONLY){
 734                 thisdockapp_copy=*dockapp;
 735                 thisdockapp_copy.geom=*geom;
 736                 da=&thisdockapp_copy;
 737                 update=TRUE;
 738             }
 739             da->geom=*geom;
 740         }
 741
 742         if(update){
 743             /* Calculcate preferred size */
 744             dockapp_calc_preferred_size(dock, grow, &tile_size, da);
 745
 746             /* Determine whether dockapp should be placed on a tile */
 747             da->tile=da->geom.w<=tile_size.w && da->geom.h<=tile_size.h;
 748
 749             /* Calculate width and height */
 750             if(da->tile){
 751                 da->tile_geom.w=tile_size.w;
 752                 da->tile_geom.h=tile_size.h;
 753             }else{
 754                 da->tile_geom.w=da->geom.w;
 755                 da->tile_geom.h=da->geom.h;
 756             }
 757
 758             /* Calculate border width and height */
 759             da->border_geom.w=dockapp_bdw.left+da->tile_geom.w+dockapp_bdw.right;
 760             da->border_geom.h=dockapp_bdw.top+da->tile_geom.h+dockapp_bdw.right;
 761         }
 762
 763         /* Calculate maximum and accumulated widths and heights */
 764         if(da->border_geom.w>max_w)
 765             max_w=da->border_geom.w;
 766         total_w+=da->border_geom.w+(n_dockapps ? dockapp_bdw.spacing : 0);
 767
 768         if(da->border_geom.h>max_h)
 769             max_h=da->border_geom.h;
 770         total_h+=da->border_geom.h+(n_dockapps ? dockapp_bdw.spacing : 0);
 771
 772         /* Count dockapps */
 773         ++n_dockapps;
 774     }
 775
 776     if(thisdockapp==NULL && reg!=NULL){
 777         warn("Requesting dockapp not found.");
 778         if(geomret)
 779             *geomret=REGION_GEOM(reg);
 780         return;
 781     }
 782
 783     /* Calculate width and height of dock */
 784     if(n_dockapps){
 785         switch(grow){
 786         case DOCK_GROW_LEFT:
 787         case DOCK_GROW_RIGHT:
 788             dock_geom.w=total_w;
 789             dock_geom.h=max_h;
 790             break;
 791         case DOCK_GROW_UP:
 792         case DOCK_GROW_DOWN:
 793         default:
 794             dock_geom.w=max_w;
 795             dock_geom.h=total_h;
 796             break;
 797         }
 798     }else{
 799         dock_geom.w=tile_size.w;
 800         dock_geom.h=tile_size.h;
 801     }
 802     border_dock_geom.w=dock_bdw.left+dock_geom.w+dock_bdw.right;
 803     border_dock_geom.h=dock_bdw.top+dock_geom.h+dock_bdw.bottom;
 804
 805     calc_dock_pos(&border_dock_geom, &parent_geom, pos);
 806
 807     /* Fit dock to new geom if required */
 808     if(!(flags&REGION_RQGEOM_TRYONLY)){
 809         WRQGeomParams rq=RQGEOMPARAMS_INIT;
 810
 811         dock_set_minmax(dock, grow, &border_dock_geom);
 812
 813         if(just_update_minmax)
 814             return;
 815
 816         rq.flags=REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y;
 817         rq.geom=border_dock_geom;
 818
 819         dock->arrange_called=FALSE;
 820
 821         region_rqgeom((WRegion*)dock, &rq, NULL);
 822
 823         if(!dock->arrange_called)
 824             dock_arrange_dockapps(dock, &REGION_GEOM(dock), NULL, NULL);
 825
 826         if(thisdockapp!=NULL && geomret!=NULL)
 827             *geomret=thisdockapp->geom;
 828     }else{
 829         if(thisdockapp!=NULL && geomret!=NULL){
 830             dock_arrange_dockapps(dock, &REGION_GEOM(dock),
 831                                   thisdockapp, &thisdockapp_copy);
 832             *geomret=thisdockapp_copy.geom;
 833         }
 834     }
 835 }
 836
 837 static void dock_managed_rqgeom(WDock *dock, WRegion *reg,
 838                                 const WRQGeomParams *rq,
 839                                 WRectangle *geomret)
 840 {
 841     dock_managed_rqgeom_(dock, reg, rq->flags, &rq->geom, geomret, FALSE);
 842 }
 843
 844
 845 void dock_size_hints(WDock *dock, WSizeHints *hints)
 846 {
 847     hints->min_set=TRUE;
 848     hints->min_width=dock->min_w;
 849     hints->min_height=dock->min_h;
 850
 851     hints->max_set=TRUE;
 852     hints->max_width=dock->max_w;
 853     hints->max_height=dock->max_h;
 854 }
 855
 856
 857 static bool dock_fitrep(WDock *dock, WWindow *parent, const WFitParams *fp)
 858 {
 859     if(!window_fitrep(&(dock->win), parent, fp))
 860         return FALSE;
 861
 862     dock_arrange_dockapps(dock, &(fp->g), NULL, NULL);
 863
 864     if(shape_extension)
 865         dock_reshape(dock);
 866
 867     return TRUE;
 868 }
 869
 870
 871 static int dock_orientation(WDock *dock)
 872 {
 873     return ((dock->grow==DOCK_GROW_LEFT || dock->grow==DOCK_GROW_RIGHT)
 874             ? REGION_ORIENTATION_HORIZONTAL
 875             : REGION_ORIENTATION_VERTICAL);
 876 }
 877
 878
 879 /*}}}*/
 880
 881
 882 /*{{{ Drawing */
 883
 884
 885 static void dock_draw(WDock *dock, bool complete)
 886 {
 887     int outline_style;
 888     WRectangle g;
 889
 890     if(dock->brush==NULL)
 891         return;
 892
 893     g.x=0;
 894     g.y=0;
 895     g.w=REGION_GEOM(dock).w;
 896     g.h=REGION_GEOM(dock).h;
 897
 898     grbrush_begin(dock->brush, &g, (complete ? 0 : GRBRUSH_NO_CLEAR_OK));
 899
 900     dock_get_outline_style(dock, &outline_style);
 901     switch(outline_style){
 902     case DOCK_OUTLINE_STYLE_NONE:
 903         break;
 904     case DOCK_OUTLINE_STYLE_ALL:
 905         {
 906             WRectangle geom=REGION_GEOM(dock);
 907             geom.x=geom.y=0;
 908             grbrush_draw_border(dock->brush, &geom);
 909         }
 910         break;
 911     case DOCK_OUTLINE_STYLE_EACH:
 912         {
 913             WDockApp *dockapp;
 914             for(dockapp=dock->dockapps; dockapp!=NULL;
 915                 dockapp=dockapp->next){
 916                 grbrush_draw_border(dock->brush, &dockapp->tile_geom);
 917             }
 918         }
 919         break;
 920     }
 921
 922     grbrush_end(dock->brush);
 923 }
 924
 925
 926 /*EXTL_DOC
 927  * Resizes and refreshes \var{dock}.
 928  */
 929 EXTL_EXPORT_MEMBER
 930 void dock_resize(WDock *dock)
 931 {
 932     dock_managed_rqgeom_(dock, NULL, 0, NULL, NULL, FALSE);
 933     dock_draw(dock, TRUE);
 934
 935 }
 936
 937 static void dock_brush_release(WDock *dock)
 938 {
 939
 940     if(dock->brush){
 941         grbrush_release(dock->brush);
 942         dock->brush=NULL;
 943     }
 944
 945 }
 946
 947
 948 static void dock_brush_get(WDock *dock)
 949 {
 950
 951     dock_brush_release(dock);
 952     dock->brush=gr_get_brush(((WWindow*)dock)->win,
 953                              region_rootwin_of((WRegion*)dock),
 954                              "stdisp-dock");
 955 }
 956
 957
 958 static void dock_updategr(WDock *dock)
 959 {
 960     dock_brush_get(dock);
 961     dock_resize(dock);
 962 }
 963
 964 /*}}}*/
 965
 966
 967 /*{{{ Set/get */
 968
 969
 970 static void mplexpos(int pos, int *mpos)
 971 {
 972     int hp=pos&DOCK_HPOS_MASK, vp=pos&DOCK_VPOS_MASK;
 973     int p;
 974
 975     p=(vp!=DOCK_VPOS_MIDDLE
 976        ? (vp==DOCK_VPOS_TOP
 977           ? (hp!=DOCK_HPOS_CENTER
 978              ? (hp==DOCK_HPOS_RIGHT
 979                 ? MPLEX_STDISP_TR
 980                 : MPLEX_STDISP_TL)
 981              : -1)
 982           : (hp!=DOCK_HPOS_CENTER
 983              ? (hp==DOCK_HPOS_RIGHT
 984                 ? MPLEX_STDISP_BR
 985                 : MPLEX_STDISP_BL)
 986              : -1))
 987        : -1);
 988
 989     if(p==-1)
 990         warn("Invalid dock position while as stdisp.");
 991     else
 992         *mpos=p;
 993 }
 994
 995
 996 static void dock_do_set(WDock *dock, ExtlTab conftab, bool resize)
 997 {
 998     char *s;
 999     bool b;
1000     bool growset=FALSE;
1001     bool posset=FALSE;
1002     bool save=FALSE;
1003
1004     if(extl_table_gets_s(conftab, dock_param_name.key, &s)){
1005         if(!region_set_name((WRegion*)dock, s)){
1006             warn_obj(modname, "Can't set name to \"%s\"", s);
1007         }
1008         free(s);
1009     }
1010
1011     if(extl_table_gets_b(conftab, "save", &save))
1012         dock->save=save;
1013
1014     if(dock_param_extl_table_set(&dock_param_pos, conftab, &dock->pos))
1015         posset=TRUE;
1016
1017     if(dock_param_extl_table_set(&dock_param_grow, conftab, &dock->grow))
1018         growset=TRUE;
1019
1020     if(extl_table_gets_b(conftab, dock_param_is_auto.key, &b))
1021         dock->is_auto=b;
1022
1023     if(resize && (growset || posset)){
1024         WMPlex *par=OBJ_CAST(REGION_PARENT(dock), WMPlex);
1025         WRegion *stdisp=NULL;
1026         WMPlexSTDispInfo din;
1027
1028         if(par!=NULL){
1029             mplex_get_stdisp(par, &stdisp, &din);
1030             din.fullsize=FALSE; /* not supported. */
1031             if(stdisp==(WRegion*)dock){
1032                 if(posset)
1033                     mplexpos(dock->pos, &din.pos);
1034                 if(growset){
1035                     /* Update min/max first */
1036                     dock_managed_rqgeom_(dock, NULL, 0, NULL, NULL, TRUE);
1037                 }
1038                 mplex_set_stdisp(par, (WRegion*)dock, &din);
1039             }
1040         }
1041
1042         dock_resize(dock);
1043     }
1044 }
1045
1046
1047 /*EXTL_DOC
1048  * Configure \var{dock}. \var{conftab} is a table of key/value pairs:
1049  *
1050  * \begin{tabularx}{\linewidth}{llX}
1051  *  \tabhead{Key & Values & Description}
1052  *  \var{name} & string & Name of dock \\
1053  *  \var{pos} & string in $\{t,m,b\}\times\{t,c,b\}$ & Dock position.
1054  *       Can only be used in floating mode. \\
1055  *  \var{grow} & up/down/left/right &
1056  *       Growth direction where new dockapps are added. Also
1057  *       sets orientation for dock when working as WMPlex status
1058  *       display (see \fnref{WMPlex.set_stdisp}). \\
1059  *  \var{is_auto} & bool &
1060  *       Should \var{dock} automatically manage new dockapps? \\
1061  * \end{tabularx}
1062  *
1063  * Any parameters not explicitly set in \var{conftab} will be left unchanged.
1064  */
1065 EXTL_EXPORT_MEMBER
1066 void dock_set(WDock *dock, ExtlTab conftab)
1067 {
1068     dock_do_set(dock, conftab, TRUE);
1069 }
1070
1071
1072 static void dock_do_get(WDock *dock, ExtlTab conftab)
1073 {
1074     extl_table_sets_s(conftab, dock_param_name.key,
1075                       region_name((WRegion*)dock));
1076     dock_param_extl_table_get(&dock_param_pos, conftab, dock->pos);
1077     dock_param_extl_table_get(&dock_param_grow, conftab, dock->grow);
1078     extl_table_sets_b(conftab, dock_param_is_auto.key, dock->is_auto);
1079     extl_table_sets_b(conftab, "save", dock->save);
1080 }
1081
1082
1083 /*EXTL_DOC
1084  * Get \var{dock}'s configuration table. See \fnref{WDock.set} for a
1085  * description of the table.
1086  */
1087 EXTL_SAFE
1088 EXTL_EXPORT_MEMBER
1089 ExtlTab dock_get(WDock *dock)
1090 {
1091     ExtlTab conftab;
1092
1093     conftab=extl_create_table();
1094     dock_do_get(dock, conftab);
1095     return conftab;
1096 }
1097
1098
1099 /*}}}*/
1100
1101
1102 /*{{{ Init/deinit */
1103
1104
1105 static bool dock_init(WDock *dock, WWindow *parent, const WFitParams *fp)
1106 {
1107     WFitParams fp2=*fp;
1108
1109     dock->pos=dock_param_pos.dflt;
1110     dock->grow=dock_param_grow.dflt;
1111     dock->is_auto=dock_param_is_auto.dflt;
1112     dock->brush=NULL;
1113     dock->dockapps=NULL;
1114     dock->min_w=1;
1115     dock->min_h=1;
1116     dock->max_w=1;
1117     dock->max_h=1;
1118     dock->arrange_called=FALSE;
1119     dock->save=TRUE;
1120
1121
1122     if(!window_init((WWindow*)dock, parent, &fp2))
1123         return FALSE;
1124
1125     region_add_bindmap((WRegion*)dock, dock_bindmap);
1126
1127     ((WRegion*)dock)->flags|=REGION_SKIP_FOCUS;
1128
1129     window_select_input(&(dock->win), IONCORE_EVENTMASK_CWINMGR);
1130
1131     dock_brush_get(dock);
1132
1133     LINK_ITEM(docks, dock, dock_next, dock_prev);
1134
1135     return TRUE;
1136 }
1137
1138
1139 static WDock *create_dock(WWindow *parent, const WFitParams *fp)
1140 {
1141     CREATEOBJ_IMPL(WDock, dock, (p, parent, fp));
1142 }
1143
1144
1145 static void dock_deinit(WDock *dock)
1146 {
1147     while(dock->dockapps!=NULL)
1148         destroy_obj((Obj*)dock->dockapps->reg);
1149
1150     UNLINK_ITEM(docks, dock, dock_next, dock_prev);
1151
1152     dock_brush_release(dock);
1153
1154     window_deinit((WWindow*) dock);
1155 }
1156
1157
1158 EXTL_EXPORT
1159 WDock *mod_dock_create(ExtlTab tab)
1160 {
1161     char *mode=NULL;
1162     bool floating=FALSE;
1163     int screenid=0;
1164     WScreen *screen=NULL;
1165     WDock *dock=NULL;
1166     WRegion *stdisp=NULL;
1167     WMPlexSTDispInfo din;
1168
1169     if(extl_table_gets_s(tab, "mode", &mode)){
1170         if(strcmp(mode, "floating")==0){
1171             floating=TRUE;
1172         }else if(strcmp(mode, "embedded")!=0){
1173             warn("Invalid dock mode.");
1174             free(mode);
1175             return NULL;
1176         }
1177         free(mode);
1178     }
1179
1180     extl_table_gets_i(tab, "screen", &screenid);
1181     screen=ioncore_find_screen_id(screenid);
1182     if(screen==NULL){
1183         warn("Screen %d does not exist.", screenid);
1184         return NULL;
1185     }
1186
1187     for(dock=docks; dock; dock=dock->dock_next){
1188         if(region_screen_of((WRegion*)dock)==screen){
1189             warn("Screen %d already has a dock. Refusing to create another.",
1190                  screenid);
1191             return NULL;
1192         }
1193     }
1194
1195     if(!floating){
1196         mplex_get_stdisp((WMPlex*)screen, &stdisp, &din);
1197         if(stdisp!=NULL && !extl_table_is_bool_set(tab, "force")){
1198             warn("Screen %d already has an stdisp. Refusing to add embedded "
1199                  "dock.", screenid);
1200             return NULL;
1201         }
1202     }
1203
1204     /* Create the dock */
1205
1206     if(floating){
1207         WMPlexAttachParams par;
1208
1209         par.flags=(MPLEX_ATTACH_UNNUMBERED
1210                    |MPLEX_ATTACH_SIZEPOLICY
1211                    |MPLEX_ATTACH_GEOM);
1212
1213         par.szplcy=SIZEPOLICY_FREE;
1214         par.geom.x=0;
1215         par.geom.y=0;
1216         par.geom.w=1;
1217         par.geom.h=1;
1218
1219         if(extl_table_is_bool_set(tab, "floating_hidden"))
1220             par.flags|=MPLEX_ATTACH_HIDDEN;
1221
1222         dock=(WDock*)mplex_do_attach_new((WMPlex*)screen, &par,
1223                                          (WRegionCreateFn*)create_dock,
1224                                          NULL);
1225     }else{
1226         WFitParams fp;
1227
1228         fp.mode=REGION_FIT_BOUNDS|REGION_FIT_WHATEVER;
1229         fp.g.x=0;
1230         fp.g.y=0;
1231         fp.g.w=1;
1232         fp.g.h=1;
1233
1234         dock=create_dock((WWindow*)screen, &fp);
1235     }
1236
1237     if(dock==NULL){
1238         warn("Failed to create dock.");
1239         return NULL;
1240     }
1241
1242     /* Get parameters */
1243     dock->save=FALSE;
1244     dock_do_set(dock, tab, FALSE);
1245
1246     /* Final setup */
1247     if(floating){
1248         WRQGeomParams rq=RQGEOMPARAMS_INIT;
1249         const WRectangle *pg=&REGION_GEOM(screen);
1250
1251         /* Just calculate real min/max size */
1252         dock_managed_rqgeom_(dock, NULL, 0, NULL, NULL, TRUE);
1253
1254         rq.geom.w=minof(dock->min_w, pg->w);
1255         rq.geom.h=minof(dock->min_h, pg->h);
1256         calc_dock_pos(&rq.geom, pg, dock->pos);
1257
1258         region_rqgeom((WRegion*)dock, &rq, NULL);
1259
1260         return dock;
1261     }else{
1262         mplexpos(dock->pos, &din.pos);
1263         din.fullsize=FALSE; /* not supported */
1264         if(mplex_set_stdisp((WMPlex*)screen, (WRegion*)dock, &din))
1265             return dock;
1266     }
1267
1268     /* Failed to attach. */
1269     warn("Failed to attach dock to screen.");
1270     destroy_obj((Obj*)dock);
1271     return NULL;
1272 }
1273
1274
1275 /*}}}*/
1276
1277
1278 /*{{{ Toggle */
1279
1280
1281 /*EXTL_DOC
1282  * Toggle floating docks on \var{mplex}.
1283  */
1284 EXTL_EXPORT
1285 void mod_dock_set_floating_shown_on(WMPlex *mplex, const char *how)
1286 {
1287     int setpar=libtu_setparam_invert(libtu_string_to_setparam(how));
1288     WDock *dock;
1289
1290     for(dock=docks; dock; dock=dock->dock_next){
1291         if(REGION_MANAGER(dock)==(WRegion*)mplex)
1292             mplex_set_hidden(mplex, (WRegion*)dock, setpar);
1293     }
1294 }
1295
1296
1297 /*}}}*/
1298
1299
1300 /*{{{ Save/load */
1301
1302
1303 ExtlTab dock_get_configuration(WDock *dock)
1304 {
1305     ExtlTab tab;
1306
1307     if(dock->save==FALSE)
1308         return extl_table_none();
1309
1310     tab=region_get_base_configuration((WRegion*)dock);
1311     dock_do_get(dock, tab);
1312
1313     return tab;
1314 }
1315
1316
1317 WRegion *dock_load(WWindow *par, const WFitParams *fp, ExtlTab tab)
1318 {
1319     WDock *dock=create_dock(par, fp);
1320     if(dock!=NULL){
1321         dock_set(dock, tab);
1322         dock_fitrep(dock, NULL, fp);
1323     }
1324
1325     return (WRegion*)dock;
1326 }
1327
1328
1329 /*}}}*/
1330
1331
1332 /*{{{ Client window management setup */
1333
1334
1335 static bool dock_do_attach_final(WDock *dock, WRegion *reg, void *unused)
1336 {
1337     WDockApp *dockapp, *before_dockapp;
1338     WRectangle geom;
1339     WFitParams fp;
1340     bool draw_border=TRUE;
1341     int pos=INT_MAX;
1342
1343     /* Create and initialise a new WDockApp struct */
1344     dockapp=ALLOC(WDockApp);
1345
1346     if(dockapp==NULL)
1347         return FALSE;
1348
1349     if(OBJ_IS(reg, WClientWin)){
1350         ExtlTab proptab=((WClientWin*)reg)->proptab;
1351         extl_table_gets_b(proptab, CLIENTWIN_WINPROP_BORDER, &draw_border);
1352         extl_table_gets_i(proptab, CLIENTWIN_WINPROP_POSITION, &pos);
1353     }
1354
1355     dockapp->reg=reg;
1356     dockapp->draw_border=draw_border;
1357     dockapp->pos=pos;
1358     dockapp->tile=FALSE;
1359
1360     /* Insert the dockapp at the correct relative position */
1361     before_dockapp=dock->dockapps;
1362     for(before_dockapp=dock->dockapps;
1363         before_dockapp!=NULL && dockapp->pos>=before_dockapp->pos;
1364         before_dockapp=before_dockapp->next){
1365     }
1366
1367     if(before_dockapp!=NULL){
1368         LINK_ITEM_BEFORE(dock->dockapps, before_dockapp, dockapp, next, prev);
1369     }else{
1370         LINK_ITEM(dock->dockapps, dockapp, next, prev);
1371     }
1372
1373     region_set_manager(reg, (WRegion*)dock);
1374
1375     geom=REGION_GEOM(reg);
1376     dock_managed_rqgeom_(dock, reg,
1377                          REGION_RQGEOM_WEAK_X|REGION_RQGEOM_WEAK_Y,
1378                          &geom, NULL, FALSE);
1379
1380     region_map(reg);
1381
1382     return TRUE;
1383 }
1384
1385
1386
1387 static WRegion *dock_do_attach(WDock *dock, WRegionAttachData *data)
1388 {
1389     WFitParams fp;
1390     dock_get_tile_size(dock, &(fp.g));
1391     fp.g.x=0;
1392     fp.g.y=0;
1393     fp.mode=REGION_FIT_WHATEVER|REGION_FIT_BOUNDS;
1394
1395     return region_attach_helper((WRegion*)dock, (WWindow*)dock, &fp,
1396                                 (WRegionDoAttachFn*)dock_do_attach_final,
1397                                 NULL, data);
1398 }
1399
1400
1401 /*EXTL_DOC
1402  * Attach \var{reg} to \var{dock}.
1403  */
1404 EXTL_EXPORT_MEMBER
1405 bool dock_attach(WDock *dock, WRegion *reg)
1406 {
1407     WRegionAttachData data;
1408     WFitParams fp;
1409
1410     data.type=REGION_ATTACH_REPARENT;
1411     data.u.reg=reg;
1412
1413     return (dock_do_attach(dock, &data)!=NULL);
1414 }
1415
1416
1417 static bool dock_handle_drop(WDock *dock, int x, int y,
1418                              WRegion *dropped)
1419 {
1420     return dock_attach(dock, dropped);
1421 }
1422
1423
1424 static WRegion *dock_ph_handler(WDock *dock, int flags, WRegionAttachData *data)
1425 {
1426     return dock_do_attach(dock, data);
1427 }
1428
1429
1430 static WPHolder *dock_managed_get_pholder(WDock *dock, WRegion *mgd)
1431 {
1432     return (WPHolder*)create_basicpholder((WRegion*)dock,
1433                                           ((WBasicPHolderHandler*)
1434                                            dock_ph_handler));
1435 }
1436
1437
1438 static WPHolder *dock_prepare_manage(WDock *dock, const WClientWin *cwin,
1439                                      const WManageParams *param UNUSED,
1440                                      int redir)
1441 {
1442     if(redir==MANAGE_REDIR_STRICT_YES)
1443         return NULL;
1444
1445     return (WPHolder*)create_basicpholder((WRegion*)dock,
1446                                           ((WBasicPHolderHandler*)
1447                                            dock_ph_handler));
1448 }
1449
1450
1451 static void dock_managed_remove(WDock *dock, WRegion *reg)
1452 {
1453
1454     WDockApp *dockapp=dock_find_dockapp(dock, reg);
1455
1456     if(dockapp==NULL)
1457         return;
1458
1459     UNLINK_ITEM(dock->dockapps, dockapp, next, prev);
1460     free(dockapp);
1461
1462     region_unset_manager(reg, (WRegion*)dock);
1463
1464     dock_resize(dock);
1465 }
1466
1467
1468 static bool dock_clientwin_is_dockapp(WClientWin *cwin,
1469                                       const WManageParams *param)
1470 {
1471     bool is_dockapp=FALSE;
1472
1473     /* First, inspect the WManageParams.dockapp parameter */
1474     if(param->dockapp){
1475         is_dockapp=TRUE;
1476     }
1477
1478     /* Second, inspect the _NET_WM_WINDOW_TYPE property */
1479     if(!is_dockapp){
1480         static Atom atom__net_wm_window_type=None;
1481         static Atom atom__net_wm_window_type_dock=None;
1482         Atom actual_type=None;
1483         int actual_format;
1484         unsigned long nitems;
1485         unsigned long bytes_after;
1486         unsigned char *prop;
1487
1488         if(atom__net_wm_window_type==None){
1489             atom__net_wm_window_type=XInternAtom(ioncore_g.dpy,
1490                                                  "_NET_WM_WINDOW_TYPE",
1491                                                  False);
1492         }
1493         if(atom__net_wm_window_type_dock==None){
1494             atom__net_wm_window_type_dock=XInternAtom(ioncore_g.dpy,
1495                                                      "_NET_WM_WINDOW_TYPE_DOCK",
1496                                                       False);
1497         }
1498         if(XGetWindowProperty(ioncore_g.dpy, cwin->win, atom__net_wm_window_type,
1499                               0, sizeof(Atom), False, XA_ATOM, &actual_type,
1500                               &actual_format, &nitems, &bytes_after, &prop)
1501            ==Success){
1502             if(actual_type==XA_ATOM && nitems>=1
1503                && *(Atom*)prop==atom__net_wm_window_type_dock){
1504                 is_dockapp=TRUE;
1505             }
1506             XFree(prop);
1507         }
1508     }
1509
1510     /* Third, inspect the WM_CLASS property */
1511     if(!is_dockapp){
1512         char **p;
1513         int n;
1514
1515         p=xwindow_get_text_property(cwin->win, XA_WM_CLASS, &n);
1516         if(p!=NULL){
1517             if(n>=2 && strcmp(p[1], "DockApp")==0){
1518                 is_dockapp=TRUE;
1519             }
1520             XFreeStringList(p);
1521         }
1522     }
1523
1524     /* Fourth, inspect the _KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR property */
1525     if(!is_dockapp){
1526         static Atom atom__kde_net_wm_system_tray_window_for=None;
1527         Atom actual_type=None;
1528         int actual_format;
1529         unsigned long nitems;
1530         unsigned long bytes_after;
1531         unsigned char *prop;
1532
1533         if(atom__kde_net_wm_system_tray_window_for==None){
1534             atom__kde_net_wm_system_tray_window_for=XInternAtom(ioncore_g.dpy,
1535                                                                 "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR",
1536                                                                 False);
1537         }
1538         if(XGetWindowProperty(ioncore_g.dpy, cwin->win,
1539                               atom__kde_net_wm_system_tray_window_for, 0,
1540                               sizeof(Atom), False, AnyPropertyType,
1541                               &actual_type, &actual_format, &nitems,
1542                               &bytes_after, &prop)==Success){
1543             if(actual_type!=None){
1544                 is_dockapp=TRUE;
1545             }
1546             XFree(prop);
1547         }
1548     }
1549
1550     return is_dockapp;
1551
1552 }
1553
1554
1555 static WDock *dock_find_suitable_dock(WClientWin *cwin,
1556                                       const WManageParams *param)
1557 {
1558     WDock *dock;
1559
1560     for(dock=docks; dock; dock=dock->dock_next){
1561         if(!dock->is_auto)
1562             continue;
1563         if(!region_same_rootwin((WRegion*)dock, (WRegion*)cwin))
1564             continue;
1565         break;
1566     }
1567
1568     return dock;
1569 }
1570
1571
1572 static bool clientwin_do_manage_hook(WClientWin *cwin, const WManageParams *param)
1573 {
1574     WDock *dock;
1575
1576     if(!dock_clientwin_is_dockapp(cwin, param)){
1577         return FALSE;
1578     }
1579
1580     dock=dock_find_suitable_dock(cwin, param);
1581     if(!dock){
1582         return FALSE;
1583     }
1584
1585     return region_manage_clientwin((WRegion*)dock, cwin, param,
1586                                    MANAGE_REDIR_PREFER_NO);
1587 }
1588
1589
1590 /*}}}*/
1591
1592
1593 /*{{{ Module init/deinit */
1594
1595
1596 bool mod_dock_init()
1597 {
1598
1599     if(XShapeQueryExtension(ioncore_g.dpy, &shape_event_basep,
1600                             &shape_error_basep)){
1601         shape_extension=TRUE;
1602     }else{
1603         XMissingExtension(ioncore_g.dpy, "SHAPE");
1604     }
1605
1606     if(!ioncore_register_regclass(&CLASSDESCR(WDock),
1607                                   (WRegionLoadCreateFn*)dock_load)){
1608         return FALSE;
1609     }
1610
1611     if(!mod_dock_register_exports()){
1612         ioncore_unregister_regclass(&CLASSDESCR(WDock));
1613         return FALSE;
1614     }
1615
1616     dock_bindmap=ioncore_alloc_bindmap("WDock", NULL);
1617     if(dock_bindmap==NULL){
1618         warn("Unable to allocate dock bindmap.");
1619         mod_dock_unregister_exports();
1620         ioncore_unregister_regclass(&CLASSDESCR(WDock));
1621     }
1622
1623     extl_read_config("cfg_dock", NULL, TRUE);
1624
1625     hook_add(clientwin_do_manage_alt,
1626              (WHookDummy*)clientwin_do_manage_hook);
1627
1628     return TRUE;
1629
1630 }
1631
1632
1633 void mod_dock_deinit()
1634 {
1635     WDock *dock;
1636
1637     ioncore_unregister_regclass(&CLASSDESCR(WDock));
1638
1639     hook_remove(clientwin_do_manage_alt,
1640                 (WHookDummy*)clientwin_do_manage_hook);
1641
1642     dock=docks;
1643     while(dock!=NULL){
1644         WDock *next=dock->dock_next;
1645         destroy_obj((Obj*)dock);
1646         dock=next;
1647     }
1648
1649     mod_dock_unregister_exports();
1650
1651     if(dock_bindmap!=NULL){
1652         ioncore_free_bindmap("WDock", dock_bindmap);
1653         dock_bindmap=NULL;
1654     }
1655 }
1656
1657
1658 /*}}}*/
1659
1660
1661 /*{{{ WDock class description and dynfun list */
1662
1663
1664 static DynFunTab dock_dynfuntab[]={
1665     {window_draw, dock_draw},
1666     {region_updategr, dock_updategr},
1667     {region_managed_rqgeom, dock_managed_rqgeom},
1668     {(DynFun*)region_prepare_manage, (DynFun*)dock_prepare_manage},
1669     {region_managed_remove, dock_managed_remove},
1670     {(DynFun*)region_get_configuration, (DynFun*)dock_get_configuration},
1671     {region_size_hints, dock_size_hints},
1672     {(DynFun*)region_fitrep, (DynFun*)dock_fitrep},
1673     {(DynFun*)region_orientation, (DynFun*)dock_orientation},
1674     {(DynFun*)region_handle_drop, (DynFun*)dock_handle_drop},
1675
1676     {(DynFun*)region_managed_get_pholder,
1677      (DynFun*)dock_managed_get_pholder},
1678     END_DYNFUNTAB
1679 };
1680
1681
1682 EXTL_EXPORT
1683 IMPLCLASS(WDock, WWindow, dock_deinit, dock_dynfuntab);
1684
1685
1686 /*}}}*/
1687