X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/61373fa8f36822fb88b81668df4c26d246bf5cf5..f0e5d5d22ce012e9312a63175d79c0f4a8d444be:/src/msw/display.cpp diff --git a/src/msw/display.cpp b/src/msw/display.cpp index 6c14cf0977..b7abb30192 100644 --- a/src/msw/display.cpp +++ b/src/msw/display.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// // Name: src/msw/display.cpp // Purpose: MSW Implementation of wxDisplay class -// Author: Royce Mitchell III -// Modified by: VZ (resolutions enumeration/change support, DirectDraw, ...) -// Ryan Norton (IsPrimary override) +// Author: Royce Mitchell III, Vadim Zeitlin +// Modified by: Ryan Norton (IsPrimary override) // Created: 06/21/02 // RCS-ID: $Id$ // Copyright: (c) wxWidgets team +// Copyright: (c) 2002-2006 wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -27,23 +27,21 @@ #if wxUSE_DISPLAY +#include "wx/display.h" + #ifndef WX_PRECOMP - #include "wx/app.h" - #include "wx/dynarray.h" - #include "wx/frame.h" + #include "wx/dynarray.h" + #include "wx/app.h" + #include "wx/frame.h" #endif #include "wx/dynload.h" +#include "wx/sysopt.h" -#include "wx/display.h" - -// Mingw's w32api headers don't include ddraw.h, though the user may have -// installed it. If using configure, we actually probe for ddraw.h there -// and set HAVE_DDRAW_H. Otherwise, assume we don't have it if using -// the w32api headers, and that we do otherwise. -#if !defined HAVE_W32API_H && !defined HAVE_DDRAW_H -#define HAVE_DDRAW_H 1 -#endif +#include "wx/display_impl.h" +#include "wx/msw/wrapwin.h" +#include "wx/msw/missing.h" +#include "wx/msw/private.h" #ifndef __WXWINCE__ // Older versions of windef.h don't define HMONITOR. Unfortunately, we @@ -52,27 +50,31 @@ // 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__ -#ifdef HAVE_DDRAW_H -#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 - -// ---------------------------------------------------------------------------- -// macros -// ---------------------------------------------------------------------------- - -#ifdef _UNICODE - #define WINFUNC(x) _T(#x) L"W" +// display functions are found in different DLLs under WinCE and normal Win32 +#ifdef __WXWINCE__ +static const wxChar displayDllName[] = wxT("coredll.dll"); #else - #define WINFUNC(x) #x "A" +static const wxChar displayDllName[] = wxT("user32.dll"); #endif // ---------------------------------------------------------------------------- @@ -85,311 +87,11 @@ typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName, DWORD dwFlags, LPVOID lParam); -#ifdef HAVE_DDRAW_H -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 - 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); -static EnumDisplayMonitors_t gs_EnumDisplayMonitors = NULL; -static MonitorFromPoint_t gs_MonitorFromPoint = NULL; -static MonitorFromWindow_t gs_MonitorFromWindow = NULL; -static GetMonitorInfo_t gs_GetMonitorInfo = NULL; - -// ---------------------------------------------------------------------------- -// private classes -// ---------------------------------------------------------------------------- - -class wxDisplayInfo -{ -public: - // handle of this monitor used by MonitorXXX() functions, never NULL - HMONITOR m_hmon; - - // IDirectDraw object used to control this display, may be NULL -#ifdef HAVE_DDRAW_H - IDirectDraw2 *m_pDD2; -#else - void *m_pDD2; -#endif - - // DirectDraw GUID for this display, only valid when using DirectDraw - GUID m_guid; - - // the entire area of this monitor in virtual screen coordinates - wxRect m_rect; - - // the display device name for this monitor, empty initially and retrieved - // on demand by DoGetName() - wxString m_devName; - - wxDisplayInfo() { m_hmon = NULL; m_pDD2 = NULL; } - ~wxDisplayInfo() { -#ifdef HAVE_DDRAW_H - if ( m_pDD2 ) m_pDD2->Release(); -#endif - } -}; - -WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray); -#include "wx/arrimpl.cpp" -WX_DEFINE_OBJARRAY(wxDisplayInfoArray); - -// this module is used to cleanup gs_displays array -class wxDisplayModule : public wxModule -{ -public: - virtual bool OnInit() { return true; } - virtual void OnExit(); - - DECLARE_DYNAMIC_CLASS(wxDisplayModule) -}; - -IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule) - -// ---------------------------------------------------------------------------- -// globals -// ---------------------------------------------------------------------------- - -#ifdef HAVE_DDRAW_H -// do we use DirectX? -static bool gs_useDirectX = false; -#endif - -// Try to look up the functions needed for supporting multiple monitors. If -// they aren't available (probably because we're running on Win95 or NT4 which -// predate this API), set a flag which makes wxDisplay return results for a -// single screen. -static bool OsSupportsMultipleMonitors() -{ - static int isNewEnough = -1; - if ( isNewEnough == -1 ) - { - isNewEnough = 0; - wxDynamicLibrary dllUser32(_T("user32.dll")); - // Check for one of the symbols to avoid logging errors just because - // we happen to be running on Win95 or NT4. - if ( dllUser32.IsLoaded() && - dllUser32.HasSymbol(wxT("EnumDisplayMonitors")) ) - { - // GetMonitorInfo has Unicode/ANSI variants, the others don't. - gs_EnumDisplayMonitors = (EnumDisplayMonitors_t) - dllUser32.GetSymbol(wxT("EnumDisplayMonitors")); - gs_MonitorFromPoint = (MonitorFromPoint_t) - dllUser32.GetSymbol(wxT("MonitorFromPoint")); - gs_MonitorFromWindow = (MonitorFromWindow_t) - dllUser32.GetSymbol(wxT("MonitorFromWindow")); - gs_GetMonitorInfo = (GetMonitorInfo_t) - dllUser32.GetSymbol(WINFUNC(GetMonitorInfo)); - if ( gs_EnumDisplayMonitors != NULL && - gs_MonitorFromPoint != NULL && - gs_MonitorFromWindow != NULL && - gs_GetMonitorInfo != NULL ) - { - isNewEnough = 1; - } - } - } - return (isNewEnough != 0); -} - -#ifdef HAVE_DDRAW_H -// dynamically resolved DirectDrawCreate() -static DirectDrawCreate_t gs_DirectDrawCreate = NULL; -#endif - -// this is not really MT-unsafe as wxDisplay is only going to be used from the -// main thread, i.e. we consider that it's a GUI class and so don't protect it -static wxDisplayInfoArray *gs_displays = NULL; - -// =========================================================================== -// implementation -// =========================================================================== - -// ---------------------------------------------------------------------------- -// callbacks for monitor/modes enumeration stuff -// ---------------------------------------------------------------------------- - -static BOOL CALLBACK wxmswMonitorEnumProc ( - HMONITOR hMonitor, // handle to display monitor - HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context - LPRECT lprcMonitor, // pointer to monitor intersection rectangle - LPARAM WXUNUSED(dwData) // data passed from EnumDisplayMonitors (unused) -) -{ - wxDisplayInfo *info = new wxDisplayInfo(); - - // we need hMonitor to be able to map display id to it which is needed for - // MonitorXXX() functions, in particular MonitorFromPoint() - info->m_hmon = hMonitor; - - // we also store the display geometry - info->m_rect.SetX ( lprcMonitor->left ); - info->m_rect.SetY ( lprcMonitor->top ); - info->m_rect.SetWidth ( lprcMonitor->right - lprcMonitor->left ); - info->m_rect.SetHeight ( lprcMonitor->bottom - lprcMonitor->top ); - - // now add this monitor to the array - gs_displays->Add(info); - - // continue the enumeration - return true; -} - -#ifdef HAVE_DDRAW_H -BOOL PASCAL -wxDDEnumExCallback(GUID *pGuid, - LPTSTR WXUNUSED(driverDescription), - LPTSTR driverName, - LPVOID WXUNUSED(lpContext), - HMONITOR hmon) -{ - if ( pGuid ) - { - wxDisplayInfo *info = new wxDisplayInfo(); - - info->m_hmon = hmon; - info->m_guid = *pGuid; - info->m_devName = driverName; - - gs_displays->Add(info); - } - //else: we're called for the primary monitor, skip it - - // continue the enumeration - return true; -} - -HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc, - LPVOID lpContext) -{ - // we need at least the mode size - static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH; - if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED ) - { - wxArrayVideoModes * const modes = (wxArrayVideoModes *)lpContext; - - modes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth, - lpDDSurfaceDesc->dwHeight, - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, - lpDDSurfaceDesc->dwRefreshRate)); - } - - // continue the enumeration - return DDENUMRET_OK; -} -#endif - -// ---------------------------------------------------------------------------- -// local functions -// ---------------------------------------------------------------------------- - -#ifdef HAVE_DDRAW_H -// initialize gs_displays using DirectX functions -static bool DoInitDirectX() -{ -#if wxUSE_LOG - // suppress the errors if ddraw.dll is not found - wxLog::EnableLogging(false); -#endif - - wxDynamicLibrary dllDX(_T("ddraw.dll")); - -#if wxUSE_LOG - wxLog::EnableLogging(); -#endif - - if ( !dllDX.IsLoaded() ) - return false; - - DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t) - dllDX.GetSymbol(WINFUNC(DirectDrawEnumerateEx)); - if ( !pDDEnumEx ) - return false; - - // we'll also need DirectDrawCreate() later, resolve it right now - gs_DirectDrawCreate = (DirectDrawCreate_t) - dllDX.GetSymbol(_T("DirectDrawCreate")); - if ( !gs_DirectDrawCreate ) - return false; - - if ( (*pDDEnumEx)(wxDDEnumExCallback, - NULL, - DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK ) - { - return false; - } - - // ok, it seems like we're going to use DirectDraw and so we're going to - // need ddraw.dll all the time, don't unload it - dllDX.Detach(); - - return true; -} -#endif - -// initialize gs_displays using the standard Windows functions -static void DoInitStdWindows() -{ - // enumerate all displays - if ( !gs_EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) ) - { - wxLogLastError(wxT("EnumDisplayMonitors")); - - // TODO: still create at least one (valid) entry in gs_displays for the - // primary display! - } -} - -// this function must be called before accessing gs_displays array as it -// creates and initializes it -static void InitDisplays() -{ - if ( gs_displays ) - return; - - gs_displays = new wxDisplayInfoArray(); - -#ifdef HAVE_DDRAW_H - if ( !gs_useDirectX || !DoInitDirectX() ) - { - // either we were told not to try to use DirectX or fall back to std - // functions if DirectX method failed - gs_useDirectX = false; - - DoInitStdWindows(); - } -#else - DoInitStdWindows(); -#endif -} - -// convert a DEVMODE to our wxVideoMode -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); -} - #ifndef __WXWINCE__ // emulation of ChangeDisplaySettingsEx() for Win95 LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName), @@ -402,349 +104,176 @@ LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName), } #endif // !__WXWINCE__ + // ---------------------------------------------------------------------------- -// wxDisplayModule +// wxDisplayMSW declaration // ---------------------------------------------------------------------------- -void wxDisplayModule::OnExit() +class wxDisplayMSW : public wxDisplayImpl { - delete gs_displays; -} - -// --------------------------------------------------------------------------- -// wxDisplay -// --------------------------------------------------------------------------- +public: + wxDisplayMSW(unsigned n, HMONITOR hmon) + : wxDisplayImpl(n), + m_hmon(hmon) + { + } -/* static */ -void wxDisplay::UseDirectX(bool useDX) -{ - wxCHECK_RET( !gs_displays, _T("it is too late to call UseDirectX") ); + virtual wxRect GetGeometry() const; + virtual wxRect GetClientArea() const; + virtual wxString GetName() const; + virtual bool IsPrimary() const; -#ifdef HAVE_DDRAW_H - // DirectDrawEnumerateEx requires Win98 or Win2k anyway. - if ( OsSupportsMultipleMonitors() ) gs_useDirectX = useDX; -#else - wxUnusedVar(useDX); -#endif -} + virtual wxVideoMode GetCurrentMode() const; + virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; + virtual bool ChangeMode(const wxVideoMode& mode); -// helper for GetFromPoint() and GetFromWindow() -static int DisplayFromHMONITOR(HMONITOR hmon) -{ - if ( hmon ) +protected: + // convert a DEVMODE to our wxVideoMode + static wxVideoMode ConvertToVideoMode(const DEVMODE& dm) { - const size_t count = wxDisplay::GetCount(); - - for ( size_t n = 0; n < count; n++ ) - { - if ( hmon == (*gs_displays)[n].m_hmon ) - return n; - } + // 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); } - return wxNOT_FOUND; -} - -/* static */ -size_t wxDisplayBase::GetCount() -{ - if ( !OsSupportsMultipleMonitors() ) return 1; + // Call GetMonitorInfo() and fill in the provided struct and return true if + // it succeeded, otherwise return false. + bool GetMonInfo(MONITORINFOEX& monInfo) const; - InitDisplays(); + HMONITOR m_hmon; - //RN: FIXME: This is wrong - the display info array should reload after every call - //to GetCount() - otherwise it will not be accurate. - //The user can change the number of displays in display properties/settings - //after GetCount or similar is called and really mess this up... - //wxASSERT_MSG( gs_displays->GetCount() == (size_t)::GetSystemMetrics(SM_CMONITORS), - // _T("So how many displays does this system have?") ); +private: + wxDECLARE_NO_COPY_CLASS(wxDisplayMSW); +}; - return gs_displays->GetCount(); -} -/* static */ -int wxDisplayBase::GetFromPoint ( const wxPoint& pt ) -{ - if ( !OsSupportsMultipleMonitors() ) - { - const wxSize size = wxGetDisplaySize(); - if (pt.x >= 0 && pt.x < size.GetWidth() && - pt.y >= 0 && pt.y < size.GetHeight()) - { - return 0; - } - return wxNOT_FOUND; - } +// ---------------------------------------------------------------------------- +// wxDisplayFactoryMSW declaration +// ---------------------------------------------------------------------------- - POINT pt2; - pt2.x = pt.x; - pt2.y = pt.y; +WX_DEFINE_ARRAY(HMONITOR, wxMonitorHandleArray); - return DisplayFromHMONITOR(gs_MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL)); -} +// 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; -/* static */ -int wxDisplayBase::GetFromWindow(wxWindow *window) +class wxDisplayFactoryMSW : public wxDisplayFactory { - if ( !OsSupportsMultipleMonitors() ) - { - const wxRect r(window->GetRect()); - const wxSize size = wxGetDisplaySize(); - if (r.x < size.GetWidth() && r.x + r.width >= 0 && - r.y < size.GetHeight() && r.y + r.height >= 0) - { - return 0; - } - return wxNOT_FOUND; - } +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(); + + 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); + +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; + + // the array containing information about all available displays, filled by + // MultimonEnumProc() + wxMonitorHandleArray m_displays; + + wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW); +}; - return DisplayFromHMONITOR - ( - gs_MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL) - ); -} // ---------------------------------------------------------------------------- -// wxDisplay ctor/dtor +// wxDisplay implementation // ---------------------------------------------------------------------------- -wxDisplay::wxDisplay ( size_t n ) - : wxDisplayBase ( n ) +/* static */ wxDisplayFactory *wxDisplay::CreateFactory() { - if ( !OsSupportsMultipleMonitors() ) return; + wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW; - // if we do this in ctor we won't have to call it from all the member - // functions - InitDisplays(); + if ( factoryMM->IsOk() ) + return factoryMM; -#ifdef HAVE_DDRAW_H - if ( gs_useDirectX ) - { - wxDisplayInfo& dpyInfo = (*gs_displays)[n]; - - LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2; - if ( !pDD2 ) - { - if ( !gs_DirectDrawCreate ) - { - // what to do?? - return; - } - - IDirectDraw *pDD; - HRESULT hr = (*gs_DirectDrawCreate)(&dpyInfo.m_guid, &pDD, NULL); - - if ( FAILED(hr) || !pDD ) - { - // what to do?? - wxLogApiError(_T("DirectDrawCreate"), hr); - } - else // got IDirectDraw, we want IDirectDraw2 - { - hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&pDD2); - if ( FAILED(hr) || !pDD2 ) - { - wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr); - } + delete factoryMM; - pDD->Release(); - } - } - //else: DirectDraw object corresponding to our display already exists - - // increment its ref count to account for Release() in dtor - // - // NB: pDD2 will be only really Release()d when gs_displays is - // destroyed which is ok as we don't want to recreate DD objects - // all the time - pDD2->AddRef(); - } -#endif + // fall back to a stub implementation if no multimon support (Win95?) + return new wxDisplayFactorySingle; } -wxDisplay::~wxDisplay() -{ -#ifdef HAVE_DDRAW_H - if ( !OsSupportsMultipleMonitors() ) return; - - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; - - LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2; - if ( pDD2 ) - { - pDD2->Release(); - } -#endif -} // ---------------------------------------------------------------------------- -// wxDisplay simple accessors +// wxDisplayMSW implementation // ---------------------------------------------------------------------------- -bool wxDisplay::IsOk() const +bool wxDisplayMSW::GetMonInfo(MONITORINFOEX& monInfo) const { -#ifdef HAVE_DDRAW_H - return m_index < GetCount() && - (!gs_useDirectX || (*gs_displays)[m_index].m_pDD2); -#else - return m_index < GetCount(); -#endif -} - -wxRect wxDisplay::GetGeometry() const -{ - if ( !OsSupportsMultipleMonitors() ) + if ( !gs_GetMonitorInfo(m_hmon, &monInfo) ) { - wxSize size = wxGetDisplaySize(); - return wxRect(0, 0, size.GetWidth(), size.GetHeight()); - } - - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; - wxRect& rect = dpyInfo.m_rect; - if ( !rect.width ) - { - MONITORINFO monInfo; - wxZeroMemory(monInfo); - monInfo.cbSize = sizeof(monInfo); - - if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, &monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - } - else - { - wxCopyRECTToRect(monInfo.rcMonitor, rect); - } + wxLogLastError(wxT("GetMonitorInfo")); + return false; } - return rect; + return true; } -wxString wxDisplay::GetName() const +wxRect wxDisplayMSW::GetGeometry() const { - if ( !OsSupportsMultipleMonitors() ) return wxT(""); + WinStruct monInfo; - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; - if ( dpyInfo.m_devName.empty() ) - { - MONITORINFOEX monInfo; - wxZeroMemory(monInfo); - monInfo.cbSize = sizeof(monInfo); - - // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because - // Mingw headers - unlike the ones from Microsoft's Platform SDK - - // don't derive the former from the latter in C++ mode and so - // the pointer's type is not converted implicitly. - if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - } - else - { - dpyInfo.m_devName = monInfo.szDevice; - } - } + wxRect rect; + if ( GetMonInfo(monInfo) ) + wxCopyRECTToRect(monInfo.rcMonitor, rect); - return dpyInfo.m_devName; + return rect; } -// ---------------------------------------------------------------------------- -// determine if this is the primary display -// ---------------------------------------------------------------------------- - -bool wxDisplay::IsPrimary() const +wxRect wxDisplayMSW::GetClientArea() const { - if ( !OsSupportsMultipleMonitors() ) return true; + WinStruct monInfo; - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; + wxRect rectClient; + if ( GetMonInfo(monInfo) ) + wxCopyRECTToRect(monInfo.rcWork, rectClient); - MONITORINFOEX monInfo; - wxZeroMemory(monInfo); - monInfo.cbSize = sizeof(monInfo); - - // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because - // Mingw headers - unlike the ones from Microsoft's Platform SDK - - // don't derive the former from the latter in C++ mode and so - // the pointer's type is not converted implicitly. - if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - } - - return (monInfo.dwFlags & MONITORINFOF_PRIMARY) == MONITORINFOF_PRIMARY; + return rectClient; } -// ---------------------------------------------------------------------------- -// video modes enumeration -// ---------------------------------------------------------------------------- - -#ifdef HAVE_DDRAW_H -wxArrayVideoModes -wxDisplay::DoGetModesDirectX(const wxVideoMode& WXUNUSED(modeMatch)) const +wxString wxDisplayMSW::GetName() const { - wxArrayVideoModes modes; + WinStruct monInfo; - IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2; + wxString name; + if ( GetMonInfo(monInfo) ) + name = monInfo.szDevice; - if ( pDD ) - { - HRESULT hr = pDD->EnumDisplayModes - ( - DDEDM_REFRESHRATES, - NULL, // all modes (TODO: use modeMatch!) - &modes, // callback parameter - wxDDEnumModesCallback - ); - - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr); - } - } - - return modes; + return name; } -#endif -wxArrayVideoModes -wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const +bool wxDisplayMSW::IsPrimary() 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() ? NULL : 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); - } - } + WinStruct monInfo; - return modes; -} + if ( !GetMonInfo(monInfo) ) + return false; -wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const -{ -#ifdef HAVE_DDRAW_H - return gs_useDirectX ? DoGetModesDirectX(modeMatch) - : DoGetModesWindows(modeMatch); -#else - return DoGetModesWindows(modeMatch); -#endif + return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0; } -wxVideoMode wxDisplay::GetCurrentMode() const +wxVideoMode wxDisplayMSW::GetCurrentMode() const { wxVideoMode mode; @@ -752,14 +281,17 @@ wxVideoMode wxDisplay::GetCurrentMode() const // 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() ? NULL : name.c_str(); + 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(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); + wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); } else { @@ -769,46 +301,37 @@ wxVideoMode wxDisplay::GetCurrentMode() const return mode; } -// ---------------------------------------------------------------------------- -// video mode switching -// ---------------------------------------------------------------------------- - -#ifdef HAVE_DDRAW_H -bool wxDisplay::DoChangeModeDirectX(const wxVideoMode& mode) +wxArrayVideoModes wxDisplayMSW::GetModes(const wxVideoMode& modeMatch) const { - IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2; - if ( !pDD ) - return false; - - wxWindow *winTop = wxTheApp->GetTopWindow(); - wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") ); + wxArrayVideoModes modes; - HRESULT hr = pDD->SetCooperativeLevel - ( - GetHwndOf(winTop), - DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN - ); - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::SetCooperativeLevel"), hr); + // 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(); - return false; - } + DEVMODE dm; + dm.dmSize = sizeof(dm); + dm.dmDriverExtra = 0; - hr = pDD->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0); - if ( FAILED(hr) ) + for ( int iModeNum = 0; + ::EnumDisplaySettings(deviceName, iModeNum, &dm); + iModeNum++ ) { - wxLogApiError(_T("IDirectDraw::SetDisplayMode"), hr); - - return false; + const wxVideoMode mode = ConvertToVideoMode(dm); + if ( mode.Matches(modeMatch) ) + { + modes.Add(mode); + } } - - return true; + return modes; } -#endif -bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) +bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode) { // prepare ChangeDisplaySettingsEx() parameters DEVMODE dm; @@ -824,26 +347,26 @@ bool wxDisplay::DoChangeModeWindows(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; @@ -863,13 +386,12 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL; if ( !pfnChangeDisplaySettingsEx ) { - wxDynamicLibrary dllUser32(_T("user32.dll")); - if ( dllUser32.IsLoaded() ) + wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET); + if ( dllDisplay.IsLoaded() ) { - pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t) - dllUser32.GetSymbol(WINFUNC(ChangeDisplaySettingsEx)); + 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 ) @@ -884,25 +406,25 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) // do change the mode switch ( pfnChangeDisplaySettingsEx ( - GetName(), // display name - pDevMode, // dev mode or NULL to reset - NULL, // reserved + GetName().wx_str(), // display name + pDevMode, // dev mode or NULL to reset + NULL, // reserved flags, - NULL // pointer to video parameters (not used) + NULL // pointer to video parameters (not used) ) ) { case DISP_CHANGE_SUCCESSFUL: // 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; @@ -912,20 +434,98 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) break; default: - wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") ); + wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") ); } return false; } -bool wxDisplay::ChangeMode(const wxVideoMode& mode) + +// ---------------------------------------------------------------------------- +// wxDisplayFactoryMSW implementation +// ---------------------------------------------------------------------------- + +wxDisplayFactoryMSW::wxDisplayFactoryMSW() { -#ifdef HAVE_DDRAW_H - return gs_useDirectX ? DoChangeModeDirectX(mode) - : DoChangeModeWindows(mode); -#else - return DoChangeModeWindows(mode); -#endif + 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; + + // enumerate all displays + 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) +{ + return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window), + MONITOR_DEFAULTTONULL)); } #endif // wxUSE_DISPLAY