#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"
#include "wx/display_impl.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 wxUSE_DIRECTDRAW. 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
-#endif
-
-// user may disable compilation of DirectDraw code by setting
-// wxUSE_DIRECTDRAW to 0 in the makefile/project settings
-#if defined(HAVE_DDRAW_H) && !defined(wxUSE_DIRECTDRAW)
- #define wxUSE_DIRECTDRAW 1
-#endif
+#include "wx/msw/wrapwin.h"
+#include "wx/msw/missing.h"
+#include "wx/msw/private.h"
+#include "wx/msw/private/hiddenwin.h"
#ifndef __WXWINCE__
// Older versions of windef.h don't define HMONITOR. Unfortunately, we
// 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 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
+// display functions are found in different DLLs under WinCE and normal Win32
+#ifdef __WXWINCE__
+static const wxChar displayDllName[] = wxT("coredll.dll");
+#else
+static const wxChar displayDllName[] = wxT("user32.dll");
+#endif
// ----------------------------------------------------------------------------
// typedefs for dynamically loaded Windows functions
DWORD dwFlags,
LPVOID lParam);
-#ifdef 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);
}
#endif // !__WXWINCE__
-// ----------------------------------------------------------------------------
-// display information classes
-// ----------------------------------------------------------------------------
-
-struct wxDisplayInfo
-{
- wxDisplayInfo(HMONITOR hmon = NULL)
- {
- m_hmon = hmon;
- m_flags = (DWORD)-1;
- }
-
- virtual ~wxDisplayInfo() { }
-
-
- // use GetMonitorInfo() to fill in all of our fields if needed (i.e. if it
- // hadn't been done before)
- void Initialize();
-
-
- // handle of this monitor used by MonitorXXX() functions, never NULL
- HMONITOR m_hmon;
-
- // the entire area of this monitor in virtual screen coordinates
- wxRect m_rect;
-
- // the work or client area, i.e. the area available for the normal windows
- wxRect m_rectClient;
-
- // the display device name for this monitor, empty initially and retrieved
- // on demand by DoGetName()
- wxString m_devName;
-
- // the flags of this monitor, also used as initialization marker: if this
- // is -1, GetMonitorInfo() hadn't been called yet
- DWORD m_flags;
-};
-
-WX_DEFINE_ARRAY_PTR(wxDisplayInfo *, wxDisplayInfoArray);
// ----------------------------------------------------------------------------
-// common base class for all Win32 wxDisplayImpl versions
+// wxDisplayMSW declaration
// ----------------------------------------------------------------------------
-class wxDisplayImplWin32Base : public wxDisplayImpl
+class wxDisplayMSW : public wxDisplayImpl
{
public:
- wxDisplayImplWin32Base(size_t n, wxDisplayInfo& info)
+ wxDisplayMSW(unsigned n, HMONITOR hmon)
: wxDisplayImpl(n),
- m_info(info)
+ m_hmon(hmon)
{
}
virtual bool IsPrimary() const;
virtual wxVideoMode GetCurrentMode() const;
+ virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+ virtual bool ChangeMode(const wxVideoMode& mode);
protected:
// convert a DEVMODE to our wxVideoMode
dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
}
- wxDisplayInfo& m_info;
+ // Call GetMonitorInfo() and fill in the provided struct and return true if
+ // it succeeded, otherwise return false.
+ bool GetMonInfo(MONITORINFOEX& monInfo) const;
+
+ HMONITOR m_hmon;
+
+private:
+ wxDECLARE_NO_COPY_CLASS(wxDisplayMSW);
};
+
// ----------------------------------------------------------------------------
-// common base class for all Win32 wxDisplayFactory versions
+// wxDisplayFactoryMSW declaration
// ----------------------------------------------------------------------------
-// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize()
+WX_DEFINE_ARRAY(HMONITOR, wxMonitorHandleArray);
+
+// functions dynamically bound by wxDisplayFactoryMSW ctor.
static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
static GetMonitorInfo_t gs_GetMonitorInfo = NULL;
+static EnumDisplayMonitors_t gs_EnumDisplayMonitors = NULL;
-class wxDisplayFactoryWin32Base : public wxDisplayFactory
+class wxDisplayFactoryMSW : public wxDisplayFactory
{
public:
- virtual ~wxDisplayFactoryWin32Base();
-
- 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();
-
- // find the monitor corresponding to the given handle, return wxNOT_FOUND
- // if not found
- int FindDisplayFromHMONITOR(HMONITOR hmon) const;
+ // bind the functions we need if this is the case and fills the
+ // m_displays array if they're available
+ wxDisplayFactoryMSW();
+ // Dtor destroys the hidden window we use for getting WM_SETTINGCHANGE.
+ virtual ~wxDisplayFactoryMSW();
- // 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)
-};
-
-// ----------------------------------------------------------------------------
-// wxDisplay implementation using Windows multi-monitor support functions
-// ----------------------------------------------------------------------------
-
-class wxDisplayImplMultimon : public wxDisplayImplWin32Base
-{
-public:
- wxDisplayImplMultimon(size_t n, wxDisplayInfo& info)
- : wxDisplayImplWin32Base(n, info)
- {
- }
+ bool IsOk() const { return !m_displays.empty(); }
- virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
- virtual bool ChangeMode(const wxVideoMode& mode);
+ 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:
- DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon)
-};
+ // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor
+ // handles.
+ static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); }
-class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
-{
-public:
- wxDisplayFactoryMultimon();
-
- virtual wxDisplayImpl *CreateDisplay(size_t n);
private:
// EnumDisplayMonitors() callback
LPRECT lprcMonitor,
LPARAM dwData);
+ // find the monitor corresponding to the given handle,
+ // return wxNOT_FOUND if not found
+ int FindDisplayFromHMONITOR(HMONITOR hmon) const;
- // add a monitor description to m_displays array
- void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor);
-};
-
-// ----------------------------------------------------------------------------
-// wxDisplay implementation using DirectDraw
-// ----------------------------------------------------------------------------
-
-#ifdef wxUSE_DIRECTDRAW
-
-struct wxDisplayInfoDirectDraw : wxDisplayInfo
-{
- wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name)
- : wxDisplayInfo(hmon),
- m_guid(guid)
- {
- m_pDD2 = NULL;
- m_devName = name;
- }
-
- virtual ~wxDisplayInfoDirectDraw()
- {
- if ( m_pDD2 )
- m_pDD2->Release();
- }
-
-
- // 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
-{
-public:
- wxDisplayImplDirectDraw(size_t n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
- : wxDisplayImplWin32Base(n, info),
- m_pDD2(pDD2)
- {
- m_pDD2->AddRef();
- }
-
- virtual ~wxDisplayImplDirectDraw()
- {
- m_pDD2->Release();
- }
-
- virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
- virtual bool ChangeMode(const wxVideoMode& mode);
-
-private:
- IDirectDraw2 *m_pDD2;
-
- DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw)
-};
-
-class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base
-{
-public:
- wxDisplayFactoryDirectDraw();
- virtual ~wxDisplayFactoryDirectDraw();
-
- virtual wxDisplayImpl *CreateDisplay(size_t n);
+ // Update m_displays array, used by RefreshMonitors().
+ void DoRefreshMonitors();
-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);
+ // The unique factory being used (as we don't have direct access to the
+ // global factory pointer in the common code so we just duplicate this
+ // variable (also making it of correct type for us) here).
+ static wxDisplayFactoryMSW* ms_factory;
- // ddraw.dll
- wxDynamicLibrary m_dllDDraw;
+ // the array containing information about all available displays, filled by
+ // MultimonEnumProc()
+ wxMonitorHandleArray m_displays;
- // dynamically resolved DirectDrawCreate()
- DirectDrawCreate_t m_pfnDirectDrawCreate;
+ // The hidden window we use for receiving WM_SETTINGCHANGE and its class
+ // name.
+ HWND m_hiddenHwnd;
+ const wxChar* m_hiddenClass;
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW);
};
-#endif // wxUSE_DIRECTDRAW
-
-
-// ============================================================================
-// common classes implementation
-// ============================================================================
+wxDisplayFactoryMSW* wxDisplayFactoryMSW::ms_factory = NULL;
// ----------------------------------------------------------------------------
-// wxDisplay
+// wxDisplay implementation
// ----------------------------------------------------------------------------
/* 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
-
-#ifdef wxUSE_DIRECTDRAW
- if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) )
- {
- wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
- if ( factoryDD->IsOk() )
- return factoryDD;
+ wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW;
- 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?)
+ // fall back to a stub implementation if no multimon support (Win95?)
return new wxDisplayFactorySingle;
}
+
// ----------------------------------------------------------------------------
-// wxDisplayInfo
+// wxDisplayMSW implementation
// ----------------------------------------------------------------------------
-void wxDisplayInfo::Initialize()
+bool wxDisplayMSW::GetMonInfo(MONITORINFOEX& monInfo) const
{
- if ( m_flags == (DWORD)-1 )
+ if ( !gs_GetMonitorInfo(m_hmon, &monInfo) )
{
- WinStruct<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;
+ wxLogLastError(wxT("GetMonitorInfo"));
+ return false;
}
-}
-// ----------------------------------------------------------------------------
-// wxDisplayImplWin32Base
-// ----------------------------------------------------------------------------
+ return true;
+}
-wxRect wxDisplayImplWin32Base::GetGeometry() const
+wxRect wxDisplayMSW::GetGeometry() const
{
- if ( m_info.m_rect.IsEmpty() )
- m_info.Initialize();
+ WinStruct<MONITORINFOEX> monInfo;
- return m_info.m_rect;
+ wxRect rect;
+ if ( GetMonInfo(monInfo) )
+ wxCopyRECTToRect(monInfo.rcMonitor, rect);
+
+ return rect;
}
-wxRect wxDisplayImplWin32Base::GetClientArea() const
+wxRect wxDisplayMSW::GetClientArea() const
{
- if ( m_info.m_rectClient.IsEmpty() )
- m_info.Initialize();
+ WinStruct<MONITORINFOEX> monInfo;
+
+ wxRect rectClient;
+ if ( GetMonInfo(monInfo) )
+ wxCopyRECTToRect(monInfo.rcWork, rectClient);
- return m_info.m_rectClient;
+ return rectClient;
}
-wxString wxDisplayImplWin32Base::GetName() const
+wxString wxDisplayMSW::GetName() const
{
- if ( m_info.m_devName.IsEmpty() )
- m_info.Initialize();
+ WinStruct<MONITORINFOEX> monInfo;
- return m_info.m_devName;
+ wxString name;
+ if ( GetMonInfo(monInfo) )
+ name = monInfo.szDevice;
+
+ return name;
}
-bool wxDisplayImplWin32Base::IsPrimary() const
+bool wxDisplayMSW::IsPrimary() const
{
- if ( m_info.m_flags == (DWORD)-1 )
- m_info.Initialize();
+ WinStruct<MONITORINFOEX> monInfo;
+
+ if ( !GetMonInfo(monInfo) )
+ return false;
- return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;
+ return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0;
}
-wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
+wxVideoMode wxDisplayMSW::GetCurrentMode() const
{
wxVideoMode mode;
// 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
{
return mode;
}
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryWin32Base
-// ----------------------------------------------------------------------------
-
-int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1;
-
-wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base()
-{
- 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
- }
-}
-
-void wxDisplayFactoryWin32Base::Clear()
-{
- WX_CLEAR_ARRAY(m_displays);
-}
-
-wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base()
-{
- Clear();
-}
-
-// helper for GetFromPoint() and GetFromWindow()
-int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const
-{
- if ( hmon )
- {
- const size_t count = m_displays.size();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( hmon == m_displays[n]->m_hmon )
- return n;
- }
- }
-
- return wxNOT_FOUND;
-}
-
-int wxDisplayFactoryWin32Base::GetFromPoint(const wxPoint& pt)
-{
- POINT pt2;
- pt2.x = pt.x;
- pt2.y = pt.y;
-
- return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
- MONITOR_DEFAULTTONULL));
-}
-
-int wxDisplayFactoryWin32Base::GetFromWindow(wxWindow *window)
-{
- return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
- MONITOR_DEFAULTTONULL));
-}
-
-// ============================================================================
-// wxDisplay implementation using Win32 multimon API
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryMultimon initialization
-// ----------------------------------------------------------------------------
-
-wxDisplayFactoryMultimon::wxDisplayFactoryMultimon()
-{
- if ( !ms_supportsMultimon )
- return;
-
- // look up EnumDisplayMonitors() 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"));
- }
-}
-
-/* static */
-BOOL CALLBACK
-wxDisplayFactoryMultimon::MultimonEnumProc(
- HMONITOR hMonitor, // handle to display monitor
- HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context
- LPRECT lprcMonitor, // pointer to monitor intersection rectangle
- LPARAM dwData // data passed from EnumDisplayMonitors (this)
-)
-{
- wxDisplayFactoryMultimon *const self = (wxDisplayFactoryMultimon *)dwData;
- self->AddDisplay(hMonitor, lprcMonitor);
-
- // continue the enumeration
- return TRUE;
-}
-
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryMultimon helper functions
-// ----------------------------------------------------------------------------
-
-void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor)
-{
- wxDisplayInfo *info = new wxDisplayInfo(hMonitor);
-
- // we also store the display geometry
- info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top,
- lprcMonitor->right - lprcMonitor->left,
- lprcMonitor->bottom - lprcMonitor->top);
-
- // now add this monitor to the array
- m_displays.Add(info);
-}
-
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryMultimon inherited pure virtuals implementation
-// ----------------------------------------------------------------------------
-
-wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(size_t n)
-{
- wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
-
- return new wxDisplayImplMultimon(n, *(m_displays[n]));
-}
-
-// ----------------------------------------------------------------------------
-// wxDisplayImplMultimon implementation
-// ----------------------------------------------------------------------------
-
-wxArrayVideoModes
-wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const
+wxArrayVideoModes wxDisplayMSW::GetModes(const wxVideoMode& modeMatch) const
{
wxArrayVideoModes modes;
// 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;
+
for ( int iModeNum = 0;
::EnumDisplaySettings(deviceName, iModeNum, &dm);
iModeNum++ )
return modes;
}
-bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
+bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode)
{
// prepare ChangeDisplaySettingsEx() parameters
DEVMODE dm;
}
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;
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.GetSymbolAorW(_T("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 )
// 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;
break;
default:
- wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
+ wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") );
}
return false;
}
-// ============================================================================
-// DirectDraw-based wxDisplay implementation
-// ============================================================================
-
-#if wxUSE_DIRECTDRAW
-
// ----------------------------------------------------------------------------
-// wxDisplayFactoryDirectDraw initialization
+// wxDisplayFactoryMSW implementation
// ----------------------------------------------------------------------------
-wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw()
+LRESULT APIENTRY
+wxDisplayWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
- if ( !ms_supportsMultimon )
- return;
+ if ( msg == WM_SETTINGCHANGE )
+ {
+ wxDisplayFactoryMSW::RefreshMonitors();
-#if wxUSE_LOG
- // suppress the errors if ddraw.dll is not found, we're prepared to handle
- // this
- wxLogNull noLog;
-#endif
+ return 0;
+ }
- m_dllDDraw.Load(_T("ddraw.dll"));
+ return ::DefWindowProc(hwnd, msg, wParam, lParam);
+}
- if ( !m_dllDDraw.IsLoaded() )
- return;
+wxDisplayFactoryMSW::wxDisplayFactoryMSW()
+{
+ // This is not supposed to happen with the current code, the factory is
+ // implicitly a singleton.
+ wxASSERT_MSG( !ms_factory, wxS("Using more than one factory?") );
- DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
- m_dllDDraw.GetSymbolAorW(_T("DirectDrawEnumerateEx"));
- if ( !pDDEnumEx )
- return;
+ ms_factory = this;
- // 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;
+ m_hiddenHwnd = NULL;
+ m_hiddenClass = NULL;
- if ( (*pDDEnumEx)(DDEnumExCallback,
- this,
- DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
+ if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL
+ || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL )
{
- 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();
-}
+ // First initialization, or last initialization failed.
+ wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
-// ----------------------------------------------------------------------------
-// callbacks for monitor/modes enumeration stuff
-// ----------------------------------------------------------------------------
+ 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);
-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);
+ // we can safely let dllDisplay go out of scope, the DLL itself will
+ // still remain loaded as all programs link to it statically anyhow
}
- //else: we're called for the primary monitor, skip it
-
- // continue the enumeration
- return TRUE;
-}
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryDirectDraw helpers
-// ----------------------------------------------------------------------------
+ if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL
+ || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL )
+ return;
-void wxDisplayFactoryDirectDraw::AddDisplay(const GUID& guid,
- HMONITOR hmon,
- LPTSTR name)
-{
- m_displays.Add(new wxDisplayInfoDirectDraw(guid, hmon, name));
+ DoRefreshMonitors();
+
+ // Also create a hidden window to listen for WM_SETTINGCHANGE that we
+ // receive when a monitor is added to or removed from the system as we must
+ // refresh our monitor handles information then.
+ m_hiddenHwnd = wxCreateHiddenWindow
+ (
+ &m_hiddenClass,
+ wxT("wxDisplayHiddenWindow"),
+ wxDisplayWndProc
+ );
}
-// ----------------------------------------------------------------------------
-// wxDisplayFactoryDirectDraw inherited pure virtuals implementation
-// ----------------------------------------------------------------------------
-
-wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(size_t n)
+wxDisplayFactoryMSW::~wxDisplayFactoryMSW()
{
- wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
-
- wxDisplayInfoDirectDraw *
- info = wx_static_cast(wxDisplayInfoDirectDraw *, m_displays[n]);
-
- if ( !info->m_pDD2 )
+ if ( m_hiddenHwnd )
{
- IDirectDraw *pDD;
- GUID guid(info->m_guid);
- HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL);
-
- if ( FAILED(hr) || !pDD )
+ if ( !::DestroyWindow(m_hiddenHwnd) )
{
- // what to do??
- wxLogApiError(_T("DirectDrawCreate"), hr);
- return NULL;
+ wxLogLastError(wxT("DestroyWindow(wxDisplayHiddenWindow)"));
}
- // we got IDirectDraw, but we need IDirectDraw2
- hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2);
- pDD->Release();
-
- if ( FAILED(hr) || !info->m_pDD2 )
+ if ( m_hiddenClass )
{
- wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
- return NULL;
+ if ( !::UnregisterClass(m_hiddenClass, wxGetInstance()) )
+ {
+ wxLogLastError(wxT("UnregisterClass(wxDisplayHiddenWindow)"));
+ }
}
-
- // 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);
+ ms_factory = NULL;
}
-// ============================================================================
-// wxDisplayImplDirectDraw
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// video modes enumeration
-// ----------------------------------------------------------------------------
-
-// tiny helper class used to pass information from GetModes() to
-// wxDDEnumModesCallback
-class wxDDVideoModesAdder
+void wxDisplayFactoryMSW::DoRefreshMonitors()
{
-public:
- // our Add() method will add modes matching modeMatch to modes array
- wxDDVideoModesAdder(wxArrayVideoModes& modes, const wxVideoMode& modeMatch)
- : m_modes(modes),
- m_modeMatch(modeMatch)
- {
- }
+ m_displays.Clear();
- void Add(const wxVideoMode& mode)
+ if ( !gs_EnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) )
{
- if ( mode.Matches(m_modeMatch) )
- m_modes.Add(mode);
+ wxLogLastError(wxT("EnumDisplayMonitors"));
}
+}
-private:
- wxArrayVideoModes& m_modes;
- const wxVideoMode& m_modeMatch;
-
- DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder)
-};
-
-HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
- LPVOID lpContext)
+/* 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)
{
- // 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);
+ wxDisplayFactoryMSW *const self = (wxDisplayFactoryMSW *)dwData;
- vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
- lpDDSurfaceDesc->dwHeight,
- lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
- lpDDSurfaceDesc->dwRefreshRate));
- }
+ self->m_displays.Add(hMonitor);
// continue the enumeration
- return DDENUMRET_OK;
+ return TRUE;
}
-wxArrayVideoModes
-wxDisplayImplDirectDraw::GetModes(const wxVideoMode& modeMatch) const
+wxDisplayImpl *wxDisplayFactoryMSW::CreateDisplay(unsigned n)
{
- 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);
- }
+ wxCHECK_MSG( n < m_displays.size(), NULL, wxT("An invalid index was passed to wxDisplay") );
- return modes;
+ return new wxDisplayMSW(n, m_displays[n]);
}
-// ----------------------------------------------------------------------------
-// video mode switching
-// ----------------------------------------------------------------------------
-
-bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode)
+// helper for GetFromPoint() and GetFromWindow()
+int wxDisplayFactoryMSW::FindDisplayFromHMONITOR(HMONITOR hmon) const
{
- 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) )
+ if ( hmon )
{
- wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr);
-
- return false;
+ const size_t count = m_displays.size();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( hmon == m_displays[n] )
+ return n;
+ }
}
- hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
- if ( FAILED(hr) )
- {
- wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr);
+ return wxNOT_FOUND;
+}
- return false;
- }
+int wxDisplayFactoryMSW::GetFromPoint(const wxPoint& pt)
+{
+ POINT pt2;
+ pt2.x = pt.x;
+ pt2.y = pt.y;
- return true;
+ return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
+ MONITOR_DEFAULTTONULL));
}
-#endif // wxUSE_DIRECTDRAW
+int wxDisplayFactoryMSW::GetFromWindow(const wxWindow *window)
+{
+ return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+ MONITOR_DEFAULTTONULL));
+}
#endif // wxUSE_DISPLAY
projects / wxWidgets.git / blobdiff