Initialize all fields of struct tm used by wxDateTime::Format().

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

diff --git a/src/msw/display.cpp b/src/msw/display.cpp
index cd5548c708144c58f7576c582877b32564e6cace..69285f9f044786cca73db4f586ec6a3409996193 100644 (file)
--- a/src/msw/display.cpp
+++ b/src/msw/display.cpp
@@ -1,11 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        display.cpp
+// Name:        src/msw/display.cpp

 // Purpose:     MSW Implementation of wxDisplay class
 // Purpose:     MSW Implementation of wxDisplay class

-// Author:      Royce Mitchell III
-// Modified by:
+// Author:      Royce Mitchell III, Vadim Zeitlin
+// Modified by: Ryan Norton (IsPrimary override)

 // Created:     06/21/02
 // RCS-ID:      $Id$
 // Created:     06/21/02
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows team
+// Copyright:   (c) wxWidgets team
+// Copyright:   (c) 2002-2006 wxWidgets team

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 


@@ -17,10 +18,6 @@
 // headers
 // ---------------------------------------------------------------------------
 
 // headers
 // ---------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "display.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -30,203 +27,633 @@
 
 #if wxUSE_DISPLAY
 
 
 #if wxUSE_DISPLAY
 

+#include "wx/display.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-   #include "wx/dynarray.h"
+    #include "wx/dynarray.h"
+    #include "wx/app.h"
+    #include "wx/frame.h"

 #endif
 
 #endif
 

-#include "wx/display.h"
+#include "wx/dynload.h"
+#include "wx/sysopt.h"
+
+#include "wx/display_impl.h"
+#include "wx/msw/wrapwin.h"
+#include "wx/msw/missing.h"
+#include "wx/msw/private.h"
+
+#ifndef __WXWINCE__
+    // Older versions of windef.h don't define HMONITOR.  Unfortunately, we
+    // can't directly test whether HMONITOR is defined or not in windef.h as
+    // it's not a macro but a typedef, so we test for an unrelated symbol which
+    // is only defined in winuser.h if WINVER >= 0x0500
+    #if !defined(HMONITOR_DECLARED) && !defined(MNS_NOCHECK)
+        DECLARE_HANDLE(HMONITOR);
+        typedef BOOL(CALLBACK * MONITORENUMPROC )(HMONITOR, HDC, LPRECT, LPARAM);
+        typedef struct tagMONITORINFO
+        {
+            DWORD   cbSize;
+            RECT    rcMonitor;
+            RECT    rcWork;
+            DWORD   dwFlags;
+        } MONITORINFO, *LPMONITORINFO;
+        typedef struct tagMONITORINFOEX : public tagMONITORINFO
+        {
+            TCHAR       szDevice[CCHDEVICENAME];
+        } MONITORINFOEX, *LPMONITORINFOEX;
+        #define MONITOR_DEFAULTTONULL       0x00000000
+        #define MONITOR_DEFAULTTOPRIMARY    0x00000001
+        #define MONITOR_DEFAULTTONEAREST    0x00000002
+        #define MONITORINFOF_PRIMARY        0x00000001
+        #define HMONITOR_DECLARED
+    #endif
+#endif // !__WXWINCE__
+
+// 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

 
 

-// the following define is necessary to access the multi-monitor function
-// declarations in a manner safe to use w/ Windows 95
-// JACS: not used for now until we're clear about the legality
-// of distributing multimon.h. Meanwhile you can download the file
-// yourself from:
-// http://www.microsoft.com/msj/0697/monitor/monitortextfigs.htm#fig4
+// ----------------------------------------------------------------------------
+// typedefs for dynamically loaded Windows functions
+// ----------------------------------------------------------------------------

 
 

-#if 0
-#define COMPILE_MULTIMON_STUBS
-#include "wx/msw/multimon.h"
-#endif
+typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName,
+                                                 LPDEVMODE lpDevMode,
+                                                 HWND hwnd,
+                                                 DWORD dwFlags,
+                                                 LPVOID lParam);
+
+typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
+typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
+typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);
+typedef BOOL (WINAPI *GetMonitorInfo_t)(HMONITOR,LPMONITORINFO);
+
+#ifndef __WXWINCE__
+// emulation of ChangeDisplaySettingsEx() for Win95
+LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
+                                            LPDEVMODE lpDevMode,
+                                            HWND WXUNUSED(hwnd),
+                                            DWORD dwFlags,
+                                            LPVOID WXUNUSED(lParam))
+{
+    return ::ChangeDisplaySettings(lpDevMode, dwFlags);
+}
+#endif // !__WXWINCE__

 
 

-// ---------------------------------------------------------------------------
-// constants
-// ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// display information classes
+// ----------------------------------------------------------------------------

 
 

-// ---------------------------------------------------------------------------
-// private functions
-// ---------------------------------------------------------------------------
+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();

 
 

-void wxmswInitDisplayRectArray();
+
+    // 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);

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// private classes
+// common base class for all Win32 wxDisplayImpl versions

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class wxmswDisplayInfo;
+class wxDisplayImplWin32Base : public wxDisplayImpl
+{
+public:
+    wxDisplayImplWin32Base(unsigned n, wxDisplayInfo& info)
+        : wxDisplayImpl(n),
+          m_info(info)
+    {
+    }
+
+    virtual wxRect GetGeometry() const;
+    virtual wxRect GetClientArea() const;
+    virtual wxString GetName() const;
+    virtual bool IsPrimary() const;

 
 

-WX_DECLARE_OBJARRAY(wxmswDisplayInfo, wxmswDisplayInfoArray);
+    virtual wxVideoMode GetCurrentMode() const;

 
 

-class wxmswDisplayInfo
+protected:
+    // convert a DEVMODE to our wxVideoMode
+    static wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
+    {
+        // note that dmDisplayFrequency may be 0 or 1 meaning "standard one"
+        // and although 0 is ok for us we don't want to return modes with 1hz
+        // refresh
+        return wxVideoMode(dm.dmPelsWidth,
+                           dm.dmPelsHeight,
+                           dm.dmBitsPerPel,
+                           dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
+    }
+
+    wxDisplayInfo& m_info;
+};
+
+// ----------------------------------------------------------------------------
+// common base class for all Win32 wxDisplayFactory versions
+// ----------------------------------------------------------------------------
+
+// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize()
+static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
+static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
+static GetMonitorInfo_t gs_GetMonitorInfo = NULL;
+
+class wxDisplayFactoryWin32Base : public wxDisplayFactory

 {
 public:
 {
 public:

-       HMONITOR m_hmon;
-    DISPLAY_DEVICE m_dd;
-    wxRect m_rect;
-    int m_depth;
-};
+    virtual ~wxDisplayFactoryWin32Base();

 
 

-wxmswDisplayInfoArray* g_wxmswDisplayInfoArray = 0;
+    bool IsOk() const { return !m_displays.empty(); }

 
 

-#include <wx/arrimpl.cpp> // this is a magic incantation which must be done!
-WX_DEFINE_OBJARRAY(wxmswDisplayInfoArray);
+    virtual unsigned GetCount() { return unsigned(m_displays.size()); }
+    virtual int GetFromPoint(const wxPoint& pt);
+    virtual int GetFromWindow(const wxWindow *window);

 
 

-// ===========================================================================
-// implementation
-// ===========================================================================
+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();

 
 

-BOOL CALLBACK wxmswMonitorEnumProc (
-  HMONITOR hMonitor,  // handle to display monitor
-  HDC hdcMonitor,     // handle to monitor-appropriate device context
-  LPRECT lprcMonitor, // pointer to monitor intersection rectangle
-  LPARAM dwData       // data passed from EnumDisplayMonitors
-)
+    // delete all m_displays elements: can be called from the derived class
+    // dtor if it is important to do this before destroying it,
+    // otherwise will be done by our dtor
+    void Clear();
+
+    // find the monitor corresponding to the given handle, return wxNOT_FOUND
+    // if not found
+    int FindDisplayFromHMONITOR(HMONITOR hmon) const;
+
+
+    // flag indicating whether gs_MonitorXXX functions are available
+    static int ms_supportsMultimon;
+
+    // the array containing information about all available displays, should be
+    // filled by the derived class ctors
+    wxDisplayInfoArray m_displays;
+
+
+    wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base);
+};
+
+// ----------------------------------------------------------------------------
+// wxDisplay implementation using Windows multi-monitor support functions
+// ----------------------------------------------------------------------------
+
+class wxDisplayImplMultimon : public wxDisplayImplWin32Base

 {
 {

-    wxmswDisplayInfo* info = new wxmswDisplayInfo();
-    info->m_hmon = hMonitor;
-    info->m_rect.SetX ( lprcMonitor->left );
-    info->m_rect.SetY ( lprcMonitor->top );
-    info->m_rect.SetWidth ( lprcMonitor->right - lprcMonitor->left );
-    info->m_rect.SetHeight ( lprcMonitor->bottom - lprcMonitor->top );
-    // now add this monitor to the array
-    g_wxmswDisplayInfoArray->Add ( info );
+public:
+    wxDisplayImplMultimon(unsigned n, wxDisplayInfo& info)
+        : wxDisplayImplWin32Base(n, info)
+    {
+    }

 
 

-    return TRUE; // continue the enumeration
-}
+    virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+    virtual bool ChangeMode(const wxVideoMode& mode);
+
+private:
+    wxDECLARE_NO_COPY_CLASS(wxDisplayImplMultimon);
+};

 
 

-class wxmswDisplayModule : public wxModule
+class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base

 {
 {

-    DECLARE_DYNAMIC_CLASS(wxmswDisplayModule)

 public:
 public:

-    wxmswDisplayModule() {}
-    bool OnInit();
-    void OnExit();
+    wxDisplayFactoryMultimon();
+
+    virtual wxDisplayImpl *CreateDisplay(unsigned n);
+
+private:
+    // EnumDisplayMonitors() callback
+    static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor,
+                                          HDC hdcMonitor,
+                                          LPRECT lprcMonitor,
+                                          LPARAM dwData);
+
+    // add a monitor description to m_displays array
+    void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor);

 };
 
 };
 

-IMPLEMENT_DYNAMIC_CLASS(wxmswDisplayModule, wxModule)

 
 

-bool wxmswDisplayModule::OnInit()
+// ============================================================================
+// common classes implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDisplay
+// ----------------------------------------------------------------------------
+
+/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
+{
+    wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon;
+
+    if ( factoryMM->IsOk() )
+        return factoryMM;
+
+    delete factoryMM;
+
+    // finally fall back to a stub implementation if all else failed (Win95?)
+    return new wxDisplayFactorySingle;
+}
+
+
+// ----------------------------------------------------------------------------
+// wxDisplayInfo
+// ----------------------------------------------------------------------------
+
+void wxDisplayInfo::Initialize()

 {
 {

-    g_wxmswDisplayInfoArray = new wxmswDisplayInfoArray();
-    if ( !g_wxmswDisplayInfoArray )
+    if ( m_flags == (DWORD)-1 )

     {
     {

-        wxFAIL_MSG(wxT("Couldn't allocate array for display information"));
-        return FALSE;
+        WinStruct<MONITORINFOEX> monInfo;
+        if ( !gs_GetMonitorInfo(m_hmon, (LPMONITORINFO)&monInfo) )
+        {
+            wxLogLastError(wxT("GetMonitorInfo"));
+            m_flags = 0;
+            return;
+        }
+
+        wxCopyRECTToRect(monInfo.rcMonitor, m_rect);
+        wxCopyRECTToRect(monInfo.rcWork, m_rectClient);
+        m_devName = monInfo.szDevice;
+        m_flags = monInfo.dwFlags;

     }
     }

+}

 
 

-    // Royce3: I'm assuming that the monitor's are enumerated in the same
-    // order as the calls to EnumDisplayDevices below. We shall soon see
-    // if that assumption is correct.
-    if ( !EnumDisplayMonitors ( NULL, NULL, wxmswMonitorEnumProc, 0 ) )
-        wxLogLastError(wxT("EnumDisplayMonitors"));
+// ----------------------------------------------------------------------------
+// wxDisplayImplWin32Base
+// ----------------------------------------------------------------------------

 
 

-    size_t iDevNum = 0, count = g_wxmswDisplayInfoArray->Count();
-    while ( iDevNum < count )
-    {
-        wxmswDisplayInfo& info = (*g_wxmswDisplayInfoArray)[iDevNum];
+wxRect wxDisplayImplWin32Base::GetGeometry() const
+{
+    if ( m_info.m_rect.IsEmpty() )
+        m_info.Initialize();

 
 

-        // MSDN: Before calling EnumDisplayDevices, you must initialize the cb
-        // member of DISPLAY_DEVICE to the size, in bytes, of DISPLAY_DEVICE
-        info.m_dd.cb = sizeof(info.m_dd);
+    return m_info.m_rect;
+}

 
 

-        if ( !EnumDisplayDevices ( NULL, iDevNum, &info.m_dd, 0 ) )
-            wxLogLastError(wxT("EnumDisplayDevices"));
+wxRect wxDisplayImplWin32Base::GetClientArea() const
+{
+    if ( m_info.m_rectClient.IsEmpty() )
+        m_info.Initialize();

 
 

-        // get this display's Depth
-        DEVMODE devmode;
-        memset ( &devmode, 0, sizeof(devmode) );
+    return m_info.m_rectClient;
+}

 
 

-        // MSDN: Before calling EnumDisplaySettings, set the dmSize member to
-        // sizeof(DEVMODE), and set the dmDriverExtra member to indicate the size,
-        // in bytes, of the additional space available to receive private
-        // driver-data.
-        devmode.dmSize = sizeof(devmode);
-        devmode.dmDriverExtra = 0;
+wxString wxDisplayImplWin32Base::GetName() const
+{
+    if ( m_info.m_devName.empty() )
+        m_info.Initialize();

 
 

-        if ( !EnumDisplaySettings ( info.m_dd.DeviceName, ENUM_CURRENT_SETTINGS, &devmode ) )
-        {
-            wxLogLastError(wxT("EnumDisplaySettings"));
-            devmode.dmFields = 0;
-        }
+    return m_info.m_devName;
+}

 
 

-        if ( !(devmode.dmFields&DM_BITSPERPEL) )
-            info.m_depth = -1;
-        else
-            info.m_depth = devmode.dmBitsPerPel;
+bool wxDisplayImplWin32Base::IsPrimary() const
+{
+    if ( m_info.m_flags == (DWORD)-1 )
+        m_info.Initialize();

 
 

+    return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;
+}

 
 

-        iDevNum++;
+wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
+{
+    wxVideoMode mode;
+
+    // The first parameter of EnumDisplaySettings() must be NULL under Win95
+    // according to MSDN.  The version of GetName() we implement for Win95
+    // returns an empty string.
+    const wxString name = GetName();
+    const wxChar * const deviceName = name.empty()
+                                          ? (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(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));

     }
     }

-    return TRUE;
+    else
+    {
+        mode = ConvertToVideoMode(dm);
+    }
+
+    return mode;

 }
 
 }
 

-void wxmswDisplayModule::OnExit()
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryWin32Base
+// ----------------------------------------------------------------------------
+
+int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1;
+
+wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base()

 {
 {

-    size_t count = g_wxmswDisplayInfoArray->Count();
-    while ( count-- )
+    if ( ms_supportsMultimon == -1 )

     {
     {

-        wxmswDisplayInfo* info = g_wxmswDisplayInfoArray->Detach ( count );
-        delete info;
+        ms_supportsMultimon = 0;
+
+        wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+
+        if ( (wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay)) == NULL ||
+             (wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay)) == NULL ||
+             (wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay)) == NULL )
+            return;
+
+        ms_supportsMultimon = 1;
+
+        // we can safely let dllDisplay go out of scope, the DLL itself will
+        // still remain loaded as all programs link to it statically anyhow

     }
     }

-    delete g_wxmswDisplayInfoArray;
-    g_wxmswDisplayInfoArray = 0;

 }
 
 }
 

-// ---------------------------------------------------------------------------
-// wxDisplay
-// ---------------------------------------------------------------------------
+void wxDisplayFactoryWin32Base::Clear()
+{
+    WX_CLEAR_ARRAY(m_displays);
+}

 
 

-size_t wxDisplayBase::GetCount()
+wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base()

 {
 {

-    return GetSystemMetrics ( SM_CMONITORS );
+    Clear();

 }
 
 }
 

-int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
+// 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;
 
 {
     POINT pt2;
     pt2.x = pt.x;
     pt2.y = pt.y;
 

-    HMONITOR hmon = MonitorFromPoint ( pt2, 0 );
-    if ( !hmon )
-        return -1;
-    size_t count = wxDisplayBase::GetCount(), index;
+    return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
+                                                       MONITOR_DEFAULTTONULL));
+}
+
+int wxDisplayFactoryWin32Base::GetFromWindow(const wxWindow *window)
+{
+    return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+                                                        MONITOR_DEFAULTTONULL));
+}

 
 

-    for ( index = 0; index < count; index++ )
+// ============================================================================
+// wxDisplay implementation using Win32 multimon API
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon initialization
+// ----------------------------------------------------------------------------
+
+wxDisplayFactoryMultimon::wxDisplayFactoryMultimon()
+{
+    if ( !ms_supportsMultimon )
+        return;
+
+    // look up EnumDisplayMonitors()
+    EnumDisplayMonitors_t pfnEnumDisplayMonitors;

     {
     {

-        if ( hmon == (*g_wxmswDisplayInfoArray)[index].m_hmon )
-            return index;
+        wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+        if ( (wxDL_INIT_FUNC(pfn, EnumDisplayMonitors, dllDisplay)) == NULL )
+            return;

     }
 
     }
 

-    return -1;
+    // enumerate all displays
+    if ( !pfnEnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) )
+    {
+        wxLogLastError(wxT("EnumDisplayMonitors"));
+    }

 }
 
 }
 

-wxDisplay::wxDisplay ( size_t index ) : wxDisplayBase ( index )
+/* 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;

 }
 
 }
 

-wxRect wxDisplay::GetGeometry() const
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon helper functions
+// ----------------------------------------------------------------------------
+
+void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor)

 {
 {

-    return (*g_wxmswDisplayInfoArray)[m_index].m_rect;
+    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);

 }
 
 }
 

-int wxDisplay::GetDepth() const
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon inherited pure virtuals implementation
+// ----------------------------------------------------------------------------
+
+wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(unsigned n)

 {
 {

-    return (*g_wxmswDisplayInfoArray)[m_index].m_depth;
+    wxCHECK_MSG( n < m_displays.size(), NULL, wxT("invalid display index") );
+
+    return new wxDisplayImplMultimon(n, *(m_displays[n]));

 }
 
 }
 

-wxString wxDisplay::GetName() const
+// ----------------------------------------------------------------------------
+// wxDisplayImplMultimon implementation
+// ----------------------------------------------------------------------------
+
+wxArrayVideoModes
+wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const

 {
 {

-    return wxString ( (*g_wxmswDisplayInfoArray)[m_index].m_dd.DeviceName );
+    wxArrayVideoModes modes;
+
+    // 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();
+
+    DEVMODE dm;
+    dm.dmSize = sizeof(dm);
+    dm.dmDriverExtra = 0;
+    for ( int iModeNum = 0;
+          ::EnumDisplaySettings(deviceName, iModeNum, &dm);
+          iModeNum++ )
+    {
+        const wxVideoMode mode = ConvertToVideoMode(dm);
+        if ( mode.Matches(modeMatch) )
+        {
+            modes.Add(mode);
+        }
+    }
+
+    return modes;
+}
+
+bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
+{
+    // prepare ChangeDisplaySettingsEx() parameters
+    DEVMODE dm;
+    DEVMODE *pDevMode;
+
+    int flags;
+
+    if ( mode == wxDefaultVideoMode )
+    {
+        // reset the video mode to default
+        pDevMode = NULL;
+        flags = 0;
+    }
+    else // change to the given mode
+    {
+        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.GetWidth();
+        dm.dmPelsHeight = mode.GetHeight();
+
+        if ( mode.GetDepth() )
+        {
+            dm.dmFields |= DM_BITSPERPEL;
+            dm.dmBitsPerPel = mode.GetDepth();
+        }
+
+        if ( mode.GetRefresh() )
+        {
+            dm.dmFields |= DM_DISPLAYFREQUENCY;
+            dm.dmDisplayFrequency = mode.GetRefresh();
+        }
+
+        pDevMode = &dm;
+
+#ifdef __WXWINCE__
+        flags = 0;
+#else // !__WXWINCE__
+        flags = CDS_FULLSCREEN;
+#endif // __WXWINCE__/!__WXWINCE__
+    }
+
+
+    // get pointer to the function dynamically
+    //
+    // we're only called from the main thread, so it's ok to use static
+    // variable
+    static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL;
+    if ( !pfnChangeDisplaySettingsEx )
+    {
+        wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+        if ( dllDisplay.IsLoaded() )
+        {
+            wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay);
+        }
+        //else: huh, no this DLL must always be present, what's going on??
+
+#ifndef __WXWINCE__
+        if ( !pfnChangeDisplaySettingsEx )
+        {
+            // we must be under Win95 and so there is no multiple monitors
+            // support anyhow
+            pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95;
+        }
+#endif // !__WXWINCE__
+    }
+
+    // do change the mode
+    switch ( pfnChangeDisplaySettingsEx
+             (
+                GetName().wx_str(), // display name
+                pDevMode,           // dev mode or NULL to reset
+                NULL,               // reserved
+                flags,
+                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
+                // 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.GetWidth(), current.GetHeight());
+                }
+            }
+            return true;
+
+        case DISP_CHANGE_BADMODE:
+            // don't complain about this, this is the only "expected" error
+            break;
+
+        default:
+            wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") );
+    }
+
+    return false;

 }
 
 }
 

-#endif//wxUSE_DISPLAY
+#endif // wxUSE_DISPLAY