xorg-server-1.4/randr/rrxinerama.c

   1 /*
   2  * Copyright © 2006 Keith Packard
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22 /*
  23  * This Xinerama implementation comes from the SiS driver which has
  24  * the following notice:
  25  */
  26 /*
  27  * SiS driver main code
  28  *
  29  * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria.
  30  *
  31  * Redistribution and use in source and binary forms, with or without
  32  * modification, are permitted provided that the following conditions
  33  * are met:
  34  * 1) Redistributions of source code must retain the above copyright
  35  *    notice, this list of conditions and the following disclaimer.
  36  * 2) Redistributions in binary form must reproduce the above copyright
  37  *    notice, this list of conditions and the following disclaimer in the
  38  *    documentation and/or other materials provided with the distribution.
  39  * 3) The name of the author may not be used to endorse or promote products
  40  *    derived from this software without specific prior written permission.
  41  *
  42  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  43  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  44  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  45  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  46  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  47  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  48  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  49  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  50  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  51  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  52  *
  53  * Author: Thomas Winischhofer <thomas@winischhofer.net>
  54  *      - driver entirely rewritten since 2001, only basic structure taken from
  55  *        old code (except sis_dri.c, sis_shadow.c, sis_accel.c and parts of
  56  *        sis_dga.c; these were mostly taken over; sis_dri.c was changed for
  57  *        new versions of the DRI layer)
  58  *
  59  * This notice covers the entire driver code unless indicated otherwise.
  60  *
  61  * Formerly based on code which was
  62  *           Copyright (C) 1998, 1999 by Alan Hourihane, Wigan, England.
  63  *           Written by:
  64  *           Alan Hourihane <alanh@fairlite.demon.co.uk>,
  65  *           Mike Chapman <mike@paranoia.com>,
  66  *           Juanjo Santamarta <santamarta@ctv.es>,
  67  *           Mitani Hiroshi <hmitani@drl.mei.co.jp>,
  68  *           David Thomas <davtom@dream.org.uk>.
  69  */
  70
  71 #include "randrstr.h"
  72 #include "swaprep.h"
  73 #include <X11/extensions/panoramiXproto.h>
  74
  75 #define RR_XINERAMA_MAJOR_VERSION   1
  76 #define RR_XINERAMA_MINOR_VERSION   1
  77
  78 /* Xinerama is not multi-screen capable; just report about screen 0 */
  79 #define RR_XINERAMA_SCREEN  0
  80
  81 static int ProcRRXineramaQueryVersion(ClientPtr client);
  82 static int ProcRRXineramaGetState(ClientPtr client);
  83 static int ProcRRXineramaGetScreenCount(ClientPtr client);
  84 static int ProcRRXineramaGetScreenSize(ClientPtr client);
  85 static int ProcRRXineramaIsActive(ClientPtr client);
  86 static int ProcRRXineramaQueryScreens(ClientPtr client);
  87 static int SProcRRXineramaDispatch(ClientPtr client);
  88
  89 /* Proc */
  90
  91 int
  92 ProcRRXineramaQueryVersion(ClientPtr client)
  93 {
  94     xPanoramiXQueryVersionReply   rep;
  95     register int                  n;
  96
  97     REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
  98     rep.type = X_Reply;
  99     rep.length = 0;
 100     rep.sequenceNumber = client->sequence;
 101     rep.majorVersion = RR_XINERAMA_MAJOR_VERSION;
 102     rep.minorVersion = RR_XINERAMA_MINOR_VERSION;
 103     if(client->swapped) {
 104         swaps(&rep.sequenceNumber, n);
 105         swapl(&rep.length, n);
 106         swaps(&rep.majorVersion, n);
 107         swaps(&rep.minorVersion, n);
 108     }
 109     WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *)&rep);
 110     return (client->noClientException);
 111 }
 112
 113 int
 114 ProcRRXineramaGetState(ClientPtr client)
 115 {
 116     REQUEST(xPanoramiXGetStateReq);
 117     WindowPtr                   pWin;
 118     xPanoramiXGetStateReply     rep;
 119     register int                n, rc;
 120     ScreenPtr                   pScreen;
 121     rrScrPrivPtr                pScrPriv;
 122     Bool                        active = FALSE;
 123
 124     REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 125     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
 126     if(rc != Success)
 127         return rc;
 128
 129     pScreen = pWin->drawable.pScreen;
 130     pScrPriv = rrGetScrPriv(pScreen);
 131     if (pScrPriv)
 132     {
 133         /* XXX do we need more than this? */
 134         active = TRUE;
 135     }
 136
 137     rep.type = X_Reply;
 138     rep.length = 0;
 139     rep.sequenceNumber = client->sequence;
 140     rep.state = active;
 141     if(client->swapped) {
 142        swaps (&rep.sequenceNumber, n);
 143        swapl (&rep.length, n);
 144        swaps (&rep.state, n);
 145     }
 146     WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *)&rep);
 147     return client->noClientException;
 148 }
 149
 150 static Bool
 151 RRXineramaCrtcActive (RRCrtcPtr crtc)
 152 {
 153     return crtc->mode != NULL && crtc->numOutputs > 0;
 154 }
 155
 156 static int
 157 RRXineramaScreenCount (ScreenPtr pScreen)
 158 {
 159     int i, n;
 160
 161     n = 0;
 162     if (rrGetScrPriv (pScreen))
 163     {
 164         rrScrPriv(pScreen);
 165         for (i = 0; i < pScrPriv->numCrtcs; i++)
 166             if (RRXineramaCrtcActive (pScrPriv->crtcs[i]))
 167                 n++;
 168     }
 169     return n;
 170 }
 171
 172 static Bool
 173 RRXineramaScreenActive (ScreenPtr pScreen)
 174 {
 175     return RRXineramaScreenCount (pScreen) > 0;
 176 }
 177
 178 int
 179 ProcRRXineramaGetScreenCount(ClientPtr client)
 180 {
 181     REQUEST(xPanoramiXGetScreenCountReq);
 182     WindowPtr                           pWin;
 183     xPanoramiXGetScreenCountReply       rep;
 184     register int                        n, rc;
 185
 186     REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 187     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
 188     if (rc != Success)
 189         return rc;
 190
 191     rep.type = X_Reply;
 192     rep.length = 0;
 193     rep.sequenceNumber = client->sequence;
 194     rep.ScreenCount = RRXineramaScreenCount (pWin->drawable.pScreen);
 195     if(client->swapped) {
 196        swaps(&rep.sequenceNumber, n);
 197        swapl(&rep.length, n);
 198        swaps(&rep.ScreenCount, n);
 199     }
 200     WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *)&rep);
 201     return client->noClientException;
 202 }
 203
 204 int
 205 ProcRRXineramaGetScreenSize(ClientPtr client)
 206 {
 207     REQUEST(xPanoramiXGetScreenSizeReq);
 208     WindowPtr                           pWin, pRoot;
 209     ScreenPtr                           pScreen;
 210     xPanoramiXGetScreenSizeReply        rep;
 211     register int                        n, rc;
 212
 213     REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
 214     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
 215     if (rc != Success)
 216         return rc;
 217
 218     pScreen = pWin->drawable.pScreen;
 219     pRoot = WindowTable[pScreen->myNum];
 220
 221     rep.type = X_Reply;
 222     rep.length = 0;
 223     rep.sequenceNumber = client->sequence;
 224     rep.width  = pRoot->drawable.width;
 225     rep.height = pRoot->drawable.height;
 226     if(client->swapped) {
 227        swaps(&rep.sequenceNumber, n);
 228        swapl(&rep.length, n);
 229        swaps(&rep.width, n);
 230        swaps(&rep.height, n);
 231     }
 232     WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep);
 233     return client->noClientException;
 234 }
 235
 236 int
 237 ProcRRXineramaIsActive(ClientPtr client)
 238 {
 239     xXineramaIsActiveReply      rep;
 240
 241     REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
 242
 243     rep.type = X_Reply;
 244     rep.length = 0;
 245     rep.sequenceNumber = client->sequence;
 246     rep.state = RRXineramaScreenActive (screenInfo.screens[RR_XINERAMA_SCREEN]);
 247     if(client->swapped) {
 248         register int n;
 249         swaps(&rep.sequenceNumber, n);
 250         swapl(&rep.length, n);
 251         swapl(&rep.state, n);
 252     }
 253     WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
 254     return client->noClientException;
 255 }
 256
 257 int
 258 ProcRRXineramaQueryScreens(ClientPtr client)
 259 {
 260     xXineramaQueryScreensReply  rep;
 261     ScreenPtr   pScreen = screenInfo.screens[RR_XINERAMA_SCREEN];
 262
 263     REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
 264
 265     if (RRXineramaScreenActive (pScreen))
 266     {
 267         rrScrPriv(pScreen);
 268         if (pScrPriv->numCrtcs == 0 || pScrPriv->numOutputs == 0)
 269             RRGetInfo (pScreen);
 270     }
 271
 272     rep.type = X_Reply;
 273     rep.sequenceNumber = client->sequence;
 274     rep.number = RRXineramaScreenCount (pScreen);
 275     rep.length = rep.number * sz_XineramaScreenInfo >> 2;
 276     if(client->swapped) {
 277         register int n;
 278         swaps(&rep.sequenceNumber, n);
 279         swapl(&rep.length, n);
 280         swapl(&rep.number, n);
 281     }
 282     WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep);
 283
 284     if(rep.number) {
 285         rrScrPriv(pScreen);
 286         xXineramaScreenInfo scratch;
 287         int i;
 288
 289         for(i = 0; i < pScrPriv->numCrtcs; i++) {
 290             RRCrtcPtr   crtc = pScrPriv->crtcs[i];
 291             if (RRXineramaCrtcActive (crtc))
 292             {
 293                 int width, height;
 294                 RRCrtcGetScanoutSize (crtc, &width, &height);
 295                 scratch.x_org  = crtc->x;
 296                 scratch.y_org  = crtc->y;
 297                 scratch.width  = width;
 298                 scratch.height = height;
 299                 if(client->swapped) {
 300                     register int n;
 301                     swaps(&scratch.x_org, n);
 302                     swaps(&scratch.y_org, n);
 303                     swaps(&scratch.width, n);
 304                     swaps(&scratch.height, n);
 305                 }
 306                 WriteToClient(client, sz_XineramaScreenInfo, (char *)&scratch);
 307             }
 308         }
 309     }
 310
 311     return client->noClientException;
 312 }
 313
 314 static int
 315 ProcRRXineramaDispatch(ClientPtr client)
 316 {
 317     REQUEST(xReq);
 318     switch (stuff->data) {
 319         case X_PanoramiXQueryVersion:
 320              return ProcRRXineramaQueryVersion(client);
 321         case X_PanoramiXGetState:
 322              return ProcRRXineramaGetState(client);
 323         case X_PanoramiXGetScreenCount:
 324              return ProcRRXineramaGetScreenCount(client);
 325         case X_PanoramiXGetScreenSize:
 326              return ProcRRXineramaGetScreenSize(client);
 327         case X_XineramaIsActive:
 328              return ProcRRXineramaIsActive(client);
 329         case X_XineramaQueryScreens:
 330              return ProcRRXineramaQueryScreens(client);
 331     }
 332     return BadRequest;
 333 }
 334
 335 /* SProc */
 336
 337 static int
 338 SProcRRXineramaQueryVersion (ClientPtr client)
 339 {
 340     REQUEST(xPanoramiXQueryVersionReq);
 341     register int n;
 342     swaps(&stuff->length,n);
 343     REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
 344     return ProcRRXineramaQueryVersion(client);
 345 }
 346
 347 static int
 348 SProcRRXineramaGetState(ClientPtr client)
 349 {
 350     REQUEST(xPanoramiXGetStateReq);
 351     register int n;
 352     swaps (&stuff->length, n);
 353     REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 354     return ProcRRXineramaGetState(client);
 355 }
 356
 357 static int
 358 SProcRRXineramaGetScreenCount(ClientPtr client)
 359 {
 360     REQUEST(xPanoramiXGetScreenCountReq);
 361     register int n;
 362     swaps (&stuff->length, n);
 363     REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 364     return ProcRRXineramaGetScreenCount(client);
 365 }
 366
 367 static int
 368 SProcRRXineramaGetScreenSize(ClientPtr client)
 369 {
 370     REQUEST(xPanoramiXGetScreenSizeReq);
 371     register int n;
 372     swaps (&stuff->length, n);
 373     REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
 374     return ProcRRXineramaGetScreenSize(client);
 375 }
 376
 377 static int
 378 SProcRRXineramaIsActive(ClientPtr client)
 379 {
 380     REQUEST(xXineramaIsActiveReq);
 381     register int n;
 382     swaps (&stuff->length, n);
 383     REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
 384     return ProcRRXineramaIsActive(client);
 385 }
 386
 387 static int
 388 SProcRRXineramaQueryScreens(ClientPtr client)
 389 {
 390     REQUEST(xXineramaQueryScreensReq);
 391     register int n;
 392     swaps (&stuff->length, n);
 393     REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
 394     return ProcRRXineramaQueryScreens(client);
 395 }
 396
 397 int
 398 SProcRRXineramaDispatch(ClientPtr client)
 399 {
 400     REQUEST(xReq);
 401     switch (stuff->data) {
 402         case X_PanoramiXQueryVersion:
 403              return SProcRRXineramaQueryVersion(client);
 404         case X_PanoramiXGetState:
 405              return SProcRRXineramaGetState(client);
 406         case X_PanoramiXGetScreenCount:
 407              return SProcRRXineramaGetScreenCount(client);
 408         case X_PanoramiXGetScreenSize:
 409              return SProcRRXineramaGetScreenSize(client);
 410         case X_XineramaIsActive:
 411              return SProcRRXineramaIsActive(client);
 412         case X_XineramaQueryScreens:
 413              return SProcRRXineramaQueryScreens(client);
 414     }
 415     return BadRequest;
 416 }
 417
 418 static void
 419 RRXineramaResetProc(ExtensionEntry* extEntry)
 420 {
 421 }
 422
 423 void
 424 RRXineramaExtensionInit(void)
 425 {
 426 #ifdef PANORAMIX
 427     if(!noPanoramiXExtension)
 428         return;
 429 #endif
 430
 431     /*
 432      * Xinerama isn't capable enough to have multiple protocol screens each
 433      * with their own output geometry.  So if there's more than one protocol
 434      * screen, just don't even try.
 435      */
 436     if (screenInfo.numScreens > 1)
 437         return;
 438
 439     (void) AddExtension(PANORAMIX_PROTOCOL_NAME, 0,0,
 440                         ProcRRXineramaDispatch,
 441                         SProcRRXineramaDispatch,
 442                         RRXineramaResetProc,
 443                         StandardMinorOpcode);
 444 }