qgsmargins.h

Go to the documentation of this file.

/***************************************************************************
  qgsmargins.h
  ------------
  Date                 : January 2017
  Copyright            : (C) 2017 by Nyall Dawson
  Email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSMARGINS_H
#define QGSMARGINS_H

#include "qgis_core.h"
#include "qgis.h"
#include <QString>

//This class was originally based off Qt's QgsMarginsF class
//It was forked in order to always use double values, rather than qreal values.

class CORE_EXPORT QgsMargins
{
  public:

    QgsMargins() = default;

    QgsMargins( double left, double top, double right, double bottom )
      : mLeft( left )
      , mTop( top )
      , mRight( right )
      , mBottom( bottom )
    {}

    bool isNull() const
    {
      return qgsDoubleNear( mLeft, 0.0 ) && qgsDoubleNear( mTop, 0.0 ) && qgsDoubleNear( mRight, 0.0 ) && qgsDoubleNear( mBottom, 0.0 );
    }

    double left() const { return mLeft; }

    double top() const { return mTop; }

    double right() const { return mRight; }

    double bottom() const { return mBottom; }

    void setLeft( double left ) { mLeft = left; }

    void setTop( double top ) { mTop = top; }

    void setRight( double right ) { mRight = right; }

    void setBottom( double bottom ) { mBottom = bottom; }

    inline QgsMargins &operator+=( const QgsMargins &margins );

    inline QgsMargins &operator-=( const QgsMargins &margins );

    inline QgsMargins &operator+=( double addend );

    inline QgsMargins &operator-=( double subtrahend );

    inline QgsMargins &operator*=( double factor );

    inline QgsMargins &operator/=( double divisor );

    QString toString() const;

    static QgsMargins fromString( const QString &string );

  private:
    double mLeft = 0.0;
    double mTop = 0.0;
    double mRight = 0.0;
    double mBottom = 0.0;
};


inline bool operator==( const QgsMargins &lhs, const QgsMargins &rhs )
{
  return qgsDoubleNear( lhs.left(), rhs.left() )
         && qgsDoubleNear( lhs.top(), rhs.top() )
         && qgsDoubleNear( lhs.right(), rhs.right() )
         && qgsDoubleNear( lhs.bottom(), rhs.bottom() );
}

inline bool operator!=( const QgsMargins &lhs, const QgsMargins &rhs )
{
  return !operator==( lhs, rhs );
}

inline QgsMargins operator+( const QgsMargins &m1, const QgsMargins &m2 )
{
  return QgsMargins( m1.left() + m2.left(), m1.top() + m2.top(),
                     m1.right() + m2.right(), m1.bottom() + m2.bottom() );
}

inline QgsMargins operator-( const QgsMargins &m1, const QgsMargins &m2 )
{
  return QgsMargins( m1.left() - m2.left(), m1.top() - m2.top(),
                     m1.right() - m2.right(), m1.bottom() - m2.bottom() );
}

inline QgsMargins operator+( const QgsMargins &lhs, double rhs )
{
  return QgsMargins( lhs.left() + rhs, lhs.top() + rhs,
                     lhs.right() + rhs, lhs.bottom() + rhs );
}

inline QgsMargins operator+( double lhs, const QgsMargins &rhs )
{
  return QgsMargins( rhs.left() + lhs, rhs.top() + lhs,
                     rhs.right() + lhs, rhs.bottom() + lhs );
}

inline QgsMargins operator-( const QgsMargins &lhs, double rhs )
{
  return QgsMargins( lhs.left() - rhs, lhs.top() - rhs,
                     lhs.right() - rhs, lhs.bottom() - rhs );
}

inline QgsMargins operator*( const QgsMargins &margins, double factor )
{
  return QgsMargins( margins.left() * factor, margins.top() * factor,
                     margins.right() * factor, margins.bottom() * factor );
}

inline QgsMargins operator*( double factor, const QgsMargins &margins )
{
  return QgsMargins( margins.left() * factor, margins.top() * factor,
                     margins.right() * factor, margins.bottom() * factor );
}

inline QgsMargins operator/( const QgsMargins &margins, double divisor )
{
  return QgsMargins( margins.left() / divisor, margins.top() / divisor,
                     margins.right() / divisor, margins.bottom() / divisor );
}

inline QgsMargins &QgsMargins::operator+=( const QgsMargins &margins ) SIP_SKIP
{
  return *this = *this + margins;
}

inline QgsMargins &QgsMargins::operator-=( const QgsMargins &margins ) SIP_SKIP
{
  return *this = *this - margins;
}

inline QgsMargins &QgsMargins::operator+=( double addend ) SIP_SKIP
{
  mLeft += addend;
  mTop += addend;
  mRight += addend;
  mBottom += addend;
  return *this;
}

inline QgsMargins &QgsMargins::operator-=( double subtrahend ) SIP_SKIP
{
  mLeft -= subtrahend;
  mTop -= subtrahend;
  mRight -= subtrahend;
  mBottom -= subtrahend;
  return *this;
}

inline QgsMargins &QgsMargins::operator*=( double factor ) SIP_SKIP
{
  return *this = *this * factor;
}

inline QgsMargins &QgsMargins::operator/=( double divisor ) SIP_SKIP
{
  return *this = *this / divisor;
}

inline QgsMargins operator+( const QgsMargins &margins )
{
  return margins;
}

inline QgsMargins operator-( const QgsMargins &margins )
{
  return QgsMargins( -margins.left(), -margins.top(), -margins.right(), -margins.bottom() );
}

Q_DECLARE_TYPEINFO( QgsMargins, Q_MOVABLE_TYPE );

#endif // QGSMARGINS_H