notebook.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_NOTEBOOK_H
#define EGT_NOTEBOOK_H
 
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/signal.h>
#include <memory>
#include <string>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
class Notebook;
class EGT_API NotebookTab : public Frame
{
public:
 
    NotebookTab()
    {
        name("NotebookTab" + std::to_string(m_widgetid));
 
        // tabs are not transparent by default
        fill_flags(Theme::FillFlag::solid);
    }
 
    explicit NotebookTab(Serializer::Properties& props) noexcept
        : NotebookTab(props, false)
    {
    }
 
    using Frame::add;
    void add(const std::shared_ptr<Widget>& widget) override
    {
        if (!widget)
            return;
 
        if (widget.get() == this)
            throw std::runtime_error("cannot add a widget to itself");
 
        assert(!widget->parent() && "widget already has parent!");
 
        auto cell = std::dynamic_pointer_cast<NotebookTab>(widget);
        if (cell)
            throw std::invalid_argument("cannot have nested NotebookTab");
 
        Frame::add(widget);
    }
 
protected:
 
    explicit NotebookTab(Serializer::Properties& props, bool is_derived) noexcept
        : Frame(props, true)
    {
        if (!is_derived)
            deserialize_leaf(props);
    }
 
public:
 
    virtual bool leave()
    {
        return true;
    }
 
    virtual void enter()
    {
    }
 
    void select();
};
 
class EGT_API Notebook : public Frame
{
public:
 
    Signal<> on_selected_changed;
    explicit Notebook(const Rect& rect = {}) noexcept;
 
    explicit Notebook(Frame& parent, const Rect& rect = {}) noexcept;
 
    explicit Notebook(Serializer::Properties& props) noexcept
        : Notebook(props, false)
    {
    }
 
protected:
 
    explicit Notebook(Serializer::Properties& props, bool is_derived) noexcept;
 
public:
 
    using Frame::add;
 
    void add(const std::shared_ptr<Widget>& widget) override;
 
    void remove(Widget* widget) override;
 
    void selected(size_t index);
 
    void selected(Widget* widget);
 
    EGT_NODISCARD ssize_t selected() const { return m_selected; }
 
    EGT_NODISCARD NotebookTab* get(size_t index) const;
 
    void serialize(Serializer& serializer) const override;
 
    void post_deserialize(Serializer::Properties& props) override;
 
protected:
 
    using CellArray = std::vector<std::weak_ptr<NotebookTab>>;
 
    CellArray m_cells;
 
    ssize_t m_selected{-1};
};
 
}
}
 
#endif