xrb_containerwidget.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_containerwidget.hpp by Victor Dods, created 2006/08/16
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_CONTAINERWIDGET_HPP_)
#define _XRB_CONTAINERWIDGET_HPP_

#include "xrb.hpp"

#include <list>
#include <vector>

#include "xrb_widget.hpp"

namespace Xrb
{

// NOTE: subclasses should not set m_accepts_mouseover to true
class ContainerWidget : public Widget
{
public:

    // used to prevent resizing child widgets e.g. while creating
    // the contents of a complicated Layout.
    class ChildResizeBlocker
    {
    public:

        ChildResizeBlocker (ContainerWidget *container_widget)
        {
            ASSERT1(container_widget != NULL);
            m_container_widget = container_widget;
            m_container_widget->IncrementResizeBlockerCount();
        }
        ~ChildResizeBlocker ()
        {
            ASSERT1(m_container_widget != NULL);
            m_container_widget->DecrementResizeBlockerCount();
            m_container_widget = NULL;
        }

    private:

        void *operator new (size_t) throw() { ASSERT0(false && "this class should always be instantiated on the stack"); return NULL; }
        void *operator new[] (size_t) throw() { ASSERT0(false && "this class should always be instantiated on the stack"); return NULL; }
        void operator delete (void *) throw() { ASSERT0(false && "this class should always be instantiated on the stack"); }
        void operator delete[] (void *) throw() { ASSERT0(false && "this class should always be instantiated on the stack"); }

        ContainerWidget *m_container_widget;
    }; // end of class ContainerWidget::ChildResizeBlocker

    // ///////////////////////////////////////////////////////////////////////
    // constructor and destructor
    // ///////////////////////////////////////////////////////////////////////

    ContainerWidget (ContainerWidget *parent, std::string const &name = "ContainerWidget");
    virtual ~ContainerWidget ();

    // ///////////////////////////////////////////////////////////////////////
    // accessors
    // ///////////////////////////////////////////////////////////////////////

    inline Widget *Focus () const { return m_focus; }
    inline Widget *MouseoverFocus () const { return m_mouseover_focus; }
    inline bool FocusHasMouseGrab () const { return m_focus_has_mouse_grab; }
    inline Widget *GetMainWidget () const { return m_main_widget; }
    virtual Bool2 const &MinSizeEnabled () const
    {
        return m_main_widget ?
               m_main_widget->MinSizeEnabled() :
               m_size_properties.m_min_size_enabled;
    }
    virtual ScreenCoordVector2 const &MinSize () const
    {
        return m_main_widget ?
               m_main_widget->MinSize() :
               m_size_properties.m_min_size;
    }
    virtual Bool2 const &MaxSizeEnabled () const
    {
        return m_main_widget ?
               m_main_widget->MaxSizeEnabled() :
               m_size_properties.m_max_size_enabled;
    }
    virtual ScreenCoordVector2 const &MaxSize () const
    {
        return m_main_widget ?
               m_main_widget->MaxSize() :
               m_size_properties.m_max_size;
    }
    virtual ScreenCoordVector2 AdjustedSize (ScreenCoordVector2 const &size) const;

    // ///////////////////////////////////////////////////////////////////////
    // modifiers
    // ///////////////////////////////////////////////////////////////////////

    virtual void SetSizePropertyEnabled (
        SizeProperties::Property property,
        Uint32 component,
        bool value,
        bool defer_parent_update = false);
    virtual void SetSizePropertyEnabled (
        SizeProperties::Property property,
        Bool2 const &value,
        bool defer_parent_update = false);
    virtual void SetSizeProperty (
        SizeProperties::Property property,
        Uint32 component,
        ScreenCoord value,
        bool defer_parent_update = false);
    virtual void SetSizeProperty (
        SizeProperties::Property property,
        ScreenCoordVector2 const &value,
        bool defer_parent_update = false);

    virtual void SetMainWidget (Widget *main_widget);

    // ///////////////////////////////////////////////////////////////////////
    // procedures
    // ///////////////////////////////////////////////////////////////////////

    virtual void Draw (RenderContext const &render_context) const;
    virtual void MoveBy (ScreenCoordVector2 const &delta);
    virtual ScreenCoordVector2 Resize (ScreenCoordVector2 const &size);
    virtual void AttachChild (Widget *child);
    virtual void DetachChild (Widget *child);
    virtual void MoveChildDown (Widget *child);
    virtual void MoveChildUp (Widget *child);
    virtual void MoveChildToBottom (Widget *child);
    virtual void MoveChildToTop (Widget *child);
    void DeleteAllChildren ();

protected:

    virtual Uint32 WidgetSkinHandlerChildCount () const;
    virtual WidgetSkinHandler *WidgetSkinHandlerChild (Uint32 index);

    // TODO document
    // these are interfaces for container widgets
    virtual Bool2 ContentsMinSizeEnabled () const;
    virtual ScreenCoordVector2 ContentsMinSize () const;
    virtual Bool2 ContentsMaxSizeEnabled () const;
    virtual ScreenCoordVector2 ContentsMaxSize () const;

    inline Uint32 ChildResizeBlockerCount () const { return m_child_resize_blocker_count; }
    inline bool ChildResizeWasBlocked () const { return m_child_resize_was_blocked; }

    inline void IndicateChildResizeWasBlocked () { m_child_resize_was_blocked = true; }

    virtual void HandleFrame ();
    virtual bool ProcessDeleteChildWidgetEvent (EventDeleteChildWidget const *e);

    virtual void AddModalWidget (Widget *modal_widget);
    virtual void RemoveModalWidget (Widget *modal_widget);
    virtual void CalculateMinAndMaxSizePropertiesFromContents ();
    virtual void ChildSizePropertiesChanged (Widget *child);
    virtual void ChildStackPriorityChanged (
        Widget *child,
        StackPriority previous_stack_priority);

    typedef std::vector<Widget *> WidgetVector;

    WidgetVector m_child_vector;
    SizeProperties m_preferred_size_properties;
    bool m_children_get_input_events_first;

private:

    typedef std::list<Widget *> WidgetList;

    WidgetVector::iterator FindChildWidget (Widget const *child);
    virtual bool InternalProcessKeyEvent (EventKey const *e);
    virtual bool InternalProcessMouseEvent (EventMouse const *e);
    virtual bool InternalProcessJoyEvent (EventJoy const *e);
    virtual bool InternalProcessFocusEvent (EventFocus const *e);
    virtual bool InternalProcessMouseoverEvent (EventMouseover const *e);
    bool SendMouseEventToChild (EventMouse const *e);

    void IncrementResizeBlockerCount ();
    void DecrementResizeBlockerCount ();

    Widget *m_focus;
    Widget *m_mouseover_focus;
    bool m_focus_has_mouse_grab;
    WidgetList m_modal_widget_stack;
    Widget *m_main_widget;
    Uint32 m_child_resize_blocker_count;
    bool m_child_resize_was_blocked;

    // kludgey (as are all friend statements), but this is the simplest way
    friend class ChildResizeBlocker;
    friend class Screen;
    friend class Widget;
}; // end of class ContainerWidget

} // end of namespace Xrb

#endif // !defined(_XRB_CONTAINERWIDGET_HPP_)

---