dlls/ddraw/dsurface/user.c - wine - Git at Google

 /*	User-based primary surface driver
  *
  * Copyright 2000-2001 TransGaming Technologies Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include "config.h"

 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>

 #include "winerror.h"
 #include "wine/debug.h"
 #include "ddraw_private.h"
 #include "dsurface/main.h"
 #include "dsurface/dib.h"
 #include "dsurface/user.h"
 #include "dsurface/wndproc.h"

 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);

 /* if you use OWN_WINDOW, don't use SYNC_UPDATE, or you may get trouble */
 /* #define SYNC_UPDATE */
 /*
  * FIXME: This does not work any more because the created window has its own
  *        thread queue that cannot be manipulated by application threads.
  * #define OWN_WINDOW
  */

 #ifdef OWN_WINDOW
 static void User_create_own_window(IDirectDrawSurfaceImpl* This);
 static void User_destroy_own_window(IDirectDrawSurfaceImpl* This);
 #endif
 #ifndef SYNC_UPDATE
 static DWORD CALLBACK User_update_thread(LPVOID);
 #endif
 static void User_copy_to_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc);

 static HWND get_display_window(IDirectDrawSurfaceImpl* This, LPPOINT pt);

 static ICOM_VTABLE(IDirectDrawSurface7) User_IDirectDrawSurface7_VTable;

 HRESULT
 User_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl* This,
 				 IDirectDrawImpl* pDD,
 				 const DDSURFACEDESC2* pDDSD)
 {
     USER_PRIV_VAR(priv, This);
     HRESULT hr;

     TRACE("(%p,%p,%p)\n",This,pDD,pDDSD);
     hr = DIB_DirectDrawSurface_Construct(This, pDD, pDDSD);
     if (FAILED(hr)) return hr;

     ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
 			User_IDirectDrawSurface7_VTable);

     This->final_release = User_DirectDrawSurface_final_release;
     This->duplicate_surface = User_DirectDrawSurface_duplicate_surface;

     This->lock_update   = User_DirectDrawSurface_lock_update;
     This->unlock_update = User_DirectDrawSurface_unlock_update;

     This->flip_data   = User_DirectDrawSurface_flip_data;
     This->flip_update = User_DirectDrawSurface_flip_update;

     This->get_dc     = User_DirectDrawSurface_get_dc;
     This->release_dc = User_DirectDrawSurface_release_dc;

     This->set_palette    = User_DirectDrawSurface_set_palette;
     This->update_palette = User_DirectDrawSurface_update_palette;

     This->get_gamma_ramp = User_DirectDrawSurface_get_gamma_ramp;
     This->set_gamma_ramp = User_DirectDrawSurface_set_gamma_ramp;

     This->get_display_window = User_DirectDrawSurface_get_display_window;

     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 #ifdef OWN_WINDOW
 	DirectDrawSurface_RegisterClass();
 #endif
 #ifndef SYNC_UPDATE
 	InitializeCriticalSection(&priv->user.crit);
 	priv->user.refresh_event = CreateEventA(NULL, TRUE, FALSE, NULL);
 	priv->user.update_event = CreateEventA(NULL, FALSE, FALSE, NULL);
 	priv->user.update_thread = CreateThread(NULL, 0, User_update_thread, This, 0, NULL);
 #ifdef OWN_WINDOW
 	if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN) {
 	    /* wait for window creation (or update thread destruction) */
 	    while (WaitForMultipleObjects(1, &priv->user.update_thread, FALSE, 100) == WAIT_TIMEOUT)
 		if (This->more.lpDDRAWReserved) break;
 	    if (!This->more.lpDDRAWReserved) {
 		ERR("window creation failed\n");
 	    }
 	}
 #endif
 #else
 #ifdef OWN_WINDOW
 	User_create_own_window(This);
 #endif
 #endif
 	if (!This->more.lpDDRAWReserved)
 	    This->more.lpDDRAWReserved = (LPVOID)pDD->window;
     }

     return DIB_DirectDrawSurface_alloc_dc(This, &priv->user.cached_dc);
 }

 HRESULT
 User_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
 			      const DDSURFACEDESC2 *pDDSD,
 			      LPDIRECTDRAWSURFACE7 *ppSurf,
 			      IUnknown *pUnkOuter)
 {
     IDirectDrawSurfaceImpl* This;
     HRESULT hr;
     assert(pUnkOuter == NULL);

     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 		     sizeof(*This) + sizeof(User_DirectDrawSurfaceImpl));
     if (This == NULL) return E_OUTOFMEMORY;

     This->private = (User_DirectDrawSurfaceImpl*)(This+1);

     hr = User_DirectDrawSurface_Construct(This, pDD, pDDSD);
     if (FAILED(hr))
 	HeapFree(GetProcessHeap(), 0, This);
     else
 	*ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);

     return hr;
 }

 void User_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);

     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 #ifndef SYNC_UPDATE
 	HANDLE event = priv->user.update_event;
 	priv->user.update_event = 0;
 	SetEvent(event);
 	TRACE("waiting for update thread to terminate...\n");
 #ifdef OWN_WINDOW
 	/* dispatch any waiting sendmessages */
 	{
 	    MSG msg;
 	    PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
 	}
 	/* to avoid deadlocks, allow SendMessages from update thread
 	 * through while we wait for it */
 	while (MsgWaitForMultipleObjects(1, &priv->user.update_thread, FALSE,
 					 INFINITE, QS_SENDMESSAGE) == WAIT_OBJECT_0+1)
 	{
 	    MSG msg;
 	    PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
 	}
 #else
 	WaitForSingleObject(priv->user.update_thread,INFINITE);
 #endif
 	TRACE("update thread terminated\n");
 	CloseHandle(event);
 	CloseHandle(priv->user.update_thread);
 	CloseHandle(priv->user.refresh_event);
 	DeleteCriticalSection(&priv->user.crit);
 #else
 #ifdef OWN_WINDOW
 	User_destroy_own_window(This);
 #endif
 #endif
 	This->more.lpDDRAWReserved = 0;
 #ifdef OWN_WINDOW
 	DirectDrawSurface_UnregisterClass();
 #endif
     }
     DIB_DirectDrawSurface_free_dc(This, priv->user.cached_dc);
     DIB_DirectDrawSurface_final_release(This);
 }

 static int User_DirectDrawSurface_init_wait(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);
     int need_wait;
     EnterCriticalSection(&priv->user.crit);
     priv->user.wait_count++;
     need_wait = priv->user.in_refresh;
     LeaveCriticalSection(&priv->user.crit);
     return need_wait;
 }

 static void User_DirectDrawSurface_end_wait(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);
     EnterCriticalSection(&priv->user.crit);
     if (!--priv->user.wait_count)
 	ResetEvent(priv->user.refresh_event);
     LeaveCriticalSection(&priv->user.crit);
 }

 static void User_DirectDrawSurface_wait_update(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);
     if (priv->user.in_refresh) {
 	if (User_DirectDrawSurface_init_wait(This))
 	    WaitForSingleObject(priv->user.refresh_event, 2);
 	User_DirectDrawSurface_end_wait(This);
     }
 }

 void User_DirectDrawSurface_lock_update(IDirectDrawSurfaceImpl* This,
 					LPCRECT pRect, DWORD dwFlags)
 {
 #if 0
     if (!(dwFlags & DDLOCK_WRITEONLY))
 	User_copy_from_screen(This, pRect);
 #endif
     if (dwFlags & DDLOCK_WAIT) User_DirectDrawSurface_wait_update(This);

     if (pRect) {
 	This->lastlockrect = *pRect;
     } else {
 	This->lastlockrect.left = This->lastlockrect.right = 0;
     }
 }

 void User_DirectDrawSurface_unlock_update(IDirectDrawSurfaceImpl* This,
 					  LPCRECT pRect)
 {
     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 #ifdef SYNC_UPDATE
 	User_copy_to_screen(This, pRect);
 #else
 	USER_PRIV_VAR(priv, This);
 	SetEvent(priv->user.update_event);
 #endif
     }
 }

 void User_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
 					IDirectDrawPaletteImpl* pal)
 {
     USER_PRIV_VAR(priv, This);

     if (!pal) {
 	FIXME("selecting null palette\n");
 	/* I don't think selecting GDI object 0 will work, we should select
 	 * the original palette, returned by the first SelectPalette */
 	SelectPalette(priv->user.cached_dc, 0, FALSE);
 	return;
     }

     SelectPalette(priv->user.cached_dc, pal->hpal, FALSE);

     DIB_DirectDrawSurface_set_palette(This, pal);
 }

 void User_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
 					   IDirectDrawPaletteImpl* pal,
 					   DWORD dwStart, DWORD dwCount,
 					   LPPALETTEENTRY palent)
 {
 #ifndef SYNC_UPDATE
     USER_PRIV_VAR(priv, This);
 #endif

     DIB_DirectDrawSurface_update_palette(This, pal, dwStart, dwCount, palent);
     /* FIXME: realize palette on display window */

 #ifndef SYNC_UPDATE
     /* with async updates, it's probably cool to force an update */
     SetEvent(priv->user.update_event);
 #endif
 }

 HRESULT User_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
 						 LPDIRECTDRAWSURFACE7* ppDup)
 {
     return User_DirectDrawSurface_Create(This->ddraw_owner,
 					 &This->surface_desc, ppDup, NULL);
 }

 BOOL User_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
 				      IDirectDrawSurfaceImpl* back,
 				      DWORD dwFlags)
 {
     USER_PRIV_VAR(front_priv, front);
     USER_PRIV_VAR(back_priv, back);

     {
 	HDC tmp;
 	tmp = front_priv->user.cached_dc;
 	front_priv->user.cached_dc = back_priv->user.cached_dc;
 	back_priv->user.cached_dc = tmp;
     }

     return DIB_DirectDrawSurface_flip_data(front, back, dwFlags);
 }

 void User_DirectDrawSurface_flip_update(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
 {
 #ifdef SYNC_UPDATE
     This->lastlockrect.left = This->lastlockrect.right = 0;
     assert(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE);
     User_copy_to_screen(This,NULL);
 #else
     USER_PRIV_VAR(priv, This);
     assert(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE);
     if (dwFlags & DDFLIP_WAIT) User_DirectDrawSurface_wait_update(This);
     This->lastlockrect.left = This->lastlockrect.right = 0;
     SetEvent(priv->user.update_event);
 #endif
 }

 HRESULT User_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
 {
     USER_PRIV_VAR(priv, This);

     *phDC = priv->user.cached_dc;
     return S_OK;
 }

 HRESULT User_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl* This,
 					  HDC hDC)
 {
     return S_OK;
 }

 HRESULT User_DirectDrawSurface_get_gamma_ramp(IDirectDrawSurfaceImpl* This,
 					      DWORD dwFlags,
 					      LPDDGAMMARAMP lpGammaRamp)
 {
     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 	POINT offset;
 	HWND hDisplayWnd;
 	HDC hDisplayDC;
 	HRESULT hr;
 	hDisplayWnd = get_display_window(This, &offset);
 	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
 	hr = GetDeviceGammaRamp(hDisplayDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
 	ReleaseDC(hDisplayWnd, hDisplayDC);
 	return hr;
     }
     return Main_DirectDrawSurface_get_gamma_ramp(This, dwFlags, lpGammaRamp);
 }

 HRESULT User_DirectDrawSurface_set_gamma_ramp(IDirectDrawSurfaceImpl* This,
 					      DWORD dwFlags,
 					      LPDDGAMMARAMP lpGammaRamp)
 {
     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 	POINT offset;
 	HWND hDisplayWnd;
 	HDC hDisplayDC;
 	HRESULT hr;
 	hDisplayWnd = get_display_window(This, &offset);
 	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
 	hr = SetDeviceGammaRamp(hDisplayDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
 	ReleaseDC(hDisplayWnd, hDisplayDC);
 	return hr;
     }
     return Main_DirectDrawSurface_set_gamma_ramp(This, dwFlags, lpGammaRamp);
 }

 /* Returns the window that hosts the display.
  * *pt is set to the upper left position of the window relative to the
  * upper left corner of the surface. */
 static HWND get_display_window(IDirectDrawSurfaceImpl* This, LPPOINT pt)
 {
     memset(pt, 0, sizeof(*pt));

     if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN)
     {
 #ifdef OWN_WINDOW
 	USER_PRIV_VAR(priv, This);
 #if 1
 	SetWindowPos(priv->user.window, HWND_TOP, 0, 0, 0, 0,
 		     SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOMOVE|
 		     SWP_NOREDRAW|SWP_NOSENDCHANGING|SWP_NOSIZE);
 #endif
 	return priv->user.window;
 #else
 	return This->ddraw_owner->window;
 #endif
     }
     else
     {
 	if (This->clipper != NULL)
 	{
 	    /* looks silly, but since we don't have the clipper locked */
 	    HWND hWnd = This->clipper->hWnd;

 	    if (hWnd != 0)
 	    {
 		ClientToScreen(hWnd, pt);
 		return hWnd;
 	    }
 	    else
 	    {
 		static BOOL warn = 0;
 		if (!warn++) FIXME("clipper clip lists not supported\n");

 		return GetDesktopWindow();
 	    }
 	}
 	else
 	{
 	    static BOOL warn = 0;
 	    if (!warn++) WARN("hosting on root\n");

 	    return GetDesktopWindow();
 	}
     }
 }

 HWND User_DirectDrawSurface_get_display_window(IDirectDrawSurfaceImpl* This)
 {
     POINT offset;
     return get_display_window(This, &offset);
 }

 #ifdef OWN_WINDOW
 static void User_create_own_window(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);

     if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN)
     {
 	priv->user.window = CreateWindowExA(WS_EX_TOPMOST |
 					    WS_EX_LAYERED |
 					    WS_EX_TRANSPARENT,
 					    "WINE_DDRAW", "DirectDraw",
 					    WS_POPUP,
 					    0, 0,
 					    This->surface_desc.dwWidth,
 					    This->surface_desc.dwHeight,
 					    GetDesktopWindow(),
 					    0, 0, This);
 	This->more.lpDDRAWReserved = (LPVOID)priv->user.window;
 	SetWindowPos(priv->user.window, HWND_TOP, 0, 0, 0, 0,
 		     SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOMOVE|
 		     SWP_NOREDRAW|SWP_NOSENDCHANGING|SWP_NOSIZE|SWP_SHOWWINDOW);
 	UpdateWindow(priv->user.window);
     }
 }

 static void User_destroy_own_window(IDirectDrawSurfaceImpl* This)
 {
     USER_PRIV_VAR(priv, This);

     if (priv->user.window)
     {
 	SetWindowPos(priv->user.window, 0, 0, 0, 0, 0,
 		     SWP_DEFERERASE|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOMOVE|SWP_NOZORDER|
 		     SWP_NOREDRAW|SWP_NOSENDCHANGING|SWP_NOSIZE|SWP_HIDEWINDOW);
 	This->more.lpDDRAWReserved = NULL;
 	DestroyWindow(priv->user.window);
 	priv->user.window = 0;
     }
 }
 #endif

 #ifndef SYNC_UPDATE
 static DWORD CALLBACK User_update_thread(LPVOID arg)
 {
     IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)arg;
     USER_PRIV_VAR(priv, This);
     volatile HANDLE *pActive = (volatile HANDLE *)&priv->user.update_event;
     HANDLE event = *pActive;

 #ifdef OWN_WINDOW
     User_create_own_window(This);
 #endif

     /* the point of this is that many games lock the primary surface
      * multiple times per frame; this thread will then simply copy as
      * often as it can without keeping the main thread waiting for
      * each unlock, thus keeping the frame rate high */
     do {
 #ifdef OWN_WINDOW
 	DWORD ret = MsgWaitForMultipleObjects(1, &event, FALSE, INFINITE, QS_ALLINPUT);
 	MSG msg;

 	while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
 	{
 	    switch (msg.message) {
 	    case WM_PAINT:
 		DispatchMessageA(&msg);
 		break;
 	    default:
 		/* since we risk getting keyboard messages posted to us,
 		 * repost posted messages to cooperative window */
 		PostMessageA(This->ddraw_owner->window, msg.message, msg.wParam, msg.lParam);
 	    }
 	}
 #else
 	DWORD ret = WaitForSingleObject(event, INFINITE);
 #endif
 	if (ret == WAIT_OBJECT_0)
 	{
 	    if (*pActive) {
 		priv->user.in_refresh = TRUE;
 		User_copy_to_screen(This, NULL);
 		EnterCriticalSection(&priv->user.crit);
 		priv->user.in_refresh = FALSE;
 		if (priv->user.wait_count)
 		    SetEvent(priv->user.refresh_event);
 		LeaveCriticalSection(&priv->user.crit);
 	    } else
 		break;
 	}
 	else if (ret != WAIT_OBJECT_0+1) break;
     } while (TRUE);

     SetEvent(priv->user.refresh_event);
 #ifdef OWN_WINDOW
     User_destroy_own_window(This);
 #endif

     return 0;
 }
 #endif

 static void User_copy_to_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc)
 {
     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 	POINT offset;
 	HWND hDisplayWnd;
 	HDC hDisplayDC;
 	HDC hSurfaceDC;
 	RECT drawrect;

 	if (FAILED(This->get_dc(This, &hSurfaceDC)))
 	    return;

 	hDisplayWnd = get_display_window(This, &offset);
 	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS|DCX_CACHE);
 #if 0
 	/* FIXME: this doesn't work... if users really want to run
 	 * X in 8bpp, then we need to call directly into display.drv
 	 * (or Wine's equivalent), and force a private colormap
 	 * without default entries. */
 	if (This->palette) {
 	    SelectPalette(hDisplayDC, This->palette->hpal, FALSE);
 	    RealizePalette(hDisplayDC); /* sends messages => deadlocks */
 	}
 #endif
 	drawrect.left	= 0;
 	drawrect.right	= This->surface_desc.dwWidth;
 	drawrect.top	= 0;
 	drawrect.bottom	= This->surface_desc.dwHeight;

 	if (This->clipper) {
 	    RECT xrc;
 	    HWND hwnd = This->clipper->hWnd;
 	    if (hwnd && GetClientRect(hwnd,&xrc)) {
 		OffsetRect(&xrc,offset.x,offset.y);
 		IntersectRect(&drawrect,&drawrect,&xrc);
 	    }
 	}
 	if (rc)
 	    IntersectRect(&drawrect,&drawrect,rc);
 	else {
 	    /* Only use this if the caller did not pass a rectangle, since
 	     * due to double locking this could be the wrong one ... */
 	    if (This->lastlockrect.left != This->lastlockrect.right)
 		IntersectRect(&drawrect,&drawrect,&This->lastlockrect);
 	}
 	BitBlt(hDisplayDC,
 		drawrect.left-offset.x, drawrect.top-offset.y,
 		drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
 		hSurfaceDC,
 		drawrect.left, drawrect.top,
 		SRCCOPY
 	);
 	ReleaseDC(hDisplayWnd, hDisplayDC);
     }
 }

 #if 0
 static void User_copy_from_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc)
 {
     if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
     {
 	POINT offset;
 	HWND hDisplayWnd = get_display_window(This, &offset);
 	HDC hDisplayDC = GetDC(hDisplayWnd);
 	RECT drawrect;

 	drawrect.left	= 0;
 	drawrect.right	= This->surface_desc.dwWidth;
 	drawrect.top	= 0;
 	drawrect.bottom	= This->surface_desc.dwHeight;
 	if (rc)
 	    IntersectRect(&drawrect,&drawrect,rc);

 	BitBlt(This->hDC,
 	    drawrect.left, drawrect.top,
 	    drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
 	    hDisplayDC,
 	    drawrect.left+offset.x, drawrect.top+offset.y,
 	    SRCCOPY
 	);
 	ReleaseDC(hDisplayWnd, hDisplayDC);
     }
 }
 #endif

 static ICOM_VTABLE(IDirectDrawSurface7) User_IDirectDrawSurface7_VTable =
 {
     Main_DirectDrawSurface_QueryInterface,
     Main_DirectDrawSurface_AddRef,
     Main_DirectDrawSurface_Release,
     Main_DirectDrawSurface_AddAttachedSurface,
     Main_DirectDrawSurface_AddOverlayDirtyRect,
     DIB_DirectDrawSurface_Blt,
     Main_DirectDrawSurface_BltBatch,
     DIB_DirectDrawSurface_BltFast,
     Main_DirectDrawSurface_DeleteAttachedSurface,
     Main_DirectDrawSurface_EnumAttachedSurfaces,
     Main_DirectDrawSurface_EnumOverlayZOrders,
     Main_DirectDrawSurface_Flip,
     Main_DirectDrawSurface_GetAttachedSurface,
     Main_DirectDrawSurface_GetBltStatus,
     Main_DirectDrawSurface_GetCaps,
     Main_DirectDrawSurface_GetClipper,
     Main_DirectDrawSurface_GetColorKey,
     Main_DirectDrawSurface_GetDC,
     Main_DirectDrawSurface_GetFlipStatus,
     Main_DirectDrawSurface_GetOverlayPosition,
     Main_DirectDrawSurface_GetPalette,
     Main_DirectDrawSurface_GetPixelFormat,
     Main_DirectDrawSurface_GetSurfaceDesc,
     Main_DirectDrawSurface_Initialize,
     Main_DirectDrawSurface_IsLost,
     Main_DirectDrawSurface_Lock,
     Main_DirectDrawSurface_ReleaseDC,
     DIB_DirectDrawSurface_Restore,
     Main_DirectDrawSurface_SetClipper,
     Main_DirectDrawSurface_SetColorKey,
     Main_DirectDrawSurface_SetOverlayPosition,
     Main_DirectDrawSurface_SetPalette,
     Main_DirectDrawSurface_Unlock,
     Main_DirectDrawSurface_UpdateOverlay,
     Main_DirectDrawSurface_UpdateOverlayDisplay,
     Main_DirectDrawSurface_UpdateOverlayZOrder,
     Main_DirectDrawSurface_GetDDInterface,
     Main_DirectDrawSurface_PageLock,
     Main_DirectDrawSurface_PageUnlock,
     DIB_DirectDrawSurface_SetSurfaceDesc,
     Main_DirectDrawSurface_SetPrivateData,
     Main_DirectDrawSurface_GetPrivateData,
     Main_DirectDrawSurface_FreePrivateData,
     Main_DirectDrawSurface_GetUniquenessValue,
     Main_DirectDrawSurface_ChangeUniquenessValue,
     Main_DirectDrawSurface_SetPriority,
     Main_DirectDrawSurface_GetPriority,
     Main_DirectDrawSurface_SetLOD,
     Main_DirectDrawSurface_GetLOD
 };
	/* User-based primary surface driver
	*
	* Copyright 2000-2001 TransGaming Technologies Inc.
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include "config.h"

	#include <assert.h>
	#include <stdlib.h>
	#include <string.h>

	#include "winerror.h"
	#include "wine/debug.h"
	#include "ddraw_private.h"
	#include "dsurface/main.h"
	#include "dsurface/dib.h"
	#include "dsurface/user.h"
	#include "dsurface/wndproc.h"

	WINE_DEFAULT_DEBUG_CHANNEL(ddraw);

	/* if you use OWN_WINDOW, don't use SYNC_UPDATE, or you may get trouble */
	/* #define SYNC_UPDATE */
	/*
	* FIXME: This does not work any more because the created window has its own
	* thread queue that cannot be manipulated by application threads.
	* #define OWN_WINDOW
	*/

	#ifdef OWN_WINDOW
	static void User_create_own_window(IDirectDrawSurfaceImpl* This);
	static void User_destroy_own_window(IDirectDrawSurfaceImpl* This);
	#endif
	#ifndef SYNC_UPDATE
	static DWORD CALLBACK User_update_thread(LPVOID);
	#endif
	static void User_copy_to_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc);

	static HWND get_display_window(IDirectDrawSurfaceImpl* This, LPPOINT pt);

	static ICOM_VTABLE(IDirectDrawSurface7) User_IDirectDrawSurface7_VTable;

	HRESULT
	User_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl* This,
	IDirectDrawImpl* pDD,
	const DDSURFACEDESC2* pDDSD)
	{
	USER_PRIV_VAR(priv, This);
	HRESULT hr;

	TRACE("(%p,%p,%p)\n",This,pDD,pDDSD);
	hr = DIB_DirectDrawSurface_Construct(This, pDD, pDDSD);
	if (FAILED(hr)) return hr;

	ICOM_INIT_INTERFACE(This, IDirectDrawSurface7,
	User_IDirectDrawSurface7_VTable);

	This->final_release = User_DirectDrawSurface_final_release;
	This->duplicate_surface = User_DirectDrawSurface_duplicate_surface;

	This->lock_update = User_DirectDrawSurface_lock_update;
	This->unlock_update = User_DirectDrawSurface_unlock_update;

	This->flip_data = User_DirectDrawSurface_flip_data;
	This->flip_update = User_DirectDrawSurface_flip_update;

	This->get_dc = User_DirectDrawSurface_get_dc;
	This->release_dc = User_DirectDrawSurface_release_dc;

	This->set_palette = User_DirectDrawSurface_set_palette;
	This->update_palette = User_DirectDrawSurface_update_palette;

	This->get_gamma_ramp = User_DirectDrawSurface_get_gamma_ramp;
	This->set_gamma_ramp = User_DirectDrawSurface_set_gamma_ramp;

	This->get_display_window = User_DirectDrawSurface_get_display_window;

	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	#ifdef OWN_WINDOW
	DirectDrawSurface_RegisterClass();
	#endif
	#ifndef SYNC_UPDATE
	InitializeCriticalSection(&priv->user.crit);
	priv->user.refresh_event = CreateEventA(NULL, TRUE, FALSE, NULL);
	priv->user.update_event = CreateEventA(NULL, FALSE, FALSE, NULL);
	priv->user.update_thread = CreateThread(NULL, 0, User_update_thread, This, 0, NULL);
	#ifdef OWN_WINDOW
	if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN) {
	/* wait for window creation (or update thread destruction) */
	while (WaitForMultipleObjects(1, &priv->user.update_thread, FALSE, 100) == WAIT_TIMEOUT)
	if (This->more.lpDDRAWReserved) break;
	if (!This->more.lpDDRAWReserved) {
	ERR("window creation failed\n");
	}
	}
	#endif
	#else
	#ifdef OWN_WINDOW
	User_create_own_window(This);
	#endif
	#endif
	if (!This->more.lpDDRAWReserved)
	This->more.lpDDRAWReserved = (LPVOID)pDD->window;
	}

	return DIB_DirectDrawSurface_alloc_dc(This, &priv->user.cached_dc);
	}

	HRESULT
	User_DirectDrawSurface_Create(IDirectDrawImpl *pDD,
	const DDSURFACEDESC2 *pDDSD,
	LPDIRECTDRAWSURFACE7 *ppSurf,
	IUnknown *pUnkOuter)
	{
	IDirectDrawSurfaceImpl* This;
	HRESULT hr;
	assert(pUnkOuter == NULL);

	This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
	sizeof(*This) + sizeof(User_DirectDrawSurfaceImpl));
	if (This == NULL) return E_OUTOFMEMORY;

	This->private = (User_DirectDrawSurfaceImpl*)(This+1);

	hr = User_DirectDrawSurface_Construct(This, pDD, pDDSD);
	if (FAILED(hr))
	HeapFree(GetProcessHeap(), 0, This);
	else
	*ppSurf = ICOM_INTERFACE(This, IDirectDrawSurface7);

	return hr;
	}

	void User_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);

	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	#ifndef SYNC_UPDATE
	HANDLE event = priv->user.update_event;
	priv->user.update_event = 0;
	SetEvent(event);
	TRACE("waiting for update thread to terminate...\n");
	#ifdef OWN_WINDOW
	/* dispatch any waiting sendmessages */
	{
	MSG msg;
	PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
	}
	/* to avoid deadlocks, allow SendMessages from update thread
	* through while we wait for it */
	while (MsgWaitForMultipleObjects(1, &priv->user.update_thread, FALSE,
	INFINITE, QS_SENDMESSAGE) == WAIT_OBJECT_0+1)
	{
	MSG msg;
	PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
	}
	#else
	WaitForSingleObject(priv->user.update_thread,INFINITE);
	#endif
	TRACE("update thread terminated\n");
	CloseHandle(event);
	CloseHandle(priv->user.update_thread);
	CloseHandle(priv->user.refresh_event);
	DeleteCriticalSection(&priv->user.crit);
	#else
	#ifdef OWN_WINDOW
	User_destroy_own_window(This);
	#endif
	#endif
	This->more.lpDDRAWReserved = 0;
	#ifdef OWN_WINDOW
	DirectDrawSurface_UnregisterClass();
	#endif
	}
	DIB_DirectDrawSurface_free_dc(This, priv->user.cached_dc);
	DIB_DirectDrawSurface_final_release(This);
	}

	static int User_DirectDrawSurface_init_wait(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);
	int need_wait;
	EnterCriticalSection(&priv->user.crit);
	priv->user.wait_count++;
	need_wait = priv->user.in_refresh;
	LeaveCriticalSection(&priv->user.crit);
	return need_wait;
	}

	static void User_DirectDrawSurface_end_wait(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);
	EnterCriticalSection(&priv->user.crit);
	if (!--priv->user.wait_count)
	ResetEvent(priv->user.refresh_event);
	LeaveCriticalSection(&priv->user.crit);
	}

	static void User_DirectDrawSurface_wait_update(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);
	if (priv->user.in_refresh) {
	if (User_DirectDrawSurface_init_wait(This))
	WaitForSingleObject(priv->user.refresh_event, 2);
	User_DirectDrawSurface_end_wait(This);
	}
	}

	void User_DirectDrawSurface_lock_update(IDirectDrawSurfaceImpl* This,
	LPCRECT pRect, DWORD dwFlags)
	{
	#if 0
	if (!(dwFlags & DDLOCK_WRITEONLY))
	User_copy_from_screen(This, pRect);
	#endif
	if (dwFlags & DDLOCK_WAIT) User_DirectDrawSurface_wait_update(This);

	if (pRect) {
	This->lastlockrect = *pRect;
	} else {
	This->lastlockrect.left = This->lastlockrect.right = 0;
	}
	}

	void User_DirectDrawSurface_unlock_update(IDirectDrawSurfaceImpl* This,
	LPCRECT pRect)
	{
	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	#ifdef SYNC_UPDATE
	User_copy_to_screen(This, pRect);
	#else
	USER_PRIV_VAR(priv, This);
	SetEvent(priv->user.update_event);
	#endif
	}
	}

	void User_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
	IDirectDrawPaletteImpl* pal)
	{
	USER_PRIV_VAR(priv, This);

	if (!pal) {
	FIXME("selecting null palette\n");
	/* I don't think selecting GDI object 0 will work, we should select
	* the original palette, returned by the first SelectPalette */
	SelectPalette(priv->user.cached_dc, 0, FALSE);
	return;
	}

	SelectPalette(priv->user.cached_dc, pal->hpal, FALSE);

	DIB_DirectDrawSurface_set_palette(This, pal);
	}

	void User_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
	IDirectDrawPaletteImpl* pal,
	DWORD dwStart, DWORD dwCount,
	LPPALETTEENTRY palent)
	{
	#ifndef SYNC_UPDATE
	USER_PRIV_VAR(priv, This);
	#endif

	DIB_DirectDrawSurface_update_palette(This, pal, dwStart, dwCount, palent);
	/* FIXME: realize palette on display window */

	#ifndef SYNC_UPDATE
	/* with async updates, it's probably cool to force an update */
	SetEvent(priv->user.update_event);
	#endif
	}

	HRESULT User_DirectDrawSurface_duplicate_surface(IDirectDrawSurfaceImpl* This,
	LPDIRECTDRAWSURFACE7* ppDup)
	{
	return User_DirectDrawSurface_Create(This->ddraw_owner,
	&This->surface_desc, ppDup, NULL);
	}

	BOOL User_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
	IDirectDrawSurfaceImpl* back,
	DWORD dwFlags)
	{
	USER_PRIV_VAR(front_priv, front);
	USER_PRIV_VAR(back_priv, back);

	{
	HDC tmp;
	tmp = front_priv->user.cached_dc;
	front_priv->user.cached_dc = back_priv->user.cached_dc;
	back_priv->user.cached_dc = tmp;
	}

	return DIB_DirectDrawSurface_flip_data(front, back, dwFlags);
	}

	void User_DirectDrawSurface_flip_update(IDirectDrawSurfaceImpl* This, DWORD dwFlags)
	{
	#ifdef SYNC_UPDATE
	This->lastlockrect.left = This->lastlockrect.right = 0;
	assert(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE);
	User_copy_to_screen(This,NULL);
	#else
	USER_PRIV_VAR(priv, This);
	assert(This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE);
	if (dwFlags & DDFLIP_WAIT) User_DirectDrawSurface_wait_update(This);
	This->lastlockrect.left = This->lastlockrect.right = 0;
	SetEvent(priv->user.update_event);
	#endif
	}

	HRESULT User_DirectDrawSurface_get_dc(IDirectDrawSurfaceImpl* This, HDC* phDC)
	{
	USER_PRIV_VAR(priv, This);

	*phDC = priv->user.cached_dc;
	return S_OK;
	}

	HRESULT User_DirectDrawSurface_release_dc(IDirectDrawSurfaceImpl* This,
	HDC hDC)
	{
	return S_OK;
	}

	HRESULT User_DirectDrawSurface_get_gamma_ramp(IDirectDrawSurfaceImpl* This,
	DWORD dwFlags,
	LPDDGAMMARAMP lpGammaRamp)
	{
	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	POINT offset;
	HWND hDisplayWnd;
	HDC hDisplayDC;
	HRESULT hr;
	hDisplayWnd = get_display_window(This, &offset);
	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS\|DCX_CACHE);
	hr = GetDeviceGammaRamp(hDisplayDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
	ReleaseDC(hDisplayWnd, hDisplayDC);
	return hr;
	}
	return Main_DirectDrawSurface_get_gamma_ramp(This, dwFlags, lpGammaRamp);
	}

	HRESULT User_DirectDrawSurface_set_gamma_ramp(IDirectDrawSurfaceImpl* This,
	DWORD dwFlags,
	LPDDGAMMARAMP lpGammaRamp)
	{
	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	POINT offset;
	HWND hDisplayWnd;
	HDC hDisplayDC;
	HRESULT hr;
	hDisplayWnd = get_display_window(This, &offset);
	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS\|DCX_CACHE);
	hr = SetDeviceGammaRamp(hDisplayDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
	ReleaseDC(hDisplayWnd, hDisplayDC);
	return hr;
	}
	return Main_DirectDrawSurface_set_gamma_ramp(This, dwFlags, lpGammaRamp);
	}

	/* Returns the window that hosts the display.
	* *pt is set to the upper left position of the window relative to the
	* upper left corner of the surface. */
	static HWND get_display_window(IDirectDrawSurfaceImpl* This, LPPOINT pt)
	{
	memset(pt, 0, sizeof(*pt));

	if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN)
	{
	#ifdef OWN_WINDOW
	USER_PRIV_VAR(priv, This);
	#if 1
	SetWindowPos(priv->user.window, HWND_TOP, 0, 0, 0, 0,
	SWP_DEFERERASE\|SWP_NOACTIVATE\|SWP_NOCOPYBITS\|SWP_NOMOVE\|
	SWP_NOREDRAW\|SWP_NOSENDCHANGING\|SWP_NOSIZE);
	#endif
	return priv->user.window;
	#else
	return This->ddraw_owner->window;
	#endif
	}
	else
	{
	if (This->clipper != NULL)
	{
	/* looks silly, but since we don't have the clipper locked */
	HWND hWnd = This->clipper->hWnd;

	if (hWnd != 0)
	{
	ClientToScreen(hWnd, pt);
	return hWnd;
	}
	else
	{
	static BOOL warn = 0;
	if (!warn++) FIXME("clipper clip lists not supported\n");

	return GetDesktopWindow();
	}
	}
	else
	{
	static BOOL warn = 0;
	if (!warn++) WARN("hosting on root\n");

	return GetDesktopWindow();
	}
	}
	}

	HWND User_DirectDrawSurface_get_display_window(IDirectDrawSurfaceImpl* This)
	{
	POINT offset;
	return get_display_window(This, &offset);
	}

	#ifdef OWN_WINDOW
	static void User_create_own_window(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);

	if (This->ddraw_owner->cooperative_level & DDSCL_FULLSCREEN)
	{
	priv->user.window = CreateWindowExA(WS_EX_TOPMOST \|
	WS_EX_LAYERED \|
	WS_EX_TRANSPARENT,
	"WINE_DDRAW", "DirectDraw",
	WS_POPUP,
	0, 0,
	This->surface_desc.dwWidth,
	This->surface_desc.dwHeight,
	GetDesktopWindow(),
	0, 0, This);
	This->more.lpDDRAWReserved = (LPVOID)priv->user.window;
	SetWindowPos(priv->user.window, HWND_TOP, 0, 0, 0, 0,
	SWP_DEFERERASE\|SWP_NOACTIVATE\|SWP_NOCOPYBITS\|SWP_NOMOVE\|
	SWP_NOREDRAW\|SWP_NOSENDCHANGING\|SWP_NOSIZE\|SWP_SHOWWINDOW);
	UpdateWindow(priv->user.window);
	}
	}

	static void User_destroy_own_window(IDirectDrawSurfaceImpl* This)
	{
	USER_PRIV_VAR(priv, This);

	if (priv->user.window)
	{
	SetWindowPos(priv->user.window, 0, 0, 0, 0, 0,
	SWP_DEFERERASE\|SWP_NOACTIVATE\|SWP_NOCOPYBITS\|SWP_NOMOVE\|SWP_NOZORDER\|
	SWP_NOREDRAW\|SWP_NOSENDCHANGING\|SWP_NOSIZE\|SWP_HIDEWINDOW);
	This->more.lpDDRAWReserved = NULL;
	DestroyWindow(priv->user.window);
	priv->user.window = 0;
	}
	}
	#endif

	#ifndef SYNC_UPDATE
	static DWORD CALLBACK User_update_thread(LPVOID arg)
	{
	IDirectDrawSurfaceImpl This = (IDirectDrawSurfaceImpl )arg;
	USER_PRIV_VAR(priv, This);
	volatile HANDLE pActive = (volatile HANDLE )&priv->user.update_event;
	HANDLE event = *pActive;

	#ifdef OWN_WINDOW
	User_create_own_window(This);
	#endif

	/* the point of this is that many games lock the primary surface
	* multiple times per frame; this thread will then simply copy as
	* often as it can without keeping the main thread waiting for
	* each unlock, thus keeping the frame rate high */
	do {
	#ifdef OWN_WINDOW
	DWORD ret = MsgWaitForMultipleObjects(1, &event, FALSE, INFINITE, QS_ALLINPUT);
	MSG msg;

	while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE))
	{
	switch (msg.message) {
	case WM_PAINT:
	DispatchMessageA(&msg);
	break;
	default:
	/* since we risk getting keyboard messages posted to us,
	* repost posted messages to cooperative window */
	PostMessageA(This->ddraw_owner->window, msg.message, msg.wParam, msg.lParam);
	}
	}
	#else
	DWORD ret = WaitForSingleObject(event, INFINITE);
	#endif
	if (ret == WAIT_OBJECT_0)
	{
	if (*pActive) {
	priv->user.in_refresh = TRUE;
	User_copy_to_screen(This, NULL);
	EnterCriticalSection(&priv->user.crit);
	priv->user.in_refresh = FALSE;
	if (priv->user.wait_count)
	SetEvent(priv->user.refresh_event);
	LeaveCriticalSection(&priv->user.crit);
	} else
	break;
	}
	else if (ret != WAIT_OBJECT_0+1) break;
	} while (TRUE);

	SetEvent(priv->user.refresh_event);
	#ifdef OWN_WINDOW
	User_destroy_own_window(This);
	#endif

	return 0;
	}
	#endif

	static void User_copy_to_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc)
	{
	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	POINT offset;
	HWND hDisplayWnd;
	HDC hDisplayDC;
	HDC hSurfaceDC;
	RECT drawrect;

	if (FAILED(This->get_dc(This, &hSurfaceDC)))
	return;

	hDisplayWnd = get_display_window(This, &offset);
	hDisplayDC = GetDCEx(hDisplayWnd, 0, DCX_CLIPSIBLINGS\|DCX_CACHE);
	#if 0
	/* FIXME: this doesn't work... if users really want to run
	* X in 8bpp, then we need to call directly into display.drv
	* (or Wine's equivalent), and force a private colormap
	* without default entries. */
	if (This->palette) {
	SelectPalette(hDisplayDC, This->palette->hpal, FALSE);
	RealizePalette(hDisplayDC); /* sends messages => deadlocks */
	}
	#endif
	drawrect.left = 0;
	drawrect.right = This->surface_desc.dwWidth;
	drawrect.top = 0;
	drawrect.bottom = This->surface_desc.dwHeight;

	if (This->clipper) {
	RECT xrc;
	HWND hwnd = This->clipper->hWnd;
	if (hwnd && GetClientRect(hwnd,&xrc)) {
	OffsetRect(&xrc,offset.x,offset.y);
	IntersectRect(&drawrect,&drawrect,&xrc);
	}
	}
	if (rc)
	IntersectRect(&drawrect,&drawrect,rc);
	else {
	/* Only use this if the caller did not pass a rectangle, since
	* due to double locking this could be the wrong one ... */
	if (This->lastlockrect.left != This->lastlockrect.right)
	IntersectRect(&drawrect,&drawrect,&This->lastlockrect);
	}
	BitBlt(hDisplayDC,
	drawrect.left-offset.x, drawrect.top-offset.y,
	drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
	hSurfaceDC,
	drawrect.left, drawrect.top,
	SRCCOPY
	);
	ReleaseDC(hDisplayWnd, hDisplayDC);
	}
	}

	#if 0
	static void User_copy_from_screen(IDirectDrawSurfaceImpl* This, LPCRECT rc)
	{
	if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	{
	POINT offset;
	HWND hDisplayWnd = get_display_window(This, &offset);
	HDC hDisplayDC = GetDC(hDisplayWnd);
	RECT drawrect;

	drawrect.left = 0;
	drawrect.right = This->surface_desc.dwWidth;
	drawrect.top = 0;
	drawrect.bottom = This->surface_desc.dwHeight;
	if (rc)
	IntersectRect(&drawrect,&drawrect,rc);

	BitBlt(This->hDC,
	drawrect.left, drawrect.top,
	drawrect.right-drawrect.left, drawrect.bottom-drawrect.top,
	hDisplayDC,
	drawrect.left+offset.x, drawrect.top+offset.y,
	SRCCOPY
	);
	ReleaseDC(hDisplayWnd, hDisplayDC);
	}
	}
	#endif

	static ICOM_VTABLE(IDirectDrawSurface7) User_IDirectDrawSurface7_VTable =
	{
	Main_DirectDrawSurface_QueryInterface,
	Main_DirectDrawSurface_AddRef,
	Main_DirectDrawSurface_Release,
	Main_DirectDrawSurface_AddAttachedSurface,
	Main_DirectDrawSurface_AddOverlayDirtyRect,
	DIB_DirectDrawSurface_Blt,
	Main_DirectDrawSurface_BltBatch,
	DIB_DirectDrawSurface_BltFast,
	Main_DirectDrawSurface_DeleteAttachedSurface,
	Main_DirectDrawSurface_EnumAttachedSurfaces,
	Main_DirectDrawSurface_EnumOverlayZOrders,
	Main_DirectDrawSurface_Flip,
	Main_DirectDrawSurface_GetAttachedSurface,
	Main_DirectDrawSurface_GetBltStatus,
	Main_DirectDrawSurface_GetCaps,
	Main_DirectDrawSurface_GetClipper,
	Main_DirectDrawSurface_GetColorKey,
	Main_DirectDrawSurface_GetDC,
	Main_DirectDrawSurface_GetFlipStatus,
	Main_DirectDrawSurface_GetOverlayPosition,
	Main_DirectDrawSurface_GetPalette,
	Main_DirectDrawSurface_GetPixelFormat,
	Main_DirectDrawSurface_GetSurfaceDesc,
	Main_DirectDrawSurface_Initialize,
	Main_DirectDrawSurface_IsLost,
	Main_DirectDrawSurface_Lock,
	Main_DirectDrawSurface_ReleaseDC,
	DIB_DirectDrawSurface_Restore,
	Main_DirectDrawSurface_SetClipper,
	Main_DirectDrawSurface_SetColorKey,
	Main_DirectDrawSurface_SetOverlayPosition,
	Main_DirectDrawSurface_SetPalette,
	Main_DirectDrawSurface_Unlock,
	Main_DirectDrawSurface_UpdateOverlay,
	Main_DirectDrawSurface_UpdateOverlayDisplay,
	Main_DirectDrawSurface_UpdateOverlayZOrder,
	Main_DirectDrawSurface_GetDDInterface,
	Main_DirectDrawSurface_PageLock,
	Main_DirectDrawSurface_PageUnlock,
	DIB_DirectDrawSurface_SetSurfaceDesc,
	Main_DirectDrawSurface_SetPrivateData,
	Main_DirectDrawSurface_GetPrivateData,
	Main_DirectDrawSurface_FreePrivateData,
	Main_DirectDrawSurface_GetUniquenessValue,
	Main_DirectDrawSurface_ChangeUniquenessValue,
	Main_DirectDrawSurface_SetPriority,
	Main_DirectDrawSurface_GetPriority,
	Main_DirectDrawSurface_SetLOD,
	Main_DirectDrawSurface_GetLOD
	};