[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_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxColour;
class WXDLLIMPEXP_FWD_CORE 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 WXDLLIMPEXP_CORE 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
    // ---------

    // 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__) && wxOSX_USE_CARBON ) || \
    defined(__WXPM__)

#define wxHAS_REGION_COMBINE

class WXDLLIMPEXP_CORE 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/osx/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
b5dbe15d VS	18	class WXDLLIMPEXP_FWD_CORE wxBitmap;
	19	class WXDLLIMPEXP_FWD_CORE wxColour;
	20	class WXDLLIMPEXP_FWD_CORE wxRegion;
8a16d737 VZ	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
53a2db12	58	class WXDLLIMPEXP_CORE wxRegionBase : public wxGDIObject
8a16d737 VZ	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
8a16d737 VZ	85	// Is region empty?
	86	virtual bool IsEmpty() const = 0;
	87	bool Empty() const { return IsEmpty(); }
	88
	89	// Is region equal (i.e. covers the same area as another one)?
	90	bool IsEqual(const wxRegion& region) const;
	91
	92	// Get the bounding box
	93	bool GetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
	94	{ return DoGetBox(x, y, w, h); }
	95	wxRect GetBox() const
	96	{
	97	wxCoord x, y, w, h;
	98	return DoGetBox(x, y, w, h) ? wxRect(x, y, w, h) : wxRect();
	99	}
	100
	101	// Test if the given point or rectangle is inside this region
	102	wxRegionContain Contains(wxCoord x, wxCoord y) const
	103	{ return DoContainsPoint(x, y); }
	104	wxRegionContain Contains(const wxPoint& pt) const
	105	{ return DoContainsPoint(pt.x, pt.y); }
	106	wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const
	107	{ return DoContainsRect(wxRect(x, y, w, h)); }
	108	wxRegionContain Contains(const wxRect& rect) const
	109	{ return DoContainsRect(rect); }
	110
	111
	112	// operations
	113	// ----------
	114
	115	virtual void Clear() = 0;
	116
	117	// Move the region
	118	bool Offset(wxCoord x, wxCoord y)
	119	{ return DoOffset(x, y); }
	120	bool Offset(const wxPoint& pt)
	121	{ return DoOffset(pt.x, pt.y); }
	122
	123	// Union rectangle or region with this region.
	124	bool Union(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	125	{ return DoUnionWithRect(wxRect(x, y, w, h)); }
	126	bool Union(const wxRect& rect)
	127	{ return DoUnionWithRect(rect); }
	128	bool Union(const wxRegion& region)
	129	{ return DoUnionWithRegion(region); }
	130
	131	#if wxUSE_IMAGE
	132	// Use the non-transparent pixels of a wxBitmap for the region to combine
	133	// with this region. First version takes transparency from bitmap's mask,
	134	// second lets the user specify the colour to be treated as transparent
	135	// along with an optional tolerance value.
	136	// NOTE: implemented in common/rgncmn.cpp
	137	bool Union(const wxBitmap& bmp);
	138	bool Union(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
	139	#endif // wxUSE_IMAGE
	140
	141	// Intersect rectangle or region with this one.
8e7cb70c	142	bool Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	143	bool Intersect(const wxRect& rect);
	144	bool Intersect(const wxRegion& region)
	145	{ return DoIntersect(region); }
	146
	147	// Subtract rectangle or region from this:
	148	// Combines the parts of 'this' that are not part of the second region.
8e7cb70c	149	bool Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	150	bool Subtract(const wxRect& rect);
	151	bool Subtract(const wxRegion& region)
	152	{ return DoSubtract(region); }
	153
	154	// XOR: the union of two combined regions except for any overlapping areas.
8e7cb70c	155	bool Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
8a16d737 VZ	156	bool Xor(const wxRect& rect);
	157	bool Xor(const wxRegion& region)
	158	{ return DoXor(region); }
	159
	160
	161	// Convert the region to a B&W bitmap with the white pixels being inside
	162	// the region.
	163	wxBitmap ConvertToBitmap() const;
	164
	165	protected:
	166	virtual bool DoIsEqual(const wxRegion& region) const = 0;
	167	virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const = 0;
	168	virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const = 0;
	169	virtual wxRegionContain DoContainsRect(const wxRect& rect) const = 0;
	170
	171	virtual bool DoOffset(wxCoord x, wxCoord y) = 0;
	172
	173	virtual bool DoUnionWithRect(const wxRect& rect) = 0;
	174	virtual bool DoUnionWithRegion(const wxRegion& region) = 0;
	175
	176	virtual bool DoIntersect(const wxRegion& region) = 0;
	177	virtual bool DoSubtract(const wxRegion& region) = 0;
	178	virtual bool DoXor(const wxRegion& region) = 0;
	179	};
	180
	181	// some ports implement a generic Combine() function while others only
	182	// implement individual wxRegion operations, factor out the common code for the
	183	// ports with Combine() in this class
	184	#if defined(__WXPALMOS__) \|\| \
	185	defined(__WXMSW__) \|\| \
ac9e3f1f	186	( defined(__WXMAC__) && wxOSX_USE_CARBON ) \|\| \
8a16d737 VZ	187	defined(__WXPM__)
	188
	189	#define wxHAS_REGION_COMBINE
	190
53a2db12	191	class WXDLLIMPEXP_CORE wxRegionWithCombine : public wxRegionBase
8a16d737 VZ	192	{
	193	public:
	194	// these methods are not part of public API as they're not implemented on
	195	// all ports
	196	bool Combine(wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxRegionOp op);
	197	bool Combine(const wxRect& rect, wxRegionOp op);
	198	bool Combine(const wxRegion& region, wxRegionOp op)
	199	{ return DoCombine(region, op); }
	200
	201
	202	protected:
	203	// the real Combine() method, to be defined in the derived class
	204	virtual bool DoCombine(const wxRegion& region, wxRegionOp op) = 0;
	205
	206	// implement some wxRegionBase pure virtuals in terms of Combine()
c16b9bfe PC	207	virtual bool DoUnionWithRect(const wxRect& rect);
	208	virtual bool DoUnionWithRegion(const wxRegion& region);
	209	virtual bool DoIntersect(const wxRegion& region);
	210	virtual bool DoSubtract(const wxRegion& region);
	211	virtual bool DoXor(const wxRegion& region);
8a16d737 VZ	212	};
	213
	214	#endif // ports with wxRegion::Combine()
	215
4055ed82	216	#if defined(__WXPALMOS__)
c87beb79	217	#include "wx/palmos/region.h"
ffecfa5a	218	#elif defined(__WXMSW__)
c87beb79	219	#include "wx/msw/region.h"
1be7a35c	220	#elif defined(__WXGTK20__)
c87beb79	221	#include "wx/gtk/region.h"
1be7a35c MR	222	#elif defined(__WXGTK__)
1be7a35c MR	223	#include "wx/gtk1/region.h"
c87beb79 VZ	224	#elif defined(__WXMOTIF__) \|\| defined(__WXX11__)
c87beb79 VZ	225	#include "wx/x11/region.h"
d32cad2c	226	#elif defined(__WXMGL__)
c87beb79	227	#include "wx/mgl/region.h"
b3c86150 VS	228	#elif defined(__WXDFB__)
b3c86150 VS	229	#include "wx/dfb/region.h"
34138703	230	#elif defined(__WXMAC__)
ef0e9220	231	#include "wx/osx/region.h"
e64df9bc	232	#elif defined(__WXCOCOA__)
c87beb79	233	#include "wx/cocoa/region.h"
1777b9bb	234	#elif defined(__WXPM__)
c87beb79	235	#include "wx/os2/region.h"
c801d85f KB	236	#endif
c801d85f KB	237
8a16d737 VZ	238	// ----------------------------------------------------------------------------
	239	// inline functions implementation
	240	// ----------------------------------------------------------------------------
	241
	242	// NB: these functions couldn't be defined in the class declaration as they use
	243	// wxRegion and so can be only defined after including the header declaring
	244	// the real class
	245
	246	inline bool wxRegionBase::Intersect(const wxRect& rect)
	247	{
	248	return DoIntersect(wxRegion(rect));
	249	}
	250
	251	inline bool wxRegionBase::Subtract(const wxRect& rect)
	252	{
	253	return DoSubtract(wxRegion(rect));
	254	}
	255
	256	inline bool wxRegionBase::Xor(const wxRect& rect)
	257	{
	258	return DoXor(wxRegion(rect));
	259	}
	260
8e7cb70c PC	261	// ...and these functions are here because they call the ones above, and its
	262	// not really proper to call an inline function before its defined inline.
	263
	264	inline bool wxRegionBase::Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	265	{
	266	return Intersect(wxRect(x, y, w, h));
	267	}
	268
	269	inline bool wxRegionBase::Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	270	{
	271	return Subtract(wxRect(x, y, w, h));
	272	}
	273
	274	inline bool wxRegionBase::Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
	275	{
	276	return Xor(wxRect(x, y, w, h));
	277	}
	278
8a16d737 VZ	279	#ifdef wxHAS_REGION_COMBINE
	280
	281	inline bool wxRegionWithCombine::Combine(wxCoord x,
	282	wxCoord y,
	283	wxCoord w,
	284	wxCoord h,
	285	wxRegionOp op)
	286	{
	287	return DoCombine(wxRegion(x, y, w, h), op);
	288	}
	289
	290	inline bool wxRegionWithCombine::Combine(const wxRect& rect, wxRegionOp op)
	291	{
	292	return DoCombine(wxRegion(rect), op);
	293	}
	294
	295	#endif // wxHAS_REGION_COMBINE
	296
	297	#endif // _WX_REGION_H_BASE_