src/glx/glx_pbuffer.c

   1 /*
   2  * (C) Copyright IBM Corporation 2004
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file glx_pbuffer.c
  27  * Implementation of pbuffer related functions.
  28  *
  29  * \author Ian Romanick <idr@us.ibm.com>
  30  */
  31
  32 #include <inttypes.h>
  33 #include "glxclient.h"
  34 #include <X11/extensions/extutil.h>
  35 #include <X11/extensions/Xext.h>
  36 #include <assert.h>
  37 #include <string.h>
  38 #include "glxextensions.h"
  39
  40 #ifdef GLX_USE_APPLEGL
  41 #include <pthread.h>
  42 #include "apple_glx_drawable.h"
  43 #include "glx_error.h"
  44 #endif
  45
  46 #define WARN_ONCE_GLX_1_3(a, b) {               \
  47                 static int warned=1;            \
  48                 if(warned) {                    \
  49                         warn_GLX_1_3((a), b );  \
  50                         warned=0;               \
  51                 }                               \
  52         }
  53
  54 /**
  55  * Emit a warning when clients use GLX 1.3 functions on pre-1.3 systems.
  56  */
  57 static void
  58 warn_GLX_1_3(Display * dpy, const char *function_name)
  59 {
  60    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
  61
  62    if (priv->minorVersion < 3) {
  63       fprintf(stderr,
  64               "WARNING: Application calling GLX 1.3 function \"%s\" "
  65               "when GLX 1.3 is not supported!  This is an application bug!\n",
  66               function_name);
  67    }
  68 }
  69
  70 #ifndef GLX_USE_APPLEGL
  71 /**
  72  * Change a drawable's attribute.
  73  *
  74  * This function is used to implement \c glXSelectEvent and
  75  * \c glXSelectEventSGIX.
  76  *
  77  * \note
  78  * This function dynamically determines whether to use the SGIX_pbuffer
  79  * version of the protocol or the GLX 1.3 version of the protocol.
  80  *
  81  * \todo
  82  * This function needs to be modified to work with direct-rendering drivers.
  83  */
  84 static void
  85 ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable,
  86                         const CARD32 * attribs, size_t num_attribs)
  87 {
  88    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
  89    __GLXDRIdrawable *pdraw;
  90    CARD32 *output;
  91    CARD8 opcode;
  92    int i;
  93
  94    if ((dpy == NULL) || (drawable == 0)) {
  95       return;
  96    }
  97
  98    pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
  99
 100    opcode = __glXSetupForCommand(dpy);
 101    if (!opcode)
 102       return;
 103
 104    LockDisplay(dpy);
 105
 106    if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
 107       xGLXChangeDrawableAttributesReq *req;
 108
 109       GetReqExtra(GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req);
 110       output = (CARD32 *) (req + 1);
 111
 112       req->reqType = opcode;
 113       req->glxCode = X_GLXChangeDrawableAttributes;
 114       req->drawable = drawable;
 115       req->numAttribs = (CARD32) num_attribs;
 116    }
 117    else {
 118       xGLXVendorPrivateWithReplyReq *vpreq;
 119
 120       GetReqExtra(GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq);
 121       output = (CARD32 *) (vpreq + 1);
 122
 123       vpreq->reqType = opcode;
 124       vpreq->glxCode = X_GLXVendorPrivateWithReply;
 125       vpreq->vendorCode = X_GLXvop_ChangeDrawableAttributesSGIX;
 126
 127       output[0] = (CARD32) drawable;
 128       output++;
 129    }
 130
 131    (void) memcpy(output, attribs, sizeof(CARD32) * 2 * num_attribs);
 132
 133    UnlockDisplay(dpy);
 134    SyncHandle();
 135
 136    for (i = 0; i < num_attribs; i++) {
 137       switch(attribs[i * 2]) {
 138       case GLX_EVENT_MASK:
 139          /* Keep a local copy for masking out DRI2 proto events as needed */
 140          pdraw->eventMask = attribs[i * 2 + 1];
 141          break;
 142       }
 143    }
 144
 145    return;
 146 }
 147
 148
 149 #ifdef GLX_DIRECT_RENDERING
 150 static GLenum
 151 determineTextureTarget(const int *attribs, int numAttribs)
 152 {
 153    GLenum target = 0;
 154    int i;
 155
 156    for (i = 0; i < numAttribs; i++) {
 157       if (attribs[2 * i] == GLX_TEXTURE_TARGET_EXT) {
 158          switch (attribs[2 * i + 1]) {
 159          case GLX_TEXTURE_2D_EXT:
 160             target = GL_TEXTURE_2D;
 161             break;
 162          case GLX_TEXTURE_RECTANGLE_EXT:
 163             target = GL_TEXTURE_RECTANGLE_ARB;
 164             break;
 165          }
 166       }
 167    }
 168
 169    return target;
 170 }
 171
 172 static GLenum
 173 determineTextureFormat(const int *attribs, int numAttribs)
 174 {
 175    int i;
 176
 177    for (i = 0; i < numAttribs; i++) {
 178       if (attribs[2 * i] == GLX_TEXTURE_FORMAT_EXT)
 179          return attribs[2 * i + 1];
 180    }
 181
 182    return 0;
 183 }
 184
 185 static void
 186 CreateDRIDrawable(Display *dpy, const __GLcontextModes *fbconfig,
 187                   XID drawable, XID glxdrawable,
 188                   const int *attrib_list, size_t num_attribs)
 189 {
 190    __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 191    __GLXDRIdrawable *pdraw;
 192    __GLXscreenConfigs *psc;
 193
 194    psc = priv->screenConfigs[fbconfig->screen];
 195    if (psc->driScreen == NULL)
 196       return;
 197
 198    pdraw = psc->driScreen->createDrawable(psc, drawable,
 199                                           glxdrawable, fbconfig);
 200    if (pdraw == NULL) {
 201       fprintf(stderr, "failed to create drawable\n");
 202       return;
 203    }
 204
 205    if (__glxHashInsert(priv->drawHash, glxdrawable, pdraw)) {
 206       (*pdraw->destroyDrawable) (pdraw);
 207       return; /* FIXME: Check what we're supposed to do here... */
 208    }
 209
 210    pdraw->textureTarget = determineTextureTarget(attrib_list, num_attribs);
 211    pdraw->textureFormat = determineTextureFormat(attrib_list, num_attribs);
 212 }
 213
 214 static void
 215 DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
 216 {
 217    int screen;
 218    __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 219    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
 220    __GLXscreenConfigs *psc = priv->screenConfigs[screen];
 221
 222    if (pdraw != NULL) {
 223       if (destroy_xdrawable)
 224          XFreePixmap(psc->dpy, pdraw->xDrawable);
 225       (*pdraw->destroyDrawable) (pdraw);
 226       __glxHashDelete(priv->drawHash, drawable);
 227    }
 228 }
 229
 230 #else
 231
 232 static void
 233 CreateDRIDrawable(Display *dpy, const __GLcontextModes * fbconfig,
 234                   XID drawable, XID glxdrawable,
 235                   const int *attrib_list, size_t num_attribs)
 236 {
 237 }
 238
 239 static void
 240 DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
 241 {
 242 }
 243
 244 #endif
 245
 246 /**
 247  * Get a drawable's attribute.
 248  *
 249  * This function is used to implement \c glXGetSelectedEvent and
 250  * \c glXGetSelectedEventSGIX.
 251  *
 252  * \note
 253  * This function dynamically determines whether to use the SGIX_pbuffer
 254  * version of the protocol or the GLX 1.3 version of the protocol.
 255  *
 256  * \todo
 257  * The number of attributes returned is likely to be small, probably less than
 258  * 10.  Given that, this routine should try to use an array on the stack to
 259  * capture the reply rather than always calling Xmalloc.
 260  *
 261  * \todo
 262  * This function needs to be modified to work with direct-rendering drivers.
 263  */
 264 static int
 265 GetDrawableAttribute(Display * dpy, GLXDrawable drawable,
 266                      int attribute, unsigned int *value)
 267 {
 268    __GLXdisplayPrivate *priv;
 269    xGLXGetDrawableAttributesReply reply;
 270    CARD32 *data;
 271    CARD8 opcode;
 272    unsigned int length;
 273    unsigned int i;
 274    unsigned int num_attributes;
 275    GLboolean use_glx_1_3;
 276
 277    if ((dpy == NULL) || (drawable == 0)) {
 278       return 0;
 279    }
 280
 281    priv = __glXInitialize(dpy);
 282    use_glx_1_3 = ((priv->majorVersion > 1) || (priv->minorVersion >= 3));
 283
 284    *value = 0;
 285
 286
 287    opcode = __glXSetupForCommand(dpy);
 288    if (!opcode)
 289       return 0;
 290
 291    LockDisplay(dpy);
 292
 293    if (use_glx_1_3) {
 294       xGLXGetDrawableAttributesReq *req;
 295
 296       GetReqExtra(GLXGetDrawableAttributes, 4, req);
 297       req->reqType = opcode;
 298       req->glxCode = X_GLXGetDrawableAttributes;
 299       req->drawable = drawable;
 300    }
 301    else {
 302       xGLXVendorPrivateWithReplyReq *vpreq;
 303
 304       GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
 305       data = (CARD32 *) (vpreq + 1);
 306       data[0] = (CARD32) drawable;
 307
 308       vpreq->reqType = opcode;
 309       vpreq->glxCode = X_GLXVendorPrivateWithReply;
 310       vpreq->vendorCode = X_GLXvop_GetDrawableAttributesSGIX;
 311    }
 312
 313    _XReply(dpy, (xReply *) & reply, 0, False);
 314
 315    if (reply.type == X_Error) {
 316       UnlockDisplay(dpy);
 317       SyncHandle();
 318       return 0;
 319    }
 320
 321    length = reply.length;
 322    if (length) {
 323       num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2;
 324       data = (CARD32 *) Xmalloc(length * sizeof(CARD32));
 325       if (data == NULL) {
 326          /* Throw data on the floor */
 327          _XEatData(dpy, length);
 328       }
 329       else {
 330          _XRead(dpy, (char *) data, length * sizeof(CARD32));
 331
 332          /* Search the set of returned attributes for the attribute requested by
 333           * the caller.
 334           */
 335          for (i = 0; i < num_attributes; i++) {
 336             if (data[i * 2] == attribute) {
 337                *value = data[(i * 2) + 1];
 338                break;
 339             }
 340          }
 341
 342 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 343          {
 344             __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
 345
 346             if (pdraw != NULL && !pdraw->textureTarget)
 347                pdraw->textureTarget =
 348                   determineTextureTarget((const int *) data, num_attributes);
 349             if (pdraw != NULL && !pdraw->textureFormat)
 350                pdraw->textureFormat =
 351                   determineTextureFormat((const int *) data, num_attributes);
 352          }
 353 #endif
 354
 355          Xfree(data);
 356       }
 357    }
 358
 359    UnlockDisplay(dpy);
 360    SyncHandle();
 361
 362    return 0;
 363 }
 364
 365 /**
 366  * Create a non-pbuffer GLX drawable.
 367  *
 368  * \todo
 369  * This function needs to be modified to work with direct-rendering drivers.
 370  */
 371 static GLXDrawable
 372 CreateDrawable(Display * dpy, const __GLcontextModes * fbconfig,
 373                Drawable drawable, const int *attrib_list, CARD8 glxCode)
 374 {
 375    xGLXCreateWindowReq *req;
 376    CARD32 *data;
 377    unsigned int i;
 378    CARD8 opcode;
 379
 380    i = 0;
 381    if (attrib_list) {
 382       while (attrib_list[i * 2] != None)
 383          i++;
 384    }
 385
 386    opcode = __glXSetupForCommand(dpy);
 387    if (!opcode)
 388       return None;
 389
 390    LockDisplay(dpy);
 391    GetReqExtra(GLXCreateWindow, 8 * i, req);
 392    data = (CARD32 *) (req + 1);
 393
 394    req->reqType = opcode;
 395    req->glxCode = glxCode;
 396    req->screen = (CARD32) fbconfig->screen;
 397    req->fbconfig = fbconfig->fbconfigID;
 398    req->window = (CARD32) drawable;
 399    req->glxwindow = (GLXWindow) XAllocID(dpy);
 400    req->numAttribs = (CARD32) i;
 401
 402    if (attrib_list)
 403       memcpy(data, attrib_list, 8 * i);
 404
 405    UnlockDisplay(dpy);
 406    SyncHandle();
 407
 408    CreateDRIDrawable(dpy, fbconfig, drawable, req->glxwindow, attrib_list, i);
 409
 410    return (GLXDrawable) req->glxwindow;
 411 }
 412
 413
 414 /**
 415  * Destroy a non-pbuffer GLX drawable.
 416  */
 417 static void
 418 DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode)
 419 {
 420    xGLXDestroyPbufferReq *req;
 421    CARD8 opcode;
 422
 423    if ((dpy == NULL) || (drawable == 0)) {
 424       return;
 425    }
 426
 427
 428    opcode = __glXSetupForCommand(dpy);
 429    if (!opcode)
 430       return;
 431
 432    LockDisplay(dpy);
 433
 434    GetReqExtra(GLXDestroyPbuffer, 4, req);
 435    req->reqType = opcode;
 436    req->glxCode = glxCode;
 437    req->pbuffer = (GLXPbuffer) drawable;
 438
 439    UnlockDisplay(dpy);
 440    SyncHandle();
 441
 442    DestroyDRIDrawable(dpy, drawable, GL_FALSE);
 443
 444    return;
 445 }
 446
 447
 448 /**
 449  * Create a pbuffer.
 450  *
 451  * This function is used to implement \c glXCreatePbuffer and
 452  * \c glXCreateGLXPbufferSGIX.
 453  *
 454  * \note
 455  * This function dynamically determines whether to use the SGIX_pbuffer
 456  * version of the protocol or the GLX 1.3 version of the protocol.
 457  *
 458  * \todo
 459  * This function needs to be modified to work with direct-rendering drivers.
 460  */
 461 static GLXDrawable
 462 CreatePbuffer(Display * dpy, const __GLcontextModes * fbconfig,
 463               unsigned int width, unsigned int height,
 464               const int *attrib_list, GLboolean size_in_attribs)
 465 {
 466    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
 467    GLXDrawable id = 0;
 468    CARD32 *data;
 469    CARD8 opcode;
 470    unsigned int i;
 471    Pixmap pixmap;
 472
 473    i = 0;
 474    if (attrib_list) {
 475       while (attrib_list[i * 2])
 476          i++;
 477    }
 478
 479    opcode = __glXSetupForCommand(dpy);
 480    if (!opcode)
 481       return None;
 482
 483    LockDisplay(dpy);
 484    id = XAllocID(dpy);
 485
 486    if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
 487       xGLXCreatePbufferReq *req;
 488       unsigned int extra = (size_in_attribs) ? 0 : 2;
 489
 490       GetReqExtra(GLXCreatePbuffer, (8 * (i + extra)), req);
 491       data = (CARD32 *) (req + 1);
 492
 493       req->reqType = opcode;
 494       req->glxCode = X_GLXCreatePbuffer;
 495       req->screen = (CARD32) fbconfig->screen;
 496       req->fbconfig = fbconfig->fbconfigID;
 497       req->pbuffer = (GLXPbuffer) id;
 498       req->numAttribs = (CARD32) (i + extra);
 499
 500       if (!size_in_attribs) {
 501          data[(2 * i) + 0] = GLX_PBUFFER_WIDTH;
 502          data[(2 * i) + 1] = width;
 503          data[(2 * i) + 2] = GLX_PBUFFER_HEIGHT;
 504          data[(2 * i) + 3] = height;
 505          data += 4;
 506       }
 507    }
 508    else {
 509       xGLXVendorPrivateReq *vpreq;
 510
 511       GetReqExtra(GLXVendorPrivate, 20 + (8 * i), vpreq);
 512       data = (CARD32 *) (vpreq + 1);
 513
 514       vpreq->reqType = opcode;
 515       vpreq->glxCode = X_GLXVendorPrivate;
 516       vpreq->vendorCode = X_GLXvop_CreateGLXPbufferSGIX;
 517
 518       data[0] = (CARD32) fbconfig->screen;
 519       data[1] = (CARD32) fbconfig->fbconfigID;
 520       data[2] = (CARD32) id;
 521       data[3] = (CARD32) width;
 522       data[4] = (CARD32) height;
 523       data += 5;
 524    }
 525
 526    (void) memcpy(data, attrib_list, sizeof(CARD32) * 2 * i);
 527
 528    UnlockDisplay(dpy);
 529    SyncHandle();
 530
 531    pixmap = XCreatePixmap(dpy, RootWindow(dpy, fbconfig->screen),
 532                           width, height, fbconfig->rgbBits);
 533
 534    CreateDRIDrawable(dpy, fbconfig, pixmap, id, attrib_list, i);
 535
 536    return id;
 537 }
 538
 539 /**
 540  * Destroy a pbuffer.
 541  *
 542  * This function is used to implement \c glXDestroyPbuffer and
 543  * \c glXDestroyGLXPbufferSGIX.
 544  *
 545  * \note
 546  * This function dynamically determines whether to use the SGIX_pbuffer
 547  * version of the protocol or the GLX 1.3 version of the protocol.
 548  */
 549 static void
 550 DestroyPbuffer(Display * dpy, GLXDrawable drawable)
 551 {
 552    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
 553    CARD8 opcode;
 554
 555    if ((dpy == NULL) || (drawable == 0)) {
 556       return;
 557    }
 558
 559    opcode = __glXSetupForCommand(dpy);
 560    if (!opcode)
 561       return;
 562
 563    LockDisplay(dpy);
 564
 565    if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
 566       xGLXDestroyPbufferReq *req;
 567
 568       GetReq(GLXDestroyPbuffer, req);
 569       req->reqType = opcode;
 570       req->glxCode = X_GLXDestroyPbuffer;
 571       req->pbuffer = (GLXPbuffer) drawable;
 572    }
 573    else {
 574       xGLXVendorPrivateWithReplyReq *vpreq;
 575       CARD32 *data;
 576
 577       GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
 578       data = (CARD32 *) (vpreq + 1);
 579
 580       data[0] = (CARD32) drawable;
 581
 582       vpreq->reqType = opcode;
 583       vpreq->glxCode = X_GLXVendorPrivateWithReply;
 584       vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
 585    }
 586
 587    UnlockDisplay(dpy);
 588    SyncHandle();
 589
 590    DestroyDRIDrawable(dpy, drawable, GL_TRUE);
 591
 592    return;
 593 }
 594
 595 /**
 596  * Create a new pbuffer.
 597  */
 598 PUBLIC GLXPbufferSGIX
 599 glXCreateGLXPbufferSGIX(Display * dpy, GLXFBConfigSGIX config,
 600                         unsigned int width, unsigned int height,
 601                         int *attrib_list)
 602 {
 603    return (GLXPbufferSGIX) CreatePbuffer(dpy, (__GLcontextModes *) config,
 604                                          width, height,
 605                                          attrib_list, GL_FALSE);
 606 }
 607
 608 #endif /* GLX_USE_APPLEGL */
 609
 610 /**
 611  * Create a new pbuffer.
 612  */
 613 PUBLIC GLXPbuffer
 614 glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int *attrib_list)
 615 {
 616    int i, width, height;
 617 #ifdef GLX_USE_APPLEGL
 618    GLXPbuffer result;
 619    int errorcode;
 620 #endif
 621
 622    width = 0;
 623    height = 0;
 624
 625    WARN_ONCE_GLX_1_3(dpy, __func__);
 626
 627 #ifdef GLX_USE_APPLEGL
 628    for (i = 0; attrib_list[i]; ++i) {
 629       switch (attrib_list[i]) {
 630       case GLX_PBUFFER_WIDTH:
 631          width = attrib_list[i + 1];
 632          ++i;
 633          break;
 634
 635       case GLX_PBUFFER_HEIGHT:
 636          height = attrib_list[i + 1];
 637          ++i;
 638          break;
 639
 640       case GLX_LARGEST_PBUFFER:
 641          /* This is a hint we should probably handle, but how? */
 642          ++i;
 643          break;
 644
 645       case GLX_PRESERVED_CONTENTS:
 646          /* The contents are always preserved with AppleSGLX with CGL. */
 647          ++i;
 648          break;
 649
 650       default:
 651          return None;
 652       }
 653    }
 654
 655    if (apple_glx_pbuffer_create(dpy, config, width, height, &errorcode,
 656                                 &result)) {
 657       /*
 658        * apple_glx_pbuffer_create only sets the errorcode to core X11
 659        * errors.
 660        */
 661       __glXSendError(dpy, errorcode, 0, X_GLXCreatePbuffer, true);
 662
 663       return None;
 664    }
 665
 666    return result;
 667 #else
 668    for (i = 0; attrib_list[i * 2]; i++) {
 669       switch (attrib_list[i * 2]) {
 670       case GLX_PBUFFER_WIDTH:
 671          width = attrib_list[i * 2 + 1];
 672          break;
 673       case GLX_PBUFFER_HEIGHT:
 674          height = attrib_list[i * 2 + 1];
 675          break;
 676       }
 677    }
 678
 679    return (GLXPbuffer) CreatePbuffer(dpy, (__GLcontextModes *) config,
 680                                      width, height, attrib_list, GL_TRUE);
 681 #endif
 682 }
 683
 684
 685 /**
 686  * Destroy an existing pbuffer.
 687  */
 688 PUBLIC void
 689 glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf)
 690 {
 691 #ifdef GLX_USE_APPLEGL
 692    if (apple_glx_pbuffer_destroy(dpy, pbuf)) {
 693       __glXSendError(dpy, GLXBadPbuffer, pbuf, X_GLXDestroyPbuffer, false);
 694    }
 695 #else
 696    DestroyPbuffer(dpy, pbuf);
 697 #endif
 698 }
 699
 700
 701 /**
 702  * Query an attribute of a drawable.
 703  */
 704 PUBLIC void
 705 glXQueryDrawable(Display * dpy, GLXDrawable drawable,
 706                  int attribute, unsigned int *value)
 707 {
 708    WARN_ONCE_GLX_1_3(dpy, __func__);
 709 #ifdef GLX_USE_APPLEGL
 710    Window root;
 711    int x, y;
 712    unsigned int width, height, bd, depth;
 713
 714    if (apple_glx_pixmap_query(drawable, attribute, value))
 715       return;                   /*done */
 716
 717    if (apple_glx_pbuffer_query(drawable, attribute, value))
 718       return;                   /*done */
 719
 720    /*
 721     * The OpenGL spec states that we should report GLXBadDrawable if
 722     * the drawable is invalid, however doing so would require that we
 723     * use XSetErrorHandler(), which is known to not be thread safe.
 724     * If we use a round-trip call to validate the drawable, there could
 725     * be a race, so instead we just opt in favor of letting the
 726     * XGetGeometry request fail with a GetGeometry request X error
 727     * rather than GLXBadDrawable, in what is hoped to be a rare
 728     * case of an invalid drawable.  In practice most and possibly all
 729     * X11 apps using GLX shouldn't notice a difference.
 730     */
 731    if (XGetGeometry
 732        (dpy, drawable, &root, &x, &y, &width, &height, &bd, &depth)) {
 733       switch (attribute) {
 734       case GLX_WIDTH:
 735          *value = width;
 736          break;
 737
 738       case GLX_HEIGHT:
 739          *value = height;
 740          break;
 741       }
 742    }
 743 #else
 744    GetDrawableAttribute(dpy, drawable, attribute, value);
 745 #endif
 746 }
 747
 748
 749 #ifndef GLX_USE_APPLEGL
 750 /**
 751  * Query an attribute of a pbuffer.
 752  */
 753 PUBLIC int
 754 glXQueryGLXPbufferSGIX(Display * dpy, GLXPbufferSGIX drawable,
 755                        int attribute, unsigned int *value)
 756 {
 757    return GetDrawableAttribute(dpy, drawable, attribute, value);
 758 }
 759 #endif
 760
 761 /**
 762  * Select the event mask for a drawable.
 763  */
 764 PUBLIC void
 765 glXSelectEvent(Display * dpy, GLXDrawable drawable, unsigned long mask)
 766 {
 767 #ifdef GLX_USE_APPLEGL
 768    XWindowAttributes xwattr;
 769
 770    if (apple_glx_pbuffer_set_event_mask(drawable, mask))
 771       return;                   /*done */
 772
 773    /*
 774     * The spec allows a window, but currently there are no valid
 775     * events for a window, so do nothing.
 776     */
 777    if (XGetWindowAttributes(dpy, drawable, &xwattr))
 778       return;                   /*done */
 779    /* The drawable seems to be invalid.  Report an error. */
 780
 781    __glXSendError(dpy, GLXBadDrawable, drawable,
 782                   X_GLXChangeDrawableAttributes, false);
 783 #else
 784    CARD32 attribs[2];
 785
 786    attribs[0] = (CARD32) GLX_EVENT_MASK;
 787    attribs[1] = (CARD32) mask;
 788
 789    ChangeDrawableAttribute(dpy, drawable, attribs, 1);
 790 #endif
 791 }
 792
 793
 794 /**
 795  * Get the selected event mask for a drawable.
 796  */
 797 PUBLIC void
 798 glXGetSelectedEvent(Display * dpy, GLXDrawable drawable, unsigned long *mask)
 799 {
 800 #ifdef GLX_USE_APPLEGL
 801    XWindowAttributes xwattr;
 802
 803    if (apple_glx_pbuffer_get_event_mask(drawable, mask))
 804       return;                   /*done */
 805
 806    /*
 807     * The spec allows a window, but currently there are no valid
 808     * events for a window, so do nothing, but set the mask to 0.
 809     */
 810    if (XGetWindowAttributes(dpy, drawable, &xwattr)) {
 811       /* The window is valid, so set the mask to 0. */
 812       *mask = 0;
 813       return;                   /*done */
 814    }
 815    /* The drawable seems to be invalid.  Report an error. */
 816
 817    __glXSendError(dpy, GLXBadDrawable, drawable, X_GLXGetDrawableAttributes,
 818                   true);
 819 #else
 820    unsigned int value;
 821
 822
 823    /* The non-sense with value is required because on LP64 platforms
 824     * sizeof(unsigned int) != sizeof(unsigned long).  On little-endian
 825     * we could just type-cast the pointer, but why?
 826     */
 827
 828    GetDrawableAttribute(dpy, drawable, GLX_EVENT_MASK_SGIX, &value);
 829    *mask = value;
 830 #endif
 831 }
 832
 833
 834 PUBLIC GLXPixmap
 835 glXCreatePixmap(Display * dpy, GLXFBConfig config, Pixmap pixmap,
 836                 const int *attrib_list)
 837 {
 838    WARN_ONCE_GLX_1_3(dpy, __func__);
 839
 840 #ifdef GLX_USE_APPLEGL
 841    const __GLcontextModes *modes = (const __GLcontextModes *) config;
 842
 843    if (apple_glx_pixmap_create(dpy, modes->screen, pixmap, modes))
 844       return None;
 845
 846    return pixmap;
 847 #else
 848    return CreateDrawable(dpy, (__GLcontextModes *) config,
 849                          (Drawable) pixmap, attrib_list, X_GLXCreatePixmap);
 850 #endif
 851 }
 852
 853
 854 PUBLIC GLXWindow
 855 glXCreateWindow(Display * dpy, GLXFBConfig config, Window win,
 856                 const int *attrib_list)
 857 {
 858    WARN_ONCE_GLX_1_3(dpy, __func__);
 859 #ifdef GLX_USE_APPLEGL
 860    XWindowAttributes xwattr;
 861    XVisualInfo *visinfo;
 862
 863    (void) attrib_list;          /*unused according to GLX 1.4 */
 864
 865    XGetWindowAttributes(dpy, win, &xwattr);
 866
 867    visinfo = glXGetVisualFromFBConfig(dpy, config);
 868
 869    if (NULL == visinfo) {
 870       __glXSendError(dpy, GLXBadFBConfig, 0, X_GLXCreateWindow, false);
 871       return None;
 872    }
 873
 874    if (visinfo->visualid != XVisualIDFromVisual(xwattr.visual)) {
 875       __glXSendError(dpy, BadMatch, 0, X_GLXCreateWindow, true);
 876       return None;
 877    }
 878
 879    XFree(visinfo);
 880
 881    return win;
 882 #else
 883    return CreateDrawable(dpy, (__GLcontextModes *) config,
 884                          (Drawable) win, attrib_list, X_GLXCreateWindow);
 885 #endif
 886 }
 887
 888
 889 PUBLIC void
 890 glXDestroyPixmap(Display * dpy, GLXPixmap pixmap)
 891 {
 892    WARN_ONCE_GLX_1_3(dpy, __func__);
 893 #ifdef GLX_USE_APPLEGL
 894    if (apple_glx_pixmap_destroy(dpy, pixmap))
 895       __glXSendError(dpy, GLXBadPixmap, pixmap, X_GLXDestroyPixmap, false);
 896 #else
 897    DestroyDrawable(dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap);
 898 #endif
 899 }
 900
 901
 902 PUBLIC void
 903 glXDestroyWindow(Display * dpy, GLXWindow win)
 904 {
 905    WARN_ONCE_GLX_1_3(dpy, __func__);
 906 #ifndef GLX_USE_APPLEGL
 907    DestroyDrawable(dpy, (GLXDrawable) win, X_GLXDestroyWindow);
 908 #endif
 909 }
 910
 911 #ifndef GLX_USE_APPLEGL
 912 PUBLIC
 913 GLX_ALIAS_VOID(glXDestroyGLXPbufferSGIX,
 914                (Display * dpy, GLXPbufferSGIX pbuf),
 915                (dpy, pbuf), glXDestroyPbuffer)
 916
 917 PUBLIC
 918 GLX_ALIAS_VOID(glXSelectEventSGIX,
 919                (Display * dpy, GLXDrawable drawable,
 920                 unsigned long mask), (dpy, drawable, mask), glXSelectEvent)
 921
 922 PUBLIC
 923 GLX_ALIAS_VOID(glXGetSelectedEventSGIX,
 924                (Display * dpy, GLXDrawable drawable,
 925                 unsigned long *mask), (dpy, drawable, mask),
 926                glXGetSelectedEvent)
 927 #endif