EdgeWidget.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     6-20-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// EdgeWidget.cpp


#include "EdgeWidget.h"
#include "NodeWidget.h"
#include <iostream>

using namespace gutz;
using namespace std;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// EdgeWidget
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Construct
/// from a pair of nodes
EdgeWidget::EdgeWidget( NodeWidget *start, NodeWidget *end, float rad, 
                        WidgetItem *parent)
: WidgetItem( parent ), _rad(1)
{
   if(rad != -1)
      _rad = rad;
   
   setStartNode(start);
   setEndNode(end);
}

/// just a line
EdgeWidget::EdgeWidget( const gutz::vec3f &start, const gutz::vec3f &end,  
                       float rad, WidgetItem *parent)
: WidgetItem( parent ), _rad(1), _start(start), _end(end)
{
   if(rad != -1)
      _rad = rad;
}

EdgeWidget::~EdgeWidget() 
{

}

///////////////////////////////////////////////////////////////////////////
/// Set Points
void EdgeWidget::setPoints(const gutz::vec3f &start, const gutz::vec3f &end)
{
   setStartPoint(start);
   setEndPoint(end);
}


///////////////////////////////////////////////////////////////////////////
/// area Points
WidgetItem::Point2Array EdgeWidget::getValidArea() const
{
   Point2Array p(4,Point2(0));
   /// line end points
   float x1 = _start.x;
   float x2 = _end.x;
   float y1 = _start.y;
   float y2 = _end.y;
   /// bar width
   float w = _rad;
   float dx = g_abs(x1-x2);
   float dy = g_abs(y1-y2);
   w = w*4/3+2; // approx pw*sqrt(2)
   float px = x1<x2 ? -w : w ;
   float py = y1<y2 ? -w : w ;
   if ( dx && dy && (dx > dy ? (dx*2/dy <= 2) : (dy*2/dx <= 2)) ) {
      // steep
      if ( px == py ) {
         p[0] = Point2(x1   ,y1+py);
         p[1] = Point2(x2-px,y2   );
         p[2] = Point2(x2   ,y2-py);
         p[3] = Point2(x1+px,y1   );
      } else {
         p[0] = Point2(x1+px,y1   );
         p[1] = Point2(x2   ,y2-py);
         p[2] = Point2(x2-px,y2   );
         p[3] = Point2(x1   ,y1+py);
      }
   } else if ( dx > dy ) {
      // horizontal
      p[0] = Point2(x1+px,y1+py);
      p[1] = Point2(x2-px,y2+py);
      p[2] = Point2(x2-px,y2-py);
      p[3] = Point2(x1+px,y1-py);
   } else {
      // vertical
      p[0] = Point2(x1+px,y1+py);
      p[1] = Point2(x2+px,y2-py);
      p[2] = Point2(x2-px,y2-py);
      p[3] = Point2(x1-px,y1+py);
   }

   return p;
}

///////////////////////////////////////////////////////////////////////////
/// Set Start Point
void EdgeWidget::setStartPoint(const gutz::vec3f &start)
{
   vec3f pt = getStartPoint() - start;
   if( pt.dot(pt) < .000001 ) return;

   _invalidate();
   {
      _start = _manip->getLocalPosWorld(start);
   }
   _update();

   startPointChanged(getStartPoint());
   appearanceChanged();
}

///////////////////////////////////////////////////////////////////////////
/// Set End Point
void EdgeWidget::setEndPoint(const gutz::vec3f &end)
{
   vec3f pt = getEndPoint() - end;
   if( pt.dot(pt) < .000001 ) return;

   _invalidate();
   {
      _end = _manip->getLocalPosWorld(end);
   }
   _update();

   endPointChanged(getEndPoint());
   appearanceChanged();
}

///////////////////////////////////////////////////////////////////////////
/// Set Start NODE
void EdgeWidget::setStartNode(NodeWidget *nw)
{
   if(!nw) return;
   setStartPoint(nw->getPoint());
   gutz::connect(nw->pointChanged,  this, &EdgeWidget::setStartPoint);
   gutz::connect(startPointChanged, nw,   &NodeWidget::setPoint);
}

///////////////////////////////////////////////////////////////////////////
/// Set End NODE
void EdgeWidget::setEndNode(NodeWidget *nw)
{
   if(!nw) return;
   setEndPoint(nw->getPoint());
   gutz::connect(nw->pointChanged, this, &EdgeWidget::setEndPoint);
   gutz::connect(endPointChanged,  nw,   &NodeWidget::setPoint);
}

#if 0
///////////////////////////////////////////////////////////////////////////
/// Move
bool EdgeWidget::moveDef(const gutz::MouseMoveEvent &mme)
{
   return _manip->move(mme);
   /// TODO, should be a switch! 
   if( getEvent(mme) == NO_EVENT ) return false;

   vec3f last = getStartPoint();

   vec3f del = mme.getCamera()->getPickPos(mme.getPos()) -
               mme.getCamera()->getPickPos(mme.getLast());

   setStartPoint(_start + del);
   setEndPoint(_end + del);

   return true;
}
#endif

---

Send questions, comments, and bug reports to: