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

/////////////////////////////////////////////////////////////////////////////
// Name:        cursor.cpp
// Purpose:     wxCursor class
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:       wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "cursor.h"
#endif

#include "wx/defs.h"

#include "wx/app.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#include "wx/image.h"
#include "wx/xpmdecod.h"

#include "wx/mac/private.h"

#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
#endif

const short kwxCursorBullseye = 0 ;
const short kwxCursorBlank = 1 ;
const short kwxCursorPencil = 2 ;
const short kwxCursorMagnifier = 3 ;
const short kwxCursorNoEntry = 4 ;
const short kwxCursorPaintBrush = 5 ;
const short kwxCursorPointRight = 6 ;
const short kwxCursorPointLeft = 7 ;
const short kwxCursorQuestionArrow = 8 ;
const short kwxCursorRightArrow = 9 ;
const short kwxCursorSizeNS = 10 ;
const short kwxCursorSize = 11 ;
const short kwxCursorSizeNESW = 12 ;
const short kwxCursorSizeNWSE = 13 ;
const short kwxCursorRoller = 14 ;
const short kwxCursorLast = kwxCursorRoller ;

Cursor gMacCursors[kwxCursorLast+1] =
{
{
0x0000, 0x03E0, 0x0630, 0x0808, 0x1004, 0x31C6, 0x2362, 0x2222,
0x2362, 0x31C6, 0x1004, 0x0808, 0x0630, 0x03E0, 0x0000, 0x0000,
0x0000, 0x03E0, 0x07F0, 0x0FF8, 0x1FFC, 0x3FFE, 0x3FFE, 0x3FFE,
0x3FFE, 0x3FFE, 0x1FFC, 0x0FF8, 0x07F0, 0x03E0, 0x0000, 0x0000,
0x0007, 0x0008,
},

{
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000,
},

{
0x00F0, 0x0088, 0x0108, 0x0190, 0x0270, 0x0220, 0x0440, 0x0440,
0x0880, 0x0880, 0x1100, 0x1E00, 0x1C00, 0x1800, 0x1000, 0x0000,
0x00F0, 0x00F8, 0x01F8, 0x01F0, 0x03F0, 0x03E0, 0x07C0, 0x07C0,
0x0F80, 0x0F80, 0x1F00, 0x1E00, 0x1C00, 0x1800, 0x1000, 0x0000,
0x000E, 0x0003,
},

{
0x0000, 0x1E00, 0x2100, 0x4080, 0x4080, 0x4080, 0x4080, 0x2180,
0x1FC0, 0x00E0, 0x0070, 0x0038, 0x001C, 0x000E, 0x0006, 0x0000,
0x3F00, 0x7F80, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0x7FC0,
0x3FE0, 0x1FF0, 0x00F8, 0x007C, 0x003E, 0x001F, 0x000F, 0x0007,
0x0004, 0x0004,
},

{
0x0000, 0x07E0, 0x1FF0, 0x3838, 0x3C0C, 0x6E0E, 0x6706, 0x6386,
0x61C6, 0x60E6, 0x7076, 0x303C, 0x1C1C, 0x0FF8, 0x07E0, 0x0000,
0x0540, 0x0FF0, 0x3FF8, 0x3C3C, 0x7E0E, 0xFF0F, 0x6F86, 0xE7C7,
0x63E6, 0xE1F7, 0x70FE, 0x707E, 0x3C3C, 0x1FFC, 0x0FF0, 0x0540,
0x0007, 0x0007,
},

{
0x0000, 0x0380, 0x0380, 0x0380, 0x0380, 0x0380, 0x0380, 0x0FE0,
0x1FF0, 0x1FF0, 0x0000, 0x1FF0, 0x1FF0, 0x1550, 0x1550, 0x1550,
0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x0FE0, 0x1FF0,
0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8,
0x000B, 0x0007,
},

{
0x00C0, 0x0140, 0x0640, 0x08C0, 0x3180, 0x47FE, 0x8001, 0x8001,
0x81FE, 0x8040, 0x01C0, 0x0040, 0x03C0, 0xC080, 0x3F80, 0x0000,
0x00C0, 0x01C0, 0x07C0, 0x0FC0, 0x3F80, 0x7FFE, 0xFFFF, 0xFFFF,
0xFFFE, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0xFF80, 0x3F80, 0x0000,
0x0006, 0x000F,
},

{
0x0100, 0x0280, 0x0260, 0x0310, 0x018C, 0x7FE3, 0x8000, 0x8000,
0x7F80, 0x0200, 0x0380, 0x0200, 0x03C0, 0x0107, 0x01F8, 0x0000,
0x0100, 0x0380, 0x03E0, 0x03F0, 0x01FC, 0x7FFF, 0xFFFF, 0xFFFF,
0xFFFF, 0x03FF, 0x03FF, 0x03FF, 0x03FF, 0x01FF, 0x01F8, 0x0000,
0x0006, 0x0000,
},

{
0x0000, 0x4078, 0x60FC, 0x71CE, 0x7986, 0x7C06, 0x7E0E, 0x7F1C,
0x7FB8, 0x7C30, 0x6C30, 0x4600, 0x0630, 0x0330, 0x0300, 0x0000,
0xC078, 0xE0FC, 0xF1FE, 0xFBFF, 0xFFCF, 0xFF8F, 0xFF1F, 0xFFBE,
0xFFFC, 0xFE78, 0xFF78, 0xEFF8, 0xCFF8, 0x87F8, 0x07F8, 0x0300,
0x0001, 0x0001,
},

{
0x0000, 0x0002, 0x0006, 0x000E, 0x001E, 0x003E, 0x007E, 0x00FE,
0x01FE, 0x003E, 0x0036, 0x0062, 0x0060, 0x00C0, 0x00C0, 0x0000,
0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
0x03FF, 0x07FF, 0x007F, 0x00F7, 0x00F3, 0x01E1, 0x01E0, 0x01C0,
0x0001, 0x000E,
},

{
0x0000, 0x0080, 0x01C0, 0x03E0, 0x0080, 0x0080, 0x0080, 0x1FFC,
0x1FFC, 0x0080, 0x0080, 0x0080, 0x03E0, 0x01C0, 0x0080, 0x0000,
0x0080, 0x01C0, 0x03E0, 0x07F0, 0x0FF8, 0x01C0, 0x3FFE, 0x3FFE,
0x3FFE, 0x3FFE, 0x01C0, 0x0FF8, 0x07F0, 0x03E0, 0x01C0, 0x0080,
0x0007, 0x0008,
},

{
0x0000, 0x0080, 0x01C0, 0x03E0, 0x0080, 0x0888, 0x188C, 0x3FFE,
0x188C, 0x0888, 0x0080, 0x03E0, 0x01C0, 0x0080, 0x0000, 0x0000,
0x0080, 0x01C0, 0x03E0, 0x07F0, 0x0BE8, 0x1DDC, 0x3FFE, 0x7FFF,
0x3FFE, 0x1DDC, 0x0BE8, 0x07F0, 0x03E0, 0x01C0, 0x0080, 0x0000,
0x0007, 0x0008,
},

{
0x0000, 0x001E, 0x000E, 0x060E, 0x0712, 0x03A0, 0x01C0, 0x00E0,
0x0170, 0x1238, 0x1C18, 0x1C00, 0x1E00, 0x0000, 0x0000, 0x0000,
0x007F, 0x003F, 0x0E1F, 0x0F0F, 0x0F97, 0x07E3, 0x03E1, 0x21F0,
0x31F8, 0x3A7C, 0x3C3C, 0x3E1C, 0x3F00, 0x3F80, 0x0000, 0x0000,
0x0006, 0x0009,
},

{
0x0000, 0x7800, 0x7000, 0x7060, 0x48E0, 0x05C0, 0x0380, 0x0700,
0x0E80, 0x1C48, 0x1838, 0x0038, 0x0078, 0x0000, 0x0000, 0x0000,
0xFE00, 0xFC00, 0xF870, 0xF0F0, 0xE9F0, 0xC7E0, 0x87C0, 0x0F84,
0x1F8C, 0x3E5C, 0x3C3C, 0x387C, 0x00FC, 0x01FC, 0x0000, 0x0000,
0x0006, 0x0006,
},

{
0x0006, 0x000E, 0x001C, 0x0018, 0x0020, 0x0040, 0x00F8, 0x0004,
0x1FF4, 0x200C, 0x2AA8, 0x1FF0, 0x1F80, 0x3800, 0x6000, 0x8000,
0x000F, 0x001F, 0x003E, 0x007C, 0x0070, 0x00E0, 0x01FC, 0x3FF6,
0x7FF6, 0x7FFE, 0x7FFC, 0x7FF8, 0x3FF0, 0x7FC0, 0xF800, 0xE000,
0x000A, 0x0006,
},} ;

wxCursor    gMacCurrentCursor ;

CursHandle wxGetStockCursor( int number )
{
    wxASSERT_MSG( number >= 0 && number <=kwxCursorLast , wxT("invalid stock cursor id") ) ;
    CursHandle c = (CursHandle) NewHandle( sizeof(Cursor) ) ;
    memcpy( *c , &gMacCursors[number] , sizeof( Cursor ) ) ;
    return c ;    
}

wxCursorRefData::wxCursorRefData()
{
    m_width = 16; 
    m_height = 16;
    m_hCursor = NULL ;
    m_disposeHandle = false ;
    m_releaseHandle = false ;
    m_isColorCursor = false ;
    m_themeCursor = -1 ;
}

wxCursorRefData::~wxCursorRefData()
{
    if ( m_isColorCursor )
    {
        ::DisposeCCursor( (CCrsrHandle) m_hCursor ) ;
    }
    else if ( m_disposeHandle )
    {
        ::DisposeHandle( (Handle ) m_hCursor ) ;
    } 
    else if ( m_releaseHandle )
    {
        // we don't release the resource since it may already
        // be in use again
    }
}

// Cursors
wxCursor::wxCursor()
{
}

wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
    int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
{
}

wxCursor::wxCursor( const wxImage &image )
{
    CreateFromImage( image ) ;
}

wxCursor::wxCursor(const char **bits) 
{
    (void) CreateFromXpm(bits);
}

wxCursor::wxCursor(char **bits) 
{
    (void) CreateFromXpm((const char **)bits);
}

bool wxCursor::CreateFromXpm(const char **bits)
{
    wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid cursor data") )
    wxXPMDecoder decoder;
    wxImage img = decoder.ReadData(bits);
    wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid cursor data") )    
	CreateFromImage( img ) ;
    return TRUE;
}

short GetCTabIndex( CTabHandle colors , RGBColor *col )
{
    short retval = 0 ;
    unsigned long bestdiff = 0xFFFF ;
    for ( int i = 0 ; i < (**colors).ctSize ; ++i )
    {
        unsigned long diff = abs(col->red -  (**colors).ctTable[i].rgb.red ) +
            abs(col->green -  (**colors).ctTable[i].rgb.green ) +
            abs(col->blue -  (**colors).ctTable[i].rgb.blue ) ;
        if ( diff < bestdiff )
        {
            bestdiff = diff ;
            retval = (**colors).ctTable[i].value ;
        }
    }
    return retval ;
}

void wxCursor::CreateFromImage(const wxImage & image) 
{
    m_refData = new wxCursorRefData;

    wxImage image16 = image.Scale(16,16) ;
       unsigned char * rgbBits = image16.GetData();
 
    
    int w = image16.GetWidth()  ;
    int h = image16.GetHeight() ;
    bool bHasMask = image16.HasMask() ;

       int hotSpotX = image16.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
    int hotSpotY = image16.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
    if (hotSpotX < 0 || hotSpotX >= w)
            hotSpotX = 0;
    if (hotSpotY < 0 || hotSpotY >= h)
            hotSpotY = 0;
            
    PixMapHandle pm = (PixMapHandle) NewHandleClear( sizeof (PixMap))  ;
    short extent = 16 ;
    short bytesPerPixel = 1 ;
    short depth = 8 ;
    Rect bounds = { 0 , 0 , extent , extent } ;
    CCrsrHandle ch = (CCrsrHandle) NewHandleClear ( sizeof( CCrsr ) ) ;
    CTabHandle newColors = GetCTable( 8 ) ;
    HandToHand((Handle *) &newColors);
    // set the values to the indices
    for ( int i = 0 ; i < (**newColors).ctSize ; ++i )
    {
        (**newColors).ctTable[i].value = i ;
    }
    HLock( (Handle) ch) ;
    (**ch).crsrType = 0x8001 ; // color cursors
    (**ch).crsrMap = pm ; 
    short bytesPerRow = bytesPerPixel * extent ;

    (**pm).baseAddr = 0; 
    (**pm).rowBytes = bytesPerRow | 0x8000;
    (**pm).bounds = bounds;        
    (**pm).pmVersion = 0;           
    (**pm).packType = 0;            
    (**pm).packSize = 0;            
    (**pm).hRes = 0x00480000; /* 72 DPI default res */
    (**pm).vRes = 0x00480000; /* 72 DPI default res */
    (**pm).pixelSize = depth;
    (**pm).pixelType = 0;
    (**pm).cmpCount = 1; 
    (**pm).cmpSize = depth;
    (**pm).pmTable = newColors;

    (**ch).crsrData = NewHandleClear( extent * bytesPerRow ) ;  
    (**ch).crsrXData = NULL ;
    (**ch).crsrXValid = 0;
    (**ch).crsrXHandle = NULL;

    (**ch).crsrHotSpot.h = hotSpotX ;
    (**ch).crsrHotSpot.v = hotSpotY ;
    (**ch).crsrXTable = NULL ; 
    (**ch).crsrID = GetCTSeed() ;
    
    memset( (**ch).crsr1Data  , 0 , sizeof( Bits16 ) ) ;
    memset( (**ch).crsrMask , 0 , sizeof( Bits16 ) ) ;
    
    unsigned char mr = image16.GetMaskRed() ;
    unsigned char mg = image16.GetMaskGreen() ;
    unsigned char mb = image16.GetMaskBlue() ;
    for ( int y = 0 ; y < h ; ++y )
    {
        short rowbits = 0 ;
        short maskbits = 0 ;
        
        for ( int x = 0 ; x < w ; ++x )
        {
            long pos = (y * w + x) * 3;

            unsigned char r = rgbBits[pos] ;
            unsigned char g = rgbBits[pos+1] ;
            unsigned char b = rgbBits[pos+2] ;
            RGBColor col = { 0xFFFF ,0xFFFF, 0xFFFF } ;
            
            if ( bHasMask && r==mr && g==mg && b==mb )
            {
                // masked area, does not appear anywhere
            }
            else
            {
                if ( (int)r + (int)g + (int)b < 0x0200 )
                {
                    rowbits |= ( 1 << (15-x) ) ;
                }
                maskbits |= ( 1 << (15-x) ) ;
                
                col = *((RGBColor*) wxColor( r , g , b ).GetPixel()) ;
            }
            *((*(**ch).crsrData) + y * bytesPerRow + x) = 
                GetCTabIndex( newColors , &col) ;
        }
        (**ch).crsr1Data[y] = rowbits ;
        (**ch).crsrMask[y] = maskbits ;
    }
    if ( !bHasMask )
    {
        memcpy( (**ch).crsrMask , (**ch).crsr1Data , sizeof( Bits16) ) ;
    }
    
    HUnlock((Handle) ch) ;
    M_CURSORDATA->m_hCursor = ch ;
    M_CURSORDATA->m_isColorCursor = true ;
}

wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
{
    m_refData = new wxCursorRefData;
    if ( flags == wxBITMAP_TYPE_MACCURSOR_RESOURCE )
    {
        Str255 theName ;
		wxMacStringToPascal( cursor_file , theName ) ;
        
        wxStAppResource resload ;
        Handle resHandle = ::GetNamedResource( 'crsr' , theName ) ;
        if ( resHandle )
        {
            short theId = -1 ;
            OSType theType ;
            GetResInfo( resHandle , &theId , &theType , theName ) ;
            ReleaseResource( resHandle ) ;
            M_CURSORDATA->m_hCursor = GetCCursor( theId ) ;
            if ( M_CURSORDATA->m_hCursor )
                M_CURSORDATA->m_isColorCursor = true ;
        }
        else
        {       
            Handle resHandle = ::GetNamedResource( 'CURS' , theName ) ;
            if ( resHandle )
            {
                short theId = -1 ;
                OSType theType ;
                GetResInfo( resHandle , &theId , &theType , theName ) ;
                ReleaseResource( resHandle ) ;
                 M_CURSORDATA->m_hCursor = GetCursor( theId ) ;
                if ( M_CURSORDATA->m_hCursor )
                    M_CURSORDATA->m_releaseHandle = true ;
            }
        }
    }
    else
    {
        wxImage image ;
        image.LoadFile( cursor_file , flags ) ;
        if( image.Ok() )
        {
            image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,hotSpotX ) ;
            image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,hotSpotY ) ;
            delete m_refData ;
            CreateFromImage(image) ;
        }
    }
}

// Cursors by stock number
wxCursor::wxCursor(int cursor_type)
{
    m_refData = new wxCursorRefData;
    
    switch (cursor_type)
    {
    case wxCURSOR_COPY_ARROW:
        M_CURSORDATA->m_themeCursor = kThemeCopyArrowCursor ;
        break;
    case wxCURSOR_WAIT:
        M_CURSORDATA->m_themeCursor = kThemeWatchCursor ;
        break;
    case wxCURSOR_IBEAM:
        M_CURSORDATA->m_themeCursor = kThemeIBeamCursor ;
        break;
    case wxCURSOR_CROSS:
        M_CURSORDATA->m_themeCursor = kThemeCrossCursor;
        break;
    case wxCURSOR_SIZENWSE:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNWSE);
        }
        break;
    case wxCURSOR_SIZENESW:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNESW);
        }
        break;
    case wxCURSOR_SIZEWE:
        {
            M_CURSORDATA->m_themeCursor = kThemeResizeLeftRightCursor;
        }
        break;
    case wxCURSOR_SIZENS:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNS);
        }
        break;
    case wxCURSOR_SIZING:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSize);
        }
        break;
    case wxCURSOR_HAND:
        {
            M_CURSORDATA->m_themeCursor = kThemePointingHandCursor;
        }
        break;
    case wxCURSOR_BULLSEYE:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorBullseye);
        }
        break;
    case wxCURSOR_PENCIL:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPencil);
        }
        break;
    case wxCURSOR_MAGNIFIER:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorMagnifier);
        }
        break;
    case wxCURSOR_NO_ENTRY:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorNoEntry);
        }
        break;
    case wxCURSOR_WATCH:
        {
            M_CURSORDATA->m_themeCursor = kThemeWatchCursor;
            break;
        }
    case wxCURSOR_PAINT_BRUSH:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPaintBrush);
            break;
        }
    case wxCURSOR_POINT_LEFT:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPointLeft);
            break;
        }
    case wxCURSOR_POINT_RIGHT:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPointRight);
            break;
        }
    case wxCURSOR_QUESTION_ARROW:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorQuestionArrow);
            break;
        }
    case wxCURSOR_BLANK:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorBlank);
            break;
        }
    case wxCURSOR_RIGHT_ARROW:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorRightArrow);
            break;
        }
    case wxCURSOR_SPRAYCAN:
        {
            M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorRoller);
            break;
        }
    case wxCURSOR_CHAR:
    case wxCURSOR_ARROW:
    case wxCURSOR_LEFT_BUTTON:
    case wxCURSOR_RIGHT_BUTTON:
    case wxCURSOR_MIDDLE_BUTTON:
    default:
        M_CURSORDATA->m_themeCursor = kThemeArrowCursor ;
        break;
    }
    if ( M_CURSORDATA->m_themeCursor == -1 )
        M_CURSORDATA->m_releaseHandle = true ;
}

void wxCursor::MacInstall() const 
{
    gMacCurrentCursor = *this ;
    if ( m_refData && M_CURSORDATA->m_themeCursor != -1 )
    {
        SetThemeCursor( M_CURSORDATA->m_themeCursor ) ;
    }
    else if ( m_refData && M_CURSORDATA->m_hCursor )
    {
        if ( M_CURSORDATA->m_isColorCursor )
            ::SetCCursor( (CCrsrHandle) M_CURSORDATA->m_hCursor ) ;
        else
            ::SetCursor( * (CursHandle) M_CURSORDATA->m_hCursor ) ;
    }
    else
    {
        SetThemeCursor( kThemeArrowCursor ) ;
    }
}

wxCursor::~wxCursor()
{
}

// Global cursor setting
void wxSetCursor(const wxCursor& cursor)
{
    cursor.MacInstall() ;
}
Commit	Line	Data
e9576ca5 SC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: cursor.cpp
	3	// Purpose: wxCursor class
a31a5f85	4	// Author: Stefan Csomor
e9576ca5	5	// Modified by:
a31a5f85	6	// Created: 1998-01-01
e9576ca5	7	// RCS-ID: $Id$
a31a5f85	8	// Copyright: (c) Stefan Csomor
e40298d5	9	// Licence: wxWindows licence
e9576ca5 SC	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "cursor.h"
	14	#endif
	15
0e13e965 GD	16	#include "wx/defs.h"
	17
	18	#include "wx/app.h"
e9576ca5 SC	19	#include "wx/cursor.h"
e9576ca5 SC	20	#include "wx/icon.h"
c6a071d2	21	#include "wx/image.h"
c5e59178 SC	22	#include "wx/xpmdecod.h"
c5e59178 SC	23
76a5e5d2	24	#include "wx/mac/private.h"
e9576ca5	25
2f1ae414	26	#if !USE_SHARED_LIBRARIES
e9576ca5	27	IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
2f1ae414	28	#endif
e9576ca5	29
dd05f811 SC	30	const short kwxCursorBullseye = 0 ;
	31	const short kwxCursorBlank = 1 ;
	32	const short kwxCursorPencil = 2 ;
	33	const short kwxCursorMagnifier = 3 ;
	34	const short kwxCursorNoEntry = 4 ;
	35	const short kwxCursorPaintBrush = 5 ;
	36	const short kwxCursorPointRight = 6 ;
	37	const short kwxCursorPointLeft = 7 ;
	38	const short kwxCursorQuestionArrow = 8 ;
	39	const short kwxCursorRightArrow = 9 ;
	40	const short kwxCursorSizeNS = 10 ;
	41	const short kwxCursorSize = 11 ;
	42	const short kwxCursorSizeNESW = 12 ;
	43	const short kwxCursorSizeNWSE = 13 ;
	44	const short kwxCursorRoller = 14 ;
	45	const short kwxCursorLast = kwxCursorRoller ;
	46
	47	Cursor gMacCursors[kwxCursorLast+1] =
	48	{
	49	{
	50	0x0000, 0x03E0, 0x0630, 0x0808, 0x1004, 0x31C6, 0x2362, 0x2222,
	51	0x2362, 0x31C6, 0x1004, 0x0808, 0x0630, 0x03E0, 0x0000, 0x0000,
	52	0x0000, 0x03E0, 0x07F0, 0x0FF8, 0x1FFC, 0x3FFE, 0x3FFE, 0x3FFE,
	53	0x3FFE, 0x3FFE, 0x1FFC, 0x0FF8, 0x07F0, 0x03E0, 0x0000, 0x0000,
	54	0x0007, 0x0008,
	55	},
	56
	57	{
	58	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	59	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	60	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	61	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	62	0x0000, 0x0000,
	63	},
	64
	65	{
	66	0x00F0, 0x0088, 0x0108, 0x0190, 0x0270, 0x0220, 0x0440, 0x0440,
	67	0x0880, 0x0880, 0x1100, 0x1E00, 0x1C00, 0x1800, 0x1000, 0x0000,
	68	0x00F0, 0x00F8, 0x01F8, 0x01F0, 0x03F0, 0x03E0, 0x07C0, 0x07C0,
	69	0x0F80, 0x0F80, 0x1F00, 0x1E00, 0x1C00, 0x1800, 0x1000, 0x0000,
	70	0x000E, 0x0003,
	71	},
	72
	73	{
	74	0x0000, 0x1E00, 0x2100, 0x4080, 0x4080, 0x4080, 0x4080, 0x2180,
	75	0x1FC0, 0x00E0, 0x0070, 0x0038, 0x001C, 0x000E, 0x0006, 0x0000,
	76	0x3F00, 0x7F80, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0x7FC0,
	77	0x3FE0, 0x1FF0, 0x00F8, 0x007C, 0x003E, 0x001F, 0x000F, 0x0007,
	78	0x0004, 0x0004,
	79	},
	80
	81	{
	82	0x0000, 0x07E0, 0x1FF0, 0x3838, 0x3C0C, 0x6E0E, 0x6706, 0x6386,
	83	0x61C6, 0x60E6, 0x7076, 0x303C, 0x1C1C, 0x0FF8, 0x07E0, 0x0000,
	84	0x0540, 0x0FF0, 0x3FF8, 0x3C3C, 0x7E0E, 0xFF0F, 0x6F86, 0xE7C7,
	85	0x63E6, 0xE1F7, 0x70FE, 0x707E, 0x3C3C, 0x1FFC, 0x0FF0, 0x0540,
	86	0x0007, 0x0007,
	87	},
	88
	89	{
	90	0x0000, 0x0380, 0x0380, 0x0380, 0x0380, 0x0380, 0x0380, 0x0FE0,
	91	0x1FF0, 0x1FF0, 0x0000, 0x1FF0, 0x1FF0, 0x1550, 0x1550, 0x1550,
	92	0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x07C0, 0x0FE0, 0x1FF0,
	93	0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8, 0x3FF8,
94	0x000B, 0x0007,
95	},
96
97	{
98	0x00C0, 0x0140, 0x0640, 0x08C0, 0x3180, 0x47FE, 0x8001, 0x8001,
99	0x81FE, 0x8040, 0x01C0, 0x0040, 0x03C0, 0xC080, 0x3F80, 0x0000,
100	0x00C0, 0x01C0, 0x07C0, 0x0FC0, 0x3F80, 0x7FFE, 0xFFFF, 0xFFFF,
101	0xFFFE, 0xFFC0, 0xFFC0, 0xFFC0, 0xFFC0, 0xFF80, 0x3F80, 0x0000,
102	0x0006, 0x000F,
103	},
104
105	{
106	0x0100, 0x0280, 0x0260, 0x0310, 0x018C, 0x7FE3, 0x8000, 0x8000,
107	0x7F80, 0x0200, 0x0380, 0x0200, 0x03C0, 0x0107, 0x01F8, 0x0000,
108	0x0100, 0x0380, 0x03E0, 0x03F0, 0x01FC, 0x7FFF, 0xFFFF, 0xFFFF,
109	0xFFFF, 0x03FF, 0x03FF, 0x03FF, 0x03FF, 0x01FF, 0x01F8, 0x0000,
110	0x0006, 0x0000,
111	},
112
113	{
114	0x0000, 0x4078, 0x60FC, 0x71CE, 0x7986, 0x7C06, 0x7E0E, 0x7F1C,
115	0x7FB8, 0x7C30, 0x6C30, 0x4600, 0x0630, 0x0330, 0x0300, 0x0000,
116	0xC078, 0xE0FC, 0xF1FE, 0xFBFF, 0xFFCF, 0xFF8F, 0xFF1F, 0xFFBE,
117	0xFFFC, 0xFE78, 0xFF78, 0xEFF8, 0xCFF8, 0x87F8, 0x07F8, 0x0300,
118	0x0001, 0x0001,
119	},
120
121	{
122	0x0000, 0x0002, 0x0006, 0x000E, 0x001E, 0x003E, 0x007E, 0x00FE,
123	0x01FE, 0x003E, 0x0036, 0x0062, 0x0060, 0x00C0, 0x00C0, 0x0000,
124	0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
125	0x03FF, 0x07FF, 0x007F, 0x00F7, 0x00F3, 0x01E1, 0x01E0, 0x01C0,
126	0x0001, 0x000E,
127	},
128
129	{
130	0x0000, 0x0080, 0x01C0, 0x03E0, 0x0080, 0x0080, 0x0080, 0x1FFC,
131	0x1FFC, 0x0080, 0x0080, 0x0080, 0x03E0, 0x01C0, 0x0080, 0x0000,
132	0x0080, 0x01C0, 0x03E0, 0x07F0, 0x0FF8, 0x01C0, 0x3FFE, 0x3FFE,
133	0x3FFE, 0x3FFE, 0x01C0, 0x0FF8, 0x07F0, 0x03E0, 0x01C0, 0x0080,
134	0x0007, 0x0008,
135	},
136
137	{
138	0x0000, 0x0080, 0x01C0, 0x03E0, 0x0080, 0x0888, 0x188C, 0x3FFE,
139	0x188C, 0x0888, 0x0080, 0x03E0, 0x01C0, 0x0080, 0x0000, 0x0000,
140	0x0080, 0x01C0, 0x03E0, 0x07F0, 0x0BE8, 0x1DDC, 0x3FFE, 0x7FFF,
141	0x3FFE, 0x1DDC, 0x0BE8, 0x07F0, 0x03E0, 0x01C0, 0x0080, 0x0000,
142	0x0007, 0x0008,
143	},
144
145	{
146	0x0000, 0x001E, 0x000E, 0x060E, 0x0712, 0x03A0, 0x01C0, 0x00E0,
147	0x0170, 0x1238, 0x1C18, 0x1C00, 0x1E00, 0x0000, 0x0000, 0x0000,
148	0x007F, 0x003F, 0x0E1F, 0x0F0F, 0x0F97, 0x07E3, 0x03E1, 0x21F0,
149	0x31F8, 0x3A7C, 0x3C3C, 0x3E1C, 0x3F00, 0x3F80, 0x0000, 0x0000,
150	0x0006, 0x0009,
151	},
152
153	{
154	0x0000, 0x7800, 0x7000, 0x7060, 0x48E0, 0x05C0, 0x0380, 0x0700,
155	0x0E80, 0x1C48, 0x1838, 0x0038, 0x0078, 0x0000, 0x0000, 0x0000,
156	0xFE00, 0xFC00, 0xF870, 0xF0F0, 0xE9F0, 0xC7E0, 0x87C0, 0x0F84,
157	0x1F8C, 0x3E5C, 0x3C3C, 0x387C, 0x00FC, 0x01FC, 0x0000, 0x0000,
158	0x0006, 0x0006,
159	},
160
161	{
162	0x0006, 0x000E, 0x001C, 0x0018, 0x0020, 0x0040, 0x00F8, 0x0004,
163	0x1FF4, 0x200C, 0x2AA8, 0x1FF0, 0x1F80, 0x3800, 0x6000, 0x8000,
164	0x000F, 0x001F, 0x003E, 0x007C, 0x0070, 0x00E0, 0x01FC, 0x3FF6,
165	0x7FF6, 0x7FFE, 0x7FFC, 0x7FF8, 0x3FF0, 0x7FC0, 0xF800, 0xE000,
166	0x000A, 0x0006,
167	},} ;
c6a071d2	168
e40298d5	169	wxCursor gMacCurrentCursor ;
519cb848	170
dd05f811 SC	171	CursHandle wxGetStockCursor( int number )
	172	{
	173	wxASSERT_MSG( number >= 0 && number <=kwxCursorLast , wxT("invalid stock cursor id") ) ;
	174	CursHandle c = (CursHandle) NewHandle( sizeof(Cursor) ) ;
	175	memcpy( *c , &gMacCursors[number] , sizeof( Cursor ) ) ;
	176	return c ;
	177	}
	178
e9576ca5 SC	179	wxCursorRefData::wxCursorRefData()
e9576ca5 SC	180	{
c6a071d2 SC	181	m_width = 16;
c6a071d2 SC	182	m_height = 16;
519cb848	183	m_hCursor = NULL ;
c6a071d2 SC	184	m_disposeHandle = false ;
	185	m_releaseHandle = false ;
	186	m_isColorCursor = false ;
	187	m_themeCursor = -1 ;
e9576ca5 SC	188	}
	189
	190	wxCursorRefData::~wxCursorRefData()
	191	{
c6a071d2 SC	192	if ( m_isColorCursor )
	193	{
	194	::DisposeCCursor( (CCrsrHandle) m_hCursor ) ;
	195	}
e40298d5 JS	196	else if ( m_disposeHandle )
	197	{
	198	::DisposeHandle( (Handle ) m_hCursor ) ;
	199	}
	200	else if ( m_releaseHandle )
	201	{
	202	// we don't release the resource since it may already
	203	// be in use again
	204	}
e9576ca5 SC	205	}
	206
	207	// Cursors
	208	wxCursor::wxCursor()
	209	{
	210	}
	211
	212	wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
	213	int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
	214	{
	215	}
	216
c6a071d2 SC	217	wxCursor::wxCursor( const wxImage &image )
c6a071d2 SC	218	{
ce72eadb	219	CreateFromImage( image ) ;
c6a071d2 SC	220	}
c6a071d2 SC	221
c5e59178 SC	222	wxCursor::wxCursor(const char **bits)
	223	{
	224	(void) CreateFromXpm(bits);
	225	}
	226
	227	wxCursor::wxCursor(char **bits)
	228	{
	229	(void) CreateFromXpm((const char **)bits);
	230	}
	231
	232	bool wxCursor::CreateFromXpm(const char **bits)
	233	{
	234	wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid cursor data") )
	235	wxXPMDecoder decoder;
	236	wxImage img = decoder.ReadData(bits);
	237	wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid cursor data") )
	238	CreateFromImage( img ) ;
	239	return TRUE;
	240	}
	241
	242	short GetCTabIndex( CTabHandle colors , RGBColor *col )
	243	{
	244	short retval = 0 ;
	245	unsigned long bestdiff = 0xFFFF ;
	246	for ( int i = 0 ; i < (**colors).ctSize ; ++i )
	247	{
	248	unsigned long diff = abs(col->red - (**colors).ctTable[i].rgb.red ) +
	249	abs(col->green - (**colors).ctTable[i].rgb.green ) +
	250	abs(col->blue - (**colors).ctTable[i].rgb.blue ) ;
	251	if ( diff < bestdiff )
	252	{
	253	bestdiff = diff ;
	254	retval = (**colors).ctTable[i].value ;
	255	}
	256	}
	257	return retval ;
	258	}
	259
ce72eadb	260	void wxCursor::CreateFromImage(const wxImage & image)
c6a071d2 SC	261	{
	262	m_refData = new wxCursorRefData;
	263
	264	wxImage image16 = image.Scale(16,16) ;
e40298d5	265	unsigned char * rgbBits = image16.GetData();
c6a071d2	266
e40298d5	267
c6a071d2 SC	268	int w = image16.GetWidth() ;
	269	int h = image16.GetHeight() ;
	270	bool bHasMask = image16.HasMask() ;
	271
1a81dc12 MB	272	int hotSpotX = image16.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
1a81dc12 MB	273	int hotSpotY = image16.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
c6a071d2 SC	274	if (hotSpotX < 0 \|\| hotSpotX >= w)
	275	hotSpotX = 0;
	276	if (hotSpotY < 0 \|\| hotSpotY >= h)
	277	hotSpotY = 0;
	278
c5e59178 SC	279	PixMapHandle pm = (PixMapHandle) NewHandleClear( sizeof (PixMap)) ;
	280	short extent = 16 ;
	281	short bytesPerPixel = 1 ;
	282	short depth = 8 ;
	283	Rect bounds = { 0 , 0 , extent , extent } ;
	284	CCrsrHandle ch = (CCrsrHandle) NewHandleClear ( sizeof( CCrsr ) ) ;
	285	CTabHandle newColors = GetCTable( 8 ) ;
	286	HandToHand((Handle *) &newColors);
	287	// set the values to the indices
	288	for ( int i = 0 ; i < (**newColors).ctSize ; ++i )
	289	{
	290	(**newColors).ctTable[i].value = i ;
	291	}
	292	HLock( (Handle) ch) ;
	293	(**ch).crsrType = 0x8001 ; // color cursors
	294	(**ch).crsrMap = pm ;
	295	short bytesPerRow = bytesPerPixel * extent ;
	296
	297	(**pm).baseAddr = 0;
	298	(**pm).rowBytes = bytesPerRow \| 0x8000;
	299	(**pm).bounds = bounds;
	300	(**pm).pmVersion = 0;
	301	(**pm).packType = 0;
	302	(**pm).packSize = 0;
	303	(*pm).hRes = 0x00480000; / 72 DPI default res */
	304	(*pm).vRes = 0x00480000; / 72 DPI default res */
	305	(**pm).pixelSize = depth;
	306	(**pm).pixelType = 0;
	307	(**pm).cmpCount = 1;
	308	(**pm).cmpSize = depth;
	309	(**pm).pmTable = newColors;
	310
	311	(*ch).crsrData = NewHandleClear( extent bytesPerRow ) ;
	312	(**ch).crsrXData = NULL ;
	313	(**ch).crsrXValid = 0;
	314	(**ch).crsrXHandle = NULL;
	315
	316	(**ch).crsrHotSpot.h = hotSpotX ;
	317	(**ch).crsrHotSpot.v = hotSpotY ;
	318	(**ch).crsrXTable = NULL ;
	319	(**ch).crsrID = GetCTSeed() ;
	320
	321	memset( (**ch).crsr1Data , 0 , sizeof( Bits16 ) ) ;
	322	memset( (**ch).crsrMask , 0 , sizeof( Bits16 ) ) ;
	323
	324	unsigned char mr = image16.GetMaskRed() ;
	325	unsigned char mg = image16.GetMaskGreen() ;
	326	unsigned char mb = image16.GetMaskBlue() ;
	327	for ( int y = 0 ; y < h ; ++y )
	328	{
	329	short rowbits = 0 ;
	330	short maskbits = 0 ;
	331
	332	for ( int x = 0 ; x < w ; ++x )
	333	{
	334	long pos = (y * w + x) * 3;
	335
	336	unsigned char r = rgbBits[pos] ;
	337	unsigned char g = rgbBits[pos+1] ;
	338	unsigned char b = rgbBits[pos+2] ;
	339	RGBColor col = { 0xFFFF ,0xFFFF, 0xFFFF } ;
	340
	341	if ( bHasMask && r==mr && g==mg && b==mb )
	342	{
343	// masked area, does not appear anywhere
344	}
345	else
346	{
347	if ( (int)r + (int)g + (int)b < 0x0200 )
348	{
349	rowbits \|= ( 1 << (15-x) ) ;
350	}
351	maskbits \|= ( 1 << (15-x) ) ;
352
353	col = ((RGBColor) wxColor( r , g , b ).GetPixel()) ;
354	}
355	(((*ch).crsrData) + y bytesPerRow + x) =
356	GetCTabIndex( newColors , &col) ;
357	}
358	(**ch).crsr1Data[y] = rowbits ;
359	(**ch).crsrMask[y] = maskbits ;
360	}
361	if ( !bHasMask )
362	{
363	memcpy( (ch).crsrMask , (ch).crsr1Data , sizeof( Bits16) ) ;
364	}
365
366	HUnlock((Handle) ch) ;
367	M_CURSORDATA->m_hCursor = ch ;
368	M_CURSORDATA->m_isColorCursor = true ;
c6a071d2 SC	369	}
c6a071d2 SC	370
e9576ca5 SC	371	wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
	372	{
	373	m_refData = new wxCursorRefData;
c6a071d2 SC	374	if ( flags == wxBITMAP_TYPE_MACCURSOR_RESOURCE )
c6a071d2 SC	375	{
e40298d5	376	Str255 theName ;
427ff662	377	wxMacStringToPascal( cursor_file , theName ) ;
e40298d5	378
c6a071d2	379	wxStAppResource resload ;
e40298d5 JS	380	Handle resHandle = ::GetNamedResource( 'crsr' , theName ) ;
	381	if ( resHandle )
	382	{
	383	short theId = -1 ;
	384	OSType theType ;
	385	GetResInfo( resHandle , &theId , &theType , theName ) ;
	386	ReleaseResource( resHandle ) ;
	387	M_CURSORDATA->m_hCursor = GetCCursor( theId ) ;
	388	if ( M_CURSORDATA->m_hCursor )
	389	M_CURSORDATA->m_isColorCursor = true ;
	390	}
	391	else
	392	{
	393	Handle resHandle = ::GetNamedResource( 'CURS' , theName ) ;
	394	if ( resHandle )
	395	{
	396	short theId = -1 ;
	397	OSType theType ;
	398	GetResInfo( resHandle , &theId , &theType , theName ) ;
	399	ReleaseResource( resHandle ) ;
	400	M_CURSORDATA->m_hCursor = GetCursor( theId ) ;
	401	if ( M_CURSORDATA->m_hCursor )
	402	M_CURSORDATA->m_releaseHandle = true ;
	403	}
c6a071d2 SC	404	}
	405	}
	406	else
	407	{
	408	wxImage image ;
	409	image.LoadFile( cursor_file , flags ) ;
	410	if( image.Ok() )
	411	{
1a81dc12 MB	412	image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,hotSpotX ) ;
1a81dc12 MB	413	image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,hotSpotY ) ;
c6a071d2	414	delete m_refData ;
ce72eadb	415	CreateFromImage(image) ;
c6a071d2 SC	416	}
c6a071d2 SC	417	}
e9576ca5 SC	418	}
	419
	420	// Cursors by stock number
	421	wxCursor::wxCursor(int cursor_type)
	422	{
e40298d5 JS	423	m_refData = new wxCursorRefData;
	424
	425	switch (cursor_type)
	426	{
c5e59178 SC	427	case wxCURSOR_COPY_ARROW:
	428	M_CURSORDATA->m_themeCursor = kThemeCopyArrowCursor ;
	429	break;
e9576ca5	430	case wxCURSOR_WAIT:
e40298d5 JS	431	M_CURSORDATA->m_themeCursor = kThemeWatchCursor ;
e40298d5 JS	432	break;
e9576ca5	433	case wxCURSOR_IBEAM:
e40298d5 JS	434	M_CURSORDATA->m_themeCursor = kThemeIBeamCursor ;
e40298d5 JS	435	break;
e9576ca5	436	case wxCURSOR_CROSS:
e40298d5 JS	437	M_CURSORDATA->m_themeCursor = kThemeCrossCursor;
e40298d5 JS	438	break;
e9576ca5	439	case wxCURSOR_SIZENWSE:
e40298d5	440	{
dd05f811	441	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNWSE);
e40298d5 JS	442	}
e40298d5 JS	443	break;
e9576ca5	444	case wxCURSOR_SIZENESW:
e40298d5	445	{
dd05f811	446	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNESW);
e40298d5 JS	447	}
e40298d5 JS	448	break;
e9576ca5	449	case wxCURSOR_SIZEWE:
e40298d5 JS	450	{
	451	M_CURSORDATA->m_themeCursor = kThemeResizeLeftRightCursor;
	452	}
	453	break;
e9576ca5	454	case wxCURSOR_SIZENS:
e40298d5	455	{
dd05f811	456	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSizeNS);
e40298d5 JS	457	}
	458	break;
	459	case wxCURSOR_SIZING:
	460	{
dd05f811	461	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorSize);
e40298d5 JS	462	}
e40298d5 JS	463	break;
e9576ca5	464	case wxCURSOR_HAND:
e40298d5 JS	465	{
	466	M_CURSORDATA->m_themeCursor = kThemePointingHandCursor;
	467	}
	468	break;
e9576ca5	469	case wxCURSOR_BULLSEYE:
fe3fcb05	470	{
dd05f811	471	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorBullseye);
fe3fcb05 SC	472	}
fe3fcb05 SC	473	break;
e9576ca5	474	case wxCURSOR_PENCIL:
fe3fcb05	475	{
dd05f811	476	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPencil);
fe3fcb05 SC	477	}
fe3fcb05 SC	478	break;
e9576ca5	479	case wxCURSOR_MAGNIFIER:
fe3fcb05	480	{
dd05f811	481	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorMagnifier);
fe3fcb05 SC	482	}
fe3fcb05 SC	483	break;
e9576ca5	484	case wxCURSOR_NO_ENTRY:
fe3fcb05	485	{
dd05f811	486	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorNoEntry);
fe3fcb05 SC	487	}
fe3fcb05 SC	488	break;
e9576ca5	489	case wxCURSOR_WATCH:
e40298d5 JS	490	{
	491	M_CURSORDATA->m_themeCursor = kThemeWatchCursor;
	492	break;
	493	}
e9576ca5	494	case wxCURSOR_PAINT_BRUSH:
e40298d5	495	{
dd05f811	496	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPaintBrush);
e40298d5 JS	497	break;
e40298d5 JS	498	}
e9576ca5	499	case wxCURSOR_POINT_LEFT:
e40298d5	500	{
dd05f811	501	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPointLeft);
e40298d5 JS	502	break;
e40298d5 JS	503	}
e9576ca5	504	case wxCURSOR_POINT_RIGHT:
e40298d5	505	{
dd05f811	506	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorPointRight);
e40298d5 JS	507	break;
e40298d5 JS	508	}
e9576ca5	509	case wxCURSOR_QUESTION_ARROW:
e40298d5	510	{
dd05f811	511	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorQuestionArrow);
e40298d5 JS	512	break;
e40298d5 JS	513	}
e9576ca5	514	case wxCURSOR_BLANK:
e40298d5	515	{
dd05f811	516	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorBlank);
e40298d5 JS	517	break;
e40298d5 JS	518	}
c6a071d2	519	case wxCURSOR_RIGHT_ARROW:
e40298d5	520	{
dd05f811	521	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorRightArrow);
e40298d5 JS	522	break;
e40298d5 JS	523	}
c6a071d2	524	case wxCURSOR_SPRAYCAN:
e40298d5	525	{
dd05f811	526	M_CURSORDATA->m_hCursor = wxGetStockCursor(kwxCursorRoller);
e40298d5 JS	527	break;
e40298d5 JS	528	}
c6a071d2	529	case wxCURSOR_CHAR:
e9576ca5	530	case wxCURSOR_ARROW:
c6a071d2 SC	531	case wxCURSOR_LEFT_BUTTON:
	532	case wxCURSOR_RIGHT_BUTTON:
	533	case wxCURSOR_MIDDLE_BUTTON:
e40298d5 JS	534	default:
	535	M_CURSORDATA->m_themeCursor = kThemeArrowCursor ;
	536	break;
	537	}
	538	if ( M_CURSORDATA->m_themeCursor == -1 )
	539	M_CURSORDATA->m_releaseHandle = true ;
519cb848	540	}
e9576ca5	541
519cb848 SC	542	void wxCursor::MacInstall() const
519cb848 SC	543	{
e40298d5 JS	544	gMacCurrentCursor = *this ;
	545	if ( m_refData && M_CURSORDATA->m_themeCursor != -1 )
	546	{
	547	SetThemeCursor( M_CURSORDATA->m_themeCursor ) ;
	548	}
	549	else if ( m_refData && M_CURSORDATA->m_hCursor )
	550	{
	551	if ( M_CURSORDATA->m_isColorCursor )
	552	::SetCCursor( (CCrsrHandle) M_CURSORDATA->m_hCursor ) ;
	553	else
	554	::SetCursor( * (CursHandle) M_CURSORDATA->m_hCursor ) ;
	555	}
	556	else
	557	{
	558	SetThemeCursor( kThemeArrowCursor ) ;
	559	}
e9576ca5 SC	560	}
	561
	562	wxCursor::~wxCursor()
	563	{
	564	}
	565
	566	// Global cursor setting
	567	void wxSetCursor(const wxCursor& cursor)
	568	{
e40298d5	569	cursor.MacInstall() ;
e9576ca5 SC	570	}
	571
	572