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

/// PolygonWidget.h

#ifndef __POLYGON_WIDGET_DOT_H
#define __POLYGON_WIDGET_DOT_H

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

/// A "Composite Widget" for nodes and lines.
///  The transform (_mat) is a temporary matrix which is non-identity only
///  during rotation operations.
class PolygonWidget : public WidgetItem 
{
public:
   PolygonWidget(WidgetItem *parent)
      : WidgetItem(parent)
   {}
   virtual ~PolygonWidget() 
   {
      for(unsigned int i=0; i<_nodes.size(); ++i) _nodes[i] = 0;
      for(unsigned int i=0; i<_edges.size(); ++i) _edges[i] = 0;
   }

   /// object changed
   virtual void setChanged()
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         _nodes[i]->setChanged();
   }

   ///@name Draw
   ///  just forwards draw event to children
   ///@{
   virtual void drawDef(const gutz::RenderEvent &r)
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         _nodes[i]->draw(r);
      for(unsigned int i=0; i<_edges.size(); ++i)
         _edges[i]->draw(r);
   }
   ///@}

   /// set/reset all points in polygon
   virtual void setPoints(const Point3Array &pts, 
                          const NodeWidget *const nodeProto,
                          const EdgeWidget *const edgeProto)
   {
      _nodes.clear();
      for(int i=0; i<pts.size(); ++i)
      {
         NodeWidget *n = nodeProto->cloneNode();
         n->setPoint(pts[i]);
         n->setParent(this);
         _nodes.push_back(n);
      }
      _edges.clear();
      for(int i=0; i<pts.size(); ++i)
      {
         EdgeWidget *e = edgeProto->cloneEdge();
         e->setStartNode(_nodes[i]);
         e->setEndNode(_nodes[(i+1)%_nodes.size()]);
         e->setParent(this);
         _edges.push_back(e);
      }
   }

   ///@name Transform Widget
   ///@{
   virtual void scale(const gutz::vec3f scale)
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         _nodes[i]->setPoint(_nodes[i]->getPoint() * scale);
   }

   virtual void translate(const gutz::vec3f trans)
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         _nodes[i]->setPoint(_nodes[i]->getPoint() + trans);
   }

   virtual void    applyXform(gutz::mat4f xf)
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         _nodes[i]->setPoint(xf.tpoint(_nodes[i]->getPoint()));
   }
   ///@}

   ///@name Node/Edge set/get
   ///   carefull, the set may have no "meaning", may not be 
   ///   appropriate for subclass behaviors.
   ///   The gets are very usefull though.
   ///@{
   int          getNodeSize() const              {return _nodes.size();}
   NodeWidgetSP getNode(int idx) const           {return _nodes[idx];}
   virtual void setNode(int idx, NodeWidgetSP n) {_nodes[idx] = n;}
   virtual void addNode(NodeWidgetSP n)          {_nodes.push_back(n);}

   int          getEdgeSize() const              {return _edges.size();}
   EdgeWidgetSP getEdge(int idx) const           {return _edges[idx];}
   virtual void setEdge(int idx, EdgeWidgetSP e) {_edges[idx] = e;}
   virtual void addEdge(EdgeWidgetSP e)          {_edges.push_back(e);}
   ///@}


protected:

   virtual void moveNode(int idx, const gutz::MouseMoveEvent &mme){}
   virtual void moveEdge(int idx, const gutz::MouseMoveEvent &mme){}

   /// returns -1 if not found
   int getNodeIdx(const WidgetItem *ptr) const
   {
      for(unsigned int i=0; i<_nodes.size(); ++i)
         if(ptr == _nodes[i]) return i;
      return -1;
   }
   int getEdgeIdx(const WidgetItem *ptr) const
   {
      for(unsigned int i=0; i<_edges.size(); ++i)
         if(ptr == _edges[i]) return i;
      return -1;
   }

   NodeWidgetVec _nodes;
   EdgeWidgetVec _edges;

};

typedef gutz::SmartPtr<PolygonWidget> PolygonWidgetSP;


#endif

---

Send questions, comments, and bug reports to: