DrawTextGL.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "DrawTextGL.hh"
#include <Gui/biasgl.h>

#if !defined(WIN32)
#  if defined(BIAS_HAVE_GLEW) || defined(MIP_HAVE_GLEW) 
#    include <GL/glxew.h>
#  else 
#    include <GL/glx.h>
#  endif // glew
#endif // Linux

#ifdef WIN32
#  include <windows.h>      // Header File For Windows
#else //WIN32
#  include <X11/extensions/xf86vmode.h>
#  include <X11/keysym.h>
#  include <X11/Intrinsic.h>    /* Display, Window */
//#  include <GL/glx.h>           /* GLXContext */
#endif // WIN32

#include <iostream>
#include <Base/Debug/Error.hh>
#include <Base/Debug/DebugSimple.hh>


// ------------------------------
using namespace std;
using namespace BIAS;
// ------------------------------
// alphabet starts at char 32 and ends at (32+96)
#define CHARS_START 32
#define CHARS_N 96
// ------------------------------


DrawTextGL::~DrawTextGL()
{
    DeleteFont();
}


DrawTextGL::DrawTextGL()
: initialized(false)
{
    base=0;
    fontname="";
}



// Build a bitmap font for OpenGL usage 
// Stores individual charcters in display lists
// Inspired by Nehe lesson 13
// Jan Woetzel 10/2005
int DrawTextGL::InitFont(void* handleDC,
                         const std::string theFontname,
                         const int fontHeight
                         )
{

    this->fontname=theFontname;

#ifdef WIN32
    BIASASSERT(handleDC!=NULL);
    //
    // WINDOWS (JW)
    //

    // Windows Font ID
    HFONT   font =NULL;
    HFONT   oldfont=NULL;
    // Storage For Characters
    base = glGenLists(CHARS_N);

    // CFont:
    font = CreateFont(  
        fontHeight, // height
        0, // Width 
        0, 
        0, 
        FW_NORMAL, // font weight, e.g. FW_NORMAL FW_BOLD
        FALSE, // Italic
        FALSE, // Underline
        FALSE, // Strikeout
        ANSI_CHARSET,
        OUT_TT_PRECIS, // Output Precision OUT_DEFAULT_PRECIS OUT_TT_PRECIS
        CLIP_DEFAULT_PRECIS, // Clipping Precision
        ANTIALIASED_QUALITY, // Output Quality
        FF_DONTCARE|DEFAULT_PITCH, // Family And Pitch
        fontname.c_str()  
        );

    oldfont = (HFONT)SelectObject(HDC(handleDC), font);
    if (oldfont==NULL){
        BIASERR("SelectObject failed. NULL");
    }

    // Build maps
    wglUseFontBitmaps(HDC(handleDC), CHARS_START, CHARS_N, base); 

    // Selects The Font We Want
    SelectObject(HDC(handleDC), oldfont);

    // Delete The Font since w ehave our display lists
    DeleteObject(font);

#else // WIN32

    //
    // LINUX (JW)
    // 
    Display* display=NULL;
    //display = (Display*)(handleDC);
    
    display = XOpenDisplay(0);
    if (display == NULL){
      BIASERR("XOpenDisplay failed for GLX font initialization. aborting");
      return -1;
    };
    {
      
      XFontStruct *fontX = NULL;
      // use N display lists, one for each character 
      base = glGenLists(CHARS_N);
      // load a font with a specific name in "Host Portable Character Encoding"
      fontX = XLoadQueryFont(display
                 //display.dpy
                 ,fontname.c_str()
                 // "-*-helvetica-bold-r-normal--24-*-*-*-p-*-iso8859-1"
                 );
      if (fontX == NULL)
        {
          //BIASERR("Could not load font "<<fontname<<" switching to fixed");
          // try a fallback font
        fontname="fixed";
        fontX = XLoadQueryFont( display
                   //display.dpy
                   ,fontname.c_str() );

        if (fontX == NULL)
          {
        BIASERR("Problem loading font - fallback failed, too: "<<fontname);;
        this->DeleteFont();
        initialized=false;
        return -1;
          }
        }
      // Build maps
      glXUseXFont(fontX->fid, CHARS_START, CHARS_N, base);
        
      // free XFontStruct since we have our display lists
      XFreeFont(display
            //display.dpy
            ,fontX);
    }
    // clean up
    XCloseDisplay(display);
    display = NULL;
    
#endif // WIN32
    
    
    initialized=true;
    return 0; // OK
}


// JW 
void DrawTextGL::DeleteFont()
{
    // clean up the display lists we used. 
    glDeleteLists(base, CHARS_N);
}


// JW: tested, works
void DrawTextGL::PrintNormCoords(const std::string & text, 
                     const float & xpos, const float & ypos) const
{
#ifdef BIAS_DEBUG
    if ((0>xpos)|(xpos>1) | (0>ypos)|(ypos>1) )
        BIASERR("("<<xpos<<","<<ypos<<" is out of normalized 0..1 coordinate bounds. Is this intentional?");    
#endif //BIAS_DEBUG

    // works with OpenGL 1.1
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    {
        glLoadIdentity();
        glOrtho(0.0, 1.0,
            0.0, 1.0,
            0.1, 1.0);
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        {
            glLoadIdentity();
            // move into screen 
            glTranslatef(0.0, 0.0, -0.5);
            glRasterPos2f(xpos, ypos);
            Print(text); // output 
        }
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
    }
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
}


#include <Base/Common/BIASpragmaStart.hh>
// JW: tested, works
void DrawTextGL::PrintWinCoords(const std::string & text,
                       const int & xpos, const int & ypos,
                       const int & winWidthFallback, const int &winHeightFallback) const
{
#ifdef BIAS_HAVE_GLEW
    if (GL_ARB_window_pos) {
        // Supported at least by OpenGL 1.4 
        glWindowPos2f(xpos, ypos);
        Print(text);
    } else 
#endif // BIAS_HAVE_GLEW
  {
        // fallback for OpenGL 1.1
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        {
            glLoadIdentity();
            gluOrtho2D(
                0.0, float(winWidthFallback), 
                0.0, float(winHeightFallback) 
                );
            glMatrixMode(GL_MODELVIEW);
            glPushMatrix();
            {
                glLoadIdentity();
                Print(text); // output 
            }
            glMatrixMode(GL_MODELVIEW);
            glPopMatrix();
        }
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
    }
}
#include <Base/Common/BIASpragmaEnd.hh>


// JW
void DrawTextGL::Print3D(const std::string & text,
                       const float & xpos, const float & ypos, const float & zpos) const
{
    glRasterPos3f(xpos, ypos, zpos);
    Print(text);
}


// JW
void DrawTextGL::Print3DAbsolute(const std::string & text, 
                                 const float & xpos, const float & ypos, const float & zpos) const
{
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    {
        glLoadIdentity();
        Print3D(text, xpos, ypos, zpos);
    }
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
}


// JW
void DrawTextGL::Print(const std::string & text) const
{
    if (!initialized) {
        cout<<"You must call InitFont before using DrawTextGL::Print (JW), aborting."<<endl;
        return;
    };

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    {
        //glTranslatef(0.0f,0.0f,-1.0f);                        // Move One Unit Into The Screen


        glPushAttrib(GL_LIST_BIT);
        // set display list offset base 
        glListBase(base - CHARS_START); 
        // Draws all characters as individual display list calls
        glCallLists( text.size(), GL_UNSIGNED_BYTE, text.c_str() );
        glPopAttrib(); // restire prevois displa ylist basis 
    }
    glPopMatrix();
}