/****************************************************************************
 Copyright (C) 2010-2012 the Office National des Forêts (ONF), France
                         All rights reserved.

 Contact : alexandre.piboule@onf.fr

 Developers : Alexandre PIBOULE (ONF)

 This file is part of PluginONF library.

 PluginONF is free library: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 PluginONF 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 General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with PluginONF.  If not, see <http://www.gnu.org/licenses/lgpl.html>.
*****************************************************************************/

#include "onf_actionadjustplotpositionoptions02.h"
#include "ui_onf_actionadjustplotpositionoptions02.h"

#include "actions/onf_actionadjustplotposition02.h"

#include "ct_log/ct_logmanager.h"

#include <QColorDialog>

ONF_ActionAdjustPlotPositionOptions02::ONF_ActionAdjustPlotPositionOptions02(const ONF_ActionAdjustPlotPosition02 *action) :
    CT_GAbstractActionForGraphicsViewOptions(action),
    ui(new Ui::ONF_ActionAdjustPlotPositionOptions02())
{
    ui->setupUi(this);
    ui->widget_mode2d->setVisible(true);
    ui->widget_mode3d->setVisible(false);

    ui->pb_up->setToolTip(tr("Déplacer la placette vers le Nord"));
    ui->pb_down->setToolTip(tr("Déplacer la placette vers le Sud"));
    ui->pb_left->setToolTip(tr("Déplacer la placette vers l'Ouest"));
    ui->pb_right->setToolTip(tr("Déplacer la placette vers l'Est"));
    ui->dsb_increment->setToolTip(tr("Distance de déplacement unitaire (m)"));
    ui->pb_translate->setToolTip(tr("Déplacer la placette de façon à ce que l'arbre sélectionné corresponde à l'apex sélectionné"));
    ui->dsb_dx->setToolTip(tr("Décalage selon l'axe X (positif = vers l'Est"));
    ui->dsb_dy->setToolTip(tr("Décalage selon l'axe Y (positif = vers le Nord"));
    ui->pb_reset->setToolTip(tr("Réinitialiser la position de la placette"));
    ui->sb_highlightedNumber->setToolTip(tr("Nombre d'arbre à mettre en évidence (n plus gros)"));
    ui->dsb_dbhMin->setToolTip(tr("N'afficher que les arbres dont le diamètres est supérieur à :"));
    ui->pb_treeColor->setToolTip(tr("Couleur des arbres"));
    ui->pb_highlightedTreeColor->setToolTip(tr("Couleur des n arbres les plus gros, mis en évidence"));
    ui->pb_selectedTreeColor->setToolTip(tr("Couleur de l'arbre sélectionné"));
    ui->cb_treeMode->setToolTip(tr("Déplacer les arbres individuellement (sans bouger la placette)"));
    ui->cb_apex->setToolTip(tr("Afficher les apex"));
    ui->dsb_apexSize->setToolTip(tr("Taille de représentation des apex"));
    ui->pb_apexColor->setToolTip(tr("Couleur des apex"));
    ui->pb_selectedApexColor->setToolTip(tr("Couleur de l'apex sélectionné"));
    ui->cb_plot->setToolTip(tr("Afficher les limites de la placette"));
    ui->pb_2d3d->setToolTip(tr("Changement de mode 2D/3D"));
    ui->cb_intensity->setToolTip(tr("Coloriser en fonction de l'intensité"));
    ui->cb_Z->setToolTip(tr("Coloriser en fonction de la hauteur"));
    ui->cb_last->setToolTip(tr("N'afficher que les points last (derniers retours)"));
    ui->cb_circles->setToolTip(tr("Afficher une série de cercles à la place des cylindres"));
    ui->cb_fixedH->setToolTip(tr("Forcer une hauteur fixe pour les cylindres"));
    ui->dsb_height->setToolTip(tr("Hauteur forcée des cylindres"));
    ui->dsb_radiusFactor->setToolTip(tr("Multiplicateur à appliquer aux diamètres des arbres pour l'affichage"));
    ui->pb_autoFit->setToolTip(tr("Ajustement automatique à partir des houppiers"));
    ui->pb_autoFitTrunks->setToolTip(tr("Ajustement automatique à partir des troncs"));
    ui->cb_spcolors->setToolTip(tr("Colorisation par espèces"));
    ui->cb_invertGradient->setToolTip(tr("Inversion du gradient"));
    ui->hs_fade->setToolTip(tr("Transparence du MSN"));
    ui->dsb_autoFitMaxError->setToolTip(tr("Distance maximale de déplacement de la placette"));
    ui->dsb_autoFitRadius->setToolTip(tr("Rayon de recherche des troncs"));

    _saveON = true;
}

ONF_ActionAdjustPlotPositionOptions02::~ONF_ActionAdjustPlotPositionOptions02()
{
    delete ui;
}

void ONF_ActionAdjustPlotPositionOptions02::setTranslation(double dx, double dy)
{
    ui->dsb_dx->setValue(dx);
    ui->dsb_dy->setValue(dy);
}

void ONF_ActionAdjustPlotPositionOptions02::setPlotID(QString id)
{
    ui->le_id->setText(id);
}

void ONF_ActionAdjustPlotPositionOptions02::setHminHmax(double hmin, double hmax)
{
    ui->dsb_hmin->setMinimum(hmin);
    ui->dsb_hmin->setMaximum(hmax);
    ui->dsb_hmax->setMinimum(hmin);
    ui->dsb_hmax->setMaximum(hmax);

    ui->dsb_hmin->setValue(hmin);
    ui->dsb_hmax->setValue(hmax);
}

bool ONF_ActionAdjustPlotPositionOptions02::isFixedHeight() const
{
    return ui->cb_fixedH->isChecked();
}

double ONF_ActionAdjustPlotPositionOptions02::fixedHeight() const
{
    return ui->dsb_height->value();
}

double ONF_ActionAdjustPlotPositionOptions02::translationIncrement() const
{
    return ui->dsb_increment->value();
}

bool ONF_ActionAdjustPlotPositionOptions02::isTreeModeSelected() const
{
    return ui->cb_treeMode->isChecked();
}

bool ONF_ActionAdjustPlotPositionOptions02::lastOnly() const
{
    return ui->cb_last->isChecked();
}

double ONF_ActionAdjustPlotPositionOptions02::dbhMin() const
{
    return ui->dsb_dbhMin->value();
}

bool ONF_ActionAdjustPlotPositionOptions02::colorBySpecies() const
{
    return ui->cb_spcolors->isChecked();
}

double ONF_ActionAdjustPlotPositionOptions02::translationStep() const
{
    return ui->dsb_increment->value();
}

int ONF_ActionAdjustPlotPositionOptions02::getShadeValue() const
{
    return ui->hs_fade->value();
}

bool ONF_ActionAdjustPlotPositionOptions02::isInverted() const
{
    return ui->cb_invertGradient->isChecked();
}

double ONF_ActionAdjustPlotPositionOptions02::autoFitMaxError() const
{
    return ui->dsb_autoFitMaxError->value();
}

double ONF_ActionAdjustPlotPositionOptions02::autoFitRadius() const
{
    return ui->dsb_autoFitRadius->value();
}

double ONF_ActionAdjustPlotPositionOptions02::hmin() const
{
    return ui->dsb_hmin->value();
}

double ONF_ActionAdjustPlotPositionOptions02::hmax() const
{
    return ui->dsb_hmax->value();
}

bool ONF_ActionAdjustPlotPositionOptions02::intensitySelected() const
{
    return ui->cb_intensity->isChecked();
}

QColor ONF_ActionAdjustPlotPositionOptions02::colorTree() const
{
    return _colorTree;
}

QColor ONF_ActionAdjustPlotPositionOptions02::colorHighlightedTree() const
{
    return _colorHighlightedTree;
}

QColor ONF_ActionAdjustPlotPositionOptions02::colorSelectedTree() const
{
    return _colorSelectedTree;
}

QColor ONF_ActionAdjustPlotPositionOptions02::colorApex() const
{
    return _colorApex;
}

QColor ONF_ActionAdjustPlotPositionOptions02::colorSelectedApex() const
{
    return _colorSelectedApex;
}

void ONF_ActionAdjustPlotPositionOptions02::setColors(QColor colorTree, QColor colorHighlightedTree, QColor colorSelectedTree, QColor colorApex, QColor colorSelectedApex)
{
    _colorTree = colorTree;
    _colorHighlightedTree = colorHighlightedTree;
    _colorSelectedTree = colorSelectedTree;
    _colorApex = colorApex;
    _colorSelectedApex = colorSelectedApex;

    ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorTree.name() + "; }");
    ui->pb_highlightedTreeColor->setStyleSheet("QPushButton { background-color: " + _colorHighlightedTree.name() + "; }");
    ui->pb_selectedTreeColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedTree.name() + "; }");
    ui->pb_apexColor->setStyleSheet("QPushButton { background-color: " + _colorApex.name() + "; }");
    ui->pb_selectedApexColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedApex.name() + "; }");
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_up_clicked()
{
    emit parametersChanged(0, ui->dsb_increment->value(),
                           ui->cb_circles->isChecked(),
                           ui->cb_fixedH->isChecked(),
                           ui->dsb_height->value(),
                           ui->cb_treeMode->isChecked(),
                           ui->pb_2d3d->isChecked(),
                           ui->dsb_radiusFactor->value(),
                           ui->cb_apex->isChecked(),
                           ui->dsb_apexSize->value(),
                           ui->cb_plot->isChecked());
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_down_clicked()
{
    emit parametersChanged(0, -1.0*ui->dsb_increment->value(),
                           ui->cb_circles->isChecked(),
                           ui->cb_fixedH->isChecked(),
                           ui->dsb_height->value(),
                           ui->cb_treeMode->isChecked(),
                           ui->pb_2d3d->isChecked(),
                           ui->dsb_radiusFactor->value(),
                           ui->cb_apex->isChecked(),
                           ui->dsb_apexSize->value(),
                           ui->cb_plot->isChecked());
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_left_clicked()
{
    emit parametersChanged(-1.0*ui->dsb_increment->value(), 0,
                           ui->cb_circles->isChecked(),
                           ui->cb_fixedH->isChecked(),
                           ui->dsb_height->value(),
                           ui->cb_treeMode->isChecked(),
                           ui->pb_2d3d->isChecked(),
                           ui->dsb_radiusFactor->value(),
                           ui->cb_apex->isChecked(),
                           ui->dsb_apexSize->value(),
                           ui->cb_plot->isChecked());
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_right_clicked()
{
    emit parametersChanged(ui->dsb_increment->value(), 0,
                           ui->cb_circles->isChecked(),
                           ui->cb_fixedH->isChecked(),
                           ui->dsb_height->value(),
                           ui->cb_treeMode->isChecked(),
                           ui->pb_2d3d->isChecked(),
                           ui->dsb_radiusFactor->value(),
                           ui->cb_apex->isChecked(),
                           ui->dsb_apexSize->value(),
                           ui->cb_plot->isChecked());
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_circles_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_fixedH_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_height_valueChanged(double arg1)
{
    Q_UNUSED(arg1)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());

        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_intensity_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {

        emit colorizationChanged(ui->cb_intensity->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_translate_clicked()
{
    emit askForTranslation(false);
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_reset_clicked()
{
    emit askForTranslation(true);
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_grey_clicked()
{
    emit setGradient(ui->cb_intensity->isChecked(), "grey");
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_hot_clicked()
{
    emit setGradient(ui->cb_intensity->isChecked(), "hot");
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_rainbow_clicked()
{
    emit setGradient(ui->cb_intensity->isChecked(), "rainbow");
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_hsv_clicked()
{
    emit setGradient(ui->cb_intensity->isChecked(), "hsv");
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_rycb_clicked()
{
    emit setGradient(ui->cb_intensity->isChecked(), "rycb");
}

void ONF_ActionAdjustPlotPositionOptions02::on_sb_highlightedNumber_valueChanged(int arg1)
{
    Q_UNUSED(arg1)
    if (_saveON) {
        emit changeHighlightedNumber(ui->sb_highlightedNumber->value());
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_treeMode_toggled(bool checked)
{
    Q_UNUSED(checked)
    emit parametersChanged(0, 0,
                           ui->cb_circles->isChecked(),
                           ui->cb_fixedH->isChecked(),
                           ui->dsb_height->value(),
                           ui->cb_treeMode->isChecked(),
                           ui->pb_2d3d->isChecked(),
                           ui->dsb_radiusFactor->value(),
                           ui->cb_apex->isChecked(),
                           ui->dsb_apexSize->value(),
                           ui->cb_plot->isChecked());
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_last_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit colorizationChanged(ui->cb_intensity->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_2d3d_toggled(bool checked)
{
    if (checked)
    {
        ui->widget_mode3d->setVisible(true);
        ui->widget_mode2d->setVisible(false);
    } else {
        ui->widget_mode3d->setVisible(false);
        ui->widget_mode2d->setVisible(true);
    }

    if (_saveON) {
        emit selectionModeChanged(true);
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_radiusFactor_valueChanged(double arg1)
{
    Q_UNUSED(arg1)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}



void ONF_ActionAdjustPlotPositionOptions02::on_cb_apex_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit selectionModeChanged(false);
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_apexSize_valueChanged(double arg1)
{
    Q_UNUSED(arg1)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_plot_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());

        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_sb_quality_valueChanged(int arg1)
{
    Q_UNUSED(arg1)
    emit qualityChanged(ui->sb_quality->value());
}

void ONF_ActionAdjustPlotPositionOptions02::on_le_comments_textChanged(const QString &arg1)
{
    Q_UNUSED(arg1)
    emit commentChanged(ui->le_comments->text());
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_dbhMin_valueChanged(double arg1)
{
    Q_UNUSED(arg1)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_treeColor_clicked()
{
    QColor tmp = QColorDialog::getColor(_colorTree);
    if (!tmp.isValid()) {return;}
    _colorTree = tmp;
    ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorTree.name() + "; }");
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_highlightedTreeColor_clicked()
{
    QColor tmp = QColorDialog::getColor(_colorHighlightedTree);
    if (!tmp.isValid()) {return;}
    _colorHighlightedTree = tmp;
    ui->pb_highlightedTreeColor->setStyleSheet("QPushButton { background-color: " + _colorHighlightedTree.name() + "; }");
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_apexColor_clicked()
{
    QColor tmp = QColorDialog::getColor(_colorApex);
    if (!tmp.isValid()) {return;}
    _colorApex = tmp;
    ui->pb_apexColor->setStyleSheet("QPushButton { background-color: " + _colorApex.name() + "; }");
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_selectedTreeColor_clicked()
{
    QColor tmp = QColorDialog::getColor(_colorSelectedTree);
    if (!tmp.isValid()) {return;}
    _colorSelectedTree = tmp;
    ui->pb_selectedTreeColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedTree.name() + "; }");
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_selectedApexColor_clicked()
{
    QColor tmp = QColorDialog::getColor(_colorSelectedApex);
    if (!tmp.isValid()) {return;}
    _colorSelectedApex = tmp;
    ui->pb_selectedApexColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedApex.name() + "; }");
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_cb_spcolors_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_autoFit_clicked()
{
    emit computeAutoFit();
}


void ONF_ActionAdjustPlotPositionOptions02::on_pb_autoFitTrunks_clicked()
{
    emit computeAutoFitTrunks();
}


void ONF_ActionAdjustPlotPositionOptions02::on_cb_invertGradient_toggled(bool checked)
{
    Q_UNUSED(checked)
    if (_saveON) {
        emit setGradient(ui->cb_intensity->isChecked(), "");
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_hs_fade_valueChanged(int value)
{
    Q_UNUSED(value)
    if (_saveON) {
        emit setGradient(ui->cb_intensity->isChecked(), "");
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_hmin_valueChanged(double arg1)
{
    Q_UNUSED(arg1);
    ui->dsb_hmax->setMinimum(ui->dsb_hmin->value());
    if (_saveON) {
        emit colorizationChanged(ui->cb_intensity->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_hmax_valueChanged(double arg1)
{
    Q_UNUSED(arg1);
    if (_saveON) {
        emit colorizationChanged(ui->cb_intensity->isChecked());
        emit saveSettings();
    }
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_noGnd_clicked()
{
    ui->dsb_hmin->setValue(0.5);
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_trunks_clicked()
{
    ui->dsb_hmax->setValue(8.0);
}

void ONF_ActionAdjustPlotPositionOptions02::on_pb_all_clicked()
{
    ui->dsb_hmin->setValue(ui->dsb_hmin->minimum());
    ui->dsb_hmax->setValue(ui->dsb_hmax->maximum());
}

QStringList ONF_ActionAdjustPlotPositionOptions02::getSettings()
{
    QStringList settings;

    settings.append(QString("%1").arg(ui->dsb_autoFitMaxError->value()));
    settings.append(QString("%1").arg(ui->dsb_autoFitRadius->value()));
    settings.append(QString("%1").arg(ui->sb_highlightedNumber->value()));
    settings.append(QString("%1").arg(ui->dsb_dbhMin->value()));

    settings.append(QString("%1").arg(ui->cb_spcolors->isChecked()));
    settings.append(QString("%1").arg(ui->cb_plot->isChecked()));
    settings.append(QString("%1").arg(ui->pb_2d3d->isChecked()));

    settings.append(QString("%1").arg(ui->cb_invertGradient->isChecked()));
    settings.append(QString("%1").arg(ui->hs_fade->value()));
    settings.append(QString("%1").arg(ui->dsb_hmin->value()));
    settings.append(QString("%1").arg(ui->dsb_hmax->value()));
    settings.append(QString("%1").arg(ui->cb_intensity->isChecked()));
    settings.append(QString("%1").arg(ui->cb_last->isChecked()));
    settings.append(QString("%1").arg(ui->cb_circles->isChecked()));
    settings.append(QString("%1").arg(ui->cb_fixedH->isChecked()));
    settings.append(QString("%1").arg(ui->dsb_height->value()));
    settings.append(QString("%1").arg(ui->dsb_radiusFactor->value()));
    settings.append(QString("%1").arg(ui->cb_apex->isChecked()));
    settings.append(QString("%1").arg(ui->dsb_apexSize->value()));

    settings.append(QString("%1").arg(_colorTree.red()));
    settings.append(QString("%1").arg(_colorTree.green()));
    settings.append(QString("%1").arg(_colorTree.blue()));

    settings.append(QString("%1").arg(_colorHighlightedTree.red()));
    settings.append(QString("%1").arg(_colorHighlightedTree.green()));
    settings.append(QString("%1").arg(_colorHighlightedTree.blue()));

    settings.append(QString("%1").arg(_colorSelectedTree.red()));
    settings.append(QString("%1").arg(_colorSelectedTree.green()));
    settings.append(QString("%1").arg(_colorSelectedTree.blue()));

    settings.append(QString("%1").arg(_colorApex.red()));
    settings.append(QString("%1").arg(_colorApex.green()));
    settings.append(QString("%1").arg(_colorApex.blue()));

    settings.append(QString("%1").arg(_colorSelectedApex.red()));
    settings.append(QString("%1").arg(_colorSelectedApex.green()));
    settings.append(QString("%1").arg(_colorSelectedApex.blue()));

    return settings;
}

void ONF_ActionAdjustPlotPositionOptions02::restoreSettings(const QStringList &settings)
{
    if (settings.size() >= 34)
    {
        bool ok, okr, okg, okb;
        double vald;
        int vali;
        int r, g, b;
        int index = 0;

        _saveON = false;

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_autoFitMaxError->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre autoFitMaxError non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_autoFitRadius->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre autoFitRadius non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->sb_highlightedNumber->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre highlightedNumber non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_dbhMin->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre dbhMin non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_spcolors->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre spcolors non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_plot->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre plot non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->pb_2d3d->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre 2d3d non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_invertGradient->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre invertGradient non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->hs_fade->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre fade non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok)
        {
            if (vald >= 0.5)
            {
                ui->dsb_hmin->setValue(vald);
            }
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre hmin non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok)
        {
            if (vald <= 8.0)
            {
                ui->dsb_hmax->setValue(vald);
            }
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre hmax non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_intensity->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre intensity non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_last->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre last non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_circles->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre circles non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_fixedH->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre fixedH non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_height->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre height non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_radiusFactor->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre radiusFactor non valide."));}

        vali = settings.at(index++).toInt(&ok);
        if (ok) {ui->cb_apex->setChecked(vali);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre apex non valide."));}

        vald = settings.at(index++).toDouble(&ok);
        if (ok) {ui->dsb_apexSize->setValue(vald);}
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre apexSize non valide."));}


        r = settings.at(index++).toInt(&okr);
        g = settings.at(index++).toInt(&okg);
        b = settings.at(index++).toInt(&okb);
        if (okr && okg && okb)
        {
            _colorTree = QColor(r, g, b);
            ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorTree.name() + "; }");
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre colorTree non valide."));}

        r = settings.at(index++).toInt(&okr);
        g = settings.at(index++).toInt(&okg);
        b = settings.at(index++).toInt(&okb);
        if (okr && okg && okb)
        {
            _colorHighlightedTree = QColor(r, g, b);
            ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorHighlightedTree.name() + "; }");
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre colorHighlightedTree non valide."));}

        r = settings.at(index++).toInt(&okr);
        g = settings.at(index++).toInt(&okg);
        b = settings.at(index++).toInt(&okb);
        if (okr && okg && okb)
        {
            _colorSelectedTree = QColor(r, g, b);
            ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedTree.name() + "; }");
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre colorSelectedTree non valide."));}

        r = settings.at(index++).toInt(&okr);
        g = settings.at(index++).toInt(&okg);
        b = settings.at(index++).toInt(&okb);
        if (okr && okg && okb)
        {
            _colorApex = QColor(r, g, b);
            ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorApex.name() + "; }");
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre colorApex non valide."));}

        r = settings.at(index++).toInt(&okr);
        g = settings.at(index++).toInt(&okg);
        b = settings.at(index++).toInt(&okb);
        if (okr && okg && okb)
        {
            _colorSelectedApex = QColor(r, g, b);
            ui->pb_treeColor->setStyleSheet("QPushButton { background-color: " + _colorSelectedApex.name() + "; }");
        }
        else {PS_LOG->addMessage(LogInterface::warning, LogInterface::action, tr("Erreur : paramètre colorSelectedApex non valide."));}

        _saveON = true;

        emit parametersChanged(0, 0,
                               ui->cb_circles->isChecked(),
                               ui->cb_fixedH->isChecked(),
                               ui->dsb_height->value(),
                               ui->cb_treeMode->isChecked(),
                               ui->pb_2d3d->isChecked(),
                               ui->dsb_radiusFactor->value(),
                               ui->cb_apex->isChecked(),
                               ui->dsb_apexSize->value(),
                               ui->cb_plot->isChecked());

        emit colorizationChanged(ui->cb_intensity->isChecked());
        emit changeHighlightedNumber(ui->sb_highlightedNumber->value());
        emit setGradient(ui->cb_intensity->isChecked(), "");

    } else {PS_LOG->addMessage(LogInterface::error, LogInterface::action, tr("Erreur : fichier de paramètres non valide."));}



}

void ONF_ActionAdjustPlotPositionOptions02::on_dsb_autoFitMaxError_valueChanged(double arg1)
{
    Q_UNUSED(arg1);
    emit saveSettings();
}


void ONF_ActionAdjustPlotPositionOptions02::on_dsb_autoFitRadius_valueChanged(double arg1)
{
    Q_UNUSED(arg1);
    emit saveSettings();
}