Builder.h

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
 
#include "Node.h"
#include "ScreenGraph.h"
#include "bwWidget.h"
 
namespace bWidgets {
namespace bwScreenGraph {
 
class Builder {
 public:
  template<typename _BuilderType = Builder> using BuildFunc = std::function<void(_BuilderType&)>;
 
  Builder(LayoutNode& active_layout_node);
  Builder(ScreenGraph& screen_graph);
  virtual ~Builder() = default;
 
  static void setLayout(LayoutNode& node, std::unique_ptr<bwLayoutInterface> layout);
  static void setWidget(WidgetNode& node, std::unique_ptr<bwWidget> widget);
  static auto addWidget(LayoutNode& node, std::unique_ptr<bwWidget> widget) -> bwWidget&;
 
  void setActiveLayout(bwScreenGraph::LayoutNode&);
 
  template<typename _LayoutType, typename... _Args>
  auto addLayout(_Args&&... __args) -> LayoutNode&
  {
    static_assert(std::is_base_of<bwLayoutInterface, _LayoutType>::value,
                  "Should implement bwLayoutInterface");
 
    LayoutNode& new_node = addChildNode<LayoutNode>(_active_layout_node);
    new_node.layout = std::make_unique<_LayoutType>(std::forward<_Args>(__args)...);
    setActiveLayout(new_node);
    return new_node;
  }
 
  template<typename _LayoutType, typename... _Args>
  auto buildLayout(BuildFunc<> build_func, _Args&&... __args) -> LayoutNode&
  {
    return buildLayout<_LayoutType, Builder>(build_func, std::forward<_Args>(__args)...);
  }
 
  template<typename _LayoutType, typename _BuilderType, typename... _Args>
  auto buildLayout(BuildFunc<_BuilderType> build_func, _Args&&... __args) -> LayoutNode&
  {
    static_assert(std::is_base_of_v<bwLayoutInterface, _LayoutType>,
                  "Should implement bwLayoutInterface");
    static_assert(std::is_base_of_v<Builder, _BuilderType>, "Should inherit from Builder");
 
    LayoutNode& new_node = addChildNode<LayoutNode>(_active_layout_node);
    new_node.layout = std::make_unique<_LayoutType>(std::forward<_Args>(__args)...);
    buildChildren(build_func, new_node);
 
    return new_node;
  }
 
  template<typename _WidgetType, typename... _Args>
  auto addWidget(_Args&&... __args) -> _WidgetType&
  {
    static_assert(std::is_base_of<bwWidget, _WidgetType>::value, "Should derrive from bwWidget");
 
    WidgetNode& new_node = addChildNode<WidgetNode>(_active_layout_node);
    new_node.widget = std::make_unique<_WidgetType>(std::forward<_Args>(__args)...);
    new_node.handler = new_node.widget->createHandler();
    return static_cast<_WidgetType&>(*new_node.widget);
  }
 
  template<typename _WidgetType, typename... _Args>
  auto addContainer(std::unique_ptr<bwLayoutInterface> layout, _Args&&... __args) -> ContainerNode&
  {
    static_assert(std::is_base_of<bwWidget, _WidgetType>::value, "Should derrive from bwWidget");
    static_assert(std::is_base_of<bwContainerWidget, _WidgetType>::value,
                  "Should derrive from bwContainerWidget");
 
    ContainerNode& new_node = addChildNode<ContainerNode>(_active_layout_node);
 
    setLayout(new_node, std::move(layout));
 
    new_node.widget = std::make_unique<_WidgetType>(new_node, std::forward<_Args>(__args)...);
    new_node.handler = new_node.widget->createHandler();
 
    setActiveLayout(new_node);
    return new_node;
  }
 
  template<typename _WidgetType, typename... _Args>
  auto buildContainer(BuildFunc<> build_func,
                      std::unique_ptr<bwLayoutInterface> layout,
                      _Args&&... __args) -> ContainerNode&
  {
    return buildContainer<_WidgetType, Builder>(
        build_func, std::move(layout), std::forward<_Args>(__args)...);
  }
 
  template<typename _WidgetType, typename _BuilderType, typename... _Args>
  auto buildContainer(BuildFunc<_BuilderType> build_func,
                      std::unique_ptr<bwLayoutInterface> layout,
                      _Args&&... __args) -> ContainerNode&
  {
    static_assert(std::is_base_of<bwWidget, _WidgetType>::value, "Should derrive from bwWidget");
    static_assert(std::is_base_of<bwContainerWidget, _WidgetType>::value,
                  "Should derrive from bwContainerWidget");
    static_assert(std::is_base_of_v<Builder, _BuilderType>, "Should inherit from Builder");
 
    ContainerNode& new_node = addChildNode<ContainerNode>(_active_layout_node);
    setLayout(new_node, std::move(layout));
    new_node.widget = std::make_unique<_WidgetType>(new_node, std::forward<_Args>(__args)...);
    new_node.handler = new_node.widget->createHandler();
    buildChildren(build_func, new_node);
 
    return new_node;
  }
 
  template<typename _WidgetType, typename... _Args>
  static auto emplaceWidget(LayoutNode& node, _Args&&... __args) -> _WidgetType&
  {
    static_assert(std::is_base_of<bwWidget, _WidgetType>::value, "Should derrive from bwWidget");
 
    WidgetNode& new_node = addChildNode<WidgetNode>(node);
    new_node.widget = std::make_unique<_WidgetType>(std::forward<_Args>(__args)...);
    new_node.handler = new_node.widget->createHandler();
    return static_cast<_WidgetType&>(*new_node.widget);
  }
 
 private:
  template<typename _NodeType> static auto addChildNode(LayoutNode& parent_node) -> _NodeType&
  {
    static_assert(std::is_base_of<Node, _NodeType>::value,
                  "Should derrive from bwScreenGraph::Node");
 
    parent_node.children.push_back(std::make_unique<_NodeType>());
    Node& ref = *parent_node.children.back();
    ref.parent = &parent_node;
 
    return dynamic_cast<_NodeType&>(ref);
  }
 
  template<typename _BuilderType = Builder>
  void buildChildren(BuildFunc<_BuilderType> build_func, LayoutNode& new_node)
  {
    LayoutNode& old_active_layout = _active_layout_node;
    setActiveLayout(new_node);
    build_func(static_cast<_BuilderType&>(*this));
    setActiveLayout(old_active_layout);
  }
 
  /* Never null, so use a assignable reference. */
  std::reference_wrapper<bwScreenGraph::LayoutNode> _active_layout_node;
};
 
}  // namespace bwScreenGraph
}  // namespace bWidgets