[wxWidgets.git] / src / mac / classic / display.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        display.cpp
// Purpose:     Mac implementation of wxDisplay class
// Author:      Brian Victor
// Modified by: Royce Mitchell III & Ryan Norton
// Created:     06/21/02
// RCS-ID:      $Id$
// Copyright:   (c) wxWidgets team
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_DISPLAY

#ifndef WX_PRECOMP
   #include "wx/dynarray.h"
   #include "wx/log.h"
   #include "wx/msgdlg.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>
#endif

#include "wx/display.h"
#include "wx/gdicmn.h"
#include "wx/string.h"

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

class wxDisplayMacPriv
{
public:
    GDHandle m_hndl;
};

size_t wxDisplayBase::GetCount()
{
    GDHandle hndl;
    size_t num = 0;
    hndl = DMGetFirstScreenDevice(true);
    while(hndl)
    {
        num++;
        hndl = DMGetNextScreenDevice(hndl, true);
    }
    return num;
}

int wxDisplayBase::GetFromPoint(const wxPoint &p)
{
    GDHandle hndl;
    size_t num = 0;
    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 -1;
}

wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
    m_priv ( new wxDisplayMacPriv() )
{
    GDHandle hndl;
    hndl = DMGetFirstScreenDevice(true);
    m_priv->m_hndl = NULL;
    while(hndl)
    {
        if (index == 0)
        {
            m_priv->m_hndl = hndl;
        }
        index--;
        hndl = DMGetNextScreenDevice(hndl, true);
    }
}

wxRect wxDisplay::GetGeometry() const
{
    if (!(m_priv)) return wxRect(0, 0, 0, 0);
    if (!(m_priv->m_hndl)) return wxRect(0, 0, 0, 0);
    Rect screenrect = (*(m_priv->m_hndl))->gdRect;
    return wxRect( screenrect.left, screenrect.top, 
                   screenrect.right - screenrect.left, screenrect.bottom - screenrect.top);
}

int wxDisplay::GetDepth() const
{
    if (!(m_priv)) return 0;
    if (!(m_priv->m_hndl)) return 0;

    // This cryptic looking code is based on Apple's sample code:
    // http://developer.apple.com/samplecode/Sample_Code/Graphics_2D/GDevVideo/Gen.cp.htm

    //RN - according to the docs
	//gdPMap is a bitmap-type representation of the GDevice, and all
	//0x0000FFFF does is get the lower 16 bits of pixelSize.  However,
	//since pixelSize is only 16 bits (a short)...
    return ((*(*(m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
}

wxString wxDisplay::GetName() const
{
    // Macs don't name their displays...
    return wxEmptyString;
}

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);

	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
	{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock

		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);

	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
		{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
		    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;

	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
		{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
		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
    wxDisplay::GetModes(const wxVideoMode& mode) const
{

    wxArrayVideoModes Modes;

    unsigned long dwDMVer;
    Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);

    //Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
    if (dwDMVer >= 0x020000) //version 2?
    {

    	DMListIndexType nNumModes;
    	DMListType pModes;
    	DMDisplayModeListIteratorUPP uppMLI;
    	DisplayIDType nDisplayID;

    	wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);	
    	//Create a new list...
    	wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, 							&pModes) == 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)
    	{
    	    wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
    					      uppMLI, &sModeInfo) == noErr);
    	}
    	DisposeDMDisplayModeListIteratorUPP(uppMLI);
    	wxASSERT(DMDisposeList(pModes) == noErr);	
    }
    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 wxDisplay::GetCurrentMode() const
{
    unsigned long dwDMVer;
    wxVideoMode RetMode;
    
    Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);    
    //Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
    if (dwDMVer >= 0x020000) //version 2?
    {
    	VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
    	if (DMGetDisplayMode(m_priv->m_hndl, &sMode) == noErr) 
    	{
    	    DMListIndexType nNumModes;
    	    DMListType pModes;
    		DMDisplayModeListIteratorUPP uppMLI;
    	    DisplayIDType nDisplayID;

    	    wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
    	    //Create a new list...
    	    wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == 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)
    		{
    			wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
    											uppMLI, &sModeInfo) == noErr);

    			if ( sModeInfo.bMatched == true )
    			{
    				RetMode = sModeInfo.Mode;
    				break;
    			}
    		}

    	    DisposeDMDisplayModeListIteratorUPP(uppMLI);
    	    wxASSERT(DMDisposeList(pModes) == noErr);
    	}
    	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 wxDisplay::ChangeMode(const wxVideoMode& mode)
{
    unsigned long dwDMVer;
    Gestalt(gestaltDisplayMgrVers, (long*)&dwDMVer);
    if (GetCount() == 1 || dwDMVer >= 0x020000)
    {
		if (mode == wxDefaultVideoMode)
		{
//#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
		}
		
    	//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;

    	wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
    	//Create a new list...
    	wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == 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)
    	{
    		wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
    										   uppMLI, &sModeInfo) == noErr);
    		if (sModeInfo.bMatched == true)
    		{
    			sMode = sModeInfo.sMode;
    			break;
    		}
    	}
    	if(i == nNumModes)
    		return false;

    	DisposeDMDisplayModeListIteratorUPP(uppMLI);
    	wxASSERT(DMDisposeList(pModes) == noErr);

    	// For the really paranoid -
    	// 	    unsigned long flags;
    	//      Boolean bok;
    	//     wxASSERT(noErr == DMCheckDisplayMode(m_priv->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;
    	if (DMSetDisplayMode(m_priv->m_hndl, sMode.csData,
    					    (unsigned long*) &(dwBPP), NULL
    					   //(unsigned long) &sMode
    					   , hDisplayState
    					   )  != noErr)
    	{
    		DMEndConfigureDisplays(hDisplayState);
    		wxMessageBox(wxString::Format(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::~wxDisplay()
{
    if ( m_priv )
    {
        delete m_priv;
        m_priv = 0;
    }
}

#endif // wxUSE_DISPLAY
Commit	Line	Data
2646f485 SC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: display.cpp
	3	// Purpose: Mac implementation of wxDisplay class
	4	// Author: Brian Victor
	5	// Modified by: Royce Mitchell III & Ryan Norton
	6	// Created: 06/21/02
	7	// RCS-ID: $Id$
77ffb593	8	// Copyright: (c) wxWidgets team
65571936	9	// Licence: wxWindows licence
2646f485 SC	10	/////////////////////////////////////////////////////////////////////////////
2646f485 SC	11
2646f485 SC	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#if wxUSE_DISPLAY
	20
	21	#ifndef WX_PRECOMP
	22	#include "wx/dynarray.h"
	23	#include "wx/log.h"
	24	#include "wx/msgdlg.h"
	25	#endif
	26
	27	#ifdef __DARWIN__
	28	#include <Carbon/Carbon.h>
	29	#else
	30	#include <Gestalt.h>
	31	#include <Displays.h>
	32	#include <Quickdraw.h>
	33	#include <Video.h> //for VDSwitchInfoRec
	34	#include <FixMath.h>
	35	#endif
	36
	37	#include "wx/display.h"
	38	#include "wx/gdicmn.h"
	39	#include "wx/string.h"
	40
	41	// ----------------------------------------------------------------------------
	42	// private classes
	43	// ----------------------------------------------------------------------------
	44
	45	class wxDisplayMacPriv
	46	{
	47	public:
	48	GDHandle m_hndl;
	49	};
	50
	51	size_t wxDisplayBase::GetCount()
	52	{
	53	GDHandle hndl;
	54	size_t num = 0;
	55	hndl = DMGetFirstScreenDevice(true);
	56	while(hndl)
	57	{
	58	num++;
	59	hndl = DMGetNextScreenDevice(hndl, true);
	60	}
	61	return num;
	62	}
	63
	64	int wxDisplayBase::GetFromPoint(const wxPoint &p)
	65	{
	66	GDHandle hndl;
	67	size_t num = 0;
	68	hndl = DMGetFirstScreenDevice(true);
	69	while(hndl)
	70	{
	71	Rect screenrect = (*hndl)->gdRect;
	72	if (p.x >= screenrect.left &&
	73	p.x <= screenrect.right &&
	74	p.y >= screenrect.top &&
	75	p.y <= screenrect.bottom)
76	{
77	return num;
78	}
79	num++;
80	hndl = DMGetNextScreenDevice(hndl, true);
81	}
82	return -1;
83	}
84
85	wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
86	m_priv ( new wxDisplayMacPriv() )
87	{
88	GDHandle hndl;
89	hndl = DMGetFirstScreenDevice(true);
90	m_priv->m_hndl = NULL;
91	while(hndl)
92	{
93	if (index == 0)
94	{
95	m_priv->m_hndl = hndl;
96	}
97	index--;
98	hndl = DMGetNextScreenDevice(hndl, true);
99	}
100	}
101
102	wxRect wxDisplay::GetGeometry() const
103	{
104	if (!(m_priv)) return wxRect(0, 0, 0, 0);
105	if (!(m_priv->m_hndl)) return wxRect(0, 0, 0, 0);
106	Rect screenrect = (*(m_priv->m_hndl))->gdRect;
107	return wxRect( screenrect.left, screenrect.top,
108	screenrect.right - screenrect.left, screenrect.bottom - screenrect.top);
109	}
110
111	int wxDisplay::GetDepth() const
112	{
113	if (!(m_priv)) return 0;
114	if (!(m_priv->m_hndl)) return 0;
115
116	// This cryptic looking code is based on Apple's sample code:
117	// http://developer.apple.com/samplecode/Sample_Code/Graphics_2D/GDevVideo/Gen.cp.htm
118
119	//RN - according to the docs
120	//gdPMap is a bitmap-type representation of the GDevice, and all
121	//0x0000FFFF does is get the lower 16 bits of pixelSize. However,
122	//since pixelSize is only 16 bits (a short)...
123	return ((((m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
124	}
125
126	wxString wxDisplay::GetName() const
127	{
128	// Macs don't name their displays...
129	return wxEmptyString;
130	}
131
132	struct DMModeIteratorRec
133	{
134	wxArrayVideoModes* pModes;
135	const wxVideoMode* pMatchMode;
136	};
137
138	pascal void DMModeListIteratorProc ( void* pData,
139	DMListIndexType nIndex,
140	DMDisplayModeListEntryPtr pInfo)
141	{
142	DMModeIteratorRec* pInfoData = (DMModeIteratorRec*) pData;
143
144	//Note that in testing the refresh rate is always 0 on my ibook - RN
145	int refresh = (int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate);
146
147	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
148	{
149	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
150
151	if (wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
152	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
153	(int) pDBI->vpPixelSize,
154	refresh).Matches(*pInfoData->pMatchMode) )
155	{
156	pInfoData->pModes->Add(wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
157	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
158	(int) pDBI->vpPixelSize,
159	refresh));
160	}
161	#undef pDBI
162	}
163	}
164
165	struct DMModeInfoRec
166	{
167	const wxVideoMode* pMode;
168	VDSwitchInfoRec sMode;
169	bool bMatched;
170	};
171
172	pascal void DMModeInfoProc ( void* pData,
173	DMListIndexType nIndex,
174	DMDisplayModeListEntryPtr pInfo)
175	{
176	DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
177	Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
178
179	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
180	{
181	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
182	if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
183	pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
184	pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
185	refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
186	{
187	memcpy(&pInfoData->sMode, pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
188	sizeof(VDSwitchInfoRec));
189	pInfoData->sMode.csMode = pDBI->vpPixelSize;
190	pInfoData->bMatched = true;
191	break;
192	}
193	#undef pDBI
194	}
195	}
196
197	struct DMModeTransRec
198	{
199	wxVideoMode Mode;
200	const VDSwitchInfoRec* psMode;
201	bool bMatched;
202	};
203
204	pascal void DMModeTransProc ( void* pData,
205	DMListIndexType nIndex,
206	DMDisplayModeListEntryPtr pInfo)
207	{
208	DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
209
210	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
211	{
212	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
213	if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
214	{
215	pInfoData->Mode = wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
216	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
217	(int) pDBI->vpPixelSize,
218	(int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
219	pInfoData->bMatched = true;
220	break;
221	}
222	#undef pDBI
223	}
224	}
225
226	wxArrayVideoModes
227	wxDisplay::GetModes(const wxVideoMode& mode) const
228	{
229
230	wxArrayVideoModes Modes;
231
232	unsigned long dwDMVer;
233	Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
234
235	//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
236	if (dwDMVer >= 0x020000) //version 2?
237	{
238
239	DMListIndexType nNumModes;
240	DMListType pModes;
241	DMDisplayModeListIteratorUPP uppMLI;
242	DisplayIDType nDisplayID;
243
244	wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
245	//Create a new list...
246	wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr, wxT("Could not create a new display mode list") );
247
248	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
249	wxASSERT(uppMLI);
250
251	DMModeIteratorRec sModeInfo;
252	sModeInfo.pModes = &Modes;
253	sModeInfo.pMatchMode = &mode;
254	for (DMListIndexType i = 0; i < nNumModes; ++i)
255	{
256	wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
257	uppMLI, &sModeInfo) == noErr);
258	}
259	DisposeDMDisplayModeListIteratorUPP(uppMLI);
260	wxASSERT(DMDisposeList(pModes) == noErr);
261	}
262	else //DM 1.0, 1.2, 1.x
263	{
264	wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
265	(unsigned int) dwDMVer / 0x10000,
266	(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
267	);
268	}
269
270	return Modes;
271	}
272
273	wxVideoMode wxDisplay::GetCurrentMode() const
274	{
275	unsigned long dwDMVer;
276	wxVideoMode RetMode;
277
278	Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
279	//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
280	if (dwDMVer >= 0x020000) //version 2?
281	{
282	VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
283	if (DMGetDisplayMode(m_priv->m_hndl, &sMode) == noErr)
284	{
285	DMListIndexType nNumModes;
286	DMListType pModes;
287	DMDisplayModeListIteratorUPP uppMLI;
288	DisplayIDType nDisplayID;
289
290	wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
291	//Create a new list...
292	wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
293	wxT("Could not create a new display mode list") );
294
295	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
296	wxASSERT(uppMLI);
297
298	DMModeTransRec sModeInfo;
299	sModeInfo.bMatched = false;
300	sModeInfo.psMode = &sMode;
301	for (DMListIndexType i = 0; i < nNumModes; ++i)
302	{
303	wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
304	uppMLI, &sModeInfo) == noErr);
305
306	if ( sModeInfo.bMatched == true )
307	{
308	RetMode = sModeInfo.Mode;
309	break;
310	}
311	}
312
313	DisposeDMDisplayModeListIteratorUPP(uppMLI);
314	wxASSERT(DMDisposeList(pModes) == noErr);
315	}
316	else //Can't get current mode?
317	{
318	wxLogSysError(wxString::Format(wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
319	(unsigned int) dwDMVer));
320	}
321	}
322	else //DM ver 1
323	{
324	wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
325	(unsigned int) dwDMVer / 0x10000,
326	(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
327	);
328	}
329
330	return RetMode;
331	}
332
333	bool wxDisplay::ChangeMode(const wxVideoMode& mode)
334	{
335	unsigned long dwDMVer;
336	Gestalt(gestaltDisplayMgrVers, (long*)&dwDMVer);
337	if (GetCount() == 1 \|\| dwDMVer >= 0x020000)
338	{
339	if (mode == wxDefaultVideoMode)
340	{
341	//#ifndef __DARWIN__
342	// Handle hDisplayState;
343	// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
344	// {
345	// wxLogSysError(wxT("Could not lock display for display mode changing!"));
346	// return false;
347	// }
348	// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
349	// DMEndConfigureDisplays(hDisplayState);
350	// return true;
351	//#else
352	//hmmmmm....
353	return true;
354	//#endif
355	}
356
357	//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
358	//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
359	//so we have to use this icky structure
360	VDSwitchInfoRec sMode;
361	memset(&sMode, 0, sizeof(VDSwitchInfoRec) );
362
363	DMListIndexType nNumModes;
364	DMListType pModes;
365	DMDisplayModeListIteratorUPP uppMLI;
366	DisplayIDType nDisplayID;
367
368	wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
369	//Create a new list...
370	wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
371	wxT("Could not create a new display mode list") );
372
373	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
374	wxASSERT(uppMLI);
375
376	DMModeInfoRec sModeInfo;
377	sModeInfo.bMatched = false;
378	sModeInfo.pMode = &mode;
379	unsigned int i;
380	for(i = 0; i < nNumModes; ++i)
381	{
382	wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
383	uppMLI, &sModeInfo) == noErr);
384	if (sModeInfo.bMatched == true)
385	{
386	sMode = sModeInfo.sMode;
387	break;
388	}
389	}
390	if(i == nNumModes)
391	return false;
392
393	DisposeDMDisplayModeListIteratorUPP(uppMLI);
394	wxASSERT(DMDisposeList(pModes) == noErr);
395
396	// For the really paranoid -
397	// unsigned long flags;
398	// Boolean bok;
399	// wxASSERT(noErr == DMCheckDisplayMode(m_priv->m_hndl, sMode.csData,
400	// sMode.csMode, &flags, NULL, &bok));
401	// wxASSERT(bok);
402
403	Handle hDisplayState;
404	if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
405	{
406	wxLogSysError(wxT("Could not lock display for display mode changing!"));
407	return false;
408	}
409
410	unsigned long dwBPP = (unsigned long) mode.bpp;
411	if (DMSetDisplayMode(m_priv->m_hndl, sMode.csData,
412	(unsigned long*) &(dwBPP), NULL
413	//(unsigned long) &sMode
414	, hDisplayState
415	) != noErr)
416	{
417	DMEndConfigureDisplays(hDisplayState);
418	wxMessageBox(wxString::Format(wxT("Could not set the display mode")));
419	return false;
420	}
421	DMEndConfigureDisplays(hDisplayState);
422	}
423	else //DM 1.0, 1.2, 1.x
424	{
425	wxLogSysError(wxString::Format(wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
426	(unsigned int) dwDMVer));
427	return false;
428	}
429
430	return true;
431	}
432
433	wxDisplay::~wxDisplay()
434	{
435	if ( m_priv )
436	{
437	delete m_priv;
438	m_priv = 0;
439	}
440	}
441
442	#endif // wxUSE_DISPLAY