7867008d6c1d6bd34123181f0f6011cc55cac5e6
[reactos.git] / dll / directx / wine / wined3d / surface_gdi.c
1 /*
2 * 2D Surface implementation without OpenGL
3 *
4 * Copyright 1997-2000 Marcus Meissner
5 * Copyright 1998-2000 Lionel Ulmer
6 * Copyright 2000-2001 TransGaming Technologies Inc.
7 * Copyright 2002-2005 Jason Edmeades
8 * Copyright 2002-2003 Raphael Junqueira
9 * Copyright 2004 Christian Costa
10 * Copyright 2005 Oliver Stieber
11 * Copyright 2006-2008 Stefan Dösinger
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28 #include "config.h"
29 #include "wine/port.h"
30 #include "wined3d_private.h"
31
32 #include <stdio.h>
33
34 /* Use the d3d_surface debug channel to have one channel for all surfaces */
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
36
37 void surface_gdi_cleanup(IWineD3DSurfaceImpl *This)
38 {
39 TRACE("(%p) : Cleaning up.\n", This);
40
41 if (This->Flags & SFLAG_DIBSECTION)
42 {
43 /* Release the DC. */
44 SelectObject(This->hDC, This->dib.holdbitmap);
45 DeleteDC(This->hDC);
46 /* Release the DIB section. */
47 DeleteObject(This->dib.DIBsection);
48 This->dib.bitmap_data = NULL;
49 This->resource.allocatedMemory = NULL;
50 }
51
52 if (This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
53 if (This->overlay_dest) list_remove(&This->overlay_entry);
54
55 HeapFree(GetProcessHeap(), 0, This->palette9);
56
57 resource_cleanup((IWineD3DResource *)This);
58 }
59
60 /*****************************************************************************
61 * IWineD3DSurface::Release, GDI version
62 *
63 * In general a normal COM Release method, but the GDI version doesn't have
64 * to destroy all the GL things.
65 *
66 *****************************************************************************/
67 static ULONG WINAPI IWineGDISurfaceImpl_Release(IWineD3DSurface *iface) {
68 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
69 ULONG ref = InterlockedDecrement(&This->resource.ref);
70 TRACE("(%p) : Releasing from %d\n", This, ref + 1);
71
72 if (!ref)
73 {
74 surface_gdi_cleanup(This);
75
76 TRACE("(%p) Released.\n", This);
77 HeapFree(GetProcessHeap(), 0, This);
78 }
79
80 return ref;
81 }
82
83 /*****************************************************************************
84 * IWineD3DSurface::PreLoad, GDI version
85 *
86 * This call is unsupported on GDI surfaces, if it's called something went
87 * wrong in the parent library. Write an informative warning
88 *
89 *****************************************************************************/
90 static void WINAPI
91 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface)
92 {
93 ERR("(%p): PreLoad is not supported on X11 surfaces!\n", iface);
94 ERR("(%p): Most likely the parent library did something wrong.\n", iface);
95 ERR("(%p): Please report to wine-devel\n", iface);
96 }
97
98 /*****************************************************************************
99 * IWineD3DSurface::UnLoad, GDI version
100 *
101 * This call is unsupported on GDI surfaces, if it's called something went
102 * wrong in the parent library. Write an informative warning.
103 *
104 *****************************************************************************/
105 static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface)
106 {
107 ERR("(%p): UnLoad is not supported on X11 surfaces!\n", iface);
108 ERR("(%p): Most likely the parent library did something wrong.\n", iface);
109 ERR("(%p): Please report to wine-devel\n", iface);
110 }
111
112 /*****************************************************************************
113 * IWineD3DSurface::LockRect, GDI version
114 *
115 * Locks the surface and returns a pointer to the surface memory
116 *
117 * Params:
118 * pLockedRect: Address to return the locking info at
119 * pRect: Rectangle to lock
120 * Flags: Some flags
121 *
122 * Returns:
123 * WINED3D_OK on success
124 * WINED3DERR_INVALIDCALL on errors
125 *
126 *****************************************************************************/
127 static HRESULT WINAPI
128 IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface,
129 WINED3DLOCKED_RECT* pLockedRect,
130 CONST RECT* pRect,
131 DWORD Flags)
132 {
133 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
134
135 /* Already locked? */
136 if(This->Flags & SFLAG_LOCKED)
137 {
138 WARN("(%p) Surface already locked\n", This);
139 /* What should I return here? */
140 return WINED3DERR_INVALIDCALL;
141 }
142 This->Flags |= SFLAG_LOCKED;
143
144 if(!This->resource.allocatedMemory) {
145 /* This happens on gdi surfaces if the application set a user pointer and resets it.
146 * Recreate the DIB section
147 */
148 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
149 This->resource.allocatedMemory = This->dib.bitmap_data;
150 }
151
152 return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
153 }
154
155 /*****************************************************************************
156 * IWineD3DSurface::UnlockRect, GDI version
157 *
158 * Unlocks a surface. This implementation doesn't do much, except updating
159 * the window if the front buffer is unlocked
160 *
161 * Returns:
162 * WINED3D_OK on success
163 * WINED3DERR_INVALIDCALL on failure
164 *
165 *****************************************************************************/
166 static HRESULT WINAPI
167 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
168 {
169 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
170 IWineD3DSwapChainImpl *swapchain = NULL;
171 TRACE("(%p)\n", This);
172
173 if (!(This->Flags & SFLAG_LOCKED))
174 {
175 WARN("trying to Unlock an unlocked surf@%p\n", This);
176 return WINEDDERR_NOTLOCKED;
177 }
178
179 /* Can be useful for debugging */
180 #if 0
181 {
182 static unsigned int gen = 0;
183 char buffer[4096];
184 ++gen;
185 if ((gen % 10) == 0) {
186 snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm",
187 This, This->texture_target, This->texture_level, gen);
188 IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
189 }
190 /*
191 * debugging crash code
192 if (gen == 250) {
193 void** test = NULL;
194 *test = 0;
195 }
196 */
197 }
198 #endif
199
200 /* Tell the swapchain to update the screen */
201 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
202 {
203 if(iface == swapchain->frontBuffer)
204 {
205 x11_copy_to_screen(swapchain, &This->lockedRect);
206 }
207 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
208 }
209
210 This->Flags &= ~SFLAG_LOCKED;
211 memset(&This->lockedRect, 0, sizeof(RECT));
212 return WINED3D_OK;
213 }
214
215 /*****************************************************************************
216 * IWineD3DSurface::Flip, GDI version
217 *
218 * Flips 2 flipping enabled surfaces. Determining the 2 targets is done by
219 * the parent library. This implementation changes the data pointers of the
220 * surfaces and copies the new front buffer content to the screen
221 *
222 * Params:
223 * override: Flipping target(e.g. back buffer)
224 *
225 * Returns:
226 * WINED3D_OK on success
227 *
228 *****************************************************************************/
229 static HRESULT WINAPI
230 IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface,
231 IWineD3DSurface *override,
232 DWORD Flags)
233 {
234 IWineD3DSwapChainImpl *swapchain = NULL;
235 HRESULT hr;
236
237 if(FAILED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
238 {
239 ERR("Flipped surface is not on a swapchain\n");
240 return WINEDDERR_NOTFLIPPABLE;
241 }
242
243 hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *) swapchain, NULL, NULL, 0, NULL, 0);
244 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
245 return hr;
246 }
247
248 /*****************************************************************************
249 * IWineD3DSurface::LoadTexture, GDI version
250 *
251 * This is mutually unsupported by GDI surfaces
252 *
253 * Returns:
254 * D3DERR_INVALIDCALL
255 *
256 *****************************************************************************/
257 static HRESULT WINAPI
258 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
259 {
260 ERR("Unsupported on X11 surfaces\n");
261 return WINED3DERR_INVALIDCALL;
262 }
263
264 /*****************************************************************************
265 * IWineD3DSurface::SaveSnapshot, GDI version
266 *
267 * This method writes the surface's contents to the in tga format to the
268 * file specified in filename.
269 *
270 * Params:
271 * filename: File to write to
272 *
273 * Returns:
274 * WINED3DERR_INVALIDCALL if the file couldn't be opened
275 * WINED3D_OK on success
276 *
277 *****************************************************************************/
278 static int get_shift(DWORD color_mask) {
279 int shift = 0;
280 while (color_mask > 0xFF) {
281 color_mask >>= 1;
282 shift += 1;
283 }
284 while ((color_mask & 0x80) == 0) {
285 color_mask <<= 1;
286 shift -= 1;
287 }
288 return shift;
289 }
290
291
292 static HRESULT WINAPI
293 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
294 const char* filename)
295 {
296 FILE* f = NULL;
297 UINT y = 0, x = 0;
298 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
299 static char *output = NULL;
300 static UINT size = 0;
301 const struct GlPixelFormatDesc *format_desc = This->resource.format_desc;
302
303 if (This->pow2Width > size) {
304 output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
305 size = This->pow2Width;
306 }
307
308
309 f = fopen(filename, "w+");
310 if (NULL == f) {
311 ERR("opening of %s failed with\n", filename);
312 return WINED3DERR_INVALIDCALL;
313 }
314 fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
315
316 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT)
317 {
318 unsigned char table[256][3];
319 int i;
320
321 if (This->palette == NULL) {
322 fclose(f);
323 return WINED3DERR_INVALIDCALL;
324 }
325 for (i = 0; i < 256; i++) {
326 table[i][0] = This->palette->palents[i].peRed;
327 table[i][1] = This->palette->palents[i].peGreen;
328 table[i][2] = This->palette->palents[i].peBlue;
329 }
330 for (y = 0; y < This->pow2Height; y++) {
331 unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
332 for (x = 0; x < This->pow2Width; x++) {
333 unsigned char color = *src;
334 src += 1;
335
336 output[3 * x + 0] = table[color][0];
337 output[3 * x + 1] = table[color][1];
338 output[3 * x + 2] = table[color][2];
339 }
340 fwrite(output, 3 * This->pow2Width, 1, f);
341 }
342 } else {
343 int red_shift, green_shift, blue_shift, pix_width, alpha_shift;
344
345 pix_width = format_desc->byte_count;
346
347 red_shift = get_shift(format_desc->red_mask);
348 green_shift = get_shift(format_desc->green_mask);
349 blue_shift = get_shift(format_desc->blue_mask);
350 alpha_shift = get_shift(format_desc->alpha_mask);
351
352 for (y = 0; y < This->pow2Height; y++) {
353 const unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
354 for (x = 0; x < This->pow2Width; x++) {
355 unsigned int color;
356 unsigned int comp;
357 int i;
358
359 color = 0;
360 for (i = 0; i < pix_width; i++) {
361 color |= src[i] << (8 * i);
362 }
363 src += 1 * pix_width;
364
365 comp = color & format_desc->red_mask;
366 output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
367 comp = color & format_desc->green_mask;
368 output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
369 comp = color & format_desc->alpha_mask;
370 output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift;
371 }
372 fwrite(output, 3 * This->pow2Width, 1, f);
373 }
374 }
375 fclose(f);
376 return WINED3D_OK;
377 }
378
379 static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC) {
380 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
381 WINED3DLOCKED_RECT lock;
382 HRESULT hr;
383 RGBQUAD col[256];
384
385 TRACE("(%p)->(%p)\n",This,pHDC);
386
387 if(!(This->Flags & SFLAG_DIBSECTION))
388 {
389 WARN("DC not supported on this surface\n");
390 return WINED3DERR_INVALIDCALL;
391 }
392
393 if(This->Flags & SFLAG_USERPTR) {
394 ERR("Not supported on surfaces with an application-provided surfaces\n");
395 return WINEDDERR_NODC;
396 }
397
398 /* Give more detailed info for ddraw */
399 if (This->Flags & SFLAG_DCINUSE)
400 return WINEDDERR_DCALREADYCREATED;
401
402 /* Can't GetDC if the surface is locked */
403 if (This->Flags & SFLAG_LOCKED)
404 return WINED3DERR_INVALIDCALL;
405
406 memset(&lock, 0, sizeof(lock)); /* To be sure */
407
408 /* Should have a DIB section already */
409
410 /* Lock the surface */
411 hr = IWineD3DSurface_LockRect(iface,
412 &lock,
413 NULL,
414 0);
415 if(FAILED(hr)) {
416 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
417 /* keep the dib section */
418 return hr;
419 }
420
421 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
422 || This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
423 {
424 unsigned int n;
425 const PALETTEENTRY *pal = NULL;
426
427 if(This->palette) {
428 pal = This->palette->palents;
429 } else {
430 IWineD3DSurfaceImpl *dds_primary;
431 IWineD3DSwapChainImpl *swapchain;
432 swapchain = (IWineD3DSwapChainImpl *)This->resource.wineD3DDevice->swapchains[0];
433 dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
434 if (dds_primary && dds_primary->palette)
435 pal = dds_primary->palette->palents;
436 }
437
438 if (pal) {
439 for (n=0; n<256; n++) {
440 col[n].rgbRed = pal[n].peRed;
441 col[n].rgbGreen = pal[n].peGreen;
442 col[n].rgbBlue = pal[n].peBlue;
443 col[n].rgbReserved = 0;
444 }
445 SetDIBColorTable(This->hDC, 0, 256, col);
446 }
447 }
448
449 *pHDC = This->hDC;
450 TRACE("returning %p\n",*pHDC);
451 This->Flags |= SFLAG_DCINUSE;
452
453 return WINED3D_OK;
454 }
455
456 static HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
457 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
458
459 TRACE("(%p)->(%p)\n",This,hDC);
460
461 if (!(This->Flags & SFLAG_DCINUSE))
462 return WINEDDERR_NODC;
463
464 if (This->hDC !=hDC) {
465 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
466 return WINEDDERR_NODC;
467 }
468
469 /* we locked first, so unlock now */
470 IWineD3DSurface_UnlockRect(iface);
471
472 This->Flags &= ~SFLAG_DCINUSE;
473
474 return WINED3D_OK;
475 }
476
477 static HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) {
478 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
479 RGBQUAD col[256];
480 IWineD3DPaletteImpl *pal = This->palette;
481 unsigned int n;
482 IWineD3DSwapChainImpl *swapchain;
483 TRACE("(%p)\n", This);
484
485 if (!pal) return WINED3D_OK;
486
487 if(This->Flags & SFLAG_DIBSECTION) {
488 TRACE("(%p): Updating the hdc's palette\n", This);
489 for (n=0; n<256; n++) {
490 col[n].rgbRed = pal->palents[n].peRed;
491 col[n].rgbGreen = pal->palents[n].peGreen;
492 col[n].rgbBlue = pal->palents[n].peBlue;
493 col[n].rgbReserved = 0;
494 }
495 SetDIBColorTable(This->hDC, 0, 256, col);
496 }
497
498 /* Update the image because of the palette change. Some games like e.g Red Alert
499 call SetEntries a lot to implement fading. */
500 /* Tell the swapchain to update the screen */
501 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
502 {
503 if(iface == swapchain->frontBuffer)
504 {
505 x11_copy_to_screen(swapchain, NULL);
506 }
507 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
508 }
509
510 return WINED3D_OK;
511 }
512
513 /*****************************************************************************
514 * IWineD3DSurface::PrivateSetup, GDI version
515 *
516 * Initializes the GDI surface, aka creates the DIB section we render to
517 * The DIB section creation is done by calling GetDC, which will create the
518 * section and releasing the dc to allow the app to use it. The dib section
519 * will stay until the surface is released
520 *
521 * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
522 * are set to the real sizes to save memory. The NONPOW2 flag is unset to
523 * avoid confusion in the shared surface code.
524 *
525 * Returns:
526 * WINED3D_OK on success
527 * The return values of called methods on failure
528 *
529 *****************************************************************************/
530 static HRESULT WINAPI
531 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
532 {
533 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
534 HRESULT hr;
535
536 if(This->resource.usage & WINED3DUSAGE_OVERLAY)
537 {
538 ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
539 return WINED3DERR_INVALIDCALL;
540 }
541
542 /* Sysmem textures have memory already allocated -
543 * release it, this avoids an unnecessary memcpy
544 */
545 hr = IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
546 if(SUCCEEDED(hr))
547 {
548 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
549 This->resource.heapMemory = NULL;
550 This->resource.allocatedMemory = This->dib.bitmap_data;
551 }
552
553 /* We don't mind the nonpow2 stuff in GDI */
554 This->pow2Width = This->currentDesc.Width;
555 This->pow2Height = This->currentDesc.Height;
556
557 return WINED3D_OK;
558 }
559
560 static HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
561 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
562
563 /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
564 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
565 ERR("Not supported on render targets\n");
566 return WINED3DERR_INVALIDCALL;
567 }
568
569 if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
570 WARN("Surface is locked or the HDC is in use\n");
571 return WINED3DERR_INVALIDCALL;
572 }
573
574 if(Mem && Mem != This->resource.allocatedMemory) {
575 void *release = NULL;
576
577 /* Do I have to copy the old surface content? */
578 if(This->Flags & SFLAG_DIBSECTION) {
579 /* Release the DC. No need to hold the critical section for the update
580 * Thread because this thread runs only on front buffers, but this method
581 * fails for render targets in the check above.
582 */
583 SelectObject(This->hDC, This->dib.holdbitmap);
584 DeleteDC(This->hDC);
585 /* Release the DIB section */
586 DeleteObject(This->dib.DIBsection);
587 This->dib.bitmap_data = NULL;
588 This->resource.allocatedMemory = NULL;
589 This->hDC = NULL;
590 This->Flags &= ~SFLAG_DIBSECTION;
591 } else if(!(This->Flags & SFLAG_USERPTR)) {
592 release = This->resource.allocatedMemory;
593 }
594 This->resource.allocatedMemory = Mem;
595 This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
596
597 /* Now free the old memory if any */
598 HeapFree(GetProcessHeap(), 0, release);
599 } else if(This->Flags & SFLAG_USERPTR) {
600 /* LockRect and GetDC will re-create the dib section and allocated memory */
601 This->resource.allocatedMemory = NULL;
602 This->Flags &= ~SFLAG_USERPTR;
603 }
604 return WINED3D_OK;
605 }
606
607 /***************************
608 *
609 ***************************/
610 static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
611 TRACE("(%p)->(%s, %s)\n", iface,
612 flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
613 persistent ? "TRUE" : "FALSE");
614 /* GDI surfaces can be in system memory only */
615 if(flag != SFLAG_INSYSMEM) {
616 ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture");
617 }
618 }
619
620 static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
621 if(flag != SFLAG_INSYSMEM) {
622 ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable");
623 } else {
624 TRACE("Surface requested in surface memory\n");
625 }
626 return WINED3D_OK;
627 }
628
629 static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) {
630 return SURFACE_GDI;
631 }
632
633 static HRESULT WINAPI IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
634 FIXME("GDI surfaces can't draw overlays yet\n");
635 return E_FAIL;
636 }
637
638 /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
639 * only IWineD3DBaseSurface and IWineGDISurface ones.
640 */
641 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
642 {
643 /* IUnknown */
644 IWineD3DBaseSurfaceImpl_QueryInterface,
645 IWineD3DBaseSurfaceImpl_AddRef,
646 IWineGDISurfaceImpl_Release,
647 /* IWineD3DResource */
648 IWineD3DBaseSurfaceImpl_GetParent,
649 IWineD3DBaseSurfaceImpl_GetDevice,
650 IWineD3DBaseSurfaceImpl_SetPrivateData,
651 IWineD3DBaseSurfaceImpl_GetPrivateData,
652 IWineD3DBaseSurfaceImpl_FreePrivateData,
653 IWineD3DBaseSurfaceImpl_SetPriority,
654 IWineD3DBaseSurfaceImpl_GetPriority,
655 IWineGDISurfaceImpl_PreLoad,
656 IWineGDISurfaceImpl_UnLoad,
657 IWineD3DBaseSurfaceImpl_GetType,
658 /* IWineD3DSurface */
659 IWineD3DBaseSurfaceImpl_GetContainer,
660 IWineD3DBaseSurfaceImpl_GetDesc,
661 IWineGDISurfaceImpl_LockRect,
662 IWineGDISurfaceImpl_UnlockRect,
663 IWineGDISurfaceImpl_GetDC,
664 IWineGDISurfaceImpl_ReleaseDC,
665 IWineGDISurfaceImpl_Flip,
666 IWineD3DBaseSurfaceImpl_Blt,
667 IWineD3DBaseSurfaceImpl_GetBltStatus,
668 IWineD3DBaseSurfaceImpl_GetFlipStatus,
669 IWineD3DBaseSurfaceImpl_IsLost,
670 IWineD3DBaseSurfaceImpl_Restore,
671 IWineD3DBaseSurfaceImpl_BltFast,
672 IWineD3DBaseSurfaceImpl_GetPalette,
673 IWineD3DBaseSurfaceImpl_SetPalette,
674 IWineGDISurfaceImpl_RealizePalette,
675 IWineD3DBaseSurfaceImpl_SetColorKey,
676 IWineD3DBaseSurfaceImpl_GetPitch,
677 IWineGDISurfaceImpl_SetMem,
678 IWineD3DBaseSurfaceImpl_SetOverlayPosition,
679 IWineD3DBaseSurfaceImpl_GetOverlayPosition,
680 IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
681 IWineD3DBaseSurfaceImpl_UpdateOverlay,
682 IWineD3DBaseSurfaceImpl_SetClipper,
683 IWineD3DBaseSurfaceImpl_GetClipper,
684 /* Internal use: */
685 IWineGDISurfaceImpl_LoadTexture,
686 IWineD3DBaseSurfaceImpl_BindTexture,
687 IWineGDISurfaceImpl_SaveSnapshot,
688 IWineD3DBaseSurfaceImpl_SetContainer,
689 IWineD3DBaseSurfaceImpl_GetData,
690 IWineD3DBaseSurfaceImpl_SetFormat,
691 IWineGDISurfaceImpl_PrivateSetup,
692 IWineGDISurfaceImpl_ModifyLocation,
693 IWineGDISurfaceImpl_LoadLocation,
694 IWineGDISurfaceImpl_GetImplType,
695 IWineGDISurfaceImpl_DrawOverlay
696 };