[wxWidgets.git] / include / wx / region.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/region.h
// Purpose:     Base header for wxRegion
// Author:      Julian Smart
// Modified by:
// Created:
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_REGION_H_BASE_
#define _WX_REGION_H_BASE_

#include "wx/gdiobj.h"
#include "wx/gdicmn.h"

class WXDLLIMPEXP_CORE wxBitmap;
class WXDLLEXPORT wxColour;
class WXDLLEXPORT wxRegion;

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// result of wxRegion::Contains() call
enum wxRegionContain
{
    wxOutRegion = 0,
    wxPartRegion = 1,
    wxInRegion = 2
};

// these constants are used with wxRegion::Combine() in the ports which have
// this method
enum wxRegionOp
{
    // Creates the intersection of the two combined regions.
    wxRGN_AND,

    // Creates a copy of the region
    wxRGN_COPY,

    // Combines the parts of first region that are not in the second one
    wxRGN_DIFF,

    // Creates the union of two combined regions.
    wxRGN_OR,

    // Creates the union of two regions except for any overlapping areas.
    wxRGN_XOR
};

// ----------------------------------------------------------------------------
// wxRegionBase defines wxRegion API
// ----------------------------------------------------------------------------

class WXDLLEXPORT wxRegionBase : public wxGDIObject
{
public:
    // ctors
    // -----

    // none are defined here but the following should be available:
#if 0
    wxRegion();
    wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
    wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
    wxRegion(const wxRect& rect);
    wxRegion(size_t n, const wxPoint *points, int fillStyle = wxODDEVEN_RULE);
    wxRegion(const wxBitmap& bmp);
    wxRegion(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
#endif // 0

    // operators
    // ---------

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


    // accessors
    // ---------

    bool Ok() const { return IsOk(); }
    bool IsOk() const { return m_refData != NULL; }

    // Is region empty?
    virtual bool IsEmpty() const = 0;
    bool Empty() const { return IsEmpty(); }

    // Is region equal (i.e. covers the same area as another one)?
    bool IsEqual(const wxRegion& region) const;

    // Get the bounding box
    bool GetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
        { return DoGetBox(x, y, w, h); }
    wxRect GetBox() const
    {
        wxCoord x, y, w, h;
        return DoGetBox(x, y, w, h) ? wxRect(x, y, w, h) : wxRect();
    }

    // Test if the given point or rectangle is inside this region
    wxRegionContain Contains(wxCoord x, wxCoord y) const
        { return DoContainsPoint(x, y); }
    wxRegionContain Contains(const wxPoint& pt) const
        { return DoContainsPoint(pt.x, pt.y); }
    wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const
        { return DoContainsRect(wxRect(x, y, w, h)); }
    wxRegionContain Contains(const wxRect& rect) const
        { return DoContainsRect(rect); }


    // operations
    // ----------

    virtual void Clear() = 0;

    // Move the region
    bool Offset(wxCoord x, wxCoord y)
        { return DoOffset(x, y); }
    bool Offset(const wxPoint& pt)
        { return DoOffset(pt.x, pt.y); }

    // Union rectangle or region with this region.
    bool Union(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
        { return DoUnionWithRect(wxRect(x, y, w, h)); }
    bool Union(const wxRect& rect)
        { return DoUnionWithRect(rect); }
    bool Union(const wxRegion& region)
        { return DoUnionWithRegion(region); }

#if wxUSE_IMAGE
    // Use the non-transparent pixels of a wxBitmap for the region to combine
    // with this region.  First version takes transparency from bitmap's mask,
    // second lets the user specify the colour to be treated as transparent
    // along with an optional tolerance value.
    // NOTE: implemented in common/rgncmn.cpp
    bool Union(const wxBitmap& bmp);
    bool Union(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
#endif // wxUSE_IMAGE

    // Intersect rectangle or region with this one.
    bool Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
    bool Intersect(const wxRect& rect);
    bool Intersect(const wxRegion& region)
        { return DoIntersect(region); }

    // Subtract rectangle or region from this:
    // Combines the parts of 'this' that are not part of the second region.
    bool Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
    bool Subtract(const wxRect& rect);
    bool Subtract(const wxRegion& region)
        { return DoSubtract(region); }

    // XOR: the union of two combined regions except for any overlapping areas.
    bool Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
    bool Xor(const wxRect& rect);
    bool Xor(const wxRegion& region)
        { return DoXor(region); }


    // Convert the region to a B&W bitmap with the white pixels being inside
    // the region.
    wxBitmap ConvertToBitmap() const;

protected:
    virtual bool DoIsEqual(const wxRegion& region) const = 0;
    virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const = 0;
    virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const = 0;
    virtual wxRegionContain DoContainsRect(const wxRect& rect) const = 0;

    virtual bool DoOffset(wxCoord x, wxCoord y) = 0;

    virtual bool DoUnionWithRect(const wxRect& rect) = 0;
    virtual bool DoUnionWithRegion(const wxRegion& region) = 0;

    virtual bool DoIntersect(const wxRegion& region) = 0;
    virtual bool DoSubtract(const wxRegion& region) = 0;
    virtual bool DoXor(const wxRegion& region) = 0;
};

// some ports implement a generic Combine() function while others only
// implement individual wxRegion operations, factor out the common code for the
// ports with Combine() in this class
#if defined(__WXPALMOS__) || \
    defined(__WXMSW__) || \
    defined(__WXMAC__) || \
    defined(__WXPM__)

#define wxHAS_REGION_COMBINE

class WXDLLEXPORT wxRegionWithCombine : public wxRegionBase
{
public:
    // these methods are not part of public API as they're not implemented on
    // all ports
    bool Combine(wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxRegionOp op);
    bool Combine(const wxRect& rect, wxRegionOp op);
    bool Combine(const wxRegion& region, wxRegionOp op)
        { return DoCombine(region, op); }


protected:
    // the real Combine() method, to be defined in the derived class
    virtual bool DoCombine(const wxRegion& region, wxRegionOp op) = 0;

    // implement some wxRegionBase pure virtuals in terms of Combine()
    virtual bool DoUnionWithRect(const wxRect& rect);
    virtual bool DoUnionWithRegion(const wxRegion& region);
    virtual bool DoIntersect(const wxRegion& region);
    virtual bool DoSubtract(const wxRegion& region);
    virtual bool DoXor(const wxRegion& region);
};

#endif // ports with wxRegion::Combine()

#if defined(__WXPALMOS__)
    #include "wx/palmos/region.h"
#elif defined(__WXMSW__)
    #include "wx/msw/region.h"
#elif defined(__WXGTK20__)
    #include "wx/gtk/region.h"
#elif defined(__WXGTK__)
    #include "wx/gtk1/region.h"
#elif defined(__WXMOTIF__) || defined(__WXX11__)
    #include "wx/x11/region.h"
#elif defined(__WXMGL__)
    #include "wx/mgl/region.h"
#elif defined(__WXDFB__)
    #include "wx/dfb/region.h"
#elif defined(__WXMAC__)
    #include "wx/mac/region.h"
#elif defined(__WXCOCOA__)
    #include "wx/cocoa/region.h"
#elif defined(__WXPM__)
    #include "wx/os2/region.h"
#endif

// ----------------------------------------------------------------------------
// inline functions implementation
// ----------------------------------------------------------------------------

// NB: these functions couldn't be defined in the class declaration as they use
//     wxRegion and so can be only defined after including the header declaring
//     the real class

inline bool wxRegionBase::Intersect(const wxRect& rect)
{
    return DoIntersect(wxRegion(rect));
}

inline bool wxRegionBase::Subtract(const wxRect& rect)
{
    return DoSubtract(wxRegion(rect));
}

inline bool wxRegionBase::Xor(const wxRect& rect)
{
    return DoXor(wxRegion(rect));
}

// ...and these functions are here because they call the ones above, and its
// not really proper to call an inline function before its defined inline.

inline bool wxRegionBase::Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
    return Intersect(wxRect(x, y, w, h));
}

inline bool wxRegionBase::Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
    return Subtract(wxRect(x, y, w, h));
}

inline bool wxRegionBase::Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
    return Xor(wxRect(x, y, w, h));
}

#ifdef wxHAS_REGION_COMBINE

inline bool wxRegionWithCombine::Combine(wxCoord x,
                                         wxCoord y,
                                         wxCoord w,
                                         wxCoord h,
                                         wxRegionOp op)
{
    return DoCombine(wxRegion(x, y, w, h), op);
}

inline bool wxRegionWithCombine::Combine(const wxRect& rect, wxRegionOp op)
{
    return DoCombine(wxRegion(rect), op);
}

#endif // wxHAS_REGION_COMBINE

#endif // _WX_REGION_H_BASE_
Commit	Line	Data
99d80019 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/region.h
	3	// Purpose: Base header for wxRegion
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created:
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows Licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
34138703 JS	12	#ifndef _WX_REGION_H_BASE_
34138703 JS	13	#define _WX_REGION_H_BASE_
c801d85f	14
8a16d737 VZ	15	#include "wx/gdiobj.h"
8a16d737 VZ	16	#include "wx/gdicmn.h"
c87beb79	17
c16b9bfe	18	class WXDLLIMPEXP_CORE wxBitmap;
8a16d737 VZ	19	class WXDLLEXPORT wxColour;
	20	class WXDLLEXPORT wxRegion;
	21
	22	// ----------------------------------------------------------------------------
	23	// constants
	24	// ----------------------------------------------------------------------------
	25
	26	// result of wxRegion::Contains() call
be2001fe VS	27	enum wxRegionContain
	28	{
	29	wxOutRegion = 0,
	30	wxPartRegion = 1,
	31	wxInRegion = 2
	32	};
	33
8a16d737 VZ	34	// these constants are used with wxRegion::Combine() in the ports which have
	35	// this method
	36	enum wxRegionOp
	37	{
	38	// Creates the intersection of the two combined regions.
	39	wxRGN_AND,
	40
	41	// Creates a copy of the region
	42	wxRGN_COPY,
	43
	44	// Combines the parts of first region that are not in the second one
	45	wxRGN_DIFF,
	46
	47	// Creates the union of two combined regions.
	48	wxRGN_OR,
	49
	50	// Creates the union of two regions except for any overlapping areas.
	51	wxRGN_XOR
	52	};
	53
	54	// ----------------------------------------------------------------------------
	55	// wxRegionBase defines wxRegion API
	56	// ----------------------------------------------------------------------------
	57
	58	class WXDLLEXPORT wxRegionBase : public wxGDIObject
	59	{
	60	public:
	61	// ctors
	62	// -----
	63
	64	// none are defined here but the following should be available:
	65	#if 0
	66	wxRegion();
	67	wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
	68	wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
	69	wxRegion(const wxRect& rect);
	70	wxRegion(size_t n, const wxPoint *points, int fillStyle = wxODDEVEN_RULE);
	71	wxRegion(const wxBitmap& bmp);
	72	wxRegion(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
	73	#endif // 0
	74
	75	// operators
	76	// ---------
	77
	78	bool operator==(const wxRegion& region) const { return IsEqual(region); }
	79	bool operator!=(const wxRegion& region) const { return !(*this == region); }
	80
	81
	82	// accessors
	83	// ---------
	84
b7cacb43 VZ	85	bool Ok() const { return IsOk(); }
b7cacb43 VZ	86	bool IsOk() const { return m_refData != NULL; }
8a16d737 VZ	87
	88	// Is region empty?
	89	virtual bool IsEmpty() const = 0;
	90	bool Empty() const { return IsEmpty(); }
	91
	92	// Is region equal (i.e. covers the same area as another one)?
	93	bool IsEqual(const wxRegion& region) const;
	94
	95	// Get the bounding box
	96	bool GetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
	97	{ return DoGetBox(x, y, w, h); }
	98	wxRect GetBox() const
	99	{
	100	wxCoord x, y, w, h;
	101	return DoGetBox(x, y, w, h) ? wxRect(x, y, w, h) : wxRect();
	102	}
	103
	104	// Test if the given point or rectangle is inside this region
	105	wxRegionContain Contains(wxCoord x, wxCoord y) const
	106	{ return DoContainsPoint(x, y); }
	107	wxRegionContain Contains(const wxPoint& pt) const
	108	{ return DoContainsPoint(pt.x, pt.y); }
	109	wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const
	110	{ return DoContainsRect(wxRect(x, y, w, h)); }
	111	wxRegionContain Contains(const wxRect& rect) const
	112	{ return DoContainsRect(rect); }
	113
	114
	115	// operations
	116	// ----------
	117
	118	virtual void Clear() = 0;
	119
	120	// Move the region
	121	bool Offset(wxCoord x, wxCoord y)
	122	{ return DoOffset(x, y); }
	123	bool Offset(const wxPoint& pt)
	124	{ return DoOffset(pt.x, pt.y); }
	125
	126	// Union rectangle or region with this region.
	127	bool Union(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	128	{ return DoUnionWithRect(wxRect(x, y, w, h)); }
	129	bool Union(const wxRect& rect)
	130	{ return DoUnionWithRect(rect); }
	131	bool Union(const wxRegion& region)
	132	{ return DoUnionWithRegion(region); }
	133
	134	#if wxUSE_IMAGE
	135	// Use the non-transparent pixels of a wxBitmap for the region to combine
	136	// with this region. First version takes transparency from bitmap's mask,
	137	// second lets the user specify the colour to be treated as transparent
	138	// along with an optional tolerance value.
	139	// NOTE: implemented in common/rgncmn.cpp
	140	bool Union(const wxBitmap& bmp);
	141	bool Union(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
	142	#endif // wxUSE_IMAGE
	143
	144	// Intersect rectangle or region with this one.
8e7cb70c	145	bool Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	146	bool Intersect(const wxRect& rect);
	147	bool Intersect(const wxRegion& region)
	148	{ return DoIntersect(region); }
	149
	150	// Subtract rectangle or region from this:
	151	// Combines the parts of 'this' that are not part of the second region.
8e7cb70c	152	bool Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	153	bool Subtract(const wxRect& rect);
	154	bool Subtract(const wxRegion& region)
	155	{ return DoSubtract(region); }
	156
	157	// XOR: the union of two combined regions except for any overlapping areas.
8e7cb70c	158	bool Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	159	bool Xor(const wxRect& rect);
	160	bool Xor(const wxRegion& region)
	161	{ return DoXor(region); }
	162
	163
	164	// Convert the region to a B&W bitmap with the white pixels being inside
	165	// the region.
	166	wxBitmap ConvertToBitmap() const;
	167
	168	protected:
	169	virtual bool DoIsEqual(const wxRegion& region) const = 0;
	170	virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const = 0;
	171	virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const = 0;
	172	virtual wxRegionContain DoContainsRect(const wxRect& rect) const = 0;
	173
	174	virtual bool DoOffset(wxCoord x, wxCoord y) = 0;
	175
	176	virtual bool DoUnionWithRect(const wxRect& rect) = 0;
	177	virtual bool DoUnionWithRegion(const wxRegion& region) = 0;
	178
	179	virtual bool DoIntersect(const wxRegion& region) = 0;
	180	virtual bool DoSubtract(const wxRegion& region) = 0;
	181	virtual bool DoXor(const wxRegion& region) = 0;
	182	};
	183
	184	// some ports implement a generic Combine() function while others only
	185	// implement individual wxRegion operations, factor out the common code for the
	186	// ports with Combine() in this class
	187	#if defined(__WXPALMOS__) \|\| \
	188	defined(__WXMSW__) \|\| \
	189	defined(__WXMAC__) \|\| \
	190	defined(__WXPM__)
	191
	192	#define wxHAS_REGION_COMBINE
	193
f600738e	194	class WXDLLEXPORT wxRegionWithCombine : public wxRegionBase
8a16d737 VZ	195	{
	196	public:
	197	// these methods are not part of public API as they're not implemented on
	198	// all ports
	199	bool Combine(wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxRegionOp op);
	200	bool Combine(const wxRect& rect, wxRegionOp op);
	201	bool Combine(const wxRegion& region, wxRegionOp op)
	202	{ return DoCombine(region, op); }
	203
	204
	205	protected:
	206	// the real Combine() method, to be defined in the derived class
	207	virtual bool DoCombine(const wxRegion& region, wxRegionOp op) = 0;
	208
	209	// implement some wxRegionBase pure virtuals in terms of Combine()
c16b9bfe PC	210	virtual bool DoUnionWithRect(const wxRect& rect);
	211	virtual bool DoUnionWithRegion(const wxRegion& region);
	212	virtual bool DoIntersect(const wxRegion& region);
	213	virtual bool DoSubtract(const wxRegion& region);
	214	virtual bool DoXor(const wxRegion& region);
8a16d737 VZ	215	};
	216
	217	#endif // ports with wxRegion::Combine()
	218
4055ed82	219	#if defined(__WXPALMOS__)
c87beb79	220	#include "wx/palmos/region.h"
ffecfa5a	221	#elif defined(__WXMSW__)
c87beb79	222	#include "wx/msw/region.h"
1be7a35c	223	#elif defined(__WXGTK20__)
c87beb79	224	#include "wx/gtk/region.h"
1be7a35c MR	225	#elif defined(__WXGTK__)
1be7a35c MR	226	#include "wx/gtk1/region.h"
c87beb79 VZ	227	#elif defined(__WXMOTIF__) \|\| defined(__WXX11__)
c87beb79 VZ	228	#include "wx/x11/region.h"
d32cad2c	229	#elif defined(__WXMGL__)
c87beb79	230	#include "wx/mgl/region.h"
b3c86150 VS	231	#elif defined(__WXDFB__)
b3c86150 VS	232	#include "wx/dfb/region.h"
34138703	233	#elif defined(__WXMAC__)
c87beb79	234	#include "wx/mac/region.h"
e64df9bc	235	#elif defined(__WXCOCOA__)
c87beb79	236	#include "wx/cocoa/region.h"
1777b9bb	237	#elif defined(__WXPM__)
c87beb79	238	#include "wx/os2/region.h"
c801d85f KB	239	#endif
c801d85f KB	240
8a16d737 VZ	241	// ----------------------------------------------------------------------------
	242	// inline functions implementation
	243	// ----------------------------------------------------------------------------
	244
	245	// NB: these functions couldn't be defined in the class declaration as they use
	246	// wxRegion and so can be only defined after including the header declaring
	247	// the real class
	248
	249	inline bool wxRegionBase::Intersect(const wxRect& rect)
	250	{
	251	return DoIntersect(wxRegion(rect));
	252	}
	253
	254	inline bool wxRegionBase::Subtract(const wxRect& rect)
	255	{
	256	return DoSubtract(wxRegion(rect));
	257	}
	258
	259	inline bool wxRegionBase::Xor(const wxRect& rect)
	260	{
	261	return DoXor(wxRegion(rect));
	262	}
	263
8e7cb70c PC	264	// ...and these functions are here because they call the ones above, and its
	265	// not really proper to call an inline function before its defined inline.
	266
	267	inline bool wxRegionBase::Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	268	{
	269	return Intersect(wxRect(x, y, w, h));
	270	}
	271
	272	inline bool wxRegionBase::Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	273	{
	274	return Subtract(wxRect(x, y, w, h));
	275	}
	276
	277	inline bool wxRegionBase::Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	278	{
	279	return Xor(wxRect(x, y, w, h));
	280	}
	281
8a16d737 VZ	282	#ifdef wxHAS_REGION_COMBINE
	283
	284	inline bool wxRegionWithCombine::Combine(wxCoord x,
	285	wxCoord y,
	286	wxCoord w,
	287	wxCoord h,
	288	wxRegionOp op)
	289	{
	290	return DoCombine(wxRegion(x, y, w, h), op);
	291	}
	292
	293	inline bool wxRegionWithCombine::Combine(const wxRect& rect, wxRegionOp op)
	294	{
	295	return DoCombine(wxRegion(rect), op);
	296	}
	297
	298	#endif // wxHAS_REGION_COMBINE
	299
	300	#endif // _WX_REGION_H_BASE_