summaryrefslogtreecommitdiffstats
path: root/gfx/angle/src/third_party/libXNVCtrl/NVCtrl.c
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/angle/src/third_party/libXNVCtrl/NVCtrl.c')
-rwxr-xr-xgfx/angle/src/third_party/libXNVCtrl/NVCtrl.c1240
1 files changed, 1240 insertions, 0 deletions
diff --git a/gfx/angle/src/third_party/libXNVCtrl/NVCtrl.c b/gfx/angle/src/third_party/libXNVCtrl/NVCtrl.c
new file mode 100755
index 000000000..e98437394
--- /dev/null
+++ b/gfx/angle/src/third_party/libXNVCtrl/NVCtrl.c
@@ -0,0 +1,1240 @@
+/*
+ * Copyright (c) 2008 NVIDIA, Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Make sure that XTHREADS is defined, so that the
+ * LockDisplay/UnlockDisplay macros are expanded properly and the
+ * libXNVCtrl library properly protects the Display connection.
+ */
+
+#if !defined(XTHREADS)
+#define XTHREADS
+#endif /* XTHREADS */
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <stdint.h>
+#include <stdlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include "NVCtrlLib.h"
+#include "nv_control.h"
+
+#define NVCTRL_EXT_EXISTS 1
+#define NVCTRL_EXT_NEED_TARGET_SWAP 2
+#define NVCTRL_EXT_64_BIT_ATTRIBUTES 4
+#define NVCTRL_EXT_NEED_CHECK (1 << (sizeof(XPointer) - 1))
+
+static XExtensionInfo _nvctrl_ext_info_data;
+static XExtensionInfo *nvctrl_ext_info = &_nvctrl_ext_info_data;
+static const char *nvctrl_extension_name = NV_CONTROL_NAME;
+
+#define XNVCTRLCheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, nvctrl_extension_name, val)
+#define XNVCTRLSimpleCheckExtension(dpy,i) \
+ XextSimpleCheckExtension (dpy, i, nvctrl_extension_name)
+
+static int close_display();
+static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info);
+static Bool wire_to_event();
+static /* const */ XExtensionHooks nvctrl_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ close_display, /* close_display */
+ wire_to_event, /* wire_to_event */
+ NULL, /* event_to_wire */
+ NULL, /* error */
+ NULL, /* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, nvctrl_ext_info,
+ nvctrl_extension_name,
+ &nvctrl_extension_hooks,
+ NV_CONTROL_EVENTS,
+ (XPointer)NVCTRL_EXT_NEED_CHECK)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, nvctrl_ext_info)
+
+/*
+ * NV-CONTROL versions 1.8 and 1.9 pack the target_type and target_id
+ * fields in reversed order. In order to talk to one of these servers,
+ * we need to swap these fields.
+ */
+
+static void XNVCTRLCheckTargetData(Display *dpy, XExtDisplayInfo *info,
+ int *target_type, int *target_id)
+{
+ uintptr_t flags = version_flags(dpy, info);
+
+ /* We need to swap the target_type and target_id */
+ if (flags & NVCTRL_EXT_NEED_TARGET_SWAP) {
+ int tmp;
+ tmp = *target_type;
+ *target_type = *target_id;
+ *target_id = tmp;
+ }
+}
+
+
+Bool XNVCTRLQueryExtension (
+ Display *dpy,
+ int *event_basep,
+ int *error_basep
+){
+ XExtDisplayInfo *info = find_display (dpy);
+
+ if (XextHasExtension(info)) {
+ if (event_basep) *event_basep = info->codes->first_event;
+ if (error_basep) *error_basep = info->codes->first_error;
+ return True;
+ } else {
+ return False;
+ }
+}
+
+/*
+ * Retrieve any cached flags that depend on the version of the NV-CONTROL
+ * extension.
+ */
+
+static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info)
+{
+ uintptr_t data = (uintptr_t)info->data;
+
+ /* If necessary, determine the NV-CONTROL version */
+ if (data & NVCTRL_EXT_NEED_CHECK) {
+ int major, minor;
+ data = 0;
+ if (XNVCTRLQueryVersion(dpy, &major, &minor)) {
+ data |= NVCTRL_EXT_EXISTS;
+ if (major == 1 && (minor == 8 || minor == 9)) {
+ data |= NVCTRL_EXT_NEED_TARGET_SWAP;
+ }
+ if ((major > 1) || ((major == 1) && (minor > 20))) {
+ data |= NVCTRL_EXT_64_BIT_ATTRIBUTES;
+ }
+ }
+
+ info->data = (XPointer)data;
+ }
+
+ return data;
+}
+
+Bool XNVCTRLQueryVersion (
+ Display *dpy,
+ int *major,
+ int *minor
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryExtensionReply rep;
+ xnvCtrlQueryExtensionReq *req;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryExtension, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryExtension;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ if (major) *major = rep.major;
+ if (minor) *minor = rep.minor;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return True;
+}
+
+
+Bool XNVCTRLIsNvScreen (
+ Display *dpy,
+ int screen
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlIsNvReply rep;
+ xnvCtrlIsNvReq *req;
+ Bool isnv;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlIsNv, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlIsNv;
+ req->screen = screen;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ isnv = rep.isnv;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return isnv;
+}
+
+
+Bool XNVCTRLQueryTargetCount (
+ Display *dpy,
+ int target_type,
+ int *value
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryTargetCountReply rep;
+ xnvCtrlQueryTargetCountReq *req;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryTargetCount, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryTargetCount;
+ req->target_type = target_type;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ if (value) *value = rep.count;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return True;
+}
+
+
+void XNVCTRLSetTargetAttribute (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int value
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSetAttributeReq *req;
+
+ XNVCTRLSimpleCheckExtension (dpy, info);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSetAttribute, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSetAttribute;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ req->value = value;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+}
+
+void XNVCTRLSetAttribute (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int value
+){
+ XNVCTRLSetTargetAttribute (dpy, NV_CTRL_TARGET_TYPE_X_SCREEN, screen,
+ display_mask, attribute, value);
+}
+
+
+Bool XNVCTRLSetTargetAttributeAndGetStatus (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int value
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSetAttributeAndGetStatusReq *req;
+ xnvCtrlSetAttributeAndGetStatusReply rep;
+ Bool success;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSetAttributeAndGetStatus, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSetAttributeAndGetStatus;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ req->value = value;
+ if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+
+ success = rep.flags;
+ return success;
+}
+
+Bool XNVCTRLSetAttributeAndGetStatus (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int value
+){
+ return XNVCTRLSetTargetAttributeAndGetStatus(dpy,
+ NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask,
+ attribute, value);
+}
+
+
+Bool XNVCTRLQueryTargetAttribute (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int *value
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryAttributeReply rep;
+ xnvCtrlQueryAttributeReq *req;
+ Bool exists;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryAttribute, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryAttribute;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists && value) *value = rep.value;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return exists;
+}
+
+Bool XNVCTRLQueryAttribute (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int *value
+){
+ return XNVCTRLQueryTargetAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask, attribute, value);
+}
+
+
+Bool XNVCTRLQueryTargetAttribute64 (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ int64_t *value
+){
+ XExtDisplayInfo *info = find_display(dpy);
+ xnvCtrlQueryAttribute64Reply rep;
+ xnvCtrlQueryAttributeReq *req;
+ Bool exists;
+
+ if (!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension(dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ LockDisplay(dpy);
+ GetReq(nvCtrlQueryAttribute, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryAttribute64;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists && value) *value = rep.value_64;
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return exists;
+}
+
+
+Bool XNVCTRLQueryTargetStringAttribute (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ char **ptr
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryStringAttributeReply rep;
+ xnvCtrlQueryStringAttributeReq *req;
+ Bool exists;
+ int length, numbytes, slop;
+
+ if (!ptr) return False;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryStringAttribute, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryStringAttribute;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ length = rep.length;
+ numbytes = rep.n;
+ slop = numbytes & 3;
+ exists = rep.flags;
+ if (exists) {
+ *ptr = (char *) Xmalloc(numbytes);
+ }
+ if (!exists || !*ptr) {
+ _XEatData(dpy, length);
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ } else {
+ _XRead(dpy, (char *) *ptr, numbytes);
+ if (slop) _XEatData(dpy, 4-slop);
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return exists;
+}
+
+Bool XNVCTRLQueryStringAttribute (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ char **ptr
+){
+ return XNVCTRLQueryTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask,
+ attribute, ptr);
+}
+
+
+Bool XNVCTRLSetTargetStringAttribute (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ char *ptr
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSetStringAttributeReq *req;
+ xnvCtrlSetStringAttributeReply rep;
+ int size;
+ Bool success;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ size = strlen(ptr)+1;
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSetStringAttribute, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSetStringAttribute;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ req->length += ((size + 3) & ~3) >> 2;
+ req->num_bytes = size;
+ Data(dpy, ptr, size);
+
+ if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+
+ success = rep.flags;
+ return success;
+}
+
+Bool XNVCTRLSetStringAttribute (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ char *ptr
+){
+ return XNVCTRLSetTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask,
+ attribute, ptr);
+}
+
+
+static Bool XNVCTRLQueryValidTargetAttributeValues32 (
+ Display *dpy,
+ XExtDisplayInfo *info,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ NVCTRLAttributeValidValuesRec *values
+){
+ xnvCtrlQueryValidAttributeValuesReply rep;
+ xnvCtrlQueryValidAttributeValuesReq *req;
+ Bool exists;
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryValidAttributeValues, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryValidAttributeValues;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists) {
+ values->type = rep.attr_type;
+ if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
+ values->u.range.min = rep.min;
+ values->u.range.max = rep.max;
+ }
+ if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
+ values->u.bits.ints = rep.bits;
+ }
+ values->permissions = rep.perms;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return exists;
+}
+
+
+Bool XNVCTRLQueryValidTargetStringAttributeValues (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ NVCTRLAttributeValidValuesRec *values
+){
+ XExtDisplayInfo *info = find_display(dpy);
+ Bool exists;
+ xnvCtrlQueryValidAttributeValuesReply rep;
+ xnvCtrlQueryValidAttributeValuesReq *req;
+
+ if (!values) return False;
+
+ if (!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension(dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq (nvCtrlQueryValidAttributeValues, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryValidStringAttributeValues;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists) {
+ values->type = rep.attr_type;
+ values->permissions = rep.perms;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return exists;
+}
+
+
+static Bool XNVCTRLQueryValidTargetAttributeValues64 (
+ Display *dpy,
+ XExtDisplayInfo *info,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ NVCTRLAttributeValidValuesRec *values
+){
+ xnvCtrlQueryValidAttributeValues64Reply rep;
+ xnvCtrlQueryValidAttributeValuesReq *req;
+ Bool exists;
+
+ LockDisplay(dpy);
+ GetReq(nvCtrlQueryValidAttributeValues, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryValidAttributeValues64;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply(dpy, (xReply *)&rep,
+ sz_xnvCtrlQueryValidAttributeValues64Reply_extra,
+ xTrue)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists) {
+ values->type = rep.attr_type;
+ if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
+ values->u.range.min = rep.min_64;
+ values->u.range.max = rep.max_64;
+ }
+ if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
+ values->u.bits.ints = rep.bits_64;
+ }
+ values->permissions = rep.perms;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return exists;
+}
+
+Bool XNVCTRLQueryValidTargetAttributeValues (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ NVCTRLAttributeValidValuesRec *values
+){
+ XExtDisplayInfo *info = find_display(dpy);
+ Bool exists;
+ uintptr_t flags;
+
+ if (!values) return False;
+
+ if (!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension(dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ flags = version_flags(dpy,info);
+
+ if (!(flags & NVCTRL_EXT_EXISTS))
+ return False;
+
+ if (flags & NVCTRL_EXT_64_BIT_ATTRIBUTES) {
+ exists = XNVCTRLQueryValidTargetAttributeValues64(dpy, info,
+ target_type,
+ target_id,
+ display_mask,
+ attribute,
+ values);
+ } else {
+ exists = XNVCTRLQueryValidTargetAttributeValues32(dpy, info,
+ target_type,
+ target_id,
+ display_mask,
+ attribute,
+ values);
+ }
+ return exists;
+}
+
+
+Bool XNVCTRLQueryValidAttributeValues (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ NVCTRLAttributeValidValuesRec *values
+){
+ return XNVCTRLQueryValidTargetAttributeValues(dpy,
+ NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask,
+ attribute, values);
+}
+
+
+static Bool QueryAttributePermissionsInternal (
+ Display *dpy,
+ unsigned int attribute,
+ NVCTRLAttributePermissionsRec *permissions,
+ unsigned int reqType
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryAttributePermissionsReply rep;
+ xnvCtrlQueryAttributePermissionsReq *req;
+ Bool exists;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay(dpy);
+ GetReq(nvCtrlQueryAttributePermissions, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = reqType;
+ req->attribute = attribute;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle();
+ return False;
+ }
+ exists = rep.flags;
+ if (exists && permissions) {
+ permissions->type = rep.attr_type;
+ permissions->permissions = rep.perms;
+ }
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return exists;
+}
+
+
+Bool XNVCTRLQueryAttributePermissions (
+ Display *dpy,
+ unsigned int attribute,
+ NVCTRLAttributePermissionsRec *permissions
+){
+ return QueryAttributePermissionsInternal(dpy,
+ attribute,
+ permissions,
+ X_nvCtrlQueryAttributePermissions);
+}
+
+
+Bool XNVCTRLQueryStringAttributePermissions (
+ Display *dpy,
+ unsigned int attribute,
+ NVCTRLAttributePermissionsRec *permissions
+){
+ return QueryAttributePermissionsInternal(dpy,
+ attribute,
+ permissions,
+ X_nvCtrlQueryStringAttributePermissions);
+}
+
+
+Bool XNVCTRLQueryBinaryDataAttributePermissions (
+ Display *dpy,
+ unsigned int attribute,
+ NVCTRLAttributePermissionsRec *permissions
+){
+ return QueryAttributePermissionsInternal(dpy,
+ attribute,
+ permissions,
+ X_nvCtrlQueryBinaryDataAttributePermissions);
+}
+
+
+Bool XNVCTRLQueryStringOperationAttributePermissions (
+ Display *dpy,
+ unsigned int attribute,
+ NVCTRLAttributePermissionsRec *permissions
+){
+ return QueryAttributePermissionsInternal(dpy,
+ attribute,
+ permissions,
+ X_nvCtrlQueryStringOperationAttributePermissions);
+}
+
+
+void XNVCTRLSetGvoColorConversion (
+ Display *dpy,
+ int screen,
+ float colorMatrix[3][3],
+ float colorOffset[3],
+ float colorScale[3]
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSetGvoColorConversionReq *req;
+
+ XNVCTRLSimpleCheckExtension (dpy, info);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSetGvoColorConversion, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSetGvoColorConversion;
+ req->screen = screen;
+
+ req->cscMatrix_y_r = colorMatrix[0][0];
+ req->cscMatrix_y_g = colorMatrix[0][1];
+ req->cscMatrix_y_b = colorMatrix[0][2];
+
+ req->cscMatrix_cr_r = colorMatrix[1][0];
+ req->cscMatrix_cr_g = colorMatrix[1][1];
+ req->cscMatrix_cr_b = colorMatrix[1][2];
+
+ req->cscMatrix_cb_r = colorMatrix[2][0];
+ req->cscMatrix_cb_g = colorMatrix[2][1];
+ req->cscMatrix_cb_b = colorMatrix[2][2];
+
+ req->cscOffset_y = colorOffset[0];
+ req->cscOffset_cr = colorOffset[1];
+ req->cscOffset_cb = colorOffset[2];
+
+ req->cscScale_y = colorScale[0];
+ req->cscScale_cr = colorScale[1];
+ req->cscScale_cb = colorScale[2];
+
+ UnlockDisplay (dpy);
+ SyncHandle ();
+}
+
+
+Bool XNVCTRLQueryGvoColorConversion (
+ Display *dpy,
+ int screen,
+ float colorMatrix[3][3],
+ float colorOffset[3],
+ float colorScale[3]
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryGvoColorConversionReply rep;
+ xnvCtrlQueryGvoColorConversionReq *req;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+
+ GetReq (nvCtrlQueryGvoColorConversion, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryGvoColorConversion;
+ req->screen = screen;
+
+ if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+
+ _XRead(dpy, (char *)(colorMatrix), 36);
+ _XRead(dpy, (char *)(colorOffset), 12);
+ _XRead(dpy, (char *)(colorScale), 12);
+
+ UnlockDisplay (dpy);
+ SyncHandle ();
+
+ return True;
+}
+
+
+Bool XNVCtrlSelectTargetNotify (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ int notify_type,
+ Bool onoff
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSelectTargetNotifyReq *req;
+
+ if(!XextHasExtension (info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSelectTargetNotify, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSelectTargetNotify;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->notifyType = notify_type;
+ req->onoff = onoff;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+
+ return True;
+}
+
+
+Bool XNVCtrlSelectNotify (
+ Display *dpy,
+ int screen,
+ int type,
+ Bool onoff
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlSelectNotifyReq *req;
+
+ if(!XextHasExtension (info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlSelectNotify, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlSelectNotify;
+ req->screen = screen;
+ req->notifyType = type;
+ req->onoff = onoff;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+
+ return True;
+}
+
+Bool XNVCTRLQueryTargetBinaryData (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ unsigned char **ptr,
+ int *len
+){
+ XExtDisplayInfo *info = find_display (dpy);
+ xnvCtrlQueryBinaryDataReply rep;
+ xnvCtrlQueryBinaryDataReq *req;
+ Bool exists;
+ int length, numbytes, slop;
+
+ if (!ptr) return False;
+
+ if(!XextHasExtension(info))
+ return False;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ LockDisplay (dpy);
+ GetReq (nvCtrlQueryBinaryData, req);
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlQueryBinaryData;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+ if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ }
+ length = rep.length;
+ numbytes = rep.n;
+ slop = numbytes & 3;
+ exists = rep.flags;
+ if (exists) {
+ *ptr = (unsigned char *) Xmalloc(numbytes);
+ }
+ if (!exists || !*ptr) {
+ _XEatData(dpy, length);
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return False;
+ } else {
+ _XRead(dpy, (char *) *ptr, numbytes);
+ if (slop) _XEatData(dpy, 4-slop);
+ }
+ if (len) *len = numbytes;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return exists;
+}
+
+Bool XNVCTRLQueryBinaryData (
+ Display *dpy,
+ int screen,
+ unsigned int display_mask,
+ unsigned int attribute,
+ unsigned char **ptr,
+ int *len
+){
+ return XNVCTRLQueryTargetBinaryData(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
+ screen, display_mask,
+ attribute, ptr, len);
+}
+
+Bool XNVCTRLStringOperation (
+ Display *dpy,
+ int target_type,
+ int target_id,
+ unsigned int display_mask,
+ unsigned int attribute,
+ char *pIn,
+ char **ppOut
+) {
+ XExtDisplayInfo *info = find_display(dpy);
+ xnvCtrlStringOperationReq *req;
+ xnvCtrlStringOperationReply rep;
+ Bool ret;
+ int inSize, outSize, length, slop;
+
+ if (!XextHasExtension(info))
+ return False;
+
+ if (!ppOut)
+ return False;
+
+ *ppOut = NULL;
+
+ XNVCTRLCheckExtension(dpy, info, False);
+ XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
+
+ if (pIn) {
+ inSize = strlen(pIn) + 1;
+ } else {
+ inSize = 0;
+ }
+
+ LockDisplay(dpy);
+ GetReq(nvCtrlStringOperation, req);
+
+ req->reqType = info->codes->major_opcode;
+ req->nvReqType = X_nvCtrlStringOperation;
+ req->target_type = target_type;
+ req->target_id = target_id;
+ req->display_mask = display_mask;
+ req->attribute = attribute;
+
+ req->length += ((inSize + 3) & ~3) >> 2;
+ req->num_bytes = inSize;
+
+ if (pIn) {
+ Data(dpy, pIn, inSize);
+ }
+
+ if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
+ UnlockDisplay(dpy);
+ SyncHandle();
+ return False;
+ }
+
+ length = rep.length;
+ outSize = rep.num_bytes;
+ slop = outSize & 3;
+
+ if (outSize) *ppOut = (char *) Xmalloc(outSize);
+
+ if (!*ppOut) {
+ _XEatData(dpy, length);
+ } else {
+ _XRead(dpy, (char *) *ppOut, outSize);
+ if (slop) _XEatData(dpy, 4-slop);
+ }
+
+ ret = rep.ret;
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ return ret;
+}
+
+
+static Bool wire_to_event (Display *dpy, XEvent *host, xEvent *wire)
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ XNVCtrlEvent *re;
+ xnvctrlEvent *event;
+ XNVCtrlEventTarget *reTarget;
+ xnvctrlEventTarget *eventTarget;
+ XNVCtrlEventTargetAvailability *reTargetAvailability;
+ XNVCtrlStringEventTarget *reTargetString;
+ XNVCtrlBinaryEventTarget *reTargetBinary;
+
+ XNVCTRLCheckExtension (dpy, info, False);
+
+ switch ((wire->u.u.type & 0x7F) - info->codes->first_event) {
+ case ATTRIBUTE_CHANGED_EVENT:
+ re = (XNVCtrlEvent *) host;
+ event = (xnvctrlEvent *) wire;
+ re->attribute_changed.type = event->u.u.type & 0x7F;
+ re->attribute_changed.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply*) event);
+ re->attribute_changed.send_event = ((event->u.u.type & 0x80) != 0);
+ re->attribute_changed.display = dpy;
+ re->attribute_changed.time = event->u.attribute_changed.time;
+ re->attribute_changed.screen = event->u.attribute_changed.screen;
+ re->attribute_changed.display_mask =
+ event->u.attribute_changed.display_mask;
+ re->attribute_changed.attribute = event->u.attribute_changed.attribute;
+ re->attribute_changed.value = event->u.attribute_changed.value;
+ break;
+ case TARGET_ATTRIBUTE_CHANGED_EVENT:
+ reTarget = (XNVCtrlEventTarget *) host;
+ eventTarget = (xnvctrlEventTarget *) wire;
+ reTarget->attribute_changed.type = eventTarget->u.u.type & 0x7F;
+ reTarget->attribute_changed.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
+ reTarget->attribute_changed.send_event =
+ ((eventTarget->u.u.type & 0x80) != 0);
+ reTarget->attribute_changed.display = dpy;
+ reTarget->attribute_changed.time =
+ eventTarget->u.attribute_changed.time;
+ reTarget->attribute_changed.target_type =
+ eventTarget->u.attribute_changed.target_type;
+ reTarget->attribute_changed.target_id =
+ eventTarget->u.attribute_changed.target_id;
+ reTarget->attribute_changed.display_mask =
+ eventTarget->u.attribute_changed.display_mask;
+ reTarget->attribute_changed.attribute =
+ eventTarget->u.attribute_changed.attribute;
+ reTarget->attribute_changed.value =
+ eventTarget->u.attribute_changed.value;
+ break;
+ case TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT:
+ reTargetAvailability = (XNVCtrlEventTargetAvailability *) host;
+ eventTarget = (xnvctrlEventTarget *) wire;
+ reTargetAvailability->attribute_changed.type =
+ eventTarget->u.u.type & 0x7F;
+ reTargetAvailability->attribute_changed.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
+ reTargetAvailability->attribute_changed.send_event =
+ ((eventTarget->u.u.type & 0x80) != 0);
+ reTargetAvailability->attribute_changed.display = dpy;
+ reTargetAvailability->attribute_changed.time =
+ eventTarget->u.availability_changed.time;
+ reTargetAvailability->attribute_changed.target_type =
+ eventTarget->u.availability_changed.target_type;
+ reTargetAvailability->attribute_changed.target_id =
+ eventTarget->u.availability_changed.target_id;
+ reTargetAvailability->attribute_changed.display_mask =
+ eventTarget->u.availability_changed.display_mask;
+ reTargetAvailability->attribute_changed.attribute =
+ eventTarget->u.availability_changed.attribute;
+ reTargetAvailability->attribute_changed.availability =
+ eventTarget->u.availability_changed.availability;
+ reTargetAvailability->attribute_changed.value =
+ eventTarget->u.availability_changed.value;
+ break;
+ case TARGET_STRING_ATTRIBUTE_CHANGED_EVENT:
+ reTargetString = (XNVCtrlStringEventTarget *) host;
+ eventTarget = (xnvctrlEventTarget *) wire;
+ reTargetString->attribute_changed.type = eventTarget->u.u.type & 0x7F;
+ reTargetString->attribute_changed.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
+ reTargetString->attribute_changed.send_event =
+ ((eventTarget->u.u.type & 0x80) != 0);
+ reTargetString->attribute_changed.display = dpy;
+ reTargetString->attribute_changed.time =
+ eventTarget->u.attribute_changed.time;
+ reTargetString->attribute_changed.target_type =
+ eventTarget->u.attribute_changed.target_type;
+ reTargetString->attribute_changed.target_id =
+ eventTarget->u.attribute_changed.target_id;
+ reTargetString->attribute_changed.display_mask =
+ eventTarget->u.attribute_changed.display_mask;
+ reTargetString->attribute_changed.attribute =
+ eventTarget->u.attribute_changed.attribute;
+ break;
+ case TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT:
+ reTargetBinary = (XNVCtrlBinaryEventTarget *) host;
+ eventTarget = (xnvctrlEventTarget *) wire;
+ reTargetBinary->attribute_changed.type = eventTarget->u.u.type & 0x7F;
+ reTargetBinary->attribute_changed.serial =
+ _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
+ reTargetBinary->attribute_changed.send_event =
+ ((eventTarget->u.u.type & 0x80) != 0);
+ reTargetBinary->attribute_changed.display = dpy;
+ reTargetBinary->attribute_changed.time =
+ eventTarget->u.attribute_changed.time;
+ reTargetBinary->attribute_changed.target_type =
+ eventTarget->u.attribute_changed.target_type;
+ reTargetBinary->attribute_changed.target_id =
+ eventTarget->u.attribute_changed.target_id;
+ reTargetBinary->attribute_changed.display_mask =
+ eventTarget->u.attribute_changed.display_mask;
+ reTargetBinary->attribute_changed.attribute =
+ eventTarget->u.attribute_changed.attribute;
+ break;
+
+ default:
+ return False;
+ }
+
+ return True;
+}
+