GHOST_Rect.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "GHOST_Types.h"
 
class GHOST_Rect {
 public:
  GHOST_Rect(int32_t l = 0, int32_t t = 0, int32_t r = 0, int32_t b = 0)
      : m_l(l), m_t(t), m_r(r), m_b(b)
  {
  }
 
  virtual ~GHOST_Rect() {}
 
  virtual inline int32_t getWidth() const;
 
  virtual inline int32_t getHeight() const;
 
  virtual inline void set(int32_t l, int32_t t, int32_t r, int32_t b);
 
  virtual inline bool isEmpty() const;
 
  virtual inline bool isValid() const;
 
  virtual void inset(int32_t i);
 
  virtual inline void unionRect(const GHOST_Rect &r);
 
  virtual inline void unionPoint(int32_t x, int32_t y);
 
  virtual inline void wrapPoint(int32_t &x, int32_t &y, int32_t ofs, GHOST_TAxisFlag axis);
  virtual inline void clampPoint(int32_t &x, int32_t &y);
 
  virtual inline bool isInside(int32_t x, int32_t y) const;
 
  virtual GHOST_TVisibility getVisibility(GHOST_Rect &r) const;
 
  virtual void setCenter(int32_t cx, int32_t cy);
 
  virtual void setCenter(int32_t cx, int32_t cy, int32_t w, int32_t h);
 
  virtual bool clip(GHOST_Rect &r) const;
 
  int32_t m_l;
  int32_t m_t;
  int32_t m_r;
  int32_t m_b;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_Rect")
#endif
};
 
inline int32_t GHOST_Rect::getWidth() const
{
  return m_r - m_l;
}
 
inline int32_t GHOST_Rect::getHeight() const
{
  return m_b - m_t;
}
 
inline void GHOST_Rect::set(int32_t l, int32_t t, int32_t r, int32_t 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(int32_t x, int32_t 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(int32_t &x, int32_t &y, int32_t ofs, GHOST_TAxisFlag axis)
{
  int32_t w = getWidth();
  int32_t 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_kAxisY) {
    while (y - ofs < m_t) {
      y += h - (ofs * 2);
    }
    while (y + ofs > m_b) {
      y -= h - (ofs * 2);
    }
  }
}
 
inline void GHOST_Rect::clampPoint(int32_t &x, int32_t &y)
{
  if (x < m_l) {
    x = m_l;
  }
  else if (x > m_r) {
    x = m_r;
  }
 
  if (y < m_t) {
    y = m_t;
  }
  else if (y > m_b) {
    y = m_b;
  }
}
 
inline bool GHOST_Rect::isInside(int32_t x, int32_t y) const
{
  return (x >= m_l) && (x <= m_r) && (y >= m_t) && (y <= m_b);
}