1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtCore module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #include "qpoint.h" |
41 | #include "qdatastream.h" |
42 | |
43 | #include <private/qdebug_p.h> |
44 | |
45 | QT_BEGIN_NAMESPACE |
46 | |
47 | /*! |
48 | \class QPoint |
49 | \inmodule QtCore |
50 | \ingroup painting |
51 | \reentrant |
52 | |
53 | \brief The QPoint class defines a point in the plane using integer |
54 | precision. |
55 | |
56 | A point is specified by a x coordinate and an y coordinate which |
57 | can be accessed using the x() and y() functions. The isNull() |
58 | function returns \c true if both x and y are set to 0. The |
59 | coordinates can be set (or altered) using the setX() and setY() |
60 | functions, or alternatively the rx() and ry() functions which |
61 | return references to the coordinates (allowing direct |
62 | manipulation). |
63 | |
64 | Given a point \e p, the following statements are all equivalent: |
65 | |
66 | \snippet code/src_corelib_tools_qpoint.cpp 0 |
67 | |
68 | A QPoint object can also be used as a vector: Addition and |
69 | subtraction are defined as for vectors (each component is added |
70 | separately). A QPoint object can also be divided or multiplied by |
71 | an \c int or a \c qreal. |
72 | |
73 | In addition, the QPoint class provides the manhattanLength() |
74 | function which gives an inexpensive approximation of the length of |
75 | the QPoint object interpreted as a vector. Finally, QPoint objects |
76 | can be streamed as well as compared. |
77 | |
78 | \sa QPointF, QPolygon |
79 | */ |
80 | |
81 | |
82 | /***************************************************************************** |
83 | QPoint member functions |
84 | *****************************************************************************/ |
85 | |
86 | /*! |
87 | \fn QPoint::QPoint() |
88 | |
89 | Constructs a null point, i.e. with coordinates (0, 0) |
90 | |
91 | \sa isNull() |
92 | */ |
93 | |
94 | /*! |
95 | \fn QPoint::QPoint(int xpos, int ypos) |
96 | |
97 | Constructs a point with the given coordinates (\a xpos, \a ypos). |
98 | |
99 | \sa setX(), setY() |
100 | */ |
101 | |
102 | /*! |
103 | \fn bool QPoint::isNull() const |
104 | |
105 | Returns \c true if both the x and y coordinates are set to 0, |
106 | otherwise returns \c false. |
107 | */ |
108 | |
109 | /*! |
110 | \fn int QPoint::x() const |
111 | |
112 | Returns the x coordinate of this point. |
113 | |
114 | \sa setX(), rx() |
115 | */ |
116 | |
117 | /*! |
118 | \fn int QPoint::y() const |
119 | |
120 | Returns the y coordinate of this point. |
121 | |
122 | \sa setY(), ry() |
123 | */ |
124 | |
125 | /*! |
126 | \fn void QPoint::setX(int x) |
127 | |
128 | Sets the x coordinate of this point to the given \a x coordinate. |
129 | |
130 | \sa x(), setY() |
131 | */ |
132 | |
133 | /*! |
134 | \fn void QPoint::setY(int y) |
135 | |
136 | Sets the y coordinate of this point to the given \a y coordinate. |
137 | |
138 | \sa y(), setX() |
139 | */ |
140 | |
141 | |
142 | /*! |
143 | \fn int &QPoint::rx() |
144 | |
145 | Returns a reference to the x coordinate of this point. |
146 | |
147 | Using a reference makes it possible to directly manipulate x. For example: |
148 | |
149 | \snippet code/src_corelib_tools_qpoint.cpp 1 |
150 | |
151 | \sa x(), setX() |
152 | */ |
153 | |
154 | /*! |
155 | \fn int &QPoint::ry() |
156 | |
157 | Returns a reference to the y coordinate of this point. |
158 | |
159 | Using a reference makes it possible to directly manipulate y. For |
160 | example: |
161 | |
162 | \snippet code/src_corelib_tools_qpoint.cpp 2 |
163 | |
164 | \sa y(), setY() |
165 | */ |
166 | |
167 | |
168 | /*! |
169 | \fn QPoint &QPoint::operator+=(const QPoint &point) |
170 | |
171 | Adds the given \a point to this point and returns a reference to |
172 | this point. For example: |
173 | |
174 | \snippet code/src_corelib_tools_qpoint.cpp 3 |
175 | |
176 | \sa operator-=() |
177 | */ |
178 | |
179 | /*! |
180 | \fn QPoint &QPoint::operator-=(const QPoint &point) |
181 | |
182 | Subtracts the given \a point from this point and returns a |
183 | reference to this point. For example: |
184 | |
185 | \snippet code/src_corelib_tools_qpoint.cpp 4 |
186 | |
187 | \sa operator+=() |
188 | */ |
189 | |
190 | /*! |
191 | \fn QPoint &QPoint::operator*=(float factor) |
192 | |
193 | Multiplies this point's coordinates by the given \a factor, and |
194 | returns a reference to this point. |
195 | |
196 | Note that the result is rounded to the nearest integer as points are held as |
197 | integers. Use QPointF for floating point accuracy. |
198 | |
199 | \sa operator/=() |
200 | */ |
201 | |
202 | /*! |
203 | \fn QPoint &QPoint::operator*=(double factor) |
204 | |
205 | Multiplies this point's coordinates by the given \a factor, and |
206 | returns a reference to this point. For example: |
207 | |
208 | \snippet code/src_corelib_tools_qpoint.cpp 5 |
209 | |
210 | Note that the result is rounded to the nearest integer as points are held as |
211 | integers. Use QPointF for floating point accuracy. |
212 | |
213 | \sa operator/=() |
214 | */ |
215 | |
216 | /*! |
217 | \fn QPoint &QPoint::operator*=(int factor) |
218 | |
219 | Multiplies this point's coordinates by the given \a factor, and |
220 | returns a reference to this point. |
221 | |
222 | \sa operator/=() |
223 | */ |
224 | |
225 | /*! |
226 | \fn static int QPoint::dotProduct(const QPoint &p1, const QPoint &p2) |
227 | \since 5.1 |
228 | |
229 | \snippet code/src_corelib_tools_qpoint.cpp 16 |
230 | |
231 | Returns the dot product of \a p1 and \a p2. |
232 | */ |
233 | |
234 | /*! |
235 | \fn bool operator==(const QPoint &p1, const QPoint &p2) |
236 | \relates QPoint |
237 | |
238 | Returns \c true if \a p1 and \a p2 are equal; otherwise returns |
239 | false. |
240 | */ |
241 | |
242 | /*! |
243 | \fn bool operator!=(const QPoint &p1, const QPoint &p2) |
244 | \relates QPoint |
245 | |
246 | Returns \c true if \a p1 and \a p2 are not equal; otherwise returns \c false. |
247 | */ |
248 | |
249 | /*! |
250 | \fn const QPoint operator+(const QPoint &p1, const QPoint &p2) |
251 | \relates QPoint |
252 | |
253 | Returns a QPoint object that is the sum of the given points, \a p1 |
254 | and \a p2; each component is added separately. |
255 | |
256 | \sa QPoint::operator+=() |
257 | */ |
258 | |
259 | /*! |
260 | \fn const QPoint operator-(const QPoint &p1, const QPoint &p2) |
261 | \relates QPoint |
262 | |
263 | Returns a QPoint object that is formed by subtracting \a p2 from |
264 | \a p1; each component is subtracted separately. |
265 | |
266 | \sa QPoint::operator-=() |
267 | */ |
268 | |
269 | /*! |
270 | \fn const QPoint operator*(const QPoint &point, float factor) |
271 | \relates QPoint |
272 | |
273 | Returns a copy of the given \a point multiplied by the given \a factor. |
274 | |
275 | Note that the result is rounded to the nearest integer as points |
276 | are held as integers. Use QPointF for floating point accuracy. |
277 | |
278 | \sa QPoint::operator*=() |
279 | */ |
280 | |
281 | /*! |
282 | \fn const QPoint operator*(const QPoint &point, double factor) |
283 | \relates QPoint |
284 | |
285 | Returns a copy of the given \a point multiplied by the given \a factor. |
286 | |
287 | Note that the result is rounded to the nearest integer as points |
288 | are held as integers. Use QPointF for floating point accuracy. |
289 | |
290 | \sa QPoint::operator*=() |
291 | */ |
292 | |
293 | /*! |
294 | \fn const QPoint operator*(const QPoint &point, int factor) |
295 | \relates QPoint |
296 | |
297 | Returns a copy of the given \a point multiplied by the given \a factor. |
298 | |
299 | \sa QPoint::operator*=() |
300 | */ |
301 | |
302 | /*! |
303 | \fn const QPoint operator*(float factor, const QPoint &point) |
304 | \overload |
305 | \relates QPoint |
306 | |
307 | Returns a copy of the given \a point multiplied by the given \a factor. |
308 | |
309 | Note that the result is rounded to the nearest integer as points |
310 | are held as integers. Use QPointF for floating point accuracy. |
311 | |
312 | \sa QPoint::operator*=() |
313 | */ |
314 | |
315 | /*! |
316 | \fn const QPoint operator*(double factor, const QPoint &point) |
317 | \overload |
318 | \relates QPoint |
319 | |
320 | Returns a copy of the given \a point multiplied by the given \a factor. |
321 | |
322 | Note that the result is rounded to the nearest integer as points |
323 | are held as integers. Use QPointF for floating point accuracy. |
324 | |
325 | \sa QPoint::operator*=() |
326 | */ |
327 | |
328 | /*! |
329 | \fn const QPoint operator*(int factor, const QPoint &point) |
330 | \overload |
331 | \relates QPoint |
332 | |
333 | Returns a copy of the given \a point multiplied by the given \a factor. |
334 | |
335 | \sa QPoint::operator*=() |
336 | */ |
337 | |
338 | /*! |
339 | \fn const QPoint operator+(const QPoint &point) |
340 | \relates QPoint |
341 | \since 5.0 |
342 | |
343 | Returns \a point unmodified. |
344 | */ |
345 | |
346 | /*! |
347 | \fn const QPoint operator-(const QPoint &point) |
348 | \overload |
349 | \relates QPoint |
350 | |
351 | Returns a QPoint object that is formed by changing the sign of |
352 | both components of the given \a point. |
353 | |
354 | Equivalent to \c{QPoint(0,0) - point}. |
355 | */ |
356 | |
357 | /*! |
358 | \fn QPoint &QPoint::operator/=(qreal divisor) |
359 | \overload |
360 | |
361 | Divides both x and y by the given \a divisor, and returns a reference to this |
362 | point. For example: |
363 | |
364 | \snippet code/src_corelib_tools_qpoint.cpp 6 |
365 | |
366 | Note that the result is rounded to the nearest integer as points are held as |
367 | integers. Use QPointF for floating point accuracy. |
368 | |
369 | \sa operator*=() |
370 | */ |
371 | |
372 | /*! |
373 | \fn const QPoint operator/(const QPoint &point, qreal divisor) |
374 | \relates QPoint |
375 | |
376 | Returns the QPoint formed by dividing both components of the given \a point |
377 | by the given \a divisor. |
378 | |
379 | Note that the result is rounded to the nearest integer as points are held as |
380 | integers. Use QPointF for floating point accuracy. |
381 | |
382 | \sa QPoint::operator/=() |
383 | */ |
384 | |
385 | /***************************************************************************** |
386 | QPoint stream functions |
387 | *****************************************************************************/ |
388 | #ifndef QT_NO_DATASTREAM |
389 | /*! |
390 | \fn QDataStream &operator<<(QDataStream &stream, const QPoint &point) |
391 | \relates QPoint |
392 | |
393 | Writes the given \a point to the given \a stream and returns a |
394 | reference to the stream. |
395 | |
396 | \sa {Serializing Qt Data Types} |
397 | */ |
398 | |
399 | QDataStream &operator<<(QDataStream &s, const QPoint &p) |
400 | { |
401 | if (s.version() == 1) |
402 | s << (qint16)p.x() << (qint16)p.y(); |
403 | else |
404 | s << (qint32)p.x() << (qint32)p.y(); |
405 | return s; |
406 | } |
407 | |
408 | /*! |
409 | \fn QDataStream &operator>>(QDataStream &stream, QPoint &point) |
410 | \relates QPoint |
411 | |
412 | Reads a point from the given \a stream into the given \a point |
413 | and returns a reference to the stream. |
414 | |
415 | \sa {Serializing Qt Data Types} |
416 | */ |
417 | |
418 | QDataStream &operator>>(QDataStream &s, QPoint &p) |
419 | { |
420 | if (s.version() == 1) { |
421 | qint16 x, y; |
422 | s >> x; p.rx() = x; |
423 | s >> y; p.ry() = y; |
424 | } |
425 | else { |
426 | qint32 x, y; |
427 | s >> x; p.rx() = x; |
428 | s >> y; p.ry() = y; |
429 | } |
430 | return s; |
431 | } |
432 | |
433 | #endif // QT_NO_DATASTREAM |
434 | /*! |
435 | \fn int QPoint::manhattanLength() const |
436 | |
437 | Returns the sum of the absolute values of x() and y(), |
438 | traditionally known as the "Manhattan length" of the vector from |
439 | the origin to the point. For example: |
440 | |
441 | \snippet code/src_corelib_tools_qpoint.cpp 7 |
442 | |
443 | This is a useful, and quick to calculate, approximation to the |
444 | true length: |
445 | |
446 | \snippet code/src_corelib_tools_qpoint.cpp 8 |
447 | |
448 | The tradition of "Manhattan length" arises because such distances |
449 | apply to travelers who can only travel on a rectangular grid, like |
450 | the streets of Manhattan. |
451 | */ |
452 | |
453 | #ifndef QT_NO_DEBUG_STREAM |
454 | QDebug operator<<(QDebug dbg, const QPoint &p) |
455 | { |
456 | QDebugStateSaver saver(dbg); |
457 | dbg.nospace(); |
458 | dbg << "QPoint" << '('; |
459 | QtDebugUtils::formatQPoint(dbg, p); |
460 | dbg << ')'; |
461 | return dbg; |
462 | } |
463 | |
464 | QDebug operator<<(QDebug dbg, const QPointF &p) |
465 | { |
466 | QDebugStateSaver saver(dbg); |
467 | dbg.nospace(); |
468 | dbg << "QPointF" << '('; |
469 | QtDebugUtils::formatQPoint(dbg, p); |
470 | dbg << ')'; |
471 | return dbg; |
472 | } |
473 | #endif |
474 | |
475 | /*! |
476 | \class QPointF |
477 | \inmodule QtCore |
478 | \ingroup painting |
479 | \reentrant |
480 | |
481 | \brief The QPointF class defines a point in the plane using |
482 | floating point precision. |
483 | |
484 | A point is specified by a x coordinate and an y coordinate which |
485 | can be accessed using the x() and y() functions. The coordinates |
486 | of the point are specified using floating point numbers for |
487 | accuracy. The isNull() function returns \c true if both x and y are |
488 | set to 0.0. The coordinates can be set (or altered) using the setX() |
489 | and setY() functions, or alternatively the rx() and ry() functions which |
490 | return references to the coordinates (allowing direct |
491 | manipulation). |
492 | |
493 | Given a point \e p, the following statements are all equivalent: |
494 | |
495 | \snippet code/src_corelib_tools_qpoint.cpp 9 |
496 | |
497 | A QPointF object can also be used as a vector: Addition and |
498 | subtraction are defined as for vectors (each component is added |
499 | separately). A QPointF object can also be divided or multiplied by |
500 | an \c int or a \c qreal. |
501 | |
502 | In addition, the QPointF class provides a constructor converting a |
503 | QPoint object into a QPointF object, and a corresponding toPoint() |
504 | function which returns a QPoint copy of \e this point. Finally, |
505 | QPointF objects can be streamed as well as compared. |
506 | |
507 | \sa QPoint, QPolygonF |
508 | */ |
509 | |
510 | /*! |
511 | \fn QPointF::QPointF() |
512 | |
513 | Constructs a null point, i.e. with coordinates (0.0, 0.0) |
514 | |
515 | \sa isNull() |
516 | */ |
517 | |
518 | /*! |
519 | \fn QPointF::QPointF(const QPoint &point) |
520 | |
521 | Constructs a copy of the given \a point. |
522 | |
523 | \sa toPoint() |
524 | */ |
525 | |
526 | /*! |
527 | \fn QPointF::QPointF(qreal xpos, qreal ypos) |
528 | |
529 | Constructs a point with the given coordinates (\a xpos, \a ypos). |
530 | |
531 | \sa setX(), setY() |
532 | */ |
533 | |
534 | /*! |
535 | \fn bool QPointF::isNull() const |
536 | |
537 | Returns \c true if both the x and y coordinates are set to 0.0 (ignoring |
538 | the sign); otherwise returns \c false. |
539 | */ |
540 | |
541 | |
542 | /*! |
543 | \fn qreal QPointF::manhattanLength() const |
544 | \since 4.6 |
545 | |
546 | Returns the sum of the absolute values of x() and y(), |
547 | traditionally known as the "Manhattan length" of the vector from |
548 | the origin to the point. |
549 | |
550 | \sa QPoint::manhattanLength() |
551 | */ |
552 | |
553 | /*! |
554 | \fn qreal QPointF::x() const |
555 | |
556 | Returns the x coordinate of this point. |
557 | |
558 | \sa setX(), rx() |
559 | */ |
560 | |
561 | /*! |
562 | \fn qreal QPointF::y() const |
563 | |
564 | Returns the y coordinate of this point. |
565 | |
566 | \sa setY(), ry() |
567 | */ |
568 | |
569 | /*! |
570 | \fn void QPointF::setX(qreal x) |
571 | |
572 | Sets the x coordinate of this point to the given \a x coordinate. |
573 | |
574 | \sa x(), setY() |
575 | */ |
576 | |
577 | /*! |
578 | \fn void QPointF::setY(qreal y) |
579 | |
580 | Sets the y coordinate of this point to the given \a y coordinate. |
581 | |
582 | \sa y(), setX() |
583 | */ |
584 | |
585 | /*! |
586 | \fn qreal& QPointF::rx() |
587 | |
588 | Returns a reference to the x coordinate of this point. |
589 | |
590 | Using a reference makes it possible to directly manipulate x. For example: |
591 | |
592 | \snippet code/src_corelib_tools_qpoint.cpp 10 |
593 | |
594 | \sa x(), setX() |
595 | */ |
596 | |
597 | /*! |
598 | \fn qreal& QPointF::ry() |
599 | |
600 | Returns a reference to the y coordinate of this point. |
601 | |
602 | Using a reference makes it possible to directly manipulate y. For example: |
603 | |
604 | \snippet code/src_corelib_tools_qpoint.cpp 11 |
605 | |
606 | \sa y(), setY() |
607 | */ |
608 | |
609 | /*! |
610 | \fn QPointF& QPointF::operator+=(const QPointF &point) |
611 | |
612 | Adds the given \a point to this point and returns a reference to |
613 | this point. For example: |
614 | |
615 | \snippet code/src_corelib_tools_qpoint.cpp 12 |
616 | |
617 | \sa operator-=() |
618 | */ |
619 | |
620 | /*! |
621 | \fn QPointF& QPointF::operator-=(const QPointF &point) |
622 | |
623 | Subtracts the given \a point from this point and returns a reference |
624 | to this point. For example: |
625 | |
626 | \snippet code/src_corelib_tools_qpoint.cpp 13 |
627 | |
628 | \sa operator+=() |
629 | */ |
630 | |
631 | /*! |
632 | \fn QPointF& QPointF::operator*=(qreal factor) |
633 | |
634 | Multiplies this point's coordinates by the given \a factor, and |
635 | returns a reference to this point. For example: |
636 | |
637 | \snippet code/src_corelib_tools_qpoint.cpp 14 |
638 | |
639 | \sa operator/=() |
640 | */ |
641 | |
642 | /*! |
643 | \fn QPointF& QPointF::operator/=(qreal divisor) |
644 | |
645 | Divides both x and y by the given \a divisor, and returns a reference |
646 | to this point. For example: |
647 | |
648 | \snippet code/src_corelib_tools_qpoint.cpp 15 |
649 | |
650 | \sa operator*=() |
651 | */ |
652 | |
653 | /*! |
654 | \fn const QPointF operator+(const QPointF &p1, const QPointF &p2) |
655 | \relates QPointF |
656 | |
657 | Returns a QPointF object that is the sum of the given points, \a p1 |
658 | and \a p2; each component is added separately. |
659 | |
660 | \sa QPointF::operator+=() |
661 | */ |
662 | |
663 | /*! |
664 | \fn const QPointF operator-(const QPointF &p1, const QPointF &p2) |
665 | \relates QPointF |
666 | |
667 | Returns a QPointF object that is formed by subtracting \a p2 from \a p1; |
668 | each component is subtracted separately. |
669 | |
670 | \sa QPointF::operator-=() |
671 | */ |
672 | |
673 | /*! |
674 | \fn const QPointF operator*(const QPointF &point, qreal factor) |
675 | \relates QPointF |
676 | |
677 | Returns a copy of the given \a point, multiplied by the given \a factor. |
678 | |
679 | \sa QPointF::operator*=() |
680 | */ |
681 | |
682 | /*! |
683 | \fn const QPointF operator*(qreal factor, const QPointF &point) |
684 | \relates QPointF |
685 | |
686 | \overload |
687 | |
688 | Returns a copy of the given \a point, multiplied by the given \a factor. |
689 | */ |
690 | |
691 | /*! |
692 | \fn const QPointF operator+(const QPointF &point) |
693 | \relates QPointF |
694 | \since 5.0 |
695 | |
696 | Returns \a point unmodified. |
697 | */ |
698 | |
699 | /*! |
700 | \fn const QPointF operator-(const QPointF &point) |
701 | \relates QPointF |
702 | \overload |
703 | |
704 | Returns a QPointF object that is formed by changing the sign of |
705 | both components of the given \a point. |
706 | |
707 | Equivalent to \c {QPointF(0,0) - point}. |
708 | */ |
709 | |
710 | /*! |
711 | \fn const QPointF operator/(const QPointF &point, qreal divisor) |
712 | \relates QPointF |
713 | |
714 | Returns the QPointF object formed by dividing both components of |
715 | the given \a point by the given \a divisor. |
716 | |
717 | \sa QPointF::operator/=() |
718 | */ |
719 | |
720 | /*! |
721 | \fn QPoint QPointF::toPoint() const |
722 | |
723 | Rounds the coordinates of this point to the nearest integer, and |
724 | returns a QPoint object with the rounded coordinates. |
725 | |
726 | \sa QPointF() |
727 | */ |
728 | |
729 | /*! |
730 | \fn static qreal QPointF::dotProduct(const QPointF &p1, const QPointF &p2) |
731 | \since 5.1 |
732 | |
733 | \snippet code/src_corelib_tools_qpoint.cpp 17 |
734 | |
735 | Returns the dot product of \a p1 and \a p2. |
736 | */ |
737 | |
738 | /*! |
739 | \fn bool operator==(const QPointF &p1, const QPointF &p2) |
740 | \relates QPointF |
741 | |
742 | Returns \c true if \a p1 is equal to \a p2; otherwise returns \c false. |
743 | */ |
744 | |
745 | /*! |
746 | \fn bool operator!=(const QPointF &p1, const QPointF &p2); |
747 | \relates QPointF |
748 | |
749 | Returns \c true if \a p1 is not equal to \a p2; otherwise returns \c false. |
750 | */ |
751 | |
752 | #ifndef QT_NO_DATASTREAM |
753 | /*! |
754 | \fn QDataStream &operator<<(QDataStream &stream, const QPointF &point) |
755 | \relates QPointF |
756 | |
757 | Writes the given \a point to the given \a stream and returns a |
758 | reference to the stream. |
759 | |
760 | \sa {Serializing Qt Data Types} |
761 | */ |
762 | |
763 | QDataStream &operator<<(QDataStream &s, const QPointF &p) |
764 | { |
765 | s << double(p.x()) << double(p.y()); |
766 | return s; |
767 | } |
768 | |
769 | /*! |
770 | \fn QDataStream &operator>>(QDataStream &stream, QPointF &point) |
771 | \relates QPointF |
772 | |
773 | Reads a point from the given \a stream into the given \a point |
774 | and returns a reference to the stream. |
775 | |
776 | \sa {Serializing Qt Data Types} |
777 | */ |
778 | |
779 | QDataStream &operator>>(QDataStream &s, QPointF &p) |
780 | { |
781 | double x, y; |
782 | s >> x; |
783 | s >> y; |
784 | p.setX(qreal(x)); |
785 | p.setY(qreal(y)); |
786 | return s; |
787 | } |
788 | #endif // QT_NO_DATASTREAM |
789 | |
790 | QT_END_NAMESPACE |
791 | |