faithtools/faith/size.h

Go to the documentation of this file.

#ifndef KDE__SIZE_H
#define KDE__SIZE_H

#include <faith/tools.h>




namespace Faith
{

class FAITH_TOOLS_EXPORT Size
{
        int mW, mH;
public:
        Size(int w, int h)
                : mW(w), mH(h)
        { }
        Size()
                : mW(0), mH(0)
        { }

        inline int width() const { return mW; }
        inline int height() const { return mH; }

        inline void setWidth(int w) { mW = w; }
        inline void setHeight(int h) { mH = h; }

        inline void resize(int w, int h) { mW = w; mH = h; }
        
        bool operator ==(const Size &other) const
        {
                return mW == other.mW && mH == other.mH;
        }

        bool operator !=(const Size &other) const { return !operator==(other); }

        Faith::Size expandedTo(const Faith::Size &sz) const
        {
                return Faith::Size(MAX(sz.width(), width()), MAX(sz.height(), height()));
        }
        
        Faith::Size expandedTo(int w, int h) const
        {
                return Faith::Size(MAX(w, width()), MAX(h, height()));
        }
        
        bool isValid() const
        {
                return mW >=0 && mH >= 0;
        }
        
        bool isInvalid() const
        {
                return !isValid();
        }

        Size operator -(const Size &other) const
        {
                Size copy(*this);
                copy.mW -= other.mW;
                copy.mH -= other.mH;
                return copy;
        }
        
        Size operator+ (const Size &other) const
        {
                Size s(*this);
                s += other;
                return s;
        }
        
        Size &operator +=(const Size &other)
        {
                mW += other.mW;
                mH += other.mH;
                return *this;
        }
        
        Size &operator *=(int s)
        {
                mW *= s;
                mH *= s;
                return *this;
        }
        
        Size operator *(int s) const
        {
                Size o(*this);
                o *= s;
                return o;
        }
        
        Size &operator /=(int s)
        {
                mW /= s;
                mH /= s;
                return *this;
        }
        
        Size operator /(int s) const
        {
                Size o(*this);
                o /= s;
                return o;
        }
        
};

}

#endif

---