dlls/ddraw/dsurface/x11.c

   1 /*              DirectDrawSurface Xlib implementation
   2  *
   3  * Copyright 1997-2000 Marcus Meissner
   4  * Copyright 1998-2000 Lionel Ulmer (most of Direct3D stuff)
   5  */
   6 #include "config.h"
   7 #include "winerror.h"
   8
   9 #include <unistd.h>
  10 #include <assert.h>
  11 #include <fcntl.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15
  16 #include "options.h"
  17 #include "debugtools.h"
  18 #include "x11_private.h"
  19 #include "bitmap.h"
  20 #include "win.h"
  21 #include "d3d.h"
  22
  23 #ifdef HAVE_OPENGL
  24 /* for d3d texture stuff */
  25 # include "mesa_private.h"
  26 #endif
  27
  28 DEFAULT_DEBUG_CHANNEL(ddraw);
  29
  30 #define VISIBLE(x) (SDDSCAPS(x) & (DDSCAPS_VISIBLE|DDSCAPS_PRIMARYSURFACE))
  31
  32 #define DDPRIVATE(x) x11_dd_private *ddpriv = ((x11_dd_private*)(x)->d->private)
  33 #define DPPRIVATE(x) x11_dp_private *dppriv = ((x11_dp_private*)(x)->private)
  34 #define DSPRIVATE(x) x11_ds_private *dspriv = ((x11_ds_private*)(x)->private)
  35
  36 static BYTE Xlib_TouchData(LPVOID data)
  37 {
  38     /* this is a function so it doesn't get optimized out */
  39     return *(BYTE*)data;
  40 }
  41
  42 /******************************************************************************
  43  *              IDirectDrawSurface methods
  44  *
  45  * Since DDS3 and DDS2 are supersets of DDS, we implement DDS3 and let
  46  * DDS and DDS2 use those functions. (Function calls did not change (except
  47  * using different DirectDrawSurfaceX version), just added flags and functions)
  48  */
  49 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_QueryInterface(
  50     LPDIRECTDRAWSURFACE4 iface,REFIID refiid,LPVOID *obj
  51 ) {
  52     ICOM_THIS(IDirectDrawSurface4Impl,iface);
  53
  54     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(refiid),obj);
  55
  56     /* All DirectDrawSurface versions (1, 2, 3 and 4) use
  57      * the same interface. And IUnknown does that too of course.
  58      */
  59     if ( IsEqualGUID( &IID_IDirectDrawSurface4, refiid )        ||
  60          IsEqualGUID( &IID_IDirectDrawSurface3, refiid )        ||
  61          IsEqualGUID( &IID_IDirectDrawSurface2, refiid )        ||
  62          IsEqualGUID( &IID_IDirectDrawSurface,  refiid )        ||
  63          IsEqualGUID( &IID_IUnknown,            refiid )
  64     ) {
  65             *obj = This;
  66             IDirectDrawSurface4_AddRef(iface);
  67
  68             TRACE("  Creating IDirectDrawSurface interface (%p)\n", *obj);
  69             return S_OK;
  70     }
  71 #ifdef HAVE_OPENGL
  72     if ( IsEqualGUID( &IID_IDirect3DTexture2, refiid ) ) {
  73         /* Texture interface */
  74         *obj = d3dtexture2_create(This);
  75         IDirectDrawSurface4_AddRef(iface);
  76         TRACE("  Creating IDirect3DTexture2 interface (%p)\n", *obj);
  77         return S_OK;
  78     }
  79     if ( IsEqualGUID( &IID_IDirect3DTexture, refiid ) ) {
  80         /* Texture interface */
  81         *obj = d3dtexture_create(This);
  82         IDirectDrawSurface4_AddRef(iface);
  83         TRACE("  Creating IDirect3DTexture interface (%p)\n", *obj);
  84         return S_OK;
  85     }
  86 #else
  87     if ( IsEqualGUID( &IID_IDirect3DTexture2, refiid ) ||
  88          IsEqualGUID( &IID_IDirect3DTexture, refiid )
  89        )
  90     {
  91        ERR( "Cannot provide 3D support without OpenGL/Mesa installed\n" );
  92     }
  93 #endif /* HAVE_OPENGL */
  94     FIXME("(%p):interface for IID %s NOT found!\n",This,debugstr_guid(refiid));
  95     return OLE_E_ENUM_NOMORE;
  96 }
  97
  98 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Lock(
  99     LPDIRECTDRAWSURFACE4 iface,LPRECT lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE hnd
 100 ) {
 101     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 102     DSPRIVATE(This);
 103     DDPRIVATE(This->s.ddraw);
 104
 105     /* DO NOT AddRef the surface! Lock/Unlock are NOT guaranteed to come in
 106      * matched pairs! - Marcus Meissner 20000509 */
 107     TRACE("(%p)->Lock(%p,%p,%08lx,%08lx) ret=%p\n",This,lprect,lpddsd,flags,(DWORD)hnd,__builtin_return_address(0));
 108     if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
 109         WARN("(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 110                      This,lprect,lpddsd,flags,(DWORD)hnd);
 111
 112     /* First, copy the Surface description */
 113     *lpddsd = This->s.surface_desc;
 114     TRACE("locked surface: height=%ld, width=%ld, pitch=%ld\n",
 115           lpddsd->dwHeight,lpddsd->dwWidth,lpddsd->lPitch);
 116
 117     /* If asked only for a part, change the surface pointer */
 118     if (lprect) {
 119         TRACE(" lprect: %dx%d-%dx%d\n",
 120                 lprect->top,lprect->left,lprect->bottom,lprect->right
 121         );
 122         if ((lprect->top < 0) ||
 123             (lprect->left < 0) ||
 124             (lprect->bottom < 0) ||
 125             (lprect->right < 0)) {
 126           ERR(" Negative values in LPRECT !!!\n");
 127           return DDERR_INVALIDPARAMS;
 128         }
 129         lpddsd->u1.lpSurface=(LPVOID)((char*)This->s.surface_desc.u1.lpSurface+
 130                 (lprect->top*This->s.surface_desc.lPitch) +
 131                 lprect->left*GET_BPP(This->s.surface_desc));
 132     } else
 133         assert(This->s.surface_desc.u1.lpSurface);
 134     /* wait for any previous operations to complete */
 135 #ifdef HAVE_LIBXXSHM
 136     if (dspriv->image && VISIBLE(This) && ddpriv->xshm_active) {
 137 /*
 138         int compl = InterlockedExchange( &(ddpriv->xshm_compl), 0 );
 139         if (compl) X11DRV_EVENT_WaitShmCompletion( compl );
 140 */
 141         X11DRV_EVENT_WaitShmCompletions( ddpriv->drawable );
 142     }
 143 #endif
 144
 145     /* If part of a visible 'clipped' surface, copy what is seen on the
 146        screen to the surface */
 147     if ((dspriv->image && VISIBLE(This)) &&
 148         (This->s.lpClipper)) {
 149           HWND hWnd = ((IDirectDrawClipperImpl *) This->s.lpClipper)->hWnd;
 150           WND *wndPtr = WIN_FindWndPtr(hWnd);
 151           Drawable drawable = X11DRV_WND_GetXWindow(wndPtr);
 152           int width = wndPtr->rectClient.right - wndPtr->rectClient.left;
 153           int height = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 154           /* Now, get the source / destination coordinates */
 155           int dest_x = wndPtr->rectClient.left;
 156           int dest_y = wndPtr->rectClient.top;
 157
 158           if (!drawable) { /* we are running in -desktop mode */
 159               drawable = X11DRV_WND_GetXWindow(WIN_GetDesktop());
 160               /* FIXME: not sure whether these are the right offsets */
 161               dest_x+=wndPtr->rectWindow.left;
 162               dest_y+=wndPtr->rectWindow.top;
 163               WIN_ReleaseDesktop();
 164           }
 165
 166           TSXGetSubImage(display, drawable, 0, 0, width, height, 0xFFFFFFFF,
 167                        ZPixmap, dspriv->image, dest_x, dest_y);
 168
 169           WIN_ReleaseWndPtr(wndPtr);
 170     }
 171
 172     return DD_OK;
 173 }
 174
 175 static void Xlib_copy_surface_on_screen(IDirectDrawSurface4Impl* This) {
 176   DSPRIVATE(This);
 177   DDPRIVATE(This->s.ddraw);
 178   Drawable drawable = ddpriv->drawable;
 179   POINT adjust[2] = {{0, 0}, {0, 0}};
 180   SIZE imgsiz;
 181
 182   /* Get XImage size */
 183   imgsiz.cx = dspriv->image->width;
 184   imgsiz.cy = dspriv->image->height;
 185
 186   if (This->s.lpClipper) {
 187     HWND hWnd = ((IDirectDrawClipperImpl *) This->s.lpClipper)->hWnd;
 188     SIZE csiz;
 189     WND *wndPtr = WIN_FindWndPtr(hWnd);
 190     drawable = X11DRV_WND_GetXWindow(wndPtr);
 191
 192     MapWindowPoints(hWnd, 0, adjust, 2);
 193
 194     imgsiz.cx -= adjust[0].x;
 195     imgsiz.cy -= adjust[0].y;
 196     /* (note: the rectWindow here should be the X window's interior rect, in
 197      *  case anyone thinks otherwise while rewriting managed mode) */
 198     adjust[1].x -= wndPtr->rectWindow.left;
 199     adjust[1].y -= wndPtr->rectWindow.top;
 200     csiz.cx = wndPtr->rectClient.right - wndPtr->rectClient.left;
 201     csiz.cy = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
 202     if (csiz.cx < imgsiz.cx) imgsiz.cx = csiz.cx;
 203     if (csiz.cy < imgsiz.cy) imgsiz.cy = csiz.cy;
 204
 205     TRACE("adjust: hwnd=%08x, surface %ldx%ld, drawable %ldx%ld\n", hWnd,
 206           adjust[0].x, adjust[0].y,
 207           adjust[1].x,adjust[1].y);
 208
 209     WIN_ReleaseWndPtr(wndPtr);
 210   }
 211
 212   if (!drawable) {
 213     WND *tmpWnd = WIN_FindWndPtr(This->s.ddraw->d->window);
 214     drawable = X11DRV_WND_GetXWindow(tmpWnd);
 215     WIN_ReleaseWndPtr(tmpWnd);
 216
 217     /* We don't have a context for this window. Host off the desktop */
 218     if( !drawable ) {
 219         FIXME("Have to use Desktop Root Window??? Bummer.\n");
 220         drawable = X11DRV_WND_GetXWindow(WIN_GetDesktop());
 221         WIN_ReleaseDesktop();
 222     }
 223     ddpriv->drawable = drawable;
 224   }
 225
 226   if (This->s.ddraw->d->pixel_convert != NULL)
 227     This->s.ddraw->d->pixel_convert(This->s.surface_desc.u1.lpSurface,
 228                                    dspriv->image->data,
 229                                    This->s.surface_desc.dwWidth,
 230                                    This->s.surface_desc.dwHeight,
 231                                    This->s.surface_desc.lPitch,
 232                                    This->s.palette);
 233
 234   /* if the DIB section is in GdiMod state, we must
 235    * touch the surface to get any updates from the DIB */
 236   Xlib_TouchData(dspriv->image->data);
 237 #ifdef HAVE_LIBXXSHM
 238     if (ddpriv->xshm_active) {
 239 /*
 240         X11DRV_EVENT_WaitReplaceShmCompletion( &(ddpriv->xshm_compl), This->s.ddraw->d.drawable );
 241 */
 242         /* let WaitShmCompletions track 'em for now */
 243         /* (you may want to track it again whenever you implement DX7's partial
 244         * surface locking, where threads have concurrent access) */
 245         X11DRV_EVENT_PrepareShmCompletion( ddpriv->drawable );
 246         TSXShmPutImage(display,
 247                        drawable,
 248                        DefaultGCOfScreen(X11DRV_GetXScreen()),
 249                        dspriv->image,
 250                        adjust[0].x, adjust[0].y, adjust[1].x, adjust[1].y,
 251                        imgsiz.cx, imgsiz.cy,
 252                        True
 253                        );
 254         /* make sure the image is transferred ASAP */
 255         TSXFlush(display);
 256     } else
 257 #endif
 258         TSXPutImage(display,
 259                     drawable,
 260                     DefaultGCOfScreen(X11DRV_GetXScreen()),
 261                     dspriv->image,
 262                     adjust[0].x, adjust[0].y, adjust[1].x, adjust[1].y,
 263                     imgsiz.cx, imgsiz.cy
 264                     );
 265 }
 266
 267 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Unlock(
 268     LPDIRECTDRAWSURFACE4 iface,LPVOID surface
 269 ) {
 270     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 271     DDPRIVATE(This->s.ddraw);
 272     DSPRIVATE(This);
 273     TRACE("(%p)->Unlock(%p)\n",This,surface);
 274
 275     /*if (!This->s.ddraw->d.paintable)
 276         return DD_OK; */
 277
 278     /* Only redraw the screen when unlocking the buffer that is on screen */
 279     if (dspriv->image && VISIBLE(This)) {
 280         Xlib_copy_surface_on_screen(This);
 281         if (This->s.palette) {
 282             DPPRIVATE(This->s.palette);
 283             if(dppriv->cm)
 284                 TSXSetWindowColormap(display,ddpriv->drawable,dppriv->cm);
 285         }
 286     }
 287     /* DO NOT Release the surface! Lock/Unlock are NOT guaranteed to come in
 288      * matched pairs! - Marcus Meissner 20000509 */
 289     return DD_OK;
 290 }
 291
 292 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Flip(
 293     LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
 294 ) {
 295     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 296     XImage      *image;
 297     DDPRIVATE(This->s.ddraw);
 298     DSPRIVATE(This);
 299     x11_ds_private      *fspriv;
 300     LPBYTE      surf;
 301     IDirectDrawSurface4Impl* iflipto=(IDirectDrawSurface4Impl*)flipto;
 302
 303     TRACE("(%p)->Flip(%p,%08lx)\n",This,iflipto,dwFlags);
 304     if (!This->s.ddraw->d->paintable)
 305         return DD_OK;
 306
 307     iflipto = _common_find_flipto(This,iflipto);
 308     fspriv = (x11_ds_private*)iflipto->private;
 309
 310     /* We need to switch the lowlevel surfaces, for xlib this is: */
 311     /* The surface pointer */
 312     surf                                = This->s.surface_desc.u1.lpSurface;
 313     This->s.surface_desc.u1.lpSurface   = iflipto->s.surface_desc.u1.lpSurface;
 314     iflipto->s.surface_desc.u1.lpSurface        = surf;
 315
 316     /* the associated ximage */
 317     image               = dspriv->image;
 318     dspriv->image       = fspriv->image;
 319     fspriv->image       = image;
 320
 321     if (dspriv->opengl_flip) {
 322 #ifdef HAVE_OPENGL
 323       ENTER_GL();
 324       glXSwapBuffers(display, ddpriv->drawable);
 325       LEAVE_GL();
 326 #endif
 327     } else {
 328 #ifdef HAVE_LIBXXSHM
 329       if (ddpriv->xshm_active) {
 330         /*
 331            int compl = InterlockedExchange( &(ddpriv->xshm_compl), 0 );
 332            if (compl) X11DRV_EVENT_WaitShmCompletion( compl );
 333            */
 334         X11DRV_EVENT_WaitShmCompletions( ddpriv->drawable );
 335       }
 336 #endif
 337       Xlib_copy_surface_on_screen(This);
 338       if (iflipto->s.palette) {
 339         DPPRIVATE(iflipto->s.palette);
 340         if (dppriv->cm)
 341           TSXSetWindowColormap(display,ddpriv->drawable,dppriv->cm);
 342       }
 343     }
 344     return DD_OK;
 345 }
 346
 347 /* The IDirectDrawSurface4::SetPalette method attaches the specified
 348  * DirectDrawPalette object to a surface. The surface uses this palette for all
 349  * subsequent operations. The palette change takes place immediately.
 350  */
 351 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_SetPalette(
 352     LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWPALETTE pal
 353 ) {
 354     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 355     DDPRIVATE(This->s.ddraw);
 356     IDirectDrawPaletteImpl* ipal=(IDirectDrawPaletteImpl*)pal;
 357     x11_dp_private      *dppriv;
 358     int i;
 359
 360     TRACE("(%p)->(%p)\n",This,ipal);
 361
 362     if (ipal == NULL) {
 363         if( This->s.palette != NULL )
 364             IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
 365         This->s.palette = ipal;
 366         return DD_OK;
 367     }
 368     dppriv = (x11_dp_private*)ipal->private;
 369
 370     if (!dppriv->cm &&
 371         (This->s.ddraw->d->screen_pixelformat.u.dwRGBBitCount<=8)
 372     ) {
 373         dppriv->cm = TSXCreateColormap(
 374             display,
 375             ddpriv->drawable,
 376             DefaultVisualOfScreen(X11DRV_GetXScreen()),
 377             AllocAll
 378         );
 379         if (!Options.managed)
 380             TSXInstallColormap(display,dppriv->cm);
 381
 382         for (i=0;i<256;i++) {
 383             XColor xc;
 384
 385             xc.red              = ipal->palents[i].peRed<<8;
 386             xc.blue             = ipal->palents[i].peBlue<<8;
 387             xc.green    = ipal->palents[i].peGreen<<8;
 388             xc.flags    = DoRed|DoBlue|DoGreen;
 389             xc.pixel    = i;
 390             TSXStoreColor(display,dppriv->cm,&xc);
 391         }
 392         TSXInstallColormap(display,dppriv->cm);
 393     }
 394     /* According to spec, we are only supposed to
 395      * AddRef if this is not the same palette.
 396      */
 397     if ( This->s.palette != ipal ) {
 398         if( ipal != NULL )
 399             IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
 400         if( This->s.palette != NULL )
 401             IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.palette );
 402         This->s.palette = ipal;
 403         /* Perform the refresh, only if a palette was created */
 404         if (dppriv->cm)
 405           TSXSetWindowColormap(display,ddpriv->drawable,dppriv->cm);
 406
 407         if (This->s.hdc != 0) {
 408             /* hack: set the DIBsection color map */
 409             BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
 410             X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
 411             dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
 412             GDI_ReleaseObj(This->s.DIBsection);
 413         }
 414     }
 415     return DD_OK;
 416 }
 417
 418 ULONG WINAPI Xlib_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
 419     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 420     DSPRIVATE(This);
 421     DDPRIVATE(This->s.ddraw);
 422
 423     TRACE( "(%p)->() decrementing from %lu.\n", This, This->ref );
 424     if (--(This->ref))
 425         return This->ref;
 426
 427     IDirectDraw2_Release((IDirectDraw2*)This->s.ddraw);
 428
 429     /* This frees the program-side surface. In some cases it had been
 430      * allocated with MEM_SYSTEM, so it does not get 'really' freed
 431      */
 432     VirtualFree(This->s.surface_desc.u1.lpSurface, 0, MEM_RELEASE);
 433
 434     /* Now free the XImages and the respective screen-side surfaces */
 435     if (dspriv->image != NULL) {
 436         if (dspriv->image->data != This->s.surface_desc.u1.lpSurface)
 437             VirtualFree(dspriv->image->data, 0, MEM_RELEASE);
 438 #ifdef HAVE_LIBXXSHM
 439         if (ddpriv->xshm_active) {
 440             TSXShmDetach(display, &(dspriv->shminfo));
 441             TSXDestroyImage(dspriv->image);
 442             shmdt(dspriv->shminfo.shmaddr);
 443         } else
 444 #endif
 445         {
 446             /* normal X Image memory was never allocated by X, but always by
 447              * ourselves -> Don't let X free our imagedata.
 448              */
 449             dspriv->image->data = NULL;
 450             TSXDestroyImage(dspriv->image);
 451         }
 452         dspriv->image = 0;
 453     }
 454
 455     if (This->s.palette)
 456         IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
 457
 458     /* Free the DIBSection (if any) */
 459     if (This->s.hdc != 0) {
 460         /* hack: restore the original DIBsection color map */
 461         BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
 462         X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
 463         dib->colorMap = dspriv->oldDIBmap;
 464         GDI_ReleaseObj(This->s.DIBsection);
 465
 466         SelectObject(This->s.hdc, This->s.holdbitmap);
 467         DeleteDC(This->s.hdc);
 468         DeleteObject(This->s.DIBsection);
 469     }
 470
 471     /* Free the clipper if present */
 472     if(This->s.lpClipper)
 473         IDirectDrawClipper_Release(This->s.lpClipper);
 474     HeapFree(GetProcessHeap(),0,This->private);
 475     HeapFree(GetProcessHeap(),0,This);
 476     return S_OK;
 477 }
 478
 479 HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_GetDC(LPDIRECTDRAWSURFACE4 iface,HDC* lphdc) {
 480     ICOM_THIS(IDirectDrawSurface4Impl,iface);
 481     DSPRIVATE(This);
 482     int was_ok = This->s.hdc != 0;
 483     HRESULT result = IDirectDrawSurface4Impl_GetDC(iface,lphdc);
 484     if (This->s.hdc && !was_ok) {
 485         /* hack: take over the DIBsection color map */
 486         BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(This->s.DIBsection, BITMAP_MAGIC);
 487         X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *)bmp->dib;
 488         dspriv->oldDIBmap = dib->colorMap;
 489         dib->colorMap = This->s.palette ? This->s.palette->screen_palents : NULL;
 490         GDI_ReleaseObj(This->s.DIBsection);
 491     }
 492     return result;
 493 }
 494
 495 ICOM_VTABLE(IDirectDrawSurface4) xlib_dds4vt =
 496 {
 497     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 498     Xlib_IDirectDrawSurface4Impl_QueryInterface,
 499     IDirectDrawSurface4Impl_AddRef,
 500     Xlib_IDirectDrawSurface4Impl_Release,
 501     IDirectDrawSurface4Impl_AddAttachedSurface,
 502     IDirectDrawSurface4Impl_AddOverlayDirtyRect,
 503     IDirectDrawSurface4Impl_Blt,
 504     IDirectDrawSurface4Impl_BltBatch,
 505     IDirectDrawSurface4Impl_BltFast,
 506     IDirectDrawSurface4Impl_DeleteAttachedSurface,
 507     IDirectDrawSurface4Impl_EnumAttachedSurfaces,
 508     IDirectDrawSurface4Impl_EnumOverlayZOrders,
 509     Xlib_IDirectDrawSurface4Impl_Flip,
 510     IDirectDrawSurface4Impl_GetAttachedSurface,
 511     IDirectDrawSurface4Impl_GetBltStatus,
 512     IDirectDrawSurface4Impl_GetCaps,
 513     IDirectDrawSurface4Impl_GetClipper,
 514     IDirectDrawSurface4Impl_GetColorKey,
 515     Xlib_IDirectDrawSurface4Impl_GetDC,
 516     IDirectDrawSurface4Impl_GetFlipStatus,
 517     IDirectDrawSurface4Impl_GetOverlayPosition,
 518     IDirectDrawSurface4Impl_GetPalette,
 519     IDirectDrawSurface4Impl_GetPixelFormat,
 520     IDirectDrawSurface4Impl_GetSurfaceDesc,
 521     IDirectDrawSurface4Impl_Initialize,
 522     IDirectDrawSurface4Impl_IsLost,
 523     Xlib_IDirectDrawSurface4Impl_Lock,
 524     IDirectDrawSurface4Impl_ReleaseDC,
 525     IDirectDrawSurface4Impl_Restore,
 526     IDirectDrawSurface4Impl_SetClipper,
 527     IDirectDrawSurface4Impl_SetColorKey,
 528     IDirectDrawSurface4Impl_SetOverlayPosition,
 529     Xlib_IDirectDrawSurface4Impl_SetPalette,
 530     Xlib_IDirectDrawSurface4Impl_Unlock,
 531     IDirectDrawSurface4Impl_UpdateOverlay,
 532     IDirectDrawSurface4Impl_UpdateOverlayDisplay,
 533     IDirectDrawSurface4Impl_UpdateOverlayZOrder,
 534     IDirectDrawSurface4Impl_GetDDInterface,
 535     IDirectDrawSurface4Impl_PageLock,
 536     IDirectDrawSurface4Impl_PageUnlock,
 537     IDirectDrawSurface4Impl_SetSurfaceDesc,
 538     IDirectDrawSurface4Impl_SetPrivateData,
 539     IDirectDrawSurface4Impl_GetPrivateData,
 540     IDirectDrawSurface4Impl_FreePrivateData,
 541     IDirectDrawSurface4Impl_GetUniquenessValue,
 542     IDirectDrawSurface4Impl_ChangeUniquenessValue
 543 };