TYPaletteWidget.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <limits>
 
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
 
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/core/logging.h"
#include "TYLookupTableWidget.h"
#include "Tympan/models/business/TYPalette.h"
#include "Tympan/gui/widgets/TYLineEdit.h"
 
#include <math.h>
#include <qcolordialog.h>
#include <qfiledialog.h>
#include <qpainter.h>
#include <qmessagebox.h>
#include <qtablewidget.h>
// Added by qt3to4:
#include <QGridLayout>
#include <QLabel>
#include <QTextStream>
 
#include "TYPaletteWidget.h"
#include "TYElementWidget.h"
 
#define TR(id) OLocalizator::getString("TYPaletteWidget", (id))
 
TYPaletteWidget::TYPaletteWidget(TYPalette* pElement, QWidget* _pParent /*=NULL*/)
    : TYWidget(pElement, _pParent, NULL, Qt::Dialog)
{
#ifndef NDEBUG
    bool ok = false;
#endif
    resize(500, 800);
    setWindowTitle(TR("id_caption"));
    _paletteLayout = new QVBoxLayout();
    setLayout(_paletteLayout);
 
    // ELEMENT
    _elmW = new TYElementWidget(pElement, this);
    _paletteLayout->addWidget(_elmW);
 
    // ColorMap table
    QGroupBox* pGroupBoxColorMap = new QGroupBox(this);
    pGroupBoxColorMap->setTitle(TR("id_editarray"));
    QVBoxLayout* internalLayout = new QVBoxLayout();
    pGroupBoxColorMap->setLayout(internalLayout);
    _editor = new PaletteEditor(getElement());
    internalLayout->addWidget(_editor);
    _paletteLayout->addWidget(pGroupBoxColorMap, 1);
 
    // ColorMap preview
    QGroupBox* pGroupBoxPreview = new QGroupBox(this);
    pGroupBoxPreview->setTitle(TR("id_lookuptableview"));
    // NB The internal layout of the pGroupBoxPreview is set by TYLabeledLookupTableWidget()
    p_previewWidget = new TYLabeledLookupTableWidget(getElement(), pGroupBoxPreview);
    _paletteLayout->addWidget(pGroupBoxPreview);
#ifndef NDEBUG
    ok =
#endif
        QObject::connect(_editor, &PaletteEditor::paletteChanged, p_previewWidget,
                         &TYLabeledLookupTableWidget::update);
    assert(ok);
 
    // SAVE/LOAD/RESET
    QGroupBox* pGroupBoxSaveLoad = new QGroupBox(this);
    pGroupBoxSaveLoad->setTitle(TR("id_saveload"));
    QGridLayout* pGroupBoxSaveLoadLayout = new QGridLayout();
    pGroupBoxSaveLoad->setLayout(pGroupBoxSaveLoadLayout);
    // Load button
    _pushButtonLoadPalette = new QPushButton(pGroupBoxSaveLoad);
    _pushButtonLoadPalette->setText(TR("id_load"));
    pGroupBoxSaveLoadLayout->addWidget(_pushButtonLoadPalette, 0, 0);
    QObject::connect(_pushButtonLoadPalette, &QPushButton::clicked, this, &TYPaletteWidget::loadPalette);
    // Save button
    _pushButtonSavePalette = new QPushButton(pGroupBoxSaveLoad);
    _pushButtonSavePalette->setText(TR("id_save"));
    pGroupBoxSaveLoadLayout->addWidget(_pushButtonSavePalette, 0, 1);
    QObject::connect(_pushButtonSavePalette, &QPushButton::clicked, this, &TYPaletteWidget::savePalette);
    // Reset button
    _pushButtonResetPalette = new QPushButton(pGroupBoxSaveLoad);
    _pushButtonResetPalette->setText(TR("id_reset"));
    pGroupBoxSaveLoadLayout->addWidget(_pushButtonResetPalette, 0, 2);
    QObject::connect(_pushButtonResetPalette, &QPushButton::clicked, this, &TYPaletteWidget::resetPalette);
    // Linear button
    _pushButtonLinearPalette = new QPushButton(pGroupBoxSaveLoad);
    _pushButtonLinearPalette->setText(TR("id_linear"));
    pGroupBoxSaveLoadLayout->addWidget(_pushButtonLinearPalette, 0, 3);
    QObject::connect(_pushButtonLinearPalette, &QPushButton::clicked, this,
                     &TYPaletteWidget::makeLinearPalette);
 
    _paletteLayout->addWidget(pGroupBoxSaveLoad);
 
    updateContent();
}
 
TYPaletteWidget::~TYPaletteWidget() {}
 
void TYPaletteWidget::updateContent() // Override
{
    // Mise a jour de l'element
    _elmW->updateContent();
    _editor->notifyTYPaletteExternalyChanged();
}
 
void TYPaletteWidget::apply() // Override
{
    // Element
    _elmW->apply();
}
 
void TYPaletteWidget::resetPalette()
{
    if (!getElement()->resetFromPreferences())
    {
        getElement()->resetToDefault();
        getElement()->saveToPreferences();
    }
    updateContent();
}
 
void TYPaletteWidget::makeLinearPalette()
{
    TYPaletteLimitsWidget* limits = new TYPaletteLimitsWidget(getElement(), this);
    bool ret = limits->exec();
    if (ret == QDialog::Accepted)
    {
        updateContent();
    }
}
 
void TYPaletteWidget::loadPalette()
{
    QString qFileName = QFileDialog::getOpenFileName(this, "Choose a file", QString(), "XML (*.xml)");
 
    if (!qFileName.isEmpty())
    {
        if (!qFileName.endsWith(".xml"))
        {
            qFileName += ".xml";
        }
 
        bool loaded = false;
        LPTYPalette pPalette = TYPalette::loadPaletteFromFile(qFileName);
        if (pPalette)
        {
            (*getElement()) = *pPalette;
            updateContent();
            loaded = true;
        }
        else
        {
            OMessageManager::get()->error("Invalid Palette file %s : the one element is not a Palette.",
                                          qFileName.toUtf8().data());
        }
 
        if (loaded)
        {
            QMessageBox::information(this, "Tympan", TR("id_import_ok").arg(qFileName));
        }
        else
        {
            QMessageBox::warning(this, "Tympan", TR("id_import_failed").arg(qFileName));
        }
    }
}
 
void TYPaletteWidget::savePalette()
{
    QString qFileName = QFileDialog::getSaveFileName(this, "Choose a file", QString(), "XML (*.xml)");
 
    if (qFileName.isEmpty())
    {
        return;
    }
 
    if (!qFileName.endsWith(".xml"))
    {
        qFileName += ".xml";
    }
 
    bool save = true;
 
    // Verification de l'etat du fichier
    QFileInfo fi(qFileName);
 
    // Si le fichier existe , on demande confirmation a l'utilisateur
    if (fi.exists())
    {
        // On ecrase le fichier, puis on sauve
        QFile* file = new QFile(qFileName);
        switch (
            QMessageBox::warning(this, "Attention", TR("id_file_exist"), QMessageBox::Yes, QMessageBox::No))
        {
            case QMessageBox::Yes:
                if (!file->remove())
                {
                    QMessageBox::warning(this, "Attention", TR("id_file_cannot_be_clear"));
                    save = false;
                }
                break;
            case QMessageBox::No:
                save = false;
                break;
        }
 
        delete file;
    }
 
    if (save)
    {
        LPTYPalette pPalette = new TYPalette(*getElement());
 
        bool status = pPalette->savePaletteToFile(qFileName);
        if (status)
        {
            QMessageBox::information(this, "Tympan", TR("id_export_ok").arg(qFileName));
        }
        else
        {
            QMessageBox::warning(this, "Tympan", TR("id_export_failed").arg(qFileName));
        }
    }
}
 
/* --------------- class PaletteModel --------------- */
 
PaletteModel::PaletteModel(TYPalette* p_palette_, QObject* parent)
    : QAbstractTableModel(parent), p_palette(p_palette_)
{
}
 
PaletteModel::~PaletteModel() {}
 
int PaletteModel::rowCount(const QModelIndex& parent) const
{
    return static_cast<int>(p_palette->getNbColors());
}
 
int PaletteModel::columnCount(const QModelIndex& parent) const
{
    return 2;
}
 
void PaletteModel::getBoundsForValue(unsigned row, float& inf, float& sup) const
 
{
    inf = -std::numeric_limits<float>::infinity();
    sup = +std::numeric_limits<float>::infinity();
 
    if (row > 0)
    {
        inf = p_palette->getValueFromIndex(row - 1);
    }
    if (row < rowCount(QModelIndex()) - 1)
    {
        sup = p_palette->getValueFromIndex(row + 1);
    }
}
 
QVariant PaletteModel::data(const QModelIndex& index, int role) const
{
    if (!index.isValid())
    {
        return QVariant();
    }
    switch (index.column())
    {
        case 0:                               // Request noise level (1st column)
            if (isSpecialInfiniteCell(index)) // Last cell can not be edited
            {
                if (role == Qt::DisplayRole)
                {
                    return TR("id_editarrayInfinity");
                }
            }
            switch (role)
            {
                case Qt::DisplayRole:
                    return QString("%1").arg(p_palette->getValueFromIndex(index.row()), 0, 'f', 1);
                    break;
                case Qt::EditRole:
                    return p_palette->getValueFromIndex(index.row());
                    break;
                case Qt::CheckStateRole:
                    return checked_rows.count(index.row()) ? Qt::Checked : Qt::Unchecked;
                    break;
                case Qt::TextAlignmentRole:
                    return Qt::AlignRight;
                    break;
            }
            break;
        case 1: // Request color (2nd column)
            switch (role)
            {
                case Qt::BackgroundRole:
                    OColor ocolor(p_palette->getColorFromIndex(index.row()));
                    return toQColor(ocolor);
                    break;
            }
            break;
        default:
            break;
    }
    return QVariant();
}
 
QVariant PaletteModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    switch (section)
    {
        case 0:
            return TR("id_editarraycol0");
            break;
        case 1:
            return TR("id_editarraycol1");
            break;
        default:
            return QVariant();
            break;
    }
}
 
Qt::ItemFlags PaletteModel::flags(const QModelIndex& index) const
{
    if (!index.isValid())
    {
        return Qt::ItemIsEnabled;
    }
    Qt::ItemFlags flags = QAbstractTableModel::flags(index);
    flags |= Qt::ItemIsEditable;
    flags &= ~Qt::ItemIsSelectable;
    switch (index.column())
    {
        case 0:
            if (isSpecialInfiniteCell(index))
            {
                // No edition possible for the last row value
                flags &= ~Qt::ItemIsEditable;
                flags &= ~Qt::ItemIsUserCheckable;
            }
            else
            {
                flags |= Qt::ItemIsUserCheckable;
            }
            break;
        case 1:
            // Nothing specific yet
            break;
        default:
            assert(false && "Should never be reachable");
            break;
    }
    return flags;
}
 
bool PaletteModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
    if (!index.isValid())
    {
        return false;
    }
    TYPalette::values_type real_value = NAN;
    QColor qcolor;
    bool ok = false;
    TYPalette::values_type old_value = p_palette->getValueFromIndex(index.row());
 
    switch (index.column())
    {
        case 0:                               // Request noise level (1st column)
            if (isSpecialInfiniteCell(index)) // Last cell can not be edited
            {
                return false;
            }
            switch (role)
            {
                case Qt::EditRole:
                    real_value = value.toFloat(&ok);
                    if (ok)
                    {
                        ok = p_palette->moveValue(old_value, real_value);
                        if (ok)
                        {
                            emit dataChanged(index, index);
                        }
                        return ok;
                    }
                    break;
                case Qt::CheckStateRole:
                    if (value == Qt::Checked)
                    {
                        ok = checked_rows.insert(index.row()).second;
                    }
                    else
                    {
                        ok = checked_rows.erase(index.row()) == 1;
                    }
                    break;
            }
            return ok;
            break;
        case 1: // Request color (2nd column)
            switch (role)
            {
                case Qt::BackgroundRole:
                case Qt::EditRole:
                    qcolor = value.value<QColor>();
                    p_palette->insertColor(old_value, toOColor(qcolor));
                    emit dataChanged(index, index);
                    return true;
                    break;
                default:
                    assert(false && "This should be an unreachable case");
                    break;
            }
            break;
        default:
            assert(false && "This should be an unreachable case");
            break;
    }
    return false; // to make the compiler happy with all exec path having a return.
}
 
void PaletteModel::deleteSelectedRows()
{
    BOOST_REVERSE_FOREACH(unsigned r, checked_rows)
    {
        beginRemoveRows(QModelIndex(), r, r);
        TYPalette::values_type value = p_palette->getValueFromIndex(r);
#ifndef NDEBUG
        bool ok = p_palette->removeValue(value);
        assert(ok && "This value must be valid");
#else
        p_palette->removeValue(value);
#endif
        endRemoveRows();
    }
    checked_rows.clear();
    emit dataChanged(index(0, 0), index(rowCount() - 1, 1));
}
 
void PaletteModel::addRow(float noiseLevel)
{
    TYPalette::values_type value = NAN;
    OColor color;
    unsigned r = 0;
    // We look for the index r of the row to be created
    BOOST_FOREACH (boost::tie(value, color), p_palette->getColorMap())
    {
        if (value == noiseLevel)
        {
            return; // We don't try to inser duplicates
        }
        if (value > noiseLevel)
        {
            break;
        }
        ++r;
    }
    // Now r is the index of the new row
    beginInsertRows(QModelIndex(), r, r);
    p_palette->insertColor(noiseLevel, OColor::WHITE);
    endInsertRows();
    emit dataChanged(index(r, 0), index(r, 1));
    checked_rows.clear();
}
 
/* --------------- class PaletteColorDelegate --------------- */
 
QWidget* PaletteColorDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option,
                                            const QModelIndex& index) const
{
    return new QWidget(parent);
}
 
void PaletteColorDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
#ifndef NDEBUG
    bool ok = false;
#endif
 
    QColor qcolor = index.model()->data(index, Qt::BackgroundRole).value<QColor>();
    QPalette p = editor->palette();
    p.setColor(QPalette::Window, qcolor);
    p.setColor(QPalette::Base, qcolor);
    QColorDialog* dialog = new QColorDialog(editor);
    dialog->setCurrentColor(qcolor);
#ifndef NDEBUG
    ok =
#endif
        QObject::connect(dialog, &QColorDialog::finished, this, &PaletteColorDelegate::validateColor);
    assert(ok && "Connection failed for validateColor()");
    dialog->show();
}
 
void PaletteColorDelegate::validateColor()
{
    QColorDialog* dialog = qobject_cast<QColorDialog*>(this->sender());
    QWidget* editor = dialog->parentWidget();
    if (dialog->result() == QDialog::Accepted)
    {
        QColor qcolor = dialog->currentColor();
        QPalette p = editor->palette();
        p.setColor(QPalette::Window, qcolor);
        p.setColor(QPalette::Base, qcolor);
        editor->setPalette(p);
        emit commitData(editor);
    }
    emit closeEditor(editor, QAbstractItemDelegate::NoHint);
}
 
void PaletteColorDelegate::setModelData(QWidget* editor, QAbstractItemModel* model,
                                        const QModelIndex& index) const
{
    QColor color = editor->palette().color(QPalette::Base);
    model->setData(index, color);
}
 
/* --------------- class PaletteValueDelegate --------------- */
 
QWidget* PaletteValueDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option,
                                            const QModelIndex& index) const
{
    QDoubleSpinBox* editor = new QDoubleSpinBox(parent);
    editor->setDecimals(1);
    TYPalette::values_type inf = NAN, sup = NAN;
    const PaletteModel* model = qobject_cast<const PaletteModel*>(index.model());
    assert(model && "This cast shoul always succeed.");
    model->getBoundsForValue(index.row(), inf, sup);
    editor->setMinimum(inf);
    editor->setMaximum(sup);
    return editor;
}
 
void PaletteValueDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
    bool ok = false;
    TYPalette::values_type value = index.model()->data(index).toFloat(&ok);
    QDoubleSpinBox* spinbox = qobject_cast<QDoubleSpinBox*>(editor);
    assert(spinbox && "THis cast is expecto to always work.");
    if (ok)
    {
        spinbox->setValue(value);
    }
    else
    {
        OMessageManager::get()->debug(
            QString("Invalid value for noise level : %1").arg(index.model()->data(index).toString()));
    }
}
 
void PaletteValueDelegate::setModelData(QWidget* editor, QAbstractItemModel* model,
                                        const QModelIndex& index) const
{
    QDoubleSpinBox* spinbox = qobject_cast<QDoubleSpinBox*>(editor);
    spinbox->interpretText();
    TYPalette::values_type value = spinbox->value();
    model->setData(index, value, Qt::EditRole);
}
 
/* --------------- class PaletteColorDelegate --------------- */
 
PaletteEditor::PaletteEditor(TYPalette* palette_, QWidget* parent)
    : QFrame(parent), newNoiseLevelSpin(NULL), newNoiseLevelButton(NULL), deleteNoiseLevelButton(NULL),
      p_palette(palette_), p_table(NULL), color_delegate(this), value_delegate(this),
      p_model(new PaletteModel(p_palette, this))
{
#ifndef NDEBUG
    bool ok = false;
#endif
 
    QVBoxLayout* main_layout = new QVBoxLayout(this);
    QFrame* hframe = new QFrame();
    main_layout->addWidget(hframe);
 
    QHBoxLayout* addEntryLayout = new QHBoxLayout(hframe);
    addEntryLayout->addWidget(new QLabel(TR("id_noise_level"), hframe), 1);
 
    newNoiseLevelSpin = new QDoubleSpinBox();
    newNoiseLevelSpin->setSuffix(" dBA");
    newNoiseLevelSpin->setMaximum(1000);
    newNoiseLevelSpin->setDecimals(1);
    addEntryLayout->addWidget(newNoiseLevelSpin, 1);
 
    newNoiseLevelButton = new QPushButton();
    newNoiseLevelButton->setText(TR("id_newentry"));
#ifndef NDEBUG
    ok =
#endif
        QObject::connect(newNoiseLevelButton, &QPushButton::pressed, this, &PaletteEditor::addNoiseLevel);
    assert(ok && "Connection failed for addNoiseLevel");
    addEntryLayout->addWidget(newNoiseLevelButton, 1);
 
    deleteNoiseLevelButton = new QPushButton();
    deleteNoiseLevelButton->setText(TR("id_delete_sel"));
#ifndef NDEBUG
    ok =
#endif
        QObject::connect(deleteNoiseLevelButton, &QPushButton::pressed, this,
                         &PaletteEditor::deleteNoiseLevels);
    assert(ok && "Connection failed for addNoiseLevel");
    addEntryLayout->addWidget(deleteNoiseLevelButton, 1);
 
    p_table = new QTableView(this);
    p_table->setModel(p_model);
    main_layout->addWidget(p_table, 1);
    p_table->setItemDelegateForColumn(0, &value_delegate);
    p_table->setItemDelegateForColumn(1, &color_delegate);
 
#ifndef NDEBUG
    ok =
#endif
        connect(p_model, &PaletteModel::dataChanged, this, &PaletteEditor::propagateModelChanges);
    assert(ok && "Connection failed for slot propagateModelChanges");
}
 
PaletteEditor::~PaletteEditor() {}
 
void PaletteEditor::notifyTYPaletteExternalyChanged()
{
    emit paletteChanged(p_palette);
};
 
void PaletteEditor::propagateModelChanges(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
    emit paletteChanged(p_palette);
}
 
void PaletteEditor::addNoiseLevel()
{
    qobject_cast<PaletteModel*>(p_table->model())->addRow(newNoiseLevelSpin->value());
}
 
void PaletteEditor::deleteNoiseLevels()
{
    qobject_cast<PaletteModel*>(p_table->model())->deleteSelectedRows();
}
 
// ================================================================================
 
TYPaletteLimitsWidget::TYPaletteLimitsWidget(TYPalette* pElement, QWidget* _pParent)
    : QDialog(_pParent), _pElement(pElement)
{
    Q_ASSERT(pElement);
    setWindowTitle(TR("id_caption_limits"));
    resize(300, 174);
 
    QGroupBox* _groupBox = new QGroupBox(this);
    QGridLayout* internalLayout = new QGridLayout();
    _groupBox->setLayout(internalLayout);
    _label_lower_bound = new QLabel(_groupBox);
    _label_lower_bound->setText(TR("id_lb_label"));
    _label_upper_bound = new QLabel(_groupBox);
    _label_upper_bound->setText(TR("id_ub_label"));
    _label_nb_colors = new QLabel(_groupBox);
    _label_nb_colors->setText(TR("id_nb_label"));
    _lineEdit_lower_bound = new TYLineEdit(_groupBox);
    _lineEdit_upper_bound = new TYLineEdit(_groupBox);
    _lineEdit_nb_colors = new QLineEdit(_groupBox);
    internalLayout->addWidget(_label_lower_bound, 0, 0);
    internalLayout->addWidget(_lineEdit_lower_bound, 0, 1);
    internalLayout->addWidget(_label_upper_bound, 1, 0);
    internalLayout->addWidget(_lineEdit_upper_bound, 1, 1);
    internalLayout->addWidget(_label_nb_colors, 2, 0);
    internalLayout->addWidget(_lineEdit_nb_colors, 2, 1);
 
    QBoxLayout* pBtnLayout = new QHBoxLayout();
 
    pBtnLayout->addStretch(1);
 
    QPushButton* pButtonOK = new QPushButton(TR("id_ok_btn"), this);
    pButtonOK->setDefault(true);
    QObject::connect(pButtonOK, &QPushButton::clicked, this, &TYPaletteLimitsWidget::apply);
    pBtnLayout->addWidget(pButtonOK);
 
    QPushButton* pButtonCancel = new QPushButton(TR("id_cancel_btn"), this);
    pButtonCancel->setShortcut(Qt::Key_Escape);
    QObject::connect(pButtonCancel, &QPushButton::clicked, this, &TYPaletteLimitsWidget::reject);
    pBtnLayout->addWidget(pButtonCancel);
 
    internalLayout->addLayout(pBtnLayout, 3, 1);
    updateContent();
}
 
void TYPaletteLimitsWidget::updateContent()
{
    _lineEdit_lower_bound->setText(QString().setNum(_pElement->getValueMin(), 'f', 2));
    _lineEdit_upper_bound->setText(QString().setNum(_pElement->getValueMax(), 'f', 2));
    _lineEdit_nb_colors->setText(QString().setNum(_pElement->getNbColors()));
}
 
void TYPaletteLimitsWidget::apply()
{
    double lower_bound = _lineEdit_lower_bound->text().toDouble();
    double upper_bound = _lineEdit_upper_bound->text().toDouble();
    unsigned int nb_colors = _lineEdit_nb_colors->text().toUInt();
 
    _pElement->makeLinearPalette(nb_colors, lower_bound, upper_bound);
    accept();
}