src/xinerama.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2001 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 #include <X11/extensions/Xinerama.h>
  36 #endif
  37
  38 void
  39 wInitXinerama(WScreen *scr)
  40 {
  41     scr->xine_primary_head = 0;
  42 #ifdef XINERAMA
  43     scr->xine_screens = XineramaQueryScreens(dpy, &scr->xine_count);
  44 #else
  45     scr->xine_count = 0;
  46 #endif
  47 }
  48
  49
  50 int
  51 wGetRectPlacementInfo(WScreen *scr, WMRect rect, int *flags)
  52 {
  53     int best;
  54     unsigned long area, totalArea;
  55     int i;
  56     int rx = rect.pos.x;
  57     int ry = rect.pos.y;
  58     int rw = rect.size.width;
  59     int rh = rect.size.height;
  60
  61     wassertrv(flags!=NULL, 0);
  62
  63     best = -1;
  64     area = 0;
  65     totalArea = 0;
  66
  67     *flags = XFLAG_NONE;
  68
  69     if (scr->xine_count <= 1) {
  70         unsigned long a;
  71
  72         a = calcIntersectionArea(rx, ry, rw, rh,
  73                                  0, 0, scr->scr_width, scr->scr_height);
  74
  75         if (a == 0) {
  76             *flags |= XFLAG_DEAD;
  77         } else if (a != rw*rh) {
  78             *flags |= XFLAG_PARTIAL;
  79         }
  80
  81         return scr->xine_primary_head;
  82     }
  83
  84 #ifdef XINERAMA
  85     for (i = 0; i < scr->xine_count; i++) {
  86         unsigned long a;
  87
  88         a = calcIntersectionArea(rx, ry, rw, rh,
  89                                  scr->xine_screens[i].x_org,
  90                                  scr->xine_screens[i].y_org,
  91                                  scr->xine_screens[i].width,
  92                                  scr->xine_screens[i].height);
  93
  94         totalArea += a;
  95         if (a > area) {
  96             if ( best != -1)
  97                 *flags |= XFLAG_MULTIPLE;
  98             area = a;
  99             best = i;
 100         }
 101     }
 102
 103     if ( best == -1) {
 104         *flags |= XFLAG_DEAD;
 105         best = wGetHeadForPointerLocation(scr);
 106     } else if ( totalArea != rw*rh)
 107         *flags |= XFLAG_PARTIAL;
 108
 109     return best;
 110 #endif
 111 }
 112
 113
 114
 115 /* get the head that covers most of the rectangle */
 116 int
 117 wGetHeadForRect(WScreen *scr, WMRect rect)
 118 {
 119 #ifdef XINERAMA
 120     int best;
 121     unsigned long area;
 122     int i;
 123     int rx = rect.pos.x;
 124     int ry = rect.pos.y;
 125     int rw = rect.size.width;
 126     int rh = rect.size.height;
 127
 128     if (!scr->xine_count)
 129         return scr->xine_primary_head;
 130
 131     best = -1;
 132     area = 0;
 133
 134     for (i = 0; i < scr->xine_count; i++) {
 135         unsigned long a;
 136
 137         a = calcIntersectionArea(rx, ry, rw, rh,
 138                                  scr->xine_screens[i].x_org,
 139                                  scr->xine_screens[i].y_org,
 140                                  scr->xine_screens[i].width,
 141                                  scr->xine_screens[i].height);
 142
 143         if (a > area) {
 144             area = a;
 145             best = i;
 146         }
 147     }
 148
 149     /*
 150      * in case rect is in dead space, return valid head
 151      */
 152     if (best == -1)
 153         best = wGetHeadForPointerLocation(scr);
 154
 155     return best;
 156 #else /* !XINERAMA */
 157     return scr->xine_primary_head;
 158 #endif /* !XINERAMA */
 159 }
 160
 161
 162 int
 163 wGetHeadForWindow(WWindow *wwin)
 164 {
 165     WMRect rect;
 166
 167     rect.pos.x = wwin->frame_x;
 168     rect.pos.y = wwin->frame_y;
 169     rect.size.width = wwin->frame->core->width;
 170     rect.size.height = wwin->frame->core->height;
 171
 172     return wGetHeadForRect(wwin->screen_ptr, rect);
 173 }
 174
 175
 176 /*
 177 int wGetHeadForPoint(WScreen *scr, WMPoint point, int *flags)
 178 {
 179     int i;
 180
 181     // paranoia
 182     if ( flags == NULL) {
 183         static int tmp;
 184         flags = &tmp;
 185     }
 186     *flags = XFLAG_NONE;
 187
 188     for (i = 0; i < scr->xine_count; i++) {
 189 #if 0
 190         int yy, xx;
 191
 192         xx = scr->xine_screens[i].x_org + scr->xine_screens[i].width;
 193         yy = scr->xine_screens[i].y_org + scr->xine_screens[i].height;
 194         if (point.x >= scr->xine_screens[i].x_org &&
 195             point.y >= scr->xine_screens[i].y_org &&
 196             point.x < xx && point.y < yy) {
 197             return i;
 198         }
 199 #else
 200         XineramaScreenInfo *xsi = &scr->xine_screens[i];
 201
 202         if ((unsigned)(point.x - xsi->x_org) < xsi->width &&
 203             (unsigned)(point.y - xsi->y_org) < xsi->height)
 204             return i;
 205 #endif
 206     }
 207
 208     *flags |= XFLAG_DEAD;
 209
 210     return scr->xine_primary_head;
 211 }
 212 */
 213
 214
 215
 216 int
 217 wGetHeadForPoint(WScreen *scr, WMPoint point)
 218 {
 219 #ifdef XINERAMA
 220     int i;
 221
 222     for (i = 0; i < scr->xine_count; i++) {
 223         XineramaScreenInfo *xsi = &scr->xine_screens[i];
 224
 225         if ((unsigned)(point.x - xsi->x_org) < xsi->width &&
 226             (unsigned)(point.y - xsi->y_org) < xsi->height)
 227             return i;
 228     }
 229 #endif /* XINERAMA */
 230     return scr->xine_primary_head;
 231 }
 232
 233
 234 int
 235 wGetHeadForPointerLocation(WScreen *scr)
 236 {
 237     WMPoint point;
 238     Window bla;
 239     int ble;
 240     unsigned int blo;
 241
 242     if (!scr->xine_count)
 243         return scr->xine_primary_head;
 244
 245     if (!XQueryPointer(dpy, scr->root_win, &bla, &bla,
 246                        &point.x, &point.y,
 247                        &ble, &ble,
 248                        &blo))
 249         return scr->xine_primary_head;
 250
 251     return wGetHeadForPoint(scr, point);
 252 }
 253
 254 /* get the dimensions of the head */
 255 WMRect
 256 wGetRectForHead(WScreen *scr, int head)
 257 {
 258     WMRect rect;
 259
 260 #ifdef XINERAMA
 261     if (head < scr->xine_count) {
 262         rect.pos.x = scr->xine_screens[head].x_org;
 263         rect.pos.y = scr->xine_screens[head].y_org;
 264         rect.size.width = scr->xine_screens[head].width;
 265         rect.size.height = scr->xine_screens[head].height;
 266     } else
 267 #endif /* XINERAMA */
 268     {
 269         rect.pos.x = 0;
 270         rect.pos.y = 0;
 271         rect.size.width = scr->scr_width;
 272         rect.size.height = scr->scr_height;
 273     }
 274
 275     return rect;
 276 }
 277
 278
 279
 280 WArea
 281 wGetUsableAreaForHead(WScreen *scr, int head, WArea *totalAreaPtr)
 282 {
 283     WArea totalArea, usableArea = scr->totalUsableArea;
 284     WMRect rect = wGetRectForHead(scr, head);
 285
 286     totalArea.x1 = rect.pos.x;
 287     totalArea.y1 = rect.pos.y;
 288     totalArea.x2 = totalArea.x1 + rect.size.width;
 289     totalArea.y2 = totalArea.y1 + rect.size.height;
 290
 291     if (totalAreaPtr != NULL) *totalAreaPtr = totalArea;
 292
 293     usableArea.x1 = WMAX(totalArea.x1, usableArea.x1);
 294     usableArea.y1 = WMAX(totalArea.y1, usableArea.y1);
 295     usableArea.x2 = WMIN(totalArea.x2, usableArea.x2);
 296     usableArea.y2 = WMIN(totalArea.y2, usableArea.y2);
 297
 298     return usableArea;
 299 }
 300
 301
 302 WMPoint
 303 wGetPointToCenterRectInHead(WScreen *scr, int head, int width, int height)
 304 {
 305     WMPoint p;
 306     WMRect rect = wGetRectForHead(scr, head);
 307
 308     p.x = rect.pos.x + (rect.size.width - width)/2;
 309     p.y = rect.pos.y + (rect.size.height - height)/2;
 310
 311     return p;
 312 }
 313