forked from bartvdbraak/blender
232 lines
6.5 KiB
C++
232 lines
6.5 KiB
C++
/**
|
|
* $Id$
|
|
* ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 *****
|
|
*/
|
|
/**
|
|
* @file GHOST_Rect.h
|
|
* Declaration of GHOST_Rect rectangle class.
|
|
*/
|
|
|
|
#ifndef _H_GHOST_Rect
|
|
#define _H_GHOST_Rect
|
|
|
|
#include "GHOST_Types.h"
|
|
|
|
|
|
/**
|
|
* Implements rectangle functionality.
|
|
* The four extreme coordinates are stored as left, top, right and bottom.
|
|
* To be valid, a rectangle should have a left coordinate smaller than or equal to right.
|
|
* To be valid, a rectangle should have a top coordinate smaller than or equal to bottom.
|
|
* @author Maarten Gribnau
|
|
* @date May 10, 2001
|
|
*/
|
|
|
|
class GHOST_Rect {
|
|
public:
|
|
|
|
/**
|
|
* Constructs a rectangle with the given values.
|
|
* @param l requested left coordinate of the rectangle
|
|
* @param t requested top coordinate of the rectangle
|
|
* @param r requested right coordinate of the rectangle
|
|
* @param b requested bottom coordinate of the rectangle
|
|
*/
|
|
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) {}
|
|
|
|
/**
|
|
* Copy constructor.
|
|
* @param r rectangle to copy
|
|
*/
|
|
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) {}
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
virtual ~GHOST_Rect() {};
|
|
|
|
/**
|
|
* Access to rectangle width.
|
|
* @return width of the rectangle
|
|
*/
|
|
virtual inline GHOST_TInt32 getWidth() const;
|
|
|
|
/**
|
|
* Access to rectangle height.
|
|
* @return height of the rectangle
|
|
*/
|
|
virtual inline GHOST_TInt32 getHeight() const;
|
|
|
|
/**
|
|
* Sets all members of the rectangle.
|
|
* @param l requested left coordinate of the rectangle
|
|
* @param t requested top coordinate of the rectangle
|
|
* @param r requested right coordinate of the rectangle
|
|
* @param b requested bottom coordinate of the rectangle
|
|
*/
|
|
virtual inline void set(GHOST_TInt32 l, GHOST_TInt32 t, GHOST_TInt32 r, GHOST_TInt32 b);
|
|
|
|
/**
|
|
* Returns whether this rectangle is empty.
|
|
* Empty rectangles are rectangles that have width==0 and/or height==0.
|
|
* @return boolean value (true==empty rectangle)
|
|
*/
|
|
virtual inline bool isEmpty() const;
|
|
|
|
/**
|
|
* Returns whether this rectangle is valid.
|
|
* Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
|
|
* @return boolean value (true==valid rectangle)
|
|
*/
|
|
virtual inline bool isValid() const;
|
|
|
|
/**
|
|
* Grows (or shrinks the rectangle).
|
|
* The method avoids negative insets making the rectangle invalid
|
|
* @param i The amount of offset given to each extreme (negative values shrink the rectangle).
|
|
*/
|
|
virtual void inset(GHOST_TInt32 i);
|
|
|
|
/**
|
|
* Does a union of the rectangle given and this rectangle.
|
|
* The result is stored in this rectangle.
|
|
* @param r The rectangle that is input for the union operation.
|
|
*/
|
|
virtual inline void unionRect(const GHOST_Rect& r);
|
|
|
|
/**
|
|
* Grows the rectangle to included a point.
|
|
* @param x The x-coordinate of the point.
|
|
* @param y The y-coordinate of the point.
|
|
*/
|
|
virtual inline void unionPoint(GHOST_TInt32 x, GHOST_TInt32 y);
|
|
|
|
/**
|
|
* Returns whether the point is inside this rectangle.
|
|
* Point on the boundary is considered inside.
|
|
* @param x x-coordinate of point to test.
|
|
* @param y y-coordinate of point to test.
|
|
* @return boolean value (true if point is inside).
|
|
*/
|
|
virtual inline bool isInside(GHOST_TInt32 x, GHOST_TInt32 y) const;
|
|
|
|
/**
|
|
* Returns whether the rectangle is inside this rectangle.
|
|
* @param r rectangle to test.
|
|
* @return visibility (not, partially or fully visible).
|
|
*/
|
|
virtual GHOST_TVisibility getVisibility(GHOST_Rect& r) const;
|
|
|
|
/**
|
|
* Sets rectangle members.
|
|
* Sets rectangle members such that it is centered at the given location.
|
|
* @param cx requested center x-coordinate of the rectangle
|
|
* @param cy requested center y-coordinate of the rectangle
|
|
*/
|
|
virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy);
|
|
|
|
/**
|
|
* Sets rectangle members.
|
|
* Sets rectangle members such that it is centered at the given location,
|
|
* with the width requested.
|
|
* @param cx requested center x-coordinate of the rectangle
|
|
* @param cy requested center y-coordinate of the rectangle
|
|
* @param w requested width of the rectangle
|
|
* @param h requested height of the rectangle
|
|
*/
|
|
virtual void setCenter(GHOST_TInt32 cx, GHOST_TInt32 cy, GHOST_TInt32 w, GHOST_TInt32 h);
|
|
|
|
/**
|
|
* Clips a rectangle.
|
|
* Updates the rectangle given such that it will fit within this one.
|
|
* This can result in an empty rectangle.
|
|
* @param r the rectangle to clip
|
|
* @return whether clipping has occurred
|
|
*/
|
|
virtual bool clip(GHOST_Rect& r) const;
|
|
|
|
/** Left coordinate of the rectangle */
|
|
GHOST_TInt32 m_l;
|
|
/** Top coordinate of the rectangle */
|
|
GHOST_TInt32 m_t;
|
|
/** Right coordinate of the rectangle */
|
|
GHOST_TInt32 m_r;
|
|
/** Bottom coordinate of the rectangle */
|
|
GHOST_TInt32 m_b;
|
|
};
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
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
|
|
|