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