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