Fix compilation under MSW with GCC cross.

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

diff --git a/src/msw/display.cpp b/src/msw/display.cpp
index 56845df6e8188a49de2552dd6fffce2ae900bcc8..9266bf1b7303370b9274ecc3e649374560e59650 100644 (file)
--- a/src/msw/display.cpp
+++ b/src/msw/display.cpp
@@ -1,12 +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: VZ (resolutions enumeration/change support, DirectDraw, ...)
-//                 Ryan Norton (IsPrimary override)
+// Author:      Royce Mitchell III, Vadim Zeitlin
+// Modified by: Ryan Norton (IsPrimary override)

 // Created:     06/21/02
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWidgets team
 // Created:     06/21/02
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWidgets team

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

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


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

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #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"
 


@@ -32,56 +28,60 @@
 #if wxUSE_DISPLAY
 
 #ifndef WX_PRECOMP
 #if wxUSE_DISPLAY
 
 #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"
 #endif
 
 #include "wx/dynload.h"

+#include "wx/sysopt.h"

 
 #include "wx/display.h"
 
 #include "wx/display.h"

+#include "wx/display_impl.h"

 
 

-// the following define is necessary to access the multi-monitor function
-// declarations in a manner safe to use w/ Windows 95
-#define COMPILE_MULTIMON_STUBS
-
-// if you don't have multimon.h you can download the file from:
-//
-//  http://www.microsoft.com/msj/0697/monitor/monitortextfigs.htm#fig4
-//
-
-#ifdef _MSC_VER
-    // as (m)any standard header(s), this one doesn't compile without warnings
-    // with VC++ 6 <sigh>
-    #pragma warning(disable:4706)
-#endif
-
-// with mingw32, we must include windows.h first and it doesn't hurt with other
-// compilers
-#include <windows.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

 
 

-#include <multimon.h>
-
-#ifdef _MSC_VER
-    #pragma warning(default:4706)
+#if !defined(wxUSE_DIRECTDRAW)
+    #define wxUSE_DIRECTDRAW 0

 #endif
 
 #endif
 

-#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 } };
-
-// ----------------------------------------------------------------------------
-// macros
-// ----------------------------------------------------------------------------
-
-#ifdef _UNICODE
-    #define WINFUNC(x)  _T(#x) L"W"
-#else
-    #define WINFUNC(x) #x "A"
-#endif
+#ifndef __WXWINCE__
+    // Older versions of windef.h don't define HMONITOR.  Unfortunately, we
+    // can't directly test whether HMONITOR is defined or not in windef.h as
+    // it's not a macro but a typedef, so we test for an unrelated symbol which
+    // is only defined in winuser.h if WINVER >= 0x0500
+    #if !defined(HMONITOR_DECLARED) && !defined(MNS_NOCHECK)
+        DECLARE_HANDLE(HMONITOR);
+        typedef BOOL(CALLBACK * MONITORENUMPROC )(HMONITOR, HDC, LPRECT, LPARAM);
+        typedef struct tagMONITORINFO
+        {
+            DWORD   cbSize;
+            RECT    rcMonitor;
+            RECT    rcWork;
+            DWORD   dwFlags;
+        } MONITORINFO, *LPMONITORINFO;
+        typedef struct tagMONITORINFOEX : public tagMONITORINFO
+        {
+            TCHAR       szDevice[CCHDEVICENAME];
+        } MONITORINFOEX, *LPMONITORINFOEX;
+        #define MONITOR_DEFAULTTONULL       0x00000000
+        #define MONITOR_DEFAULTTOPRIMARY    0x00000001
+        #define MONITOR_DEFAULTTONEAREST    0x00000002
+        #define MONITORINFOF_PRIMARY        0x00000001
+        #define HMONITOR_DECLARED
+    #endif
+#endif // !__WXWINCE__
+
+#if wxUSE_DIRECTDRAW
+    #include <ddraw.h>
+
+    // we don't want to link with ddraw.lib which contains the real
+    // IID_IDirectDraw2 definition
+    const GUID wxIID_IDirectDraw2 =
+     { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
+#endif // wxUSE_DIRECTDRAW

 
 // ----------------------------------------------------------------------------
 // typedefs for dynamically loaded Windows functions
 
 // ----------------------------------------------------------------------------
 // typedefs for dynamically loaded Windows functions


@@ -93,6 +93,7 @@ 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,
 typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
                                           LPTSTR driverDescription,
                                           LPTSTR driverName,


@@ -106,515 +107,570 @@ typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback,
 typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
                                              LPDIRECTDRAW *lplpDD,
                                              IUnknown *pUnkOuter);
 typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
                                              LPDIRECTDRAW *lplpDD,
                                              IUnknown *pUnkOuter);

+#endif // wxUSE_DIRECTDRAW
+
+typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
+typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
+typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);
+typedef BOOL (WINAPI *GetMonitorInfo_t)(HMONITOR,LPMONITORINFO);
+
+#ifndef __WXWINCE__
+// emulation of ChangeDisplaySettingsEx() for Win95
+LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
+                                            LPDEVMODE lpDevMode,
+                                            HWND WXUNUSED(hwnd),
+                                            DWORD dwFlags,
+                                            LPVOID WXUNUSED(lParam))
+{
+    return ::ChangeDisplaySettings(lpDevMode, dwFlags);
+}
+#endif // !__WXWINCE__

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

-// private classes
+// display information classes

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

-class wxDisplayInfo
+struct wxDisplayInfo

 {
 {

-public:
-    // handle of this monitor used by MonitorXXX() functions, never NULL
-    HMONITOR m_hmon;
+    wxDisplayInfo(HMONITOR hmon = NULL)
+    {
+        m_hmon = hmon;
+        m_flags = (DWORD)-1;
+    }

 
 

-    // IDirectDraw object used to control this display, may be NULL
-    IDirectDraw2 *m_pDD2;
+    virtual ~wxDisplayInfo() { }

 
 

-    // DirectDraw GUID for this display, only valid when using DirectDraw
-    GUID m_guid;
+
+    // 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 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 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() { if ( m_pDD2 ) m_pDD2->Release(); }
+    // the flags of this monitor, also used as initialization marker: if this
+    // is -1, GetMonitorInfo() hadn't been called yet
+    DWORD m_flags;

 };
 
 };
 

-WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray);
-#include "wx/arrimpl.cpp"
-WX_DEFINE_OBJARRAY(wxDisplayInfoArray);
+WX_DEFINE_ARRAY_PTR(wxDisplayInfo *, wxDisplayInfoArray);

 
 

-// this module is used to cleanup gs_displays array
-class wxDisplayModule : public wxModule
+// ----------------------------------------------------------------------------
+// common base class for all Win32 wxDisplayImpl versions
+// ----------------------------------------------------------------------------
+
+class wxDisplayImplWin32Base : public wxDisplayImpl

 {
 public:
 {
 public:

-    virtual bool OnInit() { return true; }
-    virtual void OnExit();
+    wxDisplayImplWin32Base(size_t n, wxDisplayInfo& info)
+        : wxDisplayImpl(n),
+          m_info(info)
+    {
+    }

 
 

-    DECLARE_DYNAMIC_CLASS(wxDisplayModule)
-};
+    virtual wxRect GetGeometry() const;
+    virtual wxRect GetClientArea() const;
+    virtual wxString GetName() const;
+    virtual bool IsPrimary() const;

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
+    virtual wxVideoMode GetCurrentMode() const;
+
+protected:
+    // convert a DEVMODE to our wxVideoMode
+    static wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
+    {
+        // note that dmDisplayFrequency may be 0 or 1 meaning "standard one"
+        // and although 0 is ok for us we don't want to return modes with 1hz
+        // refresh
+        return wxVideoMode(dm.dmPelsWidth,
+                           dm.dmPelsHeight,
+                           dm.dmBitsPerPel,
+                           dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
+    }
+
+    wxDisplayInfo& m_info;
+};

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

-// globals
+// common base class for all Win32 wxDisplayFactory versions

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

-// do we use DirectX?
-static bool gs_useDirectX = false;
+// functions dynamically bound by wxDisplayFactoryWin32Base::Initialize()
+static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
+static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
+static GetMonitorInfo_t gs_GetMonitorInfo = NULL;

 
 

-// dynamically resolved DirectDrawCreate()
-static DirectDrawCreate_t gs_DirectDrawCreate = NULL;
+class wxDisplayFactoryWin32Base : public wxDisplayFactory
+{
+public:
+    virtual ~wxDisplayFactoryWin32Base();

 
 

-// 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;
+    bool IsOk() const { return !m_displays.empty(); }

 
 

-// ===========================================================================
-// implementation
-// ===========================================================================
+    virtual size_t GetCount() { return m_displays.size(); }
+    virtual int GetFromPoint(const wxPoint& pt);
+    virtual int GetFromWindow(wxWindow *window);
+
+protected:
+    // ctor checks if the current system supports multimon API and dynamically
+    // bind the functions we need if this is the case and sets
+    // ms_supportsMultimon if they're available
+    wxDisplayFactoryWin32Base();
+
+    // delete all m_displays elements: can be called from the derived class
+    // dtor if it is important to do this before destroying it (as in
+    // wxDisplayFactoryDirectDraw case), otherwise will be done by our dtor
+    void Clear();
+
+    // find the monitor corresponding to the given handle, return wxNOT_FOUND
+    // if not found
+    int FindDisplayFromHMONITOR(HMONITOR hmon) const;
+
+
+    // 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)
+};

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

-// callbacks for monitor/modes enumeration stuff
+// wxDisplay implementation using Windows multi-monitor support functions

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

-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)
-)
+class wxDisplayImplMultimon : public wxDisplayImplWin32Base

 {
 {

-    wxDisplayInfo *info = new wxDisplayInfo();
+public:
+    wxDisplayImplMultimon(size_t n, wxDisplayInfo& info)
+        : wxDisplayImplWin32Base(n, info)
+    {
+    }

 
 

-    // we need hMonitor to be able to map display id to it which is needed for
-    // MonitorXXX() functions, in particular MonitorFromPoint()
-    info->m_hmon = hMonitor;
+    virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+    virtual bool ChangeMode(const wxVideoMode& mode);

 
 

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

 
 

-    // now add this monitor to the array
-    gs_displays->Add(info);
+class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
+{
+public:
+    wxDisplayFactoryMultimon();

 
 

-    // continue the enumeration
-    return true;
-}
+    virtual wxDisplayImpl *CreateDisplay(size_t n);
+
+private:
+    // EnumDisplayMonitors() callback
+    static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor,
+                                          HDC hdcMonitor,
+                                          LPRECT lprcMonitor,
+                                          LPARAM dwData);
+
+
+    // add a monitor description to m_displays array
+    void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor);
+};
+
+// ----------------------------------------------------------------------------
+// wxDisplay implementation using DirectDraw
+// ----------------------------------------------------------------------------

 
 

-BOOL PASCAL
-wxDDEnumExCallback(GUID *pGuid,
-                   LPTSTR WXUNUSED(driverDescription),
-                   LPTSTR driverName,
-                   LPVOID WXUNUSED(lpContext),
-                   HMONITOR hmon)
+#if wxUSE_DIRECTDRAW
+
+struct wxDisplayInfoDirectDraw : wxDisplayInfo

 {
 {

-    if ( pGuid )
+    wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name)
+        : wxDisplayInfo(hmon),
+          m_guid(guid)

     {
     {

-        wxDisplayInfo *info = new wxDisplayInfo();
-
-        info->m_hmon = hmon;
-        info->m_guid = *pGuid;
-        info->m_devName = driverName;
+        m_pDD2 = NULL;
+        m_devName = name;
+    }

 
 

-        gs_displays->Add(info);
+    virtual ~wxDisplayInfoDirectDraw()
+    {
+        if ( m_pDD2 )
+            m_pDD2->Release();

     }
     }

-    //else: we're called for the primary monitor, skip it

 
 

-    // continue the enumeration
-    return true;
-}

 
 

-HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
-                                     LPVOID lpContext)
+    // 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

 {
 {

-    // we need at least the mode size
-    static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH;
-    if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
+public:
+    wxDisplayImplDirectDraw(size_t n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
+        : wxDisplayImplWin32Base(n, info),
+          m_pDD2(pDD2)

     {
     {

-        wxArrayVideoModes * const modes = (wxArrayVideoModes *)lpContext;
+        m_pDD2->AddRef();
+    }

 
 

-        modes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
-                               lpDDSurfaceDesc->dwHeight,
-                               lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
-                               lpDDSurfaceDesc->dwRefreshRate));
+    virtual ~wxDisplayImplDirectDraw()
+    {
+        m_pDD2->Release();

     }
 
     }
 

-    // continue the enumeration
-    return DDENUMRET_OK;
-}
+    virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
+    virtual bool ChangeMode(const wxVideoMode& mode);

 
 

-// ----------------------------------------------------------------------------
-// local functions
-// ----------------------------------------------------------------------------
+private:
+    IDirectDraw2 *m_pDD2;
+
+    DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw)
+};

 
 

-// initialize gs_displays using DirectX functions
-static bool DoInitDirectX()
+class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base

 {
 {

-#if wxUSE_LOG
-    // suppress the errors if ddraw.dll is not found
-    wxLog::EnableLogging(false);
-#endif
+public:
+    wxDisplayFactoryDirectDraw();
+    virtual ~wxDisplayFactoryDirectDraw();

 
 

-    wxDynamicLibrary dllDX(_T("ddraw.dll"));
+    virtual wxDisplayImpl *CreateDisplay(size_t n);

 
 

-#if wxUSE_LOG
-    wxLog::EnableLogging();
-#endif
+private:
+    // callback used with DirectDrawEnumerateEx()
+    static BOOL WINAPI DDEnumExCallback(GUID *pGuid,
+                                        LPTSTR driverDescription,
+                                        LPTSTR driverName,
+                                        LPVOID lpContext,
+                                        HMONITOR hmon);

 
 

-    if ( !dllDX.IsLoaded() )
-        return false;
+    // add a monitor description to m_displays array
+    void AddDisplay(const GUID& guid, HMONITOR hmon, LPTSTR name);

 
 

-    DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
-        dllDX.GetSymbol(WINFUNC(DirectDrawEnumerateEx));
-    if ( !pDDEnumEx )
-        return false;

 
 

-    // we'll also need DirectDrawCreate() later, resolve it right now
-    gs_DirectDrawCreate = (DirectDrawCreate_t)
-        dllDX.GetSymbol(_T("DirectDrawCreate"));
-    if ( !gs_DirectDrawCreate )
-        return false;
+    // ddraw.dll
+    wxDynamicLibrary m_dllDDraw;

 
 

-    if ( (*pDDEnumEx)(wxDDEnumExCallback,
-                      NULL,
-                      DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
-    {
-        return false;
-    }
+    // dynamically resolved DirectDrawCreate()
+    DirectDrawCreate_t m_pfnDirectDrawCreate;

 
 

-    // 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();
+    DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw)
+};

 
 

-    return true;
-}
+#endif // wxUSE_DIRECTDRAW

 
 

-// initialize gs_displays using the standard Windows functions
-static void DoInitStdWindows()
-{
-    // enumerate all displays
-    if ( !::EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) )
-    {
-        wxLogLastError(wxT("EnumDisplayMonitors"));

 
 

-        // TODO: still create at least one (valid) entry in gs_displays for the
-        //       primary display!
-    }
-}
+// ============================================================================
+// common classes implementation
+// ============================================================================

 
 

-// this function must be called before accessing gs_displays array as it
-// creates and initializes it
-static void InitDisplays()
-{
-    if ( gs_displays )
-        return;
+// ----------------------------------------------------------------------------
+// wxDisplay
+// ----------------------------------------------------------------------------

 
 

-    gs_displays = new wxDisplayInfoArray();
+/* 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 ( !gs_useDirectX || !DoInitDirectX() )
+#if wxUSE_DIRECTDRAW
+    if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) )

     {
     {

-        // either we were told not to try to use DirectX or fall back to std
-        // functions if DirectX method failed
-        gs_useDirectX = false;
+        wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
+        if ( factoryDD->IsOk() )
+            return factoryDD;

 
 

-        DoInitStdWindows();
+        delete factoryDD;

     }
     }

-}
+#endif // wxUSE_DIRECTDRAW

 
 

-// 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);
-}
+    wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon;
+    if ( factoryMM->IsOk() )
+        return factoryMM;

 
 

-// 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);
+    delete factoryMM;
+
+
+    // finally fall back to a stub implementation if all else failed (Win95?)
+    return new wxDisplayFactorySingle;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxDisplayModule
+// wxDisplayInfo

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

-void wxDisplayModule::OnExit()
+void wxDisplayInfo::Initialize()

 {
 {

-    delete gs_displays;
+    if ( m_flags == (DWORD)-1 )
+    {
+        WinStruct<MONITORINFOEX> monInfo;
+        if ( !gs_GetMonitorInfo(m_hmon, (LPMONITORINFO)&monInfo) )
+        {
+            wxLogLastError(_T("GetMonitorInfo"));
+            m_flags = 0;
+            return;
+        }
+
+        wxCopyRECTToRect(monInfo.rcMonitor, m_rect);
+        wxCopyRECTToRect(monInfo.rcWork, m_rectClient);
+        m_devName = monInfo.szDevice;
+        m_flags = monInfo.dwFlags;
+    }

 }
 
 }
 

-// ---------------------------------------------------------------------------
-// wxDisplay
-// ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// wxDisplayImplWin32Base
+// ----------------------------------------------------------------------------

 
 

-/* static */
-void wxDisplay::UseDirectX(bool useDX)
+wxRect wxDisplayImplWin32Base::GetGeometry() const

 {
 {

-    wxCHECK_RET( !gs_displays, _T("it is too late to call UseDirectX") );
+    if ( m_info.m_rect.IsEmpty() )
+        m_info.Initialize();

 
 

-    gs_useDirectX = useDX;
+    return m_info.m_rect;

 }
 
 }
 

-// helper of GetFromPoint() and GetFromWindow()
-static int DisplayFromHMONITOR(HMONITOR hmon)
+wxRect wxDisplayImplWin32Base::GetClientArea() const

 {
 {

-    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;
-        }
-    }
+    if ( m_info.m_rectClient.IsEmpty() )
+        m_info.Initialize();

 
 

-    return wxNOT_FOUND;
+    return m_info.m_rectClient;

 }
 
 }
 

-/* static */
-size_t wxDisplayBase::GetCount()
+wxString wxDisplayImplWin32Base::GetName() const

 {
 {

-    InitDisplays();
+    if ( m_info.m_devName.IsEmpty() )
+        m_info.Initialize();

 
 

-    //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();
+    return m_info.m_devName;

 }
 
 }
 

-/* static */
-int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
+bool wxDisplayImplWin32Base::IsPrimary() const

 {
 {

-    POINT pt2;
-    pt2.x = pt.x;
-    pt2.y = pt.y;
+    if ( m_info.m_flags == (DWORD)-1 )
+        m_info.Initialize();

 
 

-    return DisplayFromHMONITOR(::MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL));
+    return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;

 }
 
 }
 

-/* static */
-int wxDisplayBase::GetFromWindow(wxWindow *window)
+wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const

 {
 {

-    return DisplayFromHMONITOR
-           (
-            ::MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL)
-           );
+    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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxDisplay ctor/dtor
+// wxDisplayFactoryWin32Base

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

-wxDisplay::wxDisplay ( size_t n )
-         : wxDisplayBase ( n )
-{
-    // if we do this in ctor we won't have to call it from all the member
-    // functions
-    InitDisplays();
+int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1;

 
 

-    if ( gs_useDirectX )
+wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base()
+{
+    if ( ms_supportsMultimon == -1 )

     {
     {

-        wxDisplayInfo& dpyInfo = (*gs_displays)[n];
+        ms_supportsMultimon = 0;

 
 

-        LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
-        if ( !pDD2 )
-        {
-            if ( !gs_DirectDrawCreate )
-            {
-                // what to do??
-                return;
-            }
+        wxDynamicLibrary dllUser32(_T("user32.dll"));

 
 

-            IDirectDraw *pDD;
-            HRESULT hr = (*gs_DirectDrawCreate)(&dpyInfo.m_guid, &pDD, NULL);
+        wxLogNull noLog;

 
 

-            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);
-                }
+        gs_MonitorFromPoint = (MonitorFromPoint_t)
+            dllUser32.GetSymbol(wxT("MonitorFromPoint"));
+        if ( !gs_MonitorFromPoint )
+            return;

 
 

-                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();
-    }
-}
+        gs_MonitorFromWindow = (MonitorFromWindow_t)
+            dllUser32.GetSymbol(wxT("MonitorFromWindow"));
+        if ( !gs_MonitorFromWindow )
+            return;

 
 

-wxDisplay::~wxDisplay()
-{
-    wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
+        gs_GetMonitorInfo = (GetMonitorInfo_t)
+            dllUser32.GetSymbolAorW(wxT("GetMonitorInfo"));
+        if ( !gs_GetMonitorInfo )
+            return;

 
 

-    LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
-    if ( pDD2 )
-    {
-        pDD2->Release();
+        ms_supportsMultimon = 1;
+
+        // we can safely let dllUser32 go out of scope, the DLL itself will
+        // still remain loaded as all Win32 programs use it

     }
 }
 
     }
 }
 

-// ----------------------------------------------------------------------------
-// wxDisplay simple accessors
-// ----------------------------------------------------------------------------
-
-bool wxDisplay::IsOk() const
+void wxDisplayFactoryWin32Base::Clear()

 {
 {

-    return m_index < GetCount() &&
-                (!gs_useDirectX || (*gs_displays)[m_index].m_pDD2);
+    WX_CLEAR_ARRAY(m_displays);

 }
 
 }
 

-wxRect wxDisplay::GetGeometry() const
+wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base()

 {
 {

-    wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
-    wxRect& rect = dpyInfo.m_rect;
-    if ( !rect.width )
-    {
-        MONITORINFO monInfo;
-        wxZeroMemory(monInfo);
-        monInfo.cbSize = sizeof(monInfo);
-
-        if ( !::GetMonitorInfo(dpyInfo.m_hmon, &monInfo) )
-        {
-            wxLogLastError(_T("GetMonitorInfo"));
-        }
-        else
-        {
-            wxCopyRECTToRect(monInfo.rcMonitor, rect);
-        }
-    }
-
-    return rect;
+    Clear();

 }
 
 }
 

-wxString wxDisplay::GetName() const
+// helper for GetFromPoint() and GetFromWindow()
+int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const

 {
 {

-    wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
-    if ( dpyInfo.m_devName.empty() )
+    if ( hmon )

     {
     {

-        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 ( !::GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
-        {
-            wxLogLastError(_T("GetMonitorInfo"));
-        }
-        else
+        const size_t count = m_displays.size();
+        for ( size_t n = 0; n < count; n++ )

         {
         {

-            dpyInfo.m_devName = monInfo.szDevice;
+            if ( hmon == m_displays[n]->m_hmon )
+                return n;

         }
     }
 
         }
     }
 

-    return dpyInfo.m_devName;
+    return wxNOT_FOUND;

 }
 
 }
 

-wxString wxDisplay::GetNameForEnumSettings() const
+int wxDisplayFactoryWin32Base::GetFromPoint(const wxPoint& pt)

 {
 {

-    int major, minor;
-    const bool isWin95 = wxGetOsVersion(&major, &minor) == wxWIN95 &&
-                            major == 4 && minor == 0;
+    POINT pt2;
+    pt2.x = pt.x;
+    pt2.y = pt.y;

 
 

-    // the first parameter of EnumDisplaySettings() must be NULL under Win95
-    // according to MSDN but GetMonitorInfo() stub in multimon.h still returns
-    // something even in this case, so we have to correct this manually
-    wxString name;
-    if ( !isWin95 )
-        name = GetName();
+    return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
+                                                       MONITOR_DEFAULTTONULL));
+}

 
 

-    return name;
+int wxDisplayFactoryWin32Base::GetFromWindow(wxWindow *window)
+{
+    return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
+                                                        MONITOR_DEFAULTTONULL));

 }
 
 }
 

+// ============================================================================
+// wxDisplay implementation using Win32 multimon API
+// ============================================================================
+

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

-// determine if this is the primary display
+// wxDisplayFactoryMultimon initialization

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

-bool wxDisplay::IsPrimary() const
+wxDisplayFactoryMultimon::wxDisplayFactoryMultimon()

 {
 {

-    wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
+    if ( !ms_supportsMultimon )
+        return;

 
 

-    MONITORINFOEX monInfo;
-    wxZeroMemory(monInfo);
-    monInfo.cbSize = sizeof(monInfo);
+    // look up EnumDisplayMonitors() which we don't need with DirectDraw
+    // implementation
+    EnumDisplayMonitors_t pfnEnumDisplayMonitors;
+    {
+        wxLogNull noLog;

 
 

-    // 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 ( !::GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
+        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(_T("GetMonitorInfo"));
+        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);

 
 

-    return (monInfo.dwFlags & MONITORINFOF_PRIMARY) == MONITORINFOF_PRIMARY;
+    // continue the enumeration
+    return TRUE;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// video modes enumeration
+// wxDisplayFactoryMultimon helper functions

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

-wxArrayVideoModes
-wxDisplay::DoGetModesDirectX(const wxVideoMode& WXUNUSED(modeMatch)) const
+void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor)

 {
 {

-    wxArrayVideoModes modes;
+    wxDisplayInfo *info = new wxDisplayInfo(hMonitor);

 
 

-    IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2;
+    // we also store the display geometry
+    info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top,
+                          lprcMonitor->right - lprcMonitor->left,
+                          lprcMonitor->bottom - lprcMonitor->top);

 
 

-    if ( pDD )
-    {
-        HRESULT hr = pDD->EnumDisplayModes
-                          (
-                            DDEDM_REFRESHRATES,
-                            NULL,   // all modes (TODO: use modeMatch!)
-                            &modes,   // callback parameter
-                            wxDDEnumModesCallback
-                          );
+    // now add this monitor to the array
+    m_displays.Add(info);
+}

 
 

-        if ( FAILED(hr) )
-        {
-            wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
-        }
-    }
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryMultimon inherited pure virtuals implementation
+// ----------------------------------------------------------------------------

 
 

-    return modes;
+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
 wxArrayVideoModes

-wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const
+wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const

 {
     wxArrayVideoModes modes;
 
 {
     wxArrayVideoModes modes;
 

-    const wxString name = GetNameForEnumSettings();
-
+    // The first parameter of EnumDisplaySettings() must be NULL under Win95
+    // according to MSDN.  The version of GetName() we implement for Win95
+    // returns an empty string.
+    const wxString name = GetName();

     const wxChar * const deviceName = name.empty() ? NULL : name.c_str();
 
     DEVMODE dm;
     const wxChar * const deviceName = name.empty() ? NULL : name.c_str();
 
     DEVMODE dm;

+    dm.dmSize = sizeof(dm);
+    dm.dmDriverExtra = 0;

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


@@ -629,75 +685,12 @@ wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const
     return modes;
 }
 
     return modes;
 }
 

-wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const
-{
-    return gs_useDirectX ? DoGetModesDirectX(modeMatch)
-                         : DoGetModesWindows(modeMatch);
-}
-
-wxVideoMode wxDisplay::GetCurrentMode() const
+bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)

 {
 {

-    wxVideoMode mode;
-
-    const wxString name = GetNameForEnumSettings();
-
+    // prepare ChangeDisplaySettingsEx() parameters

     DEVMODE dm;
     DEVMODE dm;

-    if ( !::EnumDisplaySettings(name.empty() ? NULL : name.c_str(),
-                                ENUM_CURRENT_SETTINGS,
-                                &dm) )
-    {
-        wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
-    }
-    else
-    {
-        mode = ConvertToVideoMode(dm);
-    }
-
-    return mode;
-}
-
-// ----------------------------------------------------------------------------
-// video mode switching
-// ----------------------------------------------------------------------------
-
-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;
-}
+    DEVMODE *pDevMode;

 
 

-bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
-{
-    // prepare ChangeDisplaySettingsEx() parameters
-    DEVMODE dm,
-           *pDevMode;

     int flags;
 
     if ( mode == wxDefaultVideoMode )
     int flags;
 
     if ( mode == wxDefaultVideoMode )


@@ -713,6 +706,7 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
 
         wxZeroMemory(dm);
         dm.dmSize = sizeof(dm);
 
         wxZeroMemory(dm);
         dm.dmSize = sizeof(dm);

+        dm.dmDriverExtra = 0;

         dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
         dm.dmPelsWidth = mode.w;
         dm.dmPelsHeight = mode.h;
         dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
         dm.dmPelsWidth = mode.w;
         dm.dmPelsHeight = mode.h;


@@ -731,7 +725,11 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
 
         pDevMode = &dm;
 
 
         pDevMode = &dm;
 

+#ifdef __WXWINCE__
+        flags = 0;
+#else // !__WXWINCE__

         flags = CDS_FULLSCREEN;
         flags = CDS_FULLSCREEN;

+#endif // __WXWINCE__/!__WXWINCE__

     }
 
 
     }
 
 


@@ -746,16 +744,18 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
         if ( dllUser32.IsLoaded() )
         {
             pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t)
         if ( dllUser32.IsLoaded() )
         {
             pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t)

-                dllUser32.GetSymbol(WINFUNC(ChangeDisplaySettingsEx));
+                dllUser32.GetSymbolAorW(_T("ChangeDisplaySettingsEx"));

         }
         //else: huh, no user32.dll??
 
         }
         //else: huh, no user32.dll??
 

+#ifndef __WXWINCE__

         if ( !pfnChangeDisplaySettingsEx )
         {
             // we must be under Win95 and so there is no multiple monitors
             // support anyhow
             pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95;
         }
         if ( !pfnChangeDisplaySettingsEx )
         {
             // we must be under Win95 and so there is no multiple monitors
             // support anyhow
             pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95;
         }

+#endif // !__WXWINCE__

     }
 
     // do change the mode
     }
 
     // do change the mode


@@ -795,11 +795,243 @@ bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
     return false;
 }
 
     return false;
 }
 

-bool wxDisplay::ChangeMode(const wxVideoMode& mode)
+
+// ============================================================================
+// DirectDraw-based wxDisplay implementation
+// ============================================================================
+
+#if wxUSE_DIRECTDRAW
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryDirectDraw initialization
+// ----------------------------------------------------------------------------
+
+wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw()

 {
 {

-    return gs_useDirectX ? DoChangeModeDirectX(mode)
-                         : DoChangeModeWindows(mode);
+    if ( !ms_supportsMultimon )
+        return;
+
+#if wxUSE_LOG
+    // suppress the errors if ddraw.dll is not found, we're prepared to handle
+    // this
+    wxLogNull noLog;
+#endif
+
+    m_dllDDraw.Load(_T("ddraw.dll"));
+
+    if ( !m_dllDDraw.IsLoaded() )
+        return;
+
+    DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
+        m_dllDDraw.GetSymbolAorW(_T("DirectDrawEnumerateEx"));
+    if ( !pDDEnumEx )
+        return;
+
+    // we can't continue without DirectDrawCreate() later, so resolve it right
+    // now and fail the initialization if it's not available
+    m_pfnDirectDrawCreate = (DirectDrawCreate_t)
+        m_dllDDraw.GetSymbol(_T("DirectDrawCreate"));
+    if ( !m_pfnDirectDrawCreate )
+        return;
+
+    if ( (*pDDEnumEx)(DDEnumExCallback,
+                      this,
+                      DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
+    {
+        wxLogLastError(_T("DirectDrawEnumerateEx"));
+    }

 }
 
 }
 

-#endif // wxUSE_DISPLAY
+wxDisplayFactoryDirectDraw::~wxDisplayFactoryDirectDraw()
+{
+    // we must clear m_displays now, before m_dllDDraw is unloaded as otherwise
+    // calling m_pDD2->Release() later would crash
+    Clear();
+}
+
+// ----------------------------------------------------------------------------
+// callbacks for monitor/modes enumeration stuff
+// ----------------------------------------------------------------------------
+
+BOOL WINAPI
+wxDisplayFactoryDirectDraw::DDEnumExCallback(GUID *pGuid,
+                                             LPTSTR WXUNUSED(driverDescription),
+                                             LPTSTR driverName,
+                                             LPVOID lpContext,
+                                             HMONITOR hmon)
+{
+    if ( pGuid )
+    {
+        wxDisplayFactoryDirectDraw * self =
+            wx_static_cast(wxDisplayFactoryDirectDraw *, lpContext);
+        self->AddDisplay(*pGuid, hmon, driverName);
+    }
+    //else: we're called for the primary monitor, skip it
+
+    // continue the enumeration
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryDirectDraw helpers
+// ----------------------------------------------------------------------------
+
+void wxDisplayFactoryDirectDraw::AddDisplay(const GUID& guid,
+                                            HMONITOR hmon,
+                                            LPTSTR name)
+{
+    m_displays.Add(new wxDisplayInfoDirectDraw(guid, hmon, name));
+}
+
+// ----------------------------------------------------------------------------
+// wxDisplayFactoryDirectDraw inherited pure virtuals implementation
+// ----------------------------------------------------------------------------
+
+wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(size_t n)
+{
+    wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
+
+    wxDisplayInfoDirectDraw *
+        info = wx_static_cast(wxDisplayInfoDirectDraw *, m_displays[n]);
+
+    if ( !info->m_pDD2 )
+    {
+        IDirectDraw *pDD;
+        GUID guid(info->m_guid);
+        HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL);
+
+        if ( FAILED(hr) || !pDD )
+        {
+            // what to do??
+            wxLogApiError(_T("DirectDrawCreate"), hr);
+            return NULL;
+        }
+
+        // we got IDirectDraw, but we need IDirectDraw2
+        hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2);
+        pDD->Release();
+
+        if ( FAILED(hr) || !info->m_pDD2 )
+        {
+            wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
+            return NULL;
+        }
+
+        // NB: m_pDD2 will now be only destroyed when m_displays is destroyed
+        //     which is ok as we don't want to recreate DD objects all the time
+    }
+    //else: DirectDraw object corresponding to our display already exists

 
 

+    return new wxDisplayImplDirectDraw(n, *info, info->m_pDD2);
+}
+
+// ============================================================================
+// wxDisplayImplDirectDraw
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// video modes enumeration
+// ----------------------------------------------------------------------------
+
+// tiny helper class used to pass information from GetModes() to
+// wxDDEnumModesCallback
+class wxDDVideoModesAdder
+{
+public:
+    // our Add() method will add modes matching modeMatch to modes array
+    wxDDVideoModesAdder(wxArrayVideoModes& modes, const wxVideoMode& modeMatch)
+        : m_modes(modes),
+          m_modeMatch(modeMatch)
+    {
+    }
+
+    void Add(const wxVideoMode& mode)
+    {
+        if ( mode.Matches(m_modeMatch) )
+            m_modes.Add(mode);
+    }
+
+private:
+    wxArrayVideoModes& m_modes;
+    const wxVideoMode& m_modeMatch;
+
+    DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder)
+};
+
+HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
+                                     LPVOID lpContext)
+{
+    // we need at least the mode size
+    static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH;
+    if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
+    {
+        wxDDVideoModesAdder * const vmodes =
+            wx_static_cast(wxDDVideoModesAdder *, lpContext);
+
+        vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
+                                lpDDSurfaceDesc->dwHeight,
+                                lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
+                                lpDDSurfaceDesc->dwRefreshRate));
+    }
+
+    // continue the enumeration
+    return DDENUMRET_OK;
+}
+
+wxArrayVideoModes
+wxDisplayImplDirectDraw::GetModes(const wxVideoMode& modeMatch) const
+{
+    wxArrayVideoModes modes;
+    wxDDVideoModesAdder modesAdder(modes, modeMatch);
+
+    HRESULT hr = m_pDD2->EnumDisplayModes
+                         (
+                            DDEDM_REFRESHRATES,
+                            NULL,                   // all modes
+                            &modesAdder,            // callback parameter
+                            wxDDEnumModesCallback
+                         );
+
+    if ( FAILED(hr) )
+    {
+        wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
+    }
+
+    return modes;
+}
+
+// ----------------------------------------------------------------------------
+// video mode switching
+// ----------------------------------------------------------------------------
+
+bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode)
+{
+    wxWindow *winTop = wxTheApp->GetTopWindow();
+    wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") );
+
+    HRESULT hr = m_pDD2->SetCooperativeLevel
+                         (
+                            GetHwndOf(winTop),
+                            DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN
+                         );
+    if ( FAILED(hr) )
+    {
+        wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr);
+
+        return false;
+    }
+
+    hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
+    if ( FAILED(hr) )
+    {
+        wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr);
+
+        return false;
+    }
+
+    return true;
+}
+
+#endif // wxUSE_DIRECTDRAW
+
+#endif // wxUSE_DISPLAY