src/osx/carbon/region.cpp

/////////////////////////////////////////////////////////////////////////////
// File:      src/mac/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"

#include "wx/region.h"

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

#include "wx/osx/uma.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);

#ifndef __LP64__

    // TODO : any APIs ?
    // 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, _T("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, _T("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( _T("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 = { y , x } ;
    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()
{
    if (m_rects)
    {
        delete [] m_rects;
        m_rects = NULL;
    }
}

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)
{
    if (m_rects)
    {
        delete [] m_rects;
        m_rects = NULL;
    }

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

#ifndef __LP64__
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;
}

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

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

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

    if (m_rects)
    {
        delete [] m_rects;
        m_rects = NULL;
    }

    if (m_region.IsEmpty())
    {
        m_numRects = 0;
    }
    else
    {
#ifdef __LP64__
        // 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();

#else
        RegionToRectsUPP proc = (RegionToRectsUPP) wxMacRegionToRectsCounterCallback;

        OSStatus err = noErr;
        RgnHandle rgn = NewRgn();
        HIShapeGetAsQDRgn(OTHER_M_REGION(region), rgn);

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