yrect.h

説明を見る。

#ifndef DEFINE_H_YRECT
#define DEFINE_H_YRECT

#include <basic.h>
#include <bstdlib.h>
#include <tcode.h>
#include <errcode.h>
#include <btron/btron.h>
#include <btron/dp.h>
#include "ypoint.h"

class YRect : public RECT::_rect {
public:
  YRect() {}
  
  YRect(W x1, W y1, W x2, W y2) {
    setRect(x1, y1, x2, y2);
  }

  YRect(const YRect& src) {
    operator=(src);
  }

  YRect(const RECT& src) {
    operator=(src);
  }

  YRect(const PNT& p1, const PNT& p2) {
    setRect(p1, p2);
  }

  ~YRect() {}

  void setRect(W x1, W y1, W x2, W y2) {
    left = x1;
    top = y1;
    right = x2;
    bottom = y2;
  }

  void setRect(const PNT& p1, const PNT& p2) {
    setRect(p1.x, p1.y, p2.x, p2.y);
  }

  const YPoint& topLeft() const {
    return *((YPoint*)&((RECT*)this)->p.lefttop);
  }

  const YPoint& bottomRight() const {
    return *((YPoint*)&((RECT*)this)->p.rightbot);
  }


  YPoint center() const {
    return YPoint((right+left)/2, (top+bottom)/2);
  };
  
  W width() const {
    return right - left;
  }

  void shrink(W wx, W wy){
    left += wx;
    right -= wx;
    top += wy;
    bottom -= wy;
  }

  void expand(W wx, W wy){
    shrink(-wx, -wy);
  }

  W height() const { 
    return bottom - top;
  }
  
  const YRect& operator=(const RECT& src) {
    setRect(src.c.left, src.c.top, src.c.right, src.c.bottom);
    return *this;
  }
  
  const YRect& operator=(const YRect& src) {
    setRect(src.left, src.top, src.right, src.bottom);
    return *this;
  }

  // 領域を+expだけ移動する
  const YRect& operator+=(const PNT& exp) {
    top += exp.y;
    left += exp.x;
    right += exp.x;
    bottom += exp.y;
    return *this;
  }
  
  // 領域を-expだけ移動する
  const YRect& operator-=(const PNT& exp) {
    top -= exp.y;
    left -= exp.x;
    right -= exp.x;
    bottom -= exp.y;
    return *this;
  }
  
  bool operator==(const YRect& exp) const {
    return (top == exp.top && left == exp.left &&
            right == exp.right && bottom == exp.bottom);
  }
  
  bool operator==(const RECT& exp) const {
    return (top == exp.c.top && left == exp.c.left &&
            right == exp.c.right && bottom == exp.c.bottom);
  }
  
  bool operator!=(const YRect& exp) const {
    return !(operator==(exp));
  }

  bool operator!=(const RECT& exp) const {
    return !(operator==(exp));
  }
  
  operator const RECT() const {
    return *reinterpret_cast<const RECT*>(this);
  }

  operator RECT() {
    return *const_cast<RECT*>(reinterpret_cast<const RECT*>(this));
  }
  
  bool isInside(const PNT &pnt) {
    return (left <= pnt.x && pnt.x < right && top <= pnt.y
            && pnt.y < bottom);
  }
  
protected:

private:

};

#endif // DEFINE_H_YRECT

---