src/msw/display.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        display.cpp
   3 // Purpose:     MSW Implementation of wxDisplay class
   4 // Author:      Royce Mitchell III
   5 // Modified by: VZ (resolutions enumeration/change support, DirectDraw, ...)
   6 //                  Ryan Norton (IsPrimary override)
   7 // Created:     06/21/02
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 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 #ifndef WX_PRECOMP
  31    #include "wx/app.h"
  32    #include "wx/dynarray.h"
  33    #include "wx/frame.h"
  34 #endif
  35
  36 #include "wx/dynload.h"
  37
  38 #include "wx/display.h"
  39
  40 // the following define is necessary to access the multi-monitor function
  41 // declarations in a manner safe to use w/ Windows 95
  42 #define COMPILE_MULTIMON_STUBS
  43
  44 // if you don't have multimon.h you can download the file from:
  45 //
  46 //  http://www.microsoft.com/msj/0697/monitor/monitortextfigs.htm#fig4
  47 //
  48
  49 #ifdef _MSC_VER
  50     // as (m)any standard header(s), this one doesn't compile without warnings
  51     // with VC++ 6 <sigh>
  52     #pragma warning(disable:4706)
  53 #endif
  54
  55 // with mingw32, we must include windows.h first and it doesn't hurt with other
  56 // compilers
  57 #include <windows.h>
  58
  59 #include <multimon.h>
  60
  61 #ifdef _MSC_VER
  62     #pragma warning(default:4706)
  63 #endif
  64
  65 #include <ddraw.h>
  66
  67 // we don't want to link with ddraw.lib which contains the real
  68 // IID_IDirectDraw2 definition
  69 const GUID wxIID_IDirectDraw2 =
  70     { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
  71
  72 // ----------------------------------------------------------------------------
  73 // macros
  74 // ----------------------------------------------------------------------------
  75
  76 #ifdef _UNICODE
  77     #define WINFUNC(x)  _T(#x) L"W"
  78 #else
  79     #define WINFUNC(x) #x "A"
  80 #endif
  81
  82 // ----------------------------------------------------------------------------
  83 // typedefs for dynamically loaded Windows functions
  84 // ----------------------------------------------------------------------------
  85
  86 typedef LONG (WINAPI *ChangeDisplaySettingsEx_t)(LPCTSTR lpszDeviceName,
  87                                                  LPDEVMODE lpDevMode,
  88                                                  HWND hwnd,
  89                                                  DWORD dwFlags,
  90                                                  LPVOID lParam);
  91
  92 typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
  93                                           LPTSTR driverDescription,
  94                                           LPTSTR driverName,
  95                                           LPVOID lpContext,
  96                                           HMONITOR hmon);
  97
  98 typedef HRESULT (WINAPI *DirectDrawEnumerateEx_t)(DDEnumExCallback_t lpCallback,
  99                                                   LPVOID lpContext,
 100                                                   DWORD dwFlags);
 101
 102 typedef HRESULT (WINAPI *DirectDrawCreate_t)(GUID *lpGUID,
 103                                              LPDIRECTDRAW *lplpDD,
 104                                              IUnknown *pUnkOuter);
 105
 106 // ----------------------------------------------------------------------------
 107 // private classes
 108 // ----------------------------------------------------------------------------
 109
 110 class wxDisplayInfo
 111 {
 112 public:
 113     // handle of this monitor used by MonitorXXX() functions, never NULL
 114     HMONITOR m_hmon;
 115
 116     // IDirectDraw object used to control this display, may be NULL
 117     IDirectDraw2 *m_pDD2;
 118
 119     // DirectDraw GUID for this display, only valid when using DirectDraw
 120     GUID m_guid;
 121
 122     // the entire area of this monitor in virtual screen coordinates
 123     wxRect m_rect;
 124
 125     // the display device name for this monitor, empty initially and retrieved
 126     // on demand by DoGetName()
 127     wxString m_devName;
 128
 129     wxDisplayInfo() { m_hmon = NULL; m_pDD2 = NULL; }
 130     ~wxDisplayInfo() { if ( m_pDD2 ) m_pDD2->Release(); }
 131 };
 132
 133 WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray);
 134 #include "wx/arrimpl.cpp"
 135 WX_DEFINE_OBJARRAY(wxDisplayInfoArray);
 136
 137 // this module is used to cleanup gs_displays array
 138 class wxDisplayModule : public wxModule
 139 {
 140 public:
 141     virtual bool OnInit() { return true; }
 142     virtual void OnExit();
 143
 144     DECLARE_DYNAMIC_CLASS(wxDisplayModule)
 145 };
 146
 147 IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
 148
 149 // ----------------------------------------------------------------------------
 150 // globals
 151 // ----------------------------------------------------------------------------
 152
 153 // do we use DirectX?
 154 static bool gs_useDirectX = false;
 155
 156 // dynamically resolved DirectDrawCreate()
 157 static DirectDrawCreate_t gs_DirectDrawCreate = NULL;
 158
 159 // this is not really MT-unsafe as wxDisplay is only going to be used from the
 160 // main thread, i.e. we consider that it's a GUI class and so don't protect it
 161 static wxDisplayInfoArray *gs_displays = NULL;
 162
 163 // ===========================================================================
 164 // implementation
 165 // ===========================================================================
 166
 167 // ----------------------------------------------------------------------------
 168 // callbacks for monitor/modes enumeration stuff
 169 // ----------------------------------------------------------------------------
 170
 171 static BOOL CALLBACK wxmswMonitorEnumProc (
 172   HMONITOR hMonitor,        // handle to display monitor
 173   HDC WXUNUSED(hdcMonitor), // handle to monitor-appropriate device context
 174   LPRECT lprcMonitor,       // pointer to monitor intersection rectangle
 175   LPARAM WXUNUSED(dwData)   // data passed from EnumDisplayMonitors (unused)
 176 )
 177 {
 178     wxDisplayInfo *info = new wxDisplayInfo();
 179
 180     // we need hMonitor to be able to map display id to it which is needed for
 181     // MonitorXXX() functions, in particular MonitorFromPoint()
 182     info->m_hmon = hMonitor;
 183
 184     // we also store the display geometry
 185     info->m_rect.SetX ( lprcMonitor->left );
 186     info->m_rect.SetY ( lprcMonitor->top );
 187     info->m_rect.SetWidth ( lprcMonitor->right - lprcMonitor->left );
 188     info->m_rect.SetHeight ( lprcMonitor->bottom - lprcMonitor->top );
 189
 190     // now add this monitor to the array
 191     gs_displays->Add(info);
 192
 193     // continue the enumeration
 194     return true;
 195 }
 196
 197 BOOL PASCAL
 198 wxDDEnumExCallback(GUID *pGuid,
 199                    LPTSTR WXUNUSED(driverDescription),
 200                    LPTSTR driverName,
 201                    LPVOID WXUNUSED(lpContext),
 202                    HMONITOR hmon)
 203 {
 204     if ( pGuid )
 205     {
 206         wxDisplayInfo *info = new wxDisplayInfo();
 207
 208         info->m_hmon = hmon;
 209         info->m_guid = *pGuid;
 210         info->m_devName = driverName;
 211
 212         gs_displays->Add(info);
 213     }
 214     //else: we're called for the primary monitor, skip it
 215
 216     // continue the enumeration
 217     return true;
 218 }
 219
 220 HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
 221                                      LPVOID lpContext)
 222 {
 223     // we need at least the mode size
 224     static const DWORD FLAGS_REQUIRED = DDSD_HEIGHT | DDSD_WIDTH;
 225     if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
 226     {
 227         wxArrayVideoModes * const modes = (wxArrayVideoModes *)lpContext;
 228
 229         modes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
 230                                lpDDSurfaceDesc->dwHeight,
 231                                lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
 232                                lpDDSurfaceDesc->dwRefreshRate));
 233     }
 234
 235     // continue the enumeration
 236     return DDENUMRET_OK;
 237 }
 238
 239 // ----------------------------------------------------------------------------
 240 // local functions
 241 // ----------------------------------------------------------------------------
 242
 243 // initialize gs_displays using DirectX functions
 244 static bool DoInitDirectX()
 245 {
 246 #if wxUSE_LOG
 247     // suppress the errors if ddraw.dll is not found
 248     wxLog::EnableLogging(false);
 249 #endif
 250
 251     wxDynamicLibrary dllDX(_T("ddraw.dll"));
 252
 253 #if wxUSE_LOG
 254     wxLog::EnableLogging();
 255 #endif
 256
 257     if ( !dllDX.IsLoaded() )
 258         return false;
 259
 260     DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
 261         dllDX.GetSymbol(WINFUNC(DirectDrawEnumerateEx));
 262     if ( !pDDEnumEx )
 263         return false;
 264
 265     // we'll also need DirectDrawCreate() later, resolve it right now
 266     gs_DirectDrawCreate = (DirectDrawCreate_t)
 267         dllDX.GetSymbol(_T("DirectDrawCreate"));
 268     if ( !gs_DirectDrawCreate )
 269         return false;
 270
 271     if ( (*pDDEnumEx)(wxDDEnumExCallback,
 272                       NULL,
 273                       DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
 274     {
 275         return false;
 276     }
 277
 278     // ok, it seems like we're going to use DirectDraw and so we're going to
 279     // need ddraw.dll all the time, don't unload it
 280     dllDX.Detach();
 281
 282     return true;
 283 }
 284
 285 // initialize gs_displays using the standard Windows functions
 286 static void DoInitStdWindows()
 287 {
 288     // enumerate all displays
 289     if ( !::EnumDisplayMonitors(NULL, NULL, wxmswMonitorEnumProc, 0) )
 290     {
 291         wxLogLastError(wxT("EnumDisplayMonitors"));
 292
 293         // TODO: still create at least one (valid) entry in gs_displays for the
 294         //       primary display!
 295     }
 296 }
 297
 298 // this function must be called before accessing gs_displays array as it
 299 // creates and initializes it
 300 static void InitDisplays()
 301 {
 302     if ( gs_displays )
 303         return;
 304
 305     gs_displays = new wxDisplayInfoArray();
 306
 307     if ( !gs_useDirectX || !DoInitDirectX() )
 308     {
 309         // either we were told not to try to use DirectX or fall back to std
 310         // functions if DirectX method failed
 311         gs_useDirectX = false;
 312
 313         DoInitStdWindows();
 314     }
 315 }
 316
 317 // convert a DEVMODE to our wxVideoMode
 318 wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
 319 {
 320     // note that dmDisplayFrequency may be 0 or 1 meaning "standard one" and
 321     // although 0 is ok for us we don't want to return modes with 1hz refresh
 322     return wxVideoMode(dm.dmPelsWidth,
 323                        dm.dmPelsHeight,
 324                        dm.dmBitsPerPel,
 325                        dm.dmDisplayFrequency > 1 ? dm.dmDisplayFrequency : 0);
 326 }
 327
 328 // emulation of ChangeDisplaySettingsEx() for Win95
 329 LONG WINAPI ChangeDisplaySettingsExForWin95(LPCTSTR WXUNUSED(lpszDeviceName),
 330                                             LPDEVMODE lpDevMode,
 331                                             HWND WXUNUSED(hwnd),
 332                                             DWORD dwFlags,
 333                                             LPVOID WXUNUSED(lParam))
 334 {
 335     return ::ChangeDisplaySettings(lpDevMode, dwFlags);
 336 }
 337
 338 // ----------------------------------------------------------------------------
 339 // wxDisplayModule
 340 // ----------------------------------------------------------------------------
 341
 342 void wxDisplayModule::OnExit()
 343 {
 344     delete gs_displays;
 345 }
 346
 347 // ---------------------------------------------------------------------------
 348 // wxDisplay
 349 // ---------------------------------------------------------------------------
 350
 351 /* static */
 352 void wxDisplay::UseDirectX(bool useDX)
 353 {
 354     wxCHECK_RET( !gs_displays, _T("it is too late to call UseDirectX") );
 355
 356     gs_useDirectX = useDX;
 357 }
 358
 359 // helper of GetFromPoint() and GetFromWindow()
 360 static int DisplayFromHMONITOR(HMONITOR hmon)
 361 {
 362     if ( hmon )
 363     {
 364         const size_t count = wxDisplay::GetCount();
 365
 366         for ( size_t n = 0; n < count; n++ )
 367         {
 368             if ( hmon == (*gs_displays)[n].m_hmon )
 369                 return n;
 370         }
 371     }
 372
 373     return wxNOT_FOUND;
 374 }
 375
 376 /* static */
 377 size_t wxDisplayBase::GetCount()
 378 {
 379     InitDisplays();
 380
 381     //RN: FIXME:  This is wrong - the display info array should reload after every call
 382     //to GetCount() - otherwise it will not be accurate.
 383     //The user can change the number of displays in display properties/settings
 384     //after GetCount or similar is called and really mess this up...
 385     //wxASSERT_MSG( gs_displays->GetCount() == (size_t)::GetSystemMetrics(SM_CMONITORS),
 386     //                _T("So how many displays does this system have?") );
 387
 388     return gs_displays->GetCount();
 389 }
 390
 391 /* static */
 392 int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
 393 {
 394     POINT pt2;
 395     pt2.x = pt.x;
 396     pt2.y = pt.y;
 397
 398     return DisplayFromHMONITOR(::MonitorFromPoint(pt2, MONITOR_DEFAULTTONULL));
 399 }
 400
 401 /* static */
 402 int wxDisplayBase::GetFromWindow(wxWindow *window)
 403 {
 404     return DisplayFromHMONITOR
 405            (
 406             ::MonitorFromWindow(GetHwndOf(window), MONITOR_DEFAULTTONULL)
 407            );
 408 }
 409
 410 // ----------------------------------------------------------------------------
 411 // wxDisplay ctor/dtor
 412 // ----------------------------------------------------------------------------
 413
 414 wxDisplay::wxDisplay ( size_t n )
 415          : wxDisplayBase ( n )
 416 {
 417     // if we do this in ctor we won't have to call it from all the member
 418     // functions
 419     InitDisplays();
 420
 421     if ( gs_useDirectX )
 422     {
 423         wxDisplayInfo& dpyInfo = (*gs_displays)[n];
 424
 425         LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
 426         if ( !pDD2 )
 427         {
 428             if ( !gs_DirectDrawCreate )
 429             {
 430                 // what to do??
 431                 return;
 432             }
 433
 434             IDirectDraw *pDD;
 435             HRESULT hr = (*gs_DirectDrawCreate)(&dpyInfo.m_guid, &pDD, NULL);
 436
 437             if ( FAILED(hr) || !pDD )
 438             {
 439                 // what to do??
 440                 wxLogApiError(_T("DirectDrawCreate"), hr);
 441             }
 442             else // got IDirectDraw, we want IDirectDraw2
 443             {
 444                 hr = pDD->QueryInterface(wxIID_IDirectDraw2, (void **)&pDD2);
 445                 if ( FAILED(hr) || !pDD2 )
 446                 {
 447                     wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
 448                 }
 449
 450                 pDD->Release();
 451             }
 452         }
 453         //else: DirectDraw object corresponding to our display already exists
 454
 455         // increment its ref count to account for Release() in dtor
 456         //
 457         // NB: pDD2 will be only really Release()d when gs_displays is
 458         //     destroyed which is ok as we don't want to recreate DD objects
 459         //     all the time
 460         pDD2->AddRef();
 461     }
 462 }
 463
 464 wxDisplay::~wxDisplay()
 465 {
 466     wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
 467
 468     LPDIRECTDRAW2& pDD2 = dpyInfo.m_pDD2;
 469     if ( pDD2 )
 470     {
 471         pDD2->Release();
 472     }
 473 }
 474
 475 // ----------------------------------------------------------------------------
 476 // wxDisplay simple accessors
 477 // ----------------------------------------------------------------------------
 478
 479 bool wxDisplay::IsOk() const
 480 {
 481     return m_index < GetCount() &&
 482                 (!gs_useDirectX || (*gs_displays)[m_index].m_pDD2);
 483 }
 484
 485 wxRect wxDisplay::GetGeometry() const
 486 {
 487     wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
 488     wxRect& rect = dpyInfo.m_rect;
 489     if ( !rect.width )
 490     {
 491         MONITORINFO monInfo;
 492         wxZeroMemory(monInfo);
 493         monInfo.cbSize = sizeof(monInfo);
 494
 495         if ( !::GetMonitorInfo(dpyInfo.m_hmon, &monInfo) )
 496         {
 497             wxLogLastError(_T("GetMonitorInfo"));
 498         }
 499         else
 500         {
 501             wxCopyRECTToRect(monInfo.rcMonitor, rect);
 502         }
 503     }
 504
 505     return rect;
 506 }
 507
 508 wxString wxDisplay::GetName() const
 509 {
 510     wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
 511     if ( dpyInfo.m_devName.empty() )
 512     {
 513         MONITORINFOEX monInfo;
 514         wxZeroMemory(monInfo);
 515         monInfo.cbSize = sizeof(monInfo);
 516
 517         // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because
 518         //     Mingw headers - unlike the ones from Microsoft's Platform SDK -
 519         //     don't derive the former from the latter in C++ mode and so
 520         //     the pointer's type is not converted implicitly.
 521         if ( !::GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
 522         {
 523             wxLogLastError(_T("GetMonitorInfo"));
 524         }
 525         else
 526         {
 527             dpyInfo.m_devName = monInfo.szDevice;
 528         }
 529     }
 530
 531     return dpyInfo.m_devName;
 532 }
 533
 534 wxString wxDisplay::GetNameForEnumSettings() const
 535 {
 536     int major, minor;
 537     const bool isWin95 = wxGetOsVersion(&major, &minor) == wxWIN95 &&
 538                             major == 4 && minor == 0;
 539
 540     // the first parameter of EnumDisplaySettings() must be NULL under Win95
 541     // according to MSDN but GetMonitorInfo() stub in multimon.h still returns
 542     // something even in this case, so we have to correct this manually
 543     wxString name;
 544     if ( !isWin95 )
 545         name = GetName();
 546
 547     return name;
 548 }
 549
 550 // ----------------------------------------------------------------------------
 551 // determine if this is the primary display
 552 // ----------------------------------------------------------------------------
 553
 554 bool wxDisplay::IsPrimary() const
 555 {
 556     wxDisplayInfo& dpyInfo = (*gs_displays)[m_index];
 557
 558     MONITORINFOEX monInfo;
 559     wxZeroMemory(monInfo);
 560     monInfo.cbSize = sizeof(monInfo);
 561
 562     // NB: Cast from MONITORINFOEX* to MONITORINFO* is done because
 563     //     Mingw headers - unlike the ones from Microsoft's Platform SDK -
 564     //     don't derive the former from the latter in C++ mode and so
 565     //     the pointer's type is not converted implicitly.
 566     if ( !::GetMonitorInfo(dpyInfo.m_hmon, (LPMONITORINFO)&monInfo) )
 567     {
 568         wxLogLastError(_T("GetMonitorInfo"));
 569     }
 570
 571     return (monInfo.dwFlags & MONITORINFOF_PRIMARY) == MONITORINFOF_PRIMARY;
 572 }
 573
 574 // ----------------------------------------------------------------------------
 575 // video modes enumeration
 576 // ----------------------------------------------------------------------------
 577
 578 wxArrayVideoModes
 579 wxDisplay::DoGetModesDirectX(const wxVideoMode& WXUNUSED(modeMatch)) const
 580 {
 581     wxArrayVideoModes modes;
 582
 583     IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2;
 584
 585     if ( pDD )
 586     {
 587         HRESULT hr = pDD->EnumDisplayModes
 588                           (
 589                             DDEDM_REFRESHRATES,
 590                             NULL,   // all modes (TODO: use modeMatch!)
 591                             &modes,   // callback parameter
 592                             wxDDEnumModesCallback
 593                           );
 594
 595         if ( FAILED(hr) )
 596         {
 597             wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
 598         }
 599     }
 600
 601     return modes;
 602 }
 603
 604 wxArrayVideoModes
 605 wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const
 606 {
 607     wxArrayVideoModes modes;
 608
 609     const wxString name = GetNameForEnumSettings();
 610
 611     const wxChar * const deviceName = name.empty() ? NULL : name.c_str();
 612
 613     DEVMODE dm;
 614     for ( int iModeNum = 0;
 615           ::EnumDisplaySettings(deviceName, iModeNum, &dm);
 616           iModeNum++ )
 617     {
 618         const wxVideoMode mode = ConvertToVideoMode(dm);
 619         if ( mode.Matches(modeMatch) )
 620         {
 621             modes.Add(mode);
 622         }
 623     }
 624
 625     return modes;
 626 }
 627
 628 wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const
 629 {
 630     return gs_useDirectX ? DoGetModesDirectX(modeMatch)
 631                          : DoGetModesWindows(modeMatch);
 632 }
 633
 634 wxVideoMode wxDisplay::GetCurrentMode() const
 635 {
 636     wxVideoMode mode;
 637
 638     const wxString name = GetNameForEnumSettings();
 639
 640     DEVMODE dm;
 641     if ( !::EnumDisplaySettings(name.empty() ? NULL : name.c_str(),
 642                                 ENUM_CURRENT_SETTINGS,
 643                                 &dm) )
 644     {
 645         wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
 646     }
 647     else
 648     {
 649         mode = ConvertToVideoMode(dm);
 650     }
 651
 652     return mode;
 653 }
 654
 655 // ----------------------------------------------------------------------------
 656 // video mode switching
 657 // ----------------------------------------------------------------------------
 658
 659 bool wxDisplay::DoChangeModeDirectX(const wxVideoMode& mode)
 660 {
 661     IDirectDraw2 *pDD = (*gs_displays)[m_index].m_pDD2;
 662     if ( !pDD )
 663         return false;
 664
 665     wxWindow *winTop = wxTheApp->GetTopWindow();
 666     wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") );
 667
 668     HRESULT hr = pDD->SetCooperativeLevel
 669                       (
 670                         GetHwndOf(winTop),
 671                         DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN
 672                       );
 673     if ( FAILED(hr) )
 674     {
 675         wxLogApiError(_T("IDirectDraw::SetCooperativeLevel"), hr);
 676
 677         return false;
 678     }
 679
 680     hr = pDD->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
 681     if ( FAILED(hr) )
 682     {
 683         wxLogApiError(_T("IDirectDraw::SetDisplayMode"), hr);
 684
 685         return false;
 686     }
 687
 688
 689     return true;
 690 }
 691
 692 bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
 693 {
 694     // prepare ChangeDisplaySettingsEx() parameters
 695     DEVMODE dm,
 696            *pDevMode;
 697     int flags;
 698
 699     if ( mode == wxDefaultVideoMode )
 700     {
 701         // reset the video mode to default
 702         pDevMode = NULL;
 703         flags = 0;
 704     }
 705     else // change to the given mode
 706     {
 707         wxCHECK_MSG( mode.w && mode.h, false,
 708                         _T("at least the width and height must be specified") );
 709
 710         wxZeroMemory(dm);
 711         dm.dmSize = sizeof(dm);
 712         dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
 713         dm.dmPelsWidth = mode.w;
 714         dm.dmPelsHeight = mode.h;
 715
 716         if ( mode.bpp )
 717         {
 718             dm.dmFields |= DM_BITSPERPEL;
 719             dm.dmBitsPerPel = mode.bpp;
 720         }
 721
 722         if ( mode.refresh )
 723         {
 724             dm.dmFields |= DM_DISPLAYFREQUENCY;
 725             dm.dmDisplayFrequency = mode.refresh;
 726         }
 727
 728         pDevMode = &dm;
 729
 730         flags = CDS_FULLSCREEN;
 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 dllUser32(_T("user32.dll"));
 742         if ( dllUser32.IsLoaded() )
 743         {
 744             pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t)
 745                 dllUser32.GetSymbol(WINFUNC(ChangeDisplaySettingsEx));
 746         }
 747         //else: huh, no user32.dll??
 748
 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     }
 756
 757     // do change the mode
 758     switch ( pfnChangeDisplaySettingsEx
 759              (
 760                 GetName(),      // display name
 761                 pDevMode,       // dev mode or NULL to reset
 762                 NULL,           // reserved
 763                 flags,
 764                 NULL            // pointer to video parameters (not used)
 765              ) )
 766     {
 767         case DISP_CHANGE_SUCCESSFUL:
 768             // ok
 769             {
 770                 // If we have a top-level, full-screen frame, emulate
 771                 // the DirectX behavior and resize it.  This makes this
 772                 // API quite a bit easier to use.
 773                 wxWindow *winTop = wxTheApp->GetTopWindow();
 774                 wxFrame *frameTop = wxDynamicCast(winTop, wxFrame);
 775                 if (frameTop && frameTop->IsFullScreen())
 776                 {
 777                     wxVideoMode current = GetCurrentMode();
 778                     frameTop->SetClientSize(current.w, current.h);
 779                 }
 780             }
 781             return true;
 782
 783         case DISP_CHANGE_BADMODE:
 784             // don't complain about this, this is the only "expected" error
 785             break;
 786
 787         default:
 788             wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
 789     }
 790
 791     return false;
 792 }
 793
 794 bool wxDisplay::ChangeMode(const wxVideoMode& mode)
 795 {
 796     return gs_useDirectX ? DoChangeModeDirectX(mode)
 797                          : DoChangeModeWindows(mode);
 798 }
 799
 800 #endif // wxUSE_DISPLAY
 801