Remove ANGLE

This marks the end of EGL and OpenGL ES support on Windows.

The concepts of -opengl dynamic, -opengl desktop, QT_OPENGL=software,
etc. remain unchanged, with the exception of the disapperance of
everything ANGLE related.

CMake builds now work identically to qmake on Windows: they default to
'dynamic' OpenGL on Windows, unless -DINPUT_opengl=desktop is specified.

On Windows, Qt 6 is expected to default to the "dynamic" OpenGL model by
default, just like Qt 5.15. This can be changed by switching to "desktop"
OpenGL, which will link to opengl32 (publicly, so other libs and applications
will do so as well) and disallows using another OpenGL DLL.

The "dynamic" mode is essential still because the fallback to a software
rasterizer, such as the opengl32sw.dll we ship with the Qt packages,
has to to work exactly like in Qt 5, the removal of ANGLE does not
change this concept in any way (except of course that the middle option
of using ANGLE is now gone)

When it comes to the windows plugin's OpenGL blacklist feature, it works
like before and accepts the ANGLE/D3D related keywords. They will
then be ignored. Similarly, requesting QT_OPENGL=angle is ignored (but
will show a warning).

The D3D11 and DXGI configure time tests are removed: Qt 5.14 already
depends on D3D 11.1 and DXGI 1.3 headers being available unconditionally
on Win32 (in QRhi's D3D11 backend). No need to test for these.

[ChangeLog][Windows] ANGLE is no longer included with Qt. Dynamic OpenGL
builds work like before but ANGLE is no longer an option. OpenGL proper
or an alternative opengl32 implementation are the two remaining options
now. Attempting to set QT_OPENGL=angle or Qt::AA_UseOpenGLES will have
no effect on Windows.

Fixes: QTBUG-79103
Change-Id: Ia404e0d07f3fe191b27434d863c81180112ecb3b
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>

1 files changed, 0 insertions, 1240 deletions

diff --git a/src/3rdparty/angle/src/third_party/libXNVCtrl/NVCtrl.c b/src/3rdparty/angle/src/third_party/libXNVCtrl/NVCtrl.c
deleted file mode 100644
index e984373947..0000000000
--- a/src/3rdparty/angle/src/third_party/libXNVCtrl/NVCtrl.c
+++ /dev/null
@@ -1,1240 +0,0 @@
-/*
- * 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;
-}
-