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:

    BpsMargins();

    BpsMargins(const BpsMargins& aMargins);

    BpsMargins(qreal aValue);

    BpsMargins(qreal aTopBottom, qreal aLeftRight);

    BpsMargins(qreal aTop, qreal aRight, qreal aBottom, qreal aLeft);

    bool isNull() const;

    bool isValid() const;

    qreal top() const;

    qreal right() const;

    qreal bottom() const;

    qreal left() const;

    void setTop(qreal aValue);

    void setRight(qreal aValue);

    void setBottom(qreal aValue);

    void setLeft(qreal aValue);

    qreal& rtop();

    qreal& rright();

    qreal& rbottom();

    qreal& rleft();

    operator QVariant() const;

    BpsMargins& operator*=(qreal aFactor);

    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 BpsMargins::BpsMargins()
{ 
    mTop = mRight = mBottom = mLeft = -1.0; 
} // default constructor

inline BpsMargins::BpsMargins(const BpsMargins& aMargins)
{
    mTop = aMargins.mTop;
    mRight = aMargins.mRight;
    mBottom = aMargins.mBottom;
    mLeft = aMargins.mLeft;
} // copy constructor

inline BpsMargins::BpsMargins(qreal aValue) 
{
    mTop = mRight = mBottom = mLeft = aValue;
} // convenience constructor

inline BpsMargins::BpsMargins(qreal aTopBottom, qreal aLeftRight)
{
    mTop = mBottom = aTopBottom;
    mLeft = mRight = aLeftRight;
} // convenience constructor

inline BpsMargins::BpsMargins(qreal aTop, qreal aRight, qreal aBottom, qreal aLeft)
{ 
    mTop = aTop;
    mRight = aRight;
    mBottom = aBottom;
    mLeft = aLeft;
} // convenience constructor

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