mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
870 lines
26 KiB
870 lines
26 KiB
/*==========================================================================
|
|
*
|
|
* Copyright (C) 2000 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: dwinproc.cpp
|
|
* Content: DirectDraw processing of Window messages
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 27-Jan-00 kanqiu initial implementation
|
|
***************************************************************************/
|
|
#include "ddrawpr.h"
|
|
|
|
#include "swapchan.hpp"
|
|
|
|
#include "resource.inl"
|
|
|
|
#ifdef WINNT
|
|
|
|
#define USESHOWWINDOW
|
|
|
|
// WindowInfo structure
|
|
typedef struct _D3DWINDOWINFO
|
|
{
|
|
DWORD dwMagic;
|
|
HWND hWnd;
|
|
WNDPROC lpWndProc;
|
|
DWORD dwFlags;
|
|
CEnum *pEnum;
|
|
DWORD dwDDFlags;
|
|
} D3DWINDOWINFO;
|
|
|
|
// WindowInfo for our single hooked winproc
|
|
// This global variable should never never be accessed outside
|
|
// of this file.
|
|
D3DWINDOWINFO g_WindowInfo = {0, 0, 0, 0, 0, 0};
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::HIDESHOW_IME"
|
|
|
|
// IME hide/show function
|
|
void CSwapChain::HIDESHOW_IME()
|
|
{
|
|
if (m_lSetIME)
|
|
{
|
|
SystemParametersInfo(
|
|
SPI_SETSHOWIMEUI, m_lSetIME - 1, NULL, 0);
|
|
InterlockedExchange(&m_lSetIME, 0);
|
|
}
|
|
} // HIDESHOW_IME
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::IsWinProcDeactivated"
|
|
|
|
BOOL CSwapChain::IsWinProcDeactivated() const
|
|
{
|
|
// Do we even have our own win-proc?
|
|
if (g_WindowInfo.hWnd != Device()->FocusWindow())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Check to see if our win-proc is deactivated then
|
|
if (DDRAWILCL_ACTIVENO & g_WindowInfo.dwDDFlags)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
} // IsWinProcActive
|
|
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::MakeFullscreen"
|
|
//
|
|
// make the passed window fullscreen and topmost and set a timer
|
|
// to make the window topmost again, what a hack.
|
|
//
|
|
void CSwapChain::MakeFullscreen()
|
|
{
|
|
// We need to make sure that we don't send this
|
|
// size message to the app
|
|
g_WindowInfo.dwFlags |= WININFO_SELFSIZE;
|
|
|
|
// Do the processing
|
|
MONITORINFO MonInfo;
|
|
MonInfo.rcMonitor.top = MonInfo.rcMonitor.left = 0;
|
|
if (1 < Device()->Enum()->GetAdapterCount())
|
|
{
|
|
HMONITOR hMonitor = Device()->Enum()->
|
|
GetAdapterMonitor(Device()->AdapterIndex());
|
|
MonInfo.cbSize = sizeof(MONITORINFO);
|
|
if (hMonitor)
|
|
InternalGetMonitorInfo(hMonitor, &MonInfo);
|
|
}
|
|
SetWindowPos(m_PresentationData.hDeviceWindow, NULL,
|
|
MonInfo.rcMonitor.left,
|
|
MonInfo.rcMonitor.top,
|
|
Width(),
|
|
Height(),
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
if (GetForegroundWindow() == Device()->FocusWindow())
|
|
{
|
|
// If the exclusive mode window is not visible, make it so.
|
|
if (!IsWindowVisible(m_PresentationData.hDeviceWindow))
|
|
{
|
|
ShowWindow(m_PresentationData.hDeviceWindow, SW_SHOW);
|
|
}
|
|
|
|
SetWindowPos(m_PresentationData.hDeviceWindow, HWND_TOPMOST, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
|
|
// If the exclusive mode window is maximized, restore it.
|
|
if (IsZoomed(m_PresentationData.hDeviceWindow))
|
|
{
|
|
ShowWindow(m_PresentationData.hDeviceWindow, SW_RESTORE);
|
|
}
|
|
}
|
|
|
|
// We're done; so undo the self-size flag
|
|
g_WindowInfo.dwFlags &= ~WININFO_SELFSIZE;
|
|
|
|
} // CSwapChain::MakeFullscreen
|
|
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "handleActivateApp"
|
|
|
|
HRESULT handleActivateApp(BOOL is_active)
|
|
{
|
|
// We are going to start touching some internal
|
|
// data structures of the device and/or enum objects
|
|
// so we have to take the critical section for the device
|
|
#ifdef DEBUG
|
|
CLockD3D _lock(g_WindowInfo.pEnum, DPF_MODNAME, __FILE__);
|
|
#else
|
|
CLockD3D _lock(g_WindowInfo.pEnum);
|
|
#endif
|
|
|
|
HRESULT ddrval;
|
|
BOOL has_excl;
|
|
CEnum *pEnum = g_WindowInfo.pEnum;
|
|
|
|
#ifdef WINNT
|
|
if (pEnum->CheckExclusiveMode(NULL, &has_excl, is_active)
|
|
&& !has_excl && is_active)
|
|
{
|
|
// If we didn't get exclusive mode, for example, a different thread came in
|
|
DPF_ERR("Could not get exclusive mode when we thought we could");
|
|
return E_FAIL;
|
|
}
|
|
#endif //WINNT
|
|
|
|
/*
|
|
* stuff to do before the mode set if deactivating
|
|
*/
|
|
if (is_active)
|
|
{
|
|
/*
|
|
* restore exclusive mode. Here we don't release the ref we took on the exclusive mode mutex,
|
|
* since we want to keep the exclusive mode mutex.
|
|
*/
|
|
pEnum->StartExclusiveMode();
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* restore the mode
|
|
*/
|
|
pEnum->DoneExclusiveMode();
|
|
}
|
|
return S_OK;
|
|
} /* handleActivateApp */
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "WindowProc"
|
|
|
|
/*
|
|
* WindowProc
|
|
*/
|
|
LRESULT WINAPI WindowProc(
|
|
HWND hWnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
BOOL is_active;
|
|
WNDPROC proc;
|
|
BOOL get_away;
|
|
LRESULT rc;
|
|
|
|
/*
|
|
* Check the window proc
|
|
*/
|
|
if (g_WindowInfo.hWnd != hWnd || g_WindowInfo.dwMagic != WININFO_MAGIC)
|
|
{
|
|
DPF(4, "FATAL ERROR! Window Proc Called for hWnd %08lx, but not in list!", hWnd);
|
|
DEBUG_BREAK();
|
|
return DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
if (g_WindowInfo.dwFlags & WININFO_SELFSIZE)
|
|
{
|
|
return 0L; // don't send to app, it's caused by MakeFullscreen
|
|
}
|
|
|
|
/*
|
|
* unhook at destroy (or if the WININFO_UNHOOK bit is set)
|
|
*/
|
|
proc = g_WindowInfo.lpWndProc;
|
|
|
|
if (uMsg == WM_NCDESTROY)
|
|
{
|
|
DPF (4, "*** WM_NCDESTROY unhooking window ***");
|
|
g_WindowInfo.dwFlags |= WININFO_UNHOOK;
|
|
}
|
|
|
|
if (g_WindowInfo.dwFlags & WININFO_UNHOOK)
|
|
{
|
|
DPF (4, "*** Unhooking window proc");
|
|
|
|
if (g_WindowInfo.dwFlags & WININFO_ZOMBIE)
|
|
{
|
|
DPF (4, "*** Freeing ZOMBIE WININFO ***");
|
|
ZeroMemory(&g_WindowInfo, sizeof(g_WindowInfo));
|
|
}
|
|
|
|
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (INT_PTR) proc);
|
|
|
|
rc = CallWindowProc(proc, hWnd, uMsg, wParam, lParam);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Code to defer app activation of minimized app until it is restored.
|
|
*/
|
|
switch(uMsg)
|
|
{
|
|
#ifdef WIN95
|
|
case WM_POWERBROADCAST:
|
|
if ((wParam == PBT_APMSUSPEND) || (wParam == PBT_APMSTANDBY))
|
|
#else
|
|
//winnt doesn't know about standby vs suspend
|
|
case WM_POWER:
|
|
if (wParam == PWR_SUSPENDREQUEST)
|
|
#endif
|
|
{
|
|
DPF(4, "WM_POWERBROADCAST: deactivating application");
|
|
SendMessage(hWnd, WM_ACTIVATEAPP, 0, GetCurrentThreadId());
|
|
}
|
|
break;
|
|
case WM_SIZE:
|
|
DPF(4, "WM_SIZE hWnd=%X wp=%04X, lp=%08X dwFlags=%08lx", hWnd, wParam,
|
|
lParam, g_WindowInfo.dwFlags);
|
|
|
|
if (!(g_WindowInfo.dwFlags & WININFO_INACTIVATEAPP)
|
|
&& ((wParam == SIZE_RESTORED) || (wParam == SIZE_MAXIMIZED))
|
|
&& (GetForegroundWindow() == hWnd))
|
|
{
|
|
#ifdef WINNT
|
|
//
|
|
// Wouldncha know it, but NT's messaging order is HUGELY different when alt-tabbing
|
|
// between two exclusive mode apps. The first WM_SIZE sent to the activating app is
|
|
// sent BEFORE the deactivating app loses FSE. This WM_SIZE is totally necessary to
|
|
// reactivate the activating app, but it has to wait until the app loses FSE.
|
|
// So, we simply wait on the exclusive mode mutex. This seems to work!
|
|
//
|
|
{
|
|
DWORD dwWaitResult;
|
|
dwWaitResult = WaitForSingleObject(hExclusiveModeMutex, INFINITE);
|
|
switch (dwWaitResult)
|
|
{
|
|
case WAIT_OBJECT_0:
|
|
case WAIT_ABANDONED:
|
|
ReleaseMutex(hExclusiveModeMutex);
|
|
break;
|
|
case WAIT_TIMEOUT:
|
|
default:
|
|
DDASSERT(!"Unexpected return value from WaitForSingleObject");
|
|
}
|
|
|
|
}
|
|
#endif
|
|
DPF(4, "WM_SIZE: Window restored, sending WM_ACTIVATEAPP");
|
|
PostMessage(hWnd, WM_ACTIVATEAPP, 1, GetCurrentThreadId());
|
|
}
|
|
else
|
|
{
|
|
DPF(4, "WM_SIZE: Window restored, NOT sending WM_ACTIVATEAPP");
|
|
}
|
|
break;
|
|
|
|
case WM_ACTIVATEAPP:
|
|
if (IsIconic(hWnd) && wParam)
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: Ignoring while minimized");
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
g_WindowInfo.dwFlags |= WININFO_INACTIVATEAPP;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* is directdraw involved here?
|
|
*/
|
|
if (!(g_WindowInfo.dwFlags & WININFO_DDRAWHOOKED))
|
|
{
|
|
rc = CallWindowProc(proc, hWnd, uMsg, wParam, lParam);
|
|
|
|
// clear the WININFO_INACTIVATEAPP bit, but make sure to make sure
|
|
// we are still hooked!
|
|
if (uMsg == WM_ACTIVATEAPP && (g_WindowInfo.hWnd == hWnd))
|
|
{
|
|
g_WindowInfo.dwFlags &= ~WININFO_INACTIVATEAPP;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (!IsIconic(hWnd))
|
|
{
|
|
if (GetForegroundWindow() == hWnd)
|
|
{
|
|
HWND hwndT;
|
|
RECT rc,rcT;
|
|
|
|
GetWindowRect(hWnd, &rc);
|
|
|
|
for (hwndT = GetWindow(hWnd, GW_HWNDFIRST);
|
|
hwndT && hwndT != hWnd;
|
|
hwndT = GetWindow(hwndT, GW_HWNDNEXT))
|
|
{
|
|
if (IsWindowVisible(hwndT))
|
|
{
|
|
GetWindowRect(hwndT, &rcT);
|
|
if (IntersectRect(&rcT, &rcT, &rc))
|
|
{
|
|
DPF(4, "Window %08x is on top of us!!", hwndT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* NOTE: we don't take the DLL csect here. By not doing this, we can
|
|
* up the performance here. However, this means that the application
|
|
* could have a separate thread kill exclusive mode while window
|
|
* messages were being processed. This could cause our death.
|
|
* Is this OK?
|
|
*/
|
|
|
|
switch(uMsg)
|
|
{
|
|
/*
|
|
* WM_SYSKEYUP
|
|
*
|
|
* watch for system keys of app trying to switch away from us...
|
|
*
|
|
* we only need to do this on Win95 because we have disabled all
|
|
* the task-switching hot keys. on NT we will get switched
|
|
* away from normaly by the system.
|
|
*/
|
|
case WM_SYSKEYUP:
|
|
DPF(4, "WM_SYSKEYUP: wParam=%08lx lParam=%08lx", wParam, lParam);
|
|
get_away = FALSE;
|
|
if (wParam == VK_TAB)
|
|
{
|
|
if (lParam & 0x20000000l)
|
|
{
|
|
if (g_WindowInfo.dwFlags & WININFO_IGNORENEXTALTTAB)
|
|
{
|
|
DPF(4, "AHHHHHHHHHHHH Ignoring AltTab");
|
|
}
|
|
else
|
|
{
|
|
get_away = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if (wParam == VK_ESCAPE)
|
|
{
|
|
get_away = TRUE;
|
|
}
|
|
|
|
g_WindowInfo.dwFlags &= ~WININFO_IGNORENEXTALTTAB;
|
|
|
|
if (get_away)
|
|
{
|
|
DPF(4, "Hot key pressed, switching away from app");
|
|
PostMessage(hWnd, WM_ACTIVATEAPP, 0, GetCurrentThreadId());
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* WM_SYSCOMMAND
|
|
*
|
|
* watch for screen savers, and don't allow them!
|
|
*
|
|
*/
|
|
case WM_SYSCOMMAND:
|
|
|
|
switch(wParam)
|
|
{
|
|
case SC_SCREENSAVE:
|
|
DPF(4, "Ignoring screen saver!");
|
|
return 1;
|
|
// allow window to be restored even if it has popup(s)
|
|
case SC_RESTORE:
|
|
ShowWindow(hWnd, SW_RESTORE);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
#ifdef USESHOWWINDOW
|
|
case WM_DISPLAYCHANGE:
|
|
DPF(4, "WM_DISPLAYCHANGE: %dx%dx%d", LOWORD(lParam), HIWORD(lParam), wParam);
|
|
|
|
//
|
|
// WM_DISPLAYCHANGE is *sent* to the thread that called
|
|
// change display settings, we will most likely have the
|
|
// direct draw lock, make sure we set the WININFO_SELFSIZE
|
|
// bit while calling down the chain to prevent deadlock
|
|
//
|
|
g_WindowInfo.dwFlags |= WININFO_SELFSIZE;
|
|
|
|
rc = CallWindowProc(proc, hWnd, uMsg, wParam, lParam);
|
|
|
|
g_WindowInfo.dwFlags &= ~WININFO_SELFSIZE;
|
|
|
|
return rc;
|
|
#endif
|
|
|
|
/*
|
|
* WM_ACTIVATEAPP
|
|
*
|
|
* the application has been reactivated. In this case, we need to
|
|
* reset the mode
|
|
*
|
|
*/
|
|
case WM_ACTIVATEAPP:
|
|
|
|
is_active = (BOOL)wParam && GetForegroundWindow() == hWnd && !IsIconic(hWnd);
|
|
|
|
if (!is_active && wParam != 0)
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: setting wParam to 0, not realy active");
|
|
wParam = 0;
|
|
}
|
|
|
|
if (is_active)
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: BEGIN Activating app pid=%08lx, tid=%08lx",
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
}
|
|
else
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: BEGIN Deactivating app pid=%08lx, tid=%08lx",
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
}
|
|
if (is_active && (g_WindowInfo.dwDDFlags & DDRAWILCL_ACTIVEYES))
|
|
{
|
|
DPF(4, "*** Already activated");
|
|
}
|
|
else
|
|
if (!is_active && (g_WindowInfo.dwDDFlags & DDRAWILCL_ACTIVENO))
|
|
{
|
|
DPF(4, "*** Already deactivated");
|
|
}
|
|
else
|
|
{
|
|
if (FAILED(handleActivateApp(is_active)))
|
|
break;
|
|
DPF(4, "*** Active state changing");
|
|
if (is_active)
|
|
{
|
|
#ifdef DEBUG
|
|
if (GetAsyncKeyState(VK_MENU) < 0)
|
|
DPF(4, "ALT key is DOWN");
|
|
|
|
if (GetKeyState(VK_MENU) < 0)
|
|
DPF(4, "we think the ALT key is DOWN");
|
|
#endif DEBUG
|
|
|
|
if (GetAsyncKeyState(VK_MENU) < 0)
|
|
{
|
|
g_WindowInfo.dwFlags |= WININFO_IGNORENEXTALTTAB;
|
|
DPF(4, "AHHHHHHH Setting to ignore next alt tab");
|
|
}
|
|
else
|
|
{
|
|
g_WindowInfo.dwFlags &= ~WININFO_IGNORENEXTALTTAB;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* In the multi-mon scenario, it's possible that multiple
|
|
* devices are using this same window, so we need to do
|
|
* the following for each device.
|
|
*/
|
|
g_WindowInfo.dwDDFlags &= ~(DDRAWILCL_ACTIVEYES|DDRAWILCL_ACTIVENO);
|
|
if (is_active)
|
|
{
|
|
g_WindowInfo.dwDDFlags |= DDRAWILCL_ACTIVEYES;
|
|
}
|
|
else
|
|
{
|
|
g_WindowInfo.dwDDFlags |= DDRAWILCL_ACTIVENO;
|
|
}
|
|
}
|
|
#ifdef DEBUG
|
|
if (is_active)
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: DONE Activating app pid=%08lx, tid=%08lx",
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
}
|
|
else
|
|
{
|
|
DPF(4, "WM_ACTIVATEAPP: DONE Deactivating app pid=%08lx, tid=%08lx",
|
|
GetCurrentProcessId(), GetCurrentThreadId());
|
|
}
|
|
#endif
|
|
|
|
rc = CallWindowProc(proc, hWnd, uMsg, wParam, lParam);
|
|
|
|
// clear the WININFO_INACTIVATEAPP bit, but make sure to make sure
|
|
// we are still hooked!
|
|
if (g_WindowInfo.hWnd == hWnd)
|
|
{
|
|
g_WindowInfo.dwFlags &= ~WININFO_INACTIVATEAPP;
|
|
}
|
|
return rc;
|
|
|
|
break;
|
|
}
|
|
rc = CallWindowProc(proc, hWnd, uMsg, wParam, lParam);
|
|
return rc;
|
|
|
|
} /* WindowProc */
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::SetAppHWnd"
|
|
|
|
/*
|
|
* SetAppHWnd
|
|
*
|
|
* Set the WindowList struct up with the app's hwnd info
|
|
* Must be called with Device crit-sec taken and with the
|
|
* Global Exclusive Mode Mutex
|
|
*/
|
|
HRESULT
|
|
CSwapChain::SetAppHWnd()
|
|
{
|
|
|
|
HWND hWnd, hEnumWnd;
|
|
|
|
if (m_PresentationData.Windowed)
|
|
hWnd = NULL;
|
|
else
|
|
hWnd = Device()->FocusWindow();
|
|
|
|
hEnumWnd = Device()->Enum()->ExclusiveOwnerWindow();
|
|
if (hEnumWnd)
|
|
{
|
|
if (hEnumWnd == Device()->FocusWindow())
|
|
{
|
|
if (m_PresentationData.Windowed)
|
|
{
|
|
Device()->Enum()->SetFullScreenDevice(
|
|
Device()->AdapterIndex(), NULL);
|
|
|
|
// If our enum still has a focus-
|
|
// window then that means another
|
|
// device has gone FS with the same
|
|
// focus-window; so do nothing
|
|
if (Device()->Enum()->ExclusiveOwnerWindow())
|
|
return DD_OK;
|
|
|
|
// Else, fall through so that
|
|
// we tear down the winproc.
|
|
}
|
|
else
|
|
{
|
|
Device()->Enum()->SetFullScreenDevice(
|
|
Device()->AdapterIndex(), Device());
|
|
// Already hooked - no need to do more
|
|
return DD_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* check if this isn't doing anything
|
|
*/
|
|
if (hWnd == NULL && g_WindowInfo.hWnd == NULL)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
// Check if we have a case of different HWND trying to be hooked
|
|
if (hWnd && g_WindowInfo.hWnd && g_WindowInfo.hWnd != hWnd)
|
|
{
|
|
DPF(1, "Hwnd %08lx no good: Different Hwnd (%08lx) already set for Device",
|
|
hWnd, g_WindowInfo.hWnd);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
/*
|
|
* are we shutting an HWND down?
|
|
*/
|
|
if (hWnd == NULL)
|
|
{
|
|
if (IsWindow(g_WindowInfo.hWnd))
|
|
{
|
|
WNDPROC proc;
|
|
|
|
proc = (WNDPROC) GetWindowLongPtr(g_WindowInfo.hWnd, GWLP_WNDPROC);
|
|
|
|
if (proc != (WNDPROC) WindowProc &&
|
|
proc != (WNDPROC) g_WindowInfo.lpWndProc)
|
|
{
|
|
DPF(3, "Window has been subclassed; cannot restore!");
|
|
g_WindowInfo.dwFlags |= WININFO_ZOMBIE;
|
|
}
|
|
else if (GetWindowThreadProcessId(g_WindowInfo.hWnd, NULL) !=
|
|
GetCurrentThreadId())
|
|
{
|
|
DPF(3, "intra-thread window unhook, letting window proc do it");
|
|
g_WindowInfo.dwFlags |= WININFO_UNHOOK;
|
|
g_WindowInfo.dwFlags |= WININFO_ZOMBIE;
|
|
PostMessage(g_WindowInfo.hWnd, WM_NULL, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
DPF(4, "Unsubclassing window %08lx", g_WindowInfo.hWnd);
|
|
SetWindowLongPtr(g_WindowInfo.hWnd, GWLP_WNDPROC,
|
|
(INT_PTR) g_WindowInfo.lpWndProc);
|
|
|
|
ZeroMemory(&g_WindowInfo, sizeof(g_WindowInfo));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ZeroMemory(&g_WindowInfo, sizeof(g_WindowInfo));
|
|
}
|
|
|
|
Device()->Enum()->SetFullScreenDevice(
|
|
Device()->AdapterIndex(), NULL);
|
|
}
|
|
/*
|
|
* changing or adding an hwnd then...
|
|
*/
|
|
else
|
|
{
|
|
/*
|
|
* brand new object...
|
|
*/
|
|
if (g_WindowInfo.dwMagic == 0)
|
|
{
|
|
g_WindowInfo.dwMagic = WININFO_MAGIC;
|
|
g_WindowInfo.hWnd = hWnd;
|
|
g_WindowInfo.lpWndProc = (WNDPROC) GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
|
|
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (INT_PTR) WindowProc);
|
|
}
|
|
|
|
g_WindowInfo.pEnum = Device()->Enum();
|
|
g_WindowInfo.dwFlags |= WININFO_DDRAWHOOKED;
|
|
|
|
// Sanity check
|
|
DXGASSERT(Device()->Enum()->ExclusiveOwnerWindow() == NULL);
|
|
|
|
Device()->Enum()->SetFullScreenDevice(
|
|
Device()->AdapterIndex(), Device());
|
|
DPF(4, "Subclassing window %08lx", g_WindowInfo.hWnd);
|
|
}
|
|
return S_OK;
|
|
|
|
} /* SetAppHWnd */
|
|
extern "C" void ResetUniqueness( HANDLE hDD );
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::DoneExclusiveMode"
|
|
/*
|
|
* DoneExclusiveMode
|
|
*/
|
|
void
|
|
CSwapChain::DoneExclusiveMode(BOOL bChangeWindow)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL bMinimize = TRUE;
|
|
DPF(4, "DoneExclusiveMode");
|
|
if (m_bExclusiveMode)
|
|
{
|
|
D3D8_SETMODEDATA SetModeData;
|
|
m_bExclusiveMode = FALSE;
|
|
DPF(4, "INACTIVE: %08lx: Restoring original mode (%dx%dx%dx%d)",
|
|
GetCurrentProcessId(), Device()->DesktopMode().Width,
|
|
Device()->DesktopMode().Height,Device()->DesktopMode().Format,
|
|
Device()->DesktopMode().RefreshRate);
|
|
SetModeData.hDD = Device()->GetHandle();
|
|
SetModeData.dwWidth = Device()->DesktopMode().Width;
|
|
SetModeData.dwHeight = Device()->DesktopMode().Height;
|
|
SetModeData.Format = Device()->DesktopMode().Format;
|
|
SetModeData.dwRefreshRate = Device()->DesktopMode().RefreshRate;
|
|
SetModeData.bRestore = TRUE;
|
|
|
|
Device()->GetHalCallbacks()->SetMode(&SetModeData);
|
|
if (SetModeData.ddRVal != S_OK)
|
|
{
|
|
DPF_ERR("Unable to restore to original desktop mode");
|
|
// return SetModeData.ddRVal;
|
|
}
|
|
// some part of the runtime count on that SetMode cause device
|
|
// lost, that's not true for whistler anymore if this fullscreen
|
|
// mode happens to be the same as the original desktop mode.
|
|
// so we ResetUniqueness to force the device to get lost.
|
|
if (Device()->DesktopMode().Width == Width() &&
|
|
Device()->DesktopMode().Height == Height() &&
|
|
Device()->DesktopMode().Format == BackBufferFormat())
|
|
ResetUniqueness(Device()->GetHandle());
|
|
|
|
DPF(4, "Enabling error mode, hotkeys");
|
|
SetErrorMode(m_uiErrorMode);
|
|
|
|
#ifdef WINNT
|
|
// Restore cursor shadow coming out of fullscreen
|
|
SystemParametersInfo(SPI_SETCURSORSHADOW, 0, (LPVOID)m_pCursorShadow, 0);
|
|
#endif
|
|
|
|
// Restore reactive menus coming out of fullscreen:
|
|
SystemParametersInfo(SPI_SETHOTTRACKING, 0, (LPVOID)m_pHotTracking, 0);
|
|
InterlockedExchange(&m_lSetIME, m_lIMEState + 1);
|
|
|
|
#ifdef WINNT
|
|
// Notify the display driver that we are chaning cooperative level
|
|
|
|
D3D8_SETEXCLUSIVEMODEDATA ExclusiveData;
|
|
|
|
ExclusiveData.hDD = Device()->GetHandle();
|
|
ExclusiveData.dwEnterExcl = FALSE;
|
|
Device()->GetHalCallbacks()->SetExclusiveMode(&ExclusiveData);
|
|
/*
|
|
* If RestoreDisplayMode failed, we are probably on a different desktop. In this case,
|
|
* we should not minimize the window or else things won't work right when we switch
|
|
* back to the original desktop.
|
|
*/
|
|
if (SetModeData.ddRVal != S_OK)
|
|
{
|
|
HDESK hDesktop;
|
|
static BYTE szName1[256];
|
|
static BYTE szName2[256];
|
|
DWORD dwTemp;
|
|
|
|
// Get the name of the current desktop
|
|
hDesktop = OpenInputDesktop( 0, FALSE, DESKTOP_READOBJECTS );
|
|
GetUserObjectInformation( hDesktop, UOI_NAME, szName1, sizeof( szName1 ), &dwTemp );
|
|
CloseDesktop( hDesktop );
|
|
|
|
// Get the name of the apps' desktop
|
|
hDesktop = GetThreadDesktop( GetCurrentThreadId() );
|
|
GetUserObjectInformation( hDesktop, UOI_NAME, szName2, sizeof( szName2 ), &dwTemp );
|
|
if( lstrcmp( (const LPCSTR)szName1, (const LPCSTR)szName2 ) )
|
|
{
|
|
bMinimize = FALSE;
|
|
}
|
|
}
|
|
#endif
|
|
if (bChangeWindow)
|
|
{
|
|
HIDESHOW_IME();
|
|
/*
|
|
* minimize window if deactivating
|
|
*/
|
|
if (IsWindowVisible(m_PresentationData.hDeviceWindow) && bMinimize)
|
|
{
|
|
g_WindowInfo.dwFlags |= WININFO_SELFSIZE;
|
|
#ifdef USESHOWWINDOW
|
|
ShowWindow(m_PresentationData.hDeviceWindow, SW_SHOWMINNOACTIVE);
|
|
#else
|
|
SetWindowPos(m_PresentationData.hDeviceWindow, NULL, 0, 0, 0, 0,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
#endif
|
|
g_WindowInfo.dwFlags &= ~WININFO_SELFSIZE;
|
|
}
|
|
}
|
|
}
|
|
} /* DoneExclusiveMode */
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CSwapChain::StartExclusiveMode"
|
|
/*
|
|
* StartExclusiveMode
|
|
*/
|
|
void
|
|
CSwapChain::StartExclusiveMode(BOOL bChangeWindow)
|
|
{
|
|
DWORD dwWaitResult;
|
|
DPF(4, "StartExclusiveMode");
|
|
|
|
/*
|
|
* Preceeding code should have taken this mutex already.
|
|
*/
|
|
if (!m_bExclusiveMode)
|
|
{
|
|
m_bExclusiveMode = TRUE;
|
|
#if defined(WINNT) && defined(DEBUG)
|
|
dwWaitResult = WaitForSingleObject(hExclusiveModeMutex, 0);
|
|
DDASSERT(dwWaitResult == WAIT_OBJECT_0);
|
|
ReleaseMutex(hExclusiveModeMutex);
|
|
#endif
|
|
m_uiErrorMode = SetErrorMode(SEM_NOGPFAULTERRORBOX |
|
|
SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
|
|
|
|
#ifdef WINNT
|
|
// Save current cursor shadow setting
|
|
SystemParametersInfo(SPI_GETCURSORSHADOW, 0, (LPVOID) &(m_pCursorShadow), 0);
|
|
SystemParametersInfo(SPI_SETCURSORSHADOW, 0, 0, 0);
|
|
#endif
|
|
|
|
// Save current hot-tracking setting
|
|
SystemParametersInfo(SPI_GETHOTTRACKING, 0, (LPVOID) &(m_pHotTracking), 0);
|
|
SystemParametersInfo(SPI_GETSHOWIMEUI, 0, (LPVOID) &(m_lIMEState), 0);
|
|
|
|
//And turn it off as we go into exclusive mode
|
|
SystemParametersInfo(SPI_SETHOTTRACKING, 0, 0, 0);
|
|
InterlockedExchange(&m_lSetIME, FALSE + 1);
|
|
|
|
#ifdef WINNT
|
|
// Notify the display driver that we are chaning cooperative level
|
|
|
|
D3D8_SETEXCLUSIVEMODEDATA ExclusiveData;
|
|
|
|
ExclusiveData.hDD = Device()->GetHandle();
|
|
ExclusiveData.dwEnterExcl = TRUE;
|
|
Device()->GetHalCallbacks()->SetExclusiveMode(&ExclusiveData);
|
|
#endif
|
|
if (bChangeWindow)
|
|
{
|
|
MakeFullscreen();
|
|
HIDESHOW_IME();
|
|
if (IsWindowVisible(m_PresentationData.hDeviceWindow))
|
|
{
|
|
g_WindowInfo.dwFlags |= WININFO_SELFSIZE;
|
|
#ifdef USESHOWWINDOW
|
|
ShowWindow(m_PresentationData.hDeviceWindow, SW_SHOWNOACTIVATE);
|
|
#else
|
|
{
|
|
RECT rc;
|
|
SetRect(&rc,0,0,GetSystemMetrics(SM_CXSCREEN),GetSystemMetrics(SM_CYSCREEN));
|
|
SetWindowPos(g_WindowInfo.hWnd, NULL,rc.left, rc.top,
|
|
rc.right - rc.left,rc.bottom - rc.top,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
#endif
|
|
g_WindowInfo.dwFlags &= ~WININFO_SELFSIZE;
|
|
}
|
|
}
|
|
}
|
|
} /* StartExclusiveMode */
|
|
|
|
#endif //WINNT
|
|
// End of file : dwinproc.cpp
|