GLViewer_Drawer.h

Go to the documentation of this file.

// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  Author : OPEN CASCADE
// File:      GLViewer_Drawer.h
// Created:   November, 2004
//
#ifndef GLVIEWER_DRAWER_H
#define GLVIEWER_DRAWER_H

#ifdef WIN32
#include "windows.h"
#endif

#include <QColor>
#include <QFont>

class QFile;

#ifdef __APPLE__
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif

#include "GLViewer.h"
#include "GLViewer_Defs.h"
#include "GLViewer_Geom.h"

class GLViewer_Object;
class GLViewer_Rect;
class GLViewer_CoordSystem;

#ifdef WIN32
#pragma warning( disable:4251 )
#endif

struct GLVIEWER_API GLViewer_TexIdStored
{
  GLuint      myTexFontId;
  int         myTexFontWidth;
  int         myTexFontHeight;
};

struct GLVIEWER_API GLViewer_TexFindId
{
  QString     myFontFamily;
  bool        myIsBold;
  bool        myIsItal;
  bool        myIsUndl;
  int         myPointSize;
  long        myViewPortId;
  bool operator < (const GLViewer_TexFindId theStruct) const 
  { 
    if ( myViewPortId != theStruct.myViewPortId )
      return myViewPortId < theStruct.myViewPortId;
    else if ( myPointSize != theStruct.myPointSize )
      return myPointSize < theStruct.myPointSize;
    else if ( myIsBold != theStruct.myIsBold )
      return myIsBold < theStruct.myIsBold;
    else if ( myIsItal != theStruct.myIsItal )
      return myIsItal < theStruct.myIsItal;
    else if ( myIsUndl != theStruct.myIsUndl )
      return myIsUndl < theStruct.myIsUndl;
    else
      return myFontFamily < theStruct.myFontFamily;
  }
};

class GLVIEWER_API GLViewer_TexFont
{
public:
  GLViewer_TexFont();
  /*
  * \param theFont         - a base font
  * \param theSeparator    - separator between letters
  * \param theIsResizeable - specifies whether text drawn by this object can be scaled along with the scene
  * \param theMinMagFilter - min/mag filter, affects text sharpness
  */
  GLViewer_TexFont( QFont* theFont, 
                    int theSeparator = 2, 
                    bool theIsResizeable = false, 
                    GLuint theMinMagFilter = GL_LINEAR/*_ATTENUATION*/ );
  ~GLViewer_TexFont();
  
  bool            generateTexture();
  void            drawString( QString  theStr,
                              GLdouble theX = 0.0,
                              GLdouble theY = 0.0,
                              GLfloat  theScale = 1.0 );
  
  int             getSeparator(){ return mySeparator; }
  void            setSeparator( int theSeparator ){ mySeparator = theSeparator; }
  
  int             getStringWidth( QString theString );
  int             getStringHeight();
  
  static void     clearTextBases();

  static QMap<GLViewer_TexFindId,GLViewer_TexIdStored> TexFontBase;
  static QMap<GLViewer_TexFindId,GLuint>               BitmapFontCache;

private:
  void            init();
  
private:
  int             myNbSymbols;
  int*            myWidths;
  int*            myPositions;
  QFont           myQFont;
  GLuint          myTexFont;
  int             myTexFontWidth;
  int             myTexFontHeight;
  int             mySeparator;
  bool            myIsResizeable;
  GLuint          myMinMagFilter;
  int             myFontHeight;
  int             myMaxRowWidth;
};

class GLVIEWER_API GLViewer_Drawer
{
public:
  enum
  {
    GLText_Center = 0,
    GLText_Left,
    GLText_Right,
    GLText_Top,
    GLText_Bottom
  };

  // Objects status ( needs for change colors )
  //enum ObjectStatus
  //{
  //  OS_Normal = 0,
  //  OS_Highlighted,
  //  OS_Selected
  //};
  
  // 
  //enum ClosedStatus
  //{
  //  CS_CLOSED = 0,
  //  CS_OPEN = 1
  //};  

  GLViewer_Drawer();
  virtual ~GLViewer_Drawer();
  
  /*
  *\param xScale - current scale along X-direction
  *\param yScale - current scale along Y-direction
  *\param onlyUpdate - = true if only update highlight-select information
  */
  virtual void                    create( float xScale, float yScale, bool onlyUpdate ) = 0;  
  
  virtual void                    addObject( GLViewer_Object* theObject ){ myObjects.append( theObject ); }
  virtual void                    clear(){ myObjects.clear(); }
  
  QString                         getObjectType() const { return myObjectType; }

  int                             getPriority() const { return myPriority; }

        void                            setAntialiasing(const bool on);
  
  static void                     destroyAllTextures();
  

  virtual bool                    translateToHPGL( QFile& hFile, GLViewer_CoordSystem* aViewerCS, GLViewer_CoordSystem* aHPGLCS );
  

  virtual bool                    translateToPS( QFile& hFile, GLViewer_CoordSystem* aViewerCS, GLViewer_CoordSystem* aPSCS ); 
  
#ifdef WIN32


  virtual bool                    translateToEMF( HDC hDC, GLViewer_CoordSystem* aViewerCS, GLViewer_CoordSystem* aEMFCS );
#endif
  

  static GLuint                   loadTexture( const QString& fileName,
                                               GLint* x_size = 0,
                                               GLint* y_size = 0,
                                               GLint* t_size = 0);


  void                            drawTexture( GLuint texture,
                                               GLint size,
                                               GLfloat x,
                                               GLfloat y );


  void                            drawTexture( GLuint texture,
                                               GLint x_size,
                                               GLint y_size,
                                               GLfloat x,
                                               GLfloat y );


  void                            drawTexturePart( GLuint texture,
                                                   GLfloat x_ratio,
                                                   GLfloat y_ratio,
                                                   GLfloat x_size,
                                                   GLfloat y_size,
                                                   GLfloat x,
                                                   GLfloat y,
                                                   GLfloat scale = 0 );




  void                            drawText( const QString& text,
                                            GLfloat xPos,
                                                                          GLfloat yPos,
                                            const QColor& color,
                                            QFont* aFont,
                                            int theSeparator,
                                            DisplayTextFormat = DTF_BITMAP );


  void                            drawGLText( QString text,
                                                                            float x,
                                                                            float y,
                                              int hPosition = GLText_Center,
                                              int vPosition = GLText_Center,
                                              QColor color = Qt::black,
                                              bool smallFont = false );


  inline void                     setFont( const QFont& font ) { myFont = font; }

  inline QFont                    font() const { return myFont; }


  inline void                     setTextFormat( const DisplayTextFormat format ) { myTextFormat = format; }

  inline DisplayTextFormat        textFormat() const { return myTextFormat; }


  inline void                     setTextScale( const GLfloat factor ) { myTextScale = factor; }

  inline GLfloat                  textScale() const { return myTextScale; }

  GLViewer_Rect                   textRect( const QString& ) const;


  static void                     drawRectangle( GLViewer_Rect* theRect, QColor = Qt::black );

protected:
  //* with predefined color
  static void                     drawRectangle( GLViewer_Rect*, GLfloat, GLfloat = 0, QColor = Qt::black, 
                                                 bool = false, QColor = Qt::white );
  static void                     drawContour( GLViewer_Rect*, QColor, GLfloat, GLushort, bool );
  static void                     drawContour( const GLViewer_PntList&, QColor, GLfloat );
  static void                     drawPolygon( GLViewer_Rect*, QColor, GLushort, bool );
  static void                     drawPolygon( const GLViewer_PntList&, QColor );
  static void                     drawVertex( GLfloat, GLfloat, QColor );
  static void                     drawCross( GLfloat, GLfloat, QColor );
  static void                     drawArrow( const GLfloat red, const GLfloat green, const GLfloat blue,
                                             GLfloat, GLfloat, GLfloat, GLfloat,
                                             GLfloat, GLfloat, GLfloat, GLboolean = GL_FALSE );

  virtual void                    drawText( GLViewer_Object* theObject );

  float                           myXScale;
  float                           myYScale;
  
  QList<GLViewer_Object*>    myObjects;
  GLuint                          myTextList;
  
  QString                         myObjectType;
  int                             myPriority;

  QFont                           myFont;
  DisplayTextFormat               myTextFormat;

  GLfloat                         myTextScale;
};

#ifdef WIN32
#pragma warning ( default:4251 )
#endif

#endif // GLVIEWER_DRAWER_H