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