Selector.h

// Copyright (C), UNIGINE. All rights reserved.
#pragma once


#include <editor/Constants.h>
#include <editor/EditorGlobal.h>

#include <UnigineNode.h>
#include <UnigineVector.h>
#include <UnigineHashSet.h>


namespace Unigine
{
class UGUID;
}

namespace Editor {
class IndexList;

namespace Internal {
class SelectorGUIDsPrivate;
class SelectorNodesPrivate;
class IndexListPrivate;
}}


namespace Editor
{

enum SelectorType
{
    SELECTOR_NODES = 0,
    SELECTOR_MATERIALS,
    SELECTOR_PROPERTIES,
    SELECTOR_RUNTIMES,
    SELECTOR_USER = 0x0100
};

// Selector.
class EDITOR_API Selector
{
public:
    Selector();
    virtual ~Selector();
    virtual int type() const = 0;
    virtual bool equal(const Selector *selector) const = 0;
    virtual Selector *clone () const = 0;
};

// SelectorGUIDs.
// TODO(SiN_Bizkit: 04/11/19): Choose a clear name.
class EDITOR_API SelectorGUIDs : public Selector
{
public:
    static SelectorGUIDs *createRuntimesSelector  (Unigine::Vector<Unigine::UGUID> guids);
    static SelectorGUIDs *createMaterialsSelector (Unigine::Vector<Unigine::UGUID> guids);
    static SelectorGUIDs *createPropertiesSelector(Unigine::Vector<Unigine::UGUID> guids);

    SelectorGUIDs(int type, Unigine::Vector<Unigine::UGUID> guids);
    ~SelectorGUIDs() override;

    int type() const override;
    bool equal(const Selector *selector) const override;
    SelectorGUIDs *clone() const override;

    Unigine::Vector<Unigine::UGUID> guids() const;

    bool contains(const Unigine::UGUID &guid) const;

    bool empty() const;

private:
    ::Editor::Internal::SelectorGUIDsPrivate *d;
};

// SelectorNodes.
class EDITOR_API SelectorNodes : public Selector
{
public:
    static SelectorNodes *createObjectsSelector(const Unigine::Vector<Unigine::NodePtr> &nodes);

    enum SubType
    {
        INDEXED = 0,
        USER    = 0x0100
    };

    class EDITOR_API SubItemList
    {
    public:
        SubItemList();
        virtual ~SubItemList();

        virtual int type() const = 0;
        virtual bool equal(SubItemList *other) const = 0;
        virtual void merge(SubItemList *other) = 0;
        virtual void exclude(Constants::SubObjectType sub) = 0;

        virtual SubItemList *clone() const = 0;
    };

    SelectorNodes();
    explicit SelectorNodes(const Unigine::Vector<Unigine::NodePtr> &nodes);
    ~SelectorNodes() override;

    int type() const override;
    bool equal(const Selector *selector) const override;
    SelectorNodes *clone() const  override;

    Unigine::Vector<Unigine::NodePtr> getNodes() const;
    int size() const;
    bool empty() const;

    void extend(const Unigine::NodePtr &node);
    void extend(const Unigine::Vector<Unigine::NodePtr> &nodes);
    void extend(const Unigine::NodePtr &node, SubItemList *subs);

    void exclude(const Unigine::NodePtr &node);
    void exclude(const Unigine::Vector<Unigine::NodePtr> &nodes);
    void exclude(Constants::SubObjectType stype);

    bool contains(const Unigine::NodePtr &node) const;

    SubItemList *getSubItemList(int node_id) const;
    SubItemList *getSubItemList(const Unigine::NodePtr &node) const;
    IndexList *getIndexList(int node_id) const;
    IndexList *getIndexList(const Unigine::NodePtr &node) const;

    Unigine::HashSet<int> getIntersectedIndexes(Constants::SubObjectType stype) const;

    void resetCache();

    // `expand` flag is a shitty solution to pass a param to the `WorldModel.`. Refactor this.
    [[deprecated]]
    void setNeedExpand(bool value);
    [[deprecated]]
    bool isNeedExpand() const;

private:
    ::Editor::Internal::SelectorNodesPrivate *d;
};

class EDITOR_API IndexList : public SelectorNodes::SubItemList
{
public:
    IndexList();
    ~IndexList() override;

    void extend(Constants::SubObjectType stype, int index);
    void extend(Constants::SubObjectType stype, int from, int to);

    int type() const override;
    bool equal(SubItemList *other) const override;
    void merge(SubItemList *other) override;

    void exclude(Constants::SubObjectType stype) override;
    void exclude(Constants::SubObjectType stype, int index);

    bool contains(Constants::SubObjectType stype, int index) const;

    Unigine::HashSet<int> getSubObjectIndexes(Constants::SubObjectType stype) const;
    bool empty(Constants::SubObjectType stype) const;
    int size(Constants::SubObjectType stype) const;

    IndexList *clone() const override;

private:
    ::Editor::Internal::IndexListPrivate *d;
};


} // namespace Editor