Rectangle.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CommonUI / System / Drawing / Rectangle.cs / 1305376 / Rectangle.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Drawing { 
    using System.Runtime.Serialization.Formatters; 

    using System.Diagnostics; 

    using System;
    using System.IO;
    using Microsoft.Win32; 
    using System.ComponentModel;
    using System.Globalization; 
 

    ///  
    /// 
    ///    
    ///       Stores the location and size of a rectangular region. For
    ///       more advanced region functions use a  
    ///       object.
    ///     
    ///  
    [
    TypeConverterAttribute(typeof(RectangleConverter)), 
    ]
    [Serializable]
    [System.Runtime.InteropServices.ComVisible(true)]
    public struct Rectangle { 

        ///  
        ///  
        ///    
        ///       Stores the location and size of a rectangular region. For 
        ///       more advanced region functions use a 
        ///       object.
        ///    
        ///  
        public static readonly Rectangle Empty = new Rectangle();
 
        private int x; 
        private int y;
        private int width; 
        private int height;

        /// 
        ///  
        ///    
        ///       Initializes a new instance of the  
        ///       class with the specified location and size. 
        ///    
        ///  
        public Rectangle(int x, int y, int width, int height) {
            this.x = x;
            this.y = y;
            this.width = width; 
            this.height = height;
        } 
 
        /// 
        ///  
        ///    
        ///       Initializes a new instance of the Rectangle class with the specified location
        ///       and size.
        ///     
        /// 
        public Rectangle(Point location, Size size) { 
            this.x = location.X; 
            this.y = location.Y;
            this.width = size.Width; 
            this.height = size.Height;
        }

        ///  
        /// 
        ///    Creates a new  with 
        ///    the specified location and size. 
        /// 
        // !! Not in C++ version 
        [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
        public static Rectangle FromLTRB(int left, int top, int right, int bottom) {
            return new Rectangle(left,
                                 top, 
                                 right - left,
                                 bottom - top); 
        } 

        ///  
        /// 
        ///    
        ///       Gets or sets the coordinates of the
        ///       upper-left corner of the rectangular region represented by this . 
        ///    
        ///  
        [Browsable(false)] 
        public Point Location {
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")] 
            get {
                return new Point(X, Y);
            }
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")] 
            set {
                X = value.X; 
                Y = value.Y; 
            }
        } 

        /// 
        /// 
        ///    Gets or sets the size of this . 
        /// 
        [Browsable(false)] 
        public Size Size { 
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
            get { 
                return new Size(Width, Height);
            }
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
            set { 
                this.Width = value.Width;
                this.Height = value.Height; 
            } 
        }
 
        /// 
        /// 
        ///    Gets or sets the x-coordinate of the
        ///    upper-left corner of the rectangular region defined by this . 
        /// 
        public int X { 
            get { 
                return x;
            } 
            set {
                x = value;
            }
        } 

        ///  
        ///  
        ///    Gets or sets the y-coordinate of the
        ///    upper-left corner of the rectangular region defined by this . 
        /// 
        public int Y {
            get {
                return y; 
            }
            set { 
                y = value; 
            }
        } 

        /// 
        /// 
        ///    Gets or sets the width of the rectangular 
        ///    region defined by this .
        ///  
        public int Width { 
            get {
                return width; 
            }
            set {
                width = value;
            } 
        }
 
        ///  
        /// 
        ///    Gets or sets the width of the rectangular 
        ///    region defined by this .
        /// 
        public int Height {
            get { 
                return height;
            } 
            set { 
                height = value;
            } 
        }

        /// 
        ///  
        ///    
        ///       Gets the x-coordinate of the upper-left corner of the 
        ///       rectangular region defined by this  . 
        ///    
        ///  
        [Browsable(false)]
        public int Left {
            get {
                return X; 
            }
        } 
        ///  
        /// 
        ///     
        ///       Gets the y-coordinate of the upper-left corner of the
        ///       rectangular region defined by this .
        ///    
        ///  
        [Browsable(false)]
        public int Top { 
            get { 
                return Y;
            } 
        }

        /// 
        ///  
        ///    
        ///       Gets the x-coordinate of the lower-right corner of the 
        ///       rectangular region defined by this . 
        ///    
        ///  
        [Browsable(false)]
        public int Right {
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
            get { 
                return X + Width;
            } 
        } 

        ///  
        /// 
        ///    
        ///       Gets the y-coordinate of the lower-right corner of the
        ///       rectangular region defined by this . 
        ///    
        ///  
        [Browsable(false)] 
        public int Bottom {
            [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")] 
            get {
                return Y + Height;
            }
        } 

        ///  
        ///  
        ///    
        ///       Tests whether this  has a  
        ///       or a  of 0.
        ///    
        /// 
        [Browsable(false)] 
        public bool IsEmpty {
            get { 
                return height == 0 && width == 0 && x == 0 && y == 0; 
                // C++ uses this definition:
                // return(Width <= 0 )|| (Height <= 0); 
            }
        }

        ///  
        /// 
        ///     
        ///       Tests whether  is a  with 
        ///       the same location and size of this Rectangle.
        ///     
        /// 
        public override bool Equals(object obj) {
            if (!(obj is Rectangle))
                return false; 

            Rectangle comp = (Rectangle)obj; 
 
            return(comp.X == this.X) &&
            (comp.Y == this.Y) && 
            (comp.Width == this.Width) &&
            (comp.Height == this.Height);
        }
 
        /// 
        ///  
        ///     
        ///       Tests whether two 
        ///       objects have equal location and size. 
        ///    
        /// 
        public static bool operator ==(Rectangle left, Rectangle right) {
            return (left.X == right.X 
                    && left.Y == right.Y
                    && left.Width == right.Width 
                    && left.Height == right.Height); 
        }
 
        /// 
        /// 
        ///    
        ///       Tests whether two  
        ///       objects differ in location or size.
        ///     
        ///  
        [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
        public static bool operator !=(Rectangle left, Rectangle right) { 
            return !(left == right);
        }

        ///  
        /// 
        ///   Converts a RectangleF to a Rectangle by performing a ceiling operation on 
        ///   all the coordinates. 
        /// 
        public static Rectangle Ceiling(RectangleF value) { 
            return new Rectangle((int)Math.Ceiling(value.X),
                                 (int)Math.Ceiling(value.Y),
                                 (int)Math.Ceiling(value.Width),
                                 (int)Math.Ceiling(value.Height)); 
        }
 
        ///  
        /// 
        ///   Converts a RectangleF to a Rectangle by performing a truncate operation on 
        ///   all the coordinates.
        /// 
        public static Rectangle Truncate(RectangleF value) {
            return new Rectangle((int)value.X, 
                                 (int)value.Y,
                                 (int)value.Width, 
                                 (int)value.Height); 
        }
 
        /// 
        /// 
        ///   Converts a RectangleF to a Rectangle by performing a round operation on
        ///   all the coordinates. 
        /// 
        public static Rectangle Round(RectangleF value) { 
            return new Rectangle((int)Math.Round(value.X), 
                                 (int)Math.Round(value.Y),
                                 (int)Math.Round(value.Width), 
                                 (int)Math.Round(value.Height));
        }

        ///  
        /// 
        ///     
        ///       Determines if the specfied point is contained within the 
        ///       rectangular region defined by this  .
        ///     
        /// 
        public bool Contains(int x, int y) {
            return this.X <= x &&
            x < this.X + this.Width && 
            this.Y <= y &&
            y < this.Y + this.Height; 
        } 

        ///  
        /// 
        ///    
        ///       Determines if the specfied point is contained within the
        ///       rectangular region defined by this  . 
        ///    
        ///  
        public bool Contains(Point pt) { 
            return Contains(pt.X, pt.Y);
        } 

        /// 
        /// 
        ///     
        ///       Determines if the rectangular region represented by
        ///     is entirely contained within the rectangular region represented by 
        ///       this  . 
        ///    
        ///  
        public bool Contains(Rectangle 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));
        } 
 
        // !! Not in C++ version
        ///  
        /// 
        ///    [To be supplied.]
        /// 
        public override int GetHashCode() { 
            return(int)((UInt32)X ^
                        (((UInt32)Y << 13) | ((UInt32)Y >> 19)) ^ 
                        (((UInt32)Width << 26) | ((UInt32)Width >>  6)) ^ 
                        (((UInt32)Height <<  7) | ((UInt32)Height >> 25)));
        } 

        /// 
        /// 
        ///     
        ///       Inflates this 
        ///       by the specified amount. 
        ///     
        /// 
        [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")] 
        public void Inflate(int width, int height) {
            this.X -= width;
            this.Y -= height;
            this.Width += 2*width; 
            this.Height += 2*height;
        } 
 
        /// 
        ///  
        ///    Inflates this  by the specified amount.
        /// 
        public void Inflate(Size size) {
 
            Inflate(size.Width, size.Height);
        } 
 
        /// 
        ///  
        ///    
        ///       Creates a 
        ///       that is inflated by the specified amount.
        ///     
        /// 
        // !! Not in C++ 
        public static Rectangle Inflate(Rectangle rect, int x, int y) { 
            Rectangle r = rect;
            r.Inflate(x, y); 
            return r;
        }

        ///  
        ///  Creates a Rectangle that represents the intersection between this Rectangle and rect.
        ///  
        public void Intersect(Rectangle rect) { 
            Rectangle result = Rectangle.Intersect(rect, this);
 
            this.X = result.X;
            this.Y = result.Y;
            this.Width = result.Width;
            this.Height = result.Height; 
        }
        ///  
        ///  
        ///    Creates a rectangle that represents the intersetion between a and
        ///    b. If there is no intersection, null is returned. 
        /// 
        public static Rectangle Intersect(Rectangle a, Rectangle b) {
            int x1 = Math.Max(a.X, b.X);
            int x2 = Math.Min(a.X + a.Width, b.X + b.Width); 
            int y1 = Math.Max(a.Y, b.Y);
            int y2 = Math.Min(a.Y + a.Height, b.Y + b.Height); 
 
            if (x2 >= x1
                && y2 >= y1) { 

                return new Rectangle(x1, y1, x2 - x1, y2 - y1);
            }
            return Rectangle.Empty; 
        }
 
        ///  
        /// 
        ///     Determines if this rectangle intersets with rect. 
        /// 
        public bool IntersectsWith(Rectangle 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); 
        } 

        ///  
        /// 
        ///    
        ///       Creates a rectangle that represents the union between a and
        ///       b. 
        ///    
        ///  
        public static Rectangle Union(Rectangle a, Rectangle b) { 
            int x1 = Math.Min(a.X, b.X);
            int x2 = Math.Max(a.X + a.Width, b.X + b.Width); 
            int y1 = Math.Min(a.Y, b.Y);
            int y2 = Math.Max(a.Y + a.Height, b.Y + b.Height);

            return new Rectangle(x1, y1, x2 - x1, y2 - y1); 
        }
 
        ///  
        /// 
        ///     
        ///       Adjusts the location of this rectangle by the specified amount.
        ///    
        /// 
        public void Offset(Point pos) { 
            Offset(pos.X, pos.Y);
        } 
 
        /// 
        ///  
        ///    Adjusts the location of this rectangle by the specified amount.
        /// 
        [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
        public void Offset(int x, int y) { 
            this.X += x;
            this.Y += y; 
        } 

        ///  
        /// 
        ///    
        ///       Converts the attributes of this  to a
        ///       human readable string. 
        ///    
        ///  
        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) + "}";
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK