hdicoreMenuGroup.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_MENU_GROUP__
#define __HDI_CORE_MENU_GROUP__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include <vector>
 
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace core
    {
        class MenuItem;
    
        class MenuGroup
        {
            public:
                struct Child;
            
                typedef std::vector< std::shared_ptr<Child> > ChildVector;
            
                struct Child
                {
                    std::unique_ptr<MenuGroup> group;
                    
                    std::unique_ptr<MenuItem> item;
                    
                    Child();
                    
                    Child(const Child& kid_);
                    
                    ~Child();
                    
                    Child& operator=(const Child& rhs_);
                };
        
                typedef std::unique_ptr<Child> ChildUP;
                typedef std::shared_ptr<Child> ChildSP;
                typedef std::weak_ptr<Child> ChildWP;
            
                MenuGroup();
            
                MenuGroup(const MenuGroup& m_);
                    
                MenuGroup(
                    const BuiltinMenuGroup group_,
                    const std::string& text_,
                    const bool sort_ = false,
                    const bool mergeTop_ = false,
                    const bool divBelow_ = false,
                    const bool divAbove_ = false
                );
 
                MenuGroup(
                    const MenuGroup& group_,
                    const std::string& text_,
                    const bool sort_ = false,
                    const bool mergeTop_ = false,
                    const bool divBelow_ = false,
                    const bool divAbove_ = false
                );
 
                virtual ~MenuGroup();
 
                virtual void destroy();
            
                virtual MenuGroup& operator=(const MenuGroup& rhs_);
                
                virtual bool operator==(const MenuGroup& rhs_) const;
                
                virtual bool operator!=(const MenuGroup& rhs_) const;
 
                virtual AIMenuGroup aiMenuGroup() const;
 
                virtual AIMenuItemHandle aiMenuItemHandle() const;
 
                virtual bool isEmpty() const;
                
                virtual bool isPartial() const;
                
                virtual std::unique_ptr<MenuGroup> parent() const;
                
                virtual ChildVector children() const;
 
                virtual bool enabled() const;
 
                virtual void setEnabled(const bool enabled_);
 
                virtual std::string text() const;
 
                virtual void setText(const std::string& text_);
 
                virtual bool sorted() const;
                
                virtual void setSorted(const bool sort_);
 
 
            private:
                friend MenuGroup __accessCtor(AIMenuGroup, AIMenuItemHandle);
 
                void* __data;
 
                MenuGroup(AIMenuGroup, AIMenuItemHandle);
        };
        
        typedef std::unique_ptr<MenuGroup> MenuGroupUP;
        typedef std::shared_ptr<MenuGroup> MenuGroupSP;
        typedef std::weak_ptr<MenuGroup> MenuGroupWP;
        
        extern MenuGroup __accessCtor(AIMenuGroup, AIMenuItemHandle);
    }
}
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_MENU_GROUP__