Stroke.h

説明を見る。

#ifndef STROKE_H
#define STROKE_H

#include <basic.h>
#include <vector>
#include <btron/dp.h>
#include <tad.h>
#include <btron/taddata.h>
#include <limits.h>


class AbstractStroke {

 protected:

  std::vector<PNT> poly;

  static const int sz_header = 1;

  int y_lbound; 
  int y_ubound; 

  bool sel; 

  AbstractStroke()
    : y_lbound(INT_MAX), y_ubound(INT_MIN), sel(false)
  {
    PNT p;
    reinterpret_cast<POLY*>(&p)->round = 0;
    reinterpret_cast<POLY*>(&p)->size  = 0;    
    poly.push_back(p);
  }

 public:


  virtual void clear() = 0;


  const POLY* getPoly() const {
    return reinterpret_cast<const POLY*>(&(poly[0]));
  }


  PNT getPoint(int index) const {
    return poly.at(index + sz_header);
  }


  int getSize() const {
    return poly.size() - sz_header;
  }


  int getLowerBound() const {
    return y_lbound;
  }


  int getUpperBound() const {
    return y_ubound;
  }


  void addPoint(const PNT& p);


  void moveOffset(int dh, int dv);


  bool hasIntersection(int lb, int ub) const {
    return (getSize() > 0 &&
            ((y_lbound < ub && y_lbound > lb)
             || (y_ubound < ub && y_ubound > lb)));
  }

};



class DrawingStroke : public AbstractStroke {

  static int lwidth; 
  static LATTR lattr; 
  static PAT pat; 
  static PAT pat_sel; 
  static DCM dcm; 

 public:

  DrawingStroke() : AbstractStroke() {}


  DrawingStroke(const TF_SPLINE *p) : AbstractStroke() {
    for (int i = 0; i < p->np; i++){
      addPoint(p->pt[i]);
    }
  }


  W draw(W gid, int lb, int ub) const;


  W drawSelection(W gid) const {
    return gdra_pln(gid, (POLY*)&(poly[0]), lattr, &pat_sel, dcm);
  }


  W drawLatest(W gid) const {
    int sz = getSize();
    if (sz >= 2){
      return gdra_lin(gid, getPoint(sz-2), getPoint(sz-1), lattr, &pat, dcm);
    }
    return 0;
  }

  virtual void clear();


  void select(bool f) {
    sel = f;
  }


  bool isSelected() const {
    return sel;
  }

};



class SelectionStroke : public AbstractStroke {

  static int lwidth; 
  static LATTR lattr; 
  static PAT pat_line; 
  static PAT pat_fill; 
  static DCM dcm_line; 
  static DCM dcm_fill; 

  mutable bool sel_finished;

 public:

  SelectionStroke() : AbstractStroke(), sel_finished(false) {}


  void finishSelection() const {
    sel_finished = true;
  }


  bool isSelectionFinished() const {
    return sel_finished;
  }


  W draw(W gid, int lb, int ub) const;


  W drawLatest(W gid) const;

  virtual void clear();


  bool contain(const PNT& p) const;


  bool contain(DrawingStroke& stroke) const;

};

#endif // STROKE_H

---