TYElementGraphic.h

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/>.
 */
 
#ifndef __TY_ELEMENT_GRAPHIC__
#define __TY_ELEMENT_GRAPHIC__
 
#if _MSC_VER > 1000
    #pragma once
#endif // _MSC_VER > 1000
 
#ifdef _MSC_VER
    #pragma warning(disable : 4284)
#endif
 
#include "Tympan/models/common/3d.h"
#include "Tympan/core/color.h"
#include "Tympan/core/smartptr.h"
 
class QObject;
class TYRenderContext;
class TYElement;
 
#define TY_DECL_METIER_GRAPHIC(classname)                                                                    \
public:                                                                                                      \
    inline classname* getElement() const                                                                     \
    {                                                                                                        \
        return (classname*)_pElement;                                                                        \
    }
 
#include <list>
// Pour l'utilisation de la librairie standard STL.
using std::list;
 
class TYElementGraphic;
typedef list<TYElementGraphic*> TYListPtrTYElementGraphic;
typedef list<const TYElementGraphic*> TYListPtrConstTYElementGraphic;
 
class TYElementGraphic : public IRefCount
{
    // Methodes
public:
    virtual ~TYElementGraphic();
 
    void setElement(TYElement* pElt);
    TYElement* getTYElement()
    {
        return _pElement;
    }
 
    const TYElement* getTYElement() const
    {
        return _pElement;
    }
 
    void updateTree();
 
    virtual void update(bool force = false);
 
    virtual void display(TYRenderContext& renderContext);
 
    void setModified(bool modified = true)
    {
        _modified = modified;
        if (modified)
        {
            invalidateBoundingBox();
        }
    }
    bool getModified() const;
 
    void setVisible(bool visible = true)
    {
        _visible = visible;
    }
    bool getVisible()
    {
        return _visible;
    }
    void setRecursiveVisible(bool visible = true);
 
    void setTexture(bool state = true)
    {
        _texture = state;
    }
    bool getTexture()
    {
        return _texture;
    }
 
    OBox boundingBox() const;
 
    virtual OBox computeBoundingBox() const;
 
    virtual void getChilds(TYListPtrTYElementGraphic& childs, bool recursif = true){};
 
    void getChilds(TYListPtrConstTYElementGraphic& childs, bool recursif = true) const
    {
        TYListPtrTYElementGraphic childsNonConst;
        const_cast<TYElementGraphic*>(this)->getChilds(childsNonConst, recursif);
        for (auto elem : childsNonConst)
        {
            childs.push_back(elem);
        }
    };
 
    void setBoundingBoxVisible(bool state = true);
 
    bool isBoundingBoxVisible() const;
 
    void setOnlyBoundingBox(bool state = true);
 
public:
#if TY_USE_IHM
    virtual void activateSignal(){};
 
    virtual void connectUpdateSignal(QObject* pReceiver, const char* member){};
    virtual void disconnectUpdateSignal(QObject* pReceiver, const char* member){};
#endif // TY_USE_IHM
 
protected:
    TYElementGraphic(TYElement* pElt);
 
    void displayNormal(OVector3D normal, OPoint3D p1);
 
    void drawName(TYRenderContext& renderContext);
 
    void invalidateBoundingBox();
 
public:
    static bool _gDrawNormals;
 
    static bool _gDrawPlafond;
 
private:
    // Indique si la boite englobante doit etre recalculee
    mutable bool _boundingBoxDirty;
 
    bool _modified;
 
    bool _viewOnlyHighlight;
 
    // Cache de la boite englobante de l'element
    mutable OBox _boundingBox;
 
protected:
    TYElement* _pElement;
 
    bool _highlight;
 
    bool _texture;
 
    bool _visible;
};
 
typedef SmartPtr<TYElementGraphic> LPTYElementGraphic;
 
#endif // __TY_ELEMENT_GRAPHIC__