GHOST_Rect.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#pragma once
 
#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)
  {
  }
 
  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,
                                GHOST_TAxisFlag axis);
 
  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
  MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_Rect")
#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;
}
 
inline void GHOST_Rect::wrapPoint(GHOST_TInt32 &x,
                                  GHOST_TInt32 &y,
                                  GHOST_TInt32 ofs,
                                  GHOST_TAxisFlag axis)
{
  GHOST_TInt32 w = getWidth();
  GHOST_TInt32 h = getHeight();
 
  /* highly unlikely but avoid eternal loop */
  if (w - ofs * 2 <= 0 || h - ofs * 2 <= 0) {
    return;
  }
 
  if (axis & GHOST_kAxisX) {
    while (x - ofs < m_l)
      x += w - (ofs * 2);
    while (x + ofs > m_r)
      x -= w - (ofs * 2);
  }
  if (axis & GHOST_kGrabAxisY) {
    while (y - ofs < m_t)
      y += h - (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);
}