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