src/mac/classic/display.cpp

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

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_DISPLAY

#include "wx/display.h"

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

#include "wx/display_impl.h"

// ----------------------------------------------------------------------------
// display implementation classes
// ----------------------------------------------------------------------------

class wxDisplayImplMac : public wxDisplayImpl
{
public:
    wxDisplayImplMac(size_t 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(size_t n);
    virtual size_t GetCount();
    virtual int GetFromPoint(const wxPoint& pt);

protected:
    DECLARE_NO_COPY_CLASS(wxDisplayFactoryMac)
};

// ============================================================================
// wxDisplayFactoryMac implementation
// ============================================================================

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

int wxDisplayFactoryMac::GetFromPoint(const wxPoint &p)
{
    size_t 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(size_t n)
{
    size_t 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);

    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 wxDisplayImplMac::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_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 wxDisplayImplMac::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_hndl, &sMode) == noErr)
        {
            DMListIndexType nNumModes;
            DMListType pModes;
            DMDisplayModeListIteratorUPP uppMLI;
            DisplayIDType nDisplayID;

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