src/msw/display.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/display.cpp
   3 // Purpose:     MSW Implementation of wxDisplay class
   4 // Author:      Royce Mitchell III, Vadim Zeitlin
   5 // Modified by: Ryan Norton (IsPrimary override)
   6 // Created:     06/21/02
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Copyright:   (c) 2002-2006 wxWidgets team
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ===========================================================================
  14 // declarations
  15 // ===========================================================================
  16
  17 // ---------------------------------------------------------------------------
  18 // headers
  19 // ---------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #if wxUSE_DISPLAY
  29
  30 #include "wx/display.h"
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/dynarray.h"
  34     #include "wx/app.h"
  35     #include "wx/frame.h"
  36 #endif
  37
  38 #include "wx/dynload.h"
  39 #include "wx/sysopt.h"
  40
  41 #include "wx/display_impl.h"
  42 #include "wx/msw/wrapwin.h"
  43 #include "wx/msw/missing.h"
  44
  45 // define this to use DirectDraw for display mode switching: this is disabled
  46 // by default because ddraw.h is now always available and also it's not really
  47 // clear what are the benefits of using DirectDraw compared to the standard API
  48
  49 #if !defined(wxUSE_DIRECTDRAW)
  50     #define wxUSE_DIRECTDRAW 0
  51 #endif
  52
  53 #ifndef __WXWINCE__
  54     // Older versions of windef.h don't define HMONITOR.  Unfortunately, we
  55     // can't directly test whether HMONITOR is defined or not in windef.h as
  56     // it's not a macro but a typedef, so we test for an unrelated symbol which
  57     // is only defined in winuser.h if WINVER >= 0x0500
  58     #if !defined(HMONITOR_DECLARED) && !defined(MNS_NOCHECK)
  59         DECLARE_HANDLE(HMONITOR);
  60         typedef BOOL(CALLBACK * MONITORENUMPROC )(HMONITOR, HDC, LPRECT, LPARAM);
  61         typedef struct tagMONITORINFO
  62         {
  63             DWORD   cbSize;
  64             RECT    rcMonitor;
  65             RECT    rcWork;
  66             DWORD   dwFlags;
  67         } MONITORINFO, *LPMONITORINFO;
  68         typedef struct tagMONITORINFOEX : public tagMONITORINFO
  69         {
  70             TCHAR       szDevice[CCHDEVICENAME];
  71         } MONITORINFOEX, *LPMONITORINFOEX;
  72         #define MONITOR_DEFAULTTONULL       0x00000000
  73         #define MONITOR_DEFAULTTOPRIMARY    0x00000001
  74         #define MONITOR_DEFAULTTONEAREST    0x00000002
  75         #define MONITORINFOF_PRIMARY        0x00000001
  76         #define HMONITOR_DECLARED
  77     #endif
  78 #endif // !__WXWINCE__
  79
  80 #if wxUSE_DIRECTDRAW
  81     #include <ddraw.h>
  82
  83     // we don't want to link with ddraw.lib which contains the real
  84     // IID_IDirectDraw2 definition
  85     const GUID wxIID_IDirectDraw2 =
  86      { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
  87 #endif // wxUSE_DIRECTDRAW
  88
  89 // display functions are found in different DLLs under WinCE and normal Win32
  90 #ifdef __WXWINCE__
  91 static const wxChar displayDllName[] = _T("coredll.dll");
  92 #else
  93 static const wxChar displayDllName[] = _T("user32.dll");
  94 #endif
  95
  96 // ----------------------------------------------------------------------------
  97 // typedefs for dynamically loaded Windows functions
  98 // ----------------------------------------------------------------------------
  99
 100 typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName,
 101                                                  LPDEVMODE lpDevMode,
 102                                                  HWND hwnd,
 103                                                  DWORD dwFlags,
 104                                                  LPVOID lParam);
 105
 106 #if wxUSE_DIRECTDRAW
 107 typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
 108                                           LPTSTR driverDescription,
 109                                           LPTSTR driverName,
 110                                           LPVOID lpContext,
 111                                           HMONITOR hmon);
 112
 113 typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback,
 114                                                   LPVOID lpContext,
 115                                                   DWORD dwFlags);
 116
 117 typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
 118                                              LPDIRECTDRAW *lplpDD,
 119                                              IUnknown *pUnkOuter);
 120 #endif // wxUSE_DIRECTDRAW
 121
 122 typedef BOOL (WINAPI *EnumDisplayMonitors_t)(HDC,LPCRECT,MONITORENUMPROC,LPARAM);
 123 typedef HMONITOR (WINAPI *MonitorFromPoint_t)(POINT,DWORD);
 124 typedef HMONITOR (WINAPI *MonitorFromWindow_t)(HWND,DWORD);
 125 typedef BOOL (WINAPI *GetMonitorInfo_t)(HMONITOR,LPMONITORINFO);
 126
 127 #ifndef __WXWINCE__
 128 // emulation of ChangeDisplaySettingsEx() for Win95
 129 LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
 130                                             LPDEVMODE lpDevMode,
 131                                             HWND WXUNUSED(hwnd),
 132                                             DWORD dwFlags,
 133                                             LPVOID WXUNUSED(lParam))
 134 {
 135     return ::ChangeDisplaySettings(lpDevMode, dwFlags);
 136 }
 137 #endif // !__WXWINCE__
 138
 139 // ----------------------------------------------------------------------------
 140 // display information classes
 141 // ----------------------------------------------------------------------------
 142
 143 struct wxDisplayInfo
 144 {
 145     wxDisplayInfo(HMONITOR hmon = NULL)
 146     {
 147         m_hmon = hmon;
 148         m_flags = (DWORD)-1;
 149     }
 150
 151     virtual ~wxDisplayInfo() { }
 152
 153
 154     // use GetMonitorInfo() to fill in all of our fields if needed (i.e. if it
 155     // hadn't been done before)
 156     void Initialize();
 157
 158
 159     // handle of this monitor used by MonitorXXX() functions, never NULL
 160     HMONITOR m_hmon;
 161
 162     // the entire area of this monitor in virtual screen coordinates
 163     wxRect m_rect;
 164
 165     // the work or client area, i.e. the area available for the normal windows
 166     wxRect m_rectClient;
 167
 168     // the display device name for this monitor, empty initially and retrieved
 169     // on demand by DoGetName()
 170     wxString m_devName;
 171
 172     // the flags of this monitor, also used as initialization marker: if this
 173     // is -1, GetMonitorInfo() hadn't been called yet
 174     DWORD m_flags;
 175 };
 176
 177 WX_DEFINE_ARRAY_PTR(wxDisplayInfo *, wxDisplayInfoArray);
 178
 179 // ----------------------------------------------------------------------------
 180 // common base class for all Win32 wxDisplayImpl versions
 181 // ----------------------------------------------------------------------------
 182
 183 class wxDisplayImplWin32Base : public wxDisplayImpl
 184 {
 185 public:
 186     wxDisplayImplWin32Base(unsigned n, wxDisplayInfo& info)
 187         : wxDisplayImpl(n),
 188           m_info(info)
 189     {
 190     }
 191
 192     virtual wxRect GetGeometry() const;
 193     virtual wxRect GetClientArea() const;
 194     virtual wxString GetName() const;
 195     virtual bool IsPrimary() const;
 196
 197     virtual wxVideoMode GetCurrentMode() const;
 198
 199 protected:
 200     // convert a DEVMODE to our wxVideoMode
 201     static wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
 202     {
 203         // note that dmDisplayFrequency may be 0 or 1 meaning "standard one"
 204         // and although 0 is ok for us we don't want to return modes with 1hz
 205         // refresh
 206         return wxVideoMode(dm.dmPelsWidth,
 207                            dm.dmPelsHeight,
 208                            dm.dmBitsPerPel,
 209                            dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
 210     }
 211
 212     wxDisplayInfo& m_info;
 213 };
 214
 215 // ----------------------------------------------------------------------------
 216 // common base class for all Win32 wxDisplayFactory versions
 217 // ----------------------------------------------------------------------------
 218
 219 // functions dynamically bound by wxDisplayFactoryWin32Base::Initialize()
 220 static MonitorFromPoint_t gs_MonitorFromPoint = NULL;
 221 static MonitorFromWindow_t gs_MonitorFromWindow = NULL;
 222 static GetMonitorInfo_t gs_GetMonitorInfo = NULL;
 223
 224 class wxDisplayFactoryWin32Base : public wxDisplayFactory
 225 {
 226 public:
 227     virtual ~wxDisplayFactoryWin32Base();
 228
 229     bool IsOk() const { return !m_displays.empty(); }
 230
 231     virtual unsigned GetCount() { return unsigned(m_displays.size()); }
 232     virtual int GetFromPoint(const wxPoint& pt);
 233     virtual int GetFromWindow(const wxWindow *window);
 234
 235 protected:
 236     // ctor checks if the current system supports multimon API and dynamically
 237     // bind the functions we need if this is the case and sets
 238     // ms_supportsMultimon if they're available
 239     wxDisplayFactoryWin32Base();
 240
 241     // delete all m_displays elements: can be called from the derived class
 242     // dtor if it is important to do this before destroying it (as in
 243     // wxDisplayFactoryDirectDraw case), otherwise will be done by our dtor
 244     void Clear();
 245
 246     // find the monitor corresponding to the given handle, return wxNOT_FOUND
 247     // if not found
 248     int FindDisplayFromHMONITOR(HMONITOR hmon) const;
 249
 250
 251     // flag indicating whether gs_MonitorXXX functions are available
 252     static int ms_supportsMultimon;
 253
 254     // the array containing information about all available displays, should be
 255     // filled by the derived class ctors
 256     wxDisplayInfoArray m_displays;
 257
 258
 259     wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base);
 260 };
 261
 262 // ----------------------------------------------------------------------------
 263 // wxDisplay implementation using Windows multi-monitor support functions
 264 // ----------------------------------------------------------------------------
 265
 266 class wxDisplayImplMultimon : public wxDisplayImplWin32Base
 267 {
 268 public:
 269     wxDisplayImplMultimon(unsigned n, wxDisplayInfo& info)
 270         : wxDisplayImplWin32Base(n, info)
 271     {
 272     }
 273
 274     virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
 275     virtual bool ChangeMode(const wxVideoMode& mode);
 276
 277 private:
 278     wxDECLARE_NO_COPY_CLASS(wxDisplayImplMultimon);
 279 };
 280
 281 class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
 282 {
 283 public:
 284     wxDisplayFactoryMultimon();
 285
 286     virtual wxDisplayImpl *CreateDisplay(unsigned n);
 287
 288 private:
 289     // EnumDisplayMonitors() callback
 290     static BOOL CALLBACK MultimonEnumProc(HMONITOR hMonitor,
 291                                           HDC hdcMonitor,
 292                                           LPRECT lprcMonitor,
 293                                           LPARAM dwData);
 294
 295
 296     // add a monitor description to m_displays array
 297     void AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor);
 298 };
 299
 300 // ----------------------------------------------------------------------------
 301 // wxDisplay implementation using DirectDraw
 302 // ----------------------------------------------------------------------------
 303
 304 #if wxUSE_DIRECTDRAW
 305
 306 struct wxDisplayInfoDirectDraw : wxDisplayInfo
 307 {
 308     wxDisplayInfoDirectDraw(const GUID& guid, HMONITOR hmon, LPTSTR name)
 309         : wxDisplayInfo(hmon),
 310           m_guid(guid)
 311     {
 312         m_pDD2 = NULL;
 313         m_devName = name;
 314     }
 315
 316     virtual ~wxDisplayInfoDirectDraw()
 317     {
 318         if ( m_pDD2 )
 319             m_pDD2->Release();
 320     }
 321
 322
 323     // IDirectDraw object used to control this display, may be NULL
 324     IDirectDraw2 *m_pDD2;
 325
 326     // DirectDraw GUID for this display, only valid when using DirectDraw
 327     const GUID m_guid;
 328
 329
 330     wxDECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw);
 331 };
 332
 333 class wxDisplayImplDirectDraw : public wxDisplayImplWin32Base
 334 {
 335 public:
 336     wxDisplayImplDirectDraw(unsigned n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
 337         : wxDisplayImplWin32Base(n, info),
 338           m_pDD2(pDD2)
 339     {
 340         m_pDD2->AddRef();
 341     }
 342
 343     virtual ~wxDisplayImplDirectDraw()
 344     {
 345         m_pDD2->Release();
 346     }
 347
 348     virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
 349     virtual bool ChangeMode(const wxVideoMode& mode);
 350
 351 private:
 352     IDirectDraw2 *m_pDD2;
 353
 354     wxDECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw);
 355 };
 356
 357 class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base
 358 {
 359 public:
 360     wxDisplayFactoryDirectDraw();
 361     virtual ~wxDisplayFactoryDirectDraw();
 362
 363     virtual wxDisplayImpl *CreateDisplay(unsigned n);
 364
 365 private:
 366     // callback used with DirectDrawEnumerateEx()
 367     static BOOL WINAPI DDEnumExCallback(GUID *pGuid,
 368                                         LPTSTR driverDescription,
 369                                         LPTSTR driverName,
 370                                         LPVOID lpContext,
 371                                         HMONITOR hmon);
 372
 373     // add a monitor description to m_displays array
 374     void AddDisplay(const GUID& guid, HMONITOR hmon, LPTSTR name);
 375
 376
 377     // ddraw.dll
 378     wxDynamicLibrary m_dllDDraw;
 379
 380     // dynamically resolved DirectDrawCreate()
 381     DirectDrawCreate_t m_pfnDirectDrawCreate;
 382
 383     wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw);
 384 };
 385
 386 #endif // wxUSE_DIRECTDRAW
 387
 388
 389 // ============================================================================
 390 // common classes implementation
 391 // ============================================================================
 392
 393 // ----------------------------------------------------------------------------
 394 // wxDisplay
 395 // ----------------------------------------------------------------------------
 396
 397 /* static */ wxDisplayFactory *wxDisplay::CreateFactory()
 398 {
 399     // we have 2 implementations for modern Windows: one using standard Win32
 400     // and another using DirectDraw, the choice between them is done using a
 401     // system option
 402
 403 #if wxUSE_DIRECTDRAW
 404     if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) )
 405     {
 406         wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
 407         if ( factoryDD->IsOk() )
 408             return factoryDD;
 409
 410         delete factoryDD;
 411     }
 412 #endif // wxUSE_DIRECTDRAW
 413
 414     wxDisplayFactoryMultimon *factoryMM = new wxDisplayFactoryMultimon;
 415     if ( factoryMM->IsOk() )
 416         return factoryMM;
 417
 418     delete factoryMM;
 419
 420
 421     // finally fall back to a stub implementation if all else failed (Win95?)
 422     return new wxDisplayFactorySingle;
 423 }
 424
 425 // ----------------------------------------------------------------------------
 426 // wxDisplayInfo
 427 // ----------------------------------------------------------------------------
 428
 429 void wxDisplayInfo::Initialize()
 430 {
 431     if ( m_flags == (DWORD)-1 )
 432     {
 433         WinStruct<MONITORINFOEX> monInfo;
 434         if ( !gs_GetMonitorInfo(m_hmon, (LPMONITORINFO)&monInfo) )
 435         {
 436             wxLogLastError(_T("GetMonitorInfo"));
 437             m_flags = 0;
 438             return;
 439         }
 440
 441         wxCopyRECTToRect(monInfo.rcMonitor, m_rect);
 442         wxCopyRECTToRect(monInfo.rcWork, m_rectClient);
 443         m_devName = monInfo.szDevice;
 444         m_flags = monInfo.dwFlags;
 445     }
 446 }
 447
 448 // ----------------------------------------------------------------------------
 449 // wxDisplayImplWin32Base
 450 // ----------------------------------------------------------------------------
 451
 452 wxRect wxDisplayImplWin32Base::GetGeometry() const
 453 {
 454     if ( m_info.m_rect.IsEmpty() )
 455         m_info.Initialize();
 456
 457     return m_info.m_rect;
 458 }
 459
 460 wxRect wxDisplayImplWin32Base::GetClientArea() const
 461 {
 462     if ( m_info.m_rectClient.IsEmpty() )
 463         m_info.Initialize();
 464
 465     return m_info.m_rectClient;
 466 }
 467
 468 wxString wxDisplayImplWin32Base::GetName() const
 469 {
 470     if ( m_info.m_devName.empty() )
 471         m_info.Initialize();
 472
 473     return m_info.m_devName;
 474 }
 475
 476 bool wxDisplayImplWin32Base::IsPrimary() const
 477 {
 478     if ( m_info.m_flags == (DWORD)-1 )
 479         m_info.Initialize();
 480
 481     return (m_info.m_flags & MONITORINFOF_PRIMARY) != 0;
 482 }
 483
 484 wxVideoMode wxDisplayImplWin32Base::GetCurrentMode() const
 485 {
 486     wxVideoMode mode;
 487
 488     // The first parameter of EnumDisplaySettings() must be NULL under Win95
 489     // according to MSDN.  The version of GetName() we implement for Win95
 490     // returns an empty string.
 491     const wxString name = GetName();
 492     const wxChar * const deviceName = name.empty()
 493                                           ? (const wxChar*)NULL
 494                                           : (const wxChar*)name.c_str();
 495
 496     DEVMODE dm;
 497     dm.dmSize = sizeof(dm);
 498     dm.dmDriverExtra = 0;
 499     if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) )
 500     {
 501         wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
 502     }
 503     else
 504     {
 505         mode = ConvertToVideoMode(dm);
 506     }
 507
 508     return mode;
 509 }
 510
 511 // ----------------------------------------------------------------------------
 512 // wxDisplayFactoryWin32Base
 513 // ----------------------------------------------------------------------------
 514
 515 int wxDisplayFactoryWin32Base::ms_supportsMultimon = -1;
 516
 517 wxDisplayFactoryWin32Base::wxDisplayFactoryWin32Base()
 518 {
 519     if ( ms_supportsMultimon == -1 )
 520     {
 521         ms_supportsMultimon = 0;
 522
 523         wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
 524
 525         if ( (wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay)) == NULL ||
 526              (wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay)) == NULL ||
 527              (wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay)) == NULL )
 528             return;
 529
 530         ms_supportsMultimon = 1;
 531
 532         // we can safely let dllDisplay go out of scope, the DLL itself will
 533         // still remain loaded as all programs link to it statically anyhow
 534     }
 535 }
 536
 537 void wxDisplayFactoryWin32Base::Clear()
 538 {
 539     WX_CLEAR_ARRAY(m_displays);
 540 }
 541
 542 wxDisplayFactoryWin32Base::~wxDisplayFactoryWin32Base()
 543 {
 544     Clear();
 545 }
 546
 547 // helper for GetFromPoint() and GetFromWindow()
 548 int wxDisplayFactoryWin32Base::FindDisplayFromHMONITOR(HMONITOR hmon) const
 549 {
 550     if ( hmon )
 551     {
 552         const size_t count = m_displays.size();
 553         for ( size_t n = 0; n < count; n++ )
 554         {
 555             if ( hmon == m_displays[n]->m_hmon )
 556                 return n;
 557         }
 558     }
 559
 560     return wxNOT_FOUND;
 561 }
 562
 563 int wxDisplayFactoryWin32Base::GetFromPoint(const wxPoint& pt)
 564 {
 565     POINT pt2;
 566     pt2.x = pt.x;
 567     pt2.y = pt.y;
 568
 569     return FindDisplayFromHMONITOR(gs_MonitorFromPoint(pt2,
 570                                                        MONITOR_DEFAULTTONULL));
 571 }
 572
 573 int wxDisplayFactoryWin32Base::GetFromWindow(const wxWindow *window)
 574 {
 575     return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
 576                                                         MONITOR_DEFAULTTONULL));
 577 }
 578
 579 // ============================================================================
 580 // wxDisplay implementation using Win32 multimon API
 581 // ============================================================================
 582
 583 // ----------------------------------------------------------------------------
 584 // wxDisplayFactoryMultimon initialization
 585 // ----------------------------------------------------------------------------
 586
 587 wxDisplayFactoryMultimon::wxDisplayFactoryMultimon()
 588 {
 589     if ( !ms_supportsMultimon )
 590         return;
 591
 592     // look up EnumDisplayMonitors() which we don't need with DirectDraw
 593     // implementation
 594     EnumDisplayMonitors_t pfnEnumDisplayMonitors;
 595     {
 596         wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
 597         if ( (wxDL_INIT_FUNC(pfn, EnumDisplayMonitors, dllDisplay)) == NULL )
 598             return;
 599     }
 600
 601     // enumerate all displays
 602     if ( !pfnEnumDisplayMonitors(NULL, NULL, MultimonEnumProc, (LPARAM)this) )
 603     {
 604         wxLogLastError(wxT("EnumDisplayMonitors"));
 605     }
 606 }
 607
 608 /* static */
 609 BOOL CALLBACK
 610 wxDisplayFactoryMultimon::MultimonEnumProc(
 611   HMONITOR hMonitor,        // handle to display monitor
 612   HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context
 613   LPRECT lprcMonitor,       // pointer to monitor intersection rectangle
 614   LPARAM dwData             // data passed from EnumDisplayMonitors (this)
 615 )
 616 {
 617     wxDisplayFactoryMultimon *const self = (wxDisplayFactoryMultimon *)dwData;
 618     self->AddDisplay(hMonitor, lprcMonitor);
 619
 620     // continue the enumeration
 621     return TRUE;
 622 }
 623
 624 // ----------------------------------------------------------------------------
 625 // wxDisplayFactoryMultimon helper functions
 626 // ----------------------------------------------------------------------------
 627
 628 void wxDisplayFactoryMultimon::AddDisplay(HMONITOR hMonitor, LPRECT lprcMonitor)
 629 {
 630     wxDisplayInfo *info = new wxDisplayInfo(hMonitor);
 631
 632     // we also store the display geometry
 633     info->m_rect = wxRect(lprcMonitor->left, lprcMonitor->top,
 634                           lprcMonitor->right - lprcMonitor->left,
 635                           lprcMonitor->bottom - lprcMonitor->top);
 636
 637     // now add this monitor to the array
 638     m_displays.Add(info);
 639 }
 640
 641 // ----------------------------------------------------------------------------
 642 // wxDisplayFactoryMultimon inherited pure virtuals implementation
 643 // ----------------------------------------------------------------------------
 644
 645 wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(unsigned n)
 646 {
 647     wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
 648
 649     return new wxDisplayImplMultimon(n, *(m_displays[n]));
 650 }
 651
 652 // ----------------------------------------------------------------------------
 653 // wxDisplayImplMultimon implementation
 654 // ----------------------------------------------------------------------------
 655
 656 wxArrayVideoModes
 657 wxDisplayImplMultimon::GetModes(const wxVideoMode& modeMatch) const
 658 {
 659     wxArrayVideoModes modes;
 660
 661     // The first parameter of EnumDisplaySettings() must be NULL under Win95
 662     // according to MSDN.  The version of GetName() we implement for Win95
 663     // returns an empty string.
 664     const wxString name = GetName();
 665     const wxChar * const deviceName = name.empty()
 666                                             ? (const wxChar*)NULL
 667                                             : (const wxChar*)name.c_str();
 668
 669     DEVMODE dm;
 670     dm.dmSize = sizeof(dm);
 671     dm.dmDriverExtra = 0;
 672     for ( int iModeNum = 0;
 673           ::EnumDisplaySettings(deviceName, iModeNum, &dm);
 674           iModeNum++ )
 675     {
 676         const wxVideoMode mode = ConvertToVideoMode(dm);
 677         if ( mode.Matches(modeMatch) )
 678         {
 679             modes.Add(mode);
 680         }
 681     }
 682
 683     return modes;
 684 }
 685
 686 bool wxDisplayImplMultimon::ChangeMode(const wxVideoMode& mode)
 687 {
 688     // prepare ChangeDisplaySettingsEx() parameters
 689     DEVMODE dm;
 690     DEVMODE *pDevMode;
 691
 692     int flags;
 693
 694     if ( mode == wxDefaultVideoMode )
 695     {
 696         // reset the video mode to default
 697         pDevMode = NULL;
 698         flags = 0;
 699     }
 700     else // change to the given mode
 701     {
 702         wxCHECK_MSG( mode.GetWidth() && mode.GetHeight(), false,
 703                         _T("at least the width and height must be specified") );
 704
 705         wxZeroMemory(dm);
 706         dm.dmSize = sizeof(dm);
 707         dm.dmDriverExtra = 0;
 708         dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
 709         dm.dmPelsWidth = mode.GetWidth();
 710         dm.dmPelsHeight = mode.GetHeight();
 711
 712         if ( mode.GetDepth() )
 713         {
 714             dm.dmFields |= DM_BITSPERPEL;
 715             dm.dmBitsPerPel = mode.GetDepth();
 716         }
 717
 718         if ( mode.GetRefresh() )
 719         {
 720             dm.dmFields |= DM_DISPLAYFREQUENCY;
 721             dm.dmDisplayFrequency = mode.GetRefresh();
 722         }
 723
 724         pDevMode = &dm;
 725
 726 #ifdef __WXWINCE__
 727         flags = 0;
 728 #else // !__WXWINCE__
 729         flags = CDS_FULLSCREEN;
 730 #endif // __WXWINCE__/!__WXWINCE__
 731     }
 732
 733
 734     // get pointer to the function dynamically
 735     //
 736     // we're only called from the main thread, so it's ok to use static
 737     // variable
 738     static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL;
 739     if ( !pfnChangeDisplaySettingsEx )
 740     {
 741         wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
 742         if ( dllDisplay.IsLoaded() )
 743         {
 744             wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay);
 745         }
 746         //else: huh, no this DLL must always be present, what's going on??
 747
 748 #ifndef __WXWINCE__
 749         if ( !pfnChangeDisplaySettingsEx )
 750         {
 751             // we must be under Win95 and so there is no multiple monitors
 752             // support anyhow
 753             pfnChangeDisplaySettingsEx = ChangeDisplaySettingsExForWin95;
 754         }
 755 #endif // !__WXWINCE__
 756     }
 757
 758     // do change the mode
 759     switch ( pfnChangeDisplaySettingsEx
 760              (
 761                 GetName().wx_str(), // display name
 762                 pDevMode,           // dev mode or NULL to reset
 763                 NULL,               // reserved
 764                 flags,
 765                 NULL                // pointer to video parameters (not used)
 766              ) )
 767     {
 768         case DISP_CHANGE_SUCCESSFUL:
 769             // ok
 770             {
 771                 // If we have a top-level, full-screen frame, emulate
 772                 // the DirectX behavior and resize it.  This makes this
 773                 // API quite a bit easier to use.
 774                 wxWindow *winTop = wxTheApp->GetTopWindow();
 775                 wxFrame *frameTop = wxDynamicCast(winTop, wxFrame);
 776                 if (frameTop && frameTop->IsFullScreen())
 777                 {
 778                     wxVideoMode current = GetCurrentMode();
 779                     frameTop->SetClientSize(current.GetWidth(), current.GetHeight());
 780                 }
 781             }
 782             return true;
 783
 784         case DISP_CHANGE_BADMODE:
 785             // don't complain about this, this is the only "expected" error
 786             break;
 787
 788         default:
 789             wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
 790     }
 791
 792     return false;
 793 }
 794
 795
 796 // ============================================================================
 797 // DirectDraw-based wxDisplay implementation
 798 // ============================================================================
 799
 800 #if wxUSE_DIRECTDRAW
 801
 802 // ----------------------------------------------------------------------------
 803 // wxDisplayFactoryDirectDraw initialization
 804 // ----------------------------------------------------------------------------
 805
 806 wxDisplayFactoryDirectDraw::wxDisplayFactoryDirectDraw()
 807 {
 808     if ( !ms_supportsMultimon )
 809         return;
 810
 811     m_dllDDraw.Load(_T("ddraw.dll"), wxDL_VERBATIM | wxDL_QUIET);
 812
 813     if ( !m_dllDDraw.IsLoaded() )
 814         return;
 815
 816     DirectDrawEnumerateEx_t
 817         wxDL_INIT_FUNC_AW(pfn, DirectDrawEnumerateEx, m_dllDDraw);
 818     if ( !pfnDirectDrawEnumerateEx )
 819         return;
 820
 821     // we can't continue without DirectDrawCreate() later, so resolve it right
 822     // now and fail the initialization if it's not available
 823     if ( !wxDL_INIT_FUNC(m_pfn, DirectDrawCreate, m_dllDDraw) )
 824         return;
 825
 826     if ( (*pfnDirectDrawEnumerateEx)(DDEnumExCallback,
 827                                      this,
 828                                      DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
 829     {
 830         wxLogLastError(_T("DirectDrawEnumerateEx"));
 831     }
 832 }
 833
 834 wxDisplayFactoryDirectDraw::~wxDisplayFactoryDirectDraw()
 835 {
 836     // we must clear m_displays now, before m_dllDDraw is unloaded as otherwise
 837     // calling m_pDD2->Release() later would crash
 838     Clear();
 839 }
 840
 841 // ----------------------------------------------------------------------------
 842 // callbacks for monitor/modes enumeration stuff
 843 // ----------------------------------------------------------------------------
 844
 845 BOOL WINAPI
 846 wxDisplayFactoryDirectDraw::DDEnumExCallback(GUID *pGuid,
 847                                              LPTSTR WXUNUSED(driverDescription),
 848                                              LPTSTR driverName,
 849                                              LPVOID lpContext,
 850                                              HMONITOR hmon)
 851 {
 852     if ( pGuid )
 853     {
 854         wxDisplayFactoryDirectDraw * self =
 855             static_cast<wxDisplayFactoryDirectDraw *>(lpContext);
 856         self->AddDisplay(*pGuid, hmon, driverName);
 857     }
 858     //else: we're called for the primary monitor, skip it
 859
 860     // continue the enumeration
 861     return TRUE;
 862 }
 863
 864 // ----------------------------------------------------------------------------
 865 // wxDisplayFactoryDirectDraw helpers
 866 // ----------------------------------------------------------------------------
 867
 868 void wxDisplayFactoryDirectDraw::AddDisplay(const GUID& guid,
 869                                             HMONITOR hmon,
 870                                             LPTSTR name)
 871 {
 872     m_displays.Add(new wxDisplayInfoDirectDraw(guid, hmon, name));
 873 }
 874
 875 // ----------------------------------------------------------------------------
 876 // wxDisplayFactoryDirectDraw inherited pure virtuals implementation
 877 // ----------------------------------------------------------------------------
 878
 879 wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(unsigned n)
 880 {
 881     wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
 882
 883     wxDisplayInfoDirectDraw *
 884         info = static_cast<wxDisplayInfoDirectDraw *>(m_displays[n]);
 885
 886     if ( !info->m_pDD2 )
 887     {
 888         IDirectDraw *pDD;
 889         GUID guid(info->m_guid);
 890         HRESULT hr = (*m_pfnDirectDrawCreate)(&guid, &pDD, NULL);
 891
 892         if ( FAILED(hr) || !pDD )
 893         {
 894             // what to do??
 895             wxLogApiError(_T("DirectDrawCreate"), hr);
 896             return NULL;
 897         }
 898
 899         // we got IDirectDraw, but we need IDirectDraw2
 900         hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&info->m_pDD2);
 901         pDD->Release();
 902
 903         if ( FAILED(hr) || !info->m_pDD2 )
 904         {
 905             wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
 906             return NULL;
 907         }
 908
 909         // NB: m_pDD2 will now be only destroyed when m_displays is destroyed
 910         //     which is ok as we don't want to recreate DD objects all the time
 911     }
 912     //else: DirectDraw object corresponding to our display already exists
 913
 914     return new wxDisplayImplDirectDraw(n, *info, info->m_pDD2);
 915 }
 916
 917 // ============================================================================
 918 // wxDisplayImplDirectDraw
 919 // ============================================================================
 920
 921 // ----------------------------------------------------------------------------
 922 // video modes enumeration
 923 // ----------------------------------------------------------------------------
 924
 925 // tiny helper class used to pass information from GetModes() to
 926 // wxDDEnumModesCallback
 927 class wxDDVideoModesAdder
 928 {
 929 public:
 930     // our Add() method will add modes matching modeMatch to modes array
 931     wxDDVideoModesAdder(wxArrayVideoModes& modes, const wxVideoMode& modeMatch)
 932         : m_modes(modes),
 933           m_modeMatch(modeMatch)
 934     {
 935     }
 936
 937     void Add(const wxVideoMode& mode)
 938     {
 939         if ( mode.Matches(m_modeMatch) )
 940             m_modes.Add(mode);
 941     }
 942
 943 private:
 944     wxArrayVideoModes& m_modes;
 945     const wxVideoMode& m_modeMatch;
 946
 947     wxDECLARE_NO_COPY_CLASS(wxDDVideoModesAdder);
 948 };
 949
 950 HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
 951                                      LPVOID lpContext)
 952 {
 953     // we need at least the mode size
 954     static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH;
 955     if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
 956     {
 957         wxDDVideoModesAdder * const vmodes =
 958             static_cast<wxDDVideoModesAdder *>(lpContext);
 959
 960         vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
 961                                 lpDDSurfaceDesc->dwHeight,
 962                                 lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
 963                                 lpDDSurfaceDesc->dwRefreshRate));
 964     }
 965
 966     // continue the enumeration
 967     return DDENUMRET_OK;
 968 }
 969
 970 wxArrayVideoModes
 971 wxDisplayImplDirectDraw::GetModes(const wxVideoMode& modeMatch) const
 972 {
 973     wxArrayVideoModes modes;
 974     wxDDVideoModesAdder modesAdder(modes, modeMatch);
 975
 976     HRESULT hr = m_pDD2->EnumDisplayModes
 977                          (
 978                             DDEDM_REFRESHRATES,
 979                             NULL,                   // all modes
 980                             &modesAdder,            // callback parameter
 981                             wxDDEnumModesCallback
 982                          );
 983
 984     if ( FAILED(hr) )
 985     {
 986         wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
 987     }
 988
 989     return modes;
 990 }
 991
 992 // ----------------------------------------------------------------------------
 993 // video mode switching
 994 // ----------------------------------------------------------------------------
 995
 996 bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode)
 997 {
 998     wxWindow *winTop = wxTheApp->GetTopWindow();
 999     wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") );
1000
1001     HRESULT hr = m_pDD2->SetCooperativeLevel
1002                          (
1003                             GetHwndOf(winTop),
1004                             DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN
1005                          );
1006     if ( FAILED(hr) )
1007     {
1008         wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr);
1009
1010         return false;
1011     }
1012
1013     hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
1014     if ( FAILED(hr) )
1015     {
1016         wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr);
1017
1018         return false;
1019     }
1020
1021     return true;
1022 }
1023
1024 #endif // wxUSE_DIRECTDRAW
1025
1026 #endif // wxUSE_DISPLAY