dl_ui_panel.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include "misc/dl_component_use.h"
#include "base/dl_type_def.h"
#include "misc/dl_locator.h"
#include "base/dl_tree.h"
#include "dl_ui_background.h"
#include "render/dl_factory.h"
#include "ui/dl_ui_sprite.h"
#include "ui/dl_ui_text.h"
#include "ui/dl_ui_button_sprite.h"
#include "ui/dl_ui_button_sprite9.h"
#include "io/dl_json.h"
 
namespace dl::UI
{
enum class ElementType
{
    UNKNOWN = -1,
    BACKGROUND,
    TEXT,
    BUTTON,
    MSG_BOX,
    LOCATOR,
    LIST_BOX,
};
 
inline ElementType String2ElementType(std::string_view str)
{
    if (String::EqualToLower(str, "text"))
        return ElementType::TEXT;
    if (String::EqualToLower(str, "msg_box"))
        return ElementType::MSG_BOX;
    if (String::EqualToLower(str, "button"))
        return ElementType::BUTTON;
    if (String::EqualToLower(str, "background"))
        return ElementType::BACKGROUND;
    if (String::EqualToLower(str, "locator"))
        return ElementType::LOCATOR;
    if (String::EqualToLower(str, "list_box"))
        return ElementType::LIST_BOX;
 
    log_err("未知的type字段：{}", str);
    return ElementType::UNKNOWN;
}
 
class EditBox;

class Panel
{
    friend class Manager;
public:
    enum PickupMode
    {
        E_SIZE = 1 << 1,  
        E_ELEMENT = 1 << 2,    
        E_CHILD = 1 << 4,    
    };
    enum OrderMode
    {
        AUTO,       
        CUSTOM,       
        FORCE,     
    };

    void AddCpt(Components* cpt);
    template<typename T>
    void Add(T* p)
    {
        AddCpt(p->GetCpt());
    }

    void Add(Text* p) { AddCpt(p->GetCpt()); }
    void Add(std::string_view json_path);
    void AddPanel(Panel* child);

    void DelCpt(Components* cpt);
    template<typename T>
    void Del(T* p)
    {
        DelCpt(p->GetCpt());
    }

    Panel* Clone();

    void SetPosPixel(const Position& pos_pixel)
    {
        if (!_bAutoCoor)
        {
            log_err0("关闭了自动设置位置，设置像素位置无效！");
            return;
        }
        _posPixel = pos_pixel;
        _coor->SetPosition(_posPixel - Align::Size2Anchor(GetSize(), _align) + Align::Dir2Offset(GetSize(), _dir));
    }
    void DtPosPixel(const Position& dt)
    {
        if (!_bAutoCoor)
        {
            log_err0("关闭了自动设置位置，设置像素位置无效！");
            return;
        }
        _posPixel += dt;
        _coor->DtPosition(dt);
    }

    void SetPosScale(const Position& pos_scale)
    {
        assert(_bAutoCoor);
        if (!_bAutoCoor)
        {
            log_err0("关闭了自动设置位置，设置比例位置无效！");
            return;
        }
        _posScale = pos_scale;
        _bNeedRefreshPos = true;
    }

    void SetDir(Align::Dir4 dir);
    void SetAlign(const Align::Direction2& hv)
    {
        assert(_bAutoCoor);
        _align = hv;
        _bNeedRefreshPos = true;
    }

    void SetLocator(const Locator& loc)
    {
        assert(_bAutoCoor);
        _locator = loc;
        _bNeedRefreshLocator = true;
    }
    void SetLocator(const Locator::SL& sl)
    {
        SetLocator(Locator{ sl });
    }
    void SetLocator(std::string_view name);
    void SetAutoCoor(bool auto_coor) { _bAutoCoor = auto_coor; }
    void SetAutoRun(bool auto_run) { _bAutoRun = auto_run; }
    void SetAutoRender(bool auto_render) { _bAutoRender = auto_render; }
    void SetOrderMode(OrderMode mode)
    {
        _orderMode = mode;
        _refresh_order();
    }

    void SetOrder(float order)
    {
        assert(_orderMode == OrderMode::FORCE);
        if (_orderMode == OrderMode::FORCE)
        {
            _order = order;
            _refresh_order();
        }
    }

    void SetOrderInParent(int order_parent)
    {
        assert(_orderMode == OrderMode::CUSTOM);
        if (_orderMode == OrderMode::CUSTOM)
        {
            _orderInParent = order_parent;
            _refresh_order();
        }
    }
    void RefreshOrder()
    {
        _refresh_order();
    }

    void SetName(std::string_view name)
    {
        _name = name;
    }

    void SetSelect(size_t index)
    {
        size_t i = 0;
        for (auto& iter : _allEle)
        {
            if (auto comp = iter->Get<Cpt::SetSelect>())
            {
                comp->Call(i == index);
            }
            ++i;
        }
    }

    void ElementSetSelect(size_t index, bool select)
    {
        if (index >= _allEle.size())
            log_err0("越界！");
        if (auto comp = _allEle[index]->Get<Cpt::SetSelect>())
        {
            comp->Call(select);
            return;
        }
        log_err0("对象没有SetSelect组件！");
    }

    void SetSelectAll(bool select)
    {
        for (auto& iter : _allEle)
        {
            if (auto comp = iter->Get<Cpt::SetSelect>())
            {
                comp->Call(select);
            }
        }
    }

    void Update();
    void Render();
    void UpdateRadio();
    bool IsUpdate() { return _bUpdate; }
    bool IsRender() { return _bRender; }
    std::string GetName() const { return _name; }
    Coor* GetCoor()
    {
        assert(!_bAutoCoor);
        return _coor;
    }
    Coor* GetCoorRef()
    {
        return _coor;
    }
    Align::Dir4 GetDir() { return _dir; }
    Panel* GetParent()
    {
        if(_node->GetParent())
            return _node->GetParent()->GetValue();
        return nullptr;
    }

    std::vector<Panel*> GetChildAll()
    {
        std::vector<Panel*> ret;
        for (auto& iter : _node->GetChild())
            ret.push_back(iter->GetValue());
        return ret;
    }

    size_t GetChildNum(bool recursion = false)
    {
        size_t ret = _node->GetChild().size();
        if (recursion)
        {
            for (auto& iter : _node->GetChild())
                ret += iter->GetValue()->GetChildNum(true);
        }
        return ret;
    }

    size_t GetChildIndex(Panel* child)
    {
        size_t i = 0;
        for (auto& iter : _node->GetChild())
        {
            if (iter->GetValue() == child)
                return i;
            ++i;
        }
        return -1;
    }
    
    Panel* GetChild(size_t i)
    {
        auto& vec = _node->GetChild();
        if (i >= vec.size())
        {
            log_err("下标越界！");
            return nullptr;
        }
        return vec[i]->GetValue();
    }

    Panel* GetChildSelect();
    void SetChildSelect(Panel* panel);
    Panel* GetChildPickup();

    template<typename T>
    std::size_t GetIndex()
    {
        size_t i = 0;
        for (auto& iter : _allEle)
        {
            if (auto comp = iter->Get<T>())
            {
                if (comp->Call())
                    return i;
            }
            ++i;
        }
        return -1;
    }

    template<typename T>
    Components* Get()
    {
        for (auto& iter : _allEle)
        {
            if (auto comp = iter->Get<T>())
            {
                if (comp->Call())
                    return iter;
            }
        }
        return nullptr;
    }

    size_t GetClickIndex()
    {
        return GetIndex<Cpt::IsClick>();
    }
    std::string GetClickName()
    {
        size_t i = GetClickIndex();
        if (i != -1)
        {
            Cpt::CustomName* comp = _allEle[i]->Get<Cpt::CustomName>();
            if (comp)
                return comp->Get();
        }
        return "";
    }

    size_t GetDownIndex()
    {
        return GetIndex<Cpt::IsDown>();
    }

    size_t GetSelectIndex()
    {
        return GetIndex<Cpt::IsSelect>();
    }

    Components* GetSelect()
    {
        return Get<Cpt::IsSelect>();
    }
 
    std::string GetSelectName()
    {
        Components* cpt = GetSelect();
        return cpt ? cpt->GetName() : "";
    }

    bool IsSelectIndex(size_t index)
    {
        if (index >= _allEle.size())
        {
            log_err0("越界！");
            return false;
        }
        if (auto comp = _allEle[index]->Get<Cpt::IsSelect>())
        {
            return comp->Call();
        }
 
        log_err0("对象没有Open组件！");
        return false;
    }

    Position GetSize();
    Position GetParentSize();
    RectF GetRect();
 
    Position GetPosition()
    {
        return _coor->GetPosition();
    }
    float GetOrder()
    {
        return _order;
    }
 
    const Locator& GetLocator()
    {
        return _locator;
    }

    template<typename T>
    T* GetElement(size_t n = 0)
    {
        if(n == 0)
            return Cpt::GetFirst<T>(_allEle);
        else
            return Cpt::GetN<T>(_allEle, n);
    }

    template<typename T>
    std::vector<T*> GetElementVector()
    {
        std::vector<T*> ret;
        for (auto& iter : _allEle)
        {
            T* cpt = iter->Cast<T>();
            if (cpt)
                ret.push_back(cpt);
        }
        return ret;
    }

    bool IsPickup()
    {
        if (_pickupMode & E_SIZE)
        {
            if (g_factory->GetOrderPickup() < _order)
                return false;
            Position pos = _coor->WorldToThis(toPosition(g_input->GetCursorPosition()));
            Position size = toPosition(GetSize());
            if (pos[0] >= 0
                && pos[1] >= 0
                && pos[0] <= size[0]
                && pos[1] <= size[1])
                return true;
        }
        if (_pickupMode & E_ELEMENT)
        {
            for (Components* cpt : _allEle)
            {
                Cpt::IsPickup* comp = cpt->Get<Cpt::IsPickup>();
                if (!comp)
                    continue;
                if (comp->Call())
                    return true;
            }
        }
        if (_pickupMode & E_CHILD)
        {
            for (auto& iter : _node->GetChild())
            {
                Panel* child = iter->GetValue();
                if (child->IsPickup())
                    return true;
            }
        }
        return false;
    }
 
    // 指定大小
    void SetSize(const Position& size)
    {
        _size = size;
        _bSizeAuto = false;
        _bSizeFull = false;
        _refresh_size();
    }
    void SetAutoSize(bool auto_size)
    {
        _bSizeAuto = true;
        _bSizeFull = false;
        _refresh_size();
    }
    // 设置拾取模式
    void SetPickupMode(PickupMode mode)
    {
        _pickupMode = mode;
    }
    void SetPickupMode(int mode)
    {
        SetPickupMode((PickupMode)mode);
    }
    // 与父节点一样大
    void SetSizeFull()
    {
        _bSizeFull = true;
        _refresh_size();
    }
 
    void OnChangeElementData(Components* cpt);
 
    bool IsAutoRun() { return _bAutoRun; }
    //----------------------------------辅助函数-----------------------------
    UI::Button* ExGetButton(size_t n = 0, bool show_log = true);
    UI::ButtonSprite* ExGetButtonSprite(size_t n = 0, bool show_log = true);
    UI::ButtonSprite9* ExGetButtonSprite9(size_t n = 0, bool show_log = true);
    UI::EditBox* ExGetEditBox(size_t n = 0, bool show_log = true);
    UI::Text* ExGetText(size_t n = 0, bool show_log = true);
    UI::Background* ExGetBackground(size_t n = 0, bool show_log = true);
    void ExSetString(std::string_view str, size_t n = 0);
 
    void SetDebugName(std::string_view name)
    {
#ifndef NDEBUG
        _debugName = name;
#endif
    }
private:
    Panel() :
        _order{ Z_DEFAULT_PANEL },
        _orderMode{ OrderMode::AUTO },
        _orderInParent{ -1 },
        _bAutoRun{ true },
        _bAutoRender{ true },
        _bNeedRefreshPos{ false },
        _bNeedRefreshLocator{ false },
        _bDisableLocator{ false },
        _bAutoCoor{ true },
        _bUpdate{ false },
        _bRender{ false },
        _pickupMode{ E_SIZE },
        _align{ Align::LT },
        _dir{ Align::Dir4::RIGHT },
        _posPixel{},
        _posScale{},
        _size{},
        _bSizeFull{ true },
        _bSizeAuto{ false }
    {
        _coor = Coor::Create();
    }
    ~Panel()
    {
        //删除元素
        for (Components*& cpt : _allEle)
        {
            if (cpt->IsPure())
                delete cpt;
            else if (auto comp = cpt->Get<Cpt::DeleteThis>())
            {
                comp->Call();
            }
 
        }
        delete _coor;
    }
#ifndef NDEBUG
    std::string _debugName;
#endif
 
    // 添加到 Scene时自动设置
    std::string _name;
    std::vector<Components*> _allEle;// 子元素
 
    Coor* _coor;
    // 全局偏移（受 order模式控制）
    float _order;
    OrderMode _orderMode;
    int _orderInParent; 
 
    bool _bAutoRun;// 自动运行（由父节点调用Update和Render）
    bool _bAutoRender;// 如果调用了Update，则自动调用Render（由父节点）
    bool _bNeedRefreshPos; // 更新位置
    bool _bNeedRefreshLocator; // 重新定位
    bool _bDisableLocator;// 禁用定位器，暂未使用
    bool _bAutoCoor;// 接手Coor后，需要设为真
    bool _bUpdate;// 此帧是否已运行
    bool _bRender;// 此帧是否已绘制
    PickupMode _pickupMode;
 
    // 树节点引用
    NTree<Panel*>::Node* _node;
 
    // location
    Align::Direction2 _align; // 自己大小对齐
    Align::Dir4 _dir; // 自己朝向
    Position _posPixel;
    Position _posScale;
 
    // locator
    Locator _locator;
 
    Position _size;     // 指定大小（0表示跟随父节点大小）
    bool _bSizeFull;// 与父节点同大小
    bool _bSizeAuto; // 自动大小
 
    void _refresh_lang()
    {
 
    }

    void _refresh_pos(const Position& size);

    void _refresh_size();
    void _refresh_order();
 
    void _update_child();
    void _render_child();
 
    void _update_cpt_drag(Components* cpt);
    void _update_cpt_radio(Components* cpt);
};
 
}
 
#endif