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
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  */
  21
  22
  23 #include "wconfig.h"
  24
  25
  26 #include "xinerama.h"
  27
  28 #include "screen.h"
  29 #include "window.h"
  30 #include "framewin.h"
  31 #include "wcore.h"
  32 #include "funcs.h"
  33
  34 #ifdef XINERAMA
  35 # ifdef SOLARIS_XINERAMA /* sucks */
  36 #  define <X11/extensions/xinerama.h>
  37 # else
  38 #  include <X11/extensions/Xinerama.h>
  39 # endif
  40 #endif
  41
  42
  43
  44 void
  45 wInitXinerama(WScreen *scr)
  46 {
  47     scr->xine_info.primary_head = 0;
  48     scr->xine_info.screens = NULL;
  49     scr->xine_info.count = 0;
  50 #ifdef XINERAMA
  51 # ifdef SOLARIS_XINERAMA
  52     if (XineramaGetState(dpy, scr->screen)) {
  53         WXineramaInfo *info = &scr->xine_info;
  54         XRectangle header[MAXFRAMEBUFFERS];
  55         unsigned char hints[MAXFRAMEBUFFERS];
  56         int i;
  57
  58         if (XineramaGetInfo(dpy, scr->screen, header, hints,
  59                             &info->count)) {
  60
  61             info->screens = wmalloc(sizeof(WMRect)*(info->count+1));
  62
  63             for (i=0; i<info->count; i++) {
  64                 info->screens[i].pos.x = head[i].x;
  65                 info->screens[i].pos.y = head[i].y;
  66                 info->screens[i].size.width = head[i].width;
  67                 info->screens[i].size.height = head[i].height;
  68             }
  69         }
  70     }
  71 # else /* !SOLARIS_XINERAMA */
  72     if (XineramaIsActive(dpy)) {
  73         XineramaInfo *xine_screens;
  74         WXineramaInfo *info = &scr->xine_info;
  75         int i;
  76
  77         xine_screens = XineramaQueryScreens(dpy, &info->count);
  78
  79         info->screens = wmalloc(sizeof(WMRect)*(info->count+1));
  80
  81         for (i=0; i<info->count; i++) {
  82             info->screens[i].pos.x = info->screens[i].x_org;
  83             info->screens[i].pos.y = info->screens[i].y_org;
  84             info->screens[i].size.width = info->screens[i].width;
  85             info->screens[i].size.height = info->screens[i].height;
  86         }
  87         XFree(xine_screens);
  88     }
  89 # endif /* !SOLARIS_XINERAMA */
  90 #endif /* XINERAMA */
  91 }
  92
  93
  94 int
  95 wGetRectPlacementInfo(WScreen *scr, WMRect rect, int *flags)
  96 {
  97     int best;
  98     unsigned long area, totalArea;
  99     int i;
 100     int rx = rect.pos.x;
 101     int ry = rect.pos.y;
 102     int rw = rect.size.width;
 103     int rh = rect.size.height;
 104
 105     wassertrv(flags!=NULL, 0);
 106
 107     best = -1;
 108     area = 0;
 109     totalArea = 0;
 110
 111     *flags = XFLAG_NONE;
 112
 113     if (scr->xine_info.count <= 1) {
 114         unsigned long a;
 115
 116         a = calcIntersectionArea(rx, ry, rw, rh,
 117                                  0, 0, scr->scr_width, scr->scr_height);
 118
 119         if (a == 0) {
 120             *flags |= XFLAG_DEAD;
 121         } else if (a != rw*rh) {
 122             *flags |= XFLAG_PARTIAL;
 123         }
 124
 125         return scr->xine_info.primary_head;
 126     }
 127
 128     for (i = 0; i < scr->xine_info.count; i++) {
 129         unsigned long a;
 130
 131         a = calcIntersectionArea(rx, ry, rw, rh,
 132                                  scr->xine_info.screens[i].pos.x,
 133                                  scr->xine_info.screens[i].pos.y,
 134                                  scr->xine_info.screens[i].size.width,
 135                                  scr->xine_info.screens[i].size.height);
 136
 137         totalArea += a;
 138         if (a > area) {
 139             if ( best != -1)
 140                 *flags |= XFLAG_MULTIPLE;
 141             area = a;
 142             best = i;
 143         }
 144     }
 145
 146     if ( best == -1) {
 147         *flags |= XFLAG_DEAD;
 148         best = wGetHeadForPointerLocation(scr);
 149     } else if ( totalArea != rw*rh)
 150         *flags |= XFLAG_PARTIAL;
 151
 152     return best;
 153 }
 154
 155
 156
 157 /* get the head that covers most of the rectangle */
 158 int
 159 wGetHeadForRect(WScreen *scr, WMRect rect)
 160 {
 161     int best;
 162     unsigned long area;
 163     int i;
 164     int rx = rect.pos.x;
 165     int ry = rect.pos.y;
 166     int rw = rect.size.width;
 167     int rh = rect.size.height;
 168
 169     if (!scr->xine_info.count)
 170         return scr->xine_info.primary_head;
 171
 172     best = -1;
 173     area = 0;
 174
 175     for (i = 0; i < scr->xine_info.count; i++) {
 176         unsigned long a;
 177
 178         a = calcIntersectionArea(rx, ry, rw, rh,
 179                                  scr->xine_info.screens[i].pos.x,
 180                                  scr->xine_info.screens[i].pos.y,
 181                                  scr->xine_info.screens[i].size.width,
 182                                  scr->xine_info.screens[i].size.height);
 183
 184         if (a > area) {
 185             area = a;
 186             best = i;
 187         }
 188     }
 189
 190     /*
 191      * in case rect is in dead space, return valid head
 192      */
 193     if (best == -1)
 194         best = wGetHeadForPointerLocation(scr);
 195
 196     return best;
 197 }
 198
 199
 200 int
 201 wGetHeadForWindow(WWindow *wwin)
 202 {
 203     WMRect rect;
 204
 205     rect.pos.x = wwin->frame_x;
 206     rect.pos.y = wwin->frame_y;
 207     rect.size.width = wwin->frame->core->width;
 208     rect.size.height = wwin->frame->core->height;
 209
 210     return wGetHeadForRect(wwin->screen_ptr, rect);
 211 }
 212
 213
 214 /*
 215 int wGetHeadForPoint(WScreen *scr, WMPoint point, int *flags)
 216 {
 217     int i;
 218
 219     // paranoia
 220     if ( flags == NULL) {
 221         static int tmp;
 222         flags = &tmp;
 223     }
 224     *flags = XFLAG_NONE;
 225
 226     for (i = 0; i < scr->xine_info.count; i++) {
 227 #if 0
 228         int yy, xx;
 229
 230         xx = scr->xine_info.screens[i].pos.x + scr->xine_info.screens[i].size.width;
 231         yy = scr->xine_info.screens[i].pos.y + scr->xine_info.screens[i].size.height;
 232         if (point.x >= scr->xine_info.screens[i].pos.x &&
 233             point.y >= scr->xine_info.screens[i].pos.y &&
 234             point.x < xx && point.y < yy) {
 235             return i;
 236         }
 237 #else
 238         XineramaScreenInfo *xsi = &scr->xine_info.screens[i];
 239
 240         if ((unsigned)(point.x - xsi->x_org) < xsi->width &&
 241             (unsigned)(point.y - xsi->y_org) < xsi->height)
 242             return i;
 243 #endif
 244     }
 245
 246     *flags |= XFLAG_DEAD;
 247
 248     return scr->xine_primary_head;
 249 }
 250 */
 251
 252
 253
 254 int
 255 wGetHeadForPoint(WScreen *scr, WMPoint point)
 256 {
 257     int i;
 258
 259     for (i = 0; i < scr->xine_info.count; i++) {
 260         WMRect *rect = &scr->xine_info.screens[i];
 261
 262         if ((unsigned)(point.x - rect->pos.x) < rect->size.width &&
 263             (unsigned)(point.y - rect->pos.y) < rect->size.height)
 264             return i;
 265     }
 266     return scr->xine_info.primary_head;
 267 }
 268
 269
 270 int
 271 wGetHeadForPointerLocation(WScreen *scr)
 272 {
 273     WMPoint point;
 274     Window bla;
 275     int ble;
 276     unsigned int blo;
 277
 278     if (!scr->xine_info.count)
 279         return scr->xine_info.primary_head;
 280
 281     if (!XQueryPointer(dpy, scr->root_win, &bla, &bla,
 282                        &point.x, &point.y,
 283                        &ble, &ble,
 284                        &blo))
 285         return scr->xine_info.primary_head;
 286
 287     return wGetHeadForPoint(scr, point);
 288 }
 289
 290 /* get the dimensions of the head */
 291 WMRect
 292 wGetRectForHead(WScreen *scr, int head)
 293 {
 294     WMRect rect;
 295
 296     if (head < scr->xine_info.count) {
 297         rect.pos.x = scr->xine_info.screens[head].pos.x;
 298         rect.pos.y = scr->xine_info.screens[head].pos.y;
 299         rect.size.width = scr->xine_info.screens[head].size.width;
 300         rect.size.height = scr->xine_info.screens[head].size.height;
 301     } else
 302     {
 303         rect.pos.x = 0;
 304         rect.pos.y = 0;
 305         rect.size.width = scr->scr_width;
 306         rect.size.height = scr->scr_height;
 307     }
 308
 309     return rect;
 310 }
 311
 312
 313
 314 WArea
 315 wGetUsableAreaForHead(WScreen *scr, int head, WArea *totalAreaPtr)
 316 {
 317     WArea totalArea, usableArea = scr->totalUsableArea;
 318     WMRect rect = wGetRectForHead(scr, head);
 319
 320     totalArea.x1 = rect.pos.x;
 321     totalArea.y1 = rect.pos.y;
 322     totalArea.x2 = totalArea.x1 + rect.size.width;
 323     totalArea.y2 = totalArea.y1 + rect.size.height;
 324
 325     if (totalAreaPtr != NULL) *totalAreaPtr = totalArea;
 326
 327     usableArea.x1 = WMAX(totalArea.x1, usableArea.x1);
 328     usableArea.y1 = WMAX(totalArea.y1, usableArea.y1);
 329     usableArea.x2 = WMIN(totalArea.x2, usableArea.x2);
 330     usableArea.y2 = WMIN(totalArea.y2, usableArea.y2);
 331
 332     return usableArea;
 333 }
 334
 335
 336 WMPoint
 337 wGetPointToCenterRectInHead(WScreen *scr, int head, int width, int height)
 338 {
 339     WMPoint p;
 340     WMRect rect = wGetRectForHead(scr, head);
 341
 342     p.x = rect.pos.x + (rect.size.width - width)/2;
 343     p.y = rect.pos.y + (rect.size.height - height)/2;
 344
 345     return p;
 346 }
 347