button.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_BUTTON_H
#define EGT_BUTTON_H
 
#include <egt/buttongroup.h>
#include <egt/detail/meta.h>
#include <egt/geometry.h>
#include <egt/image.h>
#include <egt/imageholder.h>
#include <egt/textwidget.h>
#include <egt/theme.h>
#include <memory>
#include <string>
 
namespace egt
{
inline namespace v1
{
 
class Frame;
class Painter;
 
class EGT_API Button : public TextWidget
{
public:
 
    static AlignFlags default_text_align();
    static void default_text_align(const AlignFlags& align);
 
    explicit Button(const std::string& text = {},
                    const AlignFlags& text_align = default_text_align()) noexcept;
 
    Button(const std::string& text, const Rect& rect,
           const AlignFlags& text_align = default_text_align()) noexcept;
 
    explicit Button(Frame& parent, const std::string& text = {},
                    const AlignFlags& text_align = default_text_align()) noexcept;
 
    Button(Frame& parent,
           const std::string& text,
           const Rect& rect,
           const AlignFlags& text_align = default_text_align()) noexcept;
    explicit Button(Serializer::Properties& props) noexcept
        : Button(props, false)
    {
    }
 
protected:
 
    explicit Button(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    Button(const Button&) = delete;
    Button& operator=(const Button&) = delete;
    Button(Button&&) noexcept = default;
    Button& operator=(Button&&) noexcept = default;
 
    void handle(Event& event) override;
 
    using TextWidget::text;
 
    void text(const std::string& text) override;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    RegisterHandle on_click(const EventCallback& handler)
    {
        return on_event(handler, {EventId::pointer_click});
    }
 
    static void default_draw(const Button& widget, Painter& painter, const Rect& rect);
 
    using Widget::checked;
 
    void checked(bool value) override;
 
    static Size default_size();
    static void default_size(const Size& size);
 
    using TextWidget::min_size_hint;
 
    EGT_NODISCARD Size min_size_hint() const override;
 
    ~Button() noexcept override;
 
protected:
 
    void set_parent(Widget* parent) override;
 
private:
 
    static Size default_button_size_value;
    static Signal<>::RegisterHandle default_button_size_handle;
    static void register_handler();
    static void unregister_handler();
 
    static AlignFlags default_text_align_value;
 
    ButtonGroup* m_group{nullptr};
 
    friend ButtonGroup;
};
 
using ImageButton = ImageHolder<Button, Palette::ColorId::button_bg, Palette::ColorId::border, Palette::ColorId::button_text>;
 
class EGT_API CheckButton : public Button
{
    using Button::Button;
 
public:
 
    void handle(Event& event) override
    {
        Button::handle(event);
 
        switch (event.id())
        {
        case EventId::pointer_click:
            checked(!checked());
        default:
            break;
        }
    }
};
 
class EGT_API Switch : public Button
{
public:
 
    explicit Switch(const std::string& text = {},
                    const Rect& rect = {}) noexcept;
 
    explicit Switch(Serializer::Properties& props) noexcept
        : Switch(props, false)
    {
    }
 
protected:
 
    explicit Switch(Serializer::Properties& props, bool is_derived) noexcept;
 
    void serialize(Serializer& serializer) const override;
 
public:
 
    void handle(Event& event) override;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    static void default_draw(const Switch& widget, Painter& painter, const Rect& rect);
 
    using Button::min_size_hint;
 
    EGT_NODISCARD Size min_size_hint() const override;
 
    using Button::text;
    void text(const std::string& text) override;
 
    void show_label(bool value)
    {
        if (detail::change_if_diff<>(m_show_label, value))
            damage();
    }
 
    EGT_NODISCARD bool show_label() const { return m_show_label; }
 
    void switch_align(const AlignFlags& align)
    {
        if (detail::change_if_diff<>(m_switch_align, align))
        {
            damage();
            layout();
        }
    }
 
    EGT_NODISCARD AlignFlags switch_align() const { return m_switch_align; }
 
    EGT_NODISCARD Image* switch_image(bool checked) const;
 
    void switch_image(const Image& image, bool checked);
 
    void reset_switch_image(bool checked);
 
protected:
 
    virtual void draw_switch(Painter& painter, const Rect& handle) const;
 
private:
 
    void deserialize(Serializer::Properties& props);
 
    bool m_show_label{true};
    AlignFlags m_switch_align{AlignFlag::left};
 
    mutable std::unique_ptr<Image> m_normal_switch;
    mutable std::unique_ptr<Image> m_checked_switch;
};
 
namespace experimental
{
 
}
 
}
}
 
#endif