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 355
