src/gtk/region.cpp

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

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

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

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

#include "wx/region.h"

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

// Unfortunately the new way of implementing the region iterator
// doesn't work with GTK+ 2.0 or above (can't access a Region in
// GdkPrivateRegion)
#ifdef __WXGTK20__
#define OLDCODE 1
#else
#define OLDCODE 0
#endif

#include "wx/log.h"

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

class wxRegionRefData : public wxObjectRefData
{
public:
    wxRegionRefData();
    wxRegionRefData(const wxRegionRefData& refData);
    virtual ~wxRegionRefData();

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

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

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxRegionRefData
// ----------------------------------------------------------------------------

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

wxRegionRefData::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

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

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
}

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

#define M_REGIONDATA ((wxRegionRefData *)m_refData)

wxRegion::wxRegion()
{
}

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

bool wxRegion::operator==( const wxRegion& region )
{
    // VZ: compare the regions themselves, not the pointers to ref data!
    return gdk_region_equal(M_REGIONDATA->m_region,
                            M_REGIONDATA_OF(region)->m_region);
}

bool wxRegion::operator != ( const wxRegion& region )
{
    return !(*this == region);
}

void wxRegion::Unshare()
{
    if ( !m_refData )
    {
        m_refData = new wxRegionRefData;
        M_REGIONDATA->m_region = gdk_region_new();
    }
    else if ( m_refData->GetRefCount() > 1 )
    {
        wxRegionRefData *refData = new wxRegionRefData(*M_REGIONDATA);
        UnRef();
        m_refData = refData;
    }
    //else: we're not shared
}

// ----------------------------------------------------------------------------
// 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();
        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
    {
        Unshare();

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

    Unshare();

#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 )
{
    wxRegion reg( x, y, width, height );

    return Intersect( reg );
}

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

// this helper function just computes the region intersection without updating
// the list of rectangles each region maintaints: this allows us to call it
// from Intersect() itself without going into infinite recursion as we would
// if we called Intersect() itself recursively
bool wxRegion::IntersectRegionOnly(const wxRegion& region)
{
    Unshare();

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

    if ( !IntersectRegionOnly(region) )
    {
        GetRectList()->Clear();

        return FALSE;
    }

    // we need to update the rect list as well
#if OLDCODE
    wxList& list = *GetRectList();
    wxNode *node = list.First();
    while (node)
    {
        wxRect *r = (wxRect*)node->Data();

        wxRegion regCopy = region;
        if ( regCopy.IntersectRegionOnly(*r) )
        {
            // replace the node with the intersection
            *r = regCopy.GetBox();
        }
        else
        {
            // TODO remove the rect from the list
            r->width = 0;
            r->height = 0;
        }

        node = node->Next();
    }
#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();
    }

    Unshare();

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

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

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

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

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

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