1 /************************************************************
3 Copyright 1987, 1998 The Open Group
5 Permission to use, copy, modify, distribute, and sell this software and its
6 documentation for any purpose is hereby granted without fee, provided that
7 the above copyright notice appear in all copies and that both that
8 copyright notice and this permission notice appear in supporting
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 Except as contained in this notice, the name of The Open Group shall not be
22 used in advertising or otherwise to promote the sale, use or other dealings
23 in this Software without prior written authorization from The Open Group.
25 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
29 Permission to use, copy, modify, and distribute this software and its
30 documentation for any purpose and without fee is hereby granted,
31 provided that the above copyright notice appear in all copies and that
32 both that copyright notice and this permission notice appear in
33 supporting documentation, and that the name of Digital not be
34 used in advertising or publicity pertaining to distribution of the
35 software without specific, written prior permission.
37 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
45 ********************************************************/
47 #ifdef HAVE_DIX_CONFIG_H
48 #include <dix-config.h>
52 #include <X11/Xproto.h>
53 #include <X11/Xprotostr.h>
55 #include "dixstruct.h"
56 #include "extnsionst.h" /* for SendEvent */
59 /* Thanks to Jack Palevich for testing and subsequently rewriting all this */
61 /* Byte swap a list of longs */
63 SwapLongs(CARD32
*list
, unsigned long count
)
81 } while (--count
!= 0);
85 /* Byte swap a list of shorts */
87 SwapShorts(short *list
, unsigned long count
)
113 } while (--count
!= 0);
117 /* The following is used for all requests that have
118 no fields to be swapped (except "length") */
120 SProcSimpleReq(ClientPtr client
)
123 swaps(&stuff
->length
);
124 return (*ProcVector
[stuff
->reqType
]) (client
);
127 /* The following is used for all requests that have
128 only a single 32-bit field to be swapped, coming
129 right after the "length" field */
131 SProcResourceReq(ClientPtr client
)
133 REQUEST(xResourceReq
);
134 swaps(&stuff
->length
);
135 REQUEST_AT_LEAST_SIZE(xResourceReq
); /* not EXACT */
137 return (*ProcVector
[stuff
->reqType
]) (client
);
141 SProcCreateWindow(ClientPtr client
)
143 REQUEST(xCreateWindowReq
);
144 swaps(&stuff
->length
);
145 REQUEST_AT_LEAST_SIZE(xCreateWindowReq
);
147 swapl(&stuff
->parent
);
150 swaps(&stuff
->width
);
151 swaps(&stuff
->height
);
152 swaps(&stuff
->borderWidth
);
153 swaps(&stuff
->class);
154 swapl(&stuff
->visual
);
157 return ((*ProcVector
[X_CreateWindow
]) (client
));
161 SProcChangeWindowAttributes(ClientPtr client
)
163 REQUEST(xChangeWindowAttributesReq
);
164 swaps(&stuff
->length
);
165 REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq
);
166 swapl(&stuff
->window
);
167 swapl(&stuff
->valueMask
);
169 return ((*ProcVector
[X_ChangeWindowAttributes
]) (client
));
173 SProcReparentWindow(ClientPtr client
)
175 REQUEST(xReparentWindowReq
);
176 swaps(&stuff
->length
);
177 REQUEST_SIZE_MATCH(xReparentWindowReq
);
178 swapl(&stuff
->window
);
179 swapl(&stuff
->parent
);
182 return ((*ProcVector
[X_ReparentWindow
]) (client
));
186 SProcConfigureWindow(ClientPtr client
)
188 REQUEST(xConfigureWindowReq
);
189 swaps(&stuff
->length
);
190 REQUEST_AT_LEAST_SIZE(xConfigureWindowReq
);
191 swapl(&stuff
->window
);
194 return ((*ProcVector
[X_ConfigureWindow
]) (client
));
199 SProcInternAtom(ClientPtr client
)
201 REQUEST(xInternAtomReq
);
202 swaps(&stuff
->length
);
203 REQUEST_AT_LEAST_SIZE(xInternAtomReq
);
204 swaps(&stuff
->nbytes
);
205 return ((*ProcVector
[X_InternAtom
]) (client
));
209 SProcChangeProperty(ClientPtr client
)
211 REQUEST(xChangePropertyReq
);
212 swaps(&stuff
->length
);
213 REQUEST_AT_LEAST_SIZE(xChangePropertyReq
);
214 swapl(&stuff
->window
);
215 swapl(&stuff
->property
);
217 swapl(&stuff
->nUnits
);
218 switch (stuff
->format
) {
228 return ((*ProcVector
[X_ChangeProperty
]) (client
));
232 SProcDeleteProperty(ClientPtr client
)
234 REQUEST(xDeletePropertyReq
);
235 swaps(&stuff
->length
);
236 REQUEST_SIZE_MATCH(xDeletePropertyReq
);
237 swapl(&stuff
->window
);
238 swapl(&stuff
->property
);
239 return ((*ProcVector
[X_DeleteProperty
]) (client
));
244 SProcGetProperty(ClientPtr client
)
246 REQUEST(xGetPropertyReq
);
247 swaps(&stuff
->length
);
248 REQUEST_SIZE_MATCH(xGetPropertyReq
);
249 swapl(&stuff
->window
);
250 swapl(&stuff
->property
);
252 swapl(&stuff
->longOffset
);
253 swapl(&stuff
->longLength
);
254 return ((*ProcVector
[X_GetProperty
]) (client
));
258 SProcSetSelectionOwner(ClientPtr client
)
260 REQUEST(xSetSelectionOwnerReq
);
261 swaps(&stuff
->length
);
262 REQUEST_SIZE_MATCH(xSetSelectionOwnerReq
);
263 swapl(&stuff
->window
);
264 swapl(&stuff
->selection
);
266 return ((*ProcVector
[X_SetSelectionOwner
]) (client
));
270 SProcConvertSelection(ClientPtr client
)
272 REQUEST(xConvertSelectionReq
);
273 swaps(&stuff
->length
);
274 REQUEST_SIZE_MATCH(xConvertSelectionReq
);
275 swapl(&stuff
->requestor
);
276 swapl(&stuff
->selection
);
277 swapl(&stuff
->target
);
278 swapl(&stuff
->property
);
280 return ((*ProcVector
[X_ConvertSelection
]) (client
));
284 SProcSendEvent(ClientPtr client
)
286 xEvent eventT
= { .u
.u
.type
= 0 };
289 REQUEST(xSendEventReq
);
290 swaps(&stuff
->length
);
291 REQUEST_SIZE_MATCH(xSendEventReq
);
292 swapl(&stuff
->destination
);
293 swapl(&stuff
->eventMask
);
296 proc
= EventSwapVector
[stuff
->event
.u
.u
.type
& 0177];
297 if (!proc
|| proc
== NotImplemented
) /* no swapping proc; invalid event type? */
299 (*proc
) (&stuff
->event
, &eventT
);
300 stuff
->event
= eventT
;
302 return ((*ProcVector
[X_SendEvent
]) (client
));
306 SProcGrabPointer(ClientPtr client
)
308 REQUEST(xGrabPointerReq
);
309 swaps(&stuff
->length
);
310 REQUEST_SIZE_MATCH(xGrabPointerReq
);
311 swapl(&stuff
->grabWindow
);
312 swaps(&stuff
->eventMask
);
313 swapl(&stuff
->confineTo
);
314 swapl(&stuff
->cursor
);
316 return ((*ProcVector
[X_GrabPointer
]) (client
));
320 SProcGrabButton(ClientPtr client
)
322 REQUEST(xGrabButtonReq
);
323 swaps(&stuff
->length
);
324 REQUEST_SIZE_MATCH(xGrabButtonReq
);
325 swapl(&stuff
->grabWindow
);
326 swaps(&stuff
->eventMask
);
327 swapl(&stuff
->confineTo
);
328 swapl(&stuff
->cursor
);
329 swaps(&stuff
->modifiers
);
330 return ((*ProcVector
[X_GrabButton
]) (client
));
334 SProcUngrabButton(ClientPtr client
)
336 REQUEST(xUngrabButtonReq
);
337 swaps(&stuff
->length
);
338 REQUEST_SIZE_MATCH(xUngrabButtonReq
);
339 swapl(&stuff
->grabWindow
);
340 swaps(&stuff
->modifiers
);
341 return ((*ProcVector
[X_UngrabButton
]) (client
));
345 SProcChangeActivePointerGrab(ClientPtr client
)
347 REQUEST(xChangeActivePointerGrabReq
);
348 swaps(&stuff
->length
);
349 REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq
);
350 swapl(&stuff
->cursor
);
352 swaps(&stuff
->eventMask
);
353 return ((*ProcVector
[X_ChangeActivePointerGrab
]) (client
));
357 SProcGrabKeyboard(ClientPtr client
)
359 REQUEST(xGrabKeyboardReq
);
360 swaps(&stuff
->length
);
361 REQUEST_SIZE_MATCH(xGrabKeyboardReq
);
362 swapl(&stuff
->grabWindow
);
364 return ((*ProcVector
[X_GrabKeyboard
]) (client
));
368 SProcGrabKey(ClientPtr client
)
370 REQUEST(xGrabKeyReq
);
371 swaps(&stuff
->length
);
372 REQUEST_SIZE_MATCH(xGrabKeyReq
);
373 swapl(&stuff
->grabWindow
);
374 swaps(&stuff
->modifiers
);
375 return ((*ProcVector
[X_GrabKey
]) (client
));
379 SProcUngrabKey(ClientPtr client
)
381 REQUEST(xUngrabKeyReq
);
382 swaps(&stuff
->length
);
383 REQUEST_SIZE_MATCH(xUngrabKeyReq
);
384 swapl(&stuff
->grabWindow
);
385 swaps(&stuff
->modifiers
);
386 return ((*ProcVector
[X_UngrabKey
]) (client
));
390 SProcGetMotionEvents(ClientPtr client
)
392 REQUEST(xGetMotionEventsReq
);
393 swaps(&stuff
->length
);
394 REQUEST_SIZE_MATCH(xGetMotionEventsReq
);
395 swapl(&stuff
->window
);
396 swapl(&stuff
->start
);
398 return ((*ProcVector
[X_GetMotionEvents
]) (client
));
402 SProcTranslateCoords(ClientPtr client
)
404 REQUEST(xTranslateCoordsReq
);
405 swaps(&stuff
->length
);
406 REQUEST_SIZE_MATCH(xTranslateCoordsReq
);
407 swapl(&stuff
->srcWid
);
408 swapl(&stuff
->dstWid
);
411 return ((*ProcVector
[X_TranslateCoords
]) (client
));
415 SProcWarpPointer(ClientPtr client
)
417 REQUEST(xWarpPointerReq
);
418 swaps(&stuff
->length
);
419 REQUEST_SIZE_MATCH(xWarpPointerReq
);
420 swapl(&stuff
->srcWid
);
421 swapl(&stuff
->dstWid
);
424 swaps(&stuff
->srcWidth
);
425 swaps(&stuff
->srcHeight
);
428 return ((*ProcVector
[X_WarpPointer
]) (client
));
432 SProcSetInputFocus(ClientPtr client
)
434 REQUEST(xSetInputFocusReq
);
435 swaps(&stuff
->length
);
436 REQUEST_SIZE_MATCH(xSetInputFocusReq
);
437 swapl(&stuff
->focus
);
439 return ((*ProcVector
[X_SetInputFocus
]) (client
));
443 SProcOpenFont(ClientPtr client
)
445 REQUEST(xOpenFontReq
);
446 swaps(&stuff
->length
);
447 REQUEST_AT_LEAST_SIZE(xOpenFontReq
);
449 swaps(&stuff
->nbytes
);
450 return ((*ProcVector
[X_OpenFont
]) (client
));
454 SProcListFonts(ClientPtr client
)
456 REQUEST(xListFontsReq
);
457 swaps(&stuff
->length
);
458 REQUEST_AT_LEAST_SIZE(xListFontsReq
);
459 swaps(&stuff
->maxNames
);
460 swaps(&stuff
->nbytes
);
461 return ((*ProcVector
[X_ListFonts
]) (client
));
465 SProcListFontsWithInfo(ClientPtr client
)
467 REQUEST(xListFontsWithInfoReq
);
468 swaps(&stuff
->length
);
469 REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq
);
470 swaps(&stuff
->maxNames
);
471 swaps(&stuff
->nbytes
);
472 return ((*ProcVector
[X_ListFontsWithInfo
]) (client
));
476 SProcSetFontPath(ClientPtr client
)
478 REQUEST(xSetFontPathReq
);
479 swaps(&stuff
->length
);
480 REQUEST_AT_LEAST_SIZE(xSetFontPathReq
);
481 swaps(&stuff
->nFonts
);
482 return ((*ProcVector
[X_SetFontPath
]) (client
));
486 SProcCreatePixmap(ClientPtr client
)
488 REQUEST(xCreatePixmapReq
);
490 swaps(&stuff
->length
);
491 REQUEST_SIZE_MATCH(xCreatePixmapReq
);
493 swapl(&stuff
->drawable
);
494 swaps(&stuff
->width
);
495 swaps(&stuff
->height
);
496 return ((*ProcVector
[X_CreatePixmap
]) (client
));
500 SProcCreateGC(ClientPtr client
)
502 REQUEST(xCreateGCReq
);
503 swaps(&stuff
->length
);
504 REQUEST_AT_LEAST_SIZE(xCreateGCReq
);
506 swapl(&stuff
->drawable
);
509 return ((*ProcVector
[X_CreateGC
]) (client
));
513 SProcChangeGC(ClientPtr client
)
515 REQUEST(xChangeGCReq
);
516 swaps(&stuff
->length
);
517 REQUEST_AT_LEAST_SIZE(xChangeGCReq
);
521 return ((*ProcVector
[X_ChangeGC
]) (client
));
525 SProcCopyGC(ClientPtr client
)
528 swaps(&stuff
->length
);
529 REQUEST_SIZE_MATCH(xCopyGCReq
);
530 swapl(&stuff
->srcGC
);
531 swapl(&stuff
->dstGC
);
533 return ((*ProcVector
[X_CopyGC
]) (client
));
537 SProcSetDashes(ClientPtr client
)
539 REQUEST(xSetDashesReq
);
540 swaps(&stuff
->length
);
541 REQUEST_AT_LEAST_SIZE(xSetDashesReq
);
543 swaps(&stuff
->dashOffset
);
544 swaps(&stuff
->nDashes
);
545 return ((*ProcVector
[X_SetDashes
]) (client
));
550 SProcSetClipRectangles(ClientPtr client
)
552 REQUEST(xSetClipRectanglesReq
);
553 swaps(&stuff
->length
);
554 REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq
);
556 swaps(&stuff
->xOrigin
);
557 swaps(&stuff
->yOrigin
);
559 return ((*ProcVector
[X_SetClipRectangles
]) (client
));
563 SProcClearToBackground(ClientPtr client
)
565 REQUEST(xClearAreaReq
);
566 swaps(&stuff
->length
);
567 REQUEST_SIZE_MATCH(xClearAreaReq
);
568 swapl(&stuff
->window
);
571 swaps(&stuff
->width
);
572 swaps(&stuff
->height
);
573 return ((*ProcVector
[X_ClearArea
]) (client
));
577 SProcCopyArea(ClientPtr client
)
579 REQUEST(xCopyAreaReq
);
580 swaps(&stuff
->length
);
581 REQUEST_SIZE_MATCH(xCopyAreaReq
);
582 swapl(&stuff
->srcDrawable
);
583 swapl(&stuff
->dstDrawable
);
589 swaps(&stuff
->width
);
590 swaps(&stuff
->height
);
591 return ((*ProcVector
[X_CopyArea
]) (client
));
595 SProcCopyPlane(ClientPtr client
)
597 REQUEST(xCopyPlaneReq
);
598 swaps(&stuff
->length
);
599 REQUEST_SIZE_MATCH(xCopyPlaneReq
);
600 swapl(&stuff
->srcDrawable
);
601 swapl(&stuff
->dstDrawable
);
607 swaps(&stuff
->width
);
608 swaps(&stuff
->height
);
609 swapl(&stuff
->bitPlane
);
610 return ((*ProcVector
[X_CopyPlane
]) (client
));
613 /* The following routine is used for all Poly drawing requests
614 (except FillPoly, which uses a different request format) */
616 SProcPoly(ClientPtr client
)
618 REQUEST(xPolyPointReq
);
619 swaps(&stuff
->length
);
620 REQUEST_AT_LEAST_SIZE(xPolyPointReq
);
621 swapl(&stuff
->drawable
);
624 return ((*ProcVector
[stuff
->reqType
]) (client
));
627 /* cannot use SProcPoly for this one, because xFillPolyReq
628 is longer than xPolyPointReq, and we don't want to swap
629 the difference as shorts! */
631 SProcFillPoly(ClientPtr client
)
633 REQUEST(xFillPolyReq
);
634 swaps(&stuff
->length
);
635 REQUEST_AT_LEAST_SIZE(xFillPolyReq
);
636 swapl(&stuff
->drawable
);
639 return ((*ProcVector
[X_FillPoly
]) (client
));
643 SProcPutImage(ClientPtr client
)
645 REQUEST(xPutImageReq
);
646 swaps(&stuff
->length
);
647 REQUEST_AT_LEAST_SIZE(xPutImageReq
);
648 swapl(&stuff
->drawable
);
650 swaps(&stuff
->width
);
651 swaps(&stuff
->height
);
654 /* Image should already be swapped */
655 return ((*ProcVector
[X_PutImage
]) (client
));
660 SProcGetImage(ClientPtr client
)
662 REQUEST(xGetImageReq
);
663 swaps(&stuff
->length
);
664 REQUEST_SIZE_MATCH(xGetImageReq
);
665 swapl(&stuff
->drawable
);
668 swaps(&stuff
->width
);
669 swaps(&stuff
->height
);
670 swapl(&stuff
->planeMask
);
671 return ((*ProcVector
[X_GetImage
]) (client
));
674 /* ProcPolyText used for both PolyText8 and PolyText16 */
677 SProcPolyText(ClientPtr client
)
679 REQUEST(xPolyTextReq
);
680 swaps(&stuff
->length
);
681 REQUEST_AT_LEAST_SIZE(xPolyTextReq
);
682 swapl(&stuff
->drawable
);
686 return ((*ProcVector
[stuff
->reqType
]) (client
));
689 /* ProcImageText used for both ImageText8 and ImageText16 */
692 SProcImageText(ClientPtr client
)
694 REQUEST(xImageTextReq
);
695 swaps(&stuff
->length
);
696 REQUEST_AT_LEAST_SIZE(xImageTextReq
);
697 swapl(&stuff
->drawable
);
701 return ((*ProcVector
[stuff
->reqType
]) (client
));
705 SProcCreateColormap(ClientPtr client
)
707 REQUEST(xCreateColormapReq
);
708 swaps(&stuff
->length
);
709 REQUEST_SIZE_MATCH(xCreateColormapReq
);
711 swapl(&stuff
->window
);
712 swapl(&stuff
->visual
);
713 return ((*ProcVector
[X_CreateColormap
]) (client
));
717 SProcCopyColormapAndFree(ClientPtr client
)
719 REQUEST(xCopyColormapAndFreeReq
);
720 swaps(&stuff
->length
);
721 REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq
);
723 swapl(&stuff
->srcCmap
);
724 return ((*ProcVector
[X_CopyColormapAndFree
]) (client
));
729 SProcAllocColor(ClientPtr client
)
731 REQUEST(xAllocColorReq
);
732 swaps(&stuff
->length
);
733 REQUEST_SIZE_MATCH(xAllocColorReq
);
736 swaps(&stuff
->green
);
738 return ((*ProcVector
[X_AllocColor
]) (client
));
742 SProcAllocNamedColor(ClientPtr client
)
744 REQUEST(xAllocNamedColorReq
);
745 swaps(&stuff
->length
);
746 REQUEST_AT_LEAST_SIZE(xAllocNamedColorReq
);
748 swaps(&stuff
->nbytes
);
749 return ((*ProcVector
[X_AllocNamedColor
]) (client
));
753 SProcAllocColorCells(ClientPtr client
)
755 REQUEST(xAllocColorCellsReq
);
756 swaps(&stuff
->length
);
757 REQUEST_SIZE_MATCH(xAllocColorCellsReq
);
759 swaps(&stuff
->colors
);
760 swaps(&stuff
->planes
);
761 return ((*ProcVector
[X_AllocColorCells
]) (client
));
765 SProcAllocColorPlanes(ClientPtr client
)
767 REQUEST(xAllocColorPlanesReq
);
768 swaps(&stuff
->length
);
769 REQUEST_SIZE_MATCH(xAllocColorPlanesReq
);
771 swaps(&stuff
->colors
);
773 swaps(&stuff
->green
);
775 return ((*ProcVector
[X_AllocColorPlanes
]) (client
));
779 SProcFreeColors(ClientPtr client
)
781 REQUEST(xFreeColorsReq
);
782 swaps(&stuff
->length
);
783 REQUEST_AT_LEAST_SIZE(xFreeColorsReq
);
785 swapl(&stuff
->planeMask
);
787 return ((*ProcVector
[X_FreeColors
]) (client
));
792 SwapColorItem(xColorItem
* pItem
)
794 swapl(&pItem
->pixel
);
796 swaps(&pItem
->green
);
801 SProcStoreColors(ClientPtr client
)
806 REQUEST(xStoreColorsReq
);
807 swaps(&stuff
->length
);
808 REQUEST_AT_LEAST_SIZE(xStoreColorsReq
);
810 pItem
= (xColorItem
*) &stuff
[1];
811 for (count
= LengthRestB(stuff
) / sizeof(xColorItem
); --count
>= 0;)
812 SwapColorItem(pItem
++);
813 return ((*ProcVector
[X_StoreColors
]) (client
));
817 SProcStoreNamedColor(ClientPtr client
)
819 REQUEST(xStoreNamedColorReq
);
820 swaps(&stuff
->length
);
821 REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq
);
823 swapl(&stuff
->pixel
);
824 swaps(&stuff
->nbytes
);
825 return ((*ProcVector
[X_StoreNamedColor
]) (client
));
829 SProcQueryColors(ClientPtr client
)
831 REQUEST(xQueryColorsReq
);
832 swaps(&stuff
->length
);
833 REQUEST_AT_LEAST_SIZE(xQueryColorsReq
);
836 return ((*ProcVector
[X_QueryColors
]) (client
));
840 SProcLookupColor(ClientPtr client
)
842 REQUEST(xLookupColorReq
);
843 swaps(&stuff
->length
);
844 REQUEST_AT_LEAST_SIZE(xLookupColorReq
);
846 swaps(&stuff
->nbytes
);
847 return ((*ProcVector
[X_LookupColor
]) (client
));
851 SProcCreateCursor(ClientPtr client
)
853 REQUEST(xCreateCursorReq
);
854 swaps(&stuff
->length
);
855 REQUEST_SIZE_MATCH(xCreateCursorReq
);
857 swapl(&stuff
->source
);
859 swaps(&stuff
->foreRed
);
860 swaps(&stuff
->foreGreen
);
861 swaps(&stuff
->foreBlue
);
862 swaps(&stuff
->backRed
);
863 swaps(&stuff
->backGreen
);
864 swaps(&stuff
->backBlue
);
867 return ((*ProcVector
[X_CreateCursor
]) (client
));
871 SProcCreateGlyphCursor(ClientPtr client
)
873 REQUEST(xCreateGlyphCursorReq
);
874 swaps(&stuff
->length
);
875 REQUEST_SIZE_MATCH(xCreateGlyphCursorReq
);
877 swapl(&stuff
->source
);
879 swaps(&stuff
->sourceChar
);
880 swaps(&stuff
->maskChar
);
881 swaps(&stuff
->foreRed
);
882 swaps(&stuff
->foreGreen
);
883 swaps(&stuff
->foreBlue
);
884 swaps(&stuff
->backRed
);
885 swaps(&stuff
->backGreen
);
886 swaps(&stuff
->backBlue
);
887 return ((*ProcVector
[X_CreateGlyphCursor
]) (client
));
891 SProcRecolorCursor(ClientPtr client
)
893 REQUEST(xRecolorCursorReq
);
894 swaps(&stuff
->length
);
895 REQUEST_SIZE_MATCH(xRecolorCursorReq
);
896 swapl(&stuff
->cursor
);
897 swaps(&stuff
->foreRed
);
898 swaps(&stuff
->foreGreen
);
899 swaps(&stuff
->foreBlue
);
900 swaps(&stuff
->backRed
);
901 swaps(&stuff
->backGreen
);
902 swaps(&stuff
->backBlue
);
903 return ((*ProcVector
[X_RecolorCursor
]) (client
));
907 SProcQueryBestSize(ClientPtr client
)
909 REQUEST(xQueryBestSizeReq
);
910 swaps(&stuff
->length
);
911 REQUEST_SIZE_MATCH(xQueryBestSizeReq
);
912 swapl(&stuff
->drawable
);
913 swaps(&stuff
->width
);
914 swaps(&stuff
->height
);
915 return ((*ProcVector
[X_QueryBestSize
]) (client
));
920 SProcQueryExtension(ClientPtr client
)
922 REQUEST(xQueryExtensionReq
);
923 swaps(&stuff
->length
);
924 REQUEST_AT_LEAST_SIZE(xQueryExtensionReq
);
925 swaps(&stuff
->nbytes
);
926 return ((*ProcVector
[X_QueryExtension
]) (client
));
930 SProcChangeKeyboardMapping(ClientPtr client
)
932 REQUEST(xChangeKeyboardMappingReq
);
933 swaps(&stuff
->length
);
934 REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq
);
936 return ((*ProcVector
[X_ChangeKeyboardMapping
]) (client
));
940 SProcChangeKeyboardControl(ClientPtr client
)
942 REQUEST(xChangeKeyboardControlReq
);
943 swaps(&stuff
->length
);
944 REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq
);
947 return ((*ProcVector
[X_ChangeKeyboardControl
]) (client
));
951 SProcChangePointerControl(ClientPtr client
)
953 REQUEST(xChangePointerControlReq
);
954 swaps(&stuff
->length
);
955 REQUEST_SIZE_MATCH(xChangePointerControlReq
);
956 swaps(&stuff
->accelNum
);
957 swaps(&stuff
->accelDenum
);
958 swaps(&stuff
->threshold
);
959 return ((*ProcVector
[X_ChangePointerControl
]) (client
));
963 SProcSetScreenSaver(ClientPtr client
)
965 REQUEST(xSetScreenSaverReq
);
966 swaps(&stuff
->length
);
967 REQUEST_SIZE_MATCH(xSetScreenSaverReq
);
968 swaps(&stuff
->timeout
);
969 swaps(&stuff
->interval
);
970 return ((*ProcVector
[X_SetScreenSaver
]) (client
));
974 SProcChangeHosts(ClientPtr client
)
976 REQUEST(xChangeHostsReq
);
977 swaps(&stuff
->length
);
978 REQUEST_AT_LEAST_SIZE(xChangeHostsReq
);
979 swaps(&stuff
->hostLength
);
980 return ((*ProcVector
[X_ChangeHosts
]) (client
));
985 SProcRotateProperties(ClientPtr client
)
987 REQUEST(xRotatePropertiesReq
);
988 swaps(&stuff
->length
);
989 REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq
);
990 swapl(&stuff
->window
);
991 swaps(&stuff
->nAtoms
);
992 swaps(&stuff
->nPositions
);
994 return ((*ProcVector
[X_RotateProperties
]) (client
));
998 SProcNoOperation(ClientPtr client
)
1001 swaps(&stuff
->length
);
1002 return ((*ProcVector
[X_NoOperation
]) (client
));
1006 SwapConnClientPrefix(xConnClientPrefix
* pCCP
)
1008 swaps(&pCCP
->majorVersion
);
1009 swaps(&pCCP
->minorVersion
);
1010 swaps(&pCCP
->nbytesAuthProto
);
1011 swaps(&pCCP
->nbytesAuthString
);