TYElementListItem.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 <qpixmap.h>
 
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/TYProjet.h"
#include "Tympan/models/business/TYPluginManager.h"
#include "Tympan/gui/widgets/TYWidget.h"
#include "Tympan/gui/app/TYApplication.h"
#include "Tympan/gui/app/TYMainWindow.h"
#include "TYElementListItem.h"
 
#define TR(id) OLocalizator::getString("TYElementListItem", (id))
#define IMG(id) OLocalizator::getPicture("TYElementListItem", (id))
 
TYElementListItem::TYElementListItem(QTreeWidget* parent, LPTYElement pElement, LPTYCalcul pCalcul,
                                     const QStringList& labels /*=QStringList()*/, bool checkable)
    : QTreeWidgetItem(parent)
{
    initItem(pElement, pCalcul, labels, checkable);
}
 
TYElementListItem::TYElementListItem(QTreeWidgetItem* parent, LPTYElement pElement, LPTYCalcul pCalcul,
                                     const QStringList& labels /*=QStringList()*/, bool checkable)
    : QTreeWidgetItem(parent)
{
    initItem(pElement, pCalcul, labels, checkable);
}
 
TYElementListItem::TYElementListItem(QTreeWidget* parent, const QStringList& labels, LPTYCalcul pCalcul,
                                     bool checkable)
    : QTreeWidgetItem(parent, labels)
{
    initItem(NULL, pCalcul, labels, checkable);
}
 
TYElementListItem::TYElementListItem(QTreeWidgetItem* parent, const QStringList& labels, LPTYCalcul pCalcul,
                                     bool checkable)
    : QTreeWidgetItem(parent, labels)
{
    initItem(NULL, pCalcul, labels, checkable);
}
 
TYElementListItem::~TYElementListItem() {}
 
void TYElementListItem::initItem(LPTYElement pElement, LPTYCalcul pCalcul,
                                 const QStringList& labels /*=QStringList()*/, bool checkable)
{
    _pElement = pElement;
    _pCurrentCalcul = pCalcul;
    _checkable = checkable;
    _elementItem = _pElement ? true : false;
 
    if (labels.isEmpty())
    {
        //      setText(0, TYWidget::getDisplayName(_pElement)); // Commente en  VERSION 3.6.2
    }
    else
    {
        setText(0, labels[0]);
    }
 
    // Identifiant stable pour sauvegarder/restaurer l’expansion
    if (_pElement)
    {
        if (_pElement->isA("TYCalcul"))
        {
            OGenID currentId = TYCalcul::safeDownCast(_pElement)->getSolverId();
            setData(0, Qt::UserRole, currentId.toString()); // identifiant unique pour un calcul
        }
        else
        {
            setData(0, Qt::UserRole, _pElement->getID().toString()); // identifiant unique générique
        }
    }
 
    updateContent();
}
 
void TYElementListItem::updateContent()
{
    if (_pElement)
    {
        setText(0, _pElement->getName()); // VERSION 3.6.2
        //      setText(1, _pElement->getName());
 
        bool bInCurrentCalcul = false;
 
        if (_pElement->isA("TYCalcul"))
        {
            // Nom du solveur utilisé par le calcul
            TYCalcul* pCalcul = TYCalcul::safeDownCast(_pElement);
            if (pCalcul->getState() == TYCalcul::Locked)
            {
                setText(1, TR("id_locked"));
            }
            else
            {
                OGenID currentId = pCalcul->getSolverId();
                setText(1, TYPluginManager::get()->getInfo("name", currentId));
            }
        }
        else if (dynamic_cast<TYPointCalcul*>(_pElement._pObj) != nullptr)
        {
            TYPointControl* pPoint = dynamic_cast<TYPointControl*>(_pElement.getRealPointer());
            bInCurrentCalcul = pPoint->etat();
        }
        else if (dynamic_cast<TYMaillage*>(_pElement.getRealPointer()) != nullptr)
        {
            TYMaillage* pMaillage = dynamic_cast<TYMaillage*>(_pElement.getRealPointer());
            bInCurrentCalcul = pMaillage->etat();
        }
        else
        {
            if (_pCurrentCalcul)
            {
                bInCurrentCalcul = _pCurrentCalcul->isInSelection(_pElement);
            }
            else
            {
                bInCurrentCalcul = _pElement->isInCurrentCalcul();
            }
        }
 
        if (_checkable)
        {
            QTreeWidgetItem::setCheckState(0, bInCurrentCalcul ? Qt::Checked : Qt::Unchecked);
        }
 
        //       Mise a jour des items des parents
        QTreeWidgetItem* pParentItem = this->parent();
        bInCurrentCalcul = false;
        while (pParentItem)
        {
            TYElementListItem* pCheckItem = (TYElementListItem*)pParentItem;
            TYElement* pChkElt = pCheckItem->getElement();
            if (pChkElt && pCheckItem->isCheckable())
            {
                if (_pCurrentCalcul)
                {
                    bInCurrentCalcul = _pCurrentCalcul->isInSelection(pChkElt);
                }
                else
                {
                    bInCurrentCalcul = pChkElt->isInCurrentCalcul();
                }
 
                pCheckItem->QTreeWidgetItem::setCheckState(0, bInCurrentCalcul ? Qt::Checked : Qt::Unchecked);
            }
 
            pParentItem = pParentItem->parent();
        }
 
        // Mise à jour des enfant aussi ...
        updateChilds();
    }
}
 
void TYElementListItem::remove()
{
    if (childCount() == 0)
    {
        if (parent() != NULL)
        {
            return;
        }
    }
    else
    {
        TYElementListItem* childItem = nullptr;
 
        while (childCount() > 0)
        {
            childItem = (TYElementListItem*)child(0);
            childItem->remove();
            delete childItem;
        }
 
        // Appel recursif
        remove();
    }
}
 
void TYElementListItem::setOn(bool state, bool UpdateModelers)
{
    if (_pElement && _pCurrentCalcul && _checkable)
    {
        // Si le calcul courant est bloque, on empeche le changement d'etat
        // if (_pCurrentCalcul->getState()==TYCalcul::Locked) // DTn : Desactive 20110915
        //{
        //  updateContent(); // On met a jour a tout hasard ...
        //  return;
        //}
 
        // On traite a part le cas des points de controle ...
        if (dynamic_cast<TYPointCalcul*>(_pElement._pObj) != nullptr)
        {
            TYPointControl* pPoint = dynamic_cast<TYPointControl*>(_pElement.getRealPointer());
            if ((pPoint->etat() != state) && (getTYApp()->getCalculManager()->askForResetResultat()))
            {
                bool need_to_rebuild_result(false);
                if (state) // Ajout d'un point de controle
                {
                    need_to_rebuild_result |= _pCurrentCalcul->addPtCtrlToResult(pPoint);
                }
                else // Suppression d'un point de controle
                {
                    need_to_rebuild_result |= _pCurrentCalcul->remPtCtrlFromResult(pPoint);
                }
 
                if (need_to_rebuild_result)
                {
                    _pCurrentCalcul->getResultat()->buildMatrix();
                }
                if (UpdateModelers)
                {
                    if (_pElement->getParent())
                    {
                        _pElement->getParent()->setIsGeometryModified(true);
                        _pElement->getParent()->updateGraphicTree();
                    }
                    else
                    {
                        _pElement->updateGraphic();
                    }
 
                    getTYMainWnd()->updateModelers(false, false, true);
                }
            }
        }
        else if (dynamic_cast<TYMaillage*>(_pElement._pObj) != nullptr) // ... et les maillages
        {
            TYMaillage* pMaillage = dynamic_cast<TYMaillage*>(_pElement.getRealPointer());
            if ((pMaillage->etat() != state) && (getTYApp()->getCalculManager()->askForResetResultat()))
            {
                if (state) // Ajout d'un point de controle
                {
                    _pCurrentCalcul->addMaillage(pMaillage);
                }
                else // Suppression d'un point de controle
                {
                    _pCurrentCalcul->remMaillage(pMaillage);
                }
 
                if (UpdateModelers)
                {
                    if (_pElement->getParent())
                    {
                        _pElement->getParent()->setIsGeometryModified(true);
                        _pElement->getParent()->updateGraphicTree();
                    }
                    else
                    {
                        _pElement->updateGraphic();
                    }
 
                    getTYMainWnd()->updateModelers(false, false, true);
                }
            }
        }
        else if (_pCurrentCalcul->isInSelection(_pElement) != state)
        {
            if (getTYApp()->getCalculManager()->askForResetResultat())
            {
                if (state)
                {
                    _pElement->setIsAcousticModified(true);
                    _pElement->getParent()->setIsAcousticModified(true);
                    _pCurrentCalcul->addToSelection(_pElement, true);
                }
                else
                {
                    _pCurrentCalcul->remToSelection(_pElement, true);
                }
 
                if (_pElement->isA("TYSiteNode"))
                {
                    TYSiteNode* pSite = dynamic_cast<TYSiteNode*>(_pElement.getRealPointer());
                    LPTYCalcul pCalc = NULL;
                    if (getTYApp()->getCurProjet() && pSite)
                    {
                        pCalc = getTYApp()->getCurProjet()->getCurrentCalcul();
                        if (pCalc)
                        {
                            pCalc->getCalculElements(pSite);
                        }
                    }
                }
 
                if (UpdateModelers)
                {
                    if (_pElement->getParent())
                    {
                        _pElement->getParent()->setIsGeometryModified(true);
                        _pElement->getParent()->updateGraphicTree();
                    }
                    else
                    {
                        _pElement->updateGraphic();
                    }
 
                    getTYMainWnd()->updateModelers(false, false, true);
                }
            }
        }
    }
    else
    {
        // Toujours actif quand il n'y a pas de calcul courant
        state = true;
    }
 
    // Mise a jour de l'item
    updateContent();
}
 
void TYElementListItem::setCheckState(int column, Qt::CheckState state)
{
    if (_checkable)
    {
        setOn(state == Qt::Checked, true);
 
        QTreeWidgetItem::setCheckState(column, state);
    }
}
 
void TYElementListItem::updateChilds()
{
    int nbchilds = this->childCount();
    for (int i = 0; i < nbchilds; i++)
    {
        TYElementListItem* childItem = (TYElementListItem*)child(i);
        TYElement* pChkElt = childItem->getElement();
        bool bInCurrentCalcul = false;
        if (pChkElt && childItem->isCheckable())
        {
            if (TYPointControl* pPoint = dynamic_cast<TYPointControl*>(pChkElt))
            {
                childItem->QTreeWidgetItem::setCheckState(0, pPoint->etat() ? Qt::Checked : Qt::Unchecked);
                continue;
            }
 
            if (_pCurrentCalcul)
            {
                bInCurrentCalcul = _pCurrentCalcul->isInSelection(pChkElt);
            }
            else
            {
                bInCurrentCalcul = pChkElt->isInCurrentCalcul();
            }
 
            childItem->QTreeWidgetItem::setCheckState(0, bInCurrentCalcul ? Qt::Checked : Qt::Unchecked);
        }
 
        childItem->updateChilds();
    }
}