src/placement.c

   1 /* placement.c - window and icon placement on screen
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <X11/Xlib.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <limits.h>
  30
  31 #include "WindowMaker.h"
  32 #include "wcore.h"
  33 #include "framewin.h"
  34 #include "window.h"
  35 #include "icon.h"
  36 #include "appicon.h"
  37 #include "actions.h"
  38 #include "funcs.h"
  39 #include "application.h"
  40 #include "appicon.h"
  41 #include "dock.h"
  42 #include "xinerama.h"
  43
  44 extern WPreferences wPreferences;
  45
  46 #define X_ORIGIN WMAX(usableArea.x1,\
  47     wPreferences.window_place_origin.x)
  48
  49 #define Y_ORIGIN WMAX(usableArea.y1,\
  50     wPreferences.window_place_origin.y)
  51
  52 /* interactive window placement is in moveres.c */
  53 extern void InteractivePlaceWindow(WWindow *wwin, int *x_ret, int *y_ret,
  54                                    unsigned width, unsigned height);
  55
  56 /* Returns True if it is an icon and is in this workspace */
  57 static Bool
  58 iconPosition(WCoreWindow *wcore, int sx1, int sy1, int sx2, int sy2,
  59              int workspace, int *retX, int *retY)
  60 {
  61         void *parent;
  62         int ok = 0;
  63
  64         parent = wcore->descriptor.parent;
  65
  66         /* if it is an application icon */
  67         if (wcore->descriptor.parent_type == WCLASS_APPICON && !((WAppIcon *) parent)->docked) {
  68                 *retX = ((WAppIcon *) parent)->x_pos;
  69                 *retY = ((WAppIcon *) parent)->y_pos;
  70
  71                 ok = 1;
  72         } else if (wcore->descriptor.parent_type == WCLASS_MINIWINDOW &&
  73                    (((WIcon *) parent)->owner->frame->workspace == workspace
  74                     || IS_OMNIPRESENT(((WIcon *) parent)->owner)
  75                     || wPreferences.sticky_icons)
  76                    && ((WIcon *) parent)->mapped) {
  77
  78                 *retX = ((WIcon *) parent)->owner->icon_x;
  79                 *retY = ((WIcon *) parent)->owner->icon_y;
  80
  81                 ok = 1;
  82         } else if (wcore->descriptor.parent_type == WCLASS_WINDOW
  83                    && ((WWindow *) parent)->flags.icon_moved
  84                    && (((WWindow *) parent)->frame->workspace == workspace || IS_OMNIPRESENT((WWindow *) parent)
  85                        || wPreferences.sticky_icons)) {
  86                 *retX = ((WWindow *) parent)->icon_x;
  87                 *retY = ((WWindow *) parent)->icon_y;
  88
  89                 ok = 1;
  90         }
  91
  92         /* Check if it is inside the screen */
  93         if (ok) {
  94                 if (*retX < sx1 - wPreferences.icon_size)
  95                         ok = 0;
  96                 else if (*retX > sx2)
  97                         ok = 0;
  98
  99                 if (*retY < sy1 - wPreferences.icon_size)
 100                         ok = 0;
 101                 else if (*retY > sy2)
 102                         ok = 0;
 103         }
 104
 105         return ok;
 106 }
 107
 108 void PlaceIcon(WScreen *scr, int *x_ret, int *y_ret, int head)
 109 {
 110         int pf;                 /* primary axis */
 111         int sf;                 /* secondary axis */
 112         int fullW;
 113         int fullH;
 114         char *map;
 115         int pi, si;
 116         WCoreWindow *obj;
 117         int sx1, sx2, sy1, sy2; /* screen boundary */
 118         int sw, sh;
 119         int xo, yo;
 120         int xs, ys;
 121         int x, y;
 122         int isize = wPreferences.icon_size;
 123         int done = 0;
 124         WMBagIterator iter;
 125         WArea area = wGetUsableAreaForHead(scr, head, NULL, False);
 126
 127         /* Find out screen boundaries. */
 128
 129         /* Allows each head to have miniwindows */
 130         sx1 = area.x1;
 131         sy1 = area.y1;
 132         sx2 = area.x2;
 133         sy2 = area.y2;
 134         sw = sx2 - sx1;
 135         sh = sy2 - sy1;
 136
 137         sw = isize * (sw / isize);
 138         sh = isize * (sh / isize);
 139         fullW = (sx2 - sx1) / isize;
 140         fullH = (sy2 - sy1) / isize;
 141
 142         /* icon yard boundaries */
 143         if (wPreferences.icon_yard & IY_VERT) {
 144                 pf = fullH;
 145                 sf = fullW;
 146         } else {
 147                 pf = fullW;
 148                 sf = fullH;
 149         }
 150         if (wPreferences.icon_yard & IY_RIGHT) {
 151                 xo = sx2 - isize;
 152                 xs = -1;
 153         } else {
 154                 xo = sx1;
 155                 xs = 1;
 156         }
 157         if (wPreferences.icon_yard & IY_TOP) {
 158                 yo = sy1;
 159                 ys = 1;
 160         } else {
 161                 yo = sy2 - isize;
 162                 ys = -1;
 163         }
 164
 165         /*
 166          * Create a map with the occupied slots. 1 means the slot is used
 167          * or at least partially used.
 168          * The slot usage can be optimized by only marking fully used slots
 169          * or slots that have most of it covered.
 170          * Space usage is worse than the fvwm algorithm (used in the old version)
 171          * but complexity is much better (faster) than it.
 172          */
 173         map = wmalloc((sw + 2) * (sh + 2));
 174         memset(map, 0, (sw + 2) * (sh + 2));
 175
 176 #define INDEX(x,y)      (((y)+1)*(sw+2) + (x) + 1)
 177
 178         WM_ETARETI_BAG(scr->stacking_list, obj, iter) {
 179
 180                 while (obj) {
 181                         int x, y;
 182
 183                         if (iconPosition(obj, sx1, sy1, sx2, sy2, scr->current_workspace, &x, &y)) {
 184                                 int xdi, ydi;   /* rounded down */
 185                                 int xui, yui;   /* rounded up */
 186
 187                                 xdi = x / isize;
 188                                 ydi = y / isize;
 189                                 xui = (x + isize / 2) / isize;
 190                                 yui = (y + isize / 2) / isize;
 191                                 map[INDEX(xdi, ydi)] = 1;
 192                                 map[INDEX(xdi, yui)] = 1;
 193                                 map[INDEX(xui, ydi)] = 1;
 194                                 map[INDEX(xui, yui)] = 1;
 195                         }
 196                         obj = obj->stacking->under;
 197                 }
 198         }
 199         /* Default position */
 200         *x_ret = 0;
 201         *y_ret = 0;
 202
 203         /* Look for an empty slot */
 204         for (si = 0; si < sf; si++) {
 205                 for (pi = 0; pi < pf; pi++) {
 206                         if (wPreferences.icon_yard & IY_VERT) {
 207                                 x = xo + xs * (si * isize);
 208                                 y = yo + ys * (pi * isize);
 209                         } else {
 210                                 x = xo + xs * (pi * isize);
 211                                 y = yo + ys * (si * isize);
 212                         }
 213                         if (!map[INDEX(x / isize, y / isize)]) {
 214                                 *x_ret = x;
 215                                 *y_ret = y;
 216                                 done = 1;
 217                                 break;
 218                         }
 219                 }
 220                 if (done)
 221                         break;
 222         }
 223
 224         wfree(map);
 225 }
 226
 227 /* Computes the intersecting length of two line sections */
 228 int calcIntersectionLength(int p1, int l1, int p2, int l2)
 229 {
 230         int isect;
 231         int tmp;
 232
 233         if (p1 > p2) {
 234                 tmp = p1;
 235                 p1 = p2;
 236                 p2 = tmp;
 237                 tmp = l1;
 238                 l1 = l2;
 239                 l2 = tmp;
 240         }
 241
 242         if (p1 + l1 < p2)
 243                 isect = 0;
 244         else if (p2 + l2 < p1 + l1)
 245                 isect = l2;
 246         else
 247                 isect = p1 + l1 - p2;
 248
 249         return isect;
 250 }
 251
 252 /* Computes the intersecting area of two rectangles */
 253 int calcIntersectionArea(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2)
 254 {
 255         return calcIntersectionLength(x1, w1, x2, w2)
 256             * calcIntersectionLength(y1, h1, y2, h2);
 257 }
 258
 259 static int calcSumOfCoveredAreas(WWindow *wwin, int x, int y, int w, int h)
 260 {
 261         int sum_isect = 0;
 262         WWindow *test_window;
 263         int tw, tx, ty, th;
 264
 265         test_window = wwin->screen_ptr->focused_window;
 266         for (; test_window != NULL && test_window->prev != NULL;)
 267                 test_window = test_window->prev;
 268
 269         for (; test_window != NULL; test_window = test_window->next) {
 270                 if (test_window->frame->core->stacking->window_level < WMNormalLevel) {
 271                         continue;
 272                 }
 273
 274                 tw = test_window->frame->core->width;
 275                 th = test_window->frame->core->height;
 276                 tx = test_window->frame_x;
 277                 ty = test_window->frame_y;
 278
 279                 if (test_window->flags.mapped || (test_window->flags.shaded &&
 280                      test_window->frame->workspace == wwin->screen_ptr->current_workspace &&
 281                      !(test_window->flags.miniaturized || test_window->flags.hidden))) {
 282                         sum_isect += calcIntersectionArea(tx, ty, tw, th, x, y, w, h);
 283                 }
 284         }
 285
 286         return sum_isect;
 287 }
 288
 289 static void set_width_height(WWindow *wwin, unsigned int *width, unsigned int *height)
 290 {
 291         if (wwin->frame) {
 292                 *height += wwin->frame->top_width + wwin->frame->bottom_width;
 293         } else {
 294                 if (HAS_TITLEBAR(wwin))
 295                         *height += TITLEBAR_HEIGHT;
 296                 if (HAS_RESIZEBAR(wwin))
 297                         *height += RESIZEBAR_HEIGHT;
 298         }
 299         if (HAS_BORDER(wwin)) {
 300                 *height += 2 * FRAME_BORDER_WIDTH;
 301                 *width  += 2 * FRAME_BORDER_WIDTH;
 302         }
 303 }
 304
 305 static void
 306 smartPlaceWindow(WWindow *wwin, int *x_ret, int *y_ret, unsigned int width,
 307                  unsigned int height, WArea usableArea)
 308 {
 309         int test_x = 0, test_y = Y_ORIGIN;
 310         int from_x, to_x, from_y, to_y;
 311         int sx;
 312         int min_isect, min_isect_x, min_isect_y;
 313         int sum_isect;
 314
 315         set_width_height(wwin, &width, &height);
 316
 317         sx = X_ORIGIN;
 318         min_isect = INT_MAX;
 319         min_isect_x = sx;
 320         min_isect_y = test_y;
 321
 322         while (((test_y + height) < usableArea.y2)) {
 323                 test_x = sx;
 324                 while ((test_x + width) < usableArea.x2) {
 325                         sum_isect = calcSumOfCoveredAreas(wwin, test_x, test_y, width, height);
 326
 327                         if (sum_isect < min_isect) {
 328                                 min_isect = sum_isect;
 329                                 min_isect_x = test_x;
 330                                 min_isect_y = test_y;
 331                         }
 332
 333                         test_x += PLACETEST_HSTEP;
 334                 }
 335                 test_y += PLACETEST_VSTEP;
 336         }
 337
 338         from_x = min_isect_x - PLACETEST_HSTEP + 1;
 339         from_x = WMAX(from_x, X_ORIGIN);
 340         to_x = min_isect_x + PLACETEST_HSTEP;
 341         if (to_x + width > usableArea.x2)
 342                 to_x = usableArea.x2 - width;
 343
 344         from_y = min_isect_y - PLACETEST_VSTEP + 1;
 345         from_y = WMAX(from_y, Y_ORIGIN);
 346         to_y = min_isect_y + PLACETEST_VSTEP;
 347         if (to_y + height > usableArea.y2)
 348                 to_y = usableArea.y2 - height;
 349
 350         for (test_x = from_x; test_x < to_x; test_x++) {
 351                 for (test_y = from_y; test_y < to_y; test_y++) {
 352                         sum_isect = calcSumOfCoveredAreas(wwin, test_x, test_y, width, height);
 353
 354                         if (sum_isect < min_isect) {
 355                                 min_isect = sum_isect;
 356                                 min_isect_x = test_x;
 357                                 min_isect_y = test_y;
 358                         }
 359                 }
 360         }
 361
 362         *x_ret = min_isect_x;
 363         *y_ret = min_isect_y;
 364 }
 365
 366 static Bool
 367 autoPlaceWindow(WWindow *wwin, int *x_ret, int *y_ret,
 368                 unsigned int width, unsigned int height, int tryCount, WArea usableArea)
 369 {
 370         WScreen *scr = wwin->screen_ptr;
 371         int test_x = 0, test_y = Y_ORIGIN;
 372         int loc_ok = False, tw, tx, ty, th;
 373         int swidth, sx;
 374         WWindow *test_window;
 375
 376         set_width_height(wwin, &width, &height);
 377         swidth = usableArea.x2 - usableArea.x1;
 378         sx = X_ORIGIN;
 379
 380         /* this was based on fvwm2's smart placement */
 381         while (((test_y + height) < (usableArea.y2 - usableArea.y1)) && !loc_ok) {
 382                 test_x = sx;
 383
 384                 while (((test_x + width) < swidth) && (!loc_ok)) {
 385
 386                         loc_ok = True;
 387                         test_window = scr->focused_window;
 388
 389                         while ((test_window != NULL) && (loc_ok == True)) {
 390
 391                                 if (test_window->frame->core->stacking->window_level
 392                                     < WMNormalLevel && tryCount > 0) {
 393                                         test_window = test_window->next;
 394                                         continue;
 395                                 }
 396                                 tw = test_window->frame->core->width;
 397                                 th = test_window->frame->core->height;
 398                                 tx = test_window->frame_x;
 399                                 ty = test_window->frame_y;
 400
 401                                 if ((tx < (test_x + width)) && ((tx + tw) > test_x) &&
 402                                     (ty < (test_y + height)) && ((ty + th) > test_y) &&
 403                                     (test_window->flags.mapped ||
 404                                      (test_window->flags.shaded &&
 405                                       test_window->frame->workspace == scr->current_workspace &&
 406                                       !(test_window->flags.miniaturized || test_window->flags.hidden)))) {
 407
 408                                         loc_ok = False;
 409                                 }
 410                                 test_window = test_window->next;
 411                         }
 412
 413                         test_window = scr->focused_window;
 414
 415                         while ((test_window != NULL) && (loc_ok == True)) {
 416
 417                                 if (test_window->frame->core->stacking->window_level
 418                                     < WMNormalLevel && tryCount > 0) {
 419                                         test_window = test_window->prev;
 420                                         continue;
 421                                 }
 422                                 tw = test_window->frame->core->width;
 423                                 th = test_window->frame->core->height;
 424                                 tx = test_window->frame_x;
 425                                 ty = test_window->frame_y;
 426
 427                                 if ((tx < (test_x + width)) && ((tx + tw) > test_x) &&
 428                                     (ty < (test_y + height)) && ((ty + th) > test_y) &&
 429                                     (test_window->flags.mapped ||
 430                                      (test_window->flags.shaded &&
 431                                       test_window->frame->workspace == scr->current_workspace &&
 432                                       !(test_window->flags.miniaturized || test_window->flags.hidden)))) {
 433
 434                                         loc_ok = False;
 435                                 }
 436                                 test_window = test_window->prev;
 437                         }
 438                         if (loc_ok == True) {
 439                                 *x_ret = test_x;
 440                                 *y_ret = test_y;
 441                                 break;
 442                         }
 443                         test_x += PLACETEST_HSTEP;
 444                 }
 445                 test_y += PLACETEST_VSTEP;
 446         }
 447
 448         return loc_ok;
 449 }
 450
 451 static void
 452 cascadeWindow(WScreen *scr, WWindow *wwin, int *x_ret, int *y_ret,
 453               unsigned int width, unsigned int height, int h, WArea usableArea)
 454 {
 455         set_width_height(wwin, &width, &height);
 456
 457         *x_ret = h * scr->cascade_index + X_ORIGIN;
 458         *y_ret = h * scr->cascade_index + Y_ORIGIN;
 459
 460         if (width + *x_ret > usableArea.x2 || height + *y_ret > usableArea.y2) {
 461                 scr->cascade_index = 0;
 462                 *x_ret = X_ORIGIN;
 463                 *y_ret = Y_ORIGIN;
 464         }
 465 }
 466
 467 static void randomPlaceWindow(WWindow *wwin, int *x_ret, int *y_ret,
 468                   unsigned int width, unsigned int height, WArea usableArea)
 469 {
 470         int w, h;
 471
 472         set_width_height(wwin, &width, &height);
 473
 474         w = ((usableArea.x2 - X_ORIGIN) - width);
 475         h = ((usableArea.y2 - Y_ORIGIN) - height);
 476         if (w < 1)
 477                 w = 1;
 478         if (h < 1)
 479                 h = 1;
 480         *x_ret = X_ORIGIN + rand() % w;
 481         *y_ret = Y_ORIGIN + rand() % h;
 482 }
 483
 484 void PlaceWindow(WWindow *wwin, int *x_ret, int *y_ret, unsigned width, unsigned height)
 485 {
 486         WScreen *scr = wwin->screen_ptr;
 487         int h = WMFontHeight(scr->title_font)
 488                 + (wPreferences.window_title_clearance + TITLEBAR_EXTEND_SPACE) * 2;
 489         WArea usableArea = wGetUsableAreaForHead(scr, wGetHeadForPointerLocation(scr),
 490                                                  NULL, True);
 491
 492         switch (wPreferences.window_placement) {
 493         case WPM_MANUAL:
 494                 InteractivePlaceWindow(wwin, x_ret, y_ret, width, height);
 495                 break;
 496
 497         case WPM_SMART:
 498                 smartPlaceWindow(wwin, x_ret, y_ret, width, height, usableArea);
 499                 break;
 500
 501         case WPM_AUTO:
 502                 if (autoPlaceWindow(wwin, x_ret, y_ret, width, height, 0, usableArea)) {
 503                         break;
 504                 } else if (autoPlaceWindow(wwin, x_ret, y_ret, width, height, 1, usableArea)) {
 505                         break;
 506                 }
 507                 /* there isn't a break here, because if we fail, it should fall
 508                    through to cascade placement, as people who want tiling want
 509                    automagicness aren't going to want to place their window */
 510
 511         case WPM_CASCADE:
 512                 if (wPreferences.window_placement == WPM_AUTO)
 513                         scr->cascade_index++;
 514
 515                 cascadeWindow(scr, wwin, x_ret, y_ret, width, height, h, usableArea);
 516
 517                 if (wPreferences.window_placement == WPM_CASCADE)
 518                         scr->cascade_index++;
 519                 break;
 520
 521         case WPM_RANDOM:
 522                 randomPlaceWindow(wwin, x_ret, y_ret, width, height, usableArea);
 523                 break;
 524         }
 525
 526         /*
 527          * clip to usableArea instead of full screen
 528          * this will also take dock/clip etc.. into account
 529          * aswell as being xinerama friendly
 530          */
 531         if (*x_ret + width > usableArea.x2)
 532                 *x_ret = usableArea.x2 - width;
 533         if (*x_ret < usableArea.x1)
 534                 *x_ret = usableArea.x1;
 535
 536         if (*y_ret + height > usableArea.y2)
 537                 *y_ret = usableArea.y2 - height;
 538         if (*y_ret < usableArea.y1)
 539                 *y_ret = usableArea.y1;
 540 }