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