[wxWidgets.git] / interface / wx / geometry.h

/////////////////////////////////////////////////////////////////////////////
// Name:        geometry.h
// Purpose:     interface of geometry classes
// Author:      wxWidgets team
// RCS-ID:      $Id$
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////


enum wxOutCode
{
    wxInside = 0x00 ,
    wxOutLeft = 0x01 ,
    wxOutRight = 0x02 ,
    wxOutTop = 0x08 ,
    wxOutBottom = 0x04
};


class wxPoint2DInt
{
public :
    wxPoint2DInt();
    wxPoint2DInt( wxInt32 x , wxInt32 y );
    wxPoint2DInt( const wxPoint2DInt &pt );
    wxPoint2DInt( const wxPoint &pt );

    // noops for this class, just return the coords
    void GetFloor( wxInt32 *x , wxInt32 *y ) const;
    void GetRounded( wxInt32 *x , wxInt32 *y ) const;

    wxDouble GetVectorLength() const;
           wxDouble GetVectorAngle() const;
    void SetVectorLength( wxDouble length );
           void SetVectorAngle( wxDouble degrees );
           void SetPolarCoordinates( wxInt32 angle , wxInt32 length );
    // set the vector length to 1.0, preserving the angle
    void Normalize();

    wxDouble GetDistance( const wxPoint2DInt &pt ) const;
    wxDouble GetDistanceSquare( const wxPoint2DInt &pt ) const;
    wxInt32 GetDotProduct( const wxPoint2DInt &vec ) const;
    wxInt32 GetCrossProduct( const wxPoint2DInt &vec ) const;

    // the reflection of this point
    wxPoint2DInt operator-();

    wxPoint2DInt& operator=(const wxPoint2DInt& pt);
    wxPoint2DInt& operator+=(const wxPoint2DInt& pt);
    wxPoint2DInt& operator-=(const wxPoint2DInt& pt);
    wxPoint2DInt& operator*=(const wxPoint2DInt& pt);
    wxPoint2DInt& operator*=(wxDouble n);
    wxPoint2DInt& operator*=(wxInt32 n);
    wxPoint2DInt& operator/=(const wxPoint2DInt& pt);
    wxPoint2DInt& operator/=(wxDouble n);
    wxPoint2DInt& operator/=(wxInt32 n);
    operator wxPoint() const;
    bool operator==(const wxPoint2DInt& pt) const;
    bool operator!=(const wxPoint2DInt& pt) const;

    wxInt32 m_x;
    wxInt32 m_y;
};

wxPoint2DInt operator+(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
wxPoint2DInt operator-(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
wxPoint2DInt operator*(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
wxPoint2DInt operator/(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);
wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);


// wxPoint2Ds represent a point or a vector in a 2d coordinate system

class wxPoint2DDouble
{
public :
    wxPoint2DDouble();
    wxPoint2DDouble( wxDouble x , wxDouble y );
    wxPoint2DDouble( const wxPoint2DDouble &pt );
    wxPoint2DDouble( const wxPoint2DInt &pt );
    wxPoint2DDouble( const wxPoint &pt );

    // two different conversions to integers, floor and rounding
    void GetFloor( wxInt32 *x , wxInt32 *y ) const;
    void GetRounded( wxInt32 *x , wxInt32 *y ) const;

    wxDouble GetVectorLength() const;
     wxDouble GetVectorAngle() const ;
    void SetVectorLength( wxDouble length );
    void SetVectorAngle( wxDouble degrees );
    void SetPolarCoordinates( wxDouble angle , wxDouble length );
    // set the vector length to 1.0, preserving the angle
    void Normalize();

    wxDouble GetDistance( const wxPoint2DDouble &pt ) const;
    wxDouble GetDistanceSquare( const wxPoint2DDouble &pt ) const;
    wxDouble GetDotProduct( const wxPoint2DDouble &vec ) const;
    wxDouble GetCrossProduct( const wxPoint2DDouble &vec ) const;

    // the reflection of this point
    wxPoint2DDouble operator-();

    wxPoint2DDouble& operator=(const wxPoint2DDouble& pt);
    wxPoint2DDouble& operator+=(const wxPoint2DDouble& pt);
    wxPoint2DDouble& operator-=(const wxPoint2DDouble& pt);
    wxPoint2DDouble& operator*=(const wxPoint2DDouble& pt);
    wxPoint2DDouble& operator*=(wxDouble n);
    wxPoint2DDouble& operator*=(wxInt32 n);
    wxPoint2DDouble& operator/=(const wxPoint2DDouble& pt);
    wxPoint2DDouble& operator/=(wxDouble n);
    wxPoint2DDouble& operator/=(wxInt32 n);

    bool operator==(const wxPoint2DDouble& pt) const;
    bool operator!=(const wxPoint2DDouble& pt) const;

    wxDouble m_x;
    wxDouble m_y;
};

wxPoint2DDouble operator+(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
wxPoint2DDouble operator-(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
wxPoint2DDouble operator*(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
wxPoint2DDouble operator*(wxDouble n , const wxPoint2DDouble& pt);
wxPoint2DDouble operator*(wxInt32 n , const wxPoint2DDouble& pt);
wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxDouble n);
wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxInt32 n);
wxPoint2DDouble operator/(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxDouble n);
wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxInt32 n);


// wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
// top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
// left <= x < right  and top <= m_y < bottom , thus it is a half open interval.

class wxRect2DDouble
{
public:
    wxRect2DDouble();
    wxRect2DDouble(wxDouble x, wxDouble y, wxDouble w, wxDouble h);

    // single attribute accessors

    wxPoint2DDouble GetPosition();
    wxSize GetSize();

    // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
        // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately

    wxDouble GetLeft() const;
    void SetLeft( wxDouble n );
    void MoveLeftTo( wxDouble n );
    wxDouble GetTop() const;
    void SetTop( wxDouble n );
    void MoveTopTo( wxDouble n );
    wxDouble GetBottom() const;
    void SetBottom( wxDouble n );
    void MoveBottomTo( wxDouble n );
    wxDouble GetRight() const;
    void SetRight( wxDouble n );
    void MoveRightTo( wxDouble n );

    wxPoint2DDouble GetLeftTop() const;
    void SetLeftTop( const wxPoint2DDouble &pt );
    void MoveLeftTopTo( const wxPoint2DDouble &pt );
    wxPoint2DDouble GetLeftBottom() const;
    void SetLeftBottom( const wxPoint2DDouble &pt );
    void MoveLeftBottomTo( const wxPoint2DDouble &pt );
    wxPoint2DDouble GetRightTop() const;
    void SetRightTop( const wxPoint2DDouble &pt );
    void MoveRightTopTo( const wxPoint2DDouble &pt );
    wxPoint2DDouble GetRightBottom() const;
    void SetRightBottom( const wxPoint2DDouble &pt );
    void MoveRightBottomTo( const wxPoint2DDouble &pt );
    wxPoint2DDouble GetCentre() const;
    void SetCentre( const wxPoint2DDouble &pt );
    void MoveCentreTo( const wxPoint2DDouble &pt );
    wxOutCode GetOutCode( const wxPoint2DDouble &pt ) const;
    wxOutCode GetOutcode(const wxPoint2DDouble &pt) const;
    bool Contains( const wxPoint2DDouble &pt ) const;
    bool Contains( const wxRect2DDouble &rect ) const;
    bool IsEmpty() const;
    bool HaveEqualSize( const wxRect2DDouble &rect ) const;

    void Inset( wxDouble x , wxDouble y );
    void Inset( wxDouble left , wxDouble top ,wxDouble right , wxDouble bottom  );
    void Offset( const wxPoint2DDouble &pt );

    void ConstrainTo( const wxRect2DDouble &rect );

    wxPoint2DDouble Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );

    static void Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
    void Intersect( const wxRect2DDouble &otherRect );
    wxRect2DDouble CreateIntersection( const wxRect2DDouble &otherRect ) const;
    bool Intersects( const wxRect2DDouble &rect ) const;

    static void Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
    void Union( const wxRect2DDouble &otherRect );
    void Union( const wxPoint2DDouble &pt );
    wxRect2DDouble CreateUnion( const wxRect2DDouble &otherRect ) const;

    void Scale( wxDouble f );
    void Scale( wxInt32 num , wxInt32 denum );

    wxRect2DDouble& operator = (const wxRect2DDouble& rect);
    bool operator == (const wxRect2DDouble& rect) const;
    bool operator != (const wxRect2DDouble& rect) const;

    wxDouble  m_x;
    wxDouble  m_y;
    wxDouble  m_width;
    wxDouble m_height;
};


// wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
// top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
// left <= x < right  and top <= m_y < bottom , thus it is a half open interval.

class wxRect2DInt
{
public:
    wxRect2DInt();
    wxRect2DInt( const wxRect& r );
    wxRect2DInt(wxInt32 x, wxInt32 y, wxInt32 w, wxInt32 h);
    wxRect2DInt(const wxPoint2DInt& topLeft, const wxPoint2DInt& bottomRight);
    wxRect2DInt(const wxPoint2DInt& pos, const wxSize& size);
    wxRect2DInt(const wxRect2DInt& rect);

        // single attribute accessors

    wxPoint2DInt GetPosition();
    wxSize GetSize();

        // for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
        // position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately

    wxInt32 GetLeft() const;
    void SetLeft( wxInt32 n );
    void MoveLeftTo( wxInt32 n );
    wxInt32 GetTop() const;
    void SetTop( wxInt32 n );
    void MoveTopTo( wxInt32 n );
    wxInt32 GetBottom() const;
    void SetBottom( wxInt32 n );
    void MoveBottomTo( wxInt32 n );
    wxInt32 GetRight() const;
    void SetRight( wxInt32 n );
    void MoveRightTo( wxInt32 n );

    wxPoint2DInt GetLeftTop() const;
    void SetLeftTop( const wxPoint2DInt &pt ) ;
    void MoveLeftTopTo( const wxPoint2DInt &pt ) ;
    wxPoint2DInt GetLeftBottom() const ;
    void SetLeftBottom( const wxPoint2DInt &pt ) ;
    void MoveLeftBottomTo( const wxPoint2DInt &pt ) ;
    wxPoint2DInt GetRightTop() const ;
    void SetRightTop( const wxPoint2DInt &pt ) ;
    void MoveRightTopTo( const wxPoint2DInt &pt ) ;
    wxPoint2DInt GetRightBottom() const ;
    void SetRightBottom( const wxPoint2DInt &pt ) ;
    void MoveRightBottomTo( const wxPoint2DInt &pt ) ;
    wxPoint2DInt GetCentre() const ;
    void SetCentre( const wxPoint2DInt &pt ) ;
    void MoveCentreTo( const wxPoint2DInt &pt ) ;
    wxOutCode GetOutCode( const wxPoint2DInt &pt ) const;
    wxOutCode GetOutcode( const wxPoint2DInt &pt ) const;
    bool Contains( const wxPoint2DInt &pt ) const;
    bool Contains( const wxRect2DInt &rect ) const;
    bool IsEmpty() const;
    bool HaveEqualSize( const wxRect2DInt &rect ) const;

    void Inset( wxInt32 x , wxInt32 y );
    void Inset( wxInt32 left , wxInt32 top ,wxInt32 right , wxInt32 bottom  );
    void Offset( const wxPoint2DInt &pt );
    void ConstrainTo( const wxRect2DInt &rect );    
    wxPoint2DInt Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );

    static void Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
    void Intersect( const wxRect2DInt &otherRect );
    wxRect2DInt CreateIntersection( const wxRect2DInt &otherRect ) const;
    bool Intersects( const wxRect2DInt &rect ) const;

    static void Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
    void Union( const wxRect2DInt &otherRect );
    void Union( const wxPoint2DInt &pt );
    wxRect2DInt CreateUnion( const wxRect2DInt &otherRect ) const;

    void Scale( wxInt32 f );
    void Scale( wxInt32 num , wxInt32 denum );

    wxRect2DInt& operator = (const wxRect2DInt& rect);
    bool operator == (const wxRect2DInt& rect) const;
    bool operator != (const wxRect2DInt& rect) const;


    wxInt32 m_x;
    wxInt32 m_y;
    wxInt32 m_width;
    wxInt32 m_height;
};


class wxTransform2D
{
public :
    virtual ~wxTransform2D() { }
    virtual void                    Transform( wxPoint2DInt* pt )const  = 0;
    virtual void                    Transform( wxRect2DInt* r ) const;
    virtual wxPoint2DInt    Transform( const wxPoint2DInt &pt ) const;
    virtual wxRect2DInt        Transform( const wxRect2DInt &r ) const ;

    virtual void                    InverseTransform( wxPoint2DInt* pt ) const  = 0;
    virtual void                    InverseTransform( wxRect2DInt* r ) const ;
    virtual wxPoint2DInt    InverseTransform( const wxPoint2DInt &pt ) const ;
    virtual wxRect2DInt        InverseTransform( const wxRect2DInt &r ) const ;
};
Commit	Line	Data
f2e4cf3d RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: geometry.h
	3	// Purpose: interface of geometry classes
	4	// Author: wxWidgets team
a9a4f229	5	// RCS-ID: $Id$
f2e4cf3d RD	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9
	10	enum wxOutCode
	11	{
	12	wxInside = 0x00 ,
	13	wxOutLeft = 0x01 ,
	14	wxOutRight = 0x02 ,
	15	wxOutTop = 0x08 ,
	16	wxOutBottom = 0x04
	17	};
	18
	19
	20	class wxPoint2DInt
	21	{
	22	public :
	23	wxPoint2DInt();
	24	wxPoint2DInt( wxInt32 x , wxInt32 y );
	25	wxPoint2DInt( const wxPoint2DInt &pt );
	26	wxPoint2DInt( const wxPoint &pt );
	27
	28	// noops for this class, just return the coords
	29	void GetFloor( wxInt32 x , wxInt32 y ) const;
	30	void GetRounded( wxInt32 x , wxInt32 y ) const;
	31
	32	wxDouble GetVectorLength() const;
	33	wxDouble GetVectorAngle() const;
	34	void SetVectorLength( wxDouble length );
	35	void SetVectorAngle( wxDouble degrees );
	36	void SetPolarCoordinates( wxInt32 angle , wxInt32 length );
	37	// set the vector length to 1.0, preserving the angle
	38	void Normalize();
	39
	40	wxDouble GetDistance( const wxPoint2DInt &pt ) const;
	41	wxDouble GetDistanceSquare( const wxPoint2DInt &pt ) const;
	42	wxInt32 GetDotProduct( const wxPoint2DInt &vec ) const;
	43	wxInt32 GetCrossProduct( const wxPoint2DInt &vec ) const;
	44
	45	// the reflection of this point
	46	wxPoint2DInt operator-();
	47
	48	wxPoint2DInt& operator=(const wxPoint2DInt& pt);
	49	wxPoint2DInt& operator+=(const wxPoint2DInt& pt);
	50	wxPoint2DInt& operator-=(const wxPoint2DInt& pt);
	51	wxPoint2DInt& operator*=(const wxPoint2DInt& pt);
	52	wxPoint2DInt& operator*=(wxDouble n);
	53	wxPoint2DInt& operator*=(wxInt32 n);
	54	wxPoint2DInt& operator/=(const wxPoint2DInt& pt);
	55	wxPoint2DInt& operator/=(wxDouble n);
	56	wxPoint2DInt& operator/=(wxInt32 n);
	57	operator wxPoint() const;
	58	bool operator==(const wxPoint2DInt& pt) const;
	59	bool operator!=(const wxPoint2DInt& pt) const;
	60
	61	wxInt32 m_x;
	62	wxInt32 m_y;
	63	};
	64
	65	wxPoint2DInt operator+(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
	66	wxPoint2DInt operator-(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
	67	wxPoint2DInt operator*(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
	68	wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
	69	wxPoint2DInt operator*(wxInt32 n , const wxPoint2DInt& pt);
70	wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
71	wxPoint2DInt operator*(const wxPoint2DInt& pt , wxInt32 n);
72	wxPoint2DInt operator/(const wxPoint2DInt& pt1 , const wxPoint2DInt& pt2);
73	wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);
74	wxPoint2DInt operator/(const wxPoint2DInt& pt , wxInt32 n);
75
76
77	// wxPoint2Ds represent a point or a vector in a 2d coordinate system
78
79	class wxPoint2DDouble
80	{
81	public :
82	wxPoint2DDouble();
83	wxPoint2DDouble( wxDouble x , wxDouble y );
84	wxPoint2DDouble( const wxPoint2DDouble &pt );
85	wxPoint2DDouble( const wxPoint2DInt &pt );
86	wxPoint2DDouble( const wxPoint &pt );
87
88	// two different conversions to integers, floor and rounding
89	void GetFloor( wxInt32 x , wxInt32 y ) const;
90	void GetRounded( wxInt32 x , wxInt32 y ) const;
91
92	wxDouble GetVectorLength() const;
93	wxDouble GetVectorAngle() const ;
94	void SetVectorLength( wxDouble length );
95	void SetVectorAngle( wxDouble degrees );
96	void SetPolarCoordinates( wxDouble angle , wxDouble length );
97	// set the vector length to 1.0, preserving the angle
98	void Normalize();
99
100	wxDouble GetDistance( const wxPoint2DDouble &pt ) const;
101	wxDouble GetDistanceSquare( const wxPoint2DDouble &pt ) const;
102	wxDouble GetDotProduct( const wxPoint2DDouble &vec ) const;
103	wxDouble GetCrossProduct( const wxPoint2DDouble &vec ) const;
104
105	// the reflection of this point
106	wxPoint2DDouble operator-();
107
108	wxPoint2DDouble& operator=(const wxPoint2DDouble& pt);
109	wxPoint2DDouble& operator+=(const wxPoint2DDouble& pt);
110	wxPoint2DDouble& operator-=(const wxPoint2DDouble& pt);
111	wxPoint2DDouble& operator*=(const wxPoint2DDouble& pt);
112	wxPoint2DDouble& operator*=(wxDouble n);
113	wxPoint2DDouble& operator*=(wxInt32 n);
114	wxPoint2DDouble& operator/=(const wxPoint2DDouble& pt);
115	wxPoint2DDouble& operator/=(wxDouble n);
116	wxPoint2DDouble& operator/=(wxInt32 n);
117
118	bool operator==(const wxPoint2DDouble& pt) const;
119	bool operator!=(const wxPoint2DDouble& pt) const;
120
121	wxDouble m_x;
122	wxDouble m_y;
123	};
124
125	wxPoint2DDouble operator+(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
126	wxPoint2DDouble operator-(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
127	wxPoint2DDouble operator*(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
128	wxPoint2DDouble operator*(wxDouble n , const wxPoint2DDouble& pt);
129	wxPoint2DDouble operator*(wxInt32 n , const wxPoint2DDouble& pt);
130	wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxDouble n);
131	wxPoint2DDouble operator*(const wxPoint2DDouble& pt , wxInt32 n);
132	wxPoint2DDouble operator/(const wxPoint2DDouble& pt1 , const wxPoint2DDouble& pt2);
133	wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxDouble n);
134	wxPoint2DDouble operator/(const wxPoint2DDouble& pt , wxInt32 n);
135
136
137
138	// wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
139	// top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
140	// left <= x < right and top <= m_y < bottom , thus it is a half open interval.
141
142	class wxRect2DDouble
143	{
144	public:
145	wxRect2DDouble();
146	wxRect2DDouble(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
147
148	// single attribute accessors
149
150	wxPoint2DDouble GetPosition();
151	wxSize GetSize();
152
d13b34d3 DS	153	// for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
d13b34d3 DS	154	// position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
f2e4cf3d RD	155
	156	wxDouble GetLeft() const;
	157	void SetLeft( wxDouble n );
	158	void MoveLeftTo( wxDouble n );
	159	wxDouble GetTop() const;
	160	void SetTop( wxDouble n );
	161	void MoveTopTo( wxDouble n );
	162	wxDouble GetBottom() const;
	163	void SetBottom( wxDouble n );
	164	void MoveBottomTo( wxDouble n );
	165	wxDouble GetRight() const;
	166	void SetRight( wxDouble n );
	167	void MoveRightTo( wxDouble n );
	168
	169	wxPoint2DDouble GetLeftTop() const;
	170	void SetLeftTop( const wxPoint2DDouble &pt );
	171	void MoveLeftTopTo( const wxPoint2DDouble &pt );
	172	wxPoint2DDouble GetLeftBottom() const;
	173	void SetLeftBottom( const wxPoint2DDouble &pt );
	174	void MoveLeftBottomTo( const wxPoint2DDouble &pt );
	175	wxPoint2DDouble GetRightTop() const;
	176	void SetRightTop( const wxPoint2DDouble &pt );
	177	void MoveRightTopTo( const wxPoint2DDouble &pt );
	178	wxPoint2DDouble GetRightBottom() const;
	179	void SetRightBottom( const wxPoint2DDouble &pt );
	180	void MoveRightBottomTo( const wxPoint2DDouble &pt );
	181	wxPoint2DDouble GetCentre() const;
	182	void SetCentre( const wxPoint2DDouble &pt );
	183	void MoveCentreTo( const wxPoint2DDouble &pt );
	184	wxOutCode GetOutCode( const wxPoint2DDouble &pt ) const;
	185	wxOutCode GetOutcode(const wxPoint2DDouble &pt) const;
	186	bool Contains( const wxPoint2DDouble &pt ) const;
	187	bool Contains( const wxRect2DDouble &rect ) const;
	188	bool IsEmpty() const;
	189	bool HaveEqualSize( const wxRect2DDouble &rect ) const;
	190
	191	void Inset( wxDouble x , wxDouble y );
	192	void Inset( wxDouble left , wxDouble top ,wxDouble right , wxDouble bottom );
	193	void Offset( const wxPoint2DDouble &pt );
	194
	195	void ConstrainTo( const wxRect2DDouble &rect );
	196
	197	wxPoint2DDouble Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );
	198
	199	static void Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
	200	void Intersect( const wxRect2DDouble &otherRect );
	201	wxRect2DDouble CreateIntersection( const wxRect2DDouble &otherRect ) const;
	202	bool Intersects( const wxRect2DDouble &rect ) const;
	203
	204	static void Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
	205	void Union( const wxRect2DDouble &otherRect );
	206	void Union( const wxPoint2DDouble &pt );
	207	wxRect2DDouble CreateUnion( const wxRect2DDouble &otherRect ) const;
	208
	209	void Scale( wxDouble f );
	210	void Scale( wxInt32 num , wxInt32 denum );
	211
	212	wxRect2DDouble& operator = (const wxRect2DDouble& rect);
	213	bool operator == (const wxRect2DDouble& rect) const;
	214	bool operator != (const wxRect2DDouble& rect) const;
	215
	216	wxDouble m_x;
	217	wxDouble m_y;
	218	wxDouble m_width;
219	wxDouble m_height;
220	};
221
222
223
224
225	// wxRect2Ds are a axis-aligned rectangles, each side of the rect is parallel to the x- or m_y- axis. The rectangle is either defined by the
226	// top left and bottom right corner, or by the top left corner and size. A point is contained within the rectangle if
227	// left <= x < right and top <= m_y < bottom , thus it is a half open interval.
228
229	class wxRect2DInt
230	{
231	public:
232	wxRect2DInt();
233	wxRect2DInt( const wxRect& r );
234	wxRect2DInt(wxInt32 x, wxInt32 y, wxInt32 w, wxInt32 h);
235	wxRect2DInt(const wxPoint2DInt& topLeft, const wxPoint2DInt& bottomRight);
236	wxRect2DInt(const wxPoint2DInt& pos, const wxSize& size);
237	wxRect2DInt(const wxRect2DInt& rect);
238
239	// single attribute accessors
240
241	wxPoint2DInt GetPosition();
242	wxSize GetSize();
243
d13b34d3 DS	244	// for the edge and corner accessors there are two setters counterparts, the Set.. functions keep the other corners at their
d13b34d3 DS	245	// position whenever sensible, the Move.. functions keep the size of the rect and move the other corners appropriately
f2e4cf3d RD	246
	247	wxInt32 GetLeft() const;
	248	void SetLeft( wxInt32 n );
	249	void MoveLeftTo( wxInt32 n );
	250	wxInt32 GetTop() const;
	251	void SetTop( wxInt32 n );
	252	void MoveTopTo( wxInt32 n );
	253	wxInt32 GetBottom() const;
	254	void SetBottom( wxInt32 n );
	255	void MoveBottomTo( wxInt32 n );
	256	wxInt32 GetRight() const;
	257	void SetRight( wxInt32 n );
	258	void MoveRightTo( wxInt32 n );
	259
	260	wxPoint2DInt GetLeftTop() const;
	261	void SetLeftTop( const wxPoint2DInt &pt ) ;
	262	void MoveLeftTopTo( const wxPoint2DInt &pt ) ;
	263	wxPoint2DInt GetLeftBottom() const ;
	264	void SetLeftBottom( const wxPoint2DInt &pt ) ;
	265	void MoveLeftBottomTo( const wxPoint2DInt &pt ) ;
	266	wxPoint2DInt GetRightTop() const ;
	267	void SetRightTop( const wxPoint2DInt &pt ) ;
	268	void MoveRightTopTo( const wxPoint2DInt &pt ) ;
	269	wxPoint2DInt GetRightBottom() const ;
	270	void SetRightBottom( const wxPoint2DInt &pt ) ;
	271	void MoveRightBottomTo( const wxPoint2DInt &pt ) ;
	272	wxPoint2DInt GetCentre() const ;
	273	void SetCentre( const wxPoint2DInt &pt ) ;
	274	void MoveCentreTo( const wxPoint2DInt &pt ) ;
	275	wxOutCode GetOutCode( const wxPoint2DInt &pt ) const;
	276	wxOutCode GetOutcode( const wxPoint2DInt &pt ) const;
	277	bool Contains( const wxPoint2DInt &pt ) const;
	278	bool Contains( const wxRect2DInt &rect ) const;
	279	bool IsEmpty() const;
	280	bool HaveEqualSize( const wxRect2DInt &rect ) const;
	281
	282	void Inset( wxInt32 x , wxInt32 y );
	283	void Inset( wxInt32 left , wxInt32 top ,wxInt32 right , wxInt32 bottom );
	284	void Offset( const wxPoint2DInt &pt );
	285	void ConstrainTo( const wxRect2DInt &rect );
	286	wxPoint2DInt Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );
	287
	288	static void Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
	289	void Intersect( const wxRect2DInt &otherRect );
	290	wxRect2DInt CreateIntersection( const wxRect2DInt &otherRect ) const;
	291	bool Intersects( const wxRect2DInt &rect ) const;
	292
	293	static void Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
	294	void Union( const wxRect2DInt &otherRect );
	295	void Union( const wxPoint2DInt &pt );
	296	wxRect2DInt CreateUnion( const wxRect2DInt &otherRect ) const;
	297
	298	void Scale( wxInt32 f );
	299	void Scale( wxInt32 num , wxInt32 denum );
	300
	301	wxRect2DInt& operator = (const wxRect2DInt& rect);
	302	bool operator == (const wxRect2DInt& rect) const;
	303	bool operator != (const wxRect2DInt& rect) const;
	304
	305
	306	wxInt32 m_x;
	307	wxInt32 m_y;
	308	wxInt32 m_width;
	309	wxInt32 m_height;
310	};
311
312
313
314
315
316	class wxTransform2D
317	{
318	public :
319	virtual ~wxTransform2D() { }
320	virtual void Transform( wxPoint2DInt* pt )const = 0;
321	virtual void Transform( wxRect2DInt* r ) const;
322	virtual wxPoint2DInt Transform( const wxPoint2DInt &pt ) const;
323	virtual wxRect2DInt Transform( const wxRect2DInt &r ) const ;
324
325	virtual void InverseTransform( wxPoint2DInt* pt ) const = 0;
326	virtual void InverseTransform( wxRect2DInt* r ) const ;
327	virtual wxPoint2DInt InverseTransform( const wxPoint2DInt &pt ) const ;
328	virtual wxRect2DInt InverseTransform( const wxRect2DInt &r ) const ;
329	};
330
331