fvwm/geometry.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* ---------------------------- included header files ---------------------- */
  18
  19 #include "config.h"
  20
  21 #include <stdio.h>
  22
  23 #include "libs/fvwmlib.h"
  24 #include "libs/charmap.h"
  25 #include "libs/wcontext.h"
  26 #include "fvwm.h"
  27 #include "externs.h"
  28 #include "execcontext.h"
  29 #include "misc.h"
  30 #include "screen.h"
  31 #include "geometry.h"
  32 #include "module_interface.h"
  33 #include "borders.h"
  34 #include "icons.h"
  35 #include "add_window.h"
  36
  37 /* ---------------------------- local definitions -------------------------- */
  38
  39 /* ---------------------------- local macros ------------------------------- */
  40
  41 /* ---------------------------- imports ------------------------------------ */
  42
  43 /* ---------------------------- included code files ------------------------ */
  44
  45 /* ---------------------------- local types -------------------------------- */
  46
  47 /* ---------------------------- forward declarations ----------------------- */
  48
  49 /* ---------------------------- local variables ---------------------------- */
  50
  51 /* ---------------------------- exported variables (globals) --------------- */
  52
  53 /* ---------------------------- local functions ---------------------------- */
  54
  55 /* ---------------------------- interface functions ------------------------ */
  56
  57 /* Removes decorations from the source rectangle and moves it according to the
  58  * gravity specification. */
  59 void gravity_get_naked_geometry(
  60         int gravity, FvwmWindow *t, rectangle *dest_g, rectangle *orig_g)
  61 {
  62         int xoff;
  63         int yoff;
  64         size_borders b;
  65
  66         get_window_borders(t, &b);
  67         gravity_get_offsets(gravity, &xoff, &yoff);
  68         dest_g->x = orig_g->x + ((xoff + 1) * (orig_g->width - 1)) / 2;
  69         dest_g->y = orig_g->y + ((yoff + 1) * (orig_g->height - 1)) / 2;
  70         dest_g->width = orig_g->width - b.total_size.width;
  71         dest_g->height = orig_g->height - b.total_size.height;
  72
  73         return;
  74 }
  75
  76 /* Decorate the rectangle.  Resize and shift it according to gravity. */
  77 void gravity_add_decoration(
  78         int gravity, FvwmWindow *t, rectangle *dest_g, rectangle *orig_g)
  79 {
  80         size_borders b;
  81
  82         get_window_borders(t, &b);
  83         *dest_g = *orig_g;
  84         gravity_resize(
  85                 gravity, dest_g, b.total_size.width, b.total_size.height);
  86
  87         return;
  88 }
  89
  90 void get_relative_geometry(rectangle *rel_g, rectangle *abs_g)
  91 {
  92         rel_g->x = abs_g->x - Scr.Vx;
  93         rel_g->y = abs_g->y - Scr.Vy;
  94         rel_g->width = abs_g->width;
  95         rel_g->height = abs_g->height;
  96
  97         return;
  98 }
  99
 100 void get_absolute_geometry(rectangle *abs_g, rectangle *rel_g)
 101 {
 102         abs_g->x = rel_g->x + Scr.Vx;
 103         abs_g->y = rel_g->y + Scr.Vy;
 104         abs_g->width = rel_g->width;
 105         abs_g->height = rel_g->height;
 106
 107         return;
 108 }
 109
 110 void gravity_translate_to_northwest_geometry(
 111         int gravity, FvwmWindow *t, rectangle *dest_g, rectangle *orig_g)
 112 {
 113         int xoff;
 114         int yoff;
 115
 116         gravity_get_offsets(gravity, &xoff, &yoff);
 117         dest_g->x = orig_g->x -
 118                 ((xoff + 1) * (orig_g->width - 1 +
 119                                2 * t->attr_backup.border_width)) / 2;
 120         dest_g->y = orig_g->y -
 121                 ((yoff + 1) * (orig_g->height - 1 +
 122                                2 * t->attr_backup.border_width)) / 2;
 123         dest_g->width = orig_g->width;
 124         dest_g->height = orig_g->height;
 125
 126         return;
 127 }
 128
 129 void gravity_translate_to_northwest_geometry_no_bw(
 130         int gravity, FvwmWindow *t, rectangle *dest_g, rectangle *orig_g)
 131 {
 132         int bw = t->attr_backup.border_width;
 133
 134         t->attr_backup.border_width = 0;
 135         gravity_translate_to_northwest_geometry(gravity, t, dest_g, orig_g);
 136         t->attr_backup.border_width = bw;
 137
 138         return;
 139 }
 140
 141 void get_title_geometry(
 142         FvwmWindow *fw, rectangle *ret_g)
 143 {
 144         size_borders b;
 145         size_borders nt;
 146         int w;
 147         int h;
 148
 149         get_window_borders(fw, &b);
 150         get_window_borders_no_title(fw, &nt);
 151         w = (ret_g->width > 0) ? ret_g->width : fw->g.frame.width;
 152         h = (ret_g->height > 0) ? ret_g->height : fw->g.frame.height;
 153         ret_g->x = nt.top_left.width;
 154         ret_g->y = nt.top_left.height;
 155         switch (GET_TITLE_DIR(fw))
 156         {
 157         case DIR_S:
 158                 ret_g->y = h - b.bottom_right.height;
 159                 /* fall through */
 160         case DIR_N:
 161                 ret_g->width = w - b.total_size.width;
 162                 ret_g->height = fw->title_thickness;
 163                 break;
 164         case DIR_E:
 165                 ret_g->x = w - b.bottom_right.width;
 166                 /* fall through */
 167         case DIR_W:
 168                 ret_g->width = fw->title_thickness;
 169                 ret_g->height = h - b.total_size.height;
 170                 break;
 171         default:
 172                 break;
 173         }
 174
 175         return;
 176 }
 177
 178 void get_title_gravity_factors(
 179         FvwmWindow *fw, int *ret_fx, int *ret_fy)
 180 {
 181         switch (GET_TITLE_DIR(fw))
 182         {
 183         case DIR_N:
 184                 *ret_fx = 0;
 185                 *ret_fy = 1;
 186                 break;
 187         case DIR_S:
 188                 *ret_fx = 0;
 189                 *ret_fy = -1;
 190                 break;
 191         case DIR_W:
 192                 *ret_fx = 1;
 193                 *ret_fy = 0;
 194                 break;
 195         case DIR_E:
 196                 *ret_fx = -1;
 197                 *ret_fy = 0;
 198                 break;
 199         }
 200
 201         return;
 202 }
 203
 204 Bool get_title_button_geometry(
 205         FvwmWindow *fw, rectangle *ret_g, int context)
 206 {
 207         int bnum;
 208
 209         if (context & C_TITLE)
 210         {
 211                 ret_g->width = 0;
 212                 ret_g->height = 0;
 213                 get_title_geometry(fw, ret_g);
 214                 ret_g->x += fw->g.frame.x;
 215                 ret_g->y += fw->g.frame.y;
 216
 217                 return True;
 218
 219         }
 220         bnum = get_button_number(context);
 221         if (bnum < 0 || FW_W_BUTTON(fw, bnum) == None)
 222         {
 223                 return False;
 224         }
 225         if (XGetGeometry(
 226                 dpy, FW_W_BUTTON(fw, bnum), &JunkRoot, &ret_g->x, &ret_g->y,
 227                 (unsigned int*)&ret_g->width, (unsigned int*)&ret_g->height,
 228                 (unsigned int*)&JunkBW, (unsigned int*)&JunkDepth) == 0)
 229         {
 230                 return False;
 231         }
 232         XTranslateCoordinates(
 233                 dpy, FW_W_FRAME(fw), Scr.Root, ret_g->x, ret_g->y, &ret_g->x,
 234                 &ret_g->y, &JunkChild);
 235
 236         return True;
 237 }
 238
 239 void get_title_font_size_and_offset(
 240         FvwmWindow *fw, direction_t title_dir,
 241         Bool is_left_title_rotated_cw, Bool is_right_title_rotated_cw,
 242         Bool is_top_title_rotated, Bool is_bottom_title_rotated,
 243         int *size, int *offset)
 244 {
 245         int decor_size;
 246         int extra_size;
 247         int font_size;
 248         int min_offset;
 249         Bool is_rotated_cw, is_rotated;
 250         rotation_t draw_rotation;
 251
 252         /* adjust font offset according to height specified in title style */
 253         decor_size = fw->decor->title_height;
 254         font_size = fw->title_font->height + EXTRA_TITLE_FONT_HEIGHT;
 255         switch (title_dir)
 256         {
 257         case DIR_W:
 258         case DIR_E:
 259                 is_rotated_cw = (title_dir == DIR_W) ?
 260                         is_left_title_rotated_cw : is_right_title_rotated_cw;
 261                 if (is_rotated_cw)
 262                 {
 263                         fw->title_text_rotation = ROTATION_90;
 264                 }
 265                 else
 266                 {
 267                         fw->title_text_rotation = ROTATION_270;
 268                 }
 269                 break;
 270         case DIR_N:
 271         case DIR_S:
 272         default:
 273                 is_rotated = (title_dir == DIR_N) ?
 274                         is_top_title_rotated : is_bottom_title_rotated;
 275                 if (is_rotated)
 276                 {
 277                         fw->title_text_rotation = ROTATION_180;
 278                 }
 279                 else
 280                 {
 281                         fw->title_text_rotation = ROTATION_0;
 282                 }
 283                 break;
 284         }
 285         if (USE_TITLE_DECOR_ROTATION(fw))
 286         {
 287                 draw_rotation = ROTATION_0;
 288         }
 289         else
 290         {
 291                 draw_rotation = fw->title_text_rotation;
 292         }
 293         min_offset =  FlocaleGetMinOffset(
 294                 fw->title_font, draw_rotation);
 295         extra_size = (decor_size > 0) ? decor_size - font_size : 0;
 296         *offset = min_offset;
 297         if (fw->decor->min_title_height > 0 &&
 298             font_size + extra_size < fw->decor->min_title_height)
 299         {
 300                 extra_size = fw->decor->min_title_height - font_size;
 301         }
 302         if (extra_size > 0)
 303         {
 304                 *offset += extra_size / 2;
 305         }
 306         *size = font_size + extra_size;
 307
 308         return;
 309 }
 310
 311 void get_icon_corner(
 312         FvwmWindow *fw, rectangle *ret_g)
 313 {
 314         switch (GET_TITLE_DIR(fw))
 315         {
 316         case DIR_N:
 317         case DIR_W:
 318                 ret_g->x = fw->g.frame.x;
 319                 ret_g->y = fw->g.frame.y;
 320                 break;
 321         case DIR_S:
 322                 ret_g->x = fw->g.frame.x;
 323                 ret_g->y = fw->g.frame.y + fw->g.frame.height -
 324                         ret_g->height;
 325                 break;
 326         case DIR_E:
 327                 ret_g->x = fw->g.frame.x + fw->g.frame.width -
 328                         ret_g->width;
 329                 ret_g->y = fw->g.frame.y;
 330                 break;
 331         }
 332
 333         return;
 334 }
 335
 336 void get_shaded_geometry(
 337         FvwmWindow *fw, rectangle *small_g, rectangle *big_g)
 338 {
 339         size_borders b;
 340         /* this variable is necessary so the function can be called with
 341          * small_g == big_g */
 342         int big_width = big_g->width;
 343         int big_height = big_g->height;
 344         int d;
 345
 346         get_window_borders(fw, &b);
 347         *small_g = *big_g;
 348         d = 0;
 349         switch (SHADED_DIR(fw))
 350         {
 351         case DIR_S:
 352         case DIR_SW:
 353         case DIR_SE:
 354                 small_g->y = big_g->y + big_height - b.total_size.height;
 355                 d = 1;
 356                 /* fall through */
 357         case DIR_N:
 358         case DIR_NW:
 359         case DIR_NE:
 360                 small_g->height = b.total_size.height;
 361                 if (small_g->height == 0)
 362                 {
 363                         small_g->height = 1;
 364                         small_g->y -= d;
 365                 }
 366                 break;
 367         default:
 368                 break;
 369         }
 370         d = 0;
 371         switch (SHADED_DIR(fw))
 372         {
 373         case DIR_E:
 374         case DIR_NE:
 375         case DIR_SE:
 376                 small_g->x = big_g->x + big_width - b.total_size.width;
 377                 d = 1;
 378                 /* fall through */
 379         case DIR_W:
 380         case DIR_NW:
 381         case DIR_SW:
 382                 small_g->width = b.total_size.width;
 383                 if (small_g->width == 0)
 384                 {
 385                         small_g->width = 1;
 386                         small_g->x -= d;
 387                 }
 388                 break;
 389         default:
 390                 break;
 391         }
 392
 393         return;
 394 }
 395
 396 void get_shaded_geometry_with_dir(
 397         FvwmWindow *fw, rectangle *small_g, rectangle *big_g,
 398         direction_t shade_dir)
 399 {
 400         direction_t old_shade_dir;
 401
 402         old_shade_dir = SHADED_DIR(fw);
 403         SET_SHADED_DIR(fw, shade_dir);
 404         get_shaded_geometry(fw, small_g, big_g);
 405         SET_SHADED_DIR(fw, old_shade_dir);
 406
 407         return;
 408 }
 409
 410 void get_unshaded_geometry(
 411         FvwmWindow *fw, rectangle *ret_g)
 412 {
 413         if (IS_SHADED(fw))
 414         {
 415                 if (IS_MAXIMIZED(fw))
 416                 {
 417                         *ret_g = fw->g.max;
 418                 }
 419                 else
 420                 {
 421                         *ret_g = fw->g.normal;
 422                 }
 423                 get_relative_geometry(ret_g, ret_g);
 424         }
 425         else
 426         {
 427                 *ret_g = fw->g.frame;
 428         }
 429
 430         return;
 431 }
 432
 433 void get_shaded_client_window_pos(
 434         FvwmWindow *fw, rectangle *ret_g)
 435 {
 436         rectangle big_g;
 437         size_borders b;
 438
 439         get_window_borders(fw, &b);
 440         big_g = (IS_MAXIMIZED(fw)) ? fw->g.max : fw->g.normal;
 441         get_relative_geometry(&big_g, &big_g);
 442         switch (SHADED_DIR(fw))
 443         {
 444         case DIR_S:
 445         case DIR_SW:
 446         case DIR_SE:
 447                 ret_g->y = 1 - big_g.height + b.total_size.height;
 448                 break;
 449         default:
 450                 ret_g->y = 0;
 451                 break;
 452         }
 453         switch (SHADED_DIR(fw))
 454         {
 455         case DIR_E:
 456         case DIR_NE:
 457         case DIR_SE:
 458                 ret_g->x = 1 - big_g.width + b.total_size.width;
 459                 break;
 460         default:
 461                 ret_g->x = 0;
 462                 break;
 463         }
 464
 465         return;
 466 }
 467
 468 /* returns the dimensions of the borders */
 469 void get_window_borders(
 470         const FvwmWindow *fw, size_borders *borders)
 471 {
 472         borders->top_left.width = fw->boundary_width;
 473         borders->bottom_right.width = fw->boundary_width;
 474         borders->top_left.height = fw->boundary_width;
 475         borders->bottom_right.height = fw->boundary_width;
 476         switch (GET_TITLE_DIR(fw))
 477         {
 478         case DIR_N:
 479                 borders->top_left.height += fw->title_thickness;
 480                 break;
 481         case DIR_S:
 482                 borders->bottom_right.height += fw->title_thickness;
 483                 break;
 484         case DIR_W:
 485                 borders->top_left.width += fw->title_thickness;
 486                 break;
 487         case DIR_E:
 488                 borders->bottom_right.width += fw->title_thickness;
 489                 break;
 490         }
 491         borders->total_size.width =
 492                 borders->top_left.width + borders->bottom_right.width;
 493         borders->total_size.height =
 494                 borders->top_left.height + borders->bottom_right.height;
 495
 496         return;
 497 }
 498
 499 /* returns the dimensions of the borders without the title */
 500 void get_window_borders_no_title(
 501         const FvwmWindow *fw, size_borders *borders)
 502 {
 503         borders->top_left.width = fw->boundary_width;
 504         borders->bottom_right.width = fw->boundary_width;
 505         borders->top_left.height = fw->boundary_width;
 506         borders->bottom_right.height = fw->boundary_width;
 507         borders->total_size.width =
 508                 borders->top_left.width + borders->bottom_right.width;
 509         borders->total_size.height =
 510                 borders->top_left.height + borders->bottom_right.height;
 511
 512         return;
 513 }
 514
 515 void set_window_border_size(
 516         FvwmWindow *fw, int used_width)
 517 {
 518         if (used_width <= 0)
 519         {
 520                 fw->boundary_width = 0;
 521                 fw->unshaped_boundary_width = 0;
 522         }
 523         else
 524         {
 525                 fw->unshaped_boundary_width = used_width;
 526                 fw->boundary_width = (fw->wShaped) ? 0 : used_width;
 527         }
 528
 529         return;
 530 }
 531
 532 /* Returns True if all window borders are only 1 pixel thick (or less). */
 533 Bool is_window_border_minimal(
 534         FvwmWindow *fw)
 535 {
 536         size_borders nt;
 537
 538         get_window_borders_no_title(fw, &nt);
 539         if (nt.top_left.width > 1 || nt.top_left.height > 1 ||
 540             nt.bottom_right.width > 1 || nt.bottom_right.height > 1)
 541         {
 542                 return False;
 543         }
 544
 545         return True;
 546 }
 547
 548
 549 /* This function returns the geometry of the client window.  If the window is
 550  * shaded, the unshaded geometry is used instead. */
 551 void get_client_geometry(
 552         FvwmWindow *fw, rectangle *ret_g)
 553 {
 554         size_borders borders;
 555
 556         get_unshaded_geometry(fw, ret_g);
 557         get_window_borders(fw, &borders);
 558         ret_g->x += borders.top_left.width;
 559         ret_g->y += borders.top_left.height;
 560         ret_g->width -= borders.total_size.width;
 561         ret_g->height -= borders.total_size.height;
 562
 563         return;
 564 }
 565
 566 /* update the frame_g according to the window's g.normal or g.max and shaded
 567  * state */
 568 void update_relative_geometry(FvwmWindow *fw)
 569 {
 570         get_relative_geometry(
 571                 &fw->g.frame,
 572                 (IS_MAXIMIZED(fw)) ? &fw->g.max : &fw->g.normal);
 573         if (IS_SHADED(fw))
 574         {
 575                 get_shaded_geometry(
 576                         fw, &fw->g.frame, &fw->g.frame);
 577         }
 578
 579         return;
 580 }
 581
 582 /* update the g.normal or g.max according to the window's current position */
 583 void update_absolute_geometry(FvwmWindow *fw)
 584 {
 585         rectangle *dest_g;
 586         rectangle frame_g;
 587
 588         /* store orig values in absolute coords */
 589         dest_g = (IS_MAXIMIZED(fw)) ? &fw->g.max : &fw->g.normal;
 590         frame_g = *dest_g;
 591         dest_g->x = fw->g.frame.x + Scr.Vx;
 592         dest_g->y = fw->g.frame.y + Scr.Vy;
 593         dest_g->width = fw->g.frame.width;
 594         dest_g->height = fw->g.frame.height;
 595         if (IS_SHADED(fw))
 596         {
 597                 switch (SHADED_DIR(fw))
 598                 {
 599                 case DIR_SW:
 600                 case DIR_S:
 601                 case DIR_SE:
 602                         dest_g->y += fw->g.frame.height - frame_g.height;
 603                         /* fall through */
 604                 case DIR_NW:
 605                 case DIR_N:
 606                 case DIR_NE:
 607                         dest_g->height = frame_g.height;
 608                         break;
 609                 }
 610                 switch (SHADED_DIR(fw))
 611                 {
 612                 case DIR_NE:
 613                 case DIR_E:
 614                 case DIR_SE:
 615                         dest_g->x += fw->g.frame.width - frame_g.width;
 616                         /* fall through */
 617                 case DIR_NW:
 618                 case DIR_W:
 619                 case DIR_SW:
 620                         dest_g->width = frame_g.width;
 621                         break;
 622                 }
 623         }
 624
 625         return;
 626 }
 627
 628 /* make sure a maximized window and it's normal version are never a page or
 629  * more apart. */
 630 void maximize_adjust_offset(FvwmWindow *fw)
 631 {
 632         int off_x;
 633         int off_y;
 634         int dh;
 635         int dw;
 636
 637         if (!IS_MAXIMIZED(fw))
 638         {
 639                 /* otherwise we might corrupt the g.normal */
 640                 return;
 641         }
 642         off_x = fw->g.normal.x - fw->g.max.x - fw->g.max_offset.x;
 643         off_y = fw->g.normal.y - fw->g.max.y - fw->g.max_offset.y;
 644         dw = Scr.MyDisplayWidth;
 645         dh = Scr.MyDisplayHeight;
 646         if (off_x >= dw)
 647         {
 648                 fw->g.normal.x -= (off_x / dw) * dw;
 649         }
 650         else if (off_x <= -dw)
 651         {
 652                 fw->g.normal.x += (-off_x / dw) * dw;
 653         }
 654         if (off_y >= dh)
 655         {
 656                 fw->g.normal.y -= (off_y / dh) * dh;
 657         }
 658         else if (off_y <= -dh)
 659         {
 660                 fw->g.normal.y += (-off_y / dh) * dh;
 661         }
 662
 663         return;
 664 }
 665
 666 #define MAKEMULT(a,b) ((b==1) ? (a) : (((int)((a)/(b))) * (b)) )
 667 static void __cs_handle_aspect_ratio(
 668         size_rect *ret_s, FvwmWindow *fw, size_rect s, const size_rect base,
 669         const size_rect inc, size_rect min, size_rect max, int xmotion,
 670         int ymotion, int flags)
 671 {
 672         volatile double odefect;
 673         volatile double defect;
 674         volatile double rmax;
 675         volatile double rmin;
 676         volatile int delta;
 677         volatile int ow;
 678         volatile int oh;
 679
 680         if (fw->hints.flags & PBaseSize)
 681         {
 682                 /*
 683                  * ICCCM 2 demands that aspect ratio should apply to width -
 684                  * base_width. To prevent funny results, we reset PBaseSize in
 685                  * GetWindowSizeHints, if base is not smaller than min.
 686                  */
 687                 s.width -= base.width;
 688                 max.width -= base.width;
 689                 min.width -= base.width;
 690                 s.height -= base.height;
 691                 max.height -= base.height;
 692                 min.height -= base.height;
 693         }
 694         rmin = (double)fw->hints.min_aspect.x / (double)fw->hints.min_aspect.y;
 695         rmax = (double)fw->hints.max_aspect.x / (double)fw->hints.max_aspect.y;
 696         do
 697         {
 698                 double r;
 699
 700                 r = (double)s.width / (double)s.height;
 701                 ow = s.width;
 702                 oh = s.height;
 703                 odefect = 0;
 704                 if (r < rmin)
 705                 {
 706                         odefect = rmin - r;
 707                 }
 708                 else if (r > rmax)
 709                 {
 710                         odefect = r - rmax;
 711                 }
 712                 if (r < rmin && (flags & CS_ROUND_UP) && xmotion == 0)
 713                 {
 714                         /* change width to match */
 715                         delta = MAKEMULT(s.height * rmin - s.width, inc.width);
 716                         if (s.width + delta <= max.width)
 717                         {
 718                                 s.width += delta;
 719                         }
 720                         r = (double)s.width / (double)s.height;
 721                 }
 722                 if (r < rmin)
 723                 {
 724                         /* change height to match */
 725                         delta = MAKEMULT(
 726                                 s.height - s.width / rmin, inc.height);
 727                         if (s.height - delta >= min.height)
 728                         {
 729                                 s.height -= delta;
 730                         }
 731                         else
 732                         {
 733                                 delta = MAKEMULT(
 734                                         s.height * rmin - s.width, inc.width);
 735                                 if (s.width + delta <= max.width)
 736                                 {
 737                                         s.width += delta;
 738                                 }
 739                         }
 740                         r = (double)s.width / (double)s.height;
 741                 }
 742
 743                 if (r > rmax && (flags & CS_ROUND_UP) && ymotion == 0)
 744                 {
 745                         /* change height to match */
 746                         delta = MAKEMULT(s.width /rmax - s.height, inc.height);
 747                         if (s.height + delta <= max.height)
 748                         {
 749                                 s.height += delta;
 750                         }
 751                         r = (double)s.width / (double)s.height;
 752                 }
 753                 if (r > rmax)
 754                 {
 755                         /* change width to match */
 756                         delta = MAKEMULT(s.width - s.height * rmax, inc.width);
 757                         if (s.width - delta >= min.width)
 758                         {
 759                                 s.width -= delta;
 760                         }
 761                         else
 762                         {
 763                                 delta = MAKEMULT(
 764                                         s.width / rmax - s.height, inc.height);
 765                                 if (s.height + delta <= max.height)
 766                                 {
 767                                         s.height += delta;
 768                                 }
 769                         }
 770                         r = (double)s.width / (double)s.height;
 771                 }
 772                 defect = 0;
 773                 if (r < rmin)
 774                 {
 775                         defect = rmin - r;
 776                 }
 777                 else if (r > rmax)
 778                 {
 779                         defect = r - rmax;
 780                 }
 781         } while (odefect > defect);
 782         if (fw->hints.flags & PBaseSize)
 783         {
 784                 ow += base.width;
 785                 oh += base.height;
 786         }
 787         ret_s->width = ow;
 788         ret_s->height = oh;
 789
 790         return;
 791 }
 792
 793 /*
 794  *
 795  *  Procedure:
 796  *      constrain_size - adjust the given width and height to account for the
 797  *              constraints imposed by size hints
 798  */
 799 void constrain_size(
 800         FvwmWindow *fw, const XEvent *e, int *widthp, int *heightp,
 801         int xmotion, int ymotion, int flags)
 802 {
 803         size_rect min;
 804         size_rect max;
 805         size_rect inc;
 806         size_rect base;
 807         size_rect round_up;
 808         size_rect d;
 809         size_rect old;
 810         size_borders b;
 811
 812         if (DO_DISABLE_CONSTRAIN_SIZE_FULLSCREEN(fw) == 1)
 813         {
 814                 return;
 815         }
 816         if (HAS_NEW_WM_NORMAL_HINTS(fw))
 817         {
 818                 /* get the latest size hints */
 819                 XSync(dpy, 0);
 820                 GetWindowSizeHints(fw);
 821                 SET_HAS_NEW_WM_NORMAL_HINTS(fw, 0);
 822         }
 823         if (IS_MAXIMIZED(fw) && (flags & CS_UPDATE_MAX_DEFECT))
 824         {
 825                 *widthp += fw->g.max_defect.width;
 826                 *heightp += fw->g.max_defect.height;
 827         }
 828         /* gcc 4.1.1 warns about these not being initialized at the end,
 829          * but the conditions for the use are the same...*/
 830         old.width = *widthp;
 831         old.height = *heightp;
 832
 833         d.width = *widthp;
 834         d.height = *heightp;
 835         get_window_borders(fw, &b);
 836         d.width -= b.total_size.width;
 837         d.height -= b.total_size.height;
 838
 839         min.width = fw->hints.min_width;
 840         min.height = fw->hints.min_height;
 841         if (min.width < fw->min_window_width - b.total_size.width)
 842         {
 843                 min.width = fw->min_window_width - b.total_size.width;
 844         }
 845         if (min.height < fw->min_window_height - b.total_size.height)
 846         {
 847                 min.height =
 848                         fw->min_window_height - b.total_size.height;
 849         }
 850
 851         max.width = fw->hints.max_width;
 852         max.height =  fw->hints.max_height;
 853         if (max.width > fw->max_window_width - b.total_size.width)
 854         {
 855                 max.width = fw->max_window_width - b.total_size.width;
 856         }
 857         if (max.height > fw->max_window_height - b.total_size.height)
 858         {
 859                 max.height =
 860                         fw->max_window_height - b.total_size.height;
 861         }
 862
 863         if (min.width > max.width)
 864         {
 865                 min.width = max.width;
 866         }
 867         if (min.height > max.height)
 868         {
 869                 min.height = max.height;
 870         }
 871
 872         base.width = fw->hints.base_width;
 873         base.height = fw->hints.base_height;
 874
 875         inc.width = fw->hints.width_inc;
 876         inc.height = fw->hints.height_inc;
 877
 878         /*
 879          * First, clamp to min and max values
 880          */
 881         if (d.width < min.width)
 882         {
 883                 d.width = min.width;
 884         }
 885         if (d.height < min.height)
 886         {
 887                 d.height = min.height;
 888         }
 889         if (d.width > max.width)
 890         {
 891                 d.width = max.width;
 892         }
 893         if (d.height > max.height)
 894         {
 895                 d.height = max.height;
 896         }
 897
 898         /*
 899          * Second, round to base + N * inc (up or down depending on resize
 900          * type) if rounding up store amount
 901          */
 902         if (!(flags & CS_ROUND_UP))
 903         {
 904                 d.width = ((d.width - base.width) / inc.width) *
 905                         inc.width + base.width;
 906                 d.height = ((d.height - base.height) / inc.height) *
 907                         inc.height + base.height;
 908         }
 909         else
 910         {
 911                 round_up.width = d.width;
 912                 round_up.height = d.height;
 913                 d.width = ((d.width - base.width + inc.width - 1) /
 914                            inc.width) * inc.width + base.width;
 915                 d.height = ((d.height - base.height + inc.height - 1) /
 916                             inc.height) * inc.height + base.height;
 917                 round_up.width = d.width - round_up.width;
 918                 round_up.height = d.height - round_up.height;
 919         }
 920
 921         /*
 922          * Step 2a: check we didn't move the edge off screen in interactive
 923          * moves
 924          */
 925         if ((flags & CS_ROUND_UP) && e != NULL && e->type == MotionNotify)
 926         {
 927                 if (xmotion > 0 && e->xmotion.x_root < round_up.width)
 928                 {
 929                         d.width -= inc.width;
 930                 }
 931                 else if (
 932                         xmotion < 0 && e->xmotion.x_root >=
 933                         Scr.MyDisplayWidth - round_up.width)
 934                 {
 935                         d.width -= inc.width;
 936                 }
 937                 if (ymotion > 0 && e->xmotion.y_root < round_up.height)
 938                 {
 939                         d.height -= inc.height;
 940                 }
 941                 else if (
 942                         ymotion < 0 && e->xmotion.y_root >=
 943                         Scr.MyDisplayHeight - round_up.height)
 944                 {
 945                         d.height -= inc.height;
 946                 }
 947         }
 948
 949         /*
 950          * Step 2b: Check that we didn't violate min and max.
 951          */
 952         if (d.width < min.width)
 953         {
 954                 d.width += inc.width;
 955         }
 956         if (d.height < min.height)
 957         {
 958                 d.height += inc.height;
 959         }
 960         if (d.width > max.width)
 961         {
 962                 d.width -= inc.width;
 963         }
 964         if (d.height > max.height)
 965         {
 966                 d.height -= inc.height;
 967         }
 968
 969         /*
 970          * Third, adjust for aspect ratio
 971          */
 972         if (fw->hints.flags & PAspect)
 973         {
 974                 __cs_handle_aspect_ratio(
 975                         &d, fw, d, base, inc, min, max, xmotion, ymotion,
 976                         flags);
 977         }
 978
 979         /*
 980          * Fourth, account for border width and title height
 981          */
 982         *widthp = d.width + b.total_size.width;
 983         *heightp = d.height + b.total_size.height;
 984         if (IS_MAXIMIZED(fw) && (flags & CS_UPDATE_MAX_DEFECT))
 985         {
 986                 /* update size defect for maximized window */
 987                 fw->g.max_defect.width = old.width - *widthp;
 988                 fw->g.max_defect.height = old.height - *heightp;
 989         }
 990
 991         return;
 992 }
 993
 994 /* This function does roughly the same as constrain_size, but takes into account
 995  * that the window shifts according to gravity if constrain_size actually
 996  * changes the width or height. The frame_g of the window is not changed. The
 997  * target geometry is expected to be in *rect and will be retured through rect.
 998  */
 999 void gravity_constrain_size(
1000         int gravity, FvwmWindow *t, rectangle *rect, int flags)
1001 {
1002         int new_width = rect->width;
1003         int new_height = rect->height;
1004
1005         if (IS_MAXIMIZED(t) && (flags & CS_UPDATE_MAX_DEFECT))
1006         {
1007                 gravity_resize(
1008                         gravity, rect, t->g.max_defect.width,
1009                         t->g.max_defect.height);
1010                 t->g.max_defect.width = 0;
1011                 t->g.max_defect.height = 0;
1012                 new_width = rect->width;
1013                 new_height = rect->height;
1014         }
1015         constrain_size(
1016                 t, NULL, &new_width, &new_height, 0, 0, flags);
1017         if (rect->width != new_width || rect->height != new_height)
1018         {
1019                 gravity_resize(
1020                         gravity, rect, new_width - rect->width,
1021                         new_height - rect->height);
1022         }
1023
1024         return;
1025 }
1026
1027 /* returns the icon title geometry if it is visible */
1028 Bool get_visible_icon_title_geometry(
1029         FvwmWindow *fw, rectangle *ret_g)
1030 {
1031         if (HAS_NO_ICON_TITLE(fw) || IS_ICON_UNMAPPED(fw) ||
1032             !IS_ICONIFIED(fw))
1033         {
1034                 memset(ret_g, 0, sizeof(*ret_g));
1035                 return False;
1036         }
1037         *ret_g = fw->icon_g.title_w_g;
1038
1039         return True;
1040 }
1041
1042 /* returns the icon title geometry if it the icon title window exists */
1043 Bool get_icon_title_geometry(
1044         FvwmWindow *fw, rectangle *ret_g)
1045 {
1046         if (HAS_NO_ICON_TITLE(fw))
1047         {
1048                 memset(ret_g, 0, sizeof(*ret_g));
1049                 return False;
1050         }
1051         *ret_g = fw->icon_g.title_w_g;
1052
1053         return True;
1054 }
1055
1056 /* returns the icon picture geometry if it is visible */
1057 Bool get_visible_icon_picture_geometry(
1058         FvwmWindow *fw, rectangle *ret_g)
1059 {
1060         if (fw->icon_g.picture_w_g.width == 0 ||
1061             IS_ICON_UNMAPPED(fw) || !IS_ICONIFIED(fw))
1062         {
1063                 memset(ret_g, 0, sizeof(*ret_g));
1064                 return False;
1065         }
1066         *ret_g = fw->icon_g.picture_w_g;
1067
1068         return True;
1069 }
1070
1071 /* returns the icon picture geometry if it is exists */
1072 Bool get_icon_picture_geometry(
1073         FvwmWindow *fw, rectangle *ret_g)
1074 {
1075         if (fw->icon_g.picture_w_g.width == 0)
1076         {
1077                 memset(ret_g, 0, sizeof(*ret_g));
1078                 return False;
1079         }
1080         *ret_g = fw->icon_g.picture_w_g;
1081
1082         return True;
1083 }
1084
1085 /* returns the icon geometry (unexpanded title plus pixmap) if it is visible */
1086 Bool get_visible_icon_geometry(
1087         FvwmWindow *fw, rectangle *ret_g)
1088 {
1089         if (IS_ICON_UNMAPPED(fw) || !IS_ICONIFIED(fw))
1090         {
1091                 memset(ret_g, 0, sizeof(*ret_g));
1092                 return False;
1093         }
1094         if (fw->icon_g.picture_w_g.width > 0)
1095         {
1096                 *ret_g = fw->icon_g.picture_w_g;
1097                 if (!HAS_NO_ICON_TITLE(fw))
1098                 {
1099                         ret_g->height += fw->icon_g.title_w_g.height;
1100                 }
1101         }
1102         else if (!HAS_NO_ICON_TITLE(fw))
1103         {
1104                 *ret_g = fw->icon_g.title_w_g;
1105         }
1106         else
1107         {
1108                 memset(ret_g, 0, sizeof(*ret_g));
1109                 return False;
1110         }
1111
1112         return True;
1113 }
1114
1115 /* returns the icon geometry (unexpanded title plus pixmap) if it exists */
1116 void get_icon_geometry(
1117         FvwmWindow *fw, rectangle *ret_g)
1118 {
1119         /* valid geometry? */
1120         if (fw->icon_g.picture_w_g.width > 0)
1121         {
1122                 *ret_g = fw->icon_g.picture_w_g;
1123                 if (!HAS_NO_ICON_TITLE(fw))
1124                 {
1125                         ret_g->height += fw->icon_g.title_w_g.height;
1126                 }
1127         }
1128         else if (fw->icon_g.title_w_g.width > 0)
1129         {
1130                 *ret_g = fw->icon_g.title_w_g;
1131         }
1132         /* valid position? */
1133         else if (fw->icon_g.picture_w_g.x != 0 || fw->icon_g.picture_w_g.y != 0)
1134         {
1135                 *ret_g = fw->icon_g.picture_w_g;
1136         }
1137         else if (fw->icon_g.title_w_g.x != 0 || fw->icon_g.title_w_g.y != 0)
1138         {
1139                 *ret_g = fw->icon_g.title_w_g;
1140         }
1141         else
1142         {
1143                 memset(ret_g, 0, sizeof(*ret_g));
1144         }
1145
1146         return;
1147 }
1148
1149 /* Returns the visible geometry of a window or icon.  This can be used to test
1150  * if this region overlaps other windows. */
1151 Bool get_visible_window_or_icon_geometry(
1152         FvwmWindow *fw, rectangle *ret_g)
1153 {
1154         if (IS_ICONIFIED(fw))
1155         {
1156                 return get_visible_icon_geometry(fw, ret_g);
1157         }
1158         *ret_g = fw->g.frame;
1159
1160         return True;
1161 }
1162
1163 void move_icon_to_position(
1164         FvwmWindow *fw)
1165 {
1166         Bool draw_picture_w = False;
1167         Bool draw_title_w = False;
1168
1169         if (fw->icon_g.picture_w_g.width > 0)
1170         {
1171                 int cs;
1172
1173                 if (Scr.Hilite == fw)
1174                 {
1175                         cs = fw->cs_hi;
1176                 }
1177                 else
1178                 {
1179                         cs = fw->cs;
1180                 }
1181                 XMoveWindow(
1182                         dpy, FW_W_ICON_PIXMAP(fw),
1183                         fw->icon_g.picture_w_g.x,
1184                         fw->icon_g.picture_w_g.y);
1185                 if (fw->icon_alphaPixmap ||
1186                     (cs >= 0 && Colorset[cs].icon_alpha_percent < 100) ||
1187                     CSET_IS_TRANSPARENT(fw->icon_background_cs) ||
1188                     (!IS_ICON_SHAPED(fw) && fw->icon_background_padding > 0))
1189                 {
1190                         draw_picture_w = True;
1191                 }
1192         }
1193         if (!HAS_NO_ICON_TITLE(fw))
1194         {
1195                 int cs;
1196                 rectangle dummy;
1197
1198                 if (Scr.Hilite == fw)
1199                 {
1200                         cs = fw->icon_title_cs_hi;
1201                 }
1202                 else
1203                 {
1204                         cs = fw->icon_title_cs;
1205                 }
1206                 XMoveWindow(
1207                         dpy, FW_W_ICON_TITLE(fw),
1208                         fw->icon_g.title_w_g.x,
1209                         fw->icon_g.title_w_g.y);
1210                 if (CSET_IS_TRANSPARENT(cs) &&
1211                     !get_visible_icon_picture_geometry(fw, &dummy) &&
1212                     get_visible_icon_title_geometry(fw, &dummy))
1213                 {
1214                         draw_title_w = True;
1215                 }
1216         }
1217
1218         if (draw_title_w || draw_picture_w)
1219         {
1220                 DrawIconWindow(
1221                         fw, draw_title_w, draw_picture_w, False, draw_picture_w,
1222                         NULL);
1223         }
1224
1225         return;
1226 }
1227
1228 void broadcast_icon_geometry(
1229         FvwmWindow *fw, Bool do_force)
1230 {
1231         rectangle g;
1232         Bool rc;
1233
1234         rc = get_visible_icon_geometry(fw, &g);
1235         if (rc == True && (!IS_ICON_UNMAPPED(fw) || do_force == True))
1236         {
1237                 BroadcastPacket(
1238                         M_ICON_LOCATION, 7, (long)FW_W(fw),
1239                         (long)FW_W_FRAME(fw), (unsigned long)fw,
1240                         (long)g.x, (long)g.y, (long)g.width, (long)g.height);
1241         }
1242
1243         return;
1244 }
1245
1246 void modify_icon_position(
1247         FvwmWindow *fw, int dx, int dy)
1248 {
1249         if (fw->icon_g.picture_w_g.width > 0 || HAS_NO_ICON_TITLE(fw))
1250         {
1251                 /* picture position is also valid if there is neither a picture
1252                  * nor a title */
1253                 fw->icon_g.picture_w_g.x += dx;
1254                 fw->icon_g.picture_w_g.y += dy;
1255         }
1256         if (!HAS_NO_ICON_TITLE(fw))
1257         {
1258                 fw->icon_g.title_w_g.x += dx;
1259                 fw->icon_g.title_w_g.y += dy;
1260         }
1261
1262         return;
1263 }
1264
1265 /* set the icon position to the specified value. take care of the actual icon
1266  * layout */
1267 void set_icon_position(
1268         FvwmWindow *fw, int x, int y)
1269 {
1270         if (fw->icon_g.picture_w_g.width > 0)
1271         {
1272                 fw->icon_g.picture_w_g.x = x;
1273                 fw->icon_g.picture_w_g.y = y;
1274         }
1275         else
1276         {
1277                 fw->icon_g.picture_w_g.x = 0;
1278                 fw->icon_g.picture_w_g.y = 0;
1279         }
1280         if (!HAS_NO_ICON_TITLE(fw))
1281         {
1282                 fw->icon_g.title_w_g.x = x;
1283                 fw->icon_g.title_w_g.y = y;
1284         }
1285         else
1286         {
1287                 fw->icon_g.title_w_g.x = 0;
1288                 fw->icon_g.title_w_g.y = 0;
1289         }
1290         if (fw->icon_g.picture_w_g.width > 0 &&
1291             !HAS_NO_ICON_TITLE(fw))
1292         {
1293                 fw->icon_g.title_w_g.x -=
1294                         (fw->icon_g.title_w_g.width -
1295                          fw->icon_g.picture_w_g.width) / 2;
1296                 fw->icon_g.title_w_g.y +=
1297                         fw->icon_g.picture_w_g.height;
1298         }
1299         else if (fw->icon_g.picture_w_g.width <= 0 && HAS_NO_ICON_TITLE(fw))
1300         {
1301                 /* In case there is no icon, fake the icon position so the
1302                  * modules know where its window was iconified. */
1303                 fw->icon_g.picture_w_g.x = x;
1304                 fw->icon_g.picture_w_g.y = y;
1305         }
1306
1307         return;
1308 }
1309
1310 void set_icon_picture_size(
1311         FvwmWindow *fw, int w, int h)
1312 {
1313         if (fw->icon_g.picture_w_g.width > 0)
1314         {
1315                 fw->icon_g.picture_w_g.width = w;
1316                 fw->icon_g.picture_w_g.height = h;
1317         }
1318         else
1319         {
1320                 fw->icon_g.picture_w_g.width = 0;
1321                 fw->icon_g.picture_w_g.height = 0;
1322         }
1323
1324         return;
1325 }
1326
1327 void resize_icon_title_height(FvwmWindow *fw, int dh)
1328 {
1329         if (!HAS_NO_ICON_TITLE(fw))
1330         {
1331                 fw->icon_g.title_w_g.height += dh;
1332         }
1333
1334         return;
1335 }
1336
1337 void get_page_offset_rectangle(
1338         int *ret_page_x, int *ret_page_y, rectangle *r)
1339 {
1340         int xoff = Scr.Vx % Scr.MyDisplayWidth;
1341         int yoff = Scr.Vy % Scr.MyDisplayHeight;
1342
1343         /* maximize on the page where the center of the window is */
1344         *ret_page_x = truncate_to_multiple(
1345                 r->x + r->width / 2 + xoff, Scr.MyDisplayWidth) - xoff;
1346         *ret_page_y = truncate_to_multiple(
1347                 r->y + r->height / 2 + yoff, Scr.MyDisplayHeight) - yoff;
1348
1349         return;
1350 }
1351
1352 void get_page_offset(
1353         int *ret_page_x, int *ret_page_y, FvwmWindow *fw)
1354 {
1355         rectangle r;
1356
1357         r.x = fw->g.frame.x;
1358         r.y = fw->g.frame.y;
1359         r.width = fw->g.frame.width;
1360         r.height = fw->g.frame.height;
1361         get_page_offset_rectangle(ret_page_x, ret_page_y, &r);
1362
1363         return;
1364 }
1365
1366 void get_page_offset_check_visible(
1367         int *ret_page_x, int *ret_page_y, FvwmWindow *fw)
1368 {
1369         if (IsRectangleOnThisPage(&fw->g.frame, fw->Desk))
1370         {
1371                 /* maximize on visible page if any part of the window is
1372                  * visible */
1373                 *ret_page_x = 0;
1374                 *ret_page_y = 0;
1375         }
1376         else
1377         {
1378                 get_page_offset(ret_page_x, ret_page_y, fw);
1379         }
1380
1381         return;
1382 }
1383
1384 /* ---------------------------- builtin commands --------------------------- */