include/basegfx/tuple/Tuple2D.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  */
  10
  11 #pragma once
  12
  13 #include <o3tl/concepts.hxx>
  14 #include <basegfx/utils/common.hxx>
  15 #include <basegfx/numeric/ftools.hxx>
  16
  17 namespace basegfx
  18 {
  19 template <typename TYPE> class Tuple2D
  20 {
  21 protected:
  22     TYPE mnX;
  23     TYPE mnY;
  24
  25 public:
  26     /** Create a 2D Tuple
  27
  28             @param nX
  29             This parameter is used to initialize the X-coordinate
  30             of the 2D Tuple.
  31
  32             @param nY
  33             This parameter is used to initialize the Y-coordinate
  34             of the 2D Tuple.
  35     */
  36     Tuple2D(TYPE x, TYPE y)
  37         : mnX(x)
  38         , mnY(y)
  39     {
  40     }
  41
  42     double get(Axis2D eAxis) { return eAxis == Axis2D::X ? getX() : getY(); }
  43
  44     void set(Axis2D eAxis, TYPE fValue)
  45     {
  46         if (eAxis == Axis2D::X)
  47             setX(fValue);
  48         else
  49             setY(fValue);
  50     }
  51
  52     /// Get X-Coordinate of 2D Tuple
  53     TYPE getX() const { return mnX; }
  54
  55     /// Get Y-Coordinate of 2D Tuple
  56     TYPE getY() const { return mnY; }
  57
  58     /// Set X-Coordinate of 2D Tuple
  59     void setX(TYPE fX) { mnX = fX; }
  60
  61     /// Set Y-Coordinate of 2D Tuple
  62     void setY(TYPE fY) { mnY = fY; }
  63
  64     /// Adjust X-Coordinate of 2D Tuple
  65     void adjustX(TYPE fX) { mnX += fX; }
  66
  67     /// Adjust Y-Coordinate of 2D Tuple
  68     void adjustY(TYPE fY) { mnY += fY; }
  69
  70     // comparators with tolerance
  71
  72     template <o3tl::integral T = TYPE> bool equal(const Tuple2D<TYPE>& rTup) const
  73     {
  74         return mnX == rTup.mnX && mnY == rTup.mnY;
  75     }
  76
  77     template <o3tl::floating_point T = TYPE> bool equal(const Tuple2D<TYPE>& rTup) const
  78     {
  79         return this == &rTup || (fTools::equal(mnX, rTup.mnX) && fTools::equal(mnY, rTup.mnY));
  80     }
  81
  82     template <o3tl::integral T = TYPE> bool equalZero() const { return mnX == 0 && mnY == 0; }
  83
  84     template <o3tl::floating_point T = TYPE> bool equalZero() const
  85     {
  86         return fTools::equalZero(mnX) && fTools::equalZero(mnY);
  87     }
  88
  89     // operator overrides
  90
  91     Tuple2D<TYPE>& operator+=(const Tuple2D<TYPE>& rTup)
  92     {
  93         mnX += rTup.mnX;
  94         mnY += rTup.mnY;
  95         return *this;
  96     }
  97
  98     Tuple2D<TYPE>& operator-=(const Tuple2D<TYPE>& rTup)
  99     {
 100         mnX -= rTup.mnX;
 101         mnY -= rTup.mnY;
 102         return *this;
 103     }
 104
 105     Tuple2D<TYPE>& operator/=(const Tuple2D<TYPE>& rTup)
 106     {
 107         mnX /= rTup.mnX;
 108         mnY /= rTup.mnY;
 109         return *this;
 110     }
 111
 112     Tuple2D<TYPE>& operator*=(const Tuple2D<TYPE>& rTup)
 113     {
 114         mnX *= rTup.mnX;
 115         mnY *= rTup.mnY;
 116         return *this;
 117     }
 118
 119     Tuple2D<TYPE>& operator*=(TYPE t)
 120     {
 121         mnX *= t;
 122         mnY *= t;
 123         return *this;
 124     }
 125
 126     Tuple2D<TYPE>& operator/=(TYPE t)
 127     {
 128         mnX /= t;
 129         mnY /= t;
 130         return *this;
 131     }
 132
 133     Tuple2D<TYPE> operator-(void) const { return Tuple2D<TYPE>(-mnX, -mnY); }
 134
 135     bool operator==(const Tuple2D<TYPE>& rTup) const { return mnX == rTup.mnX && mnY == rTup.mnY; }
 136
 137     bool operator!=(const Tuple2D<TYPE>& rTup) const { return !(*this == rTup); }
 138 };
 139
 140 template <typename TYPE>
 141 inline Tuple2D<TYPE> operator-(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 142 {
 143     Tuple2D<TYPE> aNew(rTupA);
 144     aNew -= rTupB;
 145     return aNew;
 146 }
 147
 148 template <typename TYPE>
 149 inline Tuple2D<TYPE> operator+(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 150 {
 151     Tuple2D<TYPE> aNew(rTupA);
 152     aNew += rTupB;
 153     return aNew;
 154 }
 155
 156 template <typename TYPE>
 157 inline Tuple2D<TYPE> operator*(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 158 {
 159     Tuple2D<TYPE> aNew(rTupA);
 160     aNew *= rTupB;
 161     return aNew;
 162 }
 163
 164 template <typename TYPE>
 165 inline Tuple2D<TYPE> operator/(const Tuple2D<TYPE>& rTupA, const Tuple2D<TYPE>& rTupB)
 166 {
 167     Tuple2D<TYPE> aNew(rTupA);
 168     aNew /= rTupB;
 169     return aNew;
 170 }
 171
 172 } // end of namespace basegfx
 173
 174 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */