OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <limits> | |
6 | |
7 #include "base/logging.h" | |
8 #include "base/strings/stringprintf.h" | |
9 #include "ui/gfx/geometry/rect_base.h" | |
10 | |
11 // This file provides the implementation for RectBaese template and | |
12 // used to instantiate the base class for Rect and RectF classes. | |
13 #if !defined(GFX_IMPLEMENTATION) | |
14 #error "This file is intended for UI implementation only" | |
15 #endif | |
16 | |
17 namespace { | |
18 | |
19 template<typename Type> | |
20 void AdjustAlongAxis(Type dst_origin, Type dst_size, Type* origin, Type* size) { | |
21 *size = std::min(dst_size, *size); | |
22 if (*origin < dst_origin) | |
23 *origin = dst_origin; | |
24 else | |
25 *origin = std::min(dst_origin + dst_size, *origin + *size) - *size; | |
26 } | |
27 | |
28 } // namespace | |
29 | |
30 namespace gfx { | |
31 | |
32 template<typename Class, | |
33 typename PointClass, | |
34 typename SizeClass, | |
35 typename InsetsClass, | |
36 typename VectorClass, | |
37 typename Type> | |
38 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
39 SetRect(Type x, Type y, Type width, Type height) { | |
40 origin_.SetPoint(x, y); | |
41 set_width(width); | |
42 set_height(height); | |
43 } | |
44 | |
45 template<typename Class, | |
46 typename PointClass, | |
47 typename SizeClass, | |
48 typename InsetsClass, | |
49 typename VectorClass, | |
50 typename Type> | |
51 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
52 Inset(const InsetsClass& insets) { | |
53 Inset(insets.left(), insets.top(), insets.right(), insets.bottom()); | |
54 } | |
55 | |
56 template<typename Class, | |
57 typename PointClass, | |
58 typename SizeClass, | |
59 typename InsetsClass, | |
60 typename VectorClass, | |
61 typename Type> | |
62 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
63 Inset(Type left, Type top, Type right, Type bottom) { | |
64 origin_ += VectorClass(left, top); | |
65 set_width(std::max(width() - left - right, static_cast<Type>(0))); | |
66 set_height(std::max(height() - top - bottom, static_cast<Type>(0))); | |
67 } | |
68 | |
69 template<typename Class, | |
70 typename PointClass, | |
71 typename SizeClass, | |
72 typename InsetsClass, | |
73 typename VectorClass, | |
74 typename Type> | |
75 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
76 Offset(Type horizontal, Type vertical) { | |
77 origin_ += VectorClass(horizontal, vertical); | |
78 } | |
79 | |
80 template<typename Class, | |
81 typename PointClass, | |
82 typename SizeClass, | |
83 typename InsetsClass, | |
84 typename VectorClass, | |
85 typename Type> | |
86 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
87 operator+=(const VectorClass& offset) { | |
88 origin_ += offset; | |
89 } | |
90 | |
91 template<typename Class, | |
92 typename PointClass, | |
93 typename SizeClass, | |
94 typename InsetsClass, | |
95 typename VectorClass, | |
96 typename Type> | |
97 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
98 operator-=(const VectorClass& offset) { | |
99 origin_ -= offset; | |
100 } | |
101 | |
102 template<typename Class, | |
103 typename PointClass, | |
104 typename SizeClass, | |
105 typename InsetsClass, | |
106 typename VectorClass, | |
107 typename Type> | |
108 bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
109 operator<(const Class& other) const { | |
110 if (origin_ == other.origin_) { | |
111 if (width() == other.width()) { | |
112 return height() < other.height(); | |
113 } else { | |
114 return width() < other.width(); | |
115 } | |
116 } else { | |
117 return origin_ < other.origin_; | |
118 } | |
119 } | |
120 | |
121 template<typename Class, | |
122 typename PointClass, | |
123 typename SizeClass, | |
124 typename InsetsClass, | |
125 typename VectorClass, | |
126 typename Type> | |
127 bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
128 Contains(Type point_x, Type point_y) const { | |
129 return (point_x >= x()) && (point_x < right()) && | |
130 (point_y >= y()) && (point_y < bottom()); | |
131 } | |
132 | |
133 template<typename Class, | |
134 typename PointClass, | |
135 typename SizeClass, | |
136 typename InsetsClass, | |
137 typename VectorClass, | |
138 typename Type> | |
139 bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
140 Contains(const Class& rect) const { | |
141 return (rect.x() >= x() && rect.right() <= right() && | |
142 rect.y() >= y() && rect.bottom() <= bottom()); | |
143 } | |
144 | |
145 template<typename Class, | |
146 typename PointClass, | |
147 typename SizeClass, | |
148 typename InsetsClass, | |
149 typename VectorClass, | |
150 typename Type> | |
151 bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
152 Intersects(const Class& rect) const { | |
153 return !(IsEmpty() || rect.IsEmpty() || | |
154 rect.x() >= right() || rect.right() <= x() || | |
155 rect.y() >= bottom() || rect.bottom() <= y()); | |
156 } | |
157 | |
158 template<typename Class, | |
159 typename PointClass, | |
160 typename SizeClass, | |
161 typename InsetsClass, | |
162 typename VectorClass, | |
163 typename Type> | |
164 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
165 Intersect(const Class& rect) { | |
166 if (IsEmpty() || rect.IsEmpty()) { | |
167 SetRect(0, 0, 0, 0); | |
168 return; | |
169 } | |
170 | |
171 Type rx = std::max(x(), rect.x()); | |
172 Type ry = std::max(y(), rect.y()); | |
173 Type rr = std::min(right(), rect.right()); | |
174 Type rb = std::min(bottom(), rect.bottom()); | |
175 | |
176 if (rx >= rr || ry >= rb) | |
177 rx = ry = rr = rb = 0; // non-intersecting | |
178 | |
179 SetRect(rx, ry, rr - rx, rb - ry); | |
180 } | |
181 | |
182 template<typename Class, | |
183 typename PointClass, | |
184 typename SizeClass, | |
185 typename InsetsClass, | |
186 typename VectorClass, | |
187 typename Type> | |
188 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
189 Union(const Class& rect) { | |
190 if (IsEmpty()) { | |
191 *this = rect; | |
192 return; | |
193 } | |
194 if (rect.IsEmpty()) | |
195 return; | |
196 | |
197 Type rx = std::min(x(), rect.x()); | |
198 Type ry = std::min(y(), rect.y()); | |
199 Type rr = std::max(right(), rect.right()); | |
200 Type rb = std::max(bottom(), rect.bottom()); | |
201 | |
202 SetRect(rx, ry, rr - rx, rb - ry); | |
203 } | |
204 | |
205 template<typename Class, | |
206 typename PointClass, | |
207 typename SizeClass, | |
208 typename InsetsClass, | |
209 typename VectorClass, | |
210 typename Type> | |
211 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
212 Subtract(const Class& rect) { | |
213 if (!Intersects(rect)) | |
214 return; | |
215 if (rect.Contains(*static_cast<const Class*>(this))) { | |
216 SetRect(0, 0, 0, 0); | |
217 return; | |
218 } | |
219 | |
220 Type rx = x(); | |
221 Type ry = y(); | |
222 Type rr = right(); | |
223 Type rb = bottom(); | |
224 | |
225 if (rect.y() <= y() && rect.bottom() >= bottom()) { | |
226 // complete intersection in the y-direction | |
227 if (rect.x() <= x()) { | |
228 rx = rect.right(); | |
229 } else if (rect.right() >= right()) { | |
230 rr = rect.x(); | |
231 } | |
232 } else if (rect.x() <= x() && rect.right() >= right()) { | |
233 // complete intersection in the x-direction | |
234 if (rect.y() <= y()) { | |
235 ry = rect.bottom(); | |
236 } else if (rect.bottom() >= bottom()) { | |
237 rb = rect.y(); | |
238 } | |
239 } | |
240 SetRect(rx, ry, rr - rx, rb - ry); | |
241 } | |
242 | |
243 template<typename Class, | |
244 typename PointClass, | |
245 typename SizeClass, | |
246 typename InsetsClass, | |
247 typename VectorClass, | |
248 typename Type> | |
249 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
250 AdjustToFit(const Class& rect) { | |
251 Type new_x = x(); | |
252 Type new_y = y(); | |
253 Type new_width = width(); | |
254 Type new_height = height(); | |
255 AdjustAlongAxis(rect.x(), rect.width(), &new_x, &new_width); | |
256 AdjustAlongAxis(rect.y(), rect.height(), &new_y, &new_height); | |
257 SetRect(new_x, new_y, new_width, new_height); | |
258 } | |
259 | |
260 template<typename Class, | |
261 typename PointClass, | |
262 typename SizeClass, | |
263 typename InsetsClass, | |
264 typename VectorClass, | |
265 typename Type> | |
266 PointClass RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, | |
267 Type>::CenterPoint() const { | |
268 return PointClass(x() + width() / 2, y() + height() / 2); | |
269 } | |
270 | |
271 template<typename Class, | |
272 typename PointClass, | |
273 typename SizeClass, | |
274 typename InsetsClass, | |
275 typename VectorClass, | |
276 typename Type> | |
277 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
278 ClampToCenteredSize(const SizeClass& size) { | |
279 Type new_width = std::min(width(), size.width()); | |
280 Type new_height = std::min(height(), size.height()); | |
281 Type new_x = x() + (width() - new_width) / 2; | |
282 Type new_y = y() + (height() - new_height) / 2; | |
283 SetRect(new_x, new_y, new_width, new_height); | |
284 } | |
285 | |
286 template<typename Class, | |
287 typename PointClass, | |
288 typename SizeClass, | |
289 typename InsetsClass, | |
290 typename VectorClass, | |
291 typename Type> | |
292 void RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
293 SplitVertically(Class* left_half, Class* right_half) const { | |
294 DCHECK(left_half); | |
295 DCHECK(right_half); | |
296 | |
297 left_half->SetRect(x(), y(), width() / 2, height()); | |
298 right_half->SetRect(left_half->right(), | |
299 y(), | |
300 width() - left_half->width(), | |
301 height()); | |
302 } | |
303 | |
304 template<typename Class, | |
305 typename PointClass, | |
306 typename SizeClass, | |
307 typename InsetsClass, | |
308 typename VectorClass, | |
309 typename Type> | |
310 bool RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
311 SharesEdgeWith(const Class& rect) const { | |
312 return (y() == rect.y() && height() == rect.height() && | |
313 (x() == rect.right() || right() == rect.x())) || | |
314 (x() == rect.x() && width() == rect.width() && | |
315 (y() == rect.bottom() || bottom() == rect.y())); | |
316 } | |
317 | |
318 template<typename Class, | |
319 typename PointClass, | |
320 typename SizeClass, | |
321 typename InsetsClass, | |
322 typename VectorClass, | |
323 typename Type> | |
324 Type RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
325 ManhattanDistanceToPoint(const PointClass& point) const { | |
326 Type x_distance = std::max<Type>(0, std::max( | |
327 x() - point.x(), point.x() - right())); | |
328 Type y_distance = std::max<Type>(0, std::max( | |
329 y() - point.y(), point.y() - bottom())); | |
330 | |
331 return x_distance + y_distance; | |
332 } | |
333 | |
334 template<typename Class, | |
335 typename PointClass, | |
336 typename SizeClass, | |
337 typename InsetsClass, | |
338 typename VectorClass, | |
339 typename Type> | |
340 Type RectBase<Class, PointClass, SizeClass, InsetsClass, VectorClass, Type>:: | |
341 ManhattanInternalDistance(const Class& rect) const { | |
342 Class c(x(), y(), width(), height()); | |
343 c.Union(rect); | |
344 | |
345 static const Type kEpsilon = std::numeric_limits<Type>::is_integer | |
346 ? 1 | |
347 : std::numeric_limits<Type>::epsilon(); | |
348 | |
349 Type x = std::max<Type>(0, c.width() - width() - rect.width() + kEpsilon); | |
350 Type y = std::max<Type>(0, c.height() - height() - rect.height() + kEpsilon); | |
351 return x + y; | |
352 } | |
353 | |
354 } // namespace gfx | |
OLD | NEW |