Update copyright year in the version information resource.

[wxWidgets.git] / src / msw / display.cpp

diff --git a/src/msw/display.cpp b/src/msw/display.cpp
index 3a0844c3cec678ba3fa7bb6b630d249d2c78c479..ae087f9cd94683fb6cfc7ba358d783a283ebe2ae 100644 (file)
--- a/src/msw/display.cpp
+++ b/src/msw/display.cpp
@@ -27,27 +27,22 @@
 
 #if wxUSE_DISPLAY
 
 
 #if wxUSE_DISPLAY
 

+#include "wx/display.h"
+

 #ifndef WX_PRECOMP
     #include "wx/dynarray.h"
     #include "wx/app.h"
     #include "wx/frame.h"
 #endif
 
 #ifndef WX_PRECOMP
     #include "wx/dynarray.h"
     #include "wx/app.h"
     #include "wx/frame.h"
 #endif
 

-#include "wx/msw/missing.h"
-
-#include "wx/dynload.h"
+#include "wx/dynlib.h"

 #include "wx/sysopt.h"
 
 #include "wx/sysopt.h"
 

-#include "wx/display.h"

 #include "wx/display_impl.h"
 #include "wx/display_impl.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
-
-#if !defined(wxUSE_DIRECTDRAW)
-    #define wxUSE_DIRECTDRAW 0
-#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
 
 #ifndef __WXWINCE__
     // Older versions of windef.h don't define HMONITOR.  Unfortunately, we


@@ -76,14 +71,12 @@
     #endif
 #endif // !__WXWINCE__
 
     #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
+// 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
 
 // ----------------------------------------------------------------------------
 // typedefs for dynamically loaded Windows functions


@@ -95,22 +88,6 @@ typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName,
                                                  DWORD dwFlags,
                                                  LPVOID lParam);
 
                                                  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 *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
 typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
 typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);


@@ -128,56 +105,17 @@ LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
 }
 #endif // !__WXWINCE__
 
 }
 #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:
 {
 public:

-    wxDisplayImplWin32Base(size_t n, wxDisplayInfo& info)
+    wxDisplayMSW(unsigned n, HMONITOR hmon)

         : wxDisplayImpl(n),
         : wxDisplayImpl(n),

-          m_info(info)
+          m_hmon(hmon)

     {
     }
 
     {
     }
 


@@ -187,6 +125,8 @@ public:
     virtual bool IsPrimary() const;
 
     virtual wxVideoMode GetCurrentMode() const;
     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
 
 protected:
     // convert a DEVMODE to our wxVideoMode


@@ -201,81 +141,51 @@ protected:
                            dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
     }
 
                            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 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:
 {
 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
     // 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)
-    {
-    }
-
-    virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
-    virtual bool ChangeMode(const wxVideoMode& mode);
+    bool IsOk() const { return !m_displays.empty(); }

 
 

-private:
-    DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon)
-};
+    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);

 
 

-class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
-{
-public:
-    wxDisplayFactoryMultimon();
+    // Called when we receive WM_SETTINGCHANGE to refresh the list of monitor
+    // handles.
+    static void RefreshMonitors() { ms_factory->DoRefreshMonitors(); }

 
 

-    virtual wxDisplayImpl *CreateDisplay(size_t n);

 
 private:
     // EnumDisplayMonitors() callback
 
 private:
     // EnumDisplayMonitors() callback


@@ -284,196 +194,111 @@ private:
                                           LPRECT lprcMonitor,
                                           LPARAM dwData);
 
                                           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
-// ----------------------------------------------------------------------------
-
-#if 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()
 {
 // ----------------------------------------------------------------------------
 
 /* 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")) )
-    {
-        wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
-        if ( factoryDD->IsOk() )
-            return factoryDD;
-
-        delete factoryDD;
-    }
-#endif // wxUSE_DIRECTDRAW
+    wxDisplayFactoryMSW *factoryMM = new wxDisplayFactoryMSW;

 
 

-    wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon;

     if ( factoryMM->IsOk() )
         return factoryMM;
 
     delete factoryMM;
 
     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;
 }
 
     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;
+
+    wxRect rect;
+    if ( GetMonInfo(monInfo) )
+        wxCopyRECTToRect(monInfo.rcMonitor, rect);

 
 

-    return m_info.m_rect;
+    return rect;

 }
 
 }
 

-wxRect wxDisplayImplWin32Base::GetClientArea() const
+wxRect wxDisplayMSW::GetClientArea() const

 {
 {

-    if ( m_info.m_rectClient.IsEmpty() )
-        m_info.Initialize();
+    WinStruct<MONITORINFOEX> monInfo;

 
 

-    return m_info.m_rectClient;
+    wxRect rectClient;
+    if ( GetMonInfo(monInfo) )
+        wxCopyRECTToRect(monInfo.rcWork, rectClient);
+
+    return rectClient;

 }
 
 }
 

-wxString wxDisplayImplWin32Base::GetName() const
+wxString wxDisplayMSW::GetName() const

 {
 {

-    if ( m_info.m_devName.IsEmpty() )
-        m_info.Initialize();
+    WinStruct<MONITORINFOEX> monInfo;
+
+    wxString name;
+    if ( GetMonInfo(monInfo) )
+        name = monInfo.szDevice;

 
 

-    return m_info.m_devName;
+    return name;

 }
 
 }
 

-bool wxDisplayImplWin32Base::IsPrimary() const
+bool wxDisplayMSW::IsPrimary() const

 {
 {

-    if ( m_info.m_flags == (DWORD)-1 )
-        m_info.Initialize();
+    WinStruct<MONITORINFOEX> monInfo;

 
 

-    return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;
+    if ( !GetMonInfo(monInfo) )
+        return false;
+
+    return (monInfo.dwFlags & MONITORINFOF_PRIMARY) != 0;

 }
 
 }
 

-wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
+wxVideoMode wxDisplayMSW::GetCurrentMode() const

 {
     wxVideoMode mode;
 
 {
     wxVideoMode mode;
 


@@ -481,14 +306,17 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
     // according to MSDN.  The version of GetName() we implement for Win95
     // returns an empty string.
     const wxString name = GetName();
     // 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;
 
     DEVMODE dm;
     dm.dmSize = sizeof(dm);
     dm.dmDriverExtra = 0;

+

     if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) )
     {
     if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) )
     {

-        wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
+        wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));

     }
     else
     {
     }
     else
     {


@@ -498,169 +326,7 @@ wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
     return mode;
 }
 
     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;
 
 {
     wxArrayVideoModes modes;
 


@@ -668,11 +334,14 @@ wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const
     // according to MSDN.  The version of GetName() we implement for Win95
     // returns an empty string.
     const wxString name = GetName();
     // 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;
 
     DEVMODE dm;
     dm.dmSize = sizeof(dm);
     dm.dmDriverExtra = 0;

+

     for ( int iModeNum = 0;
           ::EnumDisplaySettings(deviceName, iModeNum, &dm);
           iModeNum++ )
     for ( int iModeNum = 0;
           ::EnumDisplaySettings(deviceName, iModeNum, &dm);
           iModeNum++ )


@@ -687,7 +356,7 @@ wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const
     return modes;
 }
 
     return modes;
 }
 

-bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
+bool wxDisplayMSW::ChangeMode(const wxVideoMode& mode)

 {
     // prepare ChangeDisplaySettingsEx() parameters
     DEVMODE dm;
 {
     // prepare ChangeDisplaySettingsEx() parameters
     DEVMODE dm;


@@ -703,26 +372,26 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
     }
     else // change to the given mode
     {
     }
     else // change to the given mode
     {

-        wxCHECK_MSG( mode.w && mode.h, false,
-                        _T("at least the width and height must be specified") );
+        wxCHECK_MSG( mode.GetWidth() && mode.GetHeight(), false,
+                        wxT("at least the width and height must be specified") );

 
         wxZeroMemory(dm);
         dm.dmSize = sizeof(dm);
         dm.dmDriverExtra = 0;
         dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
 
         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.dmFields |= DM_BITSPERPEL;

-            dm.dmBitsPerPel = mode.bpp;
+            dm.dmBitsPerPel = mode.GetDepth();

         }
 
         }
 

-        if ( mode.refresh )
+        if ( mode.GetRefresh() )

         {
             dm.dmFields |= DM_DISPLAYFREQUENCY;
         {
             dm.dmFields |= DM_DISPLAYFREQUENCY;

-            dm.dmDisplayFrequency = mode.refresh;
+            dm.dmDisplayFrequency = mode.GetRefresh();

         }
 
         pDevMode = &dm;
         }
 
         pDevMode = &dm;


@@ -742,13 +411,12 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
     static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL;
     if ( !pfnChangeDisplaySettingsEx )
     {
     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 )
 
 #ifndef __WXWINCE__
         if ( !pfnChangeDisplaySettingsEx )


@@ -763,25 +431,25 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
     // do change the mode
     switch ( 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,
                 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
              ) )
     {
         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();
                 // 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;
                 }
             }
             return true;


@@ -791,249 +459,183 @@ bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
             break;
 
         default:
             break;
 
         default:

-            wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
+            wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") );

     }
 
     return false;
 }
 
 
     }
 
     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
 
     // 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)
+{
+#ifdef __WXMSW__
+    return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+                                                        MONITOR_DEFAULTTONULL));
+#else
+    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
 
 #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
+}