propertyEditor.h

Go to the documentation of this file.

#ifndef BALL_VIEW_WIDGETS_PROPERTYEDITOR_H
#define BALL_VIEW_WIDGETS_PROPERTYEDITOR_H

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifndef BALL_DATATYPE_HASHMAP_H
# include <BALL/DATATYPE/hashMap.h>
#endif

#include <BALL/VIEW/UIC/ui_propertyEditor.h>
#include <BALL/VIEW/UIC/ui_propEditorWidget.h>
#include <BALL/VIEW/UIC/ui_editorPDBInfoDialog.h>

#ifndef BALL_FORMAT_PDBINFO_H
# include <BALL/FORMAT/PDBInfo.h>
#endif

#include <QtGui/QWidget>

class QLabel;
class QSpinBox;
class QLineEdit;
class QCheckBox;

namespace BALL
{
  class NamedProperty;
  class PropertyManager;

  namespace VIEW
  {
    class PropEditorWidget : public QWidget
    {
      Q_OBJECT

      public:
        PropEditorWidget(const std::string& name, QWidget* parent);

        virtual const QString& getName() const;

        void setEditable(bool mode);

        bool isEditable() const;

        void apply(PropertyManager* man, bool create = false);

        void reset(PropertyManager* man);

        virtual PropEditorWidget* clone(const std::string& name, QWidget* parent) = 0;

      signals:
        void deleteProperty();

        void duplicateProperty();

        void valueChanged();

      protected:
        void setupUi_();

        bool addWidget_(int i, QWidget* w);

        virtual void apply_(PropertyManager* man) = 0;

        virtual void reset_(const NamedProperty& prop) = 0;

        QString name_;
        Ui::PropEditorWidget ui_;
    };

    class BoolEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        BoolEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual BoolEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        QCheckBox* box_;
    };

    class IntEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        IntEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual IntEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);


      private:
        QSpinBox* box_;
    };

    class UIntEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        UIntEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual UIntEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        QSpinBox* box_;
    };

    class FloatEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        FloatEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual FloatEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        QLineEdit* edit_;
    };

    class DoubleEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        DoubleEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual DoubleEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        QLineEdit* edit_;
    };

    class StringEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        StringEditorWidget(const NamedProperty& prop, QWidget* parent);
        virtual StringEditorWidget* clone(const std::string& name, QWidget* parent);

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        QLineEdit* edit_;
    };

    class PropDeleteWidget : public PropEditorWidget
    {
      public:
        PropDeleteWidget(const NamedProperty& prop, QWidget* parent)
          : PropEditorWidget(prop.getName(), parent)
        {
          addWidget_(1,new QLabel(tr("(not editable)"),this));
          ui_.duplicate_button->setEnabled(false);
        }
        virtual PropEditorWidget* clone(const std::string&, QWidget*)
        {
          return NULL;
        }
      protected:
        virtual void apply_(PropertyManager *) {}
        virtual void reset_(const NamedProperty &) {}
    };

    class PDBInfoEditorWidget : public PropEditorWidget
    {
      Q_OBJECT

      public:
        PDBInfoEditorWidget(const PDBInfo& info, QWidget* parent);
        virtual PDBInfoEditorWidget* clone(const std::string& name, QWidget* parent);

      protected slots:
        void startEditorDialog();

      protected:
        virtual void apply_(PropertyManager* man);
        virtual void reset_(const NamedProperty& prop);

      private:
        // TODO: This should maybe become a generic TextEditor and not be as hackish.
        class EditorPDBInfoDialog : public QDialog {
        public:
          EditorPDBInfoDialog(QWidget* parent) : QDialog(parent)
          {
            ui_.setupUi(this);
            QFont mono("Monaco"); mono.setStyleHint(QFont::TypeWriter);
            ui_.textEditor->setFont(mono);
          }
        protected:
          friend class PDBInfoEditorWidget;
          Ui::editorPDBInfoDialog ui_;
        };

        PDBInfo localCopy_;
        EditorPDBInfoDialog* editorDialog_;
    };

    class BALL_VIEW_EXPORT PropertyEditor : public QWidget
    {
      Q_OBJECT

      public:
        explicit PropertyEditor(QWidget* parent = 0, bool editable = true);

        PropertyEditor(PropertyManager* manager, QWidget* parent, bool editable = true);

        void setPropertyManager(PropertyManager* man);

        void setEditable(bool mode);

        bool isEditable() const;

        bool hasChanges() const;

      public slots:
        void apply();

        void reset();

      signals:
        void valueChanged();

      protected:
        void setupUi_();

        PropEditorWidget* addProperty_(const NamedProperty& prop);
        PropEditorWidget* addProperty_(PropEditorWidget* editor);
        PropEditorWidget* createEditorWidget_(const NamedProperty& prop);
        QString chooseName_(const QString& initial);
        void deleteProperty_(PropEditorWidget* editor);

      protected slots:
        void scheduleDelete_();
        void scheduleDuplicate_();
        void valueChanged_();

        void createNewBool_();
        void createNewInt_();
        void createNewUInt_();
        void createNewFloat_();
        void createNewDouble_();
        void createNewString_();

      private:
        bool has_changes_;
        bool is_editable_;
        PropertyManager* manager_;
        QList<PropEditorWidget*> new_properties_;
        QList<PropEditorWidget*> deleted_properties_;

        Ui::PropertyEditor ui_;
    };

  }
}

#endif //BALL_VIEW_WIDGETS_PROPERTYEDITOR_H