src/xinerama.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License along
  17  *  with this program; if not, write to the Free Software Foundation, Inc.,
  18  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include "wconfig.h"
  22
  23 #include "xinerama.h"
  24
  25 #include "screen.h"
  26 #include "window.h"
  27 #include "framewin.h"
  28 #include "placement.h"
  29
  30 #ifdef XINERAMA
  31 # ifdef SOLARIS_XINERAMA        /* sucks */
  32 #  include <X11/extensions/xinerama.h>
  33 # else
  34 #  include <X11/extensions/Xinerama.h>
  35 # endif
  36 #endif
  37
  38 void wInitXinerama(WScreen * scr)
  39 {
  40         scr->xine_info.primary_head = 0;
  41         scr->xine_info.screens = NULL;
  42         scr->xine_info.count = 0;
  43 #ifdef XINERAMA
  44 # ifdef SOLARIS_XINERAMA
  45         if (XineramaGetState(dpy, scr->screen)) {
  46                 WXineramaInfo *info = &scr->xine_info;
  47                 XRectangle head[MAXFRAMEBUFFERS];
  48                 unsigned char hints[MAXFRAMEBUFFERS];
  49                 int i;
  50
  51                 if (XineramaGetInfo(dpy, scr->screen, head, hints, &info->count)) {
  52
  53                         info->screens = wmalloc(sizeof(WMRect) * (info->count + 1));
  54
  55                         for (i = 0; i < info->count; i++) {
  56                                 info->screens[i].pos.x = head[i].x;
  57                                 info->screens[i].pos.y = head[i].y;
  58                                 info->screens[i].size.width = head[i].width;
  59                                 info->screens[i].size.height = head[i].height;
  60                         }
  61                 }
  62         }
  63 # else                          /* !SOLARIS_XINERAMA */
  64         if (XineramaIsActive(dpy)) {
  65                 XineramaScreenInfo *xine_screens;
  66                 WXineramaInfo *info = &scr->xine_info;
  67                 int i;
  68
  69                 xine_screens = XineramaQueryScreens(dpy, &info->count);
  70
  71                 info->screens = wmalloc(sizeof(WMRect) * (info->count + 1));
  72
  73                 for (i = 0; i < info->count; i++) {
  74                         info->screens[i].pos.x = xine_screens[i].x_org;
  75                         info->screens[i].pos.y = xine_screens[i].y_org;
  76                         info->screens[i].size.width = xine_screens[i].width;
  77                         info->screens[i].size.height = xine_screens[i].height;
  78                 }
  79                 XFree(xine_screens);
  80         }
  81 # endif                         /* !SOLARIS_XINERAMA */
  82 #endif                          /* XINERAMA */
  83 }
  84
  85 int wGetRectPlacementInfo(WScreen * scr, WMRect rect, int *flags)
  86 {
  87         int best;
  88         unsigned long area, totalArea;
  89         int i;
  90         int rx = rect.pos.x;
  91         int ry = rect.pos.y;
  92         int rw = rect.size.width;
  93         int rh = rect.size.height;
  94
  95         wassertrv(flags != NULL, 0);
  96
  97         best = -1;
  98         area = 0;
  99         totalArea = 0;
 100
 101         *flags = XFLAG_NONE;
 102
 103         if (scr->xine_info.count <= 1) {
 104                 unsigned long a;
 105
 106                 a = calcIntersectionArea(rx, ry, rw, rh, 0, 0, scr->scr_width, scr->scr_height);
 107
 108                 if (a == 0) {
 109                         *flags |= XFLAG_DEAD;
 110                 } else if (a != rw * rh) {
 111                         *flags |= XFLAG_PARTIAL;
 112                 }
 113
 114                 return scr->xine_info.primary_head;
 115         }
 116
 117         for (i = 0; i < wXineramaHeads(scr); i++) {
 118                 unsigned long a;
 119
 120                 a = calcIntersectionArea(rx, ry, rw, rh,
 121                                          scr->xine_info.screens[i].pos.x,
 122                                          scr->xine_info.screens[i].pos.y,
 123                                          scr->xine_info.screens[i].size.width,
 124                                          scr->xine_info.screens[i].size.height);
 125
 126                 totalArea += a;
 127                 if (a > area) {
 128                         if (best != -1)
 129                                 *flags |= XFLAG_MULTIPLE;
 130                         area = a;
 131                         best = i;
 132                 }
 133         }
 134
 135         if (best == -1) {
 136                 *flags |= XFLAG_DEAD;
 137                 best = wGetHeadForPointerLocation(scr);
 138         } else if (totalArea != rw * rh)
 139                 *flags |= XFLAG_PARTIAL;
 140
 141         return best;
 142 }
 143
 144 /* get the head that covers most of the rectangle */
 145 int wGetHeadForRect(WScreen * scr, WMRect rect)
 146 {
 147         int best;
 148         unsigned long area;
 149         int i;
 150         int rx = rect.pos.x;
 151         int ry = rect.pos.y;
 152         int rw = rect.size.width;
 153         int rh = rect.size.height;
 154
 155         if (!scr->xine_info.count)
 156                 return scr->xine_info.primary_head;
 157
 158         best = -1;
 159         area = 0;
 160
 161         for (i = 0; i < wXineramaHeads(scr); i++) {
 162                 unsigned long a;
 163
 164                 a = calcIntersectionArea(rx, ry, rw, rh,
 165                                          scr->xine_info.screens[i].pos.x,
 166                                          scr->xine_info.screens[i].pos.y,
 167                                          scr->xine_info.screens[i].size.width,
 168                                          scr->xine_info.screens[i].size.height);
 169
 170                 if (a > area) {
 171                         area = a;
 172                         best = i;
 173                 }
 174         }
 175
 176         /*
 177          * in case rect is in dead space, return valid head
 178          */
 179         if (best == -1)
 180                 best = wGetHeadForPointerLocation(scr);
 181
 182         return best;
 183 }
 184
 185 Bool wWindowTouchesHead(WWindow * wwin, int head)
 186 {
 187         WScreen *scr;
 188         WMRect rect;
 189         int a;
 190
 191         if (!wwin || !wwin->frame)
 192                 return False;
 193
 194         scr = wwin->screen_ptr;
 195         rect = wGetRectForHead(scr, head);
 196         a = calcIntersectionArea(wwin->frame_x, wwin->frame_y,
 197                                  wwin->frame->core->width,
 198                                  wwin->frame->core->height,
 199                                  rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
 200
 201         return (a != 0);
 202 }
 203
 204 Bool wAppIconTouchesHead(WAppIcon * aicon, int head)
 205 {
 206         WScreen *scr;
 207         WMRect rect;
 208         int a;
 209
 210         if (!aicon || !aicon->icon)
 211                 return False;
 212
 213         scr = aicon->icon->core->screen_ptr;
 214         rect = wGetRectForHead(scr, head);
 215         a = calcIntersectionArea(aicon->x_pos, aicon->y_pos,
 216                                  aicon->icon->core->width,
 217                                  aicon->icon->core->height,
 218                                  rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
 219
 220         return (a != 0);
 221 }
 222
 223 int wGetHeadForWindow(WWindow * wwin)
 224 {
 225         WMRect rect;
 226
 227         if (wwin == NULL || wwin->frame == NULL)
 228                 return 0;
 229
 230         rect.pos.x = wwin->frame_x;
 231         rect.pos.y = wwin->frame_y;
 232         rect.size.width = wwin->frame->core->width;
 233         rect.size.height = wwin->frame->core->height;
 234
 235         return wGetHeadForRect(wwin->screen_ptr, rect);
 236 }
 237
 238 int wGetHeadForPoint(WScreen * scr, WMPoint point)
 239 {
 240         int i;
 241
 242         for (i = 0; i < scr->xine_info.count; i++) {
 243                 WMRect *rect = &scr->xine_info.screens[i];
 244
 245                 if ((unsigned)(point.x - rect->pos.x) < rect->size.width &&
 246                     (unsigned)(point.y - rect->pos.y) < rect->size.height)
 247                         return i;
 248         }
 249         return scr->xine_info.primary_head;
 250 }
 251
 252 int wGetHeadForPointerLocation(WScreen * scr)
 253 {
 254         WMPoint point;
 255         Window bla;
 256         int ble;
 257         unsigned int blo;
 258
 259         if (!scr->xine_info.count)
 260                 return scr->xine_info.primary_head;
 261
 262         if (!XQueryPointer(dpy, scr->root_win, &bla, &bla, &point.x, &point.y, &ble, &ble, &blo))
 263                 return scr->xine_info.primary_head;
 264
 265         return wGetHeadForPoint(scr, point);
 266 }
 267
 268 /* get the dimensions of the head */
 269 WMRect wGetRectForHead(WScreen * scr, int head)
 270 {
 271         WMRect rect;
 272
 273         if (head < scr->xine_info.count) {
 274                 rect.pos.x = scr->xine_info.screens[head].pos.x;
 275                 rect.pos.y = scr->xine_info.screens[head].pos.y;
 276                 rect.size.width = scr->xine_info.screens[head].size.width;
 277                 rect.size.height = scr->xine_info.screens[head].size.height;
 278         } else {
 279                 rect.pos.x = 0;
 280                 rect.pos.y = 0;
 281                 rect.size.width = scr->scr_width;
 282                 rect.size.height = scr->scr_height;
 283         }
 284
 285         return rect;
 286 }
 287
 288 WArea wGetUsableAreaForHead(WScreen * scr, int head, WArea * totalAreaPtr, Bool noicons)
 289 {
 290         WArea totalArea, usableArea;
 291         WMRect rect = wGetRectForHead(scr, head);
 292
 293         totalArea.x1 = rect.pos.x;
 294         totalArea.y1 = rect.pos.y;
 295         totalArea.x2 = totalArea.x1 + rect.size.width;
 296         totalArea.y2 = totalArea.y1 + rect.size.height;
 297
 298         if (totalAreaPtr != NULL)
 299                 *totalAreaPtr = totalArea;
 300
 301         if (head < wXineramaHeads(scr)) {
 302                 usableArea = noicons ? scr->totalUsableArea[head] : scr->usableArea[head];
 303         } else
 304                 usableArea = totalArea;
 305
 306         return usableArea;
 307 }
 308
 309 WMPoint wGetPointToCenterRectInHead(WScreen * scr, int head, int width, int height)
 310 {
 311         WMPoint p;
 312         WMRect rect = wGetRectForHead(scr, head);
 313
 314         p.x = rect.pos.x + (rect.size.width - width) / 2;
 315         p.y = rect.pos.y + (rect.size.height - height) / 2;
 316
 317         return p;
 318 }