开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
glbitmapfont.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：28k
源码类别：

生物技术

开发平台：

C/C++

glbitmapfont.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: glbitmapfont.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 20:50:25  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.20
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: glbitmapfont.cpp,v 1000.3 2004/06/01 20:50:25 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Mike DiCuccio
  36.  *
  37.  * File Description:
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <gui/opengl/glbitmapfont.hpp>
  43. #include <gui/opengl/gldlist.hpp>
  44. #include "glutbitmap.h"
  45. #include <math.h>
  46. #include <stdio.h>
  47. #include <util/static_map.hpp>
  49. extern "C" {
  51.     // clean fonts
  52.     extern BitmapFontRec ncbi_clean_6;
  53.     extern BitmapFontRec ncbi_clean_8;
  54.     extern BitmapFontRec ncbi_clean_10;
  55.     extern BitmapFontRec ncbi_clean_12;
  56.     extern BitmapFontRec ncbi_clean_13;
  57.     extern BitmapFontRec ncbi_clean_14;
  58.     extern BitmapFontRec ncbi_clean_15;
  59.     extern BitmapFontRec ncbi_clean_16;
  61.     // courier fonts
  62.     extern BitmapFontRec ncbi_courier_6;
  63.     extern BitmapFontRec ncbi_courier_8;
  64.     extern BitmapFontRec ncbi_courier_10;
  65.     extern BitmapFontRec ncbi_courier_12;
  66.     extern BitmapFontRec ncbi_courier_14;
  67.     extern BitmapFontRec ncbi_courier_18;
  68.     extern BitmapFontRec ncbi_courier_20;
  69.     extern BitmapFontRec ncbi_courier_24;
  71.     // fixed size fonts
  72.     extern BitmapFontRec ncbi_fixed_6;
  73.     extern BitmapFontRec ncbi_fixed_8;
  74.     extern BitmapFontRec ncbi_fixed_10;
  75.     extern BitmapFontRec ncbi_fixed_12;
  76.     extern BitmapFontRec ncbi_fixed_14;
  77.     extern BitmapFontRec ncbi_fixed_18;
  78.     extern BitmapFontRec ncbi_fixed_20;
  79.     extern BitmapFontRec ncbi_fixed_20;
  81.     // helvetica fonts
  82.     extern BitmapFontRec ncbi_helvetica_6;
  83.     extern BitmapFontRec ncbi_helvetica_8;
  84.     extern BitmapFontRec ncbi_helvetica_10;
  85.     extern BitmapFontRec ncbi_helvetica_12;
  86.     extern BitmapFontRec ncbi_helvetica_14;
  87.     extern BitmapFontRec ncbi_helvetica_18;
  88.     extern BitmapFontRec ncbi_helvetica_20;
  89.     extern BitmapFontRec ncbi_helvetica_24;
  91.     // ludica fonts
  92.     extern BitmapFontRec ncbi_lucida_6;
  93.     extern BitmapFontRec ncbi_lucida_8;
  94.     extern BitmapFontRec ncbi_lucida_10;
  95.     extern BitmapFontRec ncbi_lucida_12;
  96.     extern BitmapFontRec ncbi_lucida_14;
  97.     extern BitmapFontRec ncbi_lucida_18;
  98.     extern BitmapFontRec ncbi_lucida_20;
  99.     extern BitmapFontRec ncbi_lucida_24;
  101.     // times fonts
  102.     extern BitmapFontRec ncbi_times_6;
  103.     extern BitmapFontRec ncbi_times_8;
  104.     extern BitmapFontRec ncbi_times_10;
  105.     extern BitmapFontRec ncbi_times_12;
  106.     extern BitmapFontRec ncbi_times_14;
  107.     extern BitmapFontRec ncbi_times_18;
  108.     extern BitmapFontRec ncbi_times_20;
  109.     extern BitmapFontRec ncbi_times_24;
  110. }
  113. BEGIN_NCBI_SCOPE
  116. typedef pair<CGlBitmapFont::EFont, BitmapFontPtr> TFontPair;
  117. static const TFontPair sc_Fonts[] = {
  118.     TFontPair(CGlBitmapFont::eBitmap5x7,   &ncbi_fixed_8),
  119.     TFontPair(CGlBitmapFont::eBitmap8x13,  &ncbi_fixed_12),
  120.     TFontPair(CGlBitmapFont::eBitmap9x15,  &ncbi_fixed_14),
  121.     TFontPair(CGlBitmapFont::eBitmap10x20, &ncbi_fixed_18),
  122.     TFontPair(CGlBitmapFont::eBitmap12x24, &ncbi_fixed_20),
  124.     TFontPair(CGlBitmapFont::eHelvetica6,  &ncbi_helvetica_6),
  125.     TFontPair(CGlBitmapFont::eHelvetica8,  &ncbi_helvetica_8),
  126.     TFontPair(CGlBitmapFont::eHelvetica10, &ncbi_helvetica_10),
  127.     TFontPair(CGlBitmapFont::eHelvetica12, &ncbi_helvetica_12),
  128.     TFontPair(CGlBitmapFont::eHelvetica14, &ncbi_helvetica_14),
  129.     TFontPair(CGlBitmapFont::eHelvetica18, &ncbi_helvetica_18),
  130.     TFontPair(CGlBitmapFont::eHelvetica20, &ncbi_helvetica_20),
  131.     TFontPair(CGlBitmapFont::eHelvetica24, &ncbi_helvetica_24),
  133.     TFontPair(CGlBitmapFont::eLucida6,  &ncbi_lucida_6),
  134.     TFontPair(CGlBitmapFont::eLucida8,  &ncbi_lucida_8),
  135.     TFontPair(CGlBitmapFont::eLucida10, &ncbi_lucida_10),
  136.     TFontPair(CGlBitmapFont::eLucida12, &ncbi_lucida_12),
  137.     TFontPair(CGlBitmapFont::eLucida14, &ncbi_lucida_14),
  138.     TFontPair(CGlBitmapFont::eLucida18, &ncbi_lucida_18),
  139.     TFontPair(CGlBitmapFont::eLucida20, &ncbi_lucida_20),
  140.     TFontPair(CGlBitmapFont::eLucida24, &ncbi_lucida_24),
  142.     TFontPair(CGlBitmapFont::eCourier6,  &ncbi_courier_6),
  143.     TFontPair(CGlBitmapFont::eCourier8,  &ncbi_courier_8),
  144.     TFontPair(CGlBitmapFont::eCourier10, &ncbi_courier_10),
  145.     TFontPair(CGlBitmapFont::eCourier12, &ncbi_courier_12),
  146.     TFontPair(CGlBitmapFont::eCourier14, &ncbi_courier_14),
  147.     TFontPair(CGlBitmapFont::eCourier18, &ncbi_courier_18),
  148.     TFontPair(CGlBitmapFont::eCourier20, &ncbi_courier_20),
  149.     TFontPair(CGlBitmapFont::eCourier24, &ncbi_courier_24),
  151.     TFontPair(CGlBitmapFont::eClean6,  &ncbi_clean_6),
  152.     TFontPair(CGlBitmapFont::eClean8,  &ncbi_clean_8),
  153.     TFontPair(CGlBitmapFont::eClean10, &ncbi_clean_10),
  154.     TFontPair(CGlBitmapFont::eClean12, &ncbi_clean_12),
  155.     TFontPair(CGlBitmapFont::eClean14, &ncbi_clean_13),
  156.     TFontPair(CGlBitmapFont::eClean18, &ncbi_clean_14),
  157.     TFontPair(CGlBitmapFont::eClean20, &ncbi_clean_15),
  158.     TFontPair(CGlBitmapFont::eClean24, &ncbi_clean_16),
  160.     TFontPair(CGlBitmapFont::eFixed8,  &ncbi_fixed_8),
  161.     TFontPair(CGlBitmapFont::eFixed10, &ncbi_fixed_10),
  162.     TFontPair(CGlBitmapFont::eFixed12, &ncbi_fixed_12),
  163.     TFontPair(CGlBitmapFont::eFixed14, &ncbi_fixed_14),
  164.     TFontPair(CGlBitmapFont::eFixed18, &ncbi_fixed_18),
  165.     TFontPair(CGlBitmapFont::eFixed20, &ncbi_fixed_20),
  167.     TFontPair(CGlBitmapFont::eTimesRoman6,  &ncbi_times_6),
  168.     TFontPair(CGlBitmapFont::eTimesRoman8,  &ncbi_times_8),
  169.     TFontPair(CGlBitmapFont::eTimesRoman10, &ncbi_times_10),
  170.     TFontPair(CGlBitmapFont::eTimesRoman12, &ncbi_times_12),
  171.     TFontPair(CGlBitmapFont::eTimesRoman14, &ncbi_times_14),
  172.     TFontPair(CGlBitmapFont::eTimesRoman18, &ncbi_times_18),
  173.     TFontPair(CGlBitmapFont::eTimesRoman20, &ncbi_times_20),
  174.     TFontPair(CGlBitmapFont::eTimesRoman24, &ncbi_times_24)
  176. };
  177. typedef CStaticArrayMap<CGlBitmapFont::EFont, BitmapFontPtr> TFontMap;
  178. static const TFontMap sc_FontMap(sc_Fonts, sizeof (sc_Fonts));
  180. static inline
  181. const BitmapFontPtr s_GetFont(CGlBitmapFont::EFont font)
  182. {
  183.     TFontMap::const_iterator iter = sc_FontMap.lower_bound(font);
  184.     if (iter->first == font) {
  185.         // exact match
  186.         return iter->second;
  187.     } else if (iter->first != font) {
  188.         // probably off by size
  189.         CGlBitmapFont::EFontFace face =
  190.             static_cast<CGlBitmapFont::EFontFace>
  191.             (font & 0xff);
  192.         CGlBitmapFont::EFontFace this_face =
  193.             static_cast<CGlBitmapFont::EFontFace>
  194.             (iter->first & 0xff);
  195.         if (this_face == face) {
  196.             // faces match, return font
  197.             return iter->second;
  198.         } else {
  199.             // faces don't match
  200.             // we need to jump forward or back to get the right face
  201.             TFontMap::const_iterator back    = iter;
  202.             TFontMap::const_iterator forward = iter;
  203.             for ( ;
  204.                   back != sc_FontMap.begin()  &&
  205.                   forward != sc_FontMap.end();  ) {
  206.                 if (back != sc_FontMap.begin()) {
  207.                     CGlBitmapFont::EFontFace this_face =
  208.                         static_cast<CGlBitmapFont::EFontFace>
  209.                         (back->first & 0xff);
  210.                     if (this_face == face) {
  211.                         return back->second;
  212.                     }
  213.                     --back;
  214.                 }
  215.                 if (forward != sc_FontMap.end()) {
  216.                     CGlBitmapFont::EFontFace this_face =
  217.                         static_cast<CGlBitmapFont::EFontFace>
  218.                         (forward->first & 0xff);
  219.                     if (this_face == face) {
  220.                         return forward->second;
  221.                     }
  222.                     ++forward;
  223.                 }
  224.             }
  225.         }
  226.     }
  228.     NCBI_THROW(CException, eUnknown, "gl font not found");
  229. }
  232. //
  233. // return the width of a single character
  234. // this is really the *advance* of a character
  235. //
  236. static float s_GetCharAdvance(char c, const BitmapFontRec* font_ptr)
  237. {
  238.     if (c  <   font_ptr->first ||
  239.         c  >=  font_ptr->first + font_ptr->num_chars) {
  240.         return 0.0f;
  241.     }
  243.     const BitmapCharRec *ch = font_ptr->ch[c - font_ptr->first];
  244.     if ( !ch ) {
  245.         return 0.0f;
  246.     }
  248.     return ch->advance;
  249. }
  252. static float s_GetCharWidth(char c, const BitmapFontRec* font_ptr)
  253. {
  254.     if (c  <   font_ptr->first ||
  255.         c  >=  font_ptr->first + font_ptr->num_chars) {
  256.         return 0.0f;
  257.     }
  259.     const BitmapCharRec *ch = font_ptr->ch[c - font_ptr->first];
  260.     if ( !ch ) {
  261.         return 0.0f;
  262.     }
  264.     return (float)ch->width;
  265. }
  270. CGlBitmapFont::CGlBitmapFont()
  271.     : m_Font(eBitmap8x13)
  272. {
  273.     SetFont(eBitmap8x13);
  274. }
  277. CGlBitmapFont::CGlBitmapFont(EFont font)
  278.     : m_Font(font)
  279. {
  280.     SetFont(font);
  281. }
  284. CGlBitmapFont::~CGlBitmapFont()
  285. {
  286. }
  289. void CGlBitmapFont::SetFontFace(EFontFace face)
  290. {
  291.     EFont font = static_cast<EFont>((m_Font & 0xff) | face);
  292.     SetFont(font);
  293. }
  296. void CGlBitmapFont::SetFontSize(EFontSize size)
  297. {
  298.     EFont font = static_cast<EFont>((m_Font & ~0xff) | size);
  299.     SetFont(font);
  300. }
  303. void CGlBitmapFont::SetFont(EFont font)
  304. {
  305.     if (font != m_Font) {
  306.         m_Font = font;
  308.         // we must also invalidate all of our display lists
  309.         // this may be expensive, as it forces regeneration of display
  310.         // lists the next time we render any characters
  311.         for (int i = 0;  i < 256;  ++i) {
  312.             if (m_Chars[i]) {
  313.                 m_Chars[i]->Invalidate();
  314.             }
  315.         }
  316.     }
  317. }
  319. template<class TOutputMethod>
  320. void DoTextOut(TOutputMethod& method)
  321. {
  322.     // save a bunch of states
  323.     GLint swapbytes;
  324.     GLint lsbfirst;
  325.     GLint rowlength;
  326.     GLint skiprows;
  327.     GLint skippixels;
  328.     GLint alignment;
  329.     glGetIntegerv(GL_UNPACK_SWAP_BYTES,  &swapbytes);
  330.     glGetIntegerv(GL_UNPACK_LSB_FIRST,   &lsbfirst);
  331.     glGetIntegerv(GL_UNPACK_ROW_LENGTH,  &rowlength);
  332.     glGetIntegerv(GL_UNPACK_SKIP_ROWS,   &skiprows);
  333.     glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
  334.     glGetIntegerv(GL_UNPACK_ALIGNMENT,   &alignment);
  336.     glPixelStorei(GL_UNPACK_SWAP_BYTES,  GL_FALSE);
  337.     glPixelStorei(GL_UNPACK_LSB_FIRST,   GL_FALSE);
  338.     glPixelStorei(GL_UNPACK_ROW_LENGTH,  0);
  339.     glPixelStorei(GL_UNPACK_SKIP_ROWS,   0);
  340.     glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
  341.     glPixelStorei(GL_UNPACK_ALIGNMENT,   1);
  343.     // render our text
  344.     method();
  346.     // restore states
  347.     glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
  348.     glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
  349.     glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
  350.     glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
  351.     glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
  352.     glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
  353. }
  355. class CTextPrinter
  356. {
  357. public:
  358.     CTextPrinter(const char* text, const BitmapFontPtr& font_ptr)
  359.         : m_Text(text),
  360.           m_FontPtr(font_ptr)
  361.     {
  362.     }
  363.     void operator()()
  364.     {        
  365.         for (const char* p = m_Text;  p  &&  *p;  ++p) {
  366.             if (*p <  m_FontPtr->first  ||
  367.                 *p >= m_FontPtr->first + m_FontPtr->num_chars) {
  368.                 continue;
  369.             }
  370.             const BitmapCharRec *ch = m_FontPtr->ch[*p - m_FontPtr->first];
  371.             if (ch ) {
  372.                 glBitmap(ch->width, ch->height, ch->xorig, ch->yorig,
  373.                          ch->advance, 0, ch->bitmap);
  374.             }
  375.         }
  376.     };
  377. protected:
  378.     const char* m_Text;
  379.     const BitmapFontPtr& m_FontPtr;
  380. };
  383. //
  384. // TextOut()
  385. // This version performs most of the low-level work.  It simply
  386. // outputs text at a previously determined raster position
  387. //
  388. void CGlBitmapFont::TextOut(const char* text) const
  389. {
  390.     GLint mode;
  391.     glGetIntegerv(GL_RENDER_MODE, &mode);
  392.     switch (mode) {
  393.     case GL_FEEDBACK:
  394.         {{
  395.             GLfloat pos[4];
  396.             GLfloat col[4];
  398.             glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
  399.             glGetFloatv(GL_CURRENT_RASTER_COLOR, col);
  401.             const CGlColor c(col, 4);
  403.             typedef vector<float> TFList;
  404.             TFList vectext =
  405.                 CGlFeedbackFont::EncodeText(pos, c, text, strlen(text));
  406.             ITERATE (TFList, it, vectext) {
  407.                 glPassThrough(*it);
  408.             }
  409.         }}
  410.         break;
  412.     default:
  413.         {{
  414.             // first, retrieve our OpenGL font
  415.             const BitmapFontPtr font_ptr = s_GetFont(m_Font);
  416.             CTextPrinter    printer(text, font_ptr);
  417.             DoTextOut(printer);
  418.         }}
  419.         break;
  420.     }
  421. }
  423. class CTextArrayPrinter
  424. {
  425. public:
  426.     CTextArrayPrinter(const char* text,
  427.                       float x, float y, float dx, float dy,
  428.                       float scale_x, float scale_y,
  429.                       const BitmapFontPtr& font_ptr)
  430.         : m_Text(text),
  431.           m_X(x),
  432.           m_Y(y),
  433.           m_dX(dx),
  434.           m_dY(dy),
  435.           m_ScaleX(scale_x),
  436.           m_ScaleY(scale_y),
  437.           m_FontPtr(font_ptr)
  438.     {
  439.     }
  441.     void operator()()
  442.     {        
  443.         float k_x = m_ScaleX / 2;
  444.         float k_y = m_ScaleY / 2;
  446.         for (const char* p = m_Text;  p  &&  *p;  ++p) {
  447.             if (*p  <   m_FontPtr->first ||
  448.                 *p  >=  m_FontPtr->first + m_FontPtr->num_chars) {
  449.                 continue;
  450.             }
  451.             const BitmapCharRec *ch = m_FontPtr->ch[*p - m_FontPtr->first];
  452.             if (ch ) {
  453.                 int ind = p - m_Text;
  454.                 float pos_x = m_X + ind * m_dX;
  455.                 float pos_y = m_Y + ind * m_dY;
  456.                 float off_x = ch->width * k_x; // to current coord system
  457.                 float off_y = ch->height * k_y; // to current coord system
  458.                 
  459.                 glRasterPos2f(pos_x - off_x, pos_y - off_y);
  461.                 glBitmap(ch->width, ch->height, ch->xorig, ch->yorig,
  462.                          0, 0, ch->bitmap);
  464.                 /**
  465.                 if ( !m_Chars[*p] ) {
  466.                     m_Chars[*p].Reset(new CGlDisplayList());
  467.                 }
  469.                 if (m_Chars[*p]->IsValid()) {
  470.                     m_Chars[*p]->Call();
  471.                 } else {
  472.                     CGlDisplayListCompile COMPILE(*m_Chars[*p],
  473.                                                   GL_COMPILE_AND_EXECUTE);
  474.                     glBitmap(ch->width, ch->height, ch->xorig, ch->yorig,
  475.                              ch->advance, 0, ch->bitmap);
  476.                 }
  477.                 **/
  478.             }
  479.         }
  480.     };
  481. protected:
  482.     const char* m_Text;
  483.     float   m_X, m_Y;
  484.     float   m_dX, m_dY;
  485.     float   m_ScaleX, m_ScaleY;
  486.     const BitmapFontPtr& m_FontPtr;
  487. };
  489. void    CGlBitmapFont::ArrayTextOut(float x, float y, float dx, float dy, const char* text,
  490.                                     float scale_x, float scale_y) const
  491. {    
  492.     GLint mode;
  493.     glGetIntegerv(GL_RENDER_MODE, &mode);
  494.     switch (mode) {
  495.     case GL_FEEDBACK:
  496.         {{
  497.             _ASSERT(false); // not implemented yet
  498.         }}
  499.         break;
  500.     default:
  501.         {{
  502.             // first, retrieve our OpenGL font
  503.             const BitmapFontPtr font_ptr = s_GetFont(m_Font);
  504.             CTextArrayPrinter    printer(text, x, y, dx, dy, scale_x, scale_y, font_ptr);
  505.             DoTextOut(printer);
  506.         }}
  507.         break;
  508.     }
  509. }
  511. //
  512. // TextOut()
  513. // This version performs some label alignment in the specified box
  514. //
  515. void CGlBitmapFont::TextOut(float x, float y, float w, float h,
  516.                             const char* text, int align,
  517.                             ETruncate trunc) const
  518. {
  519.     string str;
  520.     switch (trunc) {
  521.     case eTruncate_None:
  522.         str = text;
  523.         break;
  525.     case eTruncate_Empty:
  526.     case eTruncate_Ellipsis:
  527.         x_Truncate(text, w, trunc, &str);
  528.         break;
  529.     }
  530.     
  531.     float ras_x, ras_y;
  533.     // FL_ALIGN_RIGHT or FL_ALIGN_CENTER are applied to horz position only if
  534.     // FL_ALIGN_LEFT is not specifed
  535.     if(align & FL_ALIGN_LEFT)  { 
  536.         ras_x = x;
  537.     } else if (align & FL_ALIGN_RIGHT)  { // right justify            
  538.         float text_wid = TextWidth(str.c_str());
  539.         ras_x = x + (w - text_wid);
  540.     } else  { // center
  541.         float text_wid = TextWidth(str.c_str());
  542.         ras_x = x + (w - text_wid) * 0.5f;
  543.     }
  545.     if (align & FL_ALIGN_BOTTOM)  {
  546.         ras_y = y;
  547.     } else if (align & FL_ALIGN_TOP) { // skip down enough to keep our text inside            
  548.         float text_ht = TextHeight();
  549.         ras_y = y + h - text_ht;
  550.     } else { // if nothing given or FL_ALIGN_CENTER is specified - center vertically        
  551.         float text_ht = TextHeight();
  552.         ras_y = y + (h - text_ht) * 0.5f;
  553.     }
  554.     
  555.     TextOut(ras_x, ras_y, str.c_str());
  556. }
  558. void CGlBitmapFont::TextOut(float x, float y, const char* text) const
  559. {
  560.     glRasterPos2f(x, y);
  561.     TextOut(text);
  562. }
  565. //
  566. // compute the width of a string of characters
  567. // this will count out at most n characters, stopping on a null
  568. // note that the comparison function used for 'n' is 0 or non-zero -
  569. // so passing '-1' for 'n' means 'compute until a null character is found'
  570. // This allows us to avoid calling strlen()
  571. //
  572. float CGlBitmapFont::TextWidth(const char* text, int n) const
  573. {
  574.     return GetMetric(eMetric_TextWidth, text, n);
  575. }
  578. //
  579. // compute the length of a null-terminated string
  580. //
  581. float CGlBitmapFont::TextWidth(const char* text) const
  582. {
  583.     return GetMetric(eMetric_TextWidth, text);
  584. }
  587. //
  588. // compute the height of a string
  589. //
  590. float CGlBitmapFont::TextHeight(void) const
  591. {
  592.     return GetMetric(eMetric_CharHeight);
  593. }
  596. //
  597. // generic text metric retrieval
  598. //
  599. float CGlBitmapFont::GetMetric(EMetric metric,
  600.                                const char* text, int text_len) const
  601. {
  602.     // first, retrieve our OpenGL font
  603.     const BitmapFontRec* font_ptr = s_GetFont(m_Font);
  605.     switch (metric) {
  606.     case eMetric_CharHeight:
  607.         //
  608.         // return the height of a capital letter
  609.         //
  610.         {{
  611.             // we first scan the capital letters
  612.             // this gives us the height of the text without descents but with
  613.             // ascents
  614.             static const char* sc_caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  615.             GLsizei max_ht = 0;
  617.             for (const char* p = sc_caps;  p  &&  *p;  ++p) {
  618.                 const BitmapCharRec *ch = font_ptr->ch[*p - font_ptr->first];
  619.                 if ( !ch ) {
  620.                     continue;
  621.                 }
  622.                 GLsizei ht = GLsizei(ch->height - ch->yorig);
  623.                 max_ht     = max(max_ht, ht);
  624.             }
  625.             return (float)max_ht;
  626.         }}
  628.     case eMetric_FullCharHeight:
  629.         //
  630.         // return the maximal height of all available characters
  631.         //
  632.         {{
  633.             // we first scan the capital letters
  634.             // this gives us the height of the text without descents but with
  635.             // ascents
  636.             GLsizei max_ht = 0;
  637.             for (int i = font_ptr->first;  i < font_ptr->num_chars;  ++i) {
  638.                 const BitmapCharRec *ch = font_ptr->ch[i];
  639.                 if ( !ch ) {
  640.                     continue;
  641.                 }
  642.                 GLsizei ht = GLsizei(ch->height - ch->yorig);
  643.                 max_ht     = max(max_ht, ht);
  644.             }
  645.             return (float)max_ht;
  646.         }}
  648.     case eMetric_AvgCharWidth:
  649.         //
  650.         // return the maximal height of all available characters
  651.         //
  652.         {{
  653.             // we first scan the capital letters
  654.             // this gives us the height of the text without descents but with
  655.             // ascents
  656.             GLfloat wid   = 0;
  657.             GLsizei count = 0;
  658.             for (int i = font_ptr->first;  i < font_ptr->num_chars;  ++i) {
  659.                 const BitmapCharRec *ch = font_ptr->ch[i];
  660.                 if ( !ch ) {
  661.                     continue;
  662.                 }
  663.                 wid += ch->advance;
  664.                 ++count;
  665.             }
  666.             return wid / float(count);
  667.         }}
  669.     case eMetric_MaxCharWidth:
  670.         //
  671.         // return the maximal height of all available characters
  672.         //
  673.         {{
  674.             // we first scan the capital letters
  675.             // this gives us the height of the text without descents but with
  676.             // ascents
  677.             GLfloat wid   = 0;
  678.             GLsizei count = 0;
  679.             for (int i = font_ptr->first;  i < font_ptr->num_chars;  ++i) {
  680.                 const BitmapCharRec *ch = font_ptr->ch[i];
  681.                 if ( !ch ) {
  682.                     continue;
  683.                 }
  684.                 wid = max(ch->advance, wid);
  685.                 ++count;
  686.             }
  687.             return wid;
  688.         }}
  690.     case eMetric_TextWidth:
  691.     case eMetric_FullTextWidth:
  692.         //
  693.         // return the width of the text with or without the final advance
  694.         //
  695.         if (text) {
  696.             float sum = 0.0f;
  698.             // iterate over our text
  699.             const char* p = text;
  700.             for ( ;  text_len  &&  p  &&  *p;  ++p, --text_len) {
  701.                 sum += s_GetCharAdvance(*p, font_ptr);
  702.             }
  704.             // adjust for the trailing character
  705.             if (p  &&  metric == eMetric_TextWidth) {
  706.                 --p;
  707.                 sum -= s_GetCharAdvance(*p, font_ptr);
  708.                 sum += s_GetCharWidth(*p, font_ptr);
  709.             }
  711.             return sum;
  712.         }
  713.         break;
  715.     default:
  716.         break;
  717.     }
  719.     return 0.0f;
  720. }
  722. string CGlBitmapFont::Truncate(const char* text, float w, ETruncate trunc) const
  723. {
  724.     string res;
  725.     x_Truncate(text, w, trunc, &res);
  726.     return res;
  727. }
  729. string CGlBitmapFont::Truncate(const string& str, float w, ETruncate trunc) const
  730. {
  731.     string res;
  732.     x_Truncate(str.c_str(), w, trunc, &res);
  733.     return res;
  734. }
  736. // Truncate a string for display.  This version will return the maximum
  737. // number of characters that can fit into the given width
  738. int CGlBitmapFont::x_Truncate(const char* text, float w, ETruncate trunc,
  739.                               string* str) const
  740. {
  741.     // first, retrieve our OpenGL font
  742.     const BitmapFontRec* font_ptr = s_GetFont(m_Font);
  743.     static const char* sc_ellipsis = "...";
  744.     const char* ellip = NULL;
  746.     const char* end_pos = text;
  747.     switch (trunc) {
  748.     case eTruncate_None:
  749.         end_pos = text + strlen(text);
  750.         break;
  752.     case eTruncate_Ellipsis:
  753.         {{
  754.             // first, do a blunt cut
  755.             int pos = x_Truncate(text, w, eTruncate_Empty);
  756.             end_pos = text + pos;
  757.             if ( !*end_pos ) {
  758.                 // we can fit the whole thing
  759.                 break;
  760.             }
  762.             // adjust for the ellipsis
  763.             float e_wid = TextWidth(sc_ellipsis);
  764.             while (e_wid > 0) {
  765.                 ellip = sc_ellipsis;
  766.                 e_wid -= s_GetCharWidth(*end_pos, font_ptr);
  767.                 if (end_pos > text) {
  768.                     --end_pos;
  769.                 } else {
  770.                     break;
  771.                 }
  772.             }
  773.         }}
  774.         break;
  776.     case eTruncate_Empty:
  777.         for ( ;  end_pos  &&  *end_pos  && w >= 0;  ++end_pos) {
  778.             float wid = s_GetCharAdvance(*end_pos, font_ptr);
  779.             if (w - wid < 0) {
  780.                 wid = s_GetCharWidth(*end_pos, font_ptr);
  781.             }
  783.             w -= wid;
  784.         }
  786.         if (w < 0) {
  787.             --end_pos;
  788.         }
  789.         break;
  790.     }
  792.     if (end_pos < text) {
  793.         end_pos = text;
  794.     }
  796.     if (str) {
  797.         str->assign(text, end_pos);
  798.         if (ellip) {
  799.             *str += ellip;
  800.         }
  801.     }
  802.     return end_pos - text;
  803. }
  805. static const  char* kPostfixes[] = { "", " K", " M", " G" };
  807. string CTextUtils::FormatSeparatedNumber(int Number, bool b_postfix)
  808. {
  809.     bool bNegative = Number < 0;
  810.     Number = abs(Number);
  812.     string s_number, s_postfix;
  813.     char cSep = ',';
  815.     int i_postfix = 0;
  816.     if(Number != 0  &&  b_postfix)    {
  817.         int Rest = Number % 1000;        
  818.         for( i_postfix = 0; Rest == 0; i_postfix++)  {
  819.             Number = Number / 1000;        
  820.             Rest = Number % 1000;            
  821.         }
  822.         _ASSERT(i_postfix < 4);
  823.         s_postfix = kPostfixes[i_postfix];
  824.     }    
  826.     char sTemplGroup[] = " %.3d";
  827.     sTemplGroup[0] = cSep;
  828.     char sTemplLast[] = "%d";  
  830.     char S[20];    
  831.     do    {
  832.         int Rest = Number % 1000;
  833.         Number = Number / 1000;
  834.         sprintf(S, Number ? sTemplGroup : sTemplLast, Rest);            
  835.         s_number = string(S) + s_number;    
  836.     } while(Number);
  837.     s_number += s_postfix;
  839.     if(bNegative) {
  840.         s_number = "-" + s_number;
  841.     }
  842.     return s_number;
  843. }
  845. int CTextUtils::GetCharsCount(int Number)
  846. {
  847.     int MaxDigits = (int) ceil( log10((double) Number)); // decimal digist in number
  848.     int nSep = (MaxDigits - 1) / 3; // number of separators between groups
  849.     return MaxDigits + nSep;
  850. }
  853. END_NCBI_SCOPE
  857. /*
  858.  * ===========================================================================
  859.  * $Log: glbitmapfont.cpp,v $
  860.  * Revision 1000.3  2004/06/01 20:50:25  gouriano
  861.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.20
  862.  *
  863.  * Revision 1.20  2004/05/21 22:27:44  gorelenk
  864.  * Added PCH ncbi_pch.hpp
  865.  *
  866.  * Revision 1.19  2004/05/21 12:44:12  dicuccio
  867.  * Clean-up of font handling.  Extended available font faces; added new font faces
  868.  * (clean, fixed)
  869.  *
  870.  * Revision 1.18  2004/05/03 13:03:15  dicuccio
  871.  * Fixed compiler warnings on MSVC7
  872.  *
  873.  * Revision 1.17  2004/03/12 15:29:19  dicuccio
  874.  * Use CStaticArrayMap<> to manage font lookups
  875.  *
  876.  * Revision 1.16  2004/03/11 17:37:21  dicuccio
  877.  * Split font face and font size from font specification
  878.  *
  879.  * Revision 1.15  2004/03/03 15:06:21  yazhuk
  880.  * Changed labels alignment algorithm
  881.  *
  882.  * Revision 1.14  2003/12/10 21:32:07  ucko
  883.  * +<stdio.h> for sprintf()
  884.  *
  885.  * Revision 1.13  2003/11/18 17:45:47  dicuccio
  886.  * Formatting changes
  887.  *
  888.  * Revision 1.12  2003/11/17 21:03:39  yazhuk
  889.  * Refactored Truncate() and TextOut() functions, added ArrayTextOut(),
  890.  * renamed GetDigitsCount() to GetCharsCount()
  891.  *
  892.  * Revision 1.11  2003/10/29 22:27:06  yazhuk
  893.  * Added CTextUtils class
  894.  *
  895.  * Revision 1.10  2003/10/09 17:58:39  lebedev
  896.  * Trancate method made public
  897.  *
  898.  * Revision 1.9  2003/10/07 19:38:53  dicuccio
  899.  * Temporarily disable display list inside of font - restores letters after window hide
  900.  *
  901.  * Revision 1.8  2003/09/29 15:34:45  dicuccio
  902.  * Reworked TextHeight() and TextWidth() as forwarding functions.  Expanded
  903.  * GetMetric() to handle all cases
  904.  *
  905.  * Revision 1.7  2003/09/25 17:48:19  dicuccio
  906.  * Added API for checking font metrics (only height is supported)
  907.  *
  908.  * Revision 1.6  2003/09/24 15:59:39  rsmith
  909.  * in CGlBitmapFont::SetFont use GLsizei consistently to prevent max template from complaining about being passed arguments with different types.
  910.  *
  911.  * Revision 1.5  2003/09/17 16:25:12  dicuccio
  912.  * Added new functions to handle automatic alignment, trimming of text.  Optimized
  913.  * and correctly implemented TextHeight()
  914.  *
  915.  * Revision 1.4  2003/08/28 19:27:54  dicuccio
  916.  * TextOut() functions are now const
  917.  *
  918.  * Revision 1.3  2003/08/22 15:47:12  dicuccio
  919.  * Added display lists to CGlBitmapFont
  920.  *
  921.  * Revision 1.2  2003/08/19 10:32:29  dicuccio
  922.  * Fix compilation error - max<T>() needs to be passed two valuesof the same type
  923.  *
  924.  * Revision 1.1  2003/08/18 19:24:12  dicuccio
  925.  * Initial revision of new bitmap fonts
  926.  *
  927.  * ===========================================================================
  928.  */