qrect.h
上传用户:detong
上传日期:2022-06-22
资源大小:20675k
文件大小:21k
源码类别:

系统编程

开发平台:

Unix_Linux

  1. /****************************************************************************
  2. **
  3. ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
  4. ** Contact: Qt Software Information (qt-info@nokia.com)
  5. **
  6. ** This file is part of the QtCore module of the Qt Toolkit.
  7. **
  8. ** Commercial Usage
  9. ** Licensees holding valid Qt Commercial licenses may use this file in
  10. ** accordance with the Qt Commercial License Agreement provided with the
  11. ** Software or, alternatively, in accordance with the terms contained in
  12. ** a written agreement between you and Nokia.
  13. **
  14. **
  15. ** GNU General Public License Usage
  16. ** Alternatively, this file may be used under the terms of the GNU
  17. ** General Public License versions 2.0 or 3.0 as published by the Free
  18. ** Software Foundation and appearing in the file LICENSE.GPL included in
  19. ** the packaging of this file.  Please review the following information
  20. ** to ensure GNU General Public Licensing requirements will be met:
  21. ** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
  22. ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
  23. ** exception, Nokia gives you certain additional rights. These rights
  24. ** are described in the Nokia Qt GPL Exception version 1.3, included in
  25. ** the file GPL_EXCEPTION.txt in this package.
  26. **
  27. ** Qt for Windows(R) Licensees
  28. ** As a special exception, Nokia, as the sole copyright holder for Qt
  29. ** Designer, grants users of the Qt/Eclipse Integration plug-in the
  30. ** right for the Qt/Eclipse Integration to link to functionality
  31. ** provided by Qt Designer and its related libraries.
  32. **
  33. ** If you are unsure which license is appropriate for your use, please
  34. ** contact the sales department at qt-sales@nokia.com.
  35. **
  36. ****************************************************************************/
  37. #ifndef QRECT_H
  38. #define QRECT_H
  39. #include <QtCore/qsize.h>
  40. #include <QtCore/qpoint.h>
  41. #ifdef topLeft
  42. #error qrect.h must be included before any header file that defines topLeft
  43. #endif
  44. QT_BEGIN_HEADER
  45. QT_BEGIN_NAMESPACE
  46. QT_MODULE(Core)
  47. class Q_CORE_EXPORT QRect
  48. {
  49. public:
  50.     QRect() { x1 = y1 = 0; x2 = y2 = -1; }
  51.     QRect(const QPoint &topleft, const QPoint &bottomright);
  52.     QRect(const QPoint &topleft, const QSize &size);
  53.     QRect(int left, int top, int width, int height);
  54.     bool isNull() const;
  55.     bool isEmpty() const;
  56.     bool isValid() const;
  57.     int left() const;
  58.     int top() const;
  59.     int right() const;
  60.     int bottom() const;
  61.     QRect normalized() const;
  62. #ifdef QT3_SUPPORT
  63.     QT3_SUPPORT int &rLeft() { return x1; }
  64.     QT3_SUPPORT int &rTop() { return y1; }
  65.     QT3_SUPPORT int &rRight() { return x2; }
  66.     QT3_SUPPORT int &rBottom() { return y2; }
  67.     QT3_SUPPORT QRect normalize() const { return normalized(); }
  68. #endif
  69.     int x() const;
  70.     int y() const;
  71.     void setLeft(int pos);
  72.     void setTop(int pos);
  73.     void setRight(int pos);
  74.     void setBottom(int pos);
  75.     void setX(int x);
  76.     void setY(int y);
  77.     void setTopLeft(const QPoint &p);
  78.     void setBottomRight(const QPoint &p);
  79.     void setTopRight(const QPoint &p);
  80.     void setBottomLeft(const QPoint &p);
  81.     QPoint topLeft() const;
  82.     QPoint bottomRight() const;
  83.     QPoint topRight() const;
  84.     QPoint bottomLeft() const;
  85.     QPoint center() const;
  86.     void moveLeft(int pos);
  87.     void moveTop(int pos);
  88.     void moveRight(int pos);
  89.     void moveBottom(int pos);
  90.     void moveTopLeft(const QPoint &p);
  91.     void moveBottomRight(const QPoint &p);
  92.     void moveTopRight(const QPoint &p);
  93.     void moveBottomLeft(const QPoint &p);
  94.     void moveCenter(const QPoint &p);
  95.     inline void translate(int dx, int dy);
  96.     inline void translate(const QPoint &p);
  97.     inline QRect translated(int dx, int dy) const;
  98.     inline QRect translated(const QPoint &p) const;
  99.     void moveTo(int x, int t);
  100.     void moveTo(const QPoint &p);
  101. #ifdef QT3_SUPPORT
  102.     QT3_SUPPORT void moveBy(int dx, int dy) { translate(dx, dy); }
  103.     QT3_SUPPORT void moveBy(const QPoint &p) { translate(p); }
  104. #endif
  105.     void setRect(int x, int y, int w, int h);
  106.     inline void getRect(int *x, int *y, int *w, int *h) const;
  107.     void setCoords(int x1, int y1, int x2, int y2);
  108. #ifdef QT3_SUPPORT
  109.     QT3_SUPPORT void addCoords(int x1, int y1, int x2, int y2);
  110. #endif
  111.     inline void getCoords(int *x1, int *y1, int *x2, int *y2) const;
  112.     inline void adjust(int x1, int y1, int x2, int y2);
  113.     inline QRect adjusted(int x1, int y1, int x2, int y2) const;
  114.     QSize size() const;
  115.     int width() const;
  116.     int height() const;
  117.     void setWidth(int w);
  118.     void setHeight(int h);
  119.     void setSize(const QSize &s);
  120.     QRect operator|(const QRect &r) const;
  121.     QRect operator&(const QRect &r) const;
  122.     QRect& operator|=(const QRect &r);
  123.     QRect& operator&=(const QRect &r);
  124.     bool contains(const QPoint &p, bool proper=false) const;
  125.     bool contains(int x, int y) const; // inline methods, _don't_ merge these
  126.     bool contains(int x, int y, bool proper) const;
  127.     bool contains(const QRect &r, bool proper = false) const;
  128.     QRect unite(const QRect &r) const;  // ### Qt 5: make QT4_SUPPORT
  129.     QRect united(const QRect &other) const;
  130.     QRect intersect(const QRect &r) const;  // ### Qt 5: make QT4_SUPPORT
  131.     QRect intersected(const QRect &other) const;
  132.     bool intersects(const QRect &r) const;
  133.     friend Q_CORE_EXPORT_INLINE bool operator==(const QRect &, const QRect &);
  134.     friend Q_CORE_EXPORT_INLINE bool operator!=(const QRect &, const QRect &);
  135. #ifdef QT3_SUPPORT
  136.     inline QT3_SUPPORT void rect(int *x, int *y, int *w, int *h) const { getRect(x, y, w, h); }
  137.     inline QT3_SUPPORT void coords(int *ax1, int *ay1, int *ax2, int *ay2) const
  138.     { getCoords(ax1, ay1, ax2, ay2); }
  139. #endif
  140. private:
  141. #if defined(Q_WS_X11)
  142.     friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2);
  143. #endif
  144. #if defined(Q_OS_MAC)
  145.     int y1;
  146.     int x1;
  147.     int y2;
  148.     int x2;
  149. #else
  150.     int x1;
  151.     int y1;
  152.     int x2;
  153.     int y2;
  154. #endif
  155. };
  156. Q_DECLARE_TYPEINFO(QRect, Q_MOVABLE_TYPE);
  157. Q_CORE_EXPORT_INLINE bool operator==(const QRect &, const QRect &);
  158. Q_CORE_EXPORT_INLINE bool operator!=(const QRect &, const QRect &);
  159. /*****************************************************************************
  160.   QRect stream functions
  161.  *****************************************************************************/
  162. #ifndef QT_NO_DATASTREAM
  163. Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QRect &);
  164. Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QRect &);
  165. #endif
  166. /*****************************************************************************
  167.   QRect inline member functions
  168.  *****************************************************************************/
  169. inline QRect::QRect(int aleft, int atop, int awidth, int aheight)
  170. {
  171.     x1 = aleft;
  172.     y1 = atop;
  173.     x2 = (aleft + awidth - 1);
  174.     y2 = (atop + aheight - 1);
  175. }
  176. inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight)
  177. {
  178.     x1 = atopLeft.x();
  179.     y1 = atopLeft.y();
  180.     x2 = abottomRight.x();
  181.     y2 = abottomRight.y();
  182. }
  183. inline QRect::QRect(const QPoint &atopLeft, const QSize &asize)
  184. {
  185.     x1 = atopLeft.x();
  186.     y1 = atopLeft.y();
  187.     x2 = (x1+asize.width() - 1);
  188.     y2 = (y1+asize.height() - 1);
  189. }
  190. inline bool QRect::isNull() const
  191. { return x2 == x1 - 1 && y2 == y1 - 1; }
  192. inline bool QRect::isEmpty() const
  193. { return x1 > x2 || y1 > y2; }
  194. inline bool QRect::isValid() const
  195. { return x1 <= x2 && y1 <= y2; }
  196. inline int QRect::left() const
  197. { return x1; }
  198. inline int QRect::top() const
  199. { return y1; }
  200. inline int QRect::right() const
  201. { return x2; }
  202. inline int QRect::bottom() const
  203. { return y2; }
  204. inline int QRect::x() const
  205. { return x1; }
  206. inline int QRect::y() const
  207. { return y1; }
  208. inline void QRect::setLeft(int pos)
  209. { x1 = pos; }
  210. inline void QRect::setTop(int pos)
  211. { y1 = pos; }
  212. inline void QRect::setRight(int pos)
  213. { x2 = pos; }
  214. inline void QRect::setBottom(int pos)
  215. { y2 = pos; }
  216. inline void QRect::setTopLeft(const QPoint &p)
  217. { x1 = p.x(); y1 = p.y(); }
  218. inline void QRect::setBottomRight(const QPoint &p)
  219. { x2 = p.x(); y2 = p.y(); }
  220. inline void QRect::setTopRight(const QPoint &p)
  221. { x2 = p.x(); y1 = p.y(); }
  222. inline void QRect::setBottomLeft(const QPoint &p)
  223. { x1 = p.x(); y2 = p.y(); }
  224. inline void QRect::setX(int ax)
  225. { x1 = ax; }
  226. inline void QRect::setY(int ay)
  227. { y1 = ay; }
  228. inline QPoint QRect::topLeft() const
  229. { return QPoint(x1, y1); }
  230. inline QPoint QRect::bottomRight() const
  231. { return QPoint(x2, y2); }
  232. inline QPoint QRect::topRight() const
  233. { return QPoint(x2, y1); }
  234. inline QPoint QRect::bottomLeft() const
  235. { return QPoint(x1, y2); }
  236. inline QPoint QRect::center() const
  237. { return QPoint((x1+x2)/2, (y1+y2)/2); }
  238. inline int QRect::width() const
  239. { return  x2 - x1 + 1; }
  240. inline int QRect::height() const
  241. { return  y2 - y1 + 1; }
  242. inline QSize QRect::size() const
  243. { return QSize(width(), height()); }
  244. inline void QRect::translate(int dx, int dy)
  245. {
  246.     x1 += dx;
  247.     y1 += dy;
  248.     x2 += dx;
  249.     y2 += dy;
  250. }
  251. inline void QRect::translate(const QPoint &p)
  252. {
  253.     x1 += p.x();
  254.     y1 += p.y();
  255.     x2 += p.x();
  256.     y2 += p.y();
  257. }
  258. inline QRect QRect::translated(int dx, int dy) const
  259. { return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); }
  260. inline QRect QRect::translated(const QPoint &p) const
  261. { return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }
  262. inline void QRect::moveTo(int ax, int ay)
  263. {
  264.     x2 += ax - x1;
  265.     y2 += ay - y1;
  266.     x1 = ax;
  267.     y1 = ay;
  268. }
  269. inline void QRect::moveTo(const QPoint &p)
  270. {
  271.     x2 += p.x() - x1;
  272.     y2 += p.y() - y1;
  273.     x1 = p.x();
  274.     y1 = p.y();
  275. }
  276. inline void QRect::moveLeft(int pos)
  277. { x2 += (pos - x1); x1 = pos; }
  278. inline void QRect::moveTop(int pos)
  279. { y2 += (pos - y1); y1 = pos; }
  280. inline void QRect::moveRight(int pos)
  281. {
  282.     x1 += (pos - x2);
  283.     x2 = pos;
  284. }
  285. inline void QRect::moveBottom(int pos)
  286. {
  287.     y1 += (pos - y2);
  288.     y2 = pos;
  289. }
  290. inline void QRect::moveTopLeft(const QPoint &p)
  291. {
  292.     moveLeft(p.x());
  293.     moveTop(p.y());
  294. }
  295. inline void QRect::moveBottomRight(const QPoint &p)
  296. {
  297.     moveRight(p.x());
  298.     moveBottom(p.y());
  299. }
  300. inline void QRect::moveTopRight(const QPoint &p)
  301. {
  302.     moveRight(p.x());
  303.     moveTop(p.y());
  304. }
  305. inline void QRect::moveBottomLeft(const QPoint &p)
  306. {
  307.     moveLeft(p.x());
  308.     moveBottom(p.y());
  309. }
  310. inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const
  311. {
  312.     *ax = x1;
  313.     *ay = y1;
  314.     *aw = x2 - x1 + 1;
  315.     *ah = y2 - y1 + 1;
  316. }
  317. inline void QRect::setRect(int ax, int ay, int aw, int ah)
  318. {
  319.     x1 = ax;
  320.     y1 = ay;
  321.     x2 = (ax + aw - 1);
  322.     y2 = (ay + ah - 1);
  323. }
  324. inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const
  325. {
  326.     *xp1 = x1;
  327.     *yp1 = y1;
  328.     *xp2 = x2;
  329.     *yp2 = y2;
  330. }
  331. inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2)
  332. {
  333.     x1 = xp1;
  334.     y1 = yp1;
  335.     x2 = xp2;
  336.     y2 = yp2;
  337. }
  338. #ifdef QT3_SUPPORT
  339. inline void QRect::addCoords(int dx1, int dy1, int dx2, int dy2)
  340. {
  341.     adjust(dx1, dy1, dx2, dy2);
  342. }
  343. #endif
  344. inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const
  345. { return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); }
  346. inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2)
  347. {
  348.     x1 += dx1;
  349.     y1 += dy1;
  350.     x2 += dx2;
  351.     y2 += dy2;
  352. }
  353. inline void QRect::setWidth(int w)
  354. { x2 = (x1 + w - 1); }
  355. inline void QRect::setHeight(int h)
  356. { y2 = (y1 + h - 1); }
  357. inline void QRect::setSize(const QSize &s)
  358. {
  359.     x2 = (s.width()  + x1 - 1);
  360.     y2 = (s.height() + y1 - 1);
  361. }
  362. inline bool QRect::contains(int ax, int ay, bool aproper) const
  363. {
  364.     return contains(QPoint(ax, ay), aproper);
  365. }
  366. inline bool QRect::contains(int ax, int ay) const
  367. {
  368.     return contains(QPoint(ax, ay), false);
  369. }
  370. inline QRect& QRect::operator|=(const QRect &r)
  371. {
  372.     *this = *this | r;
  373.     return *this;
  374. }
  375. inline QRect& QRect::operator&=(const QRect &r)
  376. {
  377.     *this = *this & r;
  378.     return *this;
  379. }
  380. inline QRect QRect::intersect(const QRect &r) const
  381. {
  382.     return *this & r;
  383. }
  384. inline QRect QRect::intersected(const QRect &other) const
  385. {
  386.     return intersect(other);
  387. }
  388. inline QRect QRect::unite(const QRect &r) const
  389. {
  390.     return *this | r;
  391. }
  392. inline QRect QRect::united(const QRect &r) const
  393. {
  394.      return unite(r);
  395. }
  396. inline bool operator==(const QRect &r1, const QRect &r2)
  397. {
  398.     return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2;
  399. }
  400. inline bool operator!=(const QRect &r1, const QRect &r2)
  401. {
  402.     return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2;
  403. }
  404. #ifndef QT_NO_DEBUG_STREAM
  405. Q_CORE_EXPORT QDebug operator<<(QDebug, const QRect &);
  406. #endif
  407. class Q_CORE_EXPORT QRectF
  408. {
  409. public:
  410.     QRectF() { xp = yp = 0.; w = h = 0.; }
  411.     QRectF(const QPointF &topleft, const QSizeF &size);
  412.     QRectF(const QPointF &topleft, const QPointF &bottomRight);
  413.     QRectF(qreal left, qreal top, qreal width, qreal height);
  414.     QRectF(const QRect &rect);
  415.     bool isNull() const;
  416.     bool isEmpty() const;
  417.     bool isValid() const;
  418.     QRectF normalized() const;
  419.     inline qreal left() const { return xp; }
  420.     inline qreal top() const { return yp; }
  421.     inline qreal right() const { return xp + w; }
  422.     inline qreal bottom() const { return yp + h; }
  423.     inline qreal x() const;
  424.     inline qreal y() const;
  425.     inline void setLeft(qreal pos);
  426.     inline void setTop(qreal pos);
  427.     inline void setRight(qreal pos);
  428.     inline void setBottom(qreal pos);
  429.     inline void setX(qreal pos) { setLeft(pos); }
  430.     inline void setY(qreal pos) { setTop(pos); }
  431.     inline QPointF topLeft() const { return QPointF(xp, yp); }
  432.     inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); }
  433.     inline QPointF topRight() const { return QPointF(xp+w, yp); }
  434.     inline QPointF bottomLeft() const { return QPointF(xp, yp+h); }
  435.     inline QPointF center() const;
  436.     void setTopLeft(const QPointF &p);
  437.     void setBottomRight(const QPointF &p);
  438.     void setTopRight(const QPointF &p);
  439.     void setBottomLeft(const QPointF &p);
  440.     void moveLeft(qreal pos);
  441.     void moveTop(qreal pos);
  442.     void moveRight(qreal pos);
  443.     void moveBottom(qreal pos);
  444.     void moveTopLeft(const QPointF &p);
  445.     void moveBottomRight(const QPointF &p);
  446.     void moveTopRight(const QPointF &p);
  447.     void moveBottomLeft(const QPointF &p);
  448.     void moveCenter(const QPointF &p);
  449.     void translate(qreal dx, qreal dy);
  450.     void translate(const QPointF &p);
  451.     QRectF translated(qreal dx, qreal dy) const;
  452.     QRectF translated(const QPointF &p) const;
  453.     void moveTo(qreal x, qreal t);
  454.     void moveTo(const QPointF &p);
  455.     void setRect(qreal x, qreal y, qreal w, qreal h);
  456.     void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const;
  457.     void setCoords(qreal x1, qreal y1, qreal x2, qreal y2);
  458.     void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const;
  459.     inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2);
  460.     inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const;
  461.     QSizeF size() const;
  462.     qreal width() const;
  463.     qreal height() const;
  464.     void setWidth(qreal w);
  465.     void setHeight(qreal h);
  466.     void setSize(const QSizeF &s);
  467.     QRectF operator|(const QRectF &r) const;
  468.     QRectF operator&(const QRectF &r) const;
  469.     QRectF& operator|=(const QRectF &r);
  470.     QRectF& operator&=(const QRectF &r);
  471.     bool contains(const QPointF &p) const;
  472.     bool contains(qreal x, qreal y) const;
  473.     bool contains(const QRectF &r) const;
  474.     QRectF unite(const QRectF &r) const;  // ### Qt 5: make QT4_SUPPORT
  475.     QRectF united(const QRectF &other) const;
  476.     QRectF intersect(const QRectF &r) const;  // ### Qt 5: make QT4_SUPPORT
  477.     QRectF intersected(const QRectF &other) const;
  478.     bool intersects(const QRectF &r) const;
  479.     friend Q_CORE_EXPORT_INLINE bool operator==(const QRectF &, const QRectF &);
  480.     friend Q_CORE_EXPORT_INLINE bool operator!=(const QRectF &, const QRectF &);
  481.     QRect toRect() const;
  482.     QRect toAlignedRect() const;
  483. private:
  484.     qreal xp;
  485.     qreal yp;
  486.     qreal w;
  487.     qreal h;
  488. };
  489. Q_DECLARE_TYPEINFO(QRectF, Q_MOVABLE_TYPE);
  490. Q_CORE_EXPORT_INLINE bool operator==(const QRectF &, const QRectF &);
  491. Q_CORE_EXPORT_INLINE bool operator!=(const QRectF &, const QRectF &);
  492. /*****************************************************************************
  493.   QRectF stream functions
  494.  *****************************************************************************/
  495. #ifndef QT_NO_DATASTREAM
  496. Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QRectF &);
  497. Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QRectF &);
  498. #endif
  499. /*****************************************************************************
  500.   QRectF inline member functions
  501.  *****************************************************************************/
  502. inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight)
  503.     : xp(aleft), yp(atop), w(awidth), h(aheight)
  504. {
  505. }
  506. inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize)
  507. {
  508.     xp = atopLeft.x();
  509.     yp = atopLeft.y();
  510.     w = asize.width();
  511.     h = asize.height();
  512. }
  513. inline QRectF::QRectF(const QPointF &atopLeft, const QPointF &abottomRight)
  514. {
  515.     xp = atopLeft.x();
  516.     yp = atopLeft.y();
  517.     w = abottomRight.x() - xp;
  518.     h = abottomRight.y() - yp;
  519. }
  520. inline QRectF::QRectF(const QRect &r)
  521.     : xp(r.x()), yp(r.y()), w(r.width()), h(r.height())
  522. {
  523. }
  524. inline bool QRectF::isNull() const
  525. { return qIsNull(w) && qIsNull(h); }
  526. inline bool QRectF::isEmpty() const
  527. { return w <= 0. || h <= 0.; }
  528. inline bool QRectF::isValid() const
  529. { return w > 0. && h > 0.; }
  530. inline qreal QRectF::x() const
  531. { return xp; }
  532. inline qreal QRectF::y() const
  533. { return yp; }
  534. inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; }
  535. inline void QRectF::setRight(qreal pos) { w = pos - xp; }
  536. inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; }
  537. inline void QRectF::setBottom(qreal pos) { h = pos - yp; }
  538. inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); }
  539. inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); }
  540. inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); }
  541. inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); }
  542. inline QPointF QRectF::center() const
  543. { return QPointF(xp + w/2, yp + h/2); }
  544. inline void QRectF::moveLeft(qreal pos) { xp = pos; }
  545. inline void QRectF::moveTop(qreal pos) { yp = pos; }
  546. inline void QRectF::moveRight(qreal pos) { xp = pos - w; }
  547. inline void QRectF::moveBottom(qreal pos) { yp = pos - h; }
  548. inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); }
  549. inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); }
  550. inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); }
  551. inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); }
  552. inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; }
  553. inline qreal QRectF::width() const
  554. { return w; }
  555. inline qreal QRectF::height() const
  556. { return h; }
  557. inline QSizeF QRectF::size() const
  558. { return QSizeF(w, h); }
  559. inline void QRectF::translate(qreal dx, qreal dy)
  560. {
  561.     xp += dx;
  562.     yp += dy;
  563. }
  564. inline void QRectF::translate(const QPointF &p)
  565. {
  566.     xp += p.x();
  567.     yp += p.y();
  568. }
  569. inline void QRectF::moveTo(qreal ax, qreal ay)
  570. {
  571.     xp = ax;
  572.     yp = ay;
  573. }
  574. inline void QRectF::moveTo(const QPointF &p)
  575. {
  576.     xp = p.x();
  577.     yp = p.y();
  578. }
  579. inline QRectF QRectF::translated(qreal dx, qreal dy) const
  580. { return QRectF(xp + dx, yp + dy, w, h); }
  581. inline QRectF QRectF::translated(const QPointF &p) const
  582. { return QRectF(xp + p.x(), yp + p.y(), w, h); }
  583. inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const
  584. {
  585.     *ax = this->xp;
  586.     *ay = this->yp;
  587.     *aaw = this->w;
  588.     *aah = this->h;
  589. }
  590. inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah)
  591. {
  592.     this->xp = ax;
  593.     this->yp = ay;
  594.     this->w = aaw;
  595.     this->h = aah;
  596. }
  597. inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const
  598. {
  599.     *xp1 = xp;
  600.     *yp1 = yp;
  601.     *xp2 = xp + w;
  602.     *yp2 = yp + h;
  603. }
  604. inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
  605. {
  606.     xp = xp1;
  607.     yp = yp1;
  608.     w = xp2 - xp1;
  609.     h = yp2 - yp1;
  610. }
  611. inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
  612. { xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; }
  613. inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const
  614. { return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); }
  615. inline void QRectF::setWidth(qreal aw)
  616. { this->w = aw; }
  617. inline void QRectF::setHeight(qreal ah)
  618. { this->h = ah; }
  619. inline void QRectF::setSize(const QSizeF &s)
  620. {
  621.     w = s.width();
  622.     h = s.height();
  623. }
  624. inline bool QRectF::contains(qreal ax, qreal ay) const
  625. {
  626.     return contains(QPointF(ax, ay));
  627. }
  628. inline QRectF& QRectF::operator|=(const QRectF &r)
  629. {
  630.     *this = *this | r;
  631.     return *this;
  632. }
  633. inline QRectF& QRectF::operator&=(const QRectF &r)
  634. {
  635.     *this = *this & r;
  636.     return *this;
  637. }
  638. inline QRectF QRectF::intersect(const QRectF &r) const
  639. {
  640.     return *this & r;
  641. }
  642. inline QRectF QRectF::intersected(const QRectF &r) const
  643. {
  644.     return intersect(r);
  645. }
  646. inline QRectF QRectF::unite(const QRectF &r) const
  647. {
  648.     return *this | r;
  649. }
  650. inline QRectF QRectF::united(const QRectF &r) const
  651. {
  652.     return unite(r);
  653. }
  654. inline bool operator==(const QRectF &r1, const QRectF &r2)
  655. {
  656.     return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp)
  657.            && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h);
  658. }
  659. inline bool operator!=(const QRectF &r1, const QRectF &r2)
  660. {
  661.     return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp)
  662.            || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h);
  663. }
  664. inline QRect QRectF::toRect() const
  665. {
  666.     return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h));
  667. }
  668. #ifndef QT_NO_DEBUG_STREAM
  669. Q_CORE_EXPORT QDebug operator<<(QDebug, const QRectF &);
  670. #endif
  671. QT_END_NAMESPACE
  672. QT_END_HEADER
  673. #endif // QRECT_H