/***************************************************************************
 *   Copyright (c) 2015 Stefan Tröger <stefantroeger@gmx.net>              *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#include "PreCompiled.h"

#ifndef _PreComp_
#include <Inventor/SoPickedPoint.h>
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoMarkerSet.h>

#include <sstream>

#include <QApplication>
#include <QMessageBox>
#include <QMetaMethod>
#include <QToolTip>
#endif

#include <App/Document.h>
#include <Base/Console.h>
#include <Base/UnitsApi.h>
#include <Gui/Action.h>
#include <Gui/Application.h>
#include <Gui/BitmapFactory.h>
#include <Gui/CommandT.h>
#include <Gui/Document.h>
#include <Gui/Inventor/MarkerBitmaps.h>
#include <Gui/MainWindow.h>
#include <Gui/View3DInventor.h>
#include <Gui/View3DInventorViewer.h>
#include <Mod/Fem/App/FemPostPipeline.h>

#include "ui_TaskPostClip.h"
#include "ui_TaskPostContours.h"
#include "ui_TaskPostCut.h"
#include "ui_TaskPostDataAlongLine.h"
#include "ui_TaskPostDataAtPoint.h"
#include "ui_TaskPostDisplay.h"
#include "ui_TaskPostScalarClip.h"
#include "ui_TaskPostWarpVector.h"

#include "FemSettings.h"
#include "TaskPostBoxes.h"
#include "ViewProviderFemPostFilter.h"
#include "ViewProviderFemPostFunction.h"
#include "ViewProviderFemPostObject.h"


using namespace FemGui;
using namespace Gui;

// ***************************************************************************
// point marker
PointMarker::PointMarker(Gui::View3DInventorViewer* iv, App::DocumentObject* obj)
    : connSelectPoint(QMetaObject::Connection())
    , view(iv)
    , obj(obj)
    , vp(new ViewProviderPointMarker)
{
    view->addViewProvider(vp);
}

PointMarker::~PointMarker()
{
    view->removeViewProvider(vp);
    delete vp;
}

void PointMarker::addPoint(const SbVec3f& pt)
{
    int ct = countPoints();
    vp->pCoords->point.set1Value(ct, pt);
    vp->pMarker->numPoints = ct + 1;
}

void PointMarker::clearPoints() const
{
    vp->pMarker->numPoints = 0;
    vp->pCoords->point.setNum(0);
}

int PointMarker::countPoints() const
{
    return vp->pCoords->point.getNum();
}

SbVec3f PointMarker::getPoint(int idx) const
{
    return vp->pCoords->point[idx];
}

void PointMarker::setPoint(int idx, const SbVec3f& pt) const
{
    vp->pCoords->point.set1Value(idx, pt);
}

Gui::View3DInventorViewer* PointMarker::getView() const
{
    return view;
}

App::DocumentObject* PointMarker::getObject() const
{
    return obj;
}

std::string PointMarker::ObjectInvisible()
{
    return "for amesh in App.activeDocument().Objects:\n\
    if \"Mesh\" in amesh.TypeId:\n\
         aparttoshow = amesh.Name.replace(\"_Mesh\",\"\")\n\
         for apart in App.activeDocument().Objects:\n\
             if aparttoshow == apart.Name:\n\
                 apart.ViewObject.Visibility = False\n";
}


PROPERTY_SOURCE(FemGui::ViewProviderPointMarker, Gui::ViewProviderDocumentObject)

ViewProviderPointMarker::ViewProviderPointMarker()
{
    pCoords = new SoCoordinate3();
    pCoords->ref();
    pCoords->point.setNum(0);
    pMarker = new SoMarkerSet();
    pMarker->markerIndex = Gui::Inventor::MarkerBitmaps::getMarkerIndex(
        "CIRCLE_FILLED",
        App::GetApplication()
            .GetParameterGroupByPath("User parameter:BaseApp/Preferences/View")
            ->GetInt("MarkerSize", 9));
    pMarker->numPoints = 0;
    pMarker->ref();

    SoGroup* grp = new SoGroup();
    grp->addChild(pCoords);
    grp->addChild(pMarker);
    addDisplayMaskMode(grp, "Base");
    setDisplayMaskMode("Base");
}

ViewProviderPointMarker::~ViewProviderPointMarker()
{
    pCoords->unref();
    pMarker->unref();
}


// ***************************************************************************
// DataAlongLine marker
DataAlongLineMarker::DataAlongLineMarker(Gui::View3DInventorViewer* iv,
                                         Fem::FemPostDataAlongLineFilter* obj)
    : PointMarker(iv, obj)
{}

void DataAlongLineMarker::customEvent(QEvent*)
{
    const SbVec3f& pt1 = getPoint(0);
    const SbVec3f& pt2 = getPoint(1);

    Q_EMIT PointsChanged(pt1[0], pt1[1], pt1[2], pt2[0], pt2[1], pt2[2]);
    Gui::Command::doCommand(Gui::Command::Doc,
                            "App.ActiveDocument.%s.Point1 = App.Vector(%f, %f, %f)",
                            getObject()->getNameInDocument(),
                            pt1[0],
                            pt1[1],
                            pt1[2]);
    Gui::Command::doCommand(Gui::Command::Doc,
                            "App.ActiveDocument.%s.Point2 = App.Vector(%f, %f, %f)",
                            getObject()->getNameInDocument(),
                            pt2[0],
                            pt2[1],
                            pt2[2]);
    Gui::Command::doCommand(Gui::Command::Doc, ObjectInvisible().c_str());
}


// ***************************************************************************
// DataAtPoint marker
DataAtPointMarker::DataAtPointMarker(Gui::View3DInventorViewer* iv,
                                     Fem::FemPostDataAtPointFilter* obj)
    : PointMarker(iv, obj)
{}

void DataAtPointMarker::customEvent(QEvent*)
{
    const SbVec3f& pt1 = getPoint(0);
    Q_EMIT PointsChanged(pt1[0], pt1[1], pt1[2]);
    Gui::Command::doCommand(Gui::Command::Doc,
                            "App.ActiveDocument.%s.Center = App.Vector(%f, %f, %f)",
                            getObject()->getNameInDocument(),
                            pt1[0],
                            pt1[1],
                            pt1[2]);
    Gui::Command::doCommand(Gui::Command::Doc, ObjectInvisible().c_str());
}


// ***************************************************************************
// main task dialog
TaskPostBox::TaskPostBox(Gui::ViewProviderDocumentObject* view,
                         const QPixmap& icon,
                         const QString& title,
                         QWidget* parent)
    : TaskBox(icon, title, true, parent)
    , m_object(view->getObject())
    , m_view(view)
{}

TaskPostBox::~TaskPostBox() = default;

bool TaskPostBox::autoApply()
{
    return FemSettings().getPostAutoRecompute();
}

App::Document* TaskPostBox::getDocument() const
{
    App::DocumentObject* obj = getObject();
    return (obj ? obj->getDocument() : nullptr);
}

void TaskPostBox::recompute()
{
    if (autoApply()) {
        App::Document* doc = getDocument();
        if (doc) {
            doc->recompute();
        }
    }
}

void TaskPostBox::updateEnumerationList(App::PropertyEnumeration& prop, QComboBox* box)
{
    QStringList list;
    std::vector<std::string> vec = prop.getEnumVector();
    for (auto it : vec) {
        list.push_back(QString::fromStdString(it));
    }

    int index = prop.getValue();
    // be aware the QComboxBox might be connected to the Property,
    // thus clearing the box will set back the property enumeration index too.
    // https://forum.freecad.org/viewtopic.php?f=10&t=30944
    box->clear();
    box->insertItems(0, list);
    box->setCurrentIndex(index);
}


// ***************************************************************************
// simulation dialog for the TaskView
TaskDlgPost::TaskDlgPost(Gui::ViewProviderDocumentObject* view)
    : TaskDialog()
    , m_view(view)
{
    assert(view);
}

TaskDlgPost::~TaskDlgPost() = default;

QDialogButtonBox::StandardButtons TaskDlgPost::getStandardButtons() const
{

    // check if we only have gui task boxes
    bool guionly = true;
    for (auto it : m_boxes) {
        guionly = guionly && it->isGuiTaskOnly();
    }

    if (!guionly) {
        return QDialogButtonBox::Apply | QDialogButtonBox::Ok | QDialogButtonBox::Cancel;
    }
    else {
        return QDialogButtonBox::Ok;
    }
}

void TaskDlgPost::connectSlots()
{
    // Connect emitAddedFunction() with slotAddedFunction()
    QObject* sender = nullptr;
    int indexSignal = 0;
    for (const auto dlg : m_boxes) {
        indexSignal = dlg->metaObject()->indexOfSignal(
            QMetaObject::normalizedSignature("emitAddedFunction()"));
        if (indexSignal >= 0) {
            sender = dlg;
            break;
        }
    }

    if (sender) {
        for (const auto dlg : m_boxes) {
            int indexSlot = dlg->metaObject()->indexOfSlot(
                QMetaObject::normalizedSignature("slotAddedFunction()"));
            if (indexSlot >= 0) {
                connect(sender,
                        sender->metaObject()->method(indexSignal),
                        dlg,
                        dlg->metaObject()->method(indexSlot));
            }
        }
    }
}

void TaskDlgPost::appendBox(TaskPostBox* box)
{
    m_boxes.push_back(box);
    Content.push_back(box);
}

void TaskDlgPost::open()
{
    // a transaction is already open at creation time of the pad
    QString msg = QObject::tr("Edit post processing object");
    Gui::Command::openCommand((const char*)msg.toUtf8());
}

void TaskDlgPost::clicked(int button)
{
    if (button == QDialogButtonBox::Apply) {
        recompute();
    }
}

bool TaskDlgPost::accept()
{
    try {
        std::vector<TaskPostBox*>::iterator it = m_boxes.begin();
        for (; it != m_boxes.end(); ++it) {
            (*it)->applyPythonCode();
        }
    }
    catch (const Base::Exception& e) {
        QMessageBox::warning(nullptr, tr("Input error"), QString::fromLatin1(e.what()));
        return false;
    }

    Gui::cmdGuiDocument(getDocumentName(), "resetEdit()");
    return true;
}

bool TaskDlgPost::reject()
{
    // roll back the done things
    Gui::Command::abortCommand();
    Gui::cmdGuiDocument(getDocumentName(), "resetEdit()");

    return true;
}

void TaskDlgPost::recompute()
{
    Gui::ViewProviderDocumentObject* vp = getView();
    if (vp) {
        vp->getObject()->getDocument()->recompute();
    }
}

void TaskDlgPost::modifyStandardButtons(QDialogButtonBox* box)
{

    if (box->button(QDialogButtonBox::Apply)) {
        box->button(QDialogButtonBox::Apply)->setDefault(true);
    }
}


// ***************************************************************************
// box to set the coloring
TaskPostDisplay::TaskPostDisplay(Gui::ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_ResultShow"),
                  tr("Result display options"),
                  parent)
    , ui(new Ui_TaskPostDisplay)
{
    // we need a separate container widget to add all controls to
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();

    this->groupLayout()->addWidget(proxy);

    // update all fields
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->DisplayMode,
                          ui->Representation);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);

    // get Transparency from ViewProvider
    int trans = getTypedView<ViewProviderFemPostObject>()->Transparency.getValue();
    Base::Console().Log("Transparency %i: \n", trans);
    // sync the trancparency slider
    ui->Transparency->setValue(trans);
    ui->Transparency->setToolTip(QString::number(trans) + QString::fromLatin1(" %"));
}

TaskPostDisplay::~TaskPostDisplay() = default;

void TaskPostDisplay::setupConnections()
{
    connect(ui->Representation,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDisplay::onRepresentationActivated);
    connect(ui->Field,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDisplay::onFieldActivated);
    connect(ui->VectorMode,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDisplay::onVectorModeActivated);
    connect(ui->Transparency,
            &QSlider::valueChanged,
            this,
            &TaskPostDisplay::onTransparencyValueChanged);
}

void TaskPostDisplay::slotAddedFunction()
{
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
}

void TaskPostDisplay::onRepresentationActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->DisplayMode.setValue(i);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);
}

void TaskPostDisplay::onFieldActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->Field.setValue(i);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);
}

void TaskPostDisplay::onVectorModeActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->VectorMode.setValue(i);
}

void TaskPostDisplay::onTransparencyValueChanged(int i)
{

    getTypedView<ViewProviderFemPostObject>()->Transparency.setValue(i);
    ui->Transparency->setToolTip(QString::number(i) + QString::fromLatin1(" %"));
    // highlight the tooltip
    QToolTip::showText(QCursor::pos(), QString::number(i) + QString::fromLatin1(" %"), nullptr);
}

void TaskPostDisplay::applyPythonCode()
{}


// ***************************************************************************
// functions
TaskPostFunction::TaskPostFunction(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("fem-post-geo-plane"),
                  tr("Implicit function"),
                  parent)
{
    assert(view->isDerivedFrom(ViewProviderFemPostFunction::getClassTypeId()));

    // we load the views widget
    FunctionWidget* w = getTypedView<ViewProviderFemPostFunction>()->createControlWidget();
    w->setParent(this);
    w->setViewProvider(getTypedView<ViewProviderFemPostFunction>());
    this->groupLayout()->addWidget(w);
}

TaskPostFunction::~TaskPostFunction() = default;

void TaskPostFunction::applyPythonCode()
{
    // we apply the views widgets python code
}


// ***************************************************************************
// in the following, the different filters sorted alphabetically
// ***************************************************************************


// ***************************************************************************
// data along line filter
TaskPostDataAlongLine::TaskPostDataAlongLine(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterDataAlongLine"),
                  tr("Data along a line options"),
                  parent)
    , ui(new Ui_TaskPostDataAlongLine)
    , marker(nullptr)
{
    assert(view->isDerivedFrom(ViewProviderFemPostDataAlongLine::getClassTypeId()));

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);

    setupConnectionsStep1();
    this->groupLayout()->addWidget(proxy);

    QSize size = ui->point1X->sizeForText(QStringLiteral("000000000000"));
    ui->point1X->setMinimumWidth(size.width());
    ui->point1Y->setMinimumWidth(size.width());
    ui->point1Z->setMinimumWidth(size.width());
    ui->point2X->setMinimumWidth(size.width());
    ui->point2Y->setMinimumWidth(size.width());
    ui->point2Z->setMinimumWidth(size.width());

    // set decimals before the edits are filled to avoid rounding mistakes
    int UserDecimals = Base::UnitsApi::getDecimals();
    ui->point1X->setDecimals(UserDecimals);
    ui->point1Y->setDecimals(UserDecimals);
    ui->point1Z->setDecimals(UserDecimals);
    ui->point2X->setDecimals(UserDecimals);
    ui->point2Y->setDecimals(UserDecimals);
    ui->point2Z->setDecimals(UserDecimals);

    Base::Unit lengthUnit =
        static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Point1.getUnit();
    ui->point1X->setUnit(lengthUnit);
    ui->point1Y->setUnit(lengthUnit);
    ui->point1Z->setUnit(lengthUnit);
    lengthUnit = static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Point2.getUnit();
    ui->point2X->setUnit(lengthUnit);
    ui->point2Y->setUnit(lengthUnit);
    ui->point2Z->setUnit(lengthUnit);

    const Base::Vector3d& vec1 =
        static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Point1.getValue();
    ui->point1X->setValue(vec1.x);
    ui->point1Y->setValue(vec1.y);
    ui->point1Z->setValue(vec1.z);

    const Base::Vector3d& vec2 =
        static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Point2.getValue();
    ui->point2X->setValue(vec2.x);
    ui->point2Y->setValue(vec2.y);
    ui->point2Z->setValue(vec2.z);

    int res = static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Resolution.getValue();
    ui->resolution->setValue(res);

    setupConnectionsStep2();

    // update all fields
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->DisplayMode,
                          ui->Representation);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);
}

TaskPostDataAlongLine::~TaskPostDataAlongLine()
{
    if (marker && marker->getView()) {
        marker->getView()->setEditing(false);
        marker->getView()->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                               pointCallback,
                                               marker);
    }
}

void TaskPostDataAlongLine::setupConnectionsStep1()
{
    connect(ui->SelectPoints,
            &QPushButton::clicked,
            this,
            &TaskPostDataAlongLine::onSelectPointsClicked);
    connect(ui->CreatePlot,
            &QPushButton::clicked,
            this,
            &TaskPostDataAlongLine::onCreatePlotClicked);
    connect(ui->Representation,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDataAlongLine::onRepresentationActivated);
    connect(ui->Field,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDataAlongLine::onFieldActivated);
    connect(ui->VectorMode,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDataAlongLine::onVectorModeActivated);
}

void TaskPostDataAlongLine::setupConnectionsStep2()
{
    connect(ui->point1X,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point1Changed);
    connect(ui->point1Y,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point1Changed);
    connect(ui->point1Z,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point1Changed);
    connect(ui->point2X,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point2Changed);
    connect(ui->point2Y,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point2Changed);
    connect(ui->point2Z,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::point2Changed);
    connect(ui->resolution,
            qOverload<int>(&QSpinBox::valueChanged),
            this,
            &TaskPostDataAlongLine::resolutionChanged);
}

void TaskPostDataAlongLine::applyPythonCode()
{}

static const char* cursor_triangle[] = {"32 17 3 1",
                                        "       c None",
                                        ".      c #FFFFFF",
                                        "+      c #FF0000",
                                        "      .                         ",
                                        "      .                         ",
                                        "      .                         ",
                                        "      .                         ",
                                        "      .                         ",
                                        "                                ",
                                        ".....   .....                   ",
                                        "                                ",
                                        "      .                         ",
                                        "      .                         ",
                                        "      .        ++               ",
                                        "      .       +  +              ",
                                        "      .      + ++ +             ",
                                        "            + ++++ +            ",
                                        "           +  ++ ++ +           ",
                                        "          + ++++++++ +          ",
                                        "         ++  ++  ++  ++         "};

void TaskPostDataAlongLine::onSelectPointsClicked()
{
    Gui::Command::doCommand(Gui::Command::Doc, ObjectVisible().c_str());
    auto view = static_cast<Gui::View3DInventor*>(getView()->getDocument()->getActiveView());
    if (view) {
        Gui::View3DInventorViewer* viewer = view->getViewer();
        viewer->setEditing(true);
        viewer->setEditingCursor(QCursor(QPixmap(cursor_triangle), 7, 7));

        if (!marker) {
            // Derives from QObject and we have a parent object, so we don't
            // require a delete.
            auto obj = static_cast<Fem::FemPostDataAlongLineFilter*>(getObject());
            marker = new DataAlongLineMarker(viewer, obj);
            marker->setParent(this);
        }
        else if (marker->countPoints()) {
            marker->clearPoints();
        }

        if (!marker->connSelectPoint) {
            viewer->addEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                     TaskPostDataAlongLine::pointCallback,
                                     marker);
            marker->connSelectPoint = connect(marker,
                                              &DataAlongLineMarker::PointsChanged,
                                              this,
                                              &TaskPostDataAlongLine::onChange);
        }
    }
}

std::string TaskPostDataAlongLine::ObjectVisible()
{
    return "for amesh in App.activeDocument().Objects:\n\
    if \"Mesh\" in amesh.TypeId:\n\
         aparttoshow = amesh.Name.replace(\"_Mesh\",\"\")\n\
         for apart in App.activeDocument().Objects:\n\
             if aparttoshow == apart.Name:\n\
                 apart.ViewObject.Visibility = True\n";
}

void TaskPostDataAlongLine::onCreatePlotClicked()
{
    App::DocumentObjectT objT(getObject());
    std::string ObjName = objT.getObjectPython();
    Gui::doCommandT(Gui::Command::Doc, "x = %s.XAxisData", ObjName);
    Gui::doCommandT(Gui::Command::Doc, "y = %s.YAxisData", ObjName);
    Gui::doCommandT(Gui::Command::Doc, "title = %s.PlotData", ObjName);
    Gui::doCommandT(Gui::Command::Doc, Plot().c_str());
    recompute();
}

void TaskPostDataAlongLine::onChange(double x1,
                                     double y1,
                                     double z1,
                                     double x2,
                                     double y2,
                                     double z2)
{
    // call point1Changed only once
    ui->point1X->blockSignals(true);
    ui->point1Y->blockSignals(true);
    ui->point1Z->blockSignals(true);
    ui->point1X->setValue(x1);
    ui->point1Y->setValue(y1);
    ui->point1Z->setValue(z1);
    ui->point1X->blockSignals(false);
    ui->point1Y->blockSignals(false);
    ui->point1Z->blockSignals(false);
    point1Changed(0.0);

    // same for point 2
    ui->point2X->blockSignals(true);
    ui->point2Y->blockSignals(true);
    ui->point2Z->blockSignals(true);
    ui->point2X->setValue(x2);
    ui->point2Y->setValue(y2);
    ui->point2Z->setValue(z2);
    ui->point2X->blockSignals(false);
    ui->point2Y->blockSignals(false);
    ui->point2Z->blockSignals(false);
    point2Changed(0.0);

    if (marker && marker->getView()) {
        // leave mode
        marker->getView()->setEditing(false);
        marker->getView()->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                               TaskPostDataAlongLine::pointCallback,
                                               marker);
        disconnect(marker->connSelectPoint);
    }
}

void TaskPostDataAlongLine::point1Changed(double)
{
    try {
        SbVec3f vec(ui->point1X->value().getValue(),
                    ui->point1Y->value().getValue(),
                    ui->point1Z->value().getValue());
        std::string ObjName = getObject()->getNameInDocument();
        Gui::cmdAppDocumentArgs(getDocument(),
                                "%s.Point1 = App.Vector(%f, %f, %f)",
                                ObjName,
                                vec[0],
                                vec[1],
                                vec[2]);

        if (marker && marker->countPoints() > 0) {
            marker->setPoint(0, vec);
        }

        // recompute the feature to fill all fields with data at this point
        getObject()->recomputeFeature();
        // refresh the color bar range
        auto currentField = getTypedView<ViewProviderFemPostObject>()->Field.getValue();
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(currentField);
        // also the axis data must be refreshed to get correct plots
        static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->GetAxisData();
    }
    catch (const Base::Exception& e) {
        e.ReportException();
    }
}

void TaskPostDataAlongLine::point2Changed(double)
{
    try {
        SbVec3f vec(ui->point2X->value().getValue(),
                    ui->point2Y->value().getValue(),
                    ui->point2Z->value().getValue());
        std::string ObjName = getObject()->getNameInDocument();
        Gui::cmdAppDocumentArgs(getDocument(),
                                "%s.Point2 = App.Vector(%f, %f, %f)",
                                ObjName,
                                vec[0],
                                vec[1],
                                vec[2]);

        if (marker && marker->countPoints() > 1) {
            marker->setPoint(1, vec);
        }

        // recompute the feature to fill all fields with data at this point
        getObject()->recomputeFeature();
        // refresh the color bar range
        auto currentField = getTypedView<ViewProviderFemPostObject>()->Field.getValue();
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(currentField);
        // also the axis data must be refreshed to get correct plots
        static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->GetAxisData();
    }
    catch (const Base::Exception& e) {
        e.what();
    }
}

void TaskPostDataAlongLine::resolutionChanged(int val)
{
    static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->Resolution.setValue(val);
    // recompute the feature
    getObject()->recomputeFeature();
    // axis data must be refreshed
    static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->GetAxisData();
    // eventually a full recompute is necessary
    getView()->getObject()->getDocument()->recompute();
}

void TaskPostDataAlongLine::pointCallback(void* ud, SoEventCallback* n)
{
    const SoMouseButtonEvent* mbe = static_cast<const SoMouseButtonEvent*>(n->getEvent());
    Gui::View3DInventorViewer* view = static_cast<Gui::View3DInventorViewer*>(n->getUserData());
    PointMarker* pm = static_cast<PointMarker*>(ud);

    // Mark all incoming mouse button events as handled, especially,
    // to deactivate the selection node
    n->getAction()->setHandled();

    if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 && mbe->getState() == SoButtonEvent::DOWN) {
        const SoPickedPoint* point = n->getPickedPoint();
        if (!point) {
            Base::Console().Message("No point picked.\n");
            return;
        }

        n->setHandled();
        if (pm->countPoints() < 2) {
            pm->addPoint(point->getPoint());
        }

        if (pm->countPoints() == 2) {
            QEvent* e = new QEvent(QEvent::User);
            QApplication::postEvent(pm, e);
        }
    }
    else if (mbe->getButton() != SoMouseButtonEvent::BUTTON1
             && mbe->getState() == SoButtonEvent::UP) {
        n->setHandled();
        view->setEditing(false);
        view->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                  TaskPostDataAlongLine::pointCallback,
                                  ud);
        disconnect(pm->connSelectPoint);
    }
}

void TaskPostDataAlongLine::onRepresentationActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->DisplayMode.setValue(i);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);
}

void TaskPostDataAlongLine::onFieldActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->Field.setValue(i);
    std::string FieldName = ui->Field->currentText().toStdString();
    static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->PlotData.setValue(FieldName);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->VectorMode, ui->VectorMode);

    auto vecMode = static_cast<ViewProviderFemPostObject*>(getView())->VectorMode.getEnum();
    static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->PlotDataComponent.setValue(vecMode);
}

void TaskPostDataAlongLine::onVectorModeActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->VectorMode.setValue(i);
    int comp = ui->VectorMode->currentIndex();
    static_cast<Fem::FemPostDataAlongLineFilter*>(getObject())->PlotDataComponent.setValue(comp);
}

std::string TaskPostDataAlongLine::Plot()
{
    auto obj = static_cast<Fem::FemPostDataAlongLineFilter*>(getObject());
    std::string yLabel;
    // if there is only one component, it is the magnitude
    if (obj->PlotDataComponent.getEnum().maxValue() < 1) {
        yLabel = "Magnitude";
    }
    else {
        yLabel = obj->PlotDataComponent.getValueAsString();
    }

    auto xlabel = tr("Length", "X-Axis plot label");
    std::ostringstream oss;
    oss << "import FreeCAD\n\
from PySide import QtCore\n\
import numpy as np\n\
from matplotlib import pyplot as plt\n\
plt.ioff()\n\
plt.figure(title)\n\
plt.plot(x, y)\n\
plt.xlabel(\""
        << xlabel.toStdString() << "\")\n\
plt.ylabel(\""
        << yLabel << "\")\n\
plt.title(title)\n\
plt.grid()\n\
fig_manager = plt.get_current_fig_manager()\n\
fig_manager.window.setParent(FreeCADGui.getMainWindow())\n\
fig_manager.window.setWindowFlag(QtCore.Qt.Tool)\n\
plt.show()\n";

    return oss.str();
}


// ***************************************************************************
// data at point filter
TaskPostDataAtPoint::TaskPostDataAtPoint(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterDataAtPoint"),
                  tr("Data at point options"),
                  parent)
    , ui(new Ui_TaskPostDataAtPoint)
    , marker(nullptr)
{
    assert(view->isDerivedFrom(ViewProviderFemPostDataAtPoint::getClassTypeId()));

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();

    this->groupLayout()->addWidget(proxy);

    QSize size = ui->centerX->sizeForText(QStringLiteral("000000000000"));
    ui->centerX->setMinimumWidth(size.width());
    ui->centerY->setMinimumWidth(size.width());
    ui->centerZ->setMinimumWidth(size.width());

    // set decimals before the edits are filled to avoid rounding mistakes
    int UserDecimals = Base::UnitsApi::getDecimals();
    ui->centerX->setDecimals(UserDecimals);
    ui->centerY->setDecimals(UserDecimals);
    ui->centerZ->setDecimals(UserDecimals);

    const Base::Unit lengthUnit =
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Center.getUnit();
    ui->centerX->setUnit(lengthUnit);
    ui->centerY->setUnit(lengthUnit);
    ui->centerZ->setUnit(lengthUnit);

    const Base::Vector3d& vec =
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Center.getValue();
    ui->centerX->setValue(vec.x);
    ui->centerY->setValue(vec.y);
    ui->centerZ->setValue(vec.z);

    // update all fields
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);

    // read in point value
    auto pointValue = static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->PointData[0];
    showValue(pointValue,
              static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.getValue());

    connect(ui->centerX,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAtPoint::centerChanged);
    connect(ui->centerY,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAtPoint::centerChanged);
    connect(ui->centerZ,
            qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
            this,
            &TaskPostDataAtPoint::centerChanged);

    // the point filter object needs to be recomputed
    // to fill all fields with data at the current point
    getObject()->recomputeFeature();
}

TaskPostDataAtPoint::~TaskPostDataAtPoint()
{
    App::Document* doc = getDocument();
    if (doc) {
        doc->recompute();
    }
    if (marker && marker->getView()) {
        marker->getView()->setEditing(false);
        marker->getView()->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                               pointCallback,
                                               marker);
    }
}

void TaskPostDataAtPoint::setupConnections()
{
    connect(ui->SelectPoint,
            &QPushButton::clicked,
            this,
            &TaskPostDataAtPoint::onSelectPointClicked);
    connect(ui->Field,
            qOverload<int>(&QComboBox::activated),
            this,
            &TaskPostDataAtPoint::onFieldActivated);
}

void TaskPostDataAtPoint::applyPythonCode()
{}

void TaskPostDataAtPoint::onSelectPointClicked()
{
    Gui::Command::doCommand(Gui::Command::Doc, ObjectVisible().c_str());
    auto view = static_cast<Gui::View3DInventor*>(getView()->getDocument()->getActiveView());
    if (view) {
        Gui::View3DInventorViewer* viewer = view->getViewer();
        viewer->setEditing(true);
        viewer->setEditingCursor(QCursor(QPixmap(cursor_triangle), 7, 7));

        if (!marker) {
            // Derives from QObject and we have a parent object, so we don't
            // require a delete.
            auto obj = static_cast<Fem::FemPostDataAtPointFilter*>(getObject());
            marker = new DataAtPointMarker(viewer, obj);
            marker->setParent(this);
        }

        if (!marker->connSelectPoint) {
            viewer->addEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                     TaskPostDataAtPoint::pointCallback,
                                     marker);
            marker->connSelectPoint = connect(marker,
                                              &DataAtPointMarker::PointsChanged,
                                              this,
                                              &TaskPostDataAtPoint::onChange);
        }
    }
    getTypedView<ViewProviderFemPostObject>()->DisplayMode.setValue(1);
    updateEnumerationList(getTypedView<ViewProviderFemPostObject>()->Field, ui->Field);
}

std::string TaskPostDataAtPoint::ObjectVisible()
{
    return "for amesh in App.activeDocument().Objects:\n\
    if \"Mesh\" in amesh.TypeId:\n\
         aparttoshow = amesh.Name.replace(\"_Mesh\",\"\")\n\
         for apart in App.activeDocument().Objects:\n\
             if aparttoshow == apart.Name:\n\
                 apart.ViewObject.Visibility = True\n";
}

void TaskPostDataAtPoint::onChange(double x, double y, double z)
{
    // call centerChanged only once
    ui->centerX->blockSignals(true);
    ui->centerY->blockSignals(true);
    ui->centerZ->blockSignals(true);
    ui->centerX->setValue(x);
    ui->centerY->setValue(y);
    ui->centerZ->setValue(z);
    ui->centerX->blockSignals(false);
    ui->centerY->blockSignals(false);
    ui->centerZ->blockSignals(false);
    centerChanged(0.0);
    if (marker && marker->getView()) {
        // leave mode
        marker->getView()->setEditing(false);
        marker->getView()->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                               TaskPostDataAtPoint::pointCallback,
                                               marker);
        disconnect(marker->connSelectPoint);
    }
}

void TaskPostDataAtPoint::centerChanged(double)
{
    try {
        std::string ObjName = getObject()->getNameInDocument();
        Gui::cmdAppDocumentArgs(getDocument(),
                                "%s.Center = App.Vector(%f, %f, %f)",
                                ObjName,
                                ui->centerX->value().getValue(),
                                ui->centerY->value().getValue(),
                                ui->centerZ->value().getValue());

        if (marker && marker->countPoints() == 1) {
            SbVec3f vec(ui->centerX->value().getValue(),
                        ui->centerY->value().getValue(),
                        ui->centerZ->value().getValue());
            marker->setPoint(0, vec);
        }
        // recompute the feature to fill all fields with data at this point
        getObject()->recomputeFeature();
        // show the data dialog by calling on_Field_activated with the field that is currently set
        auto currentField = getTypedView<ViewProviderFemPostObject>()->Field.getValue();
        onFieldActivated(currentField);
    }
    catch (const Base::Exception& e) {
        e.ReportException();
    }
}

void TaskPostDataAtPoint::pointCallback(void* ud, SoEventCallback* n)
{
    const SoMouseButtonEvent* mbe = static_cast<const SoMouseButtonEvent*>(n->getEvent());
    Gui::View3DInventorViewer* view = static_cast<Gui::View3DInventorViewer*>(n->getUserData());
    PointMarker* pm = static_cast<PointMarker*>(ud);

    // Mark all incoming mouse button events as handled, especially,
    // to deactivate the selection node
    n->getAction()->setHandled();

    if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 && mbe->getState() == SoButtonEvent::DOWN) {
        const SoPickedPoint* point = n->getPickedPoint();
        if (!point) {
            Base::Console().Message("No point picked.\n");
            return;
        }

        n->setHandled();
        if (pm->countPoints() < 2) {
            if (pm->countPoints() == 0) {
                pm->addPoint(point->getPoint());
            }
            else {
                pm->setPoint(0, point->getPoint());
            }

            QEvent* e = new QEvent(QEvent::User);
            QApplication::postEvent(pm, e);
        }
    }
    else if (mbe->getButton() != SoMouseButtonEvent::BUTTON1
             && mbe->getState() == SoButtonEvent::UP) {
        n->setHandled();
        view->setEditing(false);
        view->removeEventCallback(SoMouseButtonEvent::getClassTypeId(),
                                  TaskPostDataAtPoint::pointCallback,
                                  ud);
        disconnect(pm->connSelectPoint);
    }
}

void TaskPostDataAtPoint::onFieldActivated(int i)
{
    getTypedView<ViewProviderFemPostObject>()->Field.setValue(i);
    std::string FieldName = ui->Field->currentText().toStdString();
    // there is no "None" for the FieldName property, thus return here
    if (FieldName == "None") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("");
        ui->ValueAtPoint->clear();
        return;
    }
    static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->FieldName.setValue(FieldName);

    // Set the unit for the different known result types.

    //  CCX names
    if ((FieldName == "von Mises Stress") || (FieldName == "Tresca Stress")
        || (FieldName == "Major Principal Stress") || (FieldName == "Intermediate Principal Stress")
        || (FieldName == "Minor Principal Stress") || (FieldName == "Major Principal Stress Vector")
        || (FieldName == "Intermediate Principal Stress Vector")
        || (FieldName == "Minor Principal Stress Vector") || (FieldName == "Stress xx component")
        || (FieldName == "Stress xy component") || (FieldName == "Stress xz component")
        || (FieldName == "Stress yy component") || (FieldName == "Stress yz component")
        || (FieldName == "Stress zz component")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("Pa");
    }
    // The Elmer names are different. If there are EigenModes, the names are unique for
    // every mode. Therefore we only check for the beginning of the name.
    else if ((FieldName.find("tresca", 0) == 0) || (FieldName.find("vonmises", 0) == 0)
             || (FieldName.find("stress_", 0) == 0)
             || (FieldName.find("principal stress", 0) == 0)) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("Pa");
    }
    else if ((FieldName == "current density") || (FieldName == "current density re")
             || (FieldName == "current density im") || (FieldName == "current density abs")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("A/m^2");
    }
    else if ((FieldName == "Displacement") || (FieldName == "Displacement Magnitude")
             || (FieldName.find("displacement", 0) == 0)) {  // Elmer name
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("m");
    }
    else if (FieldName == "electric energy density") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("J/m^3");
    }
    else if ((FieldName == "electric field") || (FieldName == "electric field re")
             || (FieldName == "electric field im") || (FieldName == "electric field abs")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("V/m");
    }
    else if (FieldName == "electric flux") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("A*s/m^2");
    }
    else if (FieldName == "electric force density") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("N/m^2");
    }
    else if ((FieldName == "harmonic loss linear") || (FieldName == "harmonic loss quadratic")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("W");
    }
    else if ((FieldName == "joule heating") || (FieldName == "nodal joule heating")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("J");
    }
    else if ((FieldName == "magnetic field strength") || (FieldName == "magnetic field strength re")
             || (FieldName == "magnetic field strength im")
             || (FieldName == "magnetic field strength abs")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("A/m");
    }
    else if ((FieldName == "magnetic flux density") || (FieldName == "magnetic flux density re")
             || (FieldName == "magnetic flux density im")
             || (FieldName == "magnetic flux density abs")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("T");
    }
    else if ((FieldName == "maxwell stress 1") || (FieldName == "maxwell stress 2")
             || (FieldName == "maxwell stress 3") || (FieldName == "maxwell stress 4")
             || (FieldName == "maxwell stress 5") || (FieldName == "maxwell stress 6")
             || (FieldName == "maxwell stress re 1") || (FieldName == "maxwell stress re 2")
             || (FieldName == "maxwell stress re 3") || (FieldName == "maxwell stress re 4")
             || (FieldName == "maxwell stress re 5") || (FieldName == "maxwell stress re 6")
             || (FieldName == "maxwell stress im 1") || (FieldName == "maxwell stress im 2")
             || (FieldName == "maxwell stress im 3") || (FieldName == "maxwell stress im 4")
             || (FieldName == "maxwell stress im 5") || (FieldName == "maxwell stress im 6")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("As/m^3");
    }
    else if (FieldName == "nodal force") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("N");
    }
    else if ((FieldName == "potential") || (FieldName == "potential re")
             || (FieldName == "potential im") || (FieldName == "potential abs")
             || (FieldName == "av") || (FieldName == "av re") || (FieldName == "av im")
             || (FieldName == "av abs")) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("V");
    }
    else if (FieldName == "potential flux") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("W/m^2");
    }
    // potential loads are in Coulomb: https://www.elmerfem.org/forum/viewtopic.php?t=7780
    else if (FieldName == "potential loads") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("C");
    }
    else if (
        // CalculiX name
        FieldName == "Temperature" ||
        // Elmer name
        ((FieldName.find("temperature", 0) == 0) && (FieldName != "temperature flux"))) {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("K");
    }
    else if (FieldName == "temperature flux") {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("W/m^2");
    }
    else {
        static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.setValue("");
    }

    auto pointValue = static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->PointData[0];
    showValue(pointValue,
              static_cast<Fem::FemPostDataAtPointFilter*>(getObject())->Unit.getValue());
}

void TaskPostDataAtPoint::showValue(double pointValue, const char* unitStr)
{
    QString value = QString::fromStdString(toString(pointValue));
    QString unit = QString::fromUtf8(unitStr);

    ui->ValueAtPoint->setText(QString::fromLatin1("%1 %2").arg(value, unit));

    QString field = ui->Field->currentText();
    QString posX = ui->centerX->text();
    QString posY = ui->centerY->text();
    QString posZ = ui->centerZ->text();

    QString result = tr("%1 at (%2; %3; %4) is: %5 %6").arg(field, posX, posY, posZ, value, unit);
    Base::Console().Message("%s\n", result.toUtf8().data());
}

std::string TaskPostDataAtPoint::toString(double val) const
{
    // for display we must therefore convert large and small numbers to scientific notation
    // if pointValue is in the range [1e-2, 1e+4] -> fixed notation, else scientific
    bool scientific = (val < 1e-2) || (val > 1e4);
    std::ios::fmtflags flags = scientific
        ? (std::ios::scientific | std::ios::showpoint | std::ios::showpos)
        : (std::ios::fixed | std::ios::showpoint | std::ios::showpos);
    std::stringstream valueStream;
    valueStream.precision(Base::UnitsApi::getDecimals());
    valueStream.setf(flags);
    valueStream << val;

    return valueStream.str();
}


// ***************************************************************************
// clip filter
TaskPostClip::TaskPostClip(ViewProviderDocumentObject* view,
                           App::PropertyLink* function,
                           QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterClipRegion"),
                  tr("Clip region, choose implicit function"),
                  parent)
    , ui(new Ui_TaskPostClip)
{
    assert(view->isDerivedFrom(ViewProviderFemPostClip::getClassTypeId()));
    assert(function);
    Q_UNUSED(function);

    fwidget = nullptr;

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();
    this->groupLayout()->addWidget(proxy);

    // the layout for the container widget
    QVBoxLayout* layout = new QVBoxLayout();
    ui->Container->setLayout(layout);

    // fill up the combo box with possible functions
    collectImplicitFunctions();

    // add the function creation command
    Gui::CommandManager& rcCmdMgr = Gui::Application::Instance->commandManager();
    Gui::Command* cmd = rcCmdMgr.getCommandByName("FEM_PostCreateFunctions");
    if (cmd && cmd->getAction()) {
        cmd->getAction()->addTo(ui->CreateButton);
    }
    ui->CreateButton->setPopupMode(QToolButton::InstantPopup);

    // load the default values
    ui->CutCells->setChecked(
        static_cast<Fem::FemPostClipFilter*>(getObject())->CutCells.getValue());
    ui->InsideOut->setChecked(
        static_cast<Fem::FemPostClipFilter*>(getObject())->InsideOut.getValue());
}

TaskPostClip::~TaskPostClip() = default;

void TaskPostClip::setupConnections()
{
    connect(ui->CreateButton,
            &QToolButton::triggered,
            this,
            &TaskPostClip::onCreateButtonTriggered);
    connect(ui->FunctionBox,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostClip::onFunctionBoxCurrentIndexChanged);
    connect(ui->InsideOut, &QCheckBox::toggled, this, &TaskPostClip::onInsideOutToggled);
    connect(ui->CutCells, &QCheckBox::toggled, this, &TaskPostClip::onCutCellsToggled);
}

void TaskPostClip::applyPythonCode()
{}

void TaskPostClip::collectImplicitFunctions()
{
    std::vector<Fem::FemPostPipeline*> pipelines;
    pipelines = getDocument()->getObjectsOfType<Fem::FemPostPipeline>();
    if (!pipelines.empty()) {
        Fem::FemPostPipeline* pipeline = pipelines.front();
        if (pipeline->Functions.getValue()
            && pipeline->Functions.getValue()->getTypeId()
                == Fem::FemPostFunctionProvider::getClassTypeId()) {

            ui->FunctionBox->clear();
            QStringList items;
            std::size_t currentItem = 0;
            App::DocumentObject* currentFunction =
                static_cast<Fem::FemPostClipFilter*>(getObject())->Function.getValue();
            const std::vector<App::DocumentObject*>& funcs =
                static_cast<Fem::FemPostFunctionProvider*>(pipeline->Functions.getValue())
                    ->Functions.getValues();
            for (std::size_t i = 0; i < funcs.size(); ++i) {
                items.push_back(QString::fromLatin1(funcs[i]->getNameInDocument()));
                if (currentFunction == funcs[i]) {
                    currentItem = i;
                }
            }
            ui->FunctionBox->addItems(items);
            ui->FunctionBox->setCurrentIndex(currentItem);
        }
    }
}

void TaskPostClip::onCreateButtonTriggered(QAction*)
{
    int numFuncs = ui->FunctionBox->count();
    int currentItem = ui->FunctionBox->currentIndex();
    collectImplicitFunctions();

    // if a new function was successfully added use it
    int indexCount = ui->FunctionBox->count();
    if (indexCount > currentItem + 1) {
        ui->FunctionBox->setCurrentIndex(indexCount - 1);
    }

    // When the first function ever was added, a signal must be emitted
    if (numFuncs == 0) {
        Q_EMIT emitAddedFunction();
    }

    recompute();
}

void TaskPostClip::onFunctionBoxCurrentIndexChanged(int idx)
{
    // set the correct property
    std::vector<Fem::FemPostPipeline*> pipelines;
    pipelines = getDocument()->getObjectsOfType<Fem::FemPostPipeline>();
    if (!pipelines.empty()) {
        Fem::FemPostPipeline* pipeline = pipelines.front();
        if (pipeline->Functions.getValue()
            && pipeline->Functions.getValue()->getTypeId()
                == Fem::FemPostFunctionProvider::getClassTypeId()) {

            const std::vector<App::DocumentObject*>& funcs =
                static_cast<Fem::FemPostFunctionProvider*>(pipeline->Functions.getValue())
                    ->Functions.getValues();
            if (idx >= 0) {
                static_cast<Fem::FemPostClipFilter*>(getObject())->Function.setValue(funcs[idx]);
            }
            else {
                static_cast<Fem::FemPostClipFilter*>(getObject())->Function.setValue(nullptr);
            }
        }
    }

    // load the correct view
    Fem::FemPostFunction* fobj = static_cast<Fem::FemPostFunction*>(
        static_cast<Fem::FemPostClipFilter*>(getObject())->Function.getValue());
    Gui::ViewProvider* view = nullptr;
    if (fobj) {
        view = Gui::Application::Instance->getViewProvider(fobj);
    }

    if (fwidget) {
        fwidget->deleteLater();
    }

    if (view) {
        fwidget = static_cast<FemGui::ViewProviderFemPostFunction*>(view)->createControlWidget();
        fwidget->setParent(ui->Container);
        fwidget->setViewProvider(static_cast<FemGui::ViewProviderFemPostFunction*>(view));
        ui->Container->layout()->addWidget(fwidget);
    }
    recompute();
}

void TaskPostClip::onCutCellsToggled(bool val)
{
    static_cast<Fem::FemPostClipFilter*>(getObject())->CutCells.setValue(val);
    recompute();
}

void TaskPostClip::onInsideOutToggled(bool val)
{
    static_cast<Fem::FemPostClipFilter*>(getObject())->InsideOut.setValue(val);
    recompute();
}


// ***************************************************************************
// contours filter
TaskPostContours::TaskPostContours(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterContours"),
                  tr("Contours filter options"),
                  parent)
    , ui(new Ui_TaskPostContours)
{
    assert(view->isDerivedFrom(ViewProviderFemPostContours::getClassTypeId()));

    // load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    QMetaObject::connectSlotsByName(this);
    this->groupLayout()->addWidget(proxy);

    // load filter settings
    updateEnumerationList(getTypedObject<Fem::FemPostContoursFilter>()->Field, ui->fieldsCB);
    updateEnumerationList(getTypedObject<Fem::FemPostContoursFilter>()->VectorMode, ui->vectorsCB);
    // for a new filter, initialize the coloring
    auto colorState = static_cast<Fem::FemPostContoursFilter*>(getObject())->NoColor.getValue();
    if (!colorState && getTypedView<ViewProviderFemPostObject>()->Field.getValue() == 0) {
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(1);
    }

    ui->numberContoursSB->setValue(
        static_cast<Fem::FemPostContoursFilter*>(getObject())->NumberOfContours.getValue());
    ui->noColorCB->setChecked(colorState);

    // connect
    connect(ui->fieldsCB,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostContours::onFieldsChanged);
    connect(ui->vectorsCB,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostContours::onVectorModeChanged);
    connect(ui->numberContoursSB,
            qOverload<int>(&QSpinBox::valueChanged),
            this,
            &TaskPostContours::onNumberOfContoursChanged);
    connect(ui->noColorCB, &QCheckBox::toggled, this, &TaskPostContours::onNoColorChanged);
}

TaskPostContours::~TaskPostContours() = default;

void TaskPostContours::applyPythonCode()
{}

void TaskPostContours::updateFields()
{
    // update the ViewProvider Field
    // since the ViewProvider can have another field sorting, we cannot use the same index
    if (!static_cast<Fem::FemPostContoursFilter*>(getObject())->NoColor.getValue()) {
        std::string objectField =
            getTypedObject<Fem::FemPostContoursFilter>()->Field.getValueAsString();
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(objectField.c_str());
    }
    else {
        getTypedView<ViewProviderFemPostObject>()->Field.setValue("None");
    }
}

void TaskPostContours::onFieldsChanged(int idx)
{
    static_cast<Fem::FemPostContoursFilter*>(getObject())->Field.setValue(idx);

    blockVectorUpdate = true;
    updateEnumerationList(getTypedObject<Fem::FemPostContoursFilter>()->VectorMode, ui->vectorsCB);
    blockVectorUpdate = false;

    // In > 99 % of the cases the coloring should be equal to the field,
    // thus change the coloring field too. Users can override this be resetting only the coloring
    // field afterwards in the properties if really necessary.
    updateFields();

    // since a new field can be e.g. no vector while the previous one was,
    // we must also update the VectorMode
    if (!static_cast<Fem::FemPostContoursFilter*>(getObject())->NoColor.getValue()) {
        auto newMode = getTypedObject<Fem::FemPostContoursFilter>()->VectorMode.getValue();
        getTypedView<ViewProviderFemPostObject>()->VectorMode.setValue(newMode);
    }
}

void TaskPostContours::onVectorModeChanged(int idx)
{
    static_cast<Fem::FemPostContoursFilter*>(getObject())->VectorMode.setValue(idx);
    recompute();
    if (!blockVectorUpdate) {
        // we can have the case that the previous field had VectorMode "Z" but
        // since it is a 2D field, Z is eompty thus no field is available to color
        // when the user noch goes back to e.g. "Y" we must set the Field
        // first to get the possible VectorModes of that field
        updateFields();
        // now we can set the VectorMode
        if (!static_cast<Fem::FemPostContoursFilter*>(getObject())->NoColor.getValue()) {
            getTypedView<ViewProviderFemPostObject>()->VectorMode.setValue(idx);
        }
    }
}

void TaskPostContours::onNumberOfContoursChanged(int number)
{
    static_cast<Fem::FemPostContoursFilter*>(getObject())->NumberOfContours.setValue(number);
    recompute();
}

void TaskPostContours::onNoColorChanged(bool state)
{
    static_cast<Fem::FemPostContoursFilter*>(getObject())->NoColor.setValue(state);
    if (state) {
        // no color
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(long(0));
    }
    else {
        // set same field
        auto currentField = getTypedObject<Fem::FemPostContoursFilter>()->Field.getValue();
        // the ViewProvider field starts with an additional entry "None",
        // therefore the desired new setting is idx + 1
        getTypedView<ViewProviderFemPostObject>()->Field.setValue(currentField + 1);
        // set the VectorMode too
        auto currentMode = getTypedObject<Fem::FemPostContoursFilter>()->VectorMode.getValue();
        getTypedView<ViewProviderFemPostObject>()->VectorMode.setValue(currentMode);
    }
    recompute();
}


// ***************************************************************************
// cut filter
TaskPostCut::TaskPostCut(ViewProviderDocumentObject* view,
                         App::PropertyLink* function,
                         QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterCutFunction"),
                  tr("Function cut, choose implicit function"),
                  parent)
    , ui(new Ui_TaskPostCut)
{
    assert(view->isDerivedFrom(ViewProviderFemPostCut::getClassTypeId()));
    assert(function);
    Q_UNUSED(function)

    fwidget = nullptr;

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();
    this->groupLayout()->addWidget(proxy);

    // the layout for the container widget
    QVBoxLayout* layout = new QVBoxLayout();
    ui->Container->setLayout(layout);

    // fill up the combo box with possible functions
    collectImplicitFunctions();

    // add the function creation command
    Gui::CommandManager& rcCmdMgr = Gui::Application::Instance->commandManager();
    Gui::Command* cmd = rcCmdMgr.getCommandByName("FEM_PostCreateFunctions");
    if (cmd && cmd->getAction()) {
        cmd->getAction()->addTo(ui->CreateButton);
    }
    ui->CreateButton->setPopupMode(QToolButton::InstantPopup);
}

TaskPostCut::~TaskPostCut() = default;

void TaskPostCut::setupConnections()
{
    connect(ui->CreateButton, &QToolButton::triggered, this, &TaskPostCut::onCreateButtonTriggered);
    connect(ui->FunctionBox,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostCut::onFunctionBoxCurrentIndexChanged);
}

void TaskPostCut::applyPythonCode()
{}

void TaskPostCut::collectImplicitFunctions()
{
    std::vector<Fem::FemPostPipeline*> pipelines;
    pipelines = getDocument()->getObjectsOfType<Fem::FemPostPipeline>();
    if (!pipelines.empty()) {
        Fem::FemPostPipeline* pipeline = pipelines.front();
        if (pipeline->Functions.getValue()
            && pipeline->Functions.getValue()->getTypeId()
                == Fem::FemPostFunctionProvider::getClassTypeId()) {

            ui->FunctionBox->clear();
            QStringList items;
            std::size_t currentItem = 0;
            App::DocumentObject* currentFunction =
                static_cast<Fem::FemPostClipFilter*>(getObject())->Function.getValue();
            const std::vector<App::DocumentObject*>& funcs =
                static_cast<Fem::FemPostFunctionProvider*>(pipeline->Functions.getValue())
                    ->Functions.getValues();
            for (std::size_t i = 0; i < funcs.size(); ++i) {
                items.push_back(QString::fromLatin1(funcs[i]->getNameInDocument()));
                if (currentFunction == funcs[i]) {
                    currentItem = i;
                }
            }
            ui->FunctionBox->addItems(items);
            ui->FunctionBox->setCurrentIndex(currentItem);
        }
    }
}

void TaskPostCut::onCreateButtonTriggered(QAction*)
{
    int numFuncs = ui->FunctionBox->count();
    int currentItem = ui->FunctionBox->currentIndex();
    collectImplicitFunctions();

    // if a new function was successfully added use it
    int indexCount = ui->FunctionBox->count();
    if (indexCount > currentItem + 1) {
        ui->FunctionBox->setCurrentIndex(indexCount - 1);
    }

    // When the first function ever was added, a signal must be emitted
    if (numFuncs == 0) {
        Q_EMIT emitAddedFunction();
    }

    recompute();
}

void TaskPostCut::onFunctionBoxCurrentIndexChanged(int idx)
{
    // set the correct property
    std::vector<Fem::FemPostPipeline*> pipelines;
    pipelines = getDocument()->getObjectsOfType<Fem::FemPostPipeline>();
    if (!pipelines.empty()) {
        Fem::FemPostPipeline* pipeline = pipelines.front();
        if (pipeline->Functions.getValue()
            && pipeline->Functions.getValue()->getTypeId()
                == Fem::FemPostFunctionProvider::getClassTypeId()) {

            const std::vector<App::DocumentObject*>& funcs =
                static_cast<Fem::FemPostFunctionProvider*>(pipeline->Functions.getValue())
                    ->Functions.getValues();
            if (idx >= 0) {
                static_cast<Fem::FemPostCutFilter*>(getObject())->Function.setValue(funcs[idx]);
            }
            else {
                static_cast<Fem::FemPostCutFilter*>(getObject())->Function.setValue(nullptr);
            }
        }
    }

    // load the correct view
    Fem::FemPostFunction* fobj = static_cast<Fem::FemPostFunction*>(
        static_cast<Fem::FemPostCutFilter*>(getObject())->Function.getValue());
    Gui::ViewProvider* view = nullptr;
    if (fobj) {
        view = Gui::Application::Instance->getViewProvider(fobj);
    }

    if (fwidget) {
        fwidget->deleteLater();
    }

    if (view) {
        fwidget = static_cast<FemGui::ViewProviderFemPostFunction*>(view)->createControlWidget();
        fwidget->setParent(ui->Container);
        fwidget->setViewProvider(static_cast<FemGui::ViewProviderFemPostFunction*>(view));
        ui->Container->layout()->addWidget(fwidget);
    }
    recompute();
}


// ***************************************************************************
// scalar clip filter
TaskPostScalarClip::TaskPostScalarClip(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterClipScalar"),
                  tr("Scalar clip options"),
                  parent)
    , ui(new Ui_TaskPostScalarClip)
{
    assert(view->isDerivedFrom(ViewProviderFemPostScalarClip::getClassTypeId()));

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();
    this->groupLayout()->addWidget(proxy);

    // load the default values
    updateEnumerationList(getTypedObject<Fem::FemPostScalarClipFilter>()->Scalars, ui->Scalar);
    ui->InsideOut->setChecked(
        static_cast<Fem::FemPostScalarClipFilter*>(getObject())->InsideOut.getValue());
    App::PropertyFloatConstraint& scalar_prop =
        static_cast<Fem::FemPostScalarClipFilter*>(getObject())->Value;
    double scalar_factor = scalar_prop.getValue();

    // set spinbox scalar_factor, don't forget to sync the slider
    ui->Value->blockSignals(true);
    ui->Value->setValue(scalar_factor);
    ui->Value->blockSignals(false);

    // sync the slider
    // slider min = 0%, slider max = 100%
    //
    //                 scalar_factor
    // slider_value = --------------- x 100
    //                      max
    //
    double max = scalar_prop.getConstraints()->UpperBound;
    int slider_value = (scalar_factor / max) * 100.;
    ui->Slider->blockSignals(true);
    ui->Slider->setValue(slider_value);
    ui->Slider->blockSignals(false);
    Base::Console().Log("init: scalar_factor, slider_value: %f, %i: \n",
                        scalar_factor,
                        slider_value);
}

TaskPostScalarClip::~TaskPostScalarClip() = default;

void TaskPostScalarClip::setupConnections()
{
    connect(ui->Slider, &QSlider::valueChanged, this, &TaskPostScalarClip::onSliderValueChanged);
    connect(ui->Value,
            qOverload<double>(&QDoubleSpinBox::valueChanged),
            this,
            &TaskPostScalarClip::onValueValueChanged);
    connect(ui->Scalar,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostScalarClip::onScalarCurrentIndexChanged);
    connect(ui->InsideOut, &QCheckBox::toggled, this, &TaskPostScalarClip::onInsideOutToggled);
}

void TaskPostScalarClip::applyPythonCode()
{}

void TaskPostScalarClip::onScalarCurrentIndexChanged(int idx)
{
    static_cast<Fem::FemPostScalarClipFilter*>(getObject())->Scalars.setValue(idx);
    recompute();

    // update constraints and values
    App::PropertyFloatConstraint& scalar_prop =
        static_cast<Fem::FemPostScalarClipFilter*>(getObject())->Value;
    double scalar_factor = scalar_prop.getValue();
    double min = scalar_prop.getConstraints()->LowerBound;
    double max = scalar_prop.getConstraints()->UpperBound;

    ui->Maximum->setText(QString::number(min));
    ui->Minimum->setText(QString::number(max));

    // set scalar_factor, don't forget to sync the slider
    ui->Value->blockSignals(true);
    ui->Value->setValue(scalar_factor);
    ui->Value->blockSignals(false);

    // sync the slider
    ui->Slider->blockSignals(true);
    int slider_value = (scalar_factor / max) * 100.;
    ui->Slider->setValue(slider_value);
    ui->Slider->blockSignals(false);
}

void TaskPostScalarClip::onSliderValueChanged(int v)
{
    App::PropertyFloatConstraint& value =
        static_cast<Fem::FemPostScalarClipFilter*>(getObject())->Value;
    double val = value.getConstraints()->LowerBound * (1 - double(v) / 100.)
        + double(v) / 100. * value.getConstraints()->UpperBound;

    value.setValue(val);
    recompute();

    // don't forget to sync the spinbox
    ui->Value->blockSignals(true);
    ui->Value->setValue(val);
    ui->Value->blockSignals(false);
}

void TaskPostScalarClip::onValueValueChanged(double v)
{
    App::PropertyFloatConstraint& value =
        static_cast<Fem::FemPostScalarClipFilter*>(getObject())->Value;
    value.setValue(v);
    recompute();

    // don't forget to sync the slider
    ui->Slider->blockSignals(true);
    ui->Slider->setValue(
        int(((v - value.getConstraints()->LowerBound)
             / (value.getConstraints()->UpperBound - value.getConstraints()->LowerBound))
            * 100.));
    ui->Slider->blockSignals(false);
}

void TaskPostScalarClip::onInsideOutToggled(bool val)
{
    static_cast<Fem::FemPostScalarClipFilter*>(getObject())->InsideOut.setValue(val);
    recompute();
}


// ***************************************************************************
// warp vector filter
TaskPostWarpVector::TaskPostWarpVector(ViewProviderDocumentObject* view, QWidget* parent)
    : TaskPostBox(view,
                  Gui::BitmapFactory().pixmap("FEM_PostFilterWarp"),
                  tr("Warp options"),
                  parent)
    , ui(new Ui_TaskPostWarpVector)
{
    assert(view->isDerivedFrom(ViewProviderFemPostWarpVector::getClassTypeId()));

    // we load the views widget
    proxy = new QWidget(this);
    ui->setupUi(proxy);
    setupConnections();
    this->groupLayout()->addWidget(proxy);

    // load the default values for warp display
    updateEnumerationList(getTypedObject<Fem::FemPostWarpVectorFilter>()->Vector, ui->Vector);
    double warp_factor = static_cast<Fem::FemPostWarpVectorFilter*>(getObject())
                             ->Factor.getValue();  // get the standard warp factor

    // set spinbox warp_factor, don't forget to sync the slider
    ui->Value->blockSignals(true);
    ui->Value->setValue(warp_factor);
    ui->Value->blockSignals(false);

    // set min and max, don't forget to sync the slider
    // TODO if warp is set to standard 1.0, find a smarter way for standard min, max
    // and warp_factor may be depend on grid boundbox and min max vector values
    ui->Max->blockSignals(true);
    ui->Max->setValue(warp_factor == 0 ? 1 : warp_factor * 10.);
    ui->Max->blockSignals(false);
    ui->Min->blockSignals(true);
    ui->Min->setValue(warp_factor == 0 ? 0 : warp_factor / 10.);
    ui->Min->blockSignals(false);

    // sync slider
    ui->Slider->blockSignals(true);
    // slider min = 0%, slider max = 100%
    //
    //                 ( warp_factor - min )
    // slider_value = ----------------------- x 100
    //                     ( max - min )
    //
    int slider_value =
        (warp_factor - ui->Min->value()) / (ui->Max->value() - ui->Min->value()) * 100.;
    ui->Slider->setValue(slider_value);
    ui->Slider->blockSignals(false);
    Base::Console().Log("init: warp_factor, slider_value: %f, %i: \n", warp_factor, slider_value);
}

TaskPostWarpVector::~TaskPostWarpVector() = default;

void TaskPostWarpVector::setupConnections()
{
    connect(ui->Slider, &QSlider::valueChanged, this, &TaskPostWarpVector::onSliderValueChanged);
    connect(ui->Value,
            qOverload<double>(&QDoubleSpinBox::valueChanged),
            this,
            &TaskPostWarpVector::onValueValueChanged);
    connect(ui->Max,
            qOverload<double>(&QDoubleSpinBox::valueChanged),
            this,
            &TaskPostWarpVector::onMaxValueChanged);
    connect(ui->Min,
            qOverload<double>(&QDoubleSpinBox::valueChanged),
            this,
            &TaskPostWarpVector::onMinValueChanged);
    connect(ui->Vector,
            qOverload<int>(&QComboBox::currentIndexChanged),
            this,
            &TaskPostWarpVector::onVectorCurrentIndexChanged);
}

void TaskPostWarpVector::applyPythonCode()
{}

void TaskPostWarpVector::onVectorCurrentIndexChanged(int idx)
{
    // combobox to choose the result to warp

    static_cast<Fem::FemPostWarpVectorFilter*>(getObject())->Vector.setValue(idx);
    recompute();
}

void TaskPostWarpVector::onSliderValueChanged(int slider_value)
{
    // slider changed, change warp factor and sync spinbox

    //
    //                                       ( max - min )
    // warp_factor = min + ( slider_value x --------------- )
    //                                            100
    //
    double warp_factor =
        ui->Min->value() + ((ui->Max->value() - ui->Min->value()) / 100.) * slider_value;
    static_cast<Fem::FemPostWarpVectorFilter*>(getObject())->Factor.setValue(warp_factor);
    recompute();

    // sync the spinbox
    ui->Value->blockSignals(true);
    ui->Value->setValue(warp_factor);
    ui->Value->blockSignals(false);
    Base::Console().Log("Change: warp_factor, slider_value: %f, %i: \n", warp_factor, slider_value);
}

void TaskPostWarpVector::onValueValueChanged(double warp_factor)
{
    // spinbox changed, change warp factor and sync slider

    // TODO warp factor should not be smaller than min and greater than max,
    // but problems on automate change of warp_factor, see on_Max_valueChanged

    static_cast<Fem::FemPostWarpVectorFilter*>(getObject())->Factor.setValue(warp_factor);
    recompute();

    // sync the slider, see above for formula
    ui->Slider->blockSignals(true);
    int slider_value =
        (warp_factor - ui->Min->value()) / (ui->Max->value() - ui->Min->value()) * 100.;
    ui->Slider->setValue(slider_value);
    ui->Slider->blockSignals(false);
    Base::Console().Log("Change: warp_factor, slider_value: %f, %i: \n", warp_factor, slider_value);
}

void TaskPostWarpVector::onMaxValueChanged(double)
{
    // TODO max should be greater than min, see a few lines later on problem on input characters
    ui->Slider->blockSignals(true);
    ui->Slider->setValue((ui->Value->value() - ui->Min->value())
                         / (ui->Max->value() - ui->Min->value()) * 100.);
    ui->Slider->blockSignals(false);

    /*
     * problem, if warp_factor is 2000 one would like to input 4000 as max, one starts to input 4
     * immediately the warp_factor is changed to 4 because 4 < 2000, but one has just input
     * one character of their 4000. * I do not know how to solve this, but the code to set slider
     * and spinbox is fine thus I leave it ...
     *
     * mhh it works if "apply changes to pipeline directly" button is deactivated,
     * still it really confuses if the button is active. More investigation is needed.
     *
    // set warp factor to max, if warp factor > max
    if (ui->Value->value() > ui->Max->value()) {
        double warp_factor = ui->Max->value();
        static_cast<Fem::FemPostWarpVectorFilter*>(getObject())->Factor.setValue(warp_factor);
        recompute();

        // sync the slider, see above for formula
        ui->Slider->blockSignals(true);
        int slider_value = (warp_factor - ui->Min->value())
                           / (ui->Max->value() - ui->Min->value()) * 100.;
        ui->Slider->setValue(slider_value);
        ui->Slider->blockSignals(false);
        // sync the spinbox, see above for formula
        ui->Value->blockSignals(true);
        ui->Value->setValue(warp_factor);
        ui->Value->blockSignals(false);
    Base::Console().Log("Change: warp_factor, slider_value: %f, %i: \n", warp_factor, slider_value);
    }
    */
}

void TaskPostWarpVector::onMinValueChanged(double)
{
    // TODO min should be smaller than max
    // TODO if warp factor is smaller than min, warp factor should be min, don't forget to sync
    ui->Slider->blockSignals(true);
    ui->Slider->setValue((ui->Value->value() - ui->Min->value())
                         / (ui->Max->value() - ui->Min->value()) * 100.);
    ui->Slider->blockSignals(false);
}


#include "moc_TaskPostBoxes.cpp"