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