shape.c 31.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/************************************************************

Copyright 1989, 1998  The Open Group

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.

********************************************************/

27 28 29 30
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

31 32
#include <stdlib.h>

33 34
#include <X11/X.h>
#include <X11/Xproto.h>
35 36
#include "misc.h"
#include "os.h"
37 38 39 40 41 42 43 44
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "extnsionst.h"
#include "dixstruct.h"
#include "resource.h"
#include "opaque.h"
#define _SHAPE_SERVER_	/* don't want Xlib structures */
45
#include <X11/extensions/shapestr.h>
46 47
#include "regionstr.h"
#include "gcstruct.h"
48
#include "modinit.h"
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

typedef	RegionPtr (*CreateDftPtr)(
	WindowPtr /* pWin */
	);

static int ShapeFreeClient(
	pointer /* data */,
	XID /* id */
	);
static int ShapeFreeEvents(
	pointer /* data */,
	XID /* id */
	);
static void SShapeNotifyEvent(
	xShapeNotifyEvent * /* from */,
	xShapeNotifyEvent * /* to */
	);

67 68 69
/* SendShapeNotify, CreateBoundingShape and CreateClipShape are used
 * externally by the Xfixes extension and are now defined in window.h
 */
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

static DISPATCH_PROC(ProcShapeCombine);
static DISPATCH_PROC(ProcShapeDispatch);
static DISPATCH_PROC(ProcShapeGetRectangles);
static DISPATCH_PROC(ProcShapeInputSelected);
static DISPATCH_PROC(ProcShapeMask);
static DISPATCH_PROC(ProcShapeOffset);
static DISPATCH_PROC(ProcShapeQueryExtents);
static DISPATCH_PROC(ProcShapeQueryVersion);
static DISPATCH_PROC(ProcShapeRectangles);
static DISPATCH_PROC(ProcShapeSelectInput);
static DISPATCH_PROC(SProcShapeCombine);
static DISPATCH_PROC(SProcShapeDispatch);
static DISPATCH_PROC(SProcShapeGetRectangles);
static DISPATCH_PROC(SProcShapeInputSelected);
static DISPATCH_PROC(SProcShapeMask);
static DISPATCH_PROC(SProcShapeOffset);
static DISPATCH_PROC(SProcShapeQueryExtents);
static DISPATCH_PROC(SProcShapeQueryVersion);
static DISPATCH_PROC(SProcShapeRectangles);
static DISPATCH_PROC(SProcShapeSelectInput);
91 92 93

#ifdef PANORAMIX
#include "panoramiX.h"
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
94
#include "panoramiXsrv.h"
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
#endif

static int ShapeEventBase = 0;
static RESTYPE ClientType, EventType; /* resource types for event masks */

/*
 * each window has a list of clients requesting
 * ShapeNotify events.  Each client has a resource
 * for each window it selects ShapeNotify input for,
 * this resource is used to delete the ShapeNotifyRec
 * entry from the per-window queue.
 */

typedef struct _ShapeEvent *ShapeEventPtr;

typedef struct _ShapeEvent {
    ShapeEventPtr   next;
    ClientPtr	    client;
    WindowPtr	    window;
    XID		    clientResource;
} ShapeEventRec;

/****************
 * ShapeExtensionInit
 *
 * Called from InitExtensions in main() or from QueryExtension() if the
 * extension is dynamically loaded.
 *
 ****************/

125
void
126
ShapeExtensionInit(void)
127
{
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
128
    ExtensionEntry *extEntry;
129 130 131 132 133 134

    ClientType = CreateNewResourceType(ShapeFreeClient);
    EventType = CreateNewResourceType(ShapeFreeEvents);
    if (ClientType && EventType &&
	(extEntry = AddExtension(SHAPENAME, ShapeNumberEvents, 0,
				 ProcShapeDispatch, SProcShapeDispatch,
135
				 NULL, StandardMinorOpcode)))
136 137
    {
	ShapeEventBase = extEntry->eventBase;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
138
	EventSwapVector[ShapeEventBase] = (EventSwapPtr) SShapeNotifyEvent;
139 140 141
    }
}

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
142
static int
Julien Cristau's avatar
Julien Cristau committed
143 144 145 146 147 148 149 150 151
RegionOperate (
	ClientPtr client,
	WindowPtr pWin,
	int kind,
	RegionPtr *destRgnp,
	RegionPtr srcRgn,
	int op,
	int xoff, int yoff,
	CreateDftPtr create)
152 153 154 155 156 157 158 159 160 161 162
{
    ScreenPtr	pScreen = pWin->drawable.pScreen;

    if (srcRgn && (xoff || yoff))
	REGION_TRANSLATE(pScreen, srcRgn, xoff, yoff);
    if (!pWin->parent)
    {
	if (srcRgn)
	    REGION_DESTROY(pScreen, srcRgn);
	return Success;
    }
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187

    /* May/30/2001:
     * The shape.PS specs say if src is None, existing shape is to be
     * removed (and so the op-code has no meaning in such removal);
     * see shape.PS, page 3, ShapeMask.
     */
    if (srcRgn == NULL) {
      if (*destRgnp != NULL) {
	REGION_DESTROY (pScreen, *destRgnp);
	*destRgnp = 0;
	/* go on to remove shape and generate ShapeNotify */
      }
      else {
	/* May/30/2001:
	 * The target currently has no shape in effect, so nothing to
	 * do here.  The specs say that ShapeNotify is generated whenever
	 * the client region is "modified"; since no modification is done
	 * here, we do not generate that event.  The specs does not say
	 * "it is an error to request removal when there is no shape in
	 * effect", so we return good status.
	 */
	return Success;
      }
    }
    else switch (op) {
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
    case ShapeSet:
	if (*destRgnp)
	    REGION_DESTROY(pScreen, *destRgnp);
	*destRgnp = srcRgn;
	srcRgn = 0;
	break;
    case ShapeUnion:
	if (*destRgnp)
	    REGION_UNION(pScreen, *destRgnp, *destRgnp, srcRgn);
	break;
    case ShapeIntersect:
	if (*destRgnp)
	    REGION_INTERSECT(pScreen, *destRgnp, *destRgnp, srcRgn);
	else {
	    *destRgnp = srcRgn;
	    srcRgn = 0;
	}
	break;
    case ShapeSubtract:
	if (!*destRgnp)
	    *destRgnp = (*create)(pWin);
	REGION_SUBTRACT(pScreen, *destRgnp, *destRgnp, srcRgn);
	break;
    case ShapeInvert:
	if (!*destRgnp)
	    *destRgnp = REGION_CREATE(pScreen, (BoxPtr) 0, 0);
	else
	    REGION_SUBTRACT(pScreen, *destRgnp, srcRgn, *destRgnp);
	break;
    default:
	client->errorValue = op;
	return BadValue;
    }
    if (srcRgn)
	REGION_DESTROY(pScreen, srcRgn);
    (*pScreen->SetShape) (pWin);
    SendShapeNotify (pWin, kind);
    return Success;
}

228
RegionPtr
Julien Cristau's avatar
Julien Cristau committed
229
CreateBoundingShape (WindowPtr pWin)
230 231 232 233 234 235 236 237 238 239
{
    BoxRec	extents;

    extents.x1 = -wBorderWidth (pWin);
    extents.y1 = -wBorderWidth (pWin);
    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
    return REGION_CREATE(pWin->drawable.pScreen, &extents, 1);
}

240
RegionPtr
Julien Cristau's avatar
Julien Cristau committed
241
CreateClipShape (WindowPtr pWin)
242 243 244 245 246 247 248 249 250 251 252
{
    BoxRec	extents;

    extents.x1 = 0;
    extents.y1 = 0;
    extents.x2 = pWin->drawable.width;
    extents.y2 = pWin->drawable.height;
    return REGION_CREATE(pWin->drawable.pScreen, &extents, 1);
}

static int
Julien Cristau's avatar
Julien Cristau committed
253
ProcShapeQueryVersion (ClientPtr client)
254 255
{
    xShapeQueryVersionReply	rep;
256
    int		n;
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

    REQUEST_SIZE_MATCH (xShapeQueryVersionReq);
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;
    rep.majorVersion = SHAPE_MAJOR_VERSION;
    rep.minorVersion = SHAPE_MINOR_VERSION;
    if (client->swapped) {
    	swaps(&rep.sequenceNumber, n);
    	swapl(&rep.length, n);
	swaps(&rep.majorVersion, n);
	swaps(&rep.minorVersion, n);
    }
    WriteToClient(client, sizeof (xShapeQueryVersionReply), (char *)&rep);
    return (client->noClientException);
}

/*****************
 * ProcShapeRectangles
 *
 *****************/

static int
Julien Cristau's avatar
Julien Cristau committed
280
ProcShapeRectangles (ClientPtr client)
281 282 283 284 285
{
    WindowPtr		pWin;
    ScreenPtr		pScreen;
    REQUEST(xShapeRectanglesReq);
    xRectangle		*prects;
286
    int		        nrects, ctype, rc;
287 288
    RegionPtr		srcRgn;
    RegionPtr		*destRgn;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
289
    CreateDftPtr	createDefault;
290 291 292

    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
    UpdateCurrentTime();
293
    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
294 295
    if (rc != Success)
	return rc;
296 297 298 299 300 301 302
    switch (stuff->destKind) {
    case ShapeBounding:
	createDefault = CreateBoundingShape;
	break;
    case ShapeClip:
	createDefault = CreateClipShape;
	break;
303 304 305
    case ShapeInput:
	createDefault = CreateBoundingShape;
	break;
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
    default:
	client->errorValue = stuff->destKind;
	return BadValue;
    }
    if ((stuff->ordering != Unsorted) && (stuff->ordering != YSorted) &&
	(stuff->ordering != YXSorted) && (stuff->ordering != YXBanded))
    {
	client->errorValue = stuff->ordering;
        return BadValue;
    }
    pScreen = pWin->drawable.pScreen;
    nrects = ((stuff->length  << 2) - sizeof(xShapeRectanglesReq));
    if (nrects & 4)
	return BadLength;
    nrects >>= 3;
    prects = (xRectangle *) &stuff[1];
    ctype = VerifyRectOrder(nrects, prects, (int)stuff->ordering);
    if (ctype < 0)
	return BadMatch;
    srcRgn = RECTS_TO_REGION(pScreen, nrects, prects, ctype);

    if (!pWin->optional)
	MakeWindowOptional (pWin);
329 330
    switch (stuff->destKind) {
    case ShapeBounding:
331
	destRgn = &pWin->optional->boundingShape;
332 333
	break;
    case ShapeClip:
334
	destRgn = &pWin->optional->clipShape;
335 336 337 338 339 340 341
	break;
    case ShapeInput:
	destRgn = &pWin->optional->inputShape;
	break;
    default:
	return BadValue;
    }
342 343 344 345 346 347 348 349

    return RegionOperate (client, pWin, (int)stuff->destKind,
			  destRgn, srcRgn, (int)stuff->op,
			  stuff->xOff, stuff->yOff, createDefault);
}

#ifdef PANORAMIX
static int
350
ProcPanoramiXShapeRectangles(
351
    ClientPtr client)
352
{
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
353 354 355
    REQUEST(xShapeRectanglesReq);
    PanoramiXRes	*win;
    int        		j, result = 0;
356

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
357
    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
358

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
359
    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
360
		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
361 362 363 364 365
	return BadWindow;

    FOR_NSCREENS(j) {
	stuff->dest = win->info[j].id;
	result = ProcShapeRectangles (client);
366 367 368 369 370 371
	BREAK_IF(result != Success);
    }
    return (result);
}
#endif

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
372 373 374 375 376 377

/**************
 * ProcShapeMask
 **************/


378
static int
Julien Cristau's avatar
Julien Cristau committed
379
ProcShapeMask (ClientPtr client)
380 381 382 383 384 385 386
{
    WindowPtr		pWin;
    ScreenPtr		pScreen;
    REQUEST(xShapeMaskReq);
    RegionPtr		srcRgn;
    RegionPtr		*destRgn;
    PixmapPtr		pPixmap;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
387
    CreateDftPtr	createDefault;
388
    int			rc;
389 390 391

    REQUEST_SIZE_MATCH (xShapeMaskReq);
    UpdateCurrentTime();
392
    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
393 394
    if (rc != Success)
	return rc;
395 396 397 398 399 400 401
    switch (stuff->destKind) {
    case ShapeBounding:
	createDefault = CreateBoundingShape;
	break;
    case ShapeClip:
	createDefault = CreateClipShape;
	break;
402 403 404
    case ShapeInput:
	createDefault = CreateBoundingShape;
	break;
405 406 407 408 409 410 411 412
    default:
	client->errorValue = stuff->destKind;
	return BadValue;
    }
    pScreen = pWin->drawable.pScreen;
    if (stuff->src == None)
	srcRgn = 0;
    else {
413 414 415 416
	rc = dixLookupResource((pointer *)&pPixmap, stuff->src, RT_PIXMAP,
			       client, DixReadAccess);
        if (rc != Success)
	    return (rc == BadValue) ? BadPixmap : rc;
417 418 419 420 421 422 423 424 425 426
	if (pPixmap->drawable.pScreen != pScreen ||
	    pPixmap->drawable.depth != 1)
	    return BadMatch;
	srcRgn = BITMAP_TO_REGION(pScreen, pPixmap);
	if (!srcRgn)
	    return BadAlloc;
    }

    if (!pWin->optional)
	MakeWindowOptional (pWin);
427 428
    switch (stuff->destKind) {
    case ShapeBounding:
429
	destRgn = &pWin->optional->boundingShape;
430 431
	break;
    case ShapeClip:
432
	destRgn = &pWin->optional->clipShape;
433 434 435 436 437 438 439
	break;
    case ShapeInput:
	destRgn = &pWin->optional->inputShape;
	break;
    default:
	return BadValue;
    }
440 441 442 443 444 445 446 447

    return RegionOperate (client, pWin, (int)stuff->destKind,
			  destRgn, srcRgn, (int)stuff->op,
			  stuff->xOff, stuff->yOff, createDefault);
}

#ifdef PANORAMIX
static int
448
ProcPanoramiXShapeMask(
449
    ClientPtr client)
450
{
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
451 452 453
    REQUEST(xShapeMaskReq);
    PanoramiXRes	*win, *pmap;
    int 		j, result = 0;
454

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
455
    REQUEST_SIZE_MATCH (xShapeMaskReq);
456

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
457
    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
458
		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
459 460 461 462
	return BadWindow;

    if(stuff->src != None) {
	if(!(pmap = (PanoramiXRes *)SecurityLookupIDByType(
463
		client, stuff->src, XRT_PIXMAP, DixReadAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
464 465 466 467 468 469 470 471 472
	    return BadPixmap;
    } else
	pmap = NULL;

    FOR_NSCREENS(j) {
	stuff->dest = win->info[j].id;
	if(pmap)
	    stuff->src  = pmap->info[j].id;
	result = ProcShapeMask (client);
473 474 475 476 477 478
	BREAK_IF(result != Success);
    }
    return (result);
}
#endif

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
479 480 481 482 483

/************
 * ProcShapeCombine
 ************/

484
static int
Julien Cristau's avatar
Julien Cristau committed
485
ProcShapeCombine (ClientPtr client)
486 487 488 489 490 491
{
    WindowPtr		pSrcWin, pDestWin;
    ScreenPtr		pScreen;
    REQUEST(xShapeCombineReq);
    RegionPtr		srcRgn;
    RegionPtr		*destRgn;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
492 493
    CreateDftPtr	createDefault;
    CreateDftPtr	createSrc;
494
    RegionPtr		tmp;
495
    int			rc;
496 497 498

    REQUEST_SIZE_MATCH (xShapeCombineReq);
    UpdateCurrentTime();
499
    rc = dixLookupWindow(&pDestWin, stuff->dest, client, DixSetAttrAccess);
500 501
    if (rc != Success)
	return rc;
502 503 504 505 506 507 508 509 510
    if (!pDestWin->optional)
	MakeWindowOptional (pDestWin);
    switch (stuff->destKind) {
    case ShapeBounding:
	createDefault = CreateBoundingShape;
	break;
    case ShapeClip:
	createDefault = CreateClipShape;
	break;
511 512 513
    case ShapeInput:
	createDefault = CreateBoundingShape;
	break;
514 515 516 517 518 519
    default:
	client->errorValue = stuff->destKind;
	return BadValue;
    }
    pScreen = pDestWin->drawable.pScreen;

520
    rc = dixLookupWindow(&pSrcWin, stuff->src, client, DixGetAttrAccess);
521 522
    if (rc != Success)
	return rc;
523 524 525 526 527 528 529 530 531
    switch (stuff->srcKind) {
    case ShapeBounding:
	srcRgn = wBoundingShape (pSrcWin);
	createSrc = CreateBoundingShape;
	break;
    case ShapeClip:
	srcRgn = wClipShape (pSrcWin);
	createSrc = CreateClipShape;
	break;
532 533 534 535
    case ShapeInput:
	srcRgn = wInputShape (pSrcWin);
	createSrc = CreateBoundingShape;
	break;
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
    default:
	client->errorValue = stuff->srcKind;
	return BadValue;
    }
    if (pSrcWin->drawable.pScreen != pScreen)
    {
	return BadMatch;
    }

    if (srcRgn) {
        tmp = REGION_CREATE(pScreen, (BoxPtr) 0, 0);
        REGION_COPY(pScreen, tmp, srcRgn);
        srcRgn = tmp;
    } else
	srcRgn = (*createSrc) (pSrcWin);

    if (!pDestWin->optional)
	MakeWindowOptional (pDestWin);
554 555
    switch (stuff->destKind) {
    case ShapeBounding:
556
	destRgn = &pDestWin->optional->boundingShape;
557 558
	break;
    case ShapeClip:
559
	destRgn = &pDestWin->optional->clipShape;
560 561 562 563 564 565 566
	break;
    case ShapeInput:
	destRgn = &pDestWin->optional->inputShape;
	break;
    default:
	return BadValue;
    }
567 568 569 570 571 572

    return RegionOperate (client, pDestWin, (int)stuff->destKind,
			  destRgn, srcRgn, (int)stuff->op,
			  stuff->xOff, stuff->yOff, createDefault);
}

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
573

574 575
#ifdef PANORAMIX
static int
576
ProcPanoramiXShapeCombine(
577
    ClientPtr client)
578
{
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
579 580 581 582 583
    REQUEST(xShapeCombineReq);
    PanoramiXRes	*win, *win2;
    int 		j, result = 0;

    REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
584

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
585
    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
586
		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
587
	return BadWindow;
588

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
589
    if(!(win2 = (PanoramiXRes *)SecurityLookupIDByType(
590
		client, stuff->src, XRT_WINDOW, DixReadAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
591 592 593 594 595 596
	return BadWindow;

    FOR_NSCREENS(j) {
	stuff->dest = win->info[j].id;
	stuff->src =  win2->info[j].id;
	result = ProcShapeCombine (client);
597 598 599 600 601 602
	BREAK_IF(result != Success);
    }
    return (result);
}
#endif

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
603 604 605 606
/*************
 * ProcShapeOffset
 *************/

607
static int
Julien Cristau's avatar
Julien Cristau committed
608
ProcShapeOffset (ClientPtr client)
609 610 611 612 613
{
    WindowPtr		pWin;
    ScreenPtr		pScreen;
    REQUEST(xShapeOffsetReq);
    RegionPtr		srcRgn;
614
    int			rc;
615 616 617

    REQUEST_SIZE_MATCH (xShapeOffsetReq);
    UpdateCurrentTime();
618
    rc = dixLookupWindow(&pWin, stuff->dest, client, DixSetAttrAccess);
619 620
    if (rc != Success)
	return rc;
621 622 623 624 625 626 627
    switch (stuff->destKind) {
    case ShapeBounding:
	srcRgn = wBoundingShape (pWin);
	break;
    case ShapeClip:
	srcRgn = wClipShape(pWin);
	break;
628 629 630
    case ShapeInput:
	srcRgn = wInputShape (pWin);
	break;
631 632 633 634 635 636 637 638 639 640 641 642 643 644
    default:
	client->errorValue = stuff->destKind;
	return BadValue;
    }
    pScreen = pWin->drawable.pScreen;
    if (srcRgn)
    {
        REGION_TRANSLATE(pScreen, srcRgn, stuff->xOff, stuff->yOff);
        (*pScreen->SetShape) (pWin);
    }
    SendShapeNotify (pWin, (int)stuff->destKind);
    return Success;
}

Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
645 646 647

#ifdef PANORAMIX
static int
648
ProcPanoramiXShapeOffset(
649
    ClientPtr client)
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
650 651 652 653 654 655 656 657
{
    REQUEST(xShapeOffsetReq);
    PanoramiXRes *win;
    int j, result = 0;

    REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
   
    if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
658
		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
659 660 661 662 663 664 665 666 667 668 669 670
	return BadWindow;

    FOR_NSCREENS(j) {
	stuff->dest = win->info[j].id;
	result = ProcShapeOffset (client);
	if(result != Success) break;
    }
    return (result);
}
#endif


671
static int
Julien Cristau's avatar
Julien Cristau committed
672
ProcShapeQueryExtents (ClientPtr client)
673 674 675 676 677
{
    REQUEST(xShapeQueryExtentsReq);
    WindowPtr		pWin;
    xShapeQueryExtentsReply	rep;
    BoxRec		extents, *pExtents;
678
    int	n, rc;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
679
    RegionPtr		region;
680 681

    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
682
    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
683 684
    if (rc != Success)
	return rc;
685 686 687 688 689
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;
    rep.boundingShaped = (wBoundingShape(pWin) != 0);
    rep.clipShaped = (wClipShape(pWin) != 0);
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
690
    if ((region = wBoundingShape(pWin))) {
691
     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
692
	pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
693 694 695 696 697 698 699 700 701 702 703
	extents = *pExtents;
    } else {
	extents.x1 = -wBorderWidth (pWin);
	extents.y1 = -wBorderWidth (pWin);
	extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
	extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
    }
    rep.xBoundingShape = extents.x1;
    rep.yBoundingShape = extents.y1;
    rep.widthBoundingShape = extents.x2 - extents.x1;
    rep.heightBoundingShape = extents.y2 - extents.y1;
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
704
    if ((region = wClipShape(pWin))) {
705
     /* this is done in two steps because of a compiler bug on SunOS 4.1.3 */
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
706
	pExtents = REGION_EXTENTS(pWin->drawable.pScreen, region);
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
	extents = *pExtents;
    } else {
	extents.x1 = 0;
	extents.y1 = 0;
	extents.x2 = pWin->drawable.width;
	extents.y2 = pWin->drawable.height;
    }
    rep.xClipShape = extents.x1;
    rep.yClipShape = extents.y1;
    rep.widthClipShape = extents.x2 - extents.x1;
    rep.heightClipShape = extents.y2 - extents.y1;
    if (client->swapped) {
    	swaps(&rep.sequenceNumber, n);
    	swapl(&rep.length, n);
	swaps(&rep.xBoundingShape, n);
	swaps(&rep.yBoundingShape, n);
	swaps(&rep.widthBoundingShape, n);
	swaps(&rep.heightBoundingShape, n);
	swaps(&rep.xClipShape, n);
	swaps(&rep.yClipShape, n);
	swaps(&rep.widthClipShape, n);
	swaps(&rep.heightClipShape, n);
    }
    WriteToClient(client, sizeof (xShapeQueryExtentsReply), (char *)&rep);
    return (client->noClientException);
}

/*ARGSUSED*/
static int
Julien Cristau's avatar
Julien Cristau committed
736
ShapeFreeClient (pointer data, XID id)
737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
{
    ShapeEventPtr   pShapeEvent;
    WindowPtr	    pWin;
    ShapeEventPtr   *pHead, pCur, pPrev;

    pShapeEvent = (ShapeEventPtr) data;
    pWin = pShapeEvent->window;
    pHead = (ShapeEventPtr *) LookupIDByType(pWin->drawable.id, EventType);
    if (pHead) {
	pPrev = 0;
	for (pCur = *pHead; pCur && pCur != pShapeEvent; pCur=pCur->next)
	    pPrev = pCur;
	if (pCur)
	{
	    if (pPrev)
	    	pPrev->next = pShapeEvent->next;
	    else
	    	*pHead = pShapeEvent->next;
	}
    }
    xfree ((pointer) pShapeEvent);
    return 1;
}

/*ARGSUSED*/
static int
Julien Cristau's avatar
Julien Cristau committed
763
ShapeFreeEvents (pointer data, XID id)
764 765 766 767 768 769 770 771 772 773 774 775 776 777
{
    ShapeEventPtr   *pHead, pCur, pNext;

    pHead = (ShapeEventPtr *) data;
    for (pCur = *pHead; pCur; pCur = pNext) {
	pNext = pCur->next;
	FreeResource (pCur->clientResource, ClientType);
	xfree ((pointer) pCur);
    }
    xfree ((pointer) pHead);
    return 1;
}

static int
Julien Cristau's avatar
Julien Cristau committed
778
ProcShapeSelectInput (ClientPtr client)
779 780 781 782 783
{
    REQUEST(xShapeSelectInputReq);
    WindowPtr		pWin;
    ShapeEventPtr	pShapeEvent, pNewShapeEvent, *pHead;
    XID			clientResource;
784
    int			rc;
785 786

    REQUEST_SIZE_MATCH (xShapeSelectInputReq);
787
    rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
788 789
    if (rc != Success)
	return rc;
790
    pHead = (ShapeEventPtr *)SecurityLookupIDByType(client,
791
			pWin->drawable.id, EventType, DixWriteAccess);
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
    switch (stuff->enable) {
    case xTrue:
	if (pHead) {

	    /* check for existing entry. */
	    for (pShapeEvent = *pHead;
		 pShapeEvent;
 		 pShapeEvent = pShapeEvent->next)
	    {
		if (pShapeEvent->client == client)
		    return Success;
	    }
	}

	/* build the entry */
807
    	pNewShapeEvent = xalloc (sizeof (ShapeEventRec));
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
    	if (!pNewShapeEvent)
	    return BadAlloc;
    	pNewShapeEvent->next = 0;
    	pNewShapeEvent->client = client;
    	pNewShapeEvent->window = pWin;
    	/*
 	 * add a resource that will be deleted when
     	 * the client goes away
     	 */
   	clientResource = FakeClientID (client->index);
    	pNewShapeEvent->clientResource = clientResource;
    	if (!AddResource (clientResource, ClientType, (pointer)pNewShapeEvent))
	    return BadAlloc;
    	/*
     	 * create a resource to contain a pointer to the list
     	 * of clients selecting input.  This must be indirect as
     	 * the list may be arbitrarily rearranged which cannot be
     	 * done through the resource database.
     	 */
    	if (!pHead)
    	{
829
	    pHead = xalloc (sizeof (ShapeEventPtr));
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
	    if (!pHead ||
	    	!AddResource (pWin->drawable.id, EventType, (pointer)pHead))
	    {
	    	FreeResource (clientResource, RT_NONE);
	    	return BadAlloc;
	    }
	    *pHead = 0;
    	}
    	pNewShapeEvent->next = *pHead;
    	*pHead = pNewShapeEvent;
	break;
    case xFalse:
	/* delete the interest */
	if (pHead) {
	    pNewShapeEvent = 0;
	    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
		if (pShapeEvent->client == client)
		    break;
		pNewShapeEvent = pShapeEvent;
	    }
	    if (pShapeEvent) {
		FreeResource (pShapeEvent->clientResource, ClientType);
		if (pNewShapeEvent)
		    pNewShapeEvent->next = pShapeEvent->next;
		else
		    *pHead = pShapeEvent->next;
		xfree (pShapeEvent);
	    }
	}
	break;
    default:
	client->errorValue = stuff->enable;
	return BadValue;
    }
    return Success;
}

/*
 * deliver the event
 */

871
void
Julien Cristau's avatar
Julien Cristau committed
872
SendShapeNotify (WindowPtr pWin, int which)
873 874 875 876 877 878 879 880 881 882 883
{
    ShapeEventPtr	*pHead, pShapeEvent;
    ClientPtr		client;
    xShapeNotifyEvent	se;
    BoxRec		extents;
    RegionPtr		region;
    BYTE		shaped;

    pHead = (ShapeEventPtr *) LookupIDByType(pWin->drawable.id, EventType);
    if (!pHead)
	return;
884 885
    switch (which) {
    case ShapeBounding:
886 887 888 889 890 891 892 893 894 895 896
	region = wBoundingShape(pWin);
	if (region) {
	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
	    shaped = xTrue;
	} else {
	    extents.x1 = -wBorderWidth (pWin);
	    extents.y1 = -wBorderWidth (pWin);
	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
	    shaped = xFalse;
	}
897 898
	break;
    case ShapeClip:
899 900 901 902 903 904 905 906 907 908 909
	region = wClipShape(pWin);
	if (region) {
	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
	    shaped = xTrue;
	} else {
	    extents.x1 = 0;
	    extents.y1 = 0;
	    extents.x2 = pWin->drawable.width;
	    extents.y2 = pWin->drawable.height;
	    shaped = xFalse;
	}
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
	break;
    case ShapeInput:
	region = wInputShape(pWin);
	if (region) {
	    extents = *REGION_EXTENTS(pWin->drawable.pScreen, region);
	    shaped = xTrue;
	} else {
	    extents.x1 = -wBorderWidth (pWin);
	    extents.y1 = -wBorderWidth (pWin);
	    extents.x2 = pWin->drawable.width + wBorderWidth (pWin);
	    extents.y2 = pWin->drawable.height + wBorderWidth (pWin);
	    shaped = xFalse;
	}
	break;
    default:
	return;
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
    }
    for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
	client = pShapeEvent->client;
	if (client == serverClient || client->clientGone)
	    continue;
	se.type = ShapeNotify + ShapeEventBase;
	se.kind = which;
	se.window = pWin->drawable.id;
	se.sequenceNumber = client->sequence;
	se.x = extents.x1;
	se.y = extents.y1;
	se.width = extents.x2 - extents.x1;
	se.height = extents.y2 - extents.y1;
	se.time = currentTime.milliseconds;
	se.shaped = shaped;
	WriteEventsToClient (client, 1, (xEvent *) &se);
    }
}

static int
Julien Cristau's avatar
Julien Cristau committed
946
ProcShapeInputSelected (ClientPtr client)
947 948 949 950
{
    REQUEST(xShapeInputSelectedReq);
    WindowPtr		pWin;
    ShapeEventPtr	pShapeEvent, *pHead;
951
    int			enabled, rc;
952
    xShapeInputSelectedReply	rep;
953
    int		n;
954 955

    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
956
    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
957 958
    if (rc != Success)
	return rc;
959
    pHead = (ShapeEventPtr *) SecurityLookupIDByType(client,
960
			pWin->drawable.id, EventType, DixReadAccess);
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
    enabled = xFalse;
    if (pHead) {
    	for (pShapeEvent = *pHead;
	     pShapeEvent;
	     pShapeEvent = pShapeEvent->next)
    	{
	    if (pShapeEvent->client == client) {
	    	enabled = xTrue;
		break;
	    }
    	}
    }
    rep.type = X_Reply;
    rep.length = 0;
    rep.sequenceNumber = client->sequence;
    rep.enabled = enabled;
    if (client->swapped) {
	swaps (&rep.sequenceNumber, n);
	swapl (&rep.length, n);
    }
    WriteToClient (client, sizeof (xShapeInputSelectedReply), (char *) &rep);
    return (client->noClientException);
}

static int
Julien Cristau's avatar
Julien Cristau committed
986
ProcShapeGetRectangles (ClientPtr client)
987 988 989 990 991
{
    REQUEST(xShapeGetRectanglesReq);
    WindowPtr			pWin;
    xShapeGetRectanglesReply	rep;
    xRectangle			*rects;
992
    int				nrects, i, rc;
993
    RegionPtr			region;
994
    int		n;
995 996

    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
997
    rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
998 999
    if (rc != Success)
	return rc;
1000 1001 1002 1003 1004 1005 1006
    switch (stuff->kind) {
    case ShapeBounding:
	region = wBoundingShape(pWin);
	break;
    case ShapeClip:
	region = wClipShape(pWin);
	break;
1007 1008 1009
    case ShapeInput:
	region = wInputShape (pWin);
	break;
1010 1011 1012 1013 1014 1015
    default:
	client->errorValue = stuff->kind;
	return BadValue;
    }
    if (!region) {
	nrects = 1;
1016
	rects = xalloc (sizeof (xRectangle));
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
	if (!rects)
	    return BadAlloc;
	switch (stuff->kind) {
	case ShapeBounding:
	    rects->x = - (int) wBorderWidth (pWin);
	    rects->y = - (int) wBorderWidth (pWin);
	    rects->width = pWin->drawable.width + wBorderWidth (pWin);
	    rects->height = pWin->drawable.height + wBorderWidth (pWin);
	    break;
	case ShapeClip:
	    rects->x = 0;
	    rects->y = 0;
	    rects->width = pWin->drawable.width;
	    rects->height = pWin->drawable.height;
	    break;
1032 1033 1034 1035 1036 1037
	case ShapeInput:
	    rects->x = - (int) wBorderWidth (pWin);
	    rects->y = - (int) wBorderWidth (pWin);
	    rects->width = pWin->drawable.width + wBorderWidth (pWin);
	    rects->height = pWin->drawable.height + wBorderWidth (pWin);
	    break;
1038 1039 1040 1041 1042
	}
    } else {
	BoxPtr box;
	nrects = REGION_NUM_RECTS(region);
	box = REGION_RECTS(region);
1043
	rects = xalloc (nrects * sizeof (xRectangle));
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
	if (!rects && nrects)
	    return BadAlloc;
	for (i = 0; i < nrects; i++, box++) {
	    rects[i].x = box->x1;
	    rects[i].y = box->y1;
	    rects[i].width = box->x2 - box->x1;
	    rects[i].height = box->y2 - box->y1;
	}
    }
    rep.type = X_Reply;
    rep.sequenceNumber = client->sequence;
    rep.length = (nrects * sizeof (xRectangle)) >> 2;
    rep.ordering = YXBanded;
    rep.nrects = nrects;
    if (client->swapped) {
	swaps (&rep.sequenceNumber, n);
	swapl (&rep.length, n);
	swapl (&rep.nrects, n);
	SwapShorts ((short *)rects, (unsigned long)nrects * 4);
    }
    WriteToClient (client, sizeof (rep), (char *) &rep);
    WriteToClient (client, nrects * sizeof (xRectangle), (char *) rects);
Daniel Stone's avatar
Daniel Stone committed
1066
    xfree (rects);
1067 1068 1069 1070
    return client->noClientException;
}

static int
Julien Cristau's avatar
Julien Cristau committed
1071
ProcShapeDispatch (ClientPtr client)
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
{
    REQUEST(xReq);
    switch (stuff->data) {
    case X_ShapeQueryVersion:
	return ProcShapeQueryVersion (client);
    case X_ShapeRectangles:
#ifdef PANORAMIX
        if ( !noPanoramiXExtension )
	    return ProcPanoramiXShapeRectangles (client);
        else 
#endif
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
1083
	return ProcShapeRectangles (client);
1084 1085 1086 1087 1088 1089
    case X_ShapeMask:
#ifdef PANORAMIX
        if ( !noPanoramiXExtension )
           return ProcPanoramiXShapeMask (client);
	else
#endif
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
1090
	return ProcShapeMask (client);
1091 1092 1093 1094 1095 1096
    case X_ShapeCombine:
#ifdef PANORAMIX
        if ( !noPanoramiXExtension )
           return ProcPanoramiXShapeCombine (client);
	else
#endif
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
1097
	return ProcShapeCombine (client);
1098 1099 1100 1101 1102 1103
    case X_ShapeOffset:
#ifdef PANORAMIX
        if ( !noPanoramiXExtension )
           return ProcPanoramiXShapeOffset (client);
	else
#endif
Kaleb Keithley Keithley's avatar
Kaleb Keithley Keithley committed
1104
	return ProcShapeOffset (client);
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
    case X_ShapeQueryExtents:
	return ProcShapeQueryExtents (client);
    case X_ShapeSelectInput:
	return ProcShapeSelectInput (client);
    case X_ShapeInputSelected:
	return ProcShapeInputSelected (client);
    case X_ShapeGetRectangles:
	return ProcShapeGetRectangles (client);
    default:
	return BadRequest;
    }
}

static void
Julien Cristau's avatar
Julien Cristau committed
1119
SShapeNotifyEvent(xShapeNotifyEvent *from, xShapeNotifyEvent *to)
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
{
    to->type = from->type;
    to->kind = from->kind;
    cpswapl (from->window, to->window);
    cpswaps (from->sequenceNumber, to->sequenceNumber);
    cpswaps (from->x, to->x);
    cpswaps (from->y, to->y);
    cpswaps (from->width, to->width);
    cpswaps (from->height, to->height);
    cpswapl (from->time, to->time);
    to->shaped = from->shaped;
}

static int
Julien Cristau's avatar
Julien Cristau committed
1134
SProcShapeQueryVersion (ClientPtr client)
1135
{
1136
    int    n;
1137 1138 1139 1140 1141 1142 1143
    REQUEST (xShapeQueryVersionReq);

    swaps (&stuff->length, n);
    return ProcShapeQueryVersion (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1144
SProcShapeRectangles (ClientPtr client)
1145
{
1146
    char   n;
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
    REQUEST (xShapeRectanglesReq);

    swaps (&stuff->length, n);
    REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
    swapl (&stuff->dest, n);
    swaps (&stuff->xOff, n);
    swaps (&stuff->yOff, n);
    SwapRestS(stuff);
    return ProcShapeRectangles (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1159
SProcShapeMask (ClientPtr client)
1160
{
1161
    char   n;
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
    REQUEST (xShapeMaskReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeMaskReq);
    swapl (&stuff->dest, n);
    swaps (&stuff->xOff, n);
    swaps (&stuff->yOff, n);
    swapl (&stuff->src, n);
    return ProcShapeMask (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1174
SProcShapeCombine (ClientPtr client)
1175
{
1176
    char   n;
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
    REQUEST (xShapeCombineReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeCombineReq);
    swapl (&stuff->dest, n);
    swaps (&stuff->xOff, n);
    swaps (&stuff->yOff, n);
    swapl (&stuff->src, n);
    return ProcShapeCombine (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1189
SProcShapeOffset (ClientPtr client)
1190
{
1191
    char   n;
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
    REQUEST (xShapeOffsetReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeOffsetReq);
    swapl (&stuff->dest, n);
    swaps (&stuff->xOff, n);
    swaps (&stuff->yOff, n);
    return ProcShapeOffset (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1203
SProcShapeQueryExtents (ClientPtr client)
1204
{
1205
    char   n;
1206 1207 1208 1209 1210 1211 1212 1213 1214
    REQUEST (xShapeQueryExtentsReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
    swapl (&stuff->window, n);
    return ProcShapeQueryExtents (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1215
SProcShapeSelectInput (ClientPtr client)
1216
{
1217
    char   n;
1218 1219 1220 1221 1222 1223 1224 1225 1226
    REQUEST (xShapeSelectInputReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeSelectInputReq);
    swapl (&stuff->window, n);
    return ProcShapeSelectInput (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1227
SProcShapeInputSelected (ClientPtr client)
1228
{
1229
    int    n;
1230 1231 1232 1233 1234 1235 1236 1237 1238
    REQUEST (xShapeInputSelectedReq);

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
    swapl (&stuff->window, n);
    return ProcShapeInputSelected (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1239
SProcShapeGetRectangles (ClientPtr client)
1240 1241
{
    REQUEST(xShapeGetRectanglesReq);
1242
    char   n;
1243 1244 1245 1246 1247 1248 1249 1250

    swaps (&stuff->length, n);
    REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
    swapl (&stuff->window, n);
    return ProcShapeGetRectangles (client);
}

static int
Julien Cristau's avatar
Julien Cristau committed
1251
SProcShapeDispatch (ClientPtr client)
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
{
    REQUEST(xReq);
    switch (stuff->data) {
    case X_ShapeQueryVersion:
	return SProcShapeQueryVersion (client);
    case X_ShapeRectangles:
	return SProcShapeRectangles (client);
    case X_ShapeMask:
	return SProcShapeMask (client);
    case X_ShapeCombine:
	return SProcShapeCombine (client);
    case X_ShapeOffset:
	return SProcShapeOffset (client);
    case X_ShapeQueryExtents:
	return SProcShapeQueryExtents (client);
    case X_ShapeSelectInput:
	return SProcShapeSelectInput (client);
    case X_ShapeInputSelected:
	return SProcShapeInputSelected (client);
    case X_ShapeGetRectangles:
	return SProcShapeGetRectangles (client);
    default:
	return BadRequest;
    }
}