src/msw/display.cpp

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