TYModelerFrame.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program 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 2 of the License, or
 * (at your option) any later version.
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef __TY_MODELER_FRAME__
#define __TY_MODELER_FRAME__
 
#include <qwidget.h>
// Added by qt3to4:
#include <QCloseEvent>
#include <QBoxLayout>
#include <QShowEvent>
#include <QWheelEvent>
#include <QResizeEvent>
#include <QGridLayout>
#include <QFocusEvent>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QEvent>
 
#include "TYAppDefines.h"
#include "TYRenderWindowInteractor.h"
#include "TYActionManager.h"
#include "Tympan/models/business/TYElement.h"
 
class QGridLayout;
class QBoxLayout;
class QComboBox;
class QStatusBar;
class QToolButton;
class OGLTextElement;
class OGLScalarBarElement;
class OGLLineElement;
class OGLGridElement;
class OGLLightElement;
class OGLCamera;
 
class TYModelerFrame : public QWidget
{
    Q_OBJECT
 
public:
    enum ModelerViewType
    {
        TopView,
        LeftView,
        FrontView,
        PerspView,
        FreeView,
        NbOfViews
    };
 
    enum RenderMode
    {
        Points,
        Wireframe,
        Surface,
        Flat,
        Gouraud,
        Phong,
        NbOfRenderMode
    };
 
    enum ModelerMode
    {
        NoMode = -1,
        CameraMode,
        CameraZoneMode,
        DistanceMode,
        MovingMode,
        RotationMode,
        EditionMode,
        NbOfModelerMode
    };
 
    TYModelerFrame(QWidget* parent = 0, const char* name = 0, Qt::WindowFlags f = Qt::SubWindow);
    virtual ~TYModelerFrame();
 
    TYRenderWindowInteractor* getView()
    {
        return _pView;
    }
 
    TYOpenGLRenderer* getRenderer()
    {
        return _pView->getRenderer();
    }
 
    int getCurrentView()
    {
        return _curViewType;
    }
 
    int getRenderMode()
    {
        return _curRenderMode;
    }
 
    TYElementPicker* getElementPicker()
    {
        return _pPicker;
    }
    TYPickEditor* getPickEditor()
    {
        return _pPickEditor;
    }
 
    TYAbstractSceneEditor* getCurrentEditor()
    {
        return _pCurrentEditor;
    }
 
    TYCameraEditor* getCameraEditor()
    {
        return _pCameraEditor;
    }
 
    QStatusBar* statusBar()
    {
        return _pStatusBar;
    }
 
    bool getSnapGridActive()
    {
        return _snapGridActive;
    }
 
    TYActionManager* getActionManager()
    {
        return &_actionManager;
    }
 
    bool getShowSources()
    {
        return _showSources;
    }
 
    bool getShowGrid()
    {
        return _showGrid;
    }
 
    bool getWireframeOnMovingCamera()
    {
        return _wireframeOnMovingCamera;
    }
 
    void setElement(LPTYElement pElement)
    {
        _pElement = pElement;
    }
    LPTYElement getElement()
    {
        return _pElement;
    }
 
    bool isElementInCurrentCalcul();
    bool isElementInCurrentProjet();
    bool askForResetResultat();
 
    virtual bool computeCurPos(int x, int y, float* pos);
 
public slots:
    virtual void setViewType(int view);
 
    virtual void setRenderModeSlot(int mode);
 
    virtual void setRenderMode(int mode, bool bUpdateGL);
 
    virtual void setEditorMode(int mode);
    void setEditorModeToCamera()
    {
        setEditorMode(CameraMode);
    }
 
    void showGrid(bool show);
 
    void showNormals(bool show);
 
    void showPlafond(bool show);
 
    void showSources();
 
    void showRays(bool show);
    void setSnapGridActive(bool state);
 
    void setCameraCoordinates();
 
    void screenShot();
 
    virtual void updateView(bool clipping = true, bool axesAndGrid = true);
 
    void updateAxes();
 
    void updateCurPosInfo();
 
    void updateGrid();
 
    void updateElementGraphic(bool force = false);
 
    void print();
 
    void copy();
 
    void editElement();
 
    void fit();
 
    virtual void updatePreferences();
 
    void resizeGrid();
 
    virtual bool close();
 
    void setWireframeOnMovingCamera(bool state)
    {
        _wireframeOnMovingCamera = state;
    }
 
    void startMovingRenderMode();
    void stopMovingRenderMode();
 
    void updateScale();
 
    void showScale(bool show);
 
    static double getDouble(const QString& title, const QString& txt, double min, double max, double val,
                            bool& ok, int dec = 2);
 
signals:
    void aboutToClose();
 
    void viewTypeChanged(int);
 
    void editorModeChanged(int mode);
 
    void eltModified(LPTYElement pElt);
 
    void mouseEnter();
 
    void mouseLeave();
 
    void frameResized();
 
protected:
    virtual void keyPressEvent(QKeyEvent* pEvent);
    virtual void keyReleaseEvent(QKeyEvent* pEvent);
    virtual void mouseMoveEvent(QMouseEvent* pEvent);
    virtual void wheelEvent(QWheelEvent* pEvent);
    virtual void resizeEvent(QResizeEvent* pEvent);
    virtual void focusInEvent(QFocusEvent* pEvent);
    virtual void showEvent(QShowEvent* pEvent);
    virtual void closeEvent(QCloseEvent* pEvent);
    virtual void enterEvent(QEvent* pEvent);
    virtual void leaveEvent(QEvent* pEvent);
 
    void setGridLinesActorsVisibility(bool showGridXY, bool showGridXZ, bool showGridZY);
 
    OBox getGlobalBoundingBox();
 
private:
    QGridLayout* _pLayout;
 
    QComboBox* _pRenderModeBox;
 
    QToolButton* _pSnapGridBtn;
 
    bool _snapGridActive;
 
    QToolButton* _pScreenShotBtn;
 
    QToolButton* _pShowSourcesBtn;
 
    bool _showSources;
 
    QToolButton* _pShowNormalsBtn;
 
    bool _showNormals;
 
    QToolButton* _pShowPlafondBtn;
 
    bool _showPlafond;
 
    QToolButton* _pShowRaysBtn;
 
    bool _showRays;
 
    QStatusBar* _pStatusBar;
 
    int _curRenderMode;
 
    bool _wireframeOnMovingCamera;
 
    int _lastRenderMode;
 
    int _lastEditorMode;
 
    TYElementPicker* _pPicker;
 
    TYCameraEditor* _pCameraEditor;
 
    TYDistanceEditor* _pDistanceEditor;
 
    TYPositionEditor* _pPositionEditor;
 
    TYCameraZoneEditor* _pCameraZoneEditor;
 
    OGLTextElement* _pOGLTextElement;
 
    OGLLineElement* _pOGLLineElementAxeX;
    OGLLineElement* _pOGLLineElementAxeY;
    OGLLineElement* _pOGLLineElementAxeZ;
    OGLTextElement* _pOGLTextElementLabelX;
    OGLTextElement* _pOGLTextElementLabelY;
    OGLTextElement* _pOGLTextElementLabelZ;
 
    QToolButton* _pGridBtn;
 
    OGLLineElement* _pOGLLineElementX;
    OGLLineElement* _pOGLLineElementY;
 
    bool _showGrid;
 
    TYActionManager _actionManager;
 
    OGLLightElement* _pLightElement;
 
    // Les collections de lignes pour la grille.
    OGLGridElement* _pOGLGridElement;
 
    OGLScalarBarElement* _pOGLScalarBarElement;
 
    QToolButton* _pShowScale;
 
    bool _showScale;
 
    bool _firstTimeShown;
 
protected:
    QBoxLayout* _pCtrlLayout;
 
    QComboBox* _pViewTypeBox;
 
    TYRenderWindowInteractor* _pView;
 
    int _curViewType;
 
    bool _editorModeAccepted;
 
    TYAbstractSceneEditor* _pCurrentEditor;
 
    TYPickEditor* _pPickEditor;
 
    OGLCamera* _pOGLCameras[NbOfViews];
 
    float _gridStep;
    float _gridMagnStep;
    float _gridDimX;
    float _gridDimY;
 
    QToolButton* _pSetCameraCoordinatesBtn;
 
    LPTYElement _pElement;
};
 
#endif //__TY_MODELER_FRAME__