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,
        DistanceMode,
        MovingMode,
        RotationMode,
        EditionMode,
        NbOfModelerMode
    };


    TYModelerFrame(QWidget* parent = 0, const char* name = 0, Qt::WindowFlags f = 0);
    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(bool show);

    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);


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;

    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__