SelectionManager.h

#pragma once
#include <vector>
#include <list>
#include "IRefObject.h"

namespace ParaEngine
{
    using namespace std;
    class CBaseObject;
    class CGUIBase;

    struct SelectedItem
    {
        IAttributeFields::WeakPtr_type m_pObjectRef;
        enum ObjectBaseType{
            TYPE_CBASEOBJECT,
            TYPE_CGUIBASE,
            TYPE_UNKNOWN,
        }m_nItemType;

        bool m_bSelected;

    public:
        SelectedItem() :m_bSelected(false), m_nItemType(TYPE_UNKNOWN){};
        SelectedItem(CBaseObject* pObj) :m_pObjectRef((IAttributeFields*)pObj), m_bSelected(false), m_nItemType(TYPE_CBASEOBJECT){};
        SelectedItem(CGUIBase* pObj) :m_pObjectRef((IAttributeFields*)pObj), m_bSelected(false), m_nItemType(TYPE_CGUIBASE){};

        inline IAttributeFields* GetObject(){
            return m_pObjectRef.get();
        };

        CBaseObject* GetAs3DObject(){
            return Is3DObject() ? (CBaseObject*)m_pObjectRef.get() : NULL;
        };

        CGUIBase* GetAs2DObject(){
            return (Is2DObject()) ? (CGUIBase*)m_pObjectRef.get() : NULL;
        };

        operator bool() const
        {
            return m_pObjectRef;
        }

        inline bool Is3DObject(){ return m_nItemType == TYPE_CBASEOBJECT && m_pObjectRef; };
        inline bool Is2DObject(){ return m_nItemType == TYPE_CGUIBASE && m_pObjectRef; };
    };

    class CSelectionGroup : public IAttributeFields
    {
    public:
        CSelectionGroup() : m_bSelected(false), m_nMaxItemNumber(1), m_bRemoveFromBack(false), m_bExclusiveSelect(true) {};
        virtual ~CSelectionGroup(){};

        ATTRIBUTE_DEFINE_CLASS(CSelectionGroup);

        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

    public:
        int GetItemCount() { return (int)(m_items.size()); }

        SelectedItem& GetItem(int nIndex) { return m_items[nIndex]; }

        bool IsExclusive(){ return m_bExclusiveSelect; }
    public:
        vector<SelectedItem> m_items;

        bool m_bSelected;

        int m_nMaxItemNumber;

        bool m_bRemoveFromBack;

        bool m_bExclusiveSelect;
    };

    class CSelectionManager : public IRefObject
    {
    public:
        CSelectionManager(void);
        virtual ~CSelectionManager(void);
        ATTRIBUTE_DEFINE_CLASS(CSelectionManager);

        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        static CSelectionManager* GetSingleton();
    public:
        virtual void OnRefDeleted(IRefObject* rm);

        void RemoveObject(CBaseObject* pObject);
        void RemoveObject(CGUIBase* pObject);

        int GetObjectCount(CBaseObject* pObject);

        void AddObject(CBaseObject* pObject, int nGroupID = 0);
        void AddObject(CGUIBase* pObject, int nGroupID = 0);

        bool GetObject(int nGroupID, int nItemIndex, SelectedItem* pOut);

        int GetItemNumInGroup(int nGroupID);

        void SelectGroup(int nGroupID, bool bSelect);
        void ClearGroup(int nGroupID);

        void SetMaxItemNumberInGroup(int nGroupID, int nMaxItemsNumber);

        int GetMaxItemNumberInGroup(int nGroupID);

        CSelectionGroup* GetGroup(int nGroupID);

        CSelectionGroup* CreateGroup(int nGroupID);

        int GetGroupCount(){ return (int)(m_groups.size()); }

    protected:

        void UpdateGroup(int nGroupID);

    public:
        vector< ref_ptr<CSelectionGroup> > m_groups;
    };

}