From: SooChan Lim Date: Mon, 3 Sep 2012 04:32:53 +0000 (+0900) Subject: upgrade for xorg-server 1.12.99.905 (for 1.13 RC) X-Git-Tag: 2.0_alpha^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=HEAD;p=framework%2Fuifw%2Fxorg%2Flib%2Flibxrandr.git upgrade for xorg-server 1.12.99.905 (for 1.13 RC) Change-Id: I0bb4586a4b191105614f2970b34952b276317990 --- diff --git a/AUTHORS b/AUTHORS index 3fbe686..e794390 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,2 +1,2 @@ -Jim Gettys, Compaq and Hewlett-Packard, and Keith Packard, +Jim Gettys, Compaq and Hewlett-Packard, and Keith Packard, SuSE and Hewlett-Packard diff --git a/COPYING b/COPYING index 1552c1f..29a2f5d 100644 --- a/COPYING +++ b/COPYING @@ -1,4 +1,4 @@ -Copyright © 2000, Compaq Computer Corporation, +Copyright © 2000, Compaq Computer Corporation, Copyright © 2002, Hewlett Packard, Inc. Permission to use, copy, modify, distribute, and sell this software and its @@ -15,7 +15,7 @@ HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL HP 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 +OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Copyright © 2000 Compaq Computer Corporation, Inc. diff --git a/Makefile.am b/Makefile.am index 860193e..7d6700d 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,6 +1,6 @@ -# +# # 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 @@ -10,7 +10,7 @@ # 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 @@ -19,7 +19,7 @@ # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR # PERFORMANCE OF THIS SOFTWARE. -SUBDIRS = src man +SUBDIRS = src man pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = xrandr.pc diff --git a/autogen.sh b/autogen.sh new file mode 100755 index 0000000..218197d --- /dev/null +++ b/autogen.sh @@ -0,0 +1,12 @@ +#! /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 "$@" diff --git a/configure.ac b/configure.ac index 8c74adb..d89cc8b 100644 --- a/configure.ac +++ b/configure.ac @@ -29,7 +29,7 @@ AC_PREREQ([2.60]) # digit in the version number to track changes which don't affect the # protocol, so Xrandr version l.n.m corresponds to protocol version l.n # -AC_INIT([libXrandr], [1.3.2], +AC_INIT([libXrandr], [1.4.0], [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], [libXrandr]) AC_CONFIG_SRCDIR([Makefile.am]) AC_CONFIG_HEADERS([config.h]) @@ -40,7 +40,7 @@ AM_MAINTAINER_MODE # Initialize libtool AC_PROG_LIBTOOL - + # Require X.Org macros 1.8 or later for MAN_SUBSTS set by XORG_MANPAGE_SECTIONS m4_ifndef([XORG_MACROS_VERSION], [m4_fatal([must install xorg-macros 1.8 or later before running autoconf/autogen])]) diff --git a/include/X11/extensions/Xrandr.h b/include/X11/extensions/Xrandr.h index 6b756a7..b1baf8a 100644 --- a/include/X11/extensions/Xrandr.h +++ b/include/X11/extensions/Xrandr.h @@ -39,6 +39,7 @@ _XFUNCPROTOBEGIN typedef XID RROutput; typedef XID RRCrtc; typedef XID RRMode; +typedef XID RRProvider; typedef struct { int width, height; @@ -118,8 +119,43 @@ typedef struct { int state; /* NewValue, Deleted */ } XRROutputPropertyNotifyEvent; +typedef struct { + int type; /* event base */ + unsigned long serial; /* # of last request processed by server */ + Bool send_event; /* true if this came from a SendEvent request */ + Display *display; /* Display the event was read from */ + Window window; /* window which selected for this event */ + int subtype; /* RRNotify_ProviderChange */ + RRProvider provider; /* current provider (or None) */ + Time timestamp; /* time of change */ + unsigned int current_role; +} XRRProviderChangeNotifyEvent; + +typedef struct { + int type; /* event base */ + unsigned long serial; /* # of last request processed by server */ + Bool send_event; /* true if this came from a SendEvent request */ + Display *display; /* Display the event was read from */ + Window window; /* window which selected for this event */ + int subtype; /* RRNotify_ProviderProperty */ + RRProvider provider; /* related provider */ + Atom property; /* changed property */ + Time timestamp; /* time of change */ + int state; /* NewValue, Deleted */ +} XRRProviderPropertyNotifyEvent; + +typedef struct { + int type; /* event base */ + unsigned long serial; /* # of last request processed by server */ + Bool send_event; /* true if this came from a SendEvent request */ + Display *display; /* Display the event was read from */ + Window window; /* window which selected for this event */ + int subtype; /* RRNotify_ResourceChange */ + Time timestamp; /* time of change */ +} XRRResourceChangeNotifyEvent; + /* internal representation is private to the library */ -typedef struct _XRRScreenConfiguration XRRScreenConfiguration; +typedef struct _XRRScreenConfiguration XRRScreenConfiguration; Bool XRRQueryExtension (Display *dpy, int *event_base_return, @@ -130,17 +166,17 @@ Status XRRQueryVersion (Display *dpy, XRRScreenConfiguration *XRRGetScreenInfo (Display *dpy, Window window); - + void XRRFreeScreenConfigInfo (XRRScreenConfiguration *config); -/* +/* * Note that screen configuration changes are only permitted if the client can * prove it has up to date configuration information. We are trying to * insist that it become possible for screens to change dynamically, so * we want to ensure the client knows what it is talking about when requesting * changes. */ -Status XRRSetScreenConfig (Display *dpy, +Status XRRSetScreenConfig (Display *dpy, XRRScreenConfiguration *config, Drawable draw, int size_index, @@ -148,7 +184,7 @@ Status XRRSetScreenConfig (Display *dpy, Time timestamp); /* added in v1.1, sorry for the lame name */ -Status XRRSetScreenConfigAndRate (Display *dpy, +Status XRRSetScreenConfigAndRate (Display *dpy, XRRScreenConfiguration *config, Drawable draw, int size_index, @@ -165,14 +201,14 @@ XRRScreenSize *XRRConfigSizes(XRRScreenConfiguration *config, int *nsizes); short *XRRConfigRates (XRRScreenConfiguration *config, int sizeID, int *nrates); -SizeID XRRConfigCurrentConfiguration (XRRScreenConfiguration *config, +SizeID XRRConfigCurrentConfiguration (XRRScreenConfiguration *config, Rotation *rotation); - + short XRRConfigCurrentRate (XRRScreenConfiguration *config); int XRRRootToScreen(Display *dpy, Window root); -/* +/* * returns the screen configuration for the specified screen; does a lazy * evalution to delay getting the information, and caches the result. * These routines should be used in preference to XRRGetScreenInfo @@ -183,9 +219,9 @@ int XRRRootToScreen(Display *dpy, Window root); void XRRSelectInput(Display *dpy, Window window, int mask); -/* - * the following are always safe to call, even if RandR is not implemented - * on a screen +/* + * the following are always safe to call, even if RandR is not implemented + * on a screen */ @@ -237,7 +273,7 @@ typedef struct _XRRScreenResources { int nmode; XRRModeInfo *modes; } XRRScreenResources; - + XRRScreenResources * XRRGetScreenResources (Display *dpy, Window window); @@ -286,7 +322,7 @@ void XRRConfigureOutputProperty (Display *dpy, RROutput output, Atom property, Bool pending, Bool range, int num_values, long *values); - + void XRRChangeOutputProperty (Display *dpy, RROutput output, Atom property, Atom type, @@ -321,7 +357,7 @@ XRRDeleteOutputMode (Display *dpy, RROutput output, RRMode mode); void XRRFreeModeInfo (XRRModeInfo *modeInfo); - + typedef struct _XRRCrtcInfo { Time timestamp; int x, y; @@ -381,7 +417,7 @@ XRRGetScreenResourcesCurrent (Display *dpy, Window window); void XRRSetCrtcTransform (Display *dpy, - RRCrtc crtc, + RRCrtc crtc, XTransform *transform, char *filter, XFixed *params, @@ -408,7 +444,7 @@ XRRGetCrtcTransform (Display *dpy, XRRCrtcTransformAttributes **attributes); /* - * intended to take RRScreenChangeNotify, or + * intended to take RRScreenChangeNotify, or * ConfigureNotify (on the root window) * returns 1 if it is an event type it understands, 0 if not */ @@ -451,6 +487,71 @@ RROutput XRRGetOutputPrimary(Display *dpy, Window window); +typedef struct _XRRProviderResources { + Time timestamp; + int nproviders; + RRProvider *providers; +} XRRProviderResources; + +XRRProviderResources * +XRRGetProviderResources(Display *dpy, Window window); + +void +XRRFreeProviderResources(XRRProviderResources *resources); + +typedef struct _XRRProviderInfo { + unsigned int capabilities; + int ncrtcs; + RRCrtc *crtcs; + int noutputs; + RROutput *outputs; + char *name; + int nassociatedproviders; + RRProvider *associated_providers; + unsigned int *associated_capability; + int nameLen; +} XRRProviderInfo; + +XRRProviderInfo * +XRRGetProviderInfo(Display *dpy, XRRScreenResources *resources, RRProvider provider); + +void +XRRFreeProviderInfo(XRRProviderInfo *provider); + +int +XRRSetProviderOutputSource(Display *dpy, XID provider, XID source_provider); + +int +XRRSetProviderOffloadSink(Display *dpy, XID provider, XID sink_provider); + +Atom * +XRRListProviderProperties (Display *dpy, RRProvider provider, int *nprop); + +XRRPropertyInfo * +XRRQueryProviderProperty (Display *dpy, RRProvider provider, Atom property); + +void +XRRConfigureProviderProperty (Display *dpy, RRProvider provider, Atom property, + Bool pending, Bool range, int num_values, + long *values); + +void +XRRChangeProviderProperty (Display *dpy, RRProvider provider, + Atom property, Atom type, + int format, int mode, + _Xconst unsigned char *data, int nelements); + +void +XRRDeleteProviderProperty (Display *dpy, RRProvider provider, Atom property); + +int +XRRGetProviderProperty (Display *dpy, RRProvider provider, + Atom property, long offset, long length, + Bool _delete, Bool pending, Atom req_type, + Atom *actual_type, int *actual_format, + unsigned long *nitems, unsigned long *bytes_after, + unsigned char **prop); + _XFUNCPROTOEND #endif /* _XRANDR_H_ */ diff --git a/packaging/libXrandr.spec b/packaging/libXrandr.spec index 2b97570..7ada469 100644 --- a/packaging/libXrandr.spec +++ b/packaging/libXrandr.spec @@ -1,6 +1,6 @@ Summary: X.Org X11 libXrandr runtime library Name: libXrandr -Version: 1.3.1 +Version: 1.4.0 Release: 3 License: MIT Group: System Environment/Libraries diff --git a/src/Makefile.am b/src/Makefile.am index 85b05da..7a47b9c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -8,7 +8,9 @@ libXrandr_la_SOURCES = \ XrrMode.c \ XrrOutput.c \ XrrProperty.c \ - XrrScreen.c + XrrScreen.c \ + XrrProvider.c \ + XrrProviderProperty.c libXrandr_la_LIBADD = @RANDR_LIBS@ @@ -22,4 +24,4 @@ INCLUDES = -I$(top_srcdir)/include/X11/extensions libXrandr_la_LDFLAGS = -version-number 2:2:0 -no-undefined libXrandrincludedir = $(includedir)/X11/extensions -libXrandrinclude_HEADERS = $(top_srcdir)/include/X11/extensions/Xrandr.h +libXrandrinclude_HEADERS = $(top_srcdir)/include/X11/extensions/Xrandr.h diff --git a/src/Xrandr.c b/src/Xrandr.c index 8ab1eae..b1e97ec 100644 --- a/src/Xrandr.c +++ b/src/Xrandr.c @@ -16,7 +16,7 @@ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL COMPAQ * 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 + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Jim Gettys, HP Labs, HP. @@ -137,7 +137,46 @@ static Bool XRRWireToEvent(Display *dpy, XEvent *event, xEvent *wire) aevent->state = awire->state; return True; } - + case RRNotify_ProviderChange: { + XRRProviderChangeNotifyEvent *aevent = (XRRProviderChangeNotifyEvent *) event; + xRRProviderChangeNotifyEvent *awire = (xRRProviderChangeNotifyEvent *) wire; + aevent->type = awire->type & 0x7F; + aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->window = awire->window; + aevent->subtype = awire->subCode; + aevent->provider = awire->provider; + aevent->timestamp = awire->timestamp; + return True; + } + case RRNotify_ProviderProperty: { + XRRProviderPropertyNotifyEvent *aevent = (XRRProviderPropertyNotifyEvent *) event; + xRRProviderPropertyNotifyEvent *awire = (xRRProviderPropertyNotifyEvent *) wire; + aevent->type = awire->type & 0x7F; + aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->window = awire->window; + aevent->subtype = awire->subCode; + aevent->provider = awire->provider; + aevent->property = awire->atom; + aevent->timestamp = awire->timestamp; + aevent->state = awire->state; + return True; + } + case RRNotify_ResourceChange: { + XRRResourceChangeNotifyEvent *aevent = (XRRResourceChangeNotifyEvent *) event; + xRRResourceChangeNotifyEvent *awire = (xRRResourceChangeNotifyEvent *) wire; + aevent->type = awire->type & 0x7F; + aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->window = awire->window; + aevent->subtype = awire->subCode; + aevent->timestamp = awire->timestamp; + return True; + } break; } } @@ -214,6 +253,30 @@ static Status XRREventToWire(Display *dpy, XEvent *event, xEvent *wire) awire->state = aevent->state; return True; } + case RRNotify_ProviderChange: { + xRRProviderChangeNotifyEvent *awire = (xRRProviderChangeNotifyEvent *) wire; + XRRProviderChangeNotifyEvent *aevent = (XRRProviderChangeNotifyEvent *) event; + awire->window = aevent->window; + awire->provider = aevent->provider; + return True; + } + case RRNotify_ProviderProperty: { + xRRProviderPropertyNotifyEvent *awire = (xRRProviderPropertyNotifyEvent *) wire; + XRRProviderPropertyNotifyEvent *aevent = (XRRProviderPropertyNotifyEvent *) event; + awire->window = aevent->window; + awire->provider = aevent->provider; + awire->atom = aevent->property; + awire->timestamp = aevent->timestamp; + awire->state = aevent->state; + return True; + } + case RRNotify_ResourceChange: { + xRRResourceChangeNotifyEvent *awire = (xRRResourceChangeNotifyEvent *) wire; + XRRResourceChangeNotifyEvent *aevent = (XRRResourceChangeNotifyEvent *) event; + awire->window = aevent->window; + awire->timestamp = aevent->timestamp; + return True; + } } } } @@ -229,15 +292,15 @@ XRRFindDisplay (Display *dpy) dpyinfo = XextFindDisplay (&XRRExtensionInfo, dpy); if (!dpyinfo) { - dpyinfo = XextAddDisplay (&XRRExtensionInfo, dpy, + dpyinfo = XextAddDisplay (&XRRExtensionInfo, dpy, XRRExtensionName, &rr_extension_hooks, RRNumberEvents, NULL); numscreens = ScreenCount(dpy); - xrri = Xmalloc (sizeof(XRandRInfo) + + xrri = Xmalloc (sizeof(XRandRInfo) + sizeof(char *) * numscreens); xrri->config = (XRRScreenConfiguration **)(xrri + 1); - for(i = 0; i < numscreens; i++) + for(i = 0; i < numscreens; i++) xrri->config[i] = NULL; xrri->major_version = -1; dpyinfo->data = (char *) xrri; @@ -316,7 +379,7 @@ Status XRRQueryVersion (Display *dpy, xrri = (XRandRInfo *) info->data; - /* + /* * only get the version information from the server if we don't have it already */ if (xrri->major_version == -1) { @@ -369,7 +432,7 @@ _XRRVersionHandler (Display *dpy, return True; } -/* +/* * in protocol version 0.1, routine added to allow selecting for new events. */ @@ -418,7 +481,7 @@ int XRRUpdateConfiguration(XEvent *event) switch (event->type - info->codes->first_event) { case RRScreenChangeNotify: scevent = (XRRScreenChangeNotifyEvent *) event; - snum = XRRRootToScreen(dpy, + snum = XRRRootToScreen(dpy, ((XRRScreenChangeNotifyEvent *) event)->root); if (scevent->rotation & (RR_Rotate_90 | RR_Rotate_270)) { dpy->screens[snum].width = scevent->height; @@ -437,9 +500,9 @@ int XRRUpdateConfiguration(XEvent *event) return 0; } xrri = (XRandRInfo *) info->data; - /* - * so the next time someone wants some data, it will be fetched; - * it might be better to force the round trip immediately, but + /* + * so the next time someone wants some data, it will be fetched; + * it might be better to force the round trip immediately, but * I dislike pounding the server simultaneously when not necessary */ if (xrri->config[snum] != NULL) { diff --git a/src/Xrandrint.h b/src/Xrandrint.h index 7fb5831..aed10e4 100644 --- a/src/Xrandrint.h +++ b/src/Xrandrint.h @@ -1,5 +1,5 @@ /* - * Copyright © 2000, Compaq Computer Corporation, + * Copyright © 2000, Compaq Computer Corporation, * Copyright © 2002, Hewlett Packard, Inc. * * Permission to use, copy, modify, distribute, and sell this software and its @@ -16,7 +16,7 @@ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL HP * 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 + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Jim Gettys, HP Labs, Hewlett-Packard, Inc. @@ -43,7 +43,7 @@ extern char XRRExtensionName[]; XExtDisplayInfo *XRRFindDisplay (Display *dpy); -/* deliberately opaque internal data structure; can be extended, +/* deliberately opaque internal data structure; can be extended, but not reordered */ struct _XRRScreenConfiguration { Screen *screen; /* the root window in GetScreenInfo */ @@ -69,7 +69,7 @@ struct _XRRScreenConfiguration { * when next used. Returns invalid status if not an event type * the library routine understand. */ - + /* we cache one screen configuration/screen */ typedef struct _XRandRInfo { diff --git a/src/XrrConfig.c b/src/XrrConfig.c index 793d8b6..2f0282b 100644 --- a/src/XrrConfig.c +++ b/src/XrrConfig.c @@ -82,7 +82,7 @@ Time XRRConfigTimes (XRRScreenConfiguration *config, Time *config_timestamp) } -SizeID XRRConfigCurrentConfiguration (XRRScreenConfiguration *config, +SizeID XRRConfigCurrentConfiguration (XRRScreenConfiguration *config, Rotation *rotation) { *rotation = (Rotation) config->current_rotation; @@ -94,11 +94,11 @@ short XRRConfigCurrentRate (XRRScreenConfiguration *config) return config->current_rate; } -/* - * Go get the screen configuration data and salt it away for future use; +/* + * Go get the screen configuration data and salt it away for future use; * returns NULL if extension not supported */ -static XRRScreenConfiguration *_XRRValidateCache (Display *dpy, +static XRRScreenConfiguration *_XRRValidateCache (Display *dpy, XExtDisplayInfo *info, int screen) { @@ -140,7 +140,7 @@ Rotation XRRRotations(Display *dpy, int screen, Rotation *current_rotation) /* given a screen, return the information from the (possibly) cached data */ XRRScreenSize *XRRSizes(Display *dpy, int screen, int *nsizes) { - XRRScreenConfiguration *config; + XRRScreenConfiguration *config; XExtDisplayInfo *info = XRRFindDisplay(dpy); XRRScreenSize *sizes; @@ -155,12 +155,12 @@ XRRScreenSize *XRRSizes(Display *dpy, int screen, int *nsizes) UnlockDisplay(dpy); *nsizes = 0; return NULL; - } + } } short *XRRRates (Display *dpy, int screen, int sizeID, int *nrates) { - XRRScreenConfiguration *config; + XRRScreenConfiguration *config; XExtDisplayInfo *info = XRRFindDisplay(dpy); short *rates; @@ -174,13 +174,13 @@ short *XRRRates (Display *dpy, int screen, int sizeID, int *nrates) UnlockDisplay(dpy); *nrates = 0; return NULL; - } + } } /* given a screen, return the information from the (possibly) cached data */ Time XRRTimes (Display *dpy, int screen, Time *config_timestamp) { - XRRScreenConfiguration *config; + XRRScreenConfiguration *config; XExtDisplayInfo *info = XRRFindDisplay(dpy); Time ts; @@ -227,7 +227,7 @@ static XRRScreenConfiguration *_XRRGetScreenInfo (Display *dpy, vreq->randrReqType = X_RRQueryVersion; vreq->majorVersion = RANDR_MAJOR; vreq->minorVersion = RANDR_MINOR; - + async_state.version_seq = dpy->request; async_state.error = False; async.next = dpy->async_handlers; @@ -272,14 +272,14 @@ static XRRScreenConfiguration *_XRRGetScreenInfo (Display *dpy, rep.rate = 0; rep.nrateEnts = 0; } - + nbytes = (long) rep.length << 2; nbytesRead = (long) (rep.nSizes * SIZEOF (xScreenSizes) + ((rep.nrateEnts + 1)& ~1) * 2 /* SIZEOF (CARD16) */); - - /* - * first we must compute how much space to allocate for + + /* + * first we must compute how much space to allocate for * randr library's use; we'll allocate the structures in a single * allocation, on cleanlyness grounds. */ @@ -299,7 +299,7 @@ static XRRScreenConfiguration *_XRRGetScreenInfo (Display *dpy, rates = (short *) (ssp + rep.nSizes); /* set up the screen configuration structure */ - scp->screen = + scp->screen = ScreenOfDisplay (dpy, XRRRootToScreen(dpy, rep.root)); scp->sizes = ssp; @@ -322,7 +322,7 @@ static XRRScreenConfiguration *_XRRGetScreenInfo (Display *dpy, */ for (i = 0; i < rep.nSizes; i++) { _XReadPad (dpy, (char *) &size, SIZEOF (xScreenSizes)); - + ssp[i].width = size.widthInPixels; ssp[i].height = size.heightInPixels; ssp[i].mwidth = size.widthInMillimeters; @@ -332,13 +332,13 @@ static XRRScreenConfiguration *_XRRGetScreenInfo (Display *dpy, * And the rates */ _XRead16Pad (dpy, rates, 2 /* SIZEOF (CARD16) */ * rep.nrateEnts); - + /* * Skip any extra data */ if (nbytes > nbytesRead) _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); - + return (XRRScreenConfiguration *)(scp); } @@ -354,7 +354,7 @@ XRRScreenConfiguration *XRRGetScreenInfo (Display *dpy, Window window) return config; } - + void XRRFreeScreenConfigInfo (XRRScreenConfiguration *config) { Xfree (config); @@ -364,7 +364,7 @@ Status XRRSetScreenConfigAndRate (Display *dpy, XRRScreenConfiguration *config, Drawable draw, int size_index, - Rotation rotation, + Rotation rotation, short rate, Time timestamp) { @@ -378,7 +378,7 @@ Status XRRSetScreenConfigAndRate (Display *dpy, /* Make sure has_rates is set */ if (!XRRQueryVersion (dpy, &major, &minor)) return 0; - + LockDisplay (dpy); xrri = (XRandRInfo *) info->data; if (xrri->has_rates) @@ -406,7 +406,7 @@ Status XRRSetScreenConfigAndRate (Display *dpy, req->timestamp = timestamp; req->configTimestamp = config->config_timestamp; } - + (void) _XReply (dpy, (xReply *) &rep, 0, xTrue); /* actually .errorCode in struct xError */ diff --git a/src/XrrCrtc.c b/src/XrrCrtc.c index 697987a..0762373 100644 --- a/src/XrrCrtc.c +++ b/src/XrrCrtc.c @@ -62,8 +62,8 @@ XRRGetCrtcInfo (Display *dpy, XRRScreenResources *resources, RRCrtc crtc) nbytesRead = (long) (rep.nOutput * 4 + rep.nPossibleOutput * 4); - /* - * first we must compute how much space to allocate for + /* + * first we must compute how much space to allocate for * randr library's use; we'll allocate the structures in a single * allocation, on cleanlyness grounds. */ @@ -95,13 +95,13 @@ XRRGetCrtcInfo (Display *dpy, XRRScreenResources *resources, RRCrtc crtc) _XRead32 (dpy, xci->outputs, rep.nOutput << 2); _XRead32 (dpy, xci->possible, rep.nPossibleOutput << 2); - + /* * Skip any extra data */ if (nbytes > nbytesRead) _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); - + UnlockDisplay (dpy); SyncHandle (); return (XRRCrtcInfo *) xci; @@ -195,12 +195,12 @@ XRRGetCrtcGamma (Display *dpy, RRCrtc crtc) goto out; nbytes = (long) rep.length << 2; - + /* three channels of CARD16 data */ nbytesRead = (rep.size * 2 * 3); crtc_gamma = XRRAllocGamma (rep.size); - + if (!crtc_gamma) { _XEatData (dpy, (unsigned long) nbytes); @@ -209,7 +209,7 @@ XRRGetCrtcGamma (Display *dpy, RRCrtc crtc) _XRead16 (dpy, crtc_gamma->red, rep.size * 2); _XRead16 (dpy, crtc_gamma->green, rep.size * 2); _XRead16 (dpy, crtc_gamma->blue, rep.size * 2); - + if (nbytes > nbytesRead) _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); @@ -255,7 +255,7 @@ XRRSetCrtcGamma (Display *dpy, RRCrtc crtc, XRRCrtcGamma *crtc_gamma) * otherwise the channels might not be contiguous */ Data16 (dpy, crtc_gamma->red, crtc_gamma->size * 2 * 3); - + UnlockDisplay (dpy); SyncHandle (); } @@ -304,7 +304,7 @@ xRenderTransform_from_XTransform (xRenderTransform *render, void XRRSetCrtcTransform (Display *dpy, - RRCrtc crtc, + RRCrtc crtc, XTransform *transform, char *filter, XFixed *params, @@ -334,7 +334,7 @@ XRRSetCrtcTransform (Display *dpy, } #define CrtcTransformExtra (SIZEOF(xRRGetCrtcTransformReply) - 32) - + static const xRenderTransform identity = { 0x10000, 0, 0, 0, 0x10000, 0, @@ -364,7 +364,7 @@ XRRGetCrtcTransform (Display *dpy, RRCheckExtension (dpy, info, False); - if (!XRRQueryVersion (dpy, &major_version, &minor_version) || + if (!XRRQueryVersion (dpy, &major_version, &minor_version) || !_XRRHasTransform (major_version, minor_version)) { /* For pre-1.3 servers, just report identity matrices everywhere */ @@ -382,7 +382,7 @@ XRRGetCrtcTransform (Display *dpy, req->reqType = info->codes->major_opcode; req->randrReqType = X_RRGetCrtcTransform; req->crtc = crtc; - + if (!_XReply (dpy, (xReply *) &rep, CrtcTransformExtra >> 2, xFalse)) { rep.pendingTransform = identity; diff --git a/src/XrrMode.c b/src/XrrMode.c index 58ef68b..0b74a73 100644 --- a/src/XrrMode.c +++ b/src/XrrMode.c @@ -62,9 +62,9 @@ XRRCreateMode (Display *dpy, Window window, XRRModeInfo *mode_info) req->reqType = info->codes->major_opcode; req->randrReqType = X_RRCreateMode; req->length += (mode_info->nameLength + 3) >> 2; - + req->window = window; - + req->modeInfo.id = 0; req->modeInfo.width = mode_info->width; req->modeInfo.height = mode_info->height; @@ -78,7 +78,7 @@ XRRCreateMode (Display *dpy, Window window, XRRModeInfo *mode_info) req->modeInfo.vTotal = mode_info->vTotal; req->modeInfo.nameLength = mode_info->nameLength; req->modeInfo.modeFlags = mode_info->modeFlags; - + Data (dpy, mode_info->name, mode_info->nameLength); if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { @@ -86,7 +86,7 @@ XRRCreateMode (Display *dpy, Window window, XRRModeInfo *mode_info) SyncHandle (); return None; } - + UnlockDisplay (dpy); SyncHandle (); return rep.mode; diff --git a/src/XrrOutput.c b/src/XrrOutput.c index 18863bd..f13a932 100644 --- a/src/XrrOutput.c +++ b/src/XrrOutput.c @@ -34,7 +34,7 @@ #include "Xrandrint.h" #define OutputInfoExtra (SIZEOF(xRRGetOutputInfoReply) - 32) - + XRROutputInfo * XRRGetOutputInfo (Display *dpy, XRRScreenResources *resources, RROutput output) { @@ -67,8 +67,8 @@ XRRGetOutputInfo (Display *dpy, XRRScreenResources *resources, RROutput output) rep.nClones * 4 + ((rep.nameLength + 3) & ~3)); - /* - * first we must compute how much space to allocate for + /* + * first we must compute how much space to allocate for * randr library's use; we'll allocate the structures in a single * allocation, on cleanlyness grounds. */ @@ -105,19 +105,20 @@ XRRGetOutputInfo (Display *dpy, XRRScreenResources *resources, RROutput output) _XRead32 (dpy, xoi->crtcs, rep.nCrtcs << 2); _XRead32 (dpy, xoi->modes, rep.nModes << 2); _XRead32 (dpy, xoi->clones, rep.nClones << 2); - + /* * Read name and '\0' terminate */ _XReadPad (dpy, xoi->name, rep.nameLength); xoi->name[rep.nameLength] = '\0'; - + xoi->nameLen = rep.nameLength; + /* * Skip any extra data */ if (nbytes > nbytesRead) _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); - + UnlockDisplay (dpy); SyncHandle (); return (XRROutputInfo *) xoi; @@ -144,7 +145,7 @@ XRRSetOutputPrimary(Display *dpy, Window window, RROutput output) RRSimpleCheckExtension (dpy, info); - if (!XRRQueryVersion (dpy, &major_version, &minor_version) || + if (!XRRQueryVersion (dpy, &major_version, &minor_version) || !_XRRHasOutputPrimary (major_version, minor_version)) return; @@ -169,7 +170,7 @@ XRRGetOutputPrimary(Display *dpy, Window window) RRCheckExtension (dpy, info, 0); - if (!XRRQueryVersion (dpy, &major_version, &minor_version) || + if (!XRRQueryVersion (dpy, &major_version, &minor_version) || !_XRRHasOutputPrimary (major_version, minor_version)) return None; @@ -181,7 +182,7 @@ XRRGetOutputPrimary(Display *dpy, Window window) if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) rep.output = None; - + UnlockDisplay(dpy); SyncHandle(); diff --git a/src/XrrProperty.c b/src/XrrProperty.c index 1a125b2..4c3fdb0 100644 --- a/src/XrrProperty.c +++ b/src/XrrProperty.c @@ -159,7 +159,7 @@ XRRConfigureOutputProperty (Display *dpy, RROutput output, Atom property, UnlockDisplay(dpy); SyncHandle(); } - + void XRRChangeOutputProperty (Display *dpy, RROutput output, Atom property, Atom type, @@ -244,7 +244,7 @@ XRRDeleteOutputProperty (Display *dpy, RROutput output, Atom property) int XRRGetOutputProperty (Display *dpy, RROutput output, Atom property, long offset, long length, - Bool delete, Bool pending, Atom req_type, + Bool delete, Bool pending, Atom req_type, Atom *actual_type, int *actual_format, unsigned long *nitems, unsigned long *bytes_after, unsigned char **prop) diff --git a/src/XrrProvider.c b/src/XrrProvider.c new file mode 100644 index 0000000..fcd06ff --- /dev/null +++ b/src/XrrProvider.c @@ -0,0 +1,217 @@ +/* + * Copyright © 2011 Dave Airlie + * + * 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 the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS 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 +#include +/* we need to be able to manipulate the Display structure on events */ +#include +#include +#include +#include "Xrandrint.h" + +XRRProviderResources * +XRRGetProviderResources(Display *dpy, Window window) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRGetProvidersReply rep; + xRRGetProvidersReq *req; + XRRProviderResources *xrpr; + long nbytes, nbytesRead; + int rbytes; + + RRCheckExtension (dpy, info, NULL); + + LockDisplay (dpy); + + GetReq(RRGetProviders, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRGetProviders; + req->window = window; + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + nbytes = (long) rep.length << 2; + + nbytesRead = (long) (rep.nProviders * 4); + + rbytes = (sizeof(XRRProviderResources) + rep.nProviders * sizeof(RRProvider)); + xrpr = (XRRProviderResources *) Xmalloc(rbytes); + + if (xrpr == NULL) { + _XEatData (dpy, (unsigned long) nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + xrpr->timestamp = rep.timestamp; + xrpr->nproviders = rep.nProviders; + xrpr->providers = (RRProvider *)(xrpr + 1); + + _XRead32(dpy, xrpr->providers, rep.nProviders << 2); + + if (nbytes > nbytesRead) + _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); + + + UnlockDisplay (dpy); + SyncHandle(); + + return (XRRProviderResources *) xrpr; +} + +void +XRRFreeProviderResources(XRRProviderResources *provider_resources) +{ + free(provider_resources); +} + +#define ProviderInfoExtra (SIZEOF(xRRGetProviderInfoReply) - 32) +XRRProviderInfo * +XRRGetProviderInfo(Display *dpy, XRRScreenResources *resources, RRProvider provider) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRGetProviderInfoReply rep; + xRRGetProviderInfoReq *req; + int nbytes, nbytesRead, rbytes; + XRRProviderInfo *xpi; + + RRCheckExtension (dpy, info, NULL); + + LockDisplay (dpy); + GetReq (RRGetProviderInfo, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRGetProviderInfo; + req->provider = provider; + req->configTimestamp = resources->configTimestamp; + + if (!_XReply (dpy, (xReply *) &rep, ProviderInfoExtra >> 2, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + nbytes = ((long) rep.length << 2) - ProviderInfoExtra; + + nbytesRead = (long)(rep.nCrtcs * 4 + + rep.nOutputs * 4 + + rep.nAssociatedProviders * 8 + + ((rep.nameLength + 3) & ~3)); + + rbytes = (sizeof(XRRProviderInfo) + + rep.nCrtcs * sizeof(RRCrtc) + + rep.nOutputs * sizeof(RROutput) + + rep.nAssociatedProviders * (sizeof(RRProvider) + sizeof(unsigned int))+ + rep.nameLength + 1); + + xpi = (XRRProviderInfo *)Xmalloc(rbytes); + if (xpi == NULL) { + _XEatData (dpy, (unsigned long) nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + xpi->capabilities = rep.capabilities; + xpi->ncrtcs = rep.nCrtcs; + xpi->noutputs = rep.nOutputs; + xpi->nassociatedproviders = rep.nAssociatedProviders; + xpi->crtcs = (RRCrtc *)(xpi + 1); + xpi->outputs = (RROutput *)(xpi->crtcs + rep.nCrtcs); + xpi->associated_providers = (RRProvider *)(xpi->outputs + rep.nOutputs); + xpi->associated_capability = (unsigned int *)(xpi->associated_providers + rep.nAssociatedProviders); + xpi->name = (char *)(xpi->associated_capability + rep.nAssociatedProviders); + + _XRead32(dpy, xpi->crtcs, rep.nCrtcs << 2); + _XRead32(dpy, xpi->outputs, rep.nOutputs << 2); + + _XRead32(dpy, xpi->associated_providers, rep.nAssociatedProviders << 2); + _XRead32(dpy, xpi->associated_capability, rep.nAssociatedProviders << 2); + + _XReadPad(dpy, xpi->name, rep.nameLength); + xpi->name[rep.nameLength] = '\0'; + + /* + * Skip any extra data + */ + if (nbytes > nbytesRead) + _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); + + UnlockDisplay (dpy); + SyncHandle (); + return (XRRProviderInfo *) xpi; +} + +void +XRRFreeProviderInfo(XRRProviderInfo *provider) +{ + free(provider); +} + +int +XRRSetProviderOutputSource(Display *dpy, XID provider, + XID source_provider) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRSetProviderOutputSourceReq *req; + + RRCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (RRSetProviderOutputSource, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRSetProviderOutputSource; + req->provider = provider; + req->source_provider = source_provider; + UnlockDisplay (dpy); + SyncHandle (); + return 0; +} + +int +XRRSetProviderOffloadSink(Display *dpy, XID provider, + XID sink_provider) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRSetProviderOffloadSinkReq *req; + + RRCheckExtension (dpy, info, 0); + LockDisplay (dpy); + GetReq (RRSetProviderOffloadSink, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRSetProviderOffloadSink; + req->provider = provider; + req->sink_provider = sink_provider; + UnlockDisplay (dpy); + SyncHandle (); + return 0; +} diff --git a/src/XrrProviderProperty.c b/src/XrrProviderProperty.c new file mode 100644 index 0000000..c8c08e9 --- /dev/null +++ b/src/XrrProviderProperty.c @@ -0,0 +1,339 @@ +/* + * Copyright © 2006 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 the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS 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 +#include +/* we need to be able to manipulate the Display structure on events */ +#include +#include +#include +#include "Xrandrint.h" + +Atom * +XRRListProviderProperties (Display *dpy, RRProvider provider, int *nprop) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRListProviderPropertiesReply rep; + xRRListProviderPropertiesReq *req; + int nbytes, rbytes; + Atom *props = NULL; + + RRCheckExtension (dpy, info, NULL); + + LockDisplay (dpy); + GetReq (RRListProviderProperties, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRListProviderProperties; + req->provider = provider; + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + *nprop = 0; + return NULL; + } + + if (rep.nAtoms) { + rbytes = rep.nAtoms * sizeof (Atom); + nbytes = rep.nAtoms << 2; + + props = (Atom *) Xmalloc (rbytes); + if (props == NULL) { + _XEatData (dpy, nbytes); + UnlockDisplay (dpy); + SyncHandle (); + *nprop = 0; + return NULL; + } + + _XRead32 (dpy, props, nbytes); + } + + *nprop = rep.nAtoms; + UnlockDisplay (dpy); + SyncHandle (); + return props; +} + +XRRPropertyInfo * +XRRQueryProviderProperty (Display *dpy, RRProvider provider, Atom property) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRQueryProviderPropertyReply rep; + xRRQueryProviderPropertyReq *req; + int rbytes, nbytes; + XRRPropertyInfo *prop_info; + + RRCheckExtension (dpy, info, NULL); + + LockDisplay (dpy); + GetReq (RRQueryProviderProperty, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRQueryProviderProperty; + req->provider = provider; + req->property = property; + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + rbytes = sizeof (XRRPropertyInfo) + rep.length * sizeof (long); + nbytes = rep.length << 2; + + prop_info = (XRRPropertyInfo *) Xmalloc (rbytes); + if (prop_info == NULL) { + _XEatData (dpy, nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + prop_info->pending = rep.pending; + prop_info->range = rep.range; + prop_info->immutable = rep.immutable; + prop_info->num_values = rep.length; + if (rep.length != 0) { + prop_info->values = (long *) (prop_info + 1); + _XRead32 (dpy, prop_info->values, nbytes); + } else { + prop_info->values = NULL; + } + + UnlockDisplay (dpy); + SyncHandle (); + return prop_info; +} + +void +XRRConfigureProviderProperty (Display *dpy, RRProvider provider, Atom property, + Bool pending, Bool range, int num_values, + long *values) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRConfigureProviderPropertyReq *req; + long len; + + RRSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq (RRConfigureProviderProperty, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRConfigureProviderProperty; + req->provider = provider; + req->property = property; + req->pending = pending; + req->range = range; + + len = num_values; + if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) { + SetReqLen(req, len, len); + len = (long)num_values << 2; + Data32 (dpy, values, len); + } /* else force BadLength */ + + UnlockDisplay(dpy); + SyncHandle(); +} + +void +XRRChangeProviderProperty (Display *dpy, RRProvider provider, + Atom property, Atom type, + int format, int mode, + _Xconst unsigned char *data, int nelements) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRChangeProviderPropertyReq *req; + long len; + + RRSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq (RRChangeProviderProperty, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRChangeProviderProperty; + req->provider = provider; + req->property = property; + req->type = type; + req->mode = mode; + if (nelements < 0) { + req->nUnits = 0; + req->format = 0; /* ask for garbage, get garbage */ + } else { + req->nUnits = nelements; + req->format = format; + } + + switch (req->format) { + case 8: + len = ((long)nelements + 3) >> 2; + if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) { + SetReqLen(req, len, len); + Data (dpy, (char *)data, nelements); + } /* else force BadLength */ + break; + + case 16: + len = ((long)nelements + 1) >> 1; + if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) { + SetReqLen(req, len, len); + len = (long)nelements << 1; + Data16 (dpy, (short *) data, len); + } /* else force BadLength */ + break; + + case 32: + len = nelements; + if (dpy->bigreq_size || req->length + len <= (unsigned) 65535) { + SetReqLen(req, len, len); + len = (long)nelements << 2; + Data32 (dpy, (long *) data, len); + } /* else force BadLength */ + break; + + default: + /* BadValue will be generated */ ; + } + + UnlockDisplay(dpy); + SyncHandle(); +} + +void +XRRDeleteProviderProperty (Display *dpy, RRProvider provider, Atom property) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRDeleteProviderPropertyReq *req; + + RRSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(RRDeleteProviderProperty, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRDeleteProviderProperty; + req->provider = provider; + req->property = property; + UnlockDisplay(dpy); + SyncHandle(); +} + +int +XRRGetProviderProperty (Display *dpy, RRProvider provider, + Atom property, long offset, long length, + Bool delete, Bool pending, Atom req_type, + Atom *actual_type, int *actual_format, + unsigned long *nitems, unsigned long *bytes_after, + unsigned char **prop) +{ + XExtDisplayInfo *info = XRRFindDisplay(dpy); + xRRGetProviderPropertyReply rep; + xRRGetProviderPropertyReq *req; + long nbytes, rbytes; + + RRCheckExtension (dpy, info, 1); + + LockDisplay (dpy); + GetReq (RRGetProviderProperty, req); + req->reqType = info->codes->major_opcode; + req->randrReqType = X_RRGetProviderProperty; + req->provider = provider; + req->property = property; + req->type = req_type; + req->longOffset = offset; + req->longLength = length; + req->delete = delete; + req->pending = pending; + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) + { + UnlockDisplay (dpy); + SyncHandle (); + return ((xError *)&rep)->errorCode; + } + + *prop = (unsigned char *) NULL; + if (rep.propertyType != None) { + /* + * One extra byte is malloced than is needed to contain the property + * data, but this last byte is null terminated and convenient for + * returning string properties, so the client doesn't then have to + * recopy the string to make it null terminated. + */ + switch (rep.format) { + case 8: + nbytes = rep.nItems; + rbytes = rep.nItems + 1; + if (rbytes > 0 && + (*prop = (unsigned char *) Xmalloc ((unsigned)rbytes))) + _XReadPad (dpy, (char *) *prop, nbytes); + break; + + case 16: + nbytes = rep.nItems << 1; + rbytes = rep.nItems * sizeof (short) + 1; + if (rbytes > 0 && + (*prop = (unsigned char *) Xmalloc ((unsigned)rbytes))) + _XRead16Pad (dpy, (short *) *prop, nbytes); + break; + + case 32: + nbytes = rep.nItems << 2; + rbytes = rep.nItems * sizeof (long) + 1; + if (rbytes > 0 && + (*prop = (unsigned char *) Xmalloc ((unsigned)rbytes))) + _XRead32 (dpy, (long *) *prop, nbytes); + break; + + default: + /* + * This part of the code should never be reached. If it is, + * the server sent back a property with an invalid format. + */ + nbytes = rep.length << 2; + _XEatData(dpy, (unsigned long) nbytes); + UnlockDisplay(dpy); + SyncHandle(); + return(BadImplementation); + } + if (! *prop) { + _XEatData(dpy, (unsigned long) nbytes); + UnlockDisplay(dpy); + SyncHandle(); + return(BadAlloc); + } + (*prop)[rbytes - 1] = '\0'; + } + + *actual_type = rep.propertyType; + *actual_format = rep.format; + *nitems = rep.nItems; + *bytes_after = rep.bytesAfter; + UnlockDisplay (dpy); + SyncHandle (); + + return Success; +} diff --git a/src/XrrScreen.c b/src/XrrScreen.c index 54bc2ca..f830913 100644 --- a/src/XrrScreen.c +++ b/src/XrrScreen.c @@ -66,7 +66,7 @@ doGetScreenResources (Display *dpy, Window window, int poll) vreq->randrReqType = X_RRQueryVersion; vreq->majorVersion = RANDR_MAJOR; vreq->minorVersion = RANDR_MINOR; - + async_state.version_seq = dpy->request; async_state.error = False; async.next = dpy->async_handlers; @@ -112,8 +112,8 @@ doGetScreenResources (Display *dpy, Window window, int poll) rep.nModes * SIZEOF (xRRModeInfo) + ((rep.nbytesNames + 3) & ~3)); - /* - * first we must compute how much space to allocate for + /* + * first we must compute how much space to allocate for * randr library's use; we'll allocate the structures in a single * allocation, on cleanlyness grounds. */ @@ -147,10 +147,10 @@ doGetScreenResources (Display *dpy, Window window, int poll) _XRead32 (dpy, xrsr->crtcs, rep.nCrtcs << 2); _XRead32 (dpy, xrsr->outputs, rep.nOutputs << 2); - + for (i = 0; i < rep.nModes; i++) { xRRModeInfo modeInfo; - + _XReadPad (dpy, (char *) &modeInfo, SIZEOF (xRRModeInfo)); xrsr->modes[i].id = modeInfo.id; xrsr->modes[i].width = modeInfo.width; @@ -180,13 +180,13 @@ doGetScreenResources (Display *dpy, Window window, int poll) wire_name += xrsr->modes[i].nameLength; } Xfree (wire_names); - + /* * Skip any extra data */ if (nbytes > nbytesRead) _XEatData (dpy, (unsigned long) (nbytes - nbytesRead)); - + UnlockDisplay (dpy); SyncHandle(); return (XRRScreenResources *) xrsr;