/////////////////////////////////////////////////////////////////////////////
-// Name: display.cpp
+// Name: src/msw/display.cpp
// Purpose: MSW Implementation of wxDisplay class
-// Author: Royce Mitchell III
-// Modified by:
+// 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
/////////////////////////////////////////////////////////////////////////////
// headers
// ---------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "display.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#if wxUSE_DISPLAY
#ifndef WX_PRECOMP
- #include "wx/dynarray.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, this one doesn't compile without warnings
- // with VC++ 6 <sigh>
- #pragma warning(disable:4706)
-#endif
-
-#include <multimon.h>
+// define this to use DirectDraw for display mode switching: this is disabled
+// by default because ddraw.h is now always available and also it's not really
+// clear what are the benefits of using DirectDraw compared to the standard API
-#ifdef _MSC_VER
- #pragma warning(default:4706)
+#if !defined(wxUSE_DIRECTDRAW)
+ #define wxUSE_DIRECTDRAW 0
#endif
-#ifdef _UNICODE
- #define MAKE_WFUNC(x) #x "W"
- #define WINFUNC(x) L ## MAKE_WFUNC(x)
-#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 <ddraw.h>
+
+ // 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
+// typedefs for dynamically loaded Windows functions
// ----------------------------------------------------------------------------
typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName,
DWORD dwFlags,
LPVOID lParam);
+#if wxUSE_DIRECTDRAW
+typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
+ LPTSTR driverDescription,
+ LPTSTR driverName,
+ LPVOID lpContext,
+ HMONITOR hmon);
+
+typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback,
+ LPVOID lpContext,
+ DWORD dwFlags);
+
+typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
+ LPDIRECTDRAW *lplpDD,
+ IUnknown *pUnkOuter);
+#endif // wxUSE_DIRECTDRAW
+
+typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
+typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
+typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);
+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:
+ 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;
- wxDisplayInfo() { m_hmon = NULL; }
+ // 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 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 *g_displays = NULL;
+// ----------------------------------------------------------------------------
+// common base class for all Win32 wxDisplayImpl versions
+// ----------------------------------------------------------------------------
+class wxDisplayImplWin32Base : public wxDisplayImpl
+{
+public:
+ wxDisplayImplWin32Base(size_t n, wxDisplayInfo& info)
+ : wxDisplayImpl(n),
+ m_info(info)
+ {
+ }
+
+ virtual wxRect GetGeometry() const;
+ virtual wxRect GetClientArea() const;
+ virtual wxString GetName() const;
+ virtual bool IsPrimary() const;
-// this module is used to cleanup g_displays array
-class wxDisplayModule : public 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;
+};
+
+// ----------------------------------------------------------------------------
+// common base class for all Win32 wxDisplayFactory versions
+// ----------------------------------------------------------------------------
+
+// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize()
+static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
+static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
+static GetMonitorInfo_t gs_GetMonitorInfo = NULL;
+
+class wxDisplayFactoryWin32Base : public wxDisplayFactory
{
public:
- virtual bool OnInit() { return TRUE; }
- virtual void OnExit();
+ virtual ~wxDisplayFactoryWin32Base();
+
+ bool IsOk() const { return !m_displays.empty(); }
+
+ virtual size_t GetCount() { return 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();
- DECLARE_DYNAMIC_CLASS(wxDisplayModule)
+ // 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)
};
-IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
+// ----------------------------------------------------------------------------
+// wxDisplay implementation using Windows multi-monitor support functions
+// ----------------------------------------------------------------------------
-// ===========================================================================
-// implementation
-// ===========================================================================
+class wxDisplayImplMultimon : public wxDisplayImplWin32Base
+{
+public:
+ wxDisplayImplMultimon(size_t n, wxDisplayInfo& info)
+ : wxDisplayImplWin32Base(n, info)
+ {
+ }
+
+ virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+ virtual bool ChangeMode(const wxVideoMode& mode);
+
+private:
+ DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon)
+};
+
+class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
+{
+public:
+ wxDisplayFactoryMultimon();
+
+ virtual wxDisplayImpl *CreateDisplay(size_t 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);
+};
// ----------------------------------------------------------------------------
-// local functions
+// wxDisplay implementation using DirectDraw
// ----------------------------------------------------------------------------
-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)
-)
+#if wxUSE_DIRECTDRAW
+
+struct wxDisplayInfoDirectDraw : wxDisplayInfo
{
- wxDisplayInfo* info = new wxDisplayInfo();
+ wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name)
+ : wxDisplayInfo(hmon),
+ m_guid(guid)
+ {
+ m_pDD2 = NULL;
+ m_devName = name;
+ }
- // 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 ~wxDisplayInfoDirectDraw()
+ {
+ if ( m_pDD2 )
+ m_pDD2->Release();
+ }
- // 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
- g_displays->Add(info);
+ // IDirectDraw object used to control this display, may be NULL
+ IDirectDraw2 *m_pDD2;
- // continue the enumeration
- return TRUE;
-}
+ // DirectDraw GUID for this display, only valid when using DirectDraw
+ const GUID m_guid;
-// this function must be called before accessing g_displays array as it
-// creates and initializes it
-static void InitDisplays()
+
+ DECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw)
+};
+
+class wxDisplayImplDirectDraw : public wxDisplayImplWin32Base
{
- if ( g_displays )
- return;
+public:
+ wxDisplayImplDirectDraw(size_t n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
+ : wxDisplayImplWin32Base(n, info),
+ m_pDD2(pDD2)
+ {
+ m_pDD2->AddRef();
+ }
+
+ virtual ~wxDisplayImplDirectDraw()
+ {
+ m_pDD2->Release();
+ }
- g_displays = new wxDisplayInfoArray();
+ virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+ virtual bool ChangeMode(const wxVideoMode& mode);
- // enumerate all displays
- if ( !::EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) )
+private:
+ IDirectDraw2 *m_pDD2;
+
+ DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw)
+};
+
+class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base
+{
+public:
+ wxDisplayFactoryDirectDraw();
+ virtual ~wxDisplayFactoryDirectDraw();
+
+ virtual wxDisplayImpl *CreateDisplay(size_t n);
+
+private:
+ // callback used with DirectDrawEnumerateEx()
+ static BOOL WINAPI DDEnumExCallback(GUID *pGuid,
+ LPTSTR driverDescription,
+ LPTSTR driverName,
+ LPVOID lpContext,
+ HMONITOR hmon);
+
+ // add a monitor description to m_displays array
+ void AddDisplay(const GUID& guid, HMONITOR hmon, LPTSTR name);
+
+
+ // ddraw.dll
+ wxDynamicLibrary m_dllDDraw;
+
+ // dynamically resolved DirectDrawCreate()
+ DirectDrawCreate_t m_pfnDirectDrawCreate;
+
+ DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw)
+};
+
+#endif // wxUSE_DIRECTDRAW
+
+
+// ============================================================================
+// common classes implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDisplay
+// ----------------------------------------------------------------------------
+
+/* 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 wxUSE_DIRECTDRAW
+ if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) )
{
- wxLogLastError(wxT("EnumDisplayMonitors"));
+ wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
+ if ( factoryDD->IsOk() )
+ return factoryDD;
- // TODO: still create at least one (valid) entry in g_displays for the
- // primary display!
+ delete factoryDD;
}
+#endif // wxUSE_DIRECTDRAW
+
+ wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon;
+ if ( factoryMM->IsOk() )
+ return factoryMM;
+
+ delete factoryMM;
+
+
+ // finally fall back to a stub implementation if all else failed (Win95?)
+ return new wxDisplayFactorySingle;
}
-// convert a DEVMODE to our wxVideoMode
-wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
+// ----------------------------------------------------------------------------
+// wxDisplayInfo
+// ----------------------------------------------------------------------------
+
+void wxDisplayInfo::Initialize()
{
- // 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);
+ if ( m_flags == (DWORD)-1 )
+ {
+ WinStruct<MONITORINFOEX> 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;
+ }
}
-// emulation of ChangeDisplaySettingsEx() for Win95
-LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
- LPDEVMODE lpDevMode,
- HWND WXUNUSED(hwnd),
- DWORD dwFlags,
- LPVOID WXUNUSED(lParam))
+// ----------------------------------------------------------------------------
+// wxDisplayImplWin32Base
+// ----------------------------------------------------------------------------
+
+wxRect wxDisplayImplWin32Base::GetGeometry() const
{
- return ::ChangeDisplaySettings(lpDevMode, dwFlags);
+ if ( m_info.m_rect.IsEmpty() )
+ m_info.Initialize();
+
+ return m_info.m_rect;
+}
+
+wxRect wxDisplayImplWin32Base::GetClientArea() const
+{
+ if ( m_info.m_rectClient.IsEmpty() )
+ m_info.Initialize();
+
+ return m_info.m_rectClient;
+}
+
+wxString wxDisplayImplWin32Base::GetName() const
+{
+ if ( m_info.m_devName.IsEmpty() )
+ m_info.Initialize();
+
+ return m_info.m_devName;
+}
+
+bool wxDisplayImplWin32Base::IsPrimary() const
+{
+ if ( m_info.m_flags == (DWORD)-1 )
+ m_info.Initialize();
+
+ return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;
+}
+
+wxVideoMode wxDisplayImplWin32Base::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() ? 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;
}
// ----------------------------------------------------------------------------
-// wxDisplayModule
+// wxDisplayFactoryWin32Base
// ----------------------------------------------------------------------------
-void wxDisplayModule::OnExit()
+int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1;
+
+wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base()
{
- delete g_displays;
+ if ( ms_supportsMultimon == -1 )
+ {
+ ms_supportsMultimon = 0;
+
+ wxDynamicLibrary dllUser32(_T("user32.dll"));
+
+ wxLogNull noLog;
+
+ gs_MonitorFromPoint = (MonitorFromPoint_t)
+ dllUser32.GetSymbol(wxT("MonitorFromPoint"));
+ if ( !gs_MonitorFromPoint )
+ return;
+
+ gs_MonitorFromWindow = (MonitorFromWindow_t)
+ dllUser32.GetSymbol(wxT("MonitorFromWindow"));
+ if ( !gs_MonitorFromWindow )
+ return;
+
+ gs_GetMonitorInfo = (GetMonitorInfo_t)
+ dllUser32.GetSymbolAorW(wxT("GetMonitorInfo"));
+ if ( !gs_GetMonitorInfo )
+ return;
+
+ ms_supportsMultimon = 1;
+
+ // we can safely let dllUser32 go out of scope, the DLL itself will
+ // still remain loaded as all Win32 programs use it
+ }
}
-// ---------------------------------------------------------------------------
-// wxDisplay
-// ---------------------------------------------------------------------------
+void wxDisplayFactoryWin32Base::Clear()
+{
+ WX_CLEAR_ARRAY(m_displays);
+}
-// helper of GetFromPoint() and GetFromWindow()
-static int DisplayFromHMONITOR(HMONITOR hmon)
+wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base()
+{
+ Clear();
+}
+
+// helper for GetFromPoint() and GetFromWindow()
+int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const
{
if ( hmon )
{
- const size_t count = wxDisplay::GetCount();
-
+ const size_t count = m_displays.size();
for ( size_t n = 0; n < count; n++ )
{
- if ( hmon == (*g_displays)[n].m_hmon )
+ if ( hmon == m_displays[n]->m_hmon )
return n;
}
}
return wxNOT_FOUND;
}
-/* static */
-size_t wxDisplayBase::GetCount()
-{
- 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( g_displays->GetCount() == (size_t)::GetSystemMetrics(SM_CMONITORS),
- _T("So how many displays does this system have?") );
-
- return g_displays->GetCount();
-}
-
-/* static */
-int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
+int wxDisplayFactoryWin32Base::GetFromPoint(const wxPoint& pt)
{
POINT pt2;
pt2.x = pt.x;
pt2.y = pt.y;
- return DisplayFromHMONITOR(::MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL));
+ return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
+ MONITOR_DEFAULTTONULL));
}
-/* static */
-int wxDisplayBase::GetFromWindow(wxWindow *window)
+int wxDisplayFactoryWin32Base::GetFromWindow(wxWindow *window)
{
- return DisplayFromHMONITOR
- (
- ::MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL)
- );
+ return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+ MONITOR_DEFAULTTONULL));
}
-wxDisplay::wxDisplay ( size_t n )
- : wxDisplayBase ( n )
+// ============================================================================
+// wxDisplay implementation using Win32 multimon API
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon initialization
+// ----------------------------------------------------------------------------
+
+wxDisplayFactoryMultimon::wxDisplayFactoryMultimon()
{
- // if we do this in ctor we won't have to call it from all the member
- // functions
- InitDisplays();
+ if ( !ms_supportsMultimon )
+ return;
+
+ // look up EnumDisplayMonitors() which we don't need with DirectDraw
+ // implementation
+ EnumDisplayMonitors_t pfnEnumDisplayMonitors;
+ {
+ wxLogNull noLog;
+
+ wxDynamicLibrary dllUser32(_T("user32.dll"));
+ pfnEnumDisplayMonitors = (EnumDisplayMonitors_t)
+ dllUser32.GetSymbol(wxT("EnumDisplayMonitors"));
+ if ( !pfnEnumDisplayMonitors )
+ return;
+ }
+
+ // enumerate all displays
+ if ( !pfnEnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) )
+ {
+ wxLogLastError(wxT("EnumDisplayMonitors"));
+ }
}
-wxRect wxDisplay::GetGeometry() 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)
+)
{
- return (*g_displays)[m_index].m_rect;
+ wxDisplayFactoryMultimon *const self = (wxDisplayFactoryMultimon *)dwData;
+ self->AddDisplay(hMonitor, lprcMonitor);
+
+ // continue the enumeration
+ return TRUE;
}
-wxString wxDisplay::GetName() const
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon helper functions
+// ----------------------------------------------------------------------------
+
+void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor)
{
- wxDisplayInfo& dpyInfo = (*g_displays)[m_index];
- if ( dpyInfo.m_devName.empty() )
- {
- MONITORINFOEX monInfo;
- wxZeroMemory(monInfo);
- monInfo.cbSize = sizeof(monInfo);
+ wxDisplayInfo *info = new wxDisplayInfo(hMonitor);
- if ( !::GetMonitorInfo(dpyInfo.m_hmon, &monInfo) )
- {
- wxLogLastError(_T("GetMonitorInfo"));
- }
- else
- {
- dpyInfo.m_devName = monInfo.szDevice;
- }
- }
+ // we also store the display geometry
+ info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top,
+ lprcMonitor->right - lprcMonitor->left,
+ lprcMonitor->bottom - lprcMonitor->top);
- return dpyInfo.m_devName;
+ // now add this monitor to the array
+ m_displays.Add(info);
}
-wxString wxDisplay::GetNameForEnumSettings() const
-{
- int major, minor;
- const bool isWin95 = wxGetOsVersion(&major, &minor) == wxWIN95 &&
- major == 4 && minor == 0;
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon inherited pure virtuals implementation
+// ----------------------------------------------------------------------------
- // 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();
+wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(size_t n)
+{
+ wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
- return name;
+ return new wxDisplayImplMultimon(n, *(m_displays[n]));
}
-wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const
+// ----------------------------------------------------------------------------
+// wxDisplayImplMultimon implementation
+// ----------------------------------------------------------------------------
+
+wxArrayVideoModes
+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++ )
return modes;
}
-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;
-}
+ DEVMODE *pDevMode;
-bool wxDisplay::ChangeMode(const wxVideoMode& mode)
-{
- // prepare ChangeDisplaySettingsEx() parameters
- DEVMODE dm,
- *pDevMode;
int flags;
if ( mode == wxDefaultVideoMode )
}
else // change to the given mode
{
- wxCHECK_MSG( mode.w && mode.h, FALSE,
+ wxCHECK_MSG( mode.w && mode.h, false,
_T("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;
pDevMode = &dm;
+#ifdef __WXWINCE__
+ flags = 0;
+#else // !__WXWINCE__
flags = CDS_FULLSCREEN;
+#endif // __WXWINCE__/!__WXWINCE__
}
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
{
case DISP_CHANGE_SUCCESSFUL:
// ok
- return TRUE;
+ {
+ // 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:
// don't complain about this, this is the only "expected" error
wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
}
- return FALSE;
+ return false;
}
-#endif // wxUSE_DISPLAY
+// ============================================================================
+// DirectDraw-based wxDisplay implementation
+// ============================================================================
+
+#if wxUSE_DIRECTDRAW
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryDirectDraw initialization
+// ----------------------------------------------------------------------------
+
+wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw()
+{
+ 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"));
+ }
+}
+
+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(size_t 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
projects / wxWidgets.git / blobdiff