WooHoo me again ;)
[blender.git] / intern / ghost / GHOST_Rect.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * @author      Maarten Gribnau
37  * @date        May 10, 2001
38  */
39
40 #ifndef _H_GHOST_Rect
41 #define _H_GHOST_Rect
42
43 #include "GHOST_Types.h"
44
45
46 /**
47  * Implements rectangle functionality.
48  * The four extreme coordinates are stored as left, top, right and bottom.
49  * To be valid, a rectangle should have a left coordinate smaller than or equal to right.
50  * To be valid, a rectangle should have a top coordinate smaller than or equal to bottom.
51  * @author      Maarten Gribnau
52  * @date        May 10, 2001
53  */
54
55 class GHOST_Rect {
56 public:
57
58         /**
59          * Constructs a rectangle with the given values.
60          * @param       l       requested left coordinate of the rectangle
61          * @param       t       requested top coordinate of the rectangle
62          * @param       r       requested right coordinate of the rectangle
63          * @param       b       requested bottom coordinate of the rectangle
64          */
65         GHOST_Rect(GHOST_TInt32 l=0, GHOST_TInt32 t=0, GHOST_TInt32 r=0, GHOST_TInt32 b=0)
66                 : m_l(l), m_t(t), m_r(r), m_b(b) {}
67
68         /**
69          * Copy constructor.
70          * @param       r       rectangle to copy
71          */
72         GHOST_Rect(const GHOST_Rect& r)
73                 : m_l(r.m_l), m_t(r.m_t), m_r(r.m_r), m_b(r.m_b) {}
74         
75         /**
76          * Destructor.
77          */
78         virtual ~GHOST_Rect() {};
79
80         /**
81          * Access to rectangle width.
82          * @return      width of the rectangle
83          */
84         virtual inline GHOST_TInt32 getWidth() const;
85
86         /**
87          * Access to rectangle height.
88          * @return      height of the rectangle
89          */
90         virtual inline GHOST_TInt32 getHeight() const;
91
92         /**
93          * Sets all members of the rectangle.
94          * @param       l       requested left coordinate of the rectangle
95          * @param       t       requested top coordinate of the rectangle
96          * @param       r       requested right coordinate of the rectangle
97          * @param       b       requested bottom coordinate of the rectangle
98          */
99         virtual inline void set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b);
100
101         /**
102          * Returns whether this rectangle is empty.
103          * Empty rectangles are rectangles that have width==0 and/or height==0.
104          * @return      boolean value (true==empty rectangle)
105          */
106         virtual inline bool isEmpty() const;
107
108         /**
109          * Returns whether this rectangle is valid.
110          * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
111          * @return      boolean value (true==valid rectangle)
112          */
113         virtual inline bool isValid() const;
114
115         /**
116          * Grows (or shrinks the rectangle).
117          * The method avoids negative insets making the rectangle invalid
118          * @param       i       The amount of offset given to each extreme (negative values shrink the rectangle).
119          */
120         virtual void inset(GHOST_TInt32 i);
121
122         /**
123          * Does a union of the rectangle given and this rectangle.
124          * The result is stored in this rectangle.
125          * @param       r       The rectangle that is input for the union operation.
126          */
127         virtual inline void unionRect(const GHOST_Rect& r);
128
129         /**
130          * Grows the rectangle to included a point.
131          * @param       x       The x-coordinate of the point.
132          * @param       y       The y-coordinate of the point.
133          */
134         virtual inline void unionPoint(GHOST_TInt32 x, GHOST_TInt32 y);
135
136         /**
137          * Returns whether the point is inside this rectangle.
138          * Point on the boundary is considered inside.
139          * @param x     x-coordinate of point to test.
140          * @param y y-coordinate of point to test.
141          * @return boolean value (true if point is inside).
142          */
143         virtual inline bool isInside(GHOST_TInt32 x, GHOST_TInt32 y) const;
144
145         /**
146          * Returns whether the rectangle is inside this rectangle.
147          * @param       r       rectangle to test.
148          * @return      visibility (not, partially or fully visible).
149          */
150         virtual GHOST_TVisibility getVisibility(GHOST_Rect& r) const;
151
152         /**
153          * Sets rectangle members.
154          * Sets rectangle members such that it is centered at the given location.
155          * @param       cx      requested center x-coordinate of the rectangle
156          * @param       cy      requested center y-coordinate of the rectangle
157          */
158         virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy);
159
160         /**
161          * Sets rectangle members.
162          * Sets rectangle members such that it is centered at the given location,
163          * with the width requested.
164          * @param       cx      requested center x-coordinate of the rectangle
165          * @param       cy      requested center y-coordinate of the rectangle
166          * @param       w       requested width of the rectangle
167          * @param       h       requested height of the rectangle
168          */
169         virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy, GHOST_TInt32 w, GHOST_TInt32 h);
170
171         /**
172          * Clips a rectangle.
173          * Updates the rectangle given such that it will fit within this one.
174          * This can result in an empty rectangle.
175          * @param       r       the rectangle to clip
176          * @return      whether clipping has occurred
177          */
178         virtual bool clip(GHOST_Rect& r) const;
179
180         /** Left coordinate of the rectangle */
181         GHOST_TInt32 m_l;
182         /** Top coordinate of the rectangle */
183         GHOST_TInt32 m_t;
184         /** Right coordinate of the rectangle */
185         GHOST_TInt32 m_r;
186         /** Bottom coordinate of the rectangle */
187         GHOST_TInt32 m_b;
188 };
189
190
191 inline GHOST_TInt32 GHOST_Rect::getWidth() const
192 {
193         return m_r - m_l;
194 }
195
196 inline GHOST_TInt32 GHOST_Rect::getHeight() const
197 {
198         return m_b - m_t;
199 }
200
201 inline void GHOST_Rect::set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b)
202 {
203         m_l = l; m_t = t; m_r = r; m_b = b;
204 }
205
206 inline bool     GHOST_Rect::isEmpty() const
207 {
208         return (getWidth() == 0) || (getHeight() == 0);
209 }
210
211 inline bool GHOST_Rect::isValid() const
212 {
213         return (m_l <= m_r) && (m_t <= m_b);
214 }
215
216 inline void GHOST_Rect::unionRect(const GHOST_Rect& r)
217 {
218         if (r.m_l < m_l) m_l = r.m_l;
219         if (r.m_r > m_r) m_r = r.m_r;
220         if (r.m_t < m_t) m_t = r.m_t;
221         if (r.m_b > m_b) m_b = r.m_b;
222 }
223
224 inline void GHOST_Rect::unionPoint(GHOST_TInt32 x, GHOST_TInt32 y)
225 {
226         if (x < m_l) m_l = x;
227         if (x > m_r) m_r = x;
228         if (y < m_t) m_t = y;
229         if (y > m_b) m_b = y;
230 }
231
232 inline bool GHOST_Rect::isInside(GHOST_TInt32 x, GHOST_TInt32 y) const
233 {
234         return (x >= m_l) && (x <= m_r) && (y >= m_t) && (y <= m_b);
235 }
236
237 #endif // _H_GHOST_Rect
238