[wxWidgets.git] / src / osx / carbon / region.cpp

/////////////////////////////////////////////////////////////////////////////
// File:      src/osx/carbon/region.cpp
// Purpose:   Region class
// Author:    Stefan Csomor
// Created:   Fri Oct 24 10:46:34 MET 1997
// RCS-ID:    $Id$
// Copyright: (c) 1997 Stefan Csomor
// Licence:   wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#if wxOSX_USE_COCOA_OR_CARBON

#include "wx/region.h"

#ifndef WX_PRECOMP
    #include "wx/gdicmn.h"
#endif

#include "wx/osx/private.h"

IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)

//-----------------------------------------------------------------------------
// wxRegionRefData implementation
//-----------------------------------------------------------------------------

class WXDLLEXPORT wxRegionRefData : public wxGDIRefData
{
public:
    wxRegionRefData()
    {
        m_macRgn.reset( HIShapeCreateMutable() );
    }

    wxRegionRefData(wxCFRef<HIShapeRef> &region)
    {
        m_macRgn.reset( HIShapeCreateMutableCopy(region) );
    }

    wxRegionRefData(long x, long y, long w, long h)
    {
        CGRect r = CGRectMake(x,y,w,h);
        wxCFRef<HIShapeRef> rect(HIShapeCreateWithRect(&r));
        m_macRgn.reset( HIShapeCreateMutableCopy(rect) );
    }

    wxRegionRefData(const wxRegionRefData& data)
        : wxGDIRefData()
    {
        m_macRgn.reset( HIShapeCreateMutableCopy(data.m_macRgn) );
    }

    virtual ~wxRegionRefData()
    {
    }

    wxCFRef<HIMutableShapeRef> m_macRgn;
};

#define M_REGION (((wxRegionRefData*)m_refData)->m_macRgn)
#define OTHER_M_REGION(a) (((wxRegionRefData*)(a.m_refData))->m_macRgn)

//-----------------------------------------------------------------------------
// wxRegion
//-----------------------------------------------------------------------------

/*!
 * Create an empty region.
 */
wxRegion::wxRegion()
{
    m_refData = new wxRegionRefData();
}

wxRegion::wxRegion(WXHRGN hRegion )
{
    wxCFRef< HIShapeRef > shape( (HIShapeRef) hRegion );
    m_refData = new wxRegionRefData(shape);
}

wxRegion::wxRegion(long x, long y, long w, long h)
{
    m_refData = new wxRegionRefData(x , y , w , h );
}

wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
{
    m_refData = new wxRegionRefData(topLeft.x , topLeft.y ,
                                    topLeft.x - bottomRight.x ,
                                    topLeft.y - bottomRight.y);
}

wxRegion::wxRegion(const wxRect& rect)
{
    m_refData = new wxRegionRefData(rect.x , rect.y , rect.width , rect.height);
}

wxRegion::wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode WXUNUSED(fillStyle))
{
    wxUnusedVar(n);
    wxUnusedVar(points);

#if 0
    // no non-QD APIs available
    // TODO : remove ?
    // OS X somehow does not collect the region invisibly as before, so sometimes things
    // get drawn on screen instead of just being combined into a region, therefore we allocate a temp gworld now

    GWorldPtr gWorld = NULL;
    GWorldPtr oldWorld;
    GDHandle oldGDHandle;
    OSStatus err;
    Rect destRect = { 0, 0, 1, 1 };

    ::GetGWorld( &oldWorld, &oldGDHandle );
    err = ::NewGWorld( &gWorld, 32, &destRect, NULL, NULL, 0 );
    if ( err == noErr )
    {
        ::SetGWorld( gWorld, GetGDevice() );

        OpenRgn();

        wxCoord x1, x2 , y1 , y2 ;
        x2 = x1 = points[0].x ;
        y2 = y1 = points[0].y ;

        ::MoveTo( x1, y1 );
        for (size_t i = 1; i < n; i++)
        {
            x2 = points[i].x ;
            y2 = points[i].y ;
            ::LineTo( x2, y2 );
        }

        // close the polyline if necessary
        if ( x1 != x2 || y1 != y2 )
            ::LineTo( x1, y1 ) ;

        RgnHandle tempRgn = NewRgn();
        CloseRgn( tempRgn ) ;

        ::SetGWorld( oldWorld, oldGDHandle );
        wxCFRef<HIShapeRef> tempShape( HIShapeCreateWithQDRgn(tempRgn ) );
        m_refData = new wxRegionRefData(tempShape);
        DisposeRgn( tempRgn );
    }
    else
    {
        m_refData = new wxRegionRefData;
    }
#else
    wxFAIL_MSG( "not implemented" );
    m_refData = NULL;
#endif
}

wxRegion::~wxRegion()
{
    // m_refData unrefed in ~wxObject
}

wxGDIRefData *wxRegion::CreateGDIRefData() const
{
    return new wxRegionRefData;
}

wxGDIRefData *wxRegion::CloneGDIRefData(const wxGDIRefData *data) const
{
    return new wxRegionRefData(*static_cast<const wxRegionRefData *>(data));
}

//-----------------------------------------------------------------------------
//# Modify region
//-----------------------------------------------------------------------------

//! Clear current region
void wxRegion::Clear()
{
    UnRef();
}

// Move the region
bool wxRegion::DoOffset(wxCoord x, wxCoord y)
{
    wxCHECK_MSG( M_REGION, false, wxT("invalid wxRegion") );

    if ( !x && !y )
        // nothing to do
        return true;

    verify_noerr( HIShapeOffset( M_REGION , x , y ) ) ;

    return true ;
}


//! Union /e region with this.
bool wxRegion::DoCombine(const wxRegion& region, wxRegionOp op)
{
    wxCHECK_MSG( region.Ok(), false, wxT("invalid wxRegion") );

    // Don't change shared data
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
    }
    else if (m_refData->GetRefCount() > 1)
    {
        wxRegionRefData* ref = (wxRegionRefData*)m_refData;
        UnRef();
        m_refData = new wxRegionRefData(*ref);
    }

    switch (op)
    {
        case wxRGN_AND:
            verify_noerr( HIShapeIntersect( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
            break ;

        case wxRGN_OR:
            verify_noerr( HIShapeUnion( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
            break ;

        case wxRGN_XOR:
            {
                // XOR is defined as the difference between union and intersection
                wxCFRef< HIShapeRef > unionshape( HIShapeCreateUnion( M_REGION , OTHER_M_REGION(region) ) );
                wxCFRef< HIShapeRef > intersectionshape( HIShapeCreateIntersection( M_REGION , OTHER_M_REGION(region) ) );
                verify_noerr( HIShapeDifference( unionshape, intersectionshape, M_REGION ) );
            }
            break ;

        case wxRGN_DIFF:
            verify_noerr( HIShapeDifference( M_REGION , OTHER_M_REGION(region) , M_REGION ) ) ;
            break ;

        case wxRGN_COPY:
        default:
            M_REGION.reset( HIShapeCreateMutableCopy( OTHER_M_REGION(region) ) );
            break ;
    }

    return true;
}

//-----------------------------------------------------------------------------
//# Information on region
//-----------------------------------------------------------------------------

bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
{
    wxFAIL_MSG( wxT("not implemented") );

    return false;
}

// Outer bounds of region
bool wxRegion::DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
{
    if (m_refData)
    {
        CGRect box ;
        HIShapeGetBounds( M_REGION , &box ) ;
        x = static_cast<int>(box.origin.x);
        y = static_cast<int>(box.origin.y);
        w = static_cast<int>(box.size.width);
        h = static_cast<int>(box.size.height);

        return true;
    }
    else
    {
        x = y = w = h = 0;

        return false;
    }
}

// Is region empty?
bool wxRegion::IsEmpty() const
{
    if ( m_refData )
        return HIShapeIsEmpty( M_REGION ) ;
    else
        return true ;
}

const WXHRGN wxRegion::GetWXHRGN() const
{
    return M_REGION ;
}

//-----------------------------------------------------------------------------
//# Tests
//-----------------------------------------------------------------------------

// Does the region contain the point?
wxRegionContain wxRegion::DoContainsPoint(wxCoord x, wxCoord y) const
{
    if (!m_refData)
        return wxOutRegion;

    CGPoint p = { x, y } ;
    if (HIShapeContainsPoint( M_REGION , &p ) )
        return wxInRegion;

    return wxOutRegion;
}

// Does the region contain the rectangle (x, y, w, h)?
wxRegionContain wxRegion::DoContainsRect(const wxRect& r) const
{
    if (!m_refData)
        return wxOutRegion;

    CGRect rect = CGRectMake(r.x,r.y,r.width,r.height);
    wxCFRef<HIShapeRef> rectshape(HIShapeCreateWithRect(&rect));
    wxCFRef<HIShapeRef> intersect(HIShapeCreateIntersection(rectshape,M_REGION));
    CGRect bounds;
    HIShapeGetBounds(intersect, &bounds);

    if ( HIShapeIsRectangular(intersect) && CGRectEqualToRect(rect,bounds) )
        return wxInRegion;
    else if ( HIShapeIsEmpty( intersect ) )
        return wxOutRegion;
    else
        return wxPartRegion;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//                               wxRegionIterator                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

/*!
 * Initialize empty iterator
 */
wxRegionIterator::wxRegionIterator()
    : m_current(0), m_numRects(0), m_rects(NULL)
{
}

wxRegionIterator::~wxRegionIterator()
{
    wxDELETEA(m_rects);
}

wxRegionIterator::wxRegionIterator(const wxRegionIterator& iterator)
    : wxObject()
    , m_current(iterator.m_current)
    , m_numRects(0)
    , m_rects(NULL)
{
    SetRects(iterator.m_numRects, iterator.m_rects);
}

wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& iterator)
{
    m_current  = iterator.m_current;
    SetRects(iterator.m_numRects, iterator.m_rects);

    return *this;
}

/*!
 * Set iterator rects for region
 */
void wxRegionIterator::SetRects(long numRects, wxRect *rects)
{
    wxDELETEA(m_rects);

    if (rects && (numRects > 0))
    {
        int i;

        m_rects = new wxRect[numRects];
        for (i = 0; i < numRects; i++)
            m_rects[i] = rects[i];
    }

    m_numRects = numRects;
}

/*!
 * Initialize iterator for region
 */
wxRegionIterator::wxRegionIterator(const wxRegion& region)
{
    m_rects = NULL;

    Reset(region);
}

/*!
 * Reset iterator for a new /e region.
 */

class RegionToRectsCallbackData
{
public :
    wxRect* m_rects ;
    long m_current ;
};

#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5

OSStatus wxMacRegionToRectsCounterCallback(
    UInt16 message, RgnHandle WXUNUSED(region), const Rect *WXUNUSED(rect), void *data )
{
    long *m_numRects = (long*) data ;
    if ( message == kQDRegionToRectsMsgInit )
    {
        (*m_numRects) = 0 ;
    }
    else if (message == kQDRegionToRectsMsgParse)
    {
        (*m_numRects) += 1 ;
    }

    return noErr;
}

OSStatus wxMacRegionToRectsSetterCallback(
    UInt16 message, RgnHandle WXUNUSED(region), const Rect *rect, void *data )
{
    if (message == kQDRegionToRectsMsgParse)
    {
        RegionToRectsCallbackData *cb = (RegionToRectsCallbackData*) data ;
        cb->m_rects[cb->m_current++] = wxRect( rect->left , rect->top , rect->right - rect->left , rect->bottom - rect->top ) ;
    }

    return noErr;
}

#endif

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5

OSStatus wxOSXRegionToRectsCounterCallback(
    int message, HIShapeRef WXUNUSED(region), const CGRect *WXUNUSED(rect), void *data )
{
    long *m_numRects = (long*) data ;
    if ( message == kHIShapeEnumerateInit )
    {
        (*m_numRects) = 0 ;
    }
    else if (message == kHIShapeEnumerateRect)
    {
        (*m_numRects) += 1 ;
    }

    return noErr;
}

OSStatus wxOSXRegionToRectsSetterCallback(
    int message, HIShapeRef WXUNUSED(region), const CGRect *rect, void *data )
{
    if (message == kHIShapeEnumerateRect)
    {
        RegionToRectsCallbackData *cb = (RegionToRectsCallbackData*) data ;
        cb->m_rects[cb->m_current++] = wxRect( rect->origin.x , rect->origin.y , rect->size.width , rect->size.height ) ;
    }

    return noErr;
}

#endif

void wxRegionIterator::Reset(const wxRegion& region)
{
    m_current = 0;
    m_region = region;

    wxDELETEA(m_rects);

    if (m_region.IsEmpty())
    {
        m_numRects = 0;
    }
    else
    {
#if 0
        // fallback code in case we ever need it again
        // copying this to a path and dissecting the path would be an option
        m_numRects = 1;
        m_rects = new wxRect[m_numRects];
        m_rects[0] = m_region.GetBox();
#endif

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
        if ( HIShapeEnumerate != NULL )
        {
            OSStatus err = HIShapeEnumerate (OTHER_M_REGION(region), kHIShapeParseFromTopLeft, wxOSXRegionToRectsCounterCallback,
                (void*)&m_numRects);
            if (err == noErr)
            {
                m_rects = new wxRect[m_numRects];
                RegionToRectsCallbackData data ;
                data.m_rects = m_rects ;
                data.m_current = 0 ;
                HIShapeEnumerate( OTHER_M_REGION(region), kHIShapeParseFromTopLeft, wxOSXRegionToRectsSetterCallback,
                    (void*)&data );
            }
            else
            {
                m_numRects = 0;
            }
        }
        else
#endif
        {
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
            OSStatus err = noErr;
            RgnHandle rgn = NewRgn();
            HIShapeGetAsQDRgn(OTHER_M_REGION(region), rgn);

            err = QDRegionToRects (rgn, kQDParseRegionFromTopLeft, wxMacRegionToRectsCounterCallback
                , (void*)&m_numRects);
            if (err == noErr)
            {
                m_rects = new wxRect[m_numRects];
                RegionToRectsCallbackData data ;
                data.m_rects = m_rects ;
                data.m_current = 0 ;
                QDRegionToRects( rgn , kQDParseRegionFromTopLeft, wxMacRegionToRectsSetterCallback,
                    (void*)&data );
            }
            else
            {
                m_numRects = 0;
            }
            DisposeRgn( rgn );
#endif
        }
    }
}

/*!
 * Increment iterator. The rectangle returned is the one after the
 * incrementation.
 */
wxRegionIterator& wxRegionIterator::operator ++ ()
{
    if (m_current < m_numRects)
        ++m_current;

    return *this;
}

/*!
 * Increment iterator. The rectangle returned is the one before the
 * incrementation.
 */
wxRegionIterator wxRegionIterator::operator ++ (int)
{
    wxRegionIterator previous(*this);

    if (m_current < m_numRects)
        ++m_current;

    return previous;
}

long wxRegionIterator::GetX() const
{
    if (m_current < m_numRects)
        return m_rects[m_current].x;

    return 0;
}

long wxRegionIterator::GetY() const
{
    if (m_current < m_numRects)
        return m_rects[m_current].y;

    return 0;
}

long wxRegionIterator::GetW() const
{
    if (m_current < m_numRects)
        return m_rects[m_current].width ;

    return 0;
}

long wxRegionIterator::GetH() const
{
    if (m_current < m_numRects)
        return m_rects[m_current].height;

    return 0;
}

#endif
Commit	Line	Data
489468fe	1	/////////////////////////////////////////////////////////////////////////////
233f5738	2	// File: src/osx/carbon/region.cpp
489468fe SC	3	// Purpose: Region class
	4	// Author: Stefan Csomor
	5	// Created: Fri Oct 24 10:46:34 MET 1997
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 1997 Stefan Csomor
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#include "wx/wxprec.h"
	12
afd5d91c SC	13	#if wxOSX_USE_COCOA_OR_CARBON
afd5d91c SC	14
489468fe SC	15	#include "wx/region.h"
	16
	17	#ifndef WX_PRECOMP
	18	#include "wx/gdicmn.h"
	19	#endif
	20
5398a2e0	21	#include "wx/osx/private.h"
489468fe SC	22
	23	IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject)
	24	IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject)
	25
	26	//-----------------------------------------------------------------------------
	27	// wxRegionRefData implementation
	28	//-----------------------------------------------------------------------------
	29
	30	class WXDLLEXPORT wxRegionRefData : public wxGDIRefData
	31	{
	32	public:
	33	wxRegionRefData()
	34	{
	35	m_macRgn.reset( HIShapeCreateMutable() );
	36	}
	37
	38	wxRegionRefData(wxCFRef<HIShapeRef> &region)
	39	{
	40	m_macRgn.reset( HIShapeCreateMutableCopy(region) );
	41	}
	42
	43	wxRegionRefData(long x, long y, long w, long h)
	44	{
	45	CGRect r = CGRectMake(x,y,w,h);
	46	wxCFRef<HIShapeRef> rect(HIShapeCreateWithRect(&r));
	47	m_macRgn.reset( HIShapeCreateMutableCopy(rect) );
	48	}
	49
	50	wxRegionRefData(const wxRegionRefData& data)
	51	: wxGDIRefData()
	52	{
	53	m_macRgn.reset( HIShapeCreateMutableCopy(data.m_macRgn) );
	54	}
	55
	56	virtual ~wxRegionRefData()
	57	{
	58	}
	59
	60	wxCFRef<HIMutableShapeRef> m_macRgn;
	61	};
	62
	63	#define M_REGION (((wxRegionRefData*)m_refData)->m_macRgn)
	64	#define OTHER_M_REGION(a) (((wxRegionRefData*)(a.m_refData))->m_macRgn)
	65
	66	//-----------------------------------------------------------------------------
	67	// wxRegion
	68	//-----------------------------------------------------------------------------
	69
	70	/*!
	71	* Create an empty region.
	72	*/
	73	wxRegion::wxRegion()
	74	{
	75	m_refData = new wxRegionRefData();
	76	}
	77
	78	wxRegion::wxRegion(WXHRGN hRegion )
	79	{
	80	wxCFRef< HIShapeRef > shape( (HIShapeRef) hRegion );
	81	m_refData = new wxRegionRefData(shape);
	82	}
	83
	84	wxRegion::wxRegion(long x, long y, long w, long h)
	85	{
86	m_refData = new wxRegionRefData(x , y , w , h );
87	}
88
89	wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)
90	{
91	m_refData = new wxRegionRefData(topLeft.x , topLeft.y ,
92	topLeft.x - bottomRight.x ,
93	topLeft.y - bottomRight.y);
94	}
95
96	wxRegion::wxRegion(const wxRect& rect)
97	{
98	m_refData = new wxRegionRefData(rect.x , rect.y , rect.width , rect.height);
99	}
100
1ed06824	101	wxRegion::wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode WXUNUSED(fillStyle))
489468fe SC	102	{
	103	wxUnusedVar(n);
	104	wxUnusedVar(points);
	105
03647350	106	#if 0
5398a2e0 SC	107	// no non-QD APIs available
5398a2e0 SC	108	// TODO : remove ?
489468fe SC	109	// OS X somehow does not collect the region invisibly as before, so sometimes things
	110	// get drawn on screen instead of just being combined into a region, therefore we allocate a temp gworld now
	111
	112	GWorldPtr gWorld = NULL;
	113	GWorldPtr oldWorld;
	114	GDHandle oldGDHandle;
	115	OSStatus err;
	116	Rect destRect = { 0, 0, 1, 1 };
	117
	118	::GetGWorld( &oldWorld, &oldGDHandle );
	119	err = ::NewGWorld( &gWorld, 32, &destRect, NULL, NULL, 0 );
	120	if ( err == noErr )
	121	{
	122	::SetGWorld( gWorld, GetGDevice() );
	123
	124	OpenRgn();
	125
	126	wxCoord x1, x2 , y1 , y2 ;
	127	x2 = x1 = points[0].x ;
	128	y2 = y1 = points[0].y ;
	129
	130	::MoveTo( x1, y1 );
	131	for (size_t i = 1; i < n; i++)
	132	{
	133	x2 = points[i].x ;
	134	y2 = points[i].y ;
	135	::LineTo( x2, y2 );
	136	}
	137
	138	// close the polyline if necessary
	139	if ( x1 != x2 \|\| y1 != y2 )
	140	::LineTo( x1, y1 ) ;
	141
	142	RgnHandle tempRgn = NewRgn();
	143	CloseRgn( tempRgn ) ;
03647350	144
489468fe SC	145	::SetGWorld( oldWorld, oldGDHandle );
	146	wxCFRef<HIShapeRef> tempShape( HIShapeCreateWithQDRgn(tempRgn ) );
	147	m_refData = new wxRegionRefData(tempShape);
	148	DisposeRgn( tempRgn );
	149	}
	150	else
	151	{
	152	m_refData = new wxRegionRefData;
	153	}
	154	#else
	155	wxFAIL_MSG( "not implemented" );
	156	m_refData = NULL;
	157	#endif
	158	}
	159
	160	wxRegion::~wxRegion()
	161	{
	162	// m_refData unrefed in ~wxObject
	163	}
	164
	165	wxGDIRefData *wxRegion::CreateGDIRefData() const
	166	{
	167	return new wxRegionRefData;
	168	}
	169
	170	wxGDIRefData wxRegion::CloneGDIRefData(const wxGDIRefData data) const
	171	{
5c33522f	172	return new wxRegionRefData(static_cast<const wxRegionRefData >(data));
489468fe SC	173	}
	174
	175	//-----------------------------------------------------------------------------
	176	//# Modify region
	177	//-----------------------------------------------------------------------------
	178
	179	//! Clear current region
	180	void wxRegion::Clear()
	181	{
	182	UnRef();
	183	}
	184
	185	// Move the region
	186	bool wxRegion::DoOffset(wxCoord x, wxCoord y)
	187	{
9a83f860	188	wxCHECK_MSG( M_REGION, false, wxT("invalid wxRegion") );
489468fe SC	189
	190	if ( !x && !y )
	191	// nothing to do
	192	return true;
	193
	194	verify_noerr( HIShapeOffset( M_REGION , x , y ) ) ;
	195
	196	return true ;
	197	}
	198
	199
	200	//! Union /e region with this.
	201	bool wxRegion::DoCombine(const wxRegion& region, wxRegionOp op)
	202	{
9a83f860	203	wxCHECK_MSG( region.Ok(), false, wxT("invalid wxRegion") );
489468fe SC	204
	205	// Don't change shared data
	206	if (!m_refData)
	207	{
	208	m_refData = new wxRegionRefData();
	209	}
	210	else if (m_refData->GetRefCount() > 1)
	211	{
	212	wxRegionRefData* ref = (wxRegionRefData*)m_refData;
	213	UnRef();
	214	m_refData = new wxRegionRefData(*ref);
	215	}
	216
	217	switch (op)
	218	{
	219	case wxRGN_AND:
	220	verify_noerr( HIShapeIntersect( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
	221	break ;
	222
	223	case wxRGN_OR:
	224	verify_noerr( HIShapeUnion( M_REGION , OTHER_M_REGION(region) , M_REGION ) );
	225	break ;
	226
	227	case wxRGN_XOR:
	228	{
	229	// XOR is defined as the difference between union and intersection
	230	wxCFRef< HIShapeRef > unionshape( HIShapeCreateUnion( M_REGION , OTHER_M_REGION(region) ) );
	231	wxCFRef< HIShapeRef > intersectionshape( HIShapeCreateIntersection( M_REGION , OTHER_M_REGION(region) ) );
	232	verify_noerr( HIShapeDifference( unionshape, intersectionshape, M_REGION ) );
	233	}
	234	break ;
	235
	236	case wxRGN_DIFF:
	237	verify_noerr( HIShapeDifference( M_REGION , OTHER_M_REGION(region) , M_REGION ) ) ;
	238	break ;
	239
	240	case wxRGN_COPY:
	241	default:
	242	M_REGION.reset( HIShapeCreateMutableCopy( OTHER_M_REGION(region) ) );
	243	break ;
	244	}
	245
	246	return true;
	247	}
	248
	249	//-----------------------------------------------------------------------------
	250	//# Information on region
	251	//-----------------------------------------------------------------------------
	252
	253	bool wxRegion::DoIsEqual(const wxRegion& WXUNUSED(region)) const
	254	{
9a83f860	255	wxFAIL_MSG( wxT("not implemented") );
489468fe SC	256
	257	return false;
	258	}
	259
	260	// Outer bounds of region
	261	bool wxRegion::DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
	262	{
	263	if (m_refData)
	264	{
	265	CGRect box ;
	266	HIShapeGetBounds( M_REGION , &box ) ;
5c33522f VZ	267	x = static_cast<int>(box.origin.x);
	268	y = static_cast<int>(box.origin.y);
	269	w = static_cast<int>(box.size.width);
	270	h = static_cast<int>(box.size.height);
489468fe SC	271
	272	return true;
	273	}
	274	else
	275	{
	276	x = y = w = h = 0;
	277
	278	return false;
	279	}
	280	}
	281
	282	// Is region empty?
	283	bool wxRegion::IsEmpty() const
	284	{
	285	if ( m_refData )
	286	return HIShapeIsEmpty( M_REGION ) ;
	287	else
	288	return true ;
	289	}
	290
	291	const WXHRGN wxRegion::GetWXHRGN() const
	292	{
	293	return M_REGION ;
	294	}
	295
	296	//-----------------------------------------------------------------------------
	297	//# Tests
	298	//-----------------------------------------------------------------------------
	299
	300	// Does the region contain the point?
	301	wxRegionContain wxRegion::DoContainsPoint(wxCoord x, wxCoord y) const
	302	{
	303	if (!m_refData)
	304	return wxOutRegion;
	305
e331a94e	306	CGPoint p = { x, y } ;
489468fe SC	307	if (HIShapeContainsPoint( M_REGION , &p ) )
	308	return wxInRegion;
	309
	310	return wxOutRegion;
	311	}
	312
	313	// Does the region contain the rectangle (x, y, w, h)?
	314	wxRegionContain wxRegion::DoContainsRect(const wxRect& r) const
	315	{
	316	if (!m_refData)
	317	return wxOutRegion;
	318
	319	CGRect rect = CGRectMake(r.x,r.y,r.width,r.height);
	320	wxCFRef<HIShapeRef> rectshape(HIShapeCreateWithRect(&rect));
	321	wxCFRef<HIShapeRef> intersect(HIShapeCreateIntersection(rectshape,M_REGION));
	322	CGRect bounds;
	323	HIShapeGetBounds(intersect, &bounds);
	324
	325	if ( HIShapeIsRectangular(intersect) && CGRectEqualToRect(rect,bounds) )
	326	return wxInRegion;
	327	else if ( HIShapeIsEmpty( intersect ) )
	328	return wxOutRegion;
	329	else
	330	return wxPartRegion;
	331	}
	332
	333	///////////////////////////////////////////////////////////////////////////////
	334	// //
	335	// wxRegionIterator //
	336	// //
	337	///////////////////////////////////////////////////////////////////////////////
	338
	339	/*!
	340	* Initialize empty iterator
	341	*/
	342	wxRegionIterator::wxRegionIterator()
	343	: m_current(0), m_numRects(0), m_rects(NULL)
	344	{
	345	}
	346
	347	wxRegionIterator::~wxRegionIterator()
	348	{
5276b0a5	349	wxDELETEA(m_rects);
489468fe SC	350	}
	351
	352	wxRegionIterator::wxRegionIterator(const wxRegionIterator& iterator)
	353	: wxObject()
	354	, m_current(iterator.m_current)
	355	, m_numRects(0)
	356	, m_rects(NULL)
	357	{
	358	SetRects(iterator.m_numRects, iterator.m_rects);
	359	}
	360
	361	wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& iterator)
	362	{
	363	m_current = iterator.m_current;
	364	SetRects(iterator.m_numRects, iterator.m_rects);
	365
	366	return *this;
	367	}
	368
	369	/*!
	370	* Set iterator rects for region
	371	*/
	372	void wxRegionIterator::SetRects(long numRects, wxRect *rects)
	373	{
5276b0a5	374	wxDELETEA(m_rects);
489468fe SC	375
	376	if (rects && (numRects > 0))
	377	{
	378	int i;
	379
	380	m_rects = new wxRect[numRects];
	381	for (i = 0; i < numRects; i++)
	382	m_rects[i] = rects[i];
	383	}
	384
	385	m_numRects = numRects;
	386	}
	387
	388	/*!
	389	* Initialize iterator for region
	390	*/
	391	wxRegionIterator::wxRegionIterator(const wxRegion& region)
	392	{
	393	m_rects = NULL;
	394
	395	Reset(region);
	396	}
	397
	398	/*!
	399	* Reset iterator for a new /e region.
	400	*/
	401
5398a2e0 SC	402	class RegionToRectsCallbackData
	403	{
	404	public :
	405	wxRect* m_rects ;
	406	long m_current ;
	407	};
	408
	409	#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
	410
489468fe SC	411	OSStatus wxMacRegionToRectsCounterCallback(
	412	UInt16 message, RgnHandle WXUNUSED(region), const Rect WXUNUSED(rect), void data )
	413	{
	414	long m_numRects = (long) data ;
	415	if ( message == kQDRegionToRectsMsgInit )
	416	{
	417	(*m_numRects) = 0 ;
	418	}
	419	else if (message == kQDRegionToRectsMsgParse)
	420	{
	421	(*m_numRects) += 1 ;
	422	}
	423
	424	return noErr;
	425	}
	426
489468fe SC	427	OSStatus wxMacRegionToRectsSetterCallback(
	428	UInt16 message, RgnHandle WXUNUSED(region), const Rect rect, void data )
	429	{
	430	if (message == kQDRegionToRectsMsgParse)
	431	{
	432	RegionToRectsCallbackData cb = (RegionToRectsCallbackData) data ;
	433	cb->m_rects[cb->m_current++] = wxRect( rect->left , rect->top , rect->right - rect->left , rect->bottom - rect->top ) ;
	434	}
	435
	436	return noErr;
	437	}
5398a2e0 SC	438
	439	#endif
	440
	441	#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
	442
	443	OSStatus wxOSXRegionToRectsCounterCallback(
	444	int message, HIShapeRef WXUNUSED(region), const CGRect WXUNUSED(rect), void data )
	445	{
	446	long m_numRects = (long) data ;
	447	if ( message == kHIShapeEnumerateInit )
	448	{
	449	(*m_numRects) = 0 ;
	450	}
	451	else if (message == kHIShapeEnumerateRect)
	452	{
	453	(*m_numRects) += 1 ;
	454	}
	455
	456	return noErr;
	457	}
	458
	459	OSStatus wxOSXRegionToRectsSetterCallback(
	460	int message, HIShapeRef WXUNUSED(region), const CGRect rect, void data )
	461	{
	462	if (message == kHIShapeEnumerateRect)
	463	{
	464	RegionToRectsCallbackData cb = (RegionToRectsCallbackData) data ;
	465	cb->m_rects[cb->m_current++] = wxRect( rect->origin.x , rect->origin.y , rect->size.width , rect->size.height ) ;
	466	}
	467
	468	return noErr;
	469	}
	470
489468fe SC	471	#endif
	472
	473	void wxRegionIterator::Reset(const wxRegion& region)
	474	{
	475	m_current = 0;
	476	m_region = region;
	477
5276b0a5	478	wxDELETEA(m_rects);
489468fe SC	479
	480	if (m_region.IsEmpty())
	481	{
	482	m_numRects = 0;
	483	}
	484	else
	485	{
5398a2e0 SC	486	#if 0
5398a2e0 SC	487	// fallback code in case we ever need it again
489468fe SC	488	// copying this to a path and dissecting the path would be an option
	489	m_numRects = 1;
	490	m_rects = new wxRect[m_numRects];
	491	m_rects[0] = m_region.GetBox();
5398a2e0	492	#endif
489468fe	493
5398a2e0 SC	494	#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
5398a2e0 SC	495	if ( HIShapeEnumerate != NULL )
489468fe	496	{
03647350	497	OSStatus err = HIShapeEnumerate (OTHER_M_REGION(region), kHIShapeParseFromTopLeft, wxOSXRegionToRectsCounterCallback,
5398a2e0 SC	498	(void*)&m_numRects);
	499	if (err == noErr)
	500	{
	501	m_rects = new wxRect[m_numRects];
	502	RegionToRectsCallbackData data ;
	503	data.m_rects = m_rects ;
	504	data.m_current = 0 ;
03647350	505	HIShapeEnumerate( OTHER_M_REGION(region), kHIShapeParseFromTopLeft, wxOSXRegionToRectsSetterCallback,
5398a2e0 SC	506	(void*)&data );
	507	}
	508	else
	509	{
	510	m_numRects = 0;
	511	}
489468fe SC	512	}
489468fe SC	513	else
5398a2e0	514	#endif
489468fe	515	{
5398a2e0 SC	516	#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
	517	OSStatus err = noErr;
	518	RgnHandle rgn = NewRgn();
	519	HIShapeGetAsQDRgn(OTHER_M_REGION(region), rgn);
	520
	521	err = QDRegionToRects (rgn, kQDParseRegionFromTopLeft, wxMacRegionToRectsCounterCallback
	522	, (void*)&m_numRects);
	523	if (err == noErr)
	524	{
	525	m_rects = new wxRect[m_numRects];
	526	RegionToRectsCallbackData data ;
	527	data.m_rects = m_rects ;
	528	data.m_current = 0 ;
03647350	529	QDRegionToRects( rgn , kQDParseRegionFromTopLeft, wxMacRegionToRectsSetterCallback,
5398a2e0 SC	530	(void*)&data );
	531	}
	532	else
	533	{
	534	m_numRects = 0;
	535	}
	536	DisposeRgn( rgn );
489468fe	537	#endif
5398a2e0	538	}
489468fe SC	539	}
	540	}
	541
	542	/*!
	543	* Increment iterator. The rectangle returned is the one after the
	544	* incrementation.
	545	*/
	546	wxRegionIterator& wxRegionIterator::operator ++ ()
	547	{
	548	if (m_current < m_numRects)
	549	++m_current;
	550
	551	return *this;
	552	}
	553
	554	/*!
	555	* Increment iterator. The rectangle returned is the one before the
	556	* incrementation.
	557	*/
	558	wxRegionIterator wxRegionIterator::operator ++ (int)
	559	{
	560	wxRegionIterator previous(*this);
	561
	562	if (m_current < m_numRects)
	563	++m_current;
	564
	565	return previous;
	566	}
	567
	568	long wxRegionIterator::GetX() const
	569	{
	570	if (m_current < m_numRects)
	571	return m_rects[m_current].x;
	572
	573	return 0;
	574	}
	575
	576	long wxRegionIterator::GetY() const
	577	{
	578	if (m_current < m_numRects)
	579	return m_rects[m_current].y;
	580
	581	return 0;
	582	}
	583
	584	long wxRegionIterator::GetW() const
	585	{
	586	if (m_current < m_numRects)
	587	return m_rects[m_current].width ;
	588
	589	return 0;
	590	}
	591
	592	long wxRegionIterator::GetH() const
	593	{
	594	if (m_current < m_numRects)
	595	return m_rects[m_current].height;
	596
	597	return 0;
	598	}
afd5d91c SC	599
afd5d91c SC	600	#endif