// // System.Drawing.RectangleF.cs // // Author: // Mike Kestner (mkestner@speakeasy.net) // // Copyright (C) 2001 Mike Kestner // Copyright (C) 2004, 2007 Novell, Inc (http://www.novell.com) // // Permission is hereby granted, free of charge, to any person obtaining // a copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to // permit persons to whom the Software is furnished to do so, subject to // the following conditions: // // The above copyright notice and this permission notice shall be // included in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // using System; using System.ComponentModel; namespace System.Drawing { [Serializable] public struct RectangleF { private float x, y, width, height; /// /// Empty Shared Field /// /// /// /// An uninitialized RectangleF Structure. /// public static readonly RectangleF Empty; #if TARGET_JVM internal java.awt.geom.Rectangle2D NativeObject { get { return new java.awt.geom.Rectangle2D.Float(X,Y,Width,Height); } } #endif /// /// FromLTRB Shared Method /// /// /// /// Produces a RectangleF structure from left, top, right, /// and bottom coordinates. /// public static RectangleF FromLTRB (float left, float top, float right, float bottom) { return new RectangleF (left, top, right - left, bottom - top); } /// /// Inflate Shared Method /// /// /// /// Produces a new RectangleF by inflating an existing /// RectangleF by the specified coordinate values. /// public static RectangleF Inflate (RectangleF rect, float x, float y) { RectangleF ir = new RectangleF (rect.X, rect.Y, rect.Width, rect.Height); ir.Inflate (x, y); return ir; } /// /// Inflate Method /// /// /// /// Inflates the RectangleF by a specified width and height. /// public void Inflate (float x, float y) { Inflate (new SizeF (x, y)); } /// /// Inflate Method /// /// /// /// Inflates the RectangleF by a specified Size. /// public void Inflate (SizeF size) { x -= size.Width; y -= size.Height; width += size.Width * 2; height += size.Height * 2; } /// /// Intersect Shared Method /// /// /// /// Produces a new RectangleF by intersecting 2 existing /// RectangleFs. Returns null if there is no intersection. /// public static RectangleF Intersect (RectangleF a, RectangleF b) { // MS.NET returns a non-empty rectangle if the two rectangles // touch each other if (!a.IntersectsWithInclusive (b)) return Empty; return FromLTRB ( Math.Max (a.Left, b.Left), Math.Max (a.Top, b.Top), Math.Min (a.Right, b.Right), Math.Min (a.Bottom, b.Bottom)); } /// /// Intersect Method /// /// /// /// Replaces the RectangleF with the intersection of itself /// and another RectangleF. /// public void Intersect (RectangleF rect) { this = RectangleF.Intersect (this, rect); } /// /// Union Shared Method /// /// /// /// Produces a new RectangleF from the union of 2 existing /// RectangleFs. /// public static RectangleF Union (RectangleF a, RectangleF b) { return FromLTRB (Math.Min (a.Left, b.Left), Math.Min (a.Top, b.Top), Math.Max (a.Right, b.Right), Math.Max (a.Bottom, b.Bottom)); } /// /// Equality Operator /// /// /// /// Compares two RectangleF objects. The return value is /// based on the equivalence of the Location and Size /// properties of the two RectangleFs. /// public static bool operator == (RectangleF left, RectangleF right) { return (left.X == right.X) && (left.Y == right.Y) && (left.Width == right.Width) && (left.Height == right.Height); } /// /// Inequality Operator /// /// /// /// Compares two RectangleF objects. The return value is /// based on the equivalence of the Location and Size /// properties of the two RectangleFs. /// public static bool operator != (RectangleF left, RectangleF right) { return (left.X != right.X) || (left.Y != right.Y) || (left.Width != right.Width) || (left.Height != right.Height); } /// /// Rectangle to RectangleF Conversion /// /// /// /// Converts a Rectangle object to a RectangleF. /// public static implicit operator RectangleF (Rectangle r) { return new RectangleF (r.X, r.Y, r.Width, r.Height); } // ----------------------- // Public Constructors // ----------------------- /// /// RectangleF Constructor /// /// /// /// Creates a RectangleF from PointF and SizeF values. /// public RectangleF (PointF location, SizeF size) { x = location.X; y = location.Y; width = size.Width; height = size.Height; } /// /// RectangleF Constructor /// /// /// /// Creates a RectangleF from a specified x,y location and /// width and height values. /// public RectangleF (float x, float y, float width, float height) { this.x = x; this.y = y; this.width = width; this.height = height; } #if TARGET_JVM internal RectangleF (java.awt.geom.RectangularShape r2d) { this.x = (float) r2d.getX (); this.y = (float) r2d.getY (); this.width = (float) r2d.getWidth (); this.height = (float) r2d.getHeight (); } #endif /// /// Bottom Property /// /// /// /// The Y coordinate of the bottom edge of the RectangleF. /// Read only. /// [Browsable (false)] public float Bottom { get { return Y + Height; } } /// /// Height Property /// /// /// /// The Height of the RectangleF. /// public float Height { get { return height; } set { height = value; } } /// /// IsEmpty Property /// /// /// /// Indicates if the width or height are zero. Read only. /// // [Browsable (false)] public bool IsEmpty { get { return (width <= 0 || height <= 0); } } /// /// Left Property /// /// /// /// The X coordinate of the left edge of the RectangleF. /// Read only. /// [Browsable (false)] public float Left { get { return X; } } /// /// Location Property /// /// /// /// The Location of the top-left corner of the RectangleF. /// [Browsable (false)] public PointF Location { get { return new PointF (x, y); } set { x = value.X; y = value.Y; } } /// /// Right Property /// /// /// /// The X coordinate of the right edge of the RectangleF. /// Read only. /// [Browsable (false)] public float Right { get { return X + Width; } } /// /// Size Property /// /// /// /// The Size of the RectangleF. /// [Browsable (false)] public SizeF Size { get { return new SizeF (width, height); } set { width = value.Width; height = value.Height; } } /// /// Top Property /// /// /// /// The Y coordinate of the top edge of the RectangleF. /// Read only. /// [Browsable (false)] public float Top { get { return Y; } } /// /// Width Property /// /// /// /// The Width of the RectangleF. /// public float Width { get { return width; } set { width = value; } } /// /// X Property /// /// /// /// The X coordinate of the RectangleF. /// public float X { get { return x; } set { x = value; } } /// /// Y Property /// /// /// /// The Y coordinate of the RectangleF. /// public float Y { get { return y; } set { y = value; } } /// /// Contains Method /// /// /// /// Checks if an x,y coordinate lies within this RectangleF. /// public bool Contains (float x, float y) { return ((x >= Left) && (x < Right) && (y >= Top) && (y < Bottom)); } /// /// Contains Method /// /// /// /// Checks if a Point lies within this RectangleF. /// public bool Contains (PointF pt) { return Contains (pt.X, pt.Y); } /// /// Contains Method /// /// /// /// Checks if a RectangleF lies entirely within this /// RectangleF. /// public bool Contains (RectangleF rect) { return X <= rect.X && Right >= rect.Right && Y <= rect.Y && Bottom >= rect.Bottom; } /// /// Equals Method /// /// /// /// Checks equivalence of this RectangleF and an object. /// public override bool Equals (object obj) { if (!(obj is RectangleF)) return false; return (this == (RectangleF) obj); } /// /// GetHashCode Method /// /// /// /// Calculates a hashing value. /// public override int GetHashCode () { return (int) (x + y + width + height); } /// /// IntersectsWith Method /// /// /// /// Checks if a RectangleF intersects with this one. /// public bool IntersectsWith (RectangleF rect) { return !((Left >= rect.Right) || (Right <= rect.Left) || (Top >= rect.Bottom) || (Bottom <= rect.Top)); } private bool IntersectsWithInclusive (RectangleF r) { return !((Left > r.Right) || (Right < r.Left) || (Top > r.Bottom) || (Bottom < r.Top)); } /// /// Offset Method /// /// /// /// Moves the RectangleF a specified distance. /// public void Offset (float x, float y) { X += x; Y += y; } /// /// Offset Method /// /// /// /// Moves the RectangleF a specified distance. /// public void Offset (PointF pos) { Offset (pos.X, pos.Y); } /// /// ToString Method /// /// /// /// Formats the RectangleF in (x,y,w,h) notation. /// public override string ToString () { return String.Format ("{{X={0},Y={1},Width={2},Height={3}}}", x, y, width, height); } } }