Merge lp:~cern-kicad/kicad/bugfix_1256302 into lp:kicad/product

[Maciej Suminski]

[Dick Hollenbeck (dickelbeck)]

I don't think we've used std::wstring before. It's use brings two problems:

a) The width of its characters is platform dependent, because wchar_t is not certainly a given size.

b) It adds more code, since the basic_string<> template is instantiated for this new datatype, yet again.

Certainly b) would be worth it for a string design which met all our needs, but because of a), std::wstring does not.

A simpler, less costly fix is to just use wxString. At some point in the future, wxString datatype could be globally replaced with one of the project's own, but I don't think std:wstring is it.

More likely a derivative of basic_string<uint32_t> could be crafted to better solve the project's needs, with constructors taking utf8 byte sequences, and conversion operators back to wxString. But that is a topic for a another thread.

For the patch at hand, I'm advocating using wxString with an iterator, which will give you the proper a unicode value as you iterate through the wxString. Then, as long as the unicode value is OK for the vectorizer, this is less code overall, since it makes use of stuff already being linked in.

If you find that usage of wxString in this context is too slow, then you could consider encoding an 8 bit string using an ecoding that the vectorizer is assuming, one that matches unicode encoding in its first 256 positions. This might be LATIN1 or something.

But since we start with wxString, I don't think its a problem to take that as the argument to the STROKE support.

[lp:~cern-kicad/kicad/bugfix_1256302]

4520. By Maciej Suminski on 2013-12-05

Changed std::wstring to wxString.

4521. By Maciej Suminski on 2013-12-05

Glyphs and their bounding boxes are held in vectors instead of deque.
Moved scaling of font glyphs to the moment when they are created (eliminated a few multiplications unnecessary variables).
Changed some magic numbers into constants.

4522. By Maciej Suminski on 2013-12-05

Tilda handling for STROKE_FONT class.

4523. By Maciej Suminski on 2013-12-05

DIfferent handling of italic texts, depending on the mirroring setting.

[Maciej Suminski (orsonmmz)]

A lesson was learned, I modified the STROKE_TEXT functions to handle wxStrings, as it was the easiest solution and added some other missing features.
I guess that a specialized class for handling strings could save some pain. It could be particularly helpful now, when it is no more only wx2.8 & wx2.9.4, but also evolving wx3.0.

review: Needs Resubmitting

[Dick Hollenbeck (dickelbeck)]

was it just an oversight or is there some reason that you are passing wxString to the STROKE_TEXT API functions by value rather than by const reference?

[Maciej Suminski (orsonmmz)]

It was an oversight, in the previous implementation the string was split in place and the Draw() function was called recursively, but it is not the case anymore.
Thanks for noting, it is fixed in the last commit. I also did some reformatting and I hope I will not touch that part for a long time.

[Dick Hollenbeck (dickelbeck)]

On 12/05/2013 01:48 PM, Maciej Sumiński wrote:
> It was an oversight, in the previous implementation the string was split in place and the Draw() function was called recursively, but it is not the case anymore.
> Thanks for noting, it is fixed in the last commit. I also did some reformatting and I hope I will not touch that part for a long time.
>

Sorry, I already committed the branch.

[Maciej Suminski (orsonmmz)]

The most important change was introduced by you, so it is fine.

=== modified file 'common/gal/stroke_font.cpp'
--- common/gal/stroke_font.cpp	2013-10-30 20:07:52 +0000
+++ common/gal/stroke_font.cpp	2013-12-05 16:07:56 +0000
@@ -3,6 +3,8 @@
  *
  * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
  * Copyright (C) 2012 Kicad Developers, see change_log.txt for contributors.
+ * Copyright (C) 2013 CERN
+ * @author Maciej Suminski <[e-mail]>
  *
  * Stroke font class
  *
@@ -26,12 +28,13 @@
 
 #include <gal/stroke_font.h>
 #include <gal/graphics_abstraction_layer.h>
+#include <wx/string.h>
 
 using namespace KIGFX;
 
-
-const double STROKE_FONT::LINE_HEIGHT_RATIO  = 1.6;
-
+const double STROKE_FONT::OVERBAR_HEIGHT = 0.45;
+const double STROKE_FONT::BOLD_FACTOR = 1.3;
+const double STROKE_FONT::HERSHEY_SCALE = 1.0 / 21.0;
 
 STROKE_FONT::STROKE_FONT( GAL* aGal ) :
     m_gal( aGal ),
@@ -40,22 +43,18 @@
     m_mirrored( false )
 {
     // Default values
-    m_scaleFactor = 1.0 / 21.0;
     m_glyphSize = VECTOR2D( 10.0, 10.0 );
     m_verticalJustify   = GR_TEXT_VJUSTIFY_BOTTOM;
     m_horizontalJustify = GR_TEXT_HJUSTIFY_LEFT;
 }
 
 
-STROKE_FONT::~STROKE_FONT()
-{
-}
-
-
 bool STROKE_FONT::LoadNewStrokeFont( const char* const aNewStrokeFont[], int aNewStrokeFontSize )
 {
     m_glyphs.clear();
     m_glyphBoundingBoxes.clear();
+    m_glyphs.resize( aNewStrokeFontSize );
+    m_glyphBoundingBoxes.resize( aNewStrokeFontSize );
 
     for( int j = 0; j < aNewStrokeFontSize; j++ )
     {
@@ -81,8 +80,8 @@
             if( i < 2 )
             {
                 // The first two values contain the width of the char
-                glyphStartX     = coordinate[0] - 'R';
-                glyphEndX       = coordinate[1] - 'R';
+                glyphStartX     = ( coordinate[0] - 'R' ) * HERSHEY_SCALE;
+                glyphEndX       = ( coordinate[1] - 'R' ) * HERSHEY_SCALE;
                 glyphBoundingX  = VECTOR2D( 0, glyphEndX - glyphStartX );
             }
             else if( ( coordinate[0] == ' ' ) && ( coordinate[1] == 'R' ) )
@@ -97,8 +96,8 @@
             {
                 // Every coordinate description of the Hershey format has an offset,
                 // it has to be subtracted
-                point.x = (double) ( coordinate[0] - 'R' ) - glyphStartX;
-                point.y = (double) ( coordinate[1] - 'R' ) - 11.0;
+                point.x = (double) ( coordinate[0] - 'R' ) * HERSHEY_SCALE - glyphStartX;
+                point.y = (double) ( coordinate[1] - 'R' ) * HERSHEY_SCALE;
                 pointList.push_back( point );
             }
 
@@ -108,16 +107,22 @@
         if( pointList.size() > 0 )
             glyph.push_back( pointList );
 
-        m_glyphs.push_back( glyph );
+        m_glyphs[j] = glyph;
 
         // Compute the bounding box of the glyph
-        m_glyphBoundingBoxes.push_back( computeBoundingBox( glyph, glyphBoundingX ) );
+        m_glyphBoundingBoxes[j] = computeBoundingBox( glyph, glyphBoundingX );
     }
 
     return true;
 }
 
 
+int STROKE_FONT::getInterline() const
+{
+    return ( m_glyphSize.y * 14 ) / 10 + m_gal->GetLineWidth();
+}
+
+
 BOX2D STROKE_FONT::computeBoundingBox( const GLYPH& aGLYPH, const VECTOR2D& aGLYPHBoundingX ) const
 {
     BOX2D boundingBox;
@@ -142,133 +147,160 @@
 }
 
 
-void STROKE_FONT::Draw( std::string aText, const VECTOR2D& aPosition, double aRotationAngle )
+void STROKE_FONT::Draw( wxString aText, const VECTOR2D& aPosition, double aRotationAngle )
 {
-    // By default overbar is turned off
-    m_overbar = false;
-
     // Context needs to be saved before any transformations
     m_gal->Save();
 
     m_gal->Translate( aPosition );
+
+    // Single line height
+    int lineHeight = getInterline();
+
+    // The overall height of all lines of text
+    double textBlockHeight = lineHeight * ( linesCount( aText ) - 1 );
+
+    switch( m_verticalJustify )
+    {
+    case GR_TEXT_VJUSTIFY_CENTER:
+        m_gal->Translate( VECTOR2D( 0, -textBlockHeight / 2.0 ) );
+        break;
+
+    case GR_TEXT_VJUSTIFY_BOTTOM:
+        m_gal->Translate( VECTOR2D( 0, -textBlockHeight ) );
+        break;
+
+    case GR_TEXT_VJUSTIFY_TOP:
+        break;
+
+    default:
+        break;
+    }
+
     m_gal->Rotate( -aRotationAngle );
 
+    m_gal->SetIsStroke( true );
+    m_gal->SetIsFill( false );
+
+    if( m_bold )
+        m_gal->SetLineWidth( m_gal->GetLineWidth() * BOLD_FACTOR );
+
     // Split multiline strings into separate ones and draw them line by line
-    size_t newlinePos = aText.find( '\n' );
+    int begin = 0;
+    int newlinePos = aText.Find( '\n' );
 
-    if( newlinePos != std::string::npos )
+    while( newlinePos != wxNOT_FOUND )
     {
-        VECTOR2D nextlinePosition = VECTOR2D( 0.0, m_glyphSize.y * LINE_HEIGHT_RATIO );
+        size_t length = newlinePos - begin;
+        drawSingleLineText( aText.Mid( begin, length ) );
+        m_gal->Translate( VECTOR2D( 0.0, lineHeight ) );
 
-        Draw( aText.substr( newlinePos + 1 ), nextlinePosition, 0.0 );
-        aText = aText.substr( 0, newlinePos );
+        begin = newlinePos + 1;
+        newlinePos = aText.find( '\n', begin + 1 );
     }
 
+    // Draw the last (or the only one) line
+    if( !aText.IsEmpty() )
+        drawSingleLineText( aText.Mid( begin ) );
+
+    m_gal->Restore();
+}
+
+
+void STROKE_FONT::drawSingleLineText( const wxString& aText )
+{
+    // By default the overbar is turned off
+    m_overbar = false;
+
+    double xOffset;
+    VECTOR2D glyphSize( m_glyphSize );
+
     // Compute the text size
-    VECTOR2D textsize = computeTextSize( aText );
+    VECTOR2D textSize = computeTextSize( aText );
+
+    m_gal->Save();
 
     // Adjust the text position to the given alignment
     switch( m_horizontalJustify )
     {
     case GR_TEXT_HJUSTIFY_CENTER:
-        m_gal->Translate( VECTOR2D( -textsize.x / 2.0, 0 ) );
+        m_gal->Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
         break;
 
     case GR_TEXT_HJUSTIFY_RIGHT:
         if( !m_mirrored )
-            m_gal->Translate( VECTOR2D( -textsize.x, 0 ) );
-
+            m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
         break;
 
     case GR_TEXT_HJUSTIFY_LEFT:
         if( m_mirrored )
-            m_gal->Translate( VECTOR2D( -textsize.x, 0 ) );
-
-        break;
-
-    default:
-        break;
-    }
-
-    switch( m_verticalJustify )
-    {
-    case GR_TEXT_VJUSTIFY_CENTER:
-        m_gal->Translate( VECTOR2D( 0, textsize.y / 2.0 ) );
-        break;
-
-    case GR_TEXT_VJUSTIFY_TOP:
-        m_gal->Translate( VECTOR2D( 0, textsize.y ) );
-        break;
-
-    case GR_TEXT_VJUSTIFY_BOTTOM:
-        break;
-
-    default:
-        break;
-    }
-
-    double xOffset, glyphSizeX;
+            m_gal->Translate( VECTOR2D( -textSize.x, 0 ) );
+        break;
+
+    default:
+        break;
+    }
 
     if( m_mirrored )
     {
         // In case of mirrored text invert the X scale of points and their X direction
         // (m_glyphSize.x) and start drawing from the position where text normally should end
-        // (textsize.x)
-        xOffset     = textsize.x;
-        glyphSizeX  = -m_glyphSize.x;
-    }
-    else
-    {
-        xOffset     = 0.0;
-        glyphSizeX  = m_glyphSize.x;
-    }
-    double scaleY = m_scaleFactor * m_glyphSize.y;
-    double scaleX = m_scaleFactor * glyphSizeX;
-
-    m_gal->SetIsStroke( true );
-    m_gal->SetIsFill( false );
-
-    if( m_bold )
-    {
-        m_gal->SetLineWidth( m_gal->GetLineWidth() * 1.3 );
-    }
-
-    for( std::string::const_iterator chIt = aText.begin(); chIt != aText.end(); chIt++ )
-    {
+        // (textSize.x)
+        xOffset = textSize.x;
+        glyphSize.x = -m_glyphSize.x;
+    } else
+    {
+        xOffset = 0.0;
+    }
+
+    for( wxString::const_iterator chIt = aText.begin(); chIt != aText.end(); ++chIt )
+    {
+        // Toggle overbar
         if( *chIt == '~' )
         {
-            m_overbar = !m_overbar;
-            continue;
+            if( ++chIt == aText.end() )
+                break;
+
+            if( *chIt != '~' )      // It was a single tilda, it toggles overbar
+                m_overbar = !m_overbar;
+
+            // If it is a double tilda, just process the second one
         }
 
-        GLYPH_LIST::iterator glyphIt = m_glyphs.begin();
-        std::deque<BOX2D>::iterator bbIt = m_glyphBoundingBoxes.begin();
-
-        unsigned dd = (unsigned) ((unsigned char) *chIt ) - (unsigned) ' ';
-
-        if( dd >= m_glyphBoundingBoxes.size() )
+        unsigned dd = *chIt - ' ';
+
+        if( dd >= m_glyphBoundingBoxes.size() || dd < 0 )
             dd = '?' - ' ';
 
-        advance( glyphIt, dd );
-        advance( bbIt, dd );
+        GLYPH& glyph = m_glyphs[dd];
+        BOX2D& bbox = m_glyphBoundingBoxes[dd];
 
-        GLYPH glyph = *glyphIt;
+        if( m_overbar )
+        {
+            VECTOR2D startOverbar( xOffset, -getInterline() * OVERBAR_HEIGHT );
+            VECTOR2D endOverbar( xOffset + glyphSize.x * bbox.GetEnd().x,
+                                 -getInterline() * OVERBAR_HEIGHT );
+            m_gal->DrawLine( startOverbar, endOverbar );
+        }
 
         for( GLYPH::iterator pointListIt = glyph.begin(); pointListIt != glyph.end();
-             pointListIt++ )
+             ++pointListIt )
         {
             std::deque<VECTOR2D> pointListScaled;
 
             for( std::deque<VECTOR2D>::iterator pointIt = pointListIt->begin();
-                 pointIt != pointListIt->end(); pointIt++ )
+                 pointIt != pointListIt->end(); ++pointIt )
             {
-                VECTOR2D pointPos( pointIt->x * scaleX + xOffset, pointIt->y * scaleY );
+                VECTOR2D pointPos( pointIt->x * glyphSize.x + xOffset, pointIt->y * glyphSize.y );
 
                 if( m_italic )
                 {
                     // FIXME should be done other way - referring to the lowest Y value of point
                     // because now italic fonts are translated a bit
-                    pointPos.x += pointPos.y * 0.1;
+                    if( m_mirrored )
+                        pointPos.x += pointPos.y * 0.1;
+                    else
+                        pointPos.x -= pointPos.y * 0.1;
                 }
 
                 pointListScaled.push_back( pointPos );
@@ -277,39 +309,37 @@
             m_gal->DrawPolyline( pointListScaled );
         }
 
-        if( m_overbar )
-        {
-            VECTOR2D startOverbar( xOffset, -textsize.y * 1.2 );
-            VECTOR2D endOverbar( xOffset + m_scaleFactor * glyphSizeX * bbIt->GetEnd().x,
-                                 -textsize.y * 1.2 );
-            m_gal->DrawLine( startOverbar, endOverbar );
-        }
-
-        xOffset += m_scaleFactor * glyphSizeX * bbIt->GetEnd().x;
+        xOffset += glyphSize.x * bbox.GetEnd().x;
     }
 
     m_gal->Restore();
 }
 
 
-VECTOR2D STROKE_FONT::computeTextSize( const std::string& aText ) const
+VECTOR2D STROKE_FONT::computeTextSize( const wxString& aText ) const
 {
     VECTOR2D result = VECTOR2D( 0.0, m_glyphSize.y );
 
-    for( std::string::const_iterator chIt = aText.begin(); chIt != aText.end(); chIt++ )
+    for( wxString::const_iterator chIt = aText.begin(); chIt != aText.end(); ++chIt )
     {
+        wxASSERT_MSG( *chIt != '\n',
+                      wxT( "This function is intended to work with single line strings" ) );
+
+        // If it is double tilda, then it is displayed as a single tilda
+        // If it is single tilda, then it is toggling overbar, so we need to skip it
         if( *chIt == '~' )
-            continue;
-
-        std::deque<BOX2D>::const_iterator bbIt = m_glyphBoundingBoxes.begin();
-        unsigned dd =  (unsigned) ((unsigned char)*chIt) - (unsigned) ' ';
-
-        if( dd >= m_glyphBoundingBoxes.size() )
+        {
+            if( ++chIt == aText.end() )
+                break;
+        }
+
+        // Index in the bounding boxes table
+        unsigned dd = *chIt - ' ';
+
+        if( dd >= m_glyphBoundingBoxes.size() || dd < 0 )
             dd = '?' - ' ';
 
-        advance( bbIt, dd );
-
-        result.x += m_scaleFactor * m_glyphSize.x * bbIt->GetEnd().x;
+        result.x += m_glyphSize.x * m_glyphBoundingBoxes[dd].GetEnd().x;
     }
 
     return result;

=== modified file 'common/worksheet_viewitem.cpp'
--- common/worksheet_viewitem.cpp	2013-10-31 21:30:57 +0000
+++ common/worksheet_viewitem.cpp	2013-12-05 16:07:56 +0000
@@ -191,7 +191,7 @@
     aGal->SetStrokeColor( COLOR4D( aItem->GetColor() ) );
     aGal->SetLineWidth( aItem->GetThickness() );
     aGal->SetTextAttributes( aItem );
-    aGal->StrokeText( std::string( aItem->GetText().mb_str() ), position, 0.0 );
+    aGal->StrokeText( std::wstring( aItem->GetText().wc_str() ), position, 0.0 );
 }
 
 

=== modified file 'include/gal/graphics_abstraction_layer.h'
--- include/gal/graphics_abstraction_layer.h	2013-10-14 18:40:36 +0000
+++ include/gal/graphics_abstraction_layer.h	2013-12-05 16:07:56 +0000
@@ -277,7 +277,7 @@
      * @param aPosition is the text position in world coordinates.
      * @param aRotationAngle is the text rotation angle.
      */
-    inline virtual void StrokeText( const std::string& aText, const VECTOR2D& aPosition,
+    inline virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
                                     double aRotationAngle )
     {
         strokeFont.Draw( aText, aPosition, aRotationAngle );

=== modified file 'include/gal/stroke_font.h'
--- include/gal/stroke_font.h	2013-10-14 18:40:36 +0000
+++ include/gal/stroke_font.h	2013-12-05 16:07:56 +0000
@@ -3,6 +3,8 @@
  *
  * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
  * Copyright (C) 2012 Kicad Developers, see change_log.txt for contributors.
+ * Copyright (C) 2013 CERN
+ * @author Maciej Suminski <[e-mail]>
  *
  * Stroke font class
  *
@@ -39,7 +41,7 @@
 class GAL;
 
 typedef std::deque< std::deque<VECTOR2D> > GLYPH;
-typedef std::deque<GLYPH>                  GLYPH_LIST;
+typedef std::vector<GLYPH>                 GLYPH_LIST;
 
 /**
  * @brief Class STROKE_FONT implements stroke font drawing.
@@ -52,11 +54,6 @@
     /// Constructor
     STROKE_FONT( GAL* aGal );
 
-    /// Destructor
-    ~STROKE_FONT();
-
-    // TODO Load font from a text file
-
     /**
      * @brief Load the new stroke font.
      *
@@ -73,17 +70,7 @@
      * @param aPosition is the text position in world coordinates.
      * @param aRotationAngle is the text rotation angle.
      */
-    void Draw( std::string aText, const VECTOR2D& aPosition, double aRotationAngle );
-
-    /**
-     * @brief Set the scale factor of the font for the glyph size.
-     *
-     * @param aScaleFactor is the scale factor of the font.
-     */
-    inline void SetScaleFactor( const double aScaleFactor )
-    {
-        m_scaleFactor = aScaleFactor;
-    }
+    void Draw( wxString aText, const VECTOR2D& aPosition, double aRotationAngle );
 
     /**
      * @brief Set the glyph size.
@@ -158,14 +145,20 @@
 private:
     GAL*                m_gal;                                    ///< Pointer to the GAL
     GLYPH_LIST          m_glyphs;                                 ///< Glyph list
-    std::deque<BOX2D>   m_glyphBoundingBoxes;                     ///< Bounding boxes of the glyphs
-    double              m_scaleFactor;                            ///< Scale factor for the glyph
+    std::vector<BOX2D>  m_glyphBoundingBoxes;                     ///< Bounding boxes of the glyphs
     VECTOR2D            m_glyphSize;                              ///< Size of the glyphs
     EDA_TEXT_HJUSTIFY_T m_horizontalJustify;                      ///< Horizontal justification
     EDA_TEXT_VJUSTIFY_T m_verticalJustify;                        ///< Vertical justification
     bool                m_bold, m_italic, m_mirrored, m_overbar;  ///< Properties of text
 
     /**
+     * @brief Returns a single line height using current settings.
+     *
+     * @return The line height.
+     */
+    int getInterline() const;
+
+    /**
      * @brief Compute the bounding box of a given glyph.
      *
      * @param aGlyph is the glyph.
@@ -175,14 +168,49 @@
     BOX2D computeBoundingBox( const GLYPH& aGlyph, const VECTOR2D& aGlyphBoundingX ) const;
 
     /**
+     * @brief Draws a single line of text. Multiline texts should be split before using the
+     * function.
+     *
+     * @param aText is the text to be drawn.
+     */
+    void drawSingleLineText( const wxString& aText );
+
+    /**
      * @brief Compute the size of a given text.
      *
      * @param aText is the text string.
      * @return is the text size.
      */
-    VECTOR2D computeTextSize( const std::string& aText ) const;
-
-    static const double LINE_HEIGHT_RATIO;
+    VECTOR2D computeTextSize( const wxString& aText ) const;
+
+    /**
+     * @brief Returns number of lines for a given text.
+     *
+     * @param aText is the text to be checked.
+     * @return Number of lines of aText.
+     */
+    unsigned int linesCount( const wxString& aText ) const
+    {
+        wxString::const_iterator it, itEnd;
+        unsigned int lines = 1;
+
+        for( it = aText.begin(), itEnd = aText.end(); it != itEnd; ++it )
+        {
+            if( *it == '\n' )
+                ++lines;
+        }
+
+        return lines;
+    }
+
+    ///> Factor that determines relative height of overbar.
+    static const double OVERBAR_HEIGHT;
+
+    ///> Factor that determines relative line width for bold text.
+    static const double BOLD_FACTOR;
+
+    ///> Scale factor for the glyph
+    static const double HERSHEY_SCALE;
 };
 } // namespace KIGFX
 

=== modified file 'pcbnew/pcb_painter.cpp'
--- pcbnew/pcb_painter.cpp	2013-11-06 17:17:42 +0000
+++ pcbnew/pcb_painter.cpp	2013-12-05 16:07:56 +0000
@@ -280,7 +280,7 @@
             if( !net )
                 return;
 
-            std::string netName = std::string( net->GetShortNetname().mb_str() );
+            std::wstring netName = std::wstring( net->GetShortNetname().wc_str() );
             VECTOR2D textPosition = start + line / 2.0;     // center of the track
             double textOrientation = -atan( line.y / line.x );
             double textSize = std::min( static_cast<double>( width ), length / netName.length() );
@@ -456,7 +456,7 @@
                 VECTOR2D namesize( tsize, tsize );
                 m_gal->SetGlyphSize( namesize );
                 m_gal->SetLineWidth( namesize.x / 12.0 );
-                m_gal->StrokeText( std::string( aPad->GetShortNetname().mb_str() ),
+                m_gal->StrokeText( std::wstring( aPad->GetShortNetname().wc_str() ),
                                    textpos, 0.0 );
             }
 
@@ -474,8 +474,7 @@
 
                 m_gal->SetGlyphSize( numsize );
                 m_gal->SetLineWidth( numsize.x / 12.0 );
-                m_gal->StrokeText( std::string( aPad->GetPadName().mb_str() ),
-                                   textpos, 0.0 );
+                m_gal->StrokeText( std::wstring( aPad->GetPadName().wc_str() ), textpos, 0.0 );
             }
 
             m_gal->Restore();
@@ -720,7 +719,7 @@
     m_gal->SetStrokeColor( strokeColor );
     m_gal->SetLineWidth( aText->GetThickness() );
     m_gal->SetTextAttributes( aText );
-    m_gal->StrokeText( std::string( aText->GetText().mb_str() ), position, orientation );
+    m_gal->StrokeText( aText->GetText(), position, orientation );
 }
 
 
@@ -736,7 +735,7 @@
     m_gal->SetStrokeColor( strokeColor );
     m_gal->SetLineWidth( aText->GetThickness() );
     m_gal->SetTextAttributes( aText );
-    m_gal->StrokeText( std::string( aText->GetText().mb_str() ), position, orientation );
+    m_gal->StrokeText( aText->GetText(), position, orientation );
 }
 
 
@@ -836,7 +835,7 @@
 
     m_gal->SetLineWidth( text.GetThickness() );
     m_gal->SetTextAttributes( &text );
-    m_gal->StrokeText( std::string( text.GetText().mb_str() ), position, orientation );
+    m_gal->StrokeText( std::wstring( text.GetText().wc_str() ), position, orientation );
 }