?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-07 Jb Evain <jbevain@novell.com>
[mcs.git] / class / System.Drawing / System.Drawing / Rectangle.cs
blob1ba6fd32a0b12bb702a23dae6913fcf7eb6592bb
1 //
2 // System.Drawing.Rectangle.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.Runtime.InteropServices;
36 using System.ComponentModel;
37
38 namespace System.Drawing
39 {
40 [Serializable]
41 [ComVisible (true)]
42 [TypeConverter (typeof (RectangleConverter))]
43 public struct Rectangle
44 {
45 private int x, y, width, height;
46
47 /// <summary>
48 /// Empty Shared Field
49 /// </summary>
50 ///
51 /// <remarks>
52 /// An uninitialized Rectangle Structure.
53 /// </remarks>
54
55 public static readonly Rectangle Empty;
56
57 #if TARGET_JVM
58 internal java.awt.Rectangle NativeObject {
59 get {
60 return new java.awt.Rectangle(X,Y,Width,Height);
61 }
62 }
63 #endif
64
65 /// <summary>
66 /// Ceiling Shared Method
67 /// </summary>
68 ///
69 /// <remarks>
70 /// Produces a Rectangle structure from a RectangleF
71 /// structure by taking the ceiling of the X, Y, Width,
72 /// and Height properties.
73 /// </remarks>
74
75 public static Rectangle Ceiling (RectangleF value)
76 {
77 int x, y, w, h;
78 checked {
79 x = (int) Math.Ceiling (value.X);
80 y = (int) Math.Ceiling (value.Y);
81 w = (int) Math.Ceiling (value.Width);
82 h = (int) Math.Ceiling (value.Height);
83 }
84
85 return new Rectangle (x, y, w, h);
86 }
87
88 /// <summary>
89 /// FromLTRB Shared Method
90 /// </summary>
91 ///
92 /// <remarks>
93 /// Produces a Rectangle structure from left, top, right,
94 /// and bottom coordinates.
95 /// </remarks>
96
97 public static Rectangle FromLTRB (int left, int top,
98 int right, int bottom)
99 {
100 return new Rectangle (left, top, right - left,
101 bottom - top);
102 }
103
104 /// <summary>
105 /// Inflate Shared Method
106 /// </summary>
107 ///
108 /// <remarks>
109 /// Produces a new Rectangle by inflating an existing
110 /// Rectangle by the specified coordinate values.
111 /// </remarks>
112
113 public static Rectangle Inflate (Rectangle rect, int x, int y)
114 {
115 Rectangle r = new Rectangle (rect.Location, rect.Size);
116 r.Inflate (x, y);
117 return r;
118 }
119
120 /// <summary>
121 /// Inflate Method
122 /// </summary>
123 ///
124 /// <remarks>
125 /// Inflates the Rectangle by a specified width and height.
126 /// </remarks>
127
128 public void Inflate (int width, int height)
129 {
130 Inflate (new Size (width, height));
131 }
132
133 /// <summary>
134 /// Inflate Method
135 /// </summary>
136 ///
137 /// <remarks>
138 /// Inflates the Rectangle by a specified Size.
139 /// </remarks>
140
141 public void Inflate (Size size)
142 {
143 x -= size.Width;
144 y -= size.Height;
145 Width += size.Width * 2;
146 Height += size.Height * 2;
147 }
148
149 /// <summary>
150 /// Intersect Shared Method
151 /// </summary>
152 ///
153 /// <remarks>
154 /// Produces a new Rectangle by intersecting 2 existing
155 /// Rectangles. Returns null if there is no intersection.
156 /// </remarks>
157
158 public static Rectangle Intersect (Rectangle a, Rectangle b)
159 {
160 // MS.NET returns a non-empty rectangle if the two rectangles
161 // touch each other
162 if (!a.IntersectsWithInclusive (b))
163 return Empty;
164
165 return Rectangle.FromLTRB (
166 Math.Max (a.Left, b.Left),
167 Math.Max (a.Top, b.Top),
168 Math.Min (a.Right, b.Right),
169 Math.Min (a.Bottom, b.Bottom));
170 }
171
172 /// <summary>
173 /// Intersect Method
174 /// </summary>
175 ///
176 /// <remarks>
177 /// Replaces the Rectangle with the intersection of itself
178 /// and another Rectangle.
179 /// </remarks>
180
181 public void Intersect (Rectangle rect)
182 {
183 this = Rectangle.Intersect (this, rect);
184 }
185
186 /// <summary>
187 /// Round Shared Method
188 /// </summary>
189 ///
190 /// <remarks>
191 /// Produces a Rectangle structure from a RectangleF by
192 /// rounding the X, Y, Width, and Height properties.
193 /// </remarks>
194
195 public static Rectangle Round (RectangleF value)
196 {
197 int x, y, w, h;
198 checked {
199 x = (int) Math.Round (value.X);
200 y = (int) Math.Round (value.Y);
201 w = (int) Math.Round (value.Width);
202 h = (int) Math.Round (value.Height);
203 }
204
205 return new Rectangle (x, y, w, h);
206 }
207
208 /// <summary>
209 /// Truncate Shared Method
210 /// </summary>
211 ///
212 /// <remarks>
213 /// Produces a Rectangle structure from a RectangleF by
214 /// truncating the X, Y, Width, and Height properties.
215 /// </remarks>
216
217 // LAMESPEC: Should this be floor, or a pure cast to int?
218
219 public static Rectangle Truncate (RectangleF value)
220 {
221 int x, y, w, h;
222 checked {
223 x = (int) value.X;
224 y = (int) value.Y;
225 w = (int) value.Width;
226 h = (int) value.Height;
227 }
228
229 return new Rectangle (x, y, w, h);
230 }
231
232 /// <summary>
233 /// Union Shared Method
234 /// </summary>
235 ///
236 /// <remarks>
237 /// Produces a new Rectangle from the union of 2 existing
238 /// Rectangles.
239 /// </remarks>
240
241 public static Rectangle Union (Rectangle a, Rectangle b)
242 {
243 return FromLTRB (Math.Min (a.Left, b.Left),
244 Math.Min (a.Top, b.Top),
245 Math.Max (a.Right, b.Right),
246 Math.Max (a.Bottom, b.Bottom));
247 }
248
249 /// <summary>
250 /// Equality Operator
251 /// </summary>
252 ///
253 /// <remarks>
254 /// Compares two Rectangle objects. The return value is
255 /// based on the equivalence of the Location and Size
256 /// properties of the two Rectangles.
257 /// </remarks>
258
259 public static bool operator == (Rectangle left, Rectangle right)
260 {
261 return ((left.Location == right.Location) &&
262 (left.Size == right.Size));
263 }
264
265 /// <summary>
266 /// Inequality Operator
267 /// </summary>
268 ///
269 /// <remarks>
270 /// Compares two Rectangle objects. The return value is
271 /// based on the equivalence of the Location and Size
272 /// properties of the two Rectangles.
273 /// </remarks>
274
275 public static bool operator != (Rectangle left, Rectangle right)
276 {
277 return ((left.Location != right.Location) ||
278 (left.Size != right.Size));
279 }
280
281
282 // -----------------------
283 // Public Constructors
284 // -----------------------
285
286 /// <summary>
287 /// Rectangle Constructor
288 /// </summary>
289 ///
290 /// <remarks>
291 /// Creates a Rectangle from Point and Size values.
292 /// </remarks>
293
294 public Rectangle (Point location, Size size)
295 {
296 x = location.X;
297 y = location.Y;
298 width = size.Width;
299 height = size.Height;
300 }
301
302 /// <summary>
303 /// Rectangle Constructor
304 /// </summary>
305 ///
306 /// <remarks>
307 /// Creates a Rectangle from a specified x,y location and
308 /// width and height values.
309 /// </remarks>
310
311 public Rectangle (int x, int y, int width, int height)
312 {
313 this.x = x;
314 this.y = y;
315 this.width = width;
316 this.height = height;
317 }
318
319
320
321 /// <summary>
322 /// Bottom Property
323 /// </summary>
324 ///
325 /// <remarks>
326 /// The Y coordinate of the bottom edge of the Rectangle.
327 /// Read only.
328 /// </remarks>
329
330 [Browsable (false)]
331 public int Bottom {
332 get {
333 return y + height;
334 }
335 }
336
337 /// <summary>
338 /// Height Property
339 /// </summary>
340 ///
341 /// <remarks>
342 /// The Height of the Rectangle.
343 /// </remarks>
344
345 public int Height {
346 get {
347 return height;
348 }
349 set {
350 height = value;
351 }
352 }
353
354 /// <summary>
355 /// IsEmpty Property
356 /// </summary>
357 ///
358 /// <remarks>
359 /// Indicates if the width or height are zero. Read only.
360 /// </remarks>
361 [Browsable (false)]
362 public bool IsEmpty {
363 get {
364 return ((x == 0) && (y == 0) && (width == 0) && (height == 0));
365 }
366 }
367
368 /// <summary>
369 /// Left Property
370 /// </summary>
371 ///
372 /// <remarks>
373 /// The X coordinate of the left edge of the Rectangle.
374 /// Read only.
375 /// </remarks>
376
377 [Browsable (false)]
378 public int Left {
379 get {
380 return X;
381 }
382 }
383
384 /// <summary>
385 /// Location Property
386 /// </summary>
387 ///
388 /// <remarks>
389 /// The Location of the top-left corner of the Rectangle.
390 /// </remarks>
391
392 [Browsable (false)]
393 public Point Location {
394 get {
395 return new Point (x, y);
396 }
397 set {
398 x = value.X;
399 y = value.Y;
400 }
401 }
402
403 /// <summary>
404 /// Right Property
405 /// </summary>
406 ///
407 /// <remarks>
408 /// The X coordinate of the right edge of the Rectangle.
409 /// Read only.
410 /// </remarks>
411
412 [Browsable (false)]
413 public int Right {
414 get {
415 return X + Width;
416 }
417 }
418
419 /// <summary>
420 /// Size Property
421 /// </summary>
422 ///
423 /// <remarks>
424 /// The Size of the Rectangle.
425 /// </remarks>
426
427 [Browsable (false)]
428 public Size Size {
429 get {
430 return new Size (Width, Height);
431 }
432 set {
433 Width = value.Width;
434 Height = value.Height;
435 }
436 }
437
438 /// <summary>
439 /// Top Property
440 /// </summary>
441 ///
442 /// <remarks>
443 /// The Y coordinate of the top edge of the Rectangle.
444 /// Read only.
445 /// </remarks>
446
447 [Browsable (false)]
448 public int Top {
449 get {
450 return y;
451 }
452 }
453
454 /// <summary>
455 /// Width Property
456 /// </summary>
457 ///
458 /// <remarks>
459 /// The Width of the Rectangle.
460 /// </remarks>
461
462 public int Width {
463 get {
464 return width;
465 }
466 set {
467 width = value;
468 }
469 }
470
471 /// <summary>
472 /// X Property
473 /// </summary>
474 ///
475 /// <remarks>
476 /// The X coordinate of the Rectangle.
477 /// </remarks>
478
479 public int X {
480 get {
481 return x;
482 }
483 set {
484 x = value;
485 }
486 }
487
488 /// <summary>
489 /// Y Property
490 /// </summary>
491 ///
492 /// <remarks>
493 /// The Y coordinate of the Rectangle.
494 /// </remarks>
495
496 public int Y {
497 get {
498 return y;
499 }
500 set {
501 y = value;
502 }
503 }
504
505 /// <summary>
506 /// Contains Method
507 /// </summary>
508 ///
509 /// <remarks>
510 /// Checks if an x,y coordinate lies within this Rectangle.
511 /// </remarks>
512
513 public bool Contains (int x, int y)
514 {
515 return ((x >= Left) && (x < Right) &&
516 (y >= Top) && (y < Bottom));
517 }
518
519 /// <summary>
520 /// Contains Method
521 /// </summary>
522 ///
523 /// <remarks>
524 /// Checks if a Point lies within this Rectangle.
525 /// </remarks>
526
527 public bool Contains (Point pt)
528 {
529 return Contains (pt.X, pt.Y);
530 }
531
532 /// <summary>
533 /// Contains Method
534 /// </summary>
535 ///
536 /// <remarks>
537 /// Checks if a Rectangle lies entirely within this
538 /// Rectangle.
539 /// </remarks>
540
541 public bool Contains (Rectangle rect)
542 {
543 return (rect == Intersect (this, rect));
544 }
545
546 /// <summary>
547 /// Equals Method
548 /// </summary>
549 ///
550 /// <remarks>
551 /// Checks equivalence of this Rectangle and another object.
552 /// </remarks>
553
554 public override bool Equals (object obj)
555 {
556 if (!(obj is Rectangle))
557 return false;
558
559 return (this == (Rectangle) obj);
560 }
561
562 /// <summary>
563 /// GetHashCode Method
564 /// </summary>
565 ///
566 /// <remarks>
567 /// Calculates a hashing value.
568 /// </remarks>
569
570 public override int GetHashCode ()
571 {
572 return (height + width) ^ x + y;
573 }
574
575 /// <summary>
576 /// IntersectsWith Method
577 /// </summary>
578 ///
579 /// <remarks>
580 /// Checks if a Rectangle intersects with this one.
581 /// </remarks>
582
583 public bool IntersectsWith (Rectangle rect)
584 {
585 return !((Left >= rect.Right) || (Right <= rect.Left) ||
586 (Top >= rect.Bottom) || (Bottom <= rect.Top));
587 }
588
589 private bool IntersectsWithInclusive (Rectangle r)
590 {
591 return !((Left > r.Right) || (Right < r.Left) ||
592 (Top > r.Bottom) || (Bottom < r.Top));
593 }
594
595 /// <summary>
596 /// Offset Method
597 /// </summary>
598 ///
599 /// <remarks>
600 /// Moves the Rectangle a specified distance.
601 /// </remarks>
602
603 public void Offset (int x, int y)
604 {
605 this.x += x;
606 this.y += y;
607 }
608
609 /// <summary>
610 /// Offset Method
611 /// </summary>
612 ///
613 /// <remarks>
614 /// Moves the Rectangle a specified distance.
615 /// </remarks>
616
617 public void Offset (Point pos)
618 {
619 x += pos.X;
620 y += pos.Y;
621 }
622
623 /// <summary>
624 /// ToString Method
625 /// </summary>
626 ///
627 /// <remarks>
628 /// Formats the Rectangle as a string in (x,y,w,h) notation.
629 /// </remarks>
630
631 public override string ToString ()
632 {
633 return String.Format ("{{X={0},Y={1},Width={2},Height={3}}}",
634 x, y, width, height);
635 }
636
637 }
638 }
git-svn mirror of mcs