Logo Search packages:      
Sourcecode: xorg-server version File versions  Download package

glxcmds.c

/* $XFree86: xc/programs/Xserver/GL/glx/glxcmds.c,v 1.8 2001/05/02 15:06:05 dawes Exp $ */
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
** 
** http://oss.sgi.com/projects/FreeB
** 
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
** 
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
** 
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
*/

#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif

#include "dmx.h"
#include "dmxwindow.h"
#include "dmxpixmap.h"
#include "dmxfont.h"
#include "dmxsync.h"

#undef Xmalloc
#undef Xcalloc
#undef Xrealloc
#undef Xfree

#define NEED_REPLIES
#define FONT_PCF
#include "glxserver.h"
#include <GL/glxtokens.h>
#include "g_disptab.h"
#include <pixmapstr.h>
#include <windowstr.h>
#include "glxutil.h"
#include "glxext.h"
#include "unpack.h"
#include "GL/glx_ansic.h"

#include "GL/glxproto.h"
#include "glxvendor.h"
#include "glxvisuals.h"
#include "glxswap.h"

#ifdef PANORAMIX
#include "panoramiXsrv.h"
extern XID *PanoramiXVisualTable;
#endif

extern __GLXFBConfig **__glXFBConfigs;
extern int            __glXNumFBConfigs;

extern __GLXFBConfig *glxLookupFBConfig( GLXFBConfigID id );
extern __GLXFBConfig *glxLookupFBConfigByVID( VisualID vid );
extern __GLXFBConfig *glxLookupBackEndFBConfig( GLXFBConfigID id, int screen );
extern int glxIsExtensionSupported( char *ext );
extern int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);

#define BE_TO_CLIENT_ERROR(x) \
           ( (x) >= __glXerrorBase ? \
             (x) - dmxScreen->glxErrorBase + __glXerrorBase \
           : (x) )

Display *GetBackEndDisplay( __GLXclientState *cl, int s )
{
   if (! cl->be_displays[s] ) {
      cl->be_displays[s] = XOpenDisplay( DisplayString(dmxScreens[s].beDisplay) );
   }
   return( cl->be_displays[s] );
}

/*
** Create a GL context with the given properties.
*/
static int CreateContext(__GLXclientState *cl, 
                         GLXContextID gcId,
                   VisualID vid, GLXFBConfigID fbconfigId,
                   int screen,
                   GLXContextID shareList,
                   int isDirect )
{
    ClientPtr client = cl->client;
    xGLXCreateContextReq *be_req;
    xGLXCreateNewContextReq *be_new_req;
    VisualPtr pVisual;
    ScreenPtr pScreen;
    __GLXcontext *glxc, *shareglxc;
    __GLXvisualConfig *pGlxVisual;
    __GLXscreenInfo *pGlxScreen;
    VisualID visual = vid;
    GLint i;
    int from_screen = screen;
    int to_screen = screen;
    DMXScreenInfo *dmxScreen;
    VisualID be_vid;
    GLXFBConfigID be_fbconfigId;
    int num_be_screens;
    Display *dpy;
    
    /*
    ** Check if screen exists.
    */
    if (screen >= screenInfo.numScreens) {
      client->errorValue = screen;
      return BadValue;
    }


#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    /*
     ** Find the display list space that we want to share.  
     **
     */
    if (shareList == None) {
       shareglxc = NULL;
    } else {
       shareglxc = (__GLXcontext *) LookupIDByType(shareList, __glXContextRes);
       if (!shareglxc) {
        client->errorValue = shareList;
        return __glXBadContext;
       }
    }

    /*
    ** Allocate memory for the new context
    */
    glxc = (__GLXcontext *) __glXMalloc(sizeof(__GLXcontext));
    if (!glxc) {
      return BadAlloc;
    }
    __glXMemset(glxc, 0, sizeof(__GLXcontext));

    pScreen = screenInfo.screens[screen];
    pGlxScreen = &__glXActiveScreens[screen];

    if (fbconfigId != None) {
       glxc->pFBConfig = glxLookupFBConfig( fbconfigId );
       if (!glxc->pFBConfig) {
        client->errorValue = fbconfigId;
        __glXFree( glxc );
        return BadValue;
       }
       visual = glxc->pFBConfig->associatedVisualId;
    }
    else {
       glxc->pFBConfig = NULL;
    }

    if (visual != None) {
       /*
      ** Check if the visual ID is valid for this screen.
      */
       pVisual = pScreen->visuals;
       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
        if (pVisual->vid == visual) {
           break;
        }
       }
       if (i == pScreen->numVisuals) {
        client->errorValue = visual;
        __glXFree( glxc );
        return BadValue;
       }

       pGlxVisual = pGlxScreen->pGlxVisual;
       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
        if (pGlxVisual->vid == visual) {
           break;
        }
       }
       if (i == pGlxScreen->numVisuals) {
        /*
         ** Visual not support on this screen by this OpenGL implementation.
         */
        client->errorValue = visual;
        __glXFree( glxc );
        return BadValue;
       }

       if ( glxc->pFBConfig == NULL ) {
         glxc->pFBConfig = glxLookupFBConfigByVID( visual );

         if ( glxc->pFBConfig == NULL ) {
            /*
               * visual does not have an FBConfig ???
            client->errorValue = visual;
            __glXFree( glxc );
            return BadValue;
             */
         }
       }
    }
    else {
       pVisual = NULL;
       pGlxVisual = NULL;
    }

    glxc->pScreen = pScreen;
    glxc->pGlxScreen = pGlxScreen;
    glxc->pVisual = pVisual;
    glxc->pGlxVisual = pGlxVisual;

    /*
     * allocate memory for back-end servers info
     */
    num_be_screens = to_screen - from_screen + 1;
    glxc->real_ids = (XID *)__glXMalloc(sizeof(XID) * num_be_screens);
    if (!glxc->real_ids) {
      return BadAlloc;
    }
    glxc->real_vids = (XID *)__glXMalloc(sizeof(XID) * num_be_screens);
    if (!glxc->real_vids) {
      return BadAlloc;
    }

    for (screen = from_screen; screen <= to_screen; screen++) {
       int sent = 0;
       pScreen = screenInfo.screens[screen];
       pGlxScreen = &__glXActiveScreens[screen];
       dmxScreen = &dmxScreens[screen];

       if (glxc->pFBConfig) {
        __GLXFBConfig *beFBConfig = glxLookupBackEndFBConfig( glxc->pFBConfig->id, 
                                                            screen );
        be_fbconfigId = beFBConfig->id;
       }

       if (pGlxVisual) {

        be_vid = glxMatchGLXVisualInConfigList( pGlxVisual,
                                          dmxScreen->glxVisuals,
                                  dmxScreen->numGlxVisuals  );

        if (!be_vid) {
           /* visual is not supported on the back-end server */
           __glXFree( glxc->real_ids );
           __glXFree( glxc->real_vids );
           __glXFree( glxc );
           return BadValue;
        }
       }

       glxc->real_ids[screen-from_screen] = XAllocID(GetBackEndDisplay(cl,screen));

       /* send the create context request to the back-end server */
       dpy = GetBackEndDisplay(cl,screen);
       if (glxc->pFBConfig) {
           /*Since for a certain visual both RGB and COLOR INDEX
            *can be on then the only parmeter to choose the renderType
            * should be the class of the colormap since all 4 first 
            * classes does not support RGB mode only COLOR INDEX ,
            * and so TrueColor and DirectColor does not support COLOR INDEX*/
           int renderType =  glxc->pFBConfig->renderType;  
           if ( pVisual ) {
             switch ( pVisual->class ){
                 case PseudoColor:
                     case StaticColor:
                     case GrayScale:
                     case StaticGray:
                         renderType = GLX_COLOR_INDEX_TYPE;
                         break;
                     case TrueColor:
                     case DirectColor:
                     default:
                         renderType = GLX_RGBA_TYPE;
                     break;
             }
           }
        if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
           LockDisplay(dpy);
           GetReq(GLXCreateNewContext,be_new_req);
           be_new_req->reqType = dmxScreen->glxMajorOpcode;
           be_new_req->glxCode = X_GLXCreateNewContext;
           be_new_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
           be_new_req->fbconfig = (unsigned int)be_fbconfigId;
           be_new_req->screen = DefaultScreen(dpy);
           be_new_req->renderType = renderType;  

           be_new_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
           be_new_req->isDirect = 0;
           UnlockDisplay(dpy);
           glxc->real_vids[screen-from_screen] = be_fbconfigId;
           sent = 1;
        }
        else if (glxIsExtensionSupported("GLX_SGIX_fbconfig")) {

           xGLXCreateContextWithConfigSGIXReq *ext_req;
           xGLXVendorPrivateReq *vpreq;
           LockDisplay(dpy);
           GetReqExtra(GLXVendorPrivate,
                     sz_xGLXCreateContextWithConfigSGIXReq - sz_xGLXVendorPrivateReq,
                  vpreq);
           ext_req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
           ext_req->reqType = dmxScreen->glxMajorOpcode;
           ext_req->glxCode = X_GLXVendorPrivate;
           ext_req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
           ext_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
           ext_req->fbconfig = (unsigned int)be_fbconfigId;
           ext_req->screen = DefaultScreen(dpy);
           ext_req->renderType = renderType;  
           ext_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
           ext_req->isDirect = 0;
           UnlockDisplay(dpy);
           glxc->real_vids[screen-from_screen] = be_fbconfigId;
           sent = 1;
        }
       }

       if (!sent) {
        LockDisplay(dpy);
        GetReq(GLXCreateContext,be_req);
        be_req->reqType = dmxScreen->glxMajorOpcode;
        be_req->glxCode = X_GLXCreateContext;
        be_req->context = (unsigned int)glxc->real_ids[screen-from_screen];
        be_req->visual = (unsigned int)be_vid;
        be_req->screen = DefaultScreen(dpy);
        be_req->shareList = (shareglxc ? shareglxc->real_ids[screen-from_screen] : 0);
        be_req->isDirect = 0;
        UnlockDisplay(dpy);
        glxc->real_vids[screen-from_screen] = be_vid;
       }
       SyncHandle();

    }

    /*
    ** Register this context as a resource.
    */
    if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
       __glXFree( glxc->real_ids );
       __glXFree( glxc->real_vids );
       __glXFree( glxc );
      client->errorValue = gcId;
      return BadAlloc;
    }
    
    /*
    ** Finally, now that everything is working, setup the rest of the
    ** context.
    */
    glxc->id = gcId;
    glxc->share_id = shareList;
    glxc->idExists = GL_TRUE;
    glxc->isCurrent = GL_FALSE;

    return Success;
}

int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
{
    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;

    return( CreateContext(cl, req->context,req->visual, None,
                        req->screen, req->shareList, req->isDirect) );

}

int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
{
    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;

    return( CreateContext(cl, req->context,None, req->fbconfig,
                        req->screen, req->shareList, req->isDirect) );

}

int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;

    return( CreateContext(cl, req->context, None, req->fbconfig,
                        req->screen, req->shareList, req->isDirect) );

}

int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXQueryMaxSwapBarriersSGIXReq *req =
      (xGLXQueryMaxSwapBarriersSGIXReq *)pc;
    xGLXQueryMaxSwapBarriersSGIXReply reply;

    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;
    reply.length = 0;
    reply.max = QueryMaxSwapBarriersSGIX(req->screen);

    if (client->swapped) {
      __glXSwapQueryMaxSwapBarriersSGIXReply(client, &reply);
    } else {
      WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply,
                  (char *)&reply);
    }

    return Success;
}

int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
    DrawablePtr pDraw;
    __GLXpixmap *pGlxPixmap = NULL;
    __glXWindow *pGlxWindow = NULL;

    pDraw = (DrawablePtr) LookupDrawable(req->drawable, client);
    if (!pDraw) {
      pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->drawable,
                                        __glXPixmapRes);
      if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
    }

    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
       pGlxWindow = (__glXWindow *) LookupIDByType(req->drawable,
                                       __glXWindowRes);
       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
    }

    if (!pDraw) {
       client->errorValue = req->drawable;
       return __glXBadDrawable;
    }

    return BindSwapBarrierSGIX(pDraw, req->barrier);
}

int __glXJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
    DrawablePtr pDraw, pMember = NULL;
    __GLXpixmap *pGlxPixmap = NULL;
    __glXWindow *pGlxWindow = NULL;

    pDraw = (DrawablePtr) LookupDrawable(req->drawable, client);
    if (!pDraw) {
      pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->drawable,
                                        __glXPixmapRes);
      if (pGlxPixmap) pDraw = pGlxPixmap->pDraw;
    }

    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
       pGlxWindow = (__glXWindow *) LookupIDByType(req->drawable,
                                       __glXWindowRes);
       if (pGlxWindow) pDraw = pGlxWindow->pDraw;
    }

    if (!pDraw) {
       client->errorValue = req->drawable;
       return __glXBadDrawable;
    }

    if (req->member != None) {
      pMember = (DrawablePtr) LookupDrawable(req->member, client);
      if (!pMember) {
          pGlxPixmap = (__GLXpixmap *) LookupIDByType(req->member,
                                          __glXPixmapRes);
          if (pGlxPixmap) pMember = pGlxPixmap->pDraw;
      }

      if (!pMember && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
          pGlxWindow = (__glXWindow *) LookupIDByType(req->member,
                                          __glXWindowRes);
          if (pGlxWindow) pMember = pGlxWindow->pDraw;
      }

      if (!pMember) {
          client->errorValue = req->member;
          return __glXBadDrawable;
      }
    }

    return JoinSwapGroupSGIX(pDraw, pMember);
}


/*
** Destroy a GL context as an X resource.
*/
int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
    xGLXDestroyContextReq *be_req;
    GLXContextID gcId = req->context;
    __GLXcontext *glxc;
    int from_screen = 0;
    int to_screen = 0;
    int s;
    
    glxc = (__GLXcontext *) LookupIDByType(gcId, __glXContextRes);
    if (glxc) {
      /*
      ** Just free the resource; don't actually destroy the context,
      ** because it might be in use.  The
      ** destroy method will be called by the resource destruction routine
      ** if necessary.
      */
      FreeResourceByType(gcId, __glXContextRes, FALSE);

      from_screen = to_screen = glxc->pScreen->myNum;

    } else {
      client->errorValue = gcId;
      return __glXBadContext;
    }

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    /*
     * send DestroyContext request to all back-end servers
     */
    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       LockDisplay(dpy);
       GetReq(GLXDestroyContext,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXDestroyContext;
       be_req->context = glxc->real_ids[s-from_screen];
       UnlockDisplay(dpy);
       SyncHandle();
    }

    return Success;
}

/*****************************************************************************/

/*
** For each client, the server keeps a table of all the contexts that are
** current for that client (each thread of a client may have its own current
** context).  These routines add, change, and lookup contexts in the table.
*/

/*
** Add a current context, and return the tag that will be used to refer to it.
*/
static int AddCurrentContext(__GLXclientState *cl, __GLXcontext *glxc, DrawablePtr pDraw)
{
    int i;
    int num = cl->numCurrentContexts;
    __GLXcontext **table = cl->currentContexts;

    if (!glxc) return -1;
    
    /*
    ** Try to find an empty slot and use it.
    */
    for (i=0; i < num; i++) {
      if (!table[i]) {
          table[i] = glxc;
          return i+1;
      }
    }
    /*
    ** Didn't find a free slot, so we'll have to grow the table.
    */
    if (!num) {
      table = (__GLXcontext **) __glXMalloc(sizeof(__GLXcontext *));
      cl->currentDrawables = (DrawablePtr *) __glXMalloc(sizeof(DrawablePtr));
      cl->be_currentCTag = (GLXContextTag *) __glXMalloc(screenInfo.numScreens *sizeof(GLXContextTag));
    } else {
      table = (__GLXcontext **) __glXRealloc(table,
                                 (num+1)*sizeof(__GLXcontext *));
      cl->currentDrawables = (DrawablePtr *) __glXRealloc(
                                                cl->currentDrawables ,
                                      (num+1)*sizeof(DrawablePtr));
      cl->be_currentCTag = (GLXContextTag *) __glXRealloc(cl->be_currentCTag,
                  (num+1)*screenInfo.numScreens*sizeof(GLXContextTag));
    }
    table[num] = glxc;
    cl->currentDrawables[num] = pDraw;
    cl->currentContexts = table;
    cl->numCurrentContexts++;

    __glXMemset(cl->be_currentCTag + num*screenInfo.numScreens, 0, 
               screenInfo.numScreens * sizeof(Display *));

    return num+1;
}

/*
** Given a tag, change the current context for the corresponding entry.
*/
static void ChangeCurrentContext(__GLXclientState *cl, __GLXcontext *glxc,
                        GLXContextTag tag)
{
    __GLXcontext **table = cl->currentContexts;
    table[tag-1] = glxc;
}

/*
** Given a tag, and back-end screen number, retrives the current back-end
** tag.
*/
int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s)
{
   if (tag >0) {
      return( cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] );
   }
   else {
      return( 0 );
   }
}

/*
** Given a tag, and back-end screen number, sets the current back-end
** tag.
*/
static void SetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s, GLXContextTag be_tag)
{
   if (tag >0) {
      cl->be_currentCTag[ (tag-1)*screenInfo.numScreens + s ] = be_tag;
   }
}

/*
** For this implementation we have chosen to simply use the index of the
** context's entry in the table as the context tag.  A tag must be greater
** than 0.
*/
__GLXcontext *__glXLookupContextByTag(__GLXclientState *cl, GLXContextTag tag)
{
    int num = cl->numCurrentContexts;

    if (tag < 1 || tag > num) {
      return 0;
    } else {
      return cl->currentContexts[tag-1];
    }
}

DrawablePtr __glXLookupDrawableByTag(__GLXclientState *cl, GLXContextTag tag)
{
    int num = cl->numCurrentContexts;

    if (tag < 1 || tag > num) {
      return 0;
    } else {
      return cl->currentDrawables[tag-1];
    }
}

/*****************************************************************************/

static void StopUsingContext(__GLXcontext *glxc)
{
    if (glxc) {
      if (glxc == __glXLastContext) {
          /* Tell server GL library */
          __glXLastContext = 0;
      }
      glxc->isCurrent = GL_FALSE;
      if (!glxc->idExists) {
          __glXFreeContext(glxc);
      }
    }
}

static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
{
    glxc->isCurrent = GL_TRUE;
}

/*****************************************************************************/
/*
** Make an OpenGL context and drawable current.
*/
static int MakeCurrent(__GLXclientState *cl,
                       GLXDrawable drawable,
                       GLXDrawable readdrawable,
                   GLXContextID context,
                   GLXContextTag oldContextTag)
{
    ClientPtr client = cl->client;
    DrawablePtr pDraw = NULL;
    DrawablePtr pReadDraw = NULL;
    xGLXMakeCurrentReadSGIReply new_reply;
    xGLXMakeCurrentReq *be_req;
    xGLXMakeCurrentReply be_reply;
    xGLXMakeContextCurrentReq *be_new_req;
    xGLXMakeContextCurrentReply be_new_reply;
    GLXDrawable drawId = drawable;
    GLXDrawable readId = readdrawable;
    GLXContextID contextId = context;
    __GLXpixmap *pGlxPixmap = 0;
    __GLXpixmap *pReadGlxPixmap = 0;
    __GLXcontext *glxc, *prevglxc;
    GLXContextTag tag = oldContextTag;
    WindowPtr pWin = NULL;
    WindowPtr pReadWin = NULL;
    __glXWindow *pGlxWindow = NULL;
    __glXWindow *pGlxReadWindow = NULL;
    __glXPbuffer *pGlxPbuffer = NULL;
    __glXPbuffer *pGlxReadPbuffer = NULL;
#ifdef PANORAMIX
    PanoramiXRes *pXinDraw = NULL;
    PanoramiXRes *pXinReadDraw = NULL;
#endif
    int from_screen = 0;
    int to_screen = 0;
    int s;

    /*
    ** If one is None and the other isn't, it's a bad match.
    */
    if ((drawId == None && contextId != None) ||
      (drawId != None && contextId == None)) {
      return BadMatch;
    }
    
    /*
    ** Lookup old context.  If we have one, it must be in a usable state.
    */
    if (tag != 0) {
      prevglxc = __glXLookupContextByTag(cl, tag);
      if (!prevglxc) {
          /*
          ** Tag for previous context is invalid.
          */
          return __glXBadContextTag;
      }
    } else {
      prevglxc = 0;
    }

    /*
    ** Lookup new context.  It must not be current for someone else.
    */
    if (contextId != None) {
      glxc = (__GLXcontext *) LookupIDByType(contextId, __glXContextRes);
      if (!glxc) {
          client->errorValue = contextId;
          return __glXBadContext;
      }
      if ((glxc != prevglxc) && glxc->isCurrent) {
          /* Context is current to somebody else */
          return BadAccess;
      }
    } else {
      /* Switching to no context.  Ignore new drawable. */
      glxc = 0;
    }

    if (drawId != None) {
      pDraw = (DrawablePtr) LookupDrawable(drawId, client);
      if (pDraw) {
          if (pDraw->type == DRAWABLE_WINDOW) {
            /*
            ** Drawable is an X Window.
            */
              VisualID vid;
            pWin = (WindowPtr)pDraw;
            vid = wVisual(pWin);

            new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
            new_reply.writeType = GLX_WINDOW_TYPE;

            /*
            ** Check if window and context are similar.
            */
            if ((vid != glxc->pVisual->vid) ||
                (pWin->drawable.pScreen != glxc->pScreen)) {
                client->errorValue = drawId;
                return BadMatch;
            }

            from_screen = to_screen = pWin->drawable.pScreen->myNum;

          } else {
            /*
            ** An X Pixmap is not allowed as a parameter (a GLX Pixmap
            ** is, but it must first be created with glxCreateGLXPixmap).
            */
            client->errorValue = drawId;
            return __glXBadDrawable;
          }
      }

        if (!pDraw) {
          pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
                                          __glXPixmapRes);
          if (pGlxPixmap) {
            /*
            ** Check if pixmap and context are similar.
            */
            if (pGlxPixmap->pScreen != glxc->pScreen ||
                pGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
                client->errorValue = drawId;
                return BadMatch;
            }
            pDraw = pGlxPixmap->pDraw;

            new_reply.writeVid = (glxc->pFBConfig ? glxc->pFBConfig->id : 
                                  pGlxPixmap->pGlxVisual->vid);

            new_reply.writeType = GLX_PIXMAP_TYPE;

            from_screen = to_screen = pGlxPixmap->pScreen->myNum;

          }
      }

      if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
         pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
            if (pGlxWindow) {
                /*
                ** Drawable is a GLXWindow.
                **
                ** Check if GLX window and context are similar.
                */
                if (pGlxWindow->pScreen != glxc->pScreen ||
                    pGlxWindow->pGlxFBConfig != glxc->pFBConfig) {
                    client->errorValue = drawId;
                    return BadMatch;
                }

                pDraw = pGlxWindow->pDraw;
                new_reply.writeVid = pGlxWindow->pGlxFBConfig->id;
                new_reply.writeType = GLX_GLXWINDOW_TYPE;
            }

      }

      if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
         pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
         if (pGlxPbuffer) {
                if (pGlxPbuffer->pScreen != glxc->pScreen ||
                    pGlxPbuffer->pFBConfig != glxc->pFBConfig) {
                    client->errorValue = drawId;
                    return BadMatch;
                }

            pDraw = (DrawablePtr)pGlxPbuffer;
                new_reply.writeVid = pGlxPbuffer->pFBConfig->id;
                new_reply.writeType = GLX_PBUFFER_TYPE;
         }
      }

      if (!pDraw) {
         /*
          ** Drawable is not a Window , GLXWindow or a GLXPixmap.
          */
         client->errorValue = drawId;
         return __glXBadDrawable;
      }

    } else {
      pDraw = 0;
    }

    if (readId != None && readId != drawId ) {
      pReadDraw = (DrawablePtr) LookupDrawable(readId, client);
      if (pReadDraw) {
          if (pReadDraw->type == DRAWABLE_WINDOW) {
            /*
            ** Drawable is an X Window.
            */
              VisualID vid;
            pReadWin = (WindowPtr)pDraw;
            vid = wVisual(pReadWin);

            new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id : vid);
            new_reply.readType = GLX_WINDOW_TYPE;

            /*
            ** Check if window and context are similar.
            */
            if ((vid != glxc->pVisual->vid) ||
                (pReadWin->drawable.pScreen != glxc->pScreen)) {
                client->errorValue = readId;
                return BadMatch;
            }

          } else {

            /*
            ** An X Pixmap is not allowed as a parameter (a GLX Pixmap
            ** is, but it must first be created with glxCreateGLXPixmap).
            */
            client->errorValue = readId;
            return __glXBadDrawable;
          }
      }

      if (!pReadDraw) {
          pReadGlxPixmap = (__GLXpixmap *) LookupIDByType(readId,
                                          __glXPixmapRes);
          if (pReadGlxPixmap) {
            /*
            ** Check if pixmap and context are similar.
            */
            if (pReadGlxPixmap->pScreen != glxc->pScreen ||
                pReadGlxPixmap->pGlxVisual != glxc->pGlxVisual) {
                client->errorValue = readId;
                return BadMatch;
            }
            pReadDraw = pReadGlxPixmap->pDraw;

            new_reply.readVid = (glxc->pFBConfig ? glxc->pFBConfig->id :
                                 pReadGlxPixmap->pGlxVisual->vid );
            new_reply.readType = GLX_PIXMAP_TYPE;

          }
      }

      if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
         pGlxReadWindow = (__glXWindow *)
                                LookupIDByType(readId, __glXWindowRes);
            if (pGlxReadWindow) {
                /*
                ** Drawable is a GLXWindow.
                **
                ** Check if GLX window and context are similar.
                */
                if (pGlxReadWindow->pScreen != glxc->pScreen ||
                    pGlxReadWindow->pGlxFBConfig != glxc->pFBConfig) {
                    client->errorValue = readId;
                    return BadMatch;
                }

                pReadDraw = pGlxReadWindow->pDraw;
                new_reply.readVid = pGlxReadWindow->pGlxFBConfig->id;
                new_reply.readType = GLX_GLXWINDOW_TYPE;
            }
      }

      if (!pReadDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
         pGlxReadPbuffer = (__glXPbuffer *)LookupIDByType(readId, __glXPbufferRes);
         if (pGlxReadPbuffer) {
                if (pGlxReadPbuffer->pScreen != glxc->pScreen ||
                    pGlxReadPbuffer->pFBConfig != glxc->pFBConfig) {
                    client->errorValue = drawId;
                    return BadMatch;
                }

            pReadDraw = (DrawablePtr)pGlxReadPbuffer;
                new_reply.readVid = pGlxReadPbuffer->pFBConfig->id;
                new_reply.readType = GLX_PBUFFER_TYPE;
         }
      }

      if (!pReadDraw) {
         /*
          ** Drawable is neither a Window nor a GLXPixmap.
          */
         client->errorValue = readId;
         return __glXBadDrawable;
      }

    } else {
      pReadDraw = pDraw;
      pReadGlxPixmap = pGlxPixmap;
      pReadWin = pWin;
      new_reply.readVid = new_reply.writeVid;
      new_reply.readType = new_reply.writeType;
    }

    if (prevglxc) {

      if (prevglxc->pGlxPixmap) {
          /*
          ** The previous drawable was a glx pixmap, release it.
          */
          prevglxc->pGlxPixmap->refcnt--;
          __glXFreeGLXPixmap( prevglxc->pGlxPixmap );
          prevglxc->pGlxPixmap = 0;
      }

      if (prevglxc->pGlxReadPixmap && 
          prevglxc->pGlxReadPixmap != prevglxc->pGlxPixmap ) {
          /*
          ** The previous drawable was a glx pixmap, release it.
          */
          prevglxc->pGlxReadPixmap->refcnt--;
          __glXFreeGLXPixmap( prevglxc->pGlxReadPixmap );
          prevglxc->pGlxReadPixmap = 0;
      }

      if (prevglxc->pGlxWindow) {
          /*
          ** The previous drawable was a glx window, release it.
          */
          prevglxc->pGlxWindow->refcnt--;
          __glXFreeGLXWindow( prevglxc->pGlxWindow );
          prevglxc->pGlxWindow = 0;   
      }

      if (prevglxc->pGlxReadWindow &&
          prevglxc->pGlxReadWindow != prevglxc->pGlxWindow) {
          /*
          ** The previous drawable was a glx window, release it.
          */
          prevglxc->pGlxReadWindow->refcnt--;
          __glXFreeGLXWindow( prevglxc->pGlxReadWindow );
          prevglxc->pGlxReadWindow = 0;   
      }

      if (prevglxc->pGlxPbuffer) {
          /*
          ** The previous drawable was a glx Pbuffer, release it.
          */
          prevglxc->pGlxPbuffer->refcnt--;
          __glXFreeGLXPbuffer( prevglxc->pGlxPbuffer );
          prevglxc->pGlxPbuffer = 0;   
      }

      if (prevglxc->pGlxReadPbuffer &&
          prevglxc->pGlxReadPbuffer != prevglxc->pGlxPbuffer ) {
          /*
          ** The previous drawable was a glx Pbuffer, release it.
          */
          prevglxc->pGlxReadPbuffer->refcnt--;
          __glXFreeGLXPbuffer( prevglxc->pGlxReadPbuffer );
          prevglxc->pGlxReadPbuffer = 0;   
      }

      ChangeCurrentContext(cl, glxc, tag);
      ChangeCurrentContext(cl, glxc, tag);
      StopUsingContext(prevglxc);
    } else {
      tag = AddCurrentContext(cl, glxc, pDraw);
    }
    if (glxc) {

       glxc->pGlxPixmap = pGlxPixmap;
       glxc->pGlxReadPixmap = pReadGlxPixmap;
       glxc->pGlxWindow = pGlxWindow;
       glxc->pGlxReadWindow = pGlxReadWindow;
       glxc->pGlxPbuffer = pGlxPbuffer;
       glxc->pGlxReadPbuffer = pGlxReadPbuffer;

      if (pGlxPixmap) {
          pGlxPixmap->refcnt++;
      }

      if (pReadGlxPixmap && pReadGlxPixmap != pGlxPixmap) {
          pReadGlxPixmap->refcnt++;
      }

      if (pGlxWindow) {
         pGlxWindow->refcnt++;
      }

      if (pGlxReadWindow && pGlxReadWindow != pGlxWindow) {
         pGlxReadWindow->refcnt++;
      }

      if (pGlxPbuffer) {
         pGlxPbuffer->refcnt++;
      }

      if (pGlxReadPbuffer && pGlxReadPbuffer != pGlxPbuffer) {
         pGlxReadPbuffer->refcnt++;
      }

      StartUsingContext(cl, glxc);
      new_reply.contextTag = tag;
    } else {
      new_reply.contextTag = 0;
    }
    new_reply.length = 0;
    new_reply.type = X_Reply;
    new_reply.sequenceNumber = client->sequence;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;

       if (pDraw && new_reply.writeType != GLX_PBUFFER_TYPE) {
        pXinDraw = (PanoramiXRes *)
           SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
       }

       if (pReadDraw && pReadDraw != pDraw && 
           new_reply.readType != GLX_PBUFFER_TYPE) {
        pXinReadDraw = (PanoramiXRes *)
           SecurityLookupIDByClass(client, pReadDraw->id, XRC_DRAWABLE, SecurityReadAccess);
       }
       else {
        pXinReadDraw = pXinDraw;
       }
    }
#endif


    /* send the MakeCurrent request to all required
     * back-end servers.
     */
    for (s = from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);
       unsigned int be_draw = None;
       unsigned int be_read_draw = None;

       if (pGlxPixmap) {
         be_draw = pGlxPixmap->be_xids[s];
       }
       else if (pGlxPbuffer) {
        be_draw = pGlxPbuffer->be_xids[s];
       }
#ifdef PANORAMIX
       else if (pXinDraw) {
        pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[s].id,
                                             client,
                                                 SecurityReadAccess);
       }
#endif
       else if (pGlxWindow) {
        pWin = (WindowPtr)pGlxWindow->pDraw;
       }

       if (pWin && be_draw == None) {
         be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         if (!be_draw) {
            /* it might be that the window did not created yet on the */
            /* back-end server (lazy window creation option), force   */
            /* creation of the window */
            dmxCreateAndRealizeWindow( pWin, TRUE );
            be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         }
       }

       /*
      * Before sending the MakeCurrent request - sync the
      * X11 connection to the back-end servers to make sure
      * that drawable is already created
      */
       dmxSync( dmxScreen, 1 ); 

       if (drawId == readId) {
        LockDisplay(dpy);
        GetReq(GLXMakeCurrent, be_req);
        be_req->reqType = dmxScreen->glxMajorOpcode;
        be_req->glxCode = X_GLXMakeCurrent;
        be_req->drawable = be_draw;
        be_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
        be_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
        if (!_XReply(dpy, (xReply *) &be_reply, 0, False)) {

           /* The make current failed */
           UnlockDisplay(dpy);
           SyncHandle();
           return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
        }

        UnlockDisplay(dpy);
              SyncHandle();

        SetCurrentBackEndTag( cl, tag, s, be_reply.contextTag );
       }
       else {

        if (pReadGlxPixmap) {
           be_read_draw = pReadGlxPixmap->be_xids[s];
        }
        else if (pGlxReadPbuffer) {
           be_read_draw = pGlxReadPbuffer->be_xids[s];
        }
#ifdef PANORAMIX
        else if (pXinReadDraw) {
           pReadWin = (WindowPtr)SecurityLookupWindow(pXinReadDraw->info[s].id,
               client,
               SecurityReadAccess);
        }
#endif
        else if (pGlxReadWindow) {
           pReadWin = (WindowPtr)pGlxReadWindow->pDraw;
        }

              if (pReadWin && be_read_draw == None) {
           be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
         if (!be_read_draw) {
            /* it might be that the window did not created yet on the */
            /* back-end server (lazy window creation option), force   */
            /* creation of the window */
            dmxCreateAndRealizeWindow( pReadWin, TRUE );
            be_read_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pReadWin))->window;
              dmxSync( dmxScreen, 1 ); 
         }
        }

        if ( __GLX_IS_VERSION_SUPPORTED(1,3) ) {
           LockDisplay(dpy);
           GetReq(GLXMakeContextCurrent, be_new_req);
           be_new_req->reqType = dmxScreen->glxMajorOpcode;
           be_new_req->glxCode = X_GLXMakeContextCurrent;
           be_new_req->drawable = be_draw;
           be_new_req->readdrawable = be_read_draw;
           be_new_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
           be_new_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
           if (!_XReply(dpy, (xReply *) &be_new_reply, 0, False)) {

            /* The make current failed */
            UnlockDisplay(dpy);
            SyncHandle();
            return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
           }

           UnlockDisplay(dpy);
                 SyncHandle();

           SetCurrentBackEndTag( cl, tag, s, be_new_reply.contextTag );
        }
        else if (glxIsExtensionSupported("GLX_SGI_make_current_read")) {
           xGLXMakeCurrentReadSGIReq *ext_req;
           xGLXVendorPrivateWithReplyReq *vpreq;
             xGLXMakeCurrentReadSGIReply ext_reply;

           LockDisplay(dpy);
           GetReqExtra(GLXVendorPrivateWithReply, 
                     sz_xGLXMakeCurrentReadSGIReq - sz_xGLXVendorPrivateWithReplyReq,
                     vpreq);
           ext_req = (xGLXMakeCurrentReadSGIReq *)vpreq;
           ext_req->reqType = dmxScreen->glxMajorOpcode;
           ext_req->glxCode = X_GLXVendorPrivateWithReply;
           ext_req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
           ext_req->drawable = be_draw;
           ext_req->readable = be_read_draw;
           ext_req->context = (unsigned int)(glxc ? glxc->real_ids[s-from_screen] : 0);
           ext_req->oldContextTag = GetCurrentBackEndTag(cl, tag, s);
           if (!_XReply(dpy, (xReply *) &ext_reply, 0, False)) {

            /* The make current failed */
            UnlockDisplay(dpy);
            SyncHandle();
            return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
           }

           UnlockDisplay(dpy);
                 SyncHandle();

           SetCurrentBackEndTag( cl, tag, s, ext_reply.contextTag );

        }
        else {
           return BadMatch;
        }
       }

       XFlush( dpy );
    }

    if (client->swapped) {
      __glXSwapMakeCurrentReply(client, &new_reply);
    } else {
      WriteToClient(client, sz_xGLXMakeContextCurrentReply, (char *)&new_reply);
    }

    return Success;
}

int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
    xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;

    return( MakeCurrent(cl, req->drawable, req->drawable,
                      req->context, req->oldContextTag ) );
}

int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
    xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;

    return( MakeCurrent(cl, req->drawable, req->readdrawable,
                      req->context, req->oldContextTag ) );
}

int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
    xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;

    return( MakeCurrent(cl, req->drawable, req->readable,
                      req->context, req->oldContextTag ) );
}

int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
    xGLXIsDirectReply reply;
    __GLXcontext *glxc;

    /*
    ** Find the GL context.
    */
    glxc = (__GLXcontext *) LookupIDByType(req->context, __glXContextRes);
    if (!glxc) {
      client->errorValue = req->context;
      return __glXBadContext;
    }

    reply.isDirect = 0;
    reply.length = 0;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    if (client->swapped) {
      __glXSwapIsDirectReply(client, &reply);
    } else {
      WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
    }

    return Success;
}

int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
/*    xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc; */
    xGLXQueryVersionReply reply;

    /*
    ** Server should take into consideration the version numbers sent by the
    ** client if it wants to work with older clients; however, in this
    ** implementation the server just returns its version number.
    */
    reply.majorVersion = __glXVersionMajor;
    reply.minorVersion = __glXVersionMinor;
    reply.length = 0;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    if (client->swapped) {
      __glXSwapQueryVersionReply(client, &reply);
    } else {
      WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
    }
    return Success;
}

int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
{
    xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
    xGLXWaitGLReq *be_req = (xGLXWaitGLReq *)pc;
    int from_screen = 0;
    int to_screen = 0;
    int s;
    __GLXcontext *glxc = NULL;
    
    if (req->contextTag != 0) {
      glxc = __glXLookupContextByTag(cl, req->contextTag);
      if (glxc) {
         from_screen = to_screen = glxc->pScreen->myNum;
      }
    }

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       LockDisplay(dpy);
       GetReq(GLXWaitGL,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXWaitGL;
       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
       UnlockDisplay(dpy);
       SyncHandle();

       XSync(dpy, False);
    }
    
    return Success;
}

int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
{
    xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
    xGLXWaitXReq *be_req;
    int from_screen = 0;
    int to_screen = 0;
    int s;
    __GLXcontext *glxc = NULL;
    
    if (req->contextTag != 0) {
      glxc = __glXLookupContextByTag(cl, req->contextTag);
      if (glxc) {
         from_screen = to_screen = glxc->pScreen->myNum;
      }
    }

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       dmxSync( dmxScreen, 1 );

       LockDisplay(dpy);
       GetReq(GLXWaitX,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXWaitX;
       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
       UnlockDisplay(dpy);
       SyncHandle();

       XFlush( dpy );
    }

    return Success;
}

int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXCopyContextReq *be_req;
    xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
    GLXContextID source = req->source;
    GLXContextID dest = req->dest;
    GLXContextTag tag = req->contextTag;
    unsigned long mask = req->mask;
    __GLXcontext *src, *dst;
    int s;
    int from_screen = 0;
    int to_screen = 0;

    /*
    ** Check that each context exists.
    */
    src = (__GLXcontext *) LookupIDByType(source, __glXContextRes);
    if (!src) {
      client->errorValue = source;
      return __glXBadContext;
    }
    dst = (__GLXcontext *) LookupIDByType(dest, __glXContextRes);
    if (!dst) {
      client->errorValue = dest;
      return __glXBadContext;
    }

    /*
    ** They must be in the same address space, and same screen.
    */
    if (src->pGlxScreen != dst->pGlxScreen) {
      client->errorValue = source;
      return BadMatch;
    }

    /*
    ** The destination context must not be current for any client.
    */
    if (dst->isCurrent) {
      client->errorValue = dest;
      return BadAccess;
    }

    if (tag) {
      __GLXcontext *tagcx = __glXLookupContextByTag(cl, tag);
      
      if (!tagcx) {
          return __glXBadContextTag;
      }
      if (tagcx != src) {
          /*
          ** This would be caused by a faulty implementation of the client
          ** library.
          */
          return BadMatch;
      }
    }

    from_screen = to_screen = src->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       LockDisplay(dpy);
       GetReq(GLXCopyContext,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXCopyContext;
       be_req->source = (unsigned int)src->real_ids[s-from_screen];
       be_req->dest = (unsigned int)dst->real_ids[s-from_screen];
       be_req->mask = mask;
       be_req->contextTag = (tag ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
       UnlockDisplay(dpy);
       SyncHandle();
    }

    return Success;
}

int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
    xGLXGetVisualConfigsReply reply;
    __GLXscreenInfo *pGlxScreen;
    __GLXvisualConfig *pGlxVisual;
    CARD32 buf[__GLX_TOTAL_CONFIG];
    unsigned int screen;
    int i, p;

    screen = req->screen;
    if (screen > screenInfo.numScreens) {
      /* The client library must send a valid screen number. */
      client->errorValue = screen;
      return BadValue;
    }
    pGlxScreen = &__glXActiveScreens[screen];

    reply.numVisuals = pGlxScreen->numGLXVisuals;
    reply.numProps = __GLX_TOTAL_CONFIG;
    reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
                __GLX_TOTAL_CONFIG) >> 2;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);

    for (i=0; i < pGlxScreen->numVisuals; i++) {
      pGlxVisual = &pGlxScreen->pGlxVisual[i];
      if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
          /* not a usable visual */
          continue;
      }
      p = 0;
      buf[p++] = pGlxVisual->vid;
      buf[p++] = pGlxVisual->class;
      buf[p++] = pGlxVisual->rgba;

      buf[p++] = pGlxVisual->redSize;
      buf[p++] = pGlxVisual->greenSize;
      buf[p++] = pGlxVisual->blueSize;
      buf[p++] = pGlxVisual->alphaSize;
      buf[p++] = pGlxVisual->accumRedSize;
      buf[p++] = pGlxVisual->accumGreenSize;
      buf[p++] = pGlxVisual->accumBlueSize;
      buf[p++] = pGlxVisual->accumAlphaSize;

      buf[p++] = pGlxVisual->doubleBuffer;
      buf[p++] = pGlxVisual->stereo;

      buf[p++] = pGlxVisual->bufferSize;
      buf[p++] = pGlxVisual->depthSize;
      buf[p++] = pGlxVisual->stencilSize;
      buf[p++] = pGlxVisual->auxBuffers;
      buf[p++] = pGlxVisual->level;
      /* 
      ** Add token/value pairs for extensions.
      */
      buf[p++] = GLX_VISUAL_CAVEAT_EXT;
      buf[p++] = pGlxVisual->visualRating;
      buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
      buf[p++] = pGlxVisual->transparentPixel;
      buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
      buf[p++] = pGlxVisual->transparentRed;
      buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
      buf[p++] = pGlxVisual->transparentGreen;
      buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
      buf[p++] = pGlxVisual->transparentBlue;
      buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
      buf[p++] = pGlxVisual->transparentAlpha;
      buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
      buf[p++] = pGlxVisual->transparentIndex;
      buf[p++] = GLX_SAMPLES_SGIS;
      buf[p++] = pGlxVisual->multiSampleSize;
      buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
      buf[p++] = pGlxVisual->nMultiSampleBuffers;
      buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
      buf[p++] = pGlxVisual->visualSelectGroup;

      WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
            (char *)buf);
    }
    return Success;
}

/*
** Create a GLX Pixmap from an X Pixmap.
*/
static int CreateGLXPixmap(__GLXclientState *cl,
                    VisualID visual, GLXFBConfigID fbconfigId,
                int screenNum, XID pixmapId, XID glxpixmapId )
{
    ClientPtr client = cl->client;
    xGLXCreateGLXPixmapReq *be_req;
    xGLXCreatePixmapReq *be_new_req;
    DrawablePtr pDraw;
    ScreenPtr pScreen;
    VisualPtr pVisual;
    __GLXpixmap *pGlxPixmap;
    __GLXscreenInfo *pGlxScreen;
    __GLXvisualConfig *pGlxVisual;
    __GLXFBConfig *pFBConfig;
    int i;
    int s;
    int from_screen, to_screen;
#ifdef PANORAMIX
    PanoramiXRes *pXinDraw = NULL;
#endif

    pDraw = (DrawablePtr) LookupDrawable(pixmapId, client);
    if (!pDraw || pDraw->type != DRAWABLE_PIXMAP) {
      client->errorValue = pixmapId;
      return BadPixmap;
    }

    /*
    ** Check if screen of visual matches screen of pixmap.
    */
    pScreen = pDraw->pScreen;
    if (screenNum != pScreen->myNum) {
      return BadMatch;
    }

    if (fbconfigId == NULL && visual == NULL) {
        return BadValue;
    }

    if (fbconfigId != None) {
       pFBConfig = glxLookupFBConfig( fbconfigId );
       if (!pFBConfig) {
        client->errorValue = fbconfigId;
        return BadValue;
       }
       visual = pFBConfig->associatedVisualId;
    }
    else {
       pFBConfig = NULL;
    }

    if (visual != None) {
       /*
      ** Find the VisualRec for this visual.
      */
       pVisual = pScreen->visuals;
       for (i=0; i < pScreen->numVisuals; i++, pVisual++) {
        if (pVisual->vid == visual) {
           break;
        }
       }
       if (i == pScreen->numVisuals) {
        client->errorValue = visual;
        return BadValue;
       }
       /*
      ** Check if depth of visual matches depth of pixmap.
      */
       if (pVisual->nplanes != pDraw->depth) {
        client->errorValue = visual;
        return BadMatch;
       }

       /*
      ** Get configuration of the visual.
      */
       pGlxScreen = &__glXActiveScreens[screenNum];
       pGlxVisual = pGlxScreen->pGlxVisual;
       for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
        if (pGlxVisual->vid == visual) {
           break;
        }
       }
       if (i == pGlxScreen->numVisuals) {
        /*
         ** Visual not support on this screen by this OpenGL implementation.
         */
        client->errorValue = visual;
        return BadValue;
       }


       /* find the FBConfig for that visual (if any) */
       if ( pFBConfig == NULL ) {
         pFBConfig = glxLookupFBConfigByVID( visual );

         if ( pFBConfig == NULL ) {
            /*
               * visual does not have an FBConfig ???
            client->errorValue = visual;
            return BadValue;
             */
         }
       }
    }
    else {
       pVisual = NULL;
       pGlxVisual = NULL;
    }

    pGlxPixmap = (__GLXpixmap *) __glXMalloc(sizeof(__GLXpixmap));
    if (!pGlxPixmap) {
      return BadAlloc;
    }
    pGlxPixmap->be_xids = (XID *) __glXMalloc(sizeof(XID) * screenInfo.numScreens);
    if (!pGlxPixmap->be_xids) {
        __glXFree( pGlxPixmap );
      return BadAlloc;
    }

    pGlxPixmap->pDraw = pDraw;
    pGlxPixmap->pGlxScreen = pGlxScreen;
    pGlxPixmap->pGlxVisual = pGlxVisual;
    pGlxPixmap->pFBConfig = pFBConfig;
    pGlxPixmap->pScreen = pScreen;
    pGlxPixmap->idExists = True;
    pGlxPixmap->refcnt = 0;

    /*
    ** Bump the ref count on the X pixmap so it won't disappear.
    */
    ((PixmapPtr) pDraw)->refcnt++;

    /*
     * send the request to the back-end server(s)
     */
    from_screen = to_screen = screenNum;
#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;

       pXinDraw = (PanoramiXRes *)
        SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {

       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);
       Pixmap  be_pixmap;
       DrawablePtr pRealDraw = pDraw;

#ifdef PANORAMIX
       if (pXinDraw) {
        pRealDraw = (DrawablePtr) LookupDrawable(pXinDraw->info[s].id,client);
       }
#endif

       be_pixmap = (DMX_GET_PIXMAP_PRIV((PixmapPtr)pRealDraw))->pixmap;

       /* make sure pixmap already created on back-end */
       dmxSync( dmxScreen, 1 );

       if ( pFBConfig && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
              __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
        
        LockDisplay(dpy);
        pGlxPixmap->be_xids[s] = XAllocID(dpy);
        GetReq(GLXCreatePixmap,be_new_req);
        be_new_req->reqType = dmxScreen->glxMajorOpcode;
        be_new_req->glxCode = X_GLXCreatePixmap;
        be_new_req->screen = DefaultScreen(dpy);
        be_new_req->fbconfig = be_FBConfig->id;
        be_new_req->pixmap = (unsigned int)be_pixmap;
        be_new_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
        be_new_req->numAttribs = 0;
        UnlockDisplay(dpy);
        SyncHandle();
       }
       else if (pFBConfig && glxIsExtensionSupported("GLX_SGIX_fbconfig")) {
        __GLXFBConfig *be_FBConfig = glxLookupBackEndFBConfig( pFBConfig->id, s );
        xGLXCreateGLXPixmapWithConfigSGIXReq *ext_req;
        xGLXVendorPrivateReq *vpreq;
        
        LockDisplay(dpy);
        pGlxPixmap->be_xids[s] = XAllocID(dpy);
        GetReqExtra(GLXVendorPrivate,
                  sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateReq,
                  vpreq);
        ext_req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
        ext_req->reqType = dmxScreen->glxMajorOpcode;
        ext_req->glxCode = X_GLXVendorPrivate;
        ext_req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
        ext_req->screen = DefaultScreen(dpy);
        ext_req->fbconfig = be_FBConfig->id;
        ext_req->pixmap = (unsigned int)be_pixmap;
        ext_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
        UnlockDisplay(dpy);
        SyncHandle();
       }
       else if (pGlxVisual) {
        LockDisplay(dpy);
        pGlxPixmap->be_xids[s] = XAllocID(dpy);
        GetReq(GLXCreateGLXPixmap,be_req);
        be_req->reqType = dmxScreen->glxMajorOpcode;
        be_req->glxCode = X_GLXCreateGLXPixmap;
        be_req->screen = DefaultScreen(dpy);
        be_req->visual = (unsigned int)glxMatchGLXVisualInConfigList( 
            pGlxVisual,
            dmxScreen->glxVisuals,
            dmxScreen->numGlxVisuals );
        be_req->pixmap = (unsigned int)be_pixmap;
              be_req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
        UnlockDisplay(dpy);
        SyncHandle();
       }
       else {
        client->errorValue = ( visual ? visual : fbconfigId );
          __glXFree( pGlxPixmap );
        return BadValue;
       }

       XFlush( dpy );
    }

    if (!(AddResource(glxpixmapId, __glXPixmapRes, pGlxPixmap))) {
        __glXFree( pGlxPixmap );
      return BadAlloc;
    }

    return Success;
}

int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;

    return( CreateGLXPixmap(cl, req->visual, None,
                          req->screen, req->pixmap, req->glxpixmap) );
}

int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
{
    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;

    return( CreateGLXPixmap(cl, None, req->fbconfig,
                          req->screen, req->pixmap, req->glxpixmap) );
}

int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
    XID glxpixmap = req->glxpixmap;
    __GLXpixmap *pGlxPixmap;
    int s;
    int from_screen, to_screen;

    /*
    ** Check if it's a valid GLX pixmap.
    */
    pGlxPixmap = (__GLXpixmap *)LookupIDByType(glxpixmap, __glXPixmapRes);
    if (!pGlxPixmap) {
      client->errorValue = glxpixmap;
      return __glXBadPixmap;
    }
    FreeResource(glxpixmap, FALSE);

    /*
     * destroy the pixmap on the back-end server(s).
     */
    from_screen = to_screen = pGlxPixmap->pDraw->pScreen->myNum;
#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       /* make sure pixmap exist in back-end */
       dmxSync( dmxScreen, 1 );

       LockDisplay(dpy);
       GetReq(GLXDestroyGLXPixmap,req);
       req->reqType = dmxScreen->glxMajorOpcode;
       req->glxCode = X_GLXDestroyGLXPixmap;
       req->glxpixmap = (unsigned int)pGlxPixmap->be_xids[s];
       UnlockDisplay(dpy);
       SyncHandle();
    }

    
    return Success;
}

/*****************************************************************************/

/*
** NOTE: There is no portable implementation for swap buffers as of
** this time that is of value.  Consequently, this code must be
** implemented by somebody other than SGI.
*/
int __glXDoSwapBuffers(__GLXclientState *cl, XID drawId, GLXContextTag tag)
{
    ClientPtr client = cl->client;
    DrawablePtr pDraw;
    xGLXSwapBuffersReq *be_req;
    WindowPtr pWin = NULL;
    __GLXpixmap *pGlxPixmap = NULL;
    __GLXcontext *glxc = NULL;
#ifdef PANORAMIX
    PanoramiXRes *pXinDraw = NULL;
#endif
    __glXWindow *pGlxWindow = NULL;
    int from_screen = 0;
    int to_screen = 0;
    int s;
    
    /*
    ** Check that the GLX drawable is valid.
    */
    pDraw = (DrawablePtr) LookupDrawable(drawId, client);
    if (pDraw) {

        from_screen = to_screen = pDraw->pScreen->myNum;

      if (pDraw->type == DRAWABLE_WINDOW) {
          /*
          ** Drawable is an X window.
          */
         pWin = (WindowPtr)pDraw;
      } else {
          /*
          ** Drawable is an X pixmap, which is not allowed.
          */
          client->errorValue = drawId;
          return __glXBadDrawable;
      }
    } 

    if (!pDraw) {
      pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
                                        __glXPixmapRes);
      if (pGlxPixmap) {
          /*
          ** Drawable is a GLX pixmap.
          */
         pDraw = pGlxPixmap->pDraw;
         from_screen = to_screen = pGlxPixmap->pScreen->myNum;
      }
    }

    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
       pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
       if (pGlxWindow) {
        /*
         ** Drawable is a GLXWindow.
         */
        pDraw = pGlxWindow->pDraw;
        from_screen = to_screen = pGlxWindow->pScreen->myNum;
       }
    }

    if (!pDraw) {
       /*
      ** Drawable is neither a X window nor a GLX pixmap.
      */
       client->errorValue = drawId;
       return __glXBadDrawable;
    }

    if (tag) {
      glxc = __glXLookupContextByTag(cl, tag);
      if (!glxc) {
          return __glXBadContextTag;
      }
    }

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
       pXinDraw = (PanoramiXRes *)
        SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
    }
#endif

    /* If requested, send a glFinish to all back-end servers before swapping. */
    if (dmxGLXFinishSwap) {
      for (s=from_screen; s<=to_screen; s++) {
          Display *dpy = GetBackEndDisplay(cl,s);
          DMXScreenInfo *dmxScreen = &dmxScreens[s];
          xGLXSingleReq *finishReq;
          xGLXSingleReply reply;

#define X_GLXSingle 0    /* needed by GetReq below */

          LockDisplay(dpy);
          GetReq(GLXSingle,finishReq);
          finishReq->reqType = dmxScreen->glxMajorOpcode;
          finishReq->glxCode = X_GLsop_Finish;
          finishReq->contextTag = (tag ? GetCurrentBackEndTag(cl,tag,s) : 0);
          (void) _XReply(dpy, (xReply*) &reply, 0, False);
          UnlockDisplay(dpy);
          SyncHandle();
      }
    }

    /* If requested, send an XSync to all back-end servers before swapping. */
    if (dmxGLXSyncSwap) {
      for (s=from_screen; s<=to_screen; s++)
          XSync(GetBackEndDisplay(cl,s), False);
    }


    /* send the SwapBuffers request to all back-end servers */

    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);
       unsigned int be_draw = 0;

       if (pGlxPixmap) {
        be_draw = (unsigned int)pGlxPixmap->be_xids[s];
       }
#ifdef PANORAMIX
       else if (pXinDraw) {
        pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[s].id,
                                             client,
                                                 SecurityReadAccess);
       }
#endif
       else if (pGlxWindow) {
        pWin = (WindowPtr)pGlxWindow->pDraw;
       }

       if (pWin && !be_draw) {
         be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         if (!be_draw) {
            /* it might be that the window did not created yet on the */
            /* back-end server (lazy window creation option), force   */
            /* creation of the window */
            dmxCreateAndRealizeWindow( pWin, TRUE );
            be_draw = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         }
       }

       dmxSync( dmxScreen, 1 );

       LockDisplay(dpy);
       GetReq(GLXSwapBuffers,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXSwapBuffers;
       be_req->drawable = be_draw;
       be_req->contextTag = ( tag ? GetCurrentBackEndTag(cl,tag,s) : 0 );
       UnlockDisplay(dpy);
       SyncHandle();
       XFlush(dpy);
    }

    return Success;
}

int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    DrawablePtr pDraw;
    xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
    GLXContextTag tag = req->contextTag;
    XID drawId = req->drawable;
    __GLXpixmap *pGlxPixmap = NULL;
    __GLXcontext *glxc = NULL;
    __glXWindow *pGlxWindow = NULL;
    
    /*
    ** Check that the GLX drawable is valid.
    */
    pDraw = (DrawablePtr) LookupDrawable(drawId, client);
    if (pDraw) {
      if (pDraw->type != DRAWABLE_WINDOW) {
          /*
          ** Drawable is an X pixmap, which is not allowed.
          */
          client->errorValue = drawId;
          return __glXBadDrawable;
      }
    } 

    if (!pDraw) {
      pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
                                        __glXPixmapRes);
      if (pGlxPixmap) {
          /*
          ** Drawable is a GLX pixmap.
          */
         pDraw = pGlxPixmap->pDraw;
      }
    }

    if (!pDraw && __GLX_IS_VERSION_SUPPORTED(1,3) ) {
       pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
       if (pGlxWindow) {
        /*
         ** Drawable is a GLXWindow.
         */
        pDraw = pGlxWindow->pDraw;
       }
    }

    if (!pDraw) {
       /*
      ** Drawable is neither a X window nor a GLX pixmap.
      */
       client->errorValue = drawId;
       return __glXBadDrawable;
    }

    if (tag) {
      glxc = __glXLookupContextByTag(cl, tag);
      if (!glxc) {
          return __glXBadContextTag;
      }
    }

    if (pDraw &&
      pDraw->type == DRAWABLE_WINDOW &&
      DMX_GET_WINDOW_PRIV((WindowPtr)pDraw)->swapGroup) {
      return SGSwapBuffers(cl, drawId, tag, pDraw);
    }

    return __glXDoSwapBuffers(cl, drawId, tag);
}


/************************************************************************/

/*
** Render and Renderlarge are not in the GLX API.  They are used by the GLX
** client library to send batches of GL rendering commands.
*/

/*
** Execute all the drawing commands in a request.
*/
int __glXRender(__GLXclientState *cl, GLbyte *pc)
{
    xGLXRenderReq *req;
    xGLXRenderReq *be_req;
    int size;
    __GLXcontext *glxc;
    int from_screen = 0;
    int to_screen = 0;
    int s;

    /*
    ** NOTE: much of this code also appears in the byteswapping version of this
    ** routine, __glXSwapRender().  Any changes made here should also be
    ** duplicated there.
    */
    
    req = (xGLXRenderReq *) pc;

    glxc = __glXLookupContextByTag(cl, req->contextTag);
    if (!glxc) {
      return 0;
    }
    from_screen = to_screen = glxc->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    pc += sz_xGLXRenderReq;
    size = (req->length << 2) - sz_xGLXRenderReq;

    /*
     * just forward the request to back-end server(s)
     */
    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       LockDisplay(dpy);
       GetReq(GLXRender,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXRender;
       be_req->length = req->length;
       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
       _XSend(dpy, (const char *)pc, size);
       UnlockDisplay(dpy);
       SyncHandle();
    }

    return Success;
}

/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
{
    xGLXRenderLargeReq *req;
    xGLXRenderLargeReq *be_req;
    __GLXcontext *glxc;
    int from_screen = 0;
    int to_screen = 0;
    int s;

    /*
    ** NOTE: much of this code also appears in the byteswapping version of this
    ** routine, __glXSwapRenderLarge().  Any changes made here should also be
    ** duplicated there.
    */
    
    req = (xGLXRenderLargeReq *) pc;
    glxc = __glXLookupContextByTag(cl, req->contextTag);
    if (!glxc) {
      return 0;
    }
    from_screen = to_screen = glxc->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    pc += sz_xGLXRenderLargeReq;

    /*
     * just forward the request to back-end server(s)
     */
    for (s=from_screen; s<=to_screen; s++) {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       GetReq(GLXRenderLarge,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXRenderLarge;
       be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
       be_req->length = req->length;
       be_req->requestNumber = req->requestNumber;
       be_req->requestTotal = req->requestTotal;
       be_req->dataBytes = req->dataBytes;
       Data(dpy, (const char *)pc, req->dataBytes);
       UnlockDisplay(dpy);
       SyncHandle();

    }

    return Success;
}


/************************************************************************/

int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
{
    xGLXVendorPrivateReq *req;

    req = (xGLXVendorPrivateReq *) pc;

    switch( req->vendorCode ) {

       case X_GLvop_DeleteTexturesEXT:
        return __glXVForwardSingleReq( cl, pc );
        break;

       case X_GLXvop_SwapIntervalSGI:
        if (glxIsExtensionSupported("SGI_swap_control")) {
           return __glXVForwardSingleReq( cl, pc );
        }
        else {
           return Success;
        }
        break;

#if 0 /* glx 1.3 */
       case X_GLXvop_CreateGLXVideoSourceSGIX:
        break;
       case X_GLXvop_DestroyGLXVideoSourceSGIX:
        break;
       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
        break;
       case X_GLXvop_DestroyGLXPbufferSGIX:
        break;
       case X_GLXvop_ChangeDrawableAttributesSGIX:
        break;
#endif

       case X_GLXvop_BindSwapBarrierSGIX:
        return __glXBindSwapBarrierSGIX( cl, pc );
        break;

       case X_GLXvop_JoinSwapGroupSGIX:
        return __glXJoinSwapGroupSGIX( cl, pc );
        break;

       case X_GLXvop_CreateContextWithConfigSGIX:
        return __glXCreateContextWithConfigSGIX( cl, pc );
        break;

       default:
        /*
         ** unsupported private request
         */
        cl->client->errorValue = req->vendorCode;
        return __glXUnsupportedPrivateRequest;
    }

    cl->client->errorValue = req->vendorCode;
    return __glXUnsupportedPrivateRequest;

}

int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
{
    xGLXVendorPrivateWithReplyReq *req;

    req = (xGLXVendorPrivateWithReplyReq *) pc;

    switch( req->vendorCode ) {

       case X_GLvop_GetConvolutionFilterEXT:
       case X_GLvop_GetConvolutionParameterfvEXT:
       case X_GLvop_GetConvolutionParameterivEXT:
       case X_GLvop_GetSeparableFilterEXT:
       case X_GLvop_GetHistogramEXT:
       case X_GLvop_GetHistogramParameterivEXT:
       case X_GLvop_GetMinmaxEXT:
       case X_GLvop_GetMinmaxParameterfvEXT:
       case X_GLvop_GetMinmaxParameterivEXT:
       case X_GLvop_AreTexturesResidentEXT:
       case X_GLvop_IsTextureEXT:
        return( __glXVForwardPipe0WithReply(cl, pc) );
        break;

       case X_GLvop_GenTexturesEXT:
        return( __glXVForwardAllWithReply(cl, pc) );
        break;


#if 0 /* glx1.3 */
       case X_GLvop_GetDetailTexFuncSGIS:
       case X_GLvop_GetSharpenTexFuncSGIS:
       case X_GLvop_GetColorTableSGI:
       case X_GLvop_GetColorTableParameterfvSGI:
       case X_GLvop_GetColorTableParameterivSGI:
       case X_GLvop_GetTexFilterFuncSGIS:
       case X_GLvop_GetInstrumentsSGIX:
       case X_GLvop_InstrumentsBufferSGIX:
       case X_GLvop_PollInstrumentsSGIX:
       case X_GLvop_FlushRasterSGIX:
       case X_GLXvop_CreateGLXPbufferSGIX:
       case X_GLXvop_GetDrawableAttributesSGIX:
       case X_GLXvop_QueryHyperpipeNetworkSGIX:
       case X_GLXvop_QueryHyperpipeConfigSGIX:
       case X_GLXvop_HyperpipeConfigSGIX:
       case X_GLXvop_DestroyHyperpipeConfigSGIX:
#endif
       case X_GLXvop_QueryMaxSwapBarriersSGIX:
        return( __glXQueryMaxSwapBarriersSGIX(cl, pc) );
        break;

       case X_GLXvop_GetFBConfigsSGIX:
        return( __glXGetFBConfigsSGIX(cl, pc) );
        break;

       case X_GLXvop_MakeCurrentReadSGI:
        return( __glXMakeCurrentReadSGI(cl, pc) );
        break;

       case X_GLXvop_QueryContextInfoEXT:
        return( __glXQueryContextInfoEXT(cl,pc) );
        break;

       default:
        /*
         ** unsupported private request
         */
        cl->client->errorValue = req->vendorCode;
        return __glXUnsupportedPrivateRequest;
    }

}

int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
    xGLXQueryExtensionsStringReply reply;
    GLint screen;
    size_t length;
    int len, numbytes;
    char *be_buf;

#ifdef FWD_QUERY_REQ
    xGLXQueryExtensionsStringReq *be_req;
    xGLXQueryExtensionsStringReply be_reply;
    DMXScreenInfo *dmxScreen;
    Display *dpy;
    int slop;
#endif

    screen = req->screen;

    /*
    ** Check if screen exists.
    */
    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
      client->errorValue = screen;
      return BadValue;
    }

#ifdef FWD_QUERY_REQ
    dmxScreen = &dmxScreens[screen];

    /* Send the glXQueryServerString request */
    dpy = GetBackEndDisplay(cl,screen);
    LockDisplay(dpy);
    GetReq(GLXQueryExtensionsString,be_req);
    be_req->reqType = dmxScreen->glxMajorOpcode;
    be_req->glxCode = X_GLXQueryServerString;
    be_req->screen = DefaultScreen(dpy);
    _XReply(dpy, (xReply*) &be_reply, 0, False);
    len = (int)be_reply.length;
    numbytes = (int)be_reply.n;
    slop = numbytes * __GLX_SIZE_INT8 & 3;
    be_buf = (char *)Xalloc(numbytes);
    if (!be_buf) {
        /* Throw data on the floor */
        _XEatData(dpy, len);
    } else {
        _XRead(dpy, (char *)be_buf, numbytes);
        if (slop) _XEatData(dpy,4-slop);
    }
    UnlockDisplay(dpy);
    SyncHandle();

#else

    be_buf = __glXGetServerString(GLX_EXTENSIONS);
    numbytes = strlen(be_buf) + 1;
    len = __GLX_PAD(numbytes) >> 2;

#endif

    length = len;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;
    reply.length = len;
    reply.n = numbytes;

    if (client->swapped) {
        glxSwapQueryExtensionsStringReply(client, &reply, be_buf);
    } else {
        WriteToClient(client, sz_xGLXQueryExtensionsStringReply,(char *)&reply);
        WriteToClient(client, (int)(length << 2), (char *)be_buf);
    }

    return Success;
}

int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
    xGLXQueryServerStringReply reply;
    int name;
    GLint screen;
    size_t length;
    int len, numbytes;
    char *be_buf;
#ifdef FWD_QUERY_REQ
    xGLXQueryServerStringReq *be_req;
    xGLXQueryServerStringReply be_reply;
    DMXScreenInfo *dmxScreen;
    Display *dpy;
    int  slop;
#endif

    name = req->name;
    screen = req->screen;
    /*
    ** Check if screen exists.
    */
    if ((screen < 0) || (screen >= screenInfo.numScreens)) {
      client->errorValue = screen;
      return BadValue;
    }

#ifdef FWD_QUERY_REQ
    dmxScreen = &dmxScreens[screen];

    /* Send the glXQueryServerString request */
    dpy = GetBackEndDisplay(cl,screen);
    LockDisplay(dpy);
    GetReq(GLXQueryServerString,be_req);
    be_req->reqType = dmxScreen->glxMajorOpcode;
    be_req->glxCode = X_GLXQueryServerString;
    be_req->screen = DefaultScreen(dpy);
    be_req->name = name;
    _XReply(dpy, (xReply*) &be_reply, 0, False);
    len = (int)be_reply.length;
    numbytes = (int)be_reply.n;
    slop = numbytes * __GLX_SIZE_INT8 & 3;
    be_buf = (char *)Xalloc(numbytes);
    if (!be_buf) {
        /* Throw data on the floor */
        _XEatData(dpy, len);
    } else {
        _XRead(dpy, (char *)be_buf, numbytes);
        if (slop) _XEatData(dpy,4-slop);
    }
    UnlockDisplay(dpy);
    SyncHandle();

#else
    be_buf = __glXGetServerString(name);
    numbytes = strlen(be_buf) + 1;
    len = __GLX_PAD(numbytes) >> 2;
#endif

    length = len;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;
    reply.length = length;
    reply.n = numbytes;

    if (client->swapped) {
        glxSwapQueryServerStringReply(client, &reply, be_buf);
    } else {
        WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)&reply);
        WriteToClient(client, (int)(length << 2), be_buf);
    }

    return Success;
}

int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
{
    xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
    xGLXClientInfoReq *be_req;
    const char *buf;
    int from_screen = 0;
    int to_screen = 0;
    int s;
   
    cl->GLClientmajorVersion = req->major;
    cl->GLClientminorVersion = req->minor;
    if (cl->GLClientextensions) __glXFree(cl->GLClientextensions);
    buf = (const char *)(req+1);
    cl->GLClientextensions = __glXStrdup(buf);

    to_screen = screenInfo.numScreens - 1;

    for (s=from_screen; s<=to_screen; s++)
    {
       DMXScreenInfo *dmxScreen = &dmxScreens[s];
       Display *dpy = GetBackEndDisplay(cl,s);

       LockDisplay(dpy);
       GetReq(GLXClientInfo,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXClientInfo;
       be_req->major = req->major;
       be_req->minor = req->minor;
       be_req->length = req->length;
       be_req->numbytes = req->numbytes;
       Data(dpy, buf, req->numbytes);

       UnlockDisplay(dpy);
       SyncHandle();
    }

    return Success;
}

int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXUseXFontReq *req;
    xGLXUseXFontReq *be_req;
    FontPtr pFont;
    __GLXcontext *glxc = NULL;
    int from_screen = 0;
    int to_screen = 0;
    int s;
    dmxFontPrivPtr  pFontPriv;
    DMXScreenInfo *dmxScreen;
    Display *dpy;

    req = (xGLXUseXFontReq *) pc;

    if (req->contextTag != 0) {
      glxc = __glXLookupContextByTag(cl, req->contextTag);
      if (glxc) {
         from_screen = to_screen = glxc->pScreen->myNum;
      }
    }

    /*
    ** Font can actually be either the ID of a font or the ID of a GC
    ** containing a font.
    */
    pFont = (FontPtr)LookupIDByType(req->font, RT_FONT);
    if (!pFont) {
        GC *pGC = (GC *)LookupIDByType(req->font, RT_GC);
        if (!pGC) {
          client->errorValue = req->font;
            return BadFont;
      }
      pFont = pGC->font;
    }

    pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif


    for (s=from_screen; s<=to_screen; s++) {
       dmxScreen = &dmxScreens[s];
       dpy = GetBackEndDisplay(cl,s);

       dmxSync( dmxScreen, 1 );

       LockDisplay(dpy);
       GetReq(GLXUseXFont,be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXUseXFont;
       be_req->contextTag = (glxc ? GetCurrentBackEndTag(cl,req->contextTag,s) : 0);
       be_req->font = pFontPriv->font[s]->fid;
       be_req->first = req->first;
       be_req->count = req->count;
       be_req->listBase = req->listBase;
       UnlockDisplay(dpy);
       SyncHandle();

       XSync( dpy, False );
    }

    return Success;
}

/*
 * start GLX 1.3 here
 */

int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
    xGLXGetFBConfigsReply reply;
    __GLXFBConfig *pFBConfig;
    CARD32 buf[2 * __GLX_TOTAL_FBCONFIG_PROPS];
    int numAttribs = __GLX_TOTAL_FBCONFIG_PROPS;
    unsigned int screen = req->screen;
    int numFBConfigs, i, p;
    __GLXscreenInfo *pGlxScreen;

    if (screen > screenInfo.numScreens) {
      /* The client library must send a valid screen number. */
      client->errorValue = screen;
      return BadValue;
    }

    pGlxScreen = &__glXActiveScreens[screen];
    numFBConfigs = __glXNumFBConfigs;

    reply.numFBConfigs = numFBConfigs;
    reply.numAttribs = numAttribs;
    reply.length = (numFBConfigs * 2 * numAttribs * __GLX_SIZE_CARD32) >> 2;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    if (client->swapped) {
      __GLX_DECLARE_SWAP_VARIABLES;
      __GLX_SWAP_SHORT(&reply.sequenceNumber);
      __GLX_SWAP_INT(&reply.length);
      __GLX_SWAP_INT(&reply.numFBConfigs);
      __GLX_SWAP_INT(&reply.numAttribs);
    }
    WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);

    for (i=0; i < numFBConfigs; i++) {
       int associatedVisualId = 0;
       int drawableTypeIndex;
       pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1) ];

      p = 0;
      /* core attributes */
      buf[p++] = GLX_FBCONFIG_ID;
      buf[p++] = pFBConfig->id;
      buf[p++] = GLX_BUFFER_SIZE;
      buf[p++] = pFBConfig->indexBits;
      buf[p++] = GLX_LEVEL;
      buf[p++] = pFBConfig->level;
      buf[p++] = GLX_DOUBLEBUFFER;
      buf[p++] = pFBConfig->doubleBufferMode;
      buf[p++] = GLX_STEREO;
      buf[p++] = pFBConfig->stereoMode;
      buf[p++] = GLX_AUX_BUFFERS;
      buf[p++] = pFBConfig->maxAuxBuffers;
      buf[p++] = GLX_RED_SIZE;
      buf[p++] = pFBConfig->redBits;
      buf[p++] = GLX_GREEN_SIZE;
      buf[p++] = pFBConfig->greenBits;
      buf[p++] = GLX_BLUE_SIZE;
      buf[p++] = pFBConfig->blueBits;
      buf[p++] = GLX_ALPHA_SIZE;
      buf[p++] = pFBConfig->alphaBits;
      buf[p++] = GLX_DEPTH_SIZE;
      buf[p++] = pFBConfig->depthBits;
      buf[p++] = GLX_STENCIL_SIZE;
      buf[p++] = pFBConfig->stencilBits;
      buf[p++] = GLX_ACCUM_RED_SIZE;
      buf[p++] = pFBConfig->accumRedBits;
      buf[p++] = GLX_ACCUM_GREEN_SIZE;
      buf[p++] = pFBConfig->accumGreenBits;
      buf[p++] = GLX_ACCUM_BLUE_SIZE;
      buf[p++] = pFBConfig->accumBlueBits;
      buf[p++] = GLX_ACCUM_ALPHA_SIZE;
      buf[p++] = pFBConfig->accumAlphaBits;
      buf[p++] = GLX_RENDER_TYPE;
      buf[p++] = pFBConfig->renderType;
      buf[p++] = GLX_DRAWABLE_TYPE;
      drawableTypeIndex = p;
      buf[p++] = pFBConfig->drawableType;
      buf[p++] = GLX_X_VISUAL_TYPE;
      buf[p++] = pFBConfig->visualType;
      buf[p++] = GLX_CONFIG_CAVEAT;
      buf[p++] = pFBConfig->visualCaveat;
      buf[p++] = GLX_TRANSPARENT_TYPE;
      buf[p++] = pFBConfig->transparentType;
      buf[p++] = GLX_TRANSPARENT_RED_VALUE;
      buf[p++] = pFBConfig->transparentRed;
      buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
      buf[p++] = pFBConfig->transparentGreen;
      buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
      buf[p++] = pFBConfig->transparentBlue;
      buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
      buf[p++] = pFBConfig->transparentAlpha;
      buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
      buf[p++] = pFBConfig->transparentIndex;
      buf[p++] = GLX_MAX_PBUFFER_WIDTH;
      buf[p++] = pFBConfig->maxPbufferWidth;
      buf[p++] = GLX_MAX_PBUFFER_HEIGHT;
      buf[p++] = pFBConfig->maxPbufferHeight;
      buf[p++] = GLX_MAX_PBUFFER_PIXELS;
      buf[p++] = pFBConfig->maxPbufferPixels;

      /*
         * find the visual of the back-end server and match a visual
       * on the proxy.
       * do only once - if a visual is not yet associated.
       */
      if (pFBConfig->associatedVisualId == (unsigned int)-1) {
         DMXScreenInfo *dmxScreen = &dmxScreens[screen];
         __GLXFBConfig *be_pFBConfig = __glXFBConfigs[ i * (screenInfo.numScreens+1)+screen+1 ];
         __GLXvisualConfig *pGlxVisual = NULL;
         int v;
         int found = 0;
         for (v=0; v<dmxScreen->numGlxVisuals; v++) {
            if (dmxScreen->glxVisuals[v].vid == be_pFBConfig->associatedVisualId) {
             pGlxVisual = &dmxScreen->glxVisuals[v];
             break;
            }
         }

         if (pGlxVisual) {
            for (v=0; v<pGlxScreen->numVisuals; v++) {
             if (glxVisualsMatch(&pGlxScreen->pGlxVisual[v], pGlxVisual)) {
                associatedVisualId = pGlxScreen->pGlxVisual[v].vid;
                found = 1;
                break;
             }
            }
         }

         if (!found) {
            associatedVisualId = 0;
            pFBConfig->drawableType &= ~(GLX_WINDOW_BIT);
            buf[drawableTypeIndex] = pFBConfig->drawableType;
         }
#ifdef PANORAMIX
         else if (!noPanoramiXExtension) {
            /* convert the associated visualId to the panoramix one */
              for (v=0; v<255; v++) {
             if ( PanoramiXVisualTable[ v * MAXSCREENS + screen ] ==
                  associatedVisualId ) {
                associatedVisualId = v;
                break;
             } 
            }
            pFBConfig->associatedVisualId = associatedVisualId;
         }
#endif
      }
      else {
         associatedVisualId = pFBConfig->associatedVisualId;
      }

      buf[p++] = GLX_VISUAL_ID;
      buf[p++] = associatedVisualId;

      /* SGIS_multisample attributes */
      buf[p++] = GLX_SAMPLES_SGIS;
      buf[p++] = pFBConfig->multiSampleSize;
      buf[p++] = GLX_SAMPLE_BUFFERS_SGIS;
      buf[p++] = pFBConfig->nMultiSampleBuffers;

      /* SGIX_pbuffer specific attributes */
      buf[p++] = GLX_OPTIMAL_PBUFFER_WIDTH_SGIX;
      buf[p++] = pFBConfig->optimalPbufferWidth;
      buf[p++] = GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX;
      buf[p++] = pFBConfig->optimalPbufferHeight;

      buf[p++] = GLX_VISUAL_SELECT_GROUP_SGIX;
      buf[p++] = pFBConfig->visualSelectGroup;

      if (client->swapped) {
          __GLX_DECLARE_SWAP_VARIABLES;
          __GLX_SWAP_INT_ARRAY((int *)buf, 2*numAttribs);
      }
      WriteToClient(client, 2*numAttribs * __GLX_SIZE_CARD32, (char *)buf);
    }
    return Success;
}

int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
{
   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
   xGLXGetFBConfigsReq new_req;

   new_req.reqType = req->reqType;
   new_req.glxCode = req->glxCode;
   new_req.length = req->length;
   new_req.screen = req->screen;

   return( __glXGetFBConfigs( cl, (GLbyte *)&new_req ) );
}


int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
    int screen = req->screen;
    GLXFBConfigID fbconfigId = req->fbconfig;
    XID windowId = req->window;
    XID glxwindowId = req->glxwindow;
    DrawablePtr pDraw;
    ScreenPtr pScreen;
    __glXWindow *pGlxWindow;
    __GLXFBConfig *pGlxFBConfig = NULL;
    VisualPtr pVisual;
    VisualID visId;
    int i;

    /*
    ** Check if windowId is valid 
    */
    pDraw = (DrawablePtr) LookupDrawable(windowId, client);
    if (!pDraw || pDraw->type != DRAWABLE_WINDOW) {
      client->errorValue = windowId;
      return BadWindow;
    }

    /*
    ** Check if screen of window matches screen of fbconfig.
    */
    pScreen = pDraw->pScreen;
    if (screen != pScreen->myNum) {
      return BadMatch;
    }

    /*
    ** Find the FBConfigRec for this fbconfigid.
    */
    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
      client->errorValue = fbconfigId;
      return __glXBadFBConfig;
    }
    visId = pGlxFBConfig->associatedVisualId;

    /*
    ** Check if the fbconfig supports rendering to windows 
    */
    if( !(pGlxFBConfig->drawableType & GLX_WINDOW_BIT) ) {
      return BadMatch;  
    }

    if (visId != None) {
       /*
      ** Check if the visual ID is valid for this screen.
      */
       pVisual = pScreen->visuals;
       for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
        if (pVisual->vid == visId) {
           break;
        }
       }
       if (i == pScreen->numVisuals) {
        client->errorValue = visId;
        return BadValue;
       }
      
        /*
        ** Check if color buffer depth of fbconfig matches depth 
      ** of window.
        */
        if (pVisual->nplanes != pDraw->depth) {
          return BadMatch;
      }
    } else
      /*
      ** The window was created with no visual that corresponds
      ** to fbconfig 
      */
      return BadMatch;

    /*
    ** Check if there is already a fbconfig associated with this window
    */
    if ( LookupIDByType(glxwindowId, __glXWindowRes) ) {
      client->errorValue = glxwindowId;
      return BadAlloc;
    }

    pGlxWindow = (__glXWindow *) xalloc(sizeof(__glXWindow));
    if (!pGlxWindow) {
      return BadAlloc;
    }

    /*
    ** Register this GLX window as a resource
    */
    if (!(AddResource(glxwindowId, __glXWindowRes, pGlxWindow))) {
      return BadAlloc;
    }

    pGlxWindow->pDraw = pDraw;
    pGlxWindow->type = GLX_GLXWINDOW_TYPE;
    pGlxWindow->idExists = True;
    pGlxWindow->refcnt = 0;
    pGlxWindow->pGlxFBConfig = pGlxFBConfig;
    pGlxWindow->pScreen = pScreen;

    return Success;
}

int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
    XID glxwindow = req->glxwindow;

    /*
    ** Check if it's a valid GLX window.
    */
    if (!LookupIDByType(glxwindow, __glXWindowRes)) {
      client->errorValue = glxwindow;
      return __glXBadDrawable;
    }
    /*
    ** The glx window destructor will check whether it's current before
    ** freeing anything.
    */
    FreeResource(glxwindow, RT_NONE);     

    return Success;
}

int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    __GLXcontext *ctx;
    xGLXQueryContextReq *req;
    xGLXQueryContextReply reply;
    int nProps;
    int *sendBuf, *pSendBuf;
    int nReplyBytes;

    req = (xGLXQueryContextReq *)pc;
    ctx = (__GLXcontext *) LookupIDByType(req->context, __glXContextRes);
    if (!ctx) {
        client->errorValue = req->context;
        return __glXBadContext;
    }

    nProps = 3;

    reply.length = nProps << 1;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;
    reply.n = nProps;

    nReplyBytes = reply.length << 2;
    sendBuf = (int *)xalloc(nReplyBytes);
    pSendBuf = sendBuf;
    *pSendBuf++ = GLX_FBCONFIG_ID;
    *pSendBuf++ = (int)(ctx->pFBConfig->id);
    *pSendBuf++ = GLX_RENDER_TYPE;
    *pSendBuf++ = (int)(ctx->pFBConfig->renderType);
    *pSendBuf++ = GLX_SCREEN;
    *pSendBuf++ = (int)(ctx->pScreen->myNum);

    if (client->swapped) {
        __glXSwapQueryContextReply(client, &reply, sendBuf);
    } else {
        WriteToClient(client, sz_xGLXQueryContextReply, (char *)&reply);
        WriteToClient(client, nReplyBytes, (char *)sendBuf);
    }
    xfree((char *)sendBuf);

    return Success;
}

int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    __GLXcontext *ctx;
    xGLXQueryContextInfoEXTReq *req;
    xGLXQueryContextInfoEXTReply reply;
    int nProps;
    int *sendBuf, *pSendBuf;
    int nReplyBytes;

    req = (xGLXQueryContextInfoEXTReq *)pc;
    ctx = (__GLXcontext *) SecurityLookupIDByType(client, req->context, __glXContextRes, SecurityReadAccess);
    if (!ctx) {
        client->errorValue = req->context;
        return __glXBadContext;
    }

    nProps = 4;

    reply.length = nProps << 1;
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;
    reply.n = nProps;

    nReplyBytes = reply.length << 2;
    sendBuf = (int *)xalloc(nReplyBytes);
    pSendBuf = sendBuf;
    *pSendBuf++ = GLX_SHARE_CONTEXT_EXT;
    *pSendBuf++ = (int)(ctx->share_id);
    *pSendBuf++ = GLX_VISUAL_ID_EXT;
    *pSendBuf++ = (int)(ctx->pVisual ? ctx->pVisual->vid : 0);
    *pSendBuf++ = GLX_SCREEN_EXT;
    *pSendBuf++ = (int)(ctx->pScreen->myNum);
    *pSendBuf++ = GLX_FBCONFIG_ID;
    *pSendBuf++ = (int)(ctx->pFBConfig ? ctx->pFBConfig->id : 0);

    if (client->swapped) {
        __glXSwapQueryContextInfoEXTReply(client, &reply, sendBuf);
    } else {
        WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)&reply);
        WriteToClient(client, nReplyBytes, (char *)sendBuf);
    }
    xfree((char *)sendBuf);

    return Success;
}

int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
    xGLXCreatePbufferReq *be_req;
    int screen = req->screen;
    GLXFBConfigID fbconfigId = req->fbconfig;
    GLXPbuffer pbuffer = req->pbuffer;
    __glXPbuffer *pGlxPbuffer;
    int numAttribs = req->numAttribs;
    int *attr;
    ScreenPtr pScreen;
    __GLXFBConfig *pGlxFBConfig;
    __GLXFBConfig *be_pGlxFBConfig;
    XID be_xid;
    Display *dpy;
    DMXScreenInfo *dmxScreen;
    int s;
    int from_screen, to_screen;

   /*
    ** Look up screen and FBConfig.
    */
    if (screen > screenInfo.numScreens) {
        /* The client library must send a valid screen number. */
        client->errorValue = screen;
        return BadValue;
    }
    pScreen = screenInfo.screens[screen];

    /*
    ** Find the FBConfigRec for this fbconfigid.
    */
    if (!(pGlxFBConfig = glxLookupFBConfig(fbconfigId))) {
      client->errorValue = fbconfigId;
      return __glXBadFBConfig;
    }

    /*
    ** Create the GLX part of the Pbuffer.
    */
    pGlxPbuffer = (__glXPbuffer *) xalloc(sizeof(__glXPbuffer));
    if (!pGlxPbuffer) {
        return BadAlloc;
    }

    pGlxPbuffer->be_xids = (XID *) xalloc( sizeof(XID) * screenInfo.numScreens );
    if (!pGlxPbuffer->be_xids) {
        xfree(pGlxPbuffer);
        return BadAlloc;
    }

    /*
     * Allocate an XID on the back-end server(s) and send him the request
     */
    from_screen = to_screen = screen;
#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       dpy = GetBackEndDisplay(cl,s);
       be_xid = XAllocID(dpy);
       dmxScreen = &dmxScreens[s];
       be_pGlxFBConfig = glxLookupBackEndFBConfig( pGlxFBConfig->id, s );
       
       attr = (int *)( req+1 );

       LockDisplay(dpy);
       GetReqExtra(GLXCreatePbuffer, 2 * numAttribs * __GLX_SIZE_CARD32, be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXCreatePbuffer;
       be_req->screen = be_pGlxFBConfig->screen;
       be_req->fbconfig = be_pGlxFBConfig->id;
       be_req->pbuffer = be_xid;
       be_req->numAttribs = numAttribs;
    
       /* Send attributes */
       if ( attr != NULL ) {
        CARD32 *pc = (CARD32 *)(be_req + 1);

        while (numAttribs-- > 0) {
           *pc++ = *attr++;     /* token */
           *pc++ = *attr++;     /* value */
        }
       }

       UnlockDisplay(dpy);
       SyncHandle();

       pGlxPbuffer->be_xids[s] = be_xid;
    }


    pGlxPbuffer->idExists = True;
    pGlxPbuffer->refcnt = 0;
    pGlxPbuffer->pFBConfig = pGlxFBConfig;
    pGlxPbuffer->pScreen = pScreen;

    /*
    ** Register the resource.
    */
    if (!(AddResource(pbuffer, __glXPbufferRes, pGlxPbuffer))) {
        return BadAlloc;
    }

    return Success;

}

int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
    ClientPtr client = cl->client;
    xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
    xGLXDestroyPbufferReq *be_req;
    GLXPbuffer pbuffer = req->pbuffer;
    Display *dpy;
    int screen;
    DMXScreenInfo *dmxScreen;
    __glXPbuffer *pGlxPbuffer;
    int s;
    int from_screen, to_screen;

    /*
    ** Check if it's a valid Pbuffer
    */
    pGlxPbuffer = (__glXPbuffer *)LookupIDByType(pbuffer, __glXPbufferRes);
    if (!pGlxPbuffer) {
      client->errorValue = pbuffer;
      return __glXBadPbuffer;
    }

    screen = pGlxPbuffer->pScreen->myNum;

    from_screen = to_screen = screen;
#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    for (s=from_screen; s<=to_screen; s++) {
       dpy = GetBackEndDisplay(cl,s);
       dmxScreen = &dmxScreens[s];

       /* send the destroy request to the back-end server */
       LockDisplay(dpy);
       GetReq(GLXDestroyPbuffer, be_req);
       be_req->reqType = dmxScreen->glxMajorOpcode;
       be_req->glxCode = X_GLXDestroyPbuffer;
       be_req->pbuffer = pGlxPbuffer->be_xids[s];
       UnlockDisplay(dpy);
       SyncHandle();
    }

    FreeResource(pbuffer, RT_NONE); 

    return Success;
}

int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
   xGLXGetDrawableAttributesReq *be_req;
   xGLXGetDrawableAttributesReply reply;
   ClientPtr client = cl->client;
   GLXDrawable drawId = req->drawable;
   GLXDrawable be_drawable = 0;
   DrawablePtr pDraw = NULL;
   Display *dpy;
   int screen;
   DMXScreenInfo *dmxScreen;
   CARD32 *attribs = NULL;
   int attribs_size;
#ifdef PANORAMIX
    PanoramiXRes *pXinDraw = NULL;
#endif

   if (drawId != None) {
      pDraw = (DrawablePtr) LookupDrawable(drawId, client);
      if (pDraw) {
       if (pDraw->type == DRAWABLE_WINDOW) {
            WindowPtr pWin = (WindowPtr)pDraw;
            be_drawable = 0;
            screen = pWin->drawable.pScreen->myNum;

       }
       else {
          /*
           ** Drawable is not a Window , GLXWindow or a GLXPixmap.
           */
          client->errorValue = drawId;
          return __glXBadDrawable;
       }
      }

      if (!pDraw) {
       __GLXpixmap *pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
                                          __glXPixmapRes);
       if (pGlxPixmap) {
            pDraw = pGlxPixmap->pDraw;
            screen = pGlxPixmap->pScreen->myNum;
                be_drawable = pGlxPixmap->be_xids[screen];
       }
      }

      if (!pDraw) {
       __glXWindow *pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
       if (pGlxWindow) {
          pDraw = pGlxWindow->pDraw;
          screen = pGlxWindow->pScreen->myNum;
          be_drawable = 0;
       }
      }

      if (!pDraw) {
       __glXPbuffer *pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
       if (pGlxPbuffer) {
          pDraw = (DrawablePtr)pGlxPbuffer;
          screen = pGlxPbuffer->pScreen->myNum;
          be_drawable = pGlxPbuffer->be_xids[screen];
       }
      }


      if (!pDraw) {
       /*
        ** Drawable is not a Window , GLXWindow or a GLXPixmap.
        */
       client->errorValue = drawId;
       return __glXBadDrawable;
      }
    }


   /* if the drawable is a window or GLXWindow - 
    * we need to find the base id on the back-end server
    */
   if (!be_drawable) {
       WindowPtr pWin = (WindowPtr)pDraw;

#ifdef PANORAMIX
       if (!noPanoramiXExtension) {
        pXinDraw = (PanoramiXRes *)
           SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
        if (!pXinDraw) {
           client->errorValue = drawId;
           return __glXBadDrawable;
        }

        pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[screen].id,
            client,
            SecurityReadAccess);
       }
#endif

       if (pWin) {
         be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         if (!be_drawable) {
            /* it might be that the window did not created yet on the */
            /* back-end server (lazy window creation option), force   */
            /* creation of the window */
            dmxCreateAndRealizeWindow( pWin, TRUE );
            be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         }
       }
       else {
        client->errorValue = drawId;
        return __glXBadDrawable;
       }
   }


   /* send the request to the back-end server */
   dpy = GetBackEndDisplay(cl,screen);
   dmxScreen = &dmxScreens[screen];

   /* make sure drawable exists on back-end */
   dmxSync( dmxScreen, 1 );

   LockDisplay(dpy);
   GetReq(GLXGetDrawableAttributes, be_req);
   be_req->reqType = dmxScreen->glxMajorOpcode;
   be_req->glxCode = X_GLXGetDrawableAttributes;
   be_req->drawable = be_drawable;
   be_req->length = req->length;
   if (!_XReply(dpy, (xReply *) &reply, 0, False)) {
      UnlockDisplay(dpy);
      SyncHandle();
      return( BE_TO_CLIENT_ERROR(dmxLastErrorEvent.error_code) );
   }

   if (reply.numAttribs) {
      attribs_size = 2 * reply.numAttribs * __GLX_SIZE_CARD32;
      attribs = (CARD32 *) Xalloc(attribs_size);
      if (attribs == NULL) {
       UnlockDisplay(dpy);
       SyncHandle();
       return BadAlloc;
      }

      _XRead(dpy, (char *) attribs, attribs_size);
   }

   UnlockDisplay(dpy);
   SyncHandle();


   /* send the reply back to the client */
   reply.sequenceNumber = client->sequence;
   if (client->swapped) {
      __glXSwapGetDrawableAttributesReply(client, &reply, (int *)attribs);
   }
   else {
      WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)&reply);
      WriteToClient(client, attribs_size, (char *)attribs);
   }

   Xfree(attribs);

   return Success;
}

int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
   xGLXChangeDrawableAttributesReq *be_req;
   ClientPtr client = cl->client;
   GLXDrawable drawId = req->drawable;
   GLXDrawable be_drawable = 0;
   DrawablePtr pDraw = NULL;
   Display *dpy;
   int screen;
   DMXScreenInfo *dmxScreen;
   char *attrbuf;
#ifdef PANORAMIX
    PanoramiXRes *pXinDraw = NULL;
    PanoramiXRes *pXinReadDraw = NULL;
#endif

   if (drawId != None) {
      pDraw = (DrawablePtr) LookupDrawable(drawId, client);
      if (pDraw) {
       if (pDraw->type == DRAWABLE_WINDOW) {
            WindowPtr pWin = (WindowPtr)pDraw;
            be_drawable = 0;
            screen = pWin->drawable.pScreen->myNum;

       }
       else {
          /*
           ** Drawable is not a Window , GLXWindow or a GLXPixmap.
           */
          client->errorValue = drawId;
          return __glXBadDrawable;
       }
      }

      if (!pDraw) {
       __GLXpixmap *pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId,
                                          __glXPixmapRes);
       if (pGlxPixmap) {
            pDraw = pGlxPixmap->pDraw;
            screen = pGlxPixmap->pScreen->myNum;
                be_drawable = pGlxPixmap->be_xids[screen];
       }
      }

      if (!pDraw) {
       __glXWindow *pGlxWindow = (__glXWindow *) LookupIDByType(drawId, __glXWindowRes);
       if (pGlxWindow) {
          pDraw = pGlxWindow->pDraw;
          screen = pGlxWindow->pScreen->myNum;
          be_drawable = 0;
       }
      }

      if (!pDraw) {
       __glXPbuffer *pGlxPbuffer = (__glXPbuffer *)LookupIDByType(drawId, __glXPbufferRes);
       if (pGlxPbuffer) {
          pDraw = (DrawablePtr)pGlxPbuffer;
          screen = pGlxPbuffer->pScreen->myNum;
          be_drawable = pGlxPbuffer->be_xids[screen];
       }
      }


      if (!pDraw) {
       /*
        ** Drawable is not a Window , GLXWindow or a GLXPixmap.
        */
       client->errorValue = drawId;
       return __glXBadDrawable;
      }
    }


   /* if the drawable is a window or GLXWindow - 
    * we need to find the base id on the back-end server
    */
   if (!be_drawable) {
       WindowPtr pWin = (WindowPtr)pDraw;

#ifdef PANORAMIX
       if (!noPanoramiXExtension) {
        pXinDraw = (PanoramiXRes *)
           SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, SecurityReadAccess);
        if (!pXinDraw) {
           client->errorValue = drawId;
           return __glXBadDrawable;
        }

        pWin = (WindowPtr)SecurityLookupWindow(pXinDraw->info[screen].id,
            client,
            SecurityReadAccess);
       }
#endif

       if (pWin) {
         be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         if (!be_drawable) {
            /* it might be that the window did not created yet on the */
            /* back-end server (lazy window creation option), force   */
            /* creation of the window */
            dmxCreateAndRealizeWindow( pWin, TRUE );
            be_drawable = (unsigned int)(DMX_GET_WINDOW_PRIV(pWin))->window;
         }
       }
       else {
        client->errorValue = drawId;
        return __glXBadDrawable;
       }
   }


   /* send the request to the back-end server */
   dpy = GetBackEndDisplay(cl,screen);
   dmxScreen = &dmxScreens[screen];

   /* make sure drawable exists on back-end */
   dmxSync( dmxScreen, 1 );

   LockDisplay(dpy);
   GetReqExtra(GLXChangeDrawableAttributes,
                        2 * req->numAttribs * __GLX_SIZE_CARD32, be_req);
   be_req->reqType = dmxScreen->glxMajorOpcode;
   be_req->glxCode = X_GLXChangeDrawableAttributes;
   be_req->drawable = be_drawable;
   be_req->numAttribs = req->numAttribs;
   be_req->length = req->length;

   UnlockDisplay(dpy);
   SyncHandle();

   return Success;
}

int __glXSendLargeCommand(__GLXclientState *cl, GLXContextTag contextTag)
{
   ClientPtr client = cl->client;
    xGLXRenderLargeReq *req;
    GLint maxSize, amount;
    GLint totalRequests, requestNumber;
    GLint dataLen;
    GLbyte *data;
    __GLXcontext *glxc;
    int s;
    int from_screen, to_screen;

    maxSize = cl->largeCmdMaxReqDataSize - (GLint)sizeof(xGLXRenderLargeReq);
    dataLen = cl->largeCmdBytesTotal;
    totalRequests = (dataLen / maxSize);
    if (dataLen % maxSize) totalRequests++;

    glxc = __glXLookupContextByTag(cl, contextTag);
    if (!glxc) {
       client->errorValue = contextTag;
       return __glXBadContext;
    }
    from_screen = to_screen = glxc->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
       from_screen = 0;
       to_screen = screenInfo.numScreens - 1;
    }
#endif

    /*
    ** Send enough requests until the whole array is sent.
    */
    requestNumber = 1;
    data = cl->largeCmdBuf;
    while (dataLen > 0) {
      amount = dataLen;
      if (amount > maxSize) {
          amount = maxSize;
      }

      for (s=from_screen; s<=to_screen; s++) {

         Display *dpy = GetBackEndDisplay(cl,s);
         DMXScreenInfo *dmxScreen = &dmxScreens[s];

         LockDisplay(dpy);
         GetReq(GLXRenderLarge,req); 
         req->reqType = dmxScreen->glxMajorOpcode;
         req->glxCode = X_GLXRenderLarge; 
         req->contextTag = (glxc ? GetCurrentBackEndTag(cl,contextTag,s) : 0);
         req->length += (amount + 3) >> 2;
         req->requestNumber = requestNumber++;
         req->requestTotal = totalRequests;
         req->dataBytes = amount;
         Data(dpy, ((const char*)data), amount);
         dataLen -= amount;
         data = ((GLbyte *) data) + amount;
         UnlockDisplay(dpy);
         SyncHandle();
      }
    }

    return Success;
}

Generated by  Doxygen 1.6.0   Back to index