workspace/ksplash/ksplashx/qrect.cpp

   1 /****************************************************************************
   2 **
   3 ** This file is based on sources of the Qt GUI Toolkit, used under the terms
   4 ** of the GNU General Public License version 2 (see the original copyright
   5 ** notice below).
   6 ** All further contributions to this file are (and are required to be)
   7 ** licensed under the terms of the GNU General Public License as published by
   8 ** the Free Software Foundation; either version 2 of the License, or
   9 ** (at your option) any later version.
  10 **
  11 ** The original Qt license header follows:
  12 **
  13 **
  14 ** Implementation of QRect class
  15 **
  16 ** Created : 931028
  17 **
  18 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
  19 **
  20 ** This file is part of the kernel module of the Qt GUI Toolkit.
  21 **
  22 ** This file may be distributed under the terms of the Q Public License
  23 ** as defined by Trolltech AS of Norway and appearing in the file
  24 ** LICENSE.QPL included in the packaging of this file.
  25 **
  26 ** This file may be distributed and/or modified under the terms of the
  27 ** GNU General Public License version 2 as published by the Free Software
  28 ** Foundation and appearing in the file LICENSE.GPL included in the
  29 ** packaging of this file.
  30 **
  31 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
  32 ** licenses may use this file in accordance with the Qt Commercial License
  33 ** Agreement provided with the Software.
  34 **
  35 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  36 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  37 **
  38 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
  39 **   information about Qt Commercial License Agreements.
  40 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
  41 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
  42 **
  43 ** Contact info@trolltech.com if any conditions of this licensing are
  44 ** not clear to you.
  45 **
  46 **********************************************************************/
  47
  48 #define  QRECT_C
  49 #include "qrect.h"
  50 #include "qdatastream.h"
  51
  52 /*!
  53     \class QRect
  54     \brief The QRect class defines a rectangle in the plane.
  55
  56     \ingroup images
  57     \ingroup graphics
  58     \mainclass
  59
  60     A rectangle is internally represented as an upper-left corner and
  61     a bottom-right corner, but it is normally expressed as an
  62     upper-left corner and a size.
  63
  64     The coordinate type is QCOORD (defined in \c qwindowdefs.h as \c
  65     int). The minimum value of QCOORD is QCOORD_MIN (-2147483648) and
  66     the maximum value is  QCOORD_MAX (2147483647).
  67
  68     Note that the size (width and height) of a rectangle might be
  69     different from what you are used to. If the top-left corner and
  70     the bottom-right corner are the same, the height and the width of
  71     the rectangle will both be 1.
  72
  73     Generally, \e{width = right - left + 1} and \e{height = bottom -
  74     top + 1}. We designed it this way to make it correspond to
  75     rectangular spaces used by drawing functions in which the width
  76     and height denote a number of pixels. For example, drawing a
  77     rectangle with width and height 1 draws a single pixel.
  78
  79     The default coordinate system has origin (0, 0) in the top-left
  80     corner. The positive direction of the y axis is down, and the
  81     positive x axis is from left to right.
  82
  83     A QRect can be constructed with a set of left, top, width and
  84     height integers, from two QPoints or from a QPoint and a QSize.
  85     After creation the dimensions can be changed, e.g. with setLeft(),
  86     setRight(), setTop() and setBottom(), or by setting sizes, e.g.
  87     setWidth(), setHeight() and setSize(). The dimensions can also be
  88     changed with the move functions, e.g. moveBy(), moveCenter(),
  89     moveBottomRight(), etc. You can also add coordinates to a
  90     rectangle with addCoords().
  91
  92     You can test to see if a QRect contains a specific point with
  93     contains(). You can also test to see if two QRects intersect with
  94     intersects() (see also intersect()). To get the bounding rectangle
  95     of two QRects use unite().
  96
  97     \sa QPoint, QSize
  98 */
  99
 100
 101 /*****************************************************************************
 102   QRect member functions
 103  *****************************************************************************/
 104
 105 /*!
 106     \fn QRect::QRect()
 107
 108     Constructs an invalid rectangle.
 109 */
 110
 111 /*!
 112     Constructs a rectangle with \a topLeft as the top-left corner and
 113     \a bottomRight as the bottom-right corner.
 114 */
 115
 116 QRect::QRect( const QPoint &topLeft, const QPoint &bottomRight )
 117 {
 118     x1 = (QCOORD)topLeft.x();
 119     y1 = (QCOORD)topLeft.y();
 120     x2 = (QCOORD)bottomRight.x();
 121     y2 = (QCOORD)bottomRight.y();
 122 }
 123
 124 /*!
 125     Constructs a rectangle with \a topLeft as the top-left corner and
 126     \a size as the rectangle size.
 127 */
 128
 129 QRect::QRect( const QPoint &topLeft, const QSize &size )
 130 {
 131     x1 = (QCOORD)topLeft.x();
 132     y1 = (QCOORD)topLeft.y();
 133     x2 = (QCOORD)(x1+size.width()-1);
 134     y2 = (QCOORD)(y1+size.height()-1);
 135 }
 136
 137 /*!
 138     \fn QRect::QRect( int left, int top, int width, int height )
 139
 140     Constructs a rectangle with the \a top, \a left corner and \a
 141     width and \a height.
 142
 143     Example (creates three identical rectangles):
 144     \code
 145         QRect r1( QPoint(100,200), QPoint(110,215) );
 146         QRect r2( QPoint(100,200), QSize(11,16) );
 147         QRect r3( 100, 200, 11, 16 );
 148     \endcode
 149 */
 150
 151
 152 /*!
 153     \fn bool QRect::isNull() const
 154
 155     Returns TRUE if the rectangle is a null rectangle; otherwise
 156     returns FALSE.
 157
 158     A null rectangle has both the width and the height set to 0, that
 159     is right() == left() - 1 and bottom() == top() - 1.
 160
 161     Note that if right() == left() and bottom() == top(), then the
 162     rectangle has width 1 and height 1.
 163
 164     A null rectangle is also empty.
 165
 166     A null rectangle is not valid.
 167
 168     \sa isEmpty(), isValid()
 169 */
 170
 171 /*!
 172     \fn bool QRect::isEmpty() const
 173
 174     Returns TRUE if the rectangle is empty; otherwise returns FALSE.
 175
 176     An empty rectangle has a left() \> right() or top() \> bottom().
 177
 178     An empty rectangle is not valid. \c{isEmpty() == !isValid()}
 179
 180     \sa isNull(), isValid(), normalize()
 181 */
 182
 183 /*!
 184     \fn bool QRect::isValid() const
 185
 186     Returns TRUE if the rectangle is valid; otherwise returns FALSE.
 187
 188     A valid rectangle has a left() \<= right() and top() \<= bottom().
 189
 190     Note that non-trivial operations like intersections are not defined
 191     for invalid rectangles.
 192
 193     \c{isValid() == !isEmpty()}
 194
 195     \sa isNull(), isEmpty(), normalize()
 196 */
 197
 198
 199 /*!
 200     Returns a normalized rectangle, i.e. a rectangle that has a
 201     non-negative width and height.
 202
 203     It swaps left and right if left() \> right(), and swaps top and
 204     bottom if top() \> bottom().
 205
 206     \sa isValid()
 207 */
 208
 209 QRect QRect::normalize() const
 210 {
 211     QRect r;
 212     if ( x2 < x1 ) {                            // swap bad x values
 213         r.x1 = x2;
 214         r.x2 = x1;
 215     } else {
 216         r.x1 = x1;
 217         r.x2 = x2;
 218     }
 219     if ( y2 < y1 ) {                            // swap bad y values
 220         r.y1 = y2;
 221         r.y2 = y1;
 222     } else {
 223         r.y1 = y1;
 224         r.y2 = y2;
 225     }
 226     return r;
 227 }
 228
 229
 230 /*!
 231     \fn int QRect::left() const
 232
 233     Returns the left coordinate of the rectangle. Identical to x().
 234
 235     \sa setLeft(), right(), topLeft(), bottomLeft()
 236 */
 237
 238 /*!
 239     \fn int QRect::top() const
 240
 241     Returns the top coordinate of the rectangle. Identical to y().
 242
 243     \sa setTop(), bottom(), topLeft(), topRight()
 244 */
 245
 246 /*!
 247     \fn int QRect::right() const
 248
 249     Returns the right coordinate of the rectangle.
 250
 251     \sa setRight(), left(), topRight(), bottomRight()
 252 */
 253
 254 /*!
 255     \fn int QRect::bottom() const
 256
 257     Returns the bottom coordinate of the rectangle.
 258
 259     \sa setBottom(), top(), bottomLeft(), bottomRight()
 260 */
 261
 262 /*!
 263     \fn QCOORD &QRect::rLeft()
 264
 265     Returns a reference to the left coordinate of the rectangle.
 266
 267     \sa rTop(), rRight(), rBottom()
 268 */
 269
 270 /*!
 271     \fn QCOORD &QRect::rTop()
 272
 273     Returns a reference to the top coordinate of the rectangle.
 274
 275     \sa rLeft(),  rRight(), rBottom()
 276 */
 277
 278 /*!
 279     \fn QCOORD &QRect::rRight()
 280
 281     Returns a reference to the right coordinate of the rectangle.
 282
 283     \sa rLeft(), rTop(), rBottom()
 284 */
 285
 286 /*!
 287     \fn QCOORD &QRect::rBottom()
 288
 289     Returns a reference to the bottom coordinate of the rectangle.
 290
 291     \sa rLeft(), rTop(), rRight()
 292 */
 293
 294 /*!
 295     \fn int QRect::x() const
 296
 297     Returns the left coordinate of the rectangle. Identical to left().
 298
 299     \sa left(), y(), setX()
 300 */
 301
 302 /*!
 303     \fn int QRect::y() const
 304
 305     Returns the top coordinate of the rectangle. Identical to top().
 306
 307     \sa top(), x(), setY()
 308 */
 309
 310 /*!
 311     \fn void QRect::setLeft( int pos )
 312
 313     Sets the left edge of the rectangle to \a pos. May change the
 314     width, but will never change the right edge of the rectangle.
 315
 316     Identical to setX().
 317
 318     \sa left(), setTop(), setWidth()
 319 */
 320
 321 /*!
 322     \fn void QRect::setTop( int pos )
 323
 324     Sets the top edge of the rectangle to \a pos. May change the
 325     height, but will never change the bottom edge of the rectangle.
 326
 327     Identical to setY().
 328
 329     \sa top(), setBottom(), setHeight()
 330 */
 331
 332 /*!
 333     \fn void QRect::setRight( int pos )
 334
 335     Sets the right edge of the rectangle to \a pos. May change the
 336     width, but will never change the left edge of the rectangle.
 337
 338     \sa right(), setLeft(), setWidth()
 339 */
 340
 341 /*!
 342     \fn void QRect::setBottom( int pos )
 343
 344     Sets the bottom edge of the rectangle to \a pos. May change the
 345     height, but will never change the top edge of the rectangle.
 346
 347     \sa bottom(), setTop(), setHeight()
 348 */
 349
 350 /*!
 351     \fn void QRect::setX( int x )
 352
 353     Sets the x position of the rectangle (its left end) to \a x. May
 354     change the width, but will never change the right edge of the
 355     rectangle.
 356
 357     Identical to setLeft().
 358
 359     \sa x(), setY()
 360 */
 361
 362 /*!
 363     \fn void QRect::setY( int y )
 364
 365     Sets the y position of the rectangle (its top) to \a y. May change
 366     the height, but will never change the bottom edge of the
 367     rectangle.
 368
 369     Identical to setTop().
 370
 371     \sa y(), setX()
 372 */
 373
 374 /*!
 375     Set the top-left corner of the rectangle to \a p. May change
 376     the size, but will the never change the bottom-right corner of
 377     the rectangle.
 378
 379     \sa topLeft(), moveTopLeft(), setBottomRight(), setTopRight(), setBottomLeft()
 380 */
 381 void QRect::setTopLeft( const QPoint &p )
 382 {
 383     setLeft( p.x() );
 384     setTop( p.y() );
 385 }
 386
 387 /*!
 388     Set the bottom-right corner of the rectangle to \a p. May change
 389     the size, but will the never change the top-left corner of
 390     the rectangle.
 391
 392     \sa bottomRight(), moveBottomRight(), setTopLeft(), setTopRight(), setBottomLeft()
 393 */
 394 void QRect::setBottomRight( const QPoint &p )
 395 {
 396     setRight( p.x() );
 397     setBottom( p.y() );
 398 }
 399
 400 /*!
 401     Set the top-right corner of the rectangle to \a p. May change
 402     the size, but will the never change the bottom-left corner of
 403     the rectangle.
 404
 405     \sa topRight(), moveTopRight(), setTopLeft(), setBottomRight(), setBottomLeft()
 406 */
 407 void QRect::setTopRight( const QPoint &p )
 408 {
 409     setRight( p.x() );
 410     setTop( p.y() );
 411 }
 412
 413 /*!
 414     Set the bottom-left corner of the rectangle to \a p. May change
 415     the size, but will the never change the top-right corner of
 416     the rectangle.
 417
 418     \sa bottomLeft(), moveBottomLeft(), setTopLeft(), setBottomRight(), setTopRight()
 419 */
 420 void QRect::setBottomLeft( const QPoint &p )
 421 {
 422     setLeft( p.x() );
 423     setBottom( p.y() );
 424 }
 425
 426 /*!
 427     \fn QPoint QRect::topLeft() const
 428
 429     Returns the top-left position of the rectangle.
 430
 431     \sa setTopLeft(), moveTopLeft(), bottomRight(), left(), top()
 432 */
 433
 434 /*!
 435     \fn QPoint QRect::bottomRight() const
 436
 437     Returns the bottom-right position of the rectangle.
 438
 439     \sa setBottomRight(), moveBottomRight(), topLeft(), right(), bottom()
 440 */
 441
 442 /*!
 443     \fn QPoint QRect::topRight() const
 444
 445     Returns the top-right position of the rectangle.
 446
 447     \sa setTopRight(), moveTopRight(), bottomLeft(), top(), right()
 448 */
 449
 450 /*!
 451     \fn QPoint QRect::bottomLeft() const
 452
 453     Returns the bottom-left position of the rectangle.
 454
 455     \sa setBottomLeft(), moveBottomLeft(), topRight(), bottom(), left()
 456 */
 457
 458 /*!
 459     \fn QPoint QRect::center() const
 460
 461     Returns the center point of the rectangle.
 462
 463     \sa moveCenter(), topLeft(), bottomRight(), topRight(), bottomLeft()
 464 */
 465
 466
 467 /*!
 468     Extracts the rectangle parameters as the position \a *x, \a *y and
 469     width \a *w and height \a *h.
 470
 471     \sa setRect(), coords()
 472 */
 473
 474 void QRect::rect( int *x, int *y, int *w, int *h ) const
 475 {
 476     *x = x1;
 477     *y = y1;
 478     *w = x2-x1+1;
 479     *h = y2-y1+1;
 480 }
 481
 482 /*!
 483     Extracts the rectangle parameters as the top-left point \a *xp1,
 484     \a *yp1 and the bottom-right point \a *xp2, \a *yp2.
 485
 486     \sa setCoords(), rect()
 487 */
 488
 489 void QRect::coords( int *xp1, int *yp1, int *xp2, int *yp2 ) const
 490 {
 491     *xp1 = x1;
 492     *yp1 = y1;
 493     *xp2 = x2;
 494     *yp2 = y2;
 495 }
 496
 497
 498 /*!
 499     Sets the left position of the rectangle to \a pos, leaving the
 500     size unchanged.
 501
 502     \sa left(), setLeft(), moveTop(), moveRight(), moveBottom()
 503 */
 504 void QRect::moveLeft( int pos )
 505 {
 506     x2 += (QCOORD)(pos - x1);
 507     x1 = (QCOORD)pos;
 508 }
 509
 510 /*!
 511     Sets the top position of the rectangle to \a pos, leaving the
 512     size unchanged.
 513
 514     \sa top(), setTop(), moveLeft(), moveRight(), moveBottom()
 515 */
 516
 517 void QRect::moveTop( int pos )
 518 {
 519     y2 += (QCOORD)(pos - y1);
 520     y1 = (QCOORD)pos;
 521 }
 522
 523 /*!
 524     Sets the right position of the rectangle to \a pos, leaving the
 525     size unchanged.
 526
 527     \sa right(), setRight(), moveLeft(), moveTop(), moveBottom()
 528 */
 529
 530 void QRect::moveRight( int pos )
 531 {
 532     x1 += (QCOORD)(pos - x2);
 533     x2 = (QCOORD)pos;
 534 }
 535
 536 /*!
 537     Sets the bottom position of the rectangle to \a pos, leaving the
 538     size unchanged.
 539
 540     \sa bottom(), setBottom(), moveLeft(), moveTop(), moveRight()
 541 */
 542
 543 void QRect::moveBottom( int pos )
 544 {
 545     y1 += (QCOORD)(pos - y2);
 546     y2 = (QCOORD)pos;
 547 }
 548
 549 /*!
 550     Sets the top-left position of the rectangle to \a p, leaving the
 551     size unchanged.
 552
 553     \sa topLeft(), setTopLeft(), moveBottomRight(), moveTopRight(), moveBottomLeft()
 554 */
 555
 556 void QRect::moveTopLeft( const QPoint &p )
 557 {
 558     moveLeft( p.x() );
 559     moveTop( p.y() );
 560 }
 561
 562 /*!
 563     Sets the bottom-right position of the rectangle to \a p, leaving
 564     the size unchanged.
 565
 566     \sa bottomRight(), setBottomRight(), moveTopLeft(), moveTopRight(), moveBottomLeft()
 567 */
 568
 569 void QRect::moveBottomRight( const QPoint &p )
 570 {
 571     moveRight( p.x() );
 572     moveBottom( p.y() );
 573 }
 574
 575 /*!
 576     Sets the top-right position of the rectangle to \a p, leaving the
 577     size unchanged.
 578
 579     \sa topRight(), setTopRight(), moveTopLeft(), moveBottomRight(), moveBottomLeft()
 580 */
 581
 582 void QRect::moveTopRight( const QPoint &p )
 583 {
 584     moveRight( p.x() );
 585     moveTop( p.y() );
 586 }
 587
 588 /*!
 589     Sets the bottom-left position of the rectangle to \a p, leaving
 590     the size unchanged.
 591
 592     \sa bottomLeft(), setBottomLeft(), moveTopLeft(), moveBottomRight(), moveTopRight()
 593 */
 594
 595 void QRect::moveBottomLeft( const QPoint &p )
 596 {
 597     moveLeft( p.x() );
 598     moveBottom( p.y() );
 599 }
 600
 601
 602 /*!
 603     Sets the center point of the rectangle to \a p, leaving the size
 604     unchanged.
 605
 606     \sa center(), moveTopLeft(), moveBottomRight(), moveTopRight(), moveBottomLeft()
 607 */
 608
 609 void QRect::moveCenter( const QPoint &p )
 610 {
 611     QCOORD w = x2 - x1;
 612     QCOORD h = y2 - y1;
 613     x1 = (QCOORD)(p.x() - w/2);
 614     y1 = (QCOORD)(p.y() - h/2);
 615     x2 = x1 + w;
 616     y2 = y1 + h;
 617 }
 618
 619
 620 /*!
 621     Moves the rectangle \a dx along the x axis and \a dy along the y
 622     axis, relative to the current position. Positive values move the
 623     rectangle to the right and down.
 624
 625     \sa moveTopLeft()
 626 */
 627
 628 void QRect::moveBy( int dx, int dy )
 629 {
 630     x1 += (QCOORD)dx;
 631     y1 += (QCOORD)dy;
 632     x2 += (QCOORD)dx;
 633     y2 += (QCOORD)dy;
 634 }
 635
 636 /*!
 637     Sets the coordinates of the rectangle's top-left corner to \a (x,
 638     y), and its size to \a (w, h).
 639
 640     \sa rect(), setCoords()
 641 */
 642
 643 void QRect::setRect( int x, int y, int w, int h )
 644 {
 645     x1 = (QCOORD)x;
 646     y1 = (QCOORD)y;
 647     x2 = (QCOORD)(x+w-1);
 648     y2 = (QCOORD)(y+h-1);
 649 }
 650
 651 /*!
 652     Sets the coordinates of the rectangle's top-left corner to \a
 653     (xp1, yp1), and the coordinates of its bottom-right corner to \a
 654     (xp2, yp2).
 655
 656     \sa coords(), setRect()
 657 */
 658
 659 void QRect::setCoords( int xp1, int yp1, int xp2, int yp2 )
 660 {
 661     x1 = (QCOORD)xp1;
 662     y1 = (QCOORD)yp1;
 663     x2 = (QCOORD)xp2;
 664     y2 = (QCOORD)yp2;
 665 }
 666
 667 /*!
 668     Adds \a xp1, \a yp1, \a xp2 and \a yp2 respectively to the
 669     existing coordinates of the rectangle.
 670 */
 671
 672 void QRect::addCoords( int xp1, int yp1, int xp2, int yp2 )
 673 {
 674     x1 += (QCOORD)xp1;
 675     y1 += (QCOORD)yp1;
 676     x2 += (QCOORD)xp2;
 677     y2 += (QCOORD)yp2;
 678 }
 679
 680 /*!
 681     \fn QSize QRect::size() const
 682
 683     Returns the size of the rectangle.
 684
 685     \sa width(), height()
 686 */
 687
 688 /*!
 689     \fn int QRect::width() const
 690
 691     Returns the width of the rectangle. The width includes both the
 692     left and right edges, i.e. width = right - left + 1.
 693
 694     \sa height(), size(), setHeight()
 695 */
 696
 697 /*!
 698     \fn int QRect::height() const
 699
 700     Returns the height of the rectangle. The height includes both the
 701     top and bottom edges, i.e. height = bottom - top + 1.
 702
 703     \sa width(), size(), setHeight()
 704 */
 705
 706 /*!
 707     Sets the width of the rectangle to \a w. The right edge is
 708     changed, but not the left edge.
 709
 710     \sa width(), setLeft(), setRight(), setSize()
 711 */
 712
 713 void QRect::setWidth( int w )
 714 {
 715     x2 = (QCOORD)(x1 + w - 1);
 716 }
 717
 718 /*!
 719     Sets the height of the rectangle to \a h. The top edge is not
 720     moved, but the bottom edge may be moved.
 721
 722     \sa height(), setTop(), setBottom(), setSize()
 723 */
 724
 725 void QRect::setHeight( int h )
 726 {
 727     y2 = (QCOORD)(y1 + h - 1);
 728 }
 729
 730 /*!
 731     Sets the size of the rectangle to \a s. The top-left corner is not
 732     moved.
 733
 734     \sa size(), setWidth(), setHeight()
 735 */
 736
 737 void QRect::setSize( const QSize &s )
 738 {
 739     x2 = (QCOORD)(s.width() +x1-1);
 740     y2 = (QCOORD)(s.height()+y1-1);
 741 }
 742
 743 /*!
 744     Returns TRUE if the point \a p is inside or on the edge of the
 745     rectangle; otherwise returns FALSE.
 746
 747     If \a proper is TRUE, this function returns TRUE only if \a p is
 748     inside (not on the edge).
 749 */
 750
 751 bool QRect::contains( const QPoint &p, bool proper ) const
 752 {
 753     if ( proper )
 754         return p.x() > x1 && p.x() < x2 &&
 755                p.y() > y1 && p.y() < y2;
 756     else
 757         return p.x() >= x1 && p.x() <= x2 &&
 758                p.y() >= y1 && p.y() <= y2;
 759 }
 760
 761 /*!
 762     \overload bool QRect::contains( int x, int y, bool proper ) const
 763
 764     Returns TRUE if the point \a x, \a y is inside this rectangle;
 765     otherwise returns FALSE.
 766
 767     If \a proper is TRUE, this function returns TRUE only if the point
 768     is entirely inside (not on the edge).
 769 */
 770
 771 /*!
 772     \overload bool QRect::contains( int x, int y ) const
 773
 774     Returns TRUE if the point \a x, \a y is inside this rectangle;
 775     otherwise returns FALSE.
 776 */
 777
 778 /*!
 779     \overload
 780
 781     Returns TRUE if the rectangle \a r is inside this rectangle;
 782     otherwise returns FALSE.
 783
 784     If \a proper is TRUE, this function returns TRUE only if \a r is
 785     entirely inside (not on the edge).
 786
 787     \sa unite(), intersect(), intersects()
 788 */
 789
 790 bool QRect::contains( const QRect &r, bool proper ) const
 791 {
 792     if ( proper )
 793         return r.x1 > x1 && r.x2 < x2 && r.y1 > y1 && r.y2 < y2;
 794     else
 795         return r.x1 >= x1 && r.x2 <= x2 && r.y1 >= y1 && r.y2 <= y2;
 796 }
 797
 798 /*!
 799     Unites this rectangle with rectangle \a r.
 800 */
 801 QRect& QRect::operator|=(const QRect &r)
 802 {
 803     *this = *this | r;
 804     return *this;
 805 }
 806
 807 /*!
 808     Intersects this rectangle with rectangle \a r.
 809 */
 810 QRect& QRect::operator&=(const QRect &r)
 811 {
 812     *this = *this & r;
 813     return *this;
 814 }
 815
 816
 817 /*!
 818     Returns the bounding rectangle of this rectangle and rectangle \a
 819     r.
 820
 821     The bounding rectangle of a nonempty rectangle and an empty or
 822     invalid rectangle is defined to be the nonempty rectangle.
 823
 824     \sa operator|=(), operator&(), intersects(), contains()
 825 */
 826
 827 QRect QRect::operator|(const QRect &r) const
 828 {
 829     if ( isValid() ) {
 830         if ( r.isValid() ) {
 831             QRect tmp;
 832             tmp.setLeft(   qMin( x1, r.x1 ) );
 833             tmp.setRight(  qMax( x2, r.x2 ) );
 834             tmp.setTop(    qMin( y1, r.y1 ) );
 835             tmp.setBottom( qMax( y2, r.y2 ) );
 836             return tmp;
 837         } else {
 838             return *this;
 839         }
 840     } else {
 841         return r;
 842     }
 843 }
 844
 845 /*!
 846     Returns the bounding rectangle of this rectangle and rectangle \a
 847     r. \c{r.unite(s)} is equivalent to \c{r|s}.
 848 */
 849 QRect QRect::unite( const QRect &r ) const
 850 {
 851     return *this | r;
 852 }
 853
 854
 855 /*!
 856     Returns the intersection of this rectangle and rectangle \a r.
 857
 858     Returns an empty rectangle if there is no intersection.
 859
 860     \sa operator&=(), operator|(), isEmpty(), intersects(), contains()
 861 */
 862
 863 QRect QRect::operator&( const QRect &r ) const
 864 {
 865     QRect tmp;
 866     tmp.x1 = qMax( x1, r.x1 );
 867     tmp.x2 = qMin( x2, r.x2 );
 868     tmp.y1 = qMax( y1, r.y1 );
 869     tmp.y2 = qMin( y2, r.y2 );
 870     return tmp;
 871 }
 872
 873 /*!
 874     Returns the intersection of this rectangle and rectangle \a r.
 875     \c{r.intersect(s)} is equivalent to \c{r&s}.
 876 */
 877 QRect QRect::intersect( const QRect &r ) const
 878 {
 879     return *this & r;
 880 }
 881
 882 /*!
 883     Returns TRUE if this rectangle intersects with rectangle \a r
 884     (there is at least one pixel that is within both rectangles);
 885     otherwise returns FALSE.
 886
 887     \sa intersect(), contains()
 888 */
 889
 890 bool QRect::intersects( const QRect &r ) const
 891 {
 892     return ( qMax( x1, r.x1 ) <= qMin( x2, r.x2 ) &&
 893              qMax( y1, r.y1 ) <= qMin( y2, r.y2 ) );
 894 }
 895
 896
 897 /*!
 898     \relates QRect
 899
 900     Returns TRUE if \a r1 and \a r2 are equal; otherwise returns FALSE.
 901 */
 902
 903 bool operator==( const QRect &r1, const QRect &r2 )
 904 {
 905     return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2;
 906 }
 907
 908 /*!
 909     \relates QRect
 910
 911     Returns TRUE if \a r1 and \a r2 are different; otherwise returns FALSE.
 912 */
 913
 914 bool operator!=( const QRect &r1, const QRect &r2 )
 915 {
 916     return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2;
 917 }
 918
 919
 920 /*****************************************************************************
 921   QRect stream functions
 922  *****************************************************************************/
 923 #ifndef QT_NO_DATASTREAM
 924 /*!
 925     \relates QRect
 926
 927     Writes the QRect, \a r, to the stream \a s, and returns a
 928     reference to the stream.
 929
 930     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 931 */
 932
 933 QDataStream &operator<<( QDataStream &s, const QRect &r )
 934 {
 935     if ( s.version() == 1 )
 936         s << (Q_INT16)r.left() << (Q_INT16)r.top()
 937           << (Q_INT16)r.right() << (Q_INT16)r.bottom();
 938     else
 939         s << (Q_INT32)r.left() << (Q_INT32)r.top()
 940           << (Q_INT32)r.right() << (Q_INT32)r.bottom();
 941     return s;
 942 }
 943
 944 /*!
 945     \relates QRect
 946
 947     Reads a QRect from the stream \a s into rect \a r and returns a
 948     reference to the stream.
 949
 950     \sa \link datastreamformat.html Format of the QDataStream operators \endlink
 951 */
 952
 953 QDataStream &operator>>( QDataStream &s, QRect &r )
 954 {
 955     if ( s.version() == 1 ) {
 956         Q_INT16 x1, y1, x2, y2;
 957         s >> x1; s >> y1; s >> x2; s >> y2;
 958         r.setCoords( x1, y1, x2, y2 );
 959     }
 960     else {
 961         Q_INT32 x1, y1, x2, y2;
 962         s >> x1; s >> y1; s >> x2; s >> y2;
 963         r.setCoords( x1, y1, x2, y2 );
 964     }
 965     return s;
 966 }
 967 #endif // QT_NO_DATASTREAM