TYPositionEditor.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_POSITION_EDITOR__
#define __TY_POSITION_EDITOR__
 
#include <limits>
 
#include "TYAbstractSceneEditor.h"
#include "Tympan/models/business/geometry/TYGeometryNode.h"
#include "TYAction.h"
 
class TYElement;
class QTimer;
class OGLLineElement;
 
class TYPositionEditor : public TYAbstractSceneEditor
{
    Q_OBJECT
 
public:
    TYPositionEditor(TYModelerFrame* pModeler, int mode = Moving);
    virtual ~TYPositionEditor();
 
    void setInteractionTime(int time)
    {
        _interactionTime = time;
    }
    int getInteractionTime()
    {
        return _interactionTime;
    }
 
    void setSensitivity(float t)
    {
        _trackballFactor = t;
    }
    float getSensitivity()
    {
        return _trackballFactor;
    }
 
    void setMode(int mode)
    {
        _mode = mode;
    }
    int getMode()
    {
        return _mode;
    }
 
    void setAngleStep(float step)
    {
        _angleStep = step;
    }
    float getAngleStep()
    {
        return _angleStep;
    }
 
    void setPickPointPrecision(float precision)
    {
        _pickPointPrecision = precision;
    }
    float getPickPointPrecision()
    {
        return _pickPointPrecision;
    }
 
    bool getOnlyHighlight()
    {
        return _viewOnlyHighlight;
    }
 
    bool selectElement(TYElement* pElt);
 
    enum
    {
        Moving,
        Rotation,
        Edition
    };
 
public slots:
    virtual void connect();
    virtual void disconnect();
    virtual void init();
    virtual void cancel();
    virtual void close();
    virtual void slotMousePressed(int x, int y, Qt::MouseButton button, Qt::KeyboardModifiers state);
    virtual void slotMouseReleased(int x, int y, Qt::MouseButton button, Qt::KeyboardModifiers state);
    virtual void slotMouseMoved(int x, int y, Qt::MouseButtons button, Qt::KeyboardModifiers state);
    virtual void slotKeyPressed(int key);
    virtual void slotKeyReleased(int key);
    virtual void slotViewTypeChanged(int view);
 
    void viewOnlyHighlight(bool state)
    {
        _viewOnlyHighlight = state;
    }
 
protected slots:
    void initEditSiteNode(TYElement* pElt);
    void initEditVolume(TYElement* pElt);
    void initEditMachine(TYElement* pElt);
    // void initEditEtage(TYElement* pElt);
    void initEditBatiment(TYElement* pElt);
    void initEditRoute(TYElement* pElt);
    void initEditResTrans(TYElement* pElt);
    void initEditCrbNiv(TYElement* pElt);
    void initEditCrsEau(TYElement* pElt);
    void initEditPlanEau(TYElement* pElt);
    void initEditTerrain(TYElement* pElt);
    void initEditSrcPonct(TYElement* pElt);
    void initEditPointControl(TYElement* pElt);
    void initEditMaillage(TYElement* pElt);
    void initEditEcran(TYElement* pElt);
 
    void editGeoNode();
 
    void editPoint();
 
    void editPointEtage();
 
    void orienteSrcPonct();
 
protected:
    bool move(OPoint3D* pPt, bool enableX = true, bool enableY = true, bool enableZ = true);
 
    bool rotate(ORepere3D* pRepere, bool enableX = true, bool enableY = true, bool enableZ = true);
 
    int findPoint(float* ptToFind, TYTabPoint* pInPoints);
 
    void updateMovingLines(TYTabPoint* pPoints, int centralPointId);
    void updateMovingPoint(const TYPoint& point);
 
    void PointOfGeoNodeInCurrentSiteCoordinates(TYGeometryNode* pGeoNode, OPoint3D& centralPointGN);
    void PointOfCurrentSiteInGeoNodeCoordinates(TYGeometryNode* pGeoNode, OPoint3D& centralPointGN);
    void PointOfGeoNodeInCurrentSiteCoordinatesOrPointOfCurrentSiteInGeoNodeCoordinates(
        TYGeometryNode* pGeoNode, OPoint3D& centralPointGN, bool bPointOfGeoNodeInCurrentSiteCoordinates);
    void editPolyLine(LPTYElement pElt, TYTabPoint& pts, bool close, LPTYAltimetrie pAlti = NULL);
 
    void insertNewPoint(TYTabPoint& pts, TYPoint& newPoint, int& idInsert, LPTYAltimetrie pAlti = NULL);
 
    void deletePoint(TYTabPoint& pts, TYPoint& deletedPoint, int& idDelete);
 
    int findClosestSegmentToMouse(const TYTabPoint& pts);
 
    int findClosestPointToMouse(const TYTabPoint& pts);
 
    double distSegmentSqr(double mx, double my, double vx, double vy, double wx, double wy) const;
 
protected:
    int _mode;
 
    bool _active;
 
    bool _firstCall;
 
    bool _inUse;
 
    bool _viewOnlyHighlight;
 
    TYElementPicker* _pPicker;
 
    TYCameraEditor* _pCamEditor;
 
    bool _shiftOn;
 
    bool _keyAOn;
 
    bool _keyDOn;
 
    TYElement* _pEditElement;
 
    TYGeometryNode* _pEditGeoNode;
 
    TYPoint* _pEditPoint;
 
    TYTabPoint _editContour;
 
    QTimer* _pStepTimer;
    int _interactionTime;
 
    bool _mouseEventActive;
 
    int _currentMousePos[2];
    int _lastMousePos[2];
 
    float _trackballFactor;
 
    OGLLineElement* _pOGLLineElementMoving1;
    OGLLineElement* _pOGLLineElementMoving2;
 
private:
    bool _bSiteModelerFrame;
 
    float _angleInfo;
 
    TYAction* _pLastAction;
 
    float _angleStep;
 
    float _pickPointPrecision;
};
 
#endif // __TY_POSITION_EDITOR__