graphics/ddraw.c

   1 /*              DirectDraw using DGA
   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 /* Progress on following programs:
  15  *
  16  * - Diablo [640x480x8]:
  17  *   The movies play. The game doesn't work, it somehow tries to write
  18  *   into 2 lines _BEFORE_ the start of the surface. Don't know why.
  19  *
  20  * - WingCommander 4 / Win95 Patch [640x480x8]:
  21  *   The intromovie plays, in 8 bit mode (to reconfigure wc4, run wine
  22  *   "wc4w.exe -I"). The 16bit mode looks broken, but I think this is due to
  23  *   my Matrox Mystique which uses 565 (rgb) colorweight instead of the usual
  24  *   555. Specifying it in DDPIXELFORMAT didn't help.
  25  *   Requires to be run in 640x480xdepth mode (doesn't seem to heed
  26  *   DDSURFACEDESC.lPitch). You can fly the first mission with Maniac, but
  27  *   it crashes as soon as you arrive at Blue Point Station...
  28  *
  29  * - Monkey Island 3 [640x480x8]:
  30  *   Goes to the easy/hard selection screen, then hangs due to MT problems.
  31  *
  32  * - DiscWorld 2 [640x480x8]:
  33  *   [Crashes with 'cli' in released version. Yes. Privileged instructions
  34  *    in 32bit code. Will they ever learn...]
  35  *   Plays through nearly all intro movies. Sound and animation skip a lot of
  36  *   stuff (possible DirectSound problem).
  37  *
  38  * - XvT [640x480x16]:
  39  *   Shows the splash screen, then fails with missing Joystick.
  40  *
  41  * - Tomb Raider 2 Demo (using 8 bit renderer) [640x480x8]:
  42  *   Playable. Sound is weird.
  43  *
  44  * - WingCommander Prophecy Demo (using software renderer) [640x480x16]:
  45  *   [Crashes with an invalid opcode (outb) in the release version.]
  46  *   Plays intromovie, hangs in selection screen (no keyboard input, probably
  47  *   DirectInput problem).
  48  */
  49
  50 #include "config.h"
  51 #include <stdio.h>
  52 #include <unistd.h>
  53 #include <assert.h>
  54 #include "ts_xlib.h"
  55 #include <sys/signal.h>
  56
  57 #include "windows.h"
  58 #include "winerror.h"
  59 #include "interfaces.h"
  60 #include "gdi.h"
  61 #include "heap.h"
  62 #include "ldt.h"
  63 #include "dc.h"
  64 #include "win.h"
  65 #include "miscemu.h"
  66 #include "ddraw.h"
  67 #include "d3d.h"
  68 #include "debug.h"
  69
  70 #ifdef HAVE_LIBXXF86DGA
  71 #include <X11/extensions/xf86dga.h>
  72 #endif
  73
  74 /* restore signal handlers overwritten by XF86DGA
  75  * this is a define, for it will only work in emulator mode
  76  */
  77 #undef RESTORE_SIGNALS
  78
  79 static struct IDirectDrawSurface3_VTable        dds3vt;
  80 static struct IDirectDrawSurface2_VTable        dds2vt;
  81 static struct IDirectDrawSurface_VTable         ddsvt;
  82 static struct IDirectDraw_VTable                ddvt;
  83 static struct IDirectDraw2_VTable               dd2vt;
  84 static struct IDirect3D_VTable                  d3dvt;
  85 static struct IDirect3D2_VTable                 d3d2vt;
  86
  87
  88 HRESULT WINAPI
  89 DirectDrawEnumerate32A(LPDDENUMCALLBACK32A ddenumproc,LPVOID data) {
  90         /* we have just one display driver right now ... */
  91         ddenumproc(0,"WINE Display","display",data);
  92         return 0;
  93 }
  94
  95 HRESULT WINAPI
  96 DSoundHelp(DWORD x,DWORD y,DWORD z) {
  97         fprintf(stderr,"DSoundHelp(0x%08lx,0x%08lx,0x%08lx),stub!\n",x,y,z);
  98         return 0;
  99 }
 100
 101
 102 #ifdef HAVE_LIBXXF86DGA
 103
 104 /******************************************************************************
 105  *              internal helper functions
 106  */
 107 static void _dump_DDBLTFX(DWORD flagmask) {
 108         int     i;
 109         const struct {
 110                 DWORD   mask;
 111                 char    *name;
 112         } flags[] = {
 113 #define FE(x) { x, #x},
 114                 FE(DDBLTFX_ARITHSTRETCHY)
 115                 FE(DDBLTFX_MIRRORLEFTRIGHT)
 116                 FE(DDBLTFX_MIRRORUPDOWN)
 117                 FE(DDBLTFX_NOTEARING)
 118                 FE(DDBLTFX_ROTATE180)
 119                 FE(DDBLTFX_ROTATE270)
 120                 FE(DDBLTFX_ROTATE90)
 121                 FE(DDBLTFX_ZBUFFERRANGE)
 122                 FE(DDBLTFX_ZBUFFERBASEDEST)
 123         };
 124         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 125                 if (flags[i].mask & flagmask)
 126                         fprintf(stderr,"%s ",flags[i].name);
 127 }
 128
 129 static void _dump_DDBLTFAST(DWORD flagmask) {
 130         int     i;
 131         const struct {
 132                 DWORD   mask;
 133                 char    *name;
 134         } flags[] = {
 135 #define FE(x) { x, #x},
 136                 FE(DDBLTFAST_NOCOLORKEY)
 137                 FE(DDBLTFAST_SRCCOLORKEY)
 138                 FE(DDBLTFAST_DESTCOLORKEY)
 139                 FE(DDBLTFAST_WAIT)
 140         };
 141         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 142                 if (flags[i].mask & flagmask)
 143                         fprintf(stderr,"%s ",flags[i].name);
 144 }
 145
 146 static void _dump_DDBLT(DWORD flagmask) {
 147         int     i;
 148         const struct {
 149                 DWORD   mask;
 150                 char    *name;
 151         } flags[] = {
 152 #define FE(x) { x, #x},
 153                 FE(DDBLT_ALPHADEST)
 154                 FE(DDBLT_ALPHADESTCONSTOVERRIDE)
 155                 FE(DDBLT_ALPHADESTNEG)
 156                 FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
 157                 FE(DDBLT_ALPHAEDGEBLEND)
 158                 FE(DDBLT_ALPHASRC)
 159                 FE(DDBLT_ALPHASRCCONSTOVERRIDE)
 160                 FE(DDBLT_ALPHASRCNEG)
 161                 FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
 162                 FE(DDBLT_ASYNC)
 163                 FE(DDBLT_COLORFILL)
 164                 FE(DDBLT_DDFX)
 165                 FE(DDBLT_DDROPS)
 166                 FE(DDBLT_KEYDEST)
 167                 FE(DDBLT_KEYDESTOVERRIDE)
 168                 FE(DDBLT_KEYSRC)
 169                 FE(DDBLT_KEYSRCOVERRIDE)
 170                 FE(DDBLT_ROP)
 171                 FE(DDBLT_ROTATIONANGLE)
 172                 FE(DDBLT_ZBUFFER)
 173                 FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
 174                 FE(DDBLT_ZBUFFERDESTOVERRIDE)
 175                 FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
 176                 FE(DDBLT_ZBUFFERSRCOVERRIDE)
 177                 FE(DDBLT_WAIT)
 178                 FE(DDBLT_DEPTHFILL)
 179         };
 180         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 181                 if (flags[i].mask & flagmask)
 182                         fprintf(stderr,"%s ",flags[i].name);
 183 }
 184
 185 static void _dump_DDSCAPS(DWORD flagmask) {
 186         int     i;
 187         const struct {
 188                 DWORD   mask;
 189                 char    *name;
 190         } flags[] = {
 191 #define FE(x) { x, #x},
 192                 FE(DDSCAPS_RESERVED1)
 193                 FE(DDSCAPS_ALPHA)
 194                 FE(DDSCAPS_BACKBUFFER)
 195                 FE(DDSCAPS_COMPLEX)
 196                 FE(DDSCAPS_FLIP)
 197                 FE(DDSCAPS_FRONTBUFFER)
 198                 FE(DDSCAPS_OFFSCREENPLAIN)
 199                 FE(DDSCAPS_OVERLAY)
 200                 FE(DDSCAPS_PALETTE)
 201                 FE(DDSCAPS_PRIMARYSURFACE)
 202                 FE(DDSCAPS_PRIMARYSURFACELEFT)
 203                 FE(DDSCAPS_SYSTEMMEMORY)
 204                 FE(DDSCAPS_TEXTURE)
 205                 FE(DDSCAPS_3DDEVICE)
 206                 FE(DDSCAPS_VIDEOMEMORY)
 207                 FE(DDSCAPS_VISIBLE)
 208                 FE(DDSCAPS_WRITEONLY)
 209                 FE(DDSCAPS_ZBUFFER)
 210                 FE(DDSCAPS_OWNDC)
 211                 FE(DDSCAPS_LIVEVIDEO)
 212                 FE(DDSCAPS_HWCODEC)
 213                 FE(DDSCAPS_MODEX)
 214                 FE(DDSCAPS_MIPMAP)
 215                 FE(DDSCAPS_RESERVED2)
 216                 FE(DDSCAPS_ALLOCONLOAD)
 217                 FE(DDSCAPS_VIDEOPORT)
 218                 FE(DDSCAPS_LOCALVIDMEM)
 219                 FE(DDSCAPS_NONLOCALVIDMEM)
 220                 FE(DDSCAPS_STANDARDVGAMODE)
 221                 FE(DDSCAPS_OPTIMIZED)
 222         };
 223         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 224                 if (flags[i].mask & flagmask)
 225                         fprintf(stderr,"%s ",flags[i].name);
 226 }
 227
 228 static void _dump_DDCAPS(DWORD flagmask) {
 229         int     i;
 230         const struct {
 231                 DWORD   mask;
 232                 char    *name;
 233 } flags[] = {
 234 #define FE(x) { x, #x},
 235                 FE(DDCAPS_3D)
 236                 FE(DDCAPS_ALIGNBOUNDARYDEST)
 237                 FE(DDCAPS_ALIGNSIZEDEST)
 238                 FE(DDCAPS_ALIGNBOUNDARYSRC)
 239                 FE(DDCAPS_ALIGNSIZESRC)
 240                 FE(DDCAPS_ALIGNSTRIDE)
 241                 FE(DDCAPS_BLT)
 242                 FE(DDCAPS_BLTQUEUE)
 243                 FE(DDCAPS_BLTFOURCC)
 244                 FE(DDCAPS_BLTSTRETCH)
 245                 FE(DDCAPS_GDI)
 246                 FE(DDCAPS_OVERLAY)
 247                 FE(DDCAPS_OVERLAYCANTCLIP)
 248                 FE(DDCAPS_OVERLAYFOURCC)
 249                 FE(DDCAPS_OVERLAYSTRETCH)
 250                 FE(DDCAPS_PALETTE)
 251                 FE(DDCAPS_PALETTEVSYNC)
 252                 FE(DDCAPS_READSCANLINE)
 253                 FE(DDCAPS_STEREOVIEW)
 254                 FE(DDCAPS_VBI)
 255                 FE(DDCAPS_ZBLTS)
 256                 FE(DDCAPS_ZOVERLAYS)
 257                 FE(DDCAPS_COLORKEY)
 258                 FE(DDCAPS_ALPHA)
 259                 FE(DDCAPS_COLORKEYHWASSIST)
 260                 FE(DDCAPS_NOHARDWARE)
 261                 FE(DDCAPS_BLTCOLORFILL)
 262                 FE(DDCAPS_BANKSWITCHED)
 263                 FE(DDCAPS_BLTDEPTHFILL)
 264                 FE(DDCAPS_CANCLIP)
 265                 FE(DDCAPS_CANCLIPSTRETCHED)
 266                 FE(DDCAPS_CANBLTSYSMEM)
 267         };
 268         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 269                 if (flags[i].mask & flagmask)
 270                         fprintf(stderr,"%s ",flags[i].name);
 271 }
 272
 273 static void _dump_DDSD(DWORD flagmask) {
 274         int     i;
 275         const struct {
 276                 DWORD   mask;
 277                 char    *name;
 278         } flags[] = {
 279                 FE(DDSD_CAPS)
 280                 FE(DDSD_HEIGHT)
 281                 FE(DDSD_WIDTH)
 282                 FE(DDSD_PITCH)
 283                 FE(DDSD_BACKBUFFERCOUNT)
 284                 FE(DDSD_ZBUFFERBITDEPTH)
 285                 FE(DDSD_ALPHABITDEPTH)
 286                 FE(DDSD_PIXELFORMAT)
 287                 FE(DDSD_CKDESTOVERLAY)
 288                 FE(DDSD_CKDESTBLT)
 289                 FE(DDSD_CKSRCOVERLAY)
 290                 FE(DDSD_CKSRCBLT)
 291                 FE(DDSD_MIPMAPCOUNT)
 292                 FE(DDSD_REFRESHRATE)
 293                 FE(DDSD_LINEARSIZE)
 294                 FE(DDSD_LPSURFACE)
 295         };
 296         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 297                 if (flags[i].mask & flagmask)
 298                         fprintf(stderr,"%s ",flags[i].name);
 299 }
 300
 301 static int _getpixelformat(LPDIRECTDRAW ddraw,LPDDPIXELFORMAT pf) {
 302         static XVisualInfo      *vi;
 303         XVisualInfo             vt;
 304         int                     nitems;
 305
 306         if (!vi)
 307                 vi = TSXGetVisualInfo(display,VisualNoMask,&vt,&nitems);
 308
 309         pf->dwFourCC = 0;
 310         if (ddraw->d.depth==8) {
 311                 pf->dwFlags             = DDPF_RGB|DDPF_PALETTEINDEXED8;
 312                 pf->x.dwRGBBitCount     = 8;
 313                 pf->y.dwRBitMask        = 0;
 314                 pf->z.dwGBitMask        = 0;
 315                 pf->xx.dwBBitMask       = 0;
 316                 pf->xy.dwRGBAlphaBitMask= 0;
 317                 return 0;
 318         }
 319         if (ddraw->d.depth==16) {
 320                 pf->dwFlags             = DDPF_RGB;
 321                 pf->x.dwRGBBitCount     = 16;
 322                 pf->y.dwRBitMask        = vi[0].red_mask;
 323                 pf->z.dwGBitMask        = vi[0].green_mask;
 324                 pf->xx.dwBBitMask       = vi[0].blue_mask;
 325                 pf->xy.dwRGBAlphaBitMask= 0;
 326                 return 0;
 327         }
 328         fprintf(stderr,"_getpixelformat:oops?\n");
 329         return DDERR_GENERIC;
 330 }
 331
 332 /******************************************************************************
 333  *                      IDirectDrawSurface
 334  */
 335
 336 static HRESULT WINAPI IDirectDrawSurface_Lock(
 337     LPDIRECTDRAWSURFACE this,LPRECT32 lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE32 hnd
 338 ) {
 339         dprintf_info(ddraw, "IDirectDrawSurface(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 340                 this,lprect,lpddsd,flags,(DWORD)hnd);
 341         if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY))
 342             dprintf_warn(ddraw, "IDirectDrawSurface(%p)->Lock(%p,%p,%08lx,%08lx)\n",
 343                          this,lprect,lpddsd,flags,(DWORD)hnd);
 344
 345         if (lprect) {
 346                 dprintf_info(ddraw,"    lprect: %dx%d-%dx%d\n",
 347                         lprect->top,lprect->left,lprect->bottom,lprect->right
 348                 );
 349                 lpddsd->y.lpSurface =   this->s.surface+
 350                                         (lprect->top*this->s.lpitch)+
 351                                         (lprect->left*(this->s.ddraw->d.depth/8));
 352         } else
 353                 lpddsd->y.lpSurface = this->s.surface;
 354         lpddsd->dwFlags = DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_LPSURFACE;
 355         lpddsd->dwWidth         = this->s.width;
 356         lpddsd->dwHeight        = this->s.height;
 357         lpddsd->lPitch          = this->s.lpitch;
 358         _getpixelformat(this->s.ddraw,&(lpddsd->ddpfPixelFormat));
 359         return 0;
 360 }
 361
 362 static HRESULT WINAPI IDirectDrawSurface_Unlock(
 363         LPDIRECTDRAWSURFACE this,LPVOID surface
 364 ) {
 365         dprintf_info(ddraw,"IDirectDrawSurface(%p)->Unlock(%p)\n",this,surface);
 366         return 0;
 367 }
 368
 369 static HRESULT WINAPI IDirectDrawSurface_Flip(
 370         LPDIRECTDRAWSURFACE this,LPDIRECTDRAWSURFACE flipto,DWORD dwFlags
 371 ) {
 372         dprintf_info(ddraw,"IDirectDrawSurface(%p)->Flip(%p,%08lx)\n",this,flipto,dwFlags);
 373         if (!flipto) {
 374                 if (this->s.backbuffer)
 375                         flipto = this->s.backbuffer;
 376                 else
 377                         flipto = this;
 378         }
 379         XF86DGASetViewPort(display,DefaultScreen(display),0,flipto->s.fb_height);
 380         if (flipto->s.palette && flipto->s.palette->cm)
 381                 XF86DGAInstallColormap(display,DefaultScreen(display),flipto->s.palette->cm);
 382         while (!XF86DGAViewPortChanged(display,DefaultScreen(display),2)) {
 383         }
 384         if (flipto!=this) {
 385                 int     tmp;
 386                 LPVOID  ptmp;
 387
 388                 tmp = this->s.fb_height;
 389                 this->s.fb_height = flipto->s.fb_height;
 390                 flipto->s.fb_height = tmp;
 391
 392                 ptmp = this->s.surface;
 393                 this->s.surface = flipto->s.surface;
 394                 flipto->s.surface = ptmp;
 395         }
 396         return 0;
 397 }
 398
 399 static HRESULT WINAPI IDirectDrawSurface_SetPalette(
 400         LPDIRECTDRAWSURFACE this,LPDIRECTDRAWPALETTE pal
 401 ) {
 402         dprintf_info(ddraw,"IDirectDrawSurface(%p)->SetPalette(%p)\n",this,pal);
 403         this->s.palette = pal; /* probably addref it too */
 404         return 0;
 405 }
 406
 407 static HRESULT WINAPI IDirectDrawSurface_Blt(
 408         LPDIRECTDRAWSURFACE this,LPRECT32 rdst,LPDIRECTDRAWSURFACE src,LPRECT32 rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
 409 ) {
 410         RECT32  xdst,xsrc;
 411         int     i,j;
 412
 413         if (rdst)
 414                 memcpy(&xdst,rdst,sizeof(xdst));
 415         else {
 416                 xdst.top        = 0;
 417                 xdst.bottom     = this->s.height;
 418                 xdst.left       = 0;
 419                 xdst.right      = this->s.width;
 420         }
 421         if (rsrc)
 422                 memcpy(&xsrc,rsrc,sizeof(xsrc));
 423         else if (src) {
 424                 xsrc.top        = 0;
 425                 xsrc.bottom     = src->s.height;
 426                 xsrc.left       = 0;
 427                 xsrc.right      = src->s.width;
 428         }
 429
 430         if (dwFlags & DDBLT_COLORFILL) {
 431                 int     bpp = this->s.ddraw->d.depth/8;
 432                 LPBYTE  xline,xpixel;
 433
 434                 xline = (LPBYTE)this->s.surface+xdst.top*this->s.lpitch;
 435                 for (i=xdst.top;i<xdst.bottom;i++) {
 436                         xpixel = xline+bpp*xdst.left;
 437
 438                         for (j=xdst.left;j<xdst.right;j++) {
 439                                 /* FIXME: this only works on little endian
 440                                  * architectures, where DWORD starts with low
 441                                  * byte first!
 442                                  */
 443                                 memcpy(xpixel,&(lpbltfx->b.dwFillColor),bpp);
 444                                 xpixel += bpp;
 445                         }
 446                         xline += this->s.lpitch;
 447                 }
 448                 dwFlags &= ~(DDBLT_COLORFILL);
 449         }
 450         dwFlags &= ~(DDBLT_WAIT|DDBLT_ASYNC);/* FIXME: can't handle right now */
 451         if (    (xsrc.top ==0) && (xsrc.bottom ==this->s.height) &&
 452                 (xsrc.left==0) && (xsrc.right  ==this->s.width) &&
 453                 (xdst.top ==0) && (xdst.bottom ==this->s.height) &&
 454                 (xdst.left==0) && (xdst.right  ==this->s.width)  &&
 455                 !dwFlags
 456         ) {
 457                 memcpy(this->s.surface,src->s.surface,this->s.height*this->s.lpitch);
 458                 return 0;
 459         }
 460         if (dwFlags) {
 461                 fprintf(stderr,"IDirectDrawSurface(%p)->Blt(%p,%p,%p,%08lx,%p),stub!\n",
 462                         this,rdst,src,rsrc,dwFlags,lpbltfx
 463                 );
 464                 if (rdst) fprintf(stderr,"      destrect :%dx%d-%dx%d\n",rdst->left,rdst->top,rdst->right,rdst->bottom);
 465                 if (rsrc) fprintf(stderr,"      srcrect  :%dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 466                 fprintf(stderr,"\tflags: ");_dump_DDBLT(dwFlags);fprintf(stderr,"\n");
 467         }
 468         if (dwFlags & DDBLT_DDFX) {
 469                 fprintf(stderr,"        blitfx: ");_dump_DDBLTFX(lpbltfx->dwDDFX);fprintf(stderr,"\n");
 470         }
 471         return 0;
 472 }
 473
 474 static HRESULT WINAPI IDirectDrawSurface_BltFast(
 475         LPDIRECTDRAWSURFACE this,DWORD dstx,DWORD dsty,LPDIRECTDRAWSURFACE src,LPRECT32 rsrc,DWORD trans
 476 ) {
 477         int     i,bpp;
 478         if (debugging_info(ddraw)) {
 479             fprintf(stderr,"IDirectDrawSurface(%p)->BltFast(%ld,%ld,%p,%p,%08lx),stub!\n",
 480                     this,dstx,dsty,src,rsrc,trans
 481             );
 482             fprintf(stderr,"    trans:");_dump_DDBLTFAST(trans);fprintf(stderr,"\n");
 483             fprintf(stderr,"    srcrect: %dx%d-%dx%d\n",rsrc->left,rsrc->top,rsrc->right,rsrc->bottom);
 484         }
 485         bpp = this->s.ddraw->d.depth/8;
 486         for (i=0;i<rsrc->bottom-rsrc->top;i++) {
 487                 memcpy( this->s.surface+((i+dsty)*this->s.width*bpp)+dstx*bpp,
 488                         src->s.surface +(rsrc->top+i)*src->s.width*bpp+rsrc->left*bpp,
 489                         (rsrc->right-rsrc->left)*bpp
 490                 );
 491         }
 492         return 0;
 493 }
 494
 495 static HRESULT WINAPI IDirectDrawSurface_BltBatch(
 496         LPDIRECTDRAWSURFACE this,LPDDBLTBATCH ddbltbatch,DWORD x,DWORD y
 497 ) {
 498         fprintf(stderr,"IDirectDrawSurface(%p)->BltBatch(%p,%08lx,%08lx),stub!\n",
 499                 this,ddbltbatch,x,y
 500         );
 501         return 0;
 502 }
 503
 504 static HRESULT WINAPI IDirectDrawSurface_GetCaps(
 505         LPDIRECTDRAWSURFACE this,LPDDSCAPS caps
 506 ) {
 507         dprintf_info(ddraw,"IDirectDrawSurface(%p)->GetCaps(%p)\n",this,caps);
 508         caps->dwCaps = DDCAPS_PALETTE; /* probably more */
 509         return 0;
 510 }
 511
 512 static HRESULT WINAPI IDirectDrawSurface_GetSurfaceDesc(
 513         LPDIRECTDRAWSURFACE this,LPDDSURFACEDESC ddsd
 514 ) {
 515         if (debugging_info(ddraw)) {
 516                 dprintf_info(ddraw, "IDirectDrawSurface(%p)->GetSurfaceDesc(%p)\n",
 517                              this,ddsd);
 518                 fprintf(stderr,"        flags: ");
 519                 _dump_DDSD(ddsd->dwFlags);
 520                 fprintf(stderr,"\n");
 521         }
 522
 523         ddsd->dwFlags |= DDSD_PIXELFORMAT|DDSD_CAPS|DDSD_BACKBUFFERCOUNT|DDSD_HEIGHT|DDSD_WIDTH;
 524         ddsd->ddsCaps.dwCaps    = DDSCAPS_PALETTE;
 525         ddsd->dwBackBufferCount = 1;
 526         ddsd->dwHeight          = this->s.height;
 527         ddsd->dwWidth           = this->s.width;
 528         ddsd->lPitch            = this->s.lpitch;
 529         if (this->s.backbuffer)
 530                 ddsd->ddsCaps.dwCaps |= DDSCAPS_PRIMARYSURFACE|DDSCAPS_FLIP;
 531         _getpixelformat(this->s.ddraw,&(ddsd->ddpfPixelFormat));
 532
 533         return 0;
 534 }
 535
 536 static ULONG WINAPI IDirectDrawSurface_AddRef(LPDIRECTDRAWSURFACE this) {
 537         dprintf_info(ddraw,"IDirectDrawSurface(%p)->AddRef()\n",this);
 538         return ++(this->ref);
 539 }
 540
 541 static ULONG WINAPI IDirectDrawSurface_Release(LPDIRECTDRAWSURFACE this) {
 542         dprintf_info(ddraw,"IDirectDrawSurface(%p)->Release()\n",this);
 543         if (!--(this->ref)) {
 544                 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
 545                 /* clear out of surface list */
 546                 if (this->s.fb_height == -1) {
 547                         HeapFree(GetProcessHeap(),0,this->s.surface);
 548                 } else {
 549                         this->s.ddraw->d.vpmask &= ~(1<<(this->s.fb_height/this->s.ddraw->d.fb_height));
 550                 }
 551                 HeapFree(GetProcessHeap(),0,this);
 552                 return 0;
 553         }
 554         return this->ref;
 555 }
 556
 557 static HRESULT WINAPI IDirectDrawSurface_GetAttachedSurface(
 558         LPDIRECTDRAWSURFACE this,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE *lpdsf
 559 ) {
 560         dprintf_info(ddraw, "IDirectDrawSurface(%p)->GetAttachedSurface(%p,%p)\n",
 561                      this, lpddsd, lpdsf);
 562         if (debugging_info(ddraw)) {
 563                 fprintf(stderr,"        caps ");
 564                 _dump_DDSCAPS(lpddsd->dwCaps);
 565                 fprintf(stderr,"\n");
 566         }
 567         if (!(lpddsd->dwCaps & DDSCAPS_BACKBUFFER)) {
 568                 fprintf(stderr,"IDirectDrawSurface::GetAttachedSurface():whoops, can only handle backbuffers for now\n");
 569                 return E_FAIL;
 570         }
 571         /* FIXME: should handle more than one backbuffer */
 572         *lpdsf = this->s.backbuffer;
 573         return 0;
 574 }
 575
 576 static HRESULT WINAPI IDirectDrawSurface_Initialize(
 577         LPDIRECTDRAWSURFACE this,LPDIRECTDRAW ddraw,LPDDSURFACEDESC lpdsfd
 578 ) {
 579         return DDERR_ALREADYINITIALIZED;
 580 }
 581
 582 static HRESULT WINAPI IDirectDrawSurface_GetPixelFormat(
 583         LPDIRECTDRAWSURFACE this,LPDDPIXELFORMAT pf
 584 ) {
 585         return _getpixelformat(this->s.ddraw,pf);
 586 }
 587
 588 static HRESULT WINAPI IDirectDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE this,DWORD dwFlags) {
 589         fprintf(stderr,"IDirectDrawSurface(%p)->GetBltStatus(0x%08lx),stub!\n",
 590                 this,dwFlags
 591         );
 592         return 0;
 593 }
 594
 595 static HRESULT WINAPI IDirectDrawSurface_GetOverlayPosition(
 596         LPDIRECTDRAWSURFACE this,LPLONG x1,LPLONG x2
 597 ) {
 598         fprintf(stderr,"IDirectDrawSurface(%p)->GetOverlayPosition(%p,%p),stub!\n",
 599                 this,x1,x2
 600         );
 601         return 0;
 602 }
 603
 604 static HRESULT WINAPI IDirectDrawSurface_SetClipper(
 605         LPDIRECTDRAWSURFACE this,LPDIRECTDRAWCLIPPER clipper
 606 ) {
 607         fprintf(stderr,"IDirectDrawSurface(%p)->SetClipper(%p),stub!\n",this,clipper);
 608         return 0;
 609 }
 610
 611 static HRESULT WINAPI IDirectDrawSurface_AddAttachedSurface(
 612         LPDIRECTDRAWSURFACE this,LPDIRECTDRAWSURFACE surf
 613 ) {
 614         fprintf(stderr,"IDirectDrawSurface(%p)->AddAttachedSurface(%p),stub!\n",this,surf);
 615         this->s.backbuffer = surf;
 616         return 0;
 617 }
 618
 619 static HRESULT WINAPI IDirectDrawSurface_GetDC(LPDIRECTDRAWSURFACE this,HDC32* lphdc) {
 620         fprintf(stderr,"IDirectDrawSurface(%p)->GetDC(%p),stub!\n",this,lphdc);
 621         return 0;
 622 }
 623
 624 static HRESULT WINAPI IDirectDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE this,REFIID refiid,LPVOID *obj) {
 625         char    xrefiid[50];
 626
 627         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
 628         dprintf_info(ddraw,"IDirectDrawSurface(%p)->QueryInterface(%s,%p)\n",this,xrefiid,obj);
 629
 630         /* thats version 3 (DirectX 5) */
 631         if (    !memcmp(&IID_IDirectDrawSurface3,refiid,sizeof(IID_IDirectDrawSurface3))) {
 632                 this->lpvtbl->fnAddRef(this);
 633                 this->lpvtbl = (LPDIRECTDRAWSURFACE_VTABLE)&dds3vt;
 634                 *obj = this;
 635                 return 0;
 636         }
 637         /* thats version 2 (DirectX 3) */
 638         if (    !memcmp(&IID_IDirectDrawSurface2,refiid,sizeof(IID_IDirectDrawSurface2))) {
 639                 this->lpvtbl->fnAddRef(this);
 640                 this->lpvtbl = (LPDIRECTDRAWSURFACE_VTABLE)&dds2vt;
 641                 *obj = this;
 642                 return 0;
 643         }
 644         /* thats us */
 645         if (!memcmp(&IID_IDirectDrawSurface,refiid,sizeof(IID_IDirectDrawSurface))) {
 646                 this->lpvtbl->fnAddRef(this);
 647                 *obj = this;
 648                 return 0;
 649         }
 650         fprintf(stderr,"IDirectDrawSurface(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
 651         return OLE_E_ENUM_NOMORE;
 652 }
 653
 654 static HRESULT WINAPI IDirectDrawSurface_IsLost(LPDIRECTDRAWSURFACE this) {
 655         return 0; /* hmm */
 656 }
 657
 658 static struct IDirectDrawSurface_VTable ddsvt = {
 659         IDirectDrawSurface_QueryInterface,
 660         IDirectDrawSurface_AddRef,
 661         IDirectDrawSurface_Release,
 662         IDirectDrawSurface_AddAttachedSurface,
 663         (void*)5,
 664         IDirectDrawSurface_Blt,
 665         IDirectDrawSurface_BltBatch,
 666         IDirectDrawSurface_BltFast,
 667         (void*)9,
 668         (void*)10,
 669         (void*)11,
 670         IDirectDrawSurface_Flip,
 671         IDirectDrawSurface_GetAttachedSurface,
 672         IDirectDrawSurface_GetBltStatus,
 673         IDirectDrawSurface_GetCaps,
 674         (void*)16,
 675         (void*)17,
 676         IDirectDrawSurface_GetDC,
 677         (void*)19,
 678         IDirectDrawSurface_GetOverlayPosition,
 679         (void*)21,
 680         IDirectDrawSurface_GetPixelFormat,
 681         IDirectDrawSurface_GetSurfaceDesc,
 682         IDirectDrawSurface_Initialize,
 683         IDirectDrawSurface_IsLost,
 684         IDirectDrawSurface_Lock,
 685         (void*)27,
 686         (void*)28,
 687         IDirectDrawSurface_SetClipper,
 688         (void*)30,
 689         (void*)31,
 690         IDirectDrawSurface_SetPalette,
 691         IDirectDrawSurface_Unlock,
 692         (void*)34,
 693         (void*)35,
 694         (void*)36,
 695 };
 696
 697 /******************************************************************************
 698  *                      IDirectDrawSurface2
 699  *
 700  * calls IDirectDrawSurface methods where possible
 701  */
 702 static HRESULT WINAPI IDirectDrawSurface2_Lock(
 703     LPDIRECTDRAWSURFACE2 this,LPRECT32 lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE32 hnd
 704 ) {
 705         return IDirectDrawSurface_Lock((LPDIRECTDRAWSURFACE)this,lprect,lpddsd,flags,hnd);
 706 }
 707
 708 static HRESULT WINAPI IDirectDrawSurface2_Unlock(
 709         LPDIRECTDRAWSURFACE2 this,LPVOID surface
 710 ) {
 711         dprintf_info(ddraw,"IDirectDrawSurface2(%p)->Unlock(%p)\n",this,surface);
 712         return 0;
 713 }
 714
 715 static HRESULT WINAPI IDirectDrawSurface2_SetPalette(
 716         LPDIRECTDRAWSURFACE2 this,LPDIRECTDRAWPALETTE pal
 717 ) {
 718         return IDirectDrawSurface_SetPalette((LPDIRECTDRAWSURFACE)this,pal);
 719 }
 720
 721 static ULONG WINAPI IDirectDrawSurface2_AddRef(LPDIRECTDRAWSURFACE2 this) {
 722         dprintf_info(ddraw,"IDirectDrawSurface2(%p)->AddRef()\n",this);
 723         return ++(this->ref);
 724 }
 725
 726 static ULONG WINAPI IDirectDrawSurface2_Release(LPDIRECTDRAWSURFACE2 this) {
 727         return IDirectDrawSurface_Release((LPDIRECTDRAWSURFACE)this);
 728 }
 729
 730 static HRESULT WINAPI IDirectDrawSurface2_GetAttachedSurface(
 731         LPDIRECTDRAWSURFACE2 this,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE2 *lpdsf
 732 ) {
 733         HRESULT ret = IDirectDrawSurface_GetAttachedSurface((LPDIRECTDRAWSURFACE)this,lpddsd,(LPDIRECTDRAWSURFACE*)lpdsf);
 734
 735         if (!ret)
 736                 (*lpdsf)->lpvtbl = &dds2vt;
 737         return ret;
 738 }
 739
 740 static HRESULT WINAPI IDirectDrawSurface2_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE2 this,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
 741         fprintf(stderr,"IDirectDrawSurface(%p)->EnumAttachedSurfaces(%p,%p),stub!\n",this,context,esfcb);
 742         return 0;
 743 }
 744
 745 static HRESULT WINAPI IDirectDrawSurface2_QueryInterface(
 746         LPDIRECTDRAWSURFACE2 this,REFIID riid,LPVOID *ppobj
 747 ) {
 748         return IDirectDrawSurface_QueryInterface((LPDIRECTDRAWSURFACE)this,riid,ppobj);
 749 }
 750
 751 static HRESULT WINAPI IDirectDrawSurface2_IsLost(LPDIRECTDRAWSURFACE2 this) {
 752         return 0; /* hmm */
 753 }
 754
 755
 756 static struct IDirectDrawSurface2_VTable dds2vt = {
 757         IDirectDrawSurface2_QueryInterface,
 758         IDirectDrawSurface2_AddRef,
 759         IDirectDrawSurface2_Release,
 760         (void*)4,
 761         (void*)5,
 762         (void*)6/*IDirectDrawSurface_Blt*/,
 763         (void*)7/*IDirectDrawSurface_BltBatch*/,
 764         (void*)8,
 765         (void*)9,
 766         IDirectDrawSurface2_EnumAttachedSurfaces,
 767         (void*)11,
 768         (void*)12,
 769         IDirectDrawSurface2_GetAttachedSurface,
 770         (void*)14,
 771         (void*)15/*IDirectDrawSurface_GetCaps*/,
 772         (void*)16,
 773         (void*)17,
 774         (void*)18,
 775         (void*)19,
 776         (void*)20,
 777         (void*)21,
 778         (void*)22,
 779         (void*)23/*IDirectDrawSurface_GetSurfaceDesc*/,
 780         (void*)24,
 781         IDirectDrawSurface2_IsLost,
 782         IDirectDrawSurface2_Lock,
 783         (void*)27,
 784         (void*)28,
 785         (void*)29,
 786         (void*)30,
 787         (void*)31,
 788         IDirectDrawSurface2_SetPalette,
 789         IDirectDrawSurface2_Unlock,
 790         (void*)34,
 791         (void*)35,
 792         (void*)36,
 793         (void*)37,
 794         (void*)38,
 795         (void*)39,
 796 };
 797
 798 /******************************************************************************
 799  *                      IDirectDrawSurface3
 800  */
 801 static HRESULT WINAPI IDirectDrawSurface3_SetPalette(
 802         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWPALETTE pal
 803 ) {
 804         return IDirectDrawSurface_SetPalette((LPDIRECTDRAWSURFACE)this,pal);
 805 }
 806
 807 static HRESULT WINAPI IDirectDrawSurface3_GetPixelFormat(
 808         LPDIRECTDRAWSURFACE3 this,LPDDPIXELFORMAT pf
 809 ) {
 810         return _getpixelformat(this->s.ddraw,pf);
 811 }
 812
 813 static HRESULT WINAPI IDirectDrawSurface3_GetAttachedSurface(
 814         LPDIRECTDRAWSURFACE3 this,LPDDSCAPS lpddsd,LPDIRECTDRAWSURFACE3 *lpdsf
 815 ) {
 816         HRESULT ret = IDirectDrawSurface_GetAttachedSurface((LPDIRECTDRAWSURFACE)this,lpddsd,(LPDIRECTDRAWSURFACE*)lpdsf);
 817
 818         if (!ret)
 819                 (*lpdsf)->lpvtbl = &dds3vt;
 820         return ret;
 821 }
 822
 823 static ULONG WINAPI IDirectDrawSurface3_AddRef(LPDIRECTDRAWSURFACE3 this) {
 824         dprintf_info(ddraw,"IDirectDrawSurface3(%p)->AddRef()\n",this);
 825         return ++(this->ref);
 826 }
 827
 828 static ULONG WINAPI IDirectDrawSurface3_Release(LPDIRECTDRAWSURFACE3 this) {
 829         dprintf_info(ddraw,"IDirectDrawSurface3(%p)->Release()\n",this);
 830         if (!--(this->ref)) {
 831                 this->s.ddraw->lpvtbl->fnRelease(this->s.ddraw);
 832                 this->s.ddraw->d.vpmask &= ~(1<<(this->s.fb_height/this->s.ddraw->d.fb_height));
 833                 HeapFree(GetProcessHeap(),0,this);
 834                 return 0;
 835         }
 836         return this->ref;
 837 }
 838
 839 static HRESULT WINAPI IDirectDrawSurface3_Blt(
 840         LPDIRECTDRAWSURFACE3 this,LPRECT32 rdst,LPDIRECTDRAWSURFACE3 src,
 841         LPRECT32 rsrc,DWORD dwFlags,LPDDBLTFX lpbltfx
 842 ) {
 843         return IDirectDrawSurface_Blt((LPDIRECTDRAWSURFACE)this,rdst,(LPDIRECTDRAWSURFACE)src,rsrc,dwFlags,lpbltfx);
 844 }
 845
 846 static HRESULT WINAPI IDirectDrawSurface3_IsLost(LPDIRECTDRAWSURFACE3 this) {
 847         return 0; /* hmm */
 848 }
 849
 850 static HRESULT WINAPI IDirectDrawSurface3_Restore(LPDIRECTDRAWSURFACE3 this) {
 851         return 0;
 852 }
 853
 854 static HRESULT WINAPI IDirectDrawSurface3_GetBltStatus(
 855         LPDIRECTDRAWSURFACE3 this,DWORD dwflags
 856 ) {
 857         return IDirectDrawSurface_GetBltStatus((LPDIRECTDRAWSURFACE)this,dwflags);
 858 }
 859
 860 static HRESULT WINAPI IDirectDrawSurface3_Flip(
 861         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWSURFACE3 flipto,DWORD dwFlags
 862 ) {
 863         return IDirectDrawSurface_Flip((LPDIRECTDRAWSURFACE)this,(LPDIRECTDRAWSURFACE)flipto,dwFlags);
 864 }
 865
 866 static HRESULT WINAPI IDirectDrawSurface3_Lock(
 867     LPDIRECTDRAWSURFACE3 this,LPRECT32 lprect,LPDDSURFACEDESC lpddsd,DWORD flags, HANDLE32 hnd
 868 ) {
 869         return IDirectDrawSurface_Lock((LPDIRECTDRAWSURFACE)this,lprect,lpddsd,flags,hnd);
 870 }
 871
 872 static HRESULT WINAPI IDirectDrawSurface3_Unlock(
 873         LPDIRECTDRAWSURFACE3 this,LPVOID surface
 874 ) {
 875         return IDirectDrawSurface_Unlock((LPDIRECTDRAWSURFACE)this,surface);
 876 }
 877
 878 static HRESULT WINAPI IDirectDrawSurface3_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE3 this,LPVOID context,LPDDENUMSURFACESCALLBACK esfcb) {
 879         fprintf(stderr,"IDirectDrawSurface3(%p)->EnumAttachedSurfaces(%p,%p),stub!\n",this,context,esfcb);
 880         return 0;
 881 }
 882
 883 static HRESULT WINAPI IDirectDrawSurface3_SetClipper(
 884         LPDIRECTDRAWSURFACE3 this,LPDIRECTDRAWCLIPPER clipper
 885 ) {
 886         return IDirectDrawSurface_SetClipper((LPDIRECTDRAWSURFACE)this,clipper);
 887 }
 888
 889 static HRESULT WINAPI IDirectDrawSurface3_QueryInterface(
 890         LPDIRECTDRAWSURFACE3 this,REFIID riid,LPVOID *ppobj
 891 ) {
 892         return IDirectDrawSurface_QueryInterface((LPDIRECTDRAWSURFACE)this,riid,ppobj);
 893 }
 894
 895 static struct IDirectDrawSurface3_VTable dds3vt = {
 896         IDirectDrawSurface3_QueryInterface,
 897         IDirectDrawSurface3_AddRef,
 898         IDirectDrawSurface3_Release,
 899         (void*)4,
 900         (void*)5,
 901         IDirectDrawSurface3_Blt,
 902         (void*)7,
 903         (void*)8,
 904         (void*)9,
 905         IDirectDrawSurface3_EnumAttachedSurfaces,
 906         (void*)11,
 907         IDirectDrawSurface3_Flip,
 908         IDirectDrawSurface3_GetAttachedSurface,
 909         IDirectDrawSurface3_GetBltStatus,
 910         (void*)15,
 911         (void*)16,
 912         (void*)17,
 913         (void*)18,
 914         (void*)19,
 915         (void*)20,
 916         (void*)21,
 917         IDirectDrawSurface3_GetPixelFormat,
 918         (void*)23,
 919         (void*)24,
 920         IDirectDrawSurface3_IsLost,
 921         IDirectDrawSurface3_Lock,
 922         (void*)27,
 923         IDirectDrawSurface3_Restore,
 924         IDirectDrawSurface3_SetClipper,
 925         (void*)30,
 926         (void*)31,
 927         IDirectDrawSurface3_SetPalette,
 928         IDirectDrawSurface3_Unlock,
 929         (void*)34,
 930         (void*)35,
 931         (void*)36,
 932         (void*)37,
 933         (void*)38,
 934         (void*)39,
 935         (void*)40,
 936 };
 937
 938
 939 /******************************************************************************
 940  *                      IDirectDrawClipper
 941  */
 942 static HRESULT WINAPI IDirectDrawClipper_SetHwnd(
 943         LPDIRECTDRAWCLIPPER this,DWORD x,HWND32 hwnd
 944 ) {
 945         fprintf(stderr,"IDirectDrawClipper(%p)->SetHwnd(0x%08lx,0x%08lx),stub!\n",this,x,(DWORD)hwnd);
 946         return 0;
 947 }
 948
 949 static ULONG WINAPI IDirectDrawClipper_Release(LPDIRECTDRAWCLIPPER this) {
 950         this->ref--;
 951         if (this->ref)
 952                 return this->ref;
 953         HeapFree(GetProcessHeap(),0,this);
 954         return 0;
 955 }
 956
 957 static struct IDirectDrawClipper_VTable ddclipvt = {
 958         (void*)1,
 959         (void*)2,
 960         IDirectDrawClipper_Release,
 961         (void*)4,
 962         (void*)5,
 963         (void*)6,
 964         (void*)7,
 965         (void*)8,
 966         IDirectDrawClipper_SetHwnd
 967 };
 968
 969 /******************************************************************************
 970  *                      IDirectDrawPalette
 971  */
 972 static HRESULT WINAPI IDirectDrawPalette_GetEntries(
 973         LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD end,LPPALETTEENTRY palent
 974 ) {
 975         int     i;
 976
 977         fprintf(stderr,"IDirectDrawPalette(%p)->GetEntries(%08lx,%ld,%ld,%p),stub!\n",
 978                 this,x,start,end,palent
 979         );
 980         for (i=start;i<end;i++) {
 981                 palent[i-start].peRed = i;
 982                 palent[i-start].peGreen = i;
 983                 palent[i-start].peBlue = i;
 984         }
 985         return 0;
 986 }
 987
 988 static HRESULT WINAPI IDirectDrawPalette_SetEntries(
 989         LPDIRECTDRAWPALETTE this,DWORD x,DWORD start,DWORD end,LPPALETTEENTRY palent
 990 ) {
 991         XColor          xc;
 992         int             i;
 993
 994         dprintf_info(ddraw,"IDirectDrawPalette(%p)->SetEntries(%08lx,%ld,%ld,%p)\n",
 995                 this,x,start,end,palent
 996         );
 997         if (!this->cm) /* should not happen */ {
 998                 fprintf(stderr,"no colormap in SetEntries???\n");
 999                 return DDERR_GENERIC;
1000         }
1001 /* FIXME: free colorcells instead of freeing whole map */
1002         TSXFreeColormap(display,this->cm);
1003         this->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(screen),AllocAll);
1004         if (start>0) {
1005                 xc.red = xc.blue = xc.green = 0; xc.flags = DoRed|DoGreen|DoBlue; xc.pixel = 0; TSXStoreColor(display,this->cm,&xc);
1006                 this->palents[0].peRed = 0;
1007                 this->palents[0].peBlue = 0;
1008                 this->palents[0].peGreen = 0;
1009         }
1010         if (end<256) {
1011                 xc.red = xc.blue = xc.green = 0xffff; xc.flags = DoRed|DoGreen|DoBlue; xc.pixel = 255; TSXStoreColor(display,this->cm,&xc);
1012                 this->palents[255].peRed = 255;
1013                 this->palents[255].peBlue = 255;
1014                 this->palents[255].peGreen = 255;
1015         }
1016         for (i=start;i<end;i++) {
1017                 xc.red = palent[i-start].peRed<<8;
1018                 xc.blue = palent[i-start].peBlue<<8;
1019                 xc.green = palent[i-start].peGreen<<8;
1020                 xc.flags = DoRed|DoBlue|DoGreen;
1021                 xc.pixel = i;
1022                 TSXStoreColor(display,this->cm,&xc);
1023                 this->palents[i].peRed = palent[i-start].peRed;
1024                 this->palents[i].peBlue = palent[i-start].peBlue;
1025                 this->palents[i].peGreen = palent[i-start].peGreen;
1026         }
1027         XF86DGAInstallColormap(display,DefaultScreen(display),this->cm);
1028         return 0;
1029 }
1030
1031 static ULONG WINAPI IDirectDrawPalette_Release(LPDIRECTDRAWPALETTE this) {
1032         if (!--(this->ref)) {
1033                 if (this->cm) {
1034                         TSXFreeColormap(display,this->cm);
1035                         this->cm = 0;
1036                 }
1037                 HeapFree(GetProcessHeap(),0,this);
1038                 return 0;
1039         }
1040         return this->ref;
1041 }
1042
1043 static ULONG WINAPI IDirectDrawPalette_AddRef(LPDIRECTDRAWPALETTE this) {
1044         return ++(this->ref);
1045 }
1046
1047 static HRESULT WINAPI IDirectDrawPalette_Initialize(
1048         LPDIRECTDRAWPALETTE this,LPDIRECTDRAW ddraw,DWORD x,LPPALETTEENTRY palent
1049 ) {
1050         return DDERR_ALREADYINITIALIZED;
1051 }
1052
1053 static struct IDirectDrawPalette_VTable ddpalvt = {
1054         (void*)1,
1055         IDirectDrawPalette_AddRef,
1056         IDirectDrawPalette_Release,
1057         (void*)4,
1058         IDirectDrawPalette_GetEntries,
1059         IDirectDrawPalette_Initialize,
1060         IDirectDrawPalette_SetEntries
1061 };
1062
1063 /*******************************************************************************
1064  *                              IDirect3D
1065  */
1066 static struct IDirect3D_VTable d3dvt = {
1067         (void*)1,
1068         (void*)2,
1069         (void*)3,
1070         (void*)4,
1071         (void*)5,
1072         (void*)6,
1073         (void*)7,
1074         (void*)8,
1075         (void*)9,
1076 };
1077
1078 /*******************************************************************************
1079  *                              IDirect3D2
1080  */
1081 static ULONG WINAPI IDirect3D2_Release(LPDIRECT3D2 this) {
1082         this->ref--;
1083         if (!this->ref) {
1084                 this->ddraw->lpvtbl->fnRelease(this->ddraw);
1085                 HeapFree(GetProcessHeap(),0,this);
1086                 return 0;
1087         }
1088         return this->ref;
1089 }
1090
1091 static HRESULT WINAPI IDirect3D2_EnumDevices(
1092         LPDIRECT3D2 this,LPD3DENUMDEVICESCALLBACK cb, LPVOID context
1093 ) {
1094         D3DDEVICEDESC   d1,d2;
1095
1096         fprintf(stderr,"IDirect3D2(%p)->EnumDevices(%p,%p),stub!\n",this,cb,context);
1097         d1.dwSize       = sizeof(d1);
1098         d1.dwFlags      = 0;
1099
1100         d2.dwSize       = sizeof(d2);
1101         d2.dwFlags      = 0;
1102         cb(&IID_IDirect3DHALDevice,"WINE Direct3D HAL","direct3d",&d1,&d2,context);
1103         return 0;
1104 }
1105
1106 static struct IDirect3D2_VTable d3d2vt = {
1107         (void*)1,
1108         (void*)2,
1109         IDirect3D2_Release,
1110         IDirect3D2_EnumDevices,
1111         (void*)5,
1112         (void*)6,
1113         (void*)7,
1114         (void*)8,
1115         (void*)9,
1116 };
1117
1118 /*******************************************************************************
1119  *                              IDirectDraw
1120  */
1121 static HRESULT WINAPI IDirectDraw_CreateSurface(
1122         LPDIRECTDRAW this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
1123 ) {
1124         int     i;
1125
1126         dprintf_info(ddraw, "IDirectDraw(%p)->CreateSurface(%p,%p,%p)\n",
1127                      this,lpddsd,lpdsf,lpunk);
1128         if (debugging_info(ddraw)) {
1129                 fprintf(stderr,"[w=%ld,h=%ld,flags ",lpddsd->dwWidth,lpddsd->dwHeight);
1130                 _dump_DDSD(lpddsd->dwFlags);
1131                 fprintf(stderr,"caps ");
1132                 _dump_DDSCAPS(lpddsd->ddsCaps.dwCaps);
1133                 fprintf(stderr,"]\n");
1134         }
1135
1136         *lpdsf = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
1137         this->lpvtbl->fnAddRef(this);
1138         (*lpdsf)->ref = 1;
1139         (*lpdsf)->lpvtbl = &ddsvt;
1140         if (    (lpddsd->dwFlags & DDSD_CAPS) &&
1141                 (lpddsd->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN)
1142         ) {
1143                 if (!(lpddsd->dwFlags & DDSD_WIDTH))
1144                         lpddsd->dwWidth = this->d.fb_width;
1145                 if (!(lpddsd->dwFlags & DDSD_HEIGHT))
1146                         lpddsd->dwWidth = this->d.fb_height;
1147                 (*lpdsf)->s.surface = (LPBYTE)HeapAlloc(GetProcessHeap(),0,lpddsd->dwWidth*lpddsd->dwHeight*this->d.depth/8);
1148                 (*lpdsf)->s.fb_height = -1;
1149                 (*lpdsf)->s.lpitch = lpddsd->dwWidth*this->d.depth/8;
1150                 dprintf_info(ddraw,"using system memory for a primary surface\n");
1151         } else {
1152                 for (i=0;i<32;i++)
1153                         if (!(this->d.vpmask & (1<<i)))
1154                                 break;
1155                 dprintf_info(ddraw,"using viewport %d for a primary surface\n",i);
1156                 /* if i == 32 or maximum ... return error */
1157                 this->d.vpmask|=(1<<i);
1158                 (*lpdsf)->s.surface = this->d.fb_addr+((i*this->d.fb_height)*this->d.fb_width*this->d.depth/8);
1159                 (*lpdsf)->s.fb_height = i*this->d.fb_height;
1160                 (*lpdsf)->s.lpitch = this->d.fb_width*this->d.depth/8;
1161         }
1162
1163         lpddsd->lPitch = (*lpdsf)->s.lpitch;
1164
1165         (*lpdsf)->s.width = this->d.width;
1166         (*lpdsf)->s.height = this->d.height;
1167         (*lpdsf)->s.ddraw = this;
1168         (*lpdsf)->s.backbuffer = NULL;
1169         if (lpddsd->dwFlags & DDSD_BACKBUFFERCOUNT) {
1170                 LPDIRECTDRAWSURFACE     back;
1171
1172                 if (lpddsd->dwBackBufferCount>1)
1173                         fprintf(stderr,"urks, wants to have more than one backbuffer (%ld)!\n",lpddsd->dwBackBufferCount);
1174
1175                 (*lpdsf)->s.backbuffer = back = (LPDIRECTDRAWSURFACE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawSurface));
1176                 this->lpvtbl->fnAddRef(this);
1177                 back->ref = 1;
1178                 back->lpvtbl = &ddsvt;
1179                 for (i=0;i<32;i++)
1180                         if (!(this->d.vpmask & (1<<i)))
1181                                 break;
1182                 dprintf_info(ddraw,"using viewport %d for backbuffer\n",i);
1183                 /* if i == 32 or maximum ... return error */
1184                 this->d.vpmask|=(1<<i);
1185                 back->s.surface = this->d.fb_addr+((i*this->d.fb_height)*this->d.fb_width*this->d.depth/8);
1186                 back->s.fb_height = i*this->d.fb_height;
1187
1188                 back->s.width = this->d.width;
1189                 back->s.height = this->d.height;
1190                 back->s.ddraw = this;
1191                 back->s.lpitch = this->d.fb_width*this->d.depth/8;
1192                 back->s.backbuffer = NULL; /* does not have a backbuffer, it is
1193                                           * one! */
1194         }
1195         return 0;
1196 }
1197
1198 static HRESULT WINAPI IDirectDraw_DuplicateSurface(
1199         LPDIRECTDRAW this,LPDIRECTDRAWSURFACE src,LPDIRECTDRAWSURFACE *dst
1200 ) {
1201         fprintf(stderr,"IDirectDraw(%p)->DuplicateSurface(%p,%p)\n",this,src,dst);
1202         *dst = src; /* FIXME */
1203         return 0;
1204 }
1205
1206 static HRESULT WINAPI IDirectDraw_SetCooperativeLevel(
1207         LPDIRECTDRAW this,HWND32 hwnd,DWORD cooplevel
1208 ) {
1209         int     i;
1210         const struct {
1211                 int     mask;
1212                 char    *name;
1213         } flagmap[] = {
1214                 FE(DDSCL_FULLSCREEN)
1215                 FE(DDSCL_ALLOWREBOOT)
1216                 FE(DDSCL_NOWINDOWCHANGES)
1217                 FE(DDSCL_NORMAL)
1218                 FE(DDSCL_ALLOWMODEX)
1219                 FE(DDSCL_EXCLUSIVE)
1220                 FE(DDSCL_SETFOCUSWINDOW)
1221                 FE(DDSCL_SETDEVICEWINDOW)
1222                 FE(DDSCL_CREATEDEVICEWINDOW)
1223         };
1224
1225         dprintf_info(ddraw,"IDirectDraw(%p)->SetCooperativeLevel(%08lx,%08lx)\n",
1226                 this,(DWORD)hwnd,cooplevel
1227         );
1228         if(debugging_info(ddraw)){
1229           dbg_decl_str(ddraw, 512);
1230           for (i=0;i<sizeof(flagmap)/sizeof(flagmap[0]);i++)
1231             if (flagmap[i].mask & cooplevel)
1232               dsprintf(ddraw, "%s ", flagmap[i].name);
1233           dprintf_info(ddraw,"  cooperative level %s\n", dbg_str(ddraw));
1234         }
1235         this->d.mainwindow = hwnd;
1236         return 0;
1237 }
1238
1239
1240 static HRESULT WINAPI IDirectDraw_SetDisplayMode(
1241         LPDIRECTDRAW this,DWORD width,DWORD height,DWORD depth
1242 ) {
1243         int     i,*depths,depcount;
1244         char    buf[200];
1245
1246         dprintf_fixme(ddraw, "IDirectDraw(%p)->SetDisplayMode(%ld,%ld,%ld),stub!\n",
1247                       this, width, height, depth);
1248
1249         depths = TSXListDepths(display,DefaultScreen(display),&depcount);
1250         for (i=0;i<depcount;i++)
1251                 if (depths[i]==depth)
1252                         break;
1253         TSXFree(depths);
1254         if (i==depcount) {/* not found */
1255                 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), unsupported depth!",width,height,depth);
1256                 MessageBox32A(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
1257                 return DDERR_UNSUPPORTEDMODE;
1258         }
1259         if (this->d.fb_width < width) {
1260                 sprintf(buf,"SetDisplayMode(w=%ld,h=%ld,d=%ld), width %ld exceeds framebuffer width %ld",width,height,depth,width,this->d.fb_width);
1261                 MessageBox32A(0,buf,"WINE DirectDraw",MB_OK|MB_ICONSTOP);
1262                 return DDERR_UNSUPPORTEDMODE;
1263         }
1264         this->d.width   = width;
1265         this->d.height  = height;
1266         /* adjust fb_height, so we don't overlap */
1267         if (this->d.fb_height < height)
1268                 this->d.fb_height = height;
1269         this->d.depth   = depth;
1270
1271         /* FIXME: this function OVERWRITES several signal handlers.
1272          * can we save them? and restore them later? In a way that
1273          * it works for the library too?
1274          */
1275         XF86DGADirectVideo(display,DefaultScreen(display),XF86DGADirectGraphics);
1276         XF86DGASetViewPort(display,DefaultScreen(display),0,this->d.fb_height);
1277 #ifdef RESTORE_SIGNALS
1278         SIGNAL_InitEmulator();
1279 #endif
1280         return 0;
1281 }
1282
1283 static HRESULT WINAPI IDirectDraw_GetCaps(
1284         LPDIRECTDRAW this,LPDDCAPS caps1,LPDDCAPS caps2
1285 )  {
1286         dprintf_info(ddraw,"IDirectDraw(%p)->GetCaps(%p,%p)\n",this,caps1,caps2);
1287         caps1->dwVidMemTotal = this->d.fb_memsize;
1288         caps1->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1289         caps1->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1290         if (caps2) {
1291                 caps2->dwVidMemTotal = this->d.fb_memsize;
1292                 caps2->dwCaps = 0xffffffff&~(DDCAPS_BANKSWITCHED);              /* we can do anything */
1293                 caps2->ddsCaps.dwCaps = 0xffffffff;     /* we can do anything */
1294         }
1295         return 0;
1296 }
1297
1298 static HRESULT WINAPI IDirectDraw_CreateClipper(
1299         LPDIRECTDRAW this,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
1300 ) {
1301         fprintf(stderr,"IDirectDraw(%p)->CreateClipper(%08lx,%p,%p),stub!\n",
1302                 this,x,lpddclip,lpunk
1303         );
1304         *lpddclip = (LPDIRECTDRAWCLIPPER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawClipper));
1305         (*lpddclip)->ref = 1;
1306         (*lpddclip)->lpvtbl = &ddclipvt;
1307         return 0;
1308 }
1309
1310 static HRESULT WINAPI IDirectDraw_CreatePalette(
1311         LPDIRECTDRAW this,DWORD x,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
1312 ) {
1313         dprintf_info(ddraw,"IDirectDraw(%p)->CreatePalette(%08lx,%p,%p,%p)\n",
1314                 this,x,palent,lpddpal,lpunk
1315         );
1316         *lpddpal = (LPDIRECTDRAWPALETTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawPalette));
1317         (*lpddpal)->ref = 1;
1318         (*lpddpal)->lpvtbl = &ddpalvt;
1319         (*lpddpal)->ddraw = this;
1320         if (this->d.depth<=8) {
1321                 (*lpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(screen),AllocAll);
1322         } else /* we don't want palettes in hicolor or truecolor */
1323                 (*lpddpal)->cm = 0;
1324
1325         return 0;
1326 }
1327
1328 static HRESULT WINAPI IDirectDraw_RestoreDisplayMode(LPDIRECTDRAW this) {
1329         dprintf_fixme(ddraw, "IDirectDraw(%p)->RestoreDisplayMode(),stub!\n",
1330                       this);
1331         Sleep(1000);
1332         XF86DGADirectVideo(display,DefaultScreen(display),0);
1333 #ifdef RESTORE_SIGNALS
1334         SIGNAL_InitEmulator();
1335 #endif
1336         return 0;
1337 }
1338
1339
1340 static HRESULT WINAPI IDirectDraw_WaitForVerticalBlank(
1341         LPDIRECTDRAW this,DWORD x,HANDLE32 h
1342 ) {
1343         dprintf_info(ddraw,"IDirectDraw(%p)->WaitForVerticalBlank(0x%08lx,0x%08x),stub!\n",this,x,h);
1344         return 0;
1345 }
1346
1347 static ULONG WINAPI IDirectDraw_AddRef(LPDIRECTDRAW this) {
1348         return ++(this->ref);
1349 }
1350
1351 static ULONG WINAPI IDirectDraw_Release(LPDIRECTDRAW this) {
1352         if (!--(this->ref)) {
1353                 XF86DGADirectVideo(display,DefaultScreen(display),0);
1354 #ifdef RESTORE_SIGNALS
1355                 SIGNAL_InitEmulator();
1356 #endif
1357                 HeapFree(GetProcessHeap(),0,this);
1358                 return 0;
1359         }
1360         return this->ref;
1361 }
1362
1363 static HRESULT WINAPI IDirectDraw_QueryInterface(
1364         LPDIRECTDRAW this,REFIID refiid,LPVOID *obj
1365 ) {
1366         char    xrefiid[50];
1367
1368         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1369         dprintf_info(ddraw,"IDirectDraw(%p)->QueryInterface(%s,%p)\n",this,xrefiid,obj);
1370         if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1371                 *obj = this;
1372                 this->lpvtbl->fnAddRef(this);
1373                 return 0;
1374         }
1375         if (!memcmp(&IID_IDirectDraw,refiid,sizeof(IID_IDirectDraw))) {
1376                 *obj = this;
1377                 this->lpvtbl->fnAddRef(this);
1378                 return 0;
1379         }
1380         if (!memcmp(&IID_IDirectDraw2,refiid,sizeof(IID_IDirectDraw2))) {
1381                 this->lpvtbl = (LPDIRECTDRAW_VTABLE)&dd2vt;
1382                 this->lpvtbl->fnAddRef(this);
1383                 *obj = this;
1384                 return 0;
1385         }
1386         if (!memcmp(&IID_IDirect3D,refiid,sizeof(IID_IDirect3D))) {
1387                 LPDIRECT3D      d3d;
1388
1389                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1390                 d3d->ref = 1;
1391                 d3d->ddraw = this;
1392                 this->lpvtbl->fnAddRef(this);
1393                 d3d->lpvtbl = &d3dvt;
1394                 *obj = d3d;
1395                 return 0;
1396         }
1397         if (!memcmp(&IID_IDirect3D2,refiid,sizeof(IID_IDirect3D))) {
1398                 LPDIRECT3D2     d3d;
1399
1400                 d3d = HeapAlloc(GetProcessHeap(),0,sizeof(*d3d));
1401                 d3d->ref = 1;
1402                 d3d->ddraw = this;
1403                 this->lpvtbl->fnAddRef(this);
1404                 d3d->lpvtbl = &d3d2vt;
1405                 *obj = d3d;
1406                 return 0;
1407         }
1408         fprintf(stderr,"IDirectDraw(%p):interface for IID %s _NOT_ found!\n",this,xrefiid);
1409         return OLE_E_ENUM_NOMORE;
1410 }
1411
1412 static HRESULT WINAPI IDirectDraw_GetVerticalBlankStatus(
1413         LPDIRECTDRAW this,BOOL32 *status
1414 ) {
1415         dprintf_info(ddraw,"IDirectDraw(%p)->GetVerticalBlankSatus(%p)\n",this,status);
1416         *status = TRUE;
1417         return 0;
1418 }
1419
1420 static HRESULT WINAPI IDirectDraw_EnumDisplayModes(
1421         LPDIRECTDRAW this,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
1422 ) {
1423         DDSURFACEDESC   ddsfd;
1424
1425         dprintf_info(ddraw,"IDirectDraw(%p)->EnumDisplayModes(0x%08lx,%p,%p,%p)\n",this,dwFlags,lpddsfd,context,modescb);
1426
1427
1428         _getpixelformat(this,&(ddsfd.ddpfPixelFormat));
1429         ddsfd.dwSize = sizeof(ddsfd);
1430         ddsfd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
1431         if (dwFlags & DDEDM_REFRESHRATES) {
1432                 ddsfd.dwFlags |= DDSD_REFRESHRATE;
1433                 ddsfd.x.dwRefreshRate = 60;
1434         }
1435
1436         ddsfd.dwWidth = 640;
1437         ddsfd.dwHeight = 480;
1438         ddsfd.dwBackBufferCount = 1;
1439         ddsfd.ddsCaps.dwCaps = DDSCAPS_PALETTE;
1440
1441         if (!modescb(&ddsfd,context)) return 0;
1442
1443         ddsfd.dwWidth = 800;
1444         ddsfd.dwHeight = 600;
1445         if (!modescb(&ddsfd,context)) return 0;
1446
1447         if (!(dwFlags & DDEDM_STANDARDVGAMODES)) {
1448                 /* modeX is not standard VGA */
1449
1450                 ddsfd.dwHeight = 200;
1451                 ddsfd.dwWidth = 320;
1452                 if (!modescb(&ddsfd,context)) return 0;
1453         }
1454         return DD_OK;
1455 }
1456
1457 static HRESULT WINAPI IDirectDraw_GetDisplayMode(
1458         LPDIRECTDRAW this,LPDDSURFACEDESC lpddsfd
1459 ) {
1460         dprintf_info(ddraw,"IDirectDraw(%p)->GetDisplayMode(%p)\n",this,lpddsfd);
1461         lpddsfd->dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PITCH|DDSD_BACKBUFFERCOUNT|DDSD_PIXELFORMAT|DDSD_CAPS;
1462         lpddsfd->dwHeight = screenHeight;
1463         lpddsfd->dwWidth = screenWidth;
1464         lpddsfd->lPitch = this->d.fb_width*this->d.depth/8;
1465         lpddsfd->dwBackBufferCount = 1;
1466         lpddsfd->x.dwRefreshRate = 60;
1467         lpddsfd->ddsCaps.dwCaps = DDSCAPS_PALETTE;
1468         _getpixelformat(this,&(lpddsfd->ddpfPixelFormat));
1469         return DD_OK;
1470 }
1471
1472 static HRESULT WINAPI IDirectDraw_FlipToGDISurface(LPDIRECTDRAW this) {
1473         fprintf(stderr,"IDirectDraw(%p)->FlipToGDISurface(),stub!\n",this);
1474         return DD_OK;
1475 }
1476
1477 static HRESULT WINAPI IDirectDraw_GetMonitorFrequency(
1478         LPDIRECTDRAW this,LPDWORD freq
1479 ) {
1480         fprintf(stderr,"IDirectDraw(%p)->GetMonitorFrequency(%p)\n",this,freq);
1481         *freq = 60*100; /* 60 Hz */
1482         return 0;
1483 }
1484
1485 static IDirectDraw_VTable ddvt = {
1486         IDirectDraw_QueryInterface,
1487         IDirectDraw_AddRef,
1488         IDirectDraw_Release,
1489         (void*)4,
1490         IDirectDraw_CreateClipper,
1491         IDirectDraw_CreatePalette,
1492         IDirectDraw_CreateSurface,
1493         IDirectDraw_DuplicateSurface,
1494         IDirectDraw_EnumDisplayModes,
1495         (void*)10,
1496         IDirectDraw_FlipToGDISurface,
1497         IDirectDraw_GetCaps,
1498         IDirectDraw_GetDisplayMode,
1499         (void*)14,
1500         (void*)15,
1501         IDirectDraw_GetMonitorFrequency,
1502         (void*)17,
1503         IDirectDraw_GetVerticalBlankStatus,
1504         (void*)19,
1505         IDirectDraw_RestoreDisplayMode,
1506         IDirectDraw_SetCooperativeLevel,
1507         IDirectDraw_SetDisplayMode,
1508         IDirectDraw_WaitForVerticalBlank,
1509 };
1510
1511 /*****************************************************************************
1512  *      IDirectDraw2
1513  *
1514  */
1515 static HRESULT WINAPI IDirectDraw2_CreateClipper(
1516         LPDIRECTDRAW2 this,DWORD x,LPDIRECTDRAWCLIPPER *lpddclip,LPUNKNOWN lpunk
1517 ) {
1518         return IDirectDraw_CreateClipper((LPDIRECTDRAW)this,x,lpddclip,lpunk);
1519 }
1520
1521 static HRESULT WINAPI IDirectDraw2_CreateSurface(
1522         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsd,LPDIRECTDRAWSURFACE *lpdsf,IUnknown *lpunk
1523 ) {
1524         return IDirectDraw_CreateSurface((LPDIRECTDRAW)this,lpddsd,(LPDIRECTDRAWSURFACE*)lpdsf,lpunk);
1525 }
1526
1527 static HRESULT WINAPI IDirectDraw2_QueryInterface(
1528         LPDIRECTDRAW2 this,REFIID refiid,LPVOID *obj
1529 ) {
1530         return IDirectDraw_QueryInterface((LPDIRECTDRAW)this,refiid,obj);
1531 }
1532
1533 static ULONG WINAPI IDirectDraw2_AddRef(LPDIRECTDRAW2 this) {
1534         return IDirectDraw_AddRef((LPDIRECTDRAW)this);
1535 }
1536
1537 static ULONG WINAPI IDirectDraw2_Release(LPDIRECTDRAW2 this) {
1538         return IDirectDraw_Release((LPDIRECTDRAW)this);
1539 }
1540
1541 static HRESULT WINAPI IDirectDraw2_GetCaps(
1542         LPDIRECTDRAW2 this,LPDDCAPS caps1,LPDDCAPS caps2
1543 )  {
1544         return IDirectDraw_GetCaps((LPDIRECTDRAW)this,caps1,caps2);
1545 }
1546
1547 static HRESULT WINAPI IDirectDraw2_SetCooperativeLevel(
1548         LPDIRECTDRAW2 this,HWND32 hwnd,DWORD x
1549 ) {
1550         return IDirectDraw_SetCooperativeLevel((LPDIRECTDRAW)this,hwnd,x);
1551 }
1552
1553 static HRESULT WINAPI IDirectDraw2_CreatePalette(
1554         LPDIRECTDRAW2 this,DWORD x,LPPALETTEENTRY palent,LPDIRECTDRAWPALETTE *lpddpal,LPUNKNOWN lpunk
1555 ) {
1556         return IDirectDraw_CreatePalette((LPDIRECTDRAW)this,x,palent,lpddpal,lpunk);
1557 }
1558
1559
1560 static HRESULT WINAPI IDirectDraw2_SetDisplayMode(
1561         LPDIRECTDRAW2 this,DWORD width,DWORD height,DWORD depth,DWORD xx,DWORD yy
1562 ) {
1563         dprintf_fixme(ddraw,"IDirectDraw2(%p)->SetDisplayMode(%ld,%ld,%ld,%08lx,%08lx),stub!\n",
1564                       this, width, height, depth, xx, yy);
1565
1566         return IDirectDraw_SetDisplayMode((LPDIRECTDRAW)this,width,height,depth);
1567 }
1568
1569 static HRESULT WINAPI IDirectDraw2_RestoreDisplayMode(LPDIRECTDRAW2 this) {
1570         return IDirectDraw_RestoreDisplayMode((LPDIRECTDRAW)this);
1571 }
1572
1573 static HRESULT WINAPI IDirectDraw2_EnumSurfaces(
1574         LPDIRECTDRAW2 this,DWORD x,LPDDSURFACEDESC ddsfd,LPVOID context,LPDDENUMSURFACESCALLBACK ddsfcb
1575 ) {
1576         fprintf(stderr,"IDirectDraw2(%p)->EnumSurfaces(0x%08lx,%p,%p,%p),stub!\n",this,x,ddsfd,context,ddsfcb);
1577         return 0;
1578 }
1579
1580 static HRESULT WINAPI IDirectDraw2_EnumDisplayModes(
1581         LPDIRECTDRAW2 this,DWORD dwFlags,LPDDSURFACEDESC lpddsfd,LPVOID context,LPDDENUMMODESCALLBACK modescb
1582 ) {
1583         return IDirectDraw_EnumDisplayModes((LPDIRECTDRAW)this,dwFlags,lpddsfd,context,modescb);
1584 }
1585
1586 static HRESULT WINAPI IDirectDraw2_GetDisplayMode(
1587         LPDIRECTDRAW2 this,LPDDSURFACEDESC lpddsfd
1588 ) {
1589         return IDirectDraw_GetDisplayMode((LPDIRECTDRAW)this,lpddsfd);
1590 }
1591
1592 static HRESULT WINAPI IDirectDraw2_GetAvailableVidMem(
1593         LPDIRECTDRAW2 this,LPDDSCAPS ddscaps,LPDWORD total,LPDWORD free
1594 ) {
1595         fprintf(stderr,"IDirectDraw2(%p)->GetAvailableVidMem(%p,%p,%p)\n",
1596                 this,ddscaps,total,free
1597         );
1598         if (total) *total = this->d.fb_memsize * 1024;
1599         if (free) *free = this->d.fb_memsize * 1024;
1600         return 0;
1601 }
1602
1603 static HRESULT WINAPI IDirectDraw2_GetMonitorFrequency(
1604         LPDIRECTDRAW2 this,LPDWORD freq
1605 ) {
1606         return IDirectDraw_GetMonitorFrequency((LPDIRECTDRAW)this,freq);
1607 }
1608
1609 static HRESULT WINAPI IDirectDraw2_GetVerticalBlankStatus(
1610         LPDIRECTDRAW2 this,BOOL32 *status
1611 ) {
1612         return IDirectDraw_GetVerticalBlankStatus((LPDIRECTDRAW)this,status);
1613 }
1614
1615 static HRESULT WINAPI IDirectDraw2_WaitForVerticalBlank(
1616         LPDIRECTDRAW2 this,DWORD x,HANDLE32 h
1617 ) {
1618         return IDirectDraw_WaitForVerticalBlank((LPDIRECTDRAW)this,x,h);
1619 }
1620
1621 static IDirectDraw2_VTable dd2vt = {
1622         IDirectDraw2_QueryInterface,
1623         IDirectDraw2_AddRef,
1624         IDirectDraw2_Release,
1625         (void*)4,
1626         IDirectDraw2_CreateClipper,
1627         IDirectDraw2_CreatePalette,
1628         IDirectDraw2_CreateSurface,
1629         (void*)8,
1630         IDirectDraw2_EnumDisplayModes,
1631         IDirectDraw2_EnumSurfaces,
1632         (void*)11,
1633         IDirectDraw2_GetCaps,
1634         IDirectDraw2_GetDisplayMode,
1635         (void*)14,
1636         (void*)15,
1637         IDirectDraw2_GetMonitorFrequency,
1638         (void*)17,
1639         IDirectDraw2_GetVerticalBlankStatus,
1640         (void*)19,
1641         IDirectDraw2_RestoreDisplayMode,
1642         IDirectDraw2_SetCooperativeLevel,
1643         IDirectDraw2_SetDisplayMode,
1644         IDirectDraw2_WaitForVerticalBlank,
1645         IDirectDraw2_GetAvailableVidMem
1646
1647 };
1648
1649 /******************************************************************************
1650  *                              DirectDrawCreate
1651  */
1652
1653 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
1654
1655         char    xclsid[50];
1656         int     memsize,banksize,width,evbase,evret,major,minor,flags,height;
1657         char    *addr;
1658
1659         if (lpGUID)
1660                 WINE_StringFromCLSID(lpGUID,xclsid);
1661         else
1662                 strcpy(xclsid,"<null>");
1663
1664         dprintf_info(ddraw,"DirectDrawCreate(%s,%p,%p)\n",xclsid,lplpDD,pUnkOuter);
1665         if (getuid()) {
1666                 MessageBox32A(0,"Using the XF86DGA extension requires the program to be run using UID 0.","WINE DirectDraw",MB_OK|MB_ICONSTOP);
1667                 return E_UNEXPECTED;
1668         }
1669         *lplpDD = (LPDIRECTDRAW)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDraw));
1670         (*lplpDD)->lpvtbl = &ddvt;
1671         (*lplpDD)->ref = 1;
1672         if (!XF86DGAQueryExtension(display,&evbase,&evret)) {
1673                 fprintf(stderr,"No XF86DGA detected.\n");
1674                 return 0;
1675         }
1676         XF86DGAQueryVersion(display,&major,&minor);
1677         dprintf_info(ddraw,"XF86DGA is version %d.%d\n",major,minor);
1678         XF86DGAQueryDirectVideo(display,DefaultScreen(display),&flags);
1679         if (!(flags & XF86DGADirectPresent))
1680                 fprintf(stderr,"direct video is NOT ENABLED.\n");
1681         XF86DGAGetVideo(display,DefaultScreen(display),&addr,&width,&banksize,&memsize);
1682         dprintf_info(ddraw,"video framebuffer: begin %p, width %d,banksize %d,memsize %d\n",
1683                 addr,width,banksize,memsize
1684         );
1685         (*lplpDD)->d.fb_width = width;
1686         (*lplpDD)->d.fb_addr = addr;
1687         (*lplpDD)->d.fb_memsize = memsize;
1688         (*lplpDD)->d.fb_banksize = banksize;
1689
1690         XF86DGAGetViewPortSize(display,DefaultScreen(display),&width,&height);
1691         XF86DGASetViewPort(display,DefaultScreen(display),0,0);
1692         (*lplpDD)->d.vp_width = width;
1693         (*lplpDD)->d.vp_height = height;
1694         (*lplpDD)->d.fb_height = screenHeight;
1695         (*lplpDD)->d.vpmask = 1;
1696
1697         /* just assume the default depth is the DGA depth too */
1698         (*lplpDD)->d.depth = DefaultDepthOfScreen(screen);
1699 #ifdef RESTORE_SIGNALS
1700         SIGNAL_InitEmulator();
1701 #endif
1702         return 0;
1703 }
1704 #else
1705
1706 HRESULT WINAPI DirectDrawCreate( LPGUID lpGUID, LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter ) {
1707         MessageBox32A(0,"WINE DirectDraw needs the XF86DGA extensions compiled in. (libXxf86dga.a).","WINE DirectDraw",MB_OK|MB_ICONSTOP);
1708         return E_OUTOFMEMORY;
1709 }
1710 #endif