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 "funcs.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 int wGetHeadForWindow(WWindow * wwin)
 205 {
 206         WMRect rect;
 207
 208         if (wwin == NULL || wwin->frame == NULL)
 209                 return 0;
 210
 211         rect.pos.x = wwin->frame_x;
 212         rect.pos.y = wwin->frame_y;
 213         rect.size.width = wwin->frame->core->width;
 214         rect.size.height = wwin->frame->core->height;
 215
 216         return wGetHeadForRect(wwin->screen_ptr, rect);
 217 }
 218
 219 int wGetHeadForPoint(WScreen * scr, WMPoint point)
 220 {
 221         int i;
 222
 223         for (i = 0; i < scr->xine_info.count; i++) {
 224                 WMRect *rect = &scr->xine_info.screens[i];
 225
 226                 if ((unsigned)(point.x - rect->pos.x) < rect->size.width &&
 227                     (unsigned)(point.y - rect->pos.y) < rect->size.height)
 228                         return i;
 229         }
 230         return scr->xine_info.primary_head;
 231 }
 232
 233 int wGetHeadForPointerLocation(WScreen * scr)
 234 {
 235         WMPoint point;
 236         Window bla;
 237         int ble;
 238         unsigned int blo;
 239
 240         if (!scr->xine_info.count)
 241                 return scr->xine_info.primary_head;
 242
 243         if (!XQueryPointer(dpy, scr->root_win, &bla, &bla, &point.x, &point.y, &ble, &ble, &blo))
 244                 return scr->xine_info.primary_head;
 245
 246         return wGetHeadForPoint(scr, point);
 247 }
 248
 249 /* get the dimensions of the head */
 250 WMRect wGetRectForHead(WScreen * scr, int head)
 251 {
 252         WMRect rect;
 253
 254         if (head < scr->xine_info.count) {
 255                 rect.pos.x = scr->xine_info.screens[head].pos.x;
 256                 rect.pos.y = scr->xine_info.screens[head].pos.y;
 257                 rect.size.width = scr->xine_info.screens[head].size.width;
 258                 rect.size.height = scr->xine_info.screens[head].size.height;
 259         } else {
 260                 rect.pos.x = 0;
 261                 rect.pos.y = 0;
 262                 rect.size.width = scr->scr_width;
 263                 rect.size.height = scr->scr_height;
 264         }
 265
 266         return rect;
 267 }
 268
 269 WArea wGetUsableAreaForHead(WScreen * scr, int head, WArea * totalAreaPtr, Bool noicons)
 270 {
 271         WArea totalArea, usableArea;
 272         WMRect rect = wGetRectForHead(scr, head);
 273
 274         totalArea.x1 = rect.pos.x;
 275         totalArea.y1 = rect.pos.y;
 276         totalArea.x2 = totalArea.x1 + rect.size.width;
 277         totalArea.y2 = totalArea.y1 + rect.size.height;
 278
 279         if (totalAreaPtr != NULL)
 280                 *totalAreaPtr = totalArea;
 281
 282         if (head < wXineramaHeads(scr)) {
 283                 usableArea = noicons ? scr->totalUsableArea[head] : scr->usableArea[head];
 284         } else
 285                 usableArea = totalArea;
 286
 287         return usableArea;
 288 }
 289
 290 WMPoint wGetPointToCenterRectInHead(WScreen * scr, int head, int width, int height)
 291 {
 292         WMPoint p;
 293         WMRect rect = wGetRectForHead(scr, head);
 294
 295         p.x = rect.pos.x + (rect.size.width - width) / 2;
 296         p.y = rect.pos.y + (rect.size.height - height) / 2;
 297
 298         return p;
 299 }