From b083c691fe7707146f728e563247a18aa601c19b Mon Sep 17 00:00:00 2001 From: Eric Anholt Date: Sat, 31 Jul 2004 05:50:39 +0000 Subject: Bring in Xfixes, Xdamage, and Xcomposite userland from xserver CVS: - Update Xfixes headers to protocol major version 3. - Add composite headers. - Add libXfixes, libXdamage, and libXcomposite. - Add imake glue for new libraries, but leave Composite off by default until issues are resolved. --- src/Cursor.c | 217 ++++++++++++++++++++++++++++ src/Region.c | 438 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/SaveSet.c | 45 ++++++ src/Selection.c | 47 ++++++ src/Xfixes.c | 330 ++++++++++++++++++++++++++++++++++++++++++ src/Xfixesint.h | 68 +++++++++ 6 files changed, 1145 insertions(+) create mode 100644 src/Cursor.c create mode 100644 src/Region.c create mode 100644 src/SaveSet.c create mode 100644 src/Selection.c create mode 100644 src/Xfixes.c create mode 100644 src/Xfixesint.h (limited to 'src') diff --git a/src/Cursor.c b/src/Cursor.c new file mode 100644 index 0000000..c3d1123 --- /dev/null +++ b/src/Cursor.c @@ -0,0 +1,217 @@ +/* + * $XFree86: xc/lib/Xfixes/Cursor.c,v 1.1 2002/11/30 06:21:44 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Xfixesint.h" + +void +XFixesSelectCursorInput (Display *dpy, + Window win, + unsigned long eventMask) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSelectCursorInputReq *req; + + XFixesSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + GetReq (XFixesSelectCursorInput, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSelectCursorInput; + req->window = win; + req->eventMask = eventMask; + UnlockDisplay (dpy); + SyncHandle (); +} + +XFixesCursorImage * +XFixesGetCursorImage (Display *dpy) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesGetCursorImageAndNameReq *req; + xXFixesGetCursorImageAndNameReply rep; + int npixels; + int nbytes_name; + int nbytes, nread, rlength; + XFixesCursorImage *image; + char *name; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesGetCursorImageAndName, req); + req->reqType = info->codes->major_opcode; + if (info->major_version >= 2) + req->xfixesReqType = X_XFixesGetCursorImageAndName; + else + req->xfixesReqType = X_XFixesGetCursorImage; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + if (info->major_version < 2) + { + rep.cursorName = None; + rep.nbytes = 0; + } + npixels = rep.width * rep.height; + nbytes_name = rep.nbytes; + /* reply data length */ + nbytes = (long) rep.length << 2; + /* bytes of actual data in the reply */ + nread = (npixels << 2) + nbytes_name; + /* size of data returned to application */ + rlength = (sizeof (XFixesCursorImage) + + npixels * sizeof (unsigned long) + + nbytes_name + 1); + + image = (XFixesCursorImage *) Xmalloc (rlength); + if (!image) + { + _XEatData (dpy, nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + image->x = rep.x; + image->y = rep.y; + image->width = rep.width; + image->height = rep.height; + image->xhot = rep.xhot; + image->yhot = rep.yhot; + image->cursor_serial = rep.cursorSerial; + image->pixels = (unsigned long *) (image + 1); + image->atom = rep.cursorName; + name = (char *) (image->pixels + npixels); + image->name = name; + _XRead32 (dpy, image->pixels, npixels << 2); + _XRead (dpy, name, nbytes_name); + name[nbytes_name] = '\0'; /* null-terminate */ + /* skip any padding */ + if(nbytes > nread) + { + _XEatData (dpy, (unsigned long) (nbytes - nread)); + } + UnlockDisplay (dpy); + SyncHandle (); + return image; +} + +void +XFixesSetCursorName (Display *dpy, Cursor cursor, const char *name) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSetCursorNameReq *req; + int nbytes = strlen (name); + + XFixesSimpleCheckExtension (dpy, info); + if (info->major_version < 2) + return; + LockDisplay (dpy); + GetReq (XFixesSetCursorName, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSetCursorName; + req->cursor = cursor; + req->nbytes = nbytes; + req->length += (nbytes + 3) >> 2; + Data (dpy, name, nbytes); + UnlockDisplay (dpy); + SyncHandle (); +} + +const char * +XFixesGetCursorName (Display *dpy, Cursor cursor, Atom *atom) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesGetCursorNameReq *req; + xXFixesGetCursorNameReply rep; + char *name; + + XFixesCheckExtension (dpy, info, 0); + if (info->major_version < 2) + return 0; + LockDisplay (dpy); + GetReq (XFixesGetCursorName, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesGetCursorName; + req->cursor = cursor; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + *atom = rep.atom; + if ((name = (char *) Xmalloc(rep.nbytes+1))) { + _XReadPad(dpy, name, (long)rep.nbytes); + name[rep.nbytes] = '\0'; + } else { + _XEatData(dpy, (unsigned long) (rep.nbytes + 3) & ~3); + name = (char *) NULL; + } + UnlockDisplay(dpy); + SyncHandle(); + return(name); +} + +void +XFixesChangeCursor (Display *dpy, Cursor source, Cursor destination) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesChangeCursorReq *req; + + XFixesSimpleCheckExtension (dpy, info); + if (info->major_version < 2) + return; + LockDisplay (dpy); + GetReq (XFixesChangeCursor, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesChangeCursor; + req->source = source; + req->destination = destination; + UnlockDisplay(dpy); + SyncHandle(); +} + +void +XFixesChangeCursorByName (Display *dpy, Cursor source, const char *name) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesChangeCursorByNameReq *req; + int nbytes = strlen (name); + + XFixesSimpleCheckExtension (dpy, info); + if (info->major_version < 2) + return; + LockDisplay (dpy); + GetReq (XFixesChangeCursorByName, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesChangeCursorByName; + req->source = source; + req->nbytes = nbytes; + req->length += (nbytes + 3) >> 2; + Data (dpy, name, nbytes); + UnlockDisplay(dpy); + SyncHandle(); +} diff --git a/src/Region.c b/src/Region.c new file mode 100644 index 0000000..6bf0329 --- /dev/null +++ b/src/Region.c @@ -0,0 +1,438 @@ +/* + * $Id$ + * + * Copyright © 2003 Keith Packard + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Xfixesint.h" + +XserverRegion +XFixesCreateRegion (Display *dpy, XRectangle *rectangles, int nrectangles) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCreateRegionReq *req; + long len; + XserverRegion region; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesCreateRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCreateRegion; + region = req->region = XAllocID (dpy); + len = ((long) nrectangles) << 1; + SetReqLen (req, len, len); + len <<= 2; + Data16 (dpy, (short *) rectangles, len); + UnlockDisplay (dpy); + SyncHandle(); + return region; +} + +XserverRegion +XFixesCreateRegionFromBitmap (Display *dpy, Pixmap bitmap) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCreateRegionFromBitmapReq *req; + XserverRegion region; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesCreateRegionFromBitmap, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCreateRegionFromBitmap; + region = req->region = XAllocID (dpy); + req->bitmap = bitmap; + UnlockDisplay (dpy); + SyncHandle(); + return region; +} + +XserverRegion +XFixesCreateRegionFromWindow (Display *dpy, Window window, int kind) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCreateRegionFromWindowReq *req; + XserverRegion region; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesCreateRegionFromWindow, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCreateRegionFromWindow; + region = req->region = XAllocID (dpy); + req->window = window; + req->kind = kind; + UnlockDisplay (dpy); + SyncHandle(); + return region; +} + +XserverRegion +XFixesCreateRegionFromGC (Display *dpy, GC gc) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCreateRegionFromGCReq *req; + XserverRegion region; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesCreateRegionFromGC, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCreateRegionFromGC; + region = req->region = XAllocID (dpy); + req->gc = gc->gid; + UnlockDisplay (dpy); + SyncHandle(); + return region; +} + +XserverRegion +XFixesCreateRegionFromPicture (Display *dpy, XID picture) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCreateRegionFromPictureReq *req; + XserverRegion region; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesCreateRegionFromPicture, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCreateRegionFromPicture; + region = req->region = XAllocID (dpy); + req->picture = picture; + UnlockDisplay (dpy); + SyncHandle(); + return region; +} + +void +XFixesDestroyRegion (Display *dpy, XserverRegion region) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesDestroyRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesDestroyRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesDestroyRegion; + req->region = region; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesSetRegion (Display *dpy, XserverRegion region, + XRectangle *rectangles, int nrectangles) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSetRegionReq *req; + long len; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesSetRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSetRegion; + req->region = region; + len = ((long) nrectangles) << 1; + SetReqLen (req, len, len); + len <<= 2; + Data16 (dpy, (short *) rectangles, len); + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesCopyRegion (Display *dpy, XserverRegion dst, XserverRegion src) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesCopyRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesCopyRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesCopyRegion; + req->source = src; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesUnionRegion (Display *dpy, XserverRegion dst, + XserverRegion src1, XserverRegion src2) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesUnionRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesUnionRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesUnionRegion; + req->source1 = src1; + req->source2 = src2; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesIntersectRegion (Display *dpy, XserverRegion dst, + XserverRegion src1, XserverRegion src2) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesIntersectRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesIntersectRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesIntersectRegion; + req->source1 = src1; + req->source2 = src2; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesSubtractRegion (Display *dpy, XserverRegion dst, + XserverRegion src1, XserverRegion src2) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSubtractRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesSubtractRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSubtractRegion; + req->source1 = src1; + req->source2 = src2; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesInvertRegion (Display *dpy, XserverRegion dst, + XRectangle *rect, XserverRegion src) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesInvertRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesInvertRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesInvertRegion; + req->source = src; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesTranslateRegion (Display *dpy, XserverRegion region, int dx, int dy) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesTranslateRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesTranslateRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesTranslateRegion; + req->region = region; + req->dx = dx; + req->dy = dy; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesRegionExtents (Display *dpy, XserverRegion dst, XserverRegion src) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesRegionExtentsReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesRegionExtents, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesRegionExtents; + req->source = src; + req->destination = dst; + UnlockDisplay (dpy); + SyncHandle(); +} + +XRectangle * +XFixesFetchRegion (Display *dpy, XserverRegion region, int *nrectanglesRet) +{ + XRectangle bounds; + + return XFixesFetchRegionAndBounds (dpy, region, nrectanglesRet, &bounds); +} + +XRectangle * +XFixesFetchRegionAndBounds (Display *dpy, + XserverRegion region, + int *nrectanglesRet, + XRectangle *bounds) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesFetchRegionReq *req; + xXFixesFetchRegionReply rep; + XRectangle *rects; + int nrects; + long nbytes; + long nread; + + XFixesCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (XFixesFetchRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesFetchRegion; + req->region = region; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + bounds->x = rep.x; + bounds->y = rep.y; + bounds->width = rep.width; + bounds->height = rep.height; + nbytes = (long) rep.length << 2; + nrects = rep.length >> 1; + nread = nrects << 3; + rects = Xmalloc (nrects * sizeof (XRectangle)); + if (!rects) + { + _XEatData (dpy, nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + _XRead16 (dpy, (short *) rects, nrects << 3); + /* skip any padding */ + if(nbytes > nread) + { + _XEatData (dpy, (unsigned long) (nbytes - nread)); + } + UnlockDisplay (dpy); + SyncHandle(); + *nrectanglesRet = nrects; + return rects; +} + +void +XFixesSetGCClipRegion (Display *dpy, GC gc, + int clip_x_origin, int clip_y_origin, + XserverRegion region) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSetGCClipRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesSetGCClipRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSetGCClipRegion; + req->gc = gc->gid; + req->region = region; + req->xOrigin = clip_x_origin; + req->yOrigin = clip_y_origin; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesSetWindowShapeRegion (Display *dpy, Window win, int shape_kind, + int x_off, int y_off, XserverRegion region) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSetWindowShapeRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesSetWindowShapeRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSetWindowShapeRegion; + req->dest = win; + req->destKind = shape_kind; + req->xOff = x_off; + req->yOff = y_off; + req->region = region; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesSetPictureClipRegion (Display *dpy, XID picture, + int clip_x_origin, int clip_y_origin, + XserverRegion region) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSetPictureClipRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesSetPictureClipRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSetPictureClipRegion; + req->picture = picture; + req->region = region; + req->xOrigin = clip_x_origin; + req->yOrigin = clip_y_origin; + UnlockDisplay (dpy); + SyncHandle(); +} + +void +XFixesExpandRegion (Display *dpy, XserverRegion dst, XserverRegion src, + unsigned left, unsigned right, + unsigned top, unsigned bottom) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesExpandRegionReq *req; + + XFixesSimpleCheckExtension (dpy, info); + LockDisplay (dpy); + GetReq (XFixesExpandRegion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesExpandRegion; + req->source = src; + req->destination = dst; + req->left = left; + req->right = right; + req->top = top; + req->bottom = bottom; + UnlockDisplay (dpy); + SyncHandle(); +} + diff --git a/src/SaveSet.c b/src/SaveSet.c new file mode 100644 index 0000000..bb690ab --- /dev/null +++ b/src/SaveSet.c @@ -0,0 +1,45 @@ +/* + * $XFree86: xc/lib/Xfixes/SaveSet.c,v 1.1 2002/11/30 18:41:33 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Xfixesint.h" + +void +XFixesChangeSaveSet (Display *dpy, Window win, int mode, int target, int map) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesChangeSaveSetReq *req; + + XFixesSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + GetReq (XFixesChangeSaveSet, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesChangeSaveSet; + req->mode = mode; + req->target = target; + req->map = map; + req->window = win; + UnlockDisplay (dpy); + SyncHandle (); +} diff --git a/src/Selection.c b/src/Selection.c new file mode 100644 index 0000000..41679ce --- /dev/null +++ b/src/Selection.c @@ -0,0 +1,47 @@ +/* + * $XFree86: xc/lib/Xfixes/Selection.c,v 1.1 2002/11/30 06:21:45 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Xfixesint.h" + +void +XFixesSelectSelectionInput (Display *dpy, + Window win, + Atom selection, + unsigned long eventMask) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + xXFixesSelectSelectionInputReq *req; + + XFixesSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + GetReq (XFixesSelectSelectionInput, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesSelectSelectionInput; + req->window = win; + req->selection = selection; + req->eventMask = eventMask; + UnlockDisplay (dpy); + SyncHandle (); +} diff --git a/src/Xfixes.c b/src/Xfixes.c new file mode 100644 index 0000000..36d747f --- /dev/null +++ b/src/Xfixes.c @@ -0,0 +1,330 @@ +/* + * $XFree86: xc/lib/Xfixes/Xfixes.c,v 1.1 2002/11/30 06:21:45 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#include "Xfixesint.h" + +XFixesExtInfo XFixesExtensionInfo; +char XFixesExtensionName[] = XFIXES_NAME; + +static int +XFixesCloseDisplay (Display *dpy, XExtCodes *codes); + +static Bool +XFixesWireToEvent(Display *dpy, XEvent *event, xEvent *wire); + +static Status +XFixesEventToWire(Display *dpy, XEvent *event, xEvent *wire); + +/* + * XFixesExtAddDisplay - add a display to this extension. (Replaces + * XextAddDisplay) + */ +static XFixesExtDisplayInfo * +XFixesExtAddDisplay (XFixesExtInfo *extinfo, + Display *dpy, + char *ext_name) +{ + XFixesExtDisplayInfo *info; + int ev; + + info = (XFixesExtDisplayInfo *) Xmalloc (sizeof (XFixesExtDisplayInfo)); + if (!info) return NULL; + info->display = dpy; + + info->codes = XInitExtension (dpy, ext_name); + + /* + * if the server has the extension, then we can initialize the + * appropriate function vectors + */ + if (info->codes) { + xXFixesQueryVersionReply rep; + xXFixesQueryVersionReq *req; + XESetCloseDisplay (dpy, info->codes->extension, + XFixesCloseDisplay); + for (ev = info->codes->first_event; + ev < info->codes->first_event + XFixesNumberEvents; + ev++) + { + XESetWireToEvent (dpy, ev, XFixesWireToEvent); + XESetEventToWire (dpy, ev, XFixesEventToWire); + } + /* + * Get the version info + */ + LockDisplay (dpy); + GetReq (XFixesQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->xfixesReqType = X_XFixesQueryVersion; + req->majorVersion = XFIXES_MAJOR; + req->minorVersion = XFIXES_MINOR; + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) + { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + info->major_version = rep.majorVersion; + info->minor_version = rep.minorVersion; + UnlockDisplay (dpy); + } else { + /* The server doesn't have this extension. + * Use a private Xlib-internal extension to hang the close_display + * hook on so that the "cache" (extinfo->cur) is properly cleaned. + * (XBUG 7955) + */ + XExtCodes *codes = XAddExtension(dpy); + if (!codes) { + XFree(info); + return NULL; + } + XESetCloseDisplay (dpy, codes->extension, XFixesCloseDisplay); + } + + /* + * now, chain it onto the list + */ + _XLockMutex(_Xglobal_lock); + info->next = extinfo->head; + extinfo->head = info; + extinfo->cur = info; + extinfo->ndisplays++; + _XUnlockMutex(_Xglobal_lock); + return info; +} + + +/* + * XFixesExtRemoveDisplay - remove the indicated display from the + * extension object. (Replaces XextRemoveDisplay.) + */ +static int +XFixesExtRemoveDisplay (XFixesExtInfo *extinfo, Display *dpy) +{ + XFixesExtDisplayInfo *info, *prev; + + /* + * locate this display and its back link so that it can be removed + */ + _XLockMutex(_Xglobal_lock); + prev = NULL; + for (info = extinfo->head; info; info = info->next) { + if (info->display == dpy) break; + prev = info; + } + if (!info) { + _XUnlockMutex(_Xglobal_lock); + return 0; /* hmm, actually an error */ + } + + /* + * remove the display from the list; handles going to zero + */ + if (prev) + prev->next = info->next; + else + extinfo->head = info->next; + + extinfo->ndisplays--; + if (info == extinfo->cur) extinfo->cur = NULL; /* flush cache */ + _XUnlockMutex(_Xglobal_lock); + + Xfree ((char *) info); + return 1; +} + +/* + * XFixesExtFindDisplay - look for a display in this extension; keeps a + * cache of the most-recently used for efficiency. (Replaces + * XextFindDisplay.) + */ +static XFixesExtDisplayInfo * +XFixesExtFindDisplay (XFixesExtInfo *extinfo, + Display *dpy) +{ + XFixesExtDisplayInfo *info; + + /* + * see if this was the most recently accessed display + */ + if ((info = extinfo->cur) && info->display == dpy) + return info; + + /* + * look for display in list + */ + _XLockMutex(_Xglobal_lock); + for (info = extinfo->head; info; info = info->next) { + if (info->display == dpy) { + extinfo->cur = info; /* cache most recently used */ + _XUnlockMutex(_Xglobal_lock); + return info; + } + } + _XUnlockMutex(_Xglobal_lock); + + return NULL; +} + +XFixesExtDisplayInfo * +XFixesFindDisplay (Display *dpy) +{ + XFixesExtDisplayInfo *info; + + info = XFixesExtFindDisplay (&XFixesExtensionInfo, dpy); + if (!info) + info = XFixesExtAddDisplay (&XFixesExtensionInfo, dpy, + XFixesExtensionName); + return info; +} + +static int +XFixesCloseDisplay (Display *dpy, XExtCodes *codes) +{ + return XFixesExtRemoveDisplay (&XFixesExtensionInfo, dpy); +} + +static Bool +XFixesWireToEvent(Display *dpy, XEvent *event, xEvent *wire) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay(dpy); + + XFixesCheckExtension(dpy, info, False); + + switch ((wire->u.u.type & 0x7F) - info->codes->first_event) + { + case XFixesSelectionNotify: { + XFixesSelectionNotifyEvent *aevent; + xXFixesSelectionNotifyEvent *awire; + awire = (xXFixesSelectionNotifyEvent *) wire; + aevent = (XFixesSelectionNotifyEvent *) event; + aevent->type = awire->type & 0x7F; + aevent->subtype = awire->subtype; + aevent->serial = _XSetLastRequestRead(dpy, + (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->window = awire->window; + aevent->owner = awire->owner; + aevent->selection = awire->selection; + aevent->timestamp = awire->timestamp; + aevent->selection_timestamp = awire->selectionTimestamp; + return True; + } + case XFixesCursorNotify: { + XFixesCursorNotifyEvent *aevent; + xXFixesCursorNotifyEvent *awire; + awire = (xXFixesCursorNotifyEvent *) wire; + aevent = (XFixesCursorNotifyEvent *) event; + aevent->type = awire->type & 0x7F; + aevent->subtype = awire->subtype; + aevent->serial = _XSetLastRequestRead(dpy, + (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->window = awire->window; + aevent->cursor_serial = awire->cursorSerial; + aevent->timestamp = awire->timestamp; + aevent->cursor_name = awire->name; + return True; + } + } + return False; +} + +static Status +XFixesEventToWire(Display *dpy, XEvent *event, xEvent *wire) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay(dpy); + + XFixesCheckExtension(dpy, info, False); + + switch ((event->type & 0x7F) - info->codes->first_event) + { + case XFixesSelectionNotify: { + XFixesSelectionNotifyEvent *aevent; + xXFixesSelectionNotifyEvent *awire; + awire = (xXFixesSelectionNotifyEvent *) wire; + aevent = (XFixesSelectionNotifyEvent *) event; + awire->type = aevent->type | (aevent->send_event ? 0x80 : 0); + awire->subtype = aevent->subtype; + awire->window = aevent->window; + awire->owner = aevent->owner; + awire->selection = aevent->selection; + awire->timestamp = aevent->timestamp; + awire->selectionTimestamp = aevent->selection_timestamp; + return True; + } + case XFixesCursorNotify: { + XFixesCursorNotifyEvent *aevent; + xXFixesCursorNotifyEvent *awire; + awire = (xXFixesCursorNotifyEvent *) wire; + aevent = (XFixesCursorNotifyEvent *) event; + awire->type = aevent->type | (aevent->send_event ? 0x80 : 0); + awire->subtype = aevent->subtype; + awire->window = aevent->window; + awire->timestamp = aevent->timestamp; + awire->cursorSerial = aevent->cursor_serial; + awire->name = aevent->cursor_name; + } + } + return False; +} + +Bool +XFixesQueryExtension (Display *dpy, int *event_basep, int *error_basep) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + + if (XFixesHasExtension(info)) + { + *event_basep = info->codes->first_event; + *error_basep = info->codes->first_error; + return True; + } + else + return False; +} + +Status +XFixesQueryVersion (Display *dpy, + int *major_versionp, + int *minor_versionp) +{ + XFixesExtDisplayInfo *info = XFixesFindDisplay (dpy); + + XFixesCheckExtension (dpy, info, 0); + + *major_versionp = info->major_version; + *minor_versionp = info->minor_version; + UnlockDisplay (dpy); + SyncHandle (); + return 1; +} + +int +XFixesVersion (void) +{ + return XFIXES_VERSION; +} diff --git a/src/Xfixesint.h b/src/Xfixesint.h new file mode 100644 index 0000000..35e18b5 --- /dev/null +++ b/src/Xfixesint.h @@ -0,0 +1,68 @@ +/* + * $XFree86: xc/lib/Xfixes/Xfixesint.h,v 1.1 2002/11/30 06:21:45 keithp Exp $ + * + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * 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, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFIXESINT_H_ +#define _XFIXESINT_H_ + +#define NEED_EVENTS +#define NEED_REPLIES +#include +#include +#include +#include +#include "Xfixes.h" +#include + +extern char XFixesExtensionName[]; + +typedef struct _XFixesExtDisplayInfo { + struct _XFixesExtDisplayInfo *next; /* keep a linked list */ + Display *display; /* which display this is */ + XExtCodes *codes; /* the extension protocol codes */ + int major_version; /* -1 means we don't know */ + int minor_version; /* -1 means we don't know */ +} XFixesExtDisplayInfo; + +/* replaces XExtensionInfo */ +typedef struct _XFixesExtInfo { + XFixesExtDisplayInfo *head; /* start of the list */ + XFixesExtDisplayInfo *cur; /* most recently used */ + int ndisplays; /* number of displays */ +} XFixesExtInfo; + +extern XFixesExtInfo XFixesExtensionInfo; +extern char XFixesExtensionName[]; + +XFixesExtDisplayInfo * +XFixesFindDisplay (Display *dpy); + +#define XFixesHasExtension(i) ((i) && ((i)->codes)) + +#define XFixesCheckExtension(dpy,i,val) \ + if (!XFixesHasExtension(i)) { return val; } + +#define XFixesSimpleCheckExtension(dpy,i) \ + if (!XFixesHasExtension(i)) { return; } + +#endif /* _XFIXESINT_H_ */ -- cgit v1.2.3