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