Node.h

Go to the documentation of this file.

#pragma once
 
#include <list>
 
#include "bwContainerWidget.h"
#include "bwLayoutInterface.h"
#include "bwWidget.h"
 
namespace bWidgets {
namespace bwScreenGraph {
 
class EventHandler;
 
class Node {
  friend class Builder;
 
 public:
  using ChildList = std::list<std::unique_ptr<Node>>;
  using ChildIterator = ChildList::iterator;
 
  Node() = default;
  virtual ~Node() = default;
 
  virtual auto Children() const -> const ChildList*
  {
    return nullptr;
  }
  virtual auto Children() -> ChildList*
  {
    return nullptr;
  }
 
  virtual auto childrenVisible() const -> bool
  {
    return true;
  }
 
  virtual auto Layout() const -> bwLayoutInterface*
  {
    return nullptr;
  }
 
  virtual auto Widget() const -> bwWidget*
  {
    return nullptr;
  }
 
  auto Parent() const -> Node*
  {
    return parent;
  }
 
  auto eventHandler() const -> EventHandler*
  {
    return handler.get();
  }
 
  virtual auto Rectangle() const -> bwRectanglePixel = 0;
  virtual auto MaskRectangle() const -> std::optional<bwRectanglePixel> = 0;
  virtual auto isVisible() const -> bool = 0;
 
 private:
  Node* parent{nullptr};
  std::unique_ptr<EventHandler> handler{nullptr};
};
 
class LayoutNode : virtual public Node {
  friend class Builder;
 
 public:
  auto Children() const -> const ChildList* override
  {
    return &children;
  }
  auto Children() -> ChildList* override
  {
    return &children;
  }
 
  auto Layout() const -> bwLayoutInterface* override
  {
    return layout.get();
  }
 
  auto Rectangle() const -> bwRectanglePixel override
  {
    return layout->getRectangle();
  }
 
  auto MaskRectangle() const -> std::optional<bwRectanglePixel> override
  {
    return std::nullopt;
  }
 
  auto isVisible() const -> bool override
  {
    return true;
  }
 
 private:
  ChildList children;
  std::unique_ptr<bwLayoutInterface> layout;
};
 
class WidgetNode : virtual public Node {
  friend class Builder;
 
 public:
  auto Widget() const -> bwWidget* override
  {
    return &*widget;
  }
 
  auto Rectangle() const -> bwRectanglePixel override
  {
    return widget->rectangle;
  }
 
  auto MaskRectangle() const -> std::optional<bwRectanglePixel> override
  {
    return std::nullopt;
  }
 
  auto isVisible() const -> bool override
  {
    return widget->isHidden() == false;
  }
 
 private:
  std::unique_ptr<bwWidget> widget;
};
 
class ContainerNode : public LayoutNode, public WidgetNode {
 public:
  auto Children() const -> const ChildList* override
  {
    return LayoutNode::Children();
  }
  auto Children() -> ChildList* override
  {
    return LayoutNode::Children();
  }
 
  auto Layout() const -> bwLayoutInterface* override
  {
    return LayoutNode::Layout();
  }
 
  auto Widget() const -> bwWidget* override
  {
    return WidgetNode::Widget();
  }
 
  auto ContainerWidget() const -> bwContainerWidget&
  {
    return static_cast<bwContainerWidget&>(*Widget());
  }
 
  auto Rectangle() const -> bwRectanglePixel override
  {
    return WidgetNode::Rectangle();
  }
  auto ContentRectangle() const -> bwRectanglePixel
  {
    return LayoutNode::Rectangle();
  }
 
  auto MaskRectangle() const -> std::optional<bwRectanglePixel> override
  {
    return ContainerWidget().getMaskRectangle();
  }
 
  auto isVisible() const -> bool override
  {
    return WidgetNode::isVisible();
  }
 
  auto childrenVisible() const -> bool override
  {
    return ContainerWidget().childrenVisible();
  }
};
 
}  // namespace bwScreenGraph
}  // namespace bWidgets