GUIRect.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GUIRECT__H_
#define GUIRECT__H_
 
#include "GUIPoint.h"
#include "eC_Math.h"
 
 
class CGUIRect
{
public:
    CGUIRect();
 
    CGUIRect(const CGUIPoint &kLeftUpperPt, const CGUIPoint &kRightLowerPt);
 
    CGUIRect(const CGUIPoint &kOriginPt, const eC_Value& vWidth, const eC_Value& vHeight);
 
    CGUIRect(const eC_Value& vX1, const eC_Value& vY1, const eC_Value& vX2, const eC_Value& vY2);
 
    eC_Bool IsRightOf(const CGUIRect &Rect) const
    {
        return m_vX1 >= Rect.GetX2();
    }
 
    eC_Bool IsLeftOf(const CGUIRect &Rect) const
    {
        return m_vX2 <= Rect.GetX1();
    }
 
    eC_Bool IsTopOf(const CGUIRect &Rect) const
    {
        return m_vY2 <= Rect.GetY1();
    }
 
    eC_Bool IsBottomOf(const CGUIRect &Rect) const
    {
        return m_vY1 >= Rect.GetY2();
    }
 
    inline CGUIRect GetOriginRect() const
    {
        return CGUIRect(eC_FromInt(0), eC_FromInt(0), GetWidth(), GetHeight());
    }
 
    inline CGUIPoint GetCenter() const
    {
        return CGUIPoint(
            m_vX1 + eC_Div(m_vX2 - m_vX1, eC_FromInt(2)),
            m_vY1 + eC_Div(m_vY2 - m_vY1, eC_FromInt(2)));
    }
 
    inline CGUIPoint GetTopLeft() const
    {
        return CGUIPoint(m_vX1, m_vY1);
    }
 
    inline CGUIPoint GetBottomRight() const
    {
        return CGUIPoint(m_vX2, m_vY2);
    }
 
    inline eC_Value GetWidth() const
    {
        return m_vX2 - m_vX1;
    }
 
    inline eC_Value GetHeight() const
    {
        return m_vY2 - m_vY1;
    }
 
    inline void SetWidth(const eC_Value vWidth)
    {
        m_vX2 = m_vX1 + vWidth;
    }
 
    inline void SetHeight(const eC_Value vHeight)
    {
        m_vY2 = m_vY1 + vHeight;
    }
 
    inline eC_Value GetX1() const { return m_vX1; } 
    inline eC_Value GetY1() const { return m_vY1; } 
    inline eC_Value GetX2() const { return m_vX2; } 
    inline eC_Value GetY2() const { return m_vY2; } 
    inline void SetX1(const eC_Value& vX1) { m_vX1 = vX1; }
    inline void SetY1(const eC_Value& vY1) { m_vY1 = vY1; }
    inline void SetX2(const eC_Value& vX2) { m_vX2 = vX2; }
    inline void SetY2(const eC_Value& vY2) { m_vY2 = vY2; }
 
    inline eC_Bool IsComprehensive() const { return m_bComprehensive; }
 
    inline void SetComprehensive(const eC_Bool &bComprehensive)
    { 
        if (!IsNormalised() && bComprehensive)
        {
            m_bComprehensive = true;
            Normalise(); // only normalised rectangles may be comprehensive
        }
        else
        {
            m_bComprehensive = bComprehensive;
    }
    }
 
    CGUIRect(const CGUIRect &srcRect);
 
    CGUIRect& operator=(const CGUIRect& srcRect);
 
    inline eC_Bool operator==(const CGUIRect& rkRect) const
    { 
        return (m_vX1  == rkRect.GetX1()) &&
                (m_vY1  == rkRect.GetY1()) &&
                (m_vX2  == rkRect.GetX2()) &&
                (m_vY2  == rkRect.GetY2()); 
    }
 
    inline eC_Bool operator!=(const CGUIRect& rkRect) const
    {
        return !operator==(rkRect);
    }
 
    CGUIRect& Assign(const CGUIPoint &kOriginPt, const eC_Value& vWidth, const eC_Value& vHeight);
 
    CGUIRect& Assign(const eC_Value& vX1, const eC_Value& vY1, const eC_Value& vX2, const eC_Value& vY2);
 
    eC_Bool Overlaps(const CGUIRect &Rect) const;
 
    CGUIRect& Union(const CGUIRect &Rect);
 
    CGUIRect& InterSect(const CGUIRect &Rect);
 
    inline eC_Bool IsInside(const eC_Value& vX, const eC_Value& vY) const 
    {
        if (m_bComprehensive)
        {
            return ((vX >= m_vX1) && (vX < m_vX2) && (vY >= m_vY1) && (vY < m_vY2));
        }
        else
        {
            return false;
        }
    }
 
    inline eC_Bool IsInside(const CGUIPoint &kPt) const
    {
        return IsInside(kPt.m_vX, kPt.m_vY);
    }
 
    inline eC_Bool IsInside(const CGUIRect &kRect) const
    {
        return kRect.IsComprehensive() && IsInside(kRect.GetTopLeft()) && (kRect.GetY2() <= m_vY2) && (kRect.GetX2() <= m_vX2);
    }
 
    enum ExpandDirection_t
    {
        EXPAND_HORIZONTAL, 
        EXPAND_VERTICAL,   
        EXPAND_ALL         
    };
 
    inline CGUIRect& Expand(const eC_Value vDif, const ExpandDirection_t enDirection = EXPAND_ALL)
    {
        if ((enDirection == EXPAND_ALL) || (enDirection == EXPAND_HORIZONTAL))
        {
            m_vX1 = m_vX1 - vDif;
            m_vX2 = m_vX2 + vDif;
        }
 
        if ((enDirection == EXPAND_ALL) || (enDirection == EXPAND_VERTICAL))
        {
            m_vY1 = m_vY1 - vDif;
            m_vY2 = m_vY2 + vDif;
        }
        
        if ((vDif < eC_FromInt(0)) && (!IsNormalised()))
        {
            // avoid non-normalised state of "this" rectangle,
            // alternatively we could call Normalise() here but the calculated coordinates make no sense 
            // anyway -> "this" rectangle is now invalid
            m_bComprehensive = false;
        }
        return *this;
    }
    
    CGUIRect& Move(const CGUIPoint &kOffsetPt);
 
    CGUIRect& Move(const eC_Value vDeltaX, const eC_Value vDeltaY);
 
    CGUIRect& MoveTo(const eC_Value vAbsX, const eC_Value vAbsY);
 
    inline CGUIRect& Interpolate(const CGUIRect& kTargetRect, const eC_Value vInterpolationFactor)
    {
        m_vX1 = m_vX1 + eC_Mul(vInterpolationFactor, (kTargetRect.GetX1() - m_vX1));
        m_vY1 = m_vY1 + eC_Mul(vInterpolationFactor, (kTargetRect.GetY1() - m_vY1));
        m_vX2 = m_vX2 + eC_Mul(vInterpolationFactor, (kTargetRect.GetX2() - m_vX2));
        m_vY2 = m_vY2 + eC_Mul(vInterpolationFactor, (kTargetRect.GetY2() - m_vY2));
        if (vInterpolationFactor < eC_FromInt(0) && !IsNormalised())
        {
            // avoid non-normalised state of "this" rectangle,
            // alternatively we could call Normalise() here but the calculated coordinates make no sense 
            // anyway -> "this" rectangle is now invalid
            m_bComprehensive = false;
        }
        return *this;
    }
 
    void Normalise();
 
#ifdef GUILIANI_STREAM_GUI 
    void ReadFromStream();
#endif 
 
#ifdef GUILIANI_WRITE_GUI 
    void WriteToStream();
#endif
 
private:
    inline eC_Bool IsNormalised() const
    {
        //@todo: is a rectangle with width or height of 0 normalized???
        return !((m_vX1 >= m_vX2) || (m_vY1 >= m_vY2));
    }
 
    // Member variables
    eC_Bool m_bComprehensive; 
    eC_Value m_vX1, m_vY1, m_vX2, m_vY2; 
};
#endif