guard against early redraws

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

diff --git a/src/mac/carbon/display.cpp b/src/mac/carbon/display.cpp
index e25b2486e3fbe1fe4226caa3fb3acc86cd343d3d..9619dfcc2fa5ecf9c63daabf01e821aad59c4dc9 100644 (file)
--- a/src/mac/carbon/display.cpp
+++ b/src/mac/carbon/display.cpp
@@ -1,19 +1,14 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        display.cpp
 // Purpose:     Mac implementation of wxDisplay class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        display.cpp
 // Purpose:     Mac implementation of wxDisplay class

-// Author:      Brian Victor
+// Author:      Ryan Norton & Brian Victor

 // Modified by: Royce Mitchell III
 // Created:     06/21/02
 // RCS-ID:      $Id$
 // Modified by: Royce Mitchell III
 // Created:     06/21/02
 // RCS-ID:      $Id$

-// Copyright:   (c) wxWindows team
+// Copyright:   (c) wxWidgets team

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-    #pragma implementation "display.h"
-#endif
-
-// For compilers that support precompilation, includes "wx.h".

 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__


@@ -24,13 +19,18 @@
 
 #ifndef WX_PRECOMP
    #include "wx/dynarray.h"
 
 #ifndef WX_PRECOMP
    #include "wx/dynarray.h"

+   #include "wx/log.h"
+   #include "wx/msgdlg.h"

 #endif
 
 #ifdef __DARWIN__
     #include <Carbon/Carbon.h>
 #else
 #endif
 
 #ifdef __DARWIN__
     #include <Carbon/Carbon.h>
 #else

+    #include <Gestalt.h>

     #include <Displays.h>
     #include <Quickdraw.h>
     #include <Displays.h>
     #include <Quickdraw.h>

+    #include <Video.h>  // for VDSwitchInfoRec
+    #include <FixMath.h>

 #endif
 
 #include "wx/display.h"
 #endif
 
 #include "wx/display.h"


@@ -41,10 +41,181 @@
 // private classes
 // ----------------------------------------------------------------------------
 
 // private classes
 // ----------------------------------------------------------------------------
 

+#ifdef __WXMAC_OSX__
+

 class wxDisplayMacPriv
 {
 public:
 class wxDisplayMacPriv
 {
 public:

-       GDHandle m_hndl;
+    CGDirectDisplayID m_id;
+};
+
+size_t wxDisplayBase::GetCount()
+{
+    CGDisplayCount count;
+    CGDisplayErr err = 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;
+}
+
+wxDisplay::wxDisplay(size_t index)
+    : wxDisplayBase( index ) ,
+    m_priv( new wxDisplayMacPriv() )
+{
+    CGDisplayCount theCount = GetCount();
+    CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
+
+    CGDisplayErr err = 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 = (CFNumberRef) CFDictionaryGetValue( desc, key );
+    if (value == NULL)
+        return 0;
+
+    int num = 0;
+    CFNumberGetValue( value, kCFNumberIntType, &num );
+
+    return num;
+}
+
+wxArrayVideoModes
+    wxDisplay::GetModes(const wxVideoMode& mode) const
+{
+    wxArrayVideoModes resultModes;
+
+    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 ))
+            resultModes.Add( theMode );
+    }
+
+    return resultModes;
+}
+
+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 (wxDefaultVideoMode) 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()
 };
 
 size_t wxDisplayBase::GetCount()


@@ -52,11 +223,12 @@ size_t wxDisplayBase::GetCount()
     GDHandle hndl;
     size_t num = 0;
     hndl = DMGetFirstScreenDevice(true);
     GDHandle hndl;
     size_t num = 0;
     hndl = DMGetFirstScreenDevice(true);

-    while(hndl)
+    while (hndl)

     {
         num++;
         hndl = DMGetNextScreenDevice(hndl, true);
     }
     {
         num++;
         hndl = DMGetNextScreenDevice(hndl, true);
     }

+

     return num;
 }
 
     return num;
 }
 


@@ -65,7 +237,8 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
     GDHandle hndl;
     size_t num = 0;
     hndl = DMGetFirstScreenDevice(true);
     GDHandle hndl;
     size_t num = 0;
     hndl = DMGetFirstScreenDevice(true);

-    while(hndl)
+
+    while (hndl)

     {
         Rect screenrect = (*hndl)->gdRect;
         if (p.x >= screenrect.left &&
     {
         Rect screenrect = (*hndl)->gdRect;
         if (p.x >= screenrect.left &&


@@ -75,24 +248,27 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
         {
             return num;
         }
         {
             return num;
         }

+

         num++;
         hndl = DMGetNextScreenDevice(hndl, true);
     }
         num++;
         hndl = DMGetNextScreenDevice(hndl, true);
     }

+

     return -1;
 }
 
     return -1;
 }
 

-wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
-    m_priv ( new wxDisplayMacPriv() )
+wxDisplay::wxDisplay( size_t index )
+    : wxDisplayBase( index ),
+    m_priv( new wxDisplayMacPriv() )

 {
     GDHandle hndl;
     hndl = DMGetFirstScreenDevice(true);
     m_priv->m_hndl = NULL;
 {
     GDHandle hndl;
     hndl = DMGetFirstScreenDevice(true);
     m_priv->m_hndl = NULL;

-    while(hndl)
+
+    while (hndl)

     {
         if (index == 0)
     {
         if (index == 0)

-        {

             m_priv->m_hndl = hndl;
             m_priv->m_hndl = hndl;

-        }
+

         index--;
         hndl = DMGetNextScreenDevice(hndl, true);
     }
         index--;
         hndl = DMGetNextScreenDevice(hndl, true);
     }


@@ -100,27 +276,387 @@ wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
 
 wxRect wxDisplay::GetGeometry() const
 {
 
 wxRect wxDisplay::GetGeometry() const
 {

-    if (!(m_priv)) return wxRect(0, 0, 0, 0);
-    if (!(m_priv->m_hndl)) return wxRect(0, 0, 0, 0);
+    if ((m_priv == NULL) || (m_priv->m_hndl == NULL))
+        return wxRect(0, 0, 0, 0);
+

     Rect screenrect = (*(m_priv->m_hndl))->gdRect;
     Rect screenrect = (*(m_priv->m_hndl))->gdRect;

-    return wxRect( screenrect.left, screenrect.top, 
-                   screenrect.right - screenrect.left, screenrect.bottom - screenrect.top);
+    return wxRect(
+        screenrect.left, screenrect.top,
+        screenrect.right - screenrect.left,
+        screenrect.bottom - screenrect.top );

 }
 
 int wxDisplay::GetDepth() const
 {
 }
 
 int wxDisplay::GetDepth() const
 {

-    if (!(m_priv)) return 0;
-    if (!(m_priv->m_hndl)) return 0;
+    if ((m_priv == NULL) || (m_priv->m_hndl == NULL))
+        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
 
     // 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 ((*(*(m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
 }
 
 wxString wxDisplay::GetName() const
 {
     // Macs don't name their displays...

-    return wxT("");
+    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);
+
+#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
+
+    for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
+    {
+        if (wxVideoMode( (int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
+                        (int) pInfo->displayModeResolutionInfo->csVerticalLines,
+                        (int) pDBI->vpPixelSize,
+                        refresh).Matches(*pInfoData->pMatchMode) )
+        {
+            pInfoData->pModes->Add(
+                wxVideoMode(
+                    (int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
+                    (int) pInfo->displayModeResolutionInfo->csVerticalLines,
+                    (int) pDBI->vpPixelSize,
+                    refresh ) );
+        }
+    }
+
+#undef pDBI
+}
+
+struct DMModeInfoRec
+{
+    const wxVideoMode* pMode;
+    VDSwitchInfoRec sMode;
+    bool bMatched;
+};
+
+pascal void DMModeInfoProc(
+    void* pData,
+    DMListIndexType nIndex,
+    DMDisplayModeListEntryPtr pInfo )
+{
+    DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
+    Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
+
+#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
+
+    for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
+    {
+        if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
+            pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
+            pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
+            refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
+        {
+            memcpy(
+                &pInfoData->sMode,
+                pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
+                sizeof(VDSwitchInfoRec));
+            pInfoData->sMode.csMode = pDBI->vpPixelSize;
+            pInfoData->bMatched = true;
+            break;
+        }
+    }
+
+#undef pDBI
+}
+
+struct DMModeTransRec
+{
+    wxVideoMode Mode;
+    const VDSwitchInfoRec* psMode;
+    bool bMatched;
+};
+
+pascal void DMModeTransProc(
+    void* pData,
+    DMListIndexType nIndex,
+    DMDisplayModeListEntryPtr pInfo)
+{
+    DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
+
+#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
+
+    for (unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
+    {
+        if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
+        {
+            pInfoData->Mode = wxVideoMode(
+                (int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
+                (int) pInfo->displayModeResolutionInfo->csVerticalLines,
+                (int) pDBI->vpPixelSize,
+                (int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
+            pInfoData->bMatched = true;
+            break;
+        }
+    }
+
+#undef pDBI
+}
+
+wxArrayVideoModes
+    wxDisplay::GetModes(const wxVideoMode& mode) const
+{
+    wxArrayVideoModes Modes;
+    unsigned long dwDMVer;
+
+    // Check DM version == 2
+    // (for backward compatibility only - 7.5.3+ use 2.0)
+    Gestalt( gestaltDisplayMgrVers, (long*) &dwDMVer );
+    if (dwDMVer >= 0x020000)
+    {
+        DMListIndexType nNumModes;
+        DMListType pModes;
+        DMDisplayModeListIteratorUPP uppMLI;
+        DisplayIDType nDisplayID;
+        OSErr err;
+
+        err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
+        verify_noerr( err );
+
+        // Create a new list...
+        err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
+        wxASSERT_MSG( err == noErr, wxT("Could not create a new display mode list") );
+
+        uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
+        wxASSERT( uppMLI );
+
+        DMModeIteratorRec sModeInfo;
+        sModeInfo.pModes = &Modes;
+        sModeInfo.pMatchMode = &mode;
+
+        for (DMListIndexType i = 0; i < nNumModes; ++i)
+        {
+            err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
+            verify_noerr( err );
+        }
+
+        DisposeDMDisplayModeListIteratorUPP(uppMLI);
+        err = DMDisposeList(pModes);
+        verify_noerr( err );
+    }
+    else // DM 1.0, 1.2, 1.x
+    {
+        wxLogSysError(
+            wxString::Format(
+                wxT("Display Manager Version %u Not Supported!  Present? %s"),
+                (unsigned int) dwDMVer / 0x10000,
+                (dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) ) );
+    }
+
+    return Modes;
+}
+
+wxVideoMode wxDisplay::GetCurrentMode() const
+{
+    unsigned long dwDMVer;
+    wxVideoMode RetMode;
+
+    // Check DM version == 2
+    // (for backward compatibility only - 7.5.3+ use 2.0)
+    Gestalt( gestaltDisplayMgrVers, (long*) &dwDMVer );
+    if (dwDMVer >= 0x020000)
+    {
+        VDSwitchInfoRec sMode; // Note: csMode member also contains the bit depth
+        OSErr err;
+
+        err = DMGetDisplayMode( m_priv->m_hndl, &sMode );
+        if (err == noErr)
+        {
+            DMListIndexType nNumModes;
+            DMListType pModes;
+            DMDisplayModeListIteratorUPP uppMLI;
+            DisplayIDType nDisplayID;
+
+            err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
+            verify_noerr( err );
+
+            // Create a new list...
+            err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
+            wxASSERT_MSG( err == noErr, wxT("Could not create a new display mode list") );
+
+            uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
+            wxASSERT( uppMLI );
+
+            DMModeTransRec sModeInfo;
+            sModeInfo.bMatched = false;
+            sModeInfo.psMode = &sMode;
+            for (DMListIndexType i = 0; i < nNumModes; ++i)
+            {
+                err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
+                verify_noerr( err );
+
+                if ( sModeInfo.bMatched )
+                {
+                    RetMode = sModeInfo.Mode;
+                    break;
+                }
+            }
+
+            DisposeDMDisplayModeListIteratorUPP(uppMLI);
+            err = DMDisposeList(pModes);
+            verify_noerr( err );
+        }
+        else // Can't get current mode?
+        {
+            wxLogSysError(
+                wxString::Format(
+                    wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
+                    (unsigned int) dwDMVer));
+        }
+    }
+    else // DM ver 1
+    {
+        wxLogSysError(
+            wxString::Format(
+                wxT("Display Manager Version %u Not Supported!  Present? %s"),
+                (unsigned int) dwDMVer / 0x10000,
+                (dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) ) );
+    }
+
+    return RetMode;
+}
+
+bool wxDisplay::ChangeMode(const wxVideoMode& mode)
+{
+    unsigned long dwDMVer;
+
+    Gestalt( gestaltDisplayMgrVers, (long*)&dwDMVer );
+    if (GetCount() == 1 || dwDMVer >= 0x020000)
+    {
+        if (mode == wxDefaultVideoMode)
+        {
+             return true;
+
+#if 0
+//#ifndef __DARWIN__
+//            Handle hDisplayState;
+//            if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
+//            {
+//                wxLogSysError(wxT("Could not lock display for display mode changing!"));
+//                return false;
+//            }
+//
+//            wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
+//            DMEndConfigureDisplays(hDisplayState);
+//            return true;
+//#else
+             // hmmmmm....
+//           return true;
+//#endif
+#endif
+        }
+
+        //0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
+        //DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
+        //so we have to use this icky structure
+        VDSwitchInfoRec sMode;
+        memset( &sMode, 0, sizeof(VDSwitchInfoRec) );
+
+        DMListIndexType nNumModes;
+        DMListType pModes;
+        DMDisplayModeListIteratorUPP uppMLI;
+        DisplayIDType nDisplayID;
+        OSErr err;
+
+        err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
+        verify_noerr( err );
+
+        // Create a new list...
+        err = DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes);
+        wxASSERT_MSG(err == noErr, wxT("Could not create a new display mode list") );
+
+        uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
+        wxASSERT(uppMLI);
+
+        DMModeInfoRec sModeInfo;
+        sModeInfo.bMatched = false;
+        sModeInfo.pMode = &mode;
+        unsigned int i;
+
+        for (i = 0; i < nNumModes; ++i)
+        {
+            err = DMGetIndexedDisplayModeFromList(pModes, i, NULL, uppMLI, &sModeInfo);
+            verify_noerr( err );
+
+            if (sModeInfo.bMatched)
+            {
+                sMode = sModeInfo.sMode;
+                break;
+            }
+        }
+
+        if (i == nNumModes)
+            return false;
+
+        DisposeDMDisplayModeListIteratorUPP(uppMLI);
+
+        err = DMDisposeList(pModes);
+        verify_noerr( err );
+
+        // For the really paranoid -
+        //     unsigned long flags;
+        //      Boolean bok;
+        //     wxASSERT(noErr == DMCheckDisplayMode(m_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;
+        err = DMSetDisplayMode(
+            m_priv->m_hndl, sMode.csData,
+            (unsigned long*) &(dwBPP),
+            NULL, //(unsigned long) &sMode
+            hDisplayState );
+
+        if (err != 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()
 }
 
 wxDisplay::~wxDisplay()


@@ -132,4 +668,6 @@ wxDisplay::~wxDisplay()
     }
 }
 
     }
 }
 

+#endif // !OSX
+

 #endif // wxUSE_DISPLAY
 #endif // wxUSE_DISPLAY