bpsmargins.h

Go to the documentation of this file.

 
#ifndef BPSMARGINS_H
#define BPSMARGINS_H
 
#include "bpscore_global.h"
#include <QMetaType>
#include <QVariant>
 
class BPSCORE_EXPORT BpsMargins
{
public:
    static int metaType();
 
    BpsMargins();
 
    BpsMargins(const BpsMargins& aMargins);
 
    BpsMargins(qreal aValue);
 
    BpsMargins(qreal aTopBottom, qreal aLeftRight);
 
    BpsMargins(qreal aTop, qreal aRight, qreal aBottom, qreal aLeft);
 
    QString toString() const;
 
    inline bool isNull() const;
 
    inline bool isValid() const;
 
    inline qreal top() const;
 
    inline qreal right() const;
 
    inline qreal bottom() const;
 
    inline qreal left() const;
 
    inline void setTop(qreal aValue);
 
    inline void setRight(qreal aValue);
 
    inline void setBottom(qreal aValue);
 
    inline void setLeft(qreal aValue);
 
    inline qreal& rtop();
 
    inline qreal& rright();
 
    inline qreal& rbottom();
 
    inline qreal& rleft();
 
    inline operator QVariant() const;
 
    inline BpsMargins& operator*=(qreal aFactor);
 
    inline BpsMargins& operator/=(qreal aDivisor);
 
    friend inline bool operator==(const BpsMargins& aFirst, const BpsMargins& aSecond);
    friend inline bool operator!=(const BpsMargins& aFirst, const BpsMargins& aSecond);
    friend inline const BpsMargins operator*(qreal aFactor, const BpsMargins& aMargins);
    friend inline const BpsMargins operator*(const BpsMargins& aMargins, qreal aFactor);
    friend inline const BpsMargins operator/(const BpsMargins& aMargins, qreal aDivisor);
 
private:
    qreal mTop, mRight, mBottom, mLeft;
};
 
Q_DECLARE_METATYPE(BpsMargins)
Q_DECLARE_TYPEINFO(BpsMargins, Q_MOVABLE_TYPE);
 
/************************************************************************/
/* S T R E A M   F U N C T I O N S                                      */
/************************************************************************/
 
BPSCORE_EXPORT QDataStream& operator<<(QDataStream& aStream, const BpsMargins& aMargins);
 
BPSCORE_EXPORT QDataStream& operator>>(QDataStream& aStream, BpsMargins& aMargins);
 
BPSCORE_EXPORT QDebug operator<<(QDebug aDebug, const BpsMargins& aMargins);
 
/************************************************************************/
/* M E M B E R   I N L I N E S                                          */
/************************************************************************/
 
inline bool BpsMargins::isNull() const
{
    return qIsNull(mTop) && qIsNull(mRight) && qIsNull(mBottom) && qIsNull(mLeft);
} // isNull
 
inline bool BpsMargins::isValid() const
{
    return mTop>=0.0 && mRight>=0.0 && mBottom>=0.0 && mLeft>=0.0;
} // isValid
 
inline qreal BpsMargins::top() const { return mTop; }
inline qreal BpsMargins::right() const { return mRight; }
inline qreal BpsMargins::bottom() const { return mBottom; }
inline qreal BpsMargins::left() const { return mLeft; }
 
inline void BpsMargins::setTop(qreal aValue) { mTop = aValue; }
inline void BpsMargins::setRight(qreal aValue) { mRight = aValue; }
inline void BpsMargins::setBottom(qreal aValue) { mBottom = aValue; }
inline void BpsMargins::setLeft(qreal aValue) { mLeft = aValue; }
 
inline qreal& BpsMargins::rtop() { return mTop; }
inline qreal& BpsMargins::rright() { return mRight; }
inline qreal& BpsMargins::rbottom() { return mBottom; }
inline qreal& BpsMargins::rleft() { return mLeft; }
 
inline BpsMargins::operator QVariant() const
{
    return QVariant::fromValue(*this);
} // operator QVariant
 
inline BpsMargins& BpsMargins::operator*=(qreal aFactor)
{
    mTop *= aFactor;
    mRight *= aFactor;
    mBottom *= aFactor;
    mLeft *= aFactor;
    return *this;
} // operator*=
 
inline BpsMargins& BpsMargins::operator/=(qreal aDivisor)
{
    Q_ASSERT(!qIsNull(aDivisor));
    mTop /= aDivisor;
    mRight /= aDivisor;
    mBottom /= aDivisor;
    mLeft /= aDivisor;
    return *this;
} // operator/=
 
 
/************************************************************************/
/* F R I E N D   I N L I N E S                                          */
/************************************************************************/
 
inline bool operator==(const BpsMargins& aFirst, const BpsMargins& aSecond)
{
    return
        qFuzzyCompare(aFirst.mTop, aSecond.mTop) &&
        qFuzzyCompare(aFirst.mRight, aSecond.mRight) &&
        qFuzzyCompare(aFirst.mBottom, aSecond.mBottom) &&
        qFuzzyCompare(aFirst.mLeft, aSecond.mLeft);
} // operator==
 
inline bool operator!=(const BpsMargins& aFirst, const BpsMargins& aSecond)
{
    return
        !qFuzzyCompare(aFirst.mTop, aSecond.mTop) ||
        !qFuzzyCompare(aFirst.mRight, aSecond.mRight) ||
        !qFuzzyCompare(aFirst.mBottom, aSecond.mBottom) ||
        !qFuzzyCompare(aFirst.mLeft, aSecond.mLeft);
} // operator==
 
inline const BpsMargins operator*(const BpsMargins& aMargins, qreal aFactor)
{
    return
        BpsMargins(
            aMargins.mTop * aFactor,
            aMargins.mRight * aFactor,
            aMargins.mBottom * aFactor,
            aMargins.mLeft * aFactor
        );
} // operator*
 
inline const BpsMargins operator*(qreal aFactor, const BpsMargins& aMargins)
{
    return
        BpsMargins(
            aMargins.mTop * aFactor,
            aMargins.mRight * aFactor,
            aMargins.mBottom * aFactor,
            aMargins.mLeft * aFactor
        );
} // operator*
 
inline const BpsMargins operator/(const BpsMargins &aMargins, qreal aDivisor)
{
    Q_ASSERT(!qIsNull(aDivisor));
    return
        BpsMargins(
            aMargins.mTop / aDivisor,
            aMargins.mRight / aDivisor,
            aMargins.mBottom / aDivisor,
            aMargins.mLeft / aDivisor
        );
} // operator/
 
#endif // BPSMARGINS_H