pax_global_header00006660000000000000000000000064114035715650014521gustar00rootroot0000000000000052 comment=8abc1c8e920821f5ed68e639d3fb71a4ad90a102 libXdamage-1.1.3/000075500000000000000000000000001140357156500135565ustar00rootroot00000000000000libXdamage-1.1.3/.gitignore000064400000000000000000000017531140357156500155540ustar00rootroot00000000000000# # X.Org module default exclusion patterns # The next section if for module specific patterns # # Do not edit the following section # GNU Build System (Autotools) aclocal.m4 autom4te.cache/ autoscan.log ChangeLog compile config.guess config.h config.h.in config.log config-ml.in config.py config.status config.status.lineno config.sub configure configure.scan depcomp .deps/ INSTALL install-sh .libs/ libtool libtool.m4 ltmain.sh lt~obsolete.m4 ltoptions.m4 ltsugar.m4 ltversion.m4 Makefile Makefile.in mdate-sh missing mkinstalldirs *.pc py-compile stamp-h? symlink-tree texinfo.tex ylwrap # Do not edit the following section # Edit Compile Debug Document Distribute *~ *.[0-9] *.[0-9]x *.bak *.bin core *.dll *.exe *-ISO*.bdf *-JIS*.bdf *-KOI8*.bdf *.kld *.ko *.ko.cmd *.lai *.l[oa] *.[oa] *.obj *.patch *.so *.pcf.gz *.pdb *.tar.bz2 *.tar.gz # # Add & Override patterns for libXdamage # # Edit the following section as needed # For example, !report.pc overrides *.pc. See 'man gitignore' # libXdamage-1.1.3/AUTHORS000064400000000000000000000000451140357156500146250ustar00rootroot00000000000000Keith Packard, HP Eric Anholt, Intel libXdamage-1.1.3/COPYING000064400000000000000000000021571140357156500146160ustar00rootroot00000000000000 Copyright © 2001,2003 Keith Packard Copyright © 2007 Eric Anholt 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. libXdamage-1.1.3/Makefile.am000064400000000000000000000026361140357156500156210ustar00rootroot00000000000000# # Copyright © 2003 Keith Packard, Noah Levitt # # 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. SUBDIRS = src INCLUDES = $(top_srcdir)/include/ pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = xdamage.pc MAINTAINERCLEANFILES = ChangeLog INSTALL .PHONY: ChangeLog INSTALL INSTALL: $(INSTALL_CMD) ChangeLog: $(CHANGELOG_CMD) dist-hook: ChangeLog INSTALL libXdamage-1.1.3/NEWS000064400000000000000000000001551140357156500142560ustar00rootroot000000000000002004-07-30: First release with xorg 6.8.0 2007-01-08: Release of version 1.1 supporting protocol version 1.1.libXdamage-1.1.3/README000064400000000000000000000014401140357156500144350ustar00rootroot00000000000000 Damage X Damage Extension Version 1.1 2007-01-04 This package contains the library for the X Damage extension. Keith Packard keithp@keithp.com All questions regarding this software should be directed at the Xorg mailing list: http://lists.freedesktop.org/mailman/listinfo/xorg Please submit bug reports to the Xorg bugzilla: https://bugs.freedesktop.org/enter_bug.cgi?product=xorg The master development code repository can be found at: git://anongit.freedesktop.org/git/xorg/lib/libXdamage http://cgit.freedesktop.org/xorg/lib/libXdamage For patch submission instructions, see: http://www.x.org/wiki/Development/Documentation/SubmittingPatches For more information on the git code manager, see: http://wiki.x.org/wiki/GitPage libXdamage-1.1.3/autogen.sh000075500000000000000000000003031140357156500155530ustar00rootroot00000000000000#! /bin/sh srcdir=`dirname $0` test -z "$srcdir" && srcdir=. ORIGDIR=`pwd` cd $srcdir autoreconf -v --install || exit 1 cd $ORIGDIR || exit $? $srcdir/configure --enable-maintainer-mode "$@" libXdamage-1.1.3/configure.ac000064400000000000000000000047371140357156500160570ustar00rootroot00000000000000dnl dnl Copyright © 2003 Keith Packard, Noah Levitt dnl dnl Permission to use, copy, modify, distribute, and sell this software and its dnl documentation for any purpose is hereby granted without fee, provided that dnl the above copyright notice appear in all copies and that both that dnl copyright notice and this permission notice appear in supporting dnl documentation, and that the name of Keith Packard not be used in dnl advertising or publicity pertaining to distribution of the software without dnl specific, written prior permission. Keith Packard makes no dnl representations about the suitability of this software for any purpose. It dnl is provided "as is" without express or implied warranty. dnl dnl KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, dnl INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO dnl EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR dnl CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, dnl DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER dnl TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR dnl PERFORMANCE OF THIS SOFTWARE. dnl dnl Process this file with autoconf to create configure. AC_PREREQ([2.60]) dnl dnl Version should match the current XDamage version. XDamageQueryVersion dnl returns the version from damagewire.h, NOT the version we set here. But we dnl try to keep these the same. Note that the library has an extra dnl digit in the version number to track changes which don't affect the dnl protocol, so Xdamage version l.n.m corresponds to protocol version l.n dnl AC_INIT(libXdamage, 1.1.3, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], libXdamage) AM_INIT_AUTOMAKE([foreign dist-bzip2]) AM_MAINTAINER_MODE # Require xorg-macros: XORG_DEFAULT_OPTIONS m4_ifndef([XORG_MACROS_VERSION], [m4_fatal([must install xorg-macros 1.3 or later before running autoconf/autogen])]) XORG_MACROS_VERSION(1.3) XORG_DEFAULT_OPTIONS AM_CONFIG_HEADER(config.h) # Check for progs AC_PROG_CC AC_PROG_LIBTOOL # Check damageext configuration, strip extra digits from package version to # find the required protocol version DAMAGEEXT_VERSION=[`echo $VERSION | sed 's/^\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/'`] AC_SUBST(DAMAGEEXT_VERSION) PKG_CHECK_MODULES(XDAMAGE, [damageproto >= $DAMAGEEXT_VERSION] xfixes fixesproto xextproto x11) AC_SUBST(XDAMAGE_CFLAGS) AC_OUTPUT([Makefile src/Makefile xdamage.pc]) libXdamage-1.1.3/include/000075500000000000000000000000001140357156500152015ustar00rootroot00000000000000libXdamage-1.1.3/include/X11/000075500000000000000000000000001140357156500155525ustar00rootroot00000000000000libXdamage-1.1.3/include/X11/extensions/000075500000000000000000000000001140357156500177515ustar00rootroot00000000000000libXdamage-1.1.3/include/X11/extensions/Xdamage.h000064400000000000000000000044041140357156500214720ustar00rootroot00000000000000/* * 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. */ #ifndef _XDAMAGE_H_ #define _XDAMAGE_H_ #include #include #include #define XDAMAGE_1_1_INTERFACE typedef XID Damage; typedef struct { int type; /* event base */ unsigned long serial; Bool send_event; Display *display; Drawable drawable; Damage damage; int level; Bool more; /* more events will be delivered immediately */ Time timestamp; XRectangle area; XRectangle geometry; } XDamageNotifyEvent; _XFUNCPROTOBEGIN Bool XDamageQueryExtension (Display *dpy, int *event_base_return, int *error_base_return); Status XDamageQueryVersion (Display *dpy, int *major_version_return, int *minor_version_return); Damage XDamageCreate (Display *dpy, Drawable drawable, int level); void XDamageDestroy (Display *dpy, Damage damage); void XDamageSubtract (Display *dpy, Damage damage, XserverRegion repair, XserverRegion parts); void XDamageAdd (Display *dpy, Drawable drawable, XserverRegion region); _XFUNCPROTOEND #endif /* _XDAMAGE_H_ */ libXdamage-1.1.3/src/000075500000000000000000000000001140357156500143455ustar00rootroot00000000000000libXdamage-1.1.3/src/Makefile.am000064400000000000000000000006331140357156500164030ustar00rootroot00000000000000lib_LTLIBRARIES = libXdamage.la libXdamage_la_SOURCES = \ xdamageint.h \ Xdamage.c libXdamage_la_LIBADD = $(XDAMAGE_LIBS) AM_CFLAGS = $(CWARNFLAGS) $(XDAMAGE_CFLAGS) INCLUDES = -I$(top_srcdir)/include/X11/extensions libXdamage_la_LDFLAGS = -version-number 1:1:0 -no-undefined libXdamageincludedir = $(includedir)/X11/extensions libXdamageinclude_HEADERS = $(top_srcdir)/include/X11/extensions/Xdamage.h libXdamage-1.1.3/src/Xdamage.c000064400000000000000000000246411140357156500160660ustar00rootroot00000000000000/* * Copyright © 2003 Keith Packard * Copyright © 2007 Eric Anholt * * 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. */ #ifdef HAVE_CONFIG_H #include #endif #include "xdamageint.h" XDamageExtInfo XDamageExtensionInfo; const char XDamageExtensionName[] = DAMAGE_NAME; static int XDamageCloseDisplay (Display *dpy, XExtCodes *codes); static Bool XDamageWireToEvent(Display *dpy, XEvent *event, xEvent *wire); static Status XDamageEventToWire(Display *dpy, XEvent *event, xEvent *wire); /* * XDamageExtAddDisplay - add a display to this extension. (Replaces * XextAddDisplay) */ static XDamageExtDisplayInfo * XDamageExtAddDisplay (XDamageExtInfo *extinfo, Display *dpy, const char *ext_name) { XDamageExtDisplayInfo *info; int ev; info = (XDamageExtDisplayInfo *) Xmalloc (sizeof (XDamageExtDisplayInfo)); 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) { xDamageQueryVersionReply rep; xDamageQueryVersionReq *req; XESetCloseDisplay (dpy, info->codes->extension, XDamageCloseDisplay); for (ev = info->codes->first_event; ev < info->codes->first_event + XDamageNumberEvents; ev++) { XESetWireToEvent (dpy, ev, XDamageWireToEvent); XESetEventToWire (dpy, ev, XDamageEventToWire); } /* * Get the version info */ LockDisplay (dpy); GetReq (DamageQueryVersion, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageQueryVersion; req->majorVersion = DAMAGE_MAJOR; req->minorVersion = DAMAGE_MINOR; if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { UnlockDisplay (dpy); SyncHandle (); Xfree(info); return NULL; } info->major_version = rep.majorVersion; info->minor_version = rep.minorVersion; UnlockDisplay (dpy); SyncHandle (); } 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, XDamageCloseDisplay); } /* * 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; } /* * XDamageExtRemoveDisplay - remove the indicated display from the * extension object. (Replaces XextRemoveDisplay.) */ static int XDamageExtRemoveDisplay (XDamageExtInfo *extinfo, Display *dpy) { XDamageExtDisplayInfo *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; } /* * XDamageExtFindDisplay - look for a display in this extension; keeps a * cache of the most-recently used for efficiency. (Replaces * XextFindDisplay.) */ static XDamageExtDisplayInfo * XDamageExtFindDisplay (XDamageExtInfo *extinfo, Display *dpy) { XDamageExtDisplayInfo *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; } XDamageExtDisplayInfo * XDamageFindDisplay (Display *dpy) { XDamageExtDisplayInfo *info; info = XDamageExtFindDisplay (&XDamageExtensionInfo, dpy); if (!info) info = XDamageExtAddDisplay (&XDamageExtensionInfo, dpy, XDamageExtensionName); return info; } static int XDamageCloseDisplay (Display *dpy, XExtCodes *codes) { return XDamageExtRemoveDisplay (&XDamageExtensionInfo, dpy); } static Bool XDamageWireToEvent(Display *dpy, XEvent *event, xEvent *wire) { XDamageExtDisplayInfo *info = XDamageFindDisplay(dpy); XDamageCheckExtension(dpy, info, False); switch ((wire->u.u.type & 0x7F) - info->codes->first_event) { case XDamageNotify: { XDamageNotifyEvent *aevent = (XDamageNotifyEvent *) event; xDamageNotifyEvent *awire = (xDamageNotifyEvent *) wire; aevent->type = awire->type & 0x7F; aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire); aevent->send_event = (awire->type & 0x80) != 0; aevent->display = dpy; aevent->drawable = awire->drawable; aevent->damage = awire->damage; aevent->level = awire->level & ~DamageNotifyMore; aevent->more = (awire->level & DamageNotifyMore) ? True : False; aevent->timestamp = awire->timestamp; aevent->area.x = awire->area.x; aevent->area.y = awire->area.y; aevent->area.width = awire->area.width; aevent->area.height = awire->area.height; aevent->geometry.x = awire->geometry.x; aevent->geometry.y = awire->geometry.y; aevent->geometry.width = awire->geometry.width; aevent->geometry.height = awire->geometry.height; return True; } } return False; } static Status XDamageEventToWire(Display *dpy, XEvent *event, xEvent *wire) { XDamageExtDisplayInfo *info = XDamageFindDisplay(dpy); XDamageCheckExtension(dpy, info, False); switch ((event->type & 0x7F) - info->codes->first_event) { case XDamageNotify: { XDamageNotifyEvent *aevent; xDamageNotifyEvent *awire; awire = (xDamageNotifyEvent *) wire; aevent = (XDamageNotifyEvent *) event; awire->type = aevent->type | (aevent->send_event ? 0x80 : 0); awire->drawable = aevent->drawable; awire->damage = aevent->damage; awire->level = aevent->level | (aevent->more ? DamageNotifyMore : 0); awire->timestamp = aevent->timestamp; awire->area.x = aevent->area.x; awire->area.y = aevent->area.y; awire->area.width = aevent->area.width; awire->area.height = aevent->area.height; awire->geometry.x = aevent->geometry.x; awire->geometry.y = aevent->geometry.y; awire->geometry.width = aevent->geometry.width; awire->geometry.height = aevent->geometry.height; return True; } } return False; } Bool XDamageQueryExtension (Display *dpy, int *event_base_return, int *error_base_return) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); if (XDamageHasExtension(info)) { *event_base_return = info->codes->first_event; *error_base_return = info->codes->first_error; return True; } else return False; } Status XDamageQueryVersion (Display *dpy, int *major_version_return, int *minor_version_return) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); XDamageCheckExtension (dpy, info, 0); *major_version_return = info->major_version; *minor_version_return = info->minor_version; return 1; } Damage XDamageCreate (Display *dpy, Drawable drawable, int level) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); xDamageCreateReq *req; Damage damage; XDamageCheckExtension (dpy, info, 0); LockDisplay (dpy); GetReq (DamageCreate, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageCreate; req->damage = damage = XAllocID (dpy); req->drawable = drawable; req->level = level; UnlockDisplay (dpy); SyncHandle (); return damage; } void XDamageDestroy (Display *dpy, Damage damage) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); xDamageDestroyReq *req; XDamageSimpleCheckExtension (dpy, info); LockDisplay (dpy); GetReq (DamageDestroy, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageDestroy; req->damage = damage; UnlockDisplay (dpy); SyncHandle (); } void XDamageSubtract (Display *dpy, Damage damage, XserverRegion repair, XserverRegion parts) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); xDamageSubtractReq *req; XDamageSimpleCheckExtension (dpy, info); LockDisplay (dpy); GetReq (DamageSubtract, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageSubtract; req->damage = damage; req->repair = repair; req->parts = parts; UnlockDisplay (dpy); SyncHandle (); } void XDamageAdd (Display *dpy, Drawable drawable, XserverRegion region) { XDamageExtDisplayInfo *info = XDamageFindDisplay (dpy); xDamageAddReq *req; XDamageSimpleCheckExtension (dpy, info); LockDisplay (dpy); GetReq (DamageAdd, req); req->reqType = info->codes->major_opcode; req->damageReqType = X_DamageAdd; req->drawable = drawable; req->region = region; UnlockDisplay (dpy); SyncHandle (); } libXdamage-1.1.3/src/xdamageint.h000064400000000000000000000047021140357156500166420ustar00rootroot00000000000000/* * 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. */ #ifndef _XDAMAGEINT_H_ #define _XDAMAGEINT_H_ #define NEED_EVENTS #define NEED_REPLIES #include #include #include #include #include #include "Xdamage.h" typedef struct _XDamageExtDisplayInfo { struct _XDamageExtDisplayInfo *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 */ } XDamageExtDisplayInfo; /* replaces XExtensionInfo */ typedef struct _XDamageExtInfo { XDamageExtDisplayInfo *head; /* start of the list */ XDamageExtDisplayInfo *cur; /* most recently used */ int ndisplays; /* number of displays */ } XDamageExtInfo; extern XDamageExtInfo XDamageExtensionInfo; extern const char XDamageExtensionName[]; XDamageExtDisplayInfo * XDamageFindDisplay (Display *dpy); #define XDamageHasExtension(i) ((i) && ((i)->codes)) #define XDamageCheckExtension(dpy,i,val) \ if (!XDamageHasExtension(i)) { return val; } #define XDamageSimpleCheckExtension(dpy,i) \ if (!XDamageHasExtension(i)) { return; } #endif /* _XDAMAGEINT_H_ */ libXdamage-1.1.3/xdamage.pc.in000064400000000000000000000004471140357156500161220ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: Xdamage Description: X Damage Library Version: @PACKAGE_VERSION@ Requires: xproto damageproto >= @DAMAGEEXT_VERSION@ xfixes Requires.private: x11 xfixes Cflags: -I${includedir} Libs: -L${libdir} -lXdamage