Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 : #ifndef INCLUDED_TOOLS_GEN_HXX
20 : #define INCLUDED_TOOLS_GEN_HXX
21 :
22 : #include <tools/toolsdllapi.h>
23 :
24 : #include <limits.h>
25 : #include <algorithm>
26 : #include <ostream>
27 : #include <cstdlib>
28 :
29 : class SvStream;
30 : namespace rtl
31 : {
32 : class OString;
33 : }
34 :
35 : enum TriState { TRISTATE_FALSE, TRISTATE_TRUE, TRISTATE_INDET };
36 :
37 : // Pair
38 :
39 : class SAL_WARN_UNUSED Pair
40 : {
41 : public:
42 : Pair();
43 : Pair( long nA, long nB );
44 :
45 5 : long A() const { return nA; }
46 16 : long B() const { return nB; }
47 :
48 112671 : long& A() { return nA; }
49 112644 : long& B() { return nB; }
50 :
51 : bool operator == ( const Pair& rPair ) const;
52 : bool operator != ( const Pair& rPair ) const;
53 :
54 : TOOLS_DLLPUBLIC friend SvStream& ReadPair( SvStream& rIStream, Pair& rPair );
55 : TOOLS_DLLPUBLIC friend SvStream& WritePair( SvStream& rOStream, const Pair& rPair );
56 :
57 : protected:
58 : long nA;
59 : long nB;
60 : };
61 :
62 42190481 : inline Pair::Pair()
63 : {
64 42190481 : nA = nB = 0;
65 42190481 : }
66 :
67 187087280 : inline Pair::Pair( long _nA, long _nB )
68 : {
69 187087280 : Pair::nA = _nA;
70 187087280 : Pair::nB = _nB;
71 187087280 : }
72 :
73 55259564 : inline bool Pair::operator == ( const Pair& rPair ) const
74 : {
75 55259564 : return ((nA == rPair.nA) && (nB == rPair.nB));
76 : }
77 :
78 66423196 : inline bool Pair::operator != ( const Pair& rPair ) const
79 : {
80 66423196 : return ((nA != rPair.nA) || (nB != rPair.nB));
81 : }
82 :
83 : // Point
84 :
85 : class SAL_DLLPUBLIC_EXPORT SAL_WARN_UNUSED Point : public Pair
86 : {
87 : public:
88 : Point();
89 : Point( long nX, long nY );
90 :
91 286733741 : long X() const { return nA; }
92 260914421 : long Y() const { return nB; }
93 :
94 84396116 : long& X() { return nA; }
95 72177090 : long& Y() { return nB; }
96 :
97 : void Move( long nHorzMove, long nVertMove );
98 : bool IsAbove( const Point& rPoint ) const;
99 : bool IsBelow( const Point& rPoint ) const;
100 : bool IsLeft( const Point& rPoint ) const;
101 : bool IsRight( const Point& rPoint ) const;
102 :
103 : void RotateAround( long& rX, long& rY, short nOrientation ) const;
104 :
105 :
106 : Point& operator += ( const Point& rPoint );
107 : Point& operator -= ( const Point& rPoint );
108 : Point& operator *= ( const long nVal );
109 : Point& operator /= ( const long nVal );
110 :
111 : friend inline Point operator+( const Point &rVal1, const Point &rVal2 );
112 : friend inline Point operator-( const Point &rVal1, const Point &rVal2 );
113 : friend inline Point operator*( const Point &rVal1, const long nVal2 );
114 : friend inline Point operator/( const Point &rVal1, const long nVal2 );
115 :
116 119051864 : long getX() const { return X(); }
117 116215425 : long getY() const { return Y(); }
118 820332 : void setX(long nX) { X() = nX; }
119 888339 : void setY(long nY) { Y() = nY; }
120 : };
121 :
122 12065346 : inline Point::Point()
123 : {
124 12065346 : }
125 :
126 115208381 : inline Point::Point( long nX, long nY ) : Pair( nX, nY )
127 : {
128 115208381 : }
129 :
130 1413 : inline void Point::Move( long nHorzMove, long nVertMove )
131 : {
132 1413 : nA += nHorzMove;
133 1413 : nB += nVertMove;
134 1413 : }
135 :
136 : inline bool Point::IsAbove( const Point& rPoint ) const
137 : {
138 : return (nB > rPoint.nB);
139 : }
140 :
141 : inline bool Point::IsBelow( const Point& rPoint ) const
142 : {
143 : return (nB < rPoint.nB);
144 : }
145 :
146 : inline bool Point::IsLeft( const Point& rPoint ) const
147 : {
148 : return (nA < rPoint.nA);
149 : }
150 :
151 : inline bool Point::IsRight( const Point& rPoint ) const
152 : {
153 : return (nA > rPoint.nA);
154 : }
155 :
156 4205683 : inline Point& Point::operator += ( const Point& rPoint )
157 : {
158 4205683 : nA += rPoint.nA;
159 4205683 : nB += rPoint.nB;
160 4205683 : return *this;
161 : }
162 :
163 360502 : inline Point& Point::operator -= ( const Point& rPoint )
164 : {
165 360502 : nA -= rPoint.nA;
166 360502 : nB -= rPoint.nB;
167 360502 : return *this;
168 : }
169 :
170 104 : inline Point& Point::operator *= ( const long nVal )
171 : {
172 104 : nA *= nVal;
173 104 : nB *= nVal;
174 104 : return *this;
175 : }
176 :
177 0 : inline Point& Point::operator /= ( const long nVal )
178 : {
179 0 : nA /= nVal;
180 0 : nB /= nVal;
181 0 : return *this;
182 : }
183 :
184 3924746 : inline Point operator+( const Point &rVal1, const Point &rVal2 )
185 : {
186 3924746 : return Point( rVal1.nA+rVal2.nA, rVal1.nB+rVal2.nB );
187 : }
188 :
189 3618684 : inline Point operator-( const Point &rVal1, const Point &rVal2 )
190 : {
191 3618684 : return Point( rVal1.nA-rVal2.nA, rVal1.nB-rVal2.nB );
192 : }
193 :
194 0 : inline Point operator*( const Point &rVal1, const long nVal2 )
195 : {
196 0 : return Point( rVal1.nA*nVal2, rVal1.nB*nVal2 );
197 : }
198 :
199 0 : inline Point operator/( const Point &rVal1, const long nVal2 )
200 : {
201 0 : return Point( rVal1.nA/nVal2, rVal1.nB/nVal2 );
202 : }
203 :
204 : template< typename charT, typename traits >
205 : inline std::basic_ostream<charT, traits> & operator <<(
206 : std::basic_ostream<charT, traits> & stream, const Point& point )
207 : {
208 : return stream << point.X() << ',' << point.Y();
209 : }
210 :
211 : // Size
212 :
213 : class SAL_WARN_UNUSED Size : public Pair
214 : {
215 : public:
216 : Size();
217 : Size( long nWidth, long nHeight );
218 :
219 251106581 : long Width() const { return nA; }
220 297939099 : long Height() const { return nB; }
221 :
222 110234636 : long& Width() { return nA; }
223 19050184 : long& Height() { return nB; }
224 :
225 226236869 : long getWidth() const { return Width(); }
226 274901491 : long getHeight() const { return Height(); }
227 3370730 : void setWidth(long nWidth) { Width() = nWidth; }
228 3223108 : void setHeight(long nHeight) { Height() = nHeight; }
229 : };
230 :
231 30110809 : inline Size::Size()
232 : {
233 30110809 : }
234 :
235 71271356 : inline Size::Size( long nWidth, long nHeight ) :
236 71271356 : Pair( nWidth, nHeight )
237 : {
238 71271356 : }
239 :
240 : template< typename charT, typename traits >
241 0 : inline std::basic_ostream<charT, traits> & operator <<(
242 : std::basic_ostream<charT, traits> & stream, const Size& size )
243 : {
244 0 : return stream << size.Width() << 'x' << size.Height();
245 : }
246 :
247 : // Range
248 :
249 : #define RANGE_MAX LONG_MAX
250 :
251 : class SAL_WARN_UNUSED Range : public Pair
252 : {
253 : public:
254 : Range();
255 : Range( long nMin, long nMax );
256 :
257 16839 : long Min() const { return nA; }
258 17096 : long Max() const { return nB; }
259 413161 : long Len() const { return nB - nA + 1; }
260 :
261 1208333 : long& Min() { return nA; }
262 2117048 : long& Max() { return nB; }
263 :
264 : bool IsInside( long nIs ) const;
265 :
266 : void Justify();
267 : };
268 :
269 346 : inline Range::Range()
270 : {
271 346 : }
272 :
273 598721 : inline Range::Range( long nMin, long nMax ) : Pair( nMin, nMax )
274 : {
275 598721 : }
276 :
277 541 : inline bool Range::IsInside( long nIs ) const
278 : {
279 541 : return ((nA <= nIs) && (nIs <= nB ));
280 : }
281 :
282 78386 : inline void Range::Justify()
283 : {
284 78386 : if ( nA > nB )
285 : {
286 182 : long nHelp = nA;
287 182 : nA = nB;
288 182 : nB = nHelp;
289 : }
290 78386 : }
291 :
292 : template< typename charT, typename traits >
293 : inline std::basic_ostream<charT, traits> & operator <<(
294 : std::basic_ostream<charT, traits> & stream, const Range& range )
295 : {
296 : return stream << range.Min() << '-' << range.Max();
297 : }
298 :
299 : // Selection
300 :
301 : #define SELECTION_MIN LONG_MIN
302 : #define SELECTION_MAX LONG_MAX
303 :
304 : class SAL_WARN_UNUSED Selection : public Pair
305 : {
306 : public:
307 : Selection();
308 : Selection( long nPos );
309 : Selection( long nMin, long nMax );
310 :
311 0 : long Min() const { return nA; }
312 0 : long Max() const { return nB; }
313 43943 : long Len() const { return nB - nA; }
314 :
315 94650 : long& Min() { return nA; }
316 81896 : long& Max() { return nB; }
317 :
318 : bool IsInside( long nIs ) const;
319 :
320 : void Justify();
321 :
322 1121 : bool operator !() const { return !Len(); }
323 :
324 0 : long getMin() const { return Min(); }
325 : long getMax() const { return Max(); }
326 0 : void setMin(long nMin) { Min() = nMin; }
327 0 : void setMax(long nMax) { Max() = nMax; }
328 : };
329 :
330 13977 : inline Selection::Selection()
331 : {
332 13977 : }
333 :
334 0 : inline Selection::Selection( long nPos ) : Pair( nPos, nPos )
335 : {
336 0 : }
337 :
338 8793 : inline Selection::Selection( long nMin, long nMax ) :
339 8793 : Pair( nMin, nMax )
340 : {
341 8793 : }
342 :
343 0 : inline bool Selection::IsInside( long nIs ) const
344 : {
345 0 : return ((nA <= nIs) && (nIs < nB ));
346 : }
347 :
348 14444 : inline void Selection::Justify()
349 : {
350 14444 : if ( nA > nB )
351 : {
352 1 : long nHelp = nA;
353 1 : nA = nB;
354 1 : nB = nHelp;
355 : }
356 14444 : }
357 :
358 : template< typename charT, typename traits >
359 : inline std::basic_ostream<charT, traits> & operator <<(
360 : std::basic_ostream<charT, traits> & stream, const Selection& selection )
361 : {
362 : return stream << selection.Min() << '-' << selection.Max();
363 : }
364 : // Rectangle
365 :
366 : #define RECT_EMPTY ((short)-32767)
367 : #define RECT_MAX LONG_MAX
368 : #define RECT_MIN LONG_MIN
369 :
370 : class TOOLS_DLLPUBLIC SAL_WARN_UNUSED Rectangle
371 : {
372 : public:
373 : Rectangle();
374 : Rectangle( const Point& rLT, const Point& rRB );
375 : Rectangle( long nLeft, long nTop,
376 : long nRight, long nBottom );
377 : Rectangle( const Point& rLT, const Size& rSize );
378 :
379 12265842 : long Left() const { return nLeft; }
380 11558926 : long Right() const { return nRight; }
381 11978944 : long Top() const { return nTop; }
382 11356187 : long Bottom() const { return nBottom; }
383 :
384 7292660 : long& Left() { return nLeft; }
385 4313886 : long& Right() { return nRight; }
386 8058764 : long& Top() { return nTop; }
387 5124349 : long& Bottom() { return nBottom; }
388 :
389 : inline Point TopLeft() const;
390 : inline Point TopRight() const;
391 : inline Point TopCenter() const;
392 : inline Point BottomLeft() const;
393 : inline Point BottomRight() const;
394 : inline Point BottomCenter() const;
395 : inline Point LeftCenter() const;
396 : inline Point RightCenter() const;
397 : inline Point Center() const;
398 :
399 : inline void Move( long nHorzMove, long nVertMove );
400 : inline void Transpose();
401 : inline void SetPos( const Point& rPoint );
402 : void SetSize( const Size& rSize );
403 : inline Size GetSize() const;
404 :
405 : inline long GetWidth() const;
406 : inline long GetHeight() const;
407 :
408 : Rectangle& Union( const Rectangle& rRect );
409 : Rectangle& Intersection( const Rectangle& rRect );
410 : inline Rectangle GetUnion( const Rectangle& rRect ) const;
411 : inline Rectangle GetIntersection( const Rectangle& rRect ) const;
412 :
413 : void Justify();
414 :
415 : bool IsInside( const Point& rPOINT ) const;
416 : bool IsInside( const Rectangle& rRect ) const;
417 : bool IsOver( const Rectangle& rRect ) const;
418 :
419 631561 : void SetEmpty() { nRight = nBottom = RECT_EMPTY; }
420 : inline bool IsEmpty() const;
421 :
422 : inline bool operator == ( const Rectangle& rRect ) const;
423 : inline bool operator != ( const Rectangle& rRect ) const;
424 :
425 : inline Rectangle& operator += ( const Point& rPt );
426 : inline Rectangle& operator -= ( const Point& rPt );
427 :
428 : friend inline Rectangle operator + ( const Rectangle& rRect, const Point& rPt );
429 : friend inline Rectangle operator - ( const Rectangle& rRect, const Point& rPt );
430 :
431 : TOOLS_DLLPUBLIC friend SvStream& ReadRectangle( SvStream& rIStream, Rectangle& rRect );
432 : TOOLS_DLLPUBLIC friend SvStream& WriteRectangle( SvStream& rOStream, const Rectangle& rRect );
433 :
434 : // ONE
435 34277 : long getX() const { return nLeft; }
436 71808 : long getY() const { return nTop; }
437 154535 : long getWidth() const { return nRight - nLeft; }
438 149992 : long getHeight() const { return nBottom - nTop; }
439 23309 : void setX( long n ) { nRight += n-nLeft; nLeft = n; }
440 23309 : void setY( long n ) { nBottom += n-nTop; nTop = n; }
441 144053 : void setWidth( long n ) { nRight = nLeft + n; }
442 160034 : void setHeight( long n ) { nBottom = nTop + n; }
443 : /// Returns the string representation of the rectangle, format is "x, y, width, height".
444 : rtl::OString toString() const;
445 :
446 : /**
447 : * Expands the rectangle in all directions by the input value.
448 : */
449 : inline void expand(long nExpandBy);
450 : /**
451 : * Contracts the rectangle in all directions by the input value.
452 : */
453 : inline void contract(long nContractBy);
454 :
455 : private:
456 : long nLeft;
457 : long nTop;
458 : long nRight;
459 : long nBottom;
460 : };
461 :
462 11089831 : inline Rectangle::Rectangle()
463 : {
464 11089831 : nLeft = nTop = 0;
465 11089831 : nRight = nBottom = RECT_EMPTY;
466 11089831 : }
467 :
468 756078 : inline Rectangle::Rectangle( const Point& rLT, const Point& rRB )
469 : {
470 756078 : nLeft = rLT.X();
471 756078 : nTop = rLT.Y();
472 756078 : nRight = rRB.X();
473 756078 : nBottom = rRB.Y();
474 756078 : }
475 :
476 6222823 : inline Rectangle::Rectangle( long _nLeft, long _nTop,
477 : long _nRight, long _nBottom )
478 : {
479 6222823 : nLeft = _nLeft;
480 6222823 : nTop = _nTop;
481 6222823 : nRight = _nRight;
482 6222823 : nBottom = _nBottom;
483 6222823 : }
484 :
485 5706800 : inline Rectangle::Rectangle( const Point& rLT, const Size& rSize )
486 : {
487 5706800 : nLeft = rLT.X();
488 5706800 : nTop = rLT.Y();
489 5706800 : nRight = rSize.Width() ? nLeft+rSize.Width()-1 : RECT_EMPTY;
490 5706800 : nBottom = rSize.Height() ? nTop+rSize.Height()-1 : RECT_EMPTY;
491 5706800 : }
492 :
493 17201556 : inline bool Rectangle::IsEmpty() const
494 : {
495 17201556 : return ((nRight == RECT_EMPTY) || (nBottom == RECT_EMPTY));
496 : }
497 :
498 3044583 : inline Point Rectangle::TopLeft() const
499 : {
500 3044583 : return Point( nLeft, nTop );
501 : }
502 :
503 1867803 : inline Point Rectangle::TopRight() const
504 : {
505 1867803 : return Point( (nRight == RECT_EMPTY) ? nLeft : nRight, nTop );
506 : }
507 :
508 1895277 : inline Point Rectangle::BottomLeft() const
509 : {
510 1895277 : return Point( nLeft, (nBottom == RECT_EMPTY) ? nTop : nBottom );
511 : }
512 :
513 1913412 : inline Point Rectangle::BottomRight() const
514 : {
515 1913412 : return Point( (nRight == RECT_EMPTY) ? nLeft : nRight,
516 3826824 : (nBottom == RECT_EMPTY) ? nTop : nBottom );
517 : }
518 :
519 343 : inline Point Rectangle::TopCenter() const
520 : {
521 343 : if ( IsEmpty() )
522 0 : return Point( nLeft, nTop );
523 : else
524 686 : return Point( std::min( nLeft, nRight ) + std::abs( (nRight - nLeft)/2 ),
525 1029 : std::min( nTop, nBottom) );
526 : }
527 :
528 360 : inline Point Rectangle::BottomCenter() const
529 : {
530 360 : if ( IsEmpty() )
531 0 : return Point( nLeft, nTop );
532 : else
533 720 : return Point( std::min( nLeft, nRight ) + std::abs( (nRight - nLeft)/2 ),
534 1080 : std::max( nTop, nBottom) );
535 : }
536 :
537 335 : inline Point Rectangle::LeftCenter() const
538 : {
539 335 : if ( IsEmpty() )
540 0 : return Point( nLeft, nTop );
541 : else
542 335 : return Point( std::min( nLeft, nRight ), nTop + (nBottom - nTop)/2 );
543 : }
544 :
545 335 : inline Point Rectangle::RightCenter() const
546 : {
547 335 : if ( IsEmpty() )
548 0 : return Point( nLeft, nTop );
549 : else
550 335 : return Point( std::max( nLeft, nRight ), nTop + (nBottom - nTop)/2 );
551 : }
552 :
553 303638 : inline Point Rectangle::Center() const
554 : {
555 303638 : if ( IsEmpty() )
556 74722 : return Point( nLeft, nTop );
557 : else
558 228916 : return Point( nLeft+(nRight-nLeft)/2 , nTop+(nBottom-nTop)/2 );
559 : }
560 :
561 478661 : inline void Rectangle::Move( long nHorzMove, long nVertMove )
562 : {
563 478661 : nLeft += nHorzMove;
564 478661 : nTop += nVertMove;
565 478661 : if ( nRight != RECT_EMPTY )
566 308536 : nRight += nHorzMove;
567 478661 : if ( nBottom != RECT_EMPTY )
568 306946 : nBottom += nVertMove;
569 478661 : }
570 :
571 0 : void Rectangle::Transpose()
572 : {
573 0 : if ( !IsEmpty() )
574 : {
575 0 : long swap( nLeft );
576 0 : nLeft = nTop;
577 0 : nTop = swap;
578 :
579 0 : swap = nRight;
580 0 : nRight = nBottom;
581 0 : nBottom = swap;
582 : }
583 0 : }
584 :
585 6608 : inline void Rectangle::SetPos( const Point& rPoint )
586 : {
587 6608 : if ( nRight != RECT_EMPTY )
588 4166 : nRight += rPoint.X() - nLeft;
589 6608 : if ( nBottom != RECT_EMPTY )
590 4167 : nBottom += rPoint.Y() - nTop;
591 6608 : nLeft = rPoint.X();
592 6608 : nTop = rPoint.Y();
593 6608 : }
594 :
595 5034032 : inline long Rectangle::GetWidth() const
596 : {
597 : long n;
598 5034032 : if ( nRight == RECT_EMPTY )
599 90706 : n = 0;
600 : else
601 : {
602 4943326 : n = nRight - nLeft;
603 4943326 : if( n < 0 )
604 7291 : n--;
605 : else
606 4936035 : n++;
607 : }
608 :
609 5034032 : return n;
610 : }
611 :
612 5509891 : inline long Rectangle::GetHeight() const
613 : {
614 : long n;
615 5509891 : if ( nBottom == RECT_EMPTY )
616 86551 : n = 0;
617 : else
618 : {
619 5423340 : n = nBottom - nTop;
620 5423340 : if ( n < 0 )
621 6607 : n--;
622 : else
623 5416733 : n++;
624 : }
625 :
626 5509891 : return n;
627 : }
628 :
629 670336 : inline Size Rectangle::GetSize() const
630 : {
631 670336 : return Size( GetWidth(), GetHeight() );
632 : }
633 :
634 0 : inline Rectangle Rectangle::GetUnion( const Rectangle& rRect ) const
635 : {
636 0 : Rectangle aTmpRect( *this );
637 0 : return aTmpRect.Union( rRect );
638 : }
639 :
640 206629 : inline Rectangle Rectangle::GetIntersection( const Rectangle& rRect ) const
641 : {
642 206629 : Rectangle aTmpRect( *this );
643 206629 : return aTmpRect.Intersection( rRect );
644 : }
645 :
646 81058 : inline bool Rectangle::operator == ( const Rectangle& rRect ) const
647 : {
648 121884 : return ((nLeft == rRect.nLeft ) &&
649 81036 : (nTop == rRect.nTop ) &&
650 145483 : (nRight == rRect.nRight ) &&
651 105273 : (nBottom == rRect.nBottom ));
652 : }
653 :
654 211288 : inline bool Rectangle::operator != ( const Rectangle& rRect ) const
655 : {
656 373727 : return ((nLeft != rRect.nLeft ) ||
657 322426 : (nTop != rRect.nTop ) ||
658 513905 : (nRight != rRect.nRight ) ||
659 353918 : (nBottom != rRect.nBottom ));
660 : }
661 :
662 1677994 : inline Rectangle& Rectangle::operator +=( const Point& rPt )
663 : {
664 1677994 : nLeft += rPt.X();
665 1677994 : nTop += rPt.Y();
666 1677994 : if ( nRight != RECT_EMPTY )
667 1677067 : nRight += rPt.X();
668 1677994 : if ( nBottom != RECT_EMPTY )
669 1599410 : nBottom += rPt.Y();
670 1677994 : return *this;
671 : }
672 :
673 40972 : inline Rectangle& Rectangle::operator -= ( const Point& rPt )
674 : {
675 40972 : nLeft -= rPt.X();
676 40972 : nTop -= rPt.Y();
677 40972 : if ( nRight != RECT_EMPTY )
678 40972 : nRight -= rPt.X();
679 40972 : if ( nBottom != RECT_EMPTY )
680 40972 : nBottom -= rPt.Y();
681 40972 : return *this;
682 : }
683 :
684 20518 : inline Rectangle operator + ( const Rectangle& rRect, const Point& rPt )
685 : {
686 41036 : Rectangle aRect( rRect.nLeft + rPt.X(), rRect.nTop + rPt.Y(),
687 41036 : (rRect.nRight == RECT_EMPTY) ? RECT_EMPTY : rRect.nRight + rPt.X(),
688 102590 : (rRect.nBottom == RECT_EMPTY) ? RECT_EMPTY : rRect.nBottom + rPt.Y() );
689 20518 : return aRect;
690 : }
691 :
692 1451 : inline Rectangle operator - ( const Rectangle& rRect, const Point& rPt )
693 : {
694 1451 : Rectangle aRect( rRect.nLeft - rPt.X(),
695 1451 : rRect.nTop - rPt.Y(),
696 2902 : (rRect.nRight == RECT_EMPTY) ? RECT_EMPTY : rRect.nRight - rPt.X(),
697 7255 : (rRect.nBottom == RECT_EMPTY) ? RECT_EMPTY : rRect.nBottom - rPt.Y() );
698 1451 : return aRect;
699 : }
700 :
701 0 : inline void Rectangle::expand(long nExpandBy)
702 : {
703 0 : nLeft -= nExpandBy;
704 0 : nTop -= nExpandBy;
705 0 : nRight += nExpandBy;
706 0 : nBottom += nExpandBy;
707 0 : }
708 :
709 : inline void Rectangle::contract(long nContractBy)
710 : {
711 : nLeft += nContractBy;
712 : nTop += nContractBy;
713 : nRight -= nContractBy;
714 : nBottom -= nContractBy;
715 : }
716 :
717 : template< typename charT, typename traits >
718 : inline std::basic_ostream<charT, traits> & operator <<(
719 : std::basic_ostream<charT, traits> & stream, const Rectangle& rectangle )
720 : {
721 : if (rectangle.IsEmpty())
722 : return stream << "EMPTY";
723 : else
724 : return stream << rectangle.getWidth() << 'x' << rectangle.getHeight()
725 : << "@(" << rectangle.getX() << ',' << rectangle.getY() << ")";
726 : }
727 :
728 : #endif
729 :
730 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
