KiCad PCB EDA Suite
stroke_font.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KICAD, a free EDA CAD application.
3  *
4  * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
5  * Copyright (C) 2013 CERN
6  * @author Maciej Suminski <maciej.suminski@cern.ch>
7  * Copyright (C) 2016 Kicad Developers, see change_log.txt for contributors.
8  *
9  * Stroke font class
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, you may find one here:
23  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
24  * or you may search the http://www.gnu.org website for the version 2 license,
25  * or you may write to the Free Software Foundation, Inc.,
26  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
27  */
28 
29 #include <gal/stroke_font.h>
31 #include <math/util.h> // for KiROUND
32 #include <wx/string.h>
33 #include <gr_text.h>
34 
35 
36 using namespace KIGFX;
37 
38 const double STROKE_FONT::INTERLINE_PITCH_RATIO = 1.61;
39 const double STROKE_FONT::OVERBAR_POSITION_FACTOR = 1.22;
40 const double STROKE_FONT::BOLD_FACTOR = 1.3;
41 const double STROKE_FONT::STROKE_FONT_SCALE = 1.0 / 21.0;
42 const double STROKE_FONT::ITALIC_TILT = 1.0 / 8;
43 
44 
46 std::vector<BOX2D>* g_newStrokeFontGlyphBoundingBoxes;
47 
48 
50  m_gal( aGal ), m_glyphs( nullptr ), m_glyphBoundingBoxes( nullptr )
51 {
52 }
53 
54 
55 bool STROKE_FONT::LoadNewStrokeFont( const char* const aNewStrokeFont[], int aNewStrokeFontSize )
56 {
58  {
61  return true;
62  }
63 
65  g_newStrokeFontGlyphs->reserve( aNewStrokeFontSize );
66 
67  g_newStrokeFontGlyphBoundingBoxes = new std::vector<BOX2D>;
68  g_newStrokeFontGlyphBoundingBoxes->reserve( aNewStrokeFontSize );
69 
70  for( int j = 0; j < aNewStrokeFontSize; j++ )
71  {
72  GLYPH glyph;
73  double glyphStartX = 0.0;
74  double glyphEndX = 0.0;
75  double glyphWidth = 0.0;
76 
77  std::vector<VECTOR2D>* pointList = nullptr;
78 
79  int strokes = 0;
80  int i = 0;
81 
82  while( aNewStrokeFont[j][i] )
83  {
84 
85  if( aNewStrokeFont[j][i] == ' ' && aNewStrokeFont[j][i+1] == 'R' )
86  strokes++;
87 
88  i += 2;
89  }
90 
91  glyph.reserve( strokes + 1 );
92 
93  i = 0;
94 
95  while( aNewStrokeFont[j][i] )
96  {
97  VECTOR2D point( 0.0, 0.0 );
98  char coordinate[2] = { 0, };
99 
100  for( int k : { 0, 1 } )
101  coordinate[k] = aNewStrokeFont[j][i + k];
102 
103  if( i < 2 )
104  {
105  // The first two values contain the width of the char
106  glyphStartX = ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE;
107  glyphEndX = ( coordinate[1] - 'R' ) * STROKE_FONT_SCALE;
108  glyphWidth = glyphEndX - glyphStartX;
109  }
110  else if( ( coordinate[0] == ' ' ) && ( coordinate[1] == 'R' ) )
111  {
112  if( pointList )
113  pointList->shrink_to_fit();
114 
115  // Raise pen
116  pointList = nullptr;
117  }
118  else
119  {
120  // In stroke font, coordinates values are coded as <value> + 'R',
121  // <value> is an ASCII char.
122  // therefore every coordinate description of the Hershey format has an offset,
123  // it has to be subtracted
124  // Note:
125  // * the stroke coordinates are stored in reduced form (-1.0 to +1.0),
126  // and the actual size is stroke coordinate * glyph size
127  // * a few shapes have a height slightly bigger than 1.0 ( like '{' '[' )
128  point.x = (double) ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE - glyphStartX;
129  #define FONT_OFFSET -10
130  // FONT_OFFSET is here for historical reasons, due to the way the stroke font
131  // was built. It allows shapes coordinates like W M ... to be >= 0
132  // Only shapes like j y have coordinates < 0
133  point.y = (double) ( coordinate[1] - 'R' + FONT_OFFSET ) * STROKE_FONT_SCALE;
134 
135  if( !pointList )
136  {
137  glyph.emplace_back();
138  pointList = &glyph.back();
139  }
140 
141  pointList->push_back( point );
142  }
143 
144  i += 2;
145  }
146 
147  if( pointList )
148  pointList->shrink_to_fit();
149 
150  // Compute the bounding box of the glyph
151  g_newStrokeFontGlyphBoundingBoxes->emplace_back( computeBoundingBox( glyph, glyphWidth ) );
152  g_newStrokeFontGlyphs->push_back( glyph );
153  }
154 
157  return true;
158 }
159 
160 
161 // Static function:
162 double STROKE_FONT::GetInterline( double aGlyphHeight )
163 {
164  // Do not add the glyph thickness to the interline. This makes bold text line-spacing
165  // different from normal text, which is poor typography.
166  return ( aGlyphHeight * INTERLINE_PITCH_RATIO );
167 }
168 
169 
170 BOX2D STROKE_FONT::computeBoundingBox( const GLYPH& aGLYPH, double aGlyphWidth ) const
171 {
172  VECTOR2D min( 0, 0 );
173  VECTOR2D max( aGlyphWidth, 0 );
174 
175  for( const std::vector<VECTOR2D>& pointList : aGLYPH )
176  {
177  for( const VECTOR2D& point : pointList )
178  {
179  min.y = std::min( min.y, point.y );
180  max.y = std::max( max.y, point.y );
181  }
182  }
183 
184  return BOX2D( min, max - min );
185 }
186 
187 
188 void STROKE_FONT::Draw( const UTF8& aText, const VECTOR2D& aPosition, double aRotationAngle,
189  int markupFlags )
190 {
191  if( aText.empty() )
192  return;
193 
194  // Context needs to be saved before any transformations
195  m_gal->Save();
196 
197  m_gal->Translate( aPosition );
198  m_gal->Rotate( -aRotationAngle );
199 
200  // Single line height
201  int lineHeight = KiROUND( GetInterline( m_gal->GetGlyphSize().y ) );
202  int lineCount = linesCount( aText );
203  const VECTOR2D& glyphSize = m_gal->GetGlyphSize();
204 
205  // align the 1st line of text
206  switch( m_gal->GetVerticalJustify() )
207  {
209  m_gal->Translate( VECTOR2D( 0, glyphSize.y ) );
210  break;
211 
213  m_gal->Translate( VECTOR2D( 0, glyphSize.y / 2.0 ) );
214  break;
215 
217  break;
218 
219  default:
220  break;
221  }
222 
223  if( lineCount > 1 )
224  {
225  switch( m_gal->GetVerticalJustify() )
226  {
228  break;
229 
231  m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight / 2) );
232  break;
233 
235  m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight ) );
236  break;
237  }
238  }
239 
240  m_gal->SetIsStroke( true );
241  //m_gal->SetIsFill( false );
242 
243  if( m_gal->IsFontBold() )
245 
246  // Split multiline strings into separate ones and draw them line by line
247  size_t begin = 0;
248  size_t newlinePos = aText.find( '\n' );
249 
250  while( newlinePos != aText.npos )
251  {
252  size_t length = newlinePos - begin;
253 
254  drawSingleLineText( aText.substr( begin, length ), markupFlags );
255  m_gal->Translate( VECTOR2D( 0.0, lineHeight ) );
256 
257  begin = newlinePos + 1;
258  newlinePos = aText.find( '\n', begin );
259  }
260 
261  // Draw the last (or the only one) line
262  if( !aText.empty() )
263  drawSingleLineText( aText.substr( begin ), markupFlags );
264 
265  m_gal->Restore();
266 }
267 
268 
269 void STROKE_FONT::drawSingleLineText( const UTF8& aText, int markupFlags )
270 {
271  double xOffset;
272  double yOffset;
273  VECTOR2D baseGlyphSize( m_gal->GetGlyphSize() );
274  double overbar_italic_comp = computeOverbarVerticalPosition() * ITALIC_TILT;
275 
276  if( m_gal->IsTextMirrored() )
277  overbar_italic_comp = -overbar_italic_comp;
278 
279  // Compute the text size
280  VECTOR2D textSize = computeTextLineSize( aText, markupFlags );
281  double half_thickness = m_gal->GetLineWidth()/2;
282 
283  // Context needs to be saved before any transformations
284  m_gal->Save();
285 
286  // First adjust: the text X position is corrected by half_thickness
287  // because when the text with thickness is draw, its full size is textSize,
288  // but the position of lines is half_thickness to textSize - half_thickness
289  // so we must translate the coordinates by half_thickness on the X axis
290  // to place the text inside the 0 to textSize X area.
291  m_gal->Translate( VECTOR2D( half_thickness, 0 ) );
292 
293  // Adjust the text position to the given horizontal justification
294  switch( m_gal->GetHorizontalJustify() )
295  {
297  m_gal->Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
298  break;
299 
301  if( !m_gal->IsTextMirrored() )
302  m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
303  break;
304 
306  if( m_gal->IsTextMirrored() )
307  m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
308  break;
309 
310  default:
311  break;
312  }
313 
314  if( m_gal->IsTextMirrored() )
315  {
316  // In case of mirrored text invert the X scale of points and their X direction
317  // (m_glyphSize.x) and start drawing from the position where text normally should end
318  // (textSize.x)
319  xOffset = textSize.x - m_gal->GetLineWidth();
320  baseGlyphSize.x = -baseGlyphSize.x;
321  }
322  else
323  {
324  xOffset = 0.0;
325  }
326 
327  // The overbar is indented inward at the beginning of an italicized section, but
328  // must not be indented on subsequent letters to ensure that the bar segments
329  // overlap.
330  bool last_had_overbar = false;
331  bool in_overbar = false;
332  VECTOR2D glyphSize = baseGlyphSize;
333 
334  yOffset = 0;
335 
336  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
337  {
338  // Handle tabs as locked to the nearest 4th column (counting in spaces)
339  // The choice of spaces is somewhat arbitrary but sufficient for aligning text
340  if( *chIt == '\t' )
341  {
342  double space = glyphSize.x * m_glyphBoundingBoxes->at( 0 ).GetEnd().x;
343 
344  // We align to the 4th column (fmod) but only need to account for 3 of
345  // the four spaces here with the extra. This ensures that we have at
346  // least 1 space for the \t character
347  double addlSpace = 3.0 * space - std::fmod( xOffset, 4.0 * space );
348 
349  // Add the remaining space (between 0 and 3 spaces)
350  // The fourth space is added by the 'dd' character
351  xOffset += addlSpace;
352 
353  glyphSize = baseGlyphSize;
354  yOffset = 0;
355  }
356  else if( *chIt == '~' )
357  {
358  if( ++chIt == end )
359  break;
360 
361  if( *chIt == '~' )
362  {
363  // double ~ is really a ~ so go ahead and process the second one
364 
365  // so what's a triple ~? It could be a real ~ followed by an overbar, or
366  // it could be an overbar followed by a real ~. The old algorithm did the
367  // later so we will too....
368  auto tempIt = chIt;
369 
370  if( ++tempIt < end && *tempIt == '~' )
371  {
372  // eat the first two, toggle overbar, and then process the third
373  ++chIt;
374  in_overbar = !in_overbar;
375  }
376  }
377  else
378  {
379  in_overbar = !in_overbar;
380  }
381  }
382  else if( *chIt == '^' && ( markupFlags & ENABLE_SUPERSCRIPT_MARKUP ) )
383  {
384  if( ++chIt == end )
385  break;
386 
387  if( *chIt == '^' )
388  {
389  // double ^ is really a ^ so go ahead and process the second one
390  }
391  else
392  {
393  // single ^ starts a superscript
394  glyphSize = baseGlyphSize * 0.8;
395  yOffset = -baseGlyphSize.y * 0.3;
396  }
397  }
398  else if( *chIt == '#' && ( markupFlags & ENABLE_SUBSCRIPT_MARKUP ) )
399  {
400  if( ++chIt == end )
401  break;
402 
403  if( *chIt == '#' )
404  {
405  // double # is really a # so go ahead and process the second one
406  }
407  else
408  {
409  // single _ starts a subscript
410  glyphSize = baseGlyphSize * 0.8;
411  yOffset = baseGlyphSize.y * 0.1;
412  }
413  }
414  else if( *chIt == ' ' )
415  {
416  // space ends a super- or subscript
417  glyphSize = baseGlyphSize;
418  yOffset = 0;
419  }
420 
421  // Index into bounding boxes table
422  int dd = (signed) *chIt - ' ';
423 
424  if( dd >= (int) m_glyphBoundingBoxes->size() || dd < 0 )
425  {
426  int substitute = *chIt == '\t' ? ' ' : '?';
427  dd = substitute - ' ';
428  }
429 
430  const GLYPH& glyph = m_glyphs->at( dd );
431  const BOX2D& bbox = m_glyphBoundingBoxes->at( dd );
432 
433  if( in_overbar )
434  {
435  double overbar_start_x = xOffset;
436  double overbar_start_y = - computeOverbarVerticalPosition();
437  double overbar_end_x = xOffset + glyphSize.x * bbox.GetEnd().x;
438  double overbar_end_y = overbar_start_y;
439 
440  if( !last_had_overbar )
441  {
442  if( m_gal->IsFontItalic() )
443  overbar_start_x += overbar_italic_comp;
444 
445  last_had_overbar = true;
446  }
447 
448  VECTOR2D startOverbar( overbar_start_x, overbar_start_y );
449  VECTOR2D endOverbar( overbar_end_x, overbar_end_y );
450 
451  m_gal->DrawLine( startOverbar, endOverbar );
452  }
453  else
454  {
455  last_had_overbar = false;
456  }
457 
458  for( const std::vector<VECTOR2D>& ptList : glyph )
459  {
460  std::deque<VECTOR2D> ptListScaled;
461 
462  for( const VECTOR2D& pt : ptList )
463  {
464  VECTOR2D scaledPt( pt.x * glyphSize.x + xOffset, pt.y * glyphSize.y + yOffset );
465 
466  if( m_gal->IsFontItalic() )
467  {
468  // FIXME should be done other way - referring to the lowest Y value of point
469  // because now italic fonts are translated a bit
470  if( m_gal->IsTextMirrored() )
471  scaledPt.x += scaledPt.y * STROKE_FONT::ITALIC_TILT;
472  else
473  scaledPt.x -= scaledPt.y * STROKE_FONT::ITALIC_TILT;
474  }
475 
476  ptListScaled.push_back( scaledPt );
477  }
478 
479  m_gal->DrawPolyline( ptListScaled );
480  }
481 
482  xOffset += glyphSize.x * bbox.GetEnd().x;
483  }
484 
485  m_gal->Restore();
486 }
487 
488 
489 double STROKE_FONT::ComputeOverbarVerticalPosition( double aGlyphHeight, double aGlyphThickness ) const
490 {
491  // Static method.
492  // Compute the Y position of the overbar. This is the distance between
493  // the text base line and the overbar axis.
494  return aGlyphHeight * OVERBAR_POSITION_FACTOR + aGlyphThickness;
495 }
496 
497 
499 {
500  // Compute the Y position of the overbar. This is the distance between
501  // the text base line and the overbar axis.
503 }
504 
505 
506 VECTOR2D STROKE_FONT::computeTextLineSize( const UTF8& aText, int aMarkupFlags ) const
507 {
509  aMarkupFlags );
510 }
511 
512 
514  double aGlyphThickness, int markupFlags ) const
515 {
516  VECTOR2D string_bbox;
517  int line_count = 1;
518  double maxX = 0.0, curX = 0.0;
519 
520  double curScale = 1.0;
521  bool in_overbar = false;
522 
523  for( UTF8::uni_iter it = aText.ubegin(), end = aText.uend(); it < end; ++it )
524  {
525  if( *it == '\n' )
526  {
527  curX = 0.0;
528  maxX = std::max( maxX, curX );
529  ++line_count;
530  continue;
531  }
532 
533  // Handle tabs as locked to the nearest 4th column (counting in spaces)
534  // The choice of spaces is somewhat arbitrary but sufficient for aligning text
535  if( *it == '\t' )
536  {
537  double spaces = m_glyphBoundingBoxes->at( 0 ).GetEnd().x;
538  double addlSpace = 3.0 * spaces - std::fmod( curX, 4.0 * spaces );
539 
540  // Add the remaining space (between 0 and 3 spaces)
541  curX += addlSpace;
542 
543  // Tab ends a super- or subscript
544  curScale = 1.0;
545  }
546  else if( *it == '~' )
547  {
548  if( ++it == end )
549  break;
550 
551  if( *it == '~' )
552  {
553  // double ~ is really a ~ so go ahead and process the second one
554 
555  // so what's a triple ~? It could be a real ~ followed by an overbar, or
556  // it could be an overbar followed by a real ~. The old algorithm did the
557  // later so we will too....
558  auto tempIt = it;
559 
560  if( ++tempIt < end && *tempIt == '~' )
561  {
562  // eat the first two, toggle overbar, and then process the third
563  ++it;
564  in_overbar = !in_overbar;
565  }
566  }
567  else
568  {
569  // single ~ toggles overbar
570  in_overbar = !in_overbar;
571  }
572  }
573  else if( *it == '^' && ( markupFlags & ENABLE_SUPERSCRIPT_MARKUP ) )
574  {
575  if( ++it == end )
576  break;
577 
578  if( *it == '^' )
579  {
580  // double ^ is really a ^ so go ahead and process the second one
581  }
582  else
583  {
584  // single ^ starts a superscript
585  curScale = 0.8;
586  }
587  }
588  else if( *it == '#' && ( markupFlags & ENABLE_SUBSCRIPT_MARKUP ) )
589  {
590  if( ++it == end )
591  break;
592 
593  if( *it == '#' )
594  {
595  // double # is really a # so go ahead and process the second one
596  }
597  else
598  {
599  // single _ starts a subscript
600  curScale = 0.8;
601  }
602  }
603  else if( *it == ' ' )
604  {
605  // space ends a super- or subscript
606  curScale = 1.0;
607  }
608 
609  // Index in the bounding boxes table
610  int dd = (signed) *it - ' ';
611 
612  if( dd >= (int) m_glyphBoundingBoxes->size() || dd < 0 )
613  {
614  int substitute = *it == '\t' ? ' ' : '?';
615  dd = substitute - ' ';
616  }
617 
618  const BOX2D& box = m_glyphBoundingBoxes->at( dd );
619  curX += box.GetEnd().x * curScale;
620  }
621 
622  string_bbox.x = std::max( maxX, curX ) * aGlyphSize.x;
623  string_bbox.x += aGlyphThickness;
624  string_bbox.y = line_count * GetInterline( aGlyphSize.y );
625 
626  // For italic correction, take in account italic tilt
627  if( m_gal->IsFontItalic() )
628  string_bbox.x += string_bbox.y * STROKE_FONT::ITALIC_TILT;
629 
630  return string_bbox;
631 }
UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to...
Definition: utf8.h:73
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
static constexpr std::string::size_type npos
Definition: utf8.h:155
float GetLineWidth() const
Get the line width.
BOX2D computeBoundingBox(const GLYPH &aGlyph, double aGlyphWidth) const
Compute the bounding box of a given glyph.
Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:131
const Vec GetEnd() const
Definition: box2.h:194
static double GetInterline(double aGlyphHeight)
Compute the distance (interline) between 2 lines of text (for multiline texts).
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
static const double BOLD_FACTOR
Factor that determines relative line width for bold text.
Definition: stroke_font.h:180
VECTOR2D computeTextLineSize(const UTF8 &aText, int aMarkupFlags) const
Compute the X and Y size of a given text.
BOX2< VECTOR2D > BOX2D
Definition: box2.h:522
std::vector< GLYPH > GLYPH_LIST
Definition: stroke_font.h:46
uni_iter uend() const
Function uend returns a uni_iter initialized to the end of "this" UTF8 byte sequence.
Definition: utf8.h:294
bool LoadNewStrokeFont(const char *const aNewStrokeFont[], int aNewStrokeFontSize)
Load the new stroke font.
Definition: stroke_font.cpp:55
static const double ITALIC_TILT
Tilt factor for italic style (the is is the scaling factor on dY relative coordinates to give a tilst...
Definition: stroke_font.h:187
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void Rotate(double aAngle)
Rotate the context.
const VECTOR2D & GetGlyphSize() const
bool IsFontBold() const
Returns true if current font has 'bold' attribute enabled.
uni_iter ubegin() const
Function ubegin returns a uni_iter initialized to the start of "this" UTF8 byte sequence.
Definition: utf8.h:285
std::string::size_type find(char c) const
Definition: utf8.h:110
double ComputeOverbarVerticalPosition(double aGlyphHeight, double aGlyphThickness) const
Compute the vertical position of an overbar, sometimes used in texts.
GAL * m_gal
Pointer to the GAL.
Definition: stroke_font.h:123
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
VECTOR2D ComputeStringBoundaryLimits(const UTF8 &aText, const VECTOR2D &aGlyphSize, double aGlyphThickness, int markupFlags) const
Compute the boundary limits of aText (the bounding box of all shapes).
static const double INTERLINE_PITCH_RATIO
Factor that determines the pitch between 2 lines.
Definition: stroke_font.h:190
std::vector< std::vector< VECTOR2D > > GLYPH
Definition: stroke_font.h:43
std::vector< BOX2D > * g_newStrokeFontGlyphBoundingBoxes
Bounding boxes of the glyphs.
Definition: stroke_font.cpp:46
bool IsFontItalic() const
Returns true if current font has 'italic' attribute enabled.
uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded string...
Definition: utf8.h:207
GLYPH_LIST * g_newStrokeFontGlyphs
Glyph list.
Definition: stroke_font.cpp:45
double computeOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
STROKE_FONT(GAL *aGal)
Constructor.
Definition: stroke_font.cpp:49
static const double STROKE_FONT_SCALE
Scale factor for a glyph
Definition: stroke_font.h:183
virtual void Restore()
Restore the context.
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
unsigned linesCount(const UTF8 &aText) const
Returns number of lines for a given text.
Definition: stroke_font.h:167
#define FONT_OFFSET
void Draw(const UTF8 &aText, const VECTOR2D &aPosition, double aRotationAngle, int markupFlags)
Draw a string.
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:61
static const double OVERBAR_POSITION_FACTOR
Factor that determines relative vertical position of the overbar.
Definition: stroke_font.h:177
const std::vector< BOX2D > * m_glyphBoundingBoxes
Bounding boxes of the glyphs.
Definition: stroke_font.h:125
std::string substr(size_t pos=0, size_t len=npos) const
Definition: utf8.h:182
virtual void Save()
Save the context.
const GLYPH_LIST * m_glyphs
Glyph list.
Definition: stroke_font.h:124
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
void drawSingleLineText(const UTF8 &aText, int markupFlags)
Draws a single line of text.
Class GAL is the abstract interface for drawing on a 2D-surface.
bool empty() const
Definition: utf8.h:108