OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [java/] [awt/] [Rectangle.java] - Blame information for rev 771

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 771 jeremybenn
/* Rectangle.java -- represents a graphics rectangle
2
   Copyright (C) 1999, 2000, 2001, 2002, 2006, Free Software Foundation
3
 
4
This file is part of GNU Classpath.
5
 
6
GNU Classpath is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2, or (at your option)
9
any later version.
10
 
11
GNU Classpath is distributed in the hope that it will be useful, but
12
WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GNU Classpath; see the file COPYING.  If not, write to the
18
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
02110-1301 USA.
20
 
21
Linking this library statically or dynamically with other modules is
22
making a combined work based on this library.  Thus, the terms and
23
conditions of the GNU General Public License cover the whole
24
combination.
25
 
26
As a special exception, the copyright holders of this library give you
27
permission to link this library with independent modules to produce an
28
executable, regardless of the license terms of these independent
29
modules, and to copy and distribute the resulting executable under
30
terms of your choice, provided that you also meet, for each linked
31
independent module, the terms and conditions of the license of that
32
module.  An independent module is a module which is not derived from
33
or based on this library.  If you modify this library, you may extend
34
this exception to your version of the library, but you are not
35
obligated to do so.  If you do not wish to do so, delete this
36
exception statement from your version. */
37
 
38
 
39
package java.awt;
40
 
41
import java.awt.geom.Rectangle2D;
42
import java.io.Serializable;
43
 
44
/**
45
 * This class represents a rectangle and all the interesting things you
46
 * might want to do with it.  Note that the coordinate system uses
47
 * the origin (0,0) as the top left of the screen, with the x and y
48
 * values increasing as they move to the right and down respectively.
49
 *
50
 * <p>It is valid for a rectangle to have negative width or height; but it
51
 * is considered to have no area or internal points. Therefore, the behavior
52
 * in methods like <code>contains</code> or <code>intersects</code> is
53
 * undefined unless the rectangle has positive width and height.
54
 *
55
 * <p>There are some public fields; if you mess with them in an inconsistent
56
 * manner, it is your own fault when you get NullPointerException,
57
 * ArrayIndexOutOfBoundsException, or invalid results. Also, this class is
58
 * not threadsafe.
59
 *
60
 * @author Warren Levy  (warrenl@cygnus.com)
61
 * @author Aaron M. Renn (arenn@urbanophile.com)
62
 * @author Eric Blake (ebb9@email.byu.edu)
63
 * @since 1.0
64
 * @status updated to 1.4
65
 */
66
public class Rectangle extends Rectangle2D implements Shape, Serializable
67
{
68
  /**
69
   * Compatible with JDK 1.0+.
70
   */
71
  private static final long serialVersionUID = -4345857070255674764L;
72
 
73
  /**
74
   * The X coordinate of the top-left corner of the rectangle.
75
   *
76
   * @see #setLocation(int, int)
77
   * @see #getLocation()
78
   * @serial the x coordinate
79
   */
80
  public int x;
81
 
82
  /**
83
   * The Y coordinate of the top-left corner of the rectangle.
84
   *
85
   * @see #setLocation(int, int)
86
   * @see #getLocation()
87
   * @serial the y coordinate
88
   */
89
  public int y;
90
 
91
  /**
92
   * The width of the rectangle.
93
   *
94
   * @see #setSize(int, int)
95
   * @see #getSize()
96
   * @serial
97
   */
98
  public int width;
99
 
100
  /**
101
   * The height of the rectangle.
102
   *
103
   * @see #setSize(int, int)
104
   * @see #getSize()
105
   * @serial
106
   */
107
  public int height;
108
 
109
  /**
110
   * Initializes a new instance of <code>Rectangle</code> with a top
111
   * left corner at (0,0) and a width and height of 0.
112
   */
113
  public Rectangle()
114
  {
115
  }
116
 
117
  /**
118
   * Initializes a new instance of <code>Rectangle</code> from the
119
   * coordinates of the specified rectangle.
120
   *
121
   * @param r the rectangle to copy from
122
   * @since 1.1
123
   */
124
  public Rectangle(Rectangle r)
125
  {
126
    x = r.x;
127
    y = r.y;
128
    width = r.width;
129
    height = r.height;
130
  }
131
 
132
  /**
133
   * Initializes a new instance of <code>Rectangle</code> from the specified
134
   * inputs.
135
   *
136
   * @param x the X coordinate of the top left corner
137
   * @param y the Y coordinate of the top left corner
138
   * @param width the width of the rectangle
139
   * @param height the height of the rectangle
140
   */
141
  public Rectangle(int x, int y, int width, int height)
142
  {
143
    this.x = x;
144
    this.y = y;
145
    this.width = width;
146
    this.height = height;
147
  }
148
 
149
  /**
150
   * Initializes a new instance of <code>Rectangle</code> with the specified
151
   * width and height. The upper left corner of the rectangle will be at
152
   * the origin (0,0).
153
   *
154
   * @param width the width of the rectangle
155
   * @param height the height of the rectange
156
   */
157
  public Rectangle(int width, int height)
158
  {
159
    this.width = width;
160
    this.height = height;
161
  }
162
 
163
  /**
164
   * Initializes a new instance of <code>Rectangle</code> with a top-left
165
   * corner represented by the specified point and the width and height
166
   * represented by the specified dimension.
167
   *
168
   * @param p the upper left corner of the rectangle
169
   * @param d the width and height of the rectangle
170
   */
171
  public Rectangle(Point p, Dimension d)
172
  {
173
    x = p.x;
174
    y = p.y;
175
    width = d.width;
176
    height = d.height;
177
  }
178
 
179
  /**
180
   * Initializes a new instance of <code>Rectangle</code> with a top left
181
   * corner at the specified point and a width and height of zero.
182
   *
183
   * @param p the upper left corner of the rectangle
184
   */
185
  public Rectangle(Point p)
186
  {
187
    x = p.x;
188
    y = p.y;
189
  }
190
 
191
  /**
192
   * Initializes a new instance of <code>Rectangle</code> with an
193
   * upper left corner at the origin (0,0) and a width and height represented
194
   * by the specified dimension.
195
   *
196
   * @param d the width and height of the rectangle
197
   */
198
  public Rectangle(Dimension d)
199
  {
200
    width = d.width;
201
    height = d.height;
202
  }
203
 
204
  /**
205
   * Get the X coordinate of the upper-left corner.
206
   *
207
   * @return the value of x, as a double
208
   */
209
  public double getX()
210
  {
211
    return x;
212
  }
213
 
214
  /**
215
   * Get the Y coordinate of the upper-left corner.
216
   *
217
   * @return the value of y, as a double
218
   */
219
  public double getY()
220
  {
221
    return y;
222
  }
223
 
224
  /**
225
   * Get the width of the rectangle.
226
   *
227
   * @return the value of width, as a double
228
   */
229
  public double getWidth()
230
  {
231
    return width;
232
  }
233
 
234
  /**
235
   * Get the height of the rectangle.
236
   *
237
   * @return the value of height, as a double
238
   */
239
  public double getHeight()
240
  {
241
    return height;
242
  }
243
 
244
  /**
245
   * Returns the bounds of this rectangle. A pretty useless method, as this
246
   * is already a rectangle; it is included to mimic the
247
   * <code>getBounds</code> method in Component.
248
   *
249
   * @return a copy of this rectangle
250
   * @see #setBounds(Rectangle)
251
   * @since 1.1
252
   */
253
  public Rectangle getBounds()
254
  {
255
    return new Rectangle(this);
256
  }
257
 
258
  /**
259
   * Returns the high-precision bounds of this rectangle. A pretty useless
260
   * method, as this is already a rectangle.
261
   *
262
   * @return a copy of this rectangle
263
   * @see #setBounds(Rectangle)
264
   * @since 1.2
265
   */
266
  public Rectangle2D getBounds2D()
267
  {
268
    return new Rectangle(x, y, width, height);
269
  }
270
 
271
  /**
272
   * Updates this rectangle to match the dimensions of the specified
273
   * rectangle.
274
   *
275
   * @param r the rectangle to update from
276
   * @throws NullPointerException if r is null
277
   * @see #setBounds(int, int, int, int)
278
   * @since 1.1
279
   */
280
  public void setBounds(Rectangle r)
281
  {
282
    setBounds (r.x, r.y, r.width, r.height);
283
  }
284
 
285
  /**
286
   * Updates this rectangle to have the specified dimensions.
287
   *
288
   * @param x the new X coordinate of the upper left hand corner
289
   * @param y the new Y coordinate of the upper left hand corner
290
   * @param width the new width of this rectangle
291
   * @param height the new height of this rectangle
292
   * @since 1.1
293
   */
294
  public void setBounds(int x, int y, int width, int height)
295
  {
296
    reshape (x, y, width, height);
297
  }
298
 
299
  /**
300
   * Updates this rectangle to have the specified dimensions, rounded to the
301
   * integer precision used by this class (the values are rounded "outwards" so
302
   * that the stored rectangle completely encloses the specified double
303
   * precision rectangle).
304
   *
305
   * @param x the new X coordinate of the upper left hand corner
306
   * @param y the new Y coordinate of the upper left hand corner
307
   * @param width the new width of this rectangle
308
   * @param height the new height of this rectangle
309
   * @since 1.2
310
   */
311
  public void setRect(double x, double y, double width, double height)
312
  {
313
    this.x = (int) Math.floor(x);
314
    this.y = (int) Math.floor(y);
315
    this.width = (int) Math.ceil(x + width) - this.x;
316
    this.height = (int) Math.ceil(y + height) - this.y;
317
  }
318
 
319
  /**
320
   * Updates this rectangle to have the specified dimensions.
321
   *
322
   * @param x the new X coordinate of the upper left hand corner
323
   * @param y the new Y coordinate of the upper left hand corner
324
   * @param width the new width of this rectangle
325
   * @param height the new height of this rectangle
326
   * @deprecated use {@link #setBounds(int, int, int, int)} instead
327
   */
328
  public void reshape(int x, int y, int width, int height)
329
  {
330
    this.x = x;
331
    this.y = y;
332
    this.width = width;
333
    this.height = height;
334
  }
335
 
336
  /**
337
   * Returns the location of this rectangle, which is the coordinates of
338
   * its upper left corner.
339
   *
340
   * @return the point where this rectangle is located
341
   * @see #setLocation(Point)
342
   * @since 1.1
343
   */
344
  public Point getLocation()
345
  {
346
    return new Point(x,y);
347
  }
348
 
349
  /**
350
   * Moves the location of this rectangle by setting its upper left
351
   * corner to the specified point.
352
   *
353
   * @param p the point to move the rectangle to
354
   * @throws NullPointerException if p is null
355
   * @see #getLocation()
356
   * @since 1.1
357
   */
358
  public void setLocation(Point p)
359
  {
360
    setLocation (p.x, p.y);
361
  }
362
 
363
  /**
364
   * Moves the location of this rectangle by setting its upper left
365
   * corner to the specified coordinates.
366
   *
367
   * @param x the new X coordinate for this rectangle
368
   * @param y the new Y coordinate for this rectangle
369
   * @since 1.1
370
   */
371
  public void setLocation(int x, int y)
372
  {
373
    move (x, y);
374
  }
375
 
376
  /**
377
   * Moves the location of this rectangle by setting its upper left
378
   * corner to the specified coordinates.
379
   *
380
   * @param x the new X coordinate for this rectangle
381
   * @param y the new Y coordinate for this rectangle
382
   * @deprecated use {@link #setLocation(int, int)} instead
383
   */
384
  public void move(int x, int y)
385
  {
386
    this.x = x;
387
    this.y = y;
388
  }
389
 
390
  /**
391
   * Translate the location of this rectangle by the given amounts.
392
   *
393
   * @param dx the x distance to move by
394
   * @param dy the y distance to move by
395
   * @see #setLocation(int, int)
396
   */
397
  public void translate(int dx, int dy)
398
  {
399
    x += dx;
400
    y += dy;
401
  }
402
 
403
  /**
404
   * Returns the size of this rectangle.
405
   *
406
   * @return the size of this rectangle
407
   * @see #setSize(Dimension)
408
   * @since 1.1
409
   */
410
  public Dimension getSize()
411
  {
412
    return new Dimension(width, height);
413
  }
414
 
415
  /**
416
   * Sets the size of this rectangle based on the specified dimensions.
417
   *
418
   * @param d the new dimensions of the rectangle
419
   * @throws NullPointerException if d is null
420
   * @see #getSize()
421
   * @since 1.1
422
   */
423
  public void setSize(Dimension d)
424
  {
425
    setSize (d.width, d.height);
426
  }
427
 
428
  /**
429
   * Sets the size of this rectangle based on the specified dimensions.
430
   *
431
   * @param width the new width of the rectangle
432
   * @param height the new height of the rectangle
433
   * @since 1.1
434
   */
435
  public void setSize(int width, int height)
436
  {
437
    resize (width, height);
438
  }
439
 
440
  /**
441
   * Sets the size of this rectangle based on the specified dimensions.
442
   *
443
   * @param width the new width of the rectangle
444
   * @param height the new height of the rectangle
445
   * @deprecated use {@link #setSize(int, int)} instead
446
   */
447
  public void resize(int width, int height)
448
  {
449
    this.width = width;
450
    this.height = height;
451
  }
452
 
453
  /**
454
   * Tests whether or not the specified point is inside this rectangle.
455
   * According to the contract of Shape, a point on the border is in only if
456
   * it has an adjacent point inside the rectangle in either the increasing
457
   * x or y direction.
458
   *
459
   * @param p the point to test
460
   * @return true if the point is inside the rectangle
461
   * @throws NullPointerException if p is null
462
   * @see #contains(int, int)
463
   * @since 1.1
464
   */
465
  public boolean contains(Point p)
466
  {
467
    return contains (p.x, p.y);
468
  }
469
 
470
  /**
471
   * Tests whether or not the specified point is inside this rectangle.
472
   * According to the contract of Shape, a point on the border is in only if
473
   * it has an adjacent point inside the rectangle in either the increasing
474
   * x or y direction.
475
   *
476
   * @param x the X coordinate of the point to test
477
   * @param y the Y coordinate of the point to test
478
   * @return true if the point is inside the rectangle
479
   * @since 1.1
480
   */
481
  public boolean contains(int x, int y)
482
  {
483
    return inside (x, y);
484
  }
485
 
486
  /**
487
   * Checks whether all points in the given rectangle are contained in this
488
   * rectangle.
489
   *
490
   * @param r the rectangle to check
491
   * @return true if r is contained in this rectangle
492
   * @throws NullPointerException if r is null
493
   * @see #contains(int, int, int, int)
494
   * @since 1.1
495
   */
496
  public boolean contains(Rectangle r)
497
  {
498
    return contains (r.x, r.y, r.width, r.height);
499
  }
500
 
501
  /**
502
   * Checks whether all points in the given rectangle are contained in this
503
   * rectangle.
504
   *
505
   * @param x the x coordinate of the rectangle to check
506
   * @param y the y coordinate of the rectangle to check
507
   * @param w the width of the rectangle to check
508
   * @param h the height of the rectangle to check
509
   * @return true if the parameters are contained in this rectangle
510
   * @since 1.1
511
   */
512
  public boolean contains(int x, int y, int w, int h)
513
  {
514
    return width > 0 && height > 0 && w > 0 && h > 0
515
      && x >= this.x && x + w <= this.x + this.width
516
      && y >= this.y && y + h <= this.y + this.height;
517
  }
518
 
519
  /**
520
   * Tests whether or not the specified point is inside this rectangle.
521
   *
522
   * @param x the X coordinate of the point to test
523
   * @param y the Y coordinate of the point to test
524
   * @return true if the point is inside the rectangle
525
   * @deprecated use {@link #contains(int, int)} instead
526
   */
527
  public boolean inside(int x, int y)
528
  {
529
    return width > 0 && height > 0
530
      && x >= this.x && x < this.x + width
531
      && y >= this.y && y < this.y + height;
532
  }
533
 
534
  /**
535
   * Tests whether or not the specified rectangle intersects this rectangle.
536
   * This means the two rectangles share at least one internal point.
537
   *
538
   * @param r the rectangle to test against
539
   * @return true if the specified rectangle intersects this one
540
   * @throws NullPointerException if r is null
541
   * @since 1.2
542
   */
543
  public boolean intersects(Rectangle r)
544
  {
545
    return r.width > 0 && r.height > 0 && width > 0 && height > 0
546
      && r.x < x + width && r.x + r.width > x
547
      && r.y < y + height && r.y + r.height > y;
548
  }
549
 
550
  /**
551
   * Determines the rectangle which is formed by the intersection of this
552
   * rectangle with the specified rectangle. If the two do not intersect,
553
   * an empty rectangle will be returned (meaning the width and/or height
554
   * will be non-positive).
555
   *
556
   * @param r the rectange to calculate the intersection with
557
   * @return a new rectangle bounding the intersection
558
   * @throws NullPointerException if r is null
559
   */
560
  public Rectangle intersection(Rectangle r)
561
  {
562
    Rectangle res = new Rectangle();
563
    intersect(this, r, res);
564
    return res;
565
  }
566
 
567
  /**
568
   * Returns the smallest rectangle that contains both this rectangle
569
   * and the specified rectangle.
570
   *
571
   * @param r the rectangle to compute the union with
572
   * @return the smallest rectangle containing both rectangles
573
   * @throws NullPointerException if r is null
574
   */
575
  public Rectangle union(Rectangle r)
576
  {
577
    Rectangle res = new Rectangle();
578
    union(this, r, res);
579
    return res;
580
  }
581
 
582
  /**
583
   * Modifies this rectangle so that it represents the smallest rectangle
584
   * that contains both the existing rectangle and the specified point.
585
   * However, if the point falls on one of the two borders which are not
586
   * inside the rectangle, a subsequent call to <code>contains</code> may
587
   * return false.
588
   *
589
   * @param x the X coordinate of the point to add to this rectangle
590
   * @param y the Y coordinate of the point to add to this rectangle
591
   */
592
  public void add(int x, int y)
593
  {
594
    add((double) x, (double) y);
595
  }
596
 
597
  /**
598
   * Modifies this rectangle so that it represents the smallest rectangle
599
   * that contains both the existing rectangle and the specified point.
600
   * However, if the point falls on one of the two borders which are not
601
   * inside the rectangle, a subsequent call to <code>contains</code> may
602
   * return false.
603
   *
604
   * @param p the point to add to this rectangle
605
   * @throws NullPointerException if p is null
606
   */
607
  public void add(Point p)
608
  {
609
    add((double) p.x, (double) p.y);
610
  }
611
 
612
  /**
613
   * Modifies this rectangle so that it represents the smallest rectangle
614
   * that contains both the existing rectangle and the specified rectangle.
615
   *
616
   * @param r the rectangle to add to this rectangle
617
   * @throws NullPointerException if r is null
618
   * @see #union(Rectangle)
619
   */
620
  public void add(Rectangle r)
621
  {
622
    union(this, r, this);
623
  }
624
 
625
  /**
626
   * Expands the rectangle by the specified amount.  The horizontal
627
   * and vertical expansion values are applied both to the X,Y coordinate
628
   * of this rectangle, and its width and height.  Thus the width and
629
   * height will increase by 2h and 2v accordingly.
630
   *
631
   * @param h the horizontal expansion value
632
   * @param v the vertical expansion value
633
   */
634
  public void grow(int h, int v)
635
  {
636
    x -= h;
637
    y -= v;
638
    width += h + h;
639
    height += v + v;
640
  }
641
 
642
  /**
643
   * Tests whether or not this rectangle is empty.  An empty rectangle
644
   * has a non-positive width or height.
645
   *
646
   * @return true if the rectangle is empty
647
   */
648
  public boolean isEmpty()
649
  {
650
    return width <= 0 || height <= 0;
651
  }
652
 
653
  /**
654
   * Determine where the point lies with respect to this rectangle. The
655
   * result will be the binary OR of the appropriate bit masks.
656
   *
657
   * @param x the x coordinate to check
658
   * @param y the y coordinate to check
659
   * @return the binary OR of the result
660
   * @see #OUT_LEFT
661
   * @see #OUT_TOP
662
   * @see #OUT_RIGHT
663
   * @see #OUT_BOTTOM
664
   * @since 1.2
665
   */
666
  public int outcode(double x, double y)
667
  {
668
    int result = 0;
669
    if (width <= 0)
670
      result |= OUT_LEFT | OUT_RIGHT;
671
    else if (x < this.x)
672
      result |= OUT_LEFT;
673
    else if (x > this.x + width)
674
      result |= OUT_RIGHT;
675
    if (height <= 0)
676
      result |= OUT_BOTTOM | OUT_TOP;
677
    else if (y < this.y) // Remember that +y heads top-to-bottom.
678
      result |= OUT_TOP;
679
    else if (y > this.y + height)
680
      result |= OUT_BOTTOM;
681
    return result;
682
  }
683
 
684
  /**
685
   * Determines the rectangle which is formed by the intersection of this
686
   * rectangle with the specified rectangle. If the two do not intersect,
687
   * an empty rectangle will be returned (meaning the width and/or height
688
   * will be non-positive).
689
   *
690
   * @param r the rectange to calculate the intersection with
691
   * @return a new rectangle bounding the intersection
692
   * @throws NullPointerException if r is null
693
   * @since 1.2
694
   */
695
  public Rectangle2D createIntersection(Rectangle2D r)
696
  {
697
    // Favor runtime type of other rectangle.
698
    Rectangle2D res = r.getBounds2D();
699
    intersect(this, r, res);
700
    return res;
701
  }
702
 
703
  /**
704
   * Returns the smallest rectangle that contains both this rectangle
705
   * and the specified rectangle.
706
   *
707
   * @param r the rectangle to compute the union with
708
   * @return the smallest rectangle containing both rectangles
709
   * @throws NullPointerException if r is null
710
   * @since 1.2
711
   */
712
  public Rectangle2D createUnion(Rectangle2D r)
713
  {
714
    // Favor runtime type of other rectangle.
715
    Rectangle2D res = r.getBounds2D();
716
    union(this, r, res);
717
    return res;
718
  }
719
 
720
  /**
721
   * Tests this rectangle for equality against the specified object.  This
722
   * will be true if an only if the specified object is an instance of
723
   * Rectangle2D with the same coordinates and dimensions.
724
   *
725
   * @param obj the object to test against for equality
726
   * @return true if the specified object is equal to this one
727
   */
728
  public boolean equals(Object obj)
729
  {
730
    // NOTE: No special hashCode() method is required for this class,
731
    // as this equals() implementation is functionally equivalent to
732
    // super.equals(), which does define a proper hashCode().
733
 
734
    if (! (obj instanceof Rectangle2D))
735
      return false;
736
    Rectangle2D r = (Rectangle2D) obj;
737
    return r.getX() == x && r.getY() == y
738
      && r.getWidth() == width && r.getHeight() == height;
739
  }
740
 
741
  /**
742
   * Returns a string representation of this rectangle. This is in the form
743
   * <code>getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width
744
   * + ",height=" + height + ']'</code>.
745
   *
746
   * @return a string representation of this rectangle
747
   */
748
  public String toString()
749
  {
750
    return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width
751
      + ",height=" + height + ']';
752
  }
753
} // class Rectangle

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.