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 The 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef EDA_TEXT_H_
#define EDA_TEXT_H_
 
#include <memory>
#include <mutex>
#include <vector>
 
#include <eda_search_data.h>
#include <font/glyph.h>
#include <font/text_attributes.h>
#include <api/serializable.h>
#include <text_var_dependency.h>
 
 
class OUTPUTFORMATTER;
class SHAPE_COMPOUND;
class SHAPE_POLY_SET;
struct EDA_IU_SCALE;
 
 
struct EDA_TEXT_RENDER_CACHE_DATA
{
    wxString                                    text;
    const KIFONT::FONT*                         font = nullptr;
    EDA_ANGLE                                   angle;
    VECTOR2I                                    offset;
    bool                                        mirrored = false;
    std::vector<std::unique_ptr<KIFONT::GLYPH>> glyphs;
};
 
 
// 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;
 

#define DEFAULT_SIZE_TEXT   50     // default text height (in mils, i.e. 1/1000")
 

class EDA_TEXT : public SERIALIZABLE
{
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 );
 
    void Serialize( google::protobuf::Any &aContainer ) const override;
    bool Deserialize( const google::protobuf::Any &aContainer ) override;
 
    void Serialize( google::protobuf::Any &aContainer, const EDA_IU_SCALE& aScale ) const;
    bool Deserialize( const google::protobuf::Any &aContainer, const EDA_IU_SCALE& aScale );

    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; }

    const std::vector<TEXT_VAR_REF_KEY>& GetTextVarReferences() const;
 
    virtual void SetText( const wxString& aText );
 
    wxString EvaluateText( const wxString& aText ) const;

    virtual void SetTextThickness( int aWidth );
    virtual int  GetTextThickness() const { return m_attributes.m_StrokeWidth; };
 
    int GetTextThicknessProperty() const
    {
        if( GetAutoThickness() )
            return GetEffectiveTextPenWidth();
        else
            return GetTextThickness();
    }
 
    void SetAutoThickness( bool aAuto );
    bool GetAutoThickness() const               { return GetTextThickness() == 0; };

    int GetEffectiveTextPenWidth( int aDefaultPenWidth = 0 ) const;
 
    virtual void      SetTextAngle( const EDA_ANGLE& aAngle );
    virtual 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 );

    void SetItalicFlag( 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_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; }
 
    void SetUnresolvedFontName( const wxString& aFontName ) { m_unresolvedFontName = aFontName; }
    bool ResolveFont( const std::vector<wxString>* aEmbeddedFonts );
 
    wxString GetFontName() const;
 
    void SetFontProp( const wxString& aFontName );
    wxString GetFontProp() const;
 
    void SetLineSpacing( double aLineSpacing );
    double GetLineSpacing() const               { return m_attributes.m_LineSpacing; }
 
    virtual void     SetTextSize( VECTOR2I aNewSize, bool aEnforceMinTextSize = true );
    virtual VECTOR2I GetTextSize() const { return m_attributes.m_Size; }
 
    virtual void SetTextWidth( int aWidth );
    virtual int  GetTextWidth() const { return GetTextSize().x; }
 
    virtual void SetTextHeight( int aHeight );
    virtual int  GetTextHeight() const { return GetTextSize().y; }
 
    void SetTextColor( const COLOR4D& aColor )  { m_attributes.m_Color = aColor; }
    COLOR4D GetTextColor() const                { return m_attributes.m_Color; }
 
    virtual void     SetTextPos( const VECTOR2I& aPoint );
    virtual VECTOR2I GetTextPos() const { return m_pos; }
 
    virtual void SetTextX( int aX );
    virtual void SetTextY( int aY );
 
    inline void SetActiveUrl( const wxString& aUrl ) const { m_activeUrl = aUrl; }
 
    virtual 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 );

    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( const RENDER_SETTINGS* aSettings, int aLine = -1 ) const;

    int GetInterline( const RENDER_SETTINGS* aSettings ) const;

    wxString GetTextStyleName() const;

    void GetLinePositions( const RENDER_SETTINGS* aSettings, 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 aControlBits ) const;
 
    virtual EDA_ANGLE GetDrawRotation() const               { return GetTextAngle(); }
    virtual VECTOR2I GetDrawPos() const                     { return GetTextPos(); }
 
    virtual KIFONT::FONT* GetDrawFont( const RENDER_SETTINGS* aSettings ) const;
 
    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 KIFONT::FONT* aFont,
                           const EDA_ANGLE& aAngle, const VECTOR2I& aOffset );
    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 const KIFONT::METRICS& getFontMetrics() const;
 
    virtual void cacheShownText();

    void printOneLineOfText( const RENDER_SETTINGS* aSettings, const VECTOR2I& aOffset,
                             const COLOR4D& aColor, const wxString& aText, const VECTOR2I& aPos );
 
    bool containsURL() const;
 
protected:
    wxString m_hyperlink;
 
    mutable wxString m_activeUrl;
 
private:
    wxString         m_text;
    wxString         m_shown_text;           // Cache of unescaped text for efficient access
    bool             m_shown_text_has_text_var_refs = false;
 
    // Populated eagerly in cacheShownText() so reads from concurrent workers
    // (connection graph, API server, painters) see immutable storage without a
    // lock. Extracted from raw m_text (not m_shown_text) so backslash-escaped
    // ${...} literals do not fabricate dependency edges.
    std::vector<TEXT_VAR_REF_KEY> m_text_var_refs;
 
    std::reference_wrapper<const EDA_IU_SCALE>          m_IuScale;
 
    mutable std::unique_ptr<EDA_TEXT_RENDER_CACHE_DATA> m_render_cache;
 
    struct BBOX_CACHE_ENTRY
    {
        VECTOR2I m_pos;
        BOX2I    m_bbox;
    };
 
    mutable std::map<int, BBOX_CACHE_ENTRY> m_bbox_cache;
    mutable std::mutex m_bbox_cacheMutex;
 
    TEXT_ATTRIBUTES  m_attributes;
    wxString         m_unresolvedFontName;
    VECTOR2I         m_pos;
    bool             m_visible;                 // For SCH_FIELDs and PCB_FIELDs
};
 
 
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_