implementation classes don't inherit from UI classes

src/Gui/InputVector.cpp

@@ -256,4 +256,36 @@ void LocationDialog::on_direction_activated(int index)
     directionActivated(index);
 }
 
+// -----------------------------------------------------------
+
+LocationDialogUiImp::~LocationDialogUiImp()
+{
+    // no need to delete child widgets, Qt does it all for us
+}
+
+Base::Vector3d LocationDialogUiImp::getDirection() const
+{
+    return ui->getDirection();
+}
+
+Base::Vector3d LocationDialogUiImp::getPosition() const
+{
+    return ui->getPosition();
+}
+
+void LocationDialogUiImp::changeEvent(QEvent *e)
+{
+    if (e->type() == QEvent::LanguageChange) {
+        ui->retranslate(this);
+    }
+    else {
+        QDialog::changeEvent(e);
+    }
+}
+
+void LocationDialogUiImp::directionActivated(int index)
+{
+    ui->directionActivated(this,index);
+}
+
 #include "moc_InputVector.cpp"

src/Gui/InputVector.h

@@ -24,6 +24,8 @@
 #define GUI_INPUTVECTOR_H
 
 #include <cfloat>
+#include <memory>
+#include <boost/any.hpp>
 #include <QDialog>
 #include <QMessageBox>
 #include <QApplication>
@@ -399,6 +401,184 @@ protected:
     LocationUi<Ui> ui;
 };
 
+/**
+ * @brief The AbstractUi class
+ * Abstract base class the defines the class interface.
+ * @author Werner Mayer
+ */
+class AbstractUi
+{
+public:
+    virtual ~AbstractUi() = default;
+    virtual void retranslate(QDialog *dlg) = 0;
+    virtual void setPosition(const Base::Vector3d& v) = 0;
+    virtual Base::Vector3d getPosition() const = 0;
+    virtual Base::Vector3d getDirection() const = 0;
+    virtual void setDirection(const Base::Vector3d& dir) = 0;
+    virtual bool directionActivated(LocationDialog* dlg, int index) = 0;
+    virtual boost::any get() = 0;
+};
+
+/** This is the template class that implements the interface of AbstractUi.
+ * The template argument is the Ui interface class built by uic out of a
+ * .ui file.
+ * @author Werner Mayer
+ */
+template <class Ui>
+class LocationImpUi : public AbstractUi
+{
+public:
+    LocationImpUi(Ui* ui) : ui(ui)
+    {
+    }
+    ~LocationImpUi()
+    {
+    }
+
+    boost::any get()
+    {
+        return ui;
+    }
+
+    void retranslate(QDialog *dlg)
+    {
+        ui->retranslateUi(dlg);
+
+        if (ui->direction->count() == 0) {
+            ui->direction->insertItems(0, QStringList()
+             << QApplication::translate("Gui::LocationDialog", "X")
+             << QApplication::translate("Gui::LocationDialog", "Y")
+             << QApplication::translate("Gui::LocationDialog", "Z")
+             << QApplication::translate("Gui::LocationDialog", "User defined...")
+            );
+
+            ui->direction->setCurrentIndex(2);
+
+            // Vector3d declared to use with QVariant see Gui/propertyeditor/PropertyItem.h
+            ui->direction->setItemData(0, QVariant::fromValue<Base::Vector3d>(Base::Vector3d(1,0,0)));
+            ui->direction->setItemData(1, QVariant::fromValue<Base::Vector3d>(Base::Vector3d(0,1,0)));
+            ui->direction->setItemData(2, QVariant::fromValue<Base::Vector3d>(Base::Vector3d(0,0,1)));
+        }
+        else {
+            ui->direction->setItemText(0, QApplication::translate("Gui::LocationDialog", "X"));
+            ui->direction->setItemText(1, QApplication::translate("Gui::LocationDialog", "Y"));
+            ui->direction->setItemText(2, QApplication::translate("Gui::LocationDialog", "Z"));
+            ui->direction->setItemText(ui->direction->count()-1,
+                QApplication::translate("Gui::LocationDialog", "User defined..."));
+        }
+    }
+
+    void setPosition(const Base::Vector3d& v)
+    {
+        ui->xPos->setValue(v.x);
+        ui->yPos->setValue(v.y);
+        ui->zPos->setValue(v.z);
+    }
+
+    Base::Vector3d getPosition() const
+    {
+        return Base::Vector3d(ui->xPos->value().getValue(),
+                              ui->yPos->value().getValue(),
+                              ui->zPos->value().getValue());
+    }
+
+    Base::Vector3d getDirection() const
+    {
+        QVariant data = ui->direction->itemData (ui->direction->currentIndex());
+        if (data.canConvert<Base::Vector3d>()) {
+            return data.value<Base::Vector3d>();
+        }
+        else {
+            return Base::Vector3d(0,0,1);
+        }
+    }
+
+public:
+    void setDirection(const Base::Vector3d& dir)
+    {
+        if (dir.Length() < Base::Vector3d::epsilon()) {
+            return;
+        }
+
+        // check if the user-defined direction is already there
+        for (int i=0; i<ui->direction->count()-1; i++) {
+            QVariant data = ui->direction->itemData (i);
+            if (data.canConvert<Base::Vector3d>()) {
+                const Base::Vector3d val = data.value<Base::Vector3d>();
+                if (val == dir) {
+                    ui->direction->setCurrentIndex(i);
+                    return;
+                }
+            }
+        }
+
+        // add a new item before the very last item
+        QString display = QString::fromLatin1("(%1,%2,%3)")
+            .arg(dir.x)
+            .arg(dir.y)
+            .arg(dir.z);
+        ui->direction->insertItem(ui->direction->count()-1, display,
+            QVariant::fromValue<Base::Vector3d>(dir));
+        ui->direction->setCurrentIndex(ui->direction->count()-2);
+    }
+    bool directionActivated(LocationDialog* dlg, int index)
+    {
+        // last item is selected to define direction by user
+        if (index+1 == ui->direction->count()) {
+            bool ok;
+            Base::Vector3d dir = dlg->getUserDirection(&ok);
+            if (ok) {
+                if (dir.Length() < Base::Vector3d::epsilon()) {
+                    QMessageBox::critical(dlg, LocationDialog::tr("Wrong direction"),
+                        LocationDialog::tr("Direction must not be the null vector"));
+                    return false;
+                }
+                setDirection(dir);
+            }
+        }
+        return true;
+    }
+
+private:
+    std::shared_ptr<Ui> ui;
+};
+
+/** This is a subclass of LocationDialog using AbstractUi that implements
+ * the pure virtual methods of its base class.
+ * Other dialog-based classes can directly inherit from this class if the
+ * location-interface is required.
+ * The advantage of this class compared to LocationDialogImp is that the
+ * ui_-header file doesn't need to be included in the header file of its
+ * sub-classes because it uses "type erasure with templates".
+ * @author Werner Mayer
+ */
+class LocationDialogUiImp : public LocationDialog
+{
+public:
+    template<class T>
+    LocationDialogUiImp(T* t, QWidget* parent = 0, Qt::WindowFlags fl = 0)
+      : LocationDialog(parent, fl), ui(new LocationImpUi<T>(t))
+    {
+        std::shared_ptr<T> uit = boost::any_cast< std::shared_ptr<T> >(ui->get());
+        uit->setupUi(this);
+        ui->retranslate(this);
+    }
+    virtual ~LocationDialogUiImp();
+
+    Base::Vector3d getDirection() const;
+
+    Base::Vector3d getPosition() const;
+
+protected:
+    void changeEvent(QEvent *e);
+
+private:
+    void directionActivated(int index);
+
+protected:
+    std::unique_ptr<AbstractUi> ui;
+};
+
 } // namespace Gui
 
 #endif // GUI_INPUTVECTOR_H