X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/82eba82658182db222b56108a2f52e59e3f0b3d1..3f4a2351e4c677c88c18ea812b609477adee7380:/src/msw/display.cpp?ds=inline diff --git a/src/msw/display.cpp b/src/msw/display.cpp index 1fd815e37c..6f7181bfa2 100644 --- a/src/msw/display.cpp +++ b/src/msw/display.cpp @@ -1,11 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: display.cpp +// Name: src/msw/display.cpp // Purpose: MSW Implementation of wxDisplay class -// Author: Royce Mitchell III -// Modified by: VZ (resolutions enumeration/change support, DirectDraw, ...) +// Author: Royce Mitchell III, Vadim Zeitlin +// Modified by: Ryan Norton (IsPrimary override) // Created: 06/21/02 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team +// Copyright: (c) wxWidgets team +// Copyright: (c) 2002-2006 wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -17,10 +18,6 @@ // headers // --------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "display.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -31,50 +28,61 @@ #if wxUSE_DISPLAY #ifndef WX_PRECOMP - #include "wx/dynarray.h" + #include "wx/msw/missing.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" +#include "wx/display_impl.h" -// the following define is necessary to access the multi-monitor function -// declarations in a manner safe to use w/ Windows 95 -#define COMPILE_MULTIMON_STUBS - -// if you don't have multimon.h you can download the file from: -// -// http://www.microsoft.com/msj/0697/monitor/monitortextfigs.htm#fig4 -// - -#ifdef _MSC_VER - // as (m)any standard header(s), this one doesn't compile without warnings - // with VC++ 6 - #pragma warning(disable:4706) -#endif - -#include +// 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 -#ifdef _MSC_VER - #pragma warning(default:4706) +#if !defined(wxUSE_DIRECTDRAW) + #define wxUSE_DIRECTDRAW 0 #endif -#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 } }; - -// ---------------------------------------------------------------------------- -// macros -// ---------------------------------------------------------------------------- - -#ifdef _UNICODE - #define WINFUNC(x) _T(#x) L"W" -#else - #define WINFUNC(x) #x "A" -#endif +#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__ + +#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 // ---------------------------------------------------------------------------- // typedefs for dynamically loaded Windows functions @@ -86,6 +94,7 @@ 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, @@ -99,481 +108,570 @@ typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback, 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); +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__ // ---------------------------------------------------------------------------- -// private classes +// display information classes // ---------------------------------------------------------------------------- -class wxDisplayInfo +struct wxDisplayInfo { -public: - // handle of this monitor used by MonitorXXX() functions, never NULL - HMONITOR m_hmon; + wxDisplayInfo(HMONITOR hmon = NULL) + { + m_hmon = hmon; + m_flags = (DWORD)-1; + } - // IDirectDraw object used to control this display, may be NULL - IDirectDraw2 *m_pDD2; + virtual ~wxDisplayInfo() { } - // DirectDraw GUID for this display, only valid when using DirectDraw - GUID m_guid; + + // 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; - wxDisplayInfo() { m_hmon = NULL; m_pDD2 = NULL; } - ~wxDisplayInfo() { if ( m_pDD2 ) m_pDD2->Release(); } + // the flags of this monitor, also used as initialization marker: if this + // is -1, GetMonitorInfo() hadn't been called yet + DWORD m_flags; }; -WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray); -#include "wx/arrimpl.cpp" -WX_DEFINE_OBJARRAY(wxDisplayInfoArray); +WX_DEFINE_ARRAY_PTR(wxDisplayInfo *, wxDisplayInfoArray); -// this module is used to cleanup gs_displays array -class wxDisplayModule : public wxModule +// ---------------------------------------------------------------------------- +// common base class for all Win32 wxDisplayImpl versions +// ---------------------------------------------------------------------------- + +class wxDisplayImplWin32Base : public wxDisplayImpl { public: - virtual bool OnInit() { return true; } - virtual void OnExit(); + wxDisplayImplWin32Base(unsigned n, wxDisplayInfo& info) + : wxDisplayImpl(n), + m_info(info) + { + } - DECLARE_DYNAMIC_CLASS(wxDisplayModule) -}; + virtual wxRect GetGeometry() const; + virtual wxRect GetClientArea() const; + virtual wxString GetName() const; + virtual bool IsPrimary() const; -IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule) + virtual wxVideoMode GetCurrentMode() const; + +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); + } + + wxDisplayInfo& m_info; +}; // ---------------------------------------------------------------------------- -// globals +// common base class for all Win32 wxDisplayFactory versions // ---------------------------------------------------------------------------- -// do we use DirectX? -static bool gs_useDirectX = false; +// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize() +static MonitorFromPoint_t gs_MonitorFromPoint = NULL; +static MonitorFromWindow_t gs_MonitorFromWindow = NULL; +static GetMonitorInfo_t gs_GetMonitorInfo = NULL; -// dynamically resolved DirectDrawCreate() -static DirectDrawCreate_t gs_DirectDrawCreate = NULL; +class wxDisplayFactoryWin32Base : public wxDisplayFactory +{ +public: + virtual ~wxDisplayFactoryWin32Base(); -// 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; + bool IsOk() const { return !m_displays.empty(); } -// =========================================================================== -// implementation -// =========================================================================== + virtual unsigned GetCount() { return unsigned(m_displays.size()); } + virtual int GetFromPoint(const wxPoint& pt); + virtual int GetFromWindow(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 (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) +}; // ---------------------------------------------------------------------------- -// callbacks for monitor/modes enumeration stuff +// wxDisplay implementation using Windows multi-monitor support functions // ---------------------------------------------------------------------------- -static BOOL CALLBACK wxmswMonitorEnumProc ( - HMONITOR hMonitor, // handle to display monitor - HDC hdcMonitor, // handle to monitor-appropriate device context (NULL) - LPRECT lprcMonitor, // pointer to monitor intersection rectangle - LPARAM dwData // data passed from EnumDisplayMonitors (unused) -) +class wxDisplayImplMultimon : public wxDisplayImplWin32Base { - wxDisplayInfo *info = new wxDisplayInfo(); +public: + wxDisplayImplMultimon(unsigned n, wxDisplayInfo& info) + : wxDisplayImplWin32Base(n, info) + { + } - // 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; + virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; + virtual bool ChangeMode(const wxVideoMode& mode); - // 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 ); +private: + DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon) +}; - // now add this monitor to the array - gs_displays->Add(info); +class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base +{ +public: + wxDisplayFactoryMultimon(); - // continue the enumeration - return true; -} + virtual wxDisplayImpl *CreateDisplay(unsigned n); + +private: + // EnumDisplayMonitors() callback + static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor, + HDC hdcMonitor, + LPRECT lprcMonitor, + LPARAM dwData); + + + // add a monitor description to m_displays array + void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor); +}; + +// ---------------------------------------------------------------------------- +// wxDisplay implementation using DirectDraw +// ---------------------------------------------------------------------------- -BOOL PASCAL -wxDDEnumExCallback(GUID *pGuid, - LPTSTR driverDescription, - LPTSTR driverName, - LPVOID lpContext, - HMONITOR hmon) +#if wxUSE_DIRECTDRAW + +struct wxDisplayInfoDirectDraw : wxDisplayInfo { - if ( pGuid ) + wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name) + : wxDisplayInfo(hmon), + m_guid(guid) { - wxDisplayInfo *info = new wxDisplayInfo(); - - info->m_hmon = hmon; - info->m_guid = *pGuid; - info->m_devName = driverName; + m_pDD2 = NULL; + m_devName = name; + } - gs_displays->Add(info); + virtual ~wxDisplayInfoDirectDraw() + { + if ( m_pDD2 ) + m_pDD2->Release(); } - //else: we're called for the primary monitor, skip it - // continue the enumeration - return true; -} -HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc, - LPVOID lpContext) + // 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 { - // we need at least the mode size - static const int FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH; - if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED ) +public: + wxDisplayImplDirectDraw(unsigned n, wxDisplayInfo& info, IDirectDraw2 *pDD2) + : wxDisplayImplWin32Base(n, info), + m_pDD2(pDD2) { - wxArrayVideoModes * const modes = (wxArrayVideoModes *)lpContext; + m_pDD2->AddRef(); + } - modes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth, - lpDDSurfaceDesc->dwHeight, - lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, - lpDDSurfaceDesc->dwRefreshRate)); + virtual ~wxDisplayImplDirectDraw() + { + m_pDD2->Release(); } - // continue the enumeration - return DDENUMRET_OK; -} + virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const; + virtual bool ChangeMode(const wxVideoMode& mode); -// ---------------------------------------------------------------------------- -// local functions -// ---------------------------------------------------------------------------- +private: + IDirectDraw2 *m_pDD2; + + DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw) +}; -// initialize gs_displays using DirectX functions -static bool DoInitDirectX() +class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base { - // suppress the errors if ddraw.dll is not found - wxLog::EnableLogging(false); +public: + wxDisplayFactoryDirectDraw(); + virtual ~wxDisplayFactoryDirectDraw(); - wxDynamicLibrary dllDX(_T("ddraw.dll")); + virtual wxDisplayImpl *CreateDisplay(unsigned n); - wxLog::EnableLogging(true); +private: + // callback used with DirectDrawEnumerateEx() + static BOOL WINAPI DDEnumExCallback(GUID *pGuid, + LPTSTR driverDescription, + LPTSTR driverName, + LPVOID lpContext, + HMONITOR hmon); - if ( !dllDX.IsLoaded() ) - return false; + // add a monitor description to m_displays array + void AddDisplay(const GUID& guid, HMONITOR hmon, LPTSTR name); - 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; + // ddraw.dll + wxDynamicLibrary m_dllDDraw; - if ( (*pDDEnumEx)(wxDDEnumExCallback, - NULL, - DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK ) - { - return false; - } + // dynamically resolved DirectDrawCreate() + DirectDrawCreate_t m_pfnDirectDrawCreate; - // 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(); + DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw) +}; - return true; -} +#endif // wxUSE_DIRECTDRAW -// initialize gs_displays using the standard Windows functions -static void DoInitStdWindows() -{ - // enumerate all displays - if ( !::EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) ) - { - wxLogLastError(wxT("EnumDisplayMonitors")); - // TODO: still create at least one (valid) entry in gs_displays for the - // primary display! - } -} +// ============================================================================ +// common classes implementation +// ============================================================================ -// this function must be called before accessing gs_displays array as it -// creates and initializes it -static void InitDisplays() -{ - if ( gs_displays ) - return; +// ---------------------------------------------------------------------------- +// wxDisplay +// ---------------------------------------------------------------------------- - gs_displays = new wxDisplayInfoArray(); +/* 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 - if ( !gs_useDirectX || !DoInitDirectX() ) +#if wxUSE_DIRECTDRAW + if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) ) { - // either we were told not to try to use DirectX or fall back to std - // functions if DirectX method failed - gs_useDirectX = false; + wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw; + if ( factoryDD->IsOk() ) + return factoryDD; - DoInitStdWindows(); + delete factoryDD; } -} +#endif // wxUSE_DIRECTDRAW -// 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); -} + wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon; + if ( factoryMM->IsOk() ) + return factoryMM; -// 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); + delete factoryMM; + + + // finally fall back to a stub implementation if all else failed (Win95?) + return new wxDisplayFactorySingle; } // ---------------------------------------------------------------------------- -// wxDisplayModule +// wxDisplayInfo // ---------------------------------------------------------------------------- -void wxDisplayModule::OnExit() +void wxDisplayInfo::Initialize() { - delete gs_displays; + if ( m_flags == (DWORD)-1 ) + { + 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; + } } -// --------------------------------------------------------------------------- -// wxDisplay -// --------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// wxDisplayImplWin32Base +// ---------------------------------------------------------------------------- -/* static */ -void wxDisplay::UseDirectX(bool useDX) +wxRect wxDisplayImplWin32Base::GetGeometry() const { - wxCHECK_RET( !gs_displays, _T("it is too late to call UseDirectX") ); + if ( m_info.m_rect.IsEmpty() ) + m_info.Initialize(); - gs_useDirectX = useDX; + return m_info.m_rect; } -// helper of GetFromPoint() and GetFromWindow() -static int DisplayFromHMONITOR(HMONITOR hmon) +wxRect wxDisplayImplWin32Base::GetClientArea() const { - if ( hmon ) - { - const size_t count = wxDisplay::GetCount(); + if ( m_info.m_rectClient.IsEmpty() ) + m_info.Initialize(); - for ( size_t n = 0; n < count; n++ ) - { - if ( hmon == (*gs_displays)[n].m_hmon ) - return n; - } - } - - return wxNOT_FOUND; + return m_info.m_rectClient; } -/* static */ -size_t wxDisplayBase::GetCount() +wxString wxDisplayImplWin32Base::GetName() const { - InitDisplays(); - - // I'm not sure if they really always return the same thing and if this is - // not true I'd like to know in which situation does it happen - wxASSERT_MSG( gs_displays->GetCount() == (size_t)::GetSystemMetrics(SM_CMONITORS), - _T("So how many displays does this system have?") ); + if ( m_info.m_devName.empty() ) + m_info.Initialize(); - return gs_displays->GetCount(); + return m_info.m_devName; } -/* static */ -int wxDisplayBase::GetFromPoint ( const wxPoint& pt ) +bool wxDisplayImplWin32Base::IsPrimary() const { - POINT pt2; - pt2.x = pt.x; - pt2.y = pt.y; + if ( m_info.m_flags == (DWORD)-1 ) + m_info.Initialize(); - return DisplayFromHMONITOR(::MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL)); + return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0; } -/* static */ -int wxDisplayBase::GetFromWindow(wxWindow *window) +wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const { - return DisplayFromHMONITOR - ( - ::MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL) - ); + 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() ? NULL : 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)")); + } + else + { + mode = ConvertToVideoMode(dm); + } + + return mode; } // ---------------------------------------------------------------------------- -// wxDisplay ctor/dtor +// wxDisplayFactoryWin32Base // ---------------------------------------------------------------------------- -wxDisplay::wxDisplay ( size_t n ) - : wxDisplayBase ( n ) -{ - // if we do this in ctor we won't have to call it from all the member - // functions - InitDisplays(); +int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1; - if ( gs_useDirectX ) +wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base() +{ + if ( ms_supportsMultimon == -1 ) { - wxDisplayInfo& dpyInfo = (*gs_displays)[n]; + ms_supportsMultimon = 0; - LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2; - if ( !pDD2 ) - { - if ( !gs_DirectDrawCreate ) - { - // what to do?? - return; - } + wxDynamicLibrary dllUser32(_T("user32.dll")); - IDirectDraw *pDD; - HRESULT hr = (*gs_DirectDrawCreate)(&dpyInfo.m_guid, &pDD, NULL); + wxLogNull noLog; - 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); - } + gs_MonitorFromPoint = (MonitorFromPoint_t) + dllUser32.GetSymbol(wxT("MonitorFromPoint")); + if ( !gs_MonitorFromPoint ) + return; - 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(); - } -} + gs_MonitorFromWindow = (MonitorFromWindow_t) + dllUser32.GetSymbol(wxT("MonitorFromWindow")); + if ( !gs_MonitorFromWindow ) + return; -wxDisplay::~wxDisplay() -{ - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; + gs_GetMonitorInfo = (GetMonitorInfo_t) + dllUser32.GetSymbolAorW(wxT("GetMonitorInfo")); + if ( !gs_GetMonitorInfo ) + return; - LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2; - if ( pDD2 ) - { - pDD2->Release(); + 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 } } -// ---------------------------------------------------------------------------- -// wxDisplay simple accessors -// ---------------------------------------------------------------------------- +void wxDisplayFactoryWin32Base::Clear() +{ + WX_CLEAR_ARRAY(m_displays); +} -bool wxDisplay::IsOk() const +wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base() { - return m_index < GetCount() && - (!gs_useDirectX || (*gs_displays)[m_index].m_pDD2); + Clear(); } -wxRect wxDisplay::GetGeometry() const +// helper for GetFromPoint() and GetFromWindow() +int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const { - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; - wxRect& rect = dpyInfo.m_rect; - if ( !rect.width ) + if ( hmon ) { - MONITORINFO monInfo; - wxZeroMemory(monInfo); - monInfo.cbSize = sizeof(monInfo); - - if ( !::GetMonitorInfo(dpyInfo.m_hmon, &monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - } - else + const size_t count = m_displays.size(); + for ( size_t n = 0; n < count; n++ ) { - wxCopyRECTToRect(monInfo.rcMonitor, rect); + if ( hmon == m_displays[n]->m_hmon ) + return n; } } - return rect; + 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)); } -wxString wxDisplay::GetName() const +int wxDisplayFactoryWin32Base::GetFromWindow(wxWindow *window) { - wxDisplayInfo& dpyInfo = (*gs_displays)[m_index]; - if ( dpyInfo.m_devName.empty() ) + 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; { - MONITORINFOEX monInfo; - wxZeroMemory(monInfo); - monInfo.cbSize = sizeof(monInfo); + wxLogNull noLog; - if ( !::GetMonitorInfo(dpyInfo.m_hmon, &monInfo) ) - { - wxLogLastError(_T("GetMonitorInfo")); - } - else - { - dpyInfo.m_devName = monInfo.szDevice; - } + wxDynamicLibrary dllUser32(_T("user32.dll")); + pfnEnumDisplayMonitors = (EnumDisplayMonitors_t) + dllUser32.GetSymbol(wxT("EnumDisplayMonitors")); + if ( !pfnEnumDisplayMonitors ) + return; } - return dpyInfo.m_devName; + // enumerate all displays + if ( !pfnEnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) ) + { + wxLogLastError(wxT("EnumDisplayMonitors")); + } } -wxString wxDisplay::GetNameForEnumSettings() const +/* 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) +) { - int major, minor; - const bool isWin95 = wxGetOsVersion(&major, &minor) == wxWIN95 && - major == 4 && minor == 0; - - // the first parameter of EnumDisplaySettings() must be NULL under Win95 - // according to MSDN but GetMonitorInfo() stub in multimon.h still returns - // something even in this case, so we have to correct this manually - wxString name; - if ( !isWin95 ) - name = GetName(); + wxDisplayFactoryMultimon *const self = (wxDisplayFactoryMultimon *)dwData; + self->AddDisplay(hMonitor, lprcMonitor); - return name; + // continue the enumeration + return TRUE; } // ---------------------------------------------------------------------------- -// video modes enumeration +// wxDisplayFactoryMultimon helper functions // ---------------------------------------------------------------------------- -wxArrayVideoModes -wxDisplay::DoGetModesDirectX(const wxVideoMode& modeMatch) const +void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor) { - wxArrayVideoModes modes; + wxDisplayInfo *info = new wxDisplayInfo(hMonitor); - IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2; + // we also store the display geometry + info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top, + lprcMonitor->right - lprcMonitor->left, + lprcMonitor->bottom - lprcMonitor->top); - if ( pDD ) - { - HRESULT hr = pDD->EnumDisplayModes - ( - DDEDM_REFRESHRATES, - NULL, // all modes (TODO: use modeMatch!) - &modes, // callback parameter - wxDDEnumModesCallback - ); + // now add this monitor to the array + m_displays.Add(info); +} - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr); - } - } +// ---------------------------------------------------------------------------- +// wxDisplayFactoryMultimon inherited pure virtuals implementation +// ---------------------------------------------------------------------------- - return modes; +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 -wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const +wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const { wxArrayVideoModes modes; - const wxString name = GetNameForEnumSettings(); - + // 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++ ) @@ -588,75 +686,12 @@ wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const return modes; } -wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const -{ - return gs_useDirectX ? DoGetModesDirectX(modeMatch) - : DoGetModesWindows(modeMatch); -} - -wxVideoMode wxDisplay::GetCurrentMode() const +bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode) { - wxVideoMode mode; - - const wxString name = GetNameForEnumSettings(); - + // prepare ChangeDisplaySettingsEx() parameters DEVMODE dm; - if ( !::EnumDisplaySettings(name.empty() ? NULL : name.c_str(), - ENUM_CURRENT_SETTINGS, - &dm) ) - { - wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)")); - } - else - { - mode = ConvertToVideoMode(dm); - } - - return mode; -} - -// ---------------------------------------------------------------------------- -// video mode switching -// ---------------------------------------------------------------------------- - -bool wxDisplay::DoChangeModeDirectX(const wxVideoMode& mode) -{ - IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2; - if ( !pDD ) - return false; + DEVMODE *pDevMode; - wxWindow *winTop = wxTheApp->GetTopWindow(); - wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") ); - - HRESULT hr = pDD->SetCooperativeLevel - ( - GetHwndOf(winTop), - DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN - ); - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::SetCooperativeLevel"), hr); - - return false; - } - - hr = pDD->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0); - if ( FAILED(hr) ) - { - wxLogApiError(_T("IDirectDraw::SetDisplayMode"), hr); - - return false; - } - - - return true; -} - -bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) -{ - // prepare ChangeDisplaySettingsEx() parameters - DEVMODE dm, - *pDevMode; int flags; if ( mode == wxDefaultVideoMode ) @@ -672,6 +707,7 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) wxZeroMemory(dm); dm.dmSize = sizeof(dm); + dm.dmDriverExtra = 0; dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT; dm.dmPelsWidth = mode.w; dm.dmPelsHeight = mode.h; @@ -690,7 +726,11 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) pDevMode = &dm; +#ifdef __WXWINCE__ + flags = 0; +#else // !__WXWINCE__ flags = CDS_FULLSCREEN; +#endif // __WXWINCE__/!__WXWINCE__ } @@ -705,16 +745,18 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) if ( dllUser32.IsLoaded() ) { pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t) - dllUser32.GetSymbol(WINFUNC(ChangeDisplaySettingsEx)); + dllUser32.GetSymbolAorW(_T("ChangeDisplaySettingsEx")); } //else: huh, no user32.dll?? +#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 @@ -729,6 +771,18 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) { case DISP_CHANGE_SUCCESSFUL: // ok + { + // If we have a top-level, full-screen frame, emulate + // the DirectX behavior 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); + } + } return true; case DISP_CHANGE_BADMODE: @@ -742,11 +796,243 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode) return false; } -bool wxDisplay::ChangeMode(const wxVideoMode& mode) + +// ============================================================================ +// DirectDraw-based wxDisplay implementation +// ============================================================================ + +#if wxUSE_DIRECTDRAW + +// ---------------------------------------------------------------------------- +// wxDisplayFactoryDirectDraw initialization +// ---------------------------------------------------------------------------- + +wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw() { - return gs_useDirectX ? DoChangeModeDirectX(mode) - : DoChangeModeWindows(mode); + if ( !ms_supportsMultimon ) + return; + +#if wxUSE_LOG + // suppress the errors if ddraw.dll is not found, we're prepared to handle + // this + wxLogNull noLog; +#endif + + m_dllDDraw.Load(_T("ddraw.dll")); + + if ( !m_dllDDraw.IsLoaded() ) + return; + + DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t) + m_dllDDraw.GetSymbolAorW(_T("DirectDrawEnumerateEx")); + if ( !pDDEnumEx ) + return; + + // we can't continue without DirectDrawCreate() later, so resolve it right + // now and fail the initialization if it's not available + m_pfnDirectDrawCreate = (DirectDrawCreate_t) + m_dllDDraw.GetSymbol(_T("DirectDrawCreate")); + if ( !m_pfnDirectDrawCreate ) + return; + + if ( (*pDDEnumEx)(DDEnumExCallback, + this, + DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK ) + { + wxLogLastError(_T("DirectDrawEnumerateEx")); + } } -#endif // wxUSE_DISPLAY +wxDisplayFactoryDirectDraw::~wxDisplayFactoryDirectDraw() +{ + // we must clear m_displays now, before m_dllDDraw is unloaded as otherwise + // calling m_pDD2->Release() later would crash + Clear(); +} +// ---------------------------------------------------------------------------- +// callbacks for monitor/modes enumeration stuff +// ---------------------------------------------------------------------------- + +BOOL WINAPI +wxDisplayFactoryDirectDraw::DDEnumExCallback(GUID *pGuid, + LPTSTR WXUNUSED(driverDescription), + LPTSTR driverName, + LPVOID lpContext, + HMONITOR hmon) +{ + if ( pGuid ) + { + wxDisplayFactoryDirectDraw * self = + wx_static_cast(wxDisplayFactoryDirectDraw *, lpContext); + self->AddDisplay(*pGuid, hmon, driverName); + } + //else: we're called for the primary monitor, skip it + + // continue the enumeration + return TRUE; +} + +// ---------------------------------------------------------------------------- +// wxDisplayFactoryDirectDraw helpers +// ---------------------------------------------------------------------------- + +void wxDisplayFactoryDirectDraw::AddDisplay(const GUID& guid, + HMONITOR hmon, + LPTSTR name) +{ + m_displays.Add(new wxDisplayInfoDirectDraw(guid, hmon, name)); +} + +// ---------------------------------------------------------------------------- +// wxDisplayFactoryDirectDraw inherited pure virtuals implementation +// ---------------------------------------------------------------------------- + +wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(unsigned n) +{ + wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") ); + + wxDisplayInfoDirectDraw * + info = wx_static_cast(wxDisplayInfoDirectDraw *, m_displays[n]); + + if ( !info->m_pDD2 ) + { + IDirectDraw *pDD; + GUID guid(info->m_guid); + HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL); + + if ( FAILED(hr) || !pDD ) + { + // what to do?? + wxLogApiError(_T("DirectDrawCreate"), hr); + return NULL; + } + + // we got IDirectDraw, but we need IDirectDraw2 + hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2); + pDD->Release(); + + if ( FAILED(hr) || !info->m_pDD2 ) + { + wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr); + return NULL; + } + + // 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); +} + +// ============================================================================ +// wxDisplayImplDirectDraw +// ============================================================================ + +// ---------------------------------------------------------------------------- +// video modes enumeration +// ---------------------------------------------------------------------------- + +// tiny helper class used to pass information from GetModes() to +// wxDDEnumModesCallback +class wxDDVideoModesAdder +{ +public: + // our Add() method will add modes matching modeMatch to modes array + wxDDVideoModesAdder(wxArrayVideoModes& modes, const wxVideoMode& modeMatch) + : m_modes(modes), + m_modeMatch(modeMatch) + { + } + + void Add(const wxVideoMode& mode) + { + if ( mode.Matches(m_modeMatch) ) + m_modes.Add(mode); + } + +private: + wxArrayVideoModes& m_modes; + const wxVideoMode& m_modeMatch; + + DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder) +}; + +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 ) + { + wxDDVideoModesAdder * const vmodes = + wx_static_cast(wxDDVideoModesAdder *, lpContext); + + vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth, + lpDDSurfaceDesc->dwHeight, + lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, + lpDDSurfaceDesc->dwRefreshRate)); + } + + // continue the enumeration + return DDENUMRET_OK; +} + +wxArrayVideoModes +wxDisplayImplDirectDraw::GetModes(const wxVideoMode& modeMatch) const +{ + 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); + } + + return modes; +} + +// ---------------------------------------------------------------------------- +// video mode switching +// ---------------------------------------------------------------------------- + +bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode) +{ + 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) ) + { + wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr); + + return false; + } + + hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0); + if ( FAILED(hr) ) + { + wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr); + + return false; + } + + return true; +} + +#endif // wxUSE_DIRECTDRAW + +#endif // wxUSE_DISPLAY