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

    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;
    wxNode *node = m_region.GetRectList()->Nth( m_current );

    if (node)
        r = *((wxRect*)node->Data());

    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	wxList& list = *GetRectList();
	355	wxNode *node = list.First();
	356	while (node)
	357	{
	358	wxRect r = (wxRect)node->Data();
	359
	360	wxRegion regCopy = region;
	361	if ( regCopy.IntersectRegionOnly(*r) )
	362	{
	363	// replace the node with the intersection
	364	*r = regCopy.GetBox();
	365	}
	366	else
	367	{
	368	// TODO remove the rect from the list
	369	r->width = 0;
	370	r->height = 0;
	371	}
	372
	373	node = node->Next();
	374	}
	375
	376	return TRUE;
	377	}
	378
	379	bool wxRegion::Subtract( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	380	{
	381	wxRegion reg( x, y, width, height );
	382	return Subtract( reg );
	383	}
	384
	385	bool wxRegion::Subtract( const wxRect& rect )
	386	{
	387	wxRegion reg( rect );
	388	return Subtract( reg );
	389	}
	390
	391	bool wxRegion::Subtract( const wxRegion& region )
	392	{
	393	if (region.IsNull())
	394	return FALSE;
	395
	396	if (!m_refData)
	397	{
	398	m_refData = new wxRegionRefData();
	399	M_REGIONDATA->m_region = gdk_region_new();
	400	}
	401
	402	Unshare();
	403
	404	#ifdef __WXGTK20__
	405	gdk_region_subtract( M_REGIONDATA->m_region, region.GetRegion() );
	406	#else
	407	GdkRegion *reg = gdk_regions_subtract( M_REGIONDATA->m_region, region.GetRegion() );
	408	gdk_region_destroy( M_REGIONDATA->m_region );
	409	M_REGIONDATA->m_region = reg;
	410	#endif
	411
	412	return TRUE;
	413	}
	414
	415	bool wxRegion::Xor( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
	416	{
	417	wxRegion reg( x, y, width, height );
	418	return Xor( reg );
	419	}
	420
	421	bool wxRegion::Xor( const wxRect& rect )
	422	{
	423	wxRegion reg( rect );
	424	return Xor( reg );
	425	}
	426
	427	bool wxRegion::Xor( const wxRegion& region )
	428	{
	429	if (region.IsNull())
	430	return FALSE;
	431
	432	if (!m_refData)
	433	{
	434	m_refData = new wxRegionRefData();
	435	M_REGIONDATA->m_region = gdk_region_new();
	436	}
	437	else
	438	{
	439	Unshare();
	440	}
	441
	442	#ifdef __WXGTK20__
	443	gdk_region_xor( M_REGIONDATA->m_region, region.GetRegion() );
	444	#else
	445	GdkRegion *reg = gdk_regions_xor( M_REGIONDATA->m_region, region.GetRegion() );
	446	gdk_region_destroy( M_REGIONDATA->m_region );
	447	M_REGIONDATA->m_region = reg;
	448	#endif
	449
	450	#if OLDCODE
	451	wxNode *node = region.GetRectList()->First();
	452	while (node)
	453	{
	454	wxRect r = (wxRect)node->Data();
	455	M_REGIONDATA->m_rects.Append( (wxObject*) new wxRect(r->x,r->y,r->width,r->height) );
	456	node = node->Next();
	457	}
	458	#endif
	459
	460	return TRUE;
	461	}
	462
	463	// ----------------------------------------------------------------------------
	464	// wxRegion tests
	465	// ----------------------------------------------------------------------------
	466
	467	void wxRegion::GetBox( wxCoord &x, wxCoord &y, wxCoord &w, wxCoord &h ) const
	468	{
	469	if ( m_refData )
	470	{
	471	GdkRectangle rect;
	472	gdk_region_get_clipbox( M_REGIONDATA->m_region, &rect );
	473	x = rect.x;
	474	y = rect.y;
	475	w = rect.width;
	476	h = rect.height;
	477	}
	478	else
	479	{
	480	x = 0;
	481	y = 0;
	482	w = -1;
	483	h = -1;
	484	}
	485	}
	486
	487	wxRect wxRegion::GetBox() const
	488	{
	489	wxCoord x, y, w, h;
	490	GetBox( x, y, w, h );
	491	return wxRect( x, y, w, h );
	492	}
	493
	494	bool wxRegion::Empty() const
	495	{
	496	if (!m_refData)
	497	return TRUE;
	498
	499	return gdk_region_empty( M_REGIONDATA->m_region );
	500	}
	501
	502	wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y ) const
	503	{
	504	if (!m_refData)
	505	return wxOutRegion;
	506
	507	if (gdk_region_point_in( M_REGIONDATA->m_region, x, y ))
	508	return wxInRegion;
	509	else
	510	return wxOutRegion;
	511	}
	512
	513	wxRegionContain wxRegion::Contains( wxCoord x, wxCoord y, wxCoord w, wxCoord h ) const
	514	{
	515	if (!m_refData)
	516	return wxOutRegion;
	517
	518	GdkRectangle rect;
	519	rect.x = x;
	520	rect.y = y;
	521	rect.width = w;
	522	rect.height = h;
	523	GdkOverlapType res = gdk_region_rect_in( M_REGIONDATA->m_region, &rect );
	524	switch (res)
	525	{
	526	case GDK_OVERLAP_RECTANGLE_IN: return wxInRegion;
	527	case GDK_OVERLAP_RECTANGLE_OUT: return wxOutRegion;
	528	case GDK_OVERLAP_RECTANGLE_PART: return wxPartRegion;
	529	}
	530	return wxOutRegion;
	531	}
	532
	533	wxRegionContain wxRegion::Contains(const wxPoint& pt) const
	534	{
	535	return Contains( pt.x, pt.y );
	536	}
	537
	538	wxRegionContain wxRegion::Contains(const wxRect& rect) const
	539	{
	540	return Contains( rect.x, rect.y, rect.width, rect.height );
	541	}
	542
	543	GdkRegion *wxRegion::GetRegion() const
	544	{
	545	if (!m_refData)
	546	return (GdkRegion*) NULL;
	547
	548	return M_REGIONDATA->m_region;
	549	}
	550
	551	wxList *wxRegion::GetRectList() const
	552	{
	553	#if OLDCODE
	554	if (!m_refData)
	555	return (wxList*) NULL;
	556
	557	return &(M_REGIONDATA->m_rects);
	558	#else
	559	return (wxList*) NULL;
	560	#endif
	561	}
	562
	563	// ----------------------------------------------------------------------------
	564	// wxRegionIterator
	565	// ----------------------------------------------------------------------------
	566
	567	#if OLDCODE
	568
	569	wxRegionIterator::wxRegionIterator()
	570	{
	571	Reset();
	572	}
	573
	574	wxRegionIterator::wxRegionIterator( const wxRegion& region )
	575	{
	576	Reset(region);
	577	}
	578
	579	void wxRegionIterator::Reset( const wxRegion& region )
	580	{
	581	m_region = region;
	582	Reset();
	583	}
	584
	585	wxRegionIterator::operator bool () const
	586	{
	587	return m_region.GetRectList() && m_current < (size_t)m_region.GetRectList()->Number();
	588	}
	589
	590	bool wxRegionIterator::HaveRects() const
	591	{
	592	return m_region.GetRectList() && m_current < (size_t)m_region.GetRectList()->Number();
	593	}
	594
	595	void wxRegionIterator::operator ++ ()
	596	{
	597	if (HaveRects()) ++m_current;
	598	}
	599
	600	void wxRegionIterator::operator ++ (int)
	601	{
	602	if (HaveRects()) ++m_current;
	603	}
	604
	605	wxCoord wxRegionIterator::GetX() const
	606	{
	607	wxNode *node = m_region.GetRectList()->Nth( m_current );
	608	if (!node) return 0;
	609	wxRect r = (wxRect)node->Data();
	610	return r->x;
	611	}
	612
	613	wxCoord wxRegionIterator::GetY() const
	614	{
	615	wxNode *node = m_region.GetRectList()->Nth( m_current );
	616	if (!node) return 0;
	617	wxRect r = (wxRect)node->Data();
	618	return r->y;
	619	}
	620
	621	wxCoord wxRegionIterator::GetW() const
	622	{
	623	wxNode *node = m_region.GetRectList()->Nth( m_current );
	624	if (!node) return 0;
	625	wxRect r = (wxRect)node->Data();
	626	return r->width;
	627	}
	628
	629	wxCoord wxRegionIterator::GetH() const
	630	{
	631	wxNode *node = m_region.GetRectList()->Nth( m_current );
	632	if (!node) return 0;
	633	wxRect r = (wxRect)node->Data();
	634	return r->height;
	635	}
	636
	637	#else
	638
	639	// the following structures must match the private structures
	640	// in X11 region code ( xc/lib/X11/region.h )
	641
	642	// this makes the Region type transparent
	643	// and we have access to the region rectangles
	644
	645	struct _XBox {
	646	short x1, x2, y1, y2;
	647	};
	648
	649	struct _XRegion {
	650	long size , numRects;
	651	_XBox *rects, extents;
	652	};
	653
	654	class wxRIRefData: public wxObjectRefData
	655	{
	656	public:
	657
	658	wxRIRefData() : m_rects(0), m_numRects(0){}
	659	~wxRIRefData();
	660
	661	wxRect *m_rects;
	662	size_t m_numRects;
	663
	664	void CreateRects( const wxRegion& r );
	665	};
	666
	667	wxRIRefData::~wxRIRefData()
	668	{
	669	delete m_rects;
	670	}
	671
	672	#include <gdk/gdkprivate.h>
	673
	674	void wxRIRefData::CreateRects( const wxRegion& region )
	675	{
	676	if( m_rects )
	677	delete m_rects;
	678	m_rects = 0;
	679	m_numRects= 0;
	680	GdkRegion *gdkregion= region.GetRegion();
	681	if( gdkregion ){
	682	Region r= ((GdkRegionPrivate *)gdkregion)->xregion;
	683	if( r ){
	684	m_numRects= r->numRects;
	685	if( m_numRects )
	686	{
	687	m_rects= new wxRect[m_numRects];
	688	for( size_t i=0; i<m_numRects; ++i )
	689	{
	690	_XBox &xr= r->rects[i];
	691	wxRect&wr= m_rects[i];
	692	wr.x = xr.x1;
	693	wr.y = xr.y1;
	694	wr.width = xr.x2-xr.x1;
	695	wr.height= xr.y2-xr.y1;
	696	}
	697	}
	698	}
	699	}
	700	}
	701
	702	wxRegionIterator::wxRegionIterator()
	703	{
	704	m_refData = new wxRIRefData();
	705	Reset();
	706	}
	707
	708	wxRegionIterator::wxRegionIterator( const wxRegion& region )
	709	{
	710	m_refData = new wxRIRefData();
	711	Reset(region);
	712	}
	713
	714	void wxRegionIterator::Reset( const wxRegion& region )
	715	{
	716	m_region = region;
	717	((wxRIRefData*)m_refData)->CreateRects(region);
	718	Reset();
	719	}
	720
	721	bool wxRegionIterator::HaveRects() const
	722	{
	723	return m_current < ((wxRIRefData*)m_refData)->m_numRects;
	724	}
	725
	726	wxRegionIterator::operator bool () const
	727	{
	728	return HaveRects();
	729	}
	730
	731	void wxRegionIterator::operator ++ ()
	732	{
	733	if (HaveRects()) ++m_current;
	734	}
	735
	736	void wxRegionIterator::operator ++ (int)
	737	{
	738	if (HaveRects()) ++m_current;
	739	}
	740
	741	wxCoord wxRegionIterator::GetX() const
	742	{
	743	if( !HaveRects() ) return 0;
	744	return ((wxRIRefData*)m_refData)->m_rects[m_current].x;
	745	}
	746
	747	wxCoord wxRegionIterator::GetY() const
	748	{
	749	if( !HaveRects() ) return 0;
	750	return ((wxRIRefData*)m_refData)->m_rects[m_current].y;
	751	}
	752
	753	wxCoord wxRegionIterator::GetW() const
	754	{
	755	if( !HaveRects() ) return -1;
	756	return ((wxRIRefData*)m_refData)->m_rects[m_current].width;
	757	}
	758
	759	wxCoord wxRegionIterator::GetH() const
	760	{
	761	if( !HaveRects() ) return -1;
	762	return ((wxRIRefData*)m_refData)->m_rects[m_current].height;
	763	}
	764
	765	wxRect wxRegionIterator::GetRect() const
	766	{
	767	wxRect r;
	768	wxNode *node = m_region.GetRectList()->Nth( m_current );
	769
	770	if (node)
	771	r = ((wxRect)node->Data());
	772
	773	return r;
	774	}
	775
	776	#endif
	777