TYDistanceEditor.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 <qstatusbar.h>
#include <qvector3d.h>
 
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/gui/tools/OGLTextElement.h"
#include "Tympan/gui/tools/OGLLineElement.h"
#include "Tympan/gui/app/TYCameraEditor.h"
#include "Tympan/gui/app/TYRenderWindowInteractor.h"
#include "Tympan/gui/app/TYModelerFrame.h"
#include "Tympan/gui/app/TYApplication.h"
#include "TYDistanceEditor.h"
 
#define TR(id) OLocalizator::getString("TYDistanceEditor", (id))
 
TYDistanceEditor::TYDistanceEditor(TYModelerFrame* pModeler) : TYAbstractSceneEditor(pModeler)
{
    _pCameraEditor = new TYCameraEditor(pModeler);
 
    _pCameraEditor->setLeftButtonFunction2D(&TYCameraEditor::doNothing);
    _pCameraEditor->setMiddleButtonFunction2D(&TYCameraEditor::cameraTranslate);
    _pCameraEditor->setRightButtonFunction2D(&TYCameraEditor::doNothing);
    _pCameraEditor->setShiftLeftButtonFunction2D(&TYCameraEditor::cameraTranslate);
    _pCameraEditor->setShiftRightButtonFunction2D(&TYCameraEditor::cameraZoom);
 
    _shiftOn = false;
    _active = false;
 
    _pOGLLineElement = new OGLLineElement();
    _pOGLLineElement->setVisibility(false);
    OColor oLineColor;
    oLineColor.r = 1.0;
    oLineColor.g = 0.0;
    oLineColor.b = 0.0;
    _pOGLLineElement->setColor(oLineColor);
 
    _pInteractor->getRenderer()->addOGLElement(_pOGLLineElement);
}
 
TYDistanceEditor::~TYDistanceEditor()
{
    _pInteractor->getRenderer()->removeOGLElement(_pOGLLineElement);
    delete _pOGLLineElement;
 
    delete _pCameraEditor;
}
 
void TYDistanceEditor::connect()
{
    TYAbstractSceneEditor::connect();
 
    _pCameraEditor->connect();
}
 
void TYDistanceEditor::disconnect()
{
    TYAbstractSceneEditor::disconnect();
 
    _pCameraEditor->disconnect();
}
 
void TYDistanceEditor::init() {}
 
void TYDistanceEditor::cancel()
{
    close();
}
 
void TYDistanceEditor::close()
{
    showText(false);
 
    _pOGLLineElement->setVisibility(false);
 
    _pInteractor->update();
}
 
void TYDistanceEditor::slotKeyPressed(int key)
{
    switch (key)
    {
        case Qt::Key_Shift:
            _shiftOn = true;
            break;
        case Qt::Key_Escape:
            if (_active)
            {
                cancel();
            }
            break;
    }
}
 
void TYDistanceEditor::slotKeyReleased(int key)
{
    if (key == Qt::Key_Shift)
    {
        _shiftOn = false;
    }
}
 
void TYDistanceEditor::slotViewTypeChanged(int view)
{
    if ((view == TYModelerFrame::PerspView) || (view == TYModelerFrame::FreeView))
    {
        _active = false;
        cancel();
    }
    else
    {
        _active = true;
    }
 
    // On relaie le signal au CameraEditor
    _pCameraEditor->slotViewTypeChanged(view);
}
 
void TYDistanceEditor::slotMousePressed(int x, int y, Qt::MouseButton button, Qt::KeyboardModifiers state)
{
    if (_active && !_shiftOn)
    {
        if (button == Qt::LeftButton)
        {
            // 1er point
            _pOGLLineElement->setPoint1(QVector3D(x, _pInteractor->getViewport().height() - y, 0.0));
 
            // On peut dessiner la ligne
            _pOGLLineElement->setVisibility(true);
        }
    }
}
 
void TYDistanceEditor::slotMouseMoved(int x, int y, Qt::MouseButtons button, Qt::KeyboardModifiers state)
{
    if (button == Qt::LeftButton)
    {
        updateMovingLine(x, y);
    }
}
 
void TYDistanceEditor::slotMouseReleased(int x, int y, Qt::MouseButton button, Qt::KeyboardModifiers state)
{
    if (_active && !_shiftOn)
    {
        if (button == Qt::LeftButton)
        {
            // Affichage Distance dans le output
            writeOutputMsg(_pOGLTextElement->getText());
 
            // Fin
            close();
        }
    }
}
 
bool TYDistanceEditor::updateMovingLine(int x, int y)
{
    if (!_active || _shiftOn)
    {
        return false;
    }
 
    // On recupere la position du curseur
 
    // 2eme point
    _pOGLLineElement->setPoint2(QVector3D(x, _pInteractor->getViewport().height() - y, 0.0));
 
    // Calcul de la distance
    QVector3D world0 = _pInteractor->getViewport().displayToWorld(
        QVector3D(_pOGLLineElement->getPoint1()[0], _pOGLLineElement->getPoint1()[1],
                  _pOGLLineElement->getPoint1()[2]));
    QVector3D world1 = _pInteractor->getViewport().displayToWorld(
        QVector3D(_pOGLLineElement->getPoint2()[0], _pOGLLineElement->getPoint2()[1],
                  _pOGLLineElement->getPoint2()[2]));
 
    double dist = world0.distanceToPoint(world1);
 
    // Msg Dist
    QString msg = QString(TR("id_output_dist")).arg(dist, 0, 'f', 2);
 
    updateText(msg,
               (int)(_pOGLLineElement->getPoint1()[0] +
                     (_pOGLLineElement->getPoint2()[0] - _pOGLLineElement->getPoint1()[0]) / 2.0),
               (int)(_pOGLLineElement->getPoint2()[1] +
                     (_pOGLLineElement->getPoint1()[1] - _pOGLLineElement->getPoint2()[1]) / 2.0));
 
    _pInteractor->update();
 
    return true;
}