bwWidget.h

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <typeinfo>
 
#include "bwDistance.h"
#include "bwFunctorInterface.h"
#include "bwRectangle.h"
#include "bwStyleProperties.h"
#include "screen_graph/EventHandler.h"
 
namespace bWidgets {
 
class bwEvent;
class bwMouseButtonEvent;
class bwMouseButtonDragEvent;
class bwStyle;
 
class bwWidget {
 public:
  enum class State {
    NORMAL = 0,
    HIGHLIGHTED,
    SUNKEN,
 
    STATE_TOT
  };
 
  bwWidget(std::optional<unsigned int> width_hint, std::optional<unsigned int> height_hint);
  virtual ~bwWidget() = default;
 
  /* Disable these constructors/operators. Not really needed and would add complexity for
   * sub-classes. */
  bwWidget() = delete;
  bwWidget(const bwWidget&) = delete;
  bwWidget(bwWidget&&) = delete;
  auto operator=(const bwWidget&) = delete;
  auto operator=(bwWidget&&) = delete;
 
  auto getState() const -> State;
  auto setState(State) -> bwWidget&;
  auto hide(bool _hidden = true) -> bwWidget&;
  auto isHidden() -> bool;
 
  virtual auto getTypeIdentifier() const -> std::string_view = 0;
 
  virtual void draw(bwStyle& style) = 0;
  virtual auto isCoordinateInside(const bwPoint& point) const -> bool;
  virtual auto getLabel() const -> const std::string*;
  virtual auto canAlign() const -> bool;
  virtual auto createHandler() -> std::unique_ptr<bwScreenGraph::EventHandler> = 0;
 
  bwRectanglePixel rectangle;
 
  unsigned int width_hint, height_hint;
 
  bwStyleProperties style_properties;
 
 protected:
  void initialize();
  virtual void registerProperties();
 
 private:
  bool hidden{false};
 
  State state;
};
 
template<class T, class _RawT = typename std::remove_pointer<T>::type>
inline auto widget_cast(bwWidget& widget) -> _RawT*
{
  static_assert(std::is_base_of<bwWidget, _RawT>::value, "Type is not a widget");
 
  return dynamic_cast<_RawT*>(&widget);
}
 
template<class T,
         class _RawT = typename std::remove_pointer<typename std::remove_const<T>::type>::type>
inline auto widget_cast(const bwWidget& widget) -> const _RawT*
{
  static_assert(std::is_base_of<bwWidget, _RawT>::value, "Type is not a widget");
 
  return dynamic_cast<const _RawT*>(&widget);
}
 
template<class T, class _RawT = typename std::remove_pointer<T>::type>
inline auto widget_cast(bwWidget* widget) -> _RawT*
{
  static_assert(std::is_base_of<bwWidget, _RawT>::value, "Type is not a widget");
 
  return dynamic_cast<_RawT*>(widget);
}
 
template<class T,
         class _RawT = typename std::remove_pointer<typename std::remove_const<T>::type>::type>
inline auto widget_cast(const bwWidget* widget) -> const _RawT*
{
  static_assert(std::is_base_of<bwWidget, _RawT>::value, "Type is not a widget");
 
  return dynamic_cast<const _RawT*>(widget);
}
 
}  // namespace bWidgets