Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup mac

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@50006 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Csomor
2007-11-16 21:04:50 +00:00
parent d447f7531d
commit 9d46359178
28 changed files with 62 additions and 1007 deletions
Download Patch File Download Diff File Expand all files Collapse all files

479
src/mac/carbon/display.cpp
View File

@@ -34,16 +34,7 @@
#include "wx/gdicmn.h"
#endif
#ifdef __DARWIN__
#include <Carbon/Carbon.h>
#else
#include <Gestalt.h>
#include <Displays.h>
#include <Quickdraw.h>
#include <Video.h> // for VDSwitchInfoRec
#include <FixMath.h>
#include <Debugging.h>
#endif
#include <Carbon/Carbon.h>
#include "wx/display_impl.h"
@@ -51,8 +42,6 @@
// display classes implementation
// ----------------------------------------------------------------------------
#ifdef __WXMAC_OSX__
class wxDisplayImplMacOSX : public wxDisplayImpl
{
public:
@@ -263,470 +252,4 @@ bool wxDisplayImplMacOSX::ChangeMode( const wxVideoMode& mode )
return new wxDisplayFactoryMacOSX;
}
#else // !__WXMAC_OSX__
class wxDisplayImplMac : public wxDisplayImpl
{
public:
wxDisplayImplMac(unsigned n, GDHandle hndl)
: wxDisplayImpl(n),
m_hndl(hndl)
{
}
virtual wxRect GetGeometry() const;
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
GDHandle m_hndl;
DECLARE_NO_COPY_CLASS(wxDisplayImplMac)
};
class wxDisplayFactoryMac : public wxDisplayFactory
{
public:
wxDisplayFactoryMac();
virtual wxDisplayImpl *CreateDisplay(unsigned n);
virtual unsigned GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryMac)
};
// ============================================================================
// wxDisplayFactoryMac implementation
// ============================================================================
unsigned wxDisplayFactoryMac::GetCount()
{
unsigned num = 0;
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
num++;
hndl = DMGetNextScreenDevice(hndl, true);
}
return num;
}
int wxDisplayFactoryMac::GetFromPoint(const wxPoint &p)
{
unsigned num = 0;
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
Rect screenrect = (*hndl)->gdRect;
if (p.x >= screenrect.left &&
p.x <= screenrect.right &&
p.y >= screenrect.top &&
p.y <= screenrect.bottom)
{
return num;
}
num++;
hndl = DMGetNextScreenDevice(hndl, true);
}
return wxNOT_FOUND;
}
wxDisplayImpl *wxDisplayFactoryMac::CreateDisplay(unsigned n)
{
unsigned nOrig = n;
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
if (n == 0)
{
return new wxDisplayImplMac(nOrig, hndl);
}
n--;
hndl = DMGetNextScreenDevice(hndl, true);
}
return NULL;
}
// ============================================================================
// wxDisplayImplMac implementation
// ============================================================================
wxRect wxDisplayImplMac::GetGeometry() const
{
Rect screenrect = (*m_hndl)->gdRect;
return wxRect(screenrect.left, screenrect.top,
screenrect.right - screenrect.left,
screenrect.bottom - screenrect.top);
}
struct DMModeIteratorRec
{
wxArrayVideoModes* pModes;
const wxVideoMode* pMatchMode;
};
pascal void DMModeListIteratorProc(
void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeIteratorRec* pInfoData = (DMModeIteratorRec*) pData;
// Note that in testing the refresh rate is always 0 on my ibook - RN
int refresh = (int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate);
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
if (wxVideoMode( (int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh).Matches(*pInfoData->pMatchMode) )
{
pInfoData->pModes->Add(
wxVideoMode(
(int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh ) );
}
}
#undef pDBI
}
struct DMModeInfoRec
{
const wxVideoMode* pMode;
VDSwitchInfoRec sMode;
bool bMatched;
};
pascal void DMModeInfoProc(
void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo )
{
DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
{
memcpy(
&pInfoData->sMode,
pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
sizeof(VDSwitchInfoRec));
pInfoData->sMode.csMode = pDBI->vpPixelSize;
pInfoData->bMatched = true;
break;
}
}
#undef pDBI
}
struct DMModeTransRec
{
wxVideoMode Mode;
const VDSwitchInfoRec* psMode;
bool bMatched;
};
pascal void DMModeTransProc(
void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
{
pInfoData->Mode = wxVideoMode(
(int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
(int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
pInfoData->bMatched = true;
break;
}
}
#undef pDBI
}
wxArrayVideoModes wxDisplayImplMac::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes Modes;
unsigned long dwDMVer;
// Check DM version == 2
// (for backward compatibility only - 7.5.3+ use 2.0)
Gestalt( gestaltDisplayMgrVers, (long*) &dwDMVer );
if (dwDMVer >= 0x020000)
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
OSErr err;
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
wxASSERT_MSG( err == noErr, wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
wxASSERT( uppMLI );
DMModeIteratorRec sModeInfo;
sModeInfo.pModes = &Modes;
sModeInfo.pMatchMode = &mode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
verify_noerr( err );
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
err = DMDisposeList(pModes);
verify_noerr( err );
}
else // DM 1.0, 1.2, 1.x
{
wxLogSysError(
wxString::Format(
wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) ) );
}
return Modes;
}
wxVideoMode wxDisplayImplMac::GetCurrentMode() const
{
unsigned long dwDMVer;
wxVideoMode RetMode;
// Check DM version == 2
// (for backward compatibility only - 7.5.3+ use 2.0)
Gestalt( gestaltDisplayMgrVers, (long*) &dwDMVer );
if (dwDMVer >= 0x020000)
{
VDSwitchInfoRec sMode; // Note: csMode member also contains the bit depth
OSErr err;
err = DMGetDisplayMode( m_hndl, &sMode );
if (err == noErr)
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
wxASSERT_MSG( err == noErr, wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
wxASSERT( uppMLI );
DMModeTransRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.psMode = &sMode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
verify_noerr( err );
if ( sModeInfo.bMatched )
{
RetMode = sModeInfo.Mode;
break;
}
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
err = DMDisposeList(pModes);
verify_noerr( err );
}
else // Can't get current mode?
{
wxLogSysError(
wxString::Format(
wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
(unsigned int) dwDMVer));
}
}
else // DM ver 1
{
wxLogSysError(
wxString::Format(
wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) ) );
}
return RetMode;
}
bool wxDisplayImplMac::ChangeMode(const wxVideoMode& mode)
{
unsigned long dwDMVer;
Gestalt( gestaltDisplayMgrVers, (long*)&dwDMVer );
if (GetCount() == 1 || dwDMVer >= 0x020000)
{
if (mode == wxDefaultVideoMode)
{
return true;
#if 0
//#ifndef __DARWIN__
// Handle hDisplayState;
// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
// {
// wxLogSysError(wxT("Could not lock display for display mode changing!"));
// return false;
// }
//
// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
// DMEndConfigureDisplays(hDisplayState);
// return true;
//#else
// hmmmmm....
// return true;
//#endif
#endif
}
//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
//so we have to use this icky structure
VDSwitchInfoRec sMode;
memset( &sMode, 0, sizeof(VDSwitchInfoRec) );
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
OSErr err;
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
wxASSERT_MSG(err == noErr, wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
wxASSERT(uppMLI);
DMModeInfoRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.pMode = &mode;
unsigned int i;
for (i = 0; i < nNumModes; ++i)
{
err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
verify_noerr( err );
if (sModeInfo.bMatched)
{
sMode = sModeInfo.sMode;
break;
}
}
if (i == nNumModes)
return false;
DisposeDMDisplayModeListIteratorUPP(uppMLI);
err = DMDisposeList(pModes);
verify_noerr( err );
// For the really paranoid -
// unsigned long flags;
// Boolean bok;
// wxASSERT(noErr == DMCheckDisplayMode(m_hndl, sMode.csData,
// sMode.csMode, &flags, NULL, &bok));
// wxASSERT(bok);
Handle hDisplayState;
if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
{
wxLogSysError(wxT("Could not lock display for display mode changing!"));
return false;
}
unsigned long dwBPP = (unsigned long) mode.bpp;
err = DMSetDisplayMode(
m_hndl, sMode.csData,
(unsigned long*) &(dwBPP),
NULL, //(unsigned long) &sMode
hDisplayState );
if (err != noErr)
{
DMEndConfigureDisplays(hDisplayState);
wxLogError(wxT("Could not set the display mode"));
return false;
}
DMEndConfigureDisplays(hDisplayState);
}
else // DM 1.0, 1.2, 1.x
{
wxLogSysError(
wxString::Format(
wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
(unsigned int) dwDMVer));
return false;
}
return true;
}
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
return new wxDisplayFactoryMac;
}
#endif // !OSX
#endif // wxUSE_DISPLAY