You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

Rect.h 4.8KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130
  1. /* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
  2. *
  3. * This is free software; you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation; either version 2 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This software is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this software; if not, write to the Free Software
  15. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  16. * USA.
  17. */
  18. // rfb::Rect and rfb::Point structures
  19. #ifndef __RFB_RECT_INCLUDED__
  20. #define __RFB_RECT_INCLUDED__
  21. // Some platforms (e.g. Windows) include max() and min() macros in their
  22. // standard headers, but they are also standard C++ template functions, so some
  23. // C++ headers will undefine them. So we steer clear of the names min and max
  24. // and define __rfbmin and __rfbmax instead.
  25. #ifndef __rfbmax
  26. #define __rfbmax(a,b) (((a) > (b)) ? (a) : (b))
  27. #endif
  28. #ifndef __rfbmin
  29. #define __rfbmin(a,b) (((a) < (b)) ? (a) : (b))
  30. #endif
  31. namespace rfb {
  32. // rfb::Point
  33. //
  34. // Represents a point in 2D space, by X and Y coordinates.
  35. // Can also be used to represent a delta, or offset, between
  36. // two Points.
  37. // Functions are provided to allow Points to be compared for
  38. // equality and translated by a supplied offset.
  39. // Functions are also provided to negate offset Points.
  40. struct Point {
  41. Point() : x(0), y(0) {}
  42. Point(int x_, int y_) : x(x_), y(y_) {}
  43. inline Point negate() const
  44. __attribute__ ((warn_unused_result))
  45. {return Point(-x, -y);}
  46. inline bool operator==(const Point &p) const {return x==p.x && y==p.y;}
  47. inline bool operator!=(const Point &p) const {return x!=p.x || y!=p.y;}
  48. inline Point translate(const Point &p) const
  49. __attribute__ ((warn_unused_result))
  50. {return Point(x+p.x, y+p.y);}
  51. inline Point subtract(const Point &p) const
  52. __attribute__ ((warn_unused_result))
  53. {return Point(x-p.x, y-p.y);}
  54. int x, y;
  55. };
  56. // rfb::Rect
  57. //
  58. // Represents a rectangular region defined by its top-left (tl)
  59. // and bottom-right (br) Points.
  60. // Rects may be compared for equality, checked to determine whether
  61. // or not they are empty, cleared (made empty), or intersected with
  62. // one another. The bounding rectangle of two existing Rects
  63. // may be calculated, as may the area of a Rect.
  64. // Rects may also be translated, in the same way as Points, by
  65. // an offset specified in a Point structure.
  66. struct Rect {
  67. Rect() {}
  68. Rect(Point tl_, Point br_) : tl(tl_), br(br_) {}
  69. Rect(int x1, int y1, int x2, int y2) : tl(x1, y1), br(x2, y2) {}
  70. inline void setXYWH(int x, int y, int w, int h) {
  71. tl.x = x; tl.y = y; br.x = x+w; br.y = y+h;
  72. }
  73. inline Rect intersect(const Rect &r) const
  74. __attribute__ ((warn_unused_result))
  75. {
  76. Rect result;
  77. result.tl.x = __rfbmax(tl.x, r.tl.x);
  78. result.tl.y = __rfbmax(tl.y, r.tl.y);
  79. result.br.x = __rfbmax(__rfbmin(br.x, r.br.x), result.tl.x);
  80. result.br.y = __rfbmax(__rfbmin(br.y, r.br.y), result.tl.y);
  81. return result;
  82. }
  83. inline Rect union_boundary(const Rect &r) const
  84. __attribute__ ((warn_unused_result))
  85. {
  86. if (r.is_empty()) return *this;
  87. if (is_empty()) return r;
  88. Rect result;
  89. result.tl.x = __rfbmin(tl.x, r.tl.x);
  90. result.tl.y = __rfbmin(tl.y, r.tl.y);
  91. result.br.x = __rfbmax(br.x, r.br.x);
  92. result.br.y = __rfbmax(br.y, r.br.y);
  93. return result;
  94. }
  95. inline Rect translate(const Point &p) const
  96. __attribute__ ((warn_unused_result))
  97. {
  98. return Rect(tl.translate(p), br.translate(p));
  99. }
  100. inline bool operator==(const Rect &r) const {return r.tl == tl && r.br == br;}
  101. inline bool operator!=(const Rect &r) const {return r.tl != tl || r.br != br;}
  102. inline bool is_empty() const {return (tl.x >= br.x) || (tl.y >= br.y);}
  103. inline void clear() {tl = Point(); br = Point();}
  104. inline bool enclosed_by(const Rect &r) const {
  105. return (tl.x>=r.tl.x) && (tl.y>=r.tl.y) && (br.x<=r.br.x) && (br.y<=r.br.y);
  106. }
  107. inline bool overlaps(const Rect &r) const {
  108. return tl.x < r.br.x && tl.y < r.br.y && br.x > r.tl.x && br.y > r.tl.y;
  109. }
  110. inline int area() const {return is_empty() ? 0 : (br.x-tl.x)*(br.y-tl.y);}
  111. inline Point dimensions() const {return Point(width(), height());}
  112. inline int width() const {return br.x-tl.x;}
  113. inline int height() const {return br.y-tl.y;}
  114. inline bool contains(const Point &p) const {
  115. return (tl.x<=p.x) && (tl.y<=p.y) && (br.x>p.x) && (br.y>p.y);
  116. }
  117. Point tl;
  118. Point br;
  119. };
  120. }
  121. #endif // __RFB_RECT_INCLUDED__