elements.h

Go to the documentation of this file.

/*
 * Copyright 2015-2020 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/MessagePackBuilder.h>
 
#include <mc_rtc/gui/api.h>
#include <mc_rtc/gui/details/traits.h>
 
namespace mc_rtc
{
 
namespace gui
{
 
enum class Elements
{
  Label = 0,
  ArrayLabel,
  Button,
  Checkbox,
  StringInput,
  IntegerInput,
  NumberInput,
  NumberSlider,
  ArrayInput,
  ComboInput,
  DataComboInput,
  Point3D,
  Trajectory,
  Rotation,
  Transform,
  Schema,
  Form,
  Polygon,
  Force,
  Arrow,
  XYTheta,
  Table,
  Robot,
  Visual,
  PolyhedronTrianglesList,
  PolyhedronVerticesTriangles,
  GenericArray,
  OneOf,
  RobotMsg
};
 
struct MC_RTC_GUI_DLLAPI Element
{
  const std::string & name() const { return name_; }
 
  int id() const { return id_; }
 
  void id(int idIn) { id_ = idIn; }
 
  static constexpr size_t write_size() { return 3; }
 
  void write(mc_rtc::MessagePackBuilder &) {}
 
  bool handleRequest(const mc_rtc::Configuration &) { return false; }
 
  Element() {}
 
protected:
  Element(const std::string & name);
 
  std::string name_;
 
  int id_;
};
 
template<typename GetT>
struct DataElement : public Element
{
  static constexpr size_t write_size() { return Element::write_size() + 1; }
 
  void write(mc_rtc::MessagePackBuilder & builder) { builder.write(get_fn_()); }
 
  DataElement(const std::string & name, GetT get_fn) : Element(name), get_fn_(get_fn) {}
 
  DataElement() {}
 
protected:
  GetT get_fn_;
};
 
template<typename ElementT, typename Callback>
struct CallbackElement : public ElementT
{
  bool handleRequest(const mc_rtc::Configuration & data)
  {
    cb_(data);
    return true;
  }
 
  template<typename... Args>
  CallbackElement(const std::string & name, Callback cb, Args &&... args)
  : ElementT(name, std::forward<Args>(args)...), cb_(cb)
  {
  }
 
  CallbackElement() {}
 
protected:
  Callback cb_;
};
 
template<typename ElementT>
struct CallbackElement<ElementT, std::nullptr_t> : public ElementT
{
  template<typename... Args>
  CallbackElement(const std::string & name, std::nullptr_t, Args &&... args)
  : ElementT(name, std::forward<Args>(args)...)
  {
  }
 
  CallbackElement() {}
};
 
template<typename GetT, typename SetT>
struct CommonInputImpl : public CallbackElement<DataElement<GetT>, SetT>
{
  CommonInputImpl(const std::string & name, GetT get_fn, SetT set_fn)
  : CallbackElement<DataElement<GetT>, SetT>(name, set_fn, get_fn)
  {
  }
 
  CommonInputImpl() {}
};
 
template<typename ElementT, typename Callback>
struct VoidCallbackElement : public CallbackElement<ElementT, Callback>
{
  bool handleRequest(const mc_rtc::Configuration &)
  {
    this->cb_();
    return true;
  }
 
  template<typename... Args>
  VoidCallbackElement(const std::string & name, Callback cb, Args &&... args)
  : CallbackElement<ElementT, Callback>(name, cb, std::forward<Args>(args)...)
  {
  }
 
  VoidCallbackElement() {}
};
 
} // namespace gui
 
} // namespace mc_rtc