OGLScalarBarElement.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 "OGLScalarBarElement.h"
 
#if _WIN32
    #include <windows.h>
#endif //_WIN32
 
#include <GL/gl.h>
 
#include "OGLRectangle.h"
#include "OGLFont.h"
 
OGLScalarBarElement::OGLScalarBarElement()
{
    m_pOGLRectangleLeftToDisplay = new OGLRectangle();
    m_pOGLRectangleRightToDisplay = new OGLRectangle();
    m_pOGLFont0ToDisplay = new OGLFont();
    m_oPosition = QVector3D(0.0, 0.0, 0.0);
    m_stdText0 = "";
    m_stdText1 = "";
    m_stdText2 = "";
    m_fWidth = 1;
    m_fHeight = 1;
    m_bIs3D = false;
}
 
OGLScalarBarElement::~OGLScalarBarElement()
{
    if (m_pOGLRectangleLeftToDisplay)
    {
        delete m_pOGLRectangleLeftToDisplay;
    }
    if (m_pOGLRectangleRightToDisplay)
    {
        delete m_pOGLRectangleRightToDisplay;
    }
    if (m_pOGLFont0ToDisplay)
    {
        delete m_pOGLFont0ToDisplay;
    }
}
 
void OGLScalarBarElement::initPositions()
{
    m_oPosA.setX(m_oPosition.x() - (m_fWidth / 2));
    m_oPosA.setY(m_oPosition.y() - (m_fHeight / 2));
    m_oPosA.setZ(m_oPosition.z());
    m_oPosB.setX(m_oPosition.x());
    m_oPosB.setY(m_oPosition.y() - (m_fHeight / 2));
    m_oPosB.setZ(m_oPosition.z());
    m_oPosC.setX(m_oPosition.x() + (m_fWidth / 2));
    m_oPosC.setY(m_oPosition.y() - (m_fHeight / 2));
    m_oPosC.setZ(m_oPosition.z());
    m_oPosD.setX(m_oPosition.x() + (m_fWidth / 2));
    m_oPosD.setY(m_oPosition.y() + (m_fHeight / 2));
    m_oPosD.setZ(m_oPosition.z());
    m_oPosE.setX(m_oPosition.x());
    m_oPosE.setY(m_oPosition.y() + (m_fHeight / 2));
    m_oPosE.setZ(m_oPosition.z());
    m_oPosF.setX(m_oPosition.x() - (m_fWidth / 2));
    m_oPosF.setY(m_oPosition.y() + (m_fHeight / 2));
    m_oPosF.setZ(m_oPosition.z());
}
 
int OGLScalarBarElement::render()
{
    if (m_bVisible)
    {
        // ScalarBarElement must always be displayed in GL_FILL mode
        GLdouble polygonMode[2];
        glGetDoublev(GL_POLYGON_MODE, polygonMode);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
        if (m_bIs3D)
        {
            // Nouvelle vue
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            m_pOGLRectangleLeftToDisplay->drawRectangle(m_oPosA, m_oPosB, m_oPosE, m_oPosF, OColor::WHITE,
                                                        true);
            m_pOGLRectangleLeftToDisplay->drawRectangle(m_oPosB, m_oPosC, m_oPosD, m_oPosE, OColor::BLACK,
                                                        true);
            if (m_pOGLFont0ToDisplay->load(m_qsFontPath.toStdString().c_str()))
            {
                m_pOGLFont0ToDisplay->bind();
                m_pOGLFont0ToDisplay->drawText(m_stdText0, m_oFontColor, m_oPosA.x() + 1, m_oPosA.y() + 20);
                m_pOGLFont0ToDisplay->drawText(m_stdText1, m_oFontColor, m_oPosB.x() - 1, m_oPosB.y() + 22);
                m_pOGLFont0ToDisplay->drawText(m_stdText2, m_oFontColor, m_oPosC.x() - 5, m_oPosC.y() + 22);
            }
            // Ancienne vue
            glPopMatrix();
        }
        else
        {
            GLint viewport[4];
            glGetIntegerv(GL_VIEWPORT, viewport);
            unsigned int width = viewport[2];
            unsigned int height = viewport[3];
 
            // Nouvelle projection
            glMatrixMode(GL_PROJECTION);
            glPushMatrix();
            glLoadIdentity();
            glOrtho(0, width, 0.0, height, 0.0, 1.0);
 
            // Nouvelle vue
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            glLoadIdentity();
 
            m_pOGLRectangleLeftToDisplay->drawRectangle(m_oPosA, m_oPosB, m_oPosE, m_oPosF, OColor::WHITE,
                                                        true);
            m_pOGLRectangleLeftToDisplay->drawRectangle(m_oPosB, m_oPosC, m_oPosD, m_oPosE, OColor::BLACK,
                                                        true);
            if (m_pOGLFont0ToDisplay->load(m_qsFontPath.toStdString().c_str()))
            {
                m_pOGLFont0ToDisplay->bind();
                m_pOGLFont0ToDisplay->drawText(m_stdText0, m_oFontColor, m_oPosA.x() + 1, m_oPosA.y() + 22);
                m_pOGLFont0ToDisplay->drawText(m_stdText1, m_oFontColor, m_oPosB.x() - 1, m_oPosB.y() + 22);
                m_pOGLFont0ToDisplay->drawText(m_stdText2, m_oFontColor, m_oPosC.x() - 5, m_oPosC.y() + 22);
            }
 
            // Ancienne projection
            glMatrixMode(GL_PROJECTION);
            glPopMatrix();
 
            // Ancienne vue
            glMatrixMode(GL_MODELVIEW);
            glPopMatrix();
        }
 
        // Restore polygons display mode
        glPolygonMode(GL_FRONT_AND_BACK, polygonMode[0]);
    }
 
    return 0;
}