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)
      : l_(l), t_(t), r_(r), b_(b)
  {
  }

  virtual ~GHOST_Rect() = default;

  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 l_;
  int32_t t_;
  int32_t r_;
  int32_t b_;
 
  MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_Rect")
};
 
inline int32_t GHOST_Rect::getWidth() const
{
  return r_ - l_;
}
 
inline int32_t GHOST_Rect::getHeight() const
{
  return b_ - t_;
}
 
inline void GHOST_Rect::set(int32_t l, int32_t t, int32_t r, int32_t b)
{
  l_ = l;
  t_ = t;
  r_ = r;
  b_ = b;
}
 
inline bool GHOST_Rect::isEmpty() const
{
  return (getWidth() == 0) || (getHeight() == 0);
}
 
inline bool GHOST_Rect::isValid() const
{
  return (l_ <= r_) && (t_ <= b_);
}
 
inline void GHOST_Rect::unionRect(const GHOST_Rect &r)
{
  if (r.l_ < l_) {
    l_ = r.l_;
  }
  if (r.r_ > r_) {
    r_ = r.r_;
  }
  if (r.t_ < t_) {
    t_ = r.t_;
  }
  if (r.b_ > b_) {
    b_ = r.b_;
  }
}
 
inline void GHOST_Rect::unionPoint(int32_t x, int32_t y)
{
  if (x < l_) {
    l_ = x;
  }
  if (x > r_) {
    r_ = x;
  }
  if (y < t_) {
    t_ = y;
  }
  if (y > b_) {
    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 < l_) {
      x += w - (ofs * 2);
    }
    while (x + ofs > r_) {
      x -= w - (ofs * 2);
    }
  }
  if (axis & GHOST_kAxisY) {
    while (y - ofs < t_) {
      y += h - (ofs * 2);
    }
    while (y + ofs > b_) {
      y -= h - (ofs * 2);
    }
  }
}
 
inline void GHOST_Rect::clampPoint(int32_t &x, int32_t &y)
{
  if (x < l_) {
    x = l_;
  }
  else if (x > r_) {
    x = r_;
  }
 
  if (y < t_) {
    y = t_;
  }
  else if (y > b_) {
    y = b_;
  }
}
 
inline bool GHOST_Rect::isInside(int32_t x, int32_t y) const
{
  return (x >= l_) && (x <= r_) && (y >= t_) && (y <= b_);
}