widget_factory.h

#pragma once
 
#include <QComboBox>
#include <QWidget>
 
#include "mission_parameter.h"
#include "oclero/qlementine/widgets/ColorEditor.hpp"
#include "style_helpers.h"
#include "typing/type_definition.h"
#include "typing/type_reference.h"
 
class QLineEdit;
class QToolButton;
class QSpinBox;
class QPushButton;
class QLabel;
class QCheckBox;
class QFormLayout;
class IntegerOrVariableValidator;
class DoubleOrVariableValidator;
class QTableWidget;
 
namespace oclero::qlementine
{
class Label;
class LineEdit;
class ColorEditor;
}  // namespace oclero::qlementine

namespace maki
{
class WidgetGroup;
class ClickableLabel;
 
void addCompleter(const QStringList& items, QWidget* parent);

struct WidgetAlignment
{
  enum class Type
  {
    UNKNOWN = 0,
    INLINE,
    VERTICAL,
    FORM
  } type;  
 
  enum class Direction
  {
    UNKNOWN = 0,
    LEFT,
    RIGHT,
    CENTER,
    SPREAD,
    ABOVE
  } direction;  
 
  WidgetGroup* group;  
  int labelWidth = 0;
 
  static WidgetAlignment Inline()
  {
    return WidgetAlignment{WidgetAlignment::Type::INLINE};
  };
 
  static WidgetAlignment Vertical()
  {
    return WidgetAlignment{WidgetAlignment::Type::VERTICAL};
  };
 
  static WidgetAlignment Form(maki::WidgetGroup* widgetGroup, int width = 0, Direction dir = Direction::SPREAD)
  {
    return maki::WidgetAlignment{
        .type = maki::WidgetAlignment::Type::FORM,
        .direction = dir,
        .group = widgetGroup,
        .labelWidth = width,
    };
  };
};

class GridGroup : public QWidget
{
public:
  GridGroup(const QString& label, int rows, int cols, QWidget* parent);

  void addWidget(QWidget* widget);

  void addLayout(QLayout* layout);

  QWidget* widget() const;
 
private:
  QWidget* mContent;  
  const int mRows;    
  const int mCols;    
 
  int mCurrentRow;  
  int mCurrentCol;  
};

class WidgetGroup : public QWidget
{
  Q_OBJECT
public:
  WidgetGroup(const QString& label, QWidget* parent);
  WidgetGroup(const QString& label, oclero::qlementine::TextRole role, QWidget* parent);

  virtual void addWidget(QWidget* widget);

  virtual void addLayout(QLayout* layout);

  virtual void addSpacing(int spacing);

  virtual void addStretch();
 
  virtual void removeWidget(QWidget* widget);
  virtual void clear();
  virtual void setPadding(int padding);
 
protected:
  int mPadding;
  QWidget* mContentWidget = nullptr;
  QVBoxLayout* mContentLayout = nullptr;
};
 
class WidgetScrollGroup : public WidgetGroup
{
public:
  WidgetScrollGroup(const QString& label, QWidget* parent);
  WidgetScrollGroup(const QString& label, oclero::qlementine::TextRole role, QWidget* parent);
};
 
class InputWidget : public QWidget
{
  Q_OBJECT
public:
  InputWidget(const QString& label, QWidget* inputField, WidgetAlignment alignment, QWidget* parent = nullptr);
  virtual ~InputWidget() = default;
 
  void addDescription(const QString& text);
  void setToolTip(const QString& text);
 
  void setType(const koda::types::TypeReference& type);
  void setValue(const Value& value);
  Value getValue() const;
 
  virtual void writeValueToWidget(const Value& value) = 0;
 
  virtual QList<QWidget*> focusWidgets() const
  {
    return {mInputField};
  }
 
  bool isReference() const;
  void setReference(const QString& id);
  void clearReference();
  void setSupportedReferences(const QVector<MissionParameter>& parameters);
 
signals:
  void valueChanged();
  void openParameter(const QString& parameter);
 
protected:
  koda::types::TypeReference mType;
  Value mValue{};
  QWidget* mInputField = nullptr;
  QMenu* mParameterMenu;
  ClickableLabel* mParameterLabel = nullptr;
  QToolButton* mParameterButton = nullptr;
  QHBoxLayout* mContainerLayout = nullptr;
 
  void createReferenceWidgets();
  QWidget* createLayout(oclero::qlementine::Label* label, WidgetAlignment alignment);
};
 
template <typename W>
class TypedInputWidget : public InputWidget
{
public:
  TypedInputWidget(const QString& label, W* inputField, WidgetAlignment alignment, QWidget* parent = nullptr)
      : InputWidget(label, inputField, alignment, parent)
  {
  }
 
  W* widget() const
  {
    return qobject_cast<W*>(mInputField);
  }
};

class BooleanWidget : public TypedInputWidget<QCheckBox>
{
  Q_OBJECT
public:
  BooleanWidget(const QString& label, bool value, WidgetAlignment alignment, QWidget* parent);
 
  bool getValue() const;
  void setValue(bool value);
 
  void writeValueToWidget(const Value& value) override;
 
signals:
  void valueChanged(const bool value);
};

class StringWidget : public TypedInputWidget<oclero::qlementine::LineEdit>
{
  Q_OBJECT
public:
  StringWidget(const QString& label, const QString& placeholder, WidgetAlignment alignment, QWidget* parent);
  StringWidget(const QString& label, const QString& placeholder, WidgetAlignment alignment, const QString& tooltip, QWidget* parent);
 
  QString getValue() const;
  void setValue(const QString& value);
 
  void writeValueToWidget(const Value& value) override;
 
signals:
  void valueChanged(const QString& value);
 
private:
  QTimer* mUpdateTimer = nullptr;
};

class IntegerWidget : public TypedInputWidget<oclero::qlementine::LineEdit>
{
  Q_OBJECT
public:
  IntegerWidget(const QString& label, const QString& placeholder, WidgetAlignment alignment, QWidget* parent, int min = INT32_MIN, int max = INT32_MAX);

  void setAcceptVariable(bool accept);
 
  void writeValueToWidget(const Value& value) override;
 
  int getValue() const;
  void setValue(int value);
  void setValue(const QString& value);
 
signals:
  void valueChanged(const QString& value);
 
private:
  IntegerOrVariableValidator* mValidator;
};

class FloatWidget : public TypedInputWidget<oclero::qlementine::LineEdit>
{
  Q_OBJECT
public:
  FloatWidget(const QString& label, const QString& placeholder, WidgetAlignment alignment, QWidget* parent, qreal min = std::numeric_limits<qreal>::min(),
              qreal max = std::numeric_limits<qreal>::max());

  void setAcceptVariable(bool accept);
 
  void writeValueToWidget(const Value& value) override;
 
  double getValue() const;
  void setValue(double value);
  void setValue(const QString& value);
 
signals:
  void valueChanged(const QString& value);
 
private:
  DoubleOrVariableValidator* mValidator;
};

class SpinWidget : public TypedInputWidget<QSpinBox>
{
  Q_OBJECT
public:
  SpinWidget(const QString& label, int placeholder, QWidget* parent, WidgetAlignment alignment, int min = INT32_MIN, int max = INT32_MAX);
 
  int getValue() const;
  void setValue(int value);
 
  void writeValueToWidget(const Value& value) override;

  void setSuffix(const QString& suffix);
 
signals:
  void valueChanged(const int value);
};

class SelectorWidget : public TypedInputWidget<QComboBox>
{
  Q_OBJECT
public:
  SelectorWidget(const QString& label, WidgetAlignment alignment, QWidget* parent);

  SelectorWidget(const QString& label, QComboBox* comboBox, WidgetAlignment alignment, QWidget* parent);
 
  QVariant getData() const;
  void setData(const QString& value);
 
  QString getValue() const;
  void setValue(const QString& value);

  void addItem(const QString& name, const QVariant& value);
 
  void writeValueToWidget(const Value& value) override;
 
signals:
  void valueChanged(const QString& value);
  void dataChanged(const QString& text, const QVariant& value);
 
private:
  QVariant mData;
};

class ButtonWidget : public QWidget
{
  Q_OBJECT
public:
  ButtonWidget(const QString& label, QWidget* parent);

  void addDescription(const QString& label);

  void setIcon(const QIcon& icon);

  void setToolTip(const QString& tooltip);

  void setText(const QString& text);
 
signals:
  void valueChanged();
 
private:
  QPushButton* mInputField;  
};

class ColorWidget : public TypedInputWidget<oclero::qlementine::ColorEditor>
{
  Q_OBJECT
public:
  ColorWidget(const QString& label, const QString& placeholder, WidgetAlignment alignment, QWidget* parent);
 
  QColor getValue() const;
  void setValue(const QColor& value);
 
  void writeValueToWidget(const Value& color) override;
signals:
  void valueChanged(const QColor& value);
};

class TypeSelectionWidget : public QComboBox
{
  Q_OBJECT
public:
  TypeSelectionWidget(QWidget* parent);

  TypeSelectionWidget(const QString& initial, QWidget* parent);

  TypeSelectionWidget(const QString& initial, Types::PropertyTypes last, QWidget* parent);
};

class ContainerWidget : public TypedInputWidget<QWidget>
{
  Q_OBJECT
public:
  ContainerWidget(const QString& label, QWidget* widget, WidgetAlignment alignment, QWidget* parent);
 
  void writeValueToWidget(const Value& value) override;
};

class SearchWidget : public QWidget
{
  Q_OBJECT
public:
  SearchWidget(const QString& placeholder, QWidget* parent);

  void addDescription(const QString& label);

  void setValue(const QString& value);

  QString getValue() const;

  QLineEdit* widget() const;
 
signals:
  void valueChanged(const QString& value);

  void dismissed();
 
private:
  QLineEdit* mInputField;  
  QLabel* mIcon;           
  QString mValue;          
};
 
class ListWidget : public TypedInputWidget<WidgetGroup>
{
  Q_OBJECT
public:
  ListWidget(const QString& label, const koda::types::TypeReference& elementType, WidgetAlignment alignment, QWidget* parent = nullptr);
 
  ListValue getValue() const;
  void setValue(const ListValue& value);
 
  void writeValueToWidget(const Value& value) override;
 
  virtual QList<QWidget*> focusWidgets() const override;
 
private:
  koda::types::TypeReference mElementType;
 
  QWidget* mItems = nullptr;
  QVBoxLayout* mItemsLayout = nullptr;
 
  std::vector<InputWidget*> mEditors;
 
  void addItem(const Value& value);
  void clear();
};
 
class MapWidget : public TypedInputWidget<WidgetGroup>
{
  Q_OBJECT
public:
  MapWidget(const QString& label, const koda::types::TypeReference& keyType, const koda::types::TypeReference& valueType, WidgetAlignment alignment,
            QWidget* parent = nullptr);
 
  MapValue getValue() const;
  void setValue(const MapValue& value);
 
  void writeValueToWidget(const Value& value) override;
 
  virtual QList<QWidget*> focusWidgets() const override;
 
private:
  koda::types::TypeReference mKeyType;
  koda::types::TypeReference mValueType;
 
  QWidget* mItems = nullptr;
  QVBoxLayout* mItemsLayout = nullptr;
 
  struct MapField
  {
    InputWidget* keyEditor;
    InputWidget* valueEditor;
  };
 
  std::vector<MapField> mEditors;
 
  void addItem(const Value& key, const Value& value);
  void clear();
};
 
class RecordWidget : public TypedInputWidget<WidgetGroup>
{
  Q_OBJECT
public:
  RecordWidget(const QString& containerLabel, const QString& label, const koda::types::TypeDefinition& definition, WidgetAlignment alignment,
               QWidget* parent = nullptr);
 
  RecordValue getValue() const;
  void setValue(const RecordValue& value);
 
  void writeValueToWidget(const Value& value) override;
 
  virtual QList<QWidget*> focusWidgets() const override;
 
private:
  struct RecordField
  {
    QString id;
    InputWidget* editor;
  };
 
  std::vector<RecordField> mEditors;
  const koda::types::TypeDefinition mDefinition;
 
  void addItem(const QString& id, const Value& value);
  void clear();
};
 
class EnumWidget : public SelectorWidget
{
  Q_OBJECT
public:
  EnumWidget(const QString& label, const koda::types::TypeDefinition& definition, WidgetAlignment alignment, QWidget* parent = nullptr);
 
private:
  const koda::types::TypeDefinition mDefinition;
};
 
class ValueEditorFactory
{
public:
  static InputWidget* create(const QString& label, const koda::types::TypeReference& type, const Value& value, WidgetAlignment alignment, QWidget* parent);
};
 
}  // namespace maki