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