view.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_VIEW_H
#define EGT_VIEW_H
 
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/slider.h>
#include <memory>
 
namespace egt
{
inline namespace v1
{
 
class EGT_API ScrolledView : public Frame
{
public:
 
    enum class Policy
    {
        never,
        always,
        as_needed
    };
 
    explicit ScrolledView(Policy horizontal_policy = Policy::as_needed,
                          Policy vertical_policy = Policy::as_needed) noexcept;
 
    explicit ScrolledView(const Rect& rect,
                          Policy horizontal_policy = Policy::as_needed,
                          Policy vertical_policy = Policy::as_needed) noexcept;
 
    explicit ScrolledView(Frame& parent, const Rect& rect,
                          Policy horizontal_policy = Policy::as_needed,
                          Policy vertical_policy = Policy::as_needed) noexcept;
 
    explicit ScrolledView(Frame& parent,
                          Policy horizontal_policy = Policy::as_needed,
                          Policy vertical_policy = Policy::as_needed) noexcept;
 
    explicit ScrolledView(Serializer::Properties& props) noexcept
        : ScrolledView(props, false)
    {
    }
 
protected:
 
    explicit ScrolledView(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    void handle(Event& event) override;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    void resize(const Size& size) override;
 
    void layout() override;
 
    EGT_NODISCARD Point offset() const { return m_offset; }
 
    void offset(Point offset);
 
    EGT_NODISCARD const Rect& offset_range() const { return m_offset_range; };
 
    EGT_NODISCARD Point offset_min() const { return offset_range().bottom_right(); }
 
    EGT_NODISCARD Point offset_max() const { return offset_range().top_left(); }
 
    int hoffset() const { return m_offset.x(); }
 
    void hoffset(int offset)
    {
        this->offset(Point(offset, m_offset.y()));
    }
 
    int voffset() const { return m_offset.y(); }
 
    void voffset(int offset)
    {
        this->offset(Point(m_offset.x(), offset));
    }
 
    EGT_NODISCARD Policy hpolicy() const { return m_horizontal_policy; }
 
    void hpolicy(Policy policy)
    {
        if (detail::change_if_diff<>(m_horizontal_policy, policy))
            layout();
    }
 
    EGT_NODISCARD Policy vpolicy() const { return m_vertical_policy; }
 
    void vpolicy(Policy policy)
    {
        if (detail::change_if_diff<>(m_vertical_policy, policy))
            layout();
    }
 
    EGT_NODISCARD DefaultDim slider_dim() const { return m_slider_dim; }
 
    void slider_dim(DefaultDim dim)
    {
        if (detail::change_if_diff<>(m_slider_dim, dim))
            damage();
    }
 
    void serialize(Serializer& serializer) const override;
 
    void post_deserialize(Serializer::Properties& props) override;
 
    static std::string policy2str(Policy policy);
    static Policy str2policy(const std::string& str);
 
protected:
 
    bool internal_drag() const override { return true; }
 
    void damage_from_subordinate(const Rect& rect) override
    {
        damage(rect + m_offset);
    }
 
    Point point_from_subordinate(const Widget& subordinate) const override;
 
    EGT_NODISCARD bool hscrollable() const
    {
        return m_hscrollable;
    }
 
    EGT_NODISCARD bool vscrollable() const
    {
        return m_vscrollable;
    }
 
    void update_scrollable()
    {
        const auto& r = offset_range();
 
        m_hscrollable = (m_horizontal_policy == Policy::always) ||
                        (m_horizontal_policy == Policy::as_needed && r.width() > 0);
        m_vscrollable = (m_vertical_policy == Policy::always) ||
                        (m_vertical_policy == Policy::as_needed && r.height() > 0);
    }
 
    void init_sliders();
 
    void update_sliders();
 
    EGT_NODISCARD Rect super_rect() const;
 
    void resize_sliders();
 
    void deserialize(Serializer::Properties& props);
 
    bool m_hscrollable{false};
 
    bool m_vscrollable{false};
 
    Point m_offset;
 
    Rect m_offset_range;
 
    Slider m_hslider;
 
    Slider m_vslider;
 
    Point m_start_offset;
 
    Policy m_horizontal_policy{Policy::as_needed};
 
    Policy m_vertical_policy{Policy::as_needed};
 
    DefaultDim m_slider_dim{8};
};
 
}
}
 
#endif