///////////////////////////////////////////////////////////////////////////// // Name: src/msw/display.cpp // Purpose: MSW Implementation of wxDisplay class // Author: Royce Mitchell III, Vadim Zeitlin // Modified by: Ryan Norton (IsPrimary override) // Created: 06/21/02 // Copyright: (c) wxWidgets team // Copyright: (c) 2002-2006 wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // =========================================================================== // declarations // =========================================================================== // --------------------------------------------------------------------------- // headers // --------------------------------------------------------------------------- // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ #pragma hdrstop #endif #if wxUSE_DISPLAY #include "wx/display.h" #ifndef WX_PRECOMP #include "wx/dynarray.h" #include "wx/app.h" #include "wx/frame.h" #endif #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 // can't directly test whether HMONITOR is defined or not in windef.h as // it's not a macro but a typedef, so we test for an unrelated symbol which // is only defined in winuser.h if WINVER >= 0x0500 #if !defined(HMONITOR_DECLARED) && !defined(MNS_NOCHECK) DECLARE_HANDLE(HMONITOR); typedef BOOL(CALLBACK * MONITORENUMPROC )(HMONITOR, HDC, LPRECT, LPARAM); typedef struct tagMONITORINFO { DWORD cbSize; RECT rcMonitor; RECT rcWork; DWORD dwFlags; } MONITORINFO, *LPMONITORINFO; typedef struct tagMONITORINFOEX : public tagMONITORINFO { TCHAR szDevice[CCHDEVICENAME]; } MONITORINFOEX, *LPMONITORINFOEX; #define MONITOR_DEFAULTTONULL 0x00000000 #define MONITOR_DEFAULTTOPRIMARY 0x00000001 #define MONITOR_DEFAULTTONEAREST 0x00000002 #define MONITORINFOF_PRIMARY 0x00000001 #define HMONITOR_DECLARED #endif #endif // !__WXWINCE__ // 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 // ---------------------------------------------------------------------------- typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwFlags, LPVOID lParam); typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM); typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD); typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD); typedef BOOL (WINAPI *GetMonitorInfo_t)(HMONITOR,LPMONITORINFO); #ifndef __WXWINCE__ // emulation of ChangeDisplaySettingsEx() for Win95 LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName), LPDEVMODE lpDevMode, HWND WXUNUSED(hwnd), DWORD dwFlags, LPVOID WXUNUSED(lParam)) { return ::ChangeDisplaySettings(lpDevMode, dwFlags); } #endif // !__WXWINCE__ // ---------------------------------------------------------------------------- // wxDisplayMSW declaration // ---------------------------------------------------------------------------- class wxDisplayMSW : public wxDisplayImpl { public: wxDisplayMSW(unsigned n, HMONITOR hmon) : wxDisplayImpl(n), m_hmon(hmon) { } virtual wxRect GetGeometry() const; virtual wxRect GetClientArea() const; virtual wxString GetName() const; 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 static wxVideoMode ConvertToVideoMode(const DEVMODE& dm) { // note that dmDisplayFrequency may be 0 or 1 meaning "standard one" // and although 0 is ok for us we don't want to return modes with 1hz // refresh return wxVideoMode(dm.dmPelsWidth, dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0); } // 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); }; // ---------------------------------------------------------------------------- // wxDisplayFactoryMSW declaration // ---------------------------------------------------------------------------- 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 wxDisplayFactoryMSW : public wxDisplayFactory { public: // 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); // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor // handles. static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); } private: // EnumDisplayMonitors() callback static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData); // 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(); // 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; // the array containing information about all available displays, filled by // MultimonEnumProc() wxMonitorHandleArray m_displays; // The hidden window we use for receiving WM_SETTINGCHANGE and its class // name. HWND m_hiddenHwnd; const wxChar* m_hiddenClass; wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW); }; wxDisplayFactoryMSW* wxDisplayFactoryMSW::ms_factory = NULL; // ---------------------------------------------------------------------------- // wxDisplay implementation // ---------------------------------------------------------------------------- /* static */ wxDisplayFactory *wxDisplay::CreateFactory() { wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW; if ( factoryMM->IsOk() ) return factoryMM; delete factoryMM; // fall back to a stub implementation if no multimon support (Win95?) return new wxDisplayFactorySingle; } // ---------------------------------------------------------------------------- // wxDisplayMSW implementation // ---------------------------------------------------------------------------- bool wxDisplayMSW::GetMonInfo(MONITORINFOEX& monInfo) const { if ( !gs_GetMonitorInfo(m_hmon, &monInfo) ) { wxLogLastError(wxT("GetMonitorInfo")); return false; } return true; } wxRect wxDisplayMSW::GetGeometry() const { WinStruct monInfo; wxRect rect; if ( GetMonInfo(monInfo) ) wxCopyRECTToRect(monInfo.rcMonitor, rect); return rect; } wxRect wxDisplayMSW::GetClientArea() const { WinStruct monInfo; wxRect rectClient; if ( GetMonInfo(monInfo) ) wxCopyRECTToRect(monInfo.rcWork, rectClient); return rectClient; } wxString wxDisplayMSW::GetName() const { WinStruct monInfo; wxString name; if ( GetMonInfo(monInfo) ) name = monInfo.szDevice; return name; } bool wxDisplayMSW::IsPrimary() const { WinStruct monInfo; if ( !GetMonInfo(monInfo) ) return false; return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0; } wxVideoMode wxDisplayMSW::GetCurrentMode() const { wxVideoMode mode; // The first parameter of EnumDisplaySettings() must be NULL under Win95 // according to MSDN. The version of GetName() we implement for Win95 // returns an empty string. const wxString name = GetName(); const wxChar * const deviceName = name.empty() ? (const wxChar*)NULL : (const wxChar*)name.c_str(); DEVMODE dm; dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) ) { wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); } else { mode = ConvertToVideoMode(dm); } return mode; } wxArrayVideoModes wxDisplayMSW::GetModes(const wxVideoMode& modeMatch) const { wxArrayVideoModes modes; // The first parameter of EnumDisplaySettings() must be NULL under Win95 // according to MSDN. The version of GetName() we implement for Win95 // returns an empty string. const wxString name = GetName(); const wxChar * const deviceName = name.empty() ? (const wxChar*)NULL : (const wxChar*)name.c_str(); DEVMODE dm; dm.dmSize = sizeof(dm); dm.dmDriverExtra = 0; for ( int iModeNum = 0; ::EnumDisplaySettings(deviceName, iModeNum, &dm); iModeNum++ ) { const wxVideoMode mode = ConvertToVideoMode(dm); if ( mode.Matches(modeMatch) ) { modes.Add(mode); } } return modes; } bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode) { // prepare ChangeDisplaySettingsEx() parameters DEVMODE dm; DEVMODE *pDevMode; int flags; if ( mode == wxDefaultVideoMode ) { // reset the video mode to default pDevMode = NULL; flags = 0; } else // change to the given mode { 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.GetWidth(); dm.dmPelsHeight = mode.GetHeight(); if ( mode.GetDepth() ) { dm.dmFields |= DM_BITSPERPEL; dm.dmBitsPerPel = mode.GetDepth(); } if ( mode.GetRefresh() ) { dm.dmFields |= DM_DISPLAYFREQUENCY; dm.dmDisplayFrequency = mode.GetRefresh(); } pDevMode = &dm; #ifdef __WXWINCE__ flags = 0; #else // !__WXWINCE__ flags = CDS_FULLSCREEN; #endif // __WXWINCE__/!__WXWINCE__ } // get pointer to the function dynamically // // we're only called from the main thread, so it's ok to use static // variable static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL; if ( !pfnChangeDisplaySettingsEx ) { wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); if ( dllDisplay.IsLoaded() ) { wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay); } //else: huh, no this DLL must always be present, what's going on?? #ifndef __WXWINCE__ if ( !pfnChangeDisplaySettingsEx ) { // we must be under Win95 and so there is no multiple monitors // support anyhow pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95; } #endif // !__WXWINCE__ } // do change the mode switch ( pfnChangeDisplaySettingsEx ( GetName().t_str(), // display name pDevMode, // dev mode or NULL to reset NULL, // reserved flags, NULL // pointer to video parameters (not used) ) ) { case DISP_CHANGE_SUCCESSFUL: // ok { // If we have a top-level, full-screen frame, emulate // 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.GetWidth(), current.GetHeight()); } } return true; case DISP_CHANGE_BADMODE: // don't complain about this, this is the only "expected" error break; default: wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") ); } 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 }