TYResultatWidget.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 <cstdlib>
#include <qradiobutton.h>
#include <qbuttongroup.h>
#include <qtablewidget.h>
#include <qcombobox.h>
#include <qmenu.h>
#include <qfiledialog.h>
#include <qpainter.h>
 
// Added by qt3to4:
#include <QHBoxLayout>
#include <QBoxLayout>
#include <QGridLayout>
#include <QFrame>
#include <QPixmap>
#include <QHeaderView>
#include <QtWidgets>
 
#include <QtPrintSupport/QPrinter>
#include <QtPrintSupport/QPrintDialog>
 
#include "Tympan/core/logging.h"
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/TYResultat.h"
#include "Tympan/models/business/acoustic/TYUserSourcePonctuelle.h"
#include "Tympan/models/business/geoacoustic/TYAcousticVolumeNode.h"
#include "Tympan/models/business/geoacoustic/TYAcousticLine.h"
#include "Tympan/models/business/TYProjet.h"
#include "Tympan/models/business/TYCalcul.h"
#include "Tympan/models/business/TYPreferenceManager.h"
#include "Tympan/gui/widgets/TYPrintDialog.h"
#include "Tympan/gui/widgets/TYLineEdit.h"
#include "TYResultatTreeDialog.h"
#include "TYResultatWidget.h"
 
using namespace QXlsx;
 
#define TR(id) OLocalizator::getString("TYResultatWidget", (id))
#define IMG(id) OLocalizator::getPicture("TYResultatWidget", (id))
 
// Declaration de la fonction utilisee par qsort pour le tri des valeurs numerique
static int compareRes(const void* elem1, const void* elem2);
 
// Declaration de la fonction utilisee par qsort pour le tri par nom des sources
static int compareName(const void* elem1, const void* elem2);
 
TYResultatWidget::TYResultatWidget(TYResultat* pElement, QWidget* _pParent /*=nullptr*/)
    : TYWidget(pElement, _pParent)
{
    _freq = 100;
    _choixOperation = 0;
    _nbSources = 0;
    _nbRecepteurs = 0;
    _nbLignes = 0;
    _nbColonnes = 0;
 
    resize(300, 50);
    setWindowTitle(TR("id_caption"));
    _resultatLayout = new QGridLayout();
    setLayout(_resultatLayout);
 
    // Placement de l'element (evite de renumeroter les lignes chaque fois qu'on deplace un widget)
    int iln = 0;
 
    QGroupBox* groupBoxFlag = new QGroupBox(this);
    groupBoxFlag->setTitle(TR(""));
    QGridLayout* groupBoxFlagLayout = new QGridLayout();
    groupBoxFlag->setLayout(groupBoxFlagLayout);
 
    // Bouton radio dB(A)/dB(Lin)/dB(freq)
    QButtonGroup* buttonGroupALIN = new QButtonGroup();
    _radioButtonDBA = new QRadioButton(TR("id_radiobutton_db_a"));
    buttonGroupALIN->addButton(_radioButtonDBA, 0);
    _radioButtonDBLIN = new QRadioButton(TR("id_radiobutton_db_lin"));
    buttonGroupALIN->addButton(_radioButtonDBLIN, 1);
    _radioButtonDBFRQ = new QRadioButton(TR("id_radiobutton_db_freq"));
    buttonGroupALIN->addButton(_radioButtonDBFRQ, 2);
 
    _choixAffichage = DBA; // Affichage par defaut dBA
    _radioButtonDBA->setChecked(true);
    _radioButtonDBLIN->setChecked(false);
    _radioButtonDBFRQ->setChecked(false);
 
    //  ComboBox de choix des frequences
    _comboBoxFreq = new QComboBox();
    updateFreqList();
    _comboBoxFreq->setEnabled(false);
 
    // Gestion des seuils de contribution (affichage colore)
    QLabel* pLabelContribution = new QLabel(this);
    pLabelContribution->setText(TR("id_label_contribution"));
 
    static const char dirName[] = "UserPreferences";
 
    _pContributionLineEditBas = new TYLineEdit(this);
    _pContributionLineEditBas->setFixedSize(50, 20);
    QString val;
    if (TYPreferenceManager::getInstance().exists(dirName, "TYAcousticSeuilContribBas"))
        val = QString::number(
            TYPreferenceManager::getInstance().getDouble(dirName, "TYAcousticSeuilContribBas"));
    else
    {
        val = QString::number(3);
        TYPreferenceManager::getInstance().setDouble("TYAcousticSeuilContribBas", 3);
    }
    QString leqBas = "Leq - " + QString(val) + " dB";
    _pContributionLineEditBas->setText(val);
 
    _pContributionLineEditMoy = new TYLineEdit(this);
    _pContributionLineEditMoy->setFixedSize(50, 20);
 
    if (TYPreferenceManager::getInstance().exists(dirName, "TYAcousticSeuilContribMoy"))
        val = QString::number(
            TYPreferenceManager::getInstance().getDouble(dirName, "TYAcousticSeuilContribMoy"));
    else
    {
        val = QString::number(1.5);
        TYPreferenceManager::getInstance().setDouble("TYAcousticSeuilContribMoy", 1.5);
    }
    QString leqMoy = "Leq - " + QString(val) + " dB";
    _pContributionLineEditMoy->setText(val);
 
    _pContributionLineEditHaut = new TYLineEdit(this);
    _pContributionLineEditHaut->setFixedSize(50, 20);
 
    if (TYPreferenceManager::getInstance().exists(dirName, "TYAcousticSeuilContribHaut"))
        val = QString::number(
            TYPreferenceManager::getInstance().getDouble(dirName, "TYAcousticSeuilContribHaut"));
    else
    {
        val = QString::number(0.5);
        TYPreferenceManager::getInstance().setDouble("TYAcousticSeuilContribHaut", 0.5);
    }
    QString leqHaut = "Leq - " + QString(val) + " dB";
    _pContributionLineEditHaut->setText(val);
 
    _pLabelLeqBas = new QLabel(this);
    _pLabelLeqBas->setText(leqBas);
    _pLabelLeqMoy = new QLabel(this);
    _pLabelLeqMoy->setText(leqMoy);
    _pLabelLeqHaut = new QLabel(this);
    _pLabelLeqHaut->setText(leqHaut);
    _pLabelLeq100 = new QLabel(this);
    _pLabelLeq100->setText(QString("Leq"));
    _pLabelPres = new QLabel(this);
    _pLabelPres->setText(TR("id_label_pres"));
    _pLabelPres->setAlignment(Qt::AlignLeft);
 
    _pLabelPctBas = new QLabel(this);
    _pLabelPctMoy = new QLabel(this);
    _pLabelPctHaut = new QLabel(this);
    _pLabelPct100 = new QLabel(this);
    _pLabelPct100->setText(QString("100 %"));
    _pLabelEner = new QLabel(this);
    _pLabelEner->setText(TR("id_label_ener"));
    _pLabelEner->setAlignment(Qt::AlignLeft);
 
    _pLabelLeqBas->setFixedWidth(210);
    _pLabelLeqMoy->setFixedWidth(85);
    _pLabelLeqHaut->setFixedWidth(80);
    _pLabelLeq100->setFixedWidth(25);
 
    _pLabelLeqBas->setAlignment(Qt::AlignRight);
    _pLabelLeqMoy->setAlignment(Qt::AlignRight);
    _pLabelLeqHaut->setAlignment(Qt::AlignRight);
    _pLabelLeq100->setAlignment(Qt::AlignHCenter);
 
    _pLabelPctBas->setFixedWidth(210);
    _pLabelPctMoy->setFixedWidth(85);
    _pLabelPctHaut->setFixedWidth(75);
    _pLabelPct100->setFixedWidth(30);
 
    _pLabelPctBas->setAlignment(Qt::AlignRight);
    _pLabelPctMoy->setAlignment(Qt::AlignRight);
    _pLabelPctHaut->setAlignment(Qt::AlignRight);
    _pLabelPct100->setAlignment(Qt::AlignRight);
 
    // Ajout au layout
    QGridLayout* groupBoALINLayout = new QGridLayout();
    groupBoALINLayout->addWidget(_radioButtonDBA, 0, 0);
    groupBoALINLayout->addWidget(_radioButtonDBLIN, 0, 1);
    groupBoALINLayout->addWidget(_radioButtonDBFRQ, 0, 2);
    groupBoALINLayout->addWidget(_comboBoxFreq, 0, 3);
 
    groupBoALINLayout->addWidget(pLabelContribution, 1, 0);
    groupBoALINLayout->addWidget(_pContributionLineEditBas, 1, 1);
    groupBoALINLayout->addWidget(_pContributionLineEditMoy, 1, 2);
    groupBoALINLayout->addWidget(_pContributionLineEditHaut, 1, 3);
 
    QWidget* _pHorizontalLineWidget = new QWidget;
    _pHorizontalLineWidget->setFixedHeight(2);
    _pHorizontalLineWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    _pHorizontalLineWidget->setStyleSheet(QString("background-color: #c0c0c0;"));
 
    QSpacerItem* vspace = new QSpacerItem(50, 50);
    groupBoALINLayout->addItem(vspace, 1, 0);
    groupBoALINLayout->addWidget(_pHorizontalLineWidget, 2, 1, 1, 3);
 
    groupBoALINLayout->addWidget(_pLabelLeqBas, 3, 0);
    groupBoALINLayout->addWidget(_pLabelLeqMoy, 3, 1);
    groupBoALINLayout->addWidget(_pLabelLeqHaut, 3, 2);
    groupBoALINLayout->addWidget(_pLabelLeq100, 3, 3);
    groupBoALINLayout->addWidget(_pLabelPres, 3, 4);
 
    QPixmap pixmap(IMG("id_pixmap_niveau"));
    QLabel* labmap = new QLabel(this);
    labmap->setPixmap(pixmap.scaledToWidth(400));
    groupBoALINLayout->addWidget(labmap, 4, 0, 1, 4);
 
    groupBoALINLayout->addWidget(_pLabelPctBas, 5, 0);
    groupBoALINLayout->addWidget(_pLabelPctMoy, 5, 1);
    groupBoALINLayout->addWidget(_pLabelPctHaut, 5, 2);
    groupBoALINLayout->addWidget(_pLabelPct100, 5, 3);
    groupBoALINLayout->addWidget(_pLabelEner, 5, 4);
 
    QGroupBox* groupBoxALIN = new QGroupBox();
    groupBoxALIN->setTitle(TR(""));
    groupBoxALIN->setLayout(groupBoALINLayout);
 
    groupBoxFlagLayout->addWidget(groupBoxALIN, 0, 0);
 
    // Disambiguate the overloaded signals
    void (QComboBox::*_qComboBox_activated)(int) = &QComboBox::activated;
    void (QButtonGroup::*_qButtonGroup_clicked)(int) = &QButtonGroup::idClicked;
 
    // Choix du type d'operation a effectuer (Aucun / Difference / Emergence / Bruit ambiant)
    _buttonGroupOperation = new QButtonGroup();
    _radioButtonNoOp = new QRadioButton((TR("id_radiobutton_noop")));
    _buttonGroupOperation->addButton(_radioButtonNoOp, 0);
    _radioButtonDelta = new QRadioButton(TR("id_radiobutton_delta"));
    _buttonGroupOperation->addButton(_radioButtonDelta, 1);
    _radioButtonEmergence = new QRadioButton(TR("id_radiobutton_emergence"));
    _buttonGroupOperation->addButton(_radioButtonEmergence, 2);
    _radioButtonAmbiant = new QRadioButton(TR("id_radiobutton_ambiant"));
    _buttonGroupOperation->addButton(_radioButtonAmbiant, 3);
 
    _radioButtonNoOp->setChecked(true);
    _radioButtonDelta->setChecked(false);
    _radioButtonEmergence->setChecked(false);
    _radioButtonAmbiant->setChecked(false);
 
    // Choix du calcul associe au resultat
    QLabel* labelSubstCalcul = new QLabel(this);
    labelSubstCalcul->setText(TR("id_subst_calcul"));
    _comboBoxSubstCalcul = new QComboBox(this);
    connect(_comboBoxSubstCalcul, _qComboBox_activated, this, &TYResultatWidget::changeSubstCalcul);
 
    QGridLayout* groupBoxCalculLayout = new QGridLayout();
    groupBoxCalculLayout->addWidget(_radioButtonNoOp, 0, 0, Qt::AlignLeft);
    groupBoxCalculLayout->addWidget(_radioButtonDelta, 1, 0, Qt::AlignLeft);
    groupBoxCalculLayout->addWidget(_radioButtonEmergence, 2, 0, Qt::AlignLeft);
    groupBoxCalculLayout->addWidget(_radioButtonAmbiant, 3, 0, Qt::AlignLeft);
    groupBoxCalculLayout->addWidget(labelSubstCalcul, 0, 1, Qt::AlignRight);
    groupBoxCalculLayout->addWidget(_comboBoxSubstCalcul, 0, 2, Qt::AlignLeft);
 
    QGroupBox* groupBoxCalcul = new QGroupBox();
    groupBoxCalcul->setTitle(TR(""));
    groupBoxCalcul->setLayout(groupBoxCalculLayout);
 
    groupBoxFlagLayout->addWidget(groupBoxCalcul, 0, 1);
 
    _resultatLayout->addWidget(groupBoxFlag, iln, 0);
 
    // Table des resultats
    _pTable = new QTableWidget();
    _pTable->setSelectionMode(QAbstractItemView::NoSelection);
    _pTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    _resultatLayout->addWidget(_pTable, ++iln, 0);
 
    QGroupBox* pGroupBox = new QGroupBox(this);
    QHBoxLayout* pGroupBoxLayout = new QHBoxLayout();
    pGroupBox->setLayout(pGroupBoxLayout);
 
    _pButtonExportXlsx = new QPushButton(TR("id_export_global_xlsx"));
    pGroupBoxLayout->addWidget(_pButtonExportXlsx);
    _pButtonExportXlsx->setEnabled(true);
 
    _pButtonExport = new QPushButton(TR("id_export_global"));
    pGroupBoxLayout->addWidget(_pButtonExport);
    _pButtonExport->setEnabled(true);
 
    _pButtonExportSpectre = new QPushButton(TR("id_export_spectres"));
    pGroupBoxLayout->addWidget(_pButtonExportSpectre);
    _pButtonExportSpectre->setEnabled(true);
 
    QPushButton* pButtonPrint = new QPushButton(TR("id_print"));
    pGroupBoxLayout->addWidget(pButtonPrint);
 
    _resultatLayout->addWidget(pGroupBox, ++iln, 0);
 
    // Permettre le tri en cliquant sur le haut d'une colonne
    QHeaderView* entetesRecepteurs =
        _pTable->horizontalHeader(); // On recupere un pointeur sur les entetes horizontales
    entetesRecepteurs->resizeSections(QHeaderView::ResizeToContents);
    QObject::connect(entetesRecepteurs, &QHeaderView::sectionClicked, this, &TYResultatWidget::sortCol);
 
    QObject::connect(_pContributionLineEditBas, &QLineEdit::textChanged, this,
                     &TYResultatWidget::slotContributionLineEditChanged);
    QObject::connect(_pContributionLineEditMoy, &QLineEdit::textChanged, this,
                     &TYResultatWidget::slotContributionLineEditChanged);
    QObject::connect(_pContributionLineEditHaut, &QLineEdit::textChanged, this,
                     &TYResultatWidget::slotContributionLineEditChanged);
    QObject::connect(buttonGroupALIN, _qButtonGroup_clicked, this, &TYResultatWidget::changeAffichage);
    QObject::connect(_comboBoxFreq, _qComboBox_activated, this, &TYResultatWidget::setFrequency);
    QObject::connect(_buttonGroupOperation, _qButtonGroup_clicked, this, &TYResultatWidget::changeOperation);
    QObject::connect(_pButtonExportXlsx, &QPushButton::clicked, this, &TYResultatWidget::exportExcelXlsx);
    QObject::connect(_pButtonExport, &QPushButton::clicked, this, &TYResultatWidget::exportExcel);
    QObject::connect(_pButtonExportSpectre, &QPushButton::clicked, this, &TYResultatWidget::exportSpectre);
    QObject::connect(pButtonPrint, &QPushButton::clicked, this, &TYResultatWidget::print);
 
    // Tableau pour le tri des resultats
    _tabSortedRes = new TYStructIndiceResultat[getElement()->getNbOfSources()];
 
    _seuilContributionBas = _pContributionLineEditBas->text().toDouble();
    _seuilContributionMoy = _pContributionLineEditMoy->text().toDouble();
    _seuilContributionHaut = _pContributionLineEditHaut->text().toDouble();
 
    _pLabelPctBas->setText(QString::number(calcPct(_seuilContributionBas)) + QString(" %"));
    //  _pLabelPctBas->setMaximumWidth(90);
    _pLabelPctMoy->setText(QString::number(calcPct(_seuilContributionMoy)) + QString(" %"));
    // _pLabelPctBas->setFixedWidth(25);
    _pLabelPctHaut->setText(QString::number(calcPct(_seuilContributionHaut)) + QString(" %"));
    // _pLabelPctBas->setFixedWidth(25);
    // _pLabelPct100->setFixedWidth(25);
 
    groupBoALINLayout->setAlignment(Qt::AlignRight);
 
    TYPreferenceManager::completePreferences();
 
    updateContent();
 
    _printer = new QPrinter();
}
 
TYResultatWidget::~TYResultatWidget()
{
 
    if (_tabSortedRes)
    {
        delete[] _tabSortedRes;
    }
 
    if (_printer)
    {
        delete _printer;
    }
 
    _tabSortedRes = nullptr;
    _printer = nullptr;
}
 
void TYResultatWidget::updateContent()
{
    // ACtualisation du combo des calculs
    updateComboSubstCalculs();
 
    // Par defaut le combo des frequences est positionne a 100 Hz
    int indFreq = TYSpectre::getIndice(100);
    _comboBoxFreq->setCurrentIndex(indFreq);
 
    _nbSources = static_cast<int>(getElement()->getNbOfSources());
    _nbRecepteurs = static_cast<int>(getElement()->getNbOfRecepteurs());
    _nbLignes = _nbSources + 1;      // Ajouter la ligne "synthese"
    _nbColonnes = _nbRecepteurs + 2; // Ajouter les colonnes "Nom sources", et "Puissance source"
 
    // Initialisation du tableau des contributions cumulées
    _cumulatedContribs = std::vector<std::vector<double>>(_nbSources, std::vector<double>(_nbRecepteurs, 0));
 
    // Nb lignes = Nb sources + 1 car on ajoute la synthese ligne 1
    _pTable->setRowCount(_nbLignes);
 
    // Nb colonnes = Nb recepteurs + 2 car : nom des sources en colonne 1 et puissance sources en colonne 2
    _pTable->setColumnCount(_nbColonnes);
 
    // une boucle pour mettre les entetes horizontales (numeros des lignes)
    for (unsigned int row = 0; row < _nbLignes; row++)
    {
        _pTable->setVerticalHeaderItem(row, new QTableWidgetItem(QString().setNum(row)));
    }
 
    updateHeaderLabel();
 
    // L'entete de la colonne 1 indique que cette colonne donne acces a la puissance
    _pTable->setHorizontalHeaderItem(1, new QTableWidgetItem(QString("LW")));
 
    // une boucle pour mettre les nom des recepteurs
    for (unsigned int col = 0; col < _nbRecepteurs; col++)
    {
        if (getElement()->getRecepteur(col) == nullptr)
        {
            continue;
        }
 
        QString titre = getElement()->getRecepteur(col)->getName();
        _pTable->setHorizontalHeaderItem(col + 2, new QTableWidgetItem(titre));
    }
 
    // On trie par ordre decroissant des niveaux du premier point
    sortCol(1);
 
    _pTable->setColumnHidden(1, getElement()->isLWHidden());
    sortColumnsByHeaderText();
}
 
void TYResultatWidget::updateHeaderLabel()
{
    QString strVal; // Cree ici car pb avec switch/case
    // L'entete de la colonne 0 rappelle le choix d'affichage
    switch (_choixAffichage)
    {
        case DBLIN:
            _pTable->setHorizontalHeaderItem(0, new QTableWidgetItem(QString("dBZ")));
            break;
        case DBFREQ:
            strVal = QString("dB(") + QString("%1").arg(_freq) + QString(" Hz)");
            _pTable->setHorizontalHeaderItem(0, new QTableWidgetItem(strVal));
            break;
        case DBA:
        default:
            _pTable->setHorizontalHeaderItem(0, new QTableWidgetItem(QString("dBA")));
            break;
    }
}
 
void TYResultatWidget::apply() {}
 
void TYResultatWidget::changeSubstCalcul(int calcul)
{
    updateTable();
}
void TYResultatWidget::updateComboSubstCalculs()
{
    _comboBoxSubstCalcul->clear();
 
    // Remplissage du comboBox des calculs
    if (_pElement->getParent()->getParent()->isA("TYProjet"))
    {
        TYProjet* pProjet = TYProjet::safeDownCast(getElement()->getParent()->getParent());
 
        TYTabLPCalcul listCalcul = pProjet->getListCalcul();
        for (int i = 0; i < listCalcul.size(); i++)
        {
            _comboBoxSubstCalcul->insertItem(i, listCalcul[i]->getName());
        }
    }
 
    // On affiche la forme d'objet courante
    _comboBoxSubstCalcul->setCurrentIndex(0);
 
    // Si mode de calcul = none alors le combo est bloque
    if (_choixOperation == 0)
    {
        _comboBoxSubstCalcul->setEnabled(false);
    }
    else
    {
        _comboBoxSubstCalcul->setEnabled(true);
    }
}
 
TYCalcul* TYResultatWidget::getSelectedSubstCalcul()
{
    if (_pElement->getParent()->getParent()->isA("TYProjet"))
    {
        if (!_radioButtonNoOp->isChecked())
        {
            int calcul = _comboBoxSubstCalcul->currentIndex();
            TYProjet* pProjet = TYProjet::safeDownCast(getElement()->getParent()->getParent());
            return pProjet->getListCalcul()[calcul];
        }
    }
    return nullptr;
}
 
void TYResultatWidget::exportSpectre()
{
    TYResultat* pResultat = TYResultat::safeDownCast(getElement());
    if (!pResultat)
    {
        return;
    } // Securite
 
    QString qFileName = QFileDialog::getSaveFileName(this, "Choose a file", "", "CSVFile (*.csv)");
 
    if (!qFileName.isNull())
    {
        if (qFileName.right(3) != "csv")
        {
            qFileName += ".csv";
        }
 
        pResultat->saveSpectre(qFileName, getSelectedSubstCalcul());
    }
}
 
void TYResultatWidget::exportExcelXlsx()
{
    TYResultat* pResultat = TYResultat::safeDownCast(getElement());
 
    if (!pResultat)
    {
        return;
    } // Security
 
    QString qFileName = QFileDialog::getSaveFileName(this, "Choose a file", "", "Classeur Excel (*.xlsx)");
 
    if (!qFileName.isEmpty())
    {
        QFileInfo fileInfo(qFileName);
        if (fileInfo.suffix().toLower() != "xlsx")
        {
            qFileName += ".xlsx";
        }
 
        Document documentQXlsx;
        documentQXlsx.workbook()->setStringsToNumbersEnabled(true);
 
        // Onglet 1 : Contributions
        documentQXlsx.addSheet("Contributions");
        documentQXlsx.selectSheet("Contributions");
        exportContributionsTableToSheet(documentQXlsx);
 
        // Onglet 2 : Contributions cumulées
        documentQXlsx.addSheet("Contributions cumulées");
        documentQXlsx.selectSheet("Contributions cumulées");
        exportCumulatedContributionsTableToSheet(documentQXlsx);
 
        documentQXlsx.selectSheet("Contributions");
 
        if (!documentQXlsx.saveAs(qFileName))
 
        {
            QMessageBox::warning(this, tr("Erreur de sauvegarde"),
                                 tr("Impossible d'enregistrer le fichier Excel.\n"
                                    "Il est peut-être déjà ouvert dans une autre "
                                    "application.\n\n"
                                    "Veuillez fermer le fichier ou choisir un autre nom pour l'export."));
        }
    }
}
 
void TYResultatWidget::exportContributionsTableToSheet(Document& documentQXlsx)
{
    int columnCount = _pTable->columnCount();
    int rowCount = _pTable->rowCount();
 
    writeContributionsTableRow(columnCount, 0, documentQXlsx);
    writeColHeadersToSheet(documentQXlsx, columnCount /* maxCharCount*/);
 
    // Write row headers and cell contents
    for (int row = 1; row < rowCount; ++row)
    {
        writeRowHeadersToSheet(row, documentQXlsx);
        writeContributionsTableRow(columnCount, row, documentQXlsx);
    }
    adjustXlsxDocumentColumnWidths(columnCount, documentQXlsx);
}
 
void TYResultatWidget::writeContributionsTableRow(int columnCount, int row, QXlsx::Document& documentQXlsx)
{
    int xlsxRow = getXlsxRow(row);
    QHeaderView* hh = _pTable->horizontalHeader();
 
    for (int visualIndex = 0; visualIndex < columnCount; ++visualIndex)
    {
        QXlsx::Format format;
        int col = hh->logicalIndex(visualIndex);
        QTableWidgetItem* item = _pTable->item(row, col);
        if (!item)
            continue;
 
        QString cellText = item->text();
 
        getFormatFromContributionsTable(item, format);
 
        // Write with or without format depending on the case
        if (format.isValid())
            documentQXlsx.write(xlsxRow, visualIndex + 2, cellText, format);
        else
            documentQXlsx.write(xlsxRow, visualIndex + 2, cellText);
    }
}
 
int TYResultatWidget::getXlsxRow(int row)
{
    int xlsxRow = 1;
    // La synthèse au-dessus des autres lignes pour faciliter le tri
    if (row != 0)
    {
        xlsxRow = row + 2;
    }
    return xlsxRow;
}
 
void TYResultatWidget::exportCumulatedContributionsTableToSheet(Document& documentQXlsx)
{
    int columnCount = _pTable->columnCount();
    int rowCount = _pTable->rowCount();
    writeCumulatedContributionsTableRow(columnCount, 0, documentQXlsx);
    writeColHeadersToSheet(documentQXlsx, columnCount);
 
    for (int row = 1; row < rowCount; ++row)
    {
        writeRowHeadersToSheet(row, documentQXlsx);
        writeCumulatedContributionsTableRow(columnCount, row, documentQXlsx);
    }
    adjustXlsxDocumentColumnWidths(columnCount, documentQXlsx);
}
 
void TYResultatWidget::adjustXlsxDocumentColumnWidths(int columnCount, QXlsx::Document& documentQXlsx)
{
    // Ajustement automatique des colonnes
    for (int col = 0; col <= columnCount + 1; ++col)
    {
        documentQXlsx.autosizeColumnWidth(col + 1);
    }
}
 
void TYResultatWidget::writeCumulatedContributionsTableRow(int columnCount, int row,
                                                           QXlsx::Document& documentQXlsx)
{
    int xlsxRow = getXlsxRow(row);
    QHeaderView* hh = _pTable->horizontalHeader();
 
    for (int visualIndex = 0; visualIndex < columnCount; ++visualIndex)
    {
        QXlsx::Format format;
        int col = hh->logicalIndex(visualIndex);
        QTableWidgetItem* item = _pTable->item(row, col);
        QString cellText;
        if (!item)
            continue;
        if (col <= 1 || row == 0) // La synthèse, les noms et les puissances des sources
        {
            cellText = item->text();
        }
        else
        {
            cellText = QString("%1").arg(_cumulatedContribs[row - 1][col - 2], 7, 'f', 1);
        }
 
        getFormatFromContributionsTable(item, format);
 
        // Write with or without format depending on the case
        if (format.isValid())
            documentQXlsx.write(xlsxRow, visualIndex + 2, cellText, format);
        else
            documentQXlsx.write(xlsxRow, visualIndex + 2, cellText);
    }
}
 
void TYResultatWidget::writeRowHeadersToSheet(int row, QXlsx::Document& documentQXlsx)
{
    int xlsxRow = getXlsxRow(row);
 
    QString rowHeader =
        _pTable->verticalHeaderItem(row) ? _pTable->verticalHeaderItem(row)->text() : QString();
 
    documentQXlsx.write(xlsxRow, 1, rowHeader);
}
 
void TYResultatWidget::getFormatFromContributionsTable(QTableWidgetItem* item, QXlsx::Format& format)
{
    // Apply background color only if it is defined
    QVariant bgVariant = item->data(Qt::BackgroundRole);
    if (bgVariant.isValid())
    {
        QColor bgColor = bgVariant.value<QColor>();
 
        // If color is different from Qt::white or trnasparent, apply it
        if (bgColor.isValid() && bgColor != Qt::white && bgColor.alpha() > 0)
        {
            format.setPatternBackgroundColor(bgColor);
        }
        // Else, do not apply any format to leave grid pattern visible
    }
}
 
void TYResultatWidget::writeColHeadersToSheet(QXlsx::Document& documentQXlsx, int columnCount)
{
    // Write column headers (shifted by 1 to the right)
    documentQXlsx.write(1, 1, ""); // Top-left cell left empty
    QHeaderView* hh = _pTable->horizontalHeader();
    for (int visualIndex = 0; visualIndex < columnCount; ++visualIndex)
    {
        int col = hh->logicalIndex(visualIndex);
        QString headerText =
            _pTable->horizontalHeaderItem(col) ? _pTable->horizontalHeaderItem(col)->text() : QString();
        documentQXlsx.write(2, visualIndex + 2, headerText);
    }
}
 
void TYResultatWidget::exportExcel()
{
    TYResultat* pResultat = TYResultat::safeDownCast(getElement());
 
    if (!pResultat)
    {
        return;
    } // Securite
 
    QString qFileName = QFileDialog::getSaveFileName(this, "Choose a file", "", "CSVFile (*.csv)");
 
    if (!qFileName.isNull())
    {
        if (qFileName.right(3) != "csv")
        {
            qFileName += ".csv";
        }
 
        pResultat->saveValue(qFileName, _choixAffichage, _freq);
    }
}
 
void TYResultatWidget::contextMenuEvent(QContextMenuEvent* e)
{
    TYCalcul* pCalcul = TYCalcul::safeDownCast(getElement()->getParent());
    TYCalcul* pSubstCalcul = getSelectedSubstCalcul();
 
    QPoint point = _pTable->mapFrom(this, e->pos());
    if ((point.x() >= 0) && (point.y() >= 0) && (point.x() <= _pTable->width()) &&
        (point.y() <= _pTable->height()))
    {
        // It is not very explicit in Qt's QTableView documentation, but coordinates given to itemAt must be
        // in the viewport's coordinate system (viewport = cells displayed on screen -- headers excluded)
        QPoint resPoint = _pTable->viewport()->mapFrom(_pTable, point);
        QTableWidgetItem* item = _pTable->itemAt(resPoint);
        if (item)
        {
            int row = _pTable->indexAt(resPoint).row();
            row = row >= 0 ? row : 0; // Securite
            int col = _pTable->indexAt(resPoint).column();
            col = col >= 0 ? col : 0; // Securite
            int ligne = row > 0 ? _tabSortedRes[row - 1].indice : 0;
 
            OSpectre spectre1 = getSpectre(row, col, pCalcul);
            OSpectre spectre2 = getSpectre(row, col, pSubstCalcul);
 
            TYSpectre spectre = resuSpectre(spectre1, spectre2, 1);
 
            spectre.setType(SPECTRE_TYPE_LP);
            spectre = spectre.toDB();
 
            QAction *editSource = nullptr, *editRecepteur = nullptr, *editSpectre = nullptr,
                    *editContrib = nullptr;
 
            QMenu* pPopup = new QMenu(this);
            if ((row == 0) && (col > 1)) // Ligne de synthese
            {
                if (_choixOperation == 0) // pas d'operation
                {
                    editRecepteur = pPopup->addAction(TR("id_popup_see_recepteur"));
                    pPopup->addSeparator();
                }
                else
                {
                    editSpectre = pPopup->addAction(TR("id_popup_see_spectre"));
                }
 
                // Si on a conserve la matrice des resultats bruts
                if (getElement()->getPartialState())
                {
                    editContrib = pPopup->addAction(TR("id_popup_see_contrib"));
                }
            }
            else if ((row > 0) && (col > 1)) // Si on selectionne une contribution par source (!= synthese)
            {
                editSpectre = pPopup->addAction(TR("id_popup_see_spectre"));
                pPopup->addSeparator();
                editSource = pPopup->addAction(TR("id_popup_see_source"));
                pPopup->addSeparator();
                editRecepteur = pPopup->addAction(TR("id_popup_see_recepteur"));
            }
            else if ((row > 0) && (col == 0))
            {
                editSource = pPopup->addAction(TR("id_popup_see_source"));
            }
            else if ((row > 0) && (col == 1))
            {
                editSource = pPopup->addAction(TR("id_popup_see_source"));
            }
 
            QAction* ret = pPopup->exec(_pTable->mapToGlobal(point));
 
            if (ret)
            {
                if (ret == editSource)
                {
                    getElement()->getSource(ligne)->edit(this);
                }
                else if (ret == editRecepteur)
                {
                    TYCalcul* pCalcul = static_cast<TYCalcul*>(getElement()->getParent());
                    TYPointCalcul* pPoint = getElement()->getRecepteur(col - 2);
                    LPTYSpectre pSpectre = nullptr;
 
                    if (pPoint)
                    {
                        pSpectre = pCalcul->getSpectre(pPoint->getID());
                    }
                    if (pSpectre == nullptr)
                    {
                        return;
                    }
 
                    // Si c'est un resultat calcule, on ne peut pas changer les valeurs
                    if (pCalcul && (pCalcul->getState() == TYCalcul::Actif))
                    {
                        pSpectre->setIsReadOnly(true);
                    }
                    else
                    {
                        pSpectre->setIsReadOnly(false);
                    }
 
                    pSpectre->edit(this);
 
                    // Si c'est une mesure, on actualise le tableau resultat
                    if (pCalcul && (pCalcul->getState() == TYCalcul::Locked))
                    {
                        updateTable();
                    }
                }
                else if (ret == editSpectre)
                {
                    spectre.setIsReadOnly(true);
                    spectre.edit(this);
                    spectre.setIsReadOnly(false);
                }
                else if (ret == editContrib)
                {
                    showContribTreeDialog(col);
                }
            }
        }
    }
}
 
void TYResultatWidget::print()
{
    TYPrintDialog* pDialog = new TYPrintDialog(this);
    pDialog->_groupBoxProjet->setEnabled(false);
    pDialog->_groupBoxCalcul->setEnabled(false);
    if (pDialog->exec() == QDialog::Accepted)
    {
        QPrintDialog dialog(_printer, this);
        if (dialog.exec())
        {
            QPainter paint(_printer);
 
            QPixmap tmpPix;
 
            int mid = int(_printer->width() / 2) -
                      int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTete->text()) / 2);
            paint.drawText(mid, 20, pDialog->_lineEditTete->text());
            mid = int(_printer->width() / 2) -
                  int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditPied->text()) / 2);
            paint.drawText(mid, _printer->height() - 20, pDialog->_lineEditPied->text());
            paint.setFont(QFont("Helvetica", 15, QFont::Bold));
            mid = int(_printer->width() / 2) -
                  int(paint.fontMetrics().horizontalAdvance(pDialog->_lineEditTitre->text()) / 2);
            paint.drawText(mid, 45, pDialog->_lineEditTitre->text());
            paint.setFont(QFont());
 
            int sizeX = 120, sizeY = 25;
            int ymax = int(double(_printer->height()) * 4 / 5 / (_pTable->rowCount() + 1));
            if (ymax < sizeY)
            {
                sizeY = ymax;
            }
            int x = int(double(_printer->width() - sizeX * (_pTable->columnCount())) / 2);
            int y = int((double(_printer->height()) - sizeY * (_pTable->rowCount() + 3)));
 
            int i = 0;
            for (i = 0; i < _pTable->horizontalHeader()->count(); i++)
            {
                paint.drawText(x, y, _pTable->horizontalHeaderItem(i)->text());
                paint.translate(sizeX, 0);
            }
 
            paint.translate(-_pTable->columnCount() * sizeX, 0);
            paint.translate(0, sizeY);
 
            for (i = 0; i < _pTable->rowCount(); i++)
            {
                for (int j = 0; j < _pTable->columnCount(); j++)
                {
                    if (_pTable->item(i, j))
                    {
                        paint.drawText(x, y, _pTable->item(i, j)->text()); // paintCell(&paint, i, j, QRect(0,
                                                                           // 0, sizeX, sizeY), false);
                    }
                    paint.translate(sizeX, 0);
                }
                paint.translate(0, sizeY);
                paint.translate(-_pTable->columnCount() * sizeX, 0);
            }
        }
    }
}
 
void TYResultatWidget::changeAffichage(int select)
{
    switch (select)
    {
        case 1:
            _choixAffichage = DBLIN; // Affichage dBLin
            _comboBoxFreq->setEnabled(false);
            break;
        case 2:
            _choixAffichage = DBFREQ; // Affichage par frequence
            _comboBoxFreq->setEnabled(true);
            break;
        case 0:
        default:
            _choixAffichage = DBA; // Affichage dBA
            _comboBoxFreq->setEnabled(false);
            break;
    }
 
    // Mets a jour le widget
    updateHeaderLabel();
    updateTable();
}
 
void TYResultatWidget::changeOperation(int select)
{
    _choixOperation = select;
 
    if (_choixOperation == 0)
    {
        _comboBoxSubstCalcul->setEnabled(false);
        _pButtonExport->setEnabled(true);
        _pButtonExportSpectre->setEnabled(true);
    }
    else
    {
        _comboBoxSubstCalcul->setEnabled(true);
        _pButtonExport->setEnabled(false);
        _pButtonExportSpectre->setEnabled(false);
    }
 
    // Mets a jour le widget
    updateTable();
}
 
void TYResultatWidget::updateTable()
{
    // On commence par remplir la premiere colonne avec les noms des sources
    QString titre = TR("id_entete_synthese");
    _pTable->setItem(0, 0, new QTableWidgetItem(titre));
    _pTable->setRowHeight(0, 30);
    _pTable->setColumnWidth(0, 140);
 
    for (unsigned int row = 1; row < _nbLignes; row++) // On commence apres la ligne synthese
    {
        TYElement* pSource = getElement()->getSource(_tabSortedRes[row - 1].indice);
        if (pSource == nullptr)
        {
            continue;
        }
 
        QString titre = pSource->getName();
        _pTable->setItem(row, 0, new QTableWidgetItem(titre));
        _pTable->setRowHeight(row, 30);
    }
 
    // Boucle sur les colonnes pour afficher le tableau
    TYCalcul* pCalcOp = getSelectedSubstCalcul();                       // Calcul à comparer
    TYCalcul* pCalcul = TYCalcul::safeDownCast(_pElement->getParent()); // Calcul sélectionné
 
    for (unsigned int col = 1; col < _nbColonnes; col++)
    {
        displayColumn(pCalcul, pCalcOp, col);
    }
}
 
void TYResultatWidget::displayColumn(TYCalcul* pCalcul, TYCalcul* pCalcOp, const int& col)
{
    std::vector<int> couleur = calcCumulatedContribution(col, pCalcul, pCalcOp);
 
    for (unsigned int row = 0; row < _nbLignes; row++)
    {
        OSpectre spectre1 = getSpectre(row, col, pCalcul);
        OSpectre spectre2 = getSpectre(row, col, pCalcOp);
 
        QTableWidgetItem* pItem = nullptr;
        QString msg;
        double valeur = 0.0;
        bool valid = true;
 
        if (row == 0)
        {
            if (col > 1) // La case (0,1) est vide
            {
                valeur = resuAffichage(spectre1, spectre2, valid, CELL_SYNTH);
                msg = QString("%1").arg(valeur, 7, 'f', 1);
                pItem = new QTableWidgetItem(msg);
                decorsSynthese(pItem, row, col, valid, spectre1, spectre2);
                _pTable->setItem(row, col, pItem);
                _pTable->setRowHeight(row, 30);
            }
        }
        else if (col > 1) // Tout sauf ligne de synthese ou puissance de source
        {
            valeur = resuAffichage(spectre1, spectre2, valid, CELL_CONTRIB);
            msg = QString("%1").arg(valeur, 7, 'f', 1);
            pItem = new QTableWidgetItem(msg);
            decorsContributions(pItem, row, col, valid, couleur);
            _pTable->setItem(row, col, pItem);
            _pTable->setRowHeight(row, 30);
        }
        else // A priori, il ne reste que la puissance de la source
        {
            spectre2 = OSpectre(); // La puissance affichee correspond a la puissance de la source du
                                   // calcul courant
            valeur = resuAffichage(spectre1, spectre2, valid, CELL_LW);
            msg = QString("%1").arg(valeur, 7, 'f', 1);
            pItem = new QTableWidgetItem(msg);
            decorsContributions(pItem, row, col, valid, couleur);
            _pTable->setItem(row, col, pItem);
            _pTable->setRowHeight(row, 30);
        }
    }
    if (col >= 1)
    {
        _pTable->setColumnWidth(col, 50);
    }
}
 
OSpectre TYResultatWidget::getSpectre(const int& row, const int& col, TYCalcul* pCalcul)
{
    OSpectre spectre;
    spectre.setValid(false);
 
    if ((!pCalcul) || (col == 0))
    {
        return spectre;
    } // Cas de la colonne des noms de source
 
    if (col == 1) // Spectre de puissance d'une source
    {
        if (row > 0)
        {
            spectre = getPuissanceElem(_tabSortedRes[row - 1].indice);
        }
        else
        {
            spectre.setValid(false);
        }
    }
    else
    {
        if (row == 0) // Ligne synthese
        {
            TYPointCalcul* pPoint = getElement()->getRecepteur(col - 2);
            if (pPoint)
            {
                spectre = *pCalcul->getSpectre(pPoint->getID());
            }
        }
        else // Contribution d'une source en un point
        {
            // Recuperation du resultat courant
            TYResultat* pThisRes = getElement();
            // Recuperation de pointeurs sur la source et du recepteur
            TYElement* pSource = pThisRes->getSource(_tabSortedRes[row - 1].indice);
            TYPointCalcul* pRecepteur = pThisRes->getRecepteur(col - 2);
 
            // Puis on recupere le spectre correspondant dans le calcul passe en parametre
            TYResultat* pResultat = pCalcul->getResultat();
            spectre = pResultat->getSpectre(pRecepteur, pSource);
            spectre = spectre.toDB();
        }
    }
 
    return spectre;
}
 
void TYResultatWidget::initTabSort(int col)
{
    int row = 1; // Numero de 1ere ligne (ligne 0 = synthese)
 
    TYCalcul* pCalcul = TYCalcul::safeDownCast(getElement()->getParent());
    TYCalcul* pSubstCalcul = getSelectedSubstCalcul();
 
    OSpectre spectre1;
    OSpectre spectre2;
 
    bool valid = true;
 
    for (unsigned int i = 0; i < getElement()->getNbOfSources(); i++)
    {
        _tabSortedRes[i].indice = i;
        row = i + 1;
 
        if (getElement() && getElement()->getSource(i))
        {
            _tabSortedRes[i].name = getElement()->getSource(i)->getName().toStdString();
        }
 
        spectre1 = getSpectre(row, col, pCalcul);
        spectre2 = getSpectre(row, col, pSubstCalcul);
 
        _tabSortedRes[i].resultat = resuAffichage(spectre1, spectre2, valid, 1);
    }
}
 
void TYResultatWidget::sortCol(int col)
{
    if (col < 0)
    {
        return;
    }
    else if (col == 0)
    {
        sortName();
    }
    else
    {
        sortRes(col);
        // Dans ce cas, on reaffiche car on a reorganise les resultats
    }
 
    updateTable();
}
 
void TYResultatWidget::sortRes(int col)
{
    // On commence par remplir le tableau des resultats
    // (la synthese est supposee etre toujours la plus forte valeur et "surnager" en haut du tableau)
    initTabSort(col);
 
    // Tri
    qsort(_tabSortedRes, getElement()->getNbOfSources(), sizeof(TYStructIndiceResultat), compareRes);
}
 
void TYResultatWidget::sortName()
{
    // On commence par remplir le tableau des resultats
    // (la synthese est supposee etre toujours la plus forte valeur et "surnager" en haut du tableau)
    initTabSort(1);
 
    // Tri
    qsort(_tabSortedRes, getElement()->getNbOfSources(), sizeof(TYStructIndiceResultat), compareName);
}
 
TYSpectre TYResultatWidget::getPuissanceElem(const unsigned int& i)
{
    TYElement* pElement = getElement()->getSource(i);
 
    return getPuissanceElem(pElement);
}
 
TYSpectre TYResultatWidget::getPuissanceElem(TYElement* pElement)
{
    assert(pElement);
    TYSpectre spectre;
 
    std::map<TYElement*, LPTYSpectre>& mapElementSpectre = getElement()->getMapElementSpectre();
    TYSpectre* puissance = mapElementSpectre[pElement];
 
    if (puissance)
    {
        spectre = *puissance;
    }
 
    return spectre;
}
 
void TYResultatWidget::showContribTreeDialog(int col)
{
    TYResultatTreeDialog* pDlg = new TYResultatTreeDialog(this);
 
    // Recuperation du point de contrOle
    LPTYPointCalcul pPoint = getElement()->getRecepteur(col - 2);
    pDlg->set(getElement(), pPoint);
    pDlg->exec();
}
 
bool TYResultatWidget::isPresenceTonaliteMarquee(const OSpectre& spectre)
{
    return spectre.isTonalite();
}
 
void TYResultatWidget::slotContributionLineEditChanged()
{
    _seuilContributionBas = _pContributionLineEditBas->text().toDouble();
    _seuilContributionMoy = _pContributionLineEditMoy->text().toDouble();
    _seuilContributionHaut = _pContributionLineEditHaut->text().toDouble();
 
    _pLabelLeqBas->setText(QString("Leq - ") + QString::number(_seuilContributionBas) + QString(" dB"));
    _pLabelLeqMoy->setText(QString("Leq - ") + QString::number(_seuilContributionMoy) + QString(" dB"));
    _pLabelLeqHaut->setText(QString("Leq - ") + QString::number(_seuilContributionHaut) + QString(" dB"));
 
    _pLabelPctBas->setText(QString::number(calcPct(_seuilContributionBas)) + QString(" %"));
    _pLabelPctMoy->setText(QString::number(calcPct(_seuilContributionMoy)) + QString(" %"));
    _pLabelPctHaut->setText(QString::number(calcPct(_seuilContributionHaut)) + QString(" %"));
 
    updateTable();
}
 
double TYResultatWidget::calcPct(double val)
{
    double dummy = 100;
    double seuil = dummy - val;
    double dummyEner = pow(10, dummy / 10);
    double seuilEner = pow(10, seuil / 10);
    return int(100 * seuilEner / dummyEner);
}
 
struct dataPoint
{
    std::pair<double, double> data; 
    inline bool operator<(dataPoint a) 
    {
        return data.second < a.data.second;
    }
};
 
std::vector<int> TYResultatWidget::calcCumulatedContribution(const int& col, TYCalcul* pCalcul,
                                                             TYCalcul* pCalcOp)
{
    size_t nbSources = getElement()->getNbOfSources();
 
    std::vector<dataPoint> values = std::vector<dataPoint>(nbSources);
    std::vector<int> couleur = std::vector<int>(nbSources);
    if (nbSources == 0)
        return couleur;
 
    bool valid = true;
 
    // On ne s'occupe que des lignes correspondant à des sources, pas à la synthèse
    for (int row = 1; row <= nbSources; row++)
    {
        OSpectre spectre1 = getSpectre(row, col, pCalcul);
        OSpectre spectre2 = getSpectre(row, col, pCalcOp);
 
        if (col > 1)
            values[row - 1].data =
                std::pair<double, double>(row, resuAffichage(spectre1, spectre2, valid, CELL_CONTRIB));
        else
            values[row - 1].data =
                std::pair<double, double>(row, resuAffichage(spectre1, spectre2, valid, CELL_LW));
    }
    // on trie par valeur décroissante
    std::sort(values.begin(), values.end());
    std::reverse(values.begin(), values.end());
 
    // on calcul les contributions cumulées
    double cum = 0;
    for (int i = 0; i < nbSources; i++)
    {
        double val = values[i].data.second;
        val = pow(10, val * 0.1);
        cum += val;
        double res = 10 * log10(cum);
        values[i].data.second = res;
        if (col > 1) // Pas de cumul des puissances
        {
            _cumulatedContribs[int(values[i].data.first) - 1][col - 2] = res;
        }
    }
 
    // on détermine le code couleur de chaque contribution
    OSpectre spectre1 = getSpectre(0, col, pCalcul);
    OSpectre spectre2 = getSpectre(0, col, pCalcOp);
    double synthese = resuAffichage(spectre1, spectre2, valid, CELL_CONTRIB);
    double previousVal = values[0].data.second;
    for (int i = 0; i < nbSources; i++)
    {
        if (i > 0)
        {
            double currentVal = values[i].data.second;
            // La contribution max est toujours en rouge
            if (previousVal < (synthese - _seuilContributionBas) || i == 0)
                values[i].data.second = RED;
            else if (previousVal < (synthese - _seuilContributionMoy))
                values[i].data.second = ORANGE;
            else if (previousVal < (synthese - _seuilContributionHaut))
                values[i].data.second = YELLOW;
            else
                values[i].data.second = WHITE;
            previousVal = currentVal;
        }
        else
            values[i].data.second = RED;
 
        // on swap les pairs pour trier le vecteur selon l'ordre initial
        std::swap(values[i].data.first, values[i].data.second);
    }
 
    // on reprend l'ordre initial
    std::sort(values.begin(), values.end());
 
    for (int i = 0; i < nbSources; i++)
    {
        couleur[i] = values[i].data.first;
    }
 
    return couleur;
}
 
double TYResultatWidget::resuAffichage(OSpectre& spectre1, OSpectre& spectre2, bool& valid,
                                       const int& typeCase)
{
    double val1 = 0.0, val2 = 0.0;
 
    switch (_choixAffichage)
    {
        case DBLIN:
            val1 = spectre1.valGlobDBLin();
            val2 = spectre2.valGlobDBLin();
            break;
        case DBFREQ:
            val1 = spectre1.getValueReal(_freq);
            val2 = spectre2.getValueReal(_freq);
            break;
        case DBA:
        default:
            val1 = spectre1.valGlobDBA();
            val2 = spectre2.valGlobDBA();
            break;
    }
 
    if (_choixOperation != 0)
    {
        if ((!spectre2.isValid()) || (typeCase == CELL_LW))
        {
            val2 = 0.0;
        }
        if ((!spectre2.isValid()) && ((typeCase == CELL_SYNTH) || (typeCase == CELL_CONTRIB)))
        {
            valid = false;
        }
    }
 
    switch (_choixOperation)
    {
        case 0: // Pas d'operation
            return val1;
        case 1: // difference entre deux resultats
            return val1 - val2;
        case 2: // emergence (uniquement pour la ligne synthese)
            if (typeCase == CELL_SYNTH)
            {
                return (TYResultat::safeDownCast(_pElement))->getEmergence(val1, val2);
            }
            else
            {
                return val1;
            }
        case 3: // bruit ambiant (uniquement pour la ligne synthese)
        default:
            if (typeCase == CELL_SYNTH)
            {
                return (TYResultat::safeDownCast(_pElement))->getAmbiant(val1, val2);
            }
            else
            {
                return val1;
            }
    }
}
 
OSpectre TYResultatWidget::resuSpectre(OSpectre& spectre1, OSpectre& spectre2, const int& typeCase)
{
    switch (_choixOperation)
    {
        case 0: // Pas d'operation
            return spectre1;
            break;
        case 1: // difference entre deux resultats
            return spectre1.subst(spectre2);
            break;
        case 2: // emergence
            return (TYResultat::safeDownCast(_pElement))->getEmergence(spectre1, spectre2);
            break;
        case 3: // bruit ambiant
        default:
            return (TYResultat::safeDownCast(_pElement))->getAmbiant(spectre1, spectre2);
            break;
    }
 
    return OSpectre();
}
 
void TYResultatWidget::decorsSynthese(QTableWidgetItem* pItem, const int& row, const int& col,
                                      const bool& valid, OSpectre& spectre1, OSpectre& spectre2)
{
    if (!valid)
    {
        pItem->setBackground(QBrush(QColor(127, 127, 127))); // Gris uni
        return;
    }
 
    if ((_choixAffichage == DBFREQ) || (_choixOperation == 1) || (_choixOperation == 2))
    {
        pItem->setBackground(QBrush(QColor(255, 255, 255))); // Blanc uni ?
        return; // Rien si affichage sur une frequence ou difference ou emergence
    }
 
    OSpectre spectre;
    TYCalcul* pCalcul = TYCalcul::safeDownCast(_pElement->getParent());
 
    if (_choixOperation == 3) // Bruit ambiant
    {
        spectre = getElement()->getAmbiant(spectre1, spectre2);
    }
    else if (_choixOperation == 0) // Pas d'operation
    {
        spectre = getSpectre(row, col, pCalcul);
    }
 
    if (isPresenceTonaliteMarquee(spectre)) // Coloration en jaune
    {
        pItem->setBackground(QBrush(QColor(255, 255, 0)));
    }
}
 
void TYResultatWidget::decorsContributions(QTableWidgetItem* pItem, const int& row, const int& col,
                                           bool& isColored, std::vector<int> couleurs)
{
    double codeCoul = couleurs[row - 1];
    // Les cellules sont decorees sauf dans le cas ou on affiche l'ecart entre deux resultats
    if (!isColored)
    {
        pItem->setBackground(QBrush(QColor(127, 127, 127))); // Gris uni
        return;
    }
 
    if ((_choixOperation == 1) || (col == 1))
    {
        pItem->setBackground(QBrush(QColor(255, 255, 255))); // Blanc uni ?
    }
    else
    {
        // Affichage en couleur pour les cellules qui contribuent a plus que contribution cumulée -
        // seuil Uniquement dansle cas ou aucune operation n'a ete faite sur le resultat.
        if ((_choixOperation == 0) && (codeCoul == RED))
        {
            pItem->setBackground(QBrush(QColor(255, 0, 0)));
        }
        else if ((_choixOperation == 0) && (codeCoul == ORANGE))
        {
            pItem->setBackground(QBrush(QColor(255, 204, 0)));
        }
        else if ((_choixOperation == 0) && (codeCoul == YELLOW))
        {
            pItem->setBackground(QBrush(QColor(255, 255, 0)));
        }
    }
}
 
void TYResultatWidget::updateFreqList()
{
    TYTabFreq tabFreq = TYSpectre::getTabFreqNorm();
    for (unsigned int i = 0; i < tabFreq.size(); i++)
    {
        QString str;
        str.setNum(tabFreq[i], 'f', 1);
        _comboBoxFreq->insertItem(i, str);
    }
}
 
void TYResultatWidget::setFrequency(int freq)
{
    _freq = _comboBoxFreq->currentText().toFloat();
    updateHeaderLabel();
    updateTable();
}
 
int compareRes(const void* elem1, const void* elem2)
{
    TYStructIndiceResultat* Res1 = (TYStructIndiceResultat*)elem1;
    TYStructIndiceResultat* Res2 = (TYStructIndiceResultat*)elem2;
 
    double res = Res2->resultat - Res1->resultat;
    int sgn = int(res / fabs(res));
    return (sgn);
}
 
int compareName(const void* elem1, const void* elem2)
{
    TYStructIndiceResultat* Res1 = (TYStructIndiceResultat*)elem1;
    TYStructIndiceResultat* Res2 = (TYStructIndiceResultat*)elem2;
 
    if (Res1->name > Res2->name)
    {
        return 1;
    }
 
    return (-1);
}
 
void TYResultatWidget::sortColumnsByHeaderText(Qt::SortOrder order /*= Qt::AscendingOrder*/,
                                               Qt::CaseSensitivity cs /*= Qt::CaseInsensitive*/,
                                               bool localeAware /*= true*/)
{
    struct Col
    {
        QString text;
        int logical;
    };
    std::vector<Col> cols;
    cols.reserve(_nbRecepteurs);
 
    // Récupérer les libellés d'en-tête
    for (int c = 2; c < _nbRecepteurs + 2; ++c)
    {
        QString txt;
        if (auto* it = _pTable->horizontalHeaderItem(c))
            txt = it->text();
        else
            txt = _pTable->model()->headerData(c, Qt::Horizontal).toString();
        cols.push_back({txt, c});
    }
 
    // Trier par libellé
    auto cmp = [&](const Col& a, const Col& b)
    {
        int r =
            localeAware ? QString::localeAwareCompare(a.text, b.text) : QString::compare(a.text, b.text, cs);
        return (order == Qt::AscendingOrder) ? (r < 0) : (r > 0);
    };
    std::stable_sort(cols.begin(), cols.end(), cmp);
 
    // Appliquer l'ordre en déplaçant les sections
    QHeaderView* hh = _pTable->horizontalHeader();
    hh->setSectionsMovable(true);
    _pTable->setUpdatesEnabled(false);
    QSignalBlocker blockHeader(hh);
 
    for (int target = 2; target < _nbRecepteurs + 2; ++target)
    {
        int from = hh->visualIndex(cols[target - 2].logical);
        if (from != target)
            hh->moveSection(from, target);
    }
 
    _pTable->setUpdatesEnabled(true);
    hh->setSectionsMovable(false);
}