eda_text.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2004-2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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
 */
 
#ifndef EDA_TEXT_H_
#define EDA_TEXT_H_
 
#include <memory>
#include <vector>
 
#include <outline_mode.h>
#include <eda_search_data.h>
#include <font/glyph.h>
#include <font/text_attributes.h>
 
class OUTPUTFORMATTER;
class SHAPE_COMPOUND;
class SHAPE_POLY_SET;
 
 
// These are only here for algorithmic safety, not to tell the user what to do.
// PL_EDITOR has the least resolution (its internal units are microns), so the min size is chosen
// to yield 1 in PL_EDITOR.
// The max size chosen is somewhat arbitrary, but no one has complained yet.
#define TEXT_MIN_SIZE_MM 0.001 
#define TEXT_MAX_SIZE_MM 250.0 
 
 
namespace KIGFX
{
 class RENDER_SETTINGS;
 class COLOR4D;
}
 
namespace KIFONT
{
 class METRICS;
 }
 
using KIGFX::RENDER_SETTINGS;
using KIGFX::COLOR4D;
 
// part of the kicad_plugin.h family of defines.
// See kicad_plugin.h for the choice of the value
// When set when calling EDA_TEXT::Format, disable writing the "hide" keyword in save file
#define CTL_OMIT_HIDE (1 << 6)
 
 
#define DEFAULT_SIZE_TEXT 50 // default text height (in mils, i.e. 1/1000")
 
 
class EDA_TEXT
{
public:
 EDA_TEXT( const EDA_IU_SCALE& aIuScale, const wxString& aText = wxEmptyString );
 
 EDA_TEXT( const EDA_TEXT& aText );
 
 virtual ~EDA_TEXT();
 
 EDA_TEXT& operator=( const EDA_TEXT& aItem );
 
 virtual const wxString& GetText() const { return m_text; }
 
 virtual wxString GetShownText( bool aAllowExtraText, int aDepth = 0 ) const
 {
 return m_shown_text;
 }
 
 bool HasTextVars() const { return m_shown_text_has_text_var_refs; }
 
 virtual void SetText( const wxString& aText );
 
 void SetTextThickness( int aWidth );
 int GetTextThickness() const { return m_attributes.m_StrokeWidth; };
 
 int GetEffectiveTextPenWidth( int aDefaultPenWidth = 0 ) const;
 
 virtual void SetTextAngle( const EDA_ANGLE& aAngle );
 const EDA_ANGLE& GetTextAngle() const { return m_attributes.m_Angle; }
 
 // For property system:
 void SetTextAngleDegrees( double aOrientation )
 {
 SetTextAngle( EDA_ANGLE( aOrientation, DEGREES_T ) );
 }
 double GetTextAngleDegrees() const { return m_attributes.m_Angle.AsDegrees(); }
 
 void SetItalic( bool aItalic );
 bool IsItalic() const { return m_attributes.m_Italic; }
 
 void SetBold( bool aBold );
 void SetBoldFlag( bool aBold );
 bool IsBold() const { return m_attributes.m_Bold; }
 
 virtual void SetVisible( bool aVisible );
 virtual bool IsVisible() const { return m_attributes.m_Visible; }
 
 void SetMirrored( bool isMirrored );
 bool IsMirrored() const { return m_attributes.m_Mirrored; }
 
 void SetMultilineAllowed( bool aAllow );
 bool IsMultilineAllowed() const { return m_attributes.m_Multiline; }
 
 void SetHorizJustify( GR_TEXT_H_ALIGN_T aType );
 GR_TEXT_H_ALIGN_T GetHorizJustify() const { return m_attributes.m_Halign; };
 
 void SetVertJustify( GR_TEXT_V_ALIGN_T aType );
 GR_TEXT_V_ALIGN_T GetVertJustify() const { return m_attributes.m_Valign; };
 
 void SetKeepUpright( bool aKeepUpright );
 bool IsKeepUpright() const { return m_attributes.m_KeepUpright; }
 
 void FlipHJustify()
 {
 if( GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT )
 SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 else if( GetHorizJustify() == GR_TEXT_H_ALIGN_LEFT )
 SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 }
 
 void SetAttributes( const EDA_TEXT& aSrc, bool aSetPosition = true );
 
 void SwapAttributes( EDA_TEXT& aTradingPartner );
 
 void SwapText( EDA_TEXT& aTradingPartner );
 
 void CopyText( const EDA_TEXT& aSrc );
 
 void SetAttributes( const TEXT_ATTRIBUTES& aTextAttrs ) { m_attributes = aTextAttrs; }
 const TEXT_ATTRIBUTES& GetAttributes() const { return m_attributes; }
 
 bool Replace( const EDA_SEARCH_DATA& aSearchData );
 
 bool IsDefaultFormatting() const;
 
 void SetFont( KIFONT::FONT* aFont );
 KIFONT::FONT* GetFont() const { return m_attributes.m_Font; }
 
 wxString GetFontName() const;
 
 void SetFontIndex( int aIdx );
 int GetFontIndex() const;
 
 void SetLineSpacing( double aLineSpacing );
 double GetLineSpacing() const { return m_attributes.m_LineSpacing; }
 
 void SetTextSize( VECTOR2I aNewSize, bool aEnforceMinTextSize = true );
 VECTOR2I GetTextSize() const { return m_attributes.m_Size; }
 
 void SetTextWidth( int aWidth );
 int GetTextWidth() const { return m_attributes.m_Size.x; }
 
 void SetTextHeight( int aHeight );
 int GetTextHeight() const { return m_attributes.m_Size.y; }
 
 void SetTextColor( const COLOR4D& aColor ) { m_attributes.m_Color = aColor; }
 COLOR4D GetTextColor() const { return m_attributes.m_Color; }
 
 void SetTextPos( const VECTOR2I& aPoint );
 const VECTOR2I& GetTextPos() const { return m_pos; }
 
 void SetTextX( int aX );
 void SetTextY( int aY );
 
 void Offset( const VECTOR2I& aOffset );
 
 void Empty();
 
 static GR_TEXT_H_ALIGN_T MapHorizJustify( int aHorizJustify );
 static GR_TEXT_V_ALIGN_T MapVertJustify( int aVertJustify );
 
 void Print( const RENDER_SETTINGS* aSettings, const VECTOR2I& aOffset, const COLOR4D& aColor,
 OUTLINE_MODE aDisplay_mode = FILLED );
 
 std::shared_ptr<SHAPE_COMPOUND> GetEffectiveTextShape( bool aTriangulate = true,
 const BOX2I& aBBox = BOX2I(),
 const EDA_ANGLE& aAngle = ANGLE_0 ) const;
 
 virtual bool TextHitTest( const VECTOR2I& aPoint, int aAccuracy = 0 ) const;
 
 virtual bool TextHitTest( const BOX2I& aRect, bool aContains, int aAccuracy = 0 ) const;
 
 BOX2I GetTextBox( int aLine = -1 ) const;
 
 int GetInterline() const;
 
 wxString GetTextStyleName() const;
 
 void GetLinePositions( std::vector<VECTOR2I>& aPositions, int aLineCount ) const;
 
 double Levenshtein( const EDA_TEXT& aOther ) const;
 
 
 double Similarity( const EDA_TEXT& aOther ) const;
 
 virtual void Format( OUTPUTFORMATTER* aFormatter, int aNestLevel, int aControlBits ) const;
 
 virtual EDA_ANGLE GetDrawRotation() const { return GetTextAngle(); }
 virtual VECTOR2I GetDrawPos() const { return GetTextPos(); }
 
 virtual void ClearRenderCache();
 virtual void ClearBoundingBoxCache();
 
 std::vector<std::unique_ptr<KIFONT::GLYPH>>*
 GetRenderCache( const KIFONT::FONT* aFont, const wxString& forResolvedText,
 const VECTOR2I& aOffset = { 0, 0 } ) const;
 
 // Support for reading the cache from disk.
 void SetupRenderCache( const wxString& aResolvedText, const EDA_ANGLE& aAngle );
 void AddRenderCacheGlyph( const SHAPE_POLY_SET& aPoly );
 
 int Compare( const EDA_TEXT* aOther ) const;
 
 bool operator==( const EDA_TEXT& aRhs ) const { return Compare( &aRhs ) == 0; }
 bool operator<( const EDA_TEXT& aRhs ) const { return Compare( &aRhs ) < 0; }
 bool operator>( const EDA_TEXT& aRhs ) const { return Compare( &aRhs ) > 0; }
 
 virtual bool HasHyperlink() const { return !m_hyperlink.IsEmpty(); }
 wxString GetHyperlink() const { return m_hyperlink; }
 void SetHyperlink( wxString aLink ) { m_hyperlink = aLink; }
 void RemoveHyperlink() { m_hyperlink = wxEmptyString; }
 
 static bool ValidateHyperlink( const wxString& aURL );
 
 static bool IsGotoPageHref( const wxString& aHref, wxString* aDestination = nullptr );
 
 static wxString GotoPageHref( const wxString& aDestination );
 
protected:
 virtual KIFONT::FONT* getDrawFont() const;
 
 virtual const KIFONT::METRICS& getFontMetrics() const;
 
 virtual void cacheShownText();
 
 void printOneLineOfText( const RENDER_SETTINGS* aSettings, const VECTOR2I& aOffset,
 const COLOR4D& aColor, OUTLINE_MODE aFillMode, const wxString& aText,
 const VECTOR2I& aPos );
 
protected:
 wxString m_hyperlink;
 
private:
 wxString m_text;
 wxString m_shown_text; // Cache of unescaped text for efficient access
 bool m_shown_text_has_text_var_refs;
 
 std::reference_wrapper<const EDA_IU_SCALE> m_IuScale;
 
 mutable wxString m_render_cache_text;
 mutable const KIFONT::FONT* m_render_cache_font;
 mutable EDA_ANGLE m_render_cache_angle;
 mutable VECTOR2I m_render_cache_offset;
 mutable std::vector<std::unique_ptr<KIFONT::GLYPH>> m_render_cache;
 
 mutable bool m_bounding_box_cache_valid;
 mutable VECTOR2I m_bounding_box_cache_pos;
 mutable int m_bounding_box_cache_line;
 mutable BOX2I m_bounding_box_cache;
 
 TEXT_ATTRIBUTES m_attributes;
 VECTOR2I m_pos;
};
 
 
extern std::ostream& operator<<( std::ostream& aStream, const EDA_TEXT& aAttributes );
 
 
template<>
struct std::hash<EDA_TEXT>
{
 std::size_t operator()( const EDA_TEXT& aText ) const
 {
 return hash_val( aText.GetText(), aText.GetAttributes(), aText.GetTextPos().x,
 aText.GetTextPos().y );
 }
};
 
#endif // EDA_TEXT_H_