TreeCanvas.h

Go to the documentation of this file.

#pragma once
 
#include "Interfaces/ITreeNode.h"
#include "Interfaces/ITreeStructure.h"
#include "Utils/DPI.h"
#include "Visualization/StatusOverlay.h"
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
#include <wx/dcbuffer.h>
#include <wx/wx.h>
 
namespace EmberUI {

struct TreeCanvasConfig {
    int node_width = 175;
    int node_height = 75;
    int vertical_spacing = 50;
    int horizontal_spacing = 20;
    wxSize title_padding = {0, 5};
    int grid_size = 20;
 
    int autoCollapseThreshold = 500;
    int autoCollapseDepth = 3;
 
    wxColour background_color = wxColour(0x2A, 0x2A, 0x2A);
    wxColour grid_color = wxColour(0x3E, 0x3E, 0x3E);
    wxColour text_color = wxColour(0xB4, 0xB4, 0xB4);
    wxColour node_color = wxColour(0x4B, 0x4B, 0x4B);
    wxColour border_color = wxColour(0x78, 0x78, 0x78);
    wxColour selected_border_color = wxColour(0x30, 0x5C, 0xDE);
    wxColour hovered_border_color = wxColour(0x90, 0xEE, 0x90);
    wxColour connection_color = wxColour(0xFF, 0xFF, 0xFF);
 
    wxColour action_type_color = wxColour(0x4A, 0x90, 0xD9);
    wxColour control_type_color = wxColour(0x5C, 0xB8, 0x5C);
    wxColour condition_type_color = wxColour(0xF0, 0xAD, 0x4E);
    wxColour decorator_type_color = wxColour(0x9B, 0x59, 0xB6);
    wxColour behavior_tree_type_color = wxColour(0xD9, 0x53, 0x4F);
 
    int type_header_height = 24;
    bool show_type_icons = true;
    bool show_type_text = true;
    wxColour type_header_text_color = wxColour(0xFF, 0xFF, 0xFF);
    wxString icon_directory;
 
    float zoom_step = 0.1f;
    float mouse_wheel_sensitivity = 1.0f;
    float pan_sensitivity = 1.51f;
    bool zoom_follows_cursor = true;
    float pan_step_size = 40.0f;
 
    bool enable_smooth_panning = true;
    float pan_smoothness = 15.0f;
 
    int pan_mouse_button = 2;
    int pan_key_code = -1;
 
    bool enable_viewport_culling = true;
    int viewport_culling_margin = 500;
 
    bool highlight_path_to_selected = true;
    wxColour path_highlight_color = wxColour(0x90, 0xEE, 0x90);
 
    bool show_navigation_info = false;
};

class TreeCanvas : public wxPanel {
  public:
    using NodeSelectionCallback = std::function<void(EmberCore::ITreeNode *)>;
    using VisibilityChangeCallback = std::function<void()>;

    TreeCanvas(wxWindow *parent, wxWindowID id = wxID_ANY);
    virtual ~TreeCanvas();

    void SetTree(std::shared_ptr<EmberCore::ITreeStructure> tree);
    std::shared_ptr<EmberCore::ITreeStructure> GetTree() const { return m_tree; }

    TreeCanvasConfig &GetConfig() { return m_config; }
    const TreeCanvasConfig &GetConfig() const { return m_config; }

    void SetStatusProvider(IStatusProvider *provider) { m_statusProvider = provider; }
    IStatusProvider *GetStatusProvider() const { return m_statusProvider; }

    EmberCore::ITreeNode *GetSelectedNode() const { return m_selectedNode; }
    void SetSelectedNode(EmberCore::ITreeNode *node);

    void SetNodeSelectionCallback(NodeSelectionCallback callback) { m_selectionCallback = callback; }
    void SetVisibilityChangeCallback(VisibilityChangeCallback callback) { m_visibilityChangeCallback = callback; }

    void ResetView();
    void FitTreeInView();
    void CenterOnNode(EmberCore::ITreeNode *node);
    void SetZoom(float zoom);
    float GetZoom() const { return m_zoomFactor; }

    void MarkDirty() { m_dirty = true; }
    void RefreshCanvas() { MarkDirty(); }

    void InvalidateLayout() {
        m_widthCache.clear();
        m_minimapDirty = true;
        MarkDirty();
        Refresh();
    }

    void SetShowGrid(bool show) { m_showGrid = show; }
    void SetShowOverlayInfo(bool show) { m_showOverlayInfo = show; }
    void SetShowMinimap(bool show) { m_showMinimap = show; }
    void SetShowBreadcrumb(bool show) { m_showBreadcrumb = show; }

    void EnterFocusMode(EmberCore::ITreeNode *node);
    void ExitFocusMode();
    bool IsInFocusMode() const { return m_focusRoot != nullptr; }
    EmberCore::ITreeNode *GetFocusRoot() const { return m_focusRoot; }

    void LoadTypeIcons();
 
  protected:
    virtual void OnNodeSelected(EmberCore::ITreeNode *node);
    virtual void OnBeforePaintOverlays(wxDC &dc);
    virtual wxColour GetNodeFillColor(EmberCore::ITreeNode *node, bool selected, bool hovered);
    virtual wxColour GetNodeBorderColor(EmberCore::ITreeNode *node, bool selected, bool hovered);
    virtual wxColour GetNodeTextColor(EmberCore::ITreeNode *node, bool selected, bool hovered);
    virtual void OnKeyDown(wxKeyEvent &event);
    virtual void OnKeyUp(wxKeyEvent &event);

    wxPoint GetViewOffset() const { return m_viewOffset; }
    wxPoint GetTargetOffset() const { return m_targetOffset; }
    void SetTargetOffset(const wxPoint &offset) { m_targetOffset = offset; }
    void ClearWidthCache() { m_widthCache.clear(); }
    bool GetShowMinimap() const { return m_showMinimap; }
 
  private:
    void OnPaint(wxPaintEvent &event);
    void OnSize(wxSizeEvent &event);
    void OnMouseLeftDown(wxMouseEvent &event);
    void OnMouseLeftDClick(wxMouseEvent &event);
    void OnMouseMotion(wxMouseEvent &event);
    void OnMouseWheel(wxMouseEvent &event);
    void OnMouseMiddleDown(wxMouseEvent &event);
    void OnMouseMiddleUp(wxMouseEvent &event);
    void OnMouseLeftUp(wxMouseEvent &event);
    void OnMouseRightUp(wxMouseEvent &event);
 
    void DrawGrid(wxDC &dc, const wxRect &viewport);
    void DrawNode(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y, int level, const wxRect &viewport);
    void DrawNodeBox(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y);
    void DrawNodeText(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y);
    void DrawTypeHeader(wxDC &dc, EmberCore::ITreeNode *node, const wxRect &nodeRect);
    void DrawNodeConnections(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y);
    void DrawCollapseArrow(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y);
    void DrawOverlayInfo(wxDC &dc);
    void DrawMinimap(wxDC &dc);
    void DrawMinimapNode(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y, float scaleX, float scaleY,
                         int offsetX, int offsetY, const wxRect &minimapArea);
    void DrawBreadcrumb(wxDC &dc);
 
    void AutoCollapseTree(EmberCore::ITreeNode *node, int depth);
    void ExpandAllChildren(EmberCore::ITreeNode *node);
    void CollapseAllChildren(EmberCore::ITreeNode *node);
    void ExpandToDepth(EmberCore::ITreeNode *node, int relativeDepth);
    wxColour GetNodeTypeColor(EmberCore::ITreeNode::NodeType type) const;
    EmberCore::ITreeNode *GetEffectiveRoot() const;
    void ComputeTreeExtent(EmberCore::ITreeNode *node, wxCoord x, wxCoord y, int &minX, int &maxX, int &maxY);
 
    int CalculateSubtreeWidth(EmberCore::ITreeNode *node);
    wxPoint CalculateRootPosition();
    EmberCore::ITreeNode *FindNodeAtPosition(EmberCore::ITreeNode *node, wxPoint node_pos, wxPoint target_pos);
    EmberCore::ITreeNode *FindArrowAtPosition(const wxPoint &world_pos) const;
    wxPoint FindNodeWorldPosition(EmberCore::ITreeNode *target_node);
    wxPoint ScreenToWorld(const wxPoint &screen_pos) const;
    wxPoint WorldToScreen(const wxPoint &world_pos) const;
    wxRect GetViewportBounds() const;
 
    void UpdateScaledConfig();
    void BuildPathToSelected();
 
    TreeCanvasConfig m_config;
    TreeCanvasConfig m_scaled;
    std::shared_ptr<EmberCore::ITreeStructure> m_tree;
    IStatusProvider *m_statusProvider = nullptr;
 
    EmberCore::ITreeNode *m_selectedNode = nullptr;
    EmberCore::ITreeNode *m_hoveredNode = nullptr;
    EmberCore::ITreeNode *m_hoveredArrowNode = nullptr;
    EmberCore::ITreeNode *m_pressedArrowNode = nullptr;
    EmberCore::ITreeNode *m_focusRoot = nullptr;
 
    wxPoint m_viewOffset = {0, 0};
    wxPoint m_targetOffset = {0, 0};
    float m_zoomFactor = 1.0f;
    float m_minZoom = 0.05f;
    float m_maxZoom = 3.0f;
 
    bool m_isPanning = false;
    bool m_panKeyHeld = false;
    wxPoint m_lastMousePos;
    wxLongLong m_lastFrameTime;
 
    bool m_dirty = true;
    bool m_showGrid = true;
    bool m_showOverlayInfo = true;
    bool m_showMinimap = true;
    bool m_showBreadcrumb = true;
 
    wxFont m_titleFont;
    wxFont m_typeFont;
    wxFont m_headerFont;
 
    std::set<int64_t> m_executionPathIds;
    std::set<int> m_pathToSelectedIds;
 
    struct LineSegment {
        wxCoord x1, y1, x2, y2;
    };
    std::vector<LineSegment> m_highlightedSegments;
    std::vector<LineSegment> m_selectedPathSegments;
 
    struct CollapseArrowInfo {
        EmberCore::ITreeNode *node;
        wxCoord x, y;
    };
    std::vector<CollapseArrowInfo> m_collapseArrows;
 
    NodeSelectionCallback m_selectionCallback;
    VisibilityChangeCallback m_visibilityChangeCallback;
 
    wxRect m_minimapRect;
    wxBitmap m_minimapCache;
    bool m_minimapDirty = true;
    int m_minimapCacheTreeMinX = 0;
    int m_minimapCacheRootY = 0;
    float m_minimapCacheScale = 0;
    int m_minimapCacheOfsX = 0;
    int m_minimapCacheOfsY = 0;
 
    std::vector<std::pair<wxRect, EmberCore::ITreeNode *>> m_breadcrumbHitTargets;
 
    mutable std::unordered_map<EmberCore::ITreeNode *, int> m_widthCache;
 
    std::map<EmberCore::ITreeNode::NodeType, wxBitmap> m_typeIcons;
 
    wxTimer *m_refreshTimer;
 
    wxDECLARE_EVENT_TABLE();
};
 
} // namespace EmberUI