| 0,0 → 1,324 |
|---|
| |
| namespace GMap.NET |
| { |
| using System; |
| using System.Globalization; |
| |
| /// <summary> |
| /// the rect |
| /// </summary> |
| public struct GRect |
| { |
| public static readonly GRect Empty = new GRect(); |
| |
| private long x; |
| private long y; |
| private long width; |
| private long height; |
| |
| public GRect(long x, long y, long width, long height) |
| { |
| this.x = x; |
| this.y = y; |
| this.width = width; |
| this.height = height; |
| } |
| |
| public GRect(GPoint location, GSize size) |
| { |
| this.x = location.X; |
| this.y = location.Y; |
| this.width = size.Width; |
| this.height = size.Height; |
| } |
| |
| public static GRect FromLTRB(int left, int top, int right, int bottom) |
| { |
| return new GRect(left, |
| top, |
| right - left, |
| bottom - top); |
| } |
| |
| public GPoint Location |
| { |
| get |
| { |
| return new GPoint(X, Y); |
| } |
| set |
| { |
| X = value.X; |
| Y = value.Y; |
| } |
| } |
| |
| public GPoint RightBottom |
| { |
| get |
| { |
| return new GPoint(Right, Bottom); |
| } |
| } |
| |
| public GPoint RightTop |
| { |
| get |
| { |
| return new GPoint(Right, Top); |
| } |
| } |
| |
| public GPoint LeftBottom |
| { |
| get |
| { |
| return new GPoint(Left, Bottom); |
| } |
| } |
| |
| public GSize Size |
| { |
| get |
| { |
| return new GSize(Width, Height); |
| } |
| set |
| { |
| this.Width = value.Width; |
| this.Height = value.Height; |
| } |
| } |
| |
| public long X |
| { |
| get |
| { |
| return x; |
| } |
| set |
| { |
| x = value; |
| } |
| } |
| |
| public long Y |
| { |
| get |
| { |
| return y; |
| } |
| set |
| { |
| y = value; |
| } |
| } |
| |
| public long Width |
| { |
| get |
| { |
| return width; |
| } |
| set |
| { |
| width = value; |
| } |
| } |
| |
| public long Height |
| { |
| get |
| { |
| return height; |
| } |
| set |
| { |
| height = value; |
| } |
| } |
| |
| public long Left |
| { |
| get |
| { |
| return X; |
| } |
| } |
| |
| public long Top |
| { |
| get |
| { |
| return Y; |
| } |
| } |
| |
| public long Right |
| { |
| get |
| { |
| return X + Width; |
| } |
| } |
| |
| public long Bottom |
| { |
| get |
| { |
| return Y + Height; |
| } |
| } |
| |
| public bool IsEmpty |
| { |
| get |
| { |
| return height == 0 && width == 0 && x == 0 && y == 0; |
| } |
| } |
| |
| public override bool Equals(object obj) |
| { |
| if(!(obj is GRect)) |
| return false; |
| |
| GRect comp = (GRect) obj; |
| |
| return (comp.X == this.X) && |
| (comp.Y == this.Y) && |
| (comp.Width == this.Width) && |
| (comp.Height == this.Height); |
| } |
| |
| public static bool operator==(GRect left, GRect right) |
| { |
| return (left.X == right.X |
| && left.Y == right.Y |
| && left.Width == right.Width |
| && left.Height == right.Height); |
| } |
| |
| public static bool operator!=(GRect left, GRect right) |
| { |
| return !(left == right); |
| } |
| |
| public bool Contains(long x, long y) |
| { |
| return this.X <= x && |
| x < this.X + this.Width && |
| this.Y <= y && |
| y < this.Y + this.Height; |
| } |
| |
| public bool Contains(GPoint pt) |
| { |
| return Contains(pt.X, pt.Y); |
| } |
| |
| public bool Contains(GRect rect) |
| { |
| return (this.X <= rect.X) && |
| ((rect.X + rect.Width) <= (this.X + this.Width)) && |
| (this.Y <= rect.Y) && |
| ((rect.Y + rect.Height) <= (this.Y + this.Height)); |
| } |
| |
| public override int GetHashCode() |
| { |
| if(this.IsEmpty) |
| { |
| return 0; |
| } |
| return (int)(((this.X ^ ((this.Y << 13) | (this.Y >> 0x13))) ^ ((this.Width << 0x1a) | (this.Width >> 6))) ^ ((this.Height << 7) | (this.Height >> 0x19))); |
| } |
| |
| public void Inflate(long width, long height) |
| { |
| this.X -= width; |
| this.Y -= height; |
| this.Width += 2*width; |
| this.Height += 2*height; |
| } |
| |
| public void Inflate(GSize size) |
| { |
| Inflate(size.Width, size.Height); |
| } |
| |
| public static GRect Inflate(GRect rect, long x, long y) |
| { |
| GRect r = rect; |
| r.Inflate(x, y); |
| return r; |
| } |
| |
| public void Intersect(GRect rect) |
| { |
| GRect result = GRect.Intersect(rect, this); |
| |
| this.X = result.X; |
| this.Y = result.Y; |
| this.Width = result.Width; |
| this.Height = result.Height; |
| } |
| |
| public static GRect Intersect(GRect a, GRect b) |
| { |
| long x1 = Math.Max(a.X, b.X); |
| long x2 = Math.Min(a.X + a.Width, b.X + b.Width); |
| long y1 = Math.Max(a.Y, b.Y); |
| long y2 = Math.Min(a.Y + a.Height, b.Y + b.Height); |
| |
| if(x2 >= x1 |
| && y2 >= y1) |
| { |
| |
| return new GRect(x1, y1, x2 - x1, y2 - y1); |
| } |
| return GRect.Empty; |
| } |
| |
| public bool IntersectsWith(GRect rect) |
| { |
| return (rect.X < this.X + this.Width) && |
| (this.X < (rect.X + rect.Width)) && |
| (rect.Y < this.Y + this.Height) && |
| (this.Y < rect.Y + rect.Height); |
| } |
| |
| public static GRect Union(GRect a, GRect b) |
| { |
| long x1 = Math.Min(a.X, b.X); |
| long x2 = Math.Max(a.X + a.Width, b.X + b.Width); |
| long y1 = Math.Min(a.Y, b.Y); |
| long y2 = Math.Max(a.Y + a.Height, b.Y + b.Height); |
| |
| return new GRect(x1, y1, x2 - x1, y2 - y1); |
| } |
| |
| public void Offset(GPoint pos) |
| { |
| Offset(pos.X, pos.Y); |
| } |
| |
| public void OffsetNegative(GPoint pos) |
| { |
| Offset(-pos.X, -pos.Y); |
| } |
| |
| public void Offset(long x, long y) |
| { |
| this.X += x; |
| this.Y += y; |
| } |
| |
| public override string ToString() |
| { |
| return "{X=" + X.ToString(CultureInfo.CurrentCulture) + ",Y=" + Y.ToString(CultureInfo.CurrentCulture) + |
| ",Width=" + Width.ToString(CultureInfo.CurrentCulture) + |
| ",Height=" + Height.ToString(CultureInfo.CurrentCulture) + "}"; |
| } |
| } |
| } |