src/gtk1/region.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        gtk/region.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/region.h"

#include <gdk/gdk.h>
#include <gtk/gtk.h>

#define OLDCODE 0

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

class wxRegionRefData: public wxObjectRefData
{
public:
    wxRegionRefData();
    ~wxRegionRefData();

    GdkRegion  *m_region;
#if OLDCODE
    wxList      m_rects;
#endif
};

wxRegionRefData::wxRegionRefData()
{
    m_region = (GdkRegion *) NULL;
}

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

#if OLDCODE
    wxNode *node = m_rects.First();
    while (node)
    {
        wxRect *r = (wxRect*)node->Data();
        delete r;
        node = node->Next();
    }
#endif
}

//-----------------------------------------------------------------------------

#define M_REGIONDATA ((wxRegionRefData *)m_refData)

IMPLEMENT_DYNAMIC_CLASS(wxRegion,wxGDIObject);

wxRegion::wxRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
{
    m_refData = new wxRegionRefData();
    GdkRegion *reg = gdk_region_new();
    GdkRectangle rect;
    rect.x = x;
    rect.y = y;
    rect.width = w;
    rect.height = h;
#ifdef __WXGTK20__
    gdk_region_union_with_rect( reg, &rect );
    M_REGIONDATA->m_region = reg;
#else
    M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
    gdk_region_destroy( reg );
#endif
#if OLDCODE
    M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(x,y,w,h) );
#endif
}

wxRegion::wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight )
{
    m_refData = new wxRegionRefData();
    GdkRegion *reg = gdk_region_new();
    GdkRectangle rect;
    rect.x = topLeft.x;
    rect.y = topLeft.y;
    rect.width = bottomRight.x - rect.x;
    rect.height = bottomRight.y - rect.y;
#ifdef __WXGTK20__
    gdk_region_union_with_rect( reg, &rect );
    M_REGIONDATA->m_region = reg;
#else
    M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
    gdk_region_destroy( reg );
#endif
#if OLDCODE
    M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(topLeft,bottomRight) );
#endif
}

wxRegion::wxRegion( const wxRect& rect )
{
    m_refData = new wxRegionRefData();
    GdkRegion *reg = gdk_region_new();
    GdkRectangle g_rect;
    g_rect.x = rect.x;
    g_rect.y = rect.y;
    g_rect.width = rect.width;
    g_rect.height = rect.height;
#ifdef __WXGTK20__
    gdk_region_union_with_rect( reg, &g_rect );
    M_REGIONDATA->m_region = reg;
#else
    M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &g_rect );
    gdk_region_destroy( reg );
#endif
#if OLDCODE
    M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(rect.x,rect.y,rect.width,rect.height) );
#endif
}

wxRegion::wxRegion()
{
}

wxRegion::~wxRegion()
{
}

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

bool wxRegion::operator != ( const wxRegion& region )
{
    return m_refData != region.m_refData;
}

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();
        GdkRegion *reg = gdk_region_new();
#ifdef __WXGTK20__
        gdk_region_union_with_rect( reg, &rect );
        M_REGIONDATA->m_region = reg;
#else
        M_REGIONDATA->m_region = gdk_region_union_with_rect( reg, &rect );
        gdk_region_destroy( reg );
#endif
    }
    else
    {
#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
    }

#if OLDCODE
    M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(x,y,width,height) );
#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();
    }

#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

#if OLDCODE
    wxNode *node = region.GetRectList()->First();
    while (node)
    {
        wxRect *r = (wxRect*)node->Data();
        M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(r->x,r->y,r->width,r->height) );
        node = node->Next();
    }
#endif

    return TRUE;
}

bool wxRegion::Intersect( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( x, y, width, height );
    Intersect( reg );
    return TRUE;
}

bool wxRegion::Intersect( const wxRect& rect )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( rect );
    Intersect( reg );
    return TRUE;
}

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();
        return TRUE;
    }

#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 )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( x, y, width, height );
    Subtract( reg );
    return TRUE;
}

bool wxRegion::Subtract( const wxRect& rect )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( rect );
    Subtract( reg );
    return TRUE;
}

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();
    }

#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 )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( x, y, width, height );
    Xor( reg );
    return TRUE;
}

bool wxRegion::Xor( const wxRect& rect )
{
    if (!m_refData)
    {
        m_refData = new wxRegionRefData();
        M_REGIONDATA->m_region = gdk_region_new();
    }

    wxRegion reg( rect );
    Xor( reg );
    return TRUE;
}

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();
    }

#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

#if OLDCODE
    wxNode *node = region.GetRectList()->First();
    while (node)
    {
        wxRect *r = (wxRect*)node->Data();
        M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(r->x,r->y,r->width,r->height) );
        node = node->Next();
    }
#endif

    return TRUE;
}

void wxRegion::GetBox( wxCoord &x, wxCoord &y, wxCoord &w, wxCoord &h ) const
{
    x = 0;
    y = 0;
    w = -1;
    h = -1;
    if (!m_refData)
        return;

    GdkRectangle rect;
    gdk_region_get_clipbox( M_REGIONDATA->m_region, &rect );
    x = rect.x;
    y = rect.y;
    w = rect.width;
    h = rect.height;
}

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

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;
}

wxList *wxRegion::GetRectList() const
{
#if OLDCODE
    if (!m_refData)
        return (wxList*) NULL;

    return &(M_REGIONDATA->m_rects);
#else
    return (wxList*) NULL;
#endif
}

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

#if OLDCODE

IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator,wxObject);

wxRegionIterator::wxRegionIterator()
{
    Reset();
}

wxRegionIterator::wxRegionIterator( const wxRegion& region )
{
    Reset(region);
}

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

wxRegionIterator::operator bool () const
{
    return m_region.GetRectList() && m_current < (size_t)m_region.GetRectList()->Number();
}

bool wxRegionIterator::HaveRects() const
{
    return m_region.GetRectList() && m_current < (size_t)m_region.GetRectList()->Number();
}

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

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

wxCoord wxRegionIterator::GetX() const
{
    wxNode *node = m_region.GetRectList()->Nth( m_current );
    if (!node) return 0;
    wxRect *r = (wxRect*)node->Data();
    return r->x;
}

wxCoord wxRegionIterator::GetY() const
{
    wxNode *node = m_region.GetRectList()->Nth( m_current );
    if (!node) return 0;
    wxRect *r = (wxRect*)node->Data();
    return r->y;
}

wxCoord wxRegionIterator::GetW() const
{
    wxNode *node = m_region.GetRectList()->Nth( m_current );
    if (!node) return 0;
    wxRect *r = (wxRect*)node->Data();
    return r->width;
}

wxCoord wxRegionIterator::GetH() const
{
    wxNode *node = m_region.GetRectList()->Nth( m_current );
    if (!node) return 0;
    wxRect *r = (wxRect*)node->Data();
    return r->height;
}

#else

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

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

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

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;
}

#include <gdk/gdkprivate.h>

void wxRIRefData::CreateRects( const wxRegion& region )
{
  if( m_rects )
    delete m_rects;
  m_rects   = 0;
  m_numRects= 0;
  GdkRegion *gdkregion= region.GetRegion();
  if( gdkregion ){
    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;
        }
      }
    }
  }
}

IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator,wxObject);

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;
}

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