shell32: Add printers CLSID to test, clean up a bit.
[wine/testsucceed.git] / dlls / wined3d / surface_gdi.c
bloba648cde0a1031cdd7f68b4d1068edda1c80f05b2
1 /*
2 * 2D Surface implementation without OpenGL
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
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.
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.
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
28 #include "config.h"
29 #include "wine/port.h"
30 #include "wined3d_private.h"
32 #include <stdio.h>
34 /* Use the d3d_surface debug channel to have one channel for all surfaces */
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
37 void surface_gdi_cleanup(IWineD3DSurfaceImpl *This)
39 TRACE("(%p) : Cleaning up.\n", This);
41 if (This->Flags & SFLAG_DIBSECTION)
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;
52 if (This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
53 if (This->overlay_dest) list_remove(&This->overlay_entry);
55 HeapFree(GetProcessHeap(), 0, This->palette9);
57 resource_cleanup((IWineD3DResource *)This);
60 /*****************************************************************************
61 * IWineD3DSurface::Release, GDI version
63 * In general a normal COM Release method, but the GDI version doesn't have
64 * to destroy all the GL things.
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);
72 if (!ref)
74 surface_gdi_cleanup(This);
76 TRACE("(%p) Released.\n", This);
77 HeapFree(GetProcessHeap(), 0, This);
80 return ref;
83 /*****************************************************************************
84 * IWineD3DSurface::PreLoad, GDI version
86 * This call is unsupported on GDI surfaces, if it's called something went
87 * wrong in the parent library. Write an informative warning
89 *****************************************************************************/
90 static void WINAPI
91 IWineGDISurfaceImpl_PreLoad(IWineD3DSurface *iface)
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);
98 /*****************************************************************************
99 * IWineD3DSurface::UnLoad, GDI version
101 * This call is unsupported on GDI surfaces, if it's called something went
102 * wrong in the parent library. Write an informative warning.
104 *****************************************************************************/
105 static void WINAPI IWineGDISurfaceImpl_UnLoad(IWineD3DSurface *iface)
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);
112 /*****************************************************************************
113 * IWineD3DSurface::LockRect, GDI version
115 * Locks the surface and returns a pointer to the surface memory
117 * Params:
118 * pLockedRect: Address to return the locking info at
119 * pRect: Rectangle to lock
120 * Flags: Some flags
122 * Returns:
123 * WINED3D_OK on success
124 * WINED3DERR_INVALIDCALL on errors
126 *****************************************************************************/
127 static HRESULT WINAPI
128 IWineGDISurfaceImpl_LockRect(IWineD3DSurface *iface,
129 WINED3DLOCKED_RECT* pLockedRect,
130 CONST RECT* pRect,
131 DWORD Flags)
133 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
135 /* Already locked? */
136 if(This->Flags & SFLAG_LOCKED)
138 WARN("(%p) Surface already locked\n", This);
139 /* What should I return here? */
140 return WINED3DERR_INVALIDCALL;
142 This->Flags |= SFLAG_LOCKED;
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
148 IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
149 This->resource.allocatedMemory = This->dib.bitmap_data;
152 return IWineD3DBaseSurfaceImpl_LockRect(iface, pLockedRect, pRect, Flags);
155 /*****************************************************************************
156 * IWineD3DSurface::UnlockRect, GDI version
158 * Unlocks a surface. This implementation doesn't do much, except updating
159 * the window if the front buffer is unlocked
161 * Returns:
162 * WINED3D_OK on success
163 * WINED3DERR_INVALIDCALL on failure
165 *****************************************************************************/
166 static HRESULT WINAPI
167 IWineGDISurfaceImpl_UnlockRect(IWineD3DSurface *iface)
169 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
170 IWineD3DSwapChainImpl *swapchain = NULL;
171 TRACE("(%p)\n", This);
173 if (!(This->Flags & SFLAG_LOCKED))
175 WARN("trying to Unlock an unlocked surf@%p\n", This);
176 return WINEDDERR_NOTLOCKED;
179 /* Can be useful for debugging */
180 #if 0
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);
191 * debugging crash code
192 if (gen == 250) {
193 void** test = NULL;
194 *test = 0;
198 #endif
200 /* Tell the swapchain to update the screen */
201 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
203 if(iface == swapchain->frontBuffer)
205 x11_copy_to_screen(swapchain, &This->lockedRect);
207 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
210 This->Flags &= ~SFLAG_LOCKED;
211 memset(&This->lockedRect, 0, sizeof(RECT));
212 return WINED3D_OK;
215 /*****************************************************************************
216 * IWineD3DSurface::Flip, GDI version
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
222 * Params:
223 * override: Flipping target(e.g. back buffer)
225 * Returns:
226 * WINED3D_OK on success
228 *****************************************************************************/
229 static HRESULT WINAPI
230 IWineGDISurfaceImpl_Flip(IWineD3DSurface *iface,
231 IWineD3DSurface *override,
232 DWORD Flags)
234 IWineD3DSwapChainImpl *swapchain = NULL;
235 HRESULT hr;
237 if(FAILED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
239 ERR("Flipped surface is not on a swapchain\n");
240 return WINEDDERR_NOTFLIPPABLE;
243 hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *)swapchain,
244 NULL, NULL, swapchain->win_handle, NULL, 0);
245 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
246 return hr;
249 /*****************************************************************************
250 * IWineD3DSurface::LoadTexture, GDI version
252 * This is mutually unsupported by GDI surfaces
254 * Returns:
255 * D3DERR_INVALIDCALL
257 *****************************************************************************/
258 static HRESULT WINAPI
259 IWineGDISurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode)
261 ERR("Unsupported on X11 surfaces\n");
262 return WINED3DERR_INVALIDCALL;
265 /*****************************************************************************
266 * IWineD3DSurface::SaveSnapshot, GDI version
268 * This method writes the surface's contents to the in tga format to the
269 * file specified in filename.
271 * Params:
272 * filename: File to write to
274 * Returns:
275 * WINED3DERR_INVALIDCALL if the file couldn't be opened
276 * WINED3D_OK on success
278 *****************************************************************************/
279 static int get_shift(DWORD color_mask) {
280 int shift = 0;
281 while (color_mask > 0xFF) {
282 color_mask >>= 1;
283 shift += 1;
285 while ((color_mask & 0x80) == 0) {
286 color_mask <<= 1;
287 shift -= 1;
289 return shift;
293 static HRESULT WINAPI
294 IWineGDISurfaceImpl_SaveSnapshot(IWineD3DSurface *iface,
295 const char* filename)
297 FILE* f = NULL;
298 UINT y = 0, x = 0;
299 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
300 const struct wined3d_format_desc *format_desc = This->resource.format_desc;
301 static char *output = NULL;
302 static UINT size = 0;
304 if (This->pow2Width > size) {
305 output = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pow2Width * 3);
306 size = This->pow2Width;
310 f = fopen(filename, "w+");
311 if (NULL == f) {
312 ERR("opening of %s failed with\n", filename);
313 return WINED3DERR_INVALIDCALL;
315 fprintf(f, "P6\n%d %d\n255\n", This->pow2Width, This->pow2Height);
317 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT)
319 unsigned char table[256][3];
320 int i;
322 if (This->palette == NULL) {
323 fclose(f);
324 return WINED3DERR_INVALIDCALL;
326 for (i = 0; i < 256; i++) {
327 table[i][0] = This->palette->palents[i].peRed;
328 table[i][1] = This->palette->palents[i].peGreen;
329 table[i][2] = This->palette->palents[i].peBlue;
331 for (y = 0; y < This->pow2Height; y++) {
332 unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
333 for (x = 0; x < This->pow2Width; x++) {
334 unsigned char color = *src;
335 src += 1;
337 output[3 * x + 0] = table[color][0];
338 output[3 * x + 1] = table[color][1];
339 output[3 * x + 2] = table[color][2];
341 fwrite(output, 3 * This->pow2Width, 1, f);
343 } else {
344 int red_shift, green_shift, blue_shift, pix_width, alpha_shift;
346 pix_width = format_desc->byte_count;
348 red_shift = get_shift(format_desc->red_mask);
349 green_shift = get_shift(format_desc->green_mask);
350 blue_shift = get_shift(format_desc->blue_mask);
351 alpha_shift = get_shift(format_desc->alpha_mask);
353 for (y = 0; y < This->pow2Height; y++) {
354 const unsigned char *src = This->resource.allocatedMemory + (y * 1 * IWineD3DSurface_GetPitch(iface));
355 for (x = 0; x < This->pow2Width; x++) {
356 unsigned int color;
357 unsigned int comp;
358 int i;
360 color = 0;
361 for (i = 0; i < pix_width; i++) {
362 color |= src[i] << (8 * i);
364 src += 1 * pix_width;
366 comp = color & format_desc->red_mask;
367 output[3 * x + 0] = red_shift > 0 ? comp >> red_shift : comp << -red_shift;
368 comp = color & format_desc->green_mask;
369 output[3 * x + 1] = green_shift > 0 ? comp >> green_shift : comp << -green_shift;
370 comp = color & format_desc->alpha_mask;
371 output[3 * x + 2] = alpha_shift > 0 ? comp >> alpha_shift : comp << -alpha_shift;
373 fwrite(output, 3 * This->pow2Width, 1, f);
376 fclose(f);
377 return WINED3D_OK;
380 static HRESULT WINAPI IWineGDISurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC) {
381 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
382 WINED3DLOCKED_RECT lock;
383 HRESULT hr;
384 RGBQUAD col[256];
386 TRACE("(%p)->(%p)\n",This,pHDC);
388 if(!(This->Flags & SFLAG_DIBSECTION))
390 WARN("DC not supported on this surface\n");
391 return WINED3DERR_INVALIDCALL;
394 if(This->Flags & SFLAG_USERPTR) {
395 ERR("Not supported on surfaces with an application-provided surfaces\n");
396 return WINEDDERR_NODC;
399 /* Give more detailed info for ddraw */
400 if (This->Flags & SFLAG_DCINUSE)
401 return WINEDDERR_DCALREADYCREATED;
403 /* Can't GetDC if the surface is locked */
404 if (This->Flags & SFLAG_LOCKED)
405 return WINED3DERR_INVALIDCALL;
407 memset(&lock, 0, sizeof(lock)); /* To be sure */
409 /* Should have a DIB section already */
411 /* Lock the surface */
412 hr = IWineD3DSurface_LockRect(iface,
413 &lock,
414 NULL,
416 if(FAILED(hr)) {
417 ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
418 /* keep the dib section */
419 return hr;
422 if (This->resource.format_desc->format == WINED3DFMT_P8_UINT
423 || This->resource.format_desc->format == WINED3DFMT_P8_UINT_A8_UNORM)
425 unsigned int n;
426 const PALETTEENTRY *pal = NULL;
428 if(This->palette) {
429 pal = This->palette->palents;
430 } else {
431 IWineD3DSurfaceImpl *dds_primary;
432 IWineD3DSwapChainImpl *swapchain;
433 swapchain = (IWineD3DSwapChainImpl *)This->resource.device->swapchains[0];
434 dds_primary = (IWineD3DSurfaceImpl *)swapchain->frontBuffer;
435 if (dds_primary && dds_primary->palette)
436 pal = dds_primary->palette->palents;
439 if (pal) {
440 for (n=0; n<256; n++) {
441 col[n].rgbRed = pal[n].peRed;
442 col[n].rgbGreen = pal[n].peGreen;
443 col[n].rgbBlue = pal[n].peBlue;
444 col[n].rgbReserved = 0;
446 SetDIBColorTable(This->hDC, 0, 256, col);
450 *pHDC = This->hDC;
451 TRACE("returning %p\n",*pHDC);
452 This->Flags |= SFLAG_DCINUSE;
454 return WINED3D_OK;
457 static HRESULT WINAPI IWineGDISurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
458 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
460 TRACE("(%p)->(%p)\n",This,hDC);
462 if (!(This->Flags & SFLAG_DCINUSE))
463 return WINEDDERR_NODC;
465 if (This->hDC !=hDC) {
466 WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
467 return WINEDDERR_NODC;
470 /* we locked first, so unlock now */
471 IWineD3DSurface_UnlockRect(iface);
473 This->Flags &= ~SFLAG_DCINUSE;
475 return WINED3D_OK;
478 static HRESULT WINAPI IWineGDISurfaceImpl_RealizePalette(IWineD3DSurface *iface) {
479 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
480 RGBQUAD col[256];
481 IWineD3DPaletteImpl *pal = This->palette;
482 unsigned int n;
483 IWineD3DSwapChainImpl *swapchain;
484 TRACE("(%p)\n", This);
486 if (!pal) return WINED3D_OK;
488 if(This->Flags & SFLAG_DIBSECTION) {
489 TRACE("(%p): Updating the hdc's palette\n", This);
490 for (n=0; n<256; n++) {
491 col[n].rgbRed = pal->palents[n].peRed;
492 col[n].rgbGreen = pal->palents[n].peGreen;
493 col[n].rgbBlue = pal->palents[n].peBlue;
494 col[n].rgbReserved = 0;
496 SetDIBColorTable(This->hDC, 0, 256, col);
499 /* Update the image because of the palette change. Some games like e.g Red Alert
500 call SetEntries a lot to implement fading. */
501 /* Tell the swapchain to update the screen */
502 if (SUCCEEDED(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain)))
504 if(iface == swapchain->frontBuffer)
506 x11_copy_to_screen(swapchain, NULL);
508 IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
511 return WINED3D_OK;
514 /*****************************************************************************
515 * IWineD3DSurface::PrivateSetup, GDI version
517 * Initializes the GDI surface, aka creates the DIB section we render to
518 * The DIB section creation is done by calling GetDC, which will create the
519 * section and releasing the dc to allow the app to use it. The dib section
520 * will stay until the surface is released
522 * GDI surfaces do not need to be a power of 2 in size, so the pow2 sizes
523 * are set to the real sizes to save memory. The NONPOW2 flag is unset to
524 * avoid confusion in the shared surface code.
526 * Returns:
527 * WINED3D_OK on success
528 * The return values of called methods on failure
530 *****************************************************************************/
531 static HRESULT WINAPI
532 IWineGDISurfaceImpl_PrivateSetup(IWineD3DSurface *iface)
534 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
535 HRESULT hr;
537 if(This->resource.usage & WINED3DUSAGE_OVERLAY)
539 ERR("(%p) Overlays not yet supported by GDI surfaces\n", This);
540 return WINED3DERR_INVALIDCALL;
543 /* Sysmem textures have memory already allocated -
544 * release it, this avoids an unnecessary memcpy
546 hr = IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
547 if(SUCCEEDED(hr))
549 HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
550 This->resource.heapMemory = NULL;
551 This->resource.allocatedMemory = This->dib.bitmap_data;
554 /* We don't mind the nonpow2 stuff in GDI */
555 This->pow2Width = This->currentDesc.Width;
556 This->pow2Height = This->currentDesc.Height;
558 return WINED3D_OK;
561 static HRESULT WINAPI IWineGDISurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
562 IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
564 /* Render targets depend on their hdc, and we can't create an hdc on a user pointer */
565 if(This->resource.usage & WINED3DUSAGE_RENDERTARGET) {
566 ERR("Not supported on render targets\n");
567 return WINED3DERR_INVALIDCALL;
570 if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
571 WARN("Surface is locked or the HDC is in use\n");
572 return WINED3DERR_INVALIDCALL;
575 if(Mem && Mem != This->resource.allocatedMemory) {
576 void *release = NULL;
578 /* Do I have to copy the old surface content? */
579 if(This->Flags & SFLAG_DIBSECTION) {
580 /* Release the DC. No need to hold the critical section for the update
581 * Thread because this thread runs only on front buffers, but this method
582 * fails for render targets in the check above.
584 SelectObject(This->hDC, This->dib.holdbitmap);
585 DeleteDC(This->hDC);
586 /* Release the DIB section */
587 DeleteObject(This->dib.DIBsection);
588 This->dib.bitmap_data = NULL;
589 This->resource.allocatedMemory = NULL;
590 This->hDC = NULL;
591 This->Flags &= ~SFLAG_DIBSECTION;
592 } else if(!(This->Flags & SFLAG_USERPTR)) {
593 release = This->resource.allocatedMemory;
595 This->resource.allocatedMemory = Mem;
596 This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
598 /* Now free the old memory if any */
599 HeapFree(GetProcessHeap(), 0, release);
600 } else if(This->Flags & SFLAG_USERPTR) {
601 /* LockRect and GetDC will re-create the dib section and allocated memory */
602 This->resource.allocatedMemory = NULL;
603 This->Flags &= ~SFLAG_USERPTR;
605 return WINED3D_OK;
608 /***************************
610 ***************************/
611 static void WINAPI IWineGDISurfaceImpl_ModifyLocation(IWineD3DSurface *iface, DWORD flag, BOOL persistent) {
612 TRACE("(%p)->(%s, %s)\n", iface,
613 flag == SFLAG_INSYSMEM ? "SFLAG_INSYSMEM" : flag == SFLAG_INDRAWABLE ? "SFLAG_INDRAWABLE" : "SFLAG_INTEXTURE",
614 persistent ? "TRUE" : "FALSE");
615 /* GDI surfaces can be in system memory only */
616 if(flag != SFLAG_INSYSMEM) {
617 ERR("GDI Surface requested in gl %s memory\n", flag == SFLAG_INDRAWABLE ? "drawable" : "texture");
621 static HRESULT WINAPI IWineGDISurfaceImpl_LoadLocation(IWineD3DSurface *iface, DWORD flag, const RECT *rect) {
622 if(flag != SFLAG_INSYSMEM) {
623 ERR("GDI Surface requested to be copied to gl %s\n", flag == SFLAG_INTEXTURE ? "texture" : "drawable");
624 } else {
625 TRACE("Surface requested in surface memory\n");
627 return WINED3D_OK;
630 static WINED3DSURFTYPE WINAPI IWineGDISurfaceImpl_GetImplType(IWineD3DSurface *iface) {
631 return SURFACE_GDI;
634 static HRESULT WINAPI IWineGDISurfaceImpl_DrawOverlay(IWineD3DSurface *iface) {
635 FIXME("GDI surfaces can't draw overlays yet\n");
636 return E_FAIL;
639 /* FIXME: This vtable should not use any IWineD3DSurface* implementation functions,
640 * only IWineD3DBaseSurface and IWineGDISurface ones.
642 const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl =
644 /* IUnknown */
645 IWineD3DBaseSurfaceImpl_QueryInterface,
646 IWineD3DBaseSurfaceImpl_AddRef,
647 IWineGDISurfaceImpl_Release,
648 /* IWineD3DResource */
649 IWineD3DBaseSurfaceImpl_GetParent,
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