Yes I did it 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 #ifdef HAVE_CONFIG_H
44 #include <config.h>
45 #endif
46
47 #include "GHOST_Types.h"
48
49
50 /**
51  * Implements rectangle functionality.
52  * The four extreme coordinates are stored as left, top, right and bottom.
53  * To be valid, a rectangle should have a left coordinate smaller than or equal to right.
54  * To be valid, a rectangle should have a top coordinate smaller than or equal to bottom.
55  * @author      Maarten Gribnau
56  * @date        May 10, 2001
57  */
58
59 class GHOST_Rect {
60 public:
61
62         /**
63          * Constructs a rectangle with the given values.
64          * @param       l       requested left coordinate of the rectangle
65          * @param       t       requested top coordinate of the rectangle
66          * @param       r       requested right coordinate of the rectangle
67          * @param       b       requested bottom coordinate of the rectangle
68          */
69         GHOST_Rect(GHOST_TInt32 l=0, GHOST_TInt32 t=0, GHOST_TInt32 r=0, GHOST_TInt32 b=0)
70                 : m_l(l), m_t(t), m_r(r), m_b(b) {}
71
72         /**
73          * Copy constructor.
74          * @param       r       rectangle to copy
75          */
76         GHOST_Rect(const GHOST_Rect& r)
77                 : m_l(r.m_l), m_t(r.m_t), m_r(r.m_r), m_b(r.m_b) {}
78         
79         /**
80          * Destructor.
81          */
82         virtual ~GHOST_Rect() {};
83
84         /**
85          * Access to rectangle width.
86          * @return      width of the rectangle
87          */
88         virtual inline GHOST_TInt32 getWidth() const;
89
90         /**
91          * Access to rectangle height.
92          * @return      height of the rectangle
93          */
94         virtual inline GHOST_TInt32 getHeight() const;
95
96         /**
97          * Sets all members of the rectangle.
98          * @param       l       requested left coordinate of the rectangle
99          * @param       t       requested top coordinate of the rectangle
100          * @param       r       requested right coordinate of the rectangle
101          * @param       b       requested bottom coordinate of the rectangle
102          */
103         virtual inline void set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b);
104
105         /**
106          * Returns whether this rectangle is empty.
107          * Empty rectangles are rectangles that have width==0 and/or height==0.
108          * @return      boolean value (true==empty rectangle)
109          */
110         virtual inline bool isEmpty() const;
111
112         /**
113          * Returns whether this rectangle is valid.
114          * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
115          * @return      boolean value (true==valid rectangle)
116          */
117         virtual inline bool isValid() const;
118
119         /**
120          * Grows (or shrinks the rectangle).
121          * The method avoids negative insets making the rectangle invalid
122          * @param       i       The amount of offset given to each extreme (negative values shrink the rectangle).
123          */
124         virtual void inset(GHOST_TInt32 i);
125
126         /**
127          * Does a union of the rectangle given and this rectangle.
128          * The result is stored in this rectangle.
129          * @param       r       The rectangle that is input for the union operation.
130          */
131         virtual inline void unionRect(const GHOST_Rect& r);
132
133         /**
134          * Grows the rectangle to included a point.
135          * @param       x       The x-coordinate of the point.
136          * @param       y       The y-coordinate of the point.
137          */
138         virtual inline void unionPoint(GHOST_TInt32 x, GHOST_TInt32 y);
139
140         /**
141          * Returns whether the point is inside this rectangle.
142          * Point on the boundary is considered inside.
143          * @param x     x-coordinate of point to test.
144          * @param y y-coordinate of point to test.
145          * @return boolean value (true if point is inside).
146          */
147         virtual inline bool isInside(GHOST_TInt32 x, GHOST_TInt32 y) const;
148
149         /**
150          * Returns whether the rectangle is inside this rectangle.
151          * @param       r       rectangle to test.
152          * @return      visibility (not, partially or fully visible).
153          */
154         virtual GHOST_TVisibility getVisibility(GHOST_Rect& r) const;
155
156         /**
157          * Sets rectangle members.
158          * Sets rectangle members such that it is centered at the given location.
159          * @param       cx      requested center x-coordinate of the rectangle
160          * @param       cy      requested center y-coordinate of the rectangle
161          */
162         virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy);
163
164         /**
165          * Sets rectangle members.
166          * Sets rectangle members such that it is centered at the given location,
167          * with the width requested.
168          * @param       cx      requested center x-coordinate of the rectangle
169          * @param       cy      requested center y-coordinate of the rectangle
170          * @param       w       requested width of the rectangle
171          * @param       h       requested height of the rectangle
172          */
173         virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy, GHOST_TInt32 w, GHOST_TInt32 h);
174
175         /**
176          * Clips a rectangle.
177          * Updates the rectangle given such that it will fit within this one.
178          * This can result in an empty rectangle.
179          * @param       r       the rectangle to clip
180          * @return      whether clipping has occurred
181          */
182         virtual bool clip(GHOST_Rect& r) const;
183
184         /** Left coordinate of the rectangle */
185         GHOST_TInt32 m_l;
186         /** Top coordinate of the rectangle */
187         GHOST_TInt32 m_t;
188         /** Right coordinate of the rectangle */
189         GHOST_TInt32 m_r;
190         /** Bottom coordinate of the rectangle */
191         GHOST_TInt32 m_b;
192 };
193
194
195 inline GHOST_TInt32 GHOST_Rect::getWidth() const
196 {
197         return m_r - m_l;
198 }
199
200 inline GHOST_TInt32 GHOST_Rect::getHeight() const
201 {
202         return m_b - m_t;
203 }
204
205 inline void GHOST_Rect::set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b)
206 {
207         m_l = l; m_t = t; m_r = r; m_b = b;
208 }
209
210 inline bool     GHOST_Rect::isEmpty() const
211 {
212         return (getWidth() == 0) || (getHeight() == 0);
213 }
214
215 inline bool GHOST_Rect::isValid() const
216 {
217         return (m_l <= m_r) && (m_t <= m_b);
218 }
219
220 inline void GHOST_Rect::unionRect(const GHOST_Rect& r)
221 {
222         if (r.m_l < m_l) m_l = r.m_l;
223         if (r.m_r > m_r) m_r = r.m_r;
224         if (r.m_t < m_t) m_t = r.m_t;
225         if (r.m_b > m_b) m_b = r.m_b;
226 }
227
228 inline void GHOST_Rect::unionPoint(GHOST_TInt32 x, GHOST_TInt32 y)
229 {
230         if (x < m_l) m_l = x;
231         if (x > m_r) m_r = x;
232         if (y < m_t) m_t = y;
233         if (y > m_b) m_b = y;
234 }
235
236 inline bool GHOST_Rect::isInside(GHOST_TInt32 x, GHOST_TInt32 y) const
237 {
238         return (x >= m_l) && (x <= m_r) && (y >= m_t) && (y <= m_b);
239 }
240
241 #endif // _H_GHOST_Rect
242