simgear/canvas/elements/CanvasText.cxx

   1 // A text on the Canvas
   2 //
   3 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Library General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Library General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Library General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  18
  19 #include "CanvasText.hxx"
  20 #include <simgear/canvas/Canvas.hxx>
  21 #include <simgear/canvas/CanvasSystemAdapter.hxx>
  22 #include <simgear/scene/util/parse_color.hxx>
  23 #include <osg/Version>
  24 #include <osgText/Text>
  25
  26 namespace simgear
  27 {
  28 namespace canvas
  29 {
  30   class Text::TextOSG:
  31     public osgText::Text
  32   {
  33     public:
  34
  35       TextOSG(canvas::Text* text);
  36
  37       void setFontResolution(int res);
  38       void setCharacterAspect(float aspect);
  39       void setLineHeight(float factor);
  40       void setFill(const std::string& fill);
  41       void setBackgroundColor(const std::string& fill);
  42
  43       osg::Vec2 handleHit(const osg::Vec2f& pos);
  44
  45       virtual osg::BoundingBox computeBound() const;
  46
  47     protected:
  48
  49       canvas::Text *_text_element;
  50
  51       virtual void computePositions(unsigned int contextID) const;
  52   };
  53
  54   //----------------------------------------------------------------------------
  55   Text::TextOSG::TextOSG(canvas::Text* text):
  56     _text_element(text)
  57   {
  58     setBackdropImplementation(NO_DEPTH_BUFFER);
  59   }
  60
  61   //----------------------------------------------------------------------------
  62   void Text::TextOSG::setFontResolution(int res)
  63   {
  64     TextBase::setFontResolution(res, res);
  65   }
  66
  67   //----------------------------------------------------------------------------
  68   void Text::TextOSG::setCharacterAspect(float aspect)
  69   {
  70     setCharacterSize(getCharacterHeight(), aspect);
  71   }
  72
  73   //----------------------------------------------------------------------------
  74   void Text::TextOSG::setLineHeight(float factor)
  75   {
  76     setLineSpacing(factor - 1);
  77   }
  78
  79   //----------------------------------------------------------------------------
  80   void Text::TextOSG::setFill(const std::string& fill)
  81   {
  82 //    if( fill == "none" )
  83 //      TODO No text
  84 //    else
  85     osg::Vec4 color;
  86     if( parseColor(fill, color) )
  87       setColor( color );
  88   }
  89
  90   //----------------------------------------------------------------------------
  91   void Text::TextOSG::setBackgroundColor(const std::string& fill)
  92   {
  93     osg::Vec4 color;
  94     if( parseColor(fill, color) )
  95       setBoundingBoxColor( color );
  96   }
  97
  98   //----------------------------------------------------------------------------
  99   osg::Vec2 Text::TextOSG::handleHit(const osg::Vec2f& pos)
 100   {
 101     float line_height = _characterHeight + _lineSpacing;
 102
 103     // TODO check with align other than TOP
 104     float first_line_y = -0.5 * _lineSpacing;//_offset.y() - _characterHeight;
 105     size_t line = std::max<int>(0, (pos.y() - first_line_y) / line_height);
 106
 107     if( _textureGlyphQuadMap.empty() )
 108       return osg::Vec2(-1, -1);
 109
 110     // TODO check when it can be larger
 111     assert( _textureGlyphQuadMap.size() == 1 );
 112
 113     const GlyphQuads& glyphquad = _textureGlyphQuadMap.begin()->second;
 114     const GlyphQuads::Glyphs& glyphs = glyphquad._glyphs;
 115     const GlyphQuads::Coords2& coords = glyphquad._coords;
 116     const GlyphQuads::LineNumbers& line_numbers = glyphquad._lineNumbers;
 117
 118     const float HIT_FRACTION = 0.6;
 119     const float character_width = getCharacterHeight()
 120                                 * getCharacterAspectRatio();
 121
 122     float y = (line + 0.5) * line_height;
 123
 124     bool line_found = false;
 125     for(size_t i = 0; i < line_numbers.size(); ++i)
 126     {
 127       if( line_numbers[i] != line )
 128       {
 129         if( !line_found )
 130         {
 131           if( line_numbers[i] < line )
 132             // Wait for the correct line...
 133             continue;
 134
 135           // We have already passed the correct line -> It's empty...
 136           return osg::Vec2(0, y);
 137         }
 138
 139         // Next line and not returned -> not before any character
 140         // -> return position after last character of line
 141         return osg::Vec2(coords[(i - 1) * 4 + 2].x(), y);
 142       }
 143
 144       line_found = true;
 145
 146       // Get threshold for mouse x position for setting cursor before or after
 147       // current character
 148       float threshold = coords[i * 4].x()
 149                       + HIT_FRACTION * glyphs[i]->getHorizontalAdvance()
 150                                      * character_width;
 151
 152       if( pos.x() <= threshold )
 153       {
 154         osg::Vec2 hit(0, y);
 155         if( i == 0 || line_numbers[i - 1] != line )
 156           // first character of line
 157           hit.x() = coords[i * 4].x();
 158         else if( coords[(i - 1) * 4].x() == coords[(i - 1) * 4 + 2].x() )
 159           // If previous character width is zero set to begin of next character
 160           // (Happens eg. with spaces)
 161           hit.x() = coords[i * 4].x();
 162         else
 163           // position at center between characters
 164           hit.x() = 0.5 * (coords[(i - 1) * 4 + 2].x() + coords[i * 4].x());
 165
 166         return hit;
 167       }
 168     }
 169
 170     // Nothing found -> return position after last character
 171     return osg::Vec2
 172     (
 173       coords.back().x(),
 174       (_lineCount - 0.5) * line_height
 175     );
 176   }
 177
 178   //----------------------------------------------------------------------------
 179   osg::BoundingBox Text::TextOSG::computeBound() const
 180   {
 181     osg::BoundingBox bb = osgText::Text::computeBound();
 182
 183 #if OSG_VERSION_LESS_THAN(3,1,0)
 184     if( bb.valid() )
 185     {
 186       // TODO bounding box still doesn't seem always right (eg. with center
 187       //      horizontal alignment not completely accurate)
 188       bb._min.y() += _offset.y();
 189       bb._max.y() += _offset.y();
 190     }
 191 #endif
 192
 193     return bb;
 194   }
 195
 196   //----------------------------------------------------------------------------
 197   void Text::TextOSG::computePositions(unsigned int contextID) const
 198   {
 199     if( _textureGlyphQuadMap.empty() || _layout == VERTICAL )
 200       return osgText::Text::computePositions(contextID);
 201
 202     // TODO check when it can be larger
 203     assert( _textureGlyphQuadMap.size() == 1 );
 204
 205     const GlyphQuads& quads = _textureGlyphQuadMap.begin()->second;
 206     const GlyphQuads::Glyphs& glyphs = quads._glyphs;
 207     const GlyphQuads::Coords2& coords = quads._coords;
 208     const GlyphQuads::LineNumbers& line_numbers = quads._lineNumbers;
 209
 210     float wr = _characterHeight / getCharacterAspectRatio();
 211
 212     size_t cur_line = static_cast<size_t>(-1);
 213     for(size_t i = 0; i < glyphs.size(); ++i)
 214     {
 215       // Check horizontal offsets
 216
 217       bool first_char = cur_line != line_numbers[i];
 218       cur_line = line_numbers[i];
 219
 220       bool last_char = (i + 1 == glyphs.size())
 221                     || (cur_line != line_numbers[i + 1]);
 222
 223       if( first_char || last_char )
 224       {
 225         // From osg/src/osgText/Text.cpp:
 226         //
 227         // osg::Vec2 upLeft = local+osg::Vec2(0.0f-fHorizQuadMargin, ...);
 228         // osg::Vec2 lowLeft = local+osg::Vec2(0.0f-fHorizQuadMargin, ...);
 229         // osg::Vec2 lowRight = local+osg::Vec2(width+fHorizQuadMargin, ...);
 230         // osg::Vec2 upRight = local+osg::Vec2(width+fHorizQuadMargin, ...);
 231
 232         float left = coords[i * 4].x(),
 233               right = coords[i * 4 + 2].x(),
 234               width = glyphs[i]->getWidth() * wr;
 235
 236         // (local + width + fHoriz) - (local - fHoriz) = width + 2*fHoriz | -width
 237         float margin = 0.5f * (right - left - width),
 238               cursor_x = left + margin
 239                        - glyphs[i]->getHorizontalBearing().x() * wr;
 240
 241         if( first_char )
 242         {
 243           if( cur_line == 0 || cursor_x < _textBB._min.x() )
 244             _textBB._min.x() = cursor_x;
 245         }
 246
 247         if( last_char )
 248         {
 249           float cursor_w = cursor_x + glyphs[i]->getHorizontalAdvance() * wr;
 250
 251           if( cur_line == 0 || cursor_w > _textBB._max.x() )
 252             _textBB._max.x() = cursor_w;
 253         }
 254       }
 255     }
 256
 257     return osgText::Text::computePositions(contextID);
 258   }
 259
 260   //----------------------------------------------------------------------------
 261   const std::string Text::TYPE_NAME = "text";
 262
 263   //----------------------------------------------------------------------------
 264   void Text::staticInit()
 265   {
 266     if( isInit<Text>() )
 267       return;
 268
 269     osg::ref_ptr<TextOSG> Text::*text = &Text::_text;
 270
 271     addStyle("fill", "color", &TextOSG::setFill, text);
 272     addStyle("background", "color", &TextOSG::setBackgroundColor, text);
 273     addStyle("character-size",
 274              "numeric",
 275              static_cast<
 276                void (TextOSG::*)(float)
 277              > (&TextOSG::setCharacterSize),
 278              text);
 279     addStyle("character-aspect-ratio",
 280              "numeric",
 281              &TextOSG::setCharacterAspect, text);
 282     addStyle("line-height", "numeric", &TextOSG::setLineHeight, text);
 283     addStyle("font-resolution", "numeric", &TextOSG::setFontResolution, text);
 284     addStyle("padding", "numeric", &TextOSG::setBoundingBoxMargin, text);
 285     //  TEXT              = 1 default
 286     //  BOUNDINGBOX       = 2
 287     //  FILLEDBOUNDINGBOX = 4
 288     //  ALIGNMENT         = 8
 289     addStyle<int>("draw-mode", "", &TextOSG::setDrawMode, text);
 290     addStyle("max-width", "numeric", &TextOSG::setMaximumWidth, text);
 291     addStyle("font", "", &Text::setFont);
 292     addStyle("alignment", "", &Text::setAlignment);
 293     addStyle("text", "", &Text::setText, false);
 294   }
 295
 296   //----------------------------------------------------------------------------
 297   Text::Text( const CanvasWeakPtr& canvas,
 298               const SGPropertyNode_ptr& node,
 299               const Style& parent_style,
 300               Element* parent ):
 301     Element(canvas, node, parent_style, parent),
 302     _text( new Text::TextOSG(this) )
 303   {
 304     staticInit();
 305
 306     setDrawable(_text);
 307     _text->setCharacterSizeMode(osgText::Text::OBJECT_COORDS);
 308     _text->setAxisAlignment(osgText::Text::USER_DEFINED_ROTATION);
 309     _text->setRotation(osg::Quat(osg::PI, osg::X_AXIS));
 310
 311     setupStyle();
 312   }
 313
 314   //----------------------------------------------------------------------------
 315   Text::~Text()
 316   {
 317
 318   }
 319
 320   //----------------------------------------------------------------------------
 321   void Text::setText(const char* text)
 322   {
 323     _text->setText(text, osgText::String::ENCODING_UTF8);
 324   }
 325
 326   //----------------------------------------------------------------------------
 327   void Text::setFont(const char* name)
 328   {
 329     _text->setFont( Canvas::getSystemAdapter()->getFont(name) );
 330   }
 331
 332   //----------------------------------------------------------------------------
 333   void Text::setAlignment(const char* align)
 334   {
 335     const std::string align_string(align);
 336     if( 0 ) return;
 337 #define ENUM_MAPPING(enum_val, string_val) \
 338     else if( align_string == string_val )\
 339       _text->setAlignment( osgText::Text::enum_val );
 340 #include "text-alignment.hxx"
 341 #undef ENUM_MAPPING
 342     else
 343     {
 344       if( !align_string.empty() )
 345         SG_LOG
 346         (
 347           SG_GENERAL,
 348           SG_WARN,
 349           "canvas::Text: unknown alignment '" << align_string << "'"
 350         );
 351       _text->setAlignment(osgText::Text::LEFT_BASE_LINE);
 352     }
 353   }
 354
 355   //----------------------------------------------------------------------------
 356 #if 0
 357   const char* Text::getAlignment() const
 358   {
 359     switch( _text->getAlignment() )
 360     {
 361 #define ENUM_MAPPING(enum_val, string_val) \
 362       case osgText::Text::enum_val:\
 363         return string_val;
 364 #include "text-alignment.hxx"
 365 #undef ENUM_MAPPING
 366       default:
 367         return "unknown";
 368     }
 369   }
 370 #endif
 371
 372   //----------------------------------------------------------------------------
 373   osg::Vec2 Text::getNearestCursor(const osg::Vec2& pos) const
 374   {
 375     return _text->handleHit(pos);
 376   }
 377
 378 } // namespace canvas
 379 } // namespace simgear