dl_ui_tree.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include "misc/dl_component_use.h"
#include "ui/dl_ui_background.h"
#include "ui/dl_ui_panel.h"
 
namespace dl::UI
{

class Tree
{
public:
    template<typename T>
    using CbSetContent = std::function<void(UI::Panel* panel, const T& v)>;
    using CbSetPosition = std::function<void(UI::Panel* panel, size_t y, size_t extra)>;

    static Tree* Create(Panel* item)
    {
        Tree* ret = new Tree;
        ret->_item = item;
        ret->_init();
        return ret;
    }

    void SetCallbackSetPosition(CbSetPosition func)
    {
        _fnSetPosition = func;
    }
 
    void Update()
    {
        _panel->Update();
    }
 
    void Render()
    {
    }

    template<typename T>
    void Refresh(const NTree<T>& tree, CbSetContent<T> cb)
    {
        _delete_panel_child(_panel);
 
        using TreeNode = typename NTree<T>::Node;
        const TreeNode* p = tree.GetRoot();
        if (!p)
            return;
        std::function<void(const TreeNode*, UI::Panel* parent)> fn_refresh =
            [&](const TreeNode* node, UI::Panel* parent) {
 
            UI::Panel* panel = _item->Clone();
            panel->SetAutoRun(true);
            _set_panel_parent(panel, parent);
            cb(panel, node->GetValue());
 
            const std::vector<TreeNode*>& vec = node->GetChild();
            size_t j = 0;
            for (const TreeNode* child : node->GetChild())
            {
                fn_refresh(child, panel);
            }
            };
        fn_refresh(p, _panel);
 
        _refresh_pos();
    }
 
    void Clear();
 
    bool IsPickup()
    {
        return _panel->IsPickup();
    }

    std::size_t IsSelectChange()
    {
        /*if (_bSelectChange)
            return _curSelect;*/
        return -1;
    }

    std::size_t GetSelectIndex()
    {
        return 0;
    }

    Panel* GetSelect()
    {
        return nullptr;
    }

    void SetOrder(float order)
    {
        _panel->SetOrder(Math::OffsetOrder(order, 0, 0, -1));
        /*for (auto iter : _treePanel)
        {
            iter->GetValue()->SetOrder(Math::OffsetOrder(order, 0, 0, -1));
        }*/
    }
 

    void SetSize(const Position& size)
    {
        _panel->SetSize(size);
        _cptElemData._size = size;
    }
 
    Coor* GetCoor() { return _panel->GetCoor(); }
 
    Components* GetCpt() { return &_cpt; }
 
 
    ~Tree()
    {
    }
private:
    Tree() :
        _cpt{ this }
    {
        _init_cpt();
    }
 
    Panel* _panel;
    Panel* _item;
 
    CbSetPosition _fnSetPosition;
 
    Components _cpt;
    Cpt::DeleteThis _cptDeleteThis;
    Cpt::SetOrder _cptSetOrder;
    Cpt::Update _cptUpdate;
    Cpt::Render _cptRender;
    Cpt::GetCoor _cptGetCoor;
    Cpt::ElementData _cptElemData;
 
    void _delete_this() { delete this; } 
 
    void _init_cpt()
    {
        _cptDeleteThis = std::bind(&Tree::_delete_this, this);
        _cptSetOrder = std::bind(&Tree::SetOrder, this, std::placeholders::_1);
        _cptUpdate = std::bind(&Tree::Update, this);
        _cptRender = std::bind(&Tree::Render, this);
        _cptGetCoor = std::bind(&Tree::GetCoor, this);
 
        _cpt.PushBack(&_cptDeleteThis);
        _cpt.PushBack(&_cptSetOrder);
        _cpt.PushBack(&_cptUpdate);
        _cpt.PushBack(&_cptRender);
        _cpt.PushBack(&_cptGetCoor); 
        
        _cpt.PushBack(&_cptElemData);
    }
    
    void _init();
    void _set_panel_parent(UI::Panel* panel, UI::Panel* parent);
    void _delete_panel_child(UI::Panel* panel);
 
    void _refresh_pos();
};
}
 
#endif