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