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

   1 /*              DirectDraw using DGA or Xlib
   2  *
   3  * Copyright 1997,1998 Marcus Meissner
   4  */
   5 /* When DirectVideo mode is enabled you can no longer use 'normal' X
   6  * applications nor can you switch to a virtual console. Also, enabling
   7  * only works, if you have switched to the screen where the application
   8  * is running.
   9  * Some ways to debug this stuff are:
  10  * - A terminal connected to the serial port. Can be bought used for cheap.
  11  *   (This is the method I am using.)
  12  * - Another machine connected over some kind of network.
  13  *
  14  * FIXME: The Xshm implementation has been temporarily removed. It will be
  15  * later reintegrated into the Xlib implementation.
  16  */
  17
  18 #include "config.h"
  19 #include <unistd.h>
  20 #include <assert.h>
  21 #include "ts_xlib.h"
  22 #include <sys/signal.h>
  23
  24 #include "windows.h"
  25 #include "winerror.h"
  26 #include "interfaces.h"
  27 #include "gdi.h"
  28 #include "heap.h"
  29 #include "ldt.h"
  30 #include "dc.h"
  31 #include "win.h"
  32 #include "miscemu.h"
  33 #include "ddraw.h"
  34 #include "d3d.h"
  35 #include "debug.h"
  36 #include "compobj.h"
  37 #include "spy.h"
  38 #include "message.h"
  39
  40 #ifdef HAVE_LIBXXF86DGA
  41 #include "ts_xf86dga.h"
  42 #endif
  43
  44 /* define this if you want to play Diablo using XF86DGA. (bug workaround) */
  45 #undef DIABLO_HACK
  46
  47 /* restore signal handlers overwritten by XF86DGA
  48  * this is a define, for it will only work in emulator mode
  49  */
  50 #undef RESTORE_SIGNALS
  51
  52 /* Where do these GUIDs come from?  mkuuid.
  53  * They exist solely to distinguish between the targets Wine support,
  54  * and should be different than any other GUIDs in existence.
  55  */
  56 static GUID DGA_DirectDraw_GUID = { /* e2dcb020-dc60-11d1-8407-9714f5d50802 */
  57         0xe2dcb020,
  58         0xdc60,
  59         0x11d1,
  60         {0x84, 0x07, 0x97, 0x14, 0xf5, 0xd5, 0x08, 0x02}
  61 };
  62
  63 static GUID XLIB_DirectDraw_GUID = { /* 1574a740-dc61-11d1-8407-f7875a7d1879 */
  64     0x1574a740,
  65     0xdc61,
  66     0x11d1,
  67     {0x84, 0x07, 0xf7, 0x87, 0x5a, 0x7d, 0x18, 0x79}
  68 };
  69
  70 static struct IDirectDrawSurface3_VTable        dga_dds3vt, xlib_dds3vt;
  71 static struct IDirectDraw_VTable                dga_ddvt, xlib_ddvt;
  72 static struct IDirectDraw2_VTable               dga_dd2vt, xlib_dd2vt;
  73 static struct IDirectDrawClipper_VTable ddclipvt;
  74 static struct IDirectDrawPalette_VTable dga_ddpalvt, xlib_ddpalvt;
  75 static struct IDirect3D_VTable                  d3dvt;
  76 static struct IDirect3D2_VTable                 d3d2vt;
  77
  78 void Xlib_MessagePump(HWND32 hwnd) {
  79         MSG32   msg32;
  80
  81         while (EVENT_WaitNetEvent(FALSE,FALSE)) {
  82                 while (PeekMessage32A(&msg32,0,0,0,0)) {
  83                         GetMessage32A(&msg32,0,0,0);
  84                         TranslateMessage32(&msg32);
  85                         DispatchMessage32A(&msg32);
  86                 }
  87         }
  88 }
  89
  90 BOOL32
  91 DDRAW_DGA_Available()
  92 {
  93 #ifdef HAVE_LIBXXF86DGA
  94         int evbase, evret;
  95         return (getuid() == 0)&&TSXF86DGAQueryExtension(display,&evbase,&evret);
  96 #else /* defined(HAVE_LIBXXF86DGA) */
  97         return 0;
  98 #endif /* defined(HAVE_LIBXXF86DGA) */
  99 }
 100
 101 HRESULT WINAPI
 102 DirectDrawEnumerate32A(LPDDENUMCALLBACK32A ddenumproc,LPVOID data) {
 103         if (DDRAW_DGA_Available()) {
 104                 ddenumproc(&DGA_DirectDraw_GUID,"WINE with XFree86 DGA","display",data);
 105         }
 106         ddenumproc(&XLIB_DirectDraw_GUID,"WINE with Xlib","display",data);
 107         ddenumproc(NULL,"WINE","display",data);
 108         return 0;
 109 }
 110
 111 /* What is this doing here? */
 112 HRESULT WINAPI
 113 DSoundHelp(DWORD x,DWORD y,DWORD z) {
 114         FIXME(ddraw,"(0x%08lx,0x%08lx,0x%08lx),stub!\n",x,y,z);
 115         return 0;
 116 }
 117
 118
 119 /******************************************************************************
 120  *              internal helper functions
 121  */
 122 static void _dump_DDBLTFX(DWORD flagmask) {
 123         int     i;
 124         const struct {
 125                 DWORD   mask;
 126                 char    *name;
 127         } flags[] = {
 128 #define FE(x) { x, #x},
 129                 FE(DDBLTFX_ARITHSTRETCHY)
 130                 FE(DDBLTFX_MIRRORLEFTRIGHT)
 131                 FE(DDBLTFX_MIRRORUPDOWN)
 132                 FE(DDBLTFX_NOTEARING)
 133                 FE(DDBLTFX_ROTATE180)
 134                 FE(DDBLTFX_ROTATE270)
 135                 FE(DDBLTFX_ROTATE90)
 136                 FE(DDBLTFX_ZBUFFERRANGE)
 137                 FE(DDBLTFX_ZBUFFERBASEDEST)
 138         };
 139         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 140            if (flags[i].mask & flagmask) {
 141               DUMP("%s ",flags[i].name);
 142
 143            };
 144         DUMP("\n");
 145
 146 }
 147
 148 static void _dump_DDBLTFAST(DWORD flagmask) {
 149         int     i;
 150         const struct {
 151                 DWORD   mask;
 152                 char    *name;
 153         } flags[] = {
 154 #define FE(x) { x, #x},
 155                 FE(DDBLTFAST_NOCOLORKEY)
 156                 FE(DDBLTFAST_SRCCOLORKEY)
 157                 FE(DDBLTFAST_DESTCOLORKEY)
 158                 FE(DDBLTFAST_WAIT)
 159         };
 160         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 161                 if (flags[i].mask & flagmask)
 162                         DUMP("%s ",flags[i].name);
 163         DUMP("\n");
 164 }
 165
 166 static void _dump_DDBLT(DWORD flagmask) {
 167         int     i;
 168         const struct {
 169                 DWORD   mask;
 170                 char    *name;
 171         } flags[] = {
 172 #define FE(x) { x, #x},
 173                 FE(DDBLT_ALPHADEST)
 174                 FE(DDBLT_ALPHADESTCONSTOVERRIDE)
 175                 FE(DDBLT_ALPHADESTNEG)
 176                 FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
 177                 FE(DDBLT_ALPHAEDGEBLEND)
 178                 FE(DDBLT_ALPHASRC)
 179                 FE(DDBLT_ALPHASRCCONSTOVERRIDE)
 180                 FE(DDBLT_ALPHASRCNEG)
 181                 FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
 182                 FE(DDBLT_ASYNC)
 183                 FE(DDBLT_COLORFILL)
 184                 FE(DDBLT_DDFX)
 185                 FE(DDBLT_DDROPS)
 186                 FE(DDBLT_KEYDEST)
 187                 FE(DDBLT_KEYDESTOVERRIDE)
 188                 FE(DDBLT_KEYSRC)
 189                 FE(DDBLT_KEYSRCOVERRIDE)
 190                 FE(DDBLT_ROP)
 191                 FE(DDBLT_ROTATIONANGLE)
 192                 FE(DDBLT_ZBUFFER)
 193                 FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
 194                 FE(DDBLT_ZBUFFERDESTOVERRIDE)
 195                 FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
 196                 FE(DDBLT_ZBUFFERSRCOVERRIDE)
 197                 FE(DDBLT_WAIT)
 198                 FE(DDBLT_DEPTHFILL)
 199         };
 200         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 201                 if (flags[i].mask & flagmask)
 202                         DUMP("%s ",flags[i].name);
 203 }
 204
 205 static void _dump_DDSCAPS(DWORD flagmask) {
 206         int     i;
 207         const struct {
 208                 DWORD   mask;
 209                 char    *name;
 210         } flags[] = {
 211 #define FE(x) { x, #x},
 212                 FE(DDSCAPS_RESERVED1)
 213                 FE(DDSCAPS_ALPHA)
 214                 FE(DDSCAPS_BACKBUFFER)
 215                 FE(DDSCAPS_COMPLEX)
 216                 FE(DDSCAPS_FLIP)
 217                 FE(DDSCAPS_FRONTBUFFER)
 218                 FE(DDSCAPS_OFFSCREENPLAIN)
 219                 FE(DDSCAPS_OVERLAY)
 220                 FE(DDSCAPS_PALETTE)
 221                 FE(DDSCAPS_PRIMARYSURFACE)
 222                 FE(DDSCAPS_PRIMARYSURFACELEFT)
 223                 FE(DDSCAPS_SYSTEMMEMORY)
 224                 FE(DDSCAPS_TEXTURE)
 225                 FE(DDSCAPS_3DDEVICE)
 226                 FE(DDSCAPS_VIDEOMEMORY)
 227                 FE(DDSCAPS_VISIBLE)
 228                 FE(DDSCAPS_WRITEONLY)
 229                 FE(DDSCAPS_ZBUFFER)
 230                 FE(DDSCAPS_OWNDC)
 231                 FE(DDSCAPS_LIVEVIDEO)
 232                 FE(DDSCAPS_HWCODEC)
 233                 FE(DDSCAPS_MODEX)
 234                 FE(DDSCAPS_MIPMAP)
 235                 FE(DDSCAPS_RESERVED2)
 236                 FE(DDSCAPS_ALLOCONLOAD)
 237                 FE(DDSCAPS_VIDEOPORT)
 238                 FE(DDSCAPS_LOCALVIDMEM)
 239                 FE(DDSCAPS_NONLOCALVIDMEM)
 240                 FE(DDSCAPS_STANDARDVGAMODE)
 241                 FE(DDSCAPS_OPTIMIZED)
 242         };
 243         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 244                 if (flags[i].mask & flagmask)
 245                         DUMP("%s ",flags[i].name);
 246         DUMP("\n");
 247 }
 248
 249 static void _dump_DDSD(DWORD flagmask) {
 250         int     i;
 251         const struct {
 252                 DWORD   mask;
 253                 char    *name;
 254         } flags[] = {
 255                 FE(DDSD_CAPS)
 256                 FE(DDSD_HEIGHT)
 257                 FE(DDSD_WIDTH)
 258                 FE(DDSD_PITCH)
 259                 FE(DDSD_BACKBUFFERCOUNT)
 260                 FE(DDSD_ZBUFFERBITDEPTH)
 261                 FE(DDSD_ALPHABITDEPTH)
 262                 FE(DDSD_PIXELFORMAT)
 263                 FE(DDSD_CKDESTOVERLAY)
 264                 FE(DDSD_CKDESTBLT)
 265                 FE(DDSD_CKSRCOVERLAY)
 266                 FE(DDSD_CKSRCBLT)
 267                 FE(DDSD_MIPMAPCOUNT)
 268                 FE(DDSD_REFRESHRATE)
 269                 FE(DDSD_LINEARSIZE)
 270                 FE(DDSD_LPSURFACE)
 271         };
 272         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 273                 if (flags[i].mask & flagmask)
 274                         DUMP("%s ",flags[i].name);
 275         DUMP("\n");
 276 }
 277
 278 static int _getpixelformat(LPDIRECTDRAW2 ddraw,LPDDPIXELFORMAT pf) {
 279         static XVisualInfo      *vi;
 280         XVisualInfo             vt;
 281         int                     nitems;
 282
 283         if (!vi)
 284                 vi = TSXGetVisualInfo(display,VisualNoMask,&vt,&nitems);
 285
 286         pf->dwFourCC = 0;
 287         if (ddraw->d.depth==8) {
 288                 pf->dwFlags             = DDPF_RGB|DDPF_PALETTEINDEXED8;
 289                 pf->x.dwRGBBitCount     = 8;
 290                 pf->y.dwRBitMask        = 0;
 291                 pf->z.dwGBitMask        = 0;
 292                 pf->xx.dwBBitMask       = 0;
 293                 pf->xy.dwRGBAlphaBitMask= 0;
 294                 return 0;
 295         }
 296         if (ddraw->d.depth==16) {
 297                 pf->dwFlags             = DDPF_RGB;
 298                 pf->x.dwRGBBitCount     = 16;
 299                 pf->y.dwRBitMask        = vi[0].red_mask;
 300                 pf->z.dwGBitMask        = vi[0].green_mask;
 301                 pf->xx.dwBBitMask       = vi[0].blue_mask;
 302                 pf->xy.dwRGBAlphaBitMask= 0;
 303                 return 0;
 304         }
 305         FIXME(ddraw,"_getpixelformat:unknown depth %ld?\n",ddraw->d.depth);
 306         return DDERR_GENERIC;
 307 }
 308
 309 /******************************************************************************
 310  *              IDirectDrawSurface,IDirectDrawSurface2,IDirectDrawSurface3
 311  *
 312  * Since DDS3 and DDS2 are supersets of DDS, we implement DDS3 and let
 313  * DDS and DDS2 use those functions. (Function calls did not change (except
 314  * using different DirectDrawSurfaceX version), just added flags and functions)
 315  */
 316 static HRESULT WINAPI IDirectDrawSurface3_Lock(
 317     LPDIRECTDRAWSURFACE3 this,LPRECT32 lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE32 hnd
 318 ) {
 319         TRACE(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 320                 this,lprect,lpddsd,flags,(DWORD)hnd);
 321         if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
 322             WARN(ddraw, "(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 323                          this,lprect,lpddsd,flags,(DWORD)hnd);
 324
 325         if (lprect) {
 326                 FIXME(ddraw,"   lprect: %dx%d-%dx%d\n",
 327                         lprect->top,lprect->left,lprect->bottom,lprect->right
 328                 );
 329                 lpddsd->y.lpSurface = this->s.surface +
 330                         (lprect->top*this->s.lpitch) +
 331                         (lprect->left*(this->s.ddraw->d.depth/8));
 332         } else {
 333                 assert(this->s.surface);
 334                 lpddsd->y.lpSurface = this->s.surface;
 335         }
 336         lpddsd->dwFlags = DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_LPSURFACE;
 337         lpddsd->dwWidth         = this->s.width;
 338         lpddsd->dwHeight        = this->s.height;
 339         lpddsd->lPitch          = this->s.lpitch;
 340         _getpixelformat(this->s.ddraw,&(lpddsd->ddpfPixelFormat));
 341         return 0;
 342 }
 343
 344 static HRESULT WINAPI DGA_IDirectDrawSurface3_Unlock(
 345         LPDIRECTDRAWSURFACE3 this,LPVOID surface
 346 ) {
 347         TRACE(ddraw,"(%p)->Unlock(%p)\n",this,surface);
 348         return 0;
 349 }
 350
 351 static HRESULT WINAPI Xlib_IDirectDrawSurface3_Unlock(
 352         LPDIRECTDRAWSURFACE3 this,LPVOID surface
 353 ) {
 354         Xlib_MessagePump(this->s.ddraw->e.xlib.window);
 355
 356         TRACE(ddraw,"(%p)->Unlock(%p)\n",this,surface);
 357
 358         if (!this->s.ddraw->e.xlib.paintable)
 359         {
 360                 return DD_OK;
 361         }
 362
 363         TSXPutImage(            display,
 364                                 this->s.ddraw->e.xlib.drawable,
 365                                 DefaultGCOfScreen(screen),
 366                                 this->t.xlib.image,
 367                                 0, 0, 0, 0,
 368                                 this->t.xlib.image->width,
 369                                 this->t.xlib.image->height
 370         );
 371         if (this->s.palette && this->s.palette->cm)
 372                 TSXSetWindowColormap(display,this->s.ddraw->e.xlib.drawable,this->s.palette->cm);
 373
 374         return DD_OK;
 375 }
 376
 377 static HRESULT WINAPI DGA_IDirectDrawSurface3_Flip(
 378         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWSURFACE3 flipto,DWORD dwFlags
 379 ) {
 380 #ifdef HAVE_LIBXXF86DGA
 381         TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",this,flipto,dwFlags);
 382         if (!flipto) {
 383                 if (this->s.backbuffer)
 384                         flipto = this->s.backbuffer;
 385                 else
 386                         flipto = this;
 387         }
 388         TSXF86DGASetViewPort(display,DefaultScreen(display),0,flipto->t.dga.fb_height);
 389
 390         if (flipto->s.palette && flipto->s.palette->cm) {
 391                 TSXF86DGAInstallColormap(display,DefaultScreen(display),flipto->s.palette->cm);
 392         }
 393         while (!TSXF86DGAViewPortChanged(display,DefaultScreen(display),2)) {
 394         }
 395         if (flipto!=this) {
 396                 int     tmp;
 397                 LPVOID  ptmp;
 398
 399                 tmp = this->t.dga.fb_height;
 400                 this->t.dga.fb_height = flipto->t.dga.fb_height;
 401                 flipto->t.dga.fb_height = tmp;
 402
 403                 ptmp = this->s.surface;
 404                 this->s.surface = flipto->s.surface;
 405                 flipto->s.surface = ptmp;
 406         }
 407         return 0;
 408 #else /* defined(HAVE_LIBXXF86DGA) */
 409         return E_UNEXPECTED;
 410 #endif /* defined(HAVE_LIBXXF86DGA) */
 411 }
 412
 413 static HRESULT WINAPI Xlib_IDirectDrawSurface3_Flip(
 414         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWSURFACE3 flipto,DWORD dwFlags
 415 ) {
 416         TRACE(ddraw,"(%p)->Flip(%p,%08lx)\n",this,flipto,dwFlags);
 417         Xlib_MessagePump(this->s.ddraw->e.xlib.window);
 418         if (!this->s.ddraw->e.xlib.paintable)
 419                 return 0;
 420
 421         if (!flipto) {
 422                 if (this->s.backbuffer)
 423                         flipto = this->s.backbuffer;
 424                 else
 425                         flipto = this;
 426         }
 427
 428         TSXPutImage(display,
 429                                 this->s.ddraw->e.xlib.drawable,
 430                                 DefaultGCOfScreen(screen),
 431                                 flipto->t.xlib.image,
 432                                 0, 0, 0, 0,
 433                                 flipto->t.xlib.image->width,
 434                                 flipto->t.xlib.image->height);
 435         TSXSetWindowColormap(display,this->s.ddraw->e.xlib.drawable,this->s.palette->cm);
 436         if (flipto!=this) {
 437                 XImage *tmp;
 438                 LPVOID  *surf;
 439                 tmp = this->t.xlib.image;
 440                 this->t.xlib.image = flipto->t.xlib.image;
 441                 flipto->t.xlib.image = tmp;
 442                 surf = this->s.surface;
 443                 this->s.surface = flipto->s.surface;
 444                 flipto->s.surface = surf;
 445         }
 446         return 0;
 447 }
 448
 449 /* The IDirectDrawSurface3::SetPalette method attaches the specified
 450  * DirectDrawPalette object to a surface. The surface uses this palette for all
 451  * subsequent operations. The palette change takes place immediately.
 452  */
 453 static HRESULT WINAPI Xlib_IDirectDrawSurface3_SetPalette(
 454         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWPALETTE pal
 455 ) {
 456         TRACE(ddraw,"(%p)->SetPalette(%p)\n",this,pal);
 457
 458         /* According to spec, we are only supposed to
 459          * AddRef if this is not the same palette.
 460          */
 461         if( this->s.palette != pal )
 462         {
 463           if( pal != NULL )
 464             pal->lpvtbl->fnAddRef( pal );
 465           if( this->s.palette != NULL )
 466             this->s.palette->lpvtbl->fnRelease( this->s.palette );
 467           this->s.palette = pal;
 468
 469           /* I think that we need to attach it to all backbuffers...*/
 470           if( this->s.backbuffer ) {
 471              if( this->s.backbuffer->s.palette )
 472                this->s.backbuffer->s.palette->lpvtbl->fnRelease(
 473                  this->s.backbuffer->s.palette );
 474              this->s.backbuffer->s.palette = pal;
 475              if( pal )
 476                 pal->lpvtbl->fnAddRef( pal );
 477            }
 478
 479           /* Perform the refresh */
 480           TSXSetWindowColormap(display,this->s.ddraw->e.xlib.drawable,this->s.palette->cm);
 481         }
 482
 483         return 0;
 484 }
 485
 486 static HRESULT WINAPI DGA_IDirectDrawSurface3_SetPalette(
 487         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWPALETTE pal
 488 ) {
 489         TRACE(ddraw,"(%p)->SetPalette(%p)\n",this,pal);
 490
 491         /* According to spec, we are only supposed to
 492          * AddRef if this is not the same palette.
 493          */
 494         if( this->s.palette != pal )
 495         {
 496           if( pal != NULL )
 497                 pal->lpvtbl->fnAddRef( pal );
 498           if( this->s.palette != NULL )
 499             this->s.palette->lpvtbl->fnRelease( this->s.palette );
 500           this->s.palette = pal;
 501
 502           /* I think that we need to attach it to all backbuffers...*/
 503           if( this->s.backbuffer ) {
 504              if( this->s.backbuffer->s.palette )
 505                this->s.backbuffer->s.palette->lpvtbl->fnRelease(this->s.backbuffer->s.palette );
 506              this->s.backbuffer->s.palette = pal;
 507              if( pal ) pal->lpvtbl->fnAddRef( pal );
 508           }
 509           TSXF86DGAInstallColormap(display,DefaultScreen(display),this->s.palette->cm);
 510         }
 511         return 0;
 512 }
 513
 514 static HRESULT WINAPI IDirectDrawSurface3_Blt(
 515         LPDIRECTDRAWSURFACE3 this,LPRECT32 rdst,LPDIRECTDRAWSURFACE3 src,LPRECT32 rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
 516 ) {
 517         RECT32  xdst,xsrc;
 518         int     i,j;
 519
 520         if (rdst) {
 521                 memcpy(&xdst,rdst,sizeof(xdst));
 522         } else {
 523                 xdst.top        = 0;
 524                 xdst.bottom     = this->s.height;
 525                 xdst.left       = 0;
 526                 xdst.right      = this->s.width;
 527         }
 528
 529         if (rsrc) {
 530                 memcpy(&xsrc,rsrc,sizeof(xsrc));
 531         } else if (src) {
 532                 xsrc.top        = 0;
 533                 xsrc.bottom     = src->s.height;
 534                 xsrc.left       = 0;
 535                 xsrc.right      = src->s.width;
 536         }
 537
 538         if (dwFlags & DDBLT_COLORFILL) {
 539                 int     bpp = this->s.ddraw->d.depth/8;
 540                 LPBYTE  xline,xpixel;
 541
 542                 xline = (LPBYTE)this->s.surface+xdst.top*this->s.lpitch;
 543                 for (i=xdst.top;i<xdst.bottom;i++) {
 544                         xpixel = xline+bpp*xdst.left;
 545
 546                         for (j=xdst.left;j<xdst.right;j++) {
 547                                 /* FIXME: this only works on little endian
 548                                  * architectures, where DWORD starts with low
 549                                  * byte first!
 550                                  */
 551                                 memcpy(xpixel,&(lpbltfx->b.dwFillColor),bpp);
 552                                 xpixel += bpp;
 553                         }
 554                         xline += this->s.lpitch;
 555                 }
 556                 dwFlags &= ~(DDBLT_COLORFILL);
 557         }
 558         dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);/* FIXME: can't handle right now */
 559         if (    (xsrc.top ==0) && (xsrc.bottom ==this->s.height) &&
 560                 (xsrc.left==0) && (xsrc.right  ==this->s.width) &&
 561                 (xdst.top ==0) && (xdst.bottom ==this->s.height) &&
 562                 (xdst.left==0) && (xdst.right  ==this->s.width)  &&
 563                 !dwFlags
 564         ) {
 565                 memcpy(this->s.surface,src->s.surface,this->s.height*this->s.lpitch);
 566                 return 0;
 567         }
 568         if (dwFlags) {
 569                 FIXME(ddraw,"(%p)->(%p,%p,%p,%08lx,%p),stub!\n",
 570                         this,rdst,src,rsrc,dwFlags,lpbltfx
 571                 );
 572                 if (rdst) TRACE(ddraw," destrect :%dx%d-%dx%d\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
 573                 if (rsrc) TRACE(ddraw," srcrect  :%dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 574                 TRACE(ddraw,"\tflags: ");_dump_DDBLT(dwFlags);fprintf(stderr,"\n");
 575         }
 576         if (dwFlags & DDBLT_DDFX) {
 577                 TRACE(ddraw,"   blitfx: \n");_dump_DDBLTFX(lpbltfx->dwDDFX);
 578         }
 579         return 0;
 580 }
 581
 582 static HRESULT WINAPI IDirectDrawSurface3_BltFast(
 583         LPDIRECTDRAWSURFACE3 this,DWORD dstx,DWORD dsty,LPDIRECTDRAWSURFACE3 src,LPRECT32 rsrc,DWORD trans
 584 ) {
 585         int     i,bpp;
 586         if (TRACE_ON(ddraw)) {
 587             FIXME(ddraw,"(%p)->(%ld,%ld,%p,%p,%08lx),stub!\n",
 588                     this,dstx,dsty,src,rsrc,trans
 589             );
 590             TRACE(ddraw,"       trans:");_dump_DDBLTFAST(trans);fprintf(stderr,"\n");
 591             TRACE(ddraw,"       srcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 592         }
 593         bpp = this->s.ddraw->d.depth/8;
 594         for (i=0;i<rsrc->bottom-rsrc->top;i++) {
 595                 memcpy( this->s.surface+((i+dsty)*this->s.width*bpp)+dstx*bpp,
 596                         src->s.surface +(rsrc->top+i)*src->s.width*bpp+rsrc->left*bpp,
 597                         (rsrc->right-rsrc->left)*bpp
 598                 );
 599         }
 600         return 0;
 601 }
 602
 603 static HRESULT WINAPI IDirectDrawSurface3_BltBatch(
 604         LPDIRECTDRAWSURFACE3 this,LPDDBLTBATCH ddbltbatch,DWORD x,DWORD y
 605 ) {
 606         TRACE(ddraw,"(%p)->BltBatch(%p,%08lx,%08lx),stub!\n",
 607                 this,ddbltbatch,x,y
 608         );
 609         return 0;
 610 }
 611
 612 static HRESULT WINAPI IDirectDrawSurface3_GetCaps(
 613         LPDIRECTDRAWSURFACE3 this,LPDDSCAPS caps
 614 ) {
 615         TRACE(ddraw,"(%p)->GetCaps(%p)\n",this,caps);
 616         caps->dwCaps = DDCAPS_PALETTE; /* probably more */
 617         return 0;
 618 }
 619
 620 static HRESULT WINAPI IDirectDrawSurface3_GetSurfaceDesc(
 621         LPDIRECTDRAWSURFACE3 this,LPDDSURFACEDESC ddsd
 622 ) {
 623         if (TRACE_ON(ddraw)) {
 624                 TRACE(ddraw, "(%p)->GetSurfaceDesc(%p)\n",
 625                              this,ddsd);
 626                 fprintf(stderr,"        flags: ");
 627                 _dump_DDSD(ddsd->dwFlags);
 628                 fprintf(stderr,"\n");
 629         }
 630
 631         ddsd->dwFlags |= DDSD_PIXELFORMAT|DDSD_CAPS|DDSD_BACKBUFFERCOUNT|DDSD_HEIGHT|DDSD_WIDTH;
 632         ddsd->ddsCaps.dwCaps    = DDSCAPS_PALETTE;
 633         ddsd->dwBackBufferCount = 1;
 634         ddsd->dwHeight          = this->s.height;
 635         ddsd->dwWidth           = this->s.width;
 636         ddsd->lPitch            = this->s.lpitch;
 637         if (this->s.backbuffer)
 638                 ddsd->ddsCaps.dwCaps |= DDSCAPS_PRIMARYSURFACE|DDSCAPS_FLIP;
 639         _getpixelformat(this->s.ddraw,&(ddsd->ddpfPixelFormat));
 640
 641         return 0;
 642 }
 643
 644 static ULONG WINAPI IDirectDrawSurface3_AddRef(LPDIRECTDRAWSURFACE3 this) {
 645         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
 646
 647         return ++(this->ref);
 648 }
 649
 650 static ULONG WINAPI DGA_IDirectDrawSurface3_Release(LPDIRECTDRAWSURFACE3 this) {
 651         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
 652
 653 #ifdef HAVE_LIBXXF86DGA
 654         if (!--(this->ref)) {
 655                 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
 656                 /* clear out of surface list */
 657                 if (this->t.dga.fb_height == -1) {
 658                         HeapFree(GetProcessHeap(),0,this->s.surface);
 659                 } else {
 660                         this->s.ddraw->e.dga.vpmask &= ~(1<<(this->t.dga.fb_height/this->s.ddraw->e.dga.fb_height));
 661                 }
 662                 HeapFree(GetProcessHeap(),0,this);
 663                 return 0;
 664         }
 665 #endif /* defined(HAVE_LIBXXF86DGA) */
 666         return this->ref;
 667 }
 668
 669 static ULONG WINAPI Xlib_IDirectDrawSurface3_Release(LPDIRECTDRAWSURFACE3 this) {
 670         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
 671
 672         if (!--(this->ref)) {
 673                 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
 674                 HeapFree(GetProcessHeap(),0,this->s.surface);
 675
 676                 if( this->s.backbuffer )
 677                 {
 678                   this->s.backbuffer->lpvtbl->fnRelease(this->s.backbuffer);
 679                 }
 680
 681                 this->t.xlib.image->data = NULL;
 682                 TSXDestroyImage(this->t.xlib.image);
 683                 this->t.xlib.image = 0;
 684
 685                 if (this->s.palette)
 686                         this->s.palette->lpvtbl->fnRelease(this->s.palette);
 687
 688
 689                 HeapFree(GetProcessHeap(),0,this);
 690                 return 0;
 691         }
 692         return this->ref;
 693 }
 694
 695 static HRESULT WINAPI IDirectDrawSurface3_GetAttachedSurface(
 696         LPDIRECTDRAWSURFACE3 this,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE3 *lpdsf
 697 ) {
 698         TRACE(ddraw, "(%p)->GetAttachedSurface(%p,%p)\n",
 699                      this, lpddsd, lpdsf);
 700
 701         if (TRACE_ON(ddraw)) {
 702                 TRACE(ddraw,"   caps ");
 703                 _dump_DDSCAPS(lpddsd->dwCaps);
 704         }
 705
 706         if (!(lpddsd->dwCaps & DDSCAPS_BACKBUFFER)) {
 707                 FIXME(ddraw,"whoops, can only handle backbuffers for now\n");
 708                 return E_FAIL;
 709         }
 710
 711         /* FIXME: should handle more than one backbuffer */
 712         *lpdsf = this->s.backbuffer;
 713
 714         if( this->s.backbuffer )
 715         {
 716           this->s.backbuffer->lpvtbl->fnAddRef( this->s.backbuffer );
 717         }
 718
 719         return 0;
 720 }
 721
 722 static HRESULT WINAPI IDirectDrawSurface3_Initialize(
 723         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAW ddraw,LPDDSURFACEDESC lpdsfd
 724 ) {
 725         return DDERR_ALREADYINITIALIZED;
 726 }
 727
 728 static HRESULT WINAPI IDirectDrawSurface3_GetPixelFormat(
 729         LPDIRECTDRAWSURFACE3 this,LPDDPIXELFORMAT pf
 730 ) {
 731         return _getpixelformat(this->s.ddraw,pf);
 732 }
 733
 734 static HRESULT WINAPI IDirectDrawSurface3_GetBltStatus(LPDIRECTDRAWSURFACE3 this,DWORD dwFlags) {
 735         FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",this,dwFlags);
 736         return 0;
 737 }
 738
 739 static HRESULT WINAPI IDirectDrawSurface3_GetOverlayPosition(
 740         LPDIRECTDRAWSURFACE3 this,LPLONG x1,LPLONG x2
 741 ) {
 742         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,x1,x2);
 743         return 0;
 744 }
 745
 746 static HRESULT WINAPI IDirectDrawSurface3_SetClipper(
 747         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWCLIPPER clipper
 748 ) {
 749         FIXME(ddraw,"(%p)->(%p),stub!\n",this,clipper);
 750         return 0;
 751 }
 752
 753 static HRESULT WINAPI IDirectDrawSurface3_AddAttachedSurface(
 754         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWSURFACE3 surf
 755 ) {
 756         FIXME(ddraw,"(%p)->(%p),stub!\n",this,surf);
 757         this->s.backbuffer = surf;
 758         return 0;
 759 }
 760
 761 static HRESULT WINAPI IDirectDrawSurface3_GetDC(LPDIRECTDRAWSURFACE3 this,HDC32* lphdc) {
 762         FIXME(ddraw,"(%p)->GetDC(%p)\n",this,lphdc);
 763         *lphdc = BeginPaint32(this->s.ddraw->e.xlib.window,&this->s.ddraw->e.xlib.ps);
 764         return 0;
 765 }
 766
 767 static HRESULT WINAPI IDirectDrawSurface3_ReleaseDC(LPDIRECTDRAWSURFACE3 this,HDC32 hdc) {
 768         FIXME(ddraw,"(%p)->(0x%08lx),stub!\n",this,(long)hdc);
 769         EndPaint32(this->s.ddraw->e.xlib.window,&this->s.ddraw->e.xlib.ps);
 770         return 0;
 771 }
 772
 773
 774 static HRESULT WINAPI IDirectDrawSurface3_QueryInterface(LPDIRECTDRAWSURFACE3 this,REFIID refiid,LPVOID *obj) {
 775         char    xrefiid[50];
 776
 777         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 778         TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
 779
 780         /* DirectDrawSurface,DirectDrawSurface2 and DirectDrawSurface3 use
 781          * the same interface. And IUnknown does that too of course.
 782          */
 783         if (    !memcmp(&IID_IDirectDrawSurface3,refiid,sizeof(IID))    ||
 784                 !memcmp(&IID_IDirectDrawSurface2,refiid,sizeof(IID))    ||
 785                 !memcmp(&IID_IDirectDrawSurface,refiid,sizeof(IID))     ||
 786                 !memcmp(&IID_IUnknown,refiid,sizeof(IID))
 787         ) {
 788                 *obj = this;
 789                 this->lpvtbl->fnAddRef(this);
 790                 return 0;
 791         }
 792         FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",this,xrefiid);
 793         return OLE_E_ENUM_NOMORE;
 794 }
 795
 796 static HRESULT WINAPI IDirectDrawSurface3_IsLost(LPDIRECTDRAWSURFACE3 this) {
 797         TRACE(ddraw,"(%p)->(), stub!\n",this);
 798         return 0; /* hmm */
 799 }
 800
 801 static HRESULT WINAPI IDirectDrawSurface3_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE3 this,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
 802         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,context,esfcb);
 803         return 0;
 804 }
 805
 806 static HRESULT WINAPI IDirectDrawSurface3_Restore(LPDIRECTDRAWSURFACE3 this) {
 807         FIXME(ddraw,"(%p)->(),stub!\n",this);
 808         return 0;
 809 }
 810
 811 static HRESULT WINAPI IDirectDrawSurface3_SetColorKey(
 812         LPDIRECTDRAWSURFACE3 this, DWORD dwFlags, LPDDCOLORKEY ckey
 813 ) {
 814         FIXME(ddraw,"(%p)->(0x%08lx,%p),stub!\n",this,dwFlags,ckey);
 815
 816         if( dwFlags & DDCKEY_SRCBLT )
 817         {
 818            dwFlags &= ~DDCKEY_SRCBLT;
 819         }
 820
 821         if( dwFlags )
 822         {
 823           TRACE( ddraw, "unhandled dwFlags: %08lx\n", dwFlags );
 824         }
 825
 826         return DD_OK;
 827 }
 828
 829 static struct IDirectDrawSurface3_VTable dga_dds3vt = {
 830         IDirectDrawSurface3_QueryInterface,
 831         IDirectDrawSurface3_AddRef,
 832         DGA_IDirectDrawSurface3_Release,
 833         IDirectDrawSurface3_AddAttachedSurface,
 834         (void*)5,
 835         IDirectDrawSurface3_Blt,
 836         IDirectDrawSurface3_BltBatch,
 837         IDirectDrawSurface3_BltFast,
 838         (void*)9,
 839         IDirectDrawSurface3_EnumAttachedSurfaces,
 840         (void*)11,
 841         DGA_IDirectDrawSurface3_Flip,
 842         IDirectDrawSurface3_GetAttachedSurface,
 843         IDirectDrawSurface3_GetBltStatus,
 844         IDirectDrawSurface3_GetCaps,
 845         (void*)16,
 846         (void*)17,
 847         IDirectDrawSurface3_GetDC,
 848         (void*)19,
 849         IDirectDrawSurface3_GetOverlayPosition,
 850         (void*)21,
 851         IDirectDrawSurface3_GetPixelFormat,
 852         IDirectDrawSurface3_GetSurfaceDesc,
 853         IDirectDrawSurface3_Initialize,
 854         IDirectDrawSurface3_IsLost,
 855         IDirectDrawSurface3_Lock,
 856         IDirectDrawSurface3_ReleaseDC,
 857         IDirectDrawSurface3_Restore,
 858         IDirectDrawSurface3_SetClipper,
 859         IDirectDrawSurface3_SetColorKey,
 860         (void*)31,
 861         DGA_IDirectDrawSurface3_SetPalette,
 862         DGA_IDirectDrawSurface3_Unlock,
 863         (void*)34,
 864         (void*)35,
 865         (void*)36,
 866         (void*)37,
 867         (void*)38,
 868         (void*)39,
 869         (void*)40,
 870 };
 871
 872 static struct IDirectDrawSurface3_VTable xlib_dds3vt = {
 873         IDirectDrawSurface3_QueryInterface,
 874         IDirectDrawSurface3_AddRef,
 875         Xlib_IDirectDrawSurface3_Release,
 876         IDirectDrawSurface3_AddAttachedSurface,
 877         (void*)5,
 878         IDirectDrawSurface3_Blt,
 879         IDirectDrawSurface3_BltBatch,
 880         IDirectDrawSurface3_BltFast,
 881         (void*)9,
 882         IDirectDrawSurface3_EnumAttachedSurfaces,
 883         (void*)11,
 884         Xlib_IDirectDrawSurface3_Flip,
 885         IDirectDrawSurface3_GetAttachedSurface,
 886         IDirectDrawSurface3_GetBltStatus,
 887         IDirectDrawSurface3_GetCaps,
 888         (void*)16,
 889         (void*)17,
 890         IDirectDrawSurface3_GetDC,
 891         (void*)19,
 892         IDirectDrawSurface3_GetOverlayPosition,
 893         (void*)21,
 894         IDirectDrawSurface3_GetPixelFormat,
 895         IDirectDrawSurface3_GetSurfaceDesc,
 896         IDirectDrawSurface3_Initialize,
 897         IDirectDrawSurface3_IsLost,
 898         IDirectDrawSurface3_Lock,
 899         IDirectDrawSurface3_ReleaseDC,
 900         IDirectDrawSurface3_Restore,
 901         IDirectDrawSurface3_SetClipper,
 902         IDirectDrawSurface3_SetColorKey,
 903         (void*)31,
 904         Xlib_IDirectDrawSurface3_SetPalette,
 905         Xlib_IDirectDrawSurface3_Unlock,
 906         (void*)34,
 907         (void*)35,
 908         (void*)36,
 909         (void*)37,
 910         (void*)38,
 911         (void*)39,
 912         (void*)40,
 913 };
 914
 915 /******************************************************************************
 916  *                      IDirectDrawClipper
 917  */
 918 static HRESULT WINAPI IDirectDrawClipper_SetHwnd(
 919         LPDIRECTDRAWCLIPPER this,DWORD x,HWND32 hwnd
 920 ) {
 921         FIXME(ddraw,"(%p)->SetHwnd(0x%08lx,0x%08lx),stub!\n",this,x,(DWORD)hwnd);
 922         return 0;
 923 }
 924
 925 static ULONG WINAPI IDirectDrawClipper_Release(LPDIRECTDRAWCLIPPER this) {
 926         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
 927
 928         this->ref--;
 929         if (this->ref)
 930                 return this->ref;
 931         HeapFree(GetProcessHeap(),0,this);
 932         return 0;
 933 }
 934
 935 static HRESULT WINAPI IDirectDrawClipper_GetClipList(
 936         LPDIRECTDRAWCLIPPER this,LPRECT32 rects,LPRGNDATA lprgn,LPDWORD hmm
 937 ) {
 938         FIXME(ddraw,"(%p,%p,%p,%p),stub!\n",this,rects,lprgn,hmm);
 939         if (hmm) *hmm=0;
 940         return 0;
 941 }
 942
 943 static HRESULT WINAPI IDirectDrawClipper_SetClipList(
 944         LPDIRECTDRAWCLIPPER this,LPRGNDATA lprgn,DWORD hmm
 945 ) {
 946         FIXME(ddraw,"(%p,%p,%ld),stub!\n",this,lprgn,hmm);
 947         return 0;
 948 }
 949
 950 static struct IDirectDrawClipper_VTable ddclipvt = {
 951         (void*)1,
 952         (void*)2,
 953         IDirectDrawClipper_Release,
 954         IDirectDrawClipper_GetClipList,
 955         (void*)5,
 956         (void*)6,
 957         (void*)7,
 958         IDirectDrawClipper_SetClipList,
 959         IDirectDrawClipper_SetHwnd
 960 };
 961
 962 /******************************************************************************
 963  *                      IDirectDrawPalette
 964  */
 965 static HRESULT WINAPI IDirectDrawPalette_GetEntries(
 966         LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
 967 ) {
 968         XColor xc;
 969         int     i;
 970
 971         if (!this->cm) /* should not happen */ {
 972                 FIXME(ddraw,"app tried to read colormap for non-palettized mode\n");
 973                 return DDERR_GENERIC;
 974         }
 975         for (i=0;i<count;i++) {
 976 #if 0
 977 PH
 978                 xc.pixel = i+start;
 979                 TSXQueryColor(display,this->cm,&xc);
 980                 palent[i].peRed = xc.red>>8;
 981                 palent[i].peGreen = xc.green>>8;
 982                 palent[i].peBlue = xc.blue>>8;
 983 #endif
 984
 985                 palent[i].peRed   = this->palents[start+i].peRed;
 986                 palent[i].peBlue  = this->palents[start+i].peBlue;
 987                 palent[i].peGreen = this->palents[start+i].peGreen;
 988                 palent[i].peFlags = this->palents[start+i].peFlags;
 989
 990         }
 991         return 0;
 992 }
 993
 994 static HRESULT WINAPI Xlib_IDirectDrawPalette_SetEntries(
 995         LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
 996 ) {
 997         XColor          xc;
 998         int             i;
 999
1000         TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
1001                 this,x,start,count,palent
1002         );
1003         if (!this->cm) /* should not happen */ {
1004                 FIXME(ddraw,"app tried to set colormap in non-palettized mode\n");
1005                 return DDERR_GENERIC;
1006         }
1007         if (!this->ddraw->e.xlib.paintable)
1008                 return 0;
1009         for (i=0;i<count;i++) {
1010                 xc.red = palent[i].peRed<<8;
1011                 xc.blue = palent[i].peBlue<<8;
1012                 xc.green = palent[i].peGreen<<8;
1013                 xc.flags = DoRed|DoBlue|DoGreen;
1014                 xc.pixel = start+i;
1015
1016                 TSXStoreColor(display,this->cm,&xc);
1017
1018                 this->palents[start+i].peRed = palent[i].peRed;
1019                 this->palents[start+i].peBlue = palent[i].peBlue;
1020                 this->palents[start+i].peGreen = palent[i].peGreen;
1021                 this->palents[start+i].peFlags = palent[i].peFlags;
1022         }
1023         return 0;
1024 }
1025
1026 static HRESULT WINAPI DGA_IDirectDrawPalette_SetEntries(
1027         LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD count,LPPALETTEENTRY palent
1028 ) {
1029 #ifdef HAVE_LIBXXF86DGA
1030         XColor          xc;
1031         Colormap        cm;
1032         int             i;
1033
1034         TRACE(ddraw,"(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
1035                 this,x,start,count,palent
1036         );
1037         if (!this->cm) /* should not happen */ {
1038                 FIXME(ddraw,"app tried to set colormap in non-palettized mode\n");
1039                 return DDERR_GENERIC;
1040         }
1041         /* FIXME: free colorcells instead of freeing whole map */
1042         cm = this->cm;
1043         this->cm = TSXCopyColormapAndFree(display,this->cm);
1044         TSXFreeColormap(display,cm);
1045
1046         for (i=0;i<count;i++) {
1047                 xc.red = palent[i].peRed<<8;
1048                 xc.blue = palent[i].peBlue<<8;
1049                 xc.green = palent[i].peGreen<<8;
1050                 xc.flags = DoRed|DoBlue|DoGreen;
1051                 xc.pixel = i+start;
1052
1053                 TSXStoreColor(display,this->cm,&xc);
1054
1055                 this->palents[start+i].peRed = palent[i].peRed;
1056                 this->palents[start+i].peBlue = palent[i].peBlue;
1057                 this->palents[start+i].peGreen = palent[i].peGreen;
1058                 this->palents[start+i].peFlags = palent[i].peFlags;
1059         }
1060         TSXF86DGAInstallColormap(display,DefaultScreen(display),this->cm);
1061         return 0;
1062 #else /* defined(HAVE_LIBXXF86DGA) */
1063         return E_UNEXPECTED;
1064 #endif /* defined(HAVE_LIBXXF86DGA) */
1065 }
1066
1067 static ULONG WINAPI IDirectDrawPalette_Release(LPDIRECTDRAWPALETTE this) {
1068         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1069         if (!--(this->ref)) {
1070                 if (this->cm) {
1071                         TSXFreeColormap(display,this->cm);
1072                         this->cm = 0;
1073                 }
1074                 HeapFree(GetProcessHeap(),0,this);
1075                 return 0;
1076         }
1077         return this->ref;
1078 }
1079
1080 static ULONG WINAPI IDirectDrawPalette_AddRef(LPDIRECTDRAWPALETTE this) {
1081
1082         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1083         return ++(this->ref);
1084 }
1085
1086 static HRESULT WINAPI IDirectDrawPalette_Initialize(
1087         LPDIRECTDRAWPALETTE this,LPDIRECTDRAW ddraw,DWORD x,LPPALETTEENTRY palent
1088 ) {
1089         return DDERR_ALREADYINITIALIZED;
1090 }
1091
1092 static HRESULT WINAPI IDirectDrawPalette_GetCaps(
1093          LPDIRECTDRAWPALETTE this, LPDWORD lpdwCaps )
1094 {
1095    FIXME( ddraw, "(%p)->(%p) stub.\n", this, lpdwCaps );
1096    return DD_OK;
1097 }
1098
1099 static HRESULT WINAPI IDirectDrawPalette_QueryInterface(
1100         LPDIRECTDRAWPALETTE this,REFIID refiid,LPVOID *obj )
1101 {
1102   char    xrefiid[50];
1103
1104   WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1105   FIXME(ddraw,"(%p)->(%s,%p) stub.\n",this,xrefiid,obj);
1106
1107   return S_OK;
1108 }
1109
1110 static struct IDirectDrawPalette_VTable dga_ddpalvt = {
1111         IDirectDrawPalette_QueryInterface,
1112         IDirectDrawPalette_AddRef,
1113         IDirectDrawPalette_Release,
1114         IDirectDrawPalette_GetCaps,
1115         IDirectDrawPalette_GetEntries,
1116         IDirectDrawPalette_Initialize,
1117         DGA_IDirectDrawPalette_SetEntries
1118 };
1119
1120 static struct IDirectDrawPalette_VTable xlib_ddpalvt = {
1121         IDirectDrawPalette_QueryInterface,
1122         IDirectDrawPalette_AddRef,
1123         IDirectDrawPalette_Release,
1124         IDirectDrawPalette_GetCaps,
1125         IDirectDrawPalette_GetEntries,
1126         IDirectDrawPalette_Initialize,
1127         Xlib_IDirectDrawPalette_SetEntries
1128 };
1129
1130 static HRESULT WINAPI IDirect3D_QueryInterface(
1131         LPDIRECT3D this,REFIID refiid,LPVOID *obj
1132 ) {
1133         /* FIXME: Not sure if this is correct */
1134         char    xrefiid[50];
1135
1136         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1137         TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1138         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1139                 *obj = this;
1140                 this->lpvtbl->fnAddRef(this);
1141                 return 0;
1142         }
1143         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
1144                 LPDIRECT3D      d3d;
1145
1146                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1147                 d3d->ref = 1;
1148                 d3d->ddraw = (LPDIRECTDRAW)this;
1149                 this->lpvtbl->fnAddRef(this);
1150                 d3d->lpvtbl = &d3dvt;
1151                 *obj = d3d;
1152                 return 0;
1153         }
1154         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
1155                 LPDIRECT3D2     d3d;
1156
1157                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1158                 d3d->ref = 1;
1159                 d3d->ddraw = (LPDIRECTDRAW)this;
1160                 this->lpvtbl->fnAddRef(this);
1161                 d3d->lpvtbl = &d3d2vt;
1162                 *obj = d3d;
1163                 return 0;
1164         }
1165         FIXME(ddraw,"(%p):interface for IID %s NOT found!\n",this,xrefiid);
1166         return OLE_E_ENUM_NOMORE;
1167 }
1168
1169 static ULONG WINAPI IDirect3D_AddRef(LPDIRECT3D this) {
1170         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1171
1172         return ++(this->ref);
1173 }
1174
1175 static ULONG WINAPI IDirect3D_Release(LPDIRECT3D this)
1176 {
1177         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1178
1179         if (!--(this->ref)) {
1180                 this->ddraw->lpvtbl->fnRelease(this->ddraw);
1181                 HeapFree(GetProcessHeap(),0,this);
1182                 return 0;
1183         }
1184         return this->ref;
1185 }
1186
1187 static HRESULT WINAPI IDirect3D_Initialize(
1188          LPDIRECT3D this, REFIID refiid )
1189 {
1190   /* FIXME: Not sure if this is correct */
1191   char    xrefiid[50];
1192
1193   WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1194   FIXME(ddraw,"(%p)->(%s):stub.\n",this,xrefiid);
1195
1196   return DDERR_ALREADYINITIALIZED;
1197 }
1198
1199 /*******************************************************************************
1200  *                              IDirect3D
1201  */
1202 static struct IDirect3D_VTable d3dvt = {
1203         (void*)IDirect3D_QueryInterface,
1204         (void*)IDirect3D_AddRef,
1205         (void*)IDirect3D_Release,
1206         IDirect3D_Initialize,
1207         (void*)5,
1208         (void*)6,
1209         (void*)7,
1210         (void*)8,
1211         (void*)9,
1212 };
1213
1214 /*******************************************************************************
1215  *                              IDirect3D2
1216  */
1217 static ULONG WINAPI IDirect3D2_Release(LPDIRECT3D2 this) {
1218         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1219
1220         if (!--(this->ref)) {
1221                 this->ddraw->lpvtbl->fnRelease(this->ddraw);
1222                 HeapFree(GetProcessHeap(),0,this);
1223                 return 0;
1224         }
1225         return this->ref;
1226 }
1227
1228 static HRESULT WINAPI IDirect3D2_EnumDevices(
1229         LPDIRECT3D2 this,LPD3DENUMDEVICESCALLBACK cb, LPVOID context
1230 ) {
1231         D3DDEVICEDESC   d1,d2;
1232
1233         FIXME(ddraw,"(%p)->(%p,%p),stub!\n",this,cb,context);
1234         d1.dwSize       = sizeof(d1);
1235         d1.dwFlags      = 0;
1236
1237         d2.dwSize       = sizeof(d2);
1238         d2.dwFlags      = 0;
1239         cb((void*)&IID_IDirect3DHALDevice,"WINE Direct3D HAL","direct3d",&d1,&d2,context);
1240         return 0;
1241 }
1242
1243 static struct IDirect3D2_VTable d3d2vt = {
1244         (void*)1,
1245         (void*)2,
1246         IDirect3D2_Release,
1247         IDirect3D2_EnumDevices,
1248         (void*)5,
1249         (void*)6,
1250         (void*)7,
1251         (void*)8,
1252         (void*)9,
1253 };
1254
1255 /*******************************************************************************
1256  *                              IDirectDraw
1257  */
1258
1259 /* Used in conjunction with cbWndExtra for storage of the this ptr for the window.
1260  * Please adjust allocation in Xlib_DirectDrawCreate if you store more data here.
1261  */
1262 static INT32 ddrawXlibThisOffset = 0;
1263
1264 static HRESULT WINAPI DGA_IDirectDraw2_CreateSurface(
1265         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
1266 ) {
1267 #ifdef HAVE_LIBXXF86DGA
1268         int     i;
1269
1270         TRACE(ddraw, "(%p)->(%p,%p,%p)\n",this,lpddsd,lpdsf,lpunk);
1271         if (TRACE_ON(ddraw)) {
1272                 DUMP("[w=%ld,h=%ld,flags ",lpddsd->dwWidth,lpddsd->dwHeight);
1273                 _dump_DDSD(lpddsd->dwFlags);
1274                 fprintf(stderr,"caps ");
1275                 _dump_DDSCAPS(lpddsd->ddsCaps.dwCaps);
1276                 fprintf(stderr,"]\n");
1277         }
1278
1279         *lpdsf = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
1280         this->lpvtbl->fnAddRef(this);
1281         (*lpdsf)->ref = 1;
1282         (*lpdsf)->lpvtbl = (LPDIRECTDRAWSURFACE_VTABLE)&dga_dds3vt;
1283         if (    (lpddsd->dwFlags & DDSD_CAPS) &&
1284                 (lpddsd->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)
1285         ) {
1286                 if (!(lpddsd->dwFlags & DDSD_WIDTH))
1287                         lpddsd->dwWidth = this->e.dga.fb_width;
1288                 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
1289                         lpddsd->dwHeight = this->e.dga.fb_height;
1290                 (*lpdsf)->s.surface = (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpddsd->dwWidth*lpddsd->dwHeight*this->d.depth/8);
1291                 (*lpdsf)->t.dga.fb_height = -1;
1292                 (*lpdsf)->s.lpitch = lpddsd->dwWidth*this->d.depth/8;
1293                 TRACE(ddraw,"using system memory for a primary surface\n");
1294         } else {
1295                 for (i=0;i<32;i++)
1296                         if (!(this->e.dga.vpmask & (1<<i)))
1297                                 break;
1298                 TRACE(ddraw,"using viewport %d for a primary surface\n",i);
1299                 /* if i == 32 or maximum ... return error */
1300                 this->e.dga.vpmask|=(1<<i);
1301                 (*lpdsf)->s.surface = this->e.dga.fb_addr+((i*this->e.dga.fb_height)*this->e.dga.fb_width*this->d.depth/8);
1302                 (*lpdsf)->t.dga.fb_height = i*this->e.dga.fb_height;
1303                 (*lpdsf)->s.lpitch = this->e.dga.fb_width*this->d.depth/8;
1304         }
1305
1306         lpddsd->lPitch = (*lpdsf)->s.lpitch;
1307
1308         (*lpdsf)->s.width = this->d.width;
1309         (*lpdsf)->s.height = this->d.height;
1310         (*lpdsf)->s.ddraw = this;
1311         (*lpdsf)->s.backbuffer = NULL;
1312         if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
1313                 LPDIRECTDRAWSURFACE3    back;
1314
1315                 if (lpddsd->dwBackBufferCount>1)
1316                         FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
1317
1318                 (*lpdsf)->s.backbuffer = back = (LPDIRECTDRAWSURFACE3)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface3));
1319                 this->lpvtbl->fnAddRef(this);
1320                 back->ref = 1;
1321                 back->lpvtbl = (LPDIRECTDRAWSURFACE3_VTABLE)&dga_dds3vt;
1322                 for (i=0;i<32;i++)
1323                         if (!(this->e.dga.vpmask & (1<<i)))
1324                                 break;
1325                 TRACE(ddraw,"using viewport %d for backbuffer\n",i);
1326                 /* if i == 32 or maximum ... return error */
1327                 this->e.dga.vpmask|=(1<<i);
1328                 back->s.surface = this->e.dga.fb_addr+((i*this->e.dga.fb_height)*this->e.dga.fb_width*this->d.depth/8);
1329                 back->t.dga.fb_height = i*this->e.dga.fb_height;
1330
1331                 back->s.width = this->d.width;
1332                 back->s.height = this->d.height;
1333                 back->s.ddraw = this;
1334                 back->s.lpitch = this->e.dga.fb_width*this->d.depth/8;
1335                 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
1336                                             * one! */
1337         }
1338         return 0;
1339 #else /* defined(HAVE_LIBXXF86DGA) */
1340         return E_UNEXPECTED;
1341 #endif /* defined(HAVE_LIBXXF86DGA) */
1342 }
1343
1344 static HRESULT WINAPI Xlib_IDirectDraw2_CreateSurface(
1345         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
1346 ) {
1347         XImage *img;
1348
1349         TRACE(ddraw, "(%p)->CreateSurface(%p,%p,%p)\n",
1350                      this,lpddsd,lpdsf,lpunk);
1351
1352         if (TRACE_ON(ddraw)) {
1353                 fprintf(stderr,"[w=%ld,h=%ld,flags ",lpddsd->dwWidth,lpddsd->dwHeight);
1354                 _dump_DDSD(lpddsd->dwFlags);
1355                 fprintf(stderr,"caps ");
1356                 _dump_DDSCAPS(lpddsd->ddsCaps.dwCaps);
1357                 fprintf(stderr,"]\n");
1358         }
1359
1360         *lpdsf = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
1361
1362         this->lpvtbl->fnAddRef(this);
1363         (*lpdsf)->s.ddraw             = this;
1364         (*lpdsf)->ref                 = 1;
1365         (*lpdsf)->lpvtbl              = (LPDIRECTDRAWSURFACE_VTABLE)&xlib_dds3vt;
1366
1367         if (    (lpddsd->dwFlags & DDSD_CAPS) &&
1368                 (lpddsd->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)
1369         ) {
1370                 if (!(lpddsd->dwFlags & DDSD_WIDTH))
1371                         lpddsd->dwWidth = this->e.dga.fb_width;
1372                 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
1373                         lpddsd->dwHeight = this->e.dga.fb_height;
1374                 (*lpdsf)->s.surface = (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpddsd->dwWidth*lpddsd->dwHeight*this->d.depth/8);
1375                 TRACE(ddraw,"using system memory for a primary surface\n");
1376         } else {
1377                 TRACE(ddraw,"using standard XImage for a primary surface\n");
1378                         /* FIXME: !8 bit images */
1379                 if (!(lpddsd->dwFlags & DDSD_WIDTH))
1380                         lpddsd->dwWidth  = this->d.width;
1381                 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
1382                         lpddsd->dwHeight = this->d.height;
1383         }
1384         (*lpdsf)->s.surface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,lpddsd->dwHeight*lpddsd->dwWidth*this->d.depth/8);
1385         (*lpdsf)->s.width       = lpddsd->dwWidth;
1386         (*lpdsf)->s.height      = lpddsd->dwHeight;
1387
1388         {
1389         (*lpdsf)->t.xlib.image = img =
1390                 TSXCreateImage( display,
1391                                 DefaultVisualOfScreen(screen),
1392                                 /*FIXME: depth*/8,
1393                                 ZPixmap,
1394                                 0,
1395                                 (*lpdsf)->s.surface,
1396                                 (*lpdsf)->s.width,
1397                                 (*lpdsf)->s.height,
1398                                 32,
1399                                 (*lpdsf)->s.width*1
1400                 /* FIXME: !8 bit images */
1401                 );
1402                 /* END FIXME: Xlib */
1403         }
1404         (*lpdsf)->s.lpitch = img->bytes_per_line;
1405         if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
1406                 LPDIRECTDRAWSURFACE3    back;
1407
1408                 if (lpddsd->dwBackBufferCount>1)
1409                         FIXME(ddraw,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
1410
1411                 (*lpdsf)->s.backbuffer = back = (LPDIRECTDRAWSURFACE3)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface3));
1412
1413                 this->lpvtbl->fnAddRef(this);
1414                 back->s.ddraw = this;
1415
1416                 back->ref = 1;
1417                 back->lpvtbl = (LPDIRECTDRAWSURFACE3_VTABLE)&xlib_dds3vt;
1418                 /* FIXME: !8 bit images */
1419                 back->s.surface = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
1420                         img->width*img->height
1421                 );
1422                 back->t.xlib.image = TSXCreateImage(
1423                         display,
1424                         DefaultVisualOfScreen(screen),
1425                         /*FIXME: depth*/8,
1426                         ZPixmap,
1427                         0,
1428                         back->s.surface,
1429                         this->d.width,
1430                         this->d.height,
1431                         32,
1432                         this->d.width*1
1433                         /* FIXME: !8 bit images */
1434                 );
1435                 back->s.width = this->d.width;
1436                 back->s.height = this->d.height;
1437                 back->s.lpitch = back->t.xlib.image->bytes_per_line;
1438                 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
1439                                             * one! */
1440         }
1441         return 0;
1442 }
1443
1444 static HRESULT WINAPI IDirectDraw2_DuplicateSurface(
1445         LPDIRECTDRAW2 this,LPDIRECTDRAWSURFACE src,LPDIRECTDRAWSURFACE *dst
1446 ) {
1447         FIXME(ddraw,"(%p)->(%p,%p) simply copies\n",this,src,dst);
1448         *dst = src; /* FIXME */
1449         return 0;
1450 }
1451
1452 static HRESULT WINAPI IDirectDraw2_SetCooperativeLevel(
1453         LPDIRECTDRAW2 this,HWND32 hwnd,DWORD cooplevel
1454 ) {
1455         int     i;
1456         const struct {
1457                 int     mask;
1458                 char    *name;
1459         } flagmap[] = {
1460                 FE(DDSCL_FULLSCREEN)
1461                 FE(DDSCL_ALLOWREBOOT)
1462                 FE(DDSCL_NOWINDOWCHANGES)
1463                 FE(DDSCL_NORMAL)
1464                 FE(DDSCL_ALLOWMODEX)
1465                 FE(DDSCL_EXCLUSIVE)
1466                 FE(DDSCL_SETFOCUSWINDOW)
1467                 FE(DDSCL_SETDEVICEWINDOW)
1468                 FE(DDSCL_CREATEDEVICEWINDOW)
1469         };
1470
1471         TRACE(ddraw,"(%p)->(%08lx,%08lx)\n",this,(DWORD)hwnd,cooplevel);
1472         if(TRACE_ON(ddraw)){
1473           dbg_decl_str(ddraw, 512);
1474           for (i=0;i<sizeof(flagmap)/sizeof(flagmap[0]);i++)
1475             if (flagmap[i].mask & cooplevel)
1476               dsprintf(ddraw, "%s ", flagmap[i].name);
1477           TRACE(ddraw," cooperative level %s\n", dbg_str(ddraw));
1478         }
1479         this->d.mainWindow = hwnd;
1480         return 0;
1481 }
1482
1483
1484 static HRESULT WINAPI DGA_IDirectDraw_SetDisplayMode(
1485         LPDIRECTDRAW this,DWORD width,DWORD height,DWORD depth
1486 ) {
1487 #ifdef HAVE_LIBXXF86DGA
1488         int     i,*depths,depcount;
1489
1490         TRACE(ddraw, "(%p)->(%ld,%ld,%ld)\n", this, width, height, depth);
1491
1492         depths = TSXListDepths(display,DefaultScreen(display),&depcount);
1493         for (i=0;i<depcount;i++)
1494                 if (depths[i]==depth)
1495                         break;
1496         TSXFree(depths);
1497         if (i==depcount) {/* not found */
1498                 ERR(ddraw,"(w=%ld,h=%ld,d=%ld), unsupported depth!\n",width,height,depth);
1499                 return DDERR_UNSUPPORTEDMODE;
1500         }
1501         if (this->d.width < width) {
1502                 ERR(ddraw,"SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld\n",width,height,depth,width,this->d.width);
1503                 return DDERR_UNSUPPORTEDMODE;
1504         }
1505         this->d.width   = width;
1506         this->d.height  = height;
1507         /* adjust fb_height, so we don't overlap */
1508         if (this->e.dga.fb_height < height)
1509                 this->e.dga.fb_height = height;
1510         this->d.depth   = depth;
1511
1512         /* FIXME: this function OVERWRITES several signal handlers.
1513          * can we save them? and restore them later? In a way that
1514          * it works for the library too?
1515          */
1516         TSXF86DGADirectVideo(display,DefaultScreen(display),XF86DGADirectGraphics);
1517 #ifdef DIABLO_HACK
1518         TSXF86DGASetViewPort(display,DefaultScreen(display),0,this->e.dga.fb_height);
1519 #endif
1520
1521 #ifdef RESTORE_SIGNALS
1522         SIGNAL_InitEmulator();
1523 #endif
1524         return 0;
1525 #else /* defined(HAVE_LIBXXF86DGA) */
1526         return E_UNEXPECTED;
1527 #endif /* defined(HAVE_LIBXXF86DGA) */
1528 }
1529
1530 static HRESULT WINAPI Xlib_IDirectDraw_SetDisplayMode(
1531         LPDIRECTDRAW this,DWORD width,DWORD height,DWORD depth
1532 ) {
1533         int     i,*depths,depcount;
1534         char    buf[200];
1535
1536         TRACE(ddraw, "(%p)->SetDisplayMode(%ld,%ld,%ld)\n",
1537                       this, width, height, depth);
1538
1539         depths = TSXListDepths(display,DefaultScreen(display),&depcount);
1540         for (i=0;i<depcount;i++)
1541                 if (depths[i]==depth)
1542                         break;
1543         TSXFree(depths);
1544         if (i==depcount) {/* not found */
1545                 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
1546                 MessageBox32A(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
1547                 return DDERR_UNSUPPORTEDMODE;
1548         }
1549         /*
1550         if (this->d.width < width) {
1551                 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld",width,height,depth,width,this->d.width);
1552                 MessageBox32A(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
1553                 return DDERR_UNSUPPORTEDMODE;
1554         }
1555         */
1556         this->e.xlib.window = CreateWindowEx32A(
1557                 0,
1558                 "WINE_DirectDraw",
1559                 "WINE_DirectDraw",
1560                 WS_VISIBLE|WS_SYSMENU|WS_THICKFRAME,
1561                 0,0,
1562                 width,
1563                 height,
1564                 0,
1565                 0,
1566                 0,
1567                 NULL
1568         );
1569
1570         /* Store this with the window. We'll use it for the window procedure */
1571         SetWindowLong32A(this->e.xlib.window,ddrawXlibThisOffset,(LONG)this);
1572
1573         this->e.xlib.paintable = 1;
1574
1575         ShowWindow32(this->e.xlib.window,TRUE);
1576         UpdateWindow32(this->e.xlib.window);
1577
1578         assert(this->e.xlib.window);
1579
1580         this->e.xlib.drawable  = WIN_FindWndPtr(this->e.xlib.window)->window;
1581
1582         /* We don't have a context for this window. Host off the desktop */
1583         if( !this->e.xlib.drawable )
1584         {
1585            this->e.xlib.drawable = WIN_GetDesktop()->window;
1586         }
1587
1588         this->d.width   = width;
1589         this->d.height  = height;
1590
1591         /* adjust fb_height, so we don't overlap */
1592         /*
1593         if (this->e.dga.fb_height < height)
1594                 this->e.dga.fb_height = height;*/
1595         this->d.depth   = depth;
1596         return 0;
1597 }
1598
1599 static HRESULT WINAPI DGA_IDirectDraw2_GetCaps(
1600         LPDIRECTDRAW2 this,LPDDCAPS caps1,LPDDCAPS caps2
1601 ) {
1602 #ifdef HAVE_LIBXXF86DGA
1603         TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",this,caps1,caps2);
1604         caps1->dwVidMemTotal = this->e.dga.fb_memsize;
1605         caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1606         caps1->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1607         if (caps2) {
1608                 caps2->dwVidMemTotal = this->e.dga.fb_memsize;
1609                 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1610                 caps2->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1611         }
1612         return 0;
1613 #else /* defined(HAVE_LIBXXF86DGA) */
1614         return E_UNEXPECTED;
1615 #endif /* defined(HAVE_LIBXXF86DGA) */
1616 }
1617
1618 static HRESULT WINAPI Xlib_IDirectDraw2_GetCaps(
1619         LPDIRECTDRAW2 this,LPDDCAPS caps1,LPDDCAPS caps2
1620 )  {
1621         TRACE(ddraw,"(%p)->GetCaps(%p,%p)\n",this,caps1,caps2);
1622         /* FIXME: Xlib */
1623         caps1->dwVidMemTotal = 2048*1024;
1624         caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1625         caps1->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1626         if (caps2) {
1627                 caps2->dwVidMemTotal = 2048*1024;
1628                 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1629                 caps2->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1630         }
1631         /* END FIXME: Xlib */
1632         return 0;
1633 }
1634
1635 static HRESULT WINAPI IDirectDraw2_CreateClipper(
1636         LPDIRECTDRAW2 this,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
1637 ) {
1638         FIXME(ddraw,"(%p)->(%08lx,%p,%p),stub!\n",
1639                 this,x,lpddclip,lpunk
1640         );
1641         *lpddclip = (LPDIRECTDRAWCLIPPER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipper));
1642         (*lpddclip)->ref = 1;
1643         (*lpddclip)->lpvtbl = &ddclipvt;
1644         return 0;
1645 }
1646
1647 static HRESULT WINAPI common_IDirectDraw2_CreatePalette(
1648         LPDIRECTDRAW2 this,DWORD x,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
1649 ) {
1650         *lpddpal = (LPDIRECTDRAWPALETTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPalette));
1651         if (*lpddpal == NULL) return E_OUTOFMEMORY;
1652         (*lpddpal)->ref = 1;
1653         (*lpddpal)->ddraw = (LPDIRECTDRAW)this;
1654         (*lpddpal)->installed = 0;
1655         if (this->d.depth<=8) {
1656                 (*lpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(screen),AllocAll);
1657         } else {
1658                 /* we don't want palettes in hicolor or truecolor */
1659                 (*lpddpal)->cm = 0;
1660         }
1661         return 0;
1662 }
1663
1664 static HRESULT WINAPI DGA_IDirectDraw2_CreatePalette(
1665         LPDIRECTDRAW2 this,DWORD x,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
1666 ) {
1667         HRESULT res;
1668         TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",this,x,palent,lpddpal,lpunk);
1669         res = common_IDirectDraw2_CreatePalette(this,x,palent,lpddpal,lpunk);
1670         if (res != 0) return res;
1671         (*lpddpal)->lpvtbl = &dga_ddpalvt;
1672         return 0;
1673 }
1674
1675 static HRESULT WINAPI Xlib_IDirectDraw2_CreatePalette(
1676         LPDIRECTDRAW2 this,DWORD x,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
1677 ) {
1678         TRACE(ddraw,"(%p)->(%08lx,%p,%p,%p)\n",this,x,palent,lpddpal,lpunk);
1679         *lpddpal = (LPDIRECTDRAWPALETTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPalette));
1680         if (*lpddpal == NULL) return E_OUTOFMEMORY;
1681         (*lpddpal)->ref = 1;
1682         (*lpddpal)->installed = 0;
1683
1684         (*lpddpal)->ddraw = (LPDIRECTDRAW)this;
1685         this->lpvtbl->fnAddRef(this);
1686
1687         if (this->d.depth<=8) {
1688                 (*lpddpal)->cm = TSXCreateColormap(display,this->e.xlib.drawable,DefaultVisualOfScreen(screen),AllocAll);
1689                 /* later installed ...
1690                  * TSXInstallColormap(display,(*lpddpal)->cm);
1691                  * TSXSetWindowColormap(display,this->e.xlib.drawable,(*lpddpal)->cm);
1692                  */
1693                 TSXInstallColormap(display,(*lpddpal)->cm);
1694         }
1695         else
1696         {
1697                 /* we don't want palettes in hicolor or truecolor */
1698                 (*lpddpal)->cm = 0;
1699         }
1700
1701         (*lpddpal)->lpvtbl = &xlib_ddpalvt;
1702         return 0;
1703 }
1704
1705 static HRESULT WINAPI DGA_IDirectDraw2_RestoreDisplayMode(LPDIRECTDRAW2 this) {
1706 #ifdef HAVE_LIBXXF86DGA
1707         TRACE(ddraw, "(%p)->()\n",this);
1708         Sleep(1000);
1709         TSXF86DGADirectVideo(display,DefaultScreen(display),0);
1710 #ifdef RESTORE_SIGNALS
1711         SIGNAL_InitEmulator();
1712 #endif
1713         return 0;
1714 #else /* defined(HAVE_LIBXXF86DGA) */
1715         return E_UNEXPECTED;
1716 #endif
1717 }
1718
1719 static HRESULT WINAPI Xlib_IDirectDraw2_RestoreDisplayMode(LPDIRECTDRAW2 this) {
1720         TRACE(ddraw, "(%p)->RestoreDisplayMode()\n", this);
1721         Sleep(1000);
1722         return 0;
1723 }
1724
1725 static HRESULT WINAPI IDirectDraw2_WaitForVerticalBlank(
1726         LPDIRECTDRAW2 this,DWORD x,HANDLE32 h
1727 ) {
1728         TRACE(ddraw,"(%p)->(0x%08lx,0x%08x)\n",this,x,h);
1729         return 0;
1730 }
1731
1732 static ULONG WINAPI IDirectDraw2_AddRef(LPDIRECTDRAW2 this) {
1733         TRACE( ddraw, "(%p)->() incrementing from %lu.\n", this, this->ref );
1734
1735         return ++(this->ref);
1736 }
1737
1738 static ULONG WINAPI DGA_IDirectDraw2_Release(LPDIRECTDRAW2 this) {
1739         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1740
1741 #ifdef HAVE_LIBXXF86DGA
1742         if (!--(this->ref)) {
1743                 TSXF86DGADirectVideo(display,DefaultScreen(display),0);
1744 #ifdef RESTORE_SIGNALS
1745                 SIGNAL_InitEmulator();
1746 #endif
1747                 HeapFree(GetProcessHeap(),0,this);
1748                 return 0;
1749         }
1750 #endif /* defined(HAVE_LIBXXF86DGA) */
1751         return this->ref;
1752 }
1753
1754 static ULONG WINAPI Xlib_IDirectDraw2_Release(LPDIRECTDRAW2 this) {
1755         TRACE( ddraw, "(%p)->() decrementing from %lu.\n", this, this->ref );
1756
1757         if (!--(this->ref)) {
1758                 HeapFree(GetProcessHeap(),0,this);
1759                 return 0;
1760         }
1761         /* FIXME: destroy window ... */
1762         return this->ref;
1763 }
1764
1765 static HRESULT WINAPI DGA_IDirectDraw2_QueryInterface(
1766         LPDIRECTDRAW2 this,REFIID refiid,LPVOID *obj
1767 ) {
1768         char    xrefiid[50];
1769
1770         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1771         TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1772         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1773                 *obj = this;
1774                 this->lpvtbl->fnAddRef(this);
1775                 return 0;
1776         }
1777         if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
1778                 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&dga_ddvt;
1779                 this->lpvtbl->fnAddRef(this);
1780                 *obj = this;
1781                 return 0;
1782         }
1783         if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
1784                 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&dga_dd2vt;
1785                 this->lpvtbl->fnAddRef(this);
1786                 *obj = this;
1787                 return 0;
1788         }
1789         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
1790                 LPDIRECT3D      d3d;
1791
1792                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1793                 d3d->ref = 1;
1794                 d3d->ddraw = (LPDIRECTDRAW)this;
1795                 this->lpvtbl->fnAddRef(this);
1796                 d3d->lpvtbl = &d3dvt;
1797                 *obj = d3d;
1798                 return 0;
1799         }
1800         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
1801                 LPDIRECT3D2     d3d;
1802
1803                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1804                 d3d->ref = 1;
1805                 d3d->ddraw = (LPDIRECTDRAW)this;
1806                 this->lpvtbl->fnAddRef(this);
1807                 d3d->lpvtbl = &d3d2vt;
1808                 *obj = d3d;
1809                 return 0;
1810         }
1811         WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
1812         return OLE_E_ENUM_NOMORE;
1813 }
1814
1815 static HRESULT WINAPI Xlib_IDirectDraw2_QueryInterface(
1816         LPDIRECTDRAW2 this,REFIID refiid,LPVOID *obj
1817 ) {
1818         char    xrefiid[50];
1819
1820         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1821         TRACE(ddraw,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1822         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1823                 *obj = this;
1824                 this->lpvtbl->fnAddRef(this);
1825                 return 0;
1826         }
1827         if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
1828                 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&xlib_ddvt;
1829                 this->lpvtbl->fnAddRef(this);
1830                 *obj = this;
1831                 return 0;
1832         }
1833         if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
1834                 this->lpvtbl = (LPDIRECTDRAW2_VTABLE)&xlib_dd2vt;
1835                 this->lpvtbl->fnAddRef(this);
1836                 *obj = this;
1837                 return 0;
1838         }
1839         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
1840                 LPDIRECT3D      d3d;
1841
1842                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1843                 d3d->ref = 1;
1844                 d3d->ddraw = (LPDIRECTDRAW)this;
1845                 this->lpvtbl->fnAddRef(this);
1846                 d3d->lpvtbl = &d3dvt;
1847                 *obj = d3d;
1848                 return 0;
1849         }
1850         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
1851                 LPDIRECT3D2     d3d;
1852
1853                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1854                 d3d->ref = 1;
1855                 d3d->ddraw = (LPDIRECTDRAW)this;
1856                 this->lpvtbl->fnAddRef(this);
1857                 d3d->lpvtbl = &d3d2vt;
1858                 *obj = d3d;
1859                 return 0;
1860         }
1861         WARN(ddraw,"(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
1862         return OLE_E_ENUM_NOMORE;
1863 }
1864
1865 static HRESULT WINAPI IDirectDraw2_GetVerticalBlankStatus(
1866         LPDIRECTDRAW2 this,BOOL32 *status
1867 ) {
1868         TRACE(ddraw,"(%p)->(%p)\n",this,status);
1869         *status = TRUE;
1870         return 0;
1871 }
1872
1873 static HRESULT WINAPI IDirectDraw2_EnumDisplayModes(
1874         LPDIRECTDRAW2 this,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
1875 ) {
1876         DDSURFACEDESC   ddsfd;
1877
1878         TRACE(ddraw,"(%p)->(0x%08lx,%p,%p,%p)\n",this,dwFlags,lpddsfd,context,modescb);
1879
1880         _getpixelformat(this,&(ddsfd.ddpfPixelFormat));
1881         ddsfd.dwSize = sizeof(ddsfd);
1882         ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
1883         if (dwFlags & DDEDM_REFRESHRATES) {
1884                 ddsfd.dwFlags |= DDSD_REFRESHRATE;
1885                 ddsfd.x.dwRefreshRate = 60;
1886         }
1887
1888         ddsfd.dwWidth = 640;
1889         ddsfd.dwHeight = 480;
1890         ddsfd.dwBackBufferCount = 1;
1891         ddsfd.ddsCaps.dwCaps = DDSCAPS_PALETTE;
1892
1893         if (!modescb(&ddsfd,context)) return 0;
1894
1895         ddsfd.dwWidth = 800;
1896         ddsfd.dwHeight = 600;
1897         if (!modescb(&ddsfd,context)) return 0;
1898
1899         if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
1900                 /* modeX is not standard VGA */
1901
1902                 ddsfd.dwHeight = 200;
1903                 ddsfd.dwWidth = 320;
1904                 if (!modescb(&ddsfd,context)) return 0;
1905         }
1906         return DD_OK;
1907 }
1908
1909 static HRESULT WINAPI DGA_IDirectDraw2_GetDisplayMode(
1910         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsfd
1911 ) {
1912 #ifdef HAVE_LIBXXF86DGA
1913         TRACE(ddraw,"(%p)->(%p)\n",this,lpddsfd);
1914         lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
1915         lpddsfd->dwHeight = screenHeight;
1916         lpddsfd->dwWidth = screenWidth;
1917         lpddsfd->lPitch = this->e.dga.fb_width*this->d.depth/8;
1918         lpddsfd->dwBackBufferCount = 1;
1919         lpddsfd->x.dwRefreshRate = 60;
1920         lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
1921         _getpixelformat(this,&(lpddsfd->ddpfPixelFormat));
1922         return DD_OK;
1923 #else /* defined(HAVE_LIBXXF86DGA) */
1924         return E_UNEXPECTED;
1925 #endif /* defined(HAVE_LIBXXF86DGA) */
1926 }
1927
1928 static HRESULT WINAPI Xlib_IDirectDraw2_GetDisplayMode(
1929         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsfd
1930 ) {
1931         TRACE(ddraw,"(%p)->GetDisplayMode(%p)\n",this,lpddsfd);
1932         lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
1933         lpddsfd->dwHeight = screenHeight;
1934         lpddsfd->dwWidth = screenWidth;
1935         /* POOLE FIXME: Xlib */
1936         lpddsfd->lPitch = this->e.dga.fb_width*this->d.depth/8;
1937         /* END FIXME: Xlib */
1938         lpddsfd->dwBackBufferCount = 1;
1939         lpddsfd->x.dwRefreshRate = 60;
1940         lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
1941         _getpixelformat(this,&(lpddsfd->ddpfPixelFormat));
1942         return DD_OK;
1943 }
1944
1945 static HRESULT WINAPI IDirectDraw2_FlipToGDISurface(LPDIRECTDRAW2 this) {
1946         TRACE(ddraw,"(%p)->()\n",this);
1947         return DD_OK;
1948 }
1949
1950 static HRESULT WINAPI IDirectDraw2_GetMonitorFrequency(
1951         LPDIRECTDRAW2 this,LPDWORD freq
1952 ) {
1953         FIXME(ddraw,"(%p)->(%p) returns 60 Hz always\n",this,freq);
1954         *freq = 60*100; /* 60 Hz */
1955         return 0;
1956 }
1957
1958 /* what can we directly decompress? */
1959 static HRESULT WINAPI IDirectDraw2_GetFourCCCodes(
1960         LPDIRECTDRAW2 this,LPDWORD x,LPDWORD y
1961 ) {
1962         FIXME(ddraw,"(%p,%p,%p), stub\n",this,x,y);
1963         return 0;
1964 }
1965
1966 static HRESULT WINAPI IDirectDraw2_EnumSurfaces(
1967         LPDIRECTDRAW2 this,DWORD x,LPDDSURFACEDESC ddsfd,LPVOID context,LPDDENUMSURFACESCALLBACK ddsfcb
1968 ) {
1969         FIXME(ddraw,"(%p)->(0x%08lx,%p,%p,%p),stub!\n",this,x,ddsfd,context,ddsfcb);
1970         return 0;
1971 }
1972
1973 static HRESULT WINAPI IDirectDraw2_Compact(
1974           LPDIRECTDRAW2 this )
1975 {
1976   FIXME(ddraw,"(%p)->()\n", this );
1977
1978   return DD_OK;
1979 }
1980
1981
1982 /* Note: Hack so we can reuse the old functions without compiler warnings */
1983 #ifdef __GNUC__
1984 # define XCAST(fun)     (typeof(dga_ddvt.fn##fun))
1985 #else
1986 # define XCAST(fun)     (void*)
1987 #endif
1988
1989 static struct IDirectDraw_VTable dga_ddvt = {
1990         XCAST(QueryInterface)DGA_IDirectDraw2_QueryInterface,
1991         XCAST(AddRef)IDirectDraw2_AddRef,
1992         XCAST(Release)DGA_IDirectDraw2_Release,
1993         XCAST(Compact)IDirectDraw2_Compact,
1994         XCAST(CreateClipper)IDirectDraw2_CreateClipper,
1995         XCAST(CreatePalette)DGA_IDirectDraw2_CreatePalette,
1996         XCAST(CreateSurface)DGA_IDirectDraw2_CreateSurface,
1997         XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
1998         XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
1999         XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
2000         XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
2001         XCAST(GetCaps)DGA_IDirectDraw2_GetCaps,
2002         XCAST(GetDisplayMode)DGA_IDirectDraw2_GetDisplayMode,
2003         XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
2004         XCAST(GetGDISurface)15,
2005         XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
2006         XCAST(GetScanLine)17,
2007         XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
2008         XCAST(Initialize)19,
2009         XCAST(RestoreDisplayMode)DGA_IDirectDraw2_RestoreDisplayMode,
2010         XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
2011         DGA_IDirectDraw_SetDisplayMode,
2012         XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
2013 };
2014
2015 static struct IDirectDraw_VTable xlib_ddvt = {
2016         XCAST(QueryInterface)Xlib_IDirectDraw2_QueryInterface,
2017         XCAST(AddRef)IDirectDraw2_AddRef,
2018         XCAST(Release)Xlib_IDirectDraw2_Release,
2019         XCAST(Compact)IDirectDraw2_Compact,
2020         XCAST(CreateClipper)IDirectDraw2_CreateClipper,
2021         XCAST(CreatePalette)Xlib_IDirectDraw2_CreatePalette,
2022         XCAST(CreateSurface)Xlib_IDirectDraw2_CreateSurface,
2023         XCAST(DuplicateSurface)IDirectDraw2_DuplicateSurface,
2024         XCAST(EnumDisplayModes)IDirectDraw2_EnumDisplayModes,
2025         XCAST(EnumSurfaces)IDirectDraw2_EnumSurfaces,
2026         XCAST(FlipToGDISurface)IDirectDraw2_FlipToGDISurface,
2027         XCAST(GetCaps)Xlib_IDirectDraw2_GetCaps,
2028         XCAST(GetDisplayMode)Xlib_IDirectDraw2_GetDisplayMode,
2029         XCAST(GetFourCCCodes)IDirectDraw2_GetFourCCCodes,
2030         XCAST(GetGDISurface)15,
2031         XCAST(GetMonitorFrequency)IDirectDraw2_GetMonitorFrequency,
2032         XCAST(GetScanLine)17,
2033         XCAST(GetVerticalBlankStatus)IDirectDraw2_GetVerticalBlankStatus,
2034         XCAST(Initialize)19,
2035         XCAST(RestoreDisplayMode)Xlib_IDirectDraw2_RestoreDisplayMode,
2036         XCAST(SetCooperativeLevel)IDirectDraw2_SetCooperativeLevel,
2037         Xlib_IDirectDraw_SetDisplayMode,
2038         XCAST(WaitForVerticalBlank)IDirectDraw2_WaitForVerticalBlank,
2039 };
2040
2041 /*****************************************************************************
2042  *      IDirectDraw2
2043  *
2044  */
2045
2046
2047 static HRESULT WINAPI DGA_IDirectDraw2_SetDisplayMode(
2048         LPDIRECTDRAW2 this,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
2049 ) {
2050         return DGA_IDirectDraw_SetDisplayMode((LPDIRECTDRAW)this,width,height,depth);
2051 }
2052
2053 static HRESULT WINAPI Xlib_IDirectDraw2_SetDisplayMode(
2054         LPDIRECTDRAW2 this,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
2055 ) {
2056         return Xlib_IDirectDraw_SetDisplayMode((LPDIRECTDRAW)this,width,height,depth);
2057 }
2058
2059 static HRESULT WINAPI DGA_IDirectDraw2_GetAvailableVidMem(
2060         LPDIRECTDRAW2 this,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
2061 ) {
2062         TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
2063                 this,ddscaps,total,free
2064         );
2065         if (total) *total = this->e.dga.fb_memsize * 1024;
2066         if (free) *free = this->e.dga.fb_memsize * 1024;
2067         return 0;
2068 }
2069
2070 static HRESULT WINAPI Xlib_IDirectDraw2_GetAvailableVidMem(
2071         LPDIRECTDRAW2 this,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
2072 ) {
2073         TRACE(ddraw,"(%p)->(%p,%p,%p)\n",
2074                 this,ddscaps,total,free
2075         );
2076         if (total) *total = 2048 * 1024;
2077         if (free) *free = 2048 * 1024;
2078         return 0;
2079 }
2080
2081 static IDirectDraw2_VTable dga_dd2vt = {
2082         DGA_IDirectDraw2_QueryInterface,
2083         IDirectDraw2_AddRef,
2084         DGA_IDirectDraw2_Release,
2085         IDirectDraw2_Compact,
2086         IDirectDraw2_CreateClipper,
2087         DGA_IDirectDraw2_CreatePalette,
2088         DGA_IDirectDraw2_CreateSurface,
2089         (void*)8,
2090         IDirectDraw2_EnumDisplayModes,
2091         IDirectDraw2_EnumSurfaces,
2092         IDirectDraw2_FlipToGDISurface,
2093         DGA_IDirectDraw2_GetCaps,
2094         DGA_IDirectDraw2_GetDisplayMode,
2095         IDirectDraw2_GetFourCCCodes,
2096         (void*)15,
2097         IDirectDraw2_GetMonitorFrequency,
2098         (void*)17,
2099         IDirectDraw2_GetVerticalBlankStatus,
2100         (void*)19,
2101         DGA_IDirectDraw2_RestoreDisplayMode,
2102         IDirectDraw2_SetCooperativeLevel,
2103         DGA_IDirectDraw2_SetDisplayMode,
2104         IDirectDraw2_WaitForVerticalBlank,
2105         DGA_IDirectDraw2_GetAvailableVidMem
2106 };
2107
2108 static struct IDirectDraw2_VTable xlib_dd2vt = {
2109         Xlib_IDirectDraw2_QueryInterface,
2110         IDirectDraw2_AddRef,
2111         Xlib_IDirectDraw2_Release,
2112         IDirectDraw2_Compact,
2113         IDirectDraw2_CreateClipper,
2114         Xlib_IDirectDraw2_CreatePalette,
2115         Xlib_IDirectDraw2_CreateSurface,
2116         (void*)8,
2117         IDirectDraw2_EnumDisplayModes,
2118         IDirectDraw2_EnumSurfaces,
2119         IDirectDraw2_FlipToGDISurface,
2120         Xlib_IDirectDraw2_GetCaps,
2121         Xlib_IDirectDraw2_GetDisplayMode,
2122         IDirectDraw2_GetFourCCCodes,
2123         (void*)15,
2124         IDirectDraw2_GetMonitorFrequency,
2125         (void*)17,
2126         IDirectDraw2_GetVerticalBlankStatus,
2127         (void*)19,
2128         Xlib_IDirectDraw2_RestoreDisplayMode,
2129         IDirectDraw2_SetCooperativeLevel,
2130         Xlib_IDirectDraw2_SetDisplayMode,
2131         IDirectDraw2_WaitForVerticalBlank,
2132         Xlib_IDirectDraw2_GetAvailableVidMem
2133 };
2134
2135 /******************************************************************************
2136  *                              DirectDrawCreate
2137  */
2138
2139 HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
2140 #ifdef HAVE_LIBXXF86DGA
2141         int     memsize,banksize,width,major,minor,flags,height;
2142         char    *addr;
2143
2144         if (getuid() != 0) {
2145                 MSG("Must be root to use XF86DGA!\n");
2146                 MessageBox32A(0,"Using the XF86DGA extension requires the program to be run using UID 0.","WINE DirectDraw",MB_OK|MB_ICONSTOP);
2147                 return E_UNEXPECTED;
2148         }
2149         if (!DDRAW_DGA_Available()) {
2150                 TRACE(ddraw,"No XF86DGA detected.\n");
2151                 return DDERR_GENERIC;
2152         }
2153         *lplpDD = (LPDIRECTDRAW)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDraw));
2154         (*lplpDD)->lpvtbl = &dga_ddvt;
2155         (*lplpDD)->ref = 1;
2156         TSXF86DGAQueryVersion(display,&major,&minor);
2157         TRACE(ddraw,"XF86DGA is version %d.%d\n",major,minor);
2158         TSXF86DGAQueryDirectVideo(display,DefaultScreen(display),&flags);
2159         if (!(flags & XF86DGADirectPresent))
2160                 MSG("direct video is NOT PRESENT.\n");
2161         TSXF86DGAGetVideo(display,DefaultScreen(display),&addr,&width,&banksize,&memsize);
2162         TRACE(ddraw,"video framebuffer: begin %p, width %d,banksize %d,memsize %d\n",
2163                 addr,width,banksize,memsize
2164         );
2165         (*lplpDD)->e.dga.fb_width = width;
2166         (*lplpDD)->d.width = width;
2167         (*lplpDD)->e.dga.fb_addr = addr;
2168         (*lplpDD)->e.dga.fb_memsize = memsize;
2169         (*lplpDD)->e.dga.fb_banksize = banksize;
2170
2171         TSXF86DGAGetViewPortSize(display,DefaultScreen(display),&width,&height);
2172         TSXF86DGASetViewPort(display,DefaultScreen(display),0,0);
2173         (*lplpDD)->e.dga.fb_height = screenHeight;
2174 #ifdef DIABLO_HACK
2175         (*lplpDD)->e.dga.vpmask = 1;
2176 #else
2177         (*lplpDD)->e.dga.vpmask = 0;
2178 #endif
2179
2180         /* just assume the default depth is the DGA depth too */
2181         (*lplpDD)->d.depth = DefaultDepthOfScreen(screen);
2182 #ifdef RESTORE_SIGNALS
2183         SIGNAL_InitEmulator();
2184 #endif
2185         return 0;
2186 #else /* defined(HAVE_LIBXXF86DGA) */
2187         return DDERR_INVALIDDIRECTDRAWGUID;
2188 #endif /* defined(HAVE_LIBXXF86DGA) */
2189 }
2190
2191 LRESULT WINAPI Xlib_DDWndProc(HWND32 hwnd,UINT32 msg,WPARAM32 wParam,LPARAM lParam)
2192 {
2193    LRESULT ret;
2194    LPDIRECTDRAW ddraw = NULL;
2195    DWORD lastError;
2196
2197    /*FIXME(ddraw,"(0x%04x,%s,0x%08lx,0x%08lx),stub!\n",(int)hwnd,SPY_GetMsgName(msg),(long)wParam,(long)lParam); */
2198
2199    SetLastError( ERROR_SUCCESS );
2200    ddraw  = (LPDIRECTDRAW)GetWindowLong32A( hwnd, ddrawXlibThisOffset );
2201    if( (!ddraw)  &&
2202        ( ( lastError = GetLastError() ) != ERROR_SUCCESS )
2203      )
2204    {
2205      ERR( ddraw, "Unable to retrieve this ptr from window. Error %08lx\n", lastError );
2206    }
2207
2208    if( ddraw )
2209    {
2210       /* Perform any special direct draw functions */
2211       if (msg==WM_PAINT)
2212       {
2213         ddraw->e.xlib.paintable = 1;
2214       }
2215
2216       /* Now let the application deal with the rest of this */
2217       if( ddraw->d.mainWindow )
2218       {
2219
2220         /* Don't think that we actually need to call this but...
2221            might as well be on the safe side of things... */
2222         ret = DefWindowProc32A( hwnd, msg, wParam, lParam );
2223
2224         if( !ret )
2225         {
2226           /* We didn't handle the message - give it to the application */
2227           if (ddraw && ddraw->d.mainWindow && WIN_FindWndPtr(ddraw->d.mainWindow))
2228                 ret = CallWindowProc32A( WIN_FindWndPtr( ddraw->d.mainWindow )->winproc,
2229                                    ddraw->d.mainWindow, msg, wParam, lParam );
2230         }
2231
2232       }
2233       else
2234       {
2235         ret = DefWindowProc32A( ddraw->d.mainWindow, msg, wParam, lParam );
2236       }
2237
2238     }
2239     else
2240     {
2241         ret = DefWindowProc32A(hwnd,msg,wParam,lParam);
2242     }
2243
2244     return ret;
2245 }
2246
2247 HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
2248         WNDCLASS32A     wc;
2249         int             have_xshm = 0;
2250         WND*            pParentWindow;
2251
2252         *lplpDD = (LPDIRECTDRAW)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDraw));
2253         (*lplpDD)->lpvtbl = &xlib_ddvt;
2254         (*lplpDD)->ref = 1;
2255         (*lplpDD)->e.xlib.drawable = 0; /* in SetDisplayMode */
2256         (*lplpDD)->e.xlib.use_xshm = have_xshm;
2257         wc.style        = CS_GLOBALCLASS;
2258         wc.lpfnWndProc  = Xlib_DDWndProc;
2259         wc.cbClsExtra   = 0;
2260         wc.cbWndExtra   = /* Defines extra mem for window. This is used for storing this */
2261                           sizeof( LPDIRECTDRAW ); /*  ddrawXlibThisOffset */
2262
2263         /* We can be a child of the desktop since we're really important */
2264         pParentWindow   = WIN_GetDesktop();
2265         wc.hInstance    = pParentWindow ? pParentWindow->hwndSelf : 0;
2266         wc.hInstance    = 0;
2267
2268         wc.hIcon        = 0;
2269         wc.hCursor      = (HCURSOR32)IDC_ARROW32A;
2270         wc.hbrBackground= NULL_BRUSH;
2271         wc.lpszMenuName = 0;
2272         wc.lpszClassName= "WINE_DirectDraw";
2273
2274         (*lplpDD)->e.xlib.winclass = RegisterClass32A(&wc);
2275
2276         (*lplpDD)->d.depth = DefaultDepthOfScreen(screen);
2277         (*lplpDD)->d.height = screenHeight;
2278         (*lplpDD)->d.width = screenWidth;
2279         return 0;
2280 }
2281
2282 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
2283         char    xclsid[50];
2284
2285         if (HIWORD(lpGUID))
2286                 WINE_StringFromCLSID(lpGUID,xclsid);
2287         else {
2288                 sprintf(xclsid,"<guid-%0x08x>",(int)lpGUID);
2289                 lpGUID = NULL;
2290         }
2291
2292         TRACE(ddraw,"(%s,%p,%p)\n",xclsid,lplpDD,pUnkOuter);
2293
2294         if (!lpGUID) {
2295                 /* if they didn't request a particular interface, use the best
2296                  * supported one */
2297                 if (DDRAW_DGA_Available())
2298                         lpGUID = &DGA_DirectDraw_GUID;
2299                 else
2300                         lpGUID = &XLIB_DirectDraw_GUID;
2301         }
2302
2303         if (!memcmp(lpGUID, &DGA_DirectDraw_GUID, sizeof(GUID)))
2304                 return DGA_DirectDrawCreate(lplpDD, pUnkOuter);
2305         else if (!memcmp(lpGUID, &XLIB_DirectDraw_GUID, sizeof(GUID)))
2306                 return Xlib_DirectDrawCreate(lplpDD, pUnkOuter);
2307
2308         fprintf(stderr,"DirectDrawCreate(%s,%p,%p): did not recognize requested GUID\n",xclsid,lplpDD,pUnkOuter);
2309         return DDERR_INVALIDDIRECTDRAWGUID;
2310 }