tahoma2d/toonz/sources/tnzext/Selector.cpp

#include "ext/Selector.h"
#include "tgl.h"
//#include "drawutil.h"
#include "tmathutil.h"

using namespace ToonzExt;

//-----------------------------------------------------------------------------

namespace {
const GLfloat s_normalColor[]      = {250.0 / 255.0, 127 / 255.0, 240 / 255.0};
const GLfloat s_highlightedColor[] = {150.0 / 255.0, 255.0 / 255.0,
                                      140.0 / 255.0};
const double s_sqrt_2      = sqrt(2.0);
const double s_radius      = 5.0;
const double s_over_size   = 10;
const double s_length      = 15;
const double s_square_size = 5;
const double s_arrow_ratio = 2.5;

void drawArrow(const TPointD &from, const TPointD &direction, double length,
               const TPointD &arrowDirection = TPointD(0.0, -1.0),
               double arrowLength            = 0.0) {
  if (length <= 0 || arrowLength < 0) return;

  if (arrowLength == 0.0) arrowLength = 0.2 * length;

  TPointD pnt(from), myDir = normalize(direction);

  TPointD myArrowDirection(arrowDirection);

  if (arrowDirection.y <= 0.0) myArrowDirection = normalize(TPointD(-0.5, 0.8));

  if (direction * TPointD(1, 0) <= 0.0)
    myArrowDirection.x = -myArrowDirection.x;

  myDir            = myDir * length;
  myArrowDirection = myArrowDirection * arrowLength;

  glBegin(GL_LINES);
  tglVertex(pnt);
  pnt += myDir;
  tglVertex(pnt);
  glEnd();
  glBegin(GL_TRIANGLES);
  TPointD up = myDir + myArrowDirection;
  tglVertex(from + up);
  // tglVertex(pnt);
  tglVertex(pnt);
  myArrowDirection.y = -myArrowDirection.y;
  TPointD down       = myDir + myArrowDirection;
  tglVertex(from + down);
  glEnd();
}
}

//-----------------------------------------------------------------------------

Selector::Selector(double stroke_length, double min_val, double max_val) {
  original_stroke_length_ = stroke_length;
  range_                  = TPointD(min_val, max_val);
  isVisible_              = false;
  pixel_size_             = 1.0;
  w_                      = 0.5;
  this->init();
}

//-----------------------------------------------------------------------------

void Selector::init() {
  strokeRef_  = 0;
  signum_     = 1.0;
  isSelected_ = NONE;
}

//-----------------------------------------------------------------------------

Selector::~Selector() {}

//-----------------------------------------------------------------------------

TPointD Selector::getUp() const {
  if (!strokeRef_) return TPointD();

  TThickPoint pnt = strokeRef_->getPoint(w_);

  TPointD p = convert(pnt), p1;

  TPointD v0, v1, v = normalize(rotate90(strokeRef_->getSpeed(w_)));

  const double delta = TConsts::epsilon;

  if (w_ - delta >= 0.0)
    v0 = rotate90(strokeRef_->getSpeed(w_ - delta));
  else
    v0 = rotate90(strokeRef_->getSpeed(0));

  if (w_ + delta <= 1.0)
    v1 = rotate90(strokeRef_->getSpeed(w_ + delta));
  else
    v1 = rotate90(strokeRef_->getSpeed(1.0));

  if (!isAlmostZero(v * v0) || !isAlmostZero(v * v1)) v = normalize(v1 + v0);

  return v;
}

//-----------------------------------------------------------------------------

void Selector::draw(Designer *designer) {
  if (!strokeRef_ || !isVisible_) return;

  pixel_size_ = designer ? sqrt(designer->getPixelSize2()) : 1.0;

  TPointD v = this->getUp(), n = normalize(rotate90(v));

  TThickPoint pnt = strokeRef_->getThickPoint(w_);

  height_ = (pnt.thick + s_over_size) * pixel_size_;

  TPointD p(pnt.x, pnt.y), up = p + v * height_, down = p - v * height_;

  glColor3fv(s_normalColor);
  glBegin(GL_LINES);
  tglVertex(down);
  tglVertex(up);
  glEnd();

  if (isSelected_ == POSITION)
    glColor3fv(s_highlightedColor);
  else
    glColor3fv(s_normalColor);

  double radius = s_radius * pixel_size_;

  if (isSelected_ == POSITION) tglDrawDisk(up + v * radius, radius);

  tglDrawCircle(up + v * radius, radius);

  if (isSelected_ == LENGTH)
    glColor3fv(s_highlightedColor);
  else
    glColor3fv(s_normalColor);

  {
    // the circle center is in
    TPointD down = -this->getUp(), center = pnt + down * (height_);
    const double length = s_square_size * 0.5 * pixel_size_;

    TPointD
        //  offset(length, 0.0),
        offset(length, length),
        bottom_left = center - offset, top_right = center + offset;

    TRectD rectangle(bottom_left, top_right);

    if (isSelected_ == LENGTH) tglFillRect(rectangle);

    tglDrawRect(rectangle);
  }
  /*
TPointD
arrowDirection(-0.5,0.8);

if( signum_ < 0.0 )
arrowDirection.x = -arrowDirection.x;
const double
length = s_length  * pixel_size_,
arrow_length = length/s_arrow_ratio;

drawArrow(down,
      TPointD(1,0),
      length,
      arrowDirection,
      arrow_length);
drawArrow(down,
      TPointD(-1,0),
      length,
      arrowDirection,
      arrow_length);
*/
  // draw stroke related information
  if (designer && this->isSelected()) designer->draw(this);

#if 0  // def  _DEBUG
  {
  TThickPoint
    pnt = strokeRef_->getThickPoint(w_);

  TPointD
      up = this->getUp(),
      down = -up;

  double
    radius = s_radius * pixel_size_;

  // the circle center is in 
  TPointD 
    center = pnt + up * ( height_ + radius);

  glColor3d(1.0,0.0,1.0);
  tglDrawCircle(center,radius+pixel_size_);

  // one pixel of tolerance
  center = pnt + down * ( height_ );

  const double
    length = s_length * pixel_size_;

  TPointD
    offset(length, 0.0),
    bottom_left = center - offset,
    top_right   = center + offset;

  TRectD
    rectangle(bottom_left,
              top_right);

  rectangle = rectangle.enlarge( 2.0* pixel_size_);

  tglDrawRect(rectangle);
  }
#endif
}

//-----------------------------------------------------------------------------

void Selector::mouseDown(const TPointD &pos) {
  click_ = curr_ = pos;
  if (!strokeRef_) return;
  stroke_length_ = original_stroke_length_;
  prev_          = curr_;
}

//-----------------------------------------------------------------------------

void Selector::mouseUp(const TPointD &pos) {
  curr_ = pos;
  if (!strokeRef_) return;
  original_stroke_length_ = stroke_length_;
  prev_                   = curr_;
}

//-----------------------------------------------------------------------------

void Selector::mouseMove(const TPointD &pos) {
  curr_ = pos;
  if (!strokeRef_) return;

  isSelected_ = this->getSelection(pos);
  prev_       = curr_;
}

//-----------------------------------------------------------------------------

void Selector::mouseDrag(const TPointD &pos) {
  curr_ = pos;
  if (!strokeRef_) return;

  double val = original_stroke_length_;

  const double stroke_length = strokeRef_->getLength();

  double max_val = std::min(stroke_length, range_.y);

  TPointD v = curr_ - prev_;

  signum_ = 1.0;

  switch (isSelected_) {
  case POSITION:
    w_ = strokeRef_->getW(pos);
    break;
  case LENGTH:
    signum_        = v * TPointD(1.0, 0.0) < 0.0 ? -1.0 : 1.0;
    val            = original_stroke_length_ + signum_ * pixel_size_ * norm(v);
    stroke_length_ = std::max(std::min(max_val, val), range_.x);
    break;
  default:
    assert(false);
  }
  prev_ = curr_;
}

//-----------------------------------------------------------------------------

void Selector::setStroke(const TStroke *ref) {
  // if(strokeRef_  &&
  //   strokeRef_ != ref )
  //  w_=strokeRef_->getParameterAtLength( strokeRef_->getLength()*0.5);
  // else
  //  w_=0.5;
  this->init();
  strokeRef_ = ref;
}

//-----------------------------------------------------------------------------

Selector::Selection Selector::getSelection(const TPointD &pos) {
  if (!strokeRef_ || !isVisible_) return NONE;

  TThickPoint pnt = strokeRef_->getThickPoint(w_);

  TPointD up = this->getUp(), down = -up;

  double radius = s_radius * pixel_size_;

  // the circle center is in
  TPointD center = pnt + up * (height_ + radius);

  // one pixel of tolerance
  if (tdistance2(center, pos) <= sq(radius + pixel_size_)) return POSITION;

  center = pnt + down * (height_);

  // const double  length = s_length * pixel_size_;
  const double length = s_square_size * 0.5 * pixel_size_;

  TPointD
      //  offset(length, 0.0),
      offset(length, length),
      bottom_left = center - offset, top_right = center + offset;

  TRectD rectangle(bottom_left, top_right);

  rectangle = rectangle.enlarge(2.0 * pixel_size_);

  if (rectangle.contains(pos)) return LENGTH;

  return NONE;
}

//-----------------------------------------------------------------------------

double Selector::getLength() const { return stroke_length_; }

//-----------------------------------------------------------------------------

void Selector::setLength(double length) {
  stroke_length_ = original_stroke_length_ = length;
}

//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------