CanvasItems.h

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.h
///  mostly copied from QT examples

#ifndef __CANVAS_ITEMS_DOT_H
#define __CANVAS_ITEMS_DOT_H

#include <smartptr.h>
#include <qcanvas.h>
#include <vector>
#include <list>
#include <mathGutz.h>

typedef std::vector<QCanvasItem*> CanvasItemPVec;

namespace CID { //< canvas item defines
   enum PEN_BRUSH_COLOR_IDS {
      PRIMARY,
      SECONDARY,
      TERTIERY,
      PICKED,
      PRE_PICKED,
      PBC_LAST
   };
   
   const QColor PRIMARY_COLOR    = Qt::white;
   const QColor SECONDARY_COLOR  = Qt::lightGray;
   const QColor TERTIERY_COLOR   = Qt::gray;
   const QColor PICKED_COLOR     = Qt::red;
   const QColor PRE_PICKED_COLOR = Qt::darkRed;

   /// argh!! global arrays, but... you want
   /// to customize these and have them global too
   /// just too lazy to make a singleton here
   /// all of these must have the same number of
   ///  elements and at least PBC_LAST elements!!!

   extern int    NUM_PCB;  //< number of pen/brush/colors
   extern QColor COLORS[]; 
   extern QPen   PENS[];
   extern QBrush BRUSHES[];

} /// end canvas item defines


/// forward decl
class CanvasItemBase;

///////////////////////////////////////////////////////////////////////////
/// a composite item, for hierarchical grouping
///  these don't actually draw
///////////////////////////////////////////////////////////////////////////
class CompositeItem : public gutz::Counted {
public:
   CompositeItem() {}
   virtual ~CompositeItem() {}

   /// something changed...
   virtual void childUpdate(CanvasItemBase *child) = 0;
   /// delta change
   virtual void childMovedBy(CanvasItemBase *child, gutz::vec3d dv) = 0;
   /// absolute change
   virtual void childMoved(CanvasItemBase *child, gutz::vec3d last, gutz::vec3d point) = 0;

protected:
};

typedef gutz::SmartPtr<CompositeItem> CompositeItemSP;
typedef std::list<CompositeItemSP> CompositeItemSPList;

class NodeItem;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// a interface for smart canvas items
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////

class CanvasItemIF : 
   public QCanvasPolygonalItem
{
public:
   virtual ~CanvasItemIF(){}

   /// You have to override these!
   /// polygonalItem interface stuff
   virtual QPointArray areaPoints() const = 0;
   /// polygonalItem interface stuff
   virtual void drawShape(QPainter &p)    = 0;

   /// is it selected? (currently being modified)
   /// bool isSelected() declared in QCanvasItem
   virtual void setSelected(bool yes);
   /// has it been selected and modifiable as a group?
   /// bool isActive() declared in QCanvasItem
   virtual void setActive(bool yes);

   /// do you want this object to update other objects
   /// that are linked to it?
   bool  getUpdateLinks() const   { return _updateLinks; }
   void  setUpdateLinks(bool yes) {_updateLinks = yes; }

protected:
   CanvasItemIF(); //< not used
   CanvasItemIF(QCanvas *canvas, CompositeItem *comp)
      : QCanvasPolygonalItem(canvas), _comp(comp),
        _updateLinks(true)
   {}

   void updatePen();

   CompositeItem *_comp;

   bool _updateLinks;
};

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// a highlevel counted canvas item
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class CanvasItemBase : public CanvasItemIF, public gutz::Counted
{
public:

protected:
   CanvasItemBase(); //<not used
   CanvasItemBase(QCanvas *canvas, CompositeItem *comp)
      : CanvasItemIF(canvas, comp)
   {}
};

typedef gutz::SmartPtr<CanvasItemBase> CanvasItemBaseSP;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// an edge (line) composed from 2 nodes (points)
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class EdgeItem: public CanvasItemBase
{
public:
   EdgeItem( NodeItem*, NodeItem*, QCanvas *canvas, CompositeItem *comp = 0 );
   virtual ~EdgeItem() {}

   /// set start [sx,sy] and end [ex, ey] points
   void setPoints(double sx, double sy, double ex, double ey);
   void setPoints(const gutz::vec3d start, const gutz::vec3d end);

   gutz::vec3d startPoint() const {return _start;}
   gutz::vec3d endPoint()   const {return _end;}
   /// doesn't update nodes
   virtual void setStartPoint(gutz::vec3d start);
   virtual void setEndPoint(gutz::vec3d end);

   /// does update nodes
   virtual void moveBy(double dx, double dy);

   /// polygonalItem interface stuff
   virtual QPointArray areaPoints() const;

protected:
   /// polygonalItem interface stuff
   virtual void drawShape(QPainter &p);

   gutz::vec3d _start;
   gutz::vec3d _end;
   NodeItem *_startNode;
   NodeItem *_endNode;
};

typedef gutz::SmartPtr<EdgeItem> EdgeItemSP;
typedef std::vector<EdgeItemSP> EdgeItemVec;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// a Node (point) also can keep track of edges it is connected to
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class NodeItem: public CanvasItemBase
{
public:
   NodeItem( QCanvas *canvas, double x = 0, double y = 0, CompositeItem *comp = 0 );
   virtual ~NodeItem() {}

   /// set the position of this object, also updates any 
   /// linked edges
   virtual void        setPoint(double x, double y, EdgeItem *mover=0);
   virtual void        setPoint(gutz::vec3d v, EdgeItem *mover=0);
   gutz::vec3d getPoint() const { return gutz::vec3d(x(),y(),z()); }

   /// change the diameter of the node 
   void setSize(int sz) {_sz = sz;}

   QPoint center() { return boundingRect().center(); }

   /// part of QCanvasItem spec, not for general use
   /// updates edge items
   virtual void moveBy(double dx, double dy);

   /// polygonalItem interface stuff
   virtual QPointArray areaPoints() const;

   /// these are for registering edge links, called by edge 
   /// automatically, not for general use
   void addInEdge( EdgeItem *edge ) { inList.append( edge ); }
   void addOutEdge( EdgeItem *edge ) { outList.append( edge ); }

protected:
   /// polygonalItem interface stuff
   virtual void drawShape(QPainter &p);

   QPtrList<EdgeItem> inList;
   QPtrList<EdgeItem> outList;
   
   int _sz;

};

typedef gutz::SmartPtr<NodeItem> NodeItemSP;
typedef std::vector<NodeItemSP>  NodeItemVec;

///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// A Polygon that you can edit
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class PolygonEdit: public CanvasItemIF, public CompositeItem
{
public:
   PolygonEdit( QCanvas *canvas, CompositeItem *comp = 0 );
   virtual ~PolygonEdit();

   virtual void setPoints(QPointArray p);

   QPointArray areaPoints() const;

   /// TODO: as far as I can tell child update is unused!!
   virtual void childUpdate(CanvasItemBase *child){};
   /// child Moveby (relative motion)
   virtual void childMovedBy(CanvasItemBase *child, gutz::vec3d dv){};
   /// child moved (absolute modtion)
   virtual void childMoved(CanvasItemBase *child, gutz::vec3d last, gutz::vec3d point){};

   virtual void moveBy(double dx, double dy) {}
   /// this (incrmentaly) translates each node by differential vec "dv"
   virtual void moveBy(gutz::vec3d dv);

protected:
   virtual void drawShape(QPainter &p);
   void nukePoints();
   void nukeEdges();

   /// returns -1 if not an edge/node respectively
   int getEdgeIndex(CanvasItemBase *ptr);
   int getNodeIndex(CanvasItemBase *ptr);

   NodeItemVec _points;
   EdgeItemVec _edges;
};

#endif

---

Send questions, comments, and bug reports to: