ui.hh

Go to the documentation of this file.

#ifndef __DW_UI_HH__
#define __DW_UI_HH__
 
#ifndef __INCLUDED_FROM_DW_CORE_HH__
#   error Do not include this file directly, use "core.hh" instead.
#endif
 
namespace dw {
namespace core {
 
namespace ui {
 
class Resource;
 
class Embed: public Widget
{
   friend class Resource;
 
private:
   Resource *resource;
 
protected:
   void sizeRequestImpl (Requisition *requisition);
   void getExtremesImpl (Extremes *extremes);
   void sizeAllocateImpl (Allocation *allocation);
   void enterNotifyImpl (core::EventCrossing *event);
   void leaveNotifyImpl (core::EventCrossing *event);
   bool buttonPressImpl (core::EventButton *event);
 
public:
   static int CLASS_ID;
 
   Embed(Resource *resource);
   ~Embed();
 
   void setWidth (int width);
   void setAscent (int ascent);
   void setDescent (int descent);
   void setDisplayed (bool displayed);
   void setEnabled (bool enabled);
   void draw (View *view, Rectangle *area);
   Iterator *iterator (Content::Type mask, bool atEnd);
   void setStyle (style::Style *style);
 
   inline void setUsesHints () { setFlags (USES_HINTS); }
 
   inline Resource *getResource () { return resource; }
};
 
class Resource
{
   friend class Embed;
 
public:
   class ActivateReceiver: public lout::signal::Receiver
   {
   public:
      virtual void activate (Resource *resource) = 0;
      virtual void enter (Resource *resource) = 0;
      virtual void leave (Resource *resource) = 0;
   };
   class ClickedReceiver: public lout::signal::Receiver
   {
   public:
      virtual void clicked (Resource *resource, EventButton *event) = 0;
   };
 
private:
   class ActivateEmitter: public lout::signal::Emitter
   {
   protected:
      bool emitToReceiver (lout::signal::Receiver *receiver, int signalNo,
                           int argc, Object **argv);
   public:
      inline void connectActivate (ActivateReceiver *receiver) {
         connect (receiver); }
      void emitActivate (Resource *resource);
      void emitEnter (Resource *resource);
      void emitLeave (Resource *resource);
   };
 
   class ClickedEmitter: public lout::signal::Emitter
   {
   protected:
      bool emitToReceiver (lout::signal::Receiver *receiver, int signalNo,
                           int argc, Object **argv);
   public:
      inline void connectClicked (ClickedReceiver *receiver) {
         connect (receiver); }
      void emitClicked (Resource *resource, EventButton *event);
   };
 
   Embed *embed;
   ActivateEmitter activateEmitter;
   ClickedEmitter clickedEmitter;
 
   void emitEnter ();
   void emitLeave ();
protected:
   inline void queueResize (bool extremesChanged) {
      if (embed) embed->queueResize (0, extremesChanged);
   }
 
   virtual Embed *getEmbed () { return embed; }
   virtual void setEmbed (Embed *embed);
 
   inline void emitActivate () {
      return activateEmitter.emitActivate (this); }
   inline void emitClicked (EventButton *event) {
      clickedEmitter.emitClicked (this, event); }
 
public:
   inline Resource () { embed = NULL; }
 
   virtual ~Resource ();
 
   virtual void sizeRequest (Requisition *requisition) = 0;
   virtual void getExtremes (Extremes *extremes);
   virtual void sizeAllocate (Allocation *allocation);
   virtual void setWidth (int width);
   virtual void setAscent (int ascent);
   virtual void setDescent (int descent);
   virtual void setDisplayed (bool displayed);
   virtual void draw (View *view, Rectangle *area);
   virtual Iterator *iterator (Content::Type mask, bool atEnd) = 0;
   virtual void setStyle (style::Style *style);
 
   virtual bool isEnabled () = 0;
   virtual void setEnabled (bool enabled) = 0;
 
   inline void connectActivate (ActivateReceiver *receiver) {
      activateEmitter.connectActivate (receiver); }
   inline void connectClicked (ClickedReceiver *receiver) {
      clickedEmitter.connectClicked (receiver); }
};
 
 
class ButtonResource: public Resource
{};
 
class LabelButtonResource: public ButtonResource
{
public:
   Iterator *iterator (Content::Type mask, bool atEnd);
 
   virtual const char *getLabel () = 0;
   virtual void setLabel (const char *label) = 0;
};
 
class ComplexButtonResource: public ButtonResource
{
private:
   class LayoutReceiver: public Layout::Receiver
   {
   public:
      ComplexButtonResource *resource;
 
      void canvasSizeChanged (int width, int ascent, int descent);
   };
 
   friend class LayoutReceiver;
   LayoutReceiver layoutReceiver;
 
   Widget *childWidget;
 
protected:
   Layout *layout;
   int click_x, click_y;
 
   void setEmbed (Embed *embed);
 
   virtual Platform *createPlatform () = 0;
   virtual void setLayout (Layout *layout) = 0;
 
   virtual int reliefXThickness () = 0;
   virtual int reliefYThickness () = 0;
 
   void init (Widget *widget);
 
public:
   ComplexButtonResource ();
   ~ComplexButtonResource ();
 
   void sizeRequest (Requisition *requisition);
   void getExtremes (Extremes *extremes);
   void sizeAllocate (Allocation *allocation);
   void setWidth (int width);
   void setAscent (int ascent);
   void setDescent (int descent);
   Iterator *iterator (Content::Type mask, bool atEnd);
   int getClickX () {return click_x;};
   int getClickY () {return click_y;};
};
 
class SelectionResource: public Resource
{
public:
   virtual void addItem (const char *str, bool enabled, bool selected) = 0;
   virtual void setItem (int index, bool selected) = 0;
   virtual void pushGroup (const char *name, bool enabled) = 0;
   virtual void popGroup () = 0;
 
   virtual int getNumberOfItems () = 0;
   virtual bool isSelected (int index) = 0;
};
 
class ListResource: public SelectionResource
{
public:
   enum SelectionMode {
      SELECTION_EXACTLY_ONE,
 
      SELECTION_EXACTLY_ONE_BY_USER,
 
      SELECTION_AT_MOST_ONE,
 
      SELECTION_MULTIPLE
   };
};
 
class OptionMenuResource: public SelectionResource
{
};
 
class TextResource: public Resource
{
public:
   Iterator *iterator (Content::Type mask, bool atEnd);
 
   virtual const char *getText () = 0;
   virtual void setText (const char *text) = 0;
   virtual bool isEditable () = 0;
   virtual void setEditable (bool editable) = 0;
};
 
class EntryResource: public TextResource
{
public:
   enum { UNLIMITED_SIZE = -1 };
   virtual void setMaxLength (int maxlen) = 0;
};
 
class MultiLineTextResource: public TextResource
{
};
 
 
class ToggleButtonResource: public Resource
{
public:
   virtual bool isActivated () = 0;
   virtual void setActivated (bool activated) = 0;
};
 
class CheckButtonResource: public ToggleButtonResource
{
public:
   Iterator *iterator (Content::Type mask, bool atEnd);
};
 
class RadioButtonResource: public ToggleButtonResource
{
public:
   class GroupIterator
   {
   protected:
      GroupIterator () { }
      virtual ~GroupIterator ();
 
   public:
      virtual bool hasNext () = 0;
      virtual RadioButtonResource *getNext () = 0;
      virtual void unref () = 0;
   };
 
   virtual GroupIterator *groupIterator () = 0;
 
   Iterator *iterator (Content::Type mask, bool atEnd);
};
 
 
class ResourceFactory: public lout::object::Object
{
public:
   virtual LabelButtonResource *createLabelButtonResource (const char *label)
      = 0;
   virtual ComplexButtonResource *createComplexButtonResource (Widget *widget,
                                                               bool relief)
      = 0;
   virtual ListResource *createListResource (ListResource::SelectionMode
                                             selectionMode, int rows) = 0;
   virtual OptionMenuResource *createOptionMenuResource () = 0;
   virtual EntryResource *createEntryResource (int size, bool password,
                                               const char *label,
                                               const char *placeholder) = 0;
   virtual MultiLineTextResource *createMultiLineTextResource (int cols,
                                                               int rows,
                                                  const char *placeholder) = 0;
   virtual CheckButtonResource *createCheckButtonResource (bool activated) = 0;
   virtual RadioButtonResource *createRadioButtonResource (RadioButtonResource
                                                           *groupedWith,
                                                           bool activated) = 0;
};
 
} // namespace ui
} // namespace core
} // namespace dw
 
#endif // __DW_UI_HH__