#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/dynlib.h"
+#include "wx/sysopt.h"
-#include "wx/display.h"
-
-// Mingw's w32api headers don't include ddraw.h, though the user may have
-// installed it. If using configure, we actually probe for ddraw.h there
-// and set HAVE_DDRAW_H. Otherwise, assume we don't have it if using
-// the w32api headers, and that we do otherwise.
-#if !defined HAVE_W32API_H && !defined HAVE_DDRAW_H
-#define HAVE_DDRAW_H 1
-#endif
+#include "wx/display_impl.h"
+#include "wx/msw/wrapwin.h"
+#include "wx/msw/missing.h"
+#include "wx/msw/private.h"
+#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 HAVE_DDRAW_H
-#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 } };
+// 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
// ----------------------------------------------------------------------------
DWORD dwFlags,
LPVOID lParam);
-#ifdef HAVE_DDRAW_H
-typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
- LPTSTR driverDescription,
- LPTSTR driverName,
- LPVOID lpContext,
- HMONITOR hmon);
-
-typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback,
- LPVOID lpContext,
- DWORD dwFlags);
-
-typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
- LPDIRECTDRAW *lplpDD,
- IUnknown *pUnkOuter);
-#endif
-
typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);
typedef BOOL (WINAPI *GetMonitorInfo_t)(HMONITOR,LPMONITORINFO);
-static EnumDisplayMonitors_t gs_EnumDisplayMonitors = NULL;
-static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
-static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
-static GetMonitorInfo_t gs_GetMonitorInfo = NULL;
-
-// ----------------------------------------------------------------------------
-// private classes
-// ----------------------------------------------------------------------------
-
-class wxDisplayInfo
-{
-public:
- // handle of this monitor used by MonitorXXX() functions, never NULL
- HMONITOR m_hmon;
-
- // IDirectDraw object used to control this display, may be NULL
-#ifdef HAVE_DDRAW_H
- IDirectDraw2 *m_pDD2;
-#else
- void *m_pDD2;
-#endif
-
- // DirectDraw GUID for this display, only valid when using DirectDraw
- GUID m_guid;
-
- // the entire area of this monitor in virtual screen coordinates
- wxRect m_rect;
-
- // the display device name for this monitor, empty initially and retrieved
- // on demand by DoGetName()
- wxString m_devName;
-
- wxDisplayInfo() { m_hmon = NULL; m_pDD2 = NULL; }
- ~wxDisplayInfo() {
-#ifdef HAVE_DDRAW_H
- if ( m_pDD2 ) m_pDD2->Release();
-#endif
- }
-};
-
-WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray);
-#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(wxDisplayInfoArray);
-
-// this module is used to cleanup gs_displays array
-class wxDisplayModule : public wxModule
+#ifndef __WXWINCE__
+// emulation of ChangeDisplaySettingsEx() for Win95
+LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
+ LPDEVMODE lpDevMode,
+ HWND WXUNUSED(hwnd),
+ DWORD dwFlags,
+ LPVOID WXUNUSED(lParam))
{
-public:
- virtual bool OnInit() { return true; }
- virtual void OnExit();
-
- DECLARE_DYNAMIC_CLASS(wxDisplayModule)
-};
+ return ::ChangeDisplaySettings(lpDevMode, dwFlags);
+}
+#endif // !__WXWINCE__
-IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
// ----------------------------------------------------------------------------
-// globals
+// wxDisplayMSW declaration
// ----------------------------------------------------------------------------
-#ifdef HAVE_DDRAW_H
-// do we use DirectX?
-static bool gs_useDirectX = false;
-#endif
-
-// Try to look up the functions needed for supporting multiple monitors. If
-// they aren't available (probably because we're running on Win95 or NT4 which
-// predate this API), set a flag which makes wxDisplay return results for a
-// single screen.
-static bool OsSupportsMultipleMonitors()
+class wxDisplayMSW : public wxDisplayImpl
{
- static int isNewEnough = -1;
- if ( isNewEnough == -1 )
+public:
+ wxDisplayMSW(unsigned n, HMONITOR hmon)
+ : wxDisplayImpl(n),
+ m_hmon(hmon)
{
- isNewEnough = 0;
- wxDynamicLibrary dllUser32(_T("user32.dll"));
- // Check for one of the symbols to avoid logging errors just because
- // we happen to be running on Win95 or NT4.
- if ( dllUser32.IsLoaded() &&
- dllUser32.HasSymbol(wxT("EnumDisplayMonitors")) )
- {
- // GetMonitorInfo has Unicode/ANSI variants, the others don't.
- gs_EnumDisplayMonitors = (EnumDisplayMonitors_t)
- dllUser32.GetSymbol(wxT("EnumDisplayMonitors"));
- gs_MonitorFromPoint = (MonitorFromPoint_t)
- dllUser32.GetSymbol(wxT("MonitorFromPoint"));
- gs_MonitorFromWindow = (MonitorFromWindow_t)
- dllUser32.GetSymbol(wxT("MonitorFromWindow"));
- gs_GetMonitorInfo = (GetMonitorInfo_t)
- dllUser32.GetSymbolAorW(wxT("GetMonitorInfo"));
- if ( gs_EnumDisplayMonitors != NULL &&
- gs_MonitorFromPoint != NULL &&
- gs_MonitorFromWindow != NULL &&
- gs_GetMonitorInfo != NULL )
- {
- isNewEnough = 1;
- }
- }
}
- return (isNewEnough != 0);
-}
-
-#ifdef HAVE_DDRAW_H
-// dynamically resolved DirectDrawCreate()
-static DirectDrawCreate_t gs_DirectDrawCreate = NULL;
-#endif
-
-// this is not really MT-unsafe as wxDisplay is only going to be used from the
-// main thread, i.e. we consider that it's a GUI class and so don't protect it
-static wxDisplayInfoArray *gs_displays = NULL;
-// ===========================================================================
-// implementation
-// ===========================================================================
-
-// ----------------------------------------------------------------------------
-// callbacks for monitor/modes enumeration stuff
-// ----------------------------------------------------------------------------
-
-static BOOL CALLBACK wxmswMonitorEnumProc (
- HMONITOR hMonitor, // handle to display monitor
- HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context
- LPRECT lprcMonitor, // pointer to monitor intersection rectangle
- LPARAM WXUNUSED(dwData) // data passed from EnumDisplayMonitors (unused)
-)
-{
- wxDisplayInfo *info = new wxDisplayInfo();
-
- // we need hMonitor to be able to map display id to it which is needed for
- // MonitorXXX() functions, in particular MonitorFromPoint()
- info->m_hmon = hMonitor;
-
- // we also store the display geometry
- info->m_rect.SetX ( lprcMonitor->left );
- info->m_rect.SetY ( lprcMonitor->top );
- info->m_rect.SetWidth ( lprcMonitor->right - lprcMonitor->left );
- info->m_rect.SetHeight ( lprcMonitor->bottom - lprcMonitor->top );
+ virtual wxRect GetGeometry() const;
+ virtual wxRect GetClientArea() const;
+ virtual wxString GetName() const;
+ virtual bool IsPrimary() const;
- // now add this monitor to the array
- gs_displays->Add(info);
-
- // continue the enumeration
- return true;
-}
+ virtual wxVideoMode GetCurrentMode() const;
+ virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+ virtual bool ChangeMode(const wxVideoMode& mode);
-#ifdef HAVE_DDRAW_H
-BOOL PASCAL
-wxDDEnumExCallback(GUID *pGuid,
- LPTSTR WXUNUSED(driverDescription),
- LPTSTR driverName,
- LPVOID WXUNUSED(lpContext),
- HMONITOR hmon)
-{
- if ( pGuid )
+protected:
+ // convert a DEVMODE to our wxVideoMode
+ static wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
{
- wxDisplayInfo *info = new wxDisplayInfo();
-
- info->m_hmon = hmon;
- info->m_guid = *pGuid;
- info->m_devName = driverName;
-
- gs_displays->Add(info);
+ // 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);
}
- //else: we're called for the primary monitor, skip it
- // continue the enumeration
- return true;
-}
+ // Call GetMonitorInfo() and fill in the provided struct and return true if
+ // it succeeded, otherwise return false.
+ bool GetMonInfo(MONITORINFOEX& monInfo) const;
-HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
- LPVOID lpContext)
-{
- // we need at least the mode size
- static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH;
- if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
- {
- wxArrayVideoModes * const modes = (wxArrayVideoModes *)lpContext;
+ HMONITOR m_hmon;
- modes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
- lpDDSurfaceDesc->dwHeight,
- lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
- lpDDSurfaceDesc->dwRefreshRate));
- }
+private:
+ wxDECLARE_NO_COPY_CLASS(wxDisplayMSW);
+};
- // continue the enumeration
- return DDENUMRET_OK;
-}
-#endif
// ----------------------------------------------------------------------------
-// local functions
+// wxDisplayFactoryMSW declaration
// ----------------------------------------------------------------------------
-#ifdef HAVE_DDRAW_H
-// initialize gs_displays using DirectX functions
-static bool DoInitDirectX()
-{
-#if wxUSE_LOG
- // suppress the errors if ddraw.dll is not found
- wxLog::EnableLogging(false);
-#endif
+WX_DEFINE_ARRAY(HMONITOR, wxMonitorHandleArray);
- wxDynamicLibrary dllDX(_T("ddraw.dll"));
+// 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;
-#if wxUSE_LOG
- wxLog::EnableLogging();
-#endif
+class wxDisplayFactoryMSW : public wxDisplayFactory
+{
+public:
+ // ctor checks if the current system supports multimon API and dynamically
+ // bind the functions we need if this is the case and fills the
+ // m_displays array if they're available
+ wxDisplayFactoryMSW();
- if ( !dllDX.IsLoaded() )
- return false;
+ // Dtor destroys the hidden window we use for getting WM_SETTINGCHANGE.
+ virtual ~wxDisplayFactoryMSW();
- DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
- dllDX.GetSymbolAorW(_T("DirectDrawEnumerateEx"));
- if ( !pDDEnumEx )
- return false;
+ bool IsOk() const { return !m_displays.empty(); }
- // we'll also need DirectDrawCreate() later, resolve it right now
- gs_DirectDrawCreate = (DirectDrawCreate_t)
- dllDX.GetSymbol(_T("DirectDrawCreate"));
- if ( !gs_DirectDrawCreate )
- return false;
+ 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);
- if ( (*pDDEnumEx)(wxDDEnumExCallback,
- NULL,
- DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
- {
- return false;
- }
+ // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor
+ // handles.
+ static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); }
- // ok, it seems like we're going to use DirectDraw and so we're going to
- // need ddraw.dll all the time, don't unload it
- dllDX.Detach();
- return true;
-}
-#endif
+private:
+ // EnumDisplayMonitors() callback
+ static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor,
+ HDC hdcMonitor,
+ LPRECT lprcMonitor,
+ LPARAM dwData);
-// initialize gs_displays using the standard Windows functions
-static void DoInitStdWindows()
-{
- // enumerate all displays
- if ( !gs_EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) )
- {
- wxLogLastError(wxT("EnumDisplayMonitors"));
+ // find the monitor corresponding to the given handle,
+ // return wxNOT_FOUND if not found
+ int FindDisplayFromHMONITOR(HMONITOR hmon) const;
- // TODO: still create at least one (valid) entry in gs_displays for the
- // primary display!
- }
-}
+ // Update m_displays array, used by RefreshMonitors().
+ void DoRefreshMonitors();
-// this function must be called before accessing gs_displays array as it
-// creates and initializes it
-static void InitDisplays()
-{
- if ( gs_displays )
- return;
- gs_displays = new wxDisplayInfoArray();
+ // 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;
-#ifdef HAVE_DDRAW_H
- if ( !gs_useDirectX || !DoInitDirectX() )
- {
- // either we were told not to try to use DirectX or fall back to std
- // functions if DirectX method failed
- gs_useDirectX = false;
- DoInitStdWindows();
- }
-#else
- DoInitStdWindows();
-#endif
-}
+ // the array containing information about all available displays, filled by
+ // MultimonEnumProc()
+ wxMonitorHandleArray m_displays;
-// 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);
-}
+ // The hidden window we use for receiving WM_SETTINGCHANGE and its class
+ // name.
+ HWND m_hiddenHwnd;
+ const wxChar* m_hiddenClass;
-#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__
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryMSW);
+};
+
+wxDisplayFactoryMSW* wxDisplayFactoryMSW::ms_factory = NULL;
// ----------------------------------------------------------------------------
-// wxDisplayModule
+// wxDisplay implementation
// ----------------------------------------------------------------------------
-void wxDisplayModule::OnExit()
+/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
- delete gs_displays;
-}
+ wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW;
-// ---------------------------------------------------------------------------
-// wxDisplay
-// ---------------------------------------------------------------------------
+ if ( factoryMM->IsOk() )
+ return factoryMM;
-/* static */
-void wxDisplay::UseDirectX(bool useDX)
-{
- wxCHECK_RET( !gs_displays, _T("it is too late to call UseDirectX") );
+ delete factoryMM;
-#ifdef HAVE_DDRAW_H
- // DirectDrawEnumerateEx requires Win98 or Win2k anyway.
- if ( OsSupportsMultipleMonitors() ) gs_useDirectX = useDX;
-#else
- wxUnusedVar(useDX);
-#endif
+ // fall back to a stub implementation if no multimon support (Win95?)
+ return new wxDisplayFactorySingle;
}
-// helper for GetFromPoint() and GetFromWindow()
-static int DisplayFromHMONITOR(HMONITOR hmon)
-{
- if ( hmon )
- {
- const size_t count = wxDisplay::GetCount();
- for ( size_t n = 0; n < count; n++ )
- {
- if ( hmon == (*gs_displays)[n].m_hmon )
- return n;
- }
- }
-
- return wxNOT_FOUND;
-}
-
-/* static */
-size_t wxDisplayBase::GetCount()
-{
- if ( !OsSupportsMultipleMonitors() ) return 1;
-
- InitDisplays();
-
- //RN: FIXME: This is wrong - the display info array should reload after every call
- //to GetCount() - otherwise it will not be accurate.
- //The user can change the number of displays in display properties/settings
- //after GetCount or similar is called and really mess this up...
- //wxASSERT_MSG( gs_displays->GetCount() == (size_t)::GetSystemMetrics(SM_CMONITORS),
- // _T("So how many displays does this system have?") );
-
- return gs_displays->GetCount();
-}
-
-/* static */
-int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
-{
- if ( !OsSupportsMultipleMonitors() )
- {
- const wxSize size = wxGetDisplaySize();
- if (pt.x >= 0 && pt.x < size.GetWidth() &&
- pt.y >= 0 && pt.y < size.GetHeight())
- {
- return 0;
- }
- return wxNOT_FOUND;
- }
-
- POINT pt2;
- pt2.x = pt.x;
- pt2.y = pt.y;
-
- return DisplayFromHMONITOR(gs_MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL));
-}
+// ----------------------------------------------------------------------------
+// wxDisplayMSW implementation
+// ----------------------------------------------------------------------------
-/* static */
-int wxDisplayBase::GetFromWindow(wxWindow *window)
+bool wxDisplayMSW::GetMonInfo(MONITORINFOEX& monInfo) const
{
- if ( !OsSupportsMultipleMonitors() )
+ if ( !gs_GetMonitorInfo(m_hmon, &monInfo) )
{
- const wxRect r(window->GetRect());
- const wxSize size = wxGetDisplaySize();
- if (r.x < size.GetWidth() && r.x + r.width >= 0 &&
- r.y < size.GetHeight() && r.y + r.height >= 0)
- {
- return 0;
- }
- return wxNOT_FOUND;
+ wxLogLastError(wxT("GetMonitorInfo"));
+ return false;
}
- return DisplayFromHMONITOR
- (
- gs_MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL)
- );
+ return true;
}
-// ----------------------------------------------------------------------------
-// wxDisplay ctor/dtor
-// ----------------------------------------------------------------------------
-
-wxDisplay::wxDisplay ( size_t n )
- : wxDisplayBase ( n )
+wxRect wxDisplayMSW::GetGeometry() const
{
- if ( !OsSupportsMultipleMonitors() ) return;
+ WinStruct<MONITORINFOEX> monInfo;
- // if we do this in ctor we won't have to call it from all the member
- // functions
- InitDisplays();
+ wxRect rect;
+ if ( GetMonInfo(monInfo) )
+ wxCopyRECTToRect(monInfo.rcMonitor, rect);
-#ifdef HAVE_DDRAW_H
- if ( gs_useDirectX )
- {
- wxDisplayInfo& dpyInfo = (*gs_displays)[n];
-
- LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
- if ( !pDD2 )
- {
- if ( !gs_DirectDrawCreate )
- {
- // what to do??
- return;
- }
-
- IDirectDraw *pDD;
- HRESULT hr = (*gs_DirectDrawCreate)(&dpyInfo.m_guid, &pDD, NULL);
-
- if ( FAILED(hr) || !pDD )
- {
- // what to do??
- wxLogApiError(_T("DirectDrawCreate"), hr);
- }
- else // got IDirectDraw, we want IDirectDraw2
- {
- hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&pDD2);
- if ( FAILED(hr) || !pDD2 )
- {
- wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
- }
-
- pDD->Release();
- }
- }
- //else: DirectDraw object corresponding to our display already exists
-
- // increment its ref count to account for Release() in dtor
- //
- // NB: pDD2 will be only really Release()d when gs_displays is
- // destroyed which is ok as we don't want to recreate DD objects
- // all the time
- pDD2->AddRef();
- }
-#endif
+ return rect;
}
-wxDisplay::~wxDisplay()
+wxRect wxDisplayMSW::GetClientArea() const
{
-#ifdef HAVE_DDRAW_H
- if ( !OsSupportsMultipleMonitors() ) return;
+ WinStruct<MONITORINFOEX> monInfo;
- wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
+ wxRect rectClient;
+ if ( GetMonInfo(monInfo) )
+ wxCopyRECTToRect(monInfo.rcWork, rectClient);
- LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
- if ( pDD2 )
- {
- pDD2->Release();
- }
-#endif
+ return rectClient;
}
-// ----------------------------------------------------------------------------
-// wxDisplay simple accessors
-// ----------------------------------------------------------------------------
-
-bool wxDisplay::IsOk() const
+wxString wxDisplayMSW::GetName() const
{
-#ifdef HAVE_DDRAW_H
- return m_index < GetCount() &&
- (!gs_useDirectX || (*gs_displays)[m_index].m_pDD2);
-#else
- return m_index < GetCount();
-#endif
-}
-
-wxRect wxDisplay::GetGeometry() const
-{
- if ( !OsSupportsMultipleMonitors() )
- {
- wxSize size = wxGetDisplaySize();
- return wxRect(0, 0, size.GetWidth(), size.GetHeight());
- }
+ WinStruct<MONITORINFOEX> monInfo;
- wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
- wxRect& rect = dpyInfo.m_rect;
- if ( !rect.width )
- {
- MONITORINFO monInfo;
- wxZeroMemory(monInfo);
- monInfo.cbSize = sizeof(monInfo);
+ wxString name;
+ if ( GetMonInfo(monInfo) )
+ name = monInfo.szDevice;
- if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, &monInfo) )
- {
- wxLogLastError(_T("GetMonitorInfo"));
- }
- else
- {
- wxCopyRECTToRect(monInfo.rcMonitor, rect);
- }
- }
-
- return rect;
+ return name;
}
-wxString wxDisplay::GetName() const
+bool wxDisplayMSW::IsPrimary() const
{
- if ( !OsSupportsMultipleMonitors() ) return wxT("");
+ WinStruct<MONITORINFOEX> monInfo;
- wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
- if ( dpyInfo.m_devName.empty() )
- {
- MONITORINFOEX monInfo;
- wxZeroMemory(monInfo);
- monInfo.cbSize = sizeof(monInfo);
-
- // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because
- // Mingw headers - unlike the ones from Microsoft's Platform SDK -
- // don't derive the former from the latter in C++ mode and so
- // the pointer's type is not converted implicitly.
- if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
- {
- wxLogLastError(_T("GetMonitorInfo"));
- }
- else
- {
- dpyInfo.m_devName = monInfo.szDevice;
- }
- }
+ if ( !GetMonInfo(monInfo) )
+ return false;
- return dpyInfo.m_devName;
+ return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0;
}
-// ----------------------------------------------------------------------------
-// determine if this is the primary display
-// ----------------------------------------------------------------------------
-
-bool wxDisplay::IsPrimary() const
+wxVideoMode wxDisplayMSW::GetCurrentMode() const
{
- if ( !OsSupportsMultipleMonitors() ) return true;
+ wxVideoMode mode;
- wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
+ // The first parameter of EnumDisplaySettings() must be NULL under Win95
+ // according to MSDN. The version of GetName() we implement for Win95
+ // returns an empty string.
+ const wxString name = GetName();
+ const wxChar * const deviceName = name.empty()
+ ? (const wxChar*)NULL
+ : (const wxChar*)name.c_str();
- MONITORINFOEX monInfo;
- wxZeroMemory(monInfo);
- monInfo.cbSize = sizeof(monInfo);
+ DEVMODE dm;
+ dm.dmSize = sizeof(dm);
+ dm.dmDriverExtra = 0;
- // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because
- // Mingw headers - unlike the ones from Microsoft's Platform SDK -
- // don't derive the former from the latter in C++ mode and so
- // the pointer's type is not converted implicitly.
- if ( !gs_GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
+ if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) )
{
- wxLogLastError(_T("GetMonitorInfo"));
+ wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
}
-
- return (monInfo.dwFlags & MONITORINFOF_PRIMARY) == MONITORINFOF_PRIMARY;
-}
-
-// ----------------------------------------------------------------------------
-// video modes enumeration
-// ----------------------------------------------------------------------------
-
-#ifdef HAVE_DDRAW_H
-wxArrayVideoModes
-wxDisplay::DoGetModesDirectX(const wxVideoMode& WXUNUSED(modeMatch)) const
-{
- wxArrayVideoModes modes;
-
- IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2;
-
- if ( pDD )
+ else
{
- HRESULT hr = pDD->EnumDisplayModes
- (
- DDEDM_REFRESHRATES,
- NULL, // all modes (TODO: use modeMatch!)
- &modes, // callback parameter
- wxDDEnumModesCallback
- );
-
- if ( FAILED(hr) )
- {
- wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
- }
+ mode = ConvertToVideoMode(dm);
}
- return modes;
+ return mode;
}
-#endif
-wxArrayVideoModes
-wxDisplay::DoGetModesWindows(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;
}
-wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const
-{
-#ifdef HAVE_DDRAW_H
- return gs_useDirectX ? DoGetModesDirectX(modeMatch)
- : DoGetModesWindows(modeMatch);
-#else
- return DoGetModesWindows(modeMatch);
-#endif
-}
-
-wxVideoMode wxDisplay::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;
-}
-
-// ----------------------------------------------------------------------------
-// video mode switching
-// ----------------------------------------------------------------------------
-
-#ifdef HAVE_DDRAW_H
-bool wxDisplay::DoChangeModeDirectX(const wxVideoMode& mode)
-{
- IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2;
- if ( !pDD )
- return false;
-
- wxWindow *winTop = wxTheApp->GetTopWindow();
- wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") );
-
- 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;
-}
-#endif
-
-bool wxDisplay::DoChangeModeWindows(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().t_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;
}
-bool wxDisplay::ChangeMode(const wxVideoMode& mode)
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMSW implementation
+// ----------------------------------------------------------------------------
+
+LRESULT APIENTRY
+wxDisplayWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ if ( msg == WM_SETTINGCHANGE )
+ {
+ wxDisplayFactoryMSW::RefreshMonitors();
+
+ return 0;
+ }
+
+ return ::DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+wxDisplayFactoryMSW::wxDisplayFactoryMSW()
+{
+ // This is not supposed to happen with the current code, the factory is
+ // implicitly a singleton.
+ wxASSERT_MSG( !ms_factory, wxS("Using more than one factory?") );
+
+ ms_factory = this;
+
+ m_hiddenHwnd = NULL;
+ m_hiddenClass = NULL;
+
+ if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL
+ || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL )
+ {
+ // First initialization, or last initialization failed.
+ wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+
+ wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay);
+ wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay);
+ wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay);
+ wxDL_INIT_FUNC(gs_, EnumDisplayMonitors, dllDisplay);
+
+ // we can safely let dllDisplay go out of scope, the DLL itself will
+ // still remain loaded as all programs link to it statically anyhow
+ }
+
+ if ( gs_MonitorFromPoint==NULL || gs_MonitorFromWindow==NULL
+ || gs_GetMonitorInfo==NULL || gs_EnumDisplayMonitors==NULL )
+ return;
+
+ DoRefreshMonitors();
+
+ // Also create a hidden window to listen for WM_SETTINGCHANGE that we
+ // receive when a monitor is added to or removed from the system as we must
+ // refresh our monitor handles information then.
+ m_hiddenHwnd = wxCreateHiddenWindow
+ (
+ &m_hiddenClass,
+ wxT("wxDisplayHiddenWindow"),
+ wxDisplayWndProc
+ );
+}
+
+wxDisplayFactoryMSW::~wxDisplayFactoryMSW()
+{
+ if ( m_hiddenHwnd )
+ {
+ if ( !::DestroyWindow(m_hiddenHwnd) )
+ {
+ wxLogLastError(wxT("DestroyWindow(wxDisplayHiddenWindow)"));
+ }
+
+ if ( m_hiddenClass )
+ {
+ if ( !::UnregisterClass(m_hiddenClass, wxGetInstance()) )
+ {
+ wxLogLastError(wxT("UnregisterClass(wxDisplayHiddenWindow)"));
+ }
+ }
+ }
+
+ ms_factory = NULL;
+}
+
+void wxDisplayFactoryMSW::DoRefreshMonitors()
+{
+ m_displays.Clear();
+
+ if ( !gs_EnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) )
+ {
+ wxLogLastError(wxT("EnumDisplayMonitors"));
+ }
+}
+
+/* static */
+BOOL CALLBACK
+wxDisplayFactoryMSW::MultimonEnumProc(
+ HMONITOR hMonitor, // handle to display monitor
+ HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context
+ LPRECT WXUNUSED(lprcMonitor), // pointer to monitor intersection rectangle
+ LPARAM dwData) // data passed from EnumDisplayMonitors (this)
+{
+ wxDisplayFactoryMSW *const self = (wxDisplayFactoryMSW *)dwData;
+
+ self->m_displays.Add(hMonitor);
+
+ // continue the enumeration
+ return TRUE;
+}
+
+wxDisplayImpl *wxDisplayFactoryMSW::CreateDisplay(unsigned n)
+{
+ wxCHECK_MSG( n < m_displays.size(), NULL, wxT("An invalid index was passed to wxDisplay") );
+
+ return new wxDisplayMSW(n, m_displays[n]);
+}
+
+// helper for GetFromPoint() and GetFromWindow()
+int wxDisplayFactoryMSW::FindDisplayFromHMONITOR(HMONITOR hmon) const
+{
+ if ( hmon )
+ {
+ const size_t count = m_displays.size();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ if ( hmon == m_displays[n] )
+ return n;
+ }
+ }
+
+ return wxNOT_FOUND;
+}
+
+int wxDisplayFactoryMSW::GetFromPoint(const wxPoint& pt)
{
-#ifdef HAVE_DDRAW_H
- return gs_useDirectX ? DoChangeModeDirectX(mode)
- : DoChangeModeWindows(mode);
+ POINT pt2;
+ pt2.x = pt.x;
+ pt2.y = pt.y;
+
+ return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
+ MONITOR_DEFAULTTONULL));
+}
+
+int wxDisplayFactoryMSW::GetFromWindow(const wxWindow *window)
+{
+#ifdef __WXMSW__
+ return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+ MONITOR_DEFAULTTONULL));
#else
- return DoChangeModeWindows(mode);
+ const wxSize halfsize = window->GetSize() / 2;
+ wxPoint pt = window->GetScreenPosition();
+ pt.x += halfsize.x;
+ pt.y += halfsize.y;
+ return GetFromPoint(pt);
#endif
}
#endif // wxUSE_DISPLAY
+
+void wxClientDisplayRect(int *x, int *y, int *width, int *height)
+{
+#if defined(__WXMICROWIN__)
+ *x = 0; *y = 0;
+ wxDisplaySize(width, height);
+#else
+ // Determine the desktop dimensions minus the taskbar and any other
+ // special decorations...
+ RECT r;
+
+ SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
+ if (x) *x = r.left;
+ if (y) *y = r.top;
+ if (width) *width = r.right - r.left;
+ if (height) *height = r.bottom - r.top;
+#endif
+}
projects / wxWidgets.git / blobdiff