mcs/class/System.Drawing/System.Drawing/RectangleF.cs

   1 //
   2 // System.Drawing.RectangleF.cs
   3 //
   4 // Author:
   5 //   Mike Kestner (mkestner@speakeasy.net)
   6 //
   7 // Copyright (C) 2001 Mike Kestner
   8 // Copyright (C) 2004 Novell, Inc. http://www.novell.com
   9 //
  10
  11 //
  12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System;
  35 using System.ComponentModel;
  36
  37 namespace System.Drawing
  38 {
  39         [Serializable]
  40         public struct RectangleF
  41         {
  42                 private float x, y, width, height;
  43
  44                 /// <summary>
  45                 ///     Empty Shared Field
  46                 /// </summary>
  47                 ///
  48                 /// <remarks>
  49                 ///     An uninitialized RectangleF Structure.
  50                 /// </remarks>
  51
  52                 public static readonly RectangleF Empty;
  53
  54
  55                 /// <summary>
  56                 ///     FromLTRB Shared Method
  57                 /// </summary>
  58                 ///
  59                 /// <remarks>
  60                 ///     Produces a RectangleF structure from left, top, right,
  61                 ///     and bottom coordinates.
  62                 /// </remarks>
  63
  64                 public static RectangleF FromLTRB (float left, float top,
  65                                                    float right, float bottom)
  66                 {
  67                         return new RectangleF (left, top, right - left, bottom - top);
  68                 }
  69
  70                 /// <summary>
  71                 ///     Inflate Shared Method
  72                 /// </summary>
  73                 ///
  74                 /// <remarks>
  75                 ///     Produces a new RectangleF by inflating an existing
  76                 ///     RectangleF by the specified coordinate values.
  77                 /// </remarks>
  78
  79                 public static RectangleF Inflate (RectangleF r,
  80                                                   float x, float y)
  81                 {
  82                         RectangleF ir = new RectangleF (r.X, r.Y, r.Width, r.Height);
  83                         ir.Inflate (x, y);
  84                         return ir;
  85                 }
  86
  87                 /// <summary>
  88                 ///     Inflate Method
  89                 /// </summary>
  90                 ///
  91                 /// <remarks>
  92                 ///     Inflates the RectangleF by a specified width and height.
  93                 /// </remarks>
  94
  95                 public void Inflate (float width, float height)
  96                 {
  97                         x -= width;
  98                         y -= height;
  99                         width += width * 2;
 100                         height += height * 2;
 101                 }
 102
 103                 /// <summary>
 104                 ///     Inflate Method
 105                 /// </summary>
 106                 ///
 107                 /// <remarks>
 108                 ///     Inflates the RectangleF by a specified Size.
 109                 /// </remarks>
 110
 111                 public void Inflate (SizeF sz)
 112                 {
 113                         Inflate (sz.Width, sz.Height);
 114                 }
 115
 116                 /// <summary>
 117                 ///     Intersect Shared Method
 118                 /// </summary>
 119                 ///
 120                 /// <remarks>
 121                 ///     Produces a new RectangleF by intersecting 2 existing
 122                 ///     RectangleFs. Returns null if there is no intersection.
 123                 /// </remarks>
 124
 125                 public static RectangleF Intersect (RectangleF r1,
 126                                                     RectangleF r2)
 127                 {
 128                         RectangleF r = new RectangleF (r1.X, r1.Y, r1.Width, r1.Height);
 129                         r.Intersect (r2);
 130                         return r;
 131                 }
 132
 133                 /// <summary>
 134                 ///     Intersect Method
 135                 /// </summary>
 136                 ///
 137                 /// <remarks>
 138                 ///     Replaces the RectangleF with the intersection of itself
 139                 ///     and another RectangleF.
 140                 /// </remarks>
 141
 142                 public void Intersect (RectangleF r)
 143                 {
 144                         if (!IntersectsWith (r)) {
 145                                 x = 0;
 146                                 y = 0;
 147                                 width = 0;
 148                                 height = 0;
 149                         }
 150
 151                         x = Math.Max (Left, r.Left);
 152                         y = Math.Max (Top, r.Top);
 153                         width = Math.Min (Right, r.Right) - X;
 154                         height = Math.Min (Bottom, r.Bottom) - Y;
 155                 }
 156
 157                 /// <summary>
 158                 ///     Union Shared Method
 159                 /// </summary>
 160                 ///
 161                 /// <remarks>
 162                 ///     Produces a new RectangleF from the union of 2 existing
 163                 ///     RectangleFs.
 164                 /// </remarks>
 165
 166                 public static RectangleF Union (RectangleF r1, RectangleF r2)
 167                 {
 168                         return FromLTRB (Math.Min (r1.Left, r2.Left),
 169                                          Math.Min (r1.Top, r2.Top),
 170                                          Math.Max (r1.Right, r2.Right),
 171                                          Math.Max (r1.Bottom, r2.Bottom));
 172                 }
 173
 174                 /// <summary>
 175                 ///     Equality Operator
 176                 /// </summary>
 177                 ///
 178                 /// <remarks>
 179                 ///     Compares two RectangleF objects. The return value is
 180                 ///     based on the equivalence of the Location and Size
 181                 ///     properties of the two RectangleFs.
 182                 /// </remarks>
 183
 184                 public static bool operator == (RectangleF r1, RectangleF r2)
 185                 {
 186                         return (r1.X == r2.X) && (r1.Y == r2.Y) &&
 187                                 (r1.Width == r2.Width) && (r1.Height == r2.Height);
 188                 }
 189
 190                 /// <summary>
 191                 ///     Inequality Operator
 192                 /// </summary>
 193                 ///
 194                 /// <remarks>
 195                 ///     Compares two RectangleF objects. The return value is
 196                 ///     based on the equivalence of the Location and Size
 197                 ///     properties of the two RectangleFs.
 198                 /// </remarks>
 199
 200                 public static bool operator != (RectangleF r1, RectangleF r2)
 201                 {
 202                         return (r1.X != r2.X) && (r1.Y != r2.Y) &&
 203                                 (r1.Width != r2.Width) && (r1.Height != r2.Height);
 204                 }
 205
 206                 /// <summary>
 207                 ///     Rectangle to RectangleF Conversion
 208                 /// </summary>
 209                 ///
 210                 /// <remarks>
 211                 ///     Converts a Rectangle object to a RectangleF.
 212                 /// </remarks>
 213
 214                 public static implicit operator RectangleF (Rectangle r)
 215                 {
 216                         return new RectangleF (r.X, r.Y, r.Width, r.Height);
 217                 }
 218
 219
 220                 // -----------------------
 221                 // Public Constructors
 222                 // -----------------------
 223
 224                 /// <summary>
 225                 ///     RectangleF Constructor
 226                 /// </summary>
 227                 ///
 228                 /// <remarks>
 229                 ///     Creates a RectangleF from PointF and SizeF values.
 230                 /// </remarks>
 231
 232                 public RectangleF (PointF loc, SizeF sz)
 233                 {
 234                         x = loc.X;
 235                         y = loc.Y;
 236                         width = sz.Width;
 237                         height = sz.Height;
 238                 }
 239
 240                 /// <summary>
 241                 ///     RectangleF Constructor
 242                 /// </summary>
 243                 ///
 244                 /// <remarks>
 245                 ///     Creates a RectangleF from a specified x,y location and
 246                 ///     width and height values.
 247                 /// </remarks>
 248
 249                 public RectangleF (float x, float y, float width, float height)
 250                 {
 251                         this.x = x;
 252                         this.y = y;
 253                         this.width = width;
 254                         this.height = height;
 255                 }
 256
 257
 258
 259                 /// <summary>
 260                 ///     Bottom Property
 261                 /// </summary>
 262                 ///
 263                 /// <remarks>
 264                 ///     The Y coordinate of the bottom edge of the RectangleF.
 265                 ///     Read only.
 266                 /// </remarks>
 267
 268                 [Browsable (false)]
 269                 public float Bottom {
 270                         get {
 271                                 return Y + Height;
 272                         }
 273                 }
 274
 275                 /// <summary>
 276                 ///     Height Property
 277                 /// </summary>
 278                 ///
 279                 /// <remarks>
 280                 ///     The Height of the RectangleF.
 281                 /// </remarks>
 282
 283                 public float Height {
 284                         get {
 285                                 return height;
 286                         }
 287                         set {
 288                                 height = value;
 289                         }
 290                 }
 291
 292                 /// <summary>
 293                 ///     IsEmpty Property
 294                 /// </summary>
 295                 ///
 296                 /// <remarks>
 297                 ///     Indicates if the width or height are zero. Read only.
 298                 /// </remarks>
 299                 //
 300                 // LAMESPEC: Documentation says "This property returns true if
 301                 // the Width, Height, X, and Y properties of this RectangleF all
 302                 // have values of zero; otherwise, false.". Reality returns TRUE if
 303                 // width or height are equal 0
 304
 305                 [Browsable (false)]
 306                 public bool IsEmpty {
 307                         get {
 308                                 return ((width == 0) || (height == 0));
 309                         }
 310                 }
 311
 312                 /// <summary>
 313                 ///     Left Property
 314                 /// </summary>
 315                 ///
 316                 /// <remarks>
 317                 ///     The X coordinate of the left edge of the RectangleF.
 318                 ///     Read only.
 319                 /// </remarks>
 320
 321                 [Browsable (false)]
 322                 public float Left {
 323                         get {
 324                                 return X;
 325                         }
 326                 }
 327
 328                 /// <summary>
 329                 ///     Location Property
 330                 /// </summary>
 331                 ///
 332                 /// <remarks>
 333                 ///     The Location of the top-left corner of the RectangleF.
 334                 /// </remarks>
 335
 336                 [Browsable (false)]
 337                 public PointF Location {
 338                         get {
 339                                 return new PointF (x, y);
 340                         }
 341                         set {
 342                                 x = value.X;
 343                                 y = value.Y;
 344                         }
 345                 }
 346
 347                 /// <summary>
 348                 ///     Right Property
 349                 /// </summary>
 350                 ///
 351                 /// <remarks>
 352                 ///     The X coordinate of the right edge of the RectangleF.
 353                 ///     Read only.
 354                 /// </remarks>
 355
 356                 [Browsable (false)]
 357                 public float Right {
 358                         get {
 359                                 return X + Width;
 360                         }
 361                 }
 362
 363                 /// <summary>
 364                 ///     Size Property
 365                 /// </summary>
 366                 ///
 367                 /// <remarks>
 368                 ///     The Size of the RectangleF.
 369                 /// </remarks>
 370
 371                 [Browsable (false)]
 372                 public SizeF Size {
 373                         get {
 374                                 return new SizeF (width, height);
 375                         }
 376                         set {
 377                                 width = value.Width;
 378                                 height = value.Height;
 379                         }
 380                 }
 381
 382                 /// <summary>
 383                 ///     Top Property
 384                 /// </summary>
 385                 ///
 386                 /// <remarks>
 387                 ///     The Y coordinate of the top edge of the RectangleF.
 388                 ///     Read only.
 389                 /// </remarks>
 390
 391                 [Browsable (false)]
 392                 public float Top {
 393                         get {
 394                                 return Y;
 395                         }
 396                 }
 397
 398                 /// <summary>
 399                 ///     Width Property
 400                 /// </summary>
 401                 ///
 402                 /// <remarks>
 403                 ///     The Width of the RectangleF.
 404                 /// </remarks>
 405
 406                 public float Width {
 407                         get {
 408                                 return width;
 409                         }
 410                         set {
 411                                 width = value;
 412                         }
 413                 }
 414
 415                 /// <summary>
 416                 ///     X Property
 417                 /// </summary>
 418                 ///
 419                 /// <remarks>
 420                 ///     The X coordinate of the RectangleF.
 421                 /// </remarks>
 422
 423                 public float X {
 424                         get {
 425                                 return x;
 426                         }
 427                         set {
 428                                 x = value;
 429                         }
 430                 }
 431
 432                 /// <summary>
 433                 ///     Y Property
 434                 /// </summary>
 435                 ///
 436                 /// <remarks>
 437                 ///     The Y coordinate of the RectangleF.
 438                 /// </remarks>
 439
 440                 public float Y {
 441                         get {
 442                                 return y;
 443                         }
 444                         set {
 445                                 y = value;
 446                         }
 447                 }
 448
 449                 /// <summary>
 450                 ///     Contains Method
 451                 /// </summary>
 452                 ///
 453                 /// <remarks>
 454                 ///     Checks if an x,y coordinate lies within this RectangleF.
 455                 /// </remarks>
 456
 457                 public bool Contains (float x, float y)
 458                 {
 459                         return ((x >= Left) && (x <= Right) &&
 460                                 (y >= Top) && (y <= Bottom));
 461                 }
 462
 463                 /// <summary>
 464                 ///     Contains Method
 465                 /// </summary>
 466                 ///
 467                 /// <remarks>
 468                 ///     Checks if a Point lies within this RectangleF.
 469                 /// </remarks>
 470
 471                 public bool Contains (PointF pt)
 472                 {
 473                         return Contains (pt.X, pt.Y);
 474                 }
 475
 476                 /// <summary>
 477                 ///     Contains Method
 478                 /// </summary>
 479                 ///
 480                 /// <remarks>
 481                 ///     Checks if a RectangleF lies entirely within this
 482                 ///     RectangleF.
 483                 /// </remarks>
 484
 485                 public bool Contains (RectangleF rect)
 486                 {
 487                         return (rect == Intersect (this, rect));
 488                 }
 489
 490                 /// <summary>
 491                 ///     Equals Method
 492                 /// </summary>
 493                 ///
 494                 /// <remarks>
 495                 ///     Checks equivalence of this RectangleF and an object.
 496                 /// </remarks>
 497
 498                 public override bool Equals (object o)
 499                 {
 500                         if (!(o is RectangleF))
 501                                 return false;
 502
 503                         return (this == (RectangleF) o);
 504                 }
 505
 506                 /// <summary>
 507                 ///     GetHashCode Method
 508                 /// </summary>
 509                 ///
 510                 /// <remarks>
 511                 ///     Calculates a hashing value.
 512                 /// </remarks>
 513
 514                 public override int GetHashCode ()
 515                 {
 516                         return (int) (x + y + width + height);
 517                 }
 518
 519                 /// <summary>
 520                 ///     IntersectsWith Method
 521                 /// </summary>
 522                 ///
 523                 /// <remarks>
 524                 ///     Checks if a RectangleF intersects with this one.
 525                 /// </remarks>
 526
 527                 public bool IntersectsWith (RectangleF r)
 528                 {
 529                         return !((Left > r.Right) || (Right < r.Left) ||
 530                             (Top > r.Bottom) || (Bottom < r.Top));
 531                 }
 532
 533                 /// <summary>
 534                 ///     Offset Method
 535                 /// </summary>
 536                 ///
 537                 /// <remarks>
 538                 ///     Moves the RectangleF a specified distance.
 539                 /// </remarks>
 540
 541                 public void Offset (float dx, float dy)
 542                 {
 543                         X += dx;
 544                         Y += dy;
 545                 }
 546
 547                 /// <summary>
 548                 ///     Offset Method
 549                 /// </summary>
 550                 ///
 551                 /// <remarks>
 552                 ///     Moves the RectangleF a specified distance.
 553                 /// </remarks>
 554
 555                 public void Offset (PointF pt)
 556                 {
 557                         Offset(pt.X, pt.Y);
 558                 }
 559
 560                 /// <summary>
 561                 ///     ToString Method
 562                 /// </summary>
 563                 ///
 564                 /// <remarks>
 565                 ///     Formats the RectangleF in (x,y,w,h) notation.
 566                 /// </remarks>
 567
 568                 public override string ToString ()
 569                 {
 570                         return String.Format ("{{X={0},Y={1},Width={2},Height={3}}}",
 571                                                  x, y, width, height);
 572                 }
 573
 574         }
 575 }