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-2021 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_rect.h>

class OUTPUTFORMATTER;
class SHAPE_COMPOUND;
class SHAPE_POLY_SET;
class wxFindReplaceData;


struct TSEGM_2_POLY_PRMS
{
 int m_textWidth;
 int m_error;
 SHAPE_POLY_SET* m_cornerBuffer;
};


extern void addTextSegmToPoly( int x0, int y0, int xf, int yf, void* aData );


namespace KIGFX
{
 class RENDER_SETTINGS;
 class COLOR4D;
}

using KIGFX::RENDER_SETTINGS;
using KIGFX::COLOR4D;

#define TEXT_ANGLE_HORIZ 0
#define TEXT_ANGLE_VERT 900

// 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)


// Graphic Text justify:
// Values -1,0,1 are used in computations, do not change them
enum EDA_TEXT_HJUSTIFY_T {
 GR_TEXT_HJUSTIFY_LEFT = -1,
 GR_TEXT_HJUSTIFY_CENTER = 0,
 GR_TEXT_HJUSTIFY_RIGHT = 1
};


enum EDA_TEXT_VJUSTIFY_T {
 GR_TEXT_VJUSTIFY_TOP = -1,
 GR_TEXT_VJUSTIFY_CENTER = 0,
 GR_TEXT_VJUSTIFY_BOTTOM = 1
};


#define DEFAULT_SIZE_TEXT 50 // default text height (in mils, i.e. 1/1000")
#define DIM_ANCRE_TEXTE 2 // Anchor size for text


struct TEXT_EFFECTS
{
 TEXT_EFFECTS( int aSetOfBits = 0 ) :
 bits( aSetOfBits ),
 hjustify( GR_TEXT_HJUSTIFY_CENTER ),
 vjustify( GR_TEXT_VJUSTIFY_CENTER ),
 penwidth( 0 ),
 angle( 0.0 )
 {}

 int bits; 
 signed char hjustify; 
 signed char vjustify; 
 wxSize size;
 int penwidth;
 double angle; 
 wxPoint pos;

 void Bit( int aBit, bool aValue ) { aValue ? bits |= (1<<aBit) : bits &= ~(1<<aBit); }
 bool Bit( int aBit ) const { return bits & (1<<aBit); }
};


class EDA_TEXT
{
public:
 EDA_TEXT( const wxString& text = wxEmptyString );

 EDA_TEXT( const EDA_TEXT& aText );

 virtual ~EDA_TEXT();

 virtual const wxString& GetText() const { return m_text; }

 virtual wxString GetShownText( int aDepth = 0 ) const { return m_shown_text; }

 wxString ShortenedShownText() const;

 bool HasTextVars() const { return m_shown_text_has_text_var_refs; }

 virtual void SetText( const wxString& aText );

 void SetTextThickness( int aWidth ) { m_e.penwidth = aWidth; };
 int GetTextThickness() const { return m_e.penwidth; };

 int GetEffectiveTextPenWidth( int aDefaultWidth = 0 ) const;

 virtual void SetTextAngle( double aAngle )
 {
 // Higher level classes may be more restrictive than this by overloading
 // SetTextAngle() or merely calling EDA_TEXT::SetTextAngle() after clamping
 // aAngle before calling this lowest inline accessor.
 m_e.angle = aAngle;
 }
 double GetTextAngle() const { return m_e.angle; }

 double GetTextAngleDegrees() const { return GetTextAngle() / 10.0; }
 double GetTextAngleRadians() const { return GetTextAngle() * M_PI/1800; }

 void SetItalic( bool isItalic ) { m_e.Bit( TE_ITALIC, isItalic ); }
 bool IsItalic() const { return m_e.Bit( TE_ITALIC ); }

 void SetBold( bool aBold ) { m_e.Bit( TE_BOLD, aBold); }
 bool IsBold() const { return m_e.Bit( TE_BOLD ); }

 virtual void SetVisible( bool aVisible ) { m_e.Bit( TE_VISIBLE, aVisible ); }
 virtual bool IsVisible() const { return m_e.Bit( TE_VISIBLE ); }

 void SetMirrored( bool isMirrored ) { m_e.Bit( TE_MIRROR, isMirrored ); }
 bool IsMirrored() const { return m_e.Bit( TE_MIRROR ); }

 void SetMultilineAllowed( bool aAllow ) { m_e.Bit( TE_MULTILINE, aAllow ); }
 bool IsMultilineAllowed() const { return m_e.Bit( TE_MULTILINE ); }

 EDA_TEXT_HJUSTIFY_T GetHorizJustify() const { return EDA_TEXT_HJUSTIFY_T( m_e.hjustify ); };
 EDA_TEXT_VJUSTIFY_T GetVertJustify() const { return EDA_TEXT_VJUSTIFY_T( m_e.vjustify ); };

 void SetHorizJustify( EDA_TEXT_HJUSTIFY_T aType ) { m_e.hjustify = aType; };
 void SetVertJustify( EDA_TEXT_VJUSTIFY_T aType ) { m_e.vjustify = aType; };

 void SetEffects( const EDA_TEXT& aSrc );

 void SwapEffects( EDA_TEXT& aTradingPartner );

 void SwapText( EDA_TEXT& aTradingPartner );

 void CopyText( const EDA_TEXT& aSrc );

 bool Replace( const wxFindReplaceData& aSearchData );

 bool IsDefaultFormatting() const;

 void SetTextSize( const wxSize& aNewSize ) { m_e.size = aNewSize; }
 const wxSize& GetTextSize() const { return m_e.size; }

 void SetTextWidth( int aWidth ) { m_e.size.x = aWidth; }
 int GetTextWidth() const { return m_e.size.x; }

 void SetTextHeight( int aHeight ) { m_e.size.y = aHeight; }
 int GetTextHeight() const { return m_e.size.y; }

 void SetTextPos( const wxPoint& aPoint ) { m_e.pos = aPoint; }
 const wxPoint& GetTextPos() const { return m_e.pos; }

 void SetTextX( int aX ) { m_e.pos.x = aX; }
 void SetTextY( int aY ) { m_e.pos.y = aY; }

 void Offset( const wxPoint& aOffset ) { m_e.pos += aOffset; }

 void Empty() { m_text.Empty(); }

 static EDA_TEXT_HJUSTIFY_T MapHorizJustify( int aHorizJustify );

 static EDA_TEXT_VJUSTIFY_T MapVertJustify( int aVertJustify );

 void Print( const RENDER_SETTINGS* aSettings, const wxPoint& aOffset,
 const COLOR4D& aColor, OUTLINE_MODE aDisplay_mode = FILLED );

 std::vector<wxPoint> TransformToSegmentList() const;

 void TransformBoundingBoxWithClearanceToPolygon( SHAPE_POLY_SET* aCornerBuffer,
 int aClearanceValue ) const;

 std::shared_ptr<SHAPE_COMPOUND> GetEffectiveTextShape() const;

 virtual bool TextHitTest( const wxPoint& aPoint, int aAccuracy = 0 ) const;

 virtual bool TextHitTest( const EDA_RECT& aRect, bool aContains, int aAccuracy = 0 ) const;

 int LenSize( const wxString& aLine, int aThickness ) const;

 EDA_RECT GetTextBox( int aLine = -1, bool aInvertY = false ) const;

 int GetInterline() const;

 wxString GetTextStyleName() const;

 void GetLinePositions( std::vector<wxPoint>& aPositions, int aLineCount ) const;

 virtual void Format( OUTPUTFORMATTER* aFormatter, int aNestLevel, int aControlBits ) const;

 virtual double GetDrawRotation() const { return GetTextAngle(); }
 virtual wxPoint GetDrawPos() const { return GetTextPos(); }
 virtual EDA_TEXT_HJUSTIFY_T GetDrawHorizJustify() const { return GetHorizJustify(); };
 virtual EDA_TEXT_VJUSTIFY_T GetDrawVertJustify() const { return GetVertJustify(); };

 int Compare( const EDA_TEXT* aOther ) const;

private:
 void cacheShownText();

 void printOneLineOfText( const RENDER_SETTINGS* aSettings, const wxPoint& aOffset,
 const COLOR4D& aColor, OUTLINE_MODE aFillMode, const wxString& aText,
 const wxPoint& aPos );

 wxString m_text;
 wxString m_shown_text; // Cache of unescaped text for efficient access
 bool m_shown_text_has_text_var_refs;

 TEXT_EFFECTS m_e; // Private bitflags for text styling. API above
 // provides accessor funcs.
 enum TE_FLAGS {
 TE_MIRROR,
 TE_ITALIC,
 TE_BOLD,
 TE_MULTILINE,
 TE_VISIBLE,
 };
};


#endif // EDA_TEXT_H_