X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e2fc2bd51c2351f3cb7e289bb397efbb60b8cbc5..404b319a85dadd7decf7a5a5331020520031a41c:/src/msw/display.cpp diff --git a/src/msw/display.cpp b/src/msw/display.cpp index afa4b3ea5b..ae087f9cd9 100644 --- a/src/msw/display.cpp +++ b/src/msw/display.cpp @@ -35,20 +35,14 @@ #include "wx/frame.h" #endif -#include "wx/dynload.h" +#include "wx/dynlib.h" #include "wx/sysopt.h" #include "wx/display_impl.h" #include "wx/msw/wrapwin.h" #include "wx/msw/missing.h" - -// define this to use DirectDraw for display mode switching: this is disabled -// by default because ddraw.h is now always available and also it's not really -// clear what are the benefits of using DirectDraw compared to the standard API - -#if !defined(wxUSE_DIRECTDRAW) - #define wxUSE_DIRECTDRAW 0 -#endif +#include "wx/msw/private.h" +#include "wx/msw/private/hiddenwin.h" #ifndef __WXWINCE__ // Older versions of windef.h don't define HMONITOR. Unfortunately, we @@ -77,14 +71,12 @@ #endif #endif // !__WXWINCE__ -#if wxUSE_DIRECTDRAW - #include - - // we don't want to link with ddraw.lib which contains the real - // IID_IDirectDraw2 definition - const GUID wxIID_IDirectDraw2 = - { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } }; -#endif // wxUSE_DIRECTDRAW +// display functions are found in different DLLs under WinCE and normal Win32 +#ifdef __WXWINCE__ +static const wxChar displayDllName[] = wxT("coredll.dll"); +#else +static const wxChar displayDllName[] = wxT("user32.dll"); +#endif // ---------------------------------------------------------------------------- // typedefs for dynamically loaded Windows functions @@ -96,22 +88,6 @@ typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName, DWORD dwFlags, LPVOID lParam); -#if wxUSE_DIRECTDRAW -typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid, - LPTSTR driverDescription, - LPTSTR driverName, - LPVOID lpContext, - HMONITOR hmon); - -typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback, - LPVOID lpContext, - DWORD dwFlags); - -typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID, - LPDIRECTDRAW *lplpDD, - IUnknown *pUnkOuter); -#endif // wxUSE_DIRECTDRAW - typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM); typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD); typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD); @@ -129,56 +105,17 @@ LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName), } #endif // !__WXWINCE__ -// ---------------------------------------------------------------------------- -// display information classes -// ---------------------------------------------------------------------------- - -struct wxDisplayInfo -{ - wxDisplayInfo(HMONITOR hmon = NULL) - { - m_hmon = hmon; - m_flags = (DWORD)-1; - } - - virtual ~wxDisplayInfo() { } - - - // use GetMonitorInfo() to fill in all of our fields if needed (i.e. if it - // hadn't been done before) - void Initialize(); - - - // handle of this monitor used by MonitorXXX() functions, never NULL - HMONITOR m_hmon; - - // the entire area of this monitor in virtual screen coordinates - wxRect m_rect; - - // the work or client area, i.e. the area available for the normal windows - wxRect m_rectClient; - - // the display device name for this monitor, empty initially and retrieved - // on demand by DoGetName() - wxString m_devName; - - // the flags of this monitor, also used as initialization marker: if this - // is -1, GetMonitorInfo() hadn't been called yet - DWORD m_flags; -}; - -WX_DEFINE_ARRAY_PTR(wxDisplayInfo *, wxDisplayInfoArray); // ---------------------------------------------------------------------------- -// common base class for all Win32 wxDisplayImpl versions +// wxDisplayMSW declaration // ---------------------------------------------------------------------------- -class wxDisplayImplWin32Base : public wxDisplayImpl +class wxDisplayMSW : public wxDisplayImpl { public: - wxDisplayImplWin32Base(unsigned n, wxDisplayInfo& info) + wxDisplayMSW(unsigned n, HMONITOR hmon) : wxDisplayImpl(n), - m_info(info) + m_hmon(hmon) { } @@ -188,6 +125,8 @@ public: virtual bool IsPrimary() const; virtual wxVideoMode GetCurrentMode() const; + virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; + virtual bool ChangeMode(const wxVideoMode& mode); protected: // convert a DEVMODE to our wxVideoMode @@ -202,81 +141,51 @@ protected: dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0); } - wxDisplayInfo& m_info; + // Call GetMonitorInfo() and fill in the provided struct and return true if + // it succeeded, otherwise return false. + bool GetMonInfo(MONITORINFOEX& monInfo) const; + + HMONITOR m_hmon; + +private: + wxDECLARE_NO_COPY_CLASS(wxDisplayMSW); }; + // ---------------------------------------------------------------------------- -// common base class for all Win32 wxDisplayFactory versions +// wxDisplayFactoryMSW declaration // ---------------------------------------------------------------------------- -// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize() +WX_DEFINE_ARRAY(HMONITOR, wxMonitorHandleArray); + +// functions dynamically bound by wxDisplayFactoryMSW ctor. static MonitorFromPoint_t gs_MonitorFromPoint = NULL; static MonitorFromWindow_t gs_MonitorFromWindow = NULL; static GetMonitorInfo_t gs_GetMonitorInfo = NULL; +static EnumDisplayMonitors_t gs_EnumDisplayMonitors = NULL; -class wxDisplayFactoryWin32Base : public wxDisplayFactory +class wxDisplayFactoryMSW : public wxDisplayFactory { public: - virtual ~wxDisplayFactoryWin32Base(); + // ctor checks if the current system supports multimon API and dynamically + // bind the functions we need if this is the case and fills the + // m_displays array if they're available + wxDisplayFactoryMSW(); + + // Dtor destroys the hidden window we use for getting WM_SETTINGCHANGE. + virtual ~wxDisplayFactoryMSW(); bool IsOk() const { return !m_displays.empty(); } + virtual wxDisplayImpl *CreateDisplay(unsigned n); virtual unsigned GetCount() { return unsigned(m_displays.size()); } virtual int GetFromPoint(const wxPoint& pt); virtual int GetFromWindow(const wxWindow *window); -protected: - // ctor checks if the current system supports multimon API and dynamically - // bind the functions we need if this is the case and sets - // ms_supportsMultimon if they're available - wxDisplayFactoryWin32Base(); + // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor + // handles. + static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); } - // delete all m_displays elements: can be called from the derived class - // dtor if it is important to do this before destroying it (as in - // wxDisplayFactoryDirectDraw case), otherwise will be done by our dtor - void Clear(); - - // find the monitor corresponding to the given handle, return wxNOT_FOUND - // if not found - int FindDisplayFromHMONITOR(HMONITOR hmon) const; - - - // flag indicating whether gs_MonitorXXX functions are available - static int ms_supportsMultimon; - - // the array containing information about all available displays, should be - // filled by the derived class ctors - wxDisplayInfoArray m_displays; - - - DECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base) -}; - -// ---------------------------------------------------------------------------- -// wxDisplay implementation using Windows multi-monitor support functions -// ---------------------------------------------------------------------------- - -class wxDisplayImplMultimon : public wxDisplayImplWin32Base -{ -public: - wxDisplayImplMultimon(unsigned n, wxDisplayInfo& info) - : wxDisplayImplWin32Base(n, info) - { - } - - virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; - virtual bool ChangeMode(const wxVideoMode& mode); - -private: - DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon) -}; - -class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base -{ -public: - wxDisplayFactoryMultimon(); - - virtual wxDisplayImpl *CreateDisplay(unsigned n); private: // EnumDisplayMonitors() callback @@ -285,196 +194,111 @@ private: LPRECT lprcMonitor, LPARAM dwData); + // find the monitor corresponding to the given handle, + // return wxNOT_FOUND if not found + int FindDisplayFromHMONITOR(HMONITOR hmon) const; - // add a monitor description to m_displays array - void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor); -}; - -// ---------------------------------------------------------------------------- -// wxDisplay implementation using DirectDraw -// ---------------------------------------------------------------------------- - -#if wxUSE_DIRECTDRAW - -struct wxDisplayInfoDirectDraw : wxDisplayInfo -{ - wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name) - : wxDisplayInfo(hmon), - m_guid(guid) - { - m_pDD2 = NULL; - m_devName = name; - } - - virtual ~wxDisplayInfoDirectDraw() - { - if ( m_pDD2 ) - m_pDD2->Release(); - } - - - // IDirectDraw object used to control this display, may be NULL - IDirectDraw2 *m_pDD2; - - // DirectDraw GUID for this display, only valid when using DirectDraw - const GUID m_guid; - - - DECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw) -}; - -class wxDisplayImplDirectDraw : public wxDisplayImplWin32Base -{ -public: - wxDisplayImplDirectDraw(unsigned n, wxDisplayInfo& info, IDirectDraw2 *pDD2) - : wxDisplayImplWin32Base(n, info), - m_pDD2(pDD2) - { - m_pDD2->AddRef(); - } - - virtual ~wxDisplayImplDirectDraw() - { - m_pDD2->Release(); - } - - virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; - virtual bool ChangeMode(const wxVideoMode& mode); - -private: - IDirectDraw2 *m_pDD2; - - DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw) -}; - -class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base -{ -public: - wxDisplayFactoryDirectDraw(); - virtual ~wxDisplayFactoryDirectDraw(); - - virtual wxDisplayImpl *CreateDisplay(unsigned n); + // Update m_displays array, used by RefreshMonitors(). + void DoRefreshMonitors(); -private: - // callback used with DirectDrawEnumerateEx() - static BOOL WINAPI DDEnumExCallback(GUID *pGuid, - LPTSTR driverDescription, - LPTSTR driverName, - LPVOID lpContext, - HMONITOR hmon); - // add a monitor description to m_displays array - void AddDisplay(const GUID& guid, HMONITOR hmon, LPTSTR name); + // The unique factory being used (as we don't have direct access to the + // global factory pointer in the common code so we just duplicate this + // variable (also making it of correct type for us) here). + static wxDisplayFactoryMSW* ms_factory; - // ddraw.dll - wxDynamicLibrary m_dllDDraw; + // the array containing information about all available displays, filled by + // MultimonEnumProc() + wxMonitorHandleArray m_displays; - // dynamically resolved DirectDrawCreate() - DirectDrawCreate_t m_pfnDirectDrawCreate; + // The hidden window we use for receiving WM_SETTINGCHANGE and its class + // name. + HWND m_hiddenHwnd; + const wxChar* m_hiddenClass; - DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw) + wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW); }; -#endif // wxUSE_DIRECTDRAW - - -// ============================================================================ -// common classes implementation -// ============================================================================ +wxDisplayFactoryMSW* wxDisplayFactoryMSW::ms_factory = NULL; // ---------------------------------------------------------------------------- -// wxDisplay +// wxDisplay implementation // ---------------------------------------------------------------------------- /* static */ wxDisplayFactory *wxDisplay::CreateFactory() { - // we have 2 implementations for modern Windows: one using standard Win32 - // and another using DirectDraw, the choice between them is done using a - // system option + wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW; -#if wxUSE_DIRECTDRAW - if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) ) - { - wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw; - if ( factoryDD->IsOk() ) - return factoryDD; - - delete factoryDD; - } -#endif // wxUSE_DIRECTDRAW - - wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon; if ( factoryMM->IsOk() ) return factoryMM; delete factoryMM; - - // finally fall back to a stub implementation if all else failed (Win95?) + // fall back to a stub implementation if no multimon support (Win95?) return new wxDisplayFactorySingle; } + // ---------------------------------------------------------------------------- -// wxDisplayInfo +// wxDisplayMSW implementation // ---------------------------------------------------------------------------- -void wxDisplayInfo::Initialize() +bool wxDisplayMSW::GetMonInfo(MONITORINFOEX& monInfo) const { - if ( m_flags == (DWORD)-1 ) + if ( !gs_GetMonitorInfo(m_hmon, &monInfo) ) { - WinStruct monInfo; - if ( !gs_GetMonitorInfo(m_hmon, (LPMONITORINFO)&monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - m_flags = 0; - return; - } - - wxCopyRECTToRect(monInfo.rcMonitor, m_rect); - wxCopyRECTToRect(monInfo.rcWork, m_rectClient); - m_devName = monInfo.szDevice; - m_flags = monInfo.dwFlags; + wxLogLastError(wxT("GetMonitorInfo")); + return false; } -} -// ---------------------------------------------------------------------------- -// wxDisplayImplWin32Base -// ---------------------------------------------------------------------------- + return true; +} -wxRect wxDisplayImplWin32Base::GetGeometry() const +wxRect wxDisplayMSW::GetGeometry() const { - if ( m_info.m_rect.IsEmpty() ) - m_info.Initialize(); + WinStruct monInfo; + + wxRect rect; + if ( GetMonInfo(monInfo) ) + wxCopyRECTToRect(monInfo.rcMonitor, rect); - return m_info.m_rect; + return rect; } -wxRect wxDisplayImplWin32Base::GetClientArea() const +wxRect wxDisplayMSW::GetClientArea() const { - if ( m_info.m_rectClient.IsEmpty() ) - m_info.Initialize(); + WinStruct monInfo; + + wxRect rectClient; + if ( GetMonInfo(monInfo) ) + wxCopyRECTToRect(monInfo.rcWork, rectClient); - return m_info.m_rectClient; + return rectClient; } -wxString wxDisplayImplWin32Base::GetName() const +wxString wxDisplayMSW::GetName() const { - if ( m_info.m_devName.empty() ) - m_info.Initialize(); + WinStruct monInfo; - return m_info.m_devName; + wxString name; + if ( GetMonInfo(monInfo) ) + name = monInfo.szDevice; + + return name; } -bool wxDisplayImplWin32Base::IsPrimary() const +bool wxDisplayMSW::IsPrimary() const { - if ( m_info.m_flags == (DWORD)-1 ) - m_info.Initialize(); + WinStruct monInfo; + + if ( !GetMonInfo(monInfo) ) + return false; - return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0; + return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0; } -wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const +wxVideoMode wxDisplayMSW::GetCurrentMode() const { wxVideoMode mode; @@ -489,9 +313,10 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const DEVMODE dm; dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; + if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) ) { - wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); + wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); } else { @@ -501,153 +326,7 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const return mode; } -// ---------------------------------------------------------------------------- -// wxDisplayFactoryWin32Base -// ---------------------------------------------------------------------------- - -int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1; - -wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base() -{ - if ( ms_supportsMultimon == -1 ) - { - ms_supportsMultimon = 0; - - wxDynamicLibrary dllUser32(_T("user32.dll"), wxDL_VERBATIM | wxDL_QUIET); - - if ( (wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllUser32)) == NULL || - (wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllUser32)) == NULL || - (wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllUser32)) == NULL ) - return; - - ms_supportsMultimon = 1; - - // we can safely let dllUser32 go out of scope, the DLL itself will - // still remain loaded as all Win32 programs use it - } -} - -void wxDisplayFactoryWin32Base::Clear() -{ - WX_CLEAR_ARRAY(m_displays); -} - -wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base() -{ - Clear(); -} - -// helper for GetFromPoint() and GetFromWindow() -int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const -{ - if ( hmon ) - { - const size_t count = m_displays.size(); - for ( size_t n = 0; n < count; n++ ) - { - if ( hmon == m_displays[n]->m_hmon ) - return n; - } - } - - return wxNOT_FOUND; -} - -int wxDisplayFactoryWin32Base::GetFromPoint(const wxPoint& pt) -{ - POINT pt2; - pt2.x = pt.x; - pt2.y = pt.y; - - return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2, - MONITOR_DEFAULTTONULL)); -} - -int wxDisplayFactoryWin32Base::GetFromWindow(const wxWindow *window) -{ - return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window), - MONITOR_DEFAULTTONULL)); -} - -// ============================================================================ -// wxDisplay implementation using Win32 multimon API -// ============================================================================ - -// ---------------------------------------------------------------------------- -// wxDisplayFactoryMultimon initialization -// ---------------------------------------------------------------------------- - -wxDisplayFactoryMultimon::wxDisplayFactoryMultimon() -{ - if ( !ms_supportsMultimon ) - return; - - // look up EnumDisplayMonitors() which we don't need with DirectDraw - // implementation - EnumDisplayMonitors_t pfnEnumDisplayMonitors; - { - wxDynamicLibrary dllUser32(_T("user32.dll"), wxDL_VERBATIM | wxDL_QUIET); - if ( (wxDL_INIT_FUNC(pfn, EnumDisplayMonitors, dllUser32)) == NULL ) - return; - } - - // enumerate all displays - if ( !pfnEnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) ) - { - wxLogLastError(wxT("EnumDisplayMonitors")); - } -} - -/* static */ -BOOL CALLBACK -wxDisplayFactoryMultimon::MultimonEnumProc( - HMONITOR hMonitor, // handle to display monitor - HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context - LPRECT lprcMonitor, // pointer to monitor intersection rectangle - LPARAM dwData // data passed from EnumDisplayMonitors (this) -) -{ - wxDisplayFactoryMultimon *const self = (wxDisplayFactoryMultimon *)dwData; - self->AddDisplay(hMonitor, lprcMonitor); - - // continue the enumeration - return TRUE; -} - -// ---------------------------------------------------------------------------- -// wxDisplayFactoryMultimon helper functions -// ---------------------------------------------------------------------------- - -void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor) -{ - wxDisplayInfo *info = new wxDisplayInfo(hMonitor); - - // we also store the display geometry - info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top, - lprcMonitor->right - lprcMonitor->left, - lprcMonitor->bottom - lprcMonitor->top); - - // now add this monitor to the array - m_displays.Add(info); -} - -// ---------------------------------------------------------------------------- -// wxDisplayFactoryMultimon inherited pure virtuals implementation -// ---------------------------------------------------------------------------- - -wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(unsigned n) -{ - wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") ); - - return new wxDisplayImplMultimon(n, *(m_displays[n])); -} - -// ---------------------------------------------------------------------------- -// wxDisplayImplMultimon implementation -// ---------------------------------------------------------------------------- - -wxArrayVideoModes -wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const +wxArrayVideoModes wxDisplayMSW::GetModes(const wxVideoMode& modeMatch) const { wxArrayVideoModes modes; @@ -662,6 +341,7 @@ wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const DEVMODE dm; dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; + for ( int iModeNum = 0; ::EnumDisplaySettings(deviceName, iModeNum, &dm); iModeNum++ ) @@ -676,7 +356,7 @@ wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const return modes; } -bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) +bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode) { // prepare ChangeDisplaySettingsEx() parameters DEVMODE dm; @@ -692,26 +372,26 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) } else // change to the given mode { - wxCHECK_MSG( mode.w && mode.h, false, - _T("at least the width and height must be specified") ); + wxCHECK_MSG( mode.GetWidth() && mode.GetHeight(), false, + wxT("at least the width and height must be specified") ); wxZeroMemory(dm); dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT; - dm.dmPelsWidth = mode.w; - dm.dmPelsHeight = mode.h; + dm.dmPelsWidth = mode.GetWidth(); + dm.dmPelsHeight = mode.GetHeight(); - if ( mode.bpp ) + if ( mode.GetDepth() ) { dm.dmFields |= DM_BITSPERPEL; - dm.dmBitsPerPel = mode.bpp; + dm.dmBitsPerPel = mode.GetDepth(); } - if ( mode.refresh ) + if ( mode.GetRefresh() ) { dm.dmFields |= DM_DISPLAYFREQUENCY; - dm.dmDisplayFrequency = mode.refresh; + dm.dmDisplayFrequency = mode.GetRefresh(); } pDevMode = &dm; @@ -731,12 +411,12 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL; if ( !pfnChangeDisplaySettingsEx ) { - wxDynamicLibrary dllUser32(_T("user32.dll"), wxDL_VERBATIM | wxDL_QUIET); - if ( dllUser32.IsLoaded() ) + wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); + if ( dllDisplay.IsLoaded() ) { - wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllUser32); + wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay); } - //else: huh, no user32.dll?? + //else: huh, no this DLL must always be present, what's going on?? #ifndef __WXWINCE__ if ( !pfnChangeDisplaySettingsEx ) @@ -751,7 +431,7 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) // do change the mode switch ( pfnChangeDisplaySettingsEx ( - GetName().wx_str(), // display name + GetName().t_str(), // display name pDevMode, // dev mode or NULL to reset NULL, // reserved flags, @@ -762,14 +442,14 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) // ok { // If we have a top-level, full-screen frame, emulate - // the DirectX behavior and resize it. This makes this + // the DirectX behaviour and resize it. This makes this // API quite a bit easier to use. wxWindow *winTop = wxTheApp->GetTopWindow(); wxFrame *frameTop = wxDynamicCast(winTop, wxFrame); if (frameTop && frameTop->IsFullScreen()) { wxVideoMode current = GetCurrentMode(); - frameTop->SetClientSize(current.w, current.h); + frameTop->SetClientSize(current.GetWidth(), current.GetHeight()); } } return true; @@ -779,241 +459,183 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) break; default: - wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") ); + wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") ); } return false; } -// ============================================================================ -// DirectDraw-based wxDisplay implementation -// ============================================================================ - -#if wxUSE_DIRECTDRAW - // ---------------------------------------------------------------------------- -// wxDisplayFactoryDirectDraw initialization +// wxDisplayFactoryMSW implementation // ---------------------------------------------------------------------------- -wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw() +LRESULT APIENTRY +wxDisplayWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { - if ( !ms_supportsMultimon ) - return; - - m_dllDDraw.Load(_T("ddraw.dll"), wxDL_VERBATIM | wxDL_QUIET); - - if ( !m_dllDDraw.IsLoaded() ) - return; - - DirectDrawEnumerateEx_t - wxDL_INIT_FUNC_AW(pfn, DirectDrawEnumerateEx, m_dllDDraw); - if ( !pfnDirectDrawEnumerateEx ) - return; - - // we can't continue without DirectDrawCreate() later, so resolve it right - // now and fail the initialization if it's not available - if ( !wxDL_INIT_FUNC(m_pfn, DirectDrawCreate, m_dllDDraw) ) - return; - - if ( (*pfnDirectDrawEnumerateEx)(DDEnumExCallback, - this, - DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK ) + if ( msg == WM_SETTINGCHANGE ) { - wxLogLastError(_T("DirectDrawEnumerateEx")); + wxDisplayFactoryMSW::RefreshMonitors(); + + return 0; } + + return ::DefWindowProc(hwnd, msg, wParam, lParam); } -wxDisplayFactoryDirectDraw::~wxDisplayFactoryDirectDraw() +wxDisplayFactoryMSW::wxDisplayFactoryMSW() { - // we must clear m_displays now, before m_dllDDraw is unloaded as otherwise - // calling m_pDD2->Release() later would crash - Clear(); -} + // This is not supposed to happen with the current code, the factory is + // implicitly a singleton. + wxASSERT_MSG( !ms_factory, wxS("Using more than one factory?") ); -// ---------------------------------------------------------------------------- -// callbacks for monitor/modes enumeration stuff -// ---------------------------------------------------------------------------- + ms_factory = this; -BOOL WINAPI -wxDisplayFactoryDirectDraw::DDEnumExCallback(GUID *pGuid, - LPTSTR WXUNUSED(driverDescription), - LPTSTR driverName, - LPVOID lpContext, - HMONITOR hmon) -{ - if ( pGuid ) + m_hiddenHwnd = NULL; + m_hiddenClass = NULL; + + if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL + || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL ) { - wxDisplayFactoryDirectDraw * self = - wx_static_cast(wxDisplayFactoryDirectDraw *, lpContext); - self->AddDisplay(*pGuid, hmon, driverName); - } - //else: we're called for the primary monitor, skip it + // First initialization, or last initialization failed. + wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); - // continue the enumeration - return TRUE; -} + wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay); + wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay); + wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay); + wxDL_INIT_FUNC(gs_, EnumDisplayMonitors, dllDisplay); -// ---------------------------------------------------------------------------- -// wxDisplayFactoryDirectDraw helpers -// ---------------------------------------------------------------------------- + // we can safely let dllDisplay go out of scope, the DLL itself will + // still remain loaded as all programs link to it statically anyhow + } -void wxDisplayFactoryDirectDraw::AddDisplay(const GUID& guid, - HMONITOR hmon, - LPTSTR name) -{ - m_displays.Add(new wxDisplayInfoDirectDraw(guid, hmon, name)); -} + if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL + || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL ) + return; -// ---------------------------------------------------------------------------- -// wxDisplayFactoryDirectDraw inherited pure virtuals implementation -// ---------------------------------------------------------------------------- + DoRefreshMonitors(); + + // Also create a hidden window to listen for WM_SETTINGCHANGE that we + // receive when a monitor is added to or removed from the system as we must + // refresh our monitor handles information then. + m_hiddenHwnd = wxCreateHiddenWindow + ( + &m_hiddenClass, + wxT("wxDisplayHiddenWindow"), + wxDisplayWndProc + ); +} -wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(unsigned n) +wxDisplayFactoryMSW::~wxDisplayFactoryMSW() { - wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") ); - - wxDisplayInfoDirectDraw * - info = wx_static_cast(wxDisplayInfoDirectDraw *, m_displays[n]); - - if ( !info->m_pDD2 ) + if ( m_hiddenHwnd ) { - IDirectDraw *pDD; - GUID guid(info->m_guid); - HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL); - - if ( FAILED(hr) || !pDD ) + if ( !::DestroyWindow(m_hiddenHwnd) ) { - // what to do?? - wxLogApiError(_T("DirectDrawCreate"), hr); - return NULL; + wxLogLastError(wxT("DestroyWindow(wxDisplayHiddenWindow)")); } - // we got IDirectDraw, but we need IDirectDraw2 - hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2); - pDD->Release(); - - if ( FAILED(hr) || !info->m_pDD2 ) + if ( m_hiddenClass ) { - wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr); - return NULL; + if ( !::UnregisterClass(m_hiddenClass, wxGetInstance()) ) + { + wxLogLastError(wxT("UnregisterClass(wxDisplayHiddenWindow)")); + } } - - // NB: m_pDD2 will now be only destroyed when m_displays is destroyed - // which is ok as we don't want to recreate DD objects all the time } - //else: DirectDraw object corresponding to our display already exists - return new wxDisplayImplDirectDraw(n, *info, info->m_pDD2); + ms_factory = NULL; } -// ============================================================================ -// wxDisplayImplDirectDraw -// ============================================================================ - -// ---------------------------------------------------------------------------- -// video modes enumeration -// ---------------------------------------------------------------------------- - -// tiny helper class used to pass information from GetModes() to -// wxDDEnumModesCallback -class wxDDVideoModesAdder +void wxDisplayFactoryMSW::DoRefreshMonitors() { -public: - // our Add() method will add modes matching modeMatch to modes array - wxDDVideoModesAdder(wxArrayVideoModes& modes, const wxVideoMode& modeMatch) - : m_modes(modes), - m_modeMatch(modeMatch) - { - } + m_displays.Clear(); - void Add(const wxVideoMode& mode) + if ( !gs_EnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) ) { - if ( mode.Matches(m_modeMatch) ) - m_modes.Add(mode); + wxLogLastError(wxT("EnumDisplayMonitors")); } +} -private: - wxArrayVideoModes& m_modes; - const wxVideoMode& m_modeMatch; - - DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder) -}; - -HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc, - LPVOID lpContext) +/* static */ +BOOL CALLBACK +wxDisplayFactoryMSW::MultimonEnumProc( + HMONITOR hMonitor, // handle to display monitor + HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context + LPRECT WXUNUSED(lprcMonitor), // pointer to monitor intersection rectangle + LPARAM dwData) // data passed from EnumDisplayMonitors (this) { - // we need at least the mode size - static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH; - if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED ) - { - wxDDVideoModesAdder * const vmodes = - wx_static_cast(wxDDVideoModesAdder *, lpContext); + wxDisplayFactoryMSW *const self = (wxDisplayFactoryMSW *)dwData; - vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth, - lpDDSurfaceDesc->dwHeight, - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, - lpDDSurfaceDesc->dwRefreshRate)); - } + self->m_displays.Add(hMonitor); // continue the enumeration - return DDENUMRET_OK; + return TRUE; } -wxArrayVideoModes -wxDisplayImplDirectDraw::GetModes(const wxVideoMode& modeMatch) const +wxDisplayImpl *wxDisplayFactoryMSW::CreateDisplay(unsigned n) { - wxArrayVideoModes modes; - wxDDVideoModesAdder modesAdder(modes, modeMatch); - - HRESULT hr = m_pDD2->EnumDisplayModes - ( - DDEDM_REFRESHRATES, - NULL, // all modes - &modesAdder, // callback parameter - wxDDEnumModesCallback - ); - - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr); - } + wxCHECK_MSG( n < m_displays.size(), NULL, wxT("An invalid index was passed to wxDisplay") ); - return modes; + return new wxDisplayMSW(n, m_displays[n]); } -// ---------------------------------------------------------------------------- -// video mode switching -// ---------------------------------------------------------------------------- - -bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode) +// helper for GetFromPoint() and GetFromWindow() +int wxDisplayFactoryMSW::FindDisplayFromHMONITOR(HMONITOR hmon) const { - wxWindow *winTop = wxTheApp->GetTopWindow(); - wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") ); - - HRESULT hr = m_pDD2->SetCooperativeLevel - ( - GetHwndOf(winTop), - DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN - ); - if ( FAILED(hr) ) + if ( hmon ) { - wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr); - - return false; + const size_t count = m_displays.size(); + for ( size_t n = 0; n < count; n++ ) + { + if ( hmon == m_displays[n] ) + return n; + } } - hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0); - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr); + return wxNOT_FOUND; +} - return false; - } +int wxDisplayFactoryMSW::GetFromPoint(const wxPoint& pt) +{ + POINT pt2; + pt2.x = pt.x; + pt2.y = pt.y; - return true; + return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2, + MONITOR_DEFAULTTONULL)); } -#endif // wxUSE_DIRECTDRAW +int wxDisplayFactoryMSW::GetFromWindow(const wxWindow *window) +{ +#ifdef __WXMSW__ + return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window), + MONITOR_DEFAULTTONULL)); +#else + const wxSize halfsize = window->GetSize() / 2; + wxPoint pt = window->GetScreenPosition(); + pt.x += halfsize.x; + pt.y += halfsize.y; + return GetFromPoint(pt); +#endif +} #endif // wxUSE_DISPLAY + +void wxClientDisplayRect(int *x, int *y, int *width, int *height) +{ +#if defined(__WXMICROWIN__) + *x = 0; *y = 0; + wxDisplaySize(width, height); +#else + // Determine the desktop dimensions minus the taskbar and any other + // special decorations... + RECT r; + + SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0); + if (x) *x = r.left; + if (y) *y = r.top; + if (width) *width = r.right - r.left; + if (height) *height = r.bottom - r.top; +#endif +}