GHOST_Rect.h

Go to the documentation of this file.

/*
 * $Id: GHOST_Rect.h 35152 2011-02-25 11:28:33Z jesterking $
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef _H_GHOST_Rect
#define _H_GHOST_Rect

#include "GHOST_Types.h"


class GHOST_Rect {
public:

        GHOST_Rect(GHOST_TInt32 l=0, GHOST_TInt32 t=0, GHOST_TInt32 r=0, GHOST_TInt32 b=0)
                : m_l(l), m_t(t), m_r(r), m_b(b) {}

        GHOST_Rect(const GHOST_Rect& r)
                : m_l(r.m_l), m_t(r.m_t), m_r(r.m_r), m_b(r.m_b) {}
        
        virtual ~GHOST_Rect() {};

        virtual inline GHOST_TInt32 getWidth() const;

        virtual inline GHOST_TInt32 getHeight() const;

        virtual inline void set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b);

        virtual inline bool isEmpty() const;

        virtual inline bool isValid() const;

        virtual void inset(GHOST_TInt32 i);

        virtual inline void unionRect(const GHOST_Rect& r);

        virtual inline void unionPoint(GHOST_TInt32 x, GHOST_TInt32 y);

        virtual inline void wrapPoint(GHOST_TInt32 &x, GHOST_TInt32 &y, GHOST_TInt32 ofs);

        virtual inline bool isInside(GHOST_TInt32 x, GHOST_TInt32 y) const;

        virtual GHOST_TVisibility getVisibility(GHOST_Rect& r) const;

        virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy);

        virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy, GHOST_TInt32 w, GHOST_TInt32 h);

        virtual bool clip(GHOST_Rect& r) const;

        GHOST_TInt32 m_l;
        GHOST_TInt32 m_t;
        GHOST_TInt32 m_r;
        GHOST_TInt32 m_b;

#ifdef WITH_CXX_GUARDEDALLOC
public:
        void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GHOST:GHOST_Rect"); }
        void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};


inline GHOST_TInt32 GHOST_Rect::getWidth() const
{
        return m_r - m_l;
}

inline GHOST_TInt32 GHOST_Rect::getHeight() const
{
        return m_b - m_t;
}

inline void GHOST_Rect::set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b)
{
        m_l = l; m_t = t; m_r = r; m_b = b;
}

inline bool     GHOST_Rect::isEmpty() const
{
        return (getWidth() == 0) || (getHeight() == 0);
}

inline bool GHOST_Rect::isValid() const
{
        return (m_l <= m_r) && (m_t <= m_b);
}

inline void GHOST_Rect::unionRect(const GHOST_Rect& r)
{
        if (r.m_l < m_l) m_l = r.m_l;
        if (r.m_r > m_r) m_r = r.m_r;
        if (r.m_t < m_t) m_t = r.m_t;
        if (r.m_b > m_b) m_b = r.m_b;
}

inline void GHOST_Rect::unionPoint(GHOST_TInt32 x, GHOST_TInt32 y)
{
        if (x < m_l) m_l = x;
        if (x > m_r) m_r = x;
        if (y < m_t) m_t = y;
        if (y > m_b) m_b = y;
}
#include <stdio.h>
inline void GHOST_Rect::wrapPoint(GHOST_TInt32 &x, GHOST_TInt32 &y, GHOST_TInt32 ofs)
{
        GHOST_TInt32 w= getWidth();
        GHOST_TInt32 h= getHeight();

        /* highly unlikely but avoid eternal loop */
        if(w-ofs*2 <= 0 || h-ofs*2 <= 0)
                return;
        while(x-ofs < m_l)              x+= w-(ofs*2);
        while(y-ofs < m_t)              y+= h-(ofs*2);
        while(x+ofs > m_r)              x-= w-(ofs*2);
        while(y+ofs > m_b)              y-= h-(ofs*2);
}

inline bool GHOST_Rect::isInside(GHOST_TInt32 x, GHOST_TInt32 y) const
{
        return (x >= m_l) && (x <= m_r) && (y >= m_t) && (y <= m_b);
}

#endif // _H_GHOST_Rect