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

// FrameWidget.h

#ifndef __FRAME_WIDGET_DOT_H
#define __FRAME_WIDGET_DOT_H

#include "PolygonWidget.h"
#include <signalGutz.h>
#include "SurfaceWidget.h"
#include "WidgetFactory.h"
#include <mathGutz.h>

/////////////////////////////////////////////////////////////////////////////
/// a Frame/Square PolygonWidget.
/// This is a composite widget, so it doesn't need any farther implementation
/// to work.  It is a widget built from other widgets, namely nodes/edges/ and
/// an optional SurfaceWidget.  To create a frame widget you need a WidgetFactory
/// that will generate the desired sub-widgets.  You have to attatch the 
/// SurfaceWidget yourself.
/////////////////////////////////////////////////////////////////////////////
class FrameWidget : public PolygonWidget {
public:

   /// supports gutz signals & slots
   HAS_SLOTS;

   /// construct from a factory
   FrameWidget(const WidgetFactory &wf, 
               WidgetItem *parent = 0,
               const gutz::vec3f &ll = gutz::vec3f(-1,-1,0),
               const gutz::vec3f &lr = gutz::vec3f(1,-1,0),
               const gutz::vec3f &ul = gutz::vec3f(-1,1,0),
               const gutz::vec3f &ur = gutz::vec3f(1,1,0));

   /// construct from a prototype of NodeWidget and EdgeWidget
   FrameWidget(const NodeWidget *const nodeProto, 
               const EdgeWidget *const edgeProto,
               WidgetItem *parent = 0,
               const gutz::vec3f &ll = gutz::vec3f(-1,-1,0),
               const gutz::vec3f &lr = gutz::vec3f(1,-1,0),
               const gutz::vec3f &ul = gutz::vec3f(-1,1,0),
               const gutz::vec3f &ur = gutz::vec3f(1,1,0));

   /// copy from existing FrameWidget
   FrameWidget(const FrameWidget &fw);

   virtual ~FrameWidget() { delSurface(); _planeConst = 0; }

   /// just copies the positions, nothing else
   FrameWidget &operator=(const FrameWidget &fw)
   {
      _nodes[LL]->setPoint(fw._nodes[LL]->getPoint());
      _nodes[LR]->setPoint(fw._nodes[LR]->getPoint());
      _nodes[UL]->setPoint(fw._nodes[UL]->getPoint());
      _nodes[UR]->setPoint(fw._nodes[UR]->getPoint());
   }

   /////////////////////////////////////////////////////
   ///@name Clones
   ///@{
   WidgetItem *clone() const
   {  return cloneFrame(); }
   
   /// notice that this ISN'T pure virtual, rather
   /// it is virtual since we only need to clone 
   /// our sub-widgets, however if you sub-class from this,
   /// you REALLY need to override this clone.
   virtual FrameWidget *cloneFrame() const
   {  return new FrameWidget(*this); }
   ///@}
   /////////////////////////////////////////////////////

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

   /////////////////////////////////////////////////////
   /// index enums for accessing the _nodes vector
   enum FRAME_NODES {
      LL,        ///< Lower Left
      LR,        ///< Lower Right
      UL,        ///< Upper Left
      UR,        ///< Upper Right
      NODE_LAST
   };
   /// index enums for accessing the _edges vector
   enum FRAME_EDGES {
      LEFT,  
      RIGHT,
      TOP,
      BOTTOM,
      EDGE_LAST
   };
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Modify the dimensions 
   ///    With some higher-level symantics, none of these
   ///   are well tested yet!
   ///@{

   /// dimensions: width & height
   virtual void setDims(float width, float height);

   /// Width
   float        getWidth() const 
   { 
      return (_nodes[LR]->getPoint() - _nodes[LL]->getPoint()).norm();
   }
   virtual void setWidth(float width);

   /// Height
   float        getHeight() const
   { 
      return (_nodes[UL]->getPoint() - _nodes[LL]->getPoint()).norm();
   }
   virtual void setHeight(float height);

   /// Center
   gutz::vec3f  getCenter() const
   {
      return   _nodes[LL]->getPoint() 
               + (_nodes[UR]->getPoint() - _nodes[LL]->getPoint()) * .5f;
   }
   virtual void setCenter(const gutz::vec3f &center);

   ///@}
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Behaviors from PolygonWidget
   ///  Notice that we dont define our own move() and mouse(), since we
   ///  don't render any geometry of our own, all events will come 
   ///  through our children.
   ///@{

   /// child mousing, right now the Frame doesn't do anything with the
   ///   mouse event, only the move event.
   virtual bool mouseChild(WidgetItem *child, const gutz::MouseEvent &me);

   /// child moving
   virtual bool moveChild(WidgetItem *child, const gutz::MouseMoveEvent &mme);

   /// draw just forwards event to children, this widget
   /// is a composite so we don't draw anything ourselves.
   virtual void drawDef(const gutz::RenderEvent &r)
   {
      PolygonWidget::drawDef(r);
      if(_surface)
         _surface->draw(r);
   }

   /// override of delChild from WidgetItem
   virtual void delChild(WidgetItem *child);

   ///@}
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Plane get
   ///@{
   /// get the gutz::plane defined by the frame
   inline
   gutz::planef  getPlane() const
   {  return gutz::planef(_nodes[LL]->getPoint(), 
                          _nodes[LR]->getPoint(),
                          _nodes[UL]->getPoint());
   }
   ///@}
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   /// THE Frame Constraint
   /// a node widget moved, not rotation! This will make sure the widget
   ///  stays a frame.  This is "what" a frame is, i.e. THE frame constraint. \n
   /// TODO: this function could be implemented as a Constraint.
   void nodeMoved(int idx, const gutz::vec3f &oldW, const gutz::vec3f &oldH);
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Surface set/get/del
   ///@{
   void             setSurface(SurfaceWidget *sw);
   SurfaceWidgetSP  getSurface() const { return _surface; }
   virtual void     delSurface();
   ///@}
   /////////////////////////////////////////////////////

   /////////////////////////////////////////////////////
   ///@name Signals 
   ///  see gutz::Signal for API details
   ///@{

   /// signal: planeChanged(gutz::planef p);
   gutz::Signal<gutz::planef>  planeChanged;

   ///@}
   /////////////////////////////////////////////////////

protected:

   void updateManip() 
   {
      _manip->setCenter( _manip->getLocalPosWorld( getCenter() ) );
      _manip->setRad( ( _nodes[LL]->getPoint() - _nodes[UR]->getPoint() ).norm() );
   }

   /// creates/recreates the frame
   void configureFrame(const NodeWidget *const nodeProto, 
                       const EdgeWidget *const edgeProto,
                       const gutz::vec3f &ll, const gutz::vec3f &lr, 
                       const gutz::vec3f &ul, const gutz::vec3f &ur);

   FrameWidget(); ///<not used

   gutz::ManipEventSP _planeConst;

   SurfaceWidgetSP   _surface;

   float             _rad; ///< for rotation, set when mouse goes down.
};

typedef gutz::SmartPtr<FrameWidget> FrameWidgetSP;


#endif

---

Send questions, comments, and bug reports to: