static M4Err DD_FlushVideo(VideoOutput *dr, M4Window *dest) { RECT rc; HRESULT hr; DDCONTEXT; if (!dd) return M4BadParam; if (dd->is_3D_out) { SwapBuffers(dd->gl_HDC); return M4OK; } if (!dd->ddraw_init) return M4BadParam; if (dest) { POINT pt; pt.x = dest->x; pt.y = dest->y; ClientToScreen(dd->hWnd, &pt); dest->x = pt.x; dest->y = pt.y; MAKERECT(rc, dest); hr = IDirectDrawSurface_Blt(dd->pPrimary, &rc, dd->pBack, NULL, DDBLT_WAIT, NULL ); } else { hr = IDirectDrawSurface_Blt(dd->pPrimary, NULL, dd->pBack, NULL, DDBLT_WAIT, NULL ); } if (hr == DDERR_SURFACELOST) { IDirectDrawSurface_Restore(dd->pPrimary); IDirectDrawSurface_Restore(dd->pBack); } return FAILED(hr) ? M4IOErr : M4OK; }
static boolean BltCopy( LPDIRECTDRAWSURFACE src_surface, RECT * src_rect, LPDIRECTDRAWSURFACE dst_surface, RECT * dst_rect ) { DDSURFACEDESC ddsd_target; HRESULT result; memset( &ddsd_target, 0, sizeof( ddsd_target ) ); ddsd_target.dwSize = sizeof( ddsd_target ); /* attempt to blt the surface sontents */ result = IDirectDrawSurface_Blt( dst_surface, dst_rect, src_surface, src_rect, DDBLT_WAIT, 0 ); if( result != DD_OK ) { if( result != DDERR_SURFACELOST ) { IDirectDrawSurface_Restore( src_surface ); IDirectDrawSurface_Restore( dst_surface ); IDirectDrawSurface_Blt( dst_surface, dst_rect, src_surface, src_rect, DDBLT_WAIT, 0 ); } else { Error( 0, "IDirectDrawSurface_Blt : error 0x%lx", result ); return FALSE; } } return TRUE; }
static boolean Overlay( LPDIRECTDRAWSURFACE src_surface, RECT * src_rect, LPDIRECTDRAWSURFACE dst_surface, RECT * dst_rect, COLORREF color_key ) { DWORD dw_color_key; DDPIXELFORMAT ddpf; DDOVERLAYFX ddofx; int flags; HRESULT result; /* compute the colorkey pixel value from the RGB value we've got/ * NOTE : based on videolan colorkey code */ memset( &ddpf, 0, sizeof( DDPIXELFORMAT )); ddpf.dwSize = sizeof( DDPIXELFORMAT ); result = IDirectDrawSurface_GetPixelFormat( dst_surface, &ddpf ); if( result != DD_OK ) { Error( 0, "IDirectDrawSurface_GetPixelFormat : could not get surface pixel format" ); return FALSE; } dw_color_key = ( DWORD ) color_key; dw_color_key = ( DWORD ) ( ( ( dw_color_key * ddpf.dwRBitMask ) / 255 ) & ddpf.dwRBitMask ); memset( &ddofx, 0, sizeof( DDOVERLAYFX ) ); ddofx.dwSize = sizeof( DDOVERLAYFX ); ddofx.dckDestColorkey.dwColorSpaceLowValue = dw_color_key; ddofx.dckDestColorkey.dwColorSpaceHighValue = dw_color_key; /* set our overlay flags */ flags = DDOVER_SHOW | DDOVER_KEYDESTOVERRIDE; /* attempt to overlay the surface */ result = IDirectDrawSurface_UpdateOverlay( src_surface, src_rect, dst_surface, dst_rect, flags, &ddofx ); if( result != DD_OK ) { if( result == DDERR_SURFACELOST ) { IDirectDrawSurface_Restore( src_surface ); IDirectDrawSurface_Restore( dst_surface ); IDirectDrawSurface_UpdateOverlay( src_surface, src_rect, dst_surface, dst_rect, flags, &ddofx ); } else { Error( 0, "IDirectDrawSurface_UpdateOverlay : error 0x%lx. You can try disable hardware acceleration (option video.directx.hwaccel).", result ); return FALSE; } } return TRUE; }
/* Display buffer */ static void PaintDD() { DWORD ddrval; if (!IsWindowVisible(hWnd) || !active || !initialized || !BackSurface[0]) return; IDirectDrawSurface_Unlock(BackSurface[0], surface[0].lpSurface); IDirectDrawSurface_Unlock(BackSurface[1], surface[1].lpSurface); if (directX == DXFULLSCREEN) { if (storeddata) free(storeddata), storeddata = NULL; storeddata = store(currentbuff ? buffer2 : buffer1, bitDepth, lineSize, displayX, displayY, mouseX, mouseY); drawmouse(currentbuff ? buffer2 : buffer1, mousepointer, bitDepth, lineSize, displayX, displayY, mouseX, mouseY); ddrval = IDirectDrawSurface_BltFast(lpSurfaces[0], 0, 0, BackSurface[currentbuff], &rcScreen, FALSE); restore(currentbuff ? buffer2 : buffer1, storeddata, bitDepth, lineSize, displayX, displayY, mouseX, mouseY); oldmouseX = mouseX; oldmouseY = mouseY; } else { ddrval = IDirectDrawSurface_Blt(lpSurfaces[0], &rcScreen, BackSurface[currentbuff], &rcViewport, DDBLT_WAIT, NULL); } if (ddrval != DD_OK) { if ((int) ddrval == (int) DDERR_SURFACELOST) { IDirectDrawSurface_Restore(lpSurfaces[0]); IDirectDrawSurface_Restore(BackSurface[0]); IDirectDrawSurface_Restore(BackSurface[1]); ddrval = IDirectDrawSurface_Blt(lpSurfaces[0], &rcScreen, BackSurface[currentbuff], &rcViewport, DDBLT_WAIT, NULL); //if (ddrval == DDERR_SURFACELOST) resized=1; /*We've lost our fractal*/ } } ddrval = IDirectDrawSurface_Lock(BackSurface[0], NULL, &surface[0], DDLOCK_WAIT, NULL); ddrval = IDirectDrawSurface_Lock(BackSurface[1], NULL, &surface[1], DDLOCK_WAIT, NULL); if (buffer1 != (char *) surface[0].lpSurface || buffer2 != (char *) surface[1].lpSurface) { DeInitDD(); x_fatalerror ("Unexpected event - buffers moved! Please contact authors!"); } needredraw = 0; }
// // Flip the real page with virtual page // - in bAppFullScreen mode, do page flipping // - in windowed mode, copy the hidden surface to the visible surface // // waitflip : if not 0, wait for page flip to end BOOL ScreenFlip(int waitflip) { HRESULT hr; RECT rect; UNREFERENCED_PARAMETER(waitflip); if (bAppFullScreen) { //hr = IDirectDrawSurface_GetFlipStatus (ScreenReal, DDGFS_); // In full-screen exclusive mode, do a hardware flip. hr = IDirectDrawSurface_Flip(ScreenReal, NULL, DDFLIP_WAIT); //return immediately // If the surface was lost, restore it. if (hr == DDERR_SURFACELOST) { IDirectDrawSurface_Restore(ScreenReal); // The restore worked, so try the flip again. hr = IDirectDrawSurface_Flip(ScreenReal, 0, DDFLIP_WAIT); } } else { rect.left = windowPosX; rect.top = windowPosY; rect.right = windowPosX + ScreenWidth - 1; rect.bottom = windowPosY + ScreenHeight - 1; // Copy the back buffer to front. hr = IDirectDrawSurface_Blt(ScreenReal, &rect, ScreenVirtual, 0, DDBLT_WAIT, 0); if (hr != DD_OK) { // If the surfaces were lost, restore them. if (IDirectDrawSurface_IsLost(ScreenReal) == DDERR_SURFACELOST) IDirectDrawSurface_Restore(ScreenReal); if (IDirectDrawSurface_IsLost(ScreenVirtual) == DDERR_SURFACELOST) IDirectDrawSurface_Restore(ScreenVirtual); // Retry the copy. hr = IDirectDrawSurface_Blt(ScreenReal,&rect, ScreenVirtual, 0, DDBLT_WAIT, 0); } } if (hr != DD_OK) I_Error("ScreenFlip() : couldn't Flip surfaces because %s", DXErrorToString(hr)); return FALSE; }
static void testsurface(void) { const char* testMsg = "ddraw device context test"; HDC hdc; HRESULT rc; rc = IDirectDrawSurface_GetDC(lpDDSBack, &hdc); ok(rc==DD_OK, "IDirectDrawSurface_GetDC returned: %x\n",rc); SetBkColor(hdc, RGB(0, 0, 255)); SetTextColor(hdc, RGB(255, 255, 0)); TextOut(hdc, 0, 0, testMsg, lstrlen(testMsg)); IDirectDrawSurface_ReleaseDC(lpDDSBack, hdc); ok(rc==DD_OK, "IDirectDrawSurface_ReleaseDC returned: %x\n",rc); while (1) { rc = IDirectDrawSurface_Flip(lpDDSPrimary, NULL, DDFLIP_WAIT); ok(rc==DD_OK || rc==DDERR_SURFACELOST, "IDirectDrawSurface_BltFast returned: %x\n",rc); if (rc == DD_OK) { break; } else if (rc == DDERR_SURFACELOST) { rc = IDirectDrawSurface_Restore(lpDDSPrimary); ok(rc==DD_OK, "IDirectDrawSurface_Restore returned: %x\n",rc); } } }
// // CreateNewSurface // static inline IDirectDrawSurface* CreateNewSurface(int dwWidth, int dwHeight, int dwSurfaceCaps) { DDSURFACEDESC ddsd; HRESULT hr; LPDIRECTDRAWSURFACE psurf; ZeroMemory(&ddsd, sizeof (ddsd)); ddsd.dwSize = sizeof (ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT |DDSD_WIDTH; ddsd.ddsCaps.dwCaps = dwSurfaceCaps; ddsd.dwHeight = dwHeight; ddsd.dwWidth = dwWidth; hr = IDirectDraw2_CreateSurface (DDr2, &ddsd, &psurf, NULL); if (hr == DD_OK) { //DDCOLORKEY ddck; IDirectDrawSurface_Restore(psurf); //hr = IDirectDrawSurface_GetColorKey(DDCKEY_SRCBLT, &ddck); //psurf->SetColorKey(DDCKEY_SRCBLT, &ddck); } else psurf = NULL; return psurf; }
// DDRestoreCanvas // ---------------------------------------------------------------------------- BOOL DDRestoreCanvas(dd_grs_canvas *canvas) { HRESULT ddresult; Assert(canvas->lpdds != NULL); ddresult = IDirectDrawSurface_Restore(canvas->lpdds); if (ddresult != DD_OK) { if (ddresult != DDERR_WRONGMODE) { logentry("DDRAW::RestoreCanvas::Surface err: %x\n", ddresult); return FALSE; } mprintf((0, "Recreating surfaces:\n")); // Must recreate canvas if (canvas->lpdds == _lpDDSPrimary || canvas->lpdds == _lpDDSBack) { mprintf((0, "DDRestoreCanvas::Screen memory was lost!\n")); exit(1); } if (canvas->sram) { // force sysmem canvas! canvas->lpdds = DDCreateSysMemSurface(canvas->canvas.cv_bitmap.bm_w, canvas->canvas.cv_bitmap.bm_h); } else { canvas->lpdds = DDCreateSurface(canvas->canvas.cv_bitmap.bm_w, canvas->canvas.cv_bitmap.bm_h, _DDSysMemSurfacing); } } return TRUE; }
static void * Lock( win32_driver_t * win32_driver, void * surface ) { LPDIRECTDRAWSURFACE lock_surface = ( LPDIRECTDRAWSURFACE ) surface; HRESULT result; if( !surface ) return 0; memset( &win32_driver->ddsd, 0, sizeof( win32_driver->ddsd ) ); win32_driver->ddsd.dwSize = sizeof( win32_driver->ddsd ); result = IDirectDrawSurface_Lock( lock_surface, 0, &win32_driver->ddsd, DDLOCK_WAIT | DDLOCK_NOSYSLOCK, 0 ); if( result == DDERR_SURFACELOST ) { IDirectDrawSurface_Restore( lock_surface ); result = IDirectDrawSurface_Lock( lock_surface, 0, &win32_driver->ddsd, DDLOCK_WAIT | DDLOCK_NOSYSLOCK, 0 ); if( result != DD_OK ) return 0; } else if( result != DD_OK ) { if( result == DDERR_GENERIC ) { Error( 0, "surface->Lock : error, DDERR_GENERIC" ); exit( 1 ); } } return win32_driver->ddsd.lpSurface; }
static void flip_page(void) { DDSURFACEDESC2 ddsd; HRESULT dxresult; IDirectDrawSurface_Unlock(g_lpddsBack, NULL); if (g_doublebuffer) { dxresult = IDirectDrawSurface_Flip(g_lpddsOverlay, NULL, DDFLIP_WAIT); if (dxresult == DDERR_SURFACELOST) { av_log(NULL, AV_LOG_INFO, "vo_directx: Lost, Restoring Surface\n"); IDirectDrawSurface_Restore(g_lpddsBack); IDirectDrawSurface_Restore(g_lpddsOverlay); IDirectDrawSurface_Restore(g_lpddsPrimary); dxresult = IDirectDrawSurface_Flip(g_lpddsOverlay, NULL, DDFLIP_WAIT); } if (dxresult != DD_OK) { av_log(NULL, AV_LOG_ERROR, "vo_directx: can not flip page\n"); } } else { DDBLTFX ddbltfx; memset(&ddbltfx, 0, sizeof(DDBLTFX)); ddbltfx.dwSize = sizeof(DDBLTFX); ddbltfx.dwDDFX = DDBLTFX_NOTEARING; IDirectDrawSurface_Blt(g_lpddsPrimary, &rd, g_lpddsBack, NULL, DDBLT_WAIT, &ddbltfx); } memset(&ddsd, 0, sizeof(DDSURFACEDESC2)); ddsd.dwSize = sizeof(DDSURFACEDESC2); if (IDirectDrawSurface_Lock(g_lpddsBack, NULL, &ddsd, DDLOCK_NOSYSLOCK | DDLOCK_WAIT, NULL) == DD_OK) { if (tmp_image) { free(tmp_image); tmp_image = NULL; } g_dstride = ddsd.lPitch; g_image = ddsd.lpSurface; } else { if (!tmp_image) { av_log(NULL, AV_LOG_INFO, "Locking the surface failed, rendering to a hidden surface!\n"); tmp_image = g_image = calloc(1, g_image_height * g_dstride * 2); } } }
// DDRestoreScreen // Restore screens // ---------------------------------------------------------------------------- int DDRestoreScreen() { mprintf((1, "Need to Restore DDraw Page0 and Page1.\n")); if (!_lpDDSPrimary || IDirectDrawSurface_Restore(_lpDDSPrimary) !=DD_OK) { mprintf((1, "Warning: Unable to restore Primary Surface.\n")); return 0; } if (!GRMODEINFO(paged) && _lpDDSBack) { if (IDirectDrawSurface_Restore(_lpDDSBack) != DD_OK) { mprintf((1, "Warning: Unable to restore Back Surface.\n")); return 0; } } else if (!_DDFullScreen) { if (!_lpDDSBack || IDirectDrawSurface_Restore(_lpDDSBack) != DD_OK) { mprintf((1, "Warning: Unable to restore Back Surface.\n")); return 0; } } return 1; }
// DDSetPalette // ---------------------------------------------------------------------------- void DDSetPalette(LPDIRECTDRAWPALETTE lpDDPal) { HRESULT ddresult; ddresult = IDirectDrawSurface_SetPalette(_lpDDSPrimary, lpDDPal); if (ddresult != DD_OK) { if (ddresult == DDERR_SURFACELOST) { IDirectDrawSurface_Restore(_lpDDSPrimary); IDirectDrawSurface_SetPalette(_lpDDSPrimary, lpDDPal); } else { Error("Unable to attach palette to primary surface: %x.", ddresult); } } }
// // Lock surface before multiple drawings by hand, for speed // boolean LockScreen(VOID) { DDSURFACEDESC ddsd; HRESULT ddrval; ZeroMemory(&ddsd, sizeof (ddsd)); ddsd.dwSize = sizeof (ddsd); // attempt to Lock the surface ddrval = IDirectDrawSurface_Lock(ScreenVirtual, NULL, &ddsd, DDLOCK_WAIT, NULL); // Always, always check for errors with DirectX! // If the surface was lost, restore it. if (ddrval == DDERR_SURFACELOST) { ddrval = IDirectDrawSurface_Restore(ScreenReal); // now retry to get the lock ddrval = IDirectDrawSurface_Lock(ScreenVirtual, NULL, &ddsd, DDLOCK_WAIT, NULL); } if (ddrval == DD_OK) { ScreenLocked = TRUE; ScreenPtr = (LPBYTE)ddsd.lpSurface; ScreenPitch = ddsd. #ifdef DUMMYUNIONNAMEN DUMMYUNIONNAMEN(1). #endif lPitch; } else { ScreenLocked = FALSE; ScreenPtr = NULL; ScreenPitch = 0; //I_Error("LockScreen() : couldn't restore the surface."); return false; } return true; }
int dd_gfx_loadbitmap2D(unsigned short handle, void *buf, int rleflag) { HRESULT ddresult; DDSURFACEDESC ddsd; char *ptr; int pitch, i; grs_bitmap tbmp; Assert(handle != 0); if (!dd_gfx_initialized) return 0; handle--; // Convert to valid handle RedoLock: memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddresult = IDirectDrawSurface_Lock(gfxBitmap[handle].lpdds, NULL, &ddsd, DDLOCK_WAIT, NULL); if (ddresult != DD_OK) { if (ddresult == DDERR_SURFACELOST) { ddresult = IDirectDrawSurface_Restore(gfxBitmap[handle].lpdds); if (ddresult != DD_OK) { if (ddresult != DDERR_WRONGMODE) { logentry("DDGFX::Restore::Surface err: %x\n", ddresult); return 1; } else { LPDIRECTDRAWSURFACE lpdds; DDCOLORKEY ddck; IDirectDrawSurface_Release(lpdds); gfxBitmap[handle].lpdds = NULL; memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; ddsd.dwWidth = gfxBitmap[handle].w; ddsd.dwHeight = gfxBitmap[handle].h; ddresult = IDirectDraw_CreateSurface(_lpDD, &ddsd, &lpdds, NULL); if (ddresult != DD_OK) { mprintf((0, "DDGFX: Failed to restore vidmem 2d bitmap.\n")); return 1; } ddck.dwColorSpaceLowValue = TRANSPARENCY_COLOR; ddck.dwColorSpaceHighValue = TRANSPARENCY_COLOR; IDirectDrawSurface_SetColorKey(lpdds, DDCKEY_SRCBLT, &ddck); gfxBitmap[handle].lpdds = lpdds; } } goto RedoLock; } else { mprintf((0, "DDGFX:Unable to lock surface!!\n")); return 1; } } // Locked! ptr = ddsd.lpSurface; pitch = ddsd.lPitch; gr_init_bitmap(&tbmp, BM_LINEAR, 0,0,gfxBitmap[handle].w, gfxBitmap[handle].h, gfxBitmap[handle].w, buf); if (rleflag) tbmp.bm_flags = BM_FLAG_RLE; for(i = 0; i < gfxBitmap[handle].h; i++) { extern ubyte scale_rle_data[]; if (rleflag) { decode_row(&tbmp,i); memcpy(ptr+(i*pitch), scale_rle_data, gfxBitmap[handle].w); } else memcpy(ptr+(i*pitch), (ubyte*)(buf)+(i*gfxBitmap[handle].w), gfxBitmap[handle].w); } IDirectDrawSurface_Unlock(gfxBitmap[handle].lpdds, ptr); // Unlocked... return 0; }
static long FAR PASCAL WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { LPCREATESTRUCT lpcs; PAINTSTRUCT ps; RECT dirty; HDC hdc; struct ggi_visual *vis = (struct ggi_visual *) GetWindowLong(hWnd, GWL_USERDATA); directx_priv *priv = NULL; HRESULT hr; if (vis) priv = GGIDIRECTX_PRIV(vis); switch (message) { case WM_DDSETPALETTE: { int setpalette; GGI_directx_Lock(priv->spincs); setpalette = priv->setpalette; GGI_directx_Unlock(priv->spincs); if(setpalette) /* setpalette canceled */ return 0; } if(GGI_directx_TryLock(priv->cs)) { /* spin */ PostMessage(hWnd, message, wParam, lParam); return 0; } if(priv->lpddp) GGI_directx_DDChangePalette(vis); GGI_directx_Lock(priv->spincs); priv->setpalette = 1; GGI_directx_Unlock(priv->spincs); GGI_directx_Unlock(priv->cs); return 0; case WM_TIMER: if (wParam != 1) break; if (GGI_directx_TryLock(priv->cs)) { int redraw = 0; GGI_directx_Lock(priv->spincs); redraw = priv->redraw; priv->redraw = 0; GGI_directx_Unlock(priv->spincs); if (redraw) /* spin */ PostMessage(hWnd, WM_USER, wParam, lParam); return 0; } GGI_directx_DDRedrawAll(vis); GGI_directx_Unlock(priv->cs); return 0; case WM_PAINT: if (GGI_directx_TryLock(priv->cs)) { int redraw = 0; GGI_directx_Lock(priv->spincs); redraw = priv->redraw; priv->redraw = 0; GGI_directx_Unlock(priv->spincs); if (redraw) /* spin */ InvalidateRect(hWnd, NULL, 0); return 0; } if (GetUpdateRect(hWnd, &dirty, FALSE)) { /* I have a back buffer to update from, * no need to involve the application... if (priv->inp) { gii_event ev; ev.any.size = sizeof(gii_expose_event); ev.any.type = evExpose; ev.any.target = priv->inp->origin; ev.expose.x = vis->origin_x + dirty.left; ev.expose.y = vis->origin_y + dirty.top; ev.expose.w = dirty.right - dirty.left; ev.expose.h = dirty.bottom - dirty.top; giiEventSend(priv->inp, &ev); } */ hr = IDirectDrawSurface_IsLost(priv->lppdds); if (hr == DDERR_SURFACELOST) hr = IDirectDrawSurface_Restore( priv->lppdds); hdc = BeginPaint(hWnd, &ps); GGI_directx_DDRedraw( vis, vis->origin_x + ps.rcPaint.left, vis->origin_y + ps.rcPaint.top, ps.rcPaint.right - ps.rcPaint.left, ps.rcPaint.bottom - ps.rcPaint.top); EndPaint(hWnd, &ps); } GGI_directx_Unlock(priv->cs); return 0; case WM_SIZING: GGI_directx_Lock(priv->sizingcs); if (priv->xstep < 0) { GGI_directx_Unlock(priv->sizingcs); break; } DDSizing(vis, wParam, (LPRECT) lParam); GGI_directx_Unlock(priv->sizingcs); return TRUE; case WM_SIZE: switch(wParam) { case SIZE_MAXIMIZED: case SIZE_RESTORED: break; default: return 0; } GGI_directx_Lock(priv->sizingcs); if (priv->xstep < 0) { GGI_directx_Unlock(priv->sizingcs); break; } DDNotifyResize(vis, LOWORD(lParam), HIWORD(lParam)); GGI_directx_Unlock(priv->sizingcs); return 0; case WM_QUERYNEWPALETTE: if(GGI_directx_TryLock(priv->cs)) { int setpalette = 0; GGI_directx_Lock(priv->spincs); setpalette = priv->setpalette; priv->redraw = 0; GGI_directx_Unlock(priv->spincs); if(setpalette) /* spin */ PostMessage(hWnd, WM_DDSETPALETTE, wParam, lParam); return 0; } if(!priv->lpddp) { GGI_directx_Unlock(priv->cs); break; } GGI_directx_DDChangePalette(vis); GGI_directx_Unlock(priv->cs); return TRUE; case WM_CREATE: lpcs = (LPCREATESTRUCT) lParam; SetWindowLong(hWnd, GWL_USERDATA, (DWORD) lpcs->lpCreateParams); return 0; case WM_CLOSE: DPRINT_EVENTS("WM_CLOSE\n"); if (priv->hParent) break; ggBroadcast(vis->instance.channel, GGI_CMDCODE_CLOSE, NULL); if (priv->exit_on_close_window) exit(0); return 0; case WM_RENDERFORMAT: case WM_RENDERALLFORMATS: { struct ggi_directx_cmddata_render_cb format; format.format = wParam; ggBroadcast(vis->instance.channel, GGI_DIRECTX_RENDERCLIPBOARD, &format); return 0; } case WM_DESTROYCLIPBOARD: ggBroadcast(vis->instance.channel, GGI_DIRECTX_DESTROYCLIPBOARD, NULL); return 0; #if 0 /* WM_CLIPBOARDUPDATE is >= Vista :-( */ case WM_CLIPBOARDUPDATE: ggBroadcast(vis->instance.channel, GGI_DIRECTX_CLIPBOARDUPDATE, NULL); return 0; #endif case WM_SETTINGCHANGE: GGI_directx_Lock(priv->cs); if (priv->settings_changed) { DPRINT("tell inputlib about " "new system parameters\n"); priv->settings_changed(priv->settings_changed_arg); GGI_directx_Unlock(priv->cs); return 0; } GGI_directx_Unlock(priv->cs); break; case WM_SETFOCUS: if (priv->grab_hotkeys) { DPRINT("Grab hotkeys (focus)\n"); PostThreadMessage(priv->nThreadID, WM_DDHOTKEY, 1, 0); } priv->focus = 1; break; case WM_KILLFOCUS: if (priv->grab_hotkeys) { DPRINT("Ungrab hotkeys (unfocus)\n"); PostThreadMessage(priv->nThreadID, WM_DDHOTKEY, 0, 0); } priv->focus = 0; break; case WM_HOTKEY: if (priv->grab_hotkeys && priv->inp) { gii_inputdx_hotkey hotkey; hotkey.id = wParam; hotkey.mod = LOWORD(lParam); hotkey.vk = HIWORD(lParam); DPRINT("WM_HOTKEY id=%d, mod=%04x, vk=%d\n", hotkey.id, hotkey.mod, hotkey.vk); ggControl(priv->inp->channel, GII_INPUTDX_HOTKEY, &hotkey); } break; } return DefWindowProc(hWnd, message, wParam, lParam); }