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

// WidgetState.h

#ifndef __WIDGET_STATE_DOT_H
#define __WIDGET_STATE_DOT_H

#include <signalGutz.h>
#include <mathGutz.h>
#include <smartptr.h>

class WidgetItem;

///////////////////////////////////////////////////////////////////////////
/// The Base interface for Widget State, this is things like colors, 
///  clipping planes, etc.  Remember at this level in the widget hierarchy
///  we don't know anything about openGL... so the specific implementations
///  of Widget States must exist elsewhere.
///////////////////////////////////////////////////////////////////////////
class WidgetState : public gutz::Counted
{
public:
   HAS_SLOTS;
   virtual ~WidgetState() {}

   virtual WidgetState* clone() = 0;

   /////////////////////////////////////////////////
   ///@name Bind/Release
   /// Bind should enable any state that is applicable, release should undo
   ///  that, back to defaults.  A Concrete Class should implement
   ///  the bindWS() and releaseWS() for the specific platform (if applicable).
   ///@{
   inline void bind()    { bindWS(); }
   inline void release() { releaseWS(); }
   ///@}
   /////////////////////////////////////////////////

protected:
   /////////////////////////////////////////////////
   /// implements bind()
   virtual void bindWS() = 0;
   /// implements release()
   virtual void releaseWS() = 0;
   /////////////////////////////////////////////////

   WidgetState() {}
   WidgetState(const WidgetState &ws) {}
   WidgetState &operator=(const WidgetState &ws) {}
   
};
typedef gutz::SmartPtr<WidgetState> WidgetStateSP;

const gutz::vec4f defColor  = gutz::vec4f(.72165f, .91373f, .62353f, 1.0f);
const gutz::vec4f defPicked = gutz::vec4f(.72165f, .62353f, .91373f, 1.0f);
const gutz::vec4f defSecond = gutz::vec4f(1.0f,.99f, .97f, 1.0f);

///////////////////////////////////////////////////////////////////////////
/// The basic Color Widget State.  Contains a primary (getColor()), 
///  secondary (getSecondary()), and picked (getPickedColor()) color.
///////////////////////////////////////////////////////////////////////////
class ColorWState : public WidgetState {
public:
   virtual ~ColorWState() {}

   ColorWState &operator=(const ColorWState &cws)
   {
      _color = cws._color;
      _pickedColor = cws._pickedColor;
      _second = cws._second;
   }

   WidgetState* clone() { return cloneColor(); }
   virtual ColorWState* cloneColor() = 0;

   /////////////////////////////////////////////////
   ///@name Colors
   ///@{
   void        setColor(const gutz::vec4f &c)        { _color = c; }
   gutz::vec4f getColor() const                      { return _color; }
   void        setPickedColor(const gutz::vec4f &pc) { _pickedColor = pc; }
   gutz::vec4f getPickedColor() const                { return _pickedColor; }
   void        setSecondary(const gutz::vec4f &sc)   { _second = sc; }
   gutz::vec4f getSecondary() const                  { return _second; }
   ///@}
   /////////////////////////////////////////////////

   /////////////////////////////////////////////////
   ///@name Set/Get Picked
   /// if _picked is true, you should use the picked color.
   /// setPicked() makes a very convenient slot ;)
   ///@{
   void setPicked(bool yes) { _picked = yes; }
   bool getPicked() const   { return _picked; }
   ///@}
   /////////////////////////////////////////////////

protected:
   /// WidgetItem is a friend so that it can create one of these
   friend class WidgetItem;

   ColorWState(const gutz::vec4f color = defColor,
               const gutz::vec4f pickedColor = defPicked,
               const gutz::vec4f second = defSecond)
               : _color(color), _pickedColor(pickedColor), _second(second),
                 _picked(false)
   {}
   ColorWState(const ColorWState &cws)
      : _color(cws._color), _pickedColor(cws._pickedColor), _second(cws._second), 
        _picked(false)
   {}

   gutz::vec4f _color;
   gutz::vec4f _pickedColor;
   gutz::vec4f _second;
   bool        _picked;

};
typedef gutz::SmartPtr<ColorWState> ColorWStateSP;


#endif

---

Send questions, comments, and bug reports to: