git.oblomov.eu Git - wine/blob - graphics/ddraw.c

   1 /*              DirectDraw using DGA or Xlib(XSHM)
   2  *
   3  * Copyright 1997,1998 Marcus Meissner
   4  * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
   5  */
   6 /* XF86DGA:
   7  * When DirectVideo mode is enabled you can no longer use 'normal' X
   8  * applications nor can you switch to a virtual console. Also, enabling
   9  * only works, if you have switched to the screen where the application
  10  * is running.
  11  * Some ways to debug this stuff are:
  12  * - A terminal connected to the serial port. Can be bought used for cheap.
  13  *   (This is the method I am using.)
  14  * - Another machine connected over some kind of network.
  15  */
  16
  17 #include "config.h"
  18
  19 #ifndef X_DISPLAY_MISSING
  20
  21 #include "ts_xlib.h"
  22 #include "ts_xutil.h"
  23
  24 #ifdef HAVE_LIBXXSHM
  25 #include <sys/types.h>
  26 #include <sys/ipc.h>
  27 #include <sys/shm.h>
  28 #include "ts_xshm.h"
  29 #endif /* defined(HAVE_LIBXXSHM) */
  30
  31 #ifdef HAVE_LIBXXF86DGA
  32 #include "ts_xf86dga.h"
  33 #endif /* defined(HAVE_LIBXXF86DGA) */
  34
  35 #ifdef HAVE_LIBXXF86VM
  36 /* X is retarted and insists on declaring INT32, INT16 etc in Xmd.h,
  37    this is a crude hack to get around it */
  38 #define XMD_H
  39 typedef int INT32;
  40 #include "ts_xf86vmode.h"
  41 #endif /* defined(HAVE_LIBXXF86VM) */
  42
  43 #include "x11drv.h"
  44
  45 #include <unistd.h>
  46 #include <assert.h>
  47 #include <sys/signal.h>
  48 #include <fcntl.h>
  49 #include <string.h>
  50 #include <stdlib.h>
  51
  52 #include "winerror.h"
  53 #include "gdi.h"
  54 #include "heap.h"
  55 #include "dc.h"
  56 #include "win.h"
  57 #include "wine/exception.h"
  58 #include "ddraw.h"
  59 #include "d3d.h"
  60 #include "debug.h"
  61 #include "spy.h"
  62 #include "message.h"
  63 #include "options.h"
  64 #include "monitor.h"
  65
  66 /* This for all the enumeration and creation of D3D-related objects */
  67 #include "ddraw_private.h"
  68 #include "d3d_private.h"
  69
  70 DEFAULT_DEBUG_CHANNEL(ddraw)
  71
  72 /* Restore signal handlers overwritten by XF86DGA
  73  */
  74 #define RESTORE_SIGNALS
  75
  76 /* Get the number of bytes per pixel for a given surface */
  77 #define GET_BPP(desc) (desc.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8 ? \
  78                        1 :                                                                    \
  79                        desc.ddpfPixelFormat.x.dwRGBBitCount / 8)
  80
  81 /* Where do these GUIDs come from?  mkuuid.
  82  * They exist solely to distinguish between the targets Wine support,
  83  * and should be different than any other GUIDs in existence.
  84  */
  85 static GUID DGA_DirectDraw_GUID = { /* e2dcb020-dc60-11d1-8407-9714f5d50802 */
  86         0xe2dcb020,
  87         0xdc60,
  88         0x11d1,
  89         {0x84, 0x07, 0x97, 0x14, 0xf5, 0xd5, 0x08, 0x02}
  90 };
  91
  92 static GUID XLIB_DirectDraw_GUID = { /* 1574a740-dc61-11d1-8407-f7875a7d1879 */
  93     0x1574a740,
  94     0xdc61,
  95     0x11d1,
  96     {0x84, 0x07, 0xf7, 0x87, 0x5a, 0x7d, 0x18, 0x79}
  97 };
  98
  99 static struct ICOM_VTABLE(IDirectDrawSurface4)  dga_dds4vt, xlib_dds4vt;
 100 static struct ICOM_VTABLE(IDirectDraw)          dga_ddvt, xlib_ddvt;
 101 static struct ICOM_VTABLE(IDirectDraw2)         dga_dd2vt, xlib_dd2vt;
 102 static struct ICOM_VTABLE(IDirectDraw4)         dga_dd4vt, xlib_dd4vt;
 103 static struct ICOM_VTABLE(IDirectDrawClipper)   ddclipvt;
 104 static struct ICOM_VTABLE(IDirectDrawPalette) dga_ddpalvt, xlib_ddpalvt;
 105 static struct ICOM_VTABLE(IDirect3D)                    d3dvt;
 106 static struct ICOM_VTABLE(IDirect3D2)                   d3d2vt;
 107
 108 #ifdef HAVE_LIBXXF86VM
 109 static XF86VidModeModeInfo *orig_mode = NULL;
 110 #endif
 111
 112 #ifdef HAVE_LIBXXSHM
 113 static int XShmErrorFlag = 0;
 114 #endif
 115
 116 BOOL
 117 DDRAW_DGA_Available(void)
 118 {
 119 #ifdef HAVE_LIBXXF86DGA
 120         int evbase, evret, fd;
 121
 122         if (Options.noDGA)
 123           return 0;
 124
 125         /* You don't have to be root to use DGA extensions. Simply having access to /dev/mem will do the trick */
 126         /* This can be achieved by adding the user to the "kmem" group on Debian 2.x systems, don't know about */
 127         /* others. --stephenc */
 128         if ((fd = open("/dev/mem", O_RDWR)) != -1)
 129           close(fd);
 130
 131         return (fd != -1) && TSXF86DGAQueryExtension(display,&evbase,&evret);
 132 #else /* defined(HAVE_LIBXXF86DGA) */
 133         return 0;
 134 #endif /* defined(HAVE_LIBXXF86DGA) */
 135 }
 136
 137 /**********************************************************************/
 138
 139 typedef struct {
 140   LPVOID lpCallback;
 141   LPVOID lpContext;
 142 } DirectDrawEnumerateProcData;
 143
 144 /***********************************************************************
 145  *              DirectDrawEnumerateExA (DDRAW.*)
 146  */
 147 HRESULT WINAPI DirectDrawEnumerateExA(
 148   LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
 149 {
 150   TRACE(ddraw, "(%p,%p, %08lx)\n", lpCallback, lpContext, dwFlags);
 151
 152   if (TRACE_ON(ddraw)) {
 153     DUMP("  Flags : ");
 154     if (dwFlags & DDENUM_ATTACHEDSECONDARYDEVICES)
 155       DUMP("DDENUM_ATTACHEDSECONDARYDEVICES ");
 156     if (dwFlags & DDENUM_DETACHEDSECONDARYDEVICES)
 157       DUMP("DDENUM_DETACHEDSECONDARYDEVICES ");
 158     if (dwFlags & DDENUM_NONDISPLAYDEVICES)
 159       DUMP("DDENUM_NONDISPLAYDEVICES ");
 160     DUMP("\n");
 161   }
 162
 163   if (dwFlags & DDENUM_NONDISPLAYDEVICES) {
 164     /* For the moment, Wine does not support any 3D only accelerators */
 165     return DD_OK;
 166   }
 167
 168   if (DDRAW_DGA_Available()) {
 169     TRACE(ddraw, "Enumerating DGA interface\n");
 170     if (!lpCallback(&DGA_DirectDraw_GUID, "WINE with XFree86 DGA", "display", lpContext, 0))
 171       return DD_OK;
 172   }
 173
 174   TRACE(ddraw, "Enumerating Xlib interface\n");
 175   if (!lpCallback(&XLIB_DirectDraw_GUID, "WINE with Xlib", "display", lpContext, 0))
 176     return DD_OK;
 177
 178   TRACE(ddraw, "Enumerating Default interface\n");
 179   if (!lpCallback(NULL,"WINE (default)", "display", lpContext, 0))
 180     return DD_OK;
 181
 182   return DD_OK;
 183 }
 184
 185 /***********************************************************************
 186  *              DirectDrawEnumerateExW (DDRAW.*)
 187  */
 188
 189 static BOOL CALLBACK DirectDrawEnumerateExProcW(
 190         GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
 191         LPVOID lpContext, HMONITOR hm)
 192 {
 193   DirectDrawEnumerateProcData *pEPD =
 194     (DirectDrawEnumerateProcData *) lpContext;
 195   LPWSTR lpDriverDescriptionW =
 196     HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverDescription);
 197   LPWSTR lpDriverNameW =
 198     HEAP_strdupAtoW(GetProcessHeap(), 0, lpDriverName);
 199
 200   BOOL bResult = (*(LPDDENUMCALLBACKEXW *) pEPD->lpCallback)(
 201     lpGUID, lpDriverDescriptionW, lpDriverNameW, pEPD->lpContext, hm);
 202
 203   HeapFree(GetProcessHeap(), 0, lpDriverDescriptionW);
 204   HeapFree(GetProcessHeap(), 0, lpDriverNameW);
 205
 206   return bResult;
 207 }
 208
 209 /**********************************************************************/
 210
 211 HRESULT WINAPI DirectDrawEnumerateExW(
 212   LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
 213 {
 214   DirectDrawEnumerateProcData epd;
 215   epd.lpCallback = (LPVOID) lpCallback;
 216   epd.lpContext = lpContext;
 217
 218   return DirectDrawEnumerateExA(DirectDrawEnumerateExProcW,
 219                                   (LPVOID) &epd, 0);
 220 }
 221
 222 /***********************************************************************
 223  *              DirectDrawEnumerateA (DDRAW.*)
 224  */
 225
 226 static BOOL CALLBACK DirectDrawEnumerateProcA(
 227         GUID *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName,
 228         LPVOID lpContext, HMONITOR hm)
 229 {
 230   DirectDrawEnumerateProcData *pEPD =
 231     (DirectDrawEnumerateProcData *) lpContext;
 232
 233   return ((LPDDENUMCALLBACKA) pEPD->lpCallback)(
 234     lpGUID, lpDriverDescription, lpDriverName, pEPD->lpContext);
 235 }
 236
 237 /**********************************************************************/
 238
 239 HRESULT WINAPI DirectDrawEnumerateA(
 240   LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
 241 {
 242   DirectDrawEnumerateProcData epd;
 243   epd.lpCallback = (LPVOID) lpCallback;
 244   epd.lpContext = lpContext;
 245
 246   return DirectDrawEnumerateExA(DirectDrawEnumerateProcA,
 247                                 (LPVOID) &epd, 0);
 248 }
 249
 250 /***********************************************************************
 251  *              DirectDrawEnumerateW (DDRAW.*)
 252  */
 253
 254 static BOOL WINAPI DirectDrawEnumerateProcW(
 255   GUID *lpGUID, LPWSTR lpDriverDescription, LPWSTR lpDriverName,
 256   LPVOID lpContext, HMONITOR hm)
 257 {
 258   DirectDrawEnumerateProcData *pEPD =
 259     (DirectDrawEnumerateProcData *) lpContext;
 260
 261   return ((LPDDENUMCALLBACKW) pEPD->lpCallback)(
 262     lpGUID, lpDriverDescription, lpDriverName,
 263     pEPD->lpContext);
 264 }
 265
 266 /**********************************************************************/
 267
 268 HRESULT WINAPI DirectDrawEnumerateW(
 269   LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
 270 {
 271   DirectDrawEnumerateProcData epd;
 272   epd.lpCallback = (LPVOID) lpCallback;
 273   epd.lpContext = lpContext;
 274
 275   return DirectDrawEnumerateExW(DirectDrawEnumerateProcW,
 276                                 (LPVOID) &epd, 0);
 277 }
 278
 279 /***********************************************************************
 280  *              DSoundHelp (DDRAW.?)
 281  */
 282
 283 /* What is this doing here? */
 284 HRESULT WINAPI
 285 DSoundHelp(DWORD x,DWORD y,DWORD z) {
 286         FIXME(ddraw,"(0x%08lx,0x%08lx,0x%08lx),stub!\n",x,y,z);
 287         return 0;
 288 }
 289
 290 /******************************************************************************
 291  *              internal helper functions
 292  */
 293 static void _dump_DDBLTFX(DWORD flagmask) {
 294         int     i;
 295         const struct {
 296                 DWORD   mask;
 297                 char    *name;
 298         } flags[] = {
 299 #define FE(x) { x, #x},
 300                 FE(DDBLTFX_ARITHSTRETCHY)
 301                 FE(DDBLTFX_MIRRORLEFTRIGHT)
 302                 FE(DDBLTFX_MIRRORUPDOWN)
 303                 FE(DDBLTFX_NOTEARING)
 304                 FE(DDBLTFX_ROTATE180)
 305                 FE(DDBLTFX_ROTATE270)
 306                 FE(DDBLTFX_ROTATE90)
 307                 FE(DDBLTFX_ZBUFFERRANGE)
 308                 FE(DDBLTFX_ZBUFFERBASEDEST)
 309 #undef FE
 310         };
 311         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 312            if (flags[i].mask & flagmask) {
 313               DUMP("%s ",flags[i].name);
 314
 315            };
 316         DUMP("\n");
 317
 318 }
 319
 320 static void _dump_DDBLTFAST(DWORD flagmask) {
 321         int     i;
 322         const struct {
 323                 DWORD   mask;
 324                 char    *name;
 325         } flags[] = {
 326 #define FE(x) { x, #x},
 327                 FE(DDBLTFAST_NOCOLORKEY)
 328                 FE(DDBLTFAST_SRCCOLORKEY)
 329                 FE(DDBLTFAST_DESTCOLORKEY)
 330                 FE(DDBLTFAST_WAIT)
 331 #undef FE
 332         };
 333         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 334                 if (flags[i].mask & flagmask)
 335                         DUMP("%s ",flags[i].name);
 336         DUMP("\n");
 337 }
 338
 339 static void _dump_DDBLT(DWORD flagmask) {
 340         int     i;
 341         const struct {
 342                 DWORD   mask;
 343                 char    *name;
 344         } flags[] = {
 345 #define FE(x) { x, #x},
 346                 FE(DDBLT_ALPHADEST)
 347                 FE(DDBLT_ALPHADESTCONSTOVERRIDE)
 348                 FE(DDBLT_ALPHADESTNEG)
 349                 FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
 350                 FE(DDBLT_ALPHAEDGEBLEND)
 351                 FE(DDBLT_ALPHASRC)
 352                 FE(DDBLT_ALPHASRCCONSTOVERRIDE)
 353                 FE(DDBLT_ALPHASRCNEG)
 354                 FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
 355                 FE(DDBLT_ASYNC)
 356                 FE(DDBLT_COLORFILL)
 357                 FE(DDBLT_DDFX)
 358                 FE(DDBLT_DDROPS)
 359                 FE(DDBLT_KEYDEST)
 360                 FE(DDBLT_KEYDESTOVERRIDE)
 361                 FE(DDBLT_KEYSRC)
 362                 FE(DDBLT_KEYSRCOVERRIDE)
 363                 FE(DDBLT_ROP)
 364                 FE(DDBLT_ROTATIONANGLE)
 365                 FE(DDBLT_ZBUFFER)
 366                 FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
 367                 FE(DDBLT_ZBUFFERDESTOVERRIDE)
 368                 FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
 369                 FE(DDBLT_ZBUFFERSRCOVERRIDE)
 370                 FE(DDBLT_WAIT)
 371                 FE(DDBLT_DEPTHFILL)
 372 #undef FE
 373         };
 374         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 375                 if (flags[i].mask & flagmask)
 376                         DUMP("%s ",flags[i].name);
 377         DUMP("\n");
 378 }
 379
 380 static void _dump_DDSCAPS(void *in) {
 381         int     i;
 382         const struct {
 383                 DWORD   mask;
 384                 char    *name;
 385         } flags[] = {
 386 #define FE(x) { x, #x},
 387                 FE(DDSCAPS_RESERVED1)
 388                 FE(DDSCAPS_ALPHA)
 389                 FE(DDSCAPS_BACKBUFFER)
 390                 FE(DDSCAPS_COMPLEX)
 391                 FE(DDSCAPS_FLIP)
 392                 FE(DDSCAPS_FRONTBUFFER)
 393                 FE(DDSCAPS_OFFSCREENPLAIN)
 394                 FE(DDSCAPS_OVERLAY)
 395                 FE(DDSCAPS_PALETTE)
 396                 FE(DDSCAPS_PRIMARYSURFACE)
 397                 FE(DDSCAPS_PRIMARYSURFACELEFT)
 398                 FE(DDSCAPS_SYSTEMMEMORY)
 399                 FE(DDSCAPS_TEXTURE)
 400                 FE(DDSCAPS_3DDEVICE)
 401                 FE(DDSCAPS_VIDEOMEMORY)
 402                 FE(DDSCAPS_VISIBLE)
 403                 FE(DDSCAPS_WRITEONLY)
 404                 FE(DDSCAPS_ZBUFFER)
 405                 FE(DDSCAPS_OWNDC)
 406                 FE(DDSCAPS_LIVEVIDEO)
 407                 FE(DDSCAPS_HWCODEC)
 408                 FE(DDSCAPS_MODEX)
 409                 FE(DDSCAPS_MIPMAP)
 410                 FE(DDSCAPS_RESERVED2)
 411                 FE(DDSCAPS_ALLOCONLOAD)
 412                 FE(DDSCAPS_VIDEOPORT)
 413                 FE(DDSCAPS_LOCALVIDMEM)
 414                 FE(DDSCAPS_NONLOCALVIDMEM)
 415                 FE(DDSCAPS_STANDARDVGAMODE)
 416                 FE(DDSCAPS_OPTIMIZED)
 417 #undef FE
 418         };
 419         DWORD flagmask = *((DWORD *) in);
 420         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 421                 if (flags[i].mask & flagmask)
 422                         DUMP("%s ",flags[i].name);
 423 }
 424
 425 static void _dump_pixelformat_flag(DWORD flagmask) {
 426         int     i;
 427         const struct {
 428                 DWORD   mask;
 429                 char    *name;
 430         } flags[] = {
 431 #define FE(x) { x, #x},
 432                 FE(DDPF_ALPHAPIXELS)
 433                 FE(DDPF_ALPHA)
 434                 FE(DDPF_FOURCC)
 435                 FE(DDPF_PALETTEINDEXED4)
 436                 FE(DDPF_PALETTEINDEXEDTO8)
 437                 FE(DDPF_PALETTEINDEXED8)
 438                 FE(DDPF_RGB)
 439                 FE(DDPF_COMPRESSED)
 440                 FE(DDPF_RGBTOYUV)
 441                 FE(DDPF_YUV)
 442                 FE(DDPF_ZBUFFER)
 443                 FE(DDPF_PALETTEINDEXED1)
 444                 FE(DDPF_PALETTEINDEXED2)
 445                 FE(DDPF_ZPIXELS)
 446 #undef FE
 447         };
 448         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 449                 if (flags[i].mask & flagmask)
 450                         DUMP("%s ",flags[i].name);
 451 }
 452
 453 static void _dump_paletteformat(DWORD dwFlags) {
 454   int   i;
 455   const struct {
 456     DWORD       mask;
 457     char        *name;
 458   } flags[] = {
 459 #define FE(x) { x, #x},
 460     FE(DDPCAPS_4BIT)
 461     FE(DDPCAPS_8BITENTRIES)
 462     FE(DDPCAPS_8BIT)
 463     FE(DDPCAPS_INITIALIZE)
 464     FE(DDPCAPS_PRIMARYSURFACE)
 465     FE(DDPCAPS_PRIMARYSURFACELEFT)
 466     FE(DDPCAPS_ALLOW256)
 467     FE(DDPCAPS_VSYNC)
 468     FE(DDPCAPS_1BIT)
 469     FE(DDPCAPS_2BIT)
 470     FE(DDPCAPS_ALPHA)
 471 #undef FE
 472   };
 473   for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 474     if (flags[i].mask & dwFlags)
 475       DUMP("%s ",flags[i].name);
 476   DUMP("\n");
 477 }
 478
 479 static void _dump_pixelformat(void *in) {
 480   LPDDPIXELFORMAT pf = (LPDDPIXELFORMAT) in;
 481   char *cmd;
 482
 483   DUMP("( ");
 484   _dump_pixelformat_flag(pf->dwFlags);
 485   if (pf->dwFlags & DDPF_FOURCC) {
 486     DUMP(", dwFourCC : %ld", pf->dwFourCC);
 487   }
 488   if (pf->dwFlags & DDPF_RGB) {
 489     DUMP(", RGB bits: %ld, ", pf->x.dwRGBBitCount);
 490     switch (pf->x.dwRGBBitCount) {
 491     case 4:
 492       cmd = "%1lx";
 493       break;
 494     case 8:
 495       cmd = "%02lx";
 496       break;
 497     case 16:
 498       cmd = "%04lx";
 499       break;
 500     case 24:
 501       cmd = "%06lx";
 502       break;
 503     case 32:
 504       cmd = "%08lx";
 505       break;
 506     default:
 507       ERR(ddraw, "Unexpected bit depth !\n");
 508       cmd = "%d";
 509     }
 510     DUMP(" R "); DUMP(cmd, pf->y.dwRBitMask);
 511     DUMP(" G "); DUMP(cmd, pf->z.dwGBitMask);
 512     DUMP(" B "); DUMP(cmd, pf->xx.dwBBitMask);
 513     if (pf->dwFlags & DDPF_ALPHAPIXELS) {
 514       DUMP(" A "); DUMP(cmd, pf->xy.dwRGBAlphaBitMask);
 515     }
 516     if (pf->dwFlags & DDPF_ZPIXELS) {
 517       DUMP(" Z "); DUMP(cmd, pf->xy.dwRGBZBitMask);
 518 }
 519   }
 520   if (pf->dwFlags & DDPF_ZBUFFER) {
 521     DUMP(", Z bits : %ld", pf->x.dwZBufferBitDepth);
 522   }
 523   if (pf->dwFlags & DDPF_ALPHA) {
 524     DUMP(", Alpha bits : %ld", pf->x.dwAlphaBitDepth);
 525   }
 526   DUMP(")");
 527 }
 528
 529 static void _dump_colorkeyflag(DWORD ck) {
 530         int     i;
 531         const struct {
 532                 DWORD   mask;
 533                 char    *name;
 534         } flags[] = {
 535 #define FE(x) { x, #x},
 536           FE(DDCKEY_COLORSPACE)
 537           FE(DDCKEY_DESTBLT)
 538           FE(DDCKEY_DESTOVERLAY)
 539           FE(DDCKEY_SRCBLT)
 540           FE(DDCKEY_SRCOVERLAY)
 541 #undef FE
 542         };
 543         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 544                 if (flags[i].mask & ck)
 545                         DUMP("%s ",flags[i].name);
 546 }
 547
 548 static void _dump_DWORD(void *in) {
 549   DUMP("%ld", *((DWORD *) in));
 550 }
 551 static void _dump_PTR(void *in) {
 552   DUMP("%p", *((void **) in));
 553 }
 554 static void _dump_DDCOLORKEY(void *in) {
 555   DDCOLORKEY *ddck = (DDCOLORKEY *) in;
 556
 557   DUMP(" Low : %ld  - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
 558 }
 559
 560 static void _dump_surface_desc(DDSURFACEDESC *lpddsd) {
 561   int   i;
 562   const struct {
 563     DWORD       mask;
 564     char        *name;
 565     void (*func)(void *);
 566     void        *elt;
 567   } flags[] = {
 568 #define FE(x,func,elt) { x, #x, func, (void *) &(lpddsd->elt)}
 569     FE(DDSD_CAPS, _dump_DDSCAPS, ddsCaps),
 570     FE(DDSD_HEIGHT, _dump_DWORD, dwHeight),
 571     FE(DDSD_WIDTH, _dump_DWORD, dwWidth),
 572     FE(DDSD_PITCH, _dump_DWORD, lPitch),
 573     FE(DDSD_BACKBUFFERCOUNT, _dump_DWORD, dwBackBufferCount),
 574     FE(DDSD_ZBUFFERBITDEPTH, _dump_DWORD, x.dwZBufferBitDepth),
 575     FE(DDSD_ALPHABITDEPTH, _dump_DWORD, dwAlphaBitDepth),
 576     FE(DDSD_PIXELFORMAT, _dump_pixelformat, ddpfPixelFormat),
 577     FE(DDSD_CKDESTOVERLAY, _dump_DDCOLORKEY, ddckCKDestOverlay),
 578     FE(DDSD_CKDESTBLT, _dump_DDCOLORKEY, ddckCKDestBlt),
 579     FE(DDSD_CKSRCOVERLAY, _dump_DDCOLORKEY, ddckCKSrcOverlay),
 580     FE(DDSD_CKSRCBLT, _dump_DDCOLORKEY, ddckCKSrcBlt),
 581     FE(DDSD_MIPMAPCOUNT, _dump_DWORD, x.dwMipMapCount),
 582     FE(DDSD_REFRESHRATE, _dump_DWORD, x.dwRefreshRate),
 583     FE(DDSD_LINEARSIZE, _dump_DWORD, y.dwLinearSize),
 584     FE(DDSD_LPSURFACE, _dump_PTR, y.lpSurface)
 585 #undef FE
 586   };
 587   for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 588     if (flags[i].mask & lpddsd->dwFlags) {
 589       DUMP(" - %s : ",flags[i].name);
 590       flags[i].func(flags[i].elt);
 591         DUMP("\n");
 592 }
 593 }
 594
 595
 596 /******************************************************************************
 597  *              IDirectDrawSurface methods
 598  *
 599  * Since DDS3 and DDS2 are supersets of DDS, we implement DDS3 and let
 600  * DDS and DDS2 use those functions. (Function calls did not change (except
 601  * using different DirectDrawSurfaceX version), just added flags and functions)
 602  */
 603 static HRESULT WINAPI IDirectDrawSurface4Impl_Lock(
 604     LPDIRECTDRAWSURFACE4 iface,LPRECT lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE hnd
 605 ) {
 606         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 607         TRACE(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 608                 This,lprect,lpddsd,flags,(DWORD)hnd);
 609         if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
 610             WARN(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 611                          This,lprect,lpddsd,flags,(DWORD)hnd);
 612
 613         /* First, copy the Surface description */
 614         *lpddsd = This->s.surface_desc;
 615         TRACE(ddraw,"locked surface: height=%ld, width=%ld, pitch=%ld\n",
 616               lpddsd->dwHeight,lpddsd->dwWidth,lpddsd->lPitch);
 617
 618         /* If asked only for a part, change the surface pointer */
 619         if (lprect) {
 620                 FIXME(ddraw,"   lprect: %dx%d-%dx%d\n",
 621                         lprect->top,lprect->left,lprect->bottom,lprect->right
 622                 );
 623                 lpddsd->y.lpSurface = (LPVOID) ((char *) This->s.surface_desc.y.lpSurface +
 624                         (lprect->top*This->s.surface_desc.lPitch) +
 625                                                 (lprect->left*(This->s.surface_desc.ddpfPixelFormat.x.dwRGBBitCount / 8)));
 626         } else {
 627                 assert(This->s.surface_desc.y.lpSurface);
 628         }
 629         return DD_OK;
 630 }
 631
 632 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_Unlock(
 633         LPDIRECTDRAWSURFACE4 iface,LPVOID surface
 634 ) {
 635         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 636         TRACE(ddraw,"(%p)->Unlock(%p)\n",This,surface);
 637         return DD_OK;
 638 }
 639
 640 static void Xlib_copy_surface_on_screen(IDirectDrawSurface4Impl* This) {
 641   if (This->s.ddraw->d.pixel_convert != NULL)
 642     This->s.ddraw->d.pixel_convert(This->s.surface_desc.y.lpSurface,
 643                                    This->t.xlib.image->data,
 644                                    This->s.surface_desc.dwWidth,
 645                                    This->s.surface_desc.dwHeight,
 646                                    This->s.surface_desc.lPitch,
 647                                    This->s.palette);
 648
 649 #ifdef HAVE_LIBXXSHM
 650     if (This->s.ddraw->e.xlib.xshm_active)
 651       TSXShmPutImage(display,
 652                      This->s.ddraw->d.drawable,
 653                      DefaultGCOfScreen(X11DRV_GetXScreen()),
 654                      This->t.xlib.image,
 655                      0, 0, 0, 0,
 656                      This->t.xlib.image->width,
 657                      This->t.xlib.image->height,
 658                      False);
 659     else
 660 #endif
 661         TSXPutImage(            display,
 662                                 This->s.ddraw->d.drawable,
 663                                 DefaultGCOfScreen(X11DRV_GetXScreen()),
 664                                 This->t.xlib.image,
 665                                 0, 0, 0, 0,
 666                                 This->t.xlib.image->width,
 667                   This->t.xlib.image->height);
 668 }
 669
 670 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Unlock(
 671         LPDIRECTDRAWSURFACE4 iface,LPVOID surface)
 672 {
 673         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 674         TRACE(ddraw,"(%p)->Unlock(%p)\n",This,surface);
 675
 676         if (!This->s.ddraw->d.paintable)
 677                 return DD_OK;
 678
 679   /* Only redraw the screen when unlocking the buffer that is on screen */
 680         if ((This->t.xlib.image != NULL) &&
 681             (This->s.surface_desc.ddsCaps.dwCaps & DDSCAPS_VISIBLE)) {
 682           Xlib_copy_surface_on_screen(This);
 683
 684         if (This->s.palette && This->s.palette->cm)
 685                 TSXSetWindowColormap(display,This->s.ddraw->d.drawable,This->s.palette->cm);
 686         }
 687
 688         return DD_OK;
 689 }
 690
 691 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_Flip(
 692         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
 693 ) {
 694         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 695         IDirectDrawSurface4Impl* iflipto=(IDirectDrawSurface4Impl*)flipto;
 696 #ifdef HAVE_LIBXXF86DGA
 697         TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",This,iflipto,dwFlags);
 698         if (!iflipto) {
 699                 if (This->s.backbuffer)
 700                         iflipto = This->s.backbuffer;
 701                 else
 702                         iflipto = This;
 703         }
 704         TSXF86DGASetViewPort(display,DefaultScreen(display),0,iflipto->t.dga.fb_height);
 705
 706         if (iflipto->s.palette && iflipto->s.palette->cm) {
 707                 TSXF86DGAInstallColormap(display,DefaultScreen(display),iflipto->s.palette->cm);
 708         }
 709         while (!TSXF86DGAViewPortChanged(display,DefaultScreen(display),2)) {
 710         }
 711         if (iflipto!=This) {
 712                 int     tmp;
 713                 LPVOID  ptmp;
 714
 715                 tmp = This->t.dga.fb_height;
 716                 This->t.dga.fb_height = iflipto->t.dga.fb_height;
 717                 iflipto->t.dga.fb_height = tmp;
 718
 719                 ptmp = This->s.surface_desc.y.lpSurface;
 720                 This->s.surface_desc.y.lpSurface = iflipto->s.surface_desc.y.lpSurface;
 721                 iflipto->s.surface_desc.y.lpSurface = ptmp;
 722         }
 723         return DD_OK;
 724 #else /* defined(HAVE_LIBXXF86DGA) */
 725         return E_UNEXPECTED;
 726 #endif /* defined(HAVE_LIBXXF86DGA) */
 727 }
 728
 729 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_Flip(
 730         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 flipto,DWORD dwFlags
 731 ) {
 732         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 733         IDirectDrawSurface4Impl* iflipto=(IDirectDrawSurface4Impl*)flipto;
 734         TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",This,iflipto,dwFlags);
 735
 736 #ifdef HAVE_MESAGL
 737         if ((This->s.d3d_device != NULL) ||
 738             ((This->s.backbuffer != NULL) && (This->s.backbuffer->s.d3d_device != NULL))) {
 739           TRACE(ddraw," - OpenGL flip\n");
 740           ENTER_GL();
 741           glXSwapBuffers(display,
 742                          This->s.ddraw->d.drawable);
 743           LEAVE_GL();
 744
 745           return DD_OK;
 746         }
 747 #endif /* defined(HAVE_MESAGL) */
 748
 749         if (!This->s.ddraw->d.paintable)
 750                 return DD_OK;
 751
 752         if (!iflipto) {
 753                 if (This->s.backbuffer)
 754                         iflipto = This->s.backbuffer;
 755                 else
 756                         iflipto = This;
 757         }
 758
 759         Xlib_copy_surface_on_screen(iflipto);
 760
 761         if (iflipto->s.palette && iflipto->s.palette->cm) {
 762           TSXSetWindowColormap(display,This->s.ddraw->d.drawable,iflipto->s.palette->cm);
 763         }
 764         if (iflipto!=This) {
 765                 XImage *tmp;
 766                 LPVOID  *surf;
 767                 tmp = This->t.xlib.image;
 768                 This->t.xlib.image = iflipto->t.xlib.image;
 769                 iflipto->t.xlib.image = tmp;
 770                 surf = This->s.surface_desc.y.lpSurface;
 771                 This->s.surface_desc.y.lpSurface = iflipto->s.surface_desc.y.lpSurface;
 772                 iflipto->s.surface_desc.y.lpSurface = surf;
 773         }
 774         return DD_OK;
 775 }
 776
 777
 778 /* The IDirectDrawSurface4::SetPalette method attaches the specified
 779  * DirectDrawPalette object to a surface. The surface uses this palette for all
 780  * subsequent operations. The palette change takes place immediately.
 781  */
 782 static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_SetPalette(
 783         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWPALETTE pal
 784 ) {
 785         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 786         IDirectDrawPaletteImpl* ipal=(IDirectDrawPaletteImpl*)pal;
 787         int i;
 788         TRACE(ddraw,"(%p)->(%p)\n",This,ipal);
 789
 790         if (ipal == NULL) {
 791           if( This->s.palette != NULL )
 792             IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
 793           This->s.palette = ipal;
 794
 795           return DD_OK;
 796         }
 797
 798         if( !(ipal->cm) && (This->s.ddraw->d.screen_pixelformat.x.dwRGBBitCount<=8))
 799         {
 800                 ipal->cm = TSXCreateColormap(display,This->s.ddraw->d.drawable,
 801                                             DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
 802
 803                 if (!Options.managed)
 804                         TSXInstallColormap(display,ipal->cm);
 805
 806                 for (i=0;i<256;i++) {
 807                         XColor xc;
 808
 809                         xc.red = ipal->palents[i].peRed<<8;
 810                         xc.blue = ipal->palents[i].peBlue<<8;
 811                         xc.green = ipal->palents[i].peGreen<<8;
 812                         xc.flags = DoRed|DoBlue|DoGreen;
 813                         xc.pixel = i;
 814                         TSXStoreColor(display,ipal->cm,&xc);
 815                 }
 816                 TSXInstallColormap(display,ipal->cm);
 817         }
 818
 819         /* According to spec, we are only supposed to
 820          * AddRef if this is not the same palette.
 821          */
 822         if( This->s.palette != ipal )
 823         {
 824           if( ipal != NULL )
 825             IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
 826           if( This->s.palette != NULL )
 827             IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.palette );
 828           This->s.palette = ipal;
 829
 830           /* I think that we need to attach it to all backbuffers...*/
 831           if( This->s.backbuffer ) {
 832              if( This->s.backbuffer->s.palette )
 833                IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.backbuffer->s.palette );
 834              This->s.backbuffer->s.palette = ipal;
 835              if( ipal )
 836                 IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
 837            }
 838           /* Perform the refresh */
 839           TSXSetWindowColormap(display,This->s.ddraw->d.drawable,This->s.palette->cm);
 840         }
 841         return DD_OK;
 842 }
 843
 844 static HRESULT WINAPI DGA_IDirectDrawSurface4Impl_SetPalette(
 845         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWPALETTE pal
 846 ) {
 847         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 848         IDirectDrawPaletteImpl* ipal=(IDirectDrawPaletteImpl*)pal;
 849         TRACE(ddraw,"(%p)->(%p)\n",This,ipal);
 850 #ifdef HAVE_LIBXXF86DGA
 851         /* According to spec, we are only supposed to
 852          * AddRef if this is not the same palette.
 853          */
 854         if( This->s.palette != ipal )
 855         {
 856           if( ipal != NULL )
 857                 IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
 858           if( This->s.palette != NULL )
 859             IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.palette );
 860           This->s.palette = ipal;
 861
 862           /* I think that we need to attach it to all backbuffers...*/
 863           if( This->s.backbuffer ) {
 864              if( This->s.backbuffer->s.palette )
 865                IDirectDrawPalette_Release( (IDirectDrawPalette*)This->s.backbuffer->s.palette );
 866              This->s.backbuffer->s.palette = ipal;
 867              if ( ipal )
 868                IDirectDrawPalette_AddRef( (IDirectDrawPalette*)ipal );
 869           }
 870           TSXF86DGAInstallColormap(display,DefaultScreen(display),This->s.palette->cm);
 871         }
 872         return DD_OK;
 873 #else /* defined(HAVE_LIBXXF86DGA) */
 874         return E_UNEXPECTED;
 875 #endif /* defined(HAVE_LIBXXF86DGA) */
 876
 877
 878 }
 879
 880 static HRESULT _Blt_ColorFill(LPBYTE buf, int width, int height, int bpp, LONG lPitch, DWORD color)
 881 {
 882         int x, y;
 883         LPBYTE first;
 884
 885         /* Do first row */
 886
 887 #define COLORFILL_ROW(type) { \
 888         type *d = (type *) buf; \
 889         for (x = 0; x < width; x++) \
 890                 d[x] = (type) color; \
 891         break; \
 892 }
 893
 894         switch(bpp) {
 895         case 1: COLORFILL_ROW(BYTE)
 896         case 2: COLORFILL_ROW(WORD)
 897         case 4: COLORFILL_ROW(DWORD)
 898         default:
 899         FIXME(ddraw, "Stretched blit not implemented for bpp %d!\n", bpp*8);
 900         return DDERR_UNSUPPORTED;
 901         }
 902
 903 #undef COLORFILL_ROW
 904
 905         /* Now copy first row */
 906         first = buf;
 907         for (y = 1; y < height; y++) {
 908                 buf += lPitch;
 909                 memcpy(buf, first, width * bpp);
 910         }
 911
 912         return DD_OK;
 913 }
 914
 915 static HRESULT WINAPI IDirectDrawSurface4Impl_Blt(
 916         LPDIRECTDRAWSURFACE4 iface,LPRECT rdst,LPDIRECTDRAWSURFACE4 src,LPRECT rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
 917 ) {
 918         ICOM_THIS(IDirectDrawSurface4Impl,iface);
 919         RECT    xdst,xsrc;
 920         DDSURFACEDESC   ddesc,sdesc;
 921         HRESULT                 ret = DD_OK;
 922         int bpp, srcheight, srcwidth, dstheight, dstwidth, width;
 923         int x, y;
 924         LPBYTE dbuf, sbuf;
 925
 926         TRACE(ddraw,"(%p)->(%p,%p,%p,%08lx,%p)\n", This,rdst,src,rsrc,dwFlags,lpbltfx);
 927
 928         if (src) IDirectDrawSurface4_Lock(src, NULL, &sdesc, 0, 0);
 929         IDirectDrawSurface4_Lock(iface,NULL,&ddesc,0,0);
 930
 931         if (TRACE_ON(ddraw)) {
 932           if (rdst) TRACE(ddraw,"       destrect :%dx%d-%dx%d\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
 933           if (rsrc) TRACE(ddraw,"       srcrect  :%dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 934           TRACE(ddraw,"\tflags: ");
 935           _dump_DDBLT(dwFlags);
 936           if (dwFlags & DDBLT_DDFX) {
 937             TRACE(ddraw,"       blitfx: \n");
 938                 _dump_DDBLTFX(lpbltfx->dwDDFX);
 939           }
 940         }
 941
 942         if (rdst) {
 943                 memcpy(&xdst,rdst,sizeof(xdst));
 944         } else {
 945                 xdst.top        = 0;
 946                 xdst.bottom     = ddesc.dwHeight;
 947                 xdst.left       = 0;
 948                 xdst.right      = ddesc.dwWidth;
 949         }
 950
 951         if (rsrc) {
 952                 memcpy(&xsrc,rsrc,sizeof(xsrc));
 953         } else {
 954                 if (src) {
 955                 xsrc.top        = 0;
 956                 xsrc.bottom     = sdesc.dwHeight;
 957                 xsrc.left       = 0;
 958                 xsrc.right      = sdesc.dwWidth;
 959                 } else {
 960                     memset(&xsrc,0,sizeof(xsrc));
 961                 }
 962         }
 963
 964         bpp = GET_BPP(ddesc);
 965         srcheight = xsrc.bottom - xsrc.top;
 966         srcwidth = xsrc.right - xsrc.left;
 967         dstheight = xdst.bottom - xdst.top;
 968         dstwidth = xdst.right - xdst.left;
 969         width = (xdst.right - xdst.left) * bpp;
 970         dbuf = (BYTE *) ddesc.y.lpSurface + (xdst.top * ddesc.lPitch) + (xdst.left * bpp);
 971
 972         dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);/* FIXME: can't handle right now */
 973
 974         /* First, all the 'source-less' blits */
 975         if (dwFlags & DDBLT_COLORFILL) {
 976                 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp,
 977                                      ddesc.lPitch, lpbltfx->b.dwFillColor);
 978                 dwFlags &= ~DDBLT_COLORFILL;
 979                 }
 980
 981         if (dwFlags & DDBLT_DEPTHFILL) {
 982 #ifdef HAVE_MESAGL
 983           GLboolean ztest;
 984
 985           /* Clears the screen */
 986           TRACE(ddraw, "        Filling depth buffer with %ld\n", lpbltfx->b.dwFillDepth);
 987           glClearDepth(lpbltfx->b.dwFillDepth / 65535.0); /* We suppose a 16 bit Z Buffer */
 988           glGetBooleanv(GL_DEPTH_TEST, &ztest);
 989           glDepthMask(GL_TRUE); /* Enables Z writing to be sure to delete also the Z buffer */
 990           glClear(GL_DEPTH_BUFFER_BIT);
 991           glDepthMask(ztest);
 992
 993           dwFlags &= ~(DDBLT_DEPTHFILL);
 994 #endif /* defined(HAVE_MESAGL) */
 995         }
 996
 997         if (dwFlags & DDBLT_ROP) {
 998                 /* Catch some degenerate cases here */
 999                 switch(lpbltfx->dwROP) {
1000                         case BLACKNESS:
1001                                 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp, ddesc.lPitch, 0);
1002                                 break;
1003                         case 0xAA0029: /* No-op */
1004                                 break;
1005                         case WHITENESS:
1006                                 ret = _Blt_ColorFill(dbuf, dstwidth, dstheight, bpp, ddesc.lPitch, ~0);
1007                                 break;
1008                         default:
1009                                 FIXME(ddraw, "Unsupported raster op: %08lx  Pattern: %p\n", lpbltfx->dwROP, lpbltfx->b.lpDDSPattern);
1010                                 goto error;
1011             }
1012                 dwFlags &= ~DDBLT_ROP;
1013         }
1014
1015     if (dwFlags & DDBLT_DDROPS) {
1016                 FIXME(ddraw, "\tDdraw Raster Ops: %08lx  Pattern: %p\n", lpbltfx->dwDDROP, lpbltfx->b.lpDDSPattern);
1017         }
1018
1019         /* Now the 'with source' blits */
1020         if (src) {
1021                 LPBYTE sbase;
1022                 int sx, xinc, sy, yinc;
1023
1024                 sbase = (BYTE *) sdesc.y.lpSurface + (xsrc.top * sdesc.lPitch) + xsrc.left * bpp;
1025                 xinc = (srcwidth << 16) / dstwidth;
1026                 yinc = (srcheight << 16) / dstheight;
1027
1028                 if (!dwFlags) {
1029
1030                         /* No effects, we can cheat here */
1031                         if (dstwidth == srcwidth) {
1032                                 if (dstheight == srcheight) {
1033                                         /* No stretching in either direction.  This needs to be as fast as possible */
1034                                         sbuf = sbase;
1035                                         for (y = 0; y < dstheight; y++) {
1036                                                 memcpy(dbuf, sbuf, width);
1037                                                 sbuf += sdesc.lPitch;
1038                                                 dbuf += ddesc.lPitch;
1039                                         }
1040         } else {
1041                                         /* Stretching in Y direction only */
1042                                         for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1043                                                 sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1044                                                 memcpy(dbuf, sbuf, width);
1045                                                 dbuf += ddesc.lPitch;
1046                   }
1047                 }
1048                         } else {
1049                                 /* Stretching in X direction */
1050                                 int last_sy = -1;
1051                                 for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1052                                         sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1053
1054                                         if ((sy >> 16) == (last_sy >> 16)) {
1055                                                 /* Same as last row - copy already stretched row */
1056                                                 memcpy(dbuf, dbuf - ddesc.lPitch, width);
1057               } else {
1058
1059 #define STRETCH_ROW(type) { \
1060         type *s = (type *) sbuf, *d = (type *) dbuf; \
1061         for (x = sx = 0; x < dstwidth; x++, sx += xinc) \
1062                 d[x] = s[sx >> 16]; \
1063         break; \
1064 }
1065
1066                                                 switch(bpp) {
1067                                                         case 1: STRETCH_ROW(BYTE)
1068                                                         case 2: STRETCH_ROW(WORD)
1069                                                         case 4: STRETCH_ROW(DWORD)
1070                                                         default:
1071                                                                 FIXME(ddraw, "Stretched blit not implemented for bpp %d!\n", bpp*8);
1072                                                                 ret = DDERR_UNSUPPORTED;
1073                                                                 goto error;
1074                 }
1075
1076 #undef STRETCH_ROW
1077
1078               }
1079                                         last_sy = sy;
1080                                         dbuf += ddesc.lPitch;
1081               }
1082             }
1083                 } else if (dwFlags & (DDBLT_KEYSRC | DDBLT_KEYDEST)) {
1084                         DWORD keylow, keyhigh;
1085
1086             if (dwFlags & DDBLT_KEYSRC) {
1087                                 keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1088                                 keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1089                         } else {
1090                                 /* I'm not sure if this is correct */
1091                                 FIXME(ddraw, "DDBLT_KEYDEST not fully supported yet.\n");
1092                                 keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1093                                 keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1094                         }
1095
1096 #define COPYROW_COLORKEY(type) { \
1097         type *s = (type *) sbuf, *d = (type *) dbuf, tmp; \
1098         for (x = sx = 0; x < dstwidth; x++, sx += xinc) { \
1099                 tmp = s[sx >> 16]; \
1100                 if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1101         } \
1102         break; \
1103                 }
1104
1105                         for (y = sy = 0; y < dstheight; y++, sy += yinc) {
1106                                 sbuf = sbase + (sy >> 16) * sdesc.lPitch;
1107
1108                                 switch (bpp) {
1109                                         case 1: COPYROW_COLORKEY(BYTE)
1110                                         case 2: COPYROW_COLORKEY(WORD)
1111                                         case 4: COPYROW_COLORKEY(DWORD)
1112               default:
1113                                                 FIXME(ddraw, "%s color-keyed blit not implemented for bpp %d!\n",
1114                                                         (dwFlags & DDBLT_KEYSRC) ? "Source" : "Destination", bpp*8);
1115                                                 ret = DDERR_UNSUPPORTED;
1116                                                 goto error;
1117               }
1118                                 dbuf += ddesc.lPitch;
1119           }
1120
1121 #undef COPYROW_COLORKEY
1122
1123                         dwFlags &= ~(DDBLT_KEYSRC | DDBLT_KEYDEST);
1124
1125         }
1126         }
1127
1128 error:
1129
1130         if (dwFlags && FIXME_ON(ddraw)) {
1131           FIXME(ddraw,"\tUnsupported flags: ");
1132           _dump_DDBLT(dwFlags);
1133         }
1134
1135         IDirectDrawSurface4_Unlock(iface,ddesc.y.lpSurface);
1136         if (src) IDirectDrawSurface4_Unlock(src,sdesc.y.lpSurface);
1137
1138         return DD_OK;
1139 }
1140
1141 static HRESULT WINAPI IDirectDrawSurface4Impl_BltFast(
1142         LPDIRECTDRAWSURFACE4 iface,DWORD dstx,DWORD dsty,LPDIRECTDRAWSURFACE4 src,LPRECT rsrc,DWORD trans
1143 ) {
1144         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1145         int                             bpp, w, h, x, y;
1146         DDSURFACEDESC   ddesc,sdesc;
1147         HRESULT                 ret = DD_OK;
1148         LPBYTE                  sbuf, dbuf;
1149
1150
1151         if (TRACE_ON(ddraw)) {
1152             FIXME(ddraw,"(%p)->(%ld,%ld,%p,%p,%08lx)\n",
1153                     This,dstx,dsty,src,rsrc,trans
1154             );
1155             FIXME(ddraw,"       trans:");
1156             if (FIXME_ON(ddraw))
1157               _dump_DDBLTFAST(trans);
1158             FIXME(ddraw,"       srcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
1159         }
1160         /* We need to lock the surfaces, or we won't get refreshes when done. */
1161         IDirectDrawSurface4_Lock(src, NULL,&sdesc,DDLOCK_READONLY, 0);
1162         IDirectDrawSurface4_Lock(iface,NULL,&ddesc,DDLOCK_WRITEONLY,0);
1163
1164         bpp = GET_BPP(This->s.surface_desc);
1165         sbuf = (BYTE *) sdesc.y.lpSurface + (rsrc->top * sdesc.lPitch) + rsrc->left * bpp;
1166         dbuf = (BYTE *) ddesc.y.lpSurface + (dsty      * ddesc.lPitch) + dstx       * bpp;
1167
1168
1169         h=rsrc->bottom-rsrc->top;
1170         if (h>ddesc.dwHeight-dsty) h=ddesc.dwHeight-dsty;
1171         if (h>sdesc.dwHeight-rsrc->top) h=sdesc.dwHeight-rsrc->top;
1172         if (h<0) h=0;
1173
1174         w=rsrc->right-rsrc->left;
1175         if (w>ddesc.dwWidth-dstx) w=ddesc.dwWidth-dstx;
1176         if (w>sdesc.dwWidth-rsrc->left) w=sdesc.dwWidth-rsrc->left;
1177         if (w<0) w=0;
1178
1179         if (trans & (DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DESTCOLORKEY)) {
1180                 DWORD keylow, keyhigh;
1181                 if (trans & DDBLTFAST_SRCCOLORKEY) {
1182                         keylow  = sdesc.ddckCKSrcBlt.dwColorSpaceLowValue;
1183                         keyhigh = sdesc.ddckCKSrcBlt.dwColorSpaceHighValue;
1184                 } else {
1185                         /* I'm not sure if this is correct */
1186                         FIXME(ddraw, "DDBLTFAST_DESTCOLORKEY not fully supported yet.\n");
1187                         keylow  = ddesc.ddckCKDestBlt.dwColorSpaceLowValue;
1188                         keyhigh = ddesc.ddckCKDestBlt.dwColorSpaceHighValue;
1189                 }
1190
1191 #define COPYBOX_COLORKEY(type) { \
1192         type *d = (type *)dbuf, *s = (type *)sbuf, tmp; \
1193         s = (type *) ((BYTE *) sdesc.y.lpSurface + (rsrc->top * sdesc.lPitch) + rsrc->left * bpp); \
1194         d = (type *) ((BYTE *) ddesc.y.lpSurface + (dsty * ddesc.lPitch) + dstx * bpp); \
1195         for (y = 0; y < h; y++) { \
1196                 for (x = 0; x < w; x++) { \
1197                         tmp = s[x]; \
1198                         if (tmp < keylow || tmp > keyhigh) d[x] = tmp; \
1199                 } \
1200                 (LPBYTE)s += sdesc.lPitch; \
1201                 (LPBYTE)d += ddesc.lPitch; \
1202         } \
1203         break; \
1204 }
1205
1206                 switch (bpp) {
1207                         case 1: COPYBOX_COLORKEY(BYTE)
1208                         case 2: COPYBOX_COLORKEY(WORD)
1209                         case 4: COPYBOX_COLORKEY(DWORD)
1210                         default:
1211                                 FIXME(ddraw, "Source color key blitting not supported for bpp %d\n", bpp*8);
1212                                 ret = DDERR_UNSUPPORTED;
1213                                 goto error;
1214         }
1215
1216 #undef COPYBOX_COLORKEY
1217
1218         } else {
1219                 int width = w * bpp;
1220
1221                 for (y = 0; y < h; y++) {
1222                         memcpy(dbuf, sbuf, width);
1223                         sbuf += sdesc.lPitch;
1224                         dbuf += ddesc.lPitch;
1225                 }
1226         }
1227
1228 error:
1229
1230         IDirectDrawSurface4_Unlock(iface,ddesc.y.lpSurface);
1231         IDirectDrawSurface4_Unlock(src,sdesc.y.lpSurface);
1232         return ret;
1233 }
1234
1235 static HRESULT WINAPI IDirectDrawSurface4Impl_BltBatch(
1236         LPDIRECTDRAWSURFACE4 iface,LPDDBLTBATCH ddbltbatch,DWORD x,DWORD y
1237 ) {
1238         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1239         FIXME(ddraw,"(%p)->BltBatch(%p,%08lx,%08lx),stub!\n",
1240                 This,ddbltbatch,x,y
1241         );
1242         return DD_OK;
1243 }
1244
1245 static HRESULT WINAPI IDirectDrawSurface4Impl_GetCaps(
1246         LPDIRECTDRAWSURFACE4 iface,LPDDSCAPS caps
1247 ) {
1248         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1249         TRACE(ddraw,"(%p)->GetCaps(%p)\n",This,caps);
1250         caps->dwCaps = DDSCAPS_PALETTE; /* probably more */
1251         return DD_OK;
1252 }
1253
1254 static HRESULT WINAPI IDirectDrawSurface4Impl_GetSurfaceDesc(
1255         LPDIRECTDRAWSURFACE4 iface,LPDDSURFACEDESC ddsd
1256 ) {
1257         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1258                 TRACE(ddraw, "(%p)->GetSurfaceDesc(%p)\n",
1259                              This,ddsd);
1260
1261   /* Simply copy the surface description stored in the object */
1262   *ddsd = This->s.surface_desc;
1263
1264   if (TRACE_ON(ddraw)) {
1265     _dump_surface_desc(ddsd);
1266         }
1267
1268         return DD_OK;
1269 }
1270
1271 static ULONG WINAPI IDirectDrawSurface4Impl_AddRef(LPDIRECTDRAWSURFACE4 iface) {
1272         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1273         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
1274
1275         return ++(This->ref);
1276 }
1277
1278 static ULONG WINAPI DGA_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
1279         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1280         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
1281
1282 #ifdef HAVE_LIBXXF86DGA
1283         if (!--(This->ref)) {
1284                 IDirectDraw2_Release((IDirectDraw2*)This->s.ddraw);
1285                 /* clear out of surface list */
1286                 if (This->t.dga.fb_height == -1) {
1287                         HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1288                 } else {
1289                         This->s.ddraw->e.dga.vpmask &= ~(1<<(This->t.dga.fb_height/This->s.ddraw->e.dga.fb_height));
1290                 }
1291
1292                 /* Free the backbuffer */
1293                 if (This->s.backbuffer)
1294                         IDirectDrawSurface4_Release((IDirectDrawSurface4*)This->s.backbuffer);
1295
1296                 /* Free the DIBSection (if any) */
1297                 if (This->s.hdc != 0) {
1298                   SelectObject(This->s.hdc, This->s.holdbitmap);
1299                   DeleteDC(This->s.hdc);
1300                   DeleteObject(This->s.DIBsection);
1301                 }
1302
1303                 HeapFree(GetProcessHeap(),0,This);
1304                 return 0;
1305         }
1306 #endif /* defined(HAVE_LIBXXF86DGA) */
1307         return This->ref;
1308 }
1309
1310 static ULONG WINAPI Xlib_IDirectDrawSurface4Impl_Release(LPDIRECTDRAWSURFACE4 iface) {
1311         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1312         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
1313
1314         if (!--(This->ref)) {
1315                 IDirectDraw2_Release((IDirectDraw2*)This->s.ddraw);
1316
1317                 if( This->s.backbuffer )
1318                   IDirectDrawSurface4_Release((IDirectDrawSurface4*)This->s.backbuffer);
1319
1320     if (This->t.xlib.image != NULL) {
1321       if (This->s.ddraw->d.pixel_convert != NULL) {
1322         /* In pixel conversion mode, there are two buffers to release... */
1323         HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1324
1325 #ifdef HAVE_LIBXXSHM
1326         if (This->s.ddraw->e.xlib.xshm_active) {
1327           TSXShmDetach(display, &(This->t.xlib.shminfo));
1328           TSXDestroyImage(This->t.xlib.image);
1329           shmdt(This->t.xlib.shminfo.shmaddr);
1330         } else {
1331 #endif
1332           HeapFree(GetProcessHeap(),0,This->t.xlib.image->data);
1333           This->t.xlib.image->data = NULL;
1334           TSXDestroyImage(This->t.xlib.image);
1335 #ifdef HAVE_LIBXXSHM
1336         }
1337 #endif
1338
1339       } else {
1340                 This->t.xlib.image->data = NULL;
1341
1342 #ifdef HAVE_LIBXXSHM
1343       if (This->s.ddraw->e.xlib.xshm_active) {
1344         TSXShmDetach(display, &(This->t.xlib.shminfo));
1345                 TSXDestroyImage(This->t.xlib.image);
1346         shmdt(This->t.xlib.shminfo.shmaddr);
1347       } else {
1348 #endif
1349               HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1350         TSXDestroyImage(This->t.xlib.image);
1351 #ifdef HAVE_LIBXXSHM
1352       }
1353 #endif
1354       }
1355
1356                 This->t.xlib.image = 0;
1357     } else {
1358             HeapFree(GetProcessHeap(),0,This->s.surface_desc.y.lpSurface);
1359     }
1360
1361                 if (This->s.palette)
1362                         IDirectDrawPalette_Release((IDirectDrawPalette*)This->s.palette);
1363
1364                 /* Free the DIBSection (if any) */
1365                 if (This->s.hdc != 0) {
1366                   SelectObject(This->s.hdc, This->s.holdbitmap);
1367                   DeleteDC(This->s.hdc);
1368                   DeleteObject(This->s.DIBsection);
1369                 }
1370
1371                 HeapFree(GetProcessHeap(),0,This);
1372                 return 0;
1373         }
1374
1375         return This->ref;
1376 }
1377
1378 static HRESULT WINAPI IDirectDrawSurface4Impl_GetAttachedSurface(
1379         LPDIRECTDRAWSURFACE4 iface,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE4 *lpdsf
1380 ) {
1381         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1382         TRACE(ddraw, "(%p)->GetAttachedSurface(%p,%p)\n",
1383                      This, lpddsd, lpdsf);
1384
1385         if (TRACE_ON(ddraw)) {
1386                 TRACE(ddraw,"   caps ");
1387                 _dump_DDSCAPS((void *) &(lpddsd->dwCaps));
1388                 DUMP("\n");
1389         }
1390
1391         if (!(lpddsd->dwCaps & DDSCAPS_BACKBUFFER)) {
1392                 FIXME(ddraw,"whoops, can only handle backbuffers for now\n");
1393                 return E_FAIL;
1394         }
1395
1396         /* FIXME: should handle more than one backbuffer */
1397         *lpdsf = (LPDIRECTDRAWSURFACE4)This->s.backbuffer;
1398
1399         if( This->s.backbuffer )
1400           IDirectDrawSurface4_AddRef( (IDirectDrawSurface4*)This->s.backbuffer );
1401
1402         return DD_OK;
1403 }
1404
1405 static HRESULT WINAPI IDirectDrawSurface4Impl_Initialize(
1406         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAW ddraw,LPDDSURFACEDESC lpdsfd
1407 ) {
1408         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1409         TRACE(ddraw,"(%p)->(%p, %p)\n",This,ddraw,lpdsfd);
1410
1411         return DDERR_ALREADYINITIALIZED;
1412 }
1413
1414 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPixelFormat(
1415         LPDIRECTDRAWSURFACE4 iface,LPDDPIXELFORMAT pf
1416 ) {
1417         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1418         TRACE(ddraw,"(%p)->(%p)\n",This,pf);
1419
1420         *pf = This->s.surface_desc.ddpfPixelFormat;
1421
1422         if (TRACE_ON(ddraw)) {
1423         _dump_pixelformat(pf);
1424           DUMP("\n");
1425         }
1426
1427         return DD_OK;
1428 }
1429
1430 static HRESULT WINAPI IDirectDrawSurface4Impl_GetBltStatus(LPDIRECTDRAWSURFACE4 iface,DWORD dwFlags) {
1431         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1432         FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",This,dwFlags);
1433         return DD_OK;
1434 }
1435
1436 static HRESULT WINAPI IDirectDrawSurface4Impl_GetOverlayPosition(
1437         LPDIRECTDRAWSURFACE4 iface,LPLONG x1,LPLONG x2
1438 ) {
1439         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1440         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",This,x1,x2);
1441         return DD_OK;
1442 }
1443
1444 static HRESULT WINAPI IDirectDrawSurface4Impl_SetClipper(
1445         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWCLIPPER clipper
1446 ) {
1447         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1448         FIXME(ddraw,"(%p)->(%p),stub!\n",This,clipper);
1449         return DD_OK;
1450 }
1451
1452 static HRESULT WINAPI IDirectDrawSurface4Impl_AddAttachedSurface(
1453         LPDIRECTDRAWSURFACE4 iface,LPDIRECTDRAWSURFACE4 surf
1454 ) {
1455         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1456         FIXME(ddraw,"(%p)->(%p),stub!\n",This,surf);
1457
1458         IDirectDrawSurface4_AddRef(iface);
1459
1460         /* This hack will be enough for the moment */
1461         if (This->s.backbuffer == NULL)
1462           This->s.backbuffer = (IDirectDrawSurface4Impl*)surf;
1463         return DD_OK;
1464 }
1465
1466 static HRESULT WINAPI IDirectDrawSurface4Impl_GetDC(LPDIRECTDRAWSURFACE4 iface,HDC* lphdc) {
1467         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1468   DDSURFACEDESC desc;
1469   BITMAPINFO *b_info;
1470   UINT usage;
1471
1472         FIXME(ddraw,"(%p)->GetDC(%p)\n",This,lphdc);
1473
1474   /* Creates a DIB Section of the same size / format as the surface */
1475   IDirectDrawSurface4_Lock(iface,NULL,&desc,0,0);
1476
1477   if (This->s.hdc == 0) {
1478     switch (desc.ddpfPixelFormat.x.dwRGBBitCount) {
1479     case 16:
1480     case 32:
1481 #if 0 /* This should be filled if Wine's DIBSection did understand BI_BITFIELDS */
1482       b_info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
1483       break;
1484 #endif
1485
1486     case 24:
1487       b_info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER));
1488       break;
1489
1490     default:
1491       b_info = (BITMAPINFO *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1492                                         sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (2 << desc.ddpfPixelFormat.x.dwRGBBitCount));
1493       break;
1494     }
1495
1496     b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1497     b_info->bmiHeader.biWidth = desc.dwWidth;
1498     b_info->bmiHeader.biHeight = desc.dwHeight;
1499     b_info->bmiHeader.biPlanes = 1;
1500     b_info->bmiHeader.biBitCount = desc.ddpfPixelFormat.x.dwRGBBitCount;
1501 #if 0
1502     if ((desc.ddpfPixelFormat.x.dwRGBBitCount != 16) &&
1503         (desc.ddpfPixelFormat.x.dwRGBBitCount != 32))
1504 #endif
1505       b_info->bmiHeader.biCompression = BI_RGB;
1506 #if 0
1507     else
1508       b_info->bmiHeader.biCompression = BI_BITFIELDS;
1509 #endif
1510     b_info->bmiHeader.biSizeImage = (desc.ddpfPixelFormat.x.dwRGBBitCount / 8) * desc.dwWidth * desc.dwHeight;
1511     b_info->bmiHeader.biXPelsPerMeter = 0;
1512     b_info->bmiHeader.biYPelsPerMeter = 0;
1513     b_info->bmiHeader.biClrUsed = 0;
1514     b_info->bmiHeader.biClrImportant = 0;
1515
1516     switch (desc.ddpfPixelFormat.x.dwRGBBitCount) {
1517     case 16:
1518     case 32:
1519 #if 0
1520       {
1521         DWORD *masks = (DWORD *) &(b_info->bmiColors);
1522
1523         usage = 0;
1524         masks[0] = desc.ddpfPixelFormat.y.dwRBitMask;
1525         masks[1] = desc.ddpfPixelFormat.z.dwGBitMask;
1526         masks[2] = desc.ddpfPixelFormat.xx.dwBBitMask;
1527       } break;
1528 #endif
1529
1530     case 24:
1531       /* Nothing to do */
1532       usage = DIB_RGB_COLORS;
1533       break;
1534
1535     default: {
1536       int i;
1537
1538       /* Fill the palette */
1539       usage = DIB_RGB_COLORS;
1540
1541       if (This->s.palette == NULL) {
1542         ERR(ddraw, "Bad palette !!!\n");
1543       } else {
1544         RGBQUAD *rgb = (RGBQUAD *) &(b_info->bmiColors);
1545         PALETTEENTRY *pent = (PALETTEENTRY *) &(This->s.palette->palents);
1546
1547         for (i = 0; i < (2 << desc.ddpfPixelFormat.x.dwRGBBitCount); i++) {
1548           rgb[i].rgbBlue = pent[i].peBlue;
1549           rgb[i].rgbRed = pent[i].peRed;
1550           rgb[i].rgbGreen = pent[i].peGreen;
1551         }
1552       }
1553     } break;
1554     }
1555
1556     This->s.DIBsection = CreateDIBSection(BeginPaint(This->s.ddraw->d.mainWindow,&This->s.ddraw->d.ps),
1557                                           b_info,
1558                                           usage,
1559                                           &(This->s.bitmap_data),
1560                                           NULL,
1561                                           0);
1562     EndPaint(This->s.ddraw->d.mainWindow,&This->s.ddraw->d.ps);
1563     TRACE(ddraw, "DIBSection at : %p\n", This->s.bitmap_data);
1564
1565     /* b_info is not useful anymore */
1566     HeapFree(GetProcessHeap(), 0, b_info);
1567
1568     /* Create the DC */
1569     This->s.hdc = CreateCompatibleDC(0);
1570     This->s.holdbitmap = SelectObject(This->s.hdc, This->s.DIBsection);
1571   }
1572
1573   /* Copy our surface in the DIB section */
1574   if ((GET_BPP(desc) * desc.dwWidth) == desc.lPitch) {
1575     memcpy(This->s.bitmap_data, desc.y.lpSurface, desc.lPitch * desc.dwHeight);
1576   } else {
1577     /* TODO */
1578     FIXME(ddraw, "This case has to be done :/\n");
1579   }
1580
1581   TRACE(ddraw, "HDC : %08lx\n", (DWORD) This->s.hdc);
1582   *lphdc = This->s.hdc;
1583
1584         return DD_OK;
1585 }
1586
1587 static HRESULT WINAPI IDirectDrawSurface4Impl_ReleaseDC(LPDIRECTDRAWSURFACE4 iface,HDC hdc) {
1588         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1589
1590         FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",This,(long)hdc);
1591
1592   TRACE(ddraw, "Copying DIBSection at : %p\n", This->s.bitmap_data);
1593
1594   /* Copy the DIB section to our surface */
1595   if ((GET_BPP(This->s.surface_desc) * This->s.surface_desc.dwWidth) == This->s.surface_desc.lPitch) {
1596     memcpy(This->s.surface_desc.y.lpSurface, This->s.bitmap_data, This->s.surface_desc.lPitch * This->s.surface_desc.dwHeight);
1597   } else {
1598     /* TODO */
1599     FIXME(ddraw, "This case has to be done :/\n");
1600         }
1601
1602   /* Unlock the surface */
1603   IDirectDrawSurface4_Unlock(iface,This->s.surface_desc.y.lpSurface);
1604
1605         return DD_OK;
1606
1607 }
1608
1609 static HRESULT WINAPI IDirectDrawSurface4Impl_QueryInterface(LPDIRECTDRAWSURFACE4 iface,REFIID refiid,LPVOID *obj) {
1610         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1611         char    xrefiid[50];
1612
1613         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1614         TRACE(ddraw,"(%p)->(%s,%p)\n",This,xrefiid,obj);
1615
1616         /* All DirectDrawSurface versions (1, 2, 3 and 4) use
1617          * the same interface. And IUnknown does that too of course.
1618          */
1619         if (    !memcmp(&IID_IDirectDrawSurface4,refiid,sizeof(IID))    ||
1620                 !memcmp(&IID_IDirectDrawSurface3,refiid,sizeof(IID))    ||
1621                 !memcmp(&IID_IDirectDrawSurface2,refiid,sizeof(IID))    ||
1622                 !memcmp(&IID_IDirectDrawSurface,refiid,sizeof(IID))     ||
1623                 !memcmp(&IID_IUnknown,refiid,sizeof(IID))
1624         ) {
1625                 *obj = This;
1626                 IDirectDrawSurface4_AddRef(iface);
1627
1628                 TRACE(ddraw, "  Creating IDirectDrawSurface interface (%p)\n", *obj);
1629
1630                 return S_OK;
1631         }
1632         else if (!memcmp(&IID_IDirect3DTexture2,refiid,sizeof(IID)))
1633           {
1634             /* Texture interface */
1635             *obj = d3dtexture2_create(This);
1636             IDirectDrawSurface4_AddRef(iface);
1637
1638             TRACE(ddraw, "  Creating IDirect3DTexture2 interface (%p)\n", *obj);
1639
1640             return S_OK;
1641           }
1642         else if (!memcmp(&IID_IDirect3DTexture,refiid,sizeof(IID)))
1643           {
1644             /* Texture interface */
1645             *obj = d3dtexture_create(This);
1646             IDirectDrawSurface4_AddRef(iface);
1647
1648             TRACE(ddraw, "  Creating IDirect3DTexture interface (%p)\n", *obj);
1649
1650             return S_OK;
1651           }
1652         else if (is_OpenGL_dx3(refiid, (IDirectDrawSurfaceImpl*)This, (IDirect3DDeviceImpl**) obj))
1653           {
1654             /* It is the OpenGL Direct3D Device */
1655             IDirectDrawSurface4_AddRef(iface);
1656
1657             TRACE(ddraw, "  Creating IDirect3DDevice interface (%p)\n", *obj);
1658
1659                 return S_OK;
1660         }
1661
1662         FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",This,xrefiid);
1663         return OLE_E_ENUM_NOMORE;
1664 }
1665
1666 static HRESULT WINAPI IDirectDrawSurface4Impl_IsLost(LPDIRECTDRAWSURFACE4 iface) {
1667         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1668         TRACE(ddraw,"(%p)->(), stub!\n",This);
1669         return DD_OK; /* hmm */
1670 }
1671
1672 static HRESULT WINAPI IDirectDrawSurface4Impl_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE4 iface,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
1673         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1674         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",This,context,esfcb);
1675
1676         /* For the moment, only enumerating the back buffer */
1677         if (This->s.backbuffer != NULL) {
1678           TRACE(ddraw, "Enumerating back-buffer (%p)\n", This->s.backbuffer);
1679           if (esfcb((LPDIRECTDRAWSURFACE) This->s.backbuffer, &(This->s.backbuffer->s.surface_desc), context) == DDENUMRET_CANCEL)
1680             return DD_OK;
1681         }
1682
1683         return DD_OK;
1684 }
1685
1686 static HRESULT WINAPI IDirectDrawSurface4Impl_Restore(LPDIRECTDRAWSURFACE4 iface) {
1687         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1688         FIXME(ddraw,"(%p)->(),stub!\n",This);
1689         return DD_OK;
1690 }
1691
1692 static HRESULT WINAPI IDirectDrawSurface4Impl_SetColorKey(
1693         LPDIRECTDRAWSURFACE4 iface, DWORD dwFlags, LPDDCOLORKEY ckey )
1694 {
1695         ICOM_THIS(IDirectDrawSurface4Impl,iface);
1696         TRACE(ddraw,"(%p)->(0x%08lx,%p)\n",This,dwFlags,ckey);
1697         if (TRACE_ON(ddraw)) {
1698           _dump_colorkeyflag(dwFlags);
1699           DUMP(" : ");
1700           _dump_DDCOLORKEY((void *) ckey);
1701           DUMP("\n");
1702         }
1703
1704         /* If this surface was loaded as a texture, call also the texture
1705            SetColorKey callback */
1706         if (This->s.texture) {
1707           This->s.SetColorKey_cb(This->s.texture, dwFlags, ckey);
1708         }
1709
1710         if( dwFlags & DDCKEY_SRCBLT )
1711         {
1712            dwFlags &= ~DDCKEY_SRCBLT;
1713            This->s.surface_desc.dwFlags |= DDSD_CKSRCBLT;
1714            memcpy( &(This->s.surface_desc.ddckCKSrcBlt), ckey, sizeof( *ckey ) );
1715         }
1716
1717         if( dwFlags & DDCKEY_DESTBLT )
1718         {
1719            dwFlags &= ~DDCKEY_DESTBLT;
1720            This->s.surface_desc.dwFlags |= DDSD_CKDESTBLT;
1721            memcpy( &(This->s.surface_desc.ddckCKDestBlt), ckey, sizeof( *ckey ) );
1722         }
1723
1724         if( dwFlags & DDCKEY_SRCOVERLAY )
1725         {
1726            dwFlags &= ~DDCKEY_SRCOVERLAY;
1727            This->s.surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
1728            memcpy( &(This->s.surface_desc.ddckCKSrcOverlay), ckey, sizeof( *ckey ) );
1729         }
1730
1731         if( dwFlags & DDCKEY_DESTOVERLAY )
1732         {
1733            dwFlags &= ~DDCKEY_DESTOVERLAY;
1734            This->s.surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
1735            memcpy( &(This->s.surface_desc.ddckCKDestOverlay), ckey, sizeof( *ckey ) );
1736         }
1737
1738         if( dwFlags )
1739         {
1740           FIXME( ddraw, "unhandled dwFlags: 0x%08lx\n", dwFlags );
1741         }
1742
1743         return DD_OK;
1744
1745 }
1746
1747 static HRESULT WINAPI IDirectDrawSurface4Impl_AddOverlayDirtyRect(
1748         LPDIRECTDRAWSURFACE4 iface,
1749         LPRECT lpRect )
1750 {
1751   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1752   FIXME(ddraw,"(%p)->(%p),stub!\n",This,lpRect);
1753
1754   return DD_OK;
1755 }
1756
1757 static HRESULT WINAPI IDirectDrawSurface4Impl_DeleteAttachedSurface(
1758         LPDIRECTDRAWSURFACE4 iface,
1759         DWORD dwFlags,
1760         LPDIRECTDRAWSURFACE4 lpDDSAttachedSurface )
1761 {
1762   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1763   FIXME(ddraw,"(%p)->(0x%08lx,%p),stub!\n",This,dwFlags,lpDDSAttachedSurface);
1764
1765   return DD_OK;
1766 }
1767
1768 static HRESULT WINAPI IDirectDrawSurface4Impl_EnumOverlayZOrders(
1769         LPDIRECTDRAWSURFACE4 iface,
1770         DWORD dwFlags,
1771         LPVOID lpContext,
1772         LPDDENUMSURFACESCALLBACK lpfnCallback )
1773 {
1774   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1775   FIXME(ddraw,"(%p)->(0x%08lx,%p,%p),stub!\n", This,dwFlags,
1776           lpContext, lpfnCallback );
1777
1778   return DD_OK;
1779 }
1780
1781 static HRESULT WINAPI IDirectDrawSurface4Impl_GetClipper(
1782         LPDIRECTDRAWSURFACE4 iface,
1783         LPDIRECTDRAWCLIPPER* lplpDDClipper )
1784 {
1785   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1786   FIXME(ddraw,"(%p)->(%p),stub!\n", This, lplpDDClipper);
1787
1788   return DD_OK;
1789 }
1790
1791 static HRESULT WINAPI IDirectDrawSurface4Impl_GetColorKey(
1792         LPDIRECTDRAWSURFACE4 iface,
1793         DWORD dwFlags,
1794         LPDDCOLORKEY lpDDColorKey )
1795 {
1796   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1797   TRACE(ddraw,"(%p)->(0x%08lx,%p)\n", This, dwFlags, lpDDColorKey);
1798
1799   if( dwFlags & DDCKEY_SRCBLT )  {
1800      dwFlags &= ~DDCKEY_SRCBLT;
1801      memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKSrcBlt), sizeof( *lpDDColorKey ) );
1802   }
1803
1804   if( dwFlags & DDCKEY_DESTBLT )
1805   {
1806     dwFlags &= ~DDCKEY_DESTBLT;
1807     memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKDestBlt), sizeof( *lpDDColorKey ) );
1808   }
1809
1810   if( dwFlags & DDCKEY_SRCOVERLAY )
1811   {
1812     dwFlags &= ~DDCKEY_SRCOVERLAY;
1813     memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKSrcOverlay), sizeof( *lpDDColorKey ) );
1814   }
1815
1816   if( dwFlags & DDCKEY_DESTOVERLAY )
1817   {
1818     dwFlags &= ~DDCKEY_DESTOVERLAY;
1819     memcpy( lpDDColorKey, &(This->s.surface_desc.ddckCKDestOverlay), sizeof( *lpDDColorKey ) );
1820   }
1821
1822   if( dwFlags )
1823   {
1824     FIXME( ddraw, "unhandled dwFlags: 0x%08lx\n", dwFlags );
1825   }
1826
1827   return DD_OK;
1828 }
1829
1830 static HRESULT WINAPI IDirectDrawSurface4Impl_GetFlipStatus(
1831         LPDIRECTDRAWSURFACE4 iface,
1832         DWORD dwFlags )
1833 {
1834   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1835   FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", This, dwFlags);
1836
1837   return DD_OK;
1838 }
1839
1840 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPalette(
1841         LPDIRECTDRAWSURFACE4 iface,
1842         LPDIRECTDRAWPALETTE* lplpDDPalette )
1843 {
1844   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1845   FIXME(ddraw,"(%p)->(%p),stub!\n", This, lplpDDPalette);
1846
1847   return DD_OK;
1848 }
1849
1850 static HRESULT WINAPI IDirectDrawSurface4Impl_SetOverlayPosition(
1851         LPDIRECTDRAWSURFACE4 iface,
1852         LONG lX,
1853         LONG lY)
1854 {
1855   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1856   FIXME(ddraw,"(%p)->(%ld,%ld),stub!\n", This, lX, lY);
1857
1858   return DD_OK;
1859 }
1860
1861 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlay(
1862         LPDIRECTDRAWSURFACE4 iface,
1863         LPRECT lpSrcRect,
1864         LPDIRECTDRAWSURFACE4 lpDDDestSurface,
1865         LPRECT lpDestRect,
1866         DWORD dwFlags,
1867         LPDDOVERLAYFX lpDDOverlayFx )
1868 {
1869   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1870   FIXME(ddraw,"(%p)->(%p,%p,%p,0x%08lx,%p),stub!\n", This,
1871          lpSrcRect, lpDDDestSurface, lpDestRect, dwFlags, lpDDOverlayFx );
1872
1873   return DD_OK;
1874 }
1875
1876 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlayDisplay(
1877         LPDIRECTDRAWSURFACE4 iface,
1878         DWORD dwFlags )
1879 {
1880   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1881   FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", This, dwFlags);
1882
1883   return DD_OK;
1884 }
1885
1886 static HRESULT WINAPI IDirectDrawSurface4Impl_UpdateOverlayZOrder(
1887         LPDIRECTDRAWSURFACE4 iface,
1888         DWORD dwFlags,
1889         LPDIRECTDRAWSURFACE4 lpDDSReference )
1890 {
1891   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1892   FIXME(ddraw,"(%p)->(0x%08lx,%p),stub!\n", This, dwFlags, lpDDSReference);
1893
1894   return DD_OK;
1895 }
1896
1897 static HRESULT WINAPI IDirectDrawSurface4Impl_GetDDInterface(
1898         LPDIRECTDRAWSURFACE4 iface,
1899         LPVOID* lplpDD )
1900 {
1901   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1902   FIXME(ddraw,"(%p)->(%p),stub!\n", This, lplpDD);
1903
1904   /* Not sure about that... */
1905   *lplpDD = (void *) This->s.ddraw;
1906
1907   return DD_OK;
1908 }
1909
1910 static HRESULT WINAPI IDirectDrawSurface4Impl_PageLock(
1911         LPDIRECTDRAWSURFACE4 iface,
1912         DWORD dwFlags )
1913 {
1914   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1915   FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", This, dwFlags);
1916
1917   return DD_OK;
1918 }
1919
1920 static HRESULT WINAPI IDirectDrawSurface4Impl_PageUnlock(
1921         LPDIRECTDRAWSURFACE4 iface,
1922         DWORD dwFlags )
1923 {
1924   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1925   FIXME(ddraw,"(%p)->(0x%08lx),stub!\n", This, dwFlags);
1926
1927   return DD_OK;
1928 }
1929
1930 static HRESULT WINAPI IDirectDrawSurface4Impl_SetSurfaceDesc(
1931         LPDIRECTDRAWSURFACE4 iface,
1932         LPDDSURFACEDESC lpDDSD,
1933         DWORD dwFlags )
1934 {
1935   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1936   FIXME(ddraw,"(%p)->(%p,0x%08lx),stub!\n", This, lpDDSD, dwFlags);
1937
1938   return DD_OK;
1939 }
1940
1941 static HRESULT WINAPI IDirectDrawSurface4Impl_SetPrivateData(LPDIRECTDRAWSURFACE4 iface,
1942                                                          REFGUID guidTag,
1943                                                          LPVOID lpData,
1944                                                          DWORD cbSize,
1945                                                          DWORD dwFlags) {
1946   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1947   FIXME(ddraw, "(%p)->(%p,%p,%ld,%08lx\n", This, guidTag, lpData, cbSize, dwFlags);
1948
1949   return DD_OK;
1950 }
1951
1952 static HRESULT WINAPI IDirectDrawSurface4Impl_GetPrivateData(LPDIRECTDRAWSURFACE4 iface,
1953                                                          REFGUID guidTag,
1954                                                          LPVOID lpBuffer,
1955                                                          LPDWORD lpcbBufferSize) {
1956   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1957   FIXME(ddraw, "(%p)->(%p,%p,%p)\n", This, guidTag, lpBuffer, lpcbBufferSize);
1958
1959   return DD_OK;
1960 }
1961
1962 static HRESULT WINAPI IDirectDrawSurface4Impl_FreePrivateData(LPDIRECTDRAWSURFACE4 iface,
1963                                                           REFGUID guidTag)  {
1964   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1965   FIXME(ddraw, "(%p)->(%p)\n", This, guidTag);
1966
1967   return DD_OK;
1968 }
1969
1970 static HRESULT WINAPI IDirectDrawSurface4Impl_GetUniquenessValue(LPDIRECTDRAWSURFACE4 iface,
1971                                                              LPDWORD lpValue)  {
1972   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1973   FIXME(ddraw, "(%p)->(%p)\n", This, lpValue);
1974
1975   return DD_OK;
1976 }
1977
1978 static HRESULT WINAPI IDirectDrawSurface4Impl_ChangeUniquenessValue(LPDIRECTDRAWSURFACE4 iface) {
1979   ICOM_THIS(IDirectDrawSurface4Impl,iface);
1980   FIXME(ddraw, "(%p)\n", This);
1981
1982   return DD_OK;
1983 }
1984
1985 static ICOM_VTABLE(IDirectDrawSurface4) dga_dds4vt =
1986 {
1987         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1988         IDirectDrawSurface4Impl_QueryInterface,
1989         IDirectDrawSurface4Impl_AddRef,
1990         DGA_IDirectDrawSurface4Impl_Release,
1991         IDirectDrawSurface4Impl_AddAttachedSurface,
1992         IDirectDrawSurface4Impl_AddOverlayDirtyRect,
1993         IDirectDrawSurface4Impl_Blt,
1994         IDirectDrawSurface4Impl_BltBatch,
1995         IDirectDrawSurface4Impl_BltFast,
1996         IDirectDrawSurface4Impl_DeleteAttachedSurface,
1997         IDirectDrawSurface4Impl_EnumAttachedSurfaces,
1998         IDirectDrawSurface4Impl_EnumOverlayZOrders,
1999         DGA_IDirectDrawSurface4Impl_Flip,
2000         IDirectDrawSurface4Impl_GetAttachedSurface,
2001         IDirectDrawSurface4Impl_GetBltStatus,
2002         IDirectDrawSurface4Impl_GetCaps,
2003         IDirectDrawSurface4Impl_GetClipper,
2004         IDirectDrawSurface4Impl_GetColorKey,
2005         IDirectDrawSurface4Impl_GetDC,
2006         IDirectDrawSurface4Impl_GetFlipStatus,
2007         IDirectDrawSurface4Impl_GetOverlayPosition,
2008         IDirectDrawSurface4Impl_GetPalette,
2009         IDirectDrawSurface4Impl_GetPixelFormat,
2010         IDirectDrawSurface4Impl_GetSurfaceDesc,
2011         IDirectDrawSurface4Impl_Initialize,
2012         IDirectDrawSurface4Impl_IsLost,
2013         IDirectDrawSurface4Impl_Lock,
2014         IDirectDrawSurface4Impl_ReleaseDC,
2015         IDirectDrawSurface4Impl_Restore,
2016         IDirectDrawSurface4Impl_SetClipper,
2017         IDirectDrawSurface4Impl_SetColorKey,
2018         IDirectDrawSurface4Impl_SetOverlayPosition,
2019         DGA_IDirectDrawSurface4Impl_SetPalette,
2020         DGA_IDirectDrawSurface4Impl_Unlock,
2021         IDirectDrawSurface4Impl_UpdateOverlay,
2022         IDirectDrawSurface4Impl_UpdateOverlayDisplay,
2023         IDirectDrawSurface4Impl_UpdateOverlayZOrder,
2024         IDirectDrawSurface4Impl_GetDDInterface,
2025         IDirectDrawSurface4Impl_PageLock,
2026         IDirectDrawSurface4Impl_PageUnlock,
2027         IDirectDrawSurface4Impl_SetSurfaceDesc,
2028         IDirectDrawSurface4Impl_SetPrivateData,
2029         IDirectDrawSurface4Impl_GetPrivateData,
2030         IDirectDrawSurface4Impl_FreePrivateData,
2031         IDirectDrawSurface4Impl_GetUniquenessValue,
2032         IDirectDrawSurface4Impl_ChangeUniquenessValue
2033 };
2034
2035 static ICOM_VTABLE(IDirectDrawSurface4) xlib_dds4vt =
2036 {
2037         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2038         IDirectDrawSurface4Impl_QueryInterface,
2039         IDirectDrawSurface4Impl_AddRef,
2040         Xlib_IDirectDrawSurface4Impl_Release,
2041         IDirectDrawSurface4Impl_AddAttachedSurface,
2042         IDirectDrawSurface4Impl_AddOverlayDirtyRect,
2043         IDirectDrawSurface4Impl_Blt,
2044         IDirectDrawSurface4Impl_BltBatch,
2045         IDirectDrawSurface4Impl_BltFast,
2046         IDirectDrawSurface4Impl_DeleteAttachedSurface,
2047         IDirectDrawSurface4Impl_EnumAttachedSurfaces,
2048         IDirectDrawSurface4Impl_EnumOverlayZOrders,
2049         Xlib_IDirectDrawSurface4Impl_Flip,
2050         IDirectDrawSurface4Impl_GetAttachedSurface,
2051         IDirectDrawSurface4Impl_GetBltStatus,
2052         IDirectDrawSurface4Impl_GetCaps,
2053         IDirectDrawSurface4Impl_GetClipper,
2054         IDirectDrawSurface4Impl_GetColorKey,
2055         IDirectDrawSurface4Impl_GetDC,
2056         IDirectDrawSurface4Impl_GetFlipStatus,
2057         IDirectDrawSurface4Impl_GetOverlayPosition,
2058         IDirectDrawSurface4Impl_GetPalette,
2059         IDirectDrawSurface4Impl_GetPixelFormat,
2060         IDirectDrawSurface4Impl_GetSurfaceDesc,
2061         IDirectDrawSurface4Impl_Initialize,
2062         IDirectDrawSurface4Impl_IsLost,
2063         IDirectDrawSurface4Impl_Lock,
2064         IDirectDrawSurface4Impl_ReleaseDC,
2065         IDirectDrawSurface4Impl_Restore,
2066         IDirectDrawSurface4Impl_SetClipper,
2067         IDirectDrawSurface4Impl_SetColorKey,
2068         IDirectDrawSurface4Impl_SetOverlayPosition,
2069         Xlib_IDirectDrawSurface4Impl_SetPalette,
2070         Xlib_IDirectDrawSurface4Impl_Unlock,
2071         IDirectDrawSurface4Impl_UpdateOverlay,
2072         IDirectDrawSurface4Impl_UpdateOverlayDisplay,
2073         IDirectDrawSurface4Impl_UpdateOverlayZOrder,
2074         IDirectDrawSurface4Impl_GetDDInterface,
2075         IDirectDrawSurface4Impl_PageLock,
2076         IDirectDrawSurface4Impl_PageUnlock,
2077         IDirectDrawSurface4Impl_SetSurfaceDesc,
2078         IDirectDrawSurface4Impl_SetPrivateData,
2079         IDirectDrawSurface4Impl_GetPrivateData,
2080         IDirectDrawSurface4Impl_FreePrivateData,
2081         IDirectDrawSurface4Impl_GetUniquenessValue,
2082         IDirectDrawSurface4Impl_ChangeUniquenessValue
2083 };
2084
2085 /******************************************************************************
2086  *                      DirectDrawCreateClipper (DDRAW.7)
2087  */
2088 HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags,
2089                                         LPDIRECTDRAWCLIPPER *lplpDDClipper,
2090                                         LPUNKNOWN pUnkOuter)
2091 {
2092   IDirectDrawClipperImpl** ilplpDDClipper=(IDirectDrawClipperImpl**)lplpDDClipper;
2093   TRACE(ddraw, "(%08lx,%p,%p)\n", dwFlags, ilplpDDClipper, pUnkOuter);
2094
2095   *ilplpDDClipper = (IDirectDrawClipperImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipperImpl));
2096   (*ilplpDDClipper)->lpvtbl = &ddclipvt;
2097   (*ilplpDDClipper)->ref = 1;
2098
2099   return DD_OK;
2100 }
2101
2102 /******************************************************************************
2103  *                      IDirectDrawClipper
2104  */
2105 static HRESULT WINAPI IDirectDrawClipperImpl_SetHwnd(
2106         LPDIRECTDRAWCLIPPER iface,DWORD x,HWND hwnd
2107 ) {
2108         ICOM_THIS(IDirectDrawClipperImpl,iface);
2109         FIXME(ddraw,"(%p)->SetHwnd(0x%08lx,0x%08lx),stub!\n",This,x,(DWORD)hwnd);
2110         return DD_OK;
2111 }
2112
2113 static ULONG WINAPI IDirectDrawClipperImpl_Release(LPDIRECTDRAWCLIPPER iface) {
2114         ICOM_THIS(IDirectDrawClipperImpl,iface);
2115         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
2116
2117         This->ref--;
2118         if (This->ref)
2119                 return This->ref;
2120         HeapFree(GetProcessHeap(),0,This);
2121         return 0;
2122 }
2123
2124 static HRESULT WINAPI IDirectDrawClipperImpl_GetClipList(
2125         LPDIRECTDRAWCLIPPER iface,LPRECT rects,LPRGNDATA lprgn,LPDWORD hmm
2126 ) {
2127         ICOM_THIS(IDirectDrawClipperImpl,iface);
2128         FIXME(ddraw,"(%p,%p,%p,%p),stub!\n",This,rects,lprgn,hmm);
2129         if (hmm) *hmm=0;
2130         return DD_OK;
2131 }
2132
2133 static HRESULT WINAPI IDirectDrawClipperImpl_SetClipList(
2134         LPDIRECTDRAWCLIPPER iface,LPRGNDATA lprgn,DWORD hmm
2135 ) {
2136         ICOM_THIS(IDirectDrawClipperImpl,iface);
2137         FIXME(ddraw,"(%p,%p,%ld),stub!\n",This,lprgn,hmm);
2138         return DD_OK;
2139 }
2140
2141 static HRESULT WINAPI IDirectDrawClipperImpl_QueryInterface(
2142          LPDIRECTDRAWCLIPPER iface,
2143          REFIID riid,
2144          LPVOID* ppvObj )
2145 {
2146    ICOM_THIS(IDirectDrawClipperImpl,iface);
2147    FIXME(ddraw,"(%p)->(%p,%p),stub!\n",This,riid,ppvObj);
2148    return OLE_E_ENUM_NOMORE;
2149 }
2150
2151 static ULONG WINAPI IDirectDrawClipperImpl_AddRef( LPDIRECTDRAWCLIPPER iface )
2152 {
2153   ICOM_THIS(IDirectDrawClipperImpl,iface);
2154   TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
2155   return ++(This->ref);
2156 }
2157
2158 static HRESULT WINAPI IDirectDrawClipperImpl_GetHWnd(
2159          LPDIRECTDRAWCLIPPER iface,
2160          HWND* HWndPtr )
2161 {
2162    ICOM_THIS(IDirectDrawClipperImpl,iface);
2163    FIXME(ddraw,"(%p)->(%p),stub!\n",This,HWndPtr);
2164    return DD_OK;
2165 }
2166
2167 static HRESULT WINAPI IDirectDrawClipperImpl_Initialize(
2168          LPDIRECTDRAWCLIPPER iface,
2169          LPDIRECTDRAW lpDD,
2170          DWORD dwFlags )
2171 {
2172    ICOM_THIS(IDirectDrawClipperImpl,iface);
2173    FIXME(ddraw,"(%p)->(%p,0x%08lx),stub!\n",This,lpDD,dwFlags);
2174    return DD_OK;
2175 }
2176
2177 static HRESULT WINAPI IDirectDrawClipperImpl_IsClipListChanged(
2178          LPDIRECTDRAWCLIPPER iface,
2179          BOOL* lpbChanged )
2180 {
2181    ICOM_THIS(IDirectDrawClipperImpl,iface);
2182    FIXME(ddraw,"(%p)->(%p),stub!\n",This,lpbChanged);
2183    return DD_OK;
2184 }
2185
2186 static ICOM_VTABLE(IDirectDrawClipper) ddclipvt =
2187 {
2188         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2189         IDirectDrawClipperImpl_QueryInterface,
2190         IDirectDrawClipperImpl_AddRef,
2191         IDirectDrawClipperImpl_Release,
2192         IDirectDrawClipperImpl_GetClipList,
2193         IDirectDrawClipperImpl_GetHWnd,
2194         IDirectDrawClipperImpl_Initialize,
2195         IDirectDrawClipperImpl_IsClipListChanged,
2196         IDirectDrawClipperImpl_SetClipList,
2197         IDirectDrawClipperImpl_SetHwnd
2198 };
2199
2200
2201 /******************************************************************************
2202  *                      IDirectDrawPalette
2203  */
2204 static HRESULT WINAPI IDirectDrawPaletteImpl_GetEntries(
2205         LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2206 ) {
2207         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2208         int     i;
2209
2210         TRACE(ddraw,"(%p)->GetEntries(%08lx,%ld,%ld,%p)\n",
2211               This,x,start,count,palent);
2212
2213         /* No palette created and not in depth-convertion mode -> BUG ! */
2214         if ((This->cm == None) &&
2215             (This->ddraw->d.palette_convert == NULL))
2216         {
2217                 FIXME(ddraw,"app tried to read colormap for non-palettized mode\n");
2218                 return DDERR_GENERIC;
2219         }
2220         for (i=0;i<count;i++) {
2221                 palent[i].peRed   = This->palents[start+i].peRed;
2222                 palent[i].peBlue  = This->palents[start+i].peBlue;
2223                 palent[i].peGreen = This->palents[start+i].peGreen;
2224                 palent[i].peFlags = This->palents[start+i].peFlags;
2225
2226         }
2227         return DD_OK;
2228 }
2229
2230 static HRESULT WINAPI Xlib_IDirectDrawPaletteImpl_SetEntries(
2231         LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2232 ) {
2233         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2234         XColor          xc;
2235         int             i;
2236
2237         TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
2238                 This,x,start,count,palent
2239         );
2240         for (i=0;i<count;i++) {
2241                 xc.red = palent[i].peRed<<8;
2242                 xc.blue = palent[i].peBlue<<8;
2243                 xc.green = palent[i].peGreen<<8;
2244                 xc.flags = DoRed|DoBlue|DoGreen;
2245                 xc.pixel = start+i;
2246
2247                 if (This->cm)
2248                     TSXStoreColor(display,This->cm,&xc);
2249
2250                 This->palents[start+i].peRed = palent[i].peRed;
2251                 This->palents[start+i].peBlue = palent[i].peBlue;
2252                 This->palents[start+i].peGreen = palent[i].peGreen;
2253                 This->palents[start+i].peFlags = palent[i].peFlags;
2254         }
2255
2256         /* Now, if we are in 'depth conversion mode', update the screen palette */
2257         /* FIXME: we need to update the image or we won't get palette fading. */
2258         if (This->ddraw->d.palette_convert != NULL)
2259           This->ddraw->d.palette_convert(palent, This->screen_palents, start, count);
2260
2261         return DD_OK;
2262 }
2263
2264 static HRESULT WINAPI DGA_IDirectDrawPaletteImpl_SetEntries(
2265         LPDIRECTDRAWPALETTE iface,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
2266 ) {
2267 #ifdef HAVE_LIBXXF86DGA
2268         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2269         XColor          xc;
2270         Colormap        cm;
2271         int             i;
2272
2273         TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
2274                 This,x,start,count,palent
2275         );
2276         if (!This->cm) /* should not happen */ {
2277                 FIXME(ddraw,"app tried to set colormap in non-palettized mode\n");
2278                 return DDERR_GENERIC;
2279         }
2280         /* FIXME: free colorcells instead of freeing whole map */
2281         cm = This->cm;
2282         This->cm = TSXCopyColormapAndFree(display,This->cm);
2283         TSXFreeColormap(display,cm);
2284
2285         for (i=0;i<count;i++) {
2286                 xc.red = palent[i].peRed<<8;
2287                 xc.blue = palent[i].peBlue<<8;
2288                 xc.green = palent[i].peGreen<<8;
2289                 xc.flags = DoRed|DoBlue|DoGreen;
2290                 xc.pixel = i+start;
2291
2292                 TSXStoreColor(display,This->cm,&xc);
2293
2294                 This->palents[start+i].peRed = palent[i].peRed;
2295                 This->palents[start+i].peBlue = palent[i].peBlue;
2296                 This->palents[start+i].peGreen = palent[i].peGreen;
2297                 This->palents[start+i].peFlags = palent[i].peFlags;
2298         }
2299         TSXF86DGAInstallColormap(display,DefaultScreen(display),This->cm);
2300         return DD_OK;
2301 #else /* defined(HAVE_LIBXXF86DGA) */
2302         return E_UNEXPECTED;
2303 #endif /* defined(HAVE_LIBXXF86DGA) */
2304 }
2305
2306 static ULONG WINAPI IDirectDrawPaletteImpl_Release(LPDIRECTDRAWPALETTE iface) {
2307         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2308         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
2309         if (!--(This->ref)) {
2310                 if (This->cm) {
2311                         TSXFreeColormap(display,This->cm);
2312                         This->cm = 0;
2313                 }
2314                 HeapFree(GetProcessHeap(),0,This);
2315                 return 0;
2316         }
2317         return This->ref;
2318 }
2319
2320 static ULONG WINAPI IDirectDrawPaletteImpl_AddRef(LPDIRECTDRAWPALETTE iface) {
2321         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2322
2323         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
2324         return ++(This->ref);
2325 }
2326
2327 static HRESULT WINAPI IDirectDrawPaletteImpl_Initialize(
2328         LPDIRECTDRAWPALETTE iface,LPDIRECTDRAW ddraw,DWORD x,LPPALETTEENTRY palent
2329 ) {
2330         ICOM_THIS(IDirectDrawPaletteImpl,iface);
2331         TRACE(ddraw,"(%p)->(%p,%ld,%p)\n", This, ddraw, x, palent);
2332
2333         return DDERR_ALREADYINITIALIZED;
2334 }
2335
2336 static HRESULT WINAPI IDirectDrawPaletteImpl_GetCaps(
2337          LPDIRECTDRAWPALETTE iface, LPDWORD lpdwCaps )
2338 {
2339    ICOM_THIS(IDirectDrawPaletteImpl,iface);
2340    FIXME( ddraw, "(%p)->(%p) stub.\n", This, lpdwCaps );
2341    return DD_OK;
2342 }
2343
2344 static HRESULT WINAPI IDirectDrawPaletteImpl_QueryInterface(
2345         LPDIRECTDRAWPALETTE iface,REFIID refiid,LPVOID *obj )
2346 {
2347   ICOM_THIS(IDirectDrawPaletteImpl,iface);
2348   char    xrefiid[50];
2349
2350   WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2351   FIXME(ddraw,"(%p)->(%s,%p) stub.\n",This,xrefiid,obj);
2352
2353   return S_OK;
2354 }
2355
2356 static ICOM_VTABLE(IDirectDrawPalette) dga_ddpalvt =
2357 {
2358         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2359         IDirectDrawPaletteImpl_QueryInterface,
2360         IDirectDrawPaletteImpl_AddRef,
2361         IDirectDrawPaletteImpl_Release,
2362         IDirectDrawPaletteImpl_GetCaps,
2363         IDirectDrawPaletteImpl_GetEntries,
2364         IDirectDrawPaletteImpl_Initialize,
2365         DGA_IDirectDrawPaletteImpl_SetEntries
2366 };
2367
2368 static ICOM_VTABLE(IDirectDrawPalette) xlib_ddpalvt =
2369 {
2370         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2371         IDirectDrawPaletteImpl_QueryInterface,
2372         IDirectDrawPaletteImpl_AddRef,
2373         IDirectDrawPaletteImpl_Release,
2374         IDirectDrawPaletteImpl_GetCaps,
2375         IDirectDrawPaletteImpl_GetEntries,
2376         IDirectDrawPaletteImpl_Initialize,
2377         Xlib_IDirectDrawPaletteImpl_SetEntries
2378 };
2379
2380 /*******************************************************************************
2381  *                              IDirect3D
2382  */
2383 static HRESULT WINAPI IDirect3DImpl_QueryInterface(
2384         LPDIRECT3D iface,REFIID refiid,LPVOID *obj
2385 ) {
2386         ICOM_THIS(IDirect3DImpl,iface);
2387         /* FIXME: Not sure if this is correct */
2388         char    xrefiid[50];
2389
2390         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2391         TRACE(ddraw,"(%p)->(%s,%p)\n",This,xrefiid,obj);
2392         if ((!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) ||
2393             (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) ||
2394             (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4)))) {
2395                 *obj = This->ddraw;
2396                 IDirect3D_AddRef(iface);
2397
2398                 TRACE(ddraw, "  Creating IDirectDrawX interface (%p)\n", *obj);
2399
2400                 return S_OK;
2401         }
2402         if ((!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) ||
2403             (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)))) {
2404                 *obj = This;
2405                 IDirect3D_AddRef(iface);
2406
2407                 TRACE(ddraw, "  Creating IDirect3D interface (%p)\n", *obj);
2408
2409                 return S_OK;
2410         }
2411         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D2))) {
2412                 IDirect3D2Impl*  d3d;
2413
2414                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
2415                 d3d->ref = 1;
2416                 d3d->ddraw = This->ddraw;
2417                 IDirect3D_AddRef(iface);
2418                 d3d->lpvtbl = &d3d2vt;
2419                 *obj = d3d;
2420
2421                 TRACE(ddraw, "  Creating IDirect3D2 interface (%p)\n", *obj);
2422
2423                 return S_OK;
2424         }
2425         FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",This,xrefiid);
2426         return OLE_E_ENUM_NOMORE;
2427 }
2428
2429 static ULONG WINAPI IDirect3DImpl_AddRef(LPDIRECT3D iface) {
2430         ICOM_THIS(IDirect3DImpl,iface);
2431         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
2432
2433         return ++(This->ref);
2434 }
2435
2436 static ULONG WINAPI IDirect3DImpl_Release(LPDIRECT3D iface)
2437 {
2438         ICOM_THIS(IDirect3DImpl,iface);
2439         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
2440
2441         if (!--(This->ref)) {
2442                 IDirectDraw2_Release((IDirectDraw2*)This->ddraw);
2443                 HeapFree(GetProcessHeap(),0,This);
2444                 return 0;
2445         }
2446         return This->ref;
2447 }
2448
2449 static HRESULT WINAPI IDirect3DImpl_Initialize(
2450          LPDIRECT3D iface, REFIID refiid )
2451 {
2452   ICOM_THIS(IDirect3DImpl,iface);
2453   /* FIXME: Not sure if this is correct */
2454   char    xrefiid[50];
2455
2456   WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2457   FIXME(ddraw,"(%p)->(%s):stub.\n",This,xrefiid);
2458
2459   return DDERR_ALREADYINITIALIZED;
2460 }
2461
2462 static HRESULT WINAPI IDirect3DImpl_EnumDevices(LPDIRECT3D iface,
2463                                             LPD3DENUMDEVICESCALLBACK cb,
2464                                             LPVOID context) {
2465   ICOM_THIS(IDirect3DImpl,iface);
2466   FIXME(ddraw,"(%p)->(%p,%p),stub!\n",This,cb,context);
2467
2468   /* Call functions defined in d3ddevices.c */
2469   if (!d3d_OpenGL_dx3(cb, context))
2470     return DD_OK;
2471
2472   return DD_OK;
2473 }
2474
2475 static HRESULT WINAPI IDirect3DImpl_CreateLight(LPDIRECT3D iface,
2476                                             LPDIRECT3DLIGHT *lplight,
2477                                             IUnknown *lpunk)
2478 {
2479   ICOM_THIS(IDirect3DImpl,iface);
2480   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lplight, lpunk);
2481
2482   /* Call the creation function that is located in d3dlight.c */
2483   *lplight = d3dlight_create_dx3(This);
2484
2485   return DD_OK;
2486 }
2487
2488 static HRESULT WINAPI IDirect3DImpl_CreateMaterial(LPDIRECT3D iface,
2489                                                LPDIRECT3DMATERIAL *lpmaterial,
2490                                                IUnknown *lpunk)
2491 {
2492   ICOM_THIS(IDirect3DImpl,iface);
2493   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpmaterial, lpunk);
2494
2495   /* Call the creation function that is located in d3dviewport.c */
2496   *lpmaterial = d3dmaterial_create(This);
2497
2498   return DD_OK;
2499 }
2500
2501 static HRESULT WINAPI IDirect3DImpl_CreateViewport(LPDIRECT3D iface,
2502                                                LPDIRECT3DVIEWPORT *lpviewport,
2503                                                IUnknown *lpunk)
2504 {
2505   ICOM_THIS(IDirect3DImpl,iface);
2506   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpviewport, lpunk);
2507
2508   /* Call the creation function that is located in d3dviewport.c */
2509   *lpviewport = d3dviewport_create(This);
2510
2511   return DD_OK;
2512 }
2513
2514 static HRESULT WINAPI IDirect3DImpl_FindDevice(LPDIRECT3D iface,
2515                                            LPD3DFINDDEVICESEARCH lpfinddevsrc,
2516                                            LPD3DFINDDEVICERESULT lpfinddevrst)
2517 {
2518   ICOM_THIS(IDirect3DImpl,iface);
2519   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpfinddevsrc, lpfinddevrst);
2520
2521   return DD_OK;
2522 }
2523
2524 static ICOM_VTABLE(IDirect3D) d3dvt =
2525 {
2526         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2527         IDirect3DImpl_QueryInterface,
2528         IDirect3DImpl_AddRef,
2529         IDirect3DImpl_Release,
2530         IDirect3DImpl_Initialize,
2531         IDirect3DImpl_EnumDevices,
2532         IDirect3DImpl_CreateLight,
2533         IDirect3DImpl_CreateMaterial,
2534         IDirect3DImpl_CreateViewport,
2535         IDirect3DImpl_FindDevice
2536 };
2537
2538 /*******************************************************************************
2539  *                              IDirect3D2
2540  */
2541 static HRESULT WINAPI IDirect3D2Impl_QueryInterface(
2542         LPDIRECT3D2 iface,REFIID refiid,LPVOID *obj) {
2543         ICOM_THIS(IDirect3D2Impl,iface);
2544
2545         /* FIXME: Not sure if this is correct */
2546         char    xrefiid[50];
2547
2548         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
2549         TRACE(ddraw,"(%p)->(%s,%p)\n",This,xrefiid,obj);
2550         if ((!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) ||
2551             (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) ||
2552             (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4)))) {
2553                 *obj = This->ddraw;
2554                 IDirect3D2_AddRef(iface);
2555
2556                 TRACE(ddraw, "  Creating IDirectDrawX interface (%p)\n", *obj);
2557
2558                 return S_OK;
2559         }
2560         if ((!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D2))) ||
2561             (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)))) {
2562                 *obj = This;
2563                 IDirect3D2_AddRef(iface);
2564
2565                 TRACE(ddraw, "  Creating IDirect3D2 interface (%p)\n", *obj);
2566
2567                 return S_OK;
2568         }
2569         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
2570                 IDirect3DImpl*  d3d;
2571
2572                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
2573                 d3d->ref = 1;
2574                 d3d->ddraw = This->ddraw;
2575                 IDirect3D2_AddRef(iface);
2576                 d3d->lpvtbl = &d3dvt;
2577                 *obj = d3d;
2578
2579                 TRACE(ddraw, "  Creating IDirect3D interface (%p)\n", *obj);
2580
2581                 return S_OK;
2582         }
2583         FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",This,xrefiid);
2584         return OLE_E_ENUM_NOMORE;
2585 }
2586
2587 static ULONG WINAPI IDirect3D2Impl_AddRef(LPDIRECT3D2 iface) {
2588         ICOM_THIS(IDirect3D2Impl,iface);
2589         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
2590
2591         return ++(This->ref);
2592 }
2593
2594 static ULONG WINAPI IDirect3D2Impl_Release(LPDIRECT3D2 iface) {
2595         ICOM_THIS(IDirect3D2Impl,iface);
2596         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
2597
2598         if (!--(This->ref)) {
2599                 IDirectDraw2_Release((IDirectDraw2*)This->ddraw);
2600                 HeapFree(GetProcessHeap(),0,This);
2601                 return 0;
2602         }
2603         return This->ref;
2604 }
2605
2606 static HRESULT WINAPI IDirect3D2Impl_EnumDevices(
2607         LPDIRECT3D2 iface,LPD3DENUMDEVICESCALLBACK cb, LPVOID context
2608 ) {
2609         ICOM_THIS(IDirect3D2Impl,iface);
2610         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",This,cb,context);
2611
2612         /* Call functions defined in d3ddevices.c */
2613         if (!d3d_OpenGL(cb, context))
2614           return DD_OK;
2615
2616         return DD_OK;
2617 }
2618
2619 static HRESULT WINAPI IDirect3D2Impl_CreateLight(LPDIRECT3D2 iface,
2620                                              LPDIRECT3DLIGHT *lplight,
2621                                              IUnknown *lpunk)
2622 {
2623   ICOM_THIS(IDirect3D2Impl,iface);
2624   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lplight, lpunk);
2625
2626   /* Call the creation function that is located in d3dlight.c */
2627   *lplight = d3dlight_create(This);
2628
2629         return DD_OK;
2630 }
2631
2632 static HRESULT WINAPI IDirect3D2Impl_CreateMaterial(LPDIRECT3D2 iface,
2633                                                 LPDIRECT3DMATERIAL2 *lpmaterial,
2634                                                 IUnknown *lpunk)
2635 {
2636   ICOM_THIS(IDirect3D2Impl,iface);
2637   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpmaterial, lpunk);
2638
2639   /* Call the creation function that is located in d3dviewport.c */
2640   *lpmaterial = d3dmaterial2_create(This);
2641
2642   return DD_OK;
2643 }
2644
2645 static HRESULT WINAPI IDirect3D2Impl_CreateViewport(LPDIRECT3D2 iface,
2646                                                 LPDIRECT3DVIEWPORT2 *lpviewport,
2647                                                 IUnknown *lpunk)
2648 {
2649   ICOM_THIS(IDirect3D2Impl,iface);
2650   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpviewport, lpunk);
2651
2652   /* Call the creation function that is located in d3dviewport.c */
2653   *lpviewport = d3dviewport2_create(This);
2654
2655   return DD_OK;
2656 }
2657
2658 static HRESULT WINAPI IDirect3D2Impl_FindDevice(LPDIRECT3D2 iface,
2659                                             LPD3DFINDDEVICESEARCH lpfinddevsrc,
2660                                             LPD3DFINDDEVICERESULT lpfinddevrst)
2661 {
2662   ICOM_THIS(IDirect3D2Impl,iface);
2663   TRACE(ddraw, "(%p)->(%p,%p): stub\n", This, lpfinddevsrc, lpfinddevrst);
2664
2665   return DD_OK;
2666 }
2667
2668 static HRESULT WINAPI IDirect3D2Impl_CreateDevice(LPDIRECT3D2 iface,
2669                                               REFCLSID rguid,
2670                                               LPDIRECTDRAWSURFACE surface,
2671                                               LPDIRECT3DDEVICE2 *device)
2672 {
2673   ICOM_THIS(IDirect3D2Impl,iface);
2674   char  xbuf[50];
2675
2676   WINE_StringFromCLSID(rguid,xbuf);
2677   FIXME(ddraw,"(%p)->(%s,%p,%p): stub\n",This,xbuf,surface,device);
2678
2679   if (is_OpenGL(rguid, (IDirectDrawSurfaceImpl*)surface, (IDirect3DDevice2Impl**)device, This)) {
2680     IDirect3D2_AddRef(iface);
2681     return DD_OK;
2682 }
2683
2684   return DDERR_INVALIDPARAMS;
2685 }
2686
2687 static ICOM_VTABLE(IDirect3D2) d3d2vt =
2688 {
2689         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2690         IDirect3D2Impl_QueryInterface,
2691         IDirect3D2Impl_AddRef,
2692         IDirect3D2Impl_Release,
2693         IDirect3D2Impl_EnumDevices,
2694         IDirect3D2Impl_CreateLight,
2695         IDirect3D2Impl_CreateMaterial,
2696         IDirect3D2Impl_CreateViewport,
2697         IDirect3D2Impl_FindDevice,
2698         IDirect3D2Impl_CreateDevice
2699 };
2700
2701 /*******************************************************************************
2702  *                              IDirectDraw
2703  */
2704
2705 /* Used in conjunction with cbWndExtra for storage of the this ptr for the window.
2706  * Please adjust allocation in Xlib_DirectDrawCreate if you store more data here.
2707  */
2708 static INT ddrawXlibThisOffset = 0;
2709
2710 static HRESULT common_off_screen_CreateSurface(IDirectDraw2Impl* This,
2711                                                IDirectDrawSurfaceImpl* lpdsf)
2712 {
2713   int bpp;
2714
2715   /* The surface was already allocated when entering in this function */
2716   TRACE(ddraw,"using system memory for a surface (%p)\n", lpdsf);
2717
2718   if (lpdsf->s.surface_desc.dwFlags & DDSD_ZBUFFERBITDEPTH) {
2719     /* This is a Z Buffer */
2720     TRACE(ddraw, "Creating Z-Buffer of %ld bit depth\n", lpdsf->s.surface_desc.x.dwZBufferBitDepth);
2721     bpp = lpdsf->s.surface_desc.x.dwZBufferBitDepth / 8;
2722   } else {
2723     /* This is a standard image */
2724     if (!(lpdsf->s.surface_desc.dwFlags & DDSD_PIXELFORMAT)) {
2725     /* No pixel format => use DirectDraw's format */
2726       lpdsf->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
2727       lpdsf->s.surface_desc.dwFlags |= DDSD_PIXELFORMAT;
2728   }
2729
2730     bpp = GET_BPP(lpdsf->s.surface_desc);
2731   }
2732
2733   if (lpdsf->s.surface_desc.dwFlags & DDSD_LPSURFACE) {
2734     /* The surface was preallocated : seems that we have nothing to do :-) */
2735     WARN(ddraw, "Creates a surface that is already allocated : assuming this is an application bug !\n");
2736   }
2737
2738   lpdsf->s.surface_desc.dwFlags |= DDSD_PITCH|DDSD_LPSURFACE;
2739   lpdsf->s.surface_desc.y.lpSurface =
2740     (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpdsf->s.surface_desc.dwWidth * lpdsf->s.surface_desc.dwHeight * bpp);
2741   lpdsf->s.surface_desc.lPitch = lpdsf->s.surface_desc.dwWidth * bpp;
2742
2743   return DD_OK;
2744 }
2745
2746 static HRESULT WINAPI DGA_IDirectDraw2Impl_CreateSurface(
2747         LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
2748 ) {
2749 #ifdef HAVE_LIBXXF86DGA
2750         ICOM_THIS(IDirectDraw2Impl,iface);
2751         IDirectDrawSurfaceImpl** ilpdsf=(IDirectDrawSurfaceImpl**)lpdsf;
2752         int     i;
2753
2754         TRACE(ddraw, "(%p)->(%p,%p,%p)\n",This,lpddsd,ilpdsf,lpunk);
2755         if (TRACE_ON(ddraw)) {
2756           _dump_surface_desc(lpddsd);
2757         }
2758
2759         *ilpdsf = (IDirectDrawSurfaceImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurfaceImpl));
2760         IDirectDraw2_AddRef(iface);
2761
2762         (*ilpdsf)->ref = 1;
2763         (*ilpdsf)->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface)*)&dga_dds4vt;
2764         (*ilpdsf)->s.ddraw = This;
2765         (*ilpdsf)->s.palette = NULL;
2766         (*ilpdsf)->t.dga.fb_height = -1; /* This is to have non-on screen surfaces freed */
2767
2768         /* Copy the surface description */
2769         (*ilpdsf)->s.surface_desc = *lpddsd;
2770
2771         if (!(lpddsd->dwFlags & DDSD_WIDTH))
2772           (*ilpdsf)->s.surface_desc.dwWidth  = This->d.width;
2773         if (!(lpddsd->dwFlags & DDSD_HEIGHT))
2774           (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
2775         (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT;
2776
2777         /* Check if this a 'primary surface' or not */
2778         if ((lpddsd->dwFlags & DDSD_CAPS) &&
2779             (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
2780
2781           /* This is THE primary surface => there is DGA-specific code */
2782           /* First, store the surface description */
2783           (*ilpdsf)->s.surface_desc = *lpddsd;
2784
2785           /* Find a viewport */
2786                 for (i=0;i<32;i++)
2787                         if (!(This->e.dga.vpmask & (1<<i)))
2788                                 break;
2789                 TRACE(ddraw,"using viewport %d for a primary surface\n",i);
2790                 /* if i == 32 or maximum ... return error */
2791                 This->e.dga.vpmask|=(1<<i);
2792           (*ilpdsf)->s.surface_desc.y.lpSurface =
2793             This->e.dga.fb_addr+((i*This->e.dga.fb_height)*This->e.dga.fb_width*This->d.directdraw_pixelformat.x.dwRGBBitCount/8);
2794                 (*ilpdsf)->t.dga.fb_height = i*This->e.dga.fb_height;
2795           (*ilpdsf)->s.surface_desc.lPitch = This->e.dga.fb_width*This->d.directdraw_pixelformat.x.dwRGBBitCount/8;
2796           lpddsd->lPitch = (*ilpdsf)->s.surface_desc.lPitch;
2797
2798           /* Add flags if there were not present */
2799           (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE|DDSD_PIXELFORMAT;
2800           (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
2801           (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
2802           TRACE(ddraw,"primary surface: dwWidth=%ld, dwHeight=%ld, lPitch=%ld\n",This->d.width,This->d.height,lpddsd->lPitch);
2803           /* We put our surface always in video memory */
2804           (*ilpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
2805           (*ilpdsf)->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
2806         (*ilpdsf)->s.backbuffer = NULL;
2807
2808         if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
2809                 IDirectDrawSurface4Impl*        back;
2810
2811                 if (lpddsd->dwBackBufferCount>1)
2812                         FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
2813
2814             (*ilpdsf)->s.backbuffer = back =
2815               (IDirectDrawSurface4Impl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface4Impl));
2816                 IDirectDraw2_AddRef(iface);
2817                 back->ref = 1;
2818                 back->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface4)*)&dga_dds4vt;
2819                 for (i=0;i<32;i++)
2820                         if (!(This->e.dga.vpmask & (1<<i)))
2821                                 break;
2822                 TRACE(ddraw,"using viewport %d for backbuffer\n",i);
2823                 /* if i == 32 or maximum ... return error */
2824                 This->e.dga.vpmask|=(1<<i);
2825                 back->t.dga.fb_height = i*This->e.dga.fb_height;
2826
2827             /* Copy the surface description from the front buffer */
2828             back->s.surface_desc = (*ilpdsf)->s.surface_desc;
2829             /* Change the parameters that are not the same */
2830             back->s.surface_desc.y.lpSurface = This->e.dga.fb_addr+
2831               ((i*This->e.dga.fb_height)*This->e.dga.fb_width*This->d.directdraw_pixelformat.x.dwRGBBitCount/8);
2832                 back->s.ddraw = This;
2833                 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
2834                                             * one! */
2835
2836             /* Add relevant info to front and back buffers */
2837             (*ilpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
2838             back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
2839             back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
2840             back->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_VISIBLE;
2841             back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
2842           }
2843         } else {
2844           /* There is no DGA-specific code here...
2845              Go to the common surface creation function */
2846           return common_off_screen_CreateSurface(This, *ilpdsf);
2847         }
2848
2849         return DD_OK;
2850 #else /* defined(HAVE_LIBXXF86DGA) */
2851         return E_UNEXPECTED;
2852 #endif /* defined(HAVE_LIBXXF86DGA) */
2853 }
2854
2855 #ifdef HAVE_LIBXXSHM
2856 /* Error handlers for Image creation */
2857 static int XShmErrorHandler(Display *dpy, XErrorEvent *event) {
2858   XShmErrorFlag = 1;
2859   return 0;
2860 }
2861
2862 static XImage *create_xshmimage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl* lpdsf) {
2863   XImage *img;
2864   int (*WineXHandler)(Display *, XErrorEvent *);
2865
2866     img = TSXShmCreateImage(display,
2867                             DefaultVisualOfScreen(X11DRV_GetXScreen()),
2868                             This->d.pixmap_depth,
2869                             ZPixmap,
2870                             NULL,
2871                             &(lpdsf->t.xlib.shminfo),
2872                             lpdsf->s.surface_desc.dwWidth,
2873                             lpdsf->s.surface_desc.dwHeight);
2874
2875   if (img == NULL) {
2876     MSG("Couldn't create XShm image (due to X11 remote display or failure).\nReverting to standard X images !\n");
2877     This->e.xlib.xshm_active = 0;
2878       return NULL;
2879   }
2880
2881     lpdsf->t.xlib.shminfo.shmid = shmget( IPC_PRIVATE, img->bytes_per_line * img->height, IPC_CREAT|0777 );
2882     if (lpdsf->t.xlib.shminfo.shmid < 0) {
2883     MSG("Couldn't create shared memory segment (due to X11 remote display or failure).\nReverting to standard X images !\n");
2884     This->e.xlib.xshm_active = 0;
2885       TSXDestroyImage(img);
2886       return NULL;
2887     }
2888
2889     lpdsf->t.xlib.shminfo.shmaddr = img->data = (char*)shmat(lpdsf->t.xlib.shminfo.shmid, 0, 0);
2890
2891     if (img->data == (char *) -1) {
2892     MSG("Couldn't attach shared memory segment (due to X11 remote display or failure).\nReverting to standard X images !\n");
2893     This->e.xlib.xshm_active = 0;
2894       TSXDestroyImage(img);
2895       shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2896       return NULL;
2897     }
2898     lpdsf->t.xlib.shminfo.readOnly = False;
2899
2900   /* This is where things start to get trickier....
2901      First, we flush the current X connections to be sure to catch all non-XShm related
2902      errors */
2903     TSXSync(display, False);
2904   /* Then we enter in the non-thread safe part of the tests */
2905   EnterCriticalSection( &X11DRV_CritSection );
2906
2907   /* Reset the error flag, sets our new error handler and try to attach the surface */
2908   XShmErrorFlag = 0;
2909   WineXHandler = XSetErrorHandler(XShmErrorHandler);
2910   XShmAttach(display, &(lpdsf->t.xlib.shminfo));
2911   XSync(display, False);
2912
2913   /* Check the error flag */
2914   if (XShmErrorFlag) {
2915     /* An error occured */
2916     XFlush(display);
2917     XShmErrorFlag = 0;
2918     XDestroyImage(img);
2919     shmdt(lpdsf->t.xlib.shminfo.shmaddr);
2920     shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2921     XSetErrorHandler(WineXHandler);
2922
2923     MSG("Couldn't attach shared memory segment to X server (due to X11 remote display or failure).\nReverting to standard X images !\n");
2924     This->e.xlib.xshm_active = 0;
2925
2926     /* Leave the critical section */
2927     LeaveCriticalSection( &X11DRV_CritSection );
2928
2929     return NULL;
2930   }
2931
2932   /* Here, to be REALLY sure, I should do a XShmPutImage to check if this works,
2933      but it may be a bit overkill.... */
2934   XSetErrorHandler(WineXHandler);
2935   LeaveCriticalSection( &X11DRV_CritSection );
2936
2937     shmctl(lpdsf->t.xlib.shminfo.shmid, IPC_RMID, 0);
2938
2939     if (This->d.pixel_convert != NULL) {
2940       lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2941                                                     lpdsf->s.surface_desc.dwWidth *
2942                                                     lpdsf->s.surface_desc.dwHeight *
2943                                                     (This->d.directdraw_pixelformat.x.dwRGBBitCount));
2944     } else {
2945     lpdsf->s.surface_desc.y.lpSurface = img->data;
2946     }
2947
2948   return img;
2949 }
2950 #endif /* HAVE_LIBXXSHM */
2951
2952 static XImage *create_ximage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl* lpdsf) {
2953   XImage *img = NULL;
2954   void *img_data;
2955
2956 #ifdef HAVE_LIBXXSHM
2957   if (This->e.xlib.xshm_active) {
2958     img = create_xshmimage(This, lpdsf);
2959   }
2960
2961   if (img == NULL) {
2962 #endif
2963     /* Allocate surface memory */
2964     lpdsf->s.surface_desc.y.lpSurface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2965                                                   lpdsf->s.surface_desc.dwWidth *
2966                                                   lpdsf->s.surface_desc.dwHeight *
2967                                                   (This->d.directdraw_pixelformat.x.dwRGBBitCount / 8));
2968
2969     if (This->d.pixel_convert != NULL) {
2970       img_data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
2971                            lpdsf->s.surface_desc.dwWidth *
2972                            lpdsf->s.surface_desc.dwHeight *
2973                            (This->d.screen_pixelformat.x.dwRGBBitCount / 8));
2974     } else {
2975       img_data = lpdsf->s.surface_desc.y.lpSurface;
2976     }
2977
2978     /* In this case, create an XImage */
2979     img =
2980       TSXCreateImage(display,
2981                      DefaultVisualOfScreen(X11DRV_GetXScreen()),
2982                      This->d.pixmap_depth,
2983                      ZPixmap,
2984                      0,
2985                      img_data,
2986                      lpdsf->s.surface_desc.dwWidth,
2987                      lpdsf->s.surface_desc.dwHeight,
2988                      32,
2989                      lpdsf->s.surface_desc.dwWidth * (This->d.screen_pixelformat.x.dwRGBBitCount / 8)
2990                      );
2991
2992 #ifdef HAVE_LIBXXSHM
2993   }
2994 #endif
2995   if (This->d.pixel_convert != NULL) {
2996     lpdsf->s.surface_desc.lPitch = (This->d.directdraw_pixelformat.x.dwRGBBitCount / 8) * lpdsf->s.surface_desc.dwWidth;
2997   } else {
2998   lpdsf->s.surface_desc.lPitch = img->bytes_per_line;
2999   }
3000
3001   return img;
3002 }
3003
3004 static HRESULT WINAPI Xlib_IDirectDraw2Impl_CreateSurface(
3005         LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
3006 ) {
3007         ICOM_THIS(IDirectDraw2Impl,iface);
3008         IDirectDrawSurfaceImpl** ilpdsf=(IDirectDrawSurfaceImpl**)lpdsf;
3009         TRACE(ddraw, "(%p)->CreateSurface(%p,%p,%p)\n",
3010                      This,lpddsd,ilpdsf,lpunk);
3011
3012         if (TRACE_ON(ddraw)) {
3013           _dump_surface_desc(lpddsd);
3014         }
3015
3016         *ilpdsf = (IDirectDrawSurfaceImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurfaceImpl));
3017
3018         IDirectDraw2_AddRef(iface);
3019         (*ilpdsf)->s.ddraw             = This;
3020         (*ilpdsf)->ref                 = 1;
3021         (*ilpdsf)->lpvtbl              = (ICOM_VTABLE(IDirectDrawSurface)*)&xlib_dds4vt;
3022         (*ilpdsf)->s.palette = NULL;
3023         (*ilpdsf)->t.xlib.image = NULL; /* This is for off-screen buffers */
3024
3025         /* Copy the surface description */
3026         (*ilpdsf)->s.surface_desc = *lpddsd;
3027
3028         if (!(lpddsd->dwFlags & DDSD_WIDTH))
3029           (*ilpdsf)->s.surface_desc.dwWidth  = This->d.width;
3030         if (!(lpddsd->dwFlags & DDSD_HEIGHT))
3031           (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
3032         (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT;
3033
3034         /* Check if this a 'primary surface' or not */
3035   if ((lpddsd->dwFlags & DDSD_CAPS) &&
3036             (lpddsd->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {
3037     XImage *img;
3038
3039     TRACE(ddraw,"using standard XImage for a primary surface (%p)\n", *ilpdsf);
3040
3041     /* Create the XImage */
3042     img = create_ximage(This, (IDirectDrawSurface4Impl*) *ilpdsf);
3043     if (img == NULL)
3044       return DDERR_OUTOFMEMORY;
3045     (*ilpdsf)->t.xlib.image = img;
3046
3047           /* Add flags if there were not present */
3048           (*ilpdsf)->s.surface_desc.dwFlags |= DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_LPSURFACE|DDSD_PIXELFORMAT;
3049           (*ilpdsf)->s.surface_desc.dwWidth = This->d.width;
3050           (*ilpdsf)->s.surface_desc.dwHeight = This->d.height;
3051           (*ilpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VISIBLE|DDSCAPS_VIDEOMEMORY;
3052           (*ilpdsf)->s.surface_desc.ddpfPixelFormat = This->d.directdraw_pixelformat;
3053           (*ilpdsf)->s.backbuffer = NULL;
3054
3055     /* Check for backbuffers */
3056         if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
3057                 IDirectDrawSurface4Impl*        back;
3058       XImage *img;
3059
3060                 if (lpddsd->dwBackBufferCount>1)
3061                         FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
3062
3063       (*ilpdsf)->s.backbuffer = back =
3064         (IDirectDrawSurface4Impl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface4Impl));
3065
3066       TRACE(ddraw,"allocated back-buffer (%p)\n", back);
3067
3068                 IDirectDraw2_AddRef(iface);
3069                 back->s.ddraw = This;
3070
3071                 back->ref = 1;
3072                 back->lpvtbl = (ICOM_VTABLE(IDirectDrawSurface4)*)&xlib_dds4vt;
3073             /* Copy the surface description from the front buffer */
3074             back->s.surface_desc = (*ilpdsf)->s.surface_desc;
3075
3076       /* Create the XImage */
3077       img = create_ximage(This, back);
3078       if (img == NULL)
3079         return DDERR_OUTOFMEMORY;
3080       back->t.xlib.image = img;
3081
3082                 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
3083                                             * one! */
3084
3085             /* Add relevant info to front and back buffers */
3086             (*ilpdsf)->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
3087             back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
3088             back->s.surface_desc.dwFlags &= ~DDSD_BACKBUFFERCOUNT;
3089             back->s.surface_desc.ddsCaps.dwCaps &= ~DDSCAPS_VISIBLE;
3090             back->s.surface_desc.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
3091         }
3092         } else {
3093           /* There is no Xlib-specific code here...
3094              Go to the common surface creation function */
3095           return common_off_screen_CreateSurface(This, *ilpdsf);
3096   }
3097
3098         return DD_OK;
3099 }
3100
3101 static HRESULT WINAPI IDirectDraw2Impl_DuplicateSurface(
3102         LPDIRECTDRAW2 iface,LPDIRECTDRAWSURFACE src,LPDIRECTDRAWSURFACE *dst
3103 ) {
3104         ICOM_THIS(IDirectDraw2Impl,iface);
3105         FIXME(ddraw,"(%p)->(%p,%p) simply copies\n",This,src,dst);
3106         *dst = src; /* FIXME */
3107         return DD_OK;
3108 }
3109
3110 /*
3111  * The Xlib Implementation tries to use the passed hwnd as drawing window,
3112  * even when the approbiate bitmasks are not specified.
3113  */
3114 static HRESULT WINAPI IDirectDraw2Impl_SetCooperativeLevel(
3115         LPDIRECTDRAW2 iface,HWND hwnd,DWORD cooplevel
3116 ) {
3117         ICOM_THIS(IDirectDraw2Impl,iface);
3118         int     i;
3119         const struct {
3120                 int     mask;
3121                 char    *name;
3122         } flagmap[] = {
3123 #define FE(x) { x, #x},
3124                 FE(DDSCL_FULLSCREEN)
3125                 FE(DDSCL_ALLOWREBOOT)
3126                 FE(DDSCL_NOWINDOWCHANGES)
3127                 FE(DDSCL_NORMAL)
3128                 FE(DDSCL_ALLOWMODEX)
3129                 FE(DDSCL_EXCLUSIVE)
3130                 FE(DDSCL_SETFOCUSWINDOW)
3131                 FE(DDSCL_SETDEVICEWINDOW)
3132                 FE(DDSCL_CREATEDEVICEWINDOW)
3133 #undef FE
3134         };
3135
3136         FIXME(ddraw,"(%p)->(%08lx,%08lx)\n",This,(DWORD)hwnd,cooplevel);
3137         if(TRACE_ON(ddraw)){
3138           dbg_decl_str(ddraw, 512);
3139           for (i=0;i<sizeof(flagmap)/sizeof(flagmap[0]);i++)
3140             if (flagmap[i].mask & cooplevel)
3141               dsprintf(ddraw, "%s ", flagmap[i].name);
3142           TRACE(ddraw," cooperative level %s\n", dbg_str(ddraw));
3143         }
3144         This->d.mainWindow = hwnd;
3145
3146         /* This will be overwritten in the case of Full Screen mode.
3147            Windowed games could work with that :-) */
3148         if (hwnd)
3149         {
3150             WND *tmpWnd = WIN_FindWndPtr(hwnd);
3151             This->d.drawable  = X11DRV_WND_GetXWindow(tmpWnd);
3152             WIN_ReleaseWndPtr(tmpWnd);
3153
3154             if( !This->d.drawable ) {
3155               This->d.drawable = ((X11DRV_WND_DATA *) WIN_GetDesktop()->pDriverData)->window;
3156               WIN_ReleaseDesktop();
3157         }
3158             TRACE(ddraw, "Setting drawable to %ld\n", This->d.drawable);
3159         }
3160
3161         return DD_OK;
3162 }
3163
3164 /* Small helper to either use the cooperative window or create a new
3165  * one (for mouse and keyboard input) and drawing in the Xlib implementation.
3166  */
3167 static void _common_IDirectDrawImpl_SetDisplayMode(IDirectDrawImpl* This) {
3168         RECT    rect;
3169
3170         /* Do not destroy the application supplied cooperative window */
3171         if (This->d.window && This->d.window != This->d.mainWindow) {
3172                 DestroyWindow(This->d.window);
3173                 This->d.window = 0;
3174         }
3175         /* Sanity check cooperative window before assigning it to drawing. */
3176         if (    IsWindow(This->d.mainWindow) &&
3177                 IsWindowVisible(This->d.mainWindow)
3178         ) {
3179                 GetWindowRect(This->d.mainWindow,&rect);
3180                 if (((rect.right-rect.left) >= This->d.width)   &&
3181                     ((rect.bottom-rect.top) >= This->d.height)
3182                 )
3183                         This->d.window = This->d.mainWindow;
3184         }
3185         /* ... failed, create new one. */
3186         if (!This->d.window) {
3187             This->d.window = CreateWindowExA(
3188                     0,
3189                     "WINE_DirectDraw",
3190                     "WINE_DirectDraw",
3191                     WS_VISIBLE|WS_SYSMENU|WS_THICKFRAME,
3192                     0,0,
3193                     This->d.width,
3194                     This->d.height,
3195                     0,
3196                     0,
3197                     0,
3198                     NULL
3199             );
3200             /*Store THIS with the window. We'll use it in the window procedure*/
3201             SetWindowLongA(This->d.window,ddrawXlibThisOffset,(LONG)This);
3202             ShowWindow(This->d.window,TRUE);
3203             UpdateWindow(This->d.window);
3204         }
3205         SetFocus(This->d.window);
3206 }
3207
3208 static int _common_depth_to_pixelformat(DWORD depth, DDPIXELFORMAT *pixelformat, DDPIXELFORMAT *screen_pixelformat, int *pix_depth) {
3209   XVisualInfo *vi;
3210   XPixmapFormatValues *pf;
3211   XVisualInfo vt;
3212   int nvisuals, npixmap, i;
3213   int match = 0;
3214
3215   vi = TSXGetVisualInfo(display, VisualNoMask, &vt, &nvisuals);
3216   pf = XListPixmapFormats(display, &npixmap);
3217
3218   for (i = 0; i < npixmap; i++) {
3219     if (pf[i].bits_per_pixel == depth) {
3220       int j;
3221
3222       for (j = 0; j < nvisuals; j++) {
3223         if (vi[j].depth == pf[i].depth) {
3224           pixelformat->dwSize = sizeof(*pixelformat);
3225           if (depth == 8) {
3226             pixelformat->dwFlags = DDPF_PALETTEINDEXED8;
3227             pixelformat->y.dwRBitMask = 0;
3228             pixelformat->z.dwGBitMask = 0;
3229             pixelformat->xx.dwBBitMask = 0;
3230           } else {
3231             pixelformat->dwFlags = DDPF_RGB;
3232             pixelformat->y.dwRBitMask = vi[j].red_mask;
3233             pixelformat->z.dwGBitMask = vi[j].green_mask;
3234             pixelformat->xx.dwBBitMask = vi[j].blue_mask;
3235           }
3236           pixelformat->dwFourCC = 0;
3237           pixelformat->x.dwRGBBitCount = pf[i].bits_per_pixel;
3238           pixelformat->xy.dwRGBAlphaBitMask= 0;
3239
3240           *screen_pixelformat = *pixelformat;
3241
3242           if (pix_depth != NULL)
3243             *pix_depth = vi[j].depth;
3244
3245           match = 1;
3246
3247           break;
3248         }
3249       }
3250
3251       if (j == nvisuals)
3252         ERR(ddraw, "No visual corresponding to pixmap format !\n");
3253     }
3254   }
3255
3256   if ((match == 0) && (depth == 8)) {
3257     pixelformat->dwSize = sizeof(*pixelformat);
3258     pixelformat->dwFlags = DDPF_PALETTEINDEXED8;
3259     pixelformat->dwFourCC = 0;
3260     pixelformat->x.dwRGBBitCount = 8;
3261     pixelformat->y.dwRBitMask = 0;
3262     pixelformat->z.dwGBitMask = 0;
3263     pixelformat->xx.dwBBitMask = 0;
3264     pixelformat->xy.dwRGBAlphaBitMask= 0;
3265
3266     /* In that case, find a visual to emulate the 8 bpp format */
3267     for (i = 0; i < npixmap; i++) {
3268       if (pf[i].bits_per_pixel >= depth) {
3269         int j;
3270
3271         for (j = 0; j < nvisuals; j++) {
3272           if (vi[j].depth == pf[i].depth) {
3273             screen_pixelformat->dwSize = sizeof(*screen_pixelformat);
3274             screen_pixelformat->dwFlags = DDPF_RGB;
3275             screen_pixelformat->dwFourCC = 0;
3276             screen_pixelformat->x.dwRGBBitCount = pf[i].bits_per_pixel;
3277             screen_pixelformat->y.dwRBitMask = vi[j].red_mask;
3278             screen_pixelformat->z.dwGBitMask = vi[j].green_mask;
3279             screen_pixelformat->xx.dwBBitMask = vi[j].blue_mask;
3280             screen_pixelformat->xy.dwRGBAlphaBitMask= 0;
3281
3282             if (pix_depth != NULL)
3283               *pix_depth = vi[j].depth;
3284
3285             match = 2;
3286
3287             break;
3288           }
3289         }
3290
3291         if (j == nvisuals)
3292           ERR(ddraw, "No visual corresponding to pixmap format !\n");
3293       }
3294     }
3295   }
3296
3297   TSXFree(vi);
3298   TSXFree(pf);
3299
3300   return match;
3301 }
3302
3303 static HRESULT WINAPI DGA_IDirectDrawImpl_SetDisplayMode(
3304         LPDIRECTDRAW iface,DWORD width,DWORD height,DWORD depth
3305 ) {
3306 #ifdef HAVE_LIBXXF86DGA
3307         ICOM_THIS(IDirectDrawImpl,iface);
3308         int     i,mode_count;
3309
3310         TRACE(ddraw, "(%p)->(%ld,%ld,%ld)\n", This, width, height, depth);
3311
3312         /* We hope getting the asked for depth */
3313         if (_common_depth_to_pixelformat(depth, &(This->d.directdraw_pixelformat), &(This->d.screen_pixelformat), NULL) != 1) {
3314           /* I.e. no visual found or emulated */
3315                 ERR(ddraw,"(w=%ld,h=%ld,d=%ld), unsupported depth!\n",width,height,depth);
3316                 return DDERR_UNSUPPORTEDMODE;
3317         }
3318
3319         if (This->d.width < width) {
3320                 ERR(ddraw,"SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld\n",width,height,depth,width,This->d.width);
3321                 return DDERR_UNSUPPORTEDMODE;
3322         }
3323         This->d.width   = width;
3324         This->d.height  = height;
3325
3326         /* adjust fb_height, so we don't overlap */
3327         if (This->e.dga.fb_height < height)
3328                 This->e.dga.fb_height = height;
3329         _common_IDirectDrawImpl_SetDisplayMode(This);
3330
3331 #ifdef HAVE_LIBXXF86VM
3332         {
3333             XF86VidModeModeInfo **all_modes, *vidmode = NULL;
3334             XF86VidModeModeLine mod_tmp;
3335             /* int dotclock_tmp; */
3336
3337             /* save original video mode and set fullscreen if available*/
3338             orig_mode = (XF86VidModeModeInfo *) malloc (sizeof(XF86VidModeModeInfo));
3339             TSXF86VidModeGetModeLine(display, DefaultScreen(display), &orig_mode->dotclock, &mod_tmp);
3340             orig_mode->hdisplay = mod_tmp.hdisplay;
3341             orig_mode->hsyncstart = mod_tmp.hsyncstart;
3342             orig_mode->hsyncend = mod_tmp.hsyncend;
3343             orig_mode->htotal = mod_tmp.htotal;
3344             orig_mode->vdisplay = mod_tmp.vdisplay;
3345             orig_mode->vsyncstart = mod_tmp.vsyncstart;
3346             orig_mode->vsyncend = mod_tmp.vsyncend;
3347             orig_mode->vtotal = mod_tmp.vtotal;
3348             orig_mode->flags = mod_tmp.flags;
3349             orig_mode->private = mod_tmp.private;
3350
3351             TSXF86VidModeGetAllModeLines(display,DefaultScreen(display),&mode_count,&all_modes);
3352             for (i=0;i<mode_count;i++)
3353             {
3354                 if (all_modes[i]->hdisplay == width && all_modes[i]->vdisplay == height)
3355                 {
3356                     vidmode = (XF86VidModeModeInfo *)malloc(sizeof(XF86VidModeModeInfo));
3357                     *vidmode = *(all_modes[i]);
3358                     break;
3359                 } else
3360                     TSXFree(all_modes[i]->private);
3361             }
3362             for (i++;i<mode_count;i++) TSXFree(all_modes[i]->private);
3363             TSXFree(all_modes);
3364
3365             if (!vidmode)
3366                 WARN(ddraw, "Fullscreen mode not available!\n");
3367
3368             if (vidmode)
3369               {
3370                 TRACE(ddraw,"SwitchToMode(%dx%d)\n",vidmode->hdisplay,vidmode->vdisplay);
3371                 TSXF86VidModeSwitchToMode(display, DefaultScreen(display), vidmode);
3372 #if 0 /* This messes up my screen (XF86_Mach64, 3.3.2.3a) for some reason, and should now be unnecessary */
3373                 TSXF86VidModeSetViewPort(display, DefaultScreen(display), 0, 0);
3374 #endif
3375               }
3376         }
3377 #endif
3378
3379         /* FIXME: this function OVERWRITES several signal handlers.
3380          * can we save them? and restore them later? In a way that
3381          * it works for the library too?
3382          */
3383         TSXF86DGADirectVideo(display,DefaultScreen(display),XF86DGADirectGraphics);
3384         TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
3385
3386 #ifdef RESTORE_SIGNALS
3387         EXC_InitHandlers();
3388 #endif
3389         return DD_OK;
3390 #else /* defined(HAVE_LIBXXF86DGA) */
3391         return E_UNEXPECTED;
3392 #endif /* defined(HAVE_LIBXXF86DGA) */
3393 }
3394
3395 /* *************************************
3396       16 / 15 bpp to palettized 8 bpp
3397    ************************************* */
3398 static void pixel_convert_16_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3399   unsigned char  *c_src = (unsigned char  *) src;
3400   unsigned short *c_dst = (unsigned short *) dst;
3401   int y;
3402
3403   if (palette != NULL) {
3404     const unsigned short * pal = (unsigned short *) palette->screen_palents;
3405
3406     for (y = height; y--; ) {
3407 #ifdef __i386__
3408       /* gcc generates slightly inefficient code for the the copy / lookup,
3409        * it generates one excess memory access (to pal) per pixel. Since
3410        * we know that pal is not modified by the memory write we can
3411        * put it into a register and reduce the number of memory accesses
3412        * from 4 to 3 pp. There are two xor eax,eax to avoid pipeline stalls.
3413        * (This is not guaranteed to be the fastest method.)
3414        */
3415       __asm__ __volatile__(
3416       "xor %%eax,%%eax\n"
3417       "1:\n"
3418       "    lodsb\n"
3419       "    movw (%%edx,%%eax,2),%%ax\n"
3420       "    stosw\n"
3421       "    xor %%eax,%%eax\n"
3422       "    loop 1b\n"
3423       : "=S" (c_src), "=D" (c_dst)
3424       : "S" (c_src), "D" (c_dst) , "c" (width), "d" (pal)
3425       : "eax", "cc", "memory"
3426       );
3427       c_src+=(pitch-width);
3428 #else
3429       unsigned char * srclineend = c_src+width;
3430       while (c_src < srclineend)
3431         *c_dst++ = pal[*c_src++];
3432       c_src+=(pitch-width);
3433 #endif
3434     }
3435   } else {
3436     WARN(ddraw, "No palette set...\n");
3437     memset(dst, 0, width * height * 2);
3438   }
3439 }
3440 static void palette_convert_16_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3441   int i;
3442   unsigned short *pal = (unsigned short *) screen_palette;
3443
3444   for (i = 0; i < count; i++)
3445     pal[start + i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 8) |
3446                       ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
3447                       ((((unsigned short) palent[i].peGreen) & 0xFC) << 3));
3448 }
3449 static void palette_convert_15_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3450   int i;
3451   unsigned short *pal = (unsigned short *) screen_palette;
3452
3453   for (i = 0; i < count; i++)
3454     pal[start + i] = (((((unsigned short) palent[i].peRed) & 0xF8) << 7) |
3455                       ((((unsigned short) palent[i].peBlue) & 0xF8) >> 3) |
3456                       ((((unsigned short) palent[i].peGreen) & 0xF8) << 2));
3457 }
3458
3459 /* *************************************
3460       24 to palettized 8 bpp
3461    ************************************* */
3462 static void pixel_convert_24_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3463   unsigned char  *c_src = (unsigned char  *) src;
3464   unsigned char *c_dst = (unsigned char *) dst;
3465   int y;
3466
3467   if (palette != NULL) {
3468     const unsigned int *pal = (unsigned int *) palette->screen_palents;
3469
3470     for (y = height; y--; ) {
3471       unsigned char * srclineend = c_src+width;
3472       while (c_src < srclineend ) {
3473         register long pixel = pal[*c_src++];
3474         *c_dst++ = pixel;
3475         *c_dst++ = pixel>>8;
3476         *c_dst++ = pixel>>16;
3477       }
3478       c_src+=(pitch-width);
3479     }
3480   } else {
3481     WARN(ddraw, "No palette set...\n");
3482     memset(dst, 0, width * height * 4);
3483   }
3484 }
3485 /* *************************************
3486       32 bpp to palettized 8 bpp
3487    ************************************* */
3488 static void pixel_convert_32_to_8(void *src, void *dst, DWORD width, DWORD height, LONG pitch, IDirectDrawPaletteImpl* palette) {
3489   unsigned char  *c_src = (unsigned char  *) src;
3490   unsigned int *c_dst = (unsigned int *) dst;
3491   int y;
3492
3493   if (palette != NULL) {
3494     const unsigned int *pal = (unsigned int *) palette->screen_palents;
3495
3496     for (y = height; y--; ) {
3497 #ifdef __i386__
3498       /* See comment in pixel_convert_16_to_8 */
3499       __asm__ __volatile__(
3500       "xor %%eax,%%eax\n"
3501       "1:\n"
3502       "    lodsb\n"
3503       "    movl (%%edx,%%eax,4),%%eax\n"
3504       "    stosl\n"
3505       "    xor %%eax,%%eax\n"
3506       "    loop 1b\n"
3507       : "=S" (c_src), "=D" (c_dst)
3508       : "S" (c_src), "D" (c_dst) , "c" (width), "d" (pal)
3509       : "eax", "cc", "memory"
3510       );
3511       c_src+=(pitch-width);
3512 #else
3513       unsigned char * srclineend = c_src+width;
3514       while (c_src < srclineend )
3515         *c_dst++ = pal[*c_src++];
3516       c_src+=(pitch-width);
3517 #endif
3518     }
3519   } else {
3520     WARN(ddraw, "No palette set...\n");
3521     memset(dst, 0, width * height * 4);
3522   }
3523 }
3524
3525 static void palette_convert_24_to_8(LPPALETTEENTRY palent, void *screen_palette, DWORD start, DWORD count) {
3526   int i;
3527   unsigned int *pal = (unsigned int *) screen_palette;
3528
3529   for (i = 0; i < count; i++)
3530     pal[start + i] = ((((unsigned int) palent[i].peRed) << 16) |
3531                       (((unsigned int) palent[i].peGreen) << 8) |
3532                       ((unsigned int) palent[i].peBlue));
3533 }
3534
3535 static HRESULT WINAPI Xlib_IDirectDrawImpl_SetDisplayMode(
3536         LPDIRECTDRAW iface,DWORD width,DWORD height,DWORD depth
3537 ) {
3538         ICOM_THIS(IDirectDrawImpl,iface);
3539         char    buf[200];
3540         WND *tmpWnd;
3541
3542         TRACE(ddraw, "(%p)->SetDisplayMode(%ld,%ld,%ld)\n",
3543                       This, width, height, depth);
3544
3545         switch (_common_depth_to_pixelformat(depth,
3546                                              &(This->d.directdraw_pixelformat),
3547                                              &(This->d.screen_pixelformat),
3548                                              &(This->d.pixmap_depth))) {
3549         case 0:
3550           sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
3551           MessageBoxA(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
3552           return DDERR_UNSUPPORTEDMODE;
3553
3554         case 1:
3555           /* No convertion */
3556           This->d.pixel_convert = NULL;
3557           This->d.palette_convert = NULL;
3558           break;
3559
3560         case 2: {
3561           int found = 0;
3562
3563           WARN(ddraw, "Warning : running in depth-convertion mode. Should run using a %ld depth for optimal performances.\n", depth);
3564
3565           /* Set the depth convertion routines */
3566           switch (This->d.screen_pixelformat.x.dwRGBBitCount) {
3567           case 16:
3568             if ((This->d.screen_pixelformat.y.dwRBitMask == 0xF800) &&
3569                 (This->d.screen_pixelformat.z.dwGBitMask == 0x07E0) &&
3570                 (This->d.screen_pixelformat.xx.dwBBitMask == 0x001F)) {
3571               /* 16 bpp */
3572               found = 1;
3573
3574               This->d.pixel_convert = pixel_convert_16_to_8;
3575               This->d.palette_convert = palette_convert_16_to_8;
3576             } else if ((This->d.screen_pixelformat.y.dwRBitMask == 0x7C00) &&
3577                        (This->d.screen_pixelformat.z.dwGBitMask == 0x03E0) &&
3578                        (This->d.screen_pixelformat.xx.dwBBitMask == 0x001F)) {
3579               /* 15 bpp */
3580               found = 1;
3581
3582               This->d.pixel_convert = pixel_convert_16_to_8;
3583               This->d.palette_convert = palette_convert_15_to_8;
3584             }
3585             break;
3586
3587           case 24:
3588             if ((This->d.screen_pixelformat.y.dwRBitMask ==  0xFF0000) &&
3589                 (This->d.screen_pixelformat.z.dwGBitMask ==  0x00FF00) &&
3590                 (This->d.screen_pixelformat.xx.dwBBitMask == 0x0000FF)) {
3591               /* 24 bpp */
3592               found = 1;
3593               This->d.pixel_convert = pixel_convert_24_to_8;
3594               This->d.palette_convert = palette_convert_24_to_8;
3595             }
3596             break;
3597
3598           case 32:
3599             if ((This->d.screen_pixelformat.y.dwRBitMask ==  0xFF0000) &&
3600                 (This->d.screen_pixelformat.z.dwGBitMask ==  0x00FF00) &&
3601                 (This->d.screen_pixelformat.xx.dwBBitMask == 0x0000FF)) {
3602               /* 24 bpp */
3603               found = 1;
3604
3605               This->d.pixel_convert = pixel_convert_32_to_8;
3606               This->d.palette_convert = palette_convert_24_to_8;
3607             }
3608             break;
3609           }
3610
3611           if (!found) {
3612                 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
3613                 MessageBoxA(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
3614                 return DDERR_UNSUPPORTEDMODE;
3615           }
3616         } break;
3617         }
3618
3619         This->d.width   = width;
3620         This->d.height  = height;
3621
3622         _common_IDirectDrawImpl_SetDisplayMode(This);
3623
3624         tmpWnd = WIN_FindWndPtr(This->d.window);
3625         This->d.paintable = 1;
3626         This->d.drawable  = ((X11DRV_WND_DATA *) tmpWnd->pDriverData)->window;
3627         WIN_ReleaseWndPtr(tmpWnd);
3628
3629         /* We don't have a context for this window. Host off the desktop */
3630         if( !This->d.drawable )
3631         {
3632            This->d.drawable = ((X11DRV_WND_DATA *) WIN_GetDesktop()->pDriverData)->window;
3633             WIN_ReleaseDesktop();
3634         }
3635         TRACE(ddraw, "Setting drawable to %ld\n", This->d.drawable);
3636
3637         return DD_OK;
3638 }
3639
3640 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetCaps(
3641         LPDIRECTDRAW2 iface,LPDDCAPS caps1,LPDDCAPS caps2
3642 ) {
3643 #ifdef HAVE_LIBXXF86DGA
3644         ICOM_THIS(IDirectDraw2Impl,iface);
3645         TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",This,caps1,caps2);
3646         if (caps1) {
3647                 caps1->dwVidMemTotal = This->e.dga.fb_memsize;
3648                 caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
3649                 caps1->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
3650         }
3651         if (caps2) {
3652                 caps2->dwVidMemTotal = This->e.dga.fb_memsize;
3653                 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
3654                 caps2->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
3655         }
3656         return DD_OK;
3657 #else /* defined(HAVE_LIBXXF86DGA) */
3658         return E_UNEXPECTED;
3659 #endif /* defined(HAVE_LIBXXF86DGA) */
3660 }
3661
3662 static void fill_caps(LPDDCAPS caps) {
3663   /* This function tries to fill the capabilities of Wine's DDraw implementation.
3664      Need to be fixed, though.. */
3665   if (caps == NULL)
3666     return;
3667
3668   caps->dwSize = sizeof(*caps);
3669   caps->dwCaps = DDCAPS_ALPHA | DDCAPS_BLT | DDCAPS_BLTSTRETCH | DDCAPS_BLTCOLORFILL | DDCAPS_BLTDEPTHFILL |
3670     DDCAPS_CANBLTSYSMEM |  DDCAPS_COLORKEY | DDCAPS_PALETTE;
3671   caps->dwCaps2 = DDCAPS2_CERTIFIED | DDCAPS2_NOPAGELOCKREQUIRED | DDCAPS2_WIDESURFACES;
3672   caps->dwCKeyCaps = 0xFFFFFFFF; /* Should put real caps here one day... */
3673   caps->dwFXCaps = 0;
3674   caps->dwFXAlphaCaps = 0;
3675   caps->dwPalCaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
3676   caps->dwSVCaps = 0;
3677   caps->dwZBufferBitDepths = DDBD_16;
3678   /* I put here 8 Mo so that D3D applications will believe they have enough memory
3679      to put textures in video memory.
3680      BTW, is this only frame buffer memory or also texture memory (for Voodoo boards
3681      for example) ? */
3682   caps->dwVidMemTotal = 8192 * 1024;
3683   caps->dwVidMemFree = 8192 * 1024;
3684   /* These are all the supported capabilities of the surfaces */
3685   caps->ddsCaps.dwCaps = DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER | DDSCAPS_COMPLEX | DDSCAPS_FLIP |
3686     DDSCAPS_FRONTBUFFER | DDSCAPS_LOCALVIDMEM | DDSCAPS_NONLOCALVIDMEM | DDSCAPS_OFFSCREENPLAIN |
3687       DDSCAPS_OVERLAY | DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_SYSTEMMEMORY |
3688         DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE;
3689 #ifdef HAVE_MESAGL
3690   caps->dwCaps |= DDCAPS_3D | DDCAPS_ZBLTS;
3691   caps->dwCaps2 |=  DDCAPS2_NO2DDURING3DSCENE;
3692   caps->ddsCaps.dwCaps |= DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER;
3693 #endif
3694 }
3695
3696 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetCaps(
3697         LPDIRECTDRAW2 iface,LPDDCAPS caps1,LPDDCAPS caps2
3698 )  {
3699         ICOM_THIS(IDirectDraw2Impl,iface);
3700         TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",This,caps1,caps2);
3701
3702         /* Put the same caps for the two capabilities */
3703         fill_caps(caps1);
3704         fill_caps(caps2);
3705
3706         return DD_OK;
3707 }
3708
3709 static HRESULT WINAPI IDirectDraw2Impl_CreateClipper(
3710         LPDIRECTDRAW2 iface,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
3711 ) {
3712         ICOM_THIS(IDirectDraw2Impl,iface);
3713         IDirectDrawClipperImpl** ilpddclip=(IDirectDrawClipperImpl**)lpddclip;
3714         FIXME(ddraw,"(%p)->(%08lx,%p,%p),stub!\n",
3715                 This,x,ilpddclip,lpunk
3716         );
3717         *ilpddclip = (IDirectDrawClipperImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipperImpl));
3718         (*ilpddclip)->ref = 1;
3719         (*ilpddclip)->lpvtbl = &ddclipvt;
3720         return DD_OK;
3721 }
3722
3723 static HRESULT WINAPI common_IDirectDraw2Impl_CreatePalette(
3724         IDirectDraw2Impl* This,DWORD dwFlags,LPPALETTEENTRY palent,IDirectDrawPaletteImpl **lpddpal,LPUNKNOWN lpunk,int *psize
3725 ) {
3726         int size = 0;
3727
3728         if (TRACE_ON(ddraw))
3729           _dump_paletteformat(dwFlags);
3730
3731         *lpddpal = (IDirectDrawPaletteImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPaletteImpl));
3732         if (*lpddpal == NULL) return E_OUTOFMEMORY;
3733         (*lpddpal)->ref = 1;
3734         (*lpddpal)->ddraw = (IDirectDrawImpl*)This;
3735         (*lpddpal)->installed = 0;
3736
3737           if (dwFlags & DDPCAPS_1BIT)
3738             size = 2;
3739           else if (dwFlags & DDPCAPS_2BIT)
3740             size = 4;
3741           else if (dwFlags & DDPCAPS_4BIT)
3742             size = 16;
3743           else if (dwFlags & DDPCAPS_8BIT)
3744             size = 256;
3745           else
3746             ERR(ddraw, "unhandled palette format\n");
3747         *psize = size;
3748
3749         if (palent)
3750         {
3751           /* Now, if we are in 'depth conversion mode', create the screen palette */
3752           if (This->d.palette_convert != NULL)
3753             This->d.palette_convert(palent, (*lpddpal)->screen_palents, 0, size);
3754
3755           memcpy((*lpddpal)->palents, palent, size * sizeof(PALETTEENTRY));
3756         } else if (This->d.palette_convert != NULL) {
3757           /* In that case, put all 0xFF */
3758           memset((*lpddpal)->screen_palents, 0xFF, 256 * sizeof(int));
3759         }
3760
3761         return DD_OK;
3762 }
3763
3764 static HRESULT WINAPI DGA_IDirectDraw2Impl_CreatePalette(
3765         LPDIRECTDRAW2 iface,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
3766 ) {
3767         ICOM_THIS(IDirectDraw2Impl,iface);
3768         IDirectDrawPaletteImpl** ilpddpal=(IDirectDrawPaletteImpl**)lpddpal;
3769         HRESULT res;
3770         int xsize = 0,i;
3771
3772         TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ilpddpal,lpunk);
3773         res = common_IDirectDraw2Impl_CreatePalette(This,dwFlags,palent,ilpddpal,lpunk,&xsize);
3774         if (res != 0) return res;
3775         (*ilpddpal)->lpvtbl = &dga_ddpalvt;
3776         if (This->d.directdraw_pixelformat.x.dwRGBBitCount<=8) {
3777                 (*ilpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll);
3778         } else {
3779                 FIXME(ddraw,"why are we doing CreatePalette in hi/truecolor?\n");
3780                 (*ilpddpal)->cm = 0;
3781         }
3782         if (((*ilpddpal)->cm)&&xsize) {
3783           for (i=0;i<xsize;i++) {
3784                   XColor xc;
3785
3786                   xc.red = (*ilpddpal)->palents[i].peRed<<8;
3787                   xc.blue = (*ilpddpal)->palents[i].peBlue<<8;
3788                   xc.green = (*ilpddpal)->palents[i].peGreen<<8;
3789                   xc.flags = DoRed|DoBlue|DoGreen;
3790                   xc.pixel = i;
3791                   TSXStoreColor(display,(*ilpddpal)->cm,&xc);
3792           }
3793         }
3794         return DD_OK;
3795 }
3796
3797 static HRESULT WINAPI Xlib_IDirectDraw2Impl_CreatePalette(
3798         LPDIRECTDRAW2 iface,DWORD dwFlags,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
3799 ) {
3800         ICOM_THIS(IDirectDraw2Impl,iface);
3801         IDirectDrawPaletteImpl** ilpddpal=(IDirectDrawPaletteImpl**)lpddpal;
3802         int xsize;
3803         HRESULT res;
3804
3805         TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",This,dwFlags,palent,ilpddpal,lpunk);
3806         res = common_IDirectDraw2Impl_CreatePalette(This,dwFlags,palent,ilpddpal,lpunk,&xsize);
3807         if (res != 0) return res;
3808         (*ilpddpal)->lpvtbl = &xlib_ddpalvt;
3809         return DD_OK;
3810 }
3811
3812 static HRESULT WINAPI DGA_IDirectDraw2Impl_RestoreDisplayMode(LPDIRECTDRAW2 iface) {
3813 #ifdef HAVE_LIBXXF86DGA
3814         ICOM_THIS(IDirectDraw2Impl,iface);
3815         TRACE(ddraw, "(%p)->()\n",This);
3816         Sleep(1000);
3817         TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3818 #ifdef RESTORE_SIGNALS
3819         EXC_InitHandlers();
3820 #endif
3821         return DD_OK;
3822 #else /* defined(HAVE_LIBXXF86DGA) */
3823         return E_UNEXPECTED;
3824 #endif
3825 }
3826
3827 static HRESULT WINAPI Xlib_IDirectDraw2Impl_RestoreDisplayMode(LPDIRECTDRAW2 iface) {
3828         ICOM_THIS(IDirectDraw2Impl,iface);
3829         TRACE(ddraw, "(%p)->RestoreDisplayMode()\n", This);
3830         Sleep(1000);
3831         return DD_OK;
3832 }
3833
3834 static HRESULT WINAPI IDirectDraw2Impl_WaitForVerticalBlank(
3835         LPDIRECTDRAW2 iface,DWORD x,HANDLE h
3836 ) {
3837         ICOM_THIS(IDirectDraw2Impl,iface);
3838         TRACE(ddraw,"(%p)->(0x%08lx,0x%08x)\n",This,x,h);
3839         return DD_OK;
3840 }
3841
3842 static ULONG WINAPI IDirectDraw2Impl_AddRef(LPDIRECTDRAW2 iface) {
3843         ICOM_THIS(IDirectDraw2Impl,iface);
3844         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", This, This->ref );
3845
3846         return ++(This->ref);
3847 }
3848
3849 static ULONG WINAPI DGA_IDirectDraw2Impl_Release(LPDIRECTDRAW2 iface) {
3850         ICOM_THIS(IDirectDraw2Impl,iface);
3851         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
3852
3853 #ifdef HAVE_LIBXXF86DGA
3854         if (!--(This->ref)) {
3855                 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
3856                 if (This->d.window && (This->d.mainWindow != This->d.window))
3857                         DestroyWindow(This->d.window);
3858 #ifdef HAVE_LIBXXF86VM
3859                 if (orig_mode) {
3860                         TSXF86VidModeSwitchToMode(
3861                                 display,
3862                                 DefaultScreen(display),
3863                                 orig_mode);
3864                         if (orig_mode->privsize)
3865                                 TSXFree(orig_mode->private);
3866                         free(orig_mode);
3867                         orig_mode = NULL;
3868                 }
3869 #endif
3870
3871 #ifdef RESTORE_SIGNALS
3872                 EXC_InitHandlers();
3873 #endif
3874                 HeapFree(GetProcessHeap(),0,This);
3875                 return 0;
3876         }
3877 #endif /* defined(HAVE_LIBXXF86DGA) */
3878         return This->ref;
3879 }
3880
3881 static ULONG WINAPI Xlib_IDirectDraw2Impl_Release(LPDIRECTDRAW2 iface) {
3882         ICOM_THIS(IDirectDraw2Impl,iface);
3883         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", This, This->ref );
3884
3885         if (!--(This->ref)) {
3886                 if (This->d.window && (This->d.mainWindow != This->d.window))
3887                         DestroyWindow(This->d.window);
3888                 HeapFree(GetProcessHeap(),0,This);
3889                 return 0;
3890         }
3891         /* FIXME: destroy window ... */
3892         return This->ref;
3893 }
3894
3895 static HRESULT WINAPI DGA_IDirectDraw2Impl_QueryInterface(
3896         LPDIRECTDRAW2 iface,REFIID refiid,LPVOID *obj
3897 ) {
3898         ICOM_THIS(IDirectDraw2Impl,iface);
3899         char    xrefiid[50];
3900
3901         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
3902         TRACE(ddraw,"(%p)->(%s,%p)\n",This,xrefiid,obj);
3903         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
3904                 *obj = This;
3905                 IDirectDraw2_AddRef(iface);
3906
3907                 TRACE(ddraw, "  Creating IUnknown interface (%p)\n", *obj);
3908
3909                 return S_OK;
3910         }
3911         if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
3912                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_ddvt;
3913                 IDirectDraw2_AddRef(iface);
3914                 *obj = This;
3915
3916                 TRACE(ddraw, "  Creating IDirectDraw interface (%p)\n", *obj);
3917
3918                 return S_OK;
3919         }
3920         if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
3921                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_dd2vt;
3922                 IDirectDraw2_AddRef(iface);
3923                 *obj = This;
3924
3925                 TRACE(ddraw, "  Creating IDirectDraw2 interface (%p)\n", *obj);
3926
3927                 return S_OK;
3928         }
3929         if (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4))) {
3930                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&dga_dd4vt;
3931                 IDirectDraw2_AddRef(iface);
3932                 *obj = This;
3933
3934                 TRACE(ddraw, "  Creating IDirectDraw4 interface (%p)\n", *obj);
3935
3936                 return S_OK;
3937         }
3938         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
3939                 IDirect3DImpl* d3d;
3940
3941                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3942                 d3d->ref = 1;
3943                 d3d->ddraw = (IDirectDrawImpl*)This;
3944                 IDirectDraw2_AddRef(iface);
3945                 d3d->lpvtbl = &d3dvt;
3946                 *obj = d3d;
3947
3948                 TRACE(ddraw, "  Creating IDirect3D interface (%p)\n", *obj);
3949
3950                 return S_OK;
3951         }
3952         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D2))) {
3953                 IDirect3D2Impl* d3d;
3954
3955                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
3956                 d3d->ref = 1;
3957                 d3d->ddraw = (IDirectDrawImpl*)This;
3958                 IDirectDraw2_AddRef(iface);
3959                 d3d->lpvtbl = &d3d2vt;
3960                 *obj = d3d;
3961
3962                 TRACE(ddraw, "  Creating IDirect3D2 interface (%p)\n", *obj);
3963
3964                 return S_OK;
3965         }
3966         WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",This,xrefiid);
3967         return OLE_E_ENUM_NOMORE;
3968 }
3969
3970 static HRESULT WINAPI Xlib_IDirectDraw2Impl_QueryInterface(
3971         LPDIRECTDRAW2 iface,REFIID refiid,LPVOID *obj
3972 ) {
3973         ICOM_THIS(IDirectDraw2Impl,iface);
3974         char    xrefiid[50];
3975
3976         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
3977         TRACE(ddraw,"(%p)->(%s,%p)\n",This,xrefiid,obj);
3978         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
3979                 *obj = This;
3980                 IDirectDraw2_AddRef(iface);
3981
3982                 TRACE(ddraw, "  Creating IUnknown interface (%p)\n", *obj);
3983
3984                 return S_OK;
3985         }
3986         if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
3987                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_ddvt;
3988                 IDirectDraw2_AddRef(iface);
3989                 *obj = This;
3990
3991                 TRACE(ddraw, "  Creating IDirectDraw interface (%p)\n", *obj);
3992
3993                 return S_OK;
3994         }
3995         if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
3996                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_dd2vt;
3997                 IDirectDraw2_AddRef(iface);
3998                 *obj = This;
3999
4000                 TRACE(ddraw, "  Creating IDirectDraw2 interface (%p)\n", *obj);
4001
4002                 return S_OK;
4003         }
4004         if (!memcmp(&IID_IDirectDraw4,refiid,sizeof(IID_IDirectDraw4))) {
4005                 This->lpvtbl = (ICOM_VTABLE(IDirectDraw2)*)&xlib_dd4vt;
4006                 IDirectDraw2_AddRef(iface);
4007                 *obj = This;
4008
4009                 TRACE(ddraw, "  Creating IDirectDraw4 interface (%p)\n", *obj);
4010
4011                 return S_OK;
4012         }
4013         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
4014                 IDirect3DImpl* d3d;
4015
4016                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4017                 d3d->ref = 1;
4018                 d3d->ddraw = (IDirectDrawImpl*)This;
4019                 IDirectDraw2_AddRef(iface);
4020                 d3d->lpvtbl = &d3dvt;
4021                 *obj = d3d;
4022
4023                 TRACE(ddraw, "  Creating IDirect3D interface (%p)\n", *obj);
4024
4025                 return S_OK;
4026         }
4027         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
4028                 IDirect3D2Impl* d3d;
4029
4030                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
4031                 d3d->ref = 1;
4032                 d3d->ddraw = (IDirectDrawImpl*)This;
4033                 IDirectDraw2_AddRef(iface);
4034                 d3d->lpvtbl = &d3d2vt;
4035                 *obj = d3d;
4036
4037                 TRACE(ddraw, "  Creating IDirect3D2 interface (%p)\n", *obj);
4038
4039                 return S_OK;
4040         }
4041         WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",This,xrefiid);
4042         return OLE_E_ENUM_NOMORE;
4043 }
4044
4045 static HRESULT WINAPI IDirectDraw2Impl_GetVerticalBlankStatus(
4046         LPDIRECTDRAW2 iface,BOOL *status
4047 ) {
4048         ICOM_THIS(IDirectDraw2Impl,iface);
4049         TRACE(ddraw,"(%p)->(%p)\n",This,status);
4050         *status = TRUE;
4051         return DD_OK;
4052 }
4053
4054 static HRESULT WINAPI DGA_IDirectDraw2Impl_EnumDisplayModes(
4055         LPDIRECTDRAW2 iface,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
4056 ) {
4057         ICOM_THIS(IDirectDraw2Impl,iface);
4058         DDSURFACEDESC   ddsfd;
4059         static struct {
4060                 int w,h;
4061         } modes[5] = { /* some of the usual modes */
4062                 {512,384},
4063                 {640,400},
4064                 {640,480},
4065                 {800,600},
4066                 {1024,768},
4067         };
4068         static int depths[4] = {8,16,24,32};
4069         int     i,j;
4070
4071         TRACE(ddraw,"(%p)->(0x%08lx,%p,%p,%p)\n",This,dwFlags,lpddsfd,context,modescb);
4072         ddsfd.dwSize = sizeof(ddsfd);
4073         ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4074         if (dwFlags & DDEDM_REFRESHRATES) {
4075                 ddsfd.dwFlags |= DDSD_REFRESHRATE;
4076                 ddsfd.x.dwRefreshRate = 60;
4077         }
4078
4079         for (i=0;i<sizeof(depths)/sizeof(depths[0]);i++) {
4080                 ddsfd.dwBackBufferCount = 1;
4081                 ddsfd.ddpfPixelFormat.dwFourCC  = 0;
4082                 ddsfd.ddpfPixelFormat.dwFlags   = DDPF_RGB;
4083                 ddsfd.ddpfPixelFormat.x.dwRGBBitCount   = depths[i];
4084                 /* FIXME: those masks would have to be set in depth > 8 */
4085                 if (depths[i]==8) {
4086                 ddsfd.ddpfPixelFormat.y.dwRBitMask      = 0;
4087                 ddsfd.ddpfPixelFormat.z.dwGBitMask      = 0;
4088                 ddsfd.ddpfPixelFormat.xx.dwBBitMask     = 0;
4089                 ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4090                         ddsfd.ddsCaps.dwCaps=DDSCAPS_PALETTE;
4091                         ddsfd.ddpfPixelFormat.dwFlags|=DDPF_PALETTEINDEXED8;
4092                 } else {
4093                   ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4094
4095                   /* FIXME: We should query those from X itself */
4096                   switch (depths[i]) {
4097                   case 16:
4098                     ddsfd.ddpfPixelFormat.y.dwRBitMask = 0xF800;
4099                     ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x07E0;
4100                     ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x001F;
4101                     break;
4102                   case 24:
4103                     ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
4104                     ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
4105                     ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
4106                     break;
4107                   case 32:
4108                     ddsfd.ddpfPixelFormat.y.dwRBitMask = 0x00FF0000;
4109                     ddsfd.ddpfPixelFormat.z.dwGBitMask = 0x0000FF00;
4110                     ddsfd.ddpfPixelFormat.xx.dwBBitMask= 0x000000FF;
4111                     break;
4112                   }
4113                 }
4114
4115                 ddsfd.dwWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4116                 ddsfd.dwHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4117                 TRACE(ddraw," enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
4118                 if (!modescb(&ddsfd,context)) return DD_OK;
4119
4120                 for (j=0;j<sizeof(modes)/sizeof(modes[0]);j++) {
4121                         ddsfd.dwWidth   = modes[j].w;
4122                         ddsfd.dwHeight  = modes[j].h;
4123                         TRACE(ddraw," enumerating (%ldx%ldx%d)\n",ddsfd.dwWidth,ddsfd.dwHeight,depths[i]);
4124                         if (!modescb(&ddsfd,context)) return DD_OK;
4125                 }
4126
4127                 if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
4128                         /* modeX is not standard VGA */
4129
4130                         ddsfd.dwHeight = 200;
4131                         ddsfd.dwWidth = 320;
4132                         TRACE(ddraw," enumerating (320x200x%d)\n",depths[i]);
4133                         if (!modescb(&ddsfd,context)) return DD_OK;
4134                 }
4135         }
4136         return DD_OK;
4137 }
4138
4139 static HRESULT WINAPI Xlib_IDirectDraw2Impl_EnumDisplayModes(
4140         LPDIRECTDRAW2 iface,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
4141 ) {
4142   ICOM_THIS(IDirectDraw2Impl,iface);
4143   XVisualInfo *vi;
4144   XPixmapFormatValues *pf;
4145   XVisualInfo vt;
4146   int nvisuals, npixmap, i;
4147   int send_mode;
4148   int has_8bpp = 0;
4149   DDSURFACEDESC ddsfd;
4150   static struct {
4151     int w,h;
4152   } modes[] = { /* some of the usual modes */
4153     {512,384},
4154     {640,400},
4155     {640,480},
4156     {800,600},
4157     {1024,768},
4158     {1280,1024}
4159   };
4160   DWORD maxWidth, maxHeight;
4161
4162   TRACE(ddraw,"(%p)->(0x%08lx,%p,%p,%p)\n",This,dwFlags,lpddsfd,context,modescb);
4163   ddsfd.dwSize = sizeof(ddsfd);
4164   ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_CAPS;
4165   if (dwFlags & DDEDM_REFRESHRATES) {
4166     ddsfd.dwFlags |= DDSD_REFRESHRATE;
4167     ddsfd.x.dwRefreshRate = 60;
4168   }
4169   maxWidth = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4170   maxHeight = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4171
4172   vi = TSXGetVisualInfo(display, VisualNoMask, &vt, &nvisuals);
4173   pf = XListPixmapFormats(display, &npixmap);
4174
4175   i = 0;
4176   send_mode = 0;
4177   while (i < npixmap) {
4178     if ((has_8bpp == 0) && (pf[i].depth == 8)) {
4179       /* Special case of a 8bpp depth */
4180       has_8bpp = 1;
4181       send_mode = 1;
4182
4183       ddsfd.ddsCaps.dwCaps = DDSCAPS_PALETTE;
4184       ddsfd.ddpfPixelFormat.dwSize = sizeof(ddsfd.ddpfPixelFormat);
4185       ddsfd.ddpfPixelFormat.dwFlags = DDPF_PALETTEINDEXED8;
4186       ddsfd.ddpfPixelFormat.dwFourCC = 0;
4187       ddsfd.ddpfPixelFormat.x.dwRGBBitCount = 8;
4188       ddsfd.ddpfPixelFormat.y.dwRBitMask = 0;
4189       ddsfd.ddpfPixelFormat.z.dwGBitMask = 0;
4190       ddsfd.ddpfPixelFormat.xx.dwBBitMask = 0;
4191       ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4192     } else if (pf[i].depth > 8) {
4193       int j;
4194
4195       /* All the 'true color' depths (15, 16 and 24)
4196          First, find the corresponding visual to extract the bit masks */
4197       for (j = 0; j < nvisuals; j++) {
4198         if (vi[j].depth == pf[i].depth) {
4199           ddsfd.ddsCaps.dwCaps = 0;
4200           ddsfd.ddpfPixelFormat.dwSize = sizeof(ddsfd.ddpfPixelFormat);
4201           ddsfd.ddpfPixelFormat.dwFlags = DDPF_RGB;
4202           ddsfd.ddpfPixelFormat.dwFourCC = 0;
4203           ddsfd.ddpfPixelFormat.x.dwRGBBitCount = pf[i].bits_per_pixel;
4204           ddsfd.ddpfPixelFormat.y.dwRBitMask = vi[j].red_mask;
4205           ddsfd.ddpfPixelFormat.z.dwGBitMask = vi[j].green_mask;
4206           ddsfd.ddpfPixelFormat.xx.dwBBitMask = vi[j].blue_mask;
4207           ddsfd.ddpfPixelFormat.xy.dwRGBAlphaBitMask= 0;
4208
4209           send_mode = 1;
4210           break;
4211         }
4212       }
4213
4214       if (j == nvisuals)
4215         ERR(ddraw, "Did not find visual corresponding the the pixmap format !\n");
4216     } else {
4217       send_mode = 0;
4218     }
4219
4220     if (send_mode) {
4221       int mode;
4222
4223       if (TRACE_ON(ddraw)) {
4224         TRACE(ddraw, "Enumerating with pixel format : \n");
4225         _dump_pixelformat(&(ddsfd.ddpfPixelFormat));
4226         DUMP("\n");
4227       }
4228
4229       for (mode = 0; mode < sizeof(modes)/sizeof(modes[0]); mode++) {
4230         /* Do not enumerate modes we cannot handle anyway */
4231         if ((modes[mode].w > maxWidth) || (modes[mode].h > maxHeight))
4232           break;
4233
4234         ddsfd.dwWidth = modes[mode].w;
4235         ddsfd.dwHeight = modes[mode].h;
4236
4237         /* Now, send the mode description to the application */
4238         TRACE(ddraw, " - mode %4ld - %4ld\n", ddsfd.dwWidth, ddsfd.dwHeight);
4239         if (!modescb(&ddsfd, context))
4240           goto exit_enum;
4241       }
4242
4243       if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
4244         /* modeX is not standard VGA */
4245         ddsfd.dwWidth = 320;
4246         ddsfd.dwHeight = 200;
4247         if (!modescb(&ddsfd, context))
4248           goto exit_enum;
4249       }
4250     }
4251
4252     /* Hack to always enumerate a 8bpp depth */
4253     i++;
4254     if ((i == npixmap) && (has_8bpp == 0)) {
4255       i--;
4256       pf[i].depth = 8;
4257     }
4258   }
4259
4260  exit_enum:
4261   TSXFree(vi);
4262   TSXFree(pf);
4263
4264   return DD_OK;
4265 }
4266
4267 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetDisplayMode(
4268         LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsfd
4269 ) {
4270 #ifdef HAVE_LIBXXF86DGA
4271         ICOM_THIS(IDirectDraw2Impl,iface);
4272         TRACE(ddraw,"(%p)->(%p)\n",This,lpddsfd);
4273         lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4274         lpddsfd->dwHeight = This->d.height;
4275         lpddsfd->dwWidth = This->d.width;
4276         lpddsfd->lPitch = This->e.dga.fb_width*This->d.directdraw_pixelformat.x.dwRGBBitCount/8;
4277         lpddsfd->dwBackBufferCount = 1;
4278         lpddsfd->x.dwRefreshRate = 60;
4279         lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
4280         lpddsfd->ddpfPixelFormat = This->d.directdraw_pixelformat;
4281         return DD_OK;
4282 #else /* defined(HAVE_LIBXXF86DGA) */
4283         return E_UNEXPECTED;
4284 #endif /* defined(HAVE_LIBXXF86DGA) */
4285 }
4286
4287 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetDisplayMode(
4288         LPDIRECTDRAW2 iface,LPDDSURFACEDESC lpddsfd
4289 ) {
4290         ICOM_THIS(IDirectDraw2Impl,iface);
4291         TRACE(ddraw,"(%p)->GetDisplayMode(%p)\n",This,lpddsfd);
4292         lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
4293         lpddsfd->dwHeight = This->d.height;
4294         lpddsfd->dwWidth = This->d.width;
4295         lpddsfd->lPitch = lpddsfd->dwWidth * This->d.directdraw_pixelformat.x.dwRGBBitCount/8;
4296         lpddsfd->dwBackBufferCount = 1;
4297         lpddsfd->x.dwRefreshRate = 60;
4298         lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
4299         lpddsfd->ddpfPixelFormat = This->d.directdraw_pixelformat;
4300         return DD_OK;
4301 }
4302
4303 static HRESULT WINAPI IDirectDraw2Impl_FlipToGDISurface(LPDIRECTDRAW2 iface) {
4304         ICOM_THIS(IDirectDraw2Impl,iface);
4305         TRACE(ddraw,"(%p)->()\n",This);
4306         return DD_OK;
4307 }
4308
4309 static HRESULT WINAPI IDirectDraw2Impl_GetMonitorFrequency(
4310         LPDIRECTDRAW2 iface,LPDWORD freq
4311 ) {
4312         ICOM_THIS(IDirectDraw2Impl,iface);
4313         FIXME(ddraw,"(%p)->(%p) returns 60 Hz always\n",This,freq);
4314         *freq = 60*100; /* 60 Hz */
4315         return DD_OK;
4316 }
4317
4318 /* what can we directly decompress? */
4319 static HRESULT WINAPI IDirectDraw2Impl_GetFourCCCodes(
4320         LPDIRECTDRAW2 iface,LPDWORD x,LPDWORD y
4321 ) {
4322         ICOM_THIS(IDirectDraw2Impl,iface);
4323         FIXME(ddraw,"(%p,%p,%p), stub\n",This,x,y);
4324         return DD_OK;
4325 }
4326
4327 static HRESULT WINAPI IDirectDraw2Impl_EnumSurfaces(
4328         LPDIRECTDRAW2 iface,DWORD x,LPDDSURFACEDESC ddsfd,LPVOID context,LPDDENUMSURFACESCALLBACK ddsfcb
4329 ) {
4330   ICOM_THIS(IDirectDraw2Impl,iface);
4331   FIXME(ddraw,"(%p)->(0x%08lx,%p,%p,%p),stub!\n",This,x,ddsfd,context,ddsfcb);
4332   return DD_OK;
4333 }
4334
4335 static HRESULT WINAPI IDirectDraw2Impl_Compact(
4336           LPDIRECTDRAW2 iface )
4337 {
4338   ICOM_THIS(IDirectDraw2Impl,iface);
4339   FIXME(ddraw,"(%p)->()\n", This );
4340
4341   return DD_OK;
4342 }
4343
4344 static HRESULT WINAPI IDirectDraw2Impl_GetGDISurface(LPDIRECTDRAW2 iface,
4345                                                  LPDIRECTDRAWSURFACE *lplpGDIDDSSurface) {
4346   ICOM_THIS(IDirectDraw2Impl,iface);
4347   FIXME(ddraw,"(%p)->(%p)\n", This, lplpGDIDDSSurface);
4348
4349   return DD_OK;
4350 }
4351
4352 static HRESULT WINAPI IDirectDraw2Impl_GetScanLine(LPDIRECTDRAW2 iface,
4353                                                LPDWORD lpdwScanLine) {
4354   ICOM_THIS(IDirectDraw2Impl,iface);
4355   FIXME(ddraw,"(%p)->(%p)\n", This, lpdwScanLine);
4356
4357   return DD_OK;
4358 }
4359
4360 static HRESULT WINAPI IDirectDraw2Impl_Initialize(LPDIRECTDRAW2 iface,
4361                                               GUID *lpGUID) {
4362   ICOM_THIS(IDirectDraw2Impl,iface);
4363   FIXME(ddraw,"(%p)->(%p)\n", This, lpGUID);
4364
4365   return DD_OK;
4366 }
4367
4368 /* Note: Hack so we can reuse the old functions without compiler warnings */
4369 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4370 # define XCAST(fun)     (typeof(dga_ddvt.fn##fun))
4371 #else
4372 # define XCAST(fun)     (void *)
4373 #endif
4374
4375 static ICOM_VTABLE(IDirectDraw) dga_ddvt =
4376 {
4377         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4378         XCAST(QueryInterface)DGA_IDirectDraw2Impl_QueryInterface,
4379         XCAST(AddRef)IDirectDraw2Impl_AddRef,
4380         XCAST(Release)DGA_IDirectDraw2Impl_Release,
4381         XCAST(Compact)IDirectDraw2Impl_Compact,
4382         XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4383         XCAST(CreatePalette)DGA_IDirectDraw2Impl_CreatePalette,
4384         XCAST(CreateSurface)DGA_IDirectDraw2Impl_CreateSurface,
4385         XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4386         XCAST(EnumDisplayModes)DGA_IDirectDraw2Impl_EnumDisplayModes,
4387         XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4388         XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4389         XCAST(GetCaps)DGA_IDirectDraw2Impl_GetCaps,
4390         XCAST(GetDisplayMode)DGA_IDirectDraw2Impl_GetDisplayMode,
4391         XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4392         XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4393         XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4394         XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4395         XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4396         XCAST(Initialize)IDirectDraw2Impl_Initialize,
4397         XCAST(RestoreDisplayMode)DGA_IDirectDraw2Impl_RestoreDisplayMode,
4398         XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4399         DGA_IDirectDrawImpl_SetDisplayMode,
4400         XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4401 };
4402
4403 static ICOM_VTABLE(IDirectDraw) xlib_ddvt =
4404 {
4405         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4406         XCAST(QueryInterface)Xlib_IDirectDraw2Impl_QueryInterface,
4407         XCAST(AddRef)IDirectDraw2Impl_AddRef,
4408         XCAST(Release)Xlib_IDirectDraw2Impl_Release,
4409         XCAST(Compact)IDirectDraw2Impl_Compact,
4410         XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4411         XCAST(CreatePalette)Xlib_IDirectDraw2Impl_CreatePalette,
4412         XCAST(CreateSurface)Xlib_IDirectDraw2Impl_CreateSurface,
4413         XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4414         XCAST(EnumDisplayModes)Xlib_IDirectDraw2Impl_EnumDisplayModes,
4415         XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4416         XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4417         XCAST(GetCaps)Xlib_IDirectDraw2Impl_GetCaps,
4418         XCAST(GetDisplayMode)Xlib_IDirectDraw2Impl_GetDisplayMode,
4419         XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4420         XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4421         XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4422         XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4423         XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4424         XCAST(Initialize)IDirectDraw2Impl_Initialize,
4425         XCAST(RestoreDisplayMode)Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4426         XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4427         Xlib_IDirectDrawImpl_SetDisplayMode,
4428         XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4429 };
4430
4431 #undef XCAST
4432
4433 /*****************************************************************************
4434  *      IDirectDraw2
4435  *
4436  */
4437
4438
4439 static HRESULT WINAPI DGA_IDirectDraw2Impl_SetDisplayMode(
4440         LPDIRECTDRAW2 iface,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
4441 ) {
4442         return DGA_IDirectDrawImpl_SetDisplayMode((LPDIRECTDRAW)iface,width,height,depth);
4443 }
4444
4445 static HRESULT WINAPI Xlib_IDirectDraw2Impl_SetDisplayMode(
4446         LPDIRECTDRAW2 iface,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
4447 ) {
4448         return Xlib_IDirectDrawImpl_SetDisplayMode((LPDIRECTDRAW)iface,width,height,depth);
4449 }
4450
4451 static HRESULT WINAPI DGA_IDirectDraw2Impl_GetAvailableVidMem(
4452         LPDIRECTDRAW2 iface,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
4453 ) {
4454         ICOM_THIS(IDirectDraw2Impl,iface);
4455         TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
4456                 This,ddscaps,total,free
4457         );
4458         if (total) *total = This->e.dga.fb_memsize * 1024;
4459         if (free) *free = This->e.dga.fb_memsize * 1024;
4460         return DD_OK;
4461 }
4462
4463 static HRESULT WINAPI Xlib_IDirectDraw2Impl_GetAvailableVidMem(
4464         LPDIRECTDRAW2 iface,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
4465 ) {
4466         ICOM_THIS(IDirectDraw2Impl,iface);
4467         TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
4468                 This,ddscaps,total,free
4469         );
4470         if (total) *total = 2048 * 1024;
4471         if (free) *free = 2048 * 1024;
4472         return DD_OK;
4473 }
4474
4475 static ICOM_VTABLE(IDirectDraw2) dga_dd2vt =
4476 {
4477         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4478         DGA_IDirectDraw2Impl_QueryInterface,
4479         IDirectDraw2Impl_AddRef,
4480         DGA_IDirectDraw2Impl_Release,
4481         IDirectDraw2Impl_Compact,
4482         IDirectDraw2Impl_CreateClipper,
4483         DGA_IDirectDraw2Impl_CreatePalette,
4484         DGA_IDirectDraw2Impl_CreateSurface,
4485         IDirectDraw2Impl_DuplicateSurface,
4486         DGA_IDirectDraw2Impl_EnumDisplayModes,
4487         IDirectDraw2Impl_EnumSurfaces,
4488         IDirectDraw2Impl_FlipToGDISurface,
4489         DGA_IDirectDraw2Impl_GetCaps,
4490         DGA_IDirectDraw2Impl_GetDisplayMode,
4491         IDirectDraw2Impl_GetFourCCCodes,
4492         IDirectDraw2Impl_GetGDISurface,
4493         IDirectDraw2Impl_GetMonitorFrequency,
4494         IDirectDraw2Impl_GetScanLine,
4495         IDirectDraw2Impl_GetVerticalBlankStatus,
4496         IDirectDraw2Impl_Initialize,
4497         DGA_IDirectDraw2Impl_RestoreDisplayMode,
4498         IDirectDraw2Impl_SetCooperativeLevel,
4499         DGA_IDirectDraw2Impl_SetDisplayMode,
4500         IDirectDraw2Impl_WaitForVerticalBlank,
4501         DGA_IDirectDraw2Impl_GetAvailableVidMem
4502 };
4503
4504 static ICOM_VTABLE(IDirectDraw2) xlib_dd2vt =
4505 {
4506         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4507         Xlib_IDirectDraw2Impl_QueryInterface,
4508         IDirectDraw2Impl_AddRef,
4509         Xlib_IDirectDraw2Impl_Release,
4510         IDirectDraw2Impl_Compact,
4511         IDirectDraw2Impl_CreateClipper,
4512         Xlib_IDirectDraw2Impl_CreatePalette,
4513         Xlib_IDirectDraw2Impl_CreateSurface,
4514         IDirectDraw2Impl_DuplicateSurface,
4515         Xlib_IDirectDraw2Impl_EnumDisplayModes,
4516         IDirectDraw2Impl_EnumSurfaces,
4517         IDirectDraw2Impl_FlipToGDISurface,
4518         Xlib_IDirectDraw2Impl_GetCaps,
4519         Xlib_IDirectDraw2Impl_GetDisplayMode,
4520         IDirectDraw2Impl_GetFourCCCodes,
4521         IDirectDraw2Impl_GetGDISurface,
4522         IDirectDraw2Impl_GetMonitorFrequency,
4523         IDirectDraw2Impl_GetScanLine,
4524         IDirectDraw2Impl_GetVerticalBlankStatus,
4525         IDirectDraw2Impl_Initialize,
4526         Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4527         IDirectDraw2Impl_SetCooperativeLevel,
4528         Xlib_IDirectDraw2Impl_SetDisplayMode,
4529         IDirectDraw2Impl_WaitForVerticalBlank,
4530         Xlib_IDirectDraw2Impl_GetAvailableVidMem
4531 };
4532
4533 /*****************************************************************************
4534  *      IDirectDraw4
4535  *
4536  */
4537
4538 static HRESULT WINAPI IDirectDraw4Impl_GetSurfaceFromDC(LPDIRECTDRAW4 iface,
4539                                                     HDC hdc,
4540                                                     LPDIRECTDRAWSURFACE *lpDDS) {
4541   ICOM_THIS(IDirectDraw4Impl,iface);
4542   FIXME(ddraw, "(%p)->(%08ld,%p)\n", This, (DWORD) hdc, lpDDS);
4543
4544   return DD_OK;
4545 }
4546
4547 static HRESULT WINAPI IDirectDraw4Impl_RestoreAllSurfaces(LPDIRECTDRAW4 iface) {
4548   ICOM_THIS(IDirectDraw4Impl,iface);
4549   FIXME(ddraw, "(%p)->()\n", This);
4550
4551   return DD_OK;
4552 }
4553
4554 static HRESULT WINAPI IDirectDraw4Impl_TestCooperativeLevel(LPDIRECTDRAW4 iface) {
4555   ICOM_THIS(IDirectDraw4Impl,iface);
4556   FIXME(ddraw, "(%p)->()\n", This);
4557
4558   return DD_OK;
4559 }
4560
4561 static HRESULT WINAPI IDirectDraw4Impl_GetDeviceIdentifier(LPDIRECTDRAW4 iface,
4562                                                        LPDDDEVICEIDENTIFIER lpdddi,
4563                                                        DWORD dwFlags) {
4564   ICOM_THIS(IDirectDraw4Impl,iface);
4565   FIXME(ddraw, "(%p)->(%p,%08lx)\n", This, lpdddi, dwFlags);
4566
4567   return DD_OK;
4568 }
4569
4570 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4571 # define XCAST(fun)     (typeof(dga_dd4vt.fn##fun))
4572 #else
4573 # define XCAST(fun)     (void*)
4574 #endif
4575
4576
4577 static ICOM_VTABLE(IDirectDraw4) dga_dd4vt =
4578 {
4579         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4580         XCAST(QueryInterface)DGA_IDirectDraw2Impl_QueryInterface,
4581         XCAST(AddRef)IDirectDraw2Impl_AddRef,
4582         XCAST(Release)DGA_IDirectDraw2Impl_Release,
4583         XCAST(Compact)IDirectDraw2Impl_Compact,
4584         XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4585         XCAST(CreatePalette)DGA_IDirectDraw2Impl_CreatePalette,
4586         XCAST(CreateSurface)DGA_IDirectDraw2Impl_CreateSurface,
4587         XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4588         XCAST(EnumDisplayModes)DGA_IDirectDraw2Impl_EnumDisplayModes,
4589         XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4590         XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4591         XCAST(GetCaps)DGA_IDirectDraw2Impl_GetCaps,
4592         XCAST(GetDisplayMode)DGA_IDirectDraw2Impl_GetDisplayMode,
4593         XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4594         XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4595         XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4596         XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4597         XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4598         XCAST(Initialize)IDirectDraw2Impl_Initialize,
4599         XCAST(RestoreDisplayMode)DGA_IDirectDraw2Impl_RestoreDisplayMode,
4600         XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4601         XCAST(SetDisplayMode)DGA_IDirectDrawImpl_SetDisplayMode,
4602         XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4603         XCAST(GetAvailableVidMem)DGA_IDirectDraw2Impl_GetAvailableVidMem,
4604         IDirectDraw4Impl_GetSurfaceFromDC,
4605         IDirectDraw4Impl_RestoreAllSurfaces,
4606         IDirectDraw4Impl_TestCooperativeLevel,
4607         IDirectDraw4Impl_GetDeviceIdentifier
4608 };
4609
4610 static ICOM_VTABLE(IDirectDraw4) xlib_dd4vt =
4611 {
4612         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
4613         XCAST(QueryInterface)Xlib_IDirectDraw2Impl_QueryInterface,
4614         XCAST(AddRef)IDirectDraw2Impl_AddRef,
4615         XCAST(Release)Xlib_IDirectDraw2Impl_Release,
4616         XCAST(Compact)IDirectDraw2Impl_Compact,
4617         XCAST(CreateClipper)IDirectDraw2Impl_CreateClipper,
4618         XCAST(CreatePalette)Xlib_IDirectDraw2Impl_CreatePalette,
4619         XCAST(CreateSurface)Xlib_IDirectDraw2Impl_CreateSurface,
4620         XCAST(DuplicateSurface)IDirectDraw2Impl_DuplicateSurface,
4621         XCAST(EnumDisplayModes)Xlib_IDirectDraw2Impl_EnumDisplayModes,
4622         XCAST(EnumSurfaces)IDirectDraw2Impl_EnumSurfaces,
4623         XCAST(FlipToGDISurface)IDirectDraw2Impl_FlipToGDISurface,
4624         XCAST(GetCaps)Xlib_IDirectDraw2Impl_GetCaps,
4625         XCAST(GetDisplayMode)Xlib_IDirectDraw2Impl_GetDisplayMode,
4626         XCAST(GetFourCCCodes)IDirectDraw2Impl_GetFourCCCodes,
4627         XCAST(GetGDISurface)IDirectDraw2Impl_GetGDISurface,
4628         XCAST(GetMonitorFrequency)IDirectDraw2Impl_GetMonitorFrequency,
4629         XCAST(GetScanLine)IDirectDraw2Impl_GetScanLine,
4630         XCAST(GetVerticalBlankStatus)IDirectDraw2Impl_GetVerticalBlankStatus,
4631         XCAST(Initialize)IDirectDraw2Impl_Initialize,
4632         XCAST(RestoreDisplayMode)Xlib_IDirectDraw2Impl_RestoreDisplayMode,
4633         XCAST(SetCooperativeLevel)IDirectDraw2Impl_SetCooperativeLevel,
4634         XCAST(SetDisplayMode)Xlib_IDirectDrawImpl_SetDisplayMode,
4635         XCAST(WaitForVerticalBlank)IDirectDraw2Impl_WaitForVerticalBlank,
4636         XCAST(GetAvailableVidMem)Xlib_IDirectDraw2Impl_GetAvailableVidMem,
4637         IDirectDraw4Impl_GetSurfaceFromDC,
4638         IDirectDraw4Impl_RestoreAllSurfaces,
4639         IDirectDraw4Impl_TestCooperativeLevel,
4640         IDirectDraw4Impl_GetDeviceIdentifier
4641 };
4642
4643 #undef XCAST
4644
4645 /******************************************************************************
4646  *                              DirectDrawCreate
4647  */
4648
4649 LRESULT WINAPI Xlib_DDWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
4650 {
4651    LRESULT ret;
4652    IDirectDrawImpl* ddraw = NULL;
4653    DWORD lastError;
4654
4655    /* FIXME(ddraw,"(0x%04x,%s,0x%08lx,0x%08lx),stub!\n",(int)hwnd,SPY_GetMsgName(msg),(long)wParam,(long)lParam); */
4656
4657    SetLastError( ERROR_SUCCESS );
4658    ddraw  = (IDirectDrawImpl*)GetWindowLongA( hwnd, ddrawXlibThisOffset );
4659    if( (!ddraw)  &&
4660        ( ( lastError = GetLastError() ) != ERROR_SUCCESS )
4661      )
4662    {
4663      ERR( ddraw, "Unable to retrieve this ptr from window. Error %08lx\n", lastError );
4664    }
4665
4666    if( ddraw )
4667    {
4668       /* Perform any special direct draw functions */
4669       if (msg==WM_PAINT)
4670         ddraw->d.paintable = 1;
4671
4672       /* Now let the application deal with the rest of this */
4673       if( ddraw->d.mainWindow )
4674       {
4675
4676         /* Don't think that we actually need to call this but...
4677            might as well be on the safe side of things... */
4678
4679         /* I changed hwnd to ddraw->d.mainWindow as I did not see why
4680            it should be the procedures of our fake window that gets called
4681            instead of those of the window provided by the application.
4682            And with this patch, mouse clicks work with Monkey Island III
4683              - Lionel */
4684         ret = DefWindowProcA( ddraw->d.mainWindow, msg, wParam, lParam );
4685
4686         if( !ret )
4687         {
4688           WND *tmpWnd =WIN_FindWndPtr(ddraw->d.mainWindow);
4689           /* We didn't handle the message - give it to the application */
4690           if (ddraw && ddraw->d.mainWindow && tmpWnd)
4691           {
4692                 ret = CallWindowProcA(tmpWnd->winproc,
4693                                    ddraw->d.mainWindow, msg, wParam, lParam );
4694           }
4695           WIN_ReleaseWndPtr(tmpWnd);
4696
4697         }
4698
4699       } else {
4700         ret = DefWindowProcA(hwnd, msg, wParam, lParam );
4701       }
4702
4703     }
4704     else
4705     {
4706         ret = DefWindowProcA(hwnd,msg,wParam,lParam);
4707     }
4708
4709     return ret;
4710 }
4711
4712 HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
4713 #ifdef HAVE_LIBXXF86DGA
4714         IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
4715         int     memsize,banksize,width,major,minor,flags,height;
4716         char    *addr;
4717         int     fd;
4718         int     depth;
4719
4720         /* Must be able to access /dev/mem for DGA extensions to work, root is not neccessary. --stephenc */
4721         if ((fd = open("/dev/mem", O_RDWR)) != -1)
4722           close(fd);
4723
4724         if (fd  == -1) {
4725           MSG("Must be able to access /dev/mem to use XF86DGA!\n");
4726           MessageBoxA(0,"Using the XF86DGA extension requires access to /dev/mem.","WINE DirectDraw",MB_OK|MB_ICONSTOP);
4727           return E_UNEXPECTED;
4728         }
4729         if (!DDRAW_DGA_Available()) {
4730                 TRACE(ddraw,"No XF86DGA detected.\n");
4731                 return DDERR_GENERIC;
4732         }
4733         *ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl));
4734         (*ilplpDD)->lpvtbl = &dga_ddvt;
4735         (*ilplpDD)->ref = 1;
4736         TSXF86DGAQueryVersion(display,&major,&minor);
4737         TRACE(ddraw,"XF86DGA is version %d.%d\n",major,minor);
4738         TSXF86DGAQueryDirectVideo(display,DefaultScreen(display),&flags);
4739         if (!(flags & XF86DGADirectPresent))
4740                 MSG("direct video is NOT PRESENT.\n");
4741         TSXF86DGAGetVideo(display,DefaultScreen(display),&addr,&width,&banksize,&memsize);
4742         (*ilplpDD)->e.dga.fb_width = width;
4743         TSXF86DGAGetViewPortSize(display,DefaultScreen(display),&width,&height);
4744         TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
4745         (*ilplpDD)->e.dga.fb_height = height;
4746         TRACE(ddraw,"video framebuffer: begin %p, width %d,banksize %d,memsize %d\n",
4747                 addr,width,banksize,memsize
4748         );
4749         TRACE(ddraw,"viewport height: %d\n",height);
4750
4751         /* Get the screen dimensions as seen by Wine.
4752            In that case, it may be better to ignore the -desktop mode and return the
4753            real screen size => print a warning */
4754         (*ilplpDD)->d.height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4755         (*ilplpDD)->d.width = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4756         if (((*ilplpDD)->d.height != height) ||
4757             ((*ilplpDD)->d.width != width))
4758           WARN(ddraw, "You seem to be runnin in -desktop mode. This may prove dangerous in DGA mode...\n");
4759         (*ilplpDD)->e.dga.fb_addr = addr;
4760         (*ilplpDD)->e.dga.fb_memsize = memsize;
4761         (*ilplpDD)->e.dga.fb_banksize = banksize;
4762         (*ilplpDD)->e.dga.vpmask = 0;
4763
4764         /* just assume the default depth is the DGA depth too */
4765         depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
4766         _common_depth_to_pixelformat(depth, &((*ilplpDD)->d.directdraw_pixelformat), &((*ilplpDD)->d.screen_pixelformat), NULL);
4767 #ifdef RESTORE_SIGNALS
4768         EXC_InitHandlers();
4769 #endif
4770
4771         return DD_OK;
4772 #else /* defined(HAVE_LIBXXF86DGA) */
4773         return DDERR_INVALIDDIRECTDRAWGUID;
4774 #endif /* defined(HAVE_LIBXXF86DGA) */
4775 }
4776
4777 BOOL
4778 DDRAW_XSHM_Available(void)
4779    {
4780 #ifdef HAVE_LIBXXSHM
4781   if (TSXShmQueryExtension(display))
4782       {
4783       int major, minor;
4784       Bool shpix;
4785
4786       if (TSXShmQueryVersion(display, &major, &minor, &shpix))
4787         return 1;
4788       else
4789         return 0;
4790     }
4791     else
4792     return 0;
4793 #else
4794   return 0;
4795 #endif
4796 }
4797
4798 HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
4799         IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
4800         int depth;
4801
4802         *ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl));
4803         (*ilplpDD)->lpvtbl = &xlib_ddvt;
4804         (*ilplpDD)->ref = 1;
4805         (*ilplpDD)->d.drawable = 0; /* in SetDisplayMode */
4806
4807         /* At DirectDraw creation, the depth is the default depth */
4808         depth = DefaultDepthOfScreen(X11DRV_GetXScreen());
4809         _common_depth_to_pixelformat(depth,
4810                                      &((*ilplpDD)->d.directdraw_pixelformat),
4811                                      &((*ilplpDD)->d.screen_pixelformat),
4812                                      &((*ilplpDD)->d.pixmap_depth));
4813         (*ilplpDD)->d.height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
4814         (*ilplpDD)->d.width = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
4815
4816 #ifdef HAVE_LIBXXSHM
4817         /* Test if XShm is available. */
4818         if (((*ilplpDD)->e.xlib.xshm_active = DDRAW_XSHM_Available()))
4819           TRACE(ddraw, "Using XShm extension.\n");
4820 #endif
4821
4822         return DD_OK;
4823 }
4824
4825 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
4826         IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
4827         char    xclsid[50];
4828         WNDCLASSA       wc;
4829         /* WND*            pParentWindow; */
4830         HRESULT ret;
4831
4832         if (HIWORD(lpGUID))
4833                 WINE_StringFromCLSID(lpGUID,xclsid);
4834         else {
4835                 sprintf(xclsid,"<guid-0x%08x>",(int)lpGUID);
4836                 lpGUID = NULL;
4837         }
4838
4839         TRACE(ddraw,"(%s,%p,%p)\n",xclsid,ilplpDD,pUnkOuter);
4840
4841         if ((!lpGUID) ||
4842             (!memcmp(lpGUID,&IID_IDirectDraw ,sizeof(IID_IDirectDraw ))) ||
4843             (!memcmp(lpGUID,&IID_IDirectDraw2,sizeof(IID_IDirectDraw2))) ||
4844             (!memcmp(lpGUID,&IID_IDirectDraw4,sizeof(IID_IDirectDraw4)))) {
4845                 /* if they didn't request a particular interface, use the best
4846                  * supported one */
4847                 if (DDRAW_DGA_Available())
4848                         lpGUID = &DGA_DirectDraw_GUID;
4849                 else
4850                         lpGUID = &XLIB_DirectDraw_GUID;
4851         }
4852
4853         wc.style        = CS_GLOBALCLASS;
4854         wc.lpfnWndProc  = Xlib_DDWndProc;
4855         wc.cbClsExtra   = 0;
4856         wc.cbWndExtra   = /* Defines extra mem for window. This is used for storing this */
4857                           sizeof( LPDIRECTDRAW ); /*  ddrawXlibThisOffset */
4858
4859         /* We can be a child of the desktop since we're really important */
4860         /*
4861          This code is not useful since hInstance is forced to 0 afterward
4862         pParentWindow   = WIN_GetDesktop();
4863         wc.hInstance    = pParentWindow ? pParentWindow->hwndSelf : 0;
4864         */
4865         wc.hInstance    = 0;
4866
4867
4868         wc.hIcon        = 0;
4869         wc.hCursor      = (HCURSOR)IDC_ARROWA;
4870         wc.hbrBackground= NULL_BRUSH;
4871         wc.lpszMenuName = 0;
4872         wc.lpszClassName= "WINE_DirectDraw";
4873         RegisterClassA(&wc);
4874
4875         if (!memcmp(lpGUID, &DGA_DirectDraw_GUID, sizeof(GUID)))
4876                 ret = DGA_DirectDrawCreate(lplpDD, pUnkOuter);
4877         else if (!memcmp(lpGUID, &XLIB_DirectDraw_GUID, sizeof(GUID)))
4878                 ret = Xlib_DirectDrawCreate(lplpDD, pUnkOuter);
4879         else
4880           goto err;
4881
4882
4883         (*ilplpDD)->d.winclass = RegisterClassA(&wc);
4884         return ret;
4885
4886       err:
4887         ERR(ddraw, "DirectDrawCreate(%s,%p,%p): did not recognize requested GUID\n",xclsid,lplpDD,pUnkOuter);
4888         return DDERR_INVALIDDIRECTDRAWGUID;
4889 }
4890
4891
4892 #else /* !defined(X_DISPLAY_MISSING) */
4893
4894 #include "windef.h"
4895
4896 #define DD_OK 0
4897
4898 typedef void *LPGUID;
4899 typedef void *LPUNKNOWN;
4900 typedef void *LPDIRECTDRAW;
4901 typedef void *LPDIRECTDRAWCLIPPER;
4902 typedef void *LPDDENUMCALLBACKA;
4903 typedef void *LPDDENUMCALLBACKEXA;
4904 typedef void *LPDDENUMCALLBACKEXW;
4905 typedef void *LPDDENUMCALLBACKW;
4906
4907 HRESULT WINAPI DSoundHelp(DWORD x, DWORD y, DWORD z)
4908 {
4909   return DD_OK;
4910 }
4911
4912 HRESULT WINAPI DirectDrawCreate(
4913   LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter)
4914 {
4915   return DD_OK;
4916 }
4917
4918 HRESULT WINAPI DirectDrawCreateClipper(
4919   DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, LPUNKNOWN pUnkOuter)
4920 {
4921   return DD_OK;
4922 }
4923
4924 HRESULT WINAPI DirectDrawEnumerateA(
4925   LPDDENUMCALLBACKA lpCallback, LPVOID lpContext)
4926 {
4927   return DD_OK;
4928 }
4929
4930 HRESULT WINAPI DirectDrawEnumerateExA(
4931   LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags)
4932 {
4933   return DD_OK;
4934 }
4935
4936 HRESULT WINAPI DirectDrawEnumerateExW(
4937   LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags)
4938 {
4939   return DD_OK;
4940 }
4941
4942 HRESULT WINAPI DirectDrawEnumerateW(
4943   LPDDENUMCALLBACKW lpCallback, LPVOID lpContext)
4944 {
4945   return DD_OK;
4946 }
4947
4948 #endif /* !defined(X_DISPLAY_MISSING) */
4949
4950
4951 /*******************************************************************************
4952  * DirectDraw ClassFactory
4953  *
4954  *  Heavily inspired (well, can you say completely copied :-) ) from DirectSound
4955  *
4956  */
4957 typedef struct
4958 {
4959     /* IUnknown fields */
4960     ICOM_VTABLE(IClassFactory)* lpvtbl;
4961     DWORD                       ref;
4962 } IClassFactoryImpl;
4963
4964 static HRESULT WINAPI
4965 DDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
4966         ICOM_THIS(IClassFactoryImpl,iface);
4967         char buf[80];
4968
4969         if (HIWORD(riid))
4970             WINE_StringFromCLSID(riid,buf);
4971         else
4972             sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
4973         FIXME(ddraw,"(%p)->(%s,%p),stub!\n",This,buf,ppobj);
4974         return E_NOINTERFACE;
4975 }
4976
4977 static ULONG WINAPI
4978 DDCF_AddRef(LPCLASSFACTORY iface) {
4979         ICOM_THIS(IClassFactoryImpl,iface);
4980         return ++(This->ref);
4981 }
4982
4983 static ULONG WINAPI DDCF_Release(LPCLASSFACTORY iface) {
4984         ICOM_THIS(IClassFactoryImpl,iface);
4985         /* static class, won't be  freed */
4986         return --(This->ref);
4987 }
4988
4989 static HRESULT WINAPI DDCF_CreateInstance(
4990         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
4991 ) {
4992         ICOM_THIS(IClassFactoryImpl,iface);
4993         char buf[80];
4994
4995         WINE_StringFromCLSID(riid,buf);
4996         TRACE(ddraw,"(%p)->(%p,%s,%p)\n",This,pOuter,buf,ppobj);
4997         if ((!memcmp(riid,&IID_IDirectDraw ,sizeof(IID_IDirectDraw ))) ||
4998             (!memcmp(riid,&IID_IDirectDraw2,sizeof(IID_IDirectDraw2))) ||
4999             (!memcmp(riid,&IID_IDirectDraw4,sizeof(IID_IDirectDraw4)))) {
5000                 /* FIXME: reuse already created DirectDraw if present? */
5001                 return DirectDrawCreate((LPGUID) riid,(LPDIRECTDRAW*)ppobj,pOuter);
5002         }
5003         return E_NOINTERFACE;
5004 }
5005
5006 static HRESULT WINAPI DDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
5007         ICOM_THIS(IClassFactoryImpl,iface);
5008         FIXME(ddraw,"(%p)->(%d),stub!\n",This,dolock);
5009         return S_OK;
5010 }
5011
5012 static ICOM_VTABLE(IClassFactory) DDCF_Vtbl =
5013 {
5014         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
5015         DDCF_QueryInterface,
5016         DDCF_AddRef,
5017         DDCF_Release,
5018         DDCF_CreateInstance,
5019         DDCF_LockServer
5020 };
5021 static IClassFactoryImpl DDRAW_CF = {&DDCF_Vtbl, 1 };
5022
5023 /*******************************************************************************
5024  * DllGetClassObject [DDRAW.13]
5025  * Retrieves class object from a DLL object
5026  *
5027  * NOTES
5028  *    Docs say returns STDAPI
5029  *
5030  * PARAMS
5031  *    rclsid [I] CLSID for the class object
5032  *    riid   [I] Reference to identifier of interface for class object
5033  *    ppv    [O] Address of variable to receive interface pointer for riid
5034  *
5035  * RETURNS
5036  *    Success: S_OK
5037  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
5038  *             E_UNEXPECTED
5039  */
5040 DWORD WINAPI DDRAW_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
5041 {
5042     char buf[80],xbuf[80];
5043
5044     if (HIWORD(rclsid))
5045         WINE_StringFromCLSID(rclsid,xbuf);
5046     else
5047         sprintf(xbuf,"<guid-0x%04x>",LOWORD(rclsid));
5048     if (HIWORD(riid))
5049         WINE_StringFromCLSID(riid,buf);
5050     else
5051         sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
5052     WINE_StringFromCLSID(riid,xbuf);
5053     TRACE(ddraw, "(%p,%p,%p)\n", xbuf, buf, ppv);
5054     if (!memcmp(riid,&IID_IClassFactory,sizeof(IID_IClassFactory))) {
5055         *ppv = (LPVOID)&DDRAW_CF;
5056         IClassFactory_AddRef((IClassFactory*)*ppv);
5057     return S_OK;
5058     }
5059     FIXME(ddraw, "(%p,%p,%p): no interface found.\n", xbuf, buf, ppv);
5060     return E_NOINTERFACE;
5061 }
5062
5063
5064 /*******************************************************************************
5065  * DllCanUnloadNow [DDRAW.12]  Determines whether the DLL is in use.
5066  *
5067  * RETURNS
5068  *    Success: S_OK
5069  *    Failure: S_FALSE
5070  */
5071 DWORD WINAPI DDRAW_DllCanUnloadNow(void)
5072 {
5073     FIXME(ddraw, "(void): stub\n");
5074     return S_FALSE;
5075 }