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

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

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
    #pragma implementation "display.h"
#endif

// 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
// ----------------------------------------------------------------------------

#ifdef __WXMAC_OSX__

class wxDisplayMacPriv
{
public:
    CGDirectDisplayID m_id;
};

size_t wxDisplayBase::GetCount()
{
    CGDisplayCount count;
#ifdef __WXDEBUG__
    CGDisplayErr err = 
#endif
    CGGetActiveDisplayList(0, NULL, &count);

    wxASSERT(err == CGDisplayNoErr);
    return count;
}

int wxDisplayBase::GetFromPoint(const wxPoint &p)
{   
    CGPoint thePoint = {(float)p.x, (float)p.y};
    CGDirectDisplayID theID;
    CGDisplayCount theCount;
    CGDisplayErr err = CGGetDisplaysWithPoint(thePoint, 1, &theID, &theCount);
    wxASSERT(err == CGDisplayNoErr);
    int nWhich = -1;
    
    if (theCount)
    {
        theCount = GetCount();
        CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
        err = CGGetActiveDisplayList(theCount, theIDs, &theCount);
        wxASSERT(err == CGDisplayNoErr);

        for(nWhich = 0; nWhich < (int) theCount; ++nWhich)
        {
            if(theIDs[nWhich] == theID)
                break;
        }
        
        delete[] theIDs;
        
        if(nWhich == (int) theCount)
        {
            wxFAIL_MSG(wxT("Failed to find display in display list"));
            nWhich = -1;
        }
    }
    
    return nWhich;
}//CFUserNotification[NSBundle bundleForClass:[self class]]

wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ) ,
    m_priv ( new wxDisplayMacPriv() )
{
    CGDisplayCount theCount = GetCount();
    CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
#ifdef __WXDEBUG__
    CGDisplayErr err = 
#endif
    CGGetActiveDisplayList(theCount, theIDs, &theCount);

    wxASSERT(err == CGDisplayNoErr);
    wxASSERT(index < theCount);
    
    m_priv->m_id = theIDs[index];
    
    delete[] theIDs;
}

wxRect wxDisplay::GetGeometry() const
{
    CGRect theRect = CGDisplayBounds(m_priv->m_id);
    return wxRect(	(int)theRect.origin.x,
                    (int)theRect.origin.y,
                    (int)theRect.size.width,
                    (int)theRect.size.height  ); //floats
}

int wxDisplay::GetDepth() const
{
    return (int) CGDisplayBitsPerPixel(m_priv->m_id); //size_t
}

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

static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
{
    CFNumberRef value;
    int num = 0;

    if ( (value = (CFNumberRef) CFDictionaryGetValue(desc, key)) == NULL )
        return 0;
    CFNumberGetValue(value, kCFNumberIntType, &num);
    return num;
}

wxArrayVideoModes
    wxDisplay::GetModes(const wxVideoMode& mode) const
{
    wxArrayVideoModes Modes;
    
    CFArrayRef theArray = CGDisplayAvailableModes(m_priv->m_id);

    for(CFIndex i = 0; i < CFArrayGetCount(theArray); ++i)
    {
        CFDictionaryRef theValue = (CFDictionaryRef) CFArrayGetValueAtIndex(theArray, i);
        
        wxVideoMode theMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
                            wxCFDictKeyToInt(theValue, kCGDisplayHeight),
                            wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
                            wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
        
        if (theMode.Matches(mode))
            Modes.Add(theMode);
    }
    
    return Modes;
}

wxVideoMode wxDisplay::GetCurrentMode() const
{
    CFDictionaryRef theValue = CGDisplayCurrentMode (m_priv->m_id);
    
    return wxVideoMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
                            wxCFDictKeyToInt(theValue, kCGDisplayHeight),
                            wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
                            wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
}

bool wxDisplay::ChangeMode(const wxVideoMode& mode)
{
    //Changing to default mode (wxDefualtVideoMode) doesn't
    //work because we don't have access to the system's 'scrn'
    //resource which holds the user's mode which the system
    //will return to after this app is done
    boolean_t bExactMatch;
    CFDictionaryRef theCGMode = CGDisplayBestModeForParametersAndRefreshRate (
                                        m_priv->m_id,
                                        (size_t)mode.bpp,
                                        (size_t)mode.w,
                                        (size_t)mode.h,
                                        (double)mode.refresh,
                                        &bExactMatch);
    
    bool bOK = bExactMatch;
    
    if(bOK)
        bOK = CGDisplaySwitchToMode(m_priv->m_id, theCGMode) == CGDisplayNoErr;

    return bOK;
}

wxDisplay::~wxDisplay()
{
    if ( m_priv )
    {
        delete m_priv;
        m_priv = 0;
    }
}

#else

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;
        OSErr err;

        err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
    	wxASSERT(err == noErr);	
        
    	//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);
    	    wxASSERT(err == noErr);
    	}
    	DisposeDMDisplayModeListIteratorUPP(uppMLI);
        
        err = DMDisposeList(pModes);
    	wxASSERT(err == 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;
            OSErr err;

            err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
    	    wxASSERT(err == noErr);
            
    	    //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);
    			wxASSERT(err == noErr);

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

    	    DisposeDMDisplayModeListIteratorUPP(uppMLI);
            
            err = DMDisposeList(pModes);
    	    wxASSERT(err == 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;
        OSErr err;

        err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
    	wxASSERT(err == noErr);
        
    	//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);
    		wxASSERT(err == noErr);
            
    		if (sModeInfo.bMatched == true)
    		{
    			sMode = sModeInfo.sMode;
    			break;
    		}
    	}
    	if(i == nNumModes)
    		return false;

    	DisposeDMDisplayModeListIteratorUPP(uppMLI);
    	
        err = DMDisposeList(pModes);
        wxASSERT(err == 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 // !OSX

#endif // wxUSE_DISPLAY
Commit	Line	Data
a536e411 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: display.cpp
	3	// Purpose: Mac implementation of wxDisplay class
cc9d56b0 RN	4	// Author: Ryan Norton & Brian Victor
cc9d56b0 RN	5	// Modified by: Royce Mitchell III
a536e411 JS	6	// Created: 06/21/02
a536e411 JS	7	// RCS-ID: $Id$
77ffb593	8	// Copyright: (c) wxWidgets team
65571936	9	// Licence: wxWindows licence
a536e411 JS	10	/////////////////////////////////////////////////////////////////////////////
a536e411 JS	11
3d1a4878	12	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
a536e411 JS	13	#pragma implementation "display.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#if wxUSE_DISPLAY
	24
	25	#ifndef WX_PRECOMP
	26	#include "wx/dynarray.h"
1ed1a609	27	#include "wx/log.h"
92094b09	28	#include "wx/msgdlg.h"
a536e411 JS	29	#endif
	30
	31	#ifdef __DARWIN__
	32	#include <Carbon/Carbon.h>
	33	#else
7c4a8e41	34	#include <Gestalt.h>
a536e411 JS	35	#include <Displays.h>
a536e411 JS	36	#include <Quickdraw.h>
1ed1a609	37	#include <Video.h> //for VDSwitchInfoRec
7c4a8e41	38	#include <FixMath.h>
a536e411 JS	39	#endif
	40
	41	#include "wx/display.h"
	42	#include "wx/gdicmn.h"
	43	#include "wx/string.h"
	44
	45	// ----------------------------------------------------------------------------
	46	// private classes
	47	// ----------------------------------------------------------------------------
	48
20b69855 SC	49	#ifdef __WXMAC_OSX__
	50
	51	class wxDisplayMacPriv
	52	{
	53	public:
	54	CGDirectDisplayID m_id;
	55	};
	56
	57	size_t wxDisplayBase::GetCount()
	58	{
	59	CGDisplayCount count;
	60	#ifdef __WXDEBUG__
	61	CGDisplayErr err =
	62	#endif
	63	CGGetActiveDisplayList(0, NULL, &count);
	64
	65	wxASSERT(err == CGDisplayNoErr);
	66	return count;
	67	}
	68
	69	int wxDisplayBase::GetFromPoint(const wxPoint &p)
	70	{
	71	CGPoint thePoint = {(float)p.x, (float)p.y};
	72	CGDirectDisplayID theID;
	73	CGDisplayCount theCount;
	74	CGDisplayErr err = CGGetDisplaysWithPoint(thePoint, 1, &theID, &theCount);
	75	wxASSERT(err == CGDisplayNoErr);
	76	int nWhich = -1;
	77
	78	if (theCount)
	79	{
	80	theCount = GetCount();
	81	CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
	82	err = CGGetActiveDisplayList(theCount, theIDs, &theCount);
	83	wxASSERT(err == CGDisplayNoErr);
	84
	85	for(nWhich = 0; nWhich < (int) theCount; ++nWhich)
	86	{
	87	if(theIDs[nWhich] == theID)
	88	break;
	89	}
	90
	91	delete[] theIDs;
	92
	93	if(nWhich == (int) theCount)
	94	{
	95	wxFAIL_MSG(wxT("Failed to find display in display list"));
	96	nWhich = -1;
	97	}
	98	}
	99
	100	return nWhich;
	101	}//CFUserNotification[NSBundle bundleForClass:[self class]]
	102
	103	wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ) ,
	104	m_priv ( new wxDisplayMacPriv() )
	105	{
	106	CGDisplayCount theCount = GetCount();
	107	CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
	108	#ifdef __WXDEBUG__
	109	CGDisplayErr err =
	110	#endif
	111	CGGetActiveDisplayList(theCount, theIDs, &theCount);
	112
113	wxASSERT(err == CGDisplayNoErr);
114	wxASSERT(index < theCount);
115
116	m_priv->m_id = theIDs[index];
117
118	delete[] theIDs;
119	}
120
121	wxRect wxDisplay::GetGeometry() const
122	{
123	CGRect theRect = CGDisplayBounds(m_priv->m_id);
124	return wxRect( (int)theRect.origin.x,
125	(int)theRect.origin.y,
126	(int)theRect.size.width,
127	(int)theRect.size.height ); //floats
128	}
129
130	int wxDisplay::GetDepth() const
131	{
132	return (int) CGDisplayBitsPerPixel(m_priv->m_id); //size_t
133	}
134
135	wxString wxDisplay::GetName() const
136	{
137	// Macs don't name their displays...
138	return wxEmptyString;
139	}
140
141	static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
142	{
143	CFNumberRef value;
144	int num = 0;
145
146	if ( (value = (CFNumberRef) CFDictionaryGetValue(desc, key)) == NULL )
147	return 0;
148	CFNumberGetValue(value, kCFNumberIntType, &num);
149	return num;
150	}
151
152	wxArrayVideoModes
153	wxDisplay::GetModes(const wxVideoMode& mode) const
154	{
155	wxArrayVideoModes Modes;
156
157	CFArrayRef theArray = CGDisplayAvailableModes(m_priv->m_id);
158
159	for(CFIndex i = 0; i < CFArrayGetCount(theArray); ++i)
160	{
161	CFDictionaryRef theValue = (CFDictionaryRef) CFArrayGetValueAtIndex(theArray, i);
162
163	wxVideoMode theMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
164	wxCFDictKeyToInt(theValue, kCGDisplayHeight),
165	wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
166	wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
167
168	if (theMode.Matches(mode))
169	Modes.Add(theMode);
170	}
171
172	return Modes;
173	}
174
175	wxVideoMode wxDisplay::GetCurrentMode() const
176	{
177	CFDictionaryRef theValue = CGDisplayCurrentMode (m_priv->m_id);
178
179	return wxVideoMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
180	wxCFDictKeyToInt(theValue, kCGDisplayHeight),
181	wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
182	wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
183	}
184
185	bool wxDisplay::ChangeMode(const wxVideoMode& mode)
186	{
187	//Changing to default mode (wxDefualtVideoMode) doesn't
188	//work because we don't have access to the system's 'scrn'
189	//resource which holds the user's mode which the system
190	//will return to after this app is done
191	boolean_t bExactMatch;
192	CFDictionaryRef theCGMode = CGDisplayBestModeForParametersAndRefreshRate (
193	m_priv->m_id,
194	(size_t)mode.bpp,
195	(size_t)mode.w,
196	(size_t)mode.h,
197	(double)mode.refresh,
198	&bExactMatch);
199
200	bool bOK = bExactMatch;
201
202	if(bOK)
203	bOK = CGDisplaySwitchToMode(m_priv->m_id, theCGMode) == CGDisplayNoErr;
204
205	return bOK;
206	}
207
208	wxDisplay::~wxDisplay()
209	{
210	if ( m_priv )
211	{
212	delete m_priv;
213	m_priv = 0;
214	}
215	}
216
217	#else
218
a536e411 JS	219	class wxDisplayMacPriv
	220	{
	221	public:
e40298d5	222	GDHandle m_hndl;
a536e411 JS	223	};
	224
	225	size_t wxDisplayBase::GetCount()
	226	{
	227	GDHandle hndl;
	228	size_t num = 0;
	229	hndl = DMGetFirstScreenDevice(true);
	230	while(hndl)
	231	{
	232	num++;
	233	hndl = DMGetNextScreenDevice(hndl, true);
	234	}
	235	return num;
	236	}
	237
	238	int wxDisplayBase::GetFromPoint(const wxPoint &p)
	239	{
	240	GDHandle hndl;
	241	size_t num = 0;
	242	hndl = DMGetFirstScreenDevice(true);
	243	while(hndl)
	244	{
	245	Rect screenrect = (*hndl)->gdRect;
	246	if (p.x >= screenrect.left &&
	247	p.x <= screenrect.right &&
	248	p.y >= screenrect.top &&
	249	p.y <= screenrect.bottom)
	250	{
	251	return num;
	252	}
	253	num++;
	254	hndl = DMGetNextScreenDevice(hndl, true);
	255	}
	256	return -1;
	257	}
	258
	259	wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
	260	m_priv ( new wxDisplayMacPriv() )
	261	{
	262	GDHandle hndl;
	263	hndl = DMGetFirstScreenDevice(true);
	264	m_priv->m_hndl = NULL;
	265	while(hndl)
	266	{
	267	if (index == 0)
	268	{
	269	m_priv->m_hndl = hndl;
	270	}
	271	index--;
	272	hndl = DMGetNextScreenDevice(hndl, true);
	273	}
	274	}
	275
	276	wxRect wxDisplay::GetGeometry() const
	277	{
	278	if (!(m_priv)) return wxRect(0, 0, 0, 0);
	279	if (!(m_priv->m_hndl)) return wxRect(0, 0, 0, 0);
	280	Rect screenrect = (*(m_priv->m_hndl))->gdRect;
	281	return wxRect( screenrect.left, screenrect.top,
	282	screenrect.right - screenrect.left, screenrect.bottom - screenrect.top);
	283	}
	284
	285	int wxDisplay::GetDepth() const
	286	{
287	if (!(m_priv)) return 0;
288	if (!(m_priv->m_hndl)) return 0;
289
290	// This cryptic looking code is based on Apple's sample code:
291	// http://developer.apple.com/samplecode/Sample_Code/Graphics_2D/GDevVideo/Gen.cp.htm
1ed1a609 SC	292
	293	//RN - according to the docs
	294	//gdPMap is a bitmap-type representation of the GDevice, and all
	295	//0x0000FFFF does is get the lower 16 bits of pixelSize. However,
	296	//since pixelSize is only 16 bits (a short)...
a536e411 JS	297	return ((((m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
	298	}
	299
	300	wxString wxDisplay::GetName() const
	301	{
	302	// Macs don't name their displays...
1e1cc1ce DS	303	return wxEmptyString;
	304	}
	305
1ed1a609 SC	306	struct DMModeIteratorRec
	307	{
	308	wxArrayVideoModes* pModes;
	309	const wxVideoMode* pMatchMode;
	310	};
	311
	312	pascal void DMModeListIteratorProc ( void* pData,
	313	DMListIndexType nIndex,
	314	DMDisplayModeListEntryPtr pInfo)
	315	{
	316	DMModeIteratorRec* pInfoData = (DMModeIteratorRec*) pData;
	317
	318	//Note that in testing the refresh rate is always 0 on my ibook - RN
	319	int refresh = (int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate);
	320
	321	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
	322	{
	323	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
	324
	325	if (wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
	326	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
	327	(int) pDBI->vpPixelSize,
	328	refresh).Matches(*pInfoData->pMatchMode) )
	329	{
	330	pInfoData->pModes->Add(wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
	331	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
	332	(int) pDBI->vpPixelSize,
	333	refresh));
	334	}
	335	#undef pDBI
	336	}
	337	}
	338
	339	struct DMModeInfoRec
	340	{
	341	const wxVideoMode* pMode;
	342	VDSwitchInfoRec sMode;
	343	bool bMatched;
	344	};
	345
	346	pascal void DMModeInfoProc ( void* pData,
	347	DMListIndexType nIndex,
	348	DMDisplayModeListEntryPtr pInfo)
	349	{
	350	DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
	351	Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
	352
	353	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
	354	{
	355	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
	356	if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
	357	pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
	358	pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
	359	refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
	360	{
	361	memcpy(&pInfoData->sMode, pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
	362	sizeof(VDSwitchInfoRec));
	363	pInfoData->sMode.csMode = pDBI->vpPixelSize;
	364	pInfoData->bMatched = true;
	365	break;
	366	}
	367	#undef pDBI
	368	}
	369	}
370
371	struct DMModeTransRec
372	{
373	wxVideoMode Mode;
374	const VDSwitchInfoRec* psMode;
375	bool bMatched;
376	};
377
378	pascal void DMModeTransProc ( void* pData,
379	DMListIndexType nIndex,
380	DMDisplayModeListEntryPtr pInfo)
381	{
382	DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
383
384	for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
385	{
386	#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
387	if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
388	{
389	pInfoData->Mode = wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
390	(int) pInfo->displayModeResolutionInfo->csVerticalLines,
391	(int) pDBI->vpPixelSize,
392	(int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
393	pInfoData->bMatched = true;
394	break;
395	}
396	#undef pDBI
397	}
398	}
399
400	wxArrayVideoModes
1e1cc1ce DS	401	wxDisplay::GetModes(const wxVideoMode& mode) const
1e1cc1ce DS	402	{
1ed1a609 SC	403
	404	wxArrayVideoModes Modes;
	405
	406	unsigned long dwDMVer;
	407	Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
	408
	409	//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
	410	if (dwDMVer >= 0x020000) //version 2?
	411	{
	412
	413	DMListIndexType nNumModes;
	414	DMListType pModes;
	415	DMDisplayModeListIteratorUPP uppMLI;
	416	DisplayIDType nDisplayID;
cc9d56b0	417	OSErr err;
1ed1a609	418
cc9d56b0 RN	419	err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
	420	wxASSERT(err == noErr);
	421
1ed1a609	422	//Create a new list...
cc9d56b0 RN	423	err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
cc9d56b0 RN	424	wxASSERT_MSG(err == noErr, wxT("Could not create a new display mode list") );
1ed1a609 SC	425
	426	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
	427	wxASSERT(uppMLI);
	428
	429	DMModeIteratorRec sModeInfo;
	430	sModeInfo.pModes = &Modes;
	431	sModeInfo.pMatchMode = &mode;
	432	for (DMListIndexType i = 0; i < nNumModes; ++i)
	433	{
cc9d56b0 RN	434	err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
cc9d56b0 RN	435	wxASSERT(err == noErr);
1ed1a609 SC	436	}
1ed1a609 SC	437	DisposeDMDisplayModeListIteratorUPP(uppMLI);
cc9d56b0 RN	438
	439	err = DMDisposeList(pModes);
	440	wxASSERT(err == noErr);
1ed1a609 SC	441	}
	442	else //DM 1.0, 1.2, 1.x
	443	{
	444	wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
	445	(unsigned int) dwDMVer / 0x10000,
	446	(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
	447	);
	448	}
	449
	450	return Modes;
1e1cc1ce DS	451	}
	452
	453	wxVideoMode wxDisplay::GetCurrentMode() const
	454	{
1ed1a609 SC	455	unsigned long dwDMVer;
	456	wxVideoMode RetMode;
	457
	458	Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
	459	//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
	460	if (dwDMVer >= 0x020000) //version 2?
	461	{
	462	VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
	463	if (DMGetDisplayMode(m_priv->m_hndl, &sMode) == noErr)
	464	{
	465	DMListIndexType nNumModes;
	466	DMListType pModes;
	467	DMDisplayModeListIteratorUPP uppMLI;
	468	DisplayIDType nDisplayID;
cc9d56b0	469	OSErr err;
1ed1a609	470
cc9d56b0 RN	471	err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
	472	wxASSERT(err == noErr);
	473
1ed1a609	474	//Create a new list...
cc9d56b0 RN	475	err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
cc9d56b0 RN	476	wxASSERT_MSG(err == noErr, wxT("Could not create a new display mode list") );
1ed1a609 SC	477
	478	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
	479	wxASSERT(uppMLI);
	480
	481	DMModeTransRec sModeInfo;
	482	sModeInfo.bMatched = false;
	483	sModeInfo.psMode = &sMode;
	484	for (DMListIndexType i = 0; i < nNumModes; ++i)
	485	{
cc9d56b0 RN	486	err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
cc9d56b0 RN	487	wxASSERT(err == noErr);
1ed1a609 SC	488
	489	if ( sModeInfo.bMatched == true )
	490	{
	491	RetMode = sModeInfo.Mode;
	492	break;
	493	}
	494	}
	495
	496	DisposeDMDisplayModeListIteratorUPP(uppMLI);
cc9d56b0 RN	497
	498	err = DMDisposeList(pModes);
	499	wxASSERT(err == noErr);
1ed1a609 SC	500	}
	501	else //Can't get current mode?
	502	{
	503	wxLogSysError(wxString::Format(wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
	504	(unsigned int) dwDMVer));
	505	}
	506	}
	507	else //DM ver 1
	508	{
	509	wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
	510	(unsigned int) dwDMVer / 0x10000,
	511	(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
	512	);
	513	}
	514
	515	return RetMode;
1e1cc1ce DS	516	}
	517
	518	bool wxDisplay::ChangeMode(const wxVideoMode& mode)
	519	{
1ed1a609 SC	520	unsigned long dwDMVer;
	521	Gestalt(gestaltDisplayMgrVers, (long*)&dwDMVer);
	522	if (GetCount() == 1 \|\| dwDMVer >= 0x020000)
	523	{
	524	if (mode == wxDefaultVideoMode)
	525	{
	526	//#ifndef __DARWIN__
	527	// Handle hDisplayState;
	528	// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
	529	// {
	530	// wxLogSysError(wxT("Could not lock display for display mode changing!"));
	531	// return false;
	532	// }
	533	// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
	534	// DMEndConfigureDisplays(hDisplayState);
	535	// return true;
	536	//#else
	537	//hmmmmm....
	538	return true;
	539	//#endif
	540	}
	541
	542	//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
	543	//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
	544	//so we have to use this icky structure
	545	VDSwitchInfoRec sMode;
	546	memset(&sMode, 0, sizeof(VDSwitchInfoRec) );
	547
	548	DMListIndexType nNumModes;
	549	DMListType pModes;
	550	DMDisplayModeListIteratorUPP uppMLI;
	551	DisplayIDType nDisplayID;
cc9d56b0	552	OSErr err;
1ed1a609	553
cc9d56b0 RN	554	err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
	555	wxASSERT(err == noErr);
	556
1ed1a609	557	//Create a new list...
cc9d56b0 RN	558	err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
cc9d56b0 RN	559	wxASSERT_MSG(err == noErr, wxT("Could not create a new display mode list") );
1ed1a609 SC	560
	561	uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
	562	wxASSERT(uppMLI);
	563
	564	DMModeInfoRec sModeInfo;
	565	sModeInfo.bMatched = false;
	566	sModeInfo.pMode = &mode;
	567	unsigned int i;
	568	for(i = 0; i < nNumModes; ++i)
	569	{
cc9d56b0 RN	570	err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
	571	wxASSERT(err == noErr);
	572
1ed1a609 SC	573	if (sModeInfo.bMatched == true)
	574	{
	575	sMode = sModeInfo.sMode;
	576	break;
	577	}
	578	}
	579	if(i == nNumModes)
	580	return false;
	581
	582	DisposeDMDisplayModeListIteratorUPP(uppMLI);
cc9d56b0 RN	583
	584	err = DMDisposeList(pModes);
	585	wxASSERT(err == noErr);
1ed1a609 SC	586
	587	// For the really paranoid -
	588	// unsigned long flags;
	589	// Boolean bok;
	590	// wxASSERT(noErr == DMCheckDisplayMode(m_priv->m_hndl, sMode.csData,
	591	// sMode.csMode, &flags, NULL, &bok));
	592	// wxASSERT(bok);
	593
	594	Handle hDisplayState;
	595	if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
	596	{
	597	wxLogSysError(wxT("Could not lock display for display mode changing!"));
	598	return false;
	599	}
	600
	601	unsigned long dwBPP = (unsigned long) mode.bpp;
	602	if (DMSetDisplayMode(m_priv->m_hndl, sMode.csData,
	603	(unsigned long*) &(dwBPP), NULL
	604	//(unsigned long) &sMode
	605	, hDisplayState
	606	) != noErr)
	607	{
	608	DMEndConfigureDisplays(hDisplayState);
	609	wxMessageBox(wxString::Format(wxT("Could not set the display mode")));
	610	return false;
	611	}
	612	DMEndConfigureDisplays(hDisplayState);
	613	}
	614	else //DM 1.0, 1.2, 1.x
	615	{
	616	wxLogSysError(wxString::Format(wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
	617	(unsigned int) dwDMVer));
	618	return false;
	619	}
	620
	621	return true;
a536e411 JS	622	}
	623
	624	wxDisplay::~wxDisplay()
	625	{
	626	if ( m_priv )
	627	{
	628	delete m_priv;
	629	m_priv = 0;
	630	}
	631	}
	632
20b69855 SC	633	#endif // !OSX
20b69855 SC	634
a536e411	635	#endif // wxUSE_DISPLAY