diff options
Diffstat (limited to 'common/gal/stroke_font.cpp')
| -rw-r--r-- | common/gal/stroke_font.cpp | 403 |
1 files changed, 403 insertions, 0 deletions
diff --git a/common/gal/stroke_font.cpp b/common/gal/stroke_font.cpp new file mode 100644 index 0000000..636f75e --- /dev/null +++ b/common/gal/stroke_font.cpp @@ -0,0 +1,403 @@ +/* + * This program source code file is part of KICAD, a free EDA CAD application. + * + * 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 <maciej.suminski@cern.ch> + * + * Stroke font class + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <gal/stroke_font.h> +#include <gal/graphics_abstraction_layer.h> +#include <wx/string.h> + +using namespace KIGFX; + +const double STROKE_FONT::INTERLINE_PITCH_RATIO = 1.5; +const double STROKE_FONT::OVERBAR_HEIGHT = 1.22; +const double STROKE_FONT::BOLD_FACTOR = 1.3; +const double STROKE_FONT::STROKE_FONT_SCALE = 1.0 / 21.0; +const double STROKE_FONT::ITALIC_TILT = 1.0 / 8; + +STROKE_FONT::STROKE_FONT( GAL* aGal ) : + m_gal( aGal ), + m_bold( false ), + m_italic( false ), + m_mirrored( false ), + m_overbar( false ) +{ + // Default values + m_glyphSize = VECTOR2D( 10.0, 10.0 ); + m_verticalJustify = GR_TEXT_VJUSTIFY_BOTTOM; + m_horizontalJustify = GR_TEXT_HJUSTIFY_LEFT; +} + + +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++ ) + { + GLYPH glyph; + double glyphStartX = 0.0; + double glyphEndX = 0.0; + VECTOR2D glyphBoundingX; + + std::deque<VECTOR2D> pointList; + + int i = 0; + + while( aNewStrokeFont[j][i] ) + { + VECTOR2D point( 0.0, 0.0 ); + char coordinate[2] = { 0, }; + + for( int k = 0; k < 2; k++ ) + { + coordinate[k] = aNewStrokeFont[j][i + k]; + } + + if( i < 2 ) + { + // The first two values contain the width of the char + glyphStartX = ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE; + glyphEndX = ( coordinate[1] - 'R' ) * STROKE_FONT_SCALE; + glyphBoundingX = VECTOR2D( 0, glyphEndX - glyphStartX ); + } + else if( ( coordinate[0] == ' ' ) && ( coordinate[1] == 'R' ) ) + { + // Raise pen + if( pointList.size() > 0 ) + glyph.push_back( pointList ); + + pointList.clear(); + } + else + { + // Every coordinate description of the Hershey format has an offset, + // it has to be subtracted + point.x = (double) ( coordinate[0] - 'R' ) * STROKE_FONT_SCALE - glyphStartX; + // -10 is here to keep GAL rendering consistent with the legacy gfx stuff + point.y = (double) ( coordinate[1] - 'R' - 10) * STROKE_FONT_SCALE; + pointList.push_back( point ); + } + + i += 2; + } + + if( pointList.size() > 0 ) + glyph.push_back( pointList ); + + m_glyphs[j] = glyph; + + // Compute the bounding box of the glyph + m_glyphBoundingBoxes[j] = computeBoundingBox( glyph, glyphBoundingX ); + } + + return true; +} + + +int STROKE_FONT::getInterline() const +{ + return KiROUND( m_glyphSize.y * INTERLINE_PITCH_RATIO ) + m_gal->GetLineWidth(); +} + + +BOX2D STROKE_FONT::computeBoundingBox( const GLYPH& aGLYPH, const VECTOR2D& aGLYPHBoundingX ) const +{ + BOX2D boundingBox; + + std::deque<VECTOR2D> boundingPoints; + + boundingPoints.push_back( VECTOR2D( aGLYPHBoundingX.x, 0 ) ); + boundingPoints.push_back( VECTOR2D( aGLYPHBoundingX.y, 0 ) ); + + for( GLYPH::const_iterator pointListIt = aGLYPH.begin(); pointListIt != aGLYPH.end(); ++pointListIt ) + { + for( std::deque<VECTOR2D>::const_iterator pointIt = pointListIt->begin(); + pointIt != pointListIt->end(); ++pointIt ) + { + boundingPoints.push_back( VECTOR2D( aGLYPHBoundingX.x, pointIt->y ) ); + } + } + + boundingBox.Compute( boundingPoints ); + + return boundingBox; +} + + +void STROKE_FONT::Draw( const UTF8& aText, const VECTOR2D& aPosition, double aRotationAngle ) +{ + if( aText.empty() ) + return; + + // Context needs to be saved before any transformations + m_gal->Save(); + + m_gal->Translate( aPosition ); + m_gal->Rotate( -aRotationAngle ); + + // Single line height + int lineHeight = getInterline( ); + int lineCount = linesCount( aText ); + + // align the 1st line of text + switch( m_verticalJustify ) + { + case GR_TEXT_VJUSTIFY_TOP: + m_gal->Translate( VECTOR2D( 0, m_glyphSize.y ) ); + break; + + case GR_TEXT_VJUSTIFY_CENTER: + m_gal->Translate( VECTOR2D( 0, m_glyphSize.y / 2.0 ) ); + break; + + case GR_TEXT_VJUSTIFY_BOTTOM: + break; + + default: + break; + } + + if( lineCount > 1 ) + { + switch( m_verticalJustify ) + { + case GR_TEXT_VJUSTIFY_TOP: + break; + + case GR_TEXT_VJUSTIFY_CENTER: + m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight / 2) ); + break; + + case GR_TEXT_VJUSTIFY_BOTTOM: + m_gal->Translate( VECTOR2D(0, -( lineCount - 1 ) * lineHeight ) ); + break; + } + } + + 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 begin = 0; + size_t newlinePos = aText.find( '\n' ); + + while( newlinePos != aText.npos ) + { + size_t length = newlinePos - begin; + + drawSingleLineText( aText.substr( begin, length ) ); + m_gal->Translate( VECTOR2D( 0.0, lineHeight ) ); + + begin = newlinePos + 1; + newlinePos = aText.find( '\n', begin ); + } + + // Draw the last (or the only one) line + if( !aText.empty() ) + drawSingleLineText( aText.substr( begin ) ); + + m_gal->Restore(); +} + + +void STROKE_FONT::drawSingleLineText( const UTF8& aText ) +{ + // By default the overbar is turned off + m_overbar = false; + + double xOffset; + VECTOR2D glyphSize( m_glyphSize ); + double overbar_italic_comp = 0.0; + + // Compute the text size + 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 ) ); + break; + + case GR_TEXT_HJUSTIFY_RIGHT: + if( !m_mirrored ) + 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; + } + + 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; + glyphSize.x = -m_glyphSize.x; + } + else + { + xOffset = 0.0; + } + + // The overbar is indented inward at the beginning of an italicized section, but + // must not be indented on subsequent letters to ensure that the bar segments + // overlap. + bool last_had_overbar = false; + + for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt ) + { + // Toggle overbar + if( *chIt == '~' ) + { + if( ++chIt >= 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 + } + + int dd = *chIt - ' '; + + if( dd >= (int) m_glyphBoundingBoxes.size() || dd < 0 ) + dd = '?' - ' '; + + GLYPH& glyph = m_glyphs[dd]; + BOX2D& bbox = m_glyphBoundingBoxes[dd]; + + if( m_overbar && m_italic ) + { + if( m_mirrored ) + { + overbar_italic_comp = (-m_glyphSize.y * OVERBAR_HEIGHT) / ITALIC_TILT; + } + else + { + overbar_italic_comp = (m_glyphSize.y * OVERBAR_HEIGHT) / ITALIC_TILT; + } + } + + if( m_overbar ) + { + double overbar_start_x = xOffset; + double overbar_start_y = -m_glyphSize.y * OVERBAR_HEIGHT; + double overbar_end_x = xOffset + glyphSize.x * bbox.GetEnd().x; + double overbar_end_y = -m_glyphSize.y * OVERBAR_HEIGHT; + + if( !last_had_overbar ) + { + overbar_start_x += overbar_italic_comp; + last_had_overbar = true; + } + + VECTOR2D startOverbar( overbar_start_x, overbar_start_y ); + VECTOR2D endOverbar( overbar_end_x, overbar_end_y ); + + m_gal->DrawLine( startOverbar, endOverbar ); + } + else + { + last_had_overbar = false; + } + + for( GLYPH::iterator pointListIt = glyph.begin(); pointListIt != glyph.end(); + ++pointListIt ) + { + std::deque<VECTOR2D> pointListScaled; + + for( std::deque<VECTOR2D>::iterator pointIt = pointListIt->begin(); + pointIt != pointListIt->end(); ++pointIt ) + { + 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 + if( m_mirrored ) + pointPos.x += pointPos.y * 0.1; + else + pointPos.x -= pointPos.y * 0.1; + } + + pointListScaled.push_back( pointPos ); + } + + m_gal->DrawPolyline( pointListScaled ); + } + + xOffset += glyphSize.x * bbox.GetEnd().x; + } + + m_gal->Restore(); +} + + +VECTOR2D STROKE_FONT::computeTextSize( const UTF8& aText ) const +{ + VECTOR2D result = VECTOR2D( 0.0, m_glyphSize.y ); + + for( UTF8::uni_iter it = aText.ubegin(), end = aText.uend(); it < end; ++it ) + { + wxASSERT_MSG( *it != '\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( *it == '~' ) + { + if( ++it >= end ) + break; + } + + // Index in the bounding boxes table + int dd = *it - ' '; + + if( dd >= (int) m_glyphBoundingBoxes.size() || dd < 0 ) + dd = '?' - ' '; + + result.x += m_glyphSize.x * m_glyphBoundingBoxes[dd].GetEnd().x; + } + + return result; +} |