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