CanvasItems.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"
//-------------------------------------------------------------------------


/// CanvasItems.cpp

#include "CanvasItems.h"
#include <qpainter.h>
#include <iostream>

using namespace std;
using namespace gutz;

namespace CID {
   int     NUM_COLORS = PBC_LAST;
   QColor COLORS[] = {
      PRIMARY_COLOR,
      SECONDARY_COLOR,
      TERTIERY_COLOR,
      PICKED_COLOR,
      PRE_PICKED_COLOR
   };
   QPen   PENS[] = {
      QPen(COLORS[0]),
      QPen(COLORS[1]),
      QPen(COLORS[2]),
      QPen(COLORS[3]),
      QPen(COLORS[4])
   };
   QBrush BRUSHES[] = {
      QBrush(COLORS[0]),
      QBrush(COLORS[1]),
      QBrush(COLORS[2]),
      QBrush(COLORS[3]),
      QBrush(COLORS[4])
   };
}// end namespace CID

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// CanvasItem interface
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// setSelected
void CanvasItemIF::setSelected(bool yes)
{
   QCanvasItem::setSelected(yes);
}

///////////////////////////////////////////////////////////////////////////
/// setActive
void CanvasItemIF::setActive(bool yes)
{
   QCanvasItem::setActive(yes);
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// EdgeItem
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Construct
EdgeItem::EdgeItem( NodeItem *from, NodeItem *to, QCanvas *canvas, CompositeItem *comp )
: CanvasItemBase( canvas, comp ), _startNode(from), _endNode(to)
{
   setPen( CID::PENS[0] );
   setBrush( CID::BRUSHES[0] );
   from->addOutEdge( this );
   to->addInEdge( this );
   if(from && to)
      setPoints( int(from->x()), int(from->y()), int(to->x()), int(to->y()) );
   setZ( 127 );
}

///////////////////////////////////////////////////////////////////////////
/// set Points
void EdgeItem::setPoints(double sx, double sy, double ex, double ey)
{
   CanvasItemIF::invalidate();
   {
      _start.x = sx;
      _start.y = sy;
      _end.x   = ex;
      _end.y   = ey;
   }
   update();
}

void EdgeItem::setPoints(const gutz::vec3d start, const gutz::vec3d end)
{
   invalidate();
   {
      _start = start;
      _end = end;
   }
   update();
}


///////////////////////////////////////////////////////////////////////////
/// area Points
QPointArray EdgeItem::areaPoints() const
{
   QPointArray p(4);
   /// objects point
   int xi = int(x());
   int yi = int(y());
   /// line end points
   int x1 = int(_start.x);
   int x2 = int(_end.x);
   int y1 = int(_start.y);
   int y2 = int(_end.y);
   /// pen width
   int pw = pen().width();
   int dx = QABS(x1-x2);
   int dy = QABS(y1-y2);
   pw = pw*4/3+2; // approx pw*sqrt(2)
   int px = x1<x2 ? -pw : pw ;
   int py = y1<y2 ? -pw : pw ;
   if ( dx && dy && (dx > dy ? (dx*2/dy <= 2) : (dy*2/dx <= 2)) ) {
      // steep
      if ( px == py ) {
         p[0] = QPoint(x1+xi   ,y1+yi+py);
         p[1] = QPoint(x2+xi-px,y2+yi   );
         p[2] = QPoint(x2+xi   ,y2+yi-py);
         p[3] = QPoint(x1+xi+px,y1+yi   );
      } else {
         p[0] = QPoint(x1+xi+px,y1+yi   );
         p[1] = QPoint(x2+xi   ,y2+yi-py);
         p[2] = QPoint(x2+xi-px,y2+yi   );
         p[3] = QPoint(x1+xi   ,y1+yi+py);
      }
   } else if ( dx > dy ) {
      // horizontal
      p[0] = QPoint(x1+xi+px,y1+yi+py);
      p[1] = QPoint(x2+xi-px,y2+yi+py);
      p[2] = QPoint(x2+xi-px,y2+yi-py);
      p[3] = QPoint(x1+xi+px,y1+yi-py);
   } else {
      // vertical
      p[0] = QPoint(x1+xi+px,y1+yi+py);
      p[1] = QPoint(x2+xi+px,y2+yi-py);
      p[2] = QPoint(x2+xi-px,y2+yi-py);
      p[3] = QPoint(x1+xi-px,y1+yi+py);
   }

   return p;
}

///////////////////////////////////////////////////////////////////////////
/// draw Shape
void EdgeItem::drawShape(QPainter &p)
{
    p.drawLine((int)(x()+_start.x), (int)(y()+_start.y), 
               (int)(x()+_end.x), (int)(y()+_end.y));
}

void EdgeItem::setStartPoint(gutz::vec3d start)
{
   setPoints(start, _end);
}

void EdgeItem::setEndPoint(gutz::vec3d end)
{
   setPoints(_start, end);
}

///////////////////////////////////////////////////////////////////////////
/// Move by
void EdgeItem::moveBy(double dx, double dy)
{
   vec3d last = startPoint();
      
   invalidate();
   {
      setStartPoint(startPoint() + vec3d(dx,dy,0.0));
      setEndPoint(  endPoint() + vec3d(dx,dy,0.0));

      if(_updateLinks)
      {
         if(_startNode)
            _startNode->setPoint(startPoint(),this);
         if(_endNode)
            _endNode->setPoint(endPoint(),this);
      }

      if(_comp)
      {
         _comp->childMoved(this,last,startPoint());
      }
   }
   update();
}


///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// NodeItem
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Construct
NodeItem::NodeItem( QCanvas *canvas, double x, double y, CompositeItem *comp )
: CanvasItemBase( canvas, comp ), _sz(6)
{
   setPen( CID::PENS[0] );
   setBrush( CID::BRUSHES[0] );
   setZ( 128 );
   move(x,y);
}

///////////////////////////////////////////////////////////////////////////
/// set point
void NodeItem::setPoint(double x, double y, EdgeItem *mover)
{
   if((x == this->x()) && (y == this->y())) return;

   setPoint(vec3d(x,y,z()),mover);
}

void NodeItem::setPoint(gutz::vec3d v, EdgeItem *mover)
{
   if((v.x == this->x()) && (v.y == this->y()) && (v.z == this->z())) return;
   
   invalidate();
   {
      vec3d last(getPoint());
      ///QCanvasItem::move(v.x,v.y);
      setX(v.x); setY(v.y); setZ(v.z);

      if(_updateLinks)
      {
         QPtrListIterator<EdgeItem> it1( inList );
         EdgeItem *edge;
         while (( edge = it1.current() )) 
         {
            ++it1;
            if(edge != mover)
            {
               edge->setEndPoint( v );
            }
         }
         QPtrListIterator<EdgeItem> it2( outList );
         while (( edge = it2.current() )) 
         {
            ++it2;
            if(edge != mover)
            {
               edge->setStartPoint( v );
            }
         }
      }
      //if(_comp)
      //{
      //   _comp->childMoved(this, last, getPoint());
      //}
   }
   update();
}


///////////////////////////////////////////////////////////////////////////
/// Move by
void NodeItem::moveBy(double dx, double dy)
{
   vec3d last = getPoint();

   invalidate();
   {
      QCanvasItem::moveBy(dx,dy);

      if(_updateLinks)
      {
         QPtrListIterator<EdgeItem> it1( inList );
         EdgeItem *edge;
         while (( edge = it1.current() )) 
         {
            ++it1;
            edge->setEndPoint( getPoint() );
         }
         QPtrListIterator<EdgeItem> it2( outList );
         while (( edge = it2.current() )) 
         {
            ++it2;
            edge->setStartPoint( getPoint() );
         }
      }
      if(_comp)
         _comp->childMoved(this,last,getPoint());
   }
   update();
}

///////////////////////////////////////////////////////////////////////////
/// areaPoints
QPointArray NodeItem::areaPoints() const
{
   int pw = pen().width();
   int sz = _sz/2 + pen().width()/2 + 1;
   QPointArray b(4);
   b[0] = QPoint(int(x() - sz), int(y() - sz));
   b[1] = QPoint(int(x() + sz), int(y() - sz));
   b[2] = QPoint(int(x() + sz), int(y() + sz));
   b[3] = QPoint(int(x() - sz), int(y() + sz));

   return b;
}

///////////////////////////////////////////////////////////////////////////
/// drawShape
void NodeItem::drawShape(QPainter &p)
{
        p.drawEllipse(int(x()-_sz/2.0+0.5), int(y()-_sz/2.0+0.5), _sz, _sz);
}

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// PolygonEdit
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
/// Construct
PolygonEdit::PolygonEdit( QCanvas *canvas, CompositeItem *comp )
: CanvasItemIF(canvas, comp)
{

}

///////////////////////////////////////////////////////////////////////////
/// Destruct
PolygonEdit::~PolygonEdit()
{
   nukePoints();
   nukeEdges();
   hide();
}

///////////////////////////////////////////////////////////////////////////
/// Area points
QPointArray PolygonEdit::areaPoints() const
{
   QPointArray pa(_points.size());
   for(int i=0; i<int(_points.size()); ++i)
   {
      pa[i] = QPoint(_points[i]->x(), _points[i]->y());
      cerr << "point - area - " 
         << _points[i]->x() << " " << _points[i]->y() << endl;
   }
   return pa;
}

///////////////////////////////////////////////////////////////////////////
/// Set Points
void PolygonEdit::setPoints(QPointArray p)
{
   nukePoints();
   nukeEdges();

   /// create nodes
   for(int i=0; i<int(p.size()); ++i)
   {
      _points.push_back(NodeItemSP(new NodeItem(canvas(), p.point(i).x(), p.point(i).y(), this)));
      _points[i]->show();
   }
   /// create points
   for(int i=0; i<int(_points.size()); ++i)
   {
      _edges.push_back(EdgeItemSP(new EdgeItem(_points[i], _points[(i+1)%_points.size()], canvas(), this)));
      _edges[i]->show();
   }
}

///////////////////////////////////////////////////////////////////////////
/// Nuke Points
void PolygonEdit::nukePoints()
{
   for(int i=0; i< int(_points.size()); ++i)
   {
      _points[i] = 0;
   }
   _points = NodeItemVec();
}

///////////////////////////////////////////////////////////////////////////
/// Nuke Edges
void PolygonEdit::nukeEdges()
{
   for(int i=0; i< int(_edges.size()); ++i)
   {
      _edges[i] = 0;
   }
   _edges = EdgeItemVec(); 
}

///////////////////////////////////////////////////////////////////////////
/// Draw Shape
void PolygonEdit::drawShape(QPainter &p)
{
   
}

///////////////////////////////////////////////////////////////////////////
/// Edge index
int PolygonEdit::getEdgeIndex(CanvasItemBase *ptr)
{
   for(int i=0; i<int(_edges.size()); ++i)
   {
      if(_edges[i] == ptr) return i;
   }
   return -1;
}

///////////////////////////////////////////////////////////////////////////
/// node index
int PolygonEdit::getNodeIndex(CanvasItemBase *ptr)
{
   for(int i=0; i<int(_points.size()); ++i)
   {
      if(_points[i] == ptr) return i;
   }
   return -1;
}

///////////////////////////////////////////////////////////////////////////
/// move by
void PolygonEdit::moveBy(gutz::vec3d dv)
{
   for(int i=0; i<int(_points.size()); ++i)
   {
      _points[i]->setPoint(_points[i]->getPoint() + dv);
   }
}

---

Send questions, comments, and bug reports to: