src/gtk/region.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        gtk/region.cpp
// Purpose:
// Author:      Robert Roebling
// Modified:    VZ at 05.10.00: use AllocExclusive(), comparison fixed
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

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

#include "wx/log.h"

#include "wx/region.h"

#include "wx/gtk/private.h"

// ----------------------------------------------------------------------------
// wxRegionRefData: private class containing the information about the region
// ----------------------------------------------------------------------------

class wxRegionRefData : public wxObjectRefData
{
public:
    wxRegionRefData()
    {
        m_region = NULL;
    }

    wxRegionRefData(const wxRegionRefData& refData)
    {
#ifdef __WXGTK20__
        m_region = gdk_region_copy(refData.m_region);
#else
        m_region = gdk_region_new();
        GdkRegion *regCopy = gdk_regions_union(m_region, refData.m_region);
        gdk_region_destroy(m_region);
        m_region = regCopy;
#endif
    }

    ~wxRegionRefData()
    {
        if (m_region)
            gdk_region_destroy( m_region );
    }

    GdkRegion  *m_region;
};

// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------

#define M_REGIONDATA ((wxRegionRefData *)m_refData)
#define M_REGIONDATA_OF(rgn) ((wxRegionRefData *)(rgn.m_refData))

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

// ----------------------------------------------------------------------------
// wxRegion construction
// ----------------------------------------------------------------------------

#define M_REGIONDATA ((wxRegionRefData *)m_refData)

void wxRegion::InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
    GdkRectangle rect;
    rect.x = x;
    rect.y = y;
    rect.width = w;
    rect.height = h;

    m_refData = new wxRegionRefData();

#ifdef __WXGTK20__
    M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
#else
    GdkRegion *reg = gdk_region_new();
    M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
    gdk_region_destroy( reg );
#endif
}

wxRegion::wxRegion( size_t n, const wxPoint *points, int fillStyle )
{
    GdkPoint *gdkpoints = new GdkPoint[n];
    for ( size_t i = 0 ; i < n ; i++ )
    {
        gdkpoints[i].x = points[i].x;
        gdkpoints[i].y = points[i].y;
    }

    m_refData = new wxRegionRefData();

    GdkRegion* reg = gdk_region_polygon
                     (
                        gdkpoints,
                        n,
                        fillStyle == wxWINDING_RULE ? GDK_WINDING_RULE
                                                    : GDK_EVEN_ODD_RULE
                     );

    M_REGIONDATA->m_region = reg;

    delete [] gdkpoints;
}

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

wxObjectRefData *wxRegion::CreateRefData() const
{
    return new wxRegionRefData;
}

wxObjectRefData *wxRegion::CloneRefData(const wxObjectRefData *data) const
{
    return new wxRegionRefData(*(wxRegionRefData *)data);
}

// ----------------------------------------------------------------------------
// wxRegion comparison
// ----------------------------------------------------------------------------

bool wxRegion::operator==( const wxRegion& region )
{
    if (m_refData == region.m_refData) return TRUE;

    if (!m_refData || !region.m_refData) return FALSE;

    // compare the regions themselves, not the pointers to ref data!
    return gdk_region_equal(M_REGIONDATA->m_region,
                            M_REGIONDATA_OF(region)->m_region);
}

// ----------------------------------------------------------------------------
// wxRegion operations
// ----------------------------------------------------------------------------

void wxRegion::Clear()
{
    UnRef();
}

bool wxRegion::Union( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
    GdkRectangle rect;
    rect.x = x;
    rect.y = y;
    rect.width = width;
    rect.height = height;

    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
#ifdef __WXGTK20__
        M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
#else
        GdkRegion *reg = gdk_region_new();
        M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
        gdk_region_destroy( reg );
#endif
    }
    else
    {
        AllocExclusive();

#ifdef __WXGTK20__
        gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
#else
        GdkRegion *reg = gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
        gdk_region_destroy( M_REGIONDATA->m_region );
        M_REGIONDATA->m_region = reg;
#endif
    }

    return TRUE;
}

bool wxRegion::Union( const wxRect& rect )
{
    return Union( rect.x, rect.y, rect.width, rect.height );
}

bool wxRegion::Union( const wxRegion& region )
{
    if (region.IsNull())
        return FALSE;

    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }
    else
    {
        AllocExclusive();
    }

#ifdef __WXGTK20__
    gdk_region_union( M_REGIONDATA->m_region, region.GetRegion() );
#else
    GdkRegion *reg = gdk_regions_union( M_REGIONDATA->m_region, region.GetRegion() );
    gdk_region_destroy( M_REGIONDATA->m_region );
    M_REGIONDATA->m_region = reg;
#endif

    return TRUE;
}

bool wxRegion::Intersect( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
    wxRegion reg( x, y, width, height );

    return Intersect( reg );
}

bool wxRegion::Intersect( const wxRect& rect )
{
    wxRegion reg( rect );

    return Intersect( reg );
}

bool wxRegion::Intersect( const wxRegion& region )
{
    if (region.IsNull())
        return FALSE;

    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();

        // leave here
        return TRUE;
    }
    else
    {
        AllocExclusive();
    }

#ifdef __WXGTK20__
    gdk_region_intersect( M_REGIONDATA->m_region, region.GetRegion() );
#else
    GdkRegion *reg = gdk_regions_intersect( M_REGIONDATA->m_region, region.GetRegion() );
    gdk_region_destroy( M_REGIONDATA->m_region );
    M_REGIONDATA->m_region = reg;
#endif

    return TRUE;
}

bool wxRegion::Subtract( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
    wxRegion reg( x, y, width, height );
    return Subtract( reg );
}

bool wxRegion::Subtract( const wxRect& rect )
{
    wxRegion reg( rect );
    return Subtract( reg );
}

bool wxRegion::Subtract( const wxRegion& region )
{
    if (region.IsNull())
        return FALSE;

    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }
    else
    {
        AllocExclusive();
    }

#ifdef __WXGTK20__
    gdk_region_subtract( M_REGIONDATA->m_region, region.GetRegion() );
#else
    GdkRegion *reg = gdk_regions_subtract( M_REGIONDATA->m_region, region.GetRegion() );
    gdk_region_destroy( M_REGIONDATA->m_region );
    M_REGIONDATA->m_region = reg;
#endif

    return TRUE;
}

bool wxRegion::Xor( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
    wxRegion reg( x, y, width, height );
    return Xor( reg );
}

bool wxRegion::Xor( const wxRect& rect )
{
    wxRegion reg( rect );
    return Xor( reg );
}

bool wxRegion::Xor( const wxRegion& region )
{
    if (region.IsNull())
        return FALSE;

    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }
    else
    {
        AllocExclusive();
    }

#ifdef __WXGTK20__
    gdk_region_xor( M_REGIONDATA->m_region, region.GetRegion() );
#else
    GdkRegion *reg = gdk_regions_xor( M_REGIONDATA->m_region, region.GetRegion() );
    gdk_region_destroy( M_REGIONDATA->m_region );
    M_REGIONDATA->m_region = reg;
#endif

    return TRUE;
}

// ----------------------------------------------------------------------------
// wxRegion tests
// ----------------------------------------------------------------------------

void wxRegion::GetBox( wxCoord &x, wxCoord &y, wxCoord &w, wxCoord &h ) const
{
    if ( m_refData )
    {
        GdkRectangle rect;
        gdk_region_get_clipbox( M_REGIONDATA->m_region, &rect );
        x = rect.x;
        y = rect.y;
        w = rect.width;
        h = rect.height;
    }
    else
    {
        x = 0;
        y = 0;
        w = -1;
        h = -1;
    }
}

wxRect wxRegion::GetBox() const
{
    wxCoord x, y, w, h;
    GetBox( x, y, w, h );
    return wxRect( x, y, w, h );
}

bool wxRegion::Offset( wxCoord x, wxCoord y )
{
    if (!m_refData)
        return FALSE;

    AllocExclusive();

    gdk_region_offset( M_REGIONDATA->m_region, x, y );

    return TRUE;
}

bool wxRegion::Empty() const
{
    if (!m_refData)
        return TRUE;

    return gdk_region_empty( M_REGIONDATA->m_region );
}

wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y ) const
{
    if (!m_refData)
        return wxOutRegion;

    if (gdk_region_point_in( M_REGIONDATA->m_region, x, y ))
        return wxInRegion;
    else
        return wxOutRegion;
}

wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) const
{
    if (!m_refData)
        return wxOutRegion;

    GdkRectangle rect;
    rect.x = x;
    rect.y = y;
    rect.width = w;
    rect.height = h;
    GdkOverlapType res = gdk_region_rect_in( M_REGIONDATA->m_region, &rect );
    switch (res)
    {
        case GDK_OVERLAP_RECTANGLE_IN:   return wxInRegion;
        case GDK_OVERLAP_RECTANGLE_OUT:  return wxOutRegion;
        case GDK_OVERLAP_RECTANGLE_PART: return wxPartRegion;
    }
    return wxOutRegion;
}

wxRegionContain wxRegion::Contains(const wxPoint& pt) const
{
    return Contains( pt.x, pt.y );
}

wxRegionContain wxRegion::Contains(const wxRect& rect) const
{
    return Contains( rect.x, rect.y, rect.width, rect.height );
}

GdkRegion *wxRegion::GetRegion() const
{
    if (!m_refData)
        return (GdkRegion*) NULL;

    return M_REGIONDATA->m_region;
}

// ----------------------------------------------------------------------------
// wxRegionIterator
// ----------------------------------------------------------------------------

#ifndef __WXGTK20__

// the following structures must match the private structures
// in X11 region code ( xc/lib/X11/region.h )

// this makes the Region type transparent
// and we have access to the region rectangles

#include <gdk/gdkprivate.h>

struct _XBox {
    short x1, x2, y1, y2;
};

struct _XRegion {
    long   size , numRects;
    _XBox *rects, extents;
};

#endif

class wxRIRefData: public wxObjectRefData
{
public:

    wxRIRefData() : m_rects(0), m_numRects(0){}
   ~wxRIRefData();

    wxRect *m_rects;
    size_t  m_numRects;

    void CreateRects( const wxRegion& r );
};

wxRIRefData::~wxRIRefData()
{
    delete m_rects;
}

void wxRIRefData::CreateRects( const wxRegion& region )
{
    if (m_rects)
      delete m_rects;

    m_rects = 0;
    m_numRects = 0;

    GdkRegion *gdkregion = region.GetRegion();
    if (!gdkregion) return;

#ifdef __WXGTK20__
    GdkRectangle *gdkrects = NULL;
    gint numRects = 0;
    gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects );

    m_numRects = numRects;
    if (numRects)
    {
        m_rects = new wxRect[m_numRects];
        for (size_t i=0; i < m_numRects; ++i)
        {
            GdkRectangle &gr = gdkrects[i];
            wxRect &wr = m_rects[i];
            wr.x = gr.x;
            wr.y = gr.y;
            wr.width = gr.width;
            wr.height = gr.height;
        }
    }
    g_free( gdkrects );
#else // GTK+ 1.x
    Region r = ((GdkRegionPrivate *)gdkregion)->xregion;
    if (r)
    {
        m_numRects = r->numRects;
        if (m_numRects)
        {
            m_rects = new wxRect[m_numRects];
            for (size_t i=0; i < m_numRects; ++i)
            {
                _XBox &xr = r->rects[i];
                wxRect &wr = m_rects[i];
                wr.x = xr.x1;
                wr.y = xr.y1;
                wr.width = xr.x2-xr.x1;
                wr.height = xr.y2-xr.y1;
            }
        }
    }
#endif // GTK+ 2.0/1.x
}

wxRegionIterator::wxRegionIterator()
{
    m_refData = new wxRIRefData();
    Reset();
}

wxRegionIterator::wxRegionIterator( const wxRegion& region )
{
    m_refData = new wxRIRefData();
    Reset(region);
}

void wxRegionIterator::Reset( const wxRegion& region )
{
    m_region = region;
    ((wxRIRefData*)m_refData)->CreateRects(region);
    Reset();
}

bool wxRegionIterator::HaveRects() const
{
    return m_current < ((wxRIRefData*)m_refData)->m_numRects;
}

wxRegionIterator::operator bool () const
{
    return HaveRects();
}

void wxRegionIterator::operator ++ ()
{
    if (HaveRects()) ++m_current;
}

void wxRegionIterator::operator ++ (int)
{
    if (HaveRects()) ++m_current;
}

wxCoord wxRegionIterator::GetX() const
{
    if( !HaveRects() ) return 0;
    return ((wxRIRefData*)m_refData)->m_rects[m_current].x;
}

wxCoord wxRegionIterator::GetY() const
{
    if( !HaveRects() ) return 0;
    return ((wxRIRefData*)m_refData)->m_rects[m_current].y;
}

wxCoord wxRegionIterator::GetW() const
{
    if( !HaveRects() ) return -1;
    return ((wxRIRefData*)m_refData)->m_rects[m_current].width;
}

wxCoord wxRegionIterator::GetH() const
{
    if( !HaveRects() ) return -1;
    return ((wxRIRefData*)m_refData)->m_rects[m_current].height;
}

wxRect wxRegionIterator::GetRect() const
{
    wxRect r;
    if( HaveRects() )
        r = ((wxRIRefData*)m_refData)->m_rects[m_current];

    return r;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: gtk/region.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Modified: VZ at 05.10.00: use AllocExclusive(), comparison fixed
	6	// Id: $Id$
	7	// Copyright: (c) 1998 Robert Roebling
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// ============================================================================
	12	// declarations
	13	// ============================================================================
	14
	15	#ifdef __GNUG__
	16	#pragma implementation "region.h"
	17	#endif
	18
	19	// ----------------------------------------------------------------------------
	20	// headers
	21	// ----------------------------------------------------------------------------
	22
	23	#include "wx/log.h"
	24
	25	#include "wx/region.h"
	26
	27	#include "wx/gtk/private.h"
	28
	29	// ----------------------------------------------------------------------------
	30	// wxRegionRefData: private class containing the information about the region
	31	// ----------------------------------------------------------------------------
	32
	33	class wxRegionRefData : public wxObjectRefData
	34	{
	35	public:
	36	wxRegionRefData()
	37	{
	38	m_region = NULL;
	39	}
	40
	41	wxRegionRefData(const wxRegionRefData& refData)
	42	{
	43	#ifdef __WXGTK20__
	44	m_region = gdk_region_copy(refData.m_region);
	45	#else
	46	m_region = gdk_region_new();
	47	GdkRegion *regCopy = gdk_regions_union(m_region, refData.m_region);
	48	gdk_region_destroy(m_region);
	49	m_region = regCopy;
	50	#endif
	51	}
	52
	53	~wxRegionRefData()
	54	{
	55	if (m_region)
	56	gdk_region_destroy( m_region );
	57	}
	58
	59	GdkRegion *m_region;
	60	};
	61
	62	// ----------------------------------------------------------------------------
	63	// macros
	64	// ----------------------------------------------------------------------------
	65
	66	#define M_REGIONDATA ((wxRegionRefData *)m_refData)
	67	#define M_REGIONDATA_OF(rgn) ((wxRegionRefData *)(rgn.m_refData))
	68
	69	IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject);
	70	IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator,wxObject);
	71
	72	// ----------------------------------------------------------------------------
	73	// wxRegion construction
	74	// ----------------------------------------------------------------------------
	75
	76	#define M_REGIONDATA ((wxRegionRefData *)m_refData)
	77
	78	void wxRegion::InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	79	{
	80	GdkRectangle rect;
	81	rect.x = x;
	82	rect.y = y;
	83	rect.width = w;
	84	rect.height = h;
	85
	86	m_refData = new wxRegionRefData();
	87
	88	#ifdef __WXGTK20__
	89	M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
	90	#else
	91	GdkRegion *reg = gdk_region_new();
	92	M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
	93	gdk_region_destroy( reg );
	94	#endif
	95	}
	96
	97	wxRegion::wxRegion( size_t n, const wxPoint *points, int fillStyle )
	98	{
	99	GdkPoint *gdkpoints = new GdkPoint[n];
	100	for ( size_t i = 0 ; i < n ; i++ )
	101	{
	102	gdkpoints[i].x = points[i].x;
	103	gdkpoints[i].y = points[i].y;
	104	}
	105
	106	m_refData = new wxRegionRefData();
	107
	108	GdkRegion* reg = gdk_region_polygon
	109	(
	110	gdkpoints,
	111	n,
	112	fillStyle == wxWINDING_RULE ? GDK_WINDING_RULE
	113	: GDK_EVEN_ODD_RULE
	114	);
	115
	116	M_REGIONDATA->m_region = reg;
	117
	118	delete [] gdkpoints;
	119	}
	120
	121	wxRegion::~wxRegion()
	122	{
	123	// m_refData unrefed in ~wxObject
	124	}
	125
	126	wxObjectRefData *wxRegion::CreateRefData() const
	127	{
	128	return new wxRegionRefData;
	129	}
	130
	131	wxObjectRefData wxRegion::CloneRefData(const wxObjectRefData data) const
	132	{
	133	return new wxRegionRefData((wxRegionRefData )data);
	134	}
	135
	136	// ----------------------------------------------------------------------------
	137	// wxRegion comparison
	138	// ----------------------------------------------------------------------------
	139
	140	bool wxRegion::operator==( const wxRegion& region )
	141	{
	142	if (m_refData == region.m_refData) return TRUE;
	143
	144	if (!m_refData \|\| !region.m_refData) return FALSE;
	145
	146	// compare the regions themselves, not the pointers to ref data!
	147	return gdk_region_equal(M_REGIONDATA->m_region,
	148	M_REGIONDATA_OF(region)->m_region);
	149	}
	150
	151	// ----------------------------------------------------------------------------
	152	// wxRegion operations
	153	// ----------------------------------------------------------------------------
	154
	155	void wxRegion::Clear()
	156	{
	157	UnRef();
	158	}
	159
	160	bool wxRegion::Union( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	161	{
	162	GdkRectangle rect;
	163	rect.x = x;
	164	rect.y = y;
	165	rect.width = width;
	166	rect.height = height;
	167
	168	if (!m_refData)
	169	{
	170	m_refData = new wxRegionRefData();
	171	#ifdef __WXGTK20__
	172	M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
	173	#else
	174	GdkRegion *reg = gdk_region_new();
	175	M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
	176	gdk_region_destroy( reg );
	177	#endif
	178	}
	179	else
	180	{
	181	AllocExclusive();
	182
	183	#ifdef __WXGTK20__
	184	gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
	185	#else
	186	GdkRegion *reg = gdk_region_union_with_rect( M_REGIONDATA->m_region, &rect );
	187	gdk_region_destroy( M_REGIONDATA->m_region );
	188	M_REGIONDATA->m_region = reg;
	189	#endif
	190	}
	191
	192	return TRUE;
	193	}
	194
	195	bool wxRegion::Union( const wxRect& rect )
	196	{
	197	return Union( rect.x, rect.y, rect.width, rect.height );
	198	}
	199
	200	bool wxRegion::Union( const wxRegion& region )
	201	{
	202	if (region.IsNull())
	203	return FALSE;
	204
	205	if (!m_refData)
	206	{
	207	m_refData = new wxRegionRefData();
	208	M_REGIONDATA->m_region = gdk_region_new();
	209	}
	210	else
	211	{
	212	AllocExclusive();
	213	}
	214
	215	#ifdef __WXGTK20__
	216	gdk_region_union( M_REGIONDATA->m_region, region.GetRegion() );
	217	#else
	218	GdkRegion *reg = gdk_regions_union( M_REGIONDATA->m_region, region.GetRegion() );
	219	gdk_region_destroy( M_REGIONDATA->m_region );
	220	M_REGIONDATA->m_region = reg;
	221	#endif
	222
	223	return TRUE;
	224	}
	225
	226	bool wxRegion::Intersect( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	227	{
	228	wxRegion reg( x, y, width, height );
	229
	230	return Intersect( reg );
	231	}
	232
	233	bool wxRegion::Intersect( const wxRect& rect )
	234	{
	235	wxRegion reg( rect );
	236
	237	return Intersect( reg );
	238	}
	239
	240	bool wxRegion::Intersect( const wxRegion& region )
	241	{
	242	if (region.IsNull())
	243	return FALSE;
	244
	245	if (!m_refData)
	246	{
	247	m_refData = new wxRegionRefData();
	248	M_REGIONDATA->m_region = gdk_region_new();
	249
	250	// leave here
	251	return TRUE;
	252	}
	253	else
	254	{
	255	AllocExclusive();
	256	}
	257
	258	#ifdef __WXGTK20__
	259	gdk_region_intersect( M_REGIONDATA->m_region, region.GetRegion() );
	260	#else
	261	GdkRegion *reg = gdk_regions_intersect( M_REGIONDATA->m_region, region.GetRegion() );
	262	gdk_region_destroy( M_REGIONDATA->m_region );
	263	M_REGIONDATA->m_region = reg;
	264	#endif
	265
	266	return TRUE;
	267	}
	268
	269	bool wxRegion::Subtract( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	270	{
	271	wxRegion reg( x, y, width, height );
	272	return Subtract( reg );
	273	}
	274
	275	bool wxRegion::Subtract( const wxRect& rect )
	276	{
	277	wxRegion reg( rect );
	278	return Subtract( reg );
	279	}
	280
	281	bool wxRegion::Subtract( const wxRegion& region )
	282	{
	283	if (region.IsNull())
	284	return FALSE;
	285
	286	if (!m_refData)
	287	{
	288	m_refData = new wxRegionRefData();
	289	M_REGIONDATA->m_region = gdk_region_new();
	290	}
	291	else
	292	{
	293	AllocExclusive();
	294	}
	295
	296	#ifdef __WXGTK20__
	297	gdk_region_subtract( M_REGIONDATA->m_region, region.GetRegion() );
	298	#else
	299	GdkRegion *reg = gdk_regions_subtract( M_REGIONDATA->m_region, region.GetRegion() );
	300	gdk_region_destroy( M_REGIONDATA->m_region );
	301	M_REGIONDATA->m_region = reg;
	302	#endif
	303
	304	return TRUE;
	305	}
	306
	307	bool wxRegion::Xor( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	308	{
	309	wxRegion reg( x, y, width, height );
	310	return Xor( reg );
	311	}
	312
	313	bool wxRegion::Xor( const wxRect& rect )
	314	{
	315	wxRegion reg( rect );
	316	return Xor( reg );
	317	}
	318
	319	bool wxRegion::Xor( const wxRegion& region )
	320	{
	321	if (region.IsNull())
	322	return FALSE;
	323
	324	if (!m_refData)
	325	{
	326	m_refData = new wxRegionRefData();
	327	M_REGIONDATA->m_region = gdk_region_new();
	328	}
	329	else
	330	{
	331	AllocExclusive();
	332	}
	333
	334	#ifdef __WXGTK20__
	335	gdk_region_xor( M_REGIONDATA->m_region, region.GetRegion() );
	336	#else
	337	GdkRegion *reg = gdk_regions_xor( M_REGIONDATA->m_region, region.GetRegion() );
	338	gdk_region_destroy( M_REGIONDATA->m_region );
	339	M_REGIONDATA->m_region = reg;
	340	#endif
	341
	342	return TRUE;
	343	}
	344
	345	// ----------------------------------------------------------------------------
	346	// wxRegion tests
	347	// ----------------------------------------------------------------------------
	348
	349	void wxRegion::GetBox( wxCoord &x, wxCoord &y, wxCoord &w, wxCoord &h ) const
	350	{
	351	if ( m_refData )
	352	{
	353	GdkRectangle rect;
	354	gdk_region_get_clipbox( M_REGIONDATA->m_region, &rect );
	355	x = rect.x;
	356	y = rect.y;
	357	w = rect.width;
	358	h = rect.height;
	359	}
	360	else
	361	{
	362	x = 0;
	363	y = 0;
	364	w = -1;
	365	h = -1;
	366	}
	367	}
	368
	369	wxRect wxRegion::GetBox() const
	370	{
	371	wxCoord x, y, w, h;
	372	GetBox( x, y, w, h );
	373	return wxRect( x, y, w, h );
	374	}
	375
	376	bool wxRegion::Offset( wxCoord x, wxCoord y )
	377	{
	378	if (!m_refData)
	379	return FALSE;
	380
	381	AllocExclusive();
	382
	383	gdk_region_offset( M_REGIONDATA->m_region, x, y );
	384
	385	return TRUE;
	386	}
	387
	388	bool wxRegion::Empty() const
	389	{
	390	if (!m_refData)
	391	return TRUE;
	392
	393	return gdk_region_empty( M_REGIONDATA->m_region );
	394	}
	395
	396	wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y ) const
	397	{
	398	if (!m_refData)
	399	return wxOutRegion;
	400
	401	if (gdk_region_point_in( M_REGIONDATA->m_region, x, y ))
	402	return wxInRegion;
	403	else
	404	return wxOutRegion;
	405	}
	406
	407	wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) const
	408	{
	409	if (!m_refData)
	410	return wxOutRegion;
	411
	412	GdkRectangle rect;
	413	rect.x = x;
	414	rect.y = y;
	415	rect.width = w;
	416	rect.height = h;
	417	GdkOverlapType res = gdk_region_rect_in( M_REGIONDATA->m_region, &rect );
	418	switch (res)
	419	{
	420	case GDK_OVERLAP_RECTANGLE_IN: return wxInRegion;
	421	case GDK_OVERLAP_RECTANGLE_OUT: return wxOutRegion;
	422	case GDK_OVERLAP_RECTANGLE_PART: return wxPartRegion;
	423	}
	424	return wxOutRegion;
	425	}
	426
	427	wxRegionContain wxRegion::Contains(const wxPoint& pt) const
	428	{
	429	return Contains( pt.x, pt.y );
	430	}
	431
	432	wxRegionContain wxRegion::Contains(const wxRect& rect) const
	433	{
	434	return Contains( rect.x, rect.y, rect.width, rect.height );
	435	}
	436
	437	GdkRegion *wxRegion::GetRegion() const
	438	{
	439	if (!m_refData)
	440	return (GdkRegion*) NULL;
	441
	442	return M_REGIONDATA->m_region;
	443	}
	444
	445	// ----------------------------------------------------------------------------
	446	// wxRegionIterator
	447	// ----------------------------------------------------------------------------
	448
	449	#ifndef __WXGTK20__
	450
	451	// the following structures must match the private structures
	452	// in X11 region code ( xc/lib/X11/region.h )
	453
	454	// this makes the Region type transparent
	455	// and we have access to the region rectangles
	456
	457	#include <gdk/gdkprivate.h>
	458
	459	struct _XBox {
	460	short x1, x2, y1, y2;
	461	};
	462
	463	struct _XRegion {
	464	long size , numRects;
	465	_XBox *rects, extents;
	466	};
	467
	468	#endif
	469
	470	class wxRIRefData: public wxObjectRefData
	471	{
	472	public:
	473
	474	wxRIRefData() : m_rects(0), m_numRects(0){}
	475	~wxRIRefData();
	476
	477	wxRect *m_rects;
	478	size_t m_numRects;
	479
	480	void CreateRects( const wxRegion& r );
	481	};
	482
	483	wxRIRefData::~wxRIRefData()
	484	{
	485	delete m_rects;
	486	}
	487
	488	void wxRIRefData::CreateRects( const wxRegion& region )
	489	{
	490	if (m_rects)
	491	delete m_rects;
	492
	493	m_rects = 0;
	494	m_numRects = 0;
	495
	496	GdkRegion *gdkregion = region.GetRegion();
	497	if (!gdkregion) return;
	498
	499	#ifdef __WXGTK20__
	500	GdkRectangle *gdkrects = NULL;
	501	gint numRects = 0;
	502	gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects );
	503
	504	m_numRects = numRects;
	505	if (numRects)
	506	{
	507	m_rects = new wxRect[m_numRects];
	508	for (size_t i=0; i < m_numRects; ++i)
	509	{
	510	GdkRectangle &gr = gdkrects[i];
	511	wxRect &wr = m_rects[i];
	512	wr.x = gr.x;
	513	wr.y = gr.y;
	514	wr.width = gr.width;
	515	wr.height = gr.height;
	516	}
	517	}
	518	g_free( gdkrects );
	519	#else // GTK+ 1.x
	520	Region r = ((GdkRegionPrivate *)gdkregion)->xregion;
	521	if (r)
	522	{
	523	m_numRects = r->numRects;
	524	if (m_numRects)
	525	{
	526	m_rects = new wxRect[m_numRects];
	527	for (size_t i=0; i < m_numRects; ++i)
	528	{
	529	_XBox &xr = r->rects[i];
	530	wxRect &wr = m_rects[i];
	531	wr.x = xr.x1;
	532	wr.y = xr.y1;
	533	wr.width = xr.x2-xr.x1;
	534	wr.height = xr.y2-xr.y1;
	535	}
	536	}
	537	}
	538	#endif // GTK+ 2.0/1.x
	539	}
	540
	541	wxRegionIterator::wxRegionIterator()
	542	{
	543	m_refData = new wxRIRefData();
	544	Reset();
	545	}
	546
	547	wxRegionIterator::wxRegionIterator( const wxRegion& region )
	548	{
	549	m_refData = new wxRIRefData();
	550	Reset(region);
	551	}
	552
	553	void wxRegionIterator::Reset( const wxRegion& region )
	554	{
	555	m_region = region;
	556	((wxRIRefData*)m_refData)->CreateRects(region);
	557	Reset();
	558	}
	559
	560	bool wxRegionIterator::HaveRects() const
	561	{
	562	return m_current < ((wxRIRefData*)m_refData)->m_numRects;
	563	}
	564
	565	wxRegionIterator::operator bool () const
	566	{
	567	return HaveRects();
	568	}
	569
	570	void wxRegionIterator::operator ++ ()
	571	{
	572	if (HaveRects()) ++m_current;
	573	}
	574
	575	void wxRegionIterator::operator ++ (int)
	576	{
	577	if (HaveRects()) ++m_current;
	578	}
	579
	580	wxCoord wxRegionIterator::GetX() const
	581	{
	582	if( !HaveRects() ) return 0;
	583	return ((wxRIRefData*)m_refData)->m_rects[m_current].x;
	584	}
	585
	586	wxCoord wxRegionIterator::GetY() const
	587	{
	588	if( !HaveRects() ) return 0;
	589	return ((wxRIRefData*)m_refData)->m_rects[m_current].y;
	590	}
	591
	592	wxCoord wxRegionIterator::GetW() const
	593	{
	594	if( !HaveRects() ) return -1;
	595	return ((wxRIRefData*)m_refData)->m_rects[m_current].width;
	596	}
	597
	598	wxCoord wxRegionIterator::GetH() const
	599	{
	600	if( !HaveRects() ) return -1;
	601	return ((wxRIRefData*)m_refData)->m_rects[m_current].height;
	602	}
	603
	604	wxRect wxRegionIterator::GetRect() const
	605	{
	606	wxRect r;
	607	if( HaveRects() )
	608	r = ((wxRIRefData*)m_refData)->m_rects[m_current];
	609
	610	return r;
	611	}
	612