glx: indent -br -i3 -npcs --no-tabs glxcurrent.c

1 files changed, 284 insertions, 265 deletions

diff --git a/src/glx/x11/glxcurrent.c b/src/glx/x11/glxcurrent.c
index 0f6afcd366..89be63c5fa 100644
--- a/src/glx/x11/glxcurrent.c
+++ b/src/glx/x11/glxcurrent.c
@@ -56,11 +56,11 @@ static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
 ** the dummy context structure.
 */
 static __GLXcontext dummyContext = {
-    &dummyBuffer[0],
-    &dummyBuffer[0],
-    &dummyBuffer[0],
-    &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
-    sizeof(dummyBuffer),
+   &dummyBuffer[0],
+   &dummyBuffer[0],
+   &dummyBuffer[0],
+   &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
+   sizeof(dummyBuffer),
 };
 
 
@@ -80,7 +80,8 @@ static __GLapi *IndirectAPI = NULL;
 static GLboolean TSDinitialized = GL_FALSE;
 static xthread_key_t ContextTSD;
 
-_X_HIDDEN __GLXcontext *__glXGetCurrentContext(void)
+_X_HIDDEN __GLXcontext *
+__glXGetCurrentContext(void)
 {
    if (!TSDinitialized) {
       xthread_key_create(&ContextTSD, NULL);
@@ -97,7 +98,8 @@ _X_HIDDEN __GLXcontext *__glXGetCurrentContext(void)
    }
 }
 
-_X_HIDDEN void __glXSetCurrentContext(__GLXcontext *c)
+_X_HIDDEN void
+__glXSetCurrentContext(__GLXcontext * c)
 {
    if (!TSDinitialized) {
       xthread_key_create(&ContextTSD, NULL);
@@ -123,12 +125,13 @@ _X_HIDDEN pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
  * \b never be \c NULL.  This is important!  Because of this
  * \c __glXGetCurrentContext can be implemented as trivial macro.
  */
-__thread void * __glX_tls_Context __attribute__((tls_model("initial-exec")))
-    = &dummyContext;
+__thread void *__glX_tls_Context __attribute__ ((tls_model("initial-exec")))
+   = &dummyContext;
 
-_X_HIDDEN void __glXSetCurrentContext( __GLXcontext * c )
+_X_HIDDEN void
+__glXSetCurrentContext(__GLXcontext * c)
 {
-    __glX_tls_Context = (c != NULL) ? c : &dummyContext;
+   __glX_tls_Context = (c != NULL) ? c : &dummyContext;
 }
 
 # else
@@ -151,28 +154,31 @@ static pthread_key_t ContextTSD;
  * initialize the per-thread data key.  This is ideally done using the
  * \c pthread_once mechanism.
  */
-static void init_thread_data( void )
+static void
+init_thread_data(void)
 {
-    if ( pthread_key_create( & ContextTSD, NULL ) != 0 ) {
-	perror( "pthread_key_create" );
-	exit( -1 );
-    }
+   if (pthread_key_create(&ContextTSD, NULL) != 0) {
+      perror("pthread_key_create");
+      exit(-1);
+   }
 }
 
-_X_HIDDEN void __glXSetCurrentContext( __GLXcontext * c )
+_X_HIDDEN void
+__glXSetCurrentContext(__GLXcontext * c)
 {
-    pthread_once( & once_control, init_thread_data );
-    pthread_setspecific( ContextTSD, c );
+   pthread_once(&once_control, init_thread_data);
+   pthread_setspecific(ContextTSD, c);
 }
 
-_X_HIDDEN __GLXcontext * __glXGetCurrentContext( void )
+_X_HIDDEN __GLXcontext *
+__glXGetCurrentContext(void)
 {
-    void * v;
+   void *v;
 
-    pthread_once( & once_control, init_thread_data );
+   pthread_once(&once_control, init_thread_data);
 
-    v = pthread_getspecific( ContextTSD );
-    return (v == NULL) ? & dummyContext : (__GLXcontext *) v;
+   v = pthread_getspecific(ContextTSD);
+   return (v == NULL) ? &dummyContext : (__GLXcontext *) v;
 }
 
 # endif /* defined( GLX_USE_TLS ) */
@@ -189,32 +195,36 @@ _X_HIDDEN __GLXcontext *__glXcurrentContext = &dummyContext;
 #endif
 
 
-_X_HIDDEN void __glXSetCurrentContextNull(void)
+_X_HIDDEN void
+__glXSetCurrentContextNull(void)
 {
-    __glXSetCurrentContext(&dummyContext);
+   __glXSetCurrentContext(&dummyContext);
 #ifdef GLX_DIRECT_RENDERING
-    _glapi_set_dispatch(NULL);  /* no-op functions */
+   _glapi_set_dispatch(NULL);   /* no-op functions */
 #endif
 }
 
 
 /************************************************************************/
 
-PUBLIC GLXContext glXGetCurrentContext(void)
+PUBLIC GLXContext
+glXGetCurrentContext(void)
 {
-    GLXContext cx = __glXGetCurrentContext();
-    
-    if (cx == &dummyContext) {
-	return NULL;
-    } else {
-	return cx;
-    }
+   GLXContext cx = __glXGetCurrentContext();
+
+   if (cx == &dummyContext) {
+      return NULL;
+   }
+   else {
+      return cx;
+   }
 }
 
-PUBLIC GLXDrawable glXGetCurrentDrawable(void)
+PUBLIC GLXDrawable
+glXGetCurrentDrawable(void)
 {
-    GLXContext gc = __glXGetCurrentContext();
-    return gc->currentDrawable;
+   GLXContext gc = __glXGetCurrentContext();
+   return gc->currentDrawable;
 }
 
 
@@ -234,107 +244,109 @@ PUBLIC GLXDrawable glXGetCurrentDrawable(void)
  * \warning
  * This function assumes that \c dpy is locked with \c LockDisplay on entry.
  */
-static Bool SendMakeCurrentRequest(Display *dpy, CARD8 opcode,
-				   GLXContextID gc_id, GLXContextTag gc_tag,
-				   GLXDrawable draw, GLXDrawable read,
-				   xGLXMakeCurrentReply *reply)
+static Bool
+SendMakeCurrentRequest(Display * dpy, CARD8 opcode,
+                       GLXContextID gc_id, GLXContextTag gc_tag,
+                       GLXDrawable draw, GLXDrawable read,
+                       xGLXMakeCurrentReply * reply)
 {
-    Bool ret;
-
-
-    LockDisplay(dpy);
-
-    if (draw == read) {
-	xGLXMakeCurrentReq *req;
-
-	GetReq(GLXMakeCurrent,req);
-	req->reqType = opcode;
-	req->glxCode = X_GLXMakeCurrent;
-	req->drawable = draw;
-	req->context = gc_id;
-	req->oldContextTag = gc_tag;
-    }
-    else {
-	__GLXdisplayPrivate *priv = __glXInitialize(dpy);
-
-	/* If the server can support the GLX 1.3 version, we should
-	 * perfer that.  Not only that, some servers support GLX 1.3 but
-	 * not the SGI extension.
-	 */
-
-	if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
-	    xGLXMakeContextCurrentReq *req;
-
-	    GetReq(GLXMakeContextCurrent,req);
-	    req->reqType = opcode;
-	    req->glxCode = X_GLXMakeContextCurrent;
-	    req->drawable = draw;
-	    req->readdrawable = read;
-	    req->context = gc_id;
-	    req->oldContextTag = gc_tag;
-	}
-	else {
-	    xGLXVendorPrivateWithReplyReq *vpreq;
-	    xGLXMakeCurrentReadSGIReq *req;
-
-	    GetReqExtra(GLXVendorPrivateWithReply,
-			sz_xGLXMakeCurrentReadSGIReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
-	    req = (xGLXMakeCurrentReadSGIReq *)vpreq;
-	    req->reqType = opcode;
-	    req->glxCode = X_GLXVendorPrivateWithReply;
-	    req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
-	    req->drawable = draw;
-	    req->readable = read;
-	    req->context = gc_id;
-	    req->oldContextTag = gc_tag;
-	}
-    }
-
-    ret = _XReply(dpy, (xReply*) reply, 0, False);
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-    return ret;
+   Bool ret;
+
+
+   LockDisplay(dpy);
+
+   if (draw == read) {
+      xGLXMakeCurrentReq *req;
+
+      GetReq(GLXMakeCurrent, req);
+      req->reqType = opcode;
+      req->glxCode = X_GLXMakeCurrent;
+      req->drawable = draw;
+      req->context = gc_id;
+      req->oldContextTag = gc_tag;
+   }
+   else {
+      __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+      /* If the server can support the GLX 1.3 version, we should
+       * perfer that.  Not only that, some servers support GLX 1.3 but
+       * not the SGI extension.
+       */
+
+      if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
+         xGLXMakeContextCurrentReq *req;
+
+         GetReq(GLXMakeContextCurrent, req);
+         req->reqType = opcode;
+         req->glxCode = X_GLXMakeContextCurrent;
+         req->drawable = draw;
+         req->readdrawable = read;
+         req->context = gc_id;
+         req->oldContextTag = gc_tag;
+      }
+      else {
+         xGLXVendorPrivateWithReplyReq *vpreq;
+         xGLXMakeCurrentReadSGIReq *req;
+
+         GetReqExtra(GLXVendorPrivateWithReply,
+                     sz_xGLXMakeCurrentReadSGIReq -
+                     sz_xGLXVendorPrivateWithReplyReq, vpreq);
+         req = (xGLXMakeCurrentReadSGIReq *) vpreq;
+         req->reqType = opcode;
+         req->glxCode = X_GLXVendorPrivateWithReply;
+         req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
+         req->drawable = draw;
+         req->readable = read;
+         req->context = gc_id;
+         req->oldContextTag = gc_tag;
+      }
+   }
+
+   ret = _XReply(dpy, (xReply *) reply, 0, False);
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return ret;
 }
 
 
 #ifdef GLX_DIRECT_RENDERING
 static __GLXDRIdrawable *
-FetchDRIDrawable(Display *dpy,
-		 GLXDrawable glxDrawable, GLXContext gc, Bool pre13)
+FetchDRIDrawable(Display * dpy,
+                 GLXDrawable glxDrawable, GLXContext gc, Bool pre13)
 {
-    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
-    __GLXDRIdrawable *pdraw;
-    __GLXscreenConfigs *psc;
-    XID drawable;
-
-    if (priv == NULL)
-	return NULL;
-    
-    psc = &priv->screenConfigs[gc->screen];
-    if (psc->drawHash == NULL)
-	return NULL;
-
-    if (__glxHashLookup(psc->drawHash, glxDrawable, (void *) &pdraw) == 0)
-	return pdraw;
-
-    /* If this is glXMakeCurrent (pre GLX 1.3) we allow creating the
-     * GLX drawable on the fly.  Otherwise we pass None as the X
-     * drawable */
-    if (pre13)
-	drawable = glxDrawable;
-    else
-	drawable = None;
-
-    pdraw = psc->driScreen->createDrawable(psc, drawable,
-					   glxDrawable, gc->mode);
-    if (__glxHashInsert(psc->drawHash, glxDrawable, pdraw)) {
-	(*pdraw->destroyDrawable)(pdraw);
-	return NULL;
-    }
-
-    return pdraw;
+   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
+   __GLXDRIdrawable *pdraw;
+   __GLXscreenConfigs *psc;
+   XID drawable;
+
+   if (priv == NULL)
+      return NULL;
+
+   psc = &priv->screenConfigs[gc->screen];
+   if (psc->drawHash == NULL)
+      return NULL;
+
+   if (__glxHashLookup(psc->drawHash, glxDrawable, (void *) &pdraw) == 0)
+      return pdraw;
+
+   /* If this is glXMakeCurrent (pre GLX 1.3) we allow creating the
+    * GLX drawable on the fly.  Otherwise we pass None as the X
+    * drawable */
+   if (pre13)
+      drawable = glxDrawable;
+   else
+      drawable = None;
+
+   pdraw = psc->driScreen->createDrawable(psc, drawable,
+                                          glxDrawable, gc->mode);
+   if (__glxHashInsert(psc->drawHash, glxDrawable, pdraw)) {
+      (*pdraw->destroyDrawable) (pdraw);
+      return NULL;
+   }
+
+   return pdraw;
 }
 #endif /* GLX_DIRECT_RENDERING */
 
@@ -344,170 +356,177 @@ FetchDRIDrawable(Display *dpy,
  * 
  * \note This is in this file so that it can access dummyContext.
  */
-static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
-			       GLXDrawable read, GLXContext gc,
-			       Bool pre13)
+static Bool
+MakeContextCurrent(Display * dpy, GLXDrawable draw,
+                   GLXDrawable read, GLXContext gc, Bool pre13)
 {
-    xGLXMakeCurrentReply reply;
-    const GLXContext oldGC = __glXGetCurrentContext();
-    const CARD8 opcode = __glXSetupForCommand(dpy);
-    const CARD8 oldOpcode = ((gc == oldGC) || (oldGC == &dummyContext))
+   xGLXMakeCurrentReply reply;
+   const GLXContext oldGC = __glXGetCurrentContext();
+   const CARD8 opcode = __glXSetupForCommand(dpy);
+   const CARD8 oldOpcode = ((gc == oldGC) || (oldGC == &dummyContext))
       ? opcode : __glXSetupForCommand(oldGC->currentDpy);
-    Bool bindReturnValue;
+   Bool bindReturnValue;
 
 
-    if (!opcode || !oldOpcode) {
-	return GL_FALSE;
-    }
+   if (!opcode || !oldOpcode) {
+      return GL_FALSE;
+   }
 
-    /* Make sure that the new context has a nonzero ID.  In the request,
-     * a zero context ID is used only to mean that we bind to no current
-     * context.
-     */
-    if ((gc != NULL) && (gc->xid == None)) {
-	return GL_FALSE;
-    }
+   /* Make sure that the new context has a nonzero ID.  In the request,
+    * a zero context ID is used only to mean that we bind to no current
+    * context.
+    */
+   if ((gc != NULL) && (gc->xid == None)) {
+      return GL_FALSE;
+   }
 
-    _glapi_check_multithread();
+   _glapi_check_multithread();
 
 #ifdef GLX_DIRECT_RENDERING
-    /* Bind the direct rendering context to the drawable */
-    if (gc && gc->driContext) {
-	__GLXDRIdrawable *pdraw = FetchDRIDrawable(dpy, draw, gc, pre13);
-	__GLXDRIdrawable *pread = FetchDRIDrawable(dpy, read, gc, pre13);
-
-	bindReturnValue =
-	    (gc->driContext->bindContext) (gc->driContext, pdraw, pread);
-    } else
+   /* Bind the direct rendering context to the drawable */
+   if (gc && gc->driContext) {
+      __GLXDRIdrawable *pdraw = FetchDRIDrawable(dpy, draw, gc, pre13);
+      __GLXDRIdrawable *pread = FetchDRIDrawable(dpy, read, gc, pre13);
+
+      bindReturnValue =
+         (gc->driContext->bindContext) (gc->driContext, pdraw, pread);
+   }
+   else
 #endif
-    {
-	/* Send a glXMakeCurrent request to bind the new context. */
-	bindReturnValue = 
-	  SendMakeCurrentRequest(dpy, opcode, gc ? gc->xid : None,
-				 ((dpy != oldGC->currentDpy) || oldGC->isDirect)
-				 ? None : oldGC->currentContextTag,
-				 draw, read, &reply);
-    }
+   {
+      /* Send a glXMakeCurrent request to bind the new context. */
+      bindReturnValue =
+         SendMakeCurrentRequest(dpy, opcode, gc ? gc->xid : None,
+                                ((dpy != oldGC->currentDpy)
+                                 || oldGC->isDirect)
+                                ? None : oldGC->currentContextTag, draw, read,
+                                &reply);
+   }
 
 
-    if (!bindReturnValue) {
-	return False;
-    }
+   if (!bindReturnValue) {
+      return False;
+   }
 
 #ifdef GLX_DIRECT_RENDERING
-    if ((dpy != oldGC->currentDpy || (gc && gc->driContext)) &&
-	!oldGC->isDirect && oldGC != &dummyContext) {
+   if ((dpy != oldGC->currentDpy || (gc && gc->driContext)) &&
+       !oldGC->isDirect && oldGC != &dummyContext) {
 #else
-    if ((dpy != oldGC->currentDpy) && oldGC != &dummyContext) {
+   if ((dpy != oldGC->currentDpy) && oldGC != &dummyContext) {
 #endif
-	xGLXMakeCurrentReply dummy_reply;
-
-	/* We are either switching from one dpy to another and have to
-	 * send a request to the previous dpy to unbind the previous
-	 * context, or we are switching away from a indirect context to
-	 * a direct context and have to send a request to the dpy to
-	 * unbind the previous context.
-	 */
-	(void) SendMakeCurrentRequest(oldGC->currentDpy, oldOpcode, None,
-				      oldGC->currentContextTag, None, None,
-				      & dummy_reply);
-    }
+      xGLXMakeCurrentReply dummy_reply;
+
+      /* We are either switching from one dpy to another and have to
+       * send a request to the previous dpy to unbind the previous
+       * context, or we are switching away from a indirect context to
+       * a direct context and have to send a request to the dpy to
+       * unbind the previous context.
+       */
+      (void) SendMakeCurrentRequest(oldGC->currentDpy, oldOpcode, None,
+                                    oldGC->currentContextTag, None, None,
+                                    &dummy_reply);
+   }
 #ifdef GLX_DIRECT_RENDERING
-    else if (oldGC->driContext) {
-	oldGC->driContext->unbindContext(oldGC->driContext);
-    }
+   else if (oldGC->driContext) {
+      oldGC->driContext->unbindContext(oldGC->driContext);
+   }
 #endif
 
 
-    /* Update our notion of what is current */
-    __glXLock();
-    if (gc == oldGC) {
-	/* Even though the contexts are the same the drawable might have
-	 * changed.  Note that gc cannot be the dummy, and that oldGC
-	 * cannot be NULL, therefore if they are the same, gc is not
-	 * NULL and not the dummy.
-	 */
-	gc->currentDrawable = draw;
-	gc->currentReadable = read;
-    } else {
-	if (oldGC != &dummyContext) {
-	    /* Old current context is no longer current to anybody */
-	    oldGC->currentDpy = 0;
-	    oldGC->currentDrawable = None;
-	    oldGC->currentReadable = None;
-	    oldGC->currentContextTag = 0;
-
-	    if (oldGC->xid == None) {
-		/* We are switching away from a context that was
-		 * previously destroyed, so we need to free the memory
-		 * for the old handle.
-		 */
+   /* Update our notion of what is current */
+   __glXLock();
+   if (gc == oldGC) {
+      /* Even though the contexts are the same the drawable might have
+       * changed.  Note that gc cannot be the dummy, and that oldGC
+       * cannot be NULL, therefore if they are the same, gc is not
+       * NULL and not the dummy.
+       */
+      gc->currentDrawable = draw;
+      gc->currentReadable = read;
+   }
+   else {
+      if (oldGC != &dummyContext) {
+         /* Old current context is no longer current to anybody */
+         oldGC->currentDpy = 0;
+         oldGC->currentDrawable = None;
+         oldGC->currentReadable = None;
+         oldGC->currentContextTag = 0;
+
+         if (oldGC->xid == None) {
+            /* We are switching away from a context that was
+             * previously destroyed, so we need to free the memory
+             * for the old handle.
+             */
 #ifdef GLX_DIRECT_RENDERING
-		/* Destroy the old direct rendering context */
-		if (oldGC->driContext) {
-		    oldGC->driContext->destroyContext(oldGC->driContext,
-						      oldGC->psc,
-						      oldGC->createDpy);
-		    oldGC->driContext = NULL;
-		}
+            /* Destroy the old direct rendering context */
+            if (oldGC->driContext) {
+               oldGC->driContext->destroyContext(oldGC->driContext,
+                                                 oldGC->psc,
+                                                 oldGC->createDpy);
+               oldGC->driContext = NULL;
+            }
 #endif
-		__glXFreeContext(oldGC);
-	    }
-	}
-	if (gc) {
-	    __glXSetCurrentContext(gc);
-
-	    gc->currentDpy = dpy;
-	    gc->currentDrawable = draw;
-	    gc->currentReadable = read;
-
-#ifdef GLX_DIRECT_RENDERING    
-            if (!gc->driContext) {
+            __glXFreeContext(oldGC);
+         }
+      }
+      if (gc) {
+         __glXSetCurrentContext(gc);
+
+         gc->currentDpy = dpy;
+         gc->currentDrawable = draw;
+         gc->currentReadable = read;
+
+#ifdef GLX_DIRECT_RENDERING
+         if (!gc->driContext) {
 #endif
-               if (!IndirectAPI)
-                  IndirectAPI = __glXNewIndirectAPI();
-               _glapi_set_dispatch(IndirectAPI);
+            if (!IndirectAPI)
+               IndirectAPI = __glXNewIndirectAPI();
+            _glapi_set_dispatch(IndirectAPI);
 
 #ifdef GLX_USE_APPLEGL
-               do {
-                   extern void XAppleDRIUseIndirectDispatch(void);
-                   XAppleDRIUseIndirectDispatch();
-               } while (0);
+            do {
+               extern void XAppleDRIUseIndirectDispatch(void);
+               XAppleDRIUseIndirectDispatch();
+            } while (0);
 #endif
 
-		__GLXattribute *state = 
-		  (__GLXattribute *)(gc->client_state_private);
-
-		gc->currentContextTag = reply.contextTag;
-		if (state->array_state == NULL) {
-		    (void) glGetString(GL_EXTENSIONS);
-		    (void) glGetString(GL_VERSION);
-		    __glXInitVertexArrayState(gc);
-		}
-#ifdef GLX_DIRECT_RENDERING    
-	    }
-	    else {
-		gc->currentContextTag = -1;
-	    }
+            __GLXattribute *state =
+               (__GLXattribute *) (gc->client_state_private);
+
+            gc->currentContextTag = reply.contextTag;
+            if (state->array_state == NULL) {
+               (void) glGetString(GL_EXTENSIONS);
+               (void) glGetString(GL_VERSION);
+               __glXInitVertexArrayState(gc);
+            }
+#ifdef GLX_DIRECT_RENDERING
+         }
+         else {
+            gc->currentContextTag = -1;
+         }
 #endif
-	} else {
-	    __glXSetCurrentContextNull();
-	}
-    }
-    __glXUnlock();
-    return GL_TRUE;
+      }
+      else {
+         __glXSetCurrentContextNull();
+      }
+   }
+   __glXUnlock();
+   return GL_TRUE;
 }
 
 
-PUBLIC Bool glXMakeCurrent(Display *dpy, GLXDrawable draw, GLXContext gc)
+PUBLIC Bool
+glXMakeCurrent(Display * dpy, GLXDrawable draw, GLXContext gc)
 {
-    return MakeContextCurrent(dpy, draw, draw, gc, True);
+   return MakeContextCurrent(dpy, draw, draw, gc, True);
 }
 
-PUBLIC GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
-	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
-	  (dpy, d, r, ctx, False), MakeContextCurrent)
+PUBLIC
+GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
+          (Display * dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
+          (dpy, d, r, ctx, False), MakeContextCurrent)
 
-PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
-	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
-	  (dpy, d, r, ctx, False), MakeContextCurrent)
+     PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
+                      (Display * dpy, GLXDrawable d, GLXDrawable r,
+                       GLXContext ctx), (dpy, d, r, ctx, False),
+                      MakeContextCurrent)