include/tools/gen.hxx

   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
  20 #pragma once
  21
  22 #include <tools/toolsdllapi.h>
  23
  24 #include <tools/long.hxx>
  25 #include <tools/degree.hxx>
  26 #include <limits.h>
  27 #include <algorithm>
  28 #include <ostream>
  29 #include <config_options.h>
  30 #include <o3tl/unit_conversion.hxx>
  31
  32 class SvStream;
  33 namespace rtl
  34 {
  35     class OString;
  36 }
  37
  38 enum TriState { TRISTATE_FALSE, TRISTATE_TRUE, TRISTATE_INDET };
  39
  40 // Pair
  41
  42 class SAL_WARN_UNUSED Pair
  43 {
  44 public:
  45     constexpr Pair() : mnA(0), mnB(0) {}
  46     constexpr Pair( tools::Long nA, tools::Long nB ) : mnA(nA), mnB(nB) {}
  47
  48     tools::Long                A() const { return mnA; }
  49     tools::Long                B() const { return mnB; }
  50
  51     tools::Long&               A() { return mnA; }
  52     tools::Long&               B() { return mnB; }
  53
  54     TOOLS_DLLPUBLIC rtl::OString        toString() const;
  55
  56     // Compute value usable as hash.
  57     TOOLS_DLLPUBLIC size_t     GetHashValue() const;
  58
  59 protected:
  60     tools::Long                mnA;
  61     tools::Long                mnB;
  62 };
  63
  64 namespace tools::detail {
  65
  66 // Used to implement operator == for subclasses of Pair:
  67 inline bool equal(Pair const & p1, Pair const & p2)
  68 {
  69     return p1.A() == p2.A() && p1.B() == p2.B();
  70 }
  71
  72 }
  73
  74 // Point
  75
  76 class Size;
  77 class SAL_WARN_UNUSED UNLESS_MERGELIBS(SAL_DLLPUBLIC_EXPORT) Point final : protected Pair
  78 {
  79 public:
  80     constexpr Point() {}
  81     constexpr Point( tools::Long nX, tools::Long nY ) : Pair( nX, nY ) {}
  82
  83     constexpr tools::Long      X() const { return mnA; }
  84     constexpr tools::Long      Y() const { return mnB; }
  85
  86     void                Move( tools::Long nHorzMove, tools::Long nVertMove );
  87     void                Move( Size const & s );
  88     tools::Long                AdjustX( tools::Long nHorzMove ) { mnA += nHorzMove; return mnA; }
  89     tools::Long                AdjustY( tools::Long nVertMove ) { mnB += nVertMove; return mnB; }
  90
  91     void                RotateAround( tools::Long& rX, tools::Long& rY, Degree10 nOrientation ) const;
  92     void                RotateAround( Point&, Degree10 nOrientation ) const;
  93
  94     Point&              operator += ( const Point& rPoint );
  95     Point&              operator -= ( const Point& rPoint );
  96     Point&              operator *= ( const tools::Long nVal );
  97     Point&              operator /= ( const tools::Long nVal );
  98
  99     friend inline Point operator+( const Point &rVal1, const Point &rVal2 );
 100     friend inline Point operator-( const Point &rVal1, const Point &rVal2 );
 101     friend inline Point operator*( const Point &rVal1, const tools::Long nVal2 );
 102     friend inline Point operator/( const Point &rVal1, const tools::Long nVal2 );
 103
 104     constexpr tools::Long      getX() const { return X(); }
 105     constexpr tools::Long      getY() const { return Y(); }
 106     void                setX(tools::Long nX)  { mnA = nX; }
 107     void                setY(tools::Long nY)  { mnB = nY; }
 108
 109     Pair const &        toPair() const { return *this; }
 110     Pair &              toPair() { return *this; }
 111
 112     // Scales relative to 0,0
 113     constexpr inline Point scale(sal_Int64 nMulX, sal_Int64 nDivX,
 114                                  sal_Int64 nMulY, sal_Int64 nDivY) const;
 115
 116     using Pair::toString;
 117     using Pair::GetHashValue;
 118 };
 119
 120 inline void Point::Move( tools::Long nHorzMove, tools::Long nVertMove )
 121 {
 122     mnA += nHorzMove;
 123     mnB += nVertMove;
 124 }
 125
 126 inline Point& Point::operator += ( const Point& rPoint )
 127 {
 128     mnA += rPoint.mnA;
 129     mnB += rPoint.mnB;
 130     return *this;
 131 }
 132
 133 inline Point& Point::operator -= ( const Point& rPoint )
 134 {
 135     mnA -= rPoint.mnA;
 136     mnB -= rPoint.mnB;
 137     return *this;
 138 }
 139
 140 inline Point& Point::operator *= ( const tools::Long nVal )
 141 {
 142     mnA *= nVal;
 143     mnB *= nVal;
 144     return *this;
 145 }
 146
 147 inline Point& Point::operator /= ( const tools::Long nVal )
 148 {
 149     mnA /= nVal;
 150     mnB /= nVal;
 151     return *this;
 152 }
 153
 154 inline Point operator+( const Point &rVal1, const Point &rVal2 )
 155 {
 156     return Point( rVal1.mnA+rVal2.mnA, rVal1.mnB+rVal2.mnB );
 157 }
 158
 159 inline Point operator-( const Point &rVal1, const Point &rVal2 )
 160 {
 161     return Point( rVal1.mnA-rVal2.mnA, rVal1.mnB-rVal2.mnB );
 162 }
 163
 164 inline Point operator*( const Point &rVal1, const tools::Long nVal2 )
 165 {
 166     return Point( rVal1.mnA*nVal2, rVal1.mnB*nVal2 );
 167 }
 168
 169 inline Point operator/( const Point &rVal1, const tools::Long nVal2 )
 170 {
 171     return Point( rVal1.mnA/nVal2, rVal1.mnB/nVal2 );
 172 }
 173
 174 inline bool operator ==(Point const & p1, Point const & p2)
 175 {
 176     return tools::detail::equal(p1.toPair(), p2.toPair());
 177 }
 178
 179 inline bool operator !=(Point const & p1, Point const & p2)
 180 {
 181     return !(p1 == p2);
 182 }
 183
 184 constexpr inline Point Point::scale(sal_Int64 nMulX, sal_Int64 nDivX, sal_Int64 nMulY, sal_Int64 nDivY) const
 185 {
 186     return Point(o3tl::convert(getX(), nMulX, nDivX),
 187                  o3tl::convert(getY(), nMulY, nDivY));
 188 }
 189
 190 namespace o3tl
 191 {
 192
 193 constexpr Point convert(const Point& rPoint, o3tl::Length eFrom, o3tl::Length eTo)
 194 {
 195     const auto [num, den] = o3tl::getConversionMulDiv(eFrom, eTo);
 196     return rPoint.scale(num, den, num, den);
 197 }
 198
 199 } // end o3tl
 200
 201 template< typename charT, typename traits >
 202 inline std::basic_ostream<charT, traits> & operator <<(
 203     std::basic_ostream<charT, traits> & stream, const Point& point )
 204 {
 205     return stream << point.X() << ',' << point.Y();
 206 }
 207
 208 // Size
 209
 210 class SAL_WARN_UNUSED Size final : protected Pair
 211 {
 212 public:
 213     constexpr Size() {}
 214     constexpr Size( tools::Long nWidth, tools::Long nHeight ) : Pair( nWidth, nHeight ) {}
 215
 216     constexpr tools::Long  Width() const  { return mnA; }
 217     constexpr tools::Long  Height() const { return mnB; }
 218
 219     tools::Long            AdjustWidth( tools::Long n ) { mnA += n; return mnA; }
 220     tools::Long            AdjustHeight( tools::Long n ) { mnB += n; return mnB; }
 221
 222     constexpr tools::Long  getWidth() const { return Width(); }
 223     constexpr tools::Long  getHeight() const { return Height(); }
 224     void            setWidth(tools::Long nWidth)  { mnA = nWidth; }
 225     void            setHeight(tools::Long nHeight)  { mnB = nHeight; }
 226
 227     bool            IsEmpty() const { return mnA <= 0 || mnB <= 0; }
 228
 229     void extendBy(tools::Long x, tools::Long y)
 230     {
 231         mnA += x;
 232         mnB += y;
 233     }
 234
 235     Pair const &    toPair() const { return *this; }
 236     Pair &          toPair() { return *this; }
 237
 238     using Pair::toString;
 239     using Pair::GetHashValue;
 240
 241     Size&              operator += ( const Size& rSize );
 242     Size&              operator -= ( const Size& rSize );
 243     Size&              operator *= ( const tools::Long nVal );
 244     Size&              operator /= ( const tools::Long nVal );
 245
 246     friend inline Size operator+( const Size &rVal1, const Size &rVal2 );
 247     friend inline Size operator-( const Size &rVal1, const Size &rVal2 );
 248     friend inline Size operator*( const Size &rVal1, const tools::Long nVal2 );
 249     friend inline Size operator/( const Size &rVal1, const tools::Long nVal2 );
 250
 251     constexpr inline Size scale(sal_Int64 nMulX, sal_Int64 nDivX,
 252                                 sal_Int64 nMulY, sal_Int64 nDivY) const;
 253
 254 };
 255
 256 inline bool operator ==(Size const & s1, Size const & s2)
 257 {
 258     return tools::detail::equal(s1.toPair(), s2.toPair());
 259 }
 260
 261 inline bool operator !=(Size const & s1, Size const & s2)
 262 {
 263     return !(s1 == s2);
 264 }
 265
 266 inline Size& Size::operator += ( const Size& rSize )
 267 {
 268     mnA += rSize.mnA;
 269     mnB += rSize.mnB;
 270     return *this;
 271 }
 272
 273 inline Size& Size::operator -= ( const Size& rSize )
 274 {
 275     mnA -= rSize.mnA;
 276     mnB -= rSize.mnB;
 277     return *this;
 278 }
 279
 280 inline Size& Size::operator *= ( const tools::Long nVal )
 281 {
 282     mnA *= nVal;
 283     mnB *= nVal;
 284     return *this;
 285 }
 286
 287 inline Size& Size::operator /= ( const tools::Long nVal )
 288 {
 289     mnA /= nVal;
 290     mnB /= nVal;
 291     return *this;
 292 }
 293
 294 inline Size operator+( const Size &rVal1, const Size &rVal2 )
 295 {
 296     return Size( rVal1.mnA+rVal2.mnA, rVal1.mnB+rVal2.mnB );
 297 }
 298
 299 inline Size operator-( const Size &rVal1, const Size &rVal2 )
 300 {
 301     return Size( rVal1.mnA-rVal2.mnA, rVal1.mnB-rVal2.mnB );
 302 }
 303
 304 inline Size operator*( const Size &rVal1, const tools::Long nVal2 )
 305 {
 306     return Size( rVal1.mnA*nVal2, rVal1.mnB*nVal2 );
 307 }
 308
 309 inline Size operator/( const Size &rVal1, const tools::Long nVal2 )
 310 {
 311     return Size( rVal1.mnA/nVal2, rVal1.mnB/nVal2 );
 312 }
 313
 314 constexpr inline Size Size::scale(sal_Int64 nMulX, sal_Int64 nDivX,
 315                                   sal_Int64 nMulY, sal_Int64 nDivY) const
 316 {
 317     return Size(o3tl::convert(Width(), nMulX, nDivX),
 318                 o3tl::convert(Height(), nMulY, nDivY));
 319 }
 320
 321 namespace o3tl
 322 {
 323
 324 constexpr Size convert(const Size& rSize, o3tl::Length eFrom, o3tl::Length eTo)
 325 {
 326     const auto [num, den] = o3tl::getConversionMulDiv(eFrom, eTo);
 327     return rSize.scale(num, den, num, den);
 328 }
 329
 330 } // end o3tl
 331
 332 template< typename charT, typename traits >
 333 inline std::basic_ostream<charT, traits> & operator <<(
 334     std::basic_ostream<charT, traits> & stream, const Size& size )
 335 {
 336     return stream << size.Width() << 'x' << size.Height();
 337 }
 338
 339 inline void Point::Move( Size const & s )
 340 {
 341     AdjustX(s.Width());
 342     AdjustY(s.Height());
 343 }
 344
 345 // Range
 346
 347 #define RANGE_MAX   LONG_MAX
 348
 349 class SAL_WARN_UNUSED Range final : protected Pair
 350 {
 351 public:
 352     constexpr Range() {}
 353     constexpr Range( tools::Long nMin, tools::Long nMax ) : Pair( nMin, nMax ) {}
 354
 355     tools::Long            Min() const { return mnA; }
 356     tools::Long            Max() const { return mnB; }
 357     tools::Long            Len() const { return mnB - mnA + 1; }
 358
 359     tools::Long&           Min() { return mnA; }
 360     tools::Long&           Max() { return mnB; }
 361
 362     bool            Contains( tools::Long nIs ) const;
 363
 364     void            Normalize();
 365
 366     Pair const &    toPair() const { return *this; }
 367     Pair &          toPair() { return *this; }
 368
 369     using Pair::toString;
 370 };
 371
 372 inline bool Range::Contains( tools::Long nIs ) const
 373 {
 374     return ((mnA <= nIs) && (nIs <= mnB ));
 375 }
 376
 377 inline void Range::Normalize()
 378 {
 379     if ( mnA > mnB )
 380         std::swap(mnA, mnB);
 381 }
 382
 383 inline bool operator ==(Range const & r1, Range const & r2)
 384 {
 385     return tools::detail::equal(r1.toPair(), r2.toPair());
 386 }
 387
 388 inline bool operator !=(Range const & r1, Range const & r2)
 389 {
 390     return !(r1 == r2);
 391 }
 392
 393 template< typename charT, typename traits >
 394 inline std::basic_ostream<charT, traits> & operator <<(
 395     std::basic_ostream<charT, traits> & stream, const Range& range )
 396 {
 397     return stream << range.Min() << '-' << range.Max();
 398 }
 399
 400 // Selection
 401
 402 #define SELECTION_MIN   LONG_MIN
 403 #define SELECTION_MAX   LONG_MAX
 404
 405 class SAL_WARN_UNUSED Selection final : protected Pair
 406 {
 407 public:
 408                     Selection() {}
 409                     Selection( tools::Long nPos ) : Pair( nPos, nPos ) {}
 410                     Selection( tools::Long nMin, tools::Long nMax ) : Pair( nMin, nMax ) {}
 411
 412     tools::Long            Min() const { return mnA; }
 413     tools::Long            Max() const { return mnB; }
 414     tools::Long            Len() const { return mnB - mnA; }
 415
 416     tools::Long&           Min() { return mnA; }
 417     tools::Long&           Max() { return mnB; }
 418
 419     bool            Contains( tools::Long nIs ) const;
 420
 421     void            Normalize();
 422
 423     bool            operator !() const { return !Len(); }
 424
 425     tools::Long            getMin() const { return Min(); }
 426     void            setMin(tools::Long nMin)  { Min() = nMin; }
 427     void            setMax(tools::Long nMax)  { Max() = nMax; }
 428
 429     Pair const &    toPair() const { return *this; }
 430     Pair &          toPair() { return *this; }
 431
 432     using Pair::toString;
 433 };
 434
 435 inline bool Selection::Contains( tools::Long nIs ) const
 436 {
 437     return ((mnA <= nIs) && (nIs < mnB ));
 438 }
 439
 440 inline void Selection::Normalize()
 441 {
 442     if ( mnA > mnB )
 443         std::swap(mnA, mnB);
 444 }
 445
 446 inline bool operator ==(Selection const & s1, Selection const & s2)
 447 {
 448     return tools::detail::equal(s1.toPair(), s2.toPair());
 449 }
 450
 451 inline bool operator !=(Selection const & s1, Selection const & s2)
 452 {
 453     return !(s1 == s2);
 454 }
 455
 456 template< typename charT, typename traits >
 457 inline std::basic_ostream<charT, traits> & operator <<(
 458     std::basic_ostream<charT, traits> & stream, const Selection& selection )
 459 {
 460     return stream << selection.Min() << '-' << selection.Max();
 461 }
 462 // Rectangle
 463
 464 #define RECT_MAX    LONG_MAX
 465 #define RECT_MIN    LONG_MIN
 466
 467 /// Note: this class is a true marvel of engineering: because the author
 468 /// could not decide whether it's better to have a closed or half-open
 469 /// interval, they just implemented *both* in the same class!
 470 ///
 471 /// If you have the misfortune of having to use this class, don't immediately
 472 /// despair but first take note that the uppercase GetWidth() / GetHeight()
 473 /// etc. methods interpret the interval as closed. To use the half open versions,
 474 /// use GetOpenWidth() / GetOpenHeight().
 475 ///
 476 /// If you want to work with Size, you must use the closed interval functions!
 477 /// And don't add GetOpenSize() / setSize; this will probably just introduce
 478 /// bugs, especially when used in combination with list-initialization.
 479 ///
 480 /// (Eventually you might notice, that the same engineer was also working on
 481 /// Qt at some point; see documentation on QRect::bottom / QRect::right ;-).
 482 namespace tools
 483 {
 484 class SAL_WARN_UNUSED TOOLS_DLLPUBLIC Rectangle final
 485 {
 486     static constexpr short RECT_EMPTY = -32767;
 487 public:
 488     constexpr Rectangle() = default;
 489     constexpr Rectangle( const Point& rLT, const Point& rRB );
 490     constexpr Rectangle( tools::Long mnLeft, tools::Long mnTop,
 491                          tools::Long mnRight, tools::Long mnBottom );
 492     /// Constructs an empty Rectangle, with top/left at the specified params
 493     constexpr Rectangle( tools::Long mnLeft, tools::Long mnTop );
 494     /// Constructs a closed interval rectangle
 495     constexpr Rectangle( const Point& rLT, const Size& rSize );
 496
 497     constexpr inline static Rectangle Normalize(const Point& rLT, const Point& rRB);
 498
 499     constexpr tools::Long Left() const { return mnLeft; }
 500     constexpr tools::Long Right() const { return IsWidthEmpty() ? mnLeft : mnRight; }
 501     constexpr tools::Long Top() const { return mnTop; }
 502     constexpr tools::Long Bottom() const { return IsHeightEmpty() ? mnTop : mnBottom; }
 503
 504     constexpr void SetLeft(tools::Long v) { mnLeft = v; }
 505     constexpr void SetRight(tools::Long v) { mnRight = v; }
 506     constexpr void SetTop(tools::Long v) { mnTop = v; }
 507     constexpr void SetBottom(tools::Long v) { mnBottom = v; }
 508
 509     constexpr Point TopLeft() const { return { Left(), Top() }; }
 510     constexpr Point TopRight() const { return { Right(), Top() }; }
 511     constexpr Point TopCenter() const { return { (Left() + Right()) / 2, Top() }; }
 512     constexpr Point BottomLeft() const { return { Left(), Bottom() }; }
 513     constexpr Point BottomRight() const { return { Right(), Bottom() }; }
 514     constexpr Point BottomCenter() const { return { (Left() + Right()) / 2, Bottom() }; }
 515     constexpr Point LeftCenter() const { return { Left(), (Top() + Bottom()) / 2 }; }
 516     constexpr Point RightCenter() const { return { Right(), (Top() + Bottom()) / 2 }; }
 517     constexpr Point Center() const { return { (Left() + Right()) / 2, (Top() + Bottom()) / 2 }; }
 518
 519     /// Move the top and left edges by a delta, preserving width and height
 520     inline void         Move( tools::Long nHorzMoveDelta, tools::Long nVertMoveDelta );
 521     void                Move( Size const & s ) { Move(s.Width(), s.Height()); }
 522     tools::Long         AdjustLeft( tools::Long nHorzMoveDelta ) { mnLeft += nHorzMoveDelta; return mnLeft; }
 523     tools::Long         AdjustRight( tools::Long nHorzMoveDelta );
 524     tools::Long         AdjustTop( tools::Long nVertMoveDelta ) { mnTop += nVertMoveDelta; return mnTop; }
 525     tools::Long         AdjustBottom( tools::Long nVertMoveDelta );
 526     /// Set the left edge of the rectangle to x, preserving the width
 527     inline void SetPosX(tools::Long x);
 528     /// Set the top edge of the rectangle to y, preserving the height
 529     inline void SetPosY(tools::Long y);
 530     inline void         SetPos( const Point& rPoint );
 531     inline void SetWidth(tools::Long);
 532     inline void SetHeight(tools::Long);
 533     inline void SetSize(const Size&);
 534
 535     constexpr Point GetPos() const { return TopLeft(); }
 536     constexpr Size GetSize() const { return { GetWidth(), GetHeight() }; }
 537
 538     /// Returns the difference between right and left, assuming the range is inclusive.
 539     constexpr inline tools::Long GetWidth() const;
 540     /// Returns the difference between bottom and top, assuming the range is inclusive.
 541     constexpr inline tools::Long GetHeight() const;
 542
 543     tools::Rectangle&          Union( const tools::Rectangle& rRect );
 544     tools::Rectangle&          Intersection( const tools::Rectangle& rRect );
 545     inline tools::Rectangle    GetUnion( const tools::Rectangle& rRect ) const;
 546     inline tools::Rectangle    GetIntersection( const tools::Rectangle& rRect ) const;
 547
 548     void                Normalize();
 549
 550     bool                Contains( const Point& rPOINT ) const;
 551     bool                Contains( const tools::Rectangle& rRect ) const;
 552     bool                Overlaps( const tools::Rectangle& rRect ) const;
 553
 554     void                SetEmpty() { mnRight = mnBottom = RECT_EMPTY; }
 555     void                SetWidthEmpty() { mnRight = RECT_EMPTY; }
 556     void                SetHeightEmpty() { mnBottom = RECT_EMPTY; }
 557     constexpr bool IsEmpty() const { return IsWidthEmpty() || IsHeightEmpty(); }
 558     constexpr bool IsWidthEmpty() const { return mnRight == RECT_EMPTY; }
 559     constexpr bool IsHeightEmpty() const { return mnBottom == RECT_EMPTY; }
 560
 561     inline bool         operator == ( const tools::Rectangle& rRect ) const;
 562     inline bool         operator != ( const tools::Rectangle& rRect ) const;
 563
 564     inline tools::Rectangle&   operator += ( const Point& rPt );
 565     inline tools::Rectangle&   operator -= ( const Point& rPt );
 566
 567     friend inline tools::Rectangle operator + ( const tools::Rectangle& rRect, const Point& rPt );
 568     friend inline tools::Rectangle operator - ( const tools::Rectangle& rRect, const Point& rPt );
 569
 570     tools::Long         getX() const { return mnLeft; }
 571     tools::Long         getY() const { return mnTop; }
 572     /// Returns the difference between right and left, assuming the range includes one end, but not the other.
 573     tools::Long getOpenWidth() const { return Right() - Left(); }
 574     /// Returns the difference between bottom and top, assuming the range includes one end, but not the other.
 575     tools::Long getOpenHeight() const { return Bottom() - Top(); }
 576     void                setWidth( tools::Long n ) { mnRight = mnLeft + n; }
 577     void                setHeight( tools::Long n ) { mnBottom = mnTop + n; }
 578     /// Returns the string representation of the rectangle, format is "x, y, width, height".
 579     rtl::OString        toString() const;
 580
 581     /**
 582      * Expands the rectangle in all directions by the input value.
 583      */
 584     void expand(tools::Long nExpandBy);
 585     void shrink(tools::Long nShrinkBy);
 586
 587     /**
 588      * Sanitizing variants for handling data from the outside
 589      */
 590     void                SaturatingSetSize(const Size& rSize);
 591     void                SaturatingSetPosX(tools::Long x);
 592     void                SaturatingSetPosY(tools::Long y);
 593
 594     // Scales relative to 0,0
 595     constexpr inline tools::Rectangle scale(sal_Int64 nMulX, sal_Int64 nDivX,
 596                                             sal_Int64 nMulY, sal_Int64 nDivY) const;
 597
 598 private:
 599     tools::Long mnLeft = 0;
 600     tools::Long mnTop = 0;
 601     tools::Long mnRight = RECT_EMPTY;
 602     tools::Long mnBottom = RECT_EMPTY;
 603 };
 604 }
 605
 606 constexpr inline tools::Rectangle::Rectangle( const Point& rLT, const Point& rRB )
 607     : Rectangle(rLT.X(), rLT.Y(), rRB.X(), rRB.Y())
 608 {}
 609
 610 constexpr inline tools::Rectangle::Rectangle( tools::Long nLeft,  tools::Long nTop,
 611                              tools::Long nRight, tools::Long nBottom )
 612     : mnLeft( nLeft )
 613     , mnTop( nTop )
 614     , mnRight( nRight )
 615     , mnBottom( nBottom )
 616 {}
 617
 618 constexpr inline tools::Rectangle::Rectangle( tools::Long nLeft,  tools::Long nTop )
 619     : mnLeft(nLeft)
 620     , mnTop(nTop)
 621 {}
 622
 623 constexpr inline tools::Rectangle::Rectangle( const Point& rLT, const Size& rSize )
 624     : mnLeft( rLT.X())
 625     , mnTop( rLT.Y())
 626     , mnRight(rSize.Width() ? mnLeft + (rSize.Width() + (rSize.Width() > 0 ? -1 : 1)) : RECT_EMPTY)
 627     , mnBottom(rSize.Height() ? mnTop + (rSize.Height() + (rSize.Height() > 0 ? -1 : 1)) : RECT_EMPTY)
 628 {}
 629
 630 constexpr inline tools::Rectangle tools::Rectangle::Normalize(const Point& rLT, const Point& rRB)
 631 {
 632     const std::pair<tools::Long, tools::Long> aLeftRight = std::minmax(rLT.X(), rRB.X());
 633     const std::pair<tools::Long, tools::Long> aTopBottom = std::minmax(rLT.Y(), rRB.Y());
 634     return { aLeftRight.first, aTopBottom.first, aLeftRight.second, aTopBottom.second };
 635 }
 636
 637 inline void tools::Rectangle::Move( tools::Long nHorzMove, tools::Long nVertMove )
 638 {
 639     mnLeft += nHorzMove;
 640     mnTop  += nVertMove;
 641     if (!IsWidthEmpty())
 642         mnRight += nHorzMove;
 643     if (!IsHeightEmpty())
 644         mnBottom += nVertMove;
 645 }
 646
 647 inline void tools::Rectangle::SetPosX(tools::Long x)
 648 {
 649     if (!IsWidthEmpty())
 650         mnRight += x - mnLeft;
 651     mnLeft = x;
 652 }
 653
 654 inline void tools::Rectangle::SetPosY(tools::Long y)
 655 {
 656     if (!IsHeightEmpty())
 657         mnBottom += y - mnTop;
 658     mnTop = y;
 659 }
 660
 661 inline void tools::Rectangle::SetPos( const Point& rPoint )
 662 {
 663     SetPosX(rPoint.X());
 664     SetPosY(rPoint.Y());
 665 }
 666
 667 inline void tools::Rectangle::SetWidth(tools::Long nWidth)
 668 {
 669     if (nWidth < 0)
 670         mnRight = mnLeft + nWidth + 1;
 671     else if (nWidth > 0)
 672         mnRight = mnLeft + nWidth - 1;
 673     else
 674         SetWidthEmpty();
 675 }
 676
 677 inline void tools::Rectangle::SetHeight(tools::Long nHeight)
 678 {
 679     if (nHeight < 0)
 680         mnBottom = mnTop + nHeight + 1;
 681     else if (nHeight > 0)
 682         mnBottom = mnTop + nHeight - 1;
 683     else
 684         SetHeightEmpty();
 685 }
 686
 687 inline void tools::Rectangle::SetSize(const Size& rSize)
 688 {
 689     SetWidth(rSize.Width());
 690     SetHeight(rSize.Height());
 691 }
 692
 693 constexpr inline tools::Long tools::Rectangle::GetWidth() const
 694 {
 695     tools::Long n = 0;
 696
 697     if (!IsWidthEmpty())
 698     {
 699         n = mnRight - mnLeft;
 700         if (n < 0)
 701             n--;
 702         else
 703             n++;
 704     }
 705
 706     return n;
 707 }
 708
 709 constexpr inline tools::Long tools::Rectangle::GetHeight() const
 710 {
 711     tools::Long n = 0;
 712
 713     if (!IsHeightEmpty())
 714     {
 715         n = mnBottom - mnTop;
 716         if (n < 0)
 717             n--;
 718         else
 719             n++;
 720     }
 721
 722     return n;
 723 }
 724
 725 inline tools::Rectangle tools::Rectangle::GetUnion( const tools::Rectangle& rRect ) const
 726 {
 727     tools::Rectangle aTmpRect( *this );
 728     return aTmpRect.Union( rRect );
 729 }
 730
 731 inline tools::Rectangle tools::Rectangle::GetIntersection( const tools::Rectangle& rRect ) const
 732 {
 733     tools::Rectangle aTmpRect( *this );
 734     return aTmpRect.Intersection( rRect );
 735 }
 736
 737 inline bool tools::Rectangle::operator == ( const tools::Rectangle& rRect ) const
 738 {
 739     return (mnLeft   == rRect.mnLeft   ) &&
 740            (mnTop    == rRect.mnTop    ) &&
 741            (mnRight  == rRect.mnRight  ) &&
 742            (mnBottom == rRect.mnBottom );
 743 }
 744
 745 inline bool tools::Rectangle::operator != ( const tools::Rectangle& rRect ) const
 746 {
 747     return (mnLeft   != rRect.mnLeft   ) ||
 748            (mnTop    != rRect.mnTop    ) ||
 749            (mnRight  != rRect.mnRight  ) ||
 750            (mnBottom != rRect.mnBottom );
 751 }
 752
 753 inline tools::Rectangle& tools::Rectangle::operator +=( const Point& rPt )
 754 {
 755     Move(rPt.X(), rPt.Y());
 756     return *this;
 757 }
 758
 759 inline tools::Rectangle& tools::Rectangle::operator -= ( const Point& rPt )
 760 {
 761     Move(-rPt.X(), -rPt.Y());
 762     return *this;
 763 }
 764
 765 namespace tools
 766 {
 767 inline Rectangle operator + ( const Rectangle& rRect, const Point& rPt )
 768 {
 769     return Rectangle{ rRect }.operator+=(rPt);
 770 }
 771
 772 inline Rectangle operator - ( const Rectangle& rRect, const Point& rPt )
 773 {
 774     return Rectangle{ rRect }.operator-=(rPt);
 775 }
 776
 777 }
 778
 779 constexpr inline tools::Rectangle tools::Rectangle::scale(sal_Int64 nMulX, sal_Int64 nDivX,
 780                                                           sal_Int64 nMulY, sal_Int64 nDivY) const
 781 {
 782     // 1. Create an empty rectangle with correct left and top
 783     tools::Rectangle aRect(o3tl::convert(Left(), nMulX, nDivX),
 784                            o3tl::convert(Top(), nMulY, nDivY));
 785     // 2. If source has width/height, set respective right and bottom
 786     if (!IsWidthEmpty())
 787         aRect.SetRight(o3tl::convert(Right(), nMulX, nDivX));
 788     if (!IsHeightEmpty())
 789         aRect.SetBottom(o3tl::convert(Bottom(), nMulY, nDivY));
 790     return aRect;
 791 }
 792
 793 namespace o3tl
 794 {
 795
 796 constexpr tools::Rectangle convert(const tools::Rectangle& rRectangle, o3tl::Length eFrom, o3tl::Length eTo)
 797 {
 798     const auto [num, den] = o3tl::getConversionMulDiv(eFrom, eTo);
 799     return rRectangle.scale(num, den, num, den);
 800 }
 801
 802 } // end o3tl
 803
 804 namespace tools
 805 {
 806 template< typename charT, typename traits >
 807 inline std::basic_ostream<charT, traits> & operator <<(
 808     std::basic_ostream<charT, traits> & stream, const tools::Rectangle& rectangle )
 809 {
 810     if (rectangle.IsEmpty())
 811         return stream << "EMPTY";
 812     else
 813         return stream << rectangle.GetWidth() << 'x' << rectangle.GetHeight()
 814                       << "@(" << rectangle.getX() << ',' << rectangle.getY() << ")";
 815 }
 816 }
 817
 818 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */