scintilla/src/Geometry.h

   1 // Scintilla source code edit control
   2 /** @file Geometry.h
   3  ** Classes and functions for geometric and colour calculations.
   4  **/
   5 // Copyright 2020 by Neil Hodgson <neilh@scintilla.org>
   6 // The License.txt file describes the conditions under which this software may be distributed.
   7
   8 #ifndef GEOMETRY_H
   9 #define GEOMETRY_H
  10
  11 namespace Scintilla::Internal {
  12
  13 typedef double XYPOSITION;
  14 typedef double XYACCUMULATOR;
  15
  16 /**
  17  * A geometric point class.
  18  * Point is similar to the Win32 POINT and GTK+ GdkPoint types.
  19  */
  20 class Point {
  21 public:
  22         XYPOSITION x;
  23         XYPOSITION y;
  24
  25         constexpr explicit Point(XYPOSITION x_=0, XYPOSITION y_=0) noexcept : x(x_), y(y_) {
  26         }
  27
  28         static constexpr Point FromInts(int x_, int y_) noexcept {
  29                 return Point(static_cast<XYPOSITION>(x_), static_cast<XYPOSITION>(y_));
  30         }
  31
  32         constexpr bool operator==(Point other) const noexcept {
  33                 return (x == other.x) && (y == other.y);
  34         }
  35
  36         constexpr bool operator!=(Point other) const noexcept {
  37                 return (x != other.x) || (y != other.y);
  38         }
  39
  40         constexpr Point operator+(Point other) const noexcept {
  41                 return Point(x + other.x, y + other.y);
  42         }
  43
  44         constexpr Point operator-(Point other) const noexcept {
  45                 return Point(x - other.x, y - other.y);
  46         }
  47
  48         // Other automatically defined methods (assignment, copy constructor, destructor) are fine
  49 };
  50
  51
  52 /**
  53  * A geometric interval class.
  54  */
  55 class Interval {
  56 public:
  57         XYPOSITION left;
  58         XYPOSITION right;
  59         constexpr bool operator==(const Interval &other) const noexcept {
  60                 return (left == other.left) && (right == other.right);
  61         }
  62         constexpr XYPOSITION Width() const noexcept { return right - left; }
  63         constexpr bool Empty() const noexcept {
  64                 return Width() <= 0;
  65         }
  66         constexpr bool Intersects(Interval other) const noexcept {
  67                 return (right > other.left) && (left < other.right);
  68         }
  69         constexpr Interval Offset(XYPOSITION offset) const noexcept {
  70                 return {left + offset, right + offset};
  71         }
  72 };
  73
  74 /**
  75  * A geometric rectangle class.
  76  * PRectangle is similar to Win32 RECT.
  77  * PRectangles contain their top and left sides, but not their right and bottom sides.
  78  */
  79 class PRectangle {
  80 public:
  81         XYPOSITION left;
  82         XYPOSITION top;
  83         XYPOSITION right;
  84         XYPOSITION bottom;
  85
  86         constexpr explicit PRectangle(XYPOSITION left_=0, XYPOSITION top_=0, XYPOSITION right_=0, XYPOSITION bottom_ = 0) noexcept :
  87                 left(left_), top(top_), right(right_), bottom(bottom_) {
  88         }
  89
  90         static constexpr PRectangle FromInts(int left_, int top_, int right_, int bottom_) noexcept {
  91                 return PRectangle(static_cast<XYPOSITION>(left_), static_cast<XYPOSITION>(top_),
  92                         static_cast<XYPOSITION>(right_), static_cast<XYPOSITION>(bottom_));
  93         }
  94
  95         // Other automatically defined methods (assignment, copy constructor, destructor) are fine
  96
  97         constexpr bool operator==(const PRectangle &rc) const noexcept {
  98                 return (rc.left == left) && (rc.right == right) &&
  99                         (rc.top == top) && (rc.bottom == bottom);
 100         }
 101         constexpr bool Contains(Point pt) const noexcept {
 102                 return (pt.x >= left) && (pt.x <= right) &&
 103                         (pt.y >= top) && (pt.y <= bottom);
 104         }
 105         constexpr bool ContainsWholePixel(Point pt) const noexcept {
 106                 // Does the rectangle contain all of the pixel to left/below the point
 107                 return (pt.x >= left) && ((pt.x+1) <= right) &&
 108                         (pt.y >= top) && ((pt.y+1) <= bottom);
 109         }
 110         constexpr bool Contains(PRectangle rc) const noexcept {
 111                 return (rc.left >= left) && (rc.right <= right) &&
 112                         (rc.top >= top) && (rc.bottom <= bottom);
 113         }
 114         constexpr bool Intersects(PRectangle other) const noexcept {
 115                 return (right > other.left) && (left < other.right) &&
 116                         (bottom > other.top) && (top < other.bottom);
 117         }
 118         constexpr bool Intersects(Interval horizontalBounds) const noexcept {
 119                 return (right > horizontalBounds.left) && (left < horizontalBounds.right);
 120         }
 121
 122         void Move(XYPOSITION xDelta, XYPOSITION yDelta) noexcept {
 123                 left += xDelta;
 124                 top += yDelta;
 125                 right += xDelta;
 126                 bottom += yDelta;
 127         }
 128
 129         PRectangle WithHorizontalBounds(Interval horizontal) const noexcept {
 130                 return PRectangle(horizontal.left, top, horizontal.right, bottom);
 131         }
 132
 133         constexpr PRectangle Inset(XYPOSITION delta) const noexcept {
 134                 return PRectangle(left + delta, top + delta, right - delta, bottom - delta);
 135         }
 136
 137         constexpr PRectangle Inset(Point delta) const noexcept {
 138                 return PRectangle(left + delta.x, top + delta.y, right - delta.x, bottom - delta.y);
 139         }
 140
 141         constexpr Point Centre() const noexcept {
 142                 return Point((left + right) / 2, (top + bottom) / 2);
 143         }
 144
 145         constexpr XYPOSITION Width() const noexcept { return right - left; }
 146         constexpr XYPOSITION Height() const noexcept { return bottom - top; }
 147         constexpr bool Empty() const noexcept {
 148                 return (Height() <= 0) || (Width() <= 0);
 149         }
 150 };
 151
 152 enum class Edge { left, top, bottom, right };
 153
 154 PRectangle Clamp(PRectangle rc, Edge edge, XYPOSITION position) noexcept;
 155 PRectangle Side(PRectangle rc, Edge edge, XYPOSITION size) noexcept;
 156
 157 Interval Intersection(Interval a, Interval b) noexcept;
 158 PRectangle Intersection(PRectangle rc, Interval horizontalBounds) noexcept;
 159 Interval HorizontalBounds(PRectangle rc) noexcept;
 160
 161 XYPOSITION PixelAlign(XYPOSITION xy, int pixelDivisions) noexcept;
 162 XYPOSITION PixelAlignFloor(XYPOSITION xy, int pixelDivisions) noexcept;
 163 XYPOSITION PixelAlignCeil(XYPOSITION xy, int pixelDivisions) noexcept;
 164
 165 Point PixelAlign(const Point &pt, int pixelDivisions) noexcept;
 166
 167 PRectangle PixelAlign(const PRectangle &rc, int pixelDivisions) noexcept;
 168 PRectangle PixelAlignOutside(const PRectangle &rc, int pixelDivisions) noexcept;
 169
 170 /**
 171 * Holds an RGBA colour with 8 bits for each component.
 172 */
 173 constexpr const float componentMaximum = 255.0f;
 174 class ColourRGBA {
 175         static constexpr int rgbMask = 0xffffff;
 176         int co;
 177 public:
 178         constexpr explicit ColourRGBA(int co_ = 0) noexcept : co(co_) {
 179         }
 180
 181         constexpr ColourRGBA(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha=0xff) noexcept :
 182                 ColourRGBA(red | (green << 8) | (blue << 16) | (alpha << 24)) {
 183         }
 184
 185         constexpr ColourRGBA(ColourRGBA cd, unsigned int alpha) noexcept :
 186                 ColourRGBA(cd.OpaqueRGB() | (alpha << 24)) {
 187         }
 188
 189         static constexpr ColourRGBA FromRGB(int co_) noexcept {
 190                 return ColourRGBA(co_ | (0xffu << 24));
 191         }
 192
 193         static constexpr ColourRGBA FromIpRGB(intptr_t co_) noexcept {
 194                 return ColourRGBA((co_ & rgbMask) | (0xffu << 24));
 195         }
 196
 197         constexpr ColourRGBA WithoutAlpha() const noexcept {
 198                 return ColourRGBA(co & rgbMask);
 199         }
 200
 201         constexpr ColourRGBA Opaque() const noexcept {
 202                 return ColourRGBA(co | (0xffu << 24));
 203         }
 204
 205         constexpr int AsInteger() const noexcept {
 206                 return co;
 207         }
 208
 209         constexpr int OpaqueRGB() const noexcept {
 210                 return co & rgbMask;
 211         }
 212
 213         // Red, green and blue values as bytes 0..255
 214         constexpr unsigned char GetRed() const noexcept {
 215                 return co & 0xffU;
 216         }
 217         constexpr unsigned char GetGreen() const noexcept {
 218                 return (co >> 8) & 0xffU;
 219         }
 220         constexpr unsigned char GetBlue() const noexcept {
 221                 return (co >> 16) & 0xffU;
 222         }
 223         constexpr unsigned char GetAlpha() const noexcept {
 224                 // Use a temporary here to prevent a 'Wconversion' warning from GCC
 225                 const int shifted = co >> 24;
 226                 return shifted & 0xffU;
 227         }
 228
 229         // Red, green, blue, and alpha values as float 0..1.0
 230         constexpr float GetRedComponent() const noexcept {
 231                 return GetRed() / componentMaximum;
 232         }
 233         constexpr float GetGreenComponent() const noexcept {
 234                 return GetGreen() / componentMaximum;
 235         }
 236         constexpr float GetBlueComponent() const noexcept {
 237                 return GetBlue() / componentMaximum;
 238         }
 239         constexpr float GetAlphaComponent() const noexcept {
 240                 return GetAlpha() / componentMaximum;
 241         }
 242
 243         constexpr bool operator==(const ColourRGBA &other) const noexcept {
 244                 return co == other.co;
 245         }
 246
 247         constexpr bool IsOpaque() const noexcept {
 248                 return GetAlpha() == 0xff;
 249         }
 250
 251         ColourRGBA MixedWith(ColourRGBA other) const noexcept;
 252         ColourRGBA MixedWith(ColourRGBA other, double proportion) const noexcept;
 253 };
 254
 255 /**
 256 * Holds an RGBA colour and stroke width to stroke a shape.
 257 */
 258 class Stroke {
 259 public:
 260         ColourRGBA colour;
 261         XYPOSITION width;
 262         constexpr Stroke(ColourRGBA colour_, XYPOSITION width_=1.0) noexcept :
 263                 colour(colour_), width(width_) {
 264         }
 265         constexpr float WidthF() const noexcept {
 266                 return static_cast<float>(width);
 267         }
 268 };
 269
 270 /**
 271 * Holds an RGBA colour to fill a shape.
 272 */
 273 class Fill {
 274 public:
 275         ColourRGBA colour;
 276         constexpr Fill(ColourRGBA colour_) noexcept :
 277                 colour(colour_) {
 278         }
 279 };
 280
 281 /**
 282 * Holds a pair of RGBA colours and stroke width to fill and stroke a shape.
 283 */
 284 class FillStroke {
 285 public:
 286         Fill fill;
 287         Stroke stroke;
 288         constexpr FillStroke(ColourRGBA colourFill_, ColourRGBA colourStroke_, XYPOSITION widthStroke_=1.0) noexcept :
 289                 fill(colourFill_), stroke(colourStroke_, widthStroke_) {
 290         }
 291         constexpr FillStroke(ColourRGBA colourBoth, XYPOSITION widthStroke_=1.0) noexcept :
 292                 fill(colourBoth), stroke(colourBoth, widthStroke_) {
 293         }
 294 };
 295
 296 /**
 297 * Holds an element of a gradient with an RGBA colour and a relative position.
 298 */
 299 class ColourStop {
 300 public:
 301         XYPOSITION position;
 302         ColourRGBA colour;
 303         constexpr ColourStop(XYPOSITION position_, ColourRGBA colour_) noexcept :
 304                 position(position_), colour(colour_) {
 305         }
 306 };
 307
 308 }
 309
 310 #endif