NavigatorTab.h

Go to the documentation of this file.

#pragma once
 
#include "Interfaces/ITab.h"
#include "Tabs/TreeHierarchyTab.h"
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include <wx/simplebook.h>
#include <wx/srchctrl.h>
#include <wx/vlbox.h>
#include <wx/wx.h>
 
namespace EmberCore {
class BehaviorTree;
class Blackboard;
class Node;
class ITreeStructure;
} // namespace EmberCore
 
namespace EmberUI {
 
class NavigatorTab;

struct NavigatorCallbacks {
    std::function<bool()> canViewInCurrentScene;
    std::function<void()> refreshVisualization;
    std::function<void(EmberCore::ITreeNode *)> centerOnNode;
    std::function<void(const std::string &)> openInNewScene;
    std::function<void()> onTabClosed;
};

class NavigatorHierarchyView : public EmberUI::TreeHierarchyTab {
  public:
    using ContextMenuPopulator = std::function<void(EmberCore::ITreeNode *, wxMenu &)>;
    using ContextMenuHandler = std::function<void(int, EmberCore::ITreeNode *)>;
    using NodeActivatedHandler = std::function<void(EmberCore::ITreeNode *)>;
 
    NavigatorHierarchyView(wxWindow *parent, const EmberUI::TreeHierarchyConfig &config);

    void SetContextMenuPopulator(ContextMenuPopulator cb) { m_contextPopulator = std::move(cb); }
    void SetContextMenuHandler(ContextMenuHandler cb) { m_contextHandler = std::move(cb); }
    void SetNodeActivatedHandler(NodeActivatedHandler cb) { m_activatedHandler = std::move(cb); }
 
  protected:
    void OnPopulateContextMenu(EmberCore::ITreeNode *node, wxMenu &menu) override;
    void OnContextMenuCommand(int id, EmberCore::ITreeNode *node) override;
    void OnNodeActivated(EmberCore::ITreeNode *node) override;
 
  private:
    ContextMenuPopulator m_contextPopulator;
    ContextMenuHandler m_contextHandler;
    NodeActivatedHandler m_activatedHandler;
};

class NavigatorTreeListBox : public wxVListBox {
  public:
    NavigatorTreeListBox(NavigatorTab *owner, wxWindow *parent, wxWindowID id);
 
  private:
    void OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const override;
    wxCoord OnMeasureItem(size_t n) const override;
    void OnDrawBackground(wxDC &dc, const wxRect &rect, size_t n) const override;
    void OnLeftDown(wxMouseEvent &event);
    void OnLeftDClick(wxMouseEvent &event);
    void OnRightDown(wxMouseEvent &event);
 
    NavigatorTab *m_owner;
};

class SearchResultsListBox : public wxVListBox {
  public:
    SearchResultsListBox(NavigatorTab *owner, wxWindow *parent, wxWindowID id);
 
  private:
    void OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const override;
    wxCoord OnMeasureItem(size_t n) const override;
    void OnDrawBackground(wxDC &dc, const wxRect &rect, size_t n) const override;
    void OnLeftDClick(wxMouseEvent &event);
    void OnRightDown(wxMouseEvent &event);
 
    NavigatorTab *m_owner;
};

class NavigatorTab : public wxPanel, public ITab {
  public:
    using TreeSelectionCallback = std::function<void(const std::string &treeId)>;
 
    NavigatorTab(wxWindow *parent);
 
    void SetCallbacks(NavigatorCallbacks cb) { m_callbacks = std::move(cb); }
    void SetEditingEnabled(bool enabled) { m_editingEnabled = enabled; }
    bool IsEditingEnabled() const { return m_editingEnabled; }
 
  protected:
    NavigatorTab(wxWindow *parent, bool deferLayout);
    void InitLayout();
    virtual NavigatorHierarchyView *CreateHierarchyView(wxWindow *parent, const TreeHierarchyConfig &cfg);
    NavigatorHierarchyView *GetHierarchyView() const { return m_hierarchyView; }
 
  public:
    // ITab interface
    wxWindow *GetWidget() override { return this; }
    wxString GetTitle() const override { return "Navigator"; }
    wxString GetTabType() const override { return "Navigator"; }
    void OnClosed() override;
    void OnActivated() override;

    void UpdateTreeList(const std::map<std::string, std::shared_ptr<EmberCore::BehaviorTree>> &trees,
                        const std::string &currentTreeId);
    void SetCurrentTree(const std::string &treeId);
    void ClearTreeList();
    void SetTreeSelectionCallback(TreeSelectionCallback callback) { m_treeSelectionCallback = std::move(callback); }
    void SetMainTreeId(const std::string &id);
 
    void SetBlackboards(const std::map<std::string, std::shared_ptr<EmberCore::Blackboard>> &bbs);
    void SetBlackboardSelectionCallback(std::function<void(const std::string &)> cb);
    void OnBlackboardClicked(const std::string &bbId);

    void SetActiveTree(std::shared_ptr<EmberCore::ITreeStructure> tree, const std::string &treeId);
    void SelectNodeById(size_t nodeId);
    void RefreshHierarchy();
 
    void SetLayoutInvalidationCallback(std::function<void()> cb);
    void SetNodeSelectionCallback(std::function<void(EmberCore::ITreeNode *)> cb);

    void DrillIntoTree(const std::string &treeId);
    void NavigateBack();
 
    // Tree list data access (for the list box drawing)
    enum class SectionType { None, MainTree, OtherTrees, Blackboards };

    struct FlatEntry {
        std::string id;
        std::string displayName;
        int nodeCount;
        int depth;
        bool isImplemented;
        bool isLastChild;
        bool hasChildren;
        bool isCollapsed;
        bool isHeader;
        SectionType section;
        int sectionCount;
        std::vector<bool> parentHasMore;
    };

    struct SearchResult {
        enum class Type { Tree, Node };
        Type type;
        std::string treeId;
        std::string nodeName;
        size_t nodeId;
    };
 
    const std::vector<FlatEntry> &GetFlatList() const { return m_flatList; }
    const std::vector<SearchResult> &GetSearchResults() const { return m_searchResults; }
    const std::string &GetCurrentTreeId() const { return m_currentTreeId; }
    const std::string &GetBrowsedTreeId() const { return m_browsedTreeId; }
 
    void ToggleCollapse(const std::string &treeId);
    void ToggleSectionCollapse(SectionType section);
    bool IsCollapsed(const std::string &treeId) const;
    bool IsSectionCollapsed(SectionType section) const;
    int GetToggleHitX(int depth, bool isCurrent) const;
 
    void ShowTreeContextMenu(int itemIndex, const wxPoint &pos);
    void ShowSearchContextMenu(int resultIndex, const wxPoint &pos);
    bool IsActiveTree(const std::string &treeId) const { return treeId == m_currentTreeId; }
    void ClearSearch();
 
  private:
    void UpdateBreadcrumb();
    void UpdateStatusLabel();
 
    struct TreeInfo {
        std::string id;
        int nodeCount;
        bool isImplemented;
        std::set<std::string> subtreeRefs;
    };
 
    void CollectSubTreeRefs(EmberCore::Node *node, std::set<std::string> &refs) const;
    void CollectAllReachableSubtrees(const std::string &treeId, std::set<std::string> &reachable) const;
    void BuildFlatList();
    void FlattenTree(const std::string &treeId, int depth, std::set<std::string> &visited, bool isLastChild,
                     std::vector<bool> parentHasMore);
    int FindItemByTreeId(const std::string &treeId) const;
 
    void PerformGlobalSearch(const wxString &query);
 
    void OnHierarchyContextMenu(EmberCore::ITreeNode *node, wxMenu &menu);
    void OnHierarchyContextCommand(int id, EmberCore::ITreeNode *node);
    void OnHierarchyNodeActivated(EmberCore::ITreeNode *node);
    void OnHierarchySelectionChanged(EmberCore::ITreeNode *node);
    EmberCore::Node *GetMutableNode(EmberCore::ITreeNode *inode) const;
 
    void OnTreeListContextViewInCurrent(wxCommandEvent &event);
    void OnTreeListContextOpenNewScene(wxCommandEvent &event);
    void OnTreeListContextBrowse(wxCommandEvent &event);
    void OnTreeListContextExpand(wxCommandEvent &event);
    void OnTreeListContextCollapse(wxCommandEvent &event);
 
    void OnSearchTextChanged(wxCommandEvent &event);
    void OnSearchEnter(wxCommandEvent &event);
 
    void OnBackClicked(wxCommandEvent &event);
 
    void CollapseAllTrees();
    void ExpandAllTrees();
 
    // UI components
    wxSearchCtrl *m_searchCtrl = nullptr;
    wxPanel *m_breadcrumbPanel = nullptr;
    wxButton *m_backBtn = nullptr;
    wxStaticText *m_breadcrumbLabel = nullptr;
    wxSimplebook *m_book = nullptr;
    NavigatorTreeListBox *m_treeListBox = nullptr;
    NavigatorHierarchyView *m_hierarchyView = nullptr;
    SearchResultsListBox *m_searchListBox = nullptr;
    wxStaticText *m_statusLabel = nullptr;
 
    enum class ViewPage { TreeList = 0, Hierarchy = 1, Search = 2 };
    ViewPage m_currentPage = ViewPage::TreeList;
    ViewPage m_pageBeforeSearch = ViewPage::TreeList;
 
    std::map<std::string, TreeInfo> m_treeInfoMap;
    std::vector<FlatEntry> m_flatList;
    std::set<std::string> m_collapsedTrees;
    bool m_mainTreeSectionCollapsed = false;
    bool m_otherTreesSectionCollapsed = false;
    bool m_blackboardsSectionCollapsed = false;
 
    std::vector<SearchResult> m_searchResults;
    wxString m_searchFilter;
 
    std::map<std::string, std::shared_ptr<EmberCore::BehaviorTree>> m_projectTrees;
    std::string m_currentTreeId;
    std::string m_mainTreeId;
    std::string m_browsedTreeId;
    std::string m_contextMenuTreeId;
 
    std::shared_ptr<EmberCore::ITreeStructure> m_activeTreeAdapter;
 
    std::map<std::string, std::shared_ptr<EmberCore::Blackboard>> m_blackboards;
    std::function<void(const std::string &)> m_blackboardSelectionCallback;
 
    NavigatorCallbacks m_callbacks;
    bool m_editingEnabled = true;
    TreeSelectionCallback m_treeSelectionCallback;
    std::function<void(EmberCore::ITreeNode *)> m_nodeSelectionCallback;
 
    enum {
        ID_SEARCH_CTRL = wxID_HIGHEST + 300,
        ID_BACK_BTN,
        ID_TREE_LIST,
        ID_SEARCH_LIST,
        ID_CTX_VIEW_CURRENT,
        ID_CTX_OPEN_NEW_SCENE,
        ID_CTX_BROWSE,
        ID_CTX_EXPAND,
        ID_CTX_COLLAPSE,
        ID_CTX_ADD_CHILD = wxID_HIGHEST + 350,
        ID_CTX_DELETE_NODE,
        ID_CTX_RENAME_NODE,
        ID_CTX_DUPLICATE_NODE,
        ID_CTX_OPEN_TREE
    };
 
    wxDECLARE_EVENT_TABLE();
};
 
} // namespace EmberUI