ioncore/resize.c

   1 /*
   2  * ion/ioncore/resize.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <stdio.h>
  10 #include <limits.h>
  11
  12 #include <libtu/objp.h>
  13 #include <libtu/minmax.h>
  14 #include <libextl/extl.h>
  15 #include <libmainloop/defer.h>
  16
  17 #include "common.h"
  18 #include "global.h"
  19 #include "resize.h"
  20 #include "gr.h"
  21 #include "sizehint.h"
  22 #include "event.h"
  23 #include "cursor.h"
  24 #include "extlconv.h"
  25 #include "grab.h"
  26 #include "framep.h"
  27 #include "infowin.h"
  28
  29
  30 #define XOR_RESIZE (!ioncore_g.opaque_resize)
  31
  32
  33 extern int ioncore_edge_resistance;
  34
  35
  36 /*{{{ Size/position display and rubberband */
  37
  38
  39 static void draw_rubberbox(WRootWin *rw, const WRectangle *rect)
  40 {
  41     XPoint fpts[5];
  42
  43     fpts[0].x=rect->x;
  44     fpts[0].y=rect->y;
  45     fpts[1].x=rect->x+rect->w;
  46     fpts[1].y=rect->y;
  47     fpts[2].x=rect->x+rect->w;
  48     fpts[2].y=rect->y+rect->h;
  49     fpts[3].x=rect->x;
  50     fpts[3].y=rect->y+rect->h;
  51     fpts[4].x=rect->x;
  52     fpts[4].y=rect->y;
  53
  54     XDrawLines(ioncore_g.dpy, WROOTWIN_ROOT(rw), rw->xor_gc, fpts, 5,
  55                CoordModeOrigin);
  56 }
  57
  58
  59 static int max_width(GrBrush *brush, const char *str)
  60 {
  61     int maxw=0, w;
  62
  63     while(str && *str!='\0'){
  64         w=grbrush_get_text_width(brush, str, 1);
  65         if(w>maxw)
  66             maxw=w;
  67         str++;
  68     }
  69
  70     return maxw;
  71 }
  72
  73
  74 static int chars_for_num(int d)
  75 {
  76     int n=0;
  77
  78     do{
  79         n++;
  80         d/=10;
  81     }while(d);
  82
  83     return n;
  84 }
  85
  86
  87 static WInfoWin *setup_moveres_display(WWindow *parent, int cx, int cy)
  88 {
  89     GrBorderWidths bdw;
  90     GrFontExtents fnte;
  91     WInfoWin *infowin;
  92     WFitParams fp;
  93
  94     fp.mode=REGION_FIT_EXACT;
  95     fp.g.x=0;
  96     fp.g.y=0;
  97     fp.g.w=1;
  98     fp.g.h=1;
  99
 100     infowin=create_infowin(parent, &fp, "moveres_display");
 101
 102     if(infowin==NULL)
 103         return NULL;
 104
 105     grbrush_get_border_widths(INFOWIN_BRUSH(infowin), &bdw);
 106     grbrush_get_font_extents(INFOWIN_BRUSH(infowin), &fnte);
 107
 108     /* Create move/resize position/size display window */
 109     fp.g.w=3;
 110     fp.g.w+=chars_for_num(REGION_GEOM(parent).w);
 111     fp.g.w+=chars_for_num(REGION_GEOM(parent).h);
 112     fp.g.w*=max_width(INFOWIN_BRUSH(infowin), "0123456789x+");
 113     fp.g.w+=bdw.left+bdw.right;
 114     fp.g.h=fnte.max_height+bdw.top+bdw.bottom;;
 115
 116     fp.g.x=cx-fp.g.w/2;
 117     fp.g.y=cy-fp.g.h/2;
 118
 119     region_fitrep((WRegion*)infowin, NULL, &fp);
 120     region_map((WRegion*)infowin);
 121
 122     return infowin;
 123 }
 124
 125
 126 static void moveres_draw_infowin(WMoveresMode *mode)
 127 {
 128     char *buf;
 129
 130     if(mode->infowin==NULL)
 131         return;
 132
 133     buf=INFOWIN_BUFFER(mode->infowin);
 134
 135     if(buf==NULL)
 136         return;
 137
 138     if(mode->mode==MOVERES_SIZE){
 139         int w, h;
 140
 141         w=mode->geom.w;
 142         h=mode->geom.h;
 143
 144         if(mode->hints.base_set){
 145             w=MAXOF(0, w-mode->hints.base_width);
 146             h=MAXOF(0, h-mode->hints.base_height);
 147         }
 148
 149         if(mode->hints.inc_set){
 150             w/=MAXOF(1, mode->hints.width_inc);
 151             h/=MAXOF(1, mode->hints.height_inc);
 152         }
 153
 154         snprintf(buf, INFOWIN_BUFFER_LEN, "%dx%d", w, h);
 155     }else{
 156         snprintf(buf, INFOWIN_BUFFER_LEN, "%+d %+d",
 157                  mode->geom.x, mode->geom.y);
 158     }
 159
 160     window_draw((WWindow*)mode->infowin, TRUE);
 161 }
 162
 163
 164 static void moveres_draw_rubberband(WMoveresMode *mode)
 165 {
 166     WRectangle rgeom=mode->geom;
 167     WRootWin *rootwin=(mode->reg==NULL
 168                        ? NULL
 169                        : region_rootwin_of(mode->reg));
 170
 171     if(rootwin==NULL)
 172         return;
 173
 174     rgeom.x+=mode->parent_rx;
 175     rgeom.y+=mode->parent_ry;
 176
 177     if(mode->rubfn==NULL)
 178         draw_rubberbox(rootwin, &rgeom);
 179     else
 180         mode->rubfn(rootwin, &rgeom);
 181 }
 182
 183
 184 /*}}}*/
 185
 186
 187 /*{{{ Move/resize mode */
 188
 189
 190 WMoveresMode *tmpmode=NULL;
 191
 192
 193 EXTL_EXPORT
 194 IMPLCLASS(WMoveresMode, Obj, NULL, NULL);
 195
 196
 197 WMoveresMode *moveres_mode(WRegion *reg)
 198 {
 199     if(tmpmode==NULL)
 200         return NULL;
 201     return ((reg==NULL || tmpmode->reg==reg) ? tmpmode : NULL);
 202 }
 203
 204
 205 WRegion *moveresmode_target(WMoveresMode *mode)
 206 {
 207     return mode->reg;
 208 }
 209
 210
 211 static bool moveresmode_init(WMoveresMode *mode, WRegion *reg,
 212                              WDrawRubberbandFn *rubfn, bool cumulative)
 213 {
 214     WWindow *parent;
 215     WRegion *mgr;
 216
 217     if(tmpmode!=NULL)
 218         return FALSE;
 219
 220     parent=REGION_PARENT(reg);
 221
 222     if(parent==NULL)
 223         return FALSE;
 224
 225     tmpmode=mode;
 226
 227     mode->snap_enabled=FALSE;
 228     region_size_hints(reg, &mode->hints);
 229
 230     region_rootpos((WRegion*)parent, &mode->parent_rx, &mode->parent_ry);
 231
 232     mode->geom=REGION_GEOM(reg);
 233     mode->origgeom=REGION_GEOM(reg);
 234     mode->dx1=0;
 235     mode->dx2=0;
 236     mode->dy1=0;
 237     mode->dy2=0;
 238     mode->rubfn=rubfn;
 239     mode->resize_cumulative=cumulative;
 240     mode->rqflags=(XOR_RESIZE ? REGION_RQGEOM_TRYONLY : 0);
 241     mode->reg=reg;
 242     mode->mode=MOVERES_SIZE;
 243
 244     /* Get snapping geometry */
 245     mgr=REGION_MANAGER(reg);
 246
 247     if(mgr!=NULL){
 248         mode->snapgeom=REGION_GEOM(mgr);
 249
 250         if(mgr==(WRegion*)parent){
 251             mode->snapgeom.x=0;
 252             mode->snapgeom.y=0;
 253             /*mode->snap_enabled=FALSE;*/
 254         }
 255         mode->snap_enabled=TRUE;
 256     }
 257
 258     if(!mode->hints.min_set || mode->hints.min_width<1)
 259         mode->hints.min_width=1;
 260     if(!mode->hints.min_set || mode->hints.min_height<1)
 261         mode->hints.min_height=1;
 262
 263     /* Set up info window */
 264     {
 265         int x=mode->geom.x+mode->geom.w/2;
 266         int y=mode->geom.y+mode->geom.h/2;
 267         mode->infowin=setup_moveres_display(parent, x, y);
 268     }
 269
 270     moveres_draw_infowin(mode);
 271
 272     if(XOR_RESIZE){
 273         XGrabServer(ioncore_g.dpy);
 274         moveres_draw_rubberband(mode);
 275     }
 276
 277     return TRUE;
 278 }
 279
 280
 281 static WMoveresMode *create_moveresmode(WRegion *reg,
 282                                         WDrawRubberbandFn *rubfn,
 283                                         bool cumulative)
 284 {
 285     CREATEOBJ_IMPL(WMoveresMode, moveresmode, (p, reg, rubfn, cumulative));
 286 }
 287
 288
 289 WMoveresMode *region_begin_resize(WRegion *reg, WDrawRubberbandFn *rubfn,
 290                                   bool cumulative)
 291 {
 292     WMoveresMode *mode=create_moveresmode(reg, rubfn, cumulative);
 293
 294     if(mode!=NULL){
 295         mode->mode=MOVERES_SIZE;
 296         ioncore_change_grab_cursor(IONCORE_CURSOR_RESIZE);
 297     }
 298
 299     return mode;
 300 }
 301
 302
 303 WMoveresMode *region_begin_move(WRegion *reg, WDrawRubberbandFn *rubfn,
 304                                 bool cumulative)
 305 {
 306     WMoveresMode *mode=create_moveresmode(reg, rubfn, cumulative);
 307
 308     if(mode!=NULL){
 309         mode->mode=MOVERES_POS;
 310         ioncore_change_grab_cursor(IONCORE_CURSOR_MOVE);
 311     }
 312
 313     return mode;
 314 }
 315
 316
 317 static void moveresmode_setorig(WMoveresMode *mode)
 318 {
 319     mode->dx1=0;
 320     mode->dx2=0;
 321     mode->dy1=0;
 322     mode->dy2=0;
 323     mode->origgeom=mode->geom;
 324 }
 325
 326
 327 static void moveresmode_do_newgeom(WMoveresMode *mode, WRQGeomParams *rq)
 328 {
 329     if(XOR_RESIZE)
 330         moveres_draw_rubberband(mode);
 331
 332     if(mode->reg!=NULL){
 333         rq->flags|=mode->rqflags;
 334         region_rqgeom(mode->reg, rq, &mode->geom);
 335     }
 336
 337     moveres_draw_infowin(mode);
 338
 339     if(XOR_RESIZE)
 340         moveres_draw_rubberband(mode);
 341 }
 342
 343
 344 static int clamp_up(int t, int low, int high)
 345 {
 346     return (t < high && t > low ? high : t);
 347 }
 348
 349
 350 static void moveresmode_delta(WMoveresMode *mode,
 351                               int dx1, int dx2, int dy1, int dy2,
 352                               WRectangle *rret)
 353 {
 354     int realdx1, realdx2, realdy1, realdy2;
 355     WRQGeomParams rq=RQGEOMPARAMS_INIT;
 356     int er=ioncore_edge_resistance;
 357     int w=0, h=0;
 358
 359     realdx1=(mode->dx1+=dx1);
 360     realdx2=(mode->dx2+=dx2);
 361     realdy1=(mode->dy1+=dy1);
 362     realdy2=(mode->dy2+=dy2);
 363     rq.geom=mode->origgeom;
 364
 365     /* snap */
 366     if(mode->snap_enabled){
 367         WRectangle *sg=&mode->snapgeom;
 368
 369         if(mode->dx1!=0 && rq.geom.x+mode->dx1<sg->x && rq.geom.x+mode->dx1>sg->x-er)
 370             realdx1=sg->x-rq.geom.x;
 371         if(mode->dx2!=0 && rq.geom.x+rq.geom.w+mode->dx2>sg->x+sg->w && rq.geom.x+rq.geom.w+mode->dx2<sg->x+sg->w+er)
 372             realdx2=sg->x+sg->w-rq.geom.x-rq.geom.w;
 373         if(mode->dy1!=0 && rq.geom.y+mode->dy1<sg->y && rq.geom.y+mode->dy1>sg->y-er)
 374             realdy1=sg->y-rq.geom.y;
 375         if(mode->dy2!=0 && rq.geom.y+rq.geom.h+mode->dy2>sg->y+sg->h && rq.geom.y+rq.geom.h+mode->dy2<sg->y+sg->h+er)
 376             realdy2=sg->y+sg->h-rq.geom.y-rq.geom.h;
 377     }
 378
 379     w=MAXOF(1, mode->origgeom.w-realdx1+realdx2);
 380     h=MAXOF(1, mode->origgeom.h-realdy1+realdy2);
 381
 382     if(mode->snap_enabled && mode->hints.base_set){
 383         w=clamp_up(w, mode->hints.base_width-er, mode->hints.base_width);
 384         h=clamp_up(h, mode->hints.base_height-er, mode->hints.base_height);
 385     }
 386
 387     /* Correct size */
 388     sizehints_correct(&mode->hints, &w, &h, TRUE, TRUE);
 389
 390     /* Do not modify coordinates and sizes that were not requested to be
 391      * changed.
 392      */
 393
 394     if(mode->dx1==mode->dx2){
 395         if(mode->dx1==0 || realdx1!=mode->dx1)
 396             rq.geom.x+=realdx1;
 397         else
 398             rq.geom.x+=realdx2;
 399     }else{
 400         rq.geom.w=w;
 401         if(mode->dx1==0 || realdx1!=mode->dx1)
 402             rq.geom.x+=realdx1;
 403         else
 404             rq.geom.x+=mode->origgeom.w-rq.geom.w;
 405     }
 406
 407
 408     if(mode->dy1==mode->dy2){
 409         if(mode->dy1==0 || realdy1!=mode->dy1)
 410             rq.geom.y+=realdy1;
 411         else
 412             rq.geom.y+=realdy2;
 413     }else{
 414         rq.geom.h=h;
 415         if(mode->dy1==0 || realdy1!=mode->dy1)
 416             rq.geom.y+=realdy1;
 417         else
 418             rq.geom.y+=mode->origgeom.h-rq.geom.h;
 419     }
 420
 421     moveresmode_do_newgeom(mode, &rq);
 422
 423     if(!mode->resize_cumulative)
 424         moveresmode_setorig(mode);
 425
 426     if(rret!=NULL)
 427         *rret=mode->geom;
 428 }
 429
 430
 431 void moveresmode_delta_resize(WMoveresMode *mode,
 432                               int dx1, int dx2, int dy1, int dy2,
 433                               WRectangle *rret)
 434 {
 435     mode->mode=MOVERES_SIZE;
 436     moveresmode_delta(mode, dx1, dx2, dy1, dy2, rret);
 437 }
 438
 439
 440 void moveresmode_delta_move(WMoveresMode *mode,
 441                             int dx, int dy, WRectangle *rret)
 442 {
 443     mode->mode=MOVERES_POS;
 444     moveresmode_delta(mode, dx, dx, dy, dy, rret);
 445 }
 446
 447
 448 void moveresmode_rqgeom(WMoveresMode *mode, WRQGeomParams *rq,
 449                         WRectangle *UNUSED(rret))
 450 {
 451     mode->mode=MOVERES_SIZE;
 452     moveresmode_do_newgeom(mode, rq);
 453     moveresmode_setorig(mode);
 454 }
 455
 456
 457 /* It is ugly to do this here, but it will have to do for now... */
 458 static void set_saved(WMoveresMode *mode, WRegion *reg)
 459 {
 460     WFrame *frame;
 461
 462     if(!OBJ_IS(reg, WFrame))
 463         return;
 464
 465     frame=(WFrame*)reg;
 466
 467     /* Restore saved sizes from the beginning of the resize action */
 468     if(mode->origgeom.w!=mode->geom.w){
 469         frame->saved_geom.x=mode->origgeom.x;
 470         frame->saved_geom.w=mode->origgeom.w;
 471     }
 472
 473     if(mode->origgeom.h!=mode->geom.h){
 474         frame->saved_geom.y=mode->origgeom.y;
 475         frame->saved_geom.h=mode->origgeom.h;
 476     }
 477 }
 478
 479
 480 bool moveresmode_do_end(WMoveresMode *mode, bool apply)
 481 {
 482     WRegion *reg=mode->reg;
 483
 484     assert(reg!=NULL);
 485     assert(tmpmode==mode);
 486
 487     tmpmode=NULL;
 488
 489     if(XOR_RESIZE){
 490         moveres_draw_rubberband(mode);
 491         if(apply){
 492             WRQGeomParams rq=RQGEOMPARAMS_INIT;
 493
 494             rq.geom=mode->geom;
 495             rq.flags=mode->rqflags&~REGION_RQGEOM_TRYONLY;
 496
 497             region_rqgeom(reg, &rq, &mode->geom);
 498         }
 499         XUngrabServer(ioncore_g.dpy);
 500     }
 501     if(apply)
 502         set_saved(mode, reg);
 503
 504     if(mode->infowin!=NULL){
 505         mainloop_defer_destroy((Obj*)mode->infowin);
 506         mode->infowin=NULL;
 507     }
 508     destroy_obj((Obj*)mode);
 509
 510     return TRUE;
 511 }
 512
 513
 514 /*}}}*/
 515
 516
 517 /*{{{ Request and other dynfuns */
 518
 519
 520 void region_rqgeom(WRegion *reg, const WRQGeomParams *rq,
 521                    WRectangle *geomret)
 522 {
 523     WRegion *mgr=REGION_MANAGER(reg);
 524
 525     if(mgr!=NULL){
 526         if(rq->flags&REGION_RQGEOM_ABSOLUTE)
 527             region_managed_rqgeom_absolute(mgr, reg, rq, geomret);
 528         else
 529             region_managed_rqgeom(mgr, reg, rq, geomret);
 530     }else{
 531         WRectangle tmp;
 532
 533         if(rq->flags&REGION_RQGEOM_ABSOLUTE)
 534             region_absolute_geom_to_parent(reg, &rq->geom, &tmp);
 535         else
 536             tmp=rq->geom;
 537
 538         if(geomret!=NULL)
 539             *geomret=tmp;
 540
 541         if(!(rq->flags&REGION_RQGEOM_TRYONLY))
 542             region_fit(reg, &tmp, REGION_FIT_EXACT);
 543     }
 544 }
 545
 546
 547 void rqgeomparams_from_table(WRQGeomParams *rq,
 548                              const WRectangle *origg, ExtlTab g)
 549 {
 550     rq->geom=*origg;
 551     rq->flags=REGION_RQGEOM_WEAK_ALL;
 552
 553     if(extl_table_gets_i(g, "x", &(rq->geom.x)))
 554        rq->flags&=~REGION_RQGEOM_WEAK_X;
 555     if(extl_table_gets_i(g, "y", &(rq->geom.y)))
 556        rq->flags&=~REGION_RQGEOM_WEAK_Y;
 557     if(extl_table_gets_i(g, "w", &(rq->geom.w)))
 558        rq->flags&=~REGION_RQGEOM_WEAK_W;
 559     if(extl_table_gets_i(g, "h", &(rq->geom.h)))
 560        rq->flags&=~REGION_RQGEOM_WEAK_H;
 561
 562     rq->geom.w=MAXOF(1, rq->geom.w);
 563     rq->geom.h=MAXOF(1, rq->geom.h);
 564 }
 565
 566
 567 /*EXTL_DOC
 568  * Attempt to resize and/or move \var{reg}. The table \var{g} is a usual
 569  * geometry specification (fields \var{x}, \var{y}, \var{w} and \var{h}),
 570  * but may contain missing fields, in which case, \var{reg}'s manager may
 571  * attempt to leave that attribute unchanged.
 572  */
 573 EXTL_EXPORT_AS(WRegion, rqgeom)
 574 ExtlTab region_rqgeom_extl(WRegion *reg, ExtlTab g)
 575 {
 576     WRQGeomParams rq=RQGEOMPARAMS_INIT;
 577     WRectangle res;
 578
 579     rqgeomparams_from_table(&rq, &REGION_GEOM(reg), g);
 580
 581     region_rqgeom(reg, &rq, &res);
 582
 583     return extl_table_from_rectangle(&res);
 584 }
 585
 586
 587 void region_managed_rqgeom(WRegion *mgr, WRegion *reg,
 588                            const WRQGeomParams *rq,
 589                            WRectangle *geomret)
 590 {
 591     CALL_DYN(region_managed_rqgeom, mgr, (mgr, reg, rq, geomret));
 592 }
 593
 594
 595 void region_managed_rqgeom_absolute(WRegion *mgr, WRegion *reg,
 596                                     const WRQGeomParams *rq,
 597                                     WRectangle *geomret)
 598 {
 599     CALL_DYN(region_managed_rqgeom_absolute, mgr,
 600              (mgr, reg, rq, geomret));
 601 }
 602
 603
 604 void region_managed_rqgeom_allow(WRegion *UNUSED(mgr), WRegion *reg,
 605                                  const WRQGeomParams *rq,
 606                                  WRectangle *geomret)
 607 {
 608     if(geomret!=NULL)
 609         *geomret=rq->geom;
 610
 611     if(!(rq->flags&REGION_RQGEOM_TRYONLY))
 612         region_fit(reg, &rq->geom, REGION_FIT_EXACT);
 613 }
 614
 615
 616 void region_managed_rqgeom_unallow(WRegion *UNUSED(mgr), WRegion *reg,
 617                                    const WRQGeomParams *UNUSED(rq),
 618                                    WRectangle *geomret)
 619 {
 620     if(geomret!=NULL)
 621         *geomret=REGION_GEOM(reg);
 622 }
 623
 624
 625 void region_managed_rqgeom_absolute_default(WRegion *mgr, WRegion *reg,
 626                                             const WRQGeomParams *rq,
 627                                             WRectangle *geomret)
 628 {
 629     WRQGeomParams rq2=RQGEOMPARAMS_INIT;
 630
 631     rq2.flags=rq->flags&~REGION_RQGEOM_ABSOLUTE;
 632     region_absolute_geom_to_parent(reg, &rq->geom, &rq2.geom);
 633
 634     region_managed_rqgeom(mgr, reg, &rq2, geomret);
 635 }
 636
 637
 638 bool region_managed_maximize(WRegion *mgr, WRegion *reg, int dir, int action)
 639 {
 640     bool ret=FALSE;
 641     CALL_DYN_RET(ret, bool, region_managed_maximize, mgr, (mgr, reg, dir, action));
 642     return ret;
 643 }
 644
 645
 646 void region_size_hints(WRegion *reg, WSizeHints *hints_ret)
 647 {
 648     sizehints_clear(hints_ret);
 649
 650     {
 651         CALL_DYN(region_size_hints, reg, (reg, hints_ret));
 652     }
 653
 654     if(!hints_ret->min_set){
 655         hints_ret->min_width=1;
 656         hints_ret->min_height=1;
 657     }
 658     if(!hints_ret->base_set){
 659         hints_ret->base_width=0;
 660         hints_ret->base_height=0;
 661     }
 662     if(!hints_ret->max_set){
 663         hints_ret->max_width=INT_MAX;
 664         hints_ret->max_height=INT_MAX;
 665     }
 666 }
 667
 668
 669 void region_size_hints_correct(WRegion *reg,
 670                                int *wp, int *hp, bool min)
 671 {
 672     WSizeHints hints;
 673
 674     region_size_hints(reg, &hints);
 675
 676     sizehints_correct(&hints, wp, hp, min, FALSE);
 677 }
 678
 679
 680 int region_orientation(WRegion *reg)
 681 {
 682     int ret=REGION_ORIENTATION_NONE;
 683
 684     CALL_DYN_RET(ret, int, region_orientation, reg, (reg));
 685
 686     return ret;
 687 }
 688
 689
 690 /*EXTL_DOC
 691  * Returns size hints for \var{reg}. The returned table always contains the
 692  * fields \code{min_?}, \code{base_?} and sometimes the fields \code{max_?},
 693  * \code{base_?} and \code{inc_?}, where \code{?}=\code{w}, \code{h}.
 694  */
 695 EXTL_SAFE
 696 EXTL_EXPORT_AS(WRegion, size_hints)
 697 ExtlTab region_size_hints_extl(WRegion *reg)
 698 {
 699     WSizeHints hints;
 700     ExtlTab tab;
 701
 702     region_size_hints(reg, &hints);
 703
 704     tab=extl_create_table();
 705
 706     if(hints.base_set){
 707         extl_table_sets_i(tab, "base_w", hints.base_width);
 708         extl_table_sets_i(tab, "base_h", hints.base_height);
 709     }
 710     if(hints.min_set){
 711         extl_table_sets_i(tab, "min_w", hints.min_width);
 712         extl_table_sets_i(tab, "min_h", hints.min_height);
 713     }
 714     if(hints.max_set){
 715         extl_table_sets_i(tab, "max_w", hints.max_width);
 716         extl_table_sets_i(tab, "max_h", hints.max_height);
 717     }
 718     if(hints.inc_set){
 719         extl_table_sets_i(tab, "inc_w", hints.width_inc);
 720         extl_table_sets_i(tab, "inc_h", hints.height_inc);
 721     }
 722
 723     return tab;
 724 }
 725
 726 /*}}}*/
 727
 728
 729 /*{{{ Restore size, maximize, shade */
 730
 731
 732 static bool rqh(WFrame *frame, int y, int h)
 733 {
 734     WRQGeomParams rq=RQGEOMPARAMS_INIT;
 735     WRectangle rgeom;
 736     int dummy_w;
 737
 738     rq.flags=REGION_RQGEOM_VERT_ONLY;
 739
 740     rq.geom.x=REGION_GEOM(frame).x;
 741     rq.geom.w=REGION_GEOM(frame).w;
 742     rq.geom.y=y;
 743     rq.geom.h=h;
 744
 745     dummy_w=rq.geom.w;
 746     region_size_hints_correct((WRegion*)frame, &dummy_w, &(rq.geom.h), TRUE);
 747
 748     region_rqgeom((WRegion*)frame, &rq, &rgeom);
 749
 750     return (abs(rgeom.y-REGION_GEOM(frame).y)>1 ||
 751             abs(rgeom.h-REGION_GEOM(frame).h)>1);
 752 }
 753
 754
 755 /*EXTL_DOC
 756  * Attempt to toggle vertical maximisation of \var{frame}.
 757  */
 758 EXTL_EXPORT_MEMBER
 759 void frame_maximize_vert(WFrame *frame)
 760 {
 761     WRegion *mp=REGION_MANAGER(frame);
 762     int oy, oh;
 763
 764     if(frame->flags&FRAME_SHADED || frame->flags&FRAME_MAXED_VERT){
 765         if(frame->flags&FRAME_SHADED)
 766             frame->flags|=FRAME_SHADED_TOGGLE;
 767         if(frame->flags&FRAME_SAVED_VERT){
 768             if(mp!=NULL && region_managed_maximize(mp, (WRegion*)frame, VERTICAL, VERIFY))
 769                 region_managed_maximize(mp, (WRegion*)frame, VERTICAL, RESTORE);
 770             else
 771                 rqh(frame, frame->saved_geom.y, frame->saved_geom.h);
 772         }
 773         frame->flags&=~(FRAME_MAXED_VERT|FRAME_SAVED_VERT|FRAME_SHADED_TOGGLE);
 774         region_goto((WRegion*)frame);
 775         return;
 776     }
 777
 778     if(mp==NULL)
 779         return;
 780
 781     oy=REGION_GEOM(frame).y;
 782     oh=REGION_GEOM(frame).h;
 783
 784     region_managed_maximize(mp, (WRegion*)frame, VERTICAL, SAVE);
 785     rqh(frame, 0, REGION_GEOM(mp).h);
 786     region_managed_maximize(mp, (WRegion*)frame, VERTICAL, RM_KEEP);
 787
 788     frame->flags|=(FRAME_MAXED_VERT|FRAME_SAVED_VERT);
 789     frame->saved_geom.y=oy;
 790     frame->saved_geom.h=oh;
 791
 792     region_goto((WRegion*)frame);
 793 }
 794
 795 static bool rqw(WFrame *frame, int x, int w)
 796 {
 797     WRQGeomParams rq=RQGEOMPARAMS_INIT;
 798     WRectangle rgeom;
 799     int dummy_h;
 800
 801     rq.flags=REGION_RQGEOM_HORIZ_ONLY;
 802
 803     rq.geom.x=x;
 804     rq.geom.w=w;
 805     rq.geom.y=REGION_GEOM(frame).y;
 806     rq.geom.h=REGION_GEOM(frame).h;
 807
 808     dummy_h=rq.geom.h;
 809     region_size_hints_correct((WRegion*)frame, &(rq.geom.w), &dummy_h, TRUE);
 810
 811     region_rqgeom((WRegion*)frame, &rq, &rgeom);
 812
 813     return (abs(rgeom.x-REGION_GEOM(frame).x)>1 ||
 814             abs(rgeom.w-REGION_GEOM(frame).w)>1);
 815 }
 816
 817
 818 /*EXTL_DOC
 819  * Attempt to toggle horizontal maximisation of \var{frame}.
 820  */
 821 EXTL_EXPORT_MEMBER
 822 void frame_maximize_horiz(WFrame *frame)
 823 {
 824     WRegion *mp=REGION_MANAGER(frame);
 825     int ox, ow;
 826
 827     if(frame->flags&FRAME_MIN_HORIZ || frame->flags&FRAME_MAXED_HORIZ){
 828         if(frame->flags&FRAME_SAVED_HORIZ){
 829             if(mp!=NULL && region_managed_maximize(mp, (WRegion*)frame, HORIZONTAL, VERIFY))
 830                 region_managed_maximize(mp, (WRegion*)frame, HORIZONTAL, RESTORE);
 831             else
 832                 rqw(frame, frame->saved_geom.x, frame->saved_geom.w);
 833         }
 834         frame->flags&=~(FRAME_MAXED_HORIZ|FRAME_SAVED_HORIZ);
 835         region_goto((WRegion*)frame);
 836         return;
 837     }
 838
 839     if(mp==NULL)
 840         return;
 841
 842     ox=REGION_GEOM(frame).x;
 843     ow=REGION_GEOM(frame).w;
 844
 845     region_managed_maximize(mp, (WRegion*)frame, HORIZONTAL, SAVE);
 846     rqw(frame, 0, REGION_GEOM(mp).w);
 847     region_managed_maximize(mp, (WRegion*)frame, HORIZONTAL, RM_KEEP);
 848
 849     frame->flags|=(FRAME_MAXED_HORIZ|FRAME_SAVED_HORIZ);
 850     frame->saved_geom.x=ox;
 851     frame->saved_geom.w=ow;
 852
 853     region_goto((WRegion*)frame);
 854 }
 855
 856
 857
 858 /*}}}*/
 859
 860
 861 /*{{{ Misc. */
 862
 863
 864 uint region_min_h(WRegion *reg)
 865 {
 866     WSizeHints hints;
 867     region_size_hints(reg, &hints);
 868     return hints.min_height;
 869 }
 870
 871
 872 uint region_min_w(WRegion *reg)
 873 {
 874     WSizeHints hints;
 875     region_size_hints(reg, &hints);
 876     return hints.min_width;
 877 }
 878
 879
 880 void region_convert_root_geom(WRegion *reg, WRectangle *geom)
 881 {
 882     int rx, ry;
 883     if(reg!=NULL){
 884         region_rootpos(reg, &rx, &ry);
 885         geom->x-=rx;
 886         geom->y-=ry;
 887     }
 888 }
 889
 890
 891 void region_absolute_geom_to_parent(WRegion *reg, const WRectangle *rgeom,
 892                                     WRectangle *pgeom)
 893 {
 894     WRegion *parent=REGION_PARENT_REG(reg);
 895
 896     pgeom->w=rgeom->w;
 897     pgeom->h=rgeom->h;
 898
 899     if(parent==NULL){
 900         pgeom->x=rgeom->x;
 901         pgeom->y=rgeom->y;
 902     }else{
 903         region_rootpos(reg, &pgeom->x, &pgeom->y);
 904         pgeom->x=rgeom->x-pgeom->x;
 905         pgeom->y=rgeom->y-pgeom->y;
 906     }
 907 }
 908
 909 /*}}}*/
 910