X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/16e4586527d89f78c665efbc218dc32f7e19c4ca..12bb29f5432174ecbd65549bda832d70d34a98ae:/src/msw/display.cpp diff --git a/src/msw/display.cpp b/src/msw/display.cpp index 69285f9f04..ae087f9cd9 100644 --- a/src/msw/display.cpp +++ b/src/msw/display.cpp @@ -35,13 +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" #include "wx/msw/private.h" +#include "wx/msw/private/hiddenwin.h" #ifndef __WXWINCE__ // Older versions of windef.h don't define HMONITOR. Unfortunately, we @@ -104,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) { } @@ -163,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 @@ -177,176 +141,164 @@ 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(); - - // delete all m_displays elements: can be called from the derived class - // dtor if it is important to do this before destroying it, - // 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; + // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor + // handles. + static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); } - // flag indicating whether gs_MonitorXXX functions are available - static int ms_supportsMultimon; +private: + // EnumDisplayMonitors() callback + static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor, + HDC hdcMonitor, + LPRECT lprcMonitor, + LPARAM dwData); - // the array containing information about all available displays, should be - // filled by the derived class ctors - wxDisplayInfoArray m_displays; + // find the monitor corresponding to the given handle, + // return wxNOT_FOUND if not found + int FindDisplayFromHMONITOR(HMONITOR hmon) const; + // Update m_displays array, used by RefreshMonitors(). + void DoRefreshMonitors(); - wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base); -}; -// ---------------------------------------------------------------------------- -// wxDisplay implementation using Windows multi-monitor support functions -// ---------------------------------------------------------------------------- + // 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; -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); + // the array containing information about all available displays, filled by + // MultimonEnumProc() + wxMonitorHandleArray m_displays; -private: - wxDECLARE_NO_COPY_CLASS(wxDisplayImplMultimon); -}; - -class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base -{ -public: - wxDisplayFactoryMultimon(); - - virtual wxDisplayImpl *CreateDisplay(unsigned n); - -private: - // EnumDisplayMonitors() callback - static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor, - HDC hdcMonitor, - LPRECT lprcMonitor, - LPARAM dwData); + // The hidden window we use for receiving WM_SETTINGCHANGE and its class + // name. + HWND m_hiddenHwnd; + const wxChar* m_hiddenClass; - // add a monitor description to m_displays array - void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor); + wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW); }; - -// ============================================================================ -// common classes implementation -// ============================================================================ +wxDisplayFactoryMSW* wxDisplayFactoryMSW::ms_factory = NULL; // ---------------------------------------------------------------------------- -// wxDisplay +// wxDisplay implementation // ---------------------------------------------------------------------------- /* static */ wxDisplayFactory *wxDisplay::CreateFactory() { - wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon; + wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW; 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(wxT("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; - return m_info.m_rect; + wxRect rect; + if ( GetMonInfo(monInfo) ) + wxCopyRECTToRect(monInfo.rcMonitor, 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; @@ -361,6 +313,7 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const DEVMODE dm; dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; + if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) ) { wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); @@ -373,152 +326,7 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const return mode; } -// ---------------------------------------------------------------------------- -// wxDisplayFactoryWin32Base -// ---------------------------------------------------------------------------- - -int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1; - -wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base() -{ - if ( ms_supportsMultimon == -1 ) - { - ms_supportsMultimon = 0; - - wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); - - if ( (wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay)) == NULL || - (wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay)) == NULL || - (wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay)) == NULL ) - return; - - ms_supportsMultimon = 1; - - // 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 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() - EnumDisplayMonitors_t pfnEnumDisplayMonitors; - { - wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); - if ( (wxDL_INIT_FUNC(pfn, EnumDisplayMonitors, dllDisplay)) == 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, wxT("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; @@ -533,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++ ) @@ -547,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; @@ -622,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, @@ -633,7 +442,7 @@ 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); @@ -656,4 +465,177 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) return false; } + +// ---------------------------------------------------------------------------- +// wxDisplayFactoryMSW implementation +// ---------------------------------------------------------------------------- + +LRESULT APIENTRY +wxDisplayWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + if ( msg == WM_SETTINGCHANGE ) + { + wxDisplayFactoryMSW::RefreshMonitors(); + + return 0; + } + + return ::DefWindowProc(hwnd, msg, wParam, lParam); +} + +wxDisplayFactoryMSW::wxDisplayFactoryMSW() +{ + // 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?") ); + + ms_factory = this; + + m_hiddenHwnd = NULL; + m_hiddenClass = NULL; + + if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL + || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL ) + { + // First initialization, or last initialization failed. + wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); + + 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); + + // we can safely let dllDisplay go out of scope, the DLL itself will + // still remain loaded as all programs link to it statically anyhow + } + + if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL + || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL ) + return; + + 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 + ); +} + +wxDisplayFactoryMSW::~wxDisplayFactoryMSW() +{ + if ( m_hiddenHwnd ) + { + if ( !::DestroyWindow(m_hiddenHwnd) ) + { + wxLogLastError(wxT("DestroyWindow(wxDisplayHiddenWindow)")); + } + + if ( m_hiddenClass ) + { + if ( !::UnregisterClass(m_hiddenClass, wxGetInstance()) ) + { + wxLogLastError(wxT("UnregisterClass(wxDisplayHiddenWindow)")); + } + } + } + + ms_factory = NULL; +} + +void wxDisplayFactoryMSW::DoRefreshMonitors() +{ + m_displays.Clear(); + + if ( !gs_EnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) ) + { + wxLogLastError(wxT("EnumDisplayMonitors")); + } +} + +/* 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) +{ + wxDisplayFactoryMSW *const self = (wxDisplayFactoryMSW *)dwData; + + self->m_displays.Add(hMonitor); + + // continue the enumeration + return TRUE; +} + +wxDisplayImpl *wxDisplayFactoryMSW::CreateDisplay(unsigned n) +{ + wxCHECK_MSG( n < m_displays.size(), NULL, wxT("An invalid index was passed to wxDisplay") ); + + return new wxDisplayMSW(n, m_displays[n]); +} + +// helper for GetFromPoint() and GetFromWindow() +int wxDisplayFactoryMSW::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] ) + return n; + } + } + + return wxNOT_FOUND; +} + +int wxDisplayFactoryMSW::GetFromPoint(const wxPoint& pt) +{ + POINT pt2; + pt2.x = pt.x; + pt2.y = pt.y; + + return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2, + MONITOR_DEFAULTTONULL)); +} + +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 +}