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

/// WidgetFactory.h

#ifndef __WIDGET_FACTORY_DOT_H
#define __WIDGET_FACTORY_DOT_H

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


/// a base class for generating basic widget items. 
/// this hides the "appearance" from the behavior levels of the hierarchy, 
///  this way we can re-use widgets even if we don't have openGL or don't like
///  the way they look.
///
/// This class should be restricted to generating only "basic" widget
///  items like, nodes, edges, sliders, and cones.  
/// More complex, composite, widgets should take a factory
///  in it's constructor to generate the correct "kind" of basic widgets using
///  the gen*() functions.
///
/// This is a prototype factory, which means all widgets must implement 
///  some form of clone() function.  The WidgetItem interface requires
///  you to be able to implement 
///  \code WidgetItem *clone() const \endcode
///  However, many classes like NodeWidget and EdgeWidget define the
///  WidgetItem::clone() and declare new clone ops for that specific 
///  subclass, which get called by their implementation of WidgetItem::clone().
///  This is very usefull since we are sepparating the behavior and appearance
///  via the class hierarchy and would still like to copy the widgets.
///
/// To create a custom factory is simplest to just create a new factory or use/copy
///  an existing "const default" one, for instance 
///  here is the definition of the default GLUWidgetFactory :
/// \code
///  const WidgetFactory GLUWidgetFactory(new GLUNodeWidget(...), new GLUEdgeWidget(...));
/// \endcode
/// To customize just copy and modify:
/// \code
///  WidgetFactory myWF = GLUWidgetFactory;
///  ... /// change atributes of the widget protos to suite
/// \endcode 
/// The advantage here is that specifics about color and appearance can remain
///  transparent at the behavior level of the widget hierarchy, it also means
///  that the "style" of the widget-set being used can be easly customeized while
///  the code remains generic.  For instance, if the user wants salmon pink nodes
///  and lime green bars, this style can be created by cloning the appropriate
///  prototypes, or by using this "prototype-widget-factory" created from an
///  example salmon-pink node and lime green bars to generate composite widgets
///  such as the FrameWidget.
class WidgetFactory : public gutz::Counted {
public:
   WidgetFactory(NodeWidget *nodeProto, EdgeWidget *edgeProto)
      : _nodeProto(nodeProto), _edgeProto(edgeProto)
   {
      //TODO: could use some error checking here to insure we have a 
      // COMPLETELY and CORRECTLY configured proto factory
   }
   WidgetFactory(const WidgetFactory &wf)
      : _nodeProto(wf._nodeProto->cloneNode()),
        _edgeProto(wf._edgeProto->cloneEdge())
   {
   }
   virtual ~WidgetFactory() {}

   WidgetFactory &operator=(const WidgetFactory &wf)
   {
      _nodeProto = wf._nodeProto->cloneNode();
      _edgeProto = wf._edgeProto->cloneEdge();
   }

   ///@name NodeWidget prototypes
   ///@{
   virtual NodeWidget  *genNode() const
   {  if(_nodeProto) return _nodeProto->cloneNode(); return 0; }
   virtual NodeWidgetSP getNodeProto() 
   { return _nodeProto; }
   virtual const NodeWidget *const getNodeProto() const
   { return _nodeProto.getPtr(); }
   virtual void         setNodeProto(NodeWidget *nw)
   { _nodeProto = nw; }
   ///@}

   ///@name EdgeWidget prototypes
   ///@{
   virtual EdgeWidget   *genEdge() const
   {  if(_edgeProto) return _edgeProto->cloneEdge(); return 0; }
   virtual EdgeWidgetSP  getEdgeProto()
   { return _edgeProto; }
   virtual const EdgeWidget *const getEdgeProto() const
   { return _edgeProto.getPtr(); }
   virtual void          setEdgeProto(EdgeWidget *ew)
   { _edgeProto = ew; }
   ///@}

protected:
   /// not used
   WidgetFactory() {}

   NodeWidgetSP _nodeProto;
   EdgeWidgetSP _edgeProto;

};

typedef gutz::SmartPtr<WidgetFactory> WidgetFactorySP;


#endif

---

Send questions, comments, and bug reports to: