dl_ui_button_base.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include "math/dl_coor.h"
#include "dl_type.h"
#include "io/dl_input.h"
#include "math/dl_align.h"
#include "misc/dl_component_use.h"
#include "render/dl_text.h"
 
namespace dl::UI
{

class Button
{
public:
    using CbCustomRender = std::function<void(Button*)>;
    using CbEventClick = std::function<void(Button*)>;
    enum class State
    {
        NORMAL, 
        OVER,   
        DOWN,   
        DISABLE,
        DOWN_OVER, 
        DOWN_DISABLE,
        MAX_NUM
    };
 
    enum class Mode
    {
        BUTTON, 
        SWITCH, 
        RADIO, 
    };
 
    struct TextData
    {
        gcText _txt;
        Align::Direction2 _hv;// 在按钮的位置
        ArrayEnum<Color, Button::State::MAX_NUM> _col;
        ArrayEnum<Position, Button::State::MAX_NUM> _offset;
        bool _bSizeWithText; // text大小改变按钮的大小
        Position _extraSize; // text大小改变按钮的大小（额外值）
 
        TextData() :
            _bSizeWithText{ false },
            _extraSize{}
        {
            _hv = Align::CC;
            for (auto& iter : _col)
                iter = ColorDef::WHITE;
            for (auto& iter : _offset)
                iter = {};
        }
    };
 
    Button() :
        _state{ State::NORMAL },
        _statePre{ State::NORMAL },
        _mode{ Mode::BUTTON },
        _bOpen{ false },
        _isClick{ false },
        _bDisable{false},
        _txtData{ nullptr },
        _cpt{ this }
    {
        _coor = Coor::Create();
        _init_cpt();
    }
 
    // 克隆使用，init_cpt不赋值值类的组件拷贝，需要手动处理
    Button(const Button& b);
 
 
    void Update();
    void Render();

    bool IsClick();
    bool IsDown()
    {
        return _state == State::DOWN;
    }

    bool IsOverOnce();
 
    bool IsRadio() { return _mode == Mode::RADIO; }
    bool IsSelect() { return _bOpen; }
 
    void SetSelect(bool open);
 
    void SetMode(Mode mode);
 
    void SetDisable(bool disable) { _bDisable = disable; }

    void ClearState();
    void SetSound(std::string_view click, std::string_view over)
    {
        _strSndClick = std::string{ click };
        _strSndOver = std::string{ over };
    }
 
    State GetState() { return _state; }

    Coor* GetCoor() { return _coor; }

    virtual Button* Clone() = 0;
    virtual bool IsPickup() = 0;
    virtual void SetOrder(float order) = 0;
    virtual float GetOrder() = 0;
    virtual Position GetSize() = 0;
    virtual Position GetAnchor() = 0;
 
    float GetOrder(int offset)
    {
        return Math::OffsetOrder(GetOrder(), 0, 0, offset);
    }
 
    void SetElementData(const Align::Direction2& hv, const Position& pos = {})
    {
        _cptElemData._hv = hv;
        _cptElemData._pos = pos;
        _refresh_element_data();
    }
    void SetElementDataRunAble(bool able)
    {
        _cptElemData._bRunAble = able;
    }
    void SetElementDataAutoSize(bool parent_w, bool parent_h)
    {
        _cptElemData._bParentW = parent_w;
        _cptElemData._bParentH = parent_h;
    }
 
    std::string GetString()
    {
        if (!_txtData)
        {
            return {};
        }
        return _txtData->_txt->GetString();
    }

    void AddText(gcText txt, 
        const std::vector<Color>& mul_col,
        const std::vector<Position>& mul_offset);
    void AddTextDefault();
    void AddText(gcText txt); 
    void AddText(gcText txt, const std::vector<Color>& mul_col);
 
    void SetString(std::string_view str);
    void SetTextAlign(const Align::Direction2& hv)
    {
        if (_txtData)
            _txtData->_hv = hv;
    }

    void SetSizeWithText(bool with, const Position& extra_size);
 
    //
    void SetName(std::string_view name)
    {
        _cptName.Set(std::string{ name });
    }
 
    void SetCustomRender(CbCustomRender cb)
    {
        _cbRender = cb;
    }
    void SetEevntClick(CbEventClick cb)
    {
        _cbClick = cb;
    }
 
    Components* GetCpt() { return &_cpt; }
 
    Mode GetMode() { return _mode; }
 
 
    // not use
    static Button* GetClickControl()
    {
        return _clickControl;
    }
 
    virtual ~Button()
    {
        if (_clickControl == this)
            _clickControl = nullptr;
        delete _coor; 
        delete _txtData;
    }
private:
    State _state;
    State _statePre;
    bool _bDisable;
 
    Mode _mode;
    bool _bOpen;
    bool _isClick;
    TextData* _txtData;

    std::string _strSndClick;
    std::string _strSndOver;
protected:
    Coor* _coor;

    std::size_t GetIndex(State state)
    {
        if (_bDisable)
        {
            if (state == State::NORMAL || state == State::OVER)
                return 3;
            else
                return 4;
        }
        else
        {
            return (std::size_t)state;
        }
    }
 
    //
    void _refresh_element_data()
    {
        _cptElemData._size = GetSize();
        _cptElemData._anchor = GetAnchor();
    }
 
    constexpr bool _use_over()
    {
#if DL_PLATFORM == DL_PLATFORM_ANDROID
        return false;
#else
        return true;
#endif
    }

    virtual void UpdateChild(State state_pre, State state);
    virtual void RenderChild(State state_pre, State state);
    virtual void RenderDebug();

    void UpdateTextOrder(float order)
    {
        if (_txtData)
            _txtData->_txt->SetOrder(Math::OffsetOrder(order, 0, 0, -1));
    }
    virtual void OnTextSizeChange(const Position& size) {};
    TextData* GetTextData() { return _txtData; }
private:
    //
    CbCustomRender _cbRender;
    CbEventClick _cbClick;
    //--------------------------组件------------------------
    Components _cpt;
    Cpt::DeleteThis _cptDeleteThis;
    Cpt::Update _cptUpdate;
    Cpt::Render _cptRender;
    Cpt::IsPickup _cptIsPickup;
    Cpt::SetOrder _cptSetOrder;
    Cpt::GetCoor _cptGetCoor;
    Cpt::IsClick _cptIsClick;
    Cpt::IsDown _cptIsDown;
    Cpt::IsSelect _cptIsOpen;
    Cpt::SetSelect _cptSetOpen;
    Cpt::RenderDebug _cptRenderDebug;
    Cpt::ElementData _cptElemData;
    Cpt::Clone _cptClone;
    Cpt::GetSize _cptGetSize;
    Cpt::CustomName _cptName;
    Cpt::CustomTag _cptTag;
 
    void _delete_this() { delete this; }
 
    Components* _clone()
    {
        return Clone()->GetCpt();
    }
 
    void _init_cpt()
    {
        _cptDeleteThis = std::bind(&Button::_delete_this, this);
        _cptUpdate = std::bind(&Button::Update, this);
        _cptRender = std::bind(&Button::Render, this);
        _cptIsPickup = std::bind(&Button::IsPickup, this);
        _cptSetOrder = std::bind(&Button::SetOrder, this, std::placeholders::_1);
        _cptGetCoor = std::bind(&Button::GetCoor, this);
        _cptIsClick = std::bind(&Button::IsClick, this);
        _cptIsDown = std::bind(&Button::IsDown, this);
        _cptIsOpen = std::bind(&Button::IsSelect, this);
        _cptSetOpen = std::bind(&Button::SetSelect, this, std::placeholders::_1);
        _cptRenderDebug = std::bind(&Button::RenderDebug, this);
        _cptClone = std::bind(&Button::_clone, this);
        _cptGetSize = std::bind(&Button::GetSize, this);
 
        _cpt.PushBack(&_cptDeleteThis);
        _cpt.PushBack(&_cptUpdate);
        _cpt.PushBack(&_cptRender);
        _cpt.PushBack(&_cptIsPickup);
        _cpt.PushBack(&_cptSetOrder);
        _cpt.PushBack(&_cptGetCoor);
        _cpt.PushBack(&_cptIsClick);
        _cpt.PushBack(&_cptIsDown);
        _cpt.PushBack(&_cptIsOpen);
        _cpt.PushBack(&_cptSetOpen);
        _cpt.PushBack(&_cptRenderDebug);
        _cpt.PushBack(&_cptClone);
        _cpt.PushBack(&_cptGetSize);
        _cpt.PushBack(&_cptName);
        _cpt.PushBack(&_cptTag);
 
        _cpt.PushBack(&_cptElemData);
    }
 
 
    static Button* _clickControl;//防止在按钮外面按下左键移动到按钮内也能触发Click
 
 
    void _update_button();
    void _update_switch();
    void _update_radio();
};
 
using ButtonMode = Button::Mode;
using ButtonState = Button::State;
 
}
 
#endif