#if wxUSE_DISPLAY
+#include "wx/display.h"
+
#ifndef WX_PRECOMP
- #include "wx/app.h"
- #include "wx/dynarray.h"
- #include "wx/frame.h"
+ #include "wx/dynarray.h"
+ #include "wx/app.h"
+ #include "wx/frame.h"
#endif
#include "wx/dynload.h"
#include "wx/sysopt.h"
-#include "wx/display.h"
#include "wx/display_impl.h"
+#include "wx/msw/wrapwin.h"
+#include "wx/msw/missing.h"
-// Mingw's w32api headers don't include ddraw.h, though the user may have
-// installed it. If using configure, we actually probe for ddraw.h there
-// and set wxUSE_DIRECTDRAW. Otherwise, assume we don't have it if using
-// the w32api headers, and that we do otherwise.
-#if !defined HAVE_W32API_H && !defined HAVE_DDRAW_H
- #define HAVE_DDRAW_H
-#endif
+// define this to use DirectDraw for display mode switching: this is disabled
+// by default because ddraw.h is now always available and also it's not really
+// clear what are the benefits of using DirectDraw compared to the standard API
-// user may disable compilation of DirectDraw code by setting
-// wxUSE_DIRECTDRAW to 0 in the makefile/project settings
-#if defined(HAVE_DDRAW_H) && !defined(wxUSE_DIRECTDRAW)
- #define wxUSE_DIRECTDRAW 1
+#if !defined(wxUSE_DIRECTDRAW)
+ #define wxUSE_DIRECTDRAW 0
#endif
#ifndef __WXWINCE__
#define MONITOR_DEFAULTTONULL 0x00000000
#define MONITOR_DEFAULTTOPRIMARY 0x00000001
#define MONITOR_DEFAULTTONEAREST 0x00000002
- #define MONITORINFOF_PRIMARY 0x00000001
+ #define MONITORINFOF_PRIMARY 0x00000001
#define HMONITOR_DECLARED
#endif
#endif // !__WXWINCE__
-#ifdef wxUSE_DIRECTDRAW
-#include <ddraw.h>
+#if wxUSE_DIRECTDRAW
+ #include <ddraw.h>
-// we don't want to link with ddraw.lib which contains the real
-// IID_IDirectDraw2 definition
-const GUID wxIID_IDirectDraw2 =
- { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
+ // we don't want to link with ddraw.lib which contains the real
+ // IID_IDirectDraw2 definition
+ const GUID wxIID_IDirectDraw2 =
+ { 0xB3A6F3E0, 0x2B43, 0x11CF, { 0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
#endif // wxUSE_DIRECTDRAW
+// display functions are found in different DLLs under WinCE and normal Win32
+#ifdef __WXWINCE__
+static const wxChar displayDllName[] = wxT("coredll.dll");
+#else
+static const wxChar displayDllName[] = wxT("user32.dll");
+#endif
+
// ----------------------------------------------------------------------------
// typedefs for dynamically loaded Windows functions
// ----------------------------------------------------------------------------
DWORD dwFlags,
LPVOID lParam);
-#ifdef wxUSE_DIRECTDRAW
+#if wxUSE_DIRECTDRAW
typedef BOOL (PASCAL *DDEnumExCallback_t)(GUID *pGuid,
LPTSTR driverDescription,
LPTSTR driverName,
class wxDisplayImplWin32Base : public wxDisplayImpl
{
public:
- wxDisplayImplWin32Base(size_t n, wxDisplayInfo& info)
+ wxDisplayImplWin32Base(unsigned n, wxDisplayInfo& info)
: wxDisplayImpl(n),
m_info(info)
{
bool IsOk() const { return !m_displays.empty(); }
- virtual size_t GetCount() { return m_displays.size(); }
+ virtual unsigned GetCount() { return unsigned(m_displays.size()); }
virtual int GetFromPoint(const wxPoint& pt);
- virtual int GetFromWindow(wxWindow *window);
+ virtual int GetFromWindow(const wxWindow *window);
protected:
// ctor checks if the current system supports multimon API and dynamically
wxDisplayInfoArray m_displays;
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryWin32Base);
};
// ----------------------------------------------------------------------------
class wxDisplayImplMultimon : public wxDisplayImplWin32Base
{
public:
- wxDisplayImplMultimon(size_t n, wxDisplayInfo& info)
+ wxDisplayImplMultimon(unsigned n, wxDisplayInfo& info)
: wxDisplayImplWin32Base(n, info)
{
}
virtual bool ChangeMode(const wxVideoMode& mode);
private:
- DECLARE_NO_COPY_CLASS(wxDisplayImplMultimon)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplMultimon);
};
class wxDisplayFactoryMultimon : public wxDisplayFactoryWin32Base
public:
wxDisplayFactoryMultimon();
- virtual wxDisplayImpl *CreateDisplay(size_t n);
+ virtual wxDisplayImpl *CreateDisplay(unsigned n);
private:
// EnumDisplayMonitors() callback
// wxDisplay implementation using DirectDraw
// ----------------------------------------------------------------------------
-#ifdef wxUSE_DIRECTDRAW
+#if wxUSE_DIRECTDRAW
struct wxDisplayInfoDirectDraw : wxDisplayInfo
{
const GUID m_guid;
- DECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayInfoDirectDraw);
};
class wxDisplayImplDirectDraw : public wxDisplayImplWin32Base
{
public:
- wxDisplayImplDirectDraw(size_t n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
+ wxDisplayImplDirectDraw(unsigned n, wxDisplayInfo& info, IDirectDraw2 *pDD2)
: wxDisplayImplWin32Base(n, info),
m_pDD2(pDD2)
{
private:
IDirectDraw2 *m_pDD2;
- DECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayImplDirectDraw);
};
class wxDisplayFactoryDirectDraw : public wxDisplayFactoryWin32Base
wxDisplayFactoryDirectDraw();
virtual ~wxDisplayFactoryDirectDraw();
- virtual wxDisplayImpl *CreateDisplay(size_t n);
+ virtual wxDisplayImpl *CreateDisplay(unsigned n);
private:
// callback used with DirectDrawEnumerateEx()
// dynamically resolved DirectDrawCreate()
DirectDrawCreate_t m_pfnDirectDrawCreate;
- DECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw)
+ wxDECLARE_NO_COPY_CLASS(wxDisplayFactoryDirectDraw);
};
#endif // wxUSE_DIRECTDRAW
// and another using DirectDraw, the choice between them is done using a
// system option
-#ifdef wxUSE_DIRECTDRAW
- if ( wxSystemOptions::GetOptionInt(_T("msw.display.directdraw")) )
+#if wxUSE_DIRECTDRAW
+ if ( wxSystemOptions::GetOptionInt(wxT("msw.display.directdraw")) )
{
wxDisplayFactoryDirectDraw *factoryDD = new wxDisplayFactoryDirectDraw;
if ( factoryDD->IsOk() )
WinStruct<MONITORINFOEX> monInfo;
if ( !gs_GetMonitorInfo(m_hmon, (LPMONITORINFO)&monInfo) )
{
- wxLogLastError(_T("GetMonitorInfo"));
+ wxLogLastError(wxT("GetMonitorInfo"));
m_flags = 0;
return;
}
wxString wxDisplayImplWin32Base::GetName() const
{
- if ( m_info.m_devName.IsEmpty() )
+ if ( m_info.m_devName.empty() )
m_info.Initialize();
return m_info.m_devName;
// according to MSDN. The version of GetName() we implement for Win95
// returns an empty string.
const wxString name = GetName();
- const wxChar * const deviceName = name.empty() ? NULL : name.c_str();
+ const wxChar * const deviceName = name.empty()
+ ? (const wxChar*)NULL
+ : (const wxChar*)name.c_str();
DEVMODE dm;
dm.dmSize = sizeof(dm);
dm.dmDriverExtra = 0;
if ( !::EnumDisplaySettings(deviceName, ENUM_CURRENT_SETTINGS, &dm) )
{
- wxLogLastError(_T("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
+ wxLogLastError(wxT("EnumDisplaySettings(ENUM_CURRENT_SETTINGS)"));
}
else
{
{
ms_supportsMultimon = 0;
- wxDynamicLibrary dllUser32(_T("user32.dll"));
-
- wxLogNull noLog;
+ wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
- gs_MonitorFromPoint = (MonitorFromPoint_t)
- dllUser32.GetSymbol(wxT("MonitorFromPoint"));
- if ( !gs_MonitorFromPoint )
- return;
-
- gs_MonitorFromWindow = (MonitorFromWindow_t)
- dllUser32.GetSymbol(wxT("MonitorFromWindow"));
- if ( !gs_MonitorFromWindow )
- return;
-
- gs_GetMonitorInfo = (GetMonitorInfo_t)
- dllUser32.GetSymbolAorW(wxT("GetMonitorInfo"));
- if ( !gs_GetMonitorInfo )
+ if ( (wxDL_INIT_FUNC(gs_, MonitorFromPoint, dllDisplay)) == NULL ||
+ (wxDL_INIT_FUNC(gs_, MonitorFromWindow, dllDisplay)) == NULL ||
+ (wxDL_INIT_FUNC_AW(gs_, GetMonitorInfo, dllDisplay)) == NULL )
return;
ms_supportsMultimon = 1;
- // we can safely let dllUser32 go out of scope, the DLL itself will
- // still remain loaded as all Win32 programs use it
+ // we can safely let dllDisplay go out of scope, the DLL itself will
+ // still remain loaded as all programs link to it statically anyhow
}
}
MONITOR_DEFAULTTONULL));
}
-int wxDisplayFactoryWin32Base::GetFromWindow(wxWindow *window)
+int wxDisplayFactoryWin32Base::GetFromWindow(const wxWindow *window)
{
return FindDisplayFromHMONITOR(gs_MonitorFromWindow(GetHwndOf(window),
MONITOR_DEFAULTTONULL));
// implementation
EnumDisplayMonitors_t pfnEnumDisplayMonitors;
{
- wxLogNull noLog;
-
- wxDynamicLibrary dllUser32(_T("user32.dll"));
- pfnEnumDisplayMonitors = (EnumDisplayMonitors_t)
- dllUser32.GetSymbol(wxT("EnumDisplayMonitors"));
- if ( !pfnEnumDisplayMonitors )
+ wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+ if ( (wxDL_INIT_FUNC(pfn, EnumDisplayMonitors, dllDisplay)) == NULL )
return;
}
// wxDisplayFactoryMultimon inherited pure virtuals implementation
// ----------------------------------------------------------------------------
-wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(size_t n)
+wxDisplayImpl *wxDisplayFactoryMultimon::CreateDisplay(unsigned n)
{
- wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
+ wxCHECK_MSG( n < m_displays.size(), NULL, wxT("invalid display index") );
return new wxDisplayImplMultimon(n, *(m_displays[n]));
}
// according to MSDN. The version of GetName() we implement for Win95
// returns an empty string.
const wxString name = GetName();
- const wxChar * const deviceName = name.empty() ? NULL : name.c_str();
+ const wxChar * const deviceName = name.empty()
+ ? (const wxChar*)NULL
+ : (const wxChar*)name.c_str();
DEVMODE dm;
dm.dmSize = sizeof(dm);
}
else // change to the given mode
{
- wxCHECK_MSG( mode.w && mode.h, false,
- _T("at least the width and height must be specified") );
+ wxCHECK_MSG( mode.GetWidth() && mode.GetHeight(), false,
+ wxT("at least the width and height must be specified") );
wxZeroMemory(dm);
dm.dmSize = sizeof(dm);
dm.dmDriverExtra = 0;
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
- dm.dmPelsWidth = mode.w;
- dm.dmPelsHeight = mode.h;
+ dm.dmPelsWidth = mode.GetWidth();
+ dm.dmPelsHeight = mode.GetHeight();
- if ( mode.bpp )
+ if ( mode.GetDepth() )
{
dm.dmFields |= DM_BITSPERPEL;
- dm.dmBitsPerPel = mode.bpp;
+ dm.dmBitsPerPel = mode.GetDepth();
}
- if ( mode.refresh )
+ if ( mode.GetRefresh() )
{
dm.dmFields |= DM_DISPLAYFREQUENCY;
- dm.dmDisplayFrequency = mode.refresh;
+ dm.dmDisplayFrequency = mode.GetRefresh();
}
pDevMode = &dm;
static ChangeDisplaySettingsEx_t pfnChangeDisplaySettingsEx = NULL;
if ( !pfnChangeDisplaySettingsEx )
{
- wxDynamicLibrary dllUser32(_T("user32.dll"));
- if ( dllUser32.IsLoaded() )
+ wxDynamicLibrary dllDisplay(displayDllName, wxDL_VERBATIM | wxDL_QUIET);
+ if ( dllDisplay.IsLoaded() )
{
- pfnChangeDisplaySettingsEx = (ChangeDisplaySettingsEx_t)
- dllUser32.GetSymbolAorW(_T("ChangeDisplaySettingsEx"));
+ wxDL_INIT_FUNC_AW(pfn, ChangeDisplaySettingsEx, dllDisplay);
}
- //else: huh, no user32.dll??
+ //else: huh, no this DLL must always be present, what's going on??
#ifndef __WXWINCE__
if ( !pfnChangeDisplaySettingsEx )
// do change the mode
switch ( pfnChangeDisplaySettingsEx
(
- GetName(), // display name
- pDevMode, // dev mode or NULL to reset
- NULL, // reserved
+ GetName().wx_str(), // display name
+ pDevMode, // dev mode or NULL to reset
+ NULL, // reserved
flags,
- NULL // pointer to video parameters (not used)
+ NULL // pointer to video parameters (not used)
) )
{
case DISP_CHANGE_SUCCESSFUL:
if (frameTop && frameTop->IsFullScreen())
{
wxVideoMode current = GetCurrentMode();
- frameTop->SetClientSize(current.w, current.h);
+ frameTop->SetClientSize(current.GetWidth(), current.GetHeight());
}
}
return true;
break;
default:
- wxFAIL_MSG( _T("unexpected ChangeDisplaySettingsEx() return value") );
+ wxFAIL_MSG( wxT("unexpected ChangeDisplaySettingsEx() return value") );
}
return false;
if ( !ms_supportsMultimon )
return;
-#if wxUSE_LOG
- // suppress the errors if ddraw.dll is not found, we're prepared to handle
- // this
- wxLogNull noLog;
-#endif
-
- m_dllDDraw.Load(_T("ddraw.dll"));
+ m_dllDDraw.Load(wxT("ddraw.dll"), wxDL_VERBATIM | wxDL_QUIET);
if ( !m_dllDDraw.IsLoaded() )
return;
- DirectDrawEnumerateEx_t pDDEnumEx = (DirectDrawEnumerateEx_t)
- m_dllDDraw.GetSymbolAorW(_T("DirectDrawEnumerateEx"));
- if ( !pDDEnumEx )
+ DirectDrawEnumerateEx_t
+ wxDL_INIT_FUNC_AW(pfn, DirectDrawEnumerateEx, m_dllDDraw);
+ if ( !pfnDirectDrawEnumerateEx )
return;
// we can't continue without DirectDrawCreate() later, so resolve it right
// now and fail the initialization if it's not available
- m_pfnDirectDrawCreate = (DirectDrawCreate_t)
- m_dllDDraw.GetSymbol(_T("DirectDrawCreate"));
- if ( !m_pfnDirectDrawCreate )
+ if ( !wxDL_INIT_FUNC(m_pfn, DirectDrawCreate, m_dllDDraw) )
return;
- if ( (*pDDEnumEx)(DDEnumExCallback,
- this,
- DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
+ if ( (*pfnDirectDrawEnumerateEx)(DDEnumExCallback,
+ this,
+ DDENUM_ATTACHEDSECONDARYDEVICES) != DD_OK )
{
- wxLogLastError(_T("DirectDrawEnumerateEx"));
+ wxLogLastError(wxT("DirectDrawEnumerateEx"));
}
}
if ( pGuid )
{
wxDisplayFactoryDirectDraw * self =
- wx_static_cast(wxDisplayFactoryDirectDraw *, lpContext);
+ static_cast<wxDisplayFactoryDirectDraw *>(lpContext);
self->AddDisplay(*pGuid, hmon, driverName);
}
//else: we're called for the primary monitor, skip it
// wxDisplayFactoryDirectDraw inherited pure virtuals implementation
// ----------------------------------------------------------------------------
-wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(size_t n)
+wxDisplayImpl *wxDisplayFactoryDirectDraw::CreateDisplay(unsigned n)
{
- wxCHECK_MSG( n < m_displays.size(), NULL, _T("invalid display index") );
+ wxCHECK_MSG( n < m_displays.size(), NULL, wxT("invalid display index") );
wxDisplayInfoDirectDraw *
- info = wx_static_cast(wxDisplayInfoDirectDraw *, m_displays[n]);
+ info = static_cast<wxDisplayInfoDirectDraw *>(m_displays[n]);
if ( !info->m_pDD2 )
{
if ( FAILED(hr) || !pDD )
{
// what to do??
- wxLogApiError(_T("DirectDrawCreate"), hr);
+ wxLogApiError(wxT("DirectDrawCreate"), hr);
return NULL;
}
if ( FAILED(hr) || !info->m_pDD2 )
{
- wxLogApiError(_T("IDirectDraw::QueryInterface(IDD2)"), hr);
+ wxLogApiError(wxT("IDirectDraw::QueryInterface(IDD2)"), hr);
return NULL;
}
wxArrayVideoModes& m_modes;
const wxVideoMode& m_modeMatch;
- DECLARE_NO_COPY_CLASS(wxDDVideoModesAdder)
+ wxDECLARE_NO_COPY_CLASS(wxDDVideoModesAdder);
};
HRESULT WINAPI wxDDEnumModesCallback(LPDDSURFACEDESC lpDDSurfaceDesc,
if ( (lpDDSurfaceDesc->dwFlags & FLAGS_REQUIRED) == FLAGS_REQUIRED )
{
wxDDVideoModesAdder * const vmodes =
- wx_static_cast(wxDDVideoModesAdder *, lpContext);
+ static_cast<wxDDVideoModesAdder *>(lpContext);
vmodes->Add(wxVideoMode(lpDDSurfaceDesc->dwWidth,
lpDDSurfaceDesc->dwHeight,
if ( FAILED(hr) )
{
- wxLogApiError(_T("IDirectDraw::EnumDisplayModes"), hr);
+ wxLogApiError(wxT("IDirectDraw::EnumDisplayModes"), hr);
}
return modes;
bool wxDisplayImplDirectDraw::ChangeMode(const wxVideoMode& mode)
{
wxWindow *winTop = wxTheApp->GetTopWindow();
- wxCHECK_MSG( winTop, false, _T("top level window required for DirectX") );
+ wxCHECK_MSG( winTop, false, wxT("top level window required for DirectX") );
HRESULT hr = m_pDD2->SetCooperativeLevel
(
);
if ( FAILED(hr) )
{
- wxLogApiError(_T("IDirectDraw2::SetCooperativeLevel"), hr);
+ wxLogApiError(wxT("IDirectDraw2::SetCooperativeLevel"), hr);
return false;
}
hr = m_pDD2->SetDisplayMode(mode.w, mode.h, mode.bpp, mode.refresh, 0);
if ( FAILED(hr) )
{
- wxLogApiError(_T("IDirectDraw2::SetDisplayMode"), hr);
+ wxLogApiError(wxT("IDirectDraw2::SetDisplayMode"), hr);
return false;
}
projects / wxWidgets.git / blobdiff