KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_textbox.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
19 * or you may search the http://www.gnu.org website for the version 2 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24#include <advanced_config.h>
25#include <pcb_edit_frame.h>
26#include <base_units.h>
27#include <bitmaps.h>
28#include <board.h>
30#include <footprint.h>
31#include <pcb_textbox.h>
32#include <pcb_painter.h>
33#include <trigo.h>
34#include <string_utils.h>
36#include <geometry/shape_rect.h>
38#include <callback_gal.h>
40#include <macros.h>
41#include <core/ignore.h>
42#include <api/api_enums.h>
43#include <api/api_utils.h>
44#include <api/board/board_types.pb.h>
45
46
48 PCB_SHAPE( aParent, aType, SHAPE_T::RECTANGLE ),
50 m_borderEnabled( true )
51{
54 SetMultilineAllowed( true );
55
56 int defaultMargin = GetLegacyTextMargin();
57 m_marginLeft = defaultMargin;
58 m_marginTop = defaultMargin;
59 m_marginRight = defaultMargin;
60 m_marginBottom = defaultMargin;
61}
62
63
67
68
69void PCB_TEXTBOX::CopyFrom( const BOARD_ITEM* aOther )
70{
71 wxCHECK( aOther && aOther->Type() == PCB_TEXTBOX_T, /* void */ );
72 *this = *static_cast<const PCB_TEXTBOX*>( aOther );
73}
74
75
76void PCB_TEXTBOX::Serialize( google::protobuf::Any &aContainer ) const
77{
78 using namespace kiapi::common::types;
79 using namespace kiapi::board;
80 types::BoardTextBox boardText;
82 boardText.mutable_id()->set_value( m_Uuid.AsStdString() );
83 boardText.set_locked( IsLocked() ? LockedState::LS_LOCKED : LockedState::LS_UNLOCKED );
84
85 TextBox& text = *boardText.mutable_textbox();
86
87 kiapi::common::PackVector2( *text.mutable_top_left(), GetPosition() );
88 kiapi::common::PackVector2( *text.mutable_bottom_right(), GetEnd() );
89 text.set_text( GetText().ToStdString() );
90 //text.set_hyperlink( GetHyperlink().ToStdString() );
91
92 TextAttributes* attrs = text.mutable_attributes();
93
94 if( GetFont() )
95 attrs->set_font_name( GetFont()->GetName().ToStdString() );
96
97 attrs->set_horizontal_alignment(
99
100 attrs->set_vertical_alignment(
102
103 attrs->mutable_angle()->set_value_degrees( GetTextAngleDegrees() );
104 attrs->set_line_spacing( GetLineSpacing() );
105 attrs->mutable_stroke_width()->set_value_nm( GetTextThickness() );
106 attrs->set_italic( IsItalic() );
107 attrs->set_bold( IsBold() );
108 attrs->set_underlined( GetAttributes().m_Underlined );
109 attrs->set_mirrored( IsMirrored() );
110 attrs->set_multiline( IsMultilineAllowed() );
111 attrs->set_keep_upright( IsKeepUpright() );
112 kiapi::common::PackVector2( *attrs->mutable_size(), GetTextSize() );
113
114 aContainer.PackFrom( boardText );
115}
116
117
118bool PCB_TEXTBOX::Deserialize( const google::protobuf::Any &aContainer )
119{
120 using namespace kiapi::board;
121 types::BoardTextBox boardText;
122
123 if( !aContainer.UnpackTo( &boardText ) )
124 return false;
125
126 const_cast<KIID&>( m_Uuid ) = KIID( boardText.id().value() );
128 SetLocked( boardText.locked() == kiapi::common::types::LockedState::LS_LOCKED );
129
130 const kiapi::common::types::TextBox& text = boardText.textbox();
131
133 SetEnd( kiapi::common::UnpackVector2( text.bottom_right() ) );
134 SetText( wxString( text.text().c_str(), wxConvUTF8 ) );
135 //SetHyperlink( wxString::FromUTF8( text.hyperlink() );
136
137 if( text.has_attributes() )
138 {
140
141 attrs.m_Bold = text.attributes().bold();
142 attrs.m_Italic = text.attributes().italic();
143 attrs.m_Underlined = text.attributes().underlined();
144 attrs.m_Mirrored = text.attributes().mirrored();
145 attrs.m_Multiline = text.attributes().multiline();
146 attrs.m_KeepUpright = text.attributes().keep_upright();
147 attrs.m_Size = kiapi::common::UnpackVector2( text.attributes().size() );
148
149 if( !text.attributes().font_name().empty() )
150 {
152 wxString( text.attributes().font_name().c_str(), wxConvUTF8 ), attrs.m_Bold,
153 attrs.m_Italic );
154 }
155
156 attrs.m_Angle = EDA_ANGLE( text.attributes().angle().value_degrees(), DEGREES_T );
157 attrs.m_LineSpacing = text.attributes().line_spacing();
158 attrs.m_StrokeWidth = text.attributes().stroke_width().value_nm();
159 attrs.m_Halign =
161 text.attributes().horizontal_alignment() );
162
164 text.attributes().vertical_alignment() );
165
166 SetAttributes( attrs );
167 }
168
169 return true;
170}
171
172
174{
176
177 SetTextSize( settings.GetTextSize( GetLayer() ) );
179 SetItalic( settings.GetTextItalic( GetLayer() ) );
180 SetKeepUpright( settings.GetTextUpright( GetLayer() ) );
181
182 if( BOARD* board = GetBoard() )
183 SetMirrored( board->IsBackLayer( GetLayer() ) );
184 else
186}
187
188
190{
191 return KiROUND( GetStroke().GetWidth() / 2.0 ) + KiROUND( GetTextSize().y * 0.75 );
192}
193
194
196{
197 EDA_ANGLE rotation = GetDrawRotation();
198
199 if( rotation == ANGLE_90 )
200 return VECTOR2I( GetStartX(), GetEndY() );
201 else if( rotation == ANGLE_180 )
202 return GetEnd();
203 else if( rotation == ANGLE_270 )
204 return VECTOR2I( GetEndX(), GetStartY() );
205 else
206 return GetStart();
207}
208
209
211{
212 EDA_ANGLE rotation = GetDrawRotation();
213
214 if( rotation == ANGLE_90 )
215 return VECTOR2I( GetEndX(), GetStartY() );
216 else if( rotation == ANGLE_180 )
217 return GetStart();
218 else if( rotation == ANGLE_270 )
219 return VECTOR2I( GetStartX(), GetEndY() );
220 else
221 return GetEnd();
222}
223
224
225void PCB_TEXTBOX::SetTop( int aVal )
226{
227 EDA_ANGLE rotation = GetDrawRotation();
228
229 if( rotation == ANGLE_90 || rotation == ANGLE_180 )
230 SetEndY( aVal );
231 else
232 SetStartY( aVal );
233}
234
235
237{
238 EDA_ANGLE rotation = GetDrawRotation();
239
240 if( rotation == ANGLE_90 || rotation == ANGLE_180 )
241 SetStartY( aVal );
242 else
243 SetEndY( aVal );
244}
245
246
247void PCB_TEXTBOX::SetLeft( int aVal )
248{
249 EDA_ANGLE rotation = GetDrawRotation();
250
251 if( rotation == ANGLE_180 || rotation == ANGLE_270 )
252 SetEndX( aVal );
253 else
254 SetStartX( aVal );
255}
256
257
258void PCB_TEXTBOX::SetRight( int aVal )
259{
260 EDA_ANGLE rotation = GetDrawRotation();
261
262 if( rotation == ANGLE_180 || rotation == ANGLE_270 )
263 SetStartX( aVal );
264 else
265 SetEndX( aVal );
266}
267
268
270{
271 EDA_ANGLE delta = aAngle.Normalized() - GetTextAngle();
273}
274
275
277{
278 return GetDrawPos( false );
279}
280
281
282VECTOR2I PCB_TEXTBOX::GetDrawPos( bool aIsFlipped ) const
283{
284 EDA_ANGLE drawAngle = GetDrawRotation();
285 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
286 GR_TEXT_H_ALIGN_T horizontalAlignment = GetHorizJustify();
287 GR_TEXT_V_ALIGN_T verticalAlignment = GetVertJustify();
288 VECTOR2I textAnchor;
289 VECTOR2I offset;
290
291 // Calculate midpoints
292 VECTOR2I midTop = ( corners[0] + corners[1] ) / 2;
293 VECTOR2I midBottom = ( corners[3] + corners[2] ) / 2;
294 VECTOR2I midLeft = ( corners[0] + corners[3] ) / 2;
295 VECTOR2I midRight = ( corners[1] + corners[2] ) / 2;
296 VECTOR2I center = ( corners[0] + corners[1] + corners[2] + corners[3] ) / 4;
297
298 if( IsMirrored() != aIsFlipped )
299 {
300 switch( GetHorizJustify() )
301 {
302 case GR_TEXT_H_ALIGN_LEFT: horizontalAlignment = GR_TEXT_H_ALIGN_RIGHT; break;
303 case GR_TEXT_H_ALIGN_CENTER: horizontalAlignment = GR_TEXT_H_ALIGN_CENTER; break;
304 case GR_TEXT_H_ALIGN_RIGHT: horizontalAlignment = GR_TEXT_H_ALIGN_LEFT; break;
306 horizontalAlignment = GR_TEXT_H_ALIGN_INDETERMINATE;
307 break;
308 }
309 }
310
311 wxASSERT_MSG(
312 horizontalAlignment != GR_TEXT_H_ALIGN_INDETERMINATE
313 && verticalAlignment != GR_TEXT_V_ALIGN_INDETERMINATE,
314 wxS( "Indeterminate state legal only in dialogs. Horizontal and vertical alignment "
315 "must be set before calling PCB_TEXTBOX::GetDrawPos." ) );
316
317 if( horizontalAlignment == GR_TEXT_H_ALIGN_INDETERMINATE
318 || verticalAlignment == GR_TEXT_V_ALIGN_INDETERMINATE )
319 {
320 return center;
321 }
322
323 if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
324 {
325 textAnchor = corners[0];
326 }
327 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
328 && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
329 {
330 textAnchor = midTop;
331 }
332 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
333 && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
334 {
335 textAnchor = corners[1];
336 }
337 else if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT
338 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
339 {
340 textAnchor = midLeft;
341 }
342 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
343 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
344 {
345 textAnchor = center;
346 }
347 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
348 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
349 {
350 textAnchor = midRight;
351 }
352 else if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT
353 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
354 {
355 textAnchor = corners[3];
356 }
357 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
358 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
359 {
360 textAnchor = midBottom;
361 }
362 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
363 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
364 {
365 textAnchor = corners[2];
366 }
367
368 int marginLeft = GetMarginLeft();
369 int marginRight = GetMarginRight();
370 int marginTop = GetMarginTop();
371 int marginBottom = GetMarginBottom();
372
373 if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT )
374 offset.x = marginLeft;
375 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT )
376 offset.x = -marginRight;
377
378 if( verticalAlignment == GR_TEXT_V_ALIGN_TOP )
379 offset.y = marginTop;
380 else if( verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
381 offset.y = -marginBottom;
382
383 RotatePoint( offset, GetDrawRotation() );
384 return textAnchor + offset;
385}
386
387
388double PCB_TEXTBOX::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
389{
390 KIGFX::PCB_PAINTER& painter = static_cast<KIGFX::PCB_PAINTER&>( *aView->GetPainter() );
391 KIGFX::PCB_RENDER_SETTINGS& renderSettings = *painter.GetSettings();
392
393 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
394 {
395 // Hide shadow if the main layer is not shown
396 if( !aView->IsLayerVisible( m_layer ) )
397 return LOD_HIDE;
398
399 // Hide shadow on dimmed tracks
400 if( renderSettings.GetHighContrast() )
401 {
402 if( m_layer != renderSettings.GetPrimaryHighContrastLayer() )
403 return LOD_HIDE;
404 }
405 }
406
407 return LOD_SHOW;
408}
409
410
411std::vector<int> PCB_TEXTBOX::ViewGetLayers() const
412{
415
416 return { GetLayer() };
417}
418
419
420wxString PCB_TEXTBOX::GetShownText( bool aAllowExtraText, int aDepth ) const
421{
422 const FOOTPRINT* parentFootprint = GetParentFootprint();
423 const BOARD* board = GetBoard();
424
425 std::function<bool( wxString* )> resolver = [&]( wxString* token ) -> bool
426 {
427 if( token->IsSameAs( wxT( "LAYER" ) ) )
428 {
429 *token = GetLayerName();
430 return true;
431 }
432
433 if( parentFootprint && parentFootprint->ResolveTextVar( token, aDepth + 1 ) )
434 return true;
435
436 if( board->ResolveTextVar( token, aDepth + 1 ) )
437 return true;
438
439 return false;
440 };
441
442 wxString text = EDA_TEXT::GetShownText( aAllowExtraText, aDepth );
443
444 if( HasTextVars() )
445 {
446 if( aDepth < ADVANCED_CFG::GetCfg().m_ResolveTextRecursionDepth )
448 }
449
450 if( text.Contains( wxT( "@{" ) ) )
452
453 KIFONT::FONT* font = GetDrawFont( nullptr );
454 EDA_ANGLE drawAngle = GetDrawRotation();
455 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
456 int colWidth = ( corners[1] - corners[0] ).EuclideanNorm();
457
458 if( GetTextAngle().IsHorizontal() )
459 colWidth -= ( GetMarginLeft() + GetMarginRight() );
460 else
461 colWidth -= ( GetMarginTop() + GetMarginBottom() );
462
463 font->LinebreakText( text, colWidth, GetTextSize(), GetTextThickness(), IsBold(), IsItalic() );
464
465 return text;
466}
467
468
469bool PCB_TEXTBOX::Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const
470{
471 return BOARD_ITEM::Matches( UnescapeString( GetText() ), aSearchData );
472}
473
474
475void PCB_TEXTBOX::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
476{
477 // Don't use GetShownText() here; we want to show the user the variable references
478 aList.emplace_back( _( "Text Box" ), KIUI::EllipsizeStatusText( aFrame, GetText() ) );
479
480 if( aFrame->GetName() == PCB_EDIT_FRAME_NAME && IsLocked() )
481 aList.emplace_back( _( "Status" ), _( "Locked" ) );
482
483 aList.emplace_back( _( "Layer" ), GetLayerName() );
484 aList.emplace_back( _( "Mirror" ), IsMirrored() ? _( "Yes" ) : _( "No" ) );
485 aList.emplace_back( _( "Angle" ), wxString::Format( "%g", GetTextAngle().AsDegrees() ) );
486
487 aList.emplace_back( _( "Font" ), GetFont() ? GetFont()->GetName() : _( "Default" ) );
488
489 if( GetTextThickness() )
490 aList.emplace_back( _( "Text Thickness" ), aFrame->MessageTextFromValue( GetEffectiveTextPenWidth() ) );
491 else
492 aList.emplace_back( _( "Text Thickness" ), _( "Auto" ) );
493
494 aList.emplace_back( _( "Text Width" ), aFrame->MessageTextFromValue( GetTextWidth() ) );
495 aList.emplace_back( _( "Text Height" ), aFrame->MessageTextFromValue( GetTextHeight() ) );
496
497 aList.emplace_back( _( "Box Width" ),
498 aFrame->MessageTextFromValue( std::abs( GetEnd().x - GetStart().x ) ) );
499
500 aList.emplace_back( _( "Box Height" ),
501 aFrame->MessageTextFromValue( std::abs( GetEnd().y - GetStart().y ) ));
502
503 m_stroke.GetMsgPanelInfo( aFrame, aList );
504}
505
506
507void PCB_TEXTBOX::Move( const VECTOR2I& aMoveVector )
508{
509 PCB_SHAPE::Move( aMoveVector );
510 EDA_TEXT::Offset( aMoveVector );
511}
512
513
514void PCB_TEXTBOX::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
515{
516 PCB_SHAPE::Rotate( aRotCentre, aAngle );
518
519 if( GetTextAngle().IsCardinal() && GetShape() != SHAPE_T::RECTANGLE )
520 {
521 // To convert the polygon to its equivalent rectangle, we use GetCornersInSequence( drawAngle )
522 // but this method uses the polygon bounding box.
523 // set the line thickness to 0 to get the actual rectangle corner
524 int lineWidth = GetWidth();
525 SetWidth( 0 );
526 EDA_ANGLE drawAngle = GetDrawRotation();
527 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
528 SetWidth( lineWidth );
529 VECTOR2I diag = corners[2] - corners[0];
530 EDA_ANGLE angle = GetTextAngle();
531
533 SetStart( corners[0] );
534
535 if( angle == ANGLE_90 )
536 SetEnd( VECTOR2I( corners[0].x + abs( diag.x ), corners[0].y - abs( diag.y ) ) );
537 else if( angle == ANGLE_180 )
538 SetEnd( VECTOR2I( corners[0].x - abs( diag.x ), corners[0].y - abs( diag.y ) ) );
539 else if( angle == ANGLE_270 )
540 SetEnd( VECTOR2I( corners[0].x - abs( diag.x ), corners[0].y + abs( diag.y ) ) );
541 else
542 SetEnd( VECTOR2I( corners[0].x + abs( diag.x ), corners[0].y + abs( diag.y ) ) );
543 }
544}
545
546
547void PCB_TEXTBOX::Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
548{
549 // the position and angle are mirrored, but not the text (or its justification)
550 PCB_SHAPE::Mirror( aCentre, aFlipDirection );
551
552 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
554 else
556}
557
558
559void PCB_TEXTBOX::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
560{
561 PCB_SHAPE::Flip( aCentre, aFlipDirection );
562
564
565 if( IsSideSpecific() )
567}
568
569
570bool PCB_TEXTBOX::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
571{
572 BOX2I rect = GetBoundingBox();
573
574 rect.Inflate( aAccuracy );
575
576 return rect.Contains( aPosition );
577}
578
579
580bool PCB_TEXTBOX::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
581{
582 BOX2I rect = aRect;
583
584 rect.Inflate( aAccuracy );
585
586 if( aContained )
587 return rect.Contains( GetBoundingBox() );
588
589 return rect.Intersects( GetBoundingBox() );
590}
591
592
593bool PCB_TEXTBOX::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
594{
595 return PCB_SHAPE::HitTest( aPoly, aContained );
596}
597
598
599wxString PCB_TEXTBOX::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
600{
601 return wxString::Format( _( "PCB text box '%s' on %s" ),
602 aFull ? GetShownText( false ) : KIUI::EllipsizeMenuText( GetText() ),
603 GetLayerName() );
604}
605
606
611
612
614{
615 return new PCB_TEXTBOX( *this );
616}
617
618
620{
621 wxASSERT( aImage->Type() == PCB_TEXTBOX_T );
622
623 std::swap( *((PCB_TEXTBOX*) this), *((PCB_TEXTBOX*) aImage) );
624}
625
626
627std::shared_ptr<SHAPE> PCB_TEXTBOX::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING aFlash ) const
628{
629 std::shared_ptr<SHAPE_COMPOUND> shape = GetEffectiveTextShape();
630
631 if( PCB_SHAPE::GetStroke().GetWidth() >= 0 )
632 shape->AddShape( PCB_SHAPE::GetEffectiveShape( aLayer, aFlash ) );
633
634 return shape;
635}
636
637
638void PCB_TEXTBOX::TransformTextToPolySet( SHAPE_POLY_SET& aBuffer, int aClearance, int aMaxError,
639 ERROR_LOC aErrorLoc ) const
640{
642 KIFONT::FONT* font = GetDrawFont( nullptr );
643 int penWidth = GetEffectiveTextPenWidth();
645 wxString shownText = GetShownText( true );
646
647 // The polygonal shape of a text can have many basic shapes, so combining these shapes can
648 // be very useful to create a final shape with a lot less vertices to speedup calculations.
649 // Simplify shapes is not usually always efficient, but in this case it is.
650 SHAPE_POLY_SET textShape;
651
652 CALLBACK_GAL callback_gal( empty_opts,
653 // Stroke callback
654 [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2 )
655 {
656 TransformOvalToPolygon( textShape, aPt1, aPt2, penWidth, aMaxError, aErrorLoc );
657 },
658 // Triangulation callback
659 [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2, const VECTOR2I& aPt3 )
660 {
661 textShape.NewOutline();
662
663 for( const VECTOR2I& point : { aPt1, aPt2, aPt3 } )
664 textShape.Append( point.x, point.y );
665 } );
666
667 if( auto* cache = GetRenderCache( font, shownText ) )
668 callback_gal.DrawGlyphs( *cache );
669 else
670 font->Draw( &callback_gal, shownText, GetDrawPos(), attrs, GetFontMetrics() );
671
672 textShape.Simplify();
673
674 if( IsKnockout() )
675 {
676 SHAPE_POLY_SET finalPoly;
677
678 TransformShapeToPolygon( finalPoly, GetLayer(), aClearance, aMaxError, aErrorLoc );
679 finalPoly.BooleanSubtract( textShape );
680
681 aBuffer.Append( finalPoly );
682 }
683 else
684 {
685 if( aClearance > 0 || aErrorLoc == ERROR_OUTSIDE )
686 {
687 if( aErrorLoc == ERROR_OUTSIDE )
688 aClearance += aMaxError;
689
690 textShape.Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError, true );
691 }
692
693 aBuffer.Append( textShape );
694 }
695}
696
697
699 int aClearance, int aMaxError, ERROR_LOC aErrorLoc,
700 bool aIgnoreLineWidth ) const
701{
702 // Don't use PCB_SHAPE::TransformShapeToPolygon. We want to treat the textbox as filled even
703 // if there's no background colour.
704
705 int width = GetWidth() + ( 2 * aClearance );
706
708 {
709 std::vector<VECTOR2I> pts = GetRectCorners();
710
711 aBuffer.NewOutline();
712
713 for( const VECTOR2I& pt : pts )
714 aBuffer.Append( pt );
715
716 if( m_borderEnabled && width > 0 )
717 {
718 // Add in segments
719 TransformOvalToPolygon( aBuffer, pts[0], pts[1], width, aMaxError, aErrorLoc );
720 TransformOvalToPolygon( aBuffer, pts[1], pts[2], width, aMaxError, aErrorLoc );
721 TransformOvalToPolygon( aBuffer, pts[2], pts[3], width, aMaxError, aErrorLoc );
722 TransformOvalToPolygon( aBuffer, pts[3], pts[0], width, aMaxError, aErrorLoc );
723 }
724 }
725 else if( GetShape() == SHAPE_T::POLY ) // Non-cardinally-rotated rect
726 {
727 aBuffer.NewOutline();
728
729 const SHAPE_LINE_CHAIN& poly = m_poly.Outline( 0 );
730
731 for( int ii = 0; ii < poly.PointCount(); ++ii )
732 aBuffer.Append( poly.GetPoint( ii ) );
733
734 if( m_borderEnabled && width > 0 )
735 {
736 for( int ii = 0; ii < poly.SegmentCount(); ++ii )
737 {
738 const SEG& seg = poly.GetSegment( ii );
739 TransformOvalToPolygon( aBuffer, seg.A, seg.B, width, aMaxError, aErrorLoc );
740 }
741 }
742 }
743}
744
745
747{
748 return m_borderEnabled;
749}
750
751
753{
754 m_borderEnabled = enabled;
755}
756
757
758void PCB_TEXTBOX::SetBorderWidth( const int aSize )
759{
760 m_stroke.SetWidth( aSize );
761}
762
763
764bool PCB_TEXTBOX::operator==( const BOARD_ITEM& aBoardItem ) const
765{
766 if( aBoardItem.Type() != Type() )
767 return false;
768
769 const PCB_TEXTBOX& other = static_cast<const PCB_TEXTBOX&>( aBoardItem );
770
771 return *this == other;
772}
773
774
775bool PCB_TEXTBOX::operator==( const PCB_TEXTBOX& aOther ) const
776{
777 return m_borderEnabled == aOther.m_borderEnabled
778 && EDA_TEXT::operator==( aOther );
779}
780
781
782double PCB_TEXTBOX::Similarity( const BOARD_ITEM& aBoardItem ) const
783{
784 if( aBoardItem.Type() != Type() )
785 return 0.0;
786
787 const PCB_TEXTBOX& other = static_cast<const PCB_TEXTBOX&>( aBoardItem );
788
789 double similarity = 1.0;
790
791 if( m_borderEnabled != other.m_borderEnabled )
792 similarity *= 0.9;
793
794 if( GetMarginLeft() != other.GetMarginLeft() )
795 similarity *= 0.9;
796
797 if( GetMarginTop() != other.GetMarginTop() )
798 similarity *= 0.9;
799
800 if( GetMarginRight() != other.GetMarginRight() )
801 similarity *= 0.9;
802
803 if( GetMarginBottom() != other.GetMarginBottom() )
804 similarity *= 0.9;
805
806 similarity *= EDA_TEXT::Similarity( other );
807
808 return similarity;
809}
810
811
812static struct PCB_TEXTBOX_DESC
813{
815 {
817
818 if( lineStyleEnum.Choices().GetCount() == 0 )
819 {
820 lineStyleEnum.Map( LINE_STYLE::SOLID, _HKI( "Solid" ) )
821 .Map( LINE_STYLE::DASH, _HKI( "Dashed" ) )
822 .Map( LINE_STYLE::DOT, _HKI( "Dotted" ) )
823 .Map( LINE_STYLE::DASHDOT, _HKI( "Dash-Dot" ) )
824 .Map( LINE_STYLE::DASHDOTDOT, _HKI( "Dash-Dot-Dot" ) );
825 }
826
833
834 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Shape" ) );
835 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start X" ) );
836 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start Y" ) );
837 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "End X" ) );
838 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "End Y" ) );
839 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Width" ) );
840 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Height" ) );
841 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Width" ) );
842 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Style" ) );
843 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Filled" ) );
844 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Corner Radius" ) );
845
846 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_TEXT ), _HKI( "Color" ) );
847
848 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( PCB_SHAPE ), _HKI( "Soldermask" ) );
849 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( PCB_SHAPE ), _HKI( "Soldermask Margin Override" ) );
850
851 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, bool, BOARD_ITEM>( _HKI( "Knockout" ),
853 _HKI( "Text Properties" ) );
854
855 const wxString borderProps = _( "Border Properties" );
856
857 void ( PCB_TEXTBOX::*lineStyleSetter )( LINE_STYLE ) = &PCB_TEXTBOX::SetLineStyle;
858 LINE_STYLE ( PCB_TEXTBOX::*lineStyleGetter )() const = &PCB_TEXTBOX::GetLineStyle;
859
860 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, bool>( _HKI( "Border" ),
862 borderProps );
863
864 propMgr.AddProperty( new PROPERTY_ENUM<PCB_TEXTBOX, LINE_STYLE>( _HKI( "Border Style" ),
865 lineStyleSetter, lineStyleGetter ),
866 borderProps );
867
868 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Border Width" ),
871 borderProps );
872
873 const wxString marginProps = _( "Margins" );
874
875 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Left" ),
878 marginProps );
879 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Top" ),
882 marginProps );
883 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Right" ),
886 marginProps );
887 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Bottom" ),
890 marginProps );
891
892 propMgr.Mask( TYPE_HASH( PCB_TEXT ), TYPE_HASH( EDA_TEXT ), _HKI( "Hyperlink" ) );
893 }
types::KiCadObjectType ToProtoEnum(KICAD_T aValue)
Definition api_enums.cpp:95
KICAD_T FromProtoEnum(types::KiCadObjectType aValue)
Definition api_enums.cpp:35
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
@ ERROR_OUTSIDE
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
BITMAPS
A list of all bitmap identifiers.
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:990
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
Container for design settings for a BOARD object.
bool GetTextUpright(PCB_LAYER_ID aLayer) const
int GetTextThickness(PCB_LAYER_ID aLayer) const
Return the default text thickness from the layer class for the given layer.
bool GetTextItalic(PCB_LAYER_ID aLayer) const
VECTOR2I GetTextSize(PCB_LAYER_ID aLayer) const
Return the default text size from the layer class for the given layer.
BOARD_ITEM(BOARD_ITEM *aParent, KICAD_T idtype, PCB_LAYER_ID aLayer=F_Cu)
Definition board_item.h:81
void SetLocked(bool aLocked) override
Definition board_item.h:323
PCB_LAYER_ID m_layer
Definition board_item.h:453
virtual bool IsKnockout() const
Definition board_item.h:319
bool IsLocked() const override
virtual void SetIsKnockout(bool aKnockout)
Definition board_item.h:320
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
FOOTPRINT * GetParentFootprint() const
const KIFONT::METRICS & GetFontMetrics() const
bool IsSideSpecific() const
wxString GetLayerName() const
Return the name of the PCB layer on which the item resides.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:317
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition box2.h:558
constexpr bool Contains(const Vec &aPoint) const
Definition box2.h:168
constexpr bool Intersects(const BOX2< Vec > &aRect) const
Definition box2.h:311
EDA_ANGLE Normalized() const
Definition eda_angle.h:240
The base class for create windows for drawing purpose.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
const KIID m_Uuid
Definition eda_item.h:516
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
virtual bool Matches(const EDA_SEARCH_DATA &aSearchData, void *aAuxData) const
Compare the item against the search criteria in aSearchData.
Definition eda_item.h:401
void SetStartX(int x)
Definition eda_shape.h:191
int GetStartY() const
Definition eda_shape.h:174
void SetEndY(int aY)
Definition eda_shape.h:226
int GetEndX() const
Definition eda_shape.h:217
void SetLineStyle(const LINE_STYLE aStyle)
void SetStartY(int y)
Definition eda_shape.h:184
std::vector< VECTOR2I > GetCornersInSequence(EDA_ANGLE angle) const
SHAPE_T GetShape() const
Definition eda_shape.h:168
int GetEndY() const
Definition eda_shape.h:216
void SetEndX(int aX)
Definition eda_shape.h:233
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition eda_shape.h:215
void SetStart(const VECTOR2I &aStart)
Definition eda_shape.h:177
LINE_STYLE GetLineStyle() const
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition eda_shape.h:173
void SetShape(SHAPE_T aShape)
Definition eda_shape.h:167
std::vector< VECTOR2I > GetRectCorners() const
void SetEnd(const VECTOR2I &aEnd)
Definition eda_shape.h:219
int GetStartX() const
Definition eda_shape.h:175
SHAPE_POLY_SET m_poly
Definition eda_shape.h:517
STROKE_PARAMS m_stroke
Definition eda_shape.h:493
void SetWidth(int aWidth)
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition eda_text.h:79
int GetTextHeight() const
Definition eda_text.h:266
bool IsItalic() const
Definition eda_text.h:168
const EDA_ANGLE & GetTextAngle() const
Definition eda_text.h:146
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
Definition eda_text.cpp:534
bool IsMultilineAllowed() const
Definition eda_text.h:196
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition eda_text.h:97
bool IsKeepUpright() const
Definition eda_text.h:205
KIFONT::FONT * GetFont() const
Definition eda_text.h:246
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition eda_text.cpp:434
void SetMirrored(bool isMirrored)
Definition eda_text.cpp:394
std::vector< std::unique_ptr< KIFONT::GLYPH > > * GetRenderCache(const KIFONT::FONT *aFont, const wxString &forResolvedText, const VECTOR2I &aOffset={ 0, 0 }) const
Definition eda_text.cpp:685
virtual EDA_ANGLE GetDrawRotation() const
Definition eda_text.h:376
int GetTextWidth() const
Definition eda_text.h:263
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
Definition eda_text.cpp:418
void Offset(const VECTOR2I &aOffset)
Definition eda_text.cpp:597
GR_TEXT_H_ALIGN_T GetHorizJustify() const
Definition eda_text.h:199
virtual KIFONT::FONT * GetDrawFont(const RENDER_SETTINGS *aSettings) const
Definition eda_text.cpp:650
bool HasTextVars() const
Indicates the ShownText has text var references which need to be processed.
Definition eda_text.h:116
EDA_TEXT(const EDA_IU_SCALE &aIuScale, const wxString &aText=wxEmptyString)
Definition eda_text.cpp:96
double GetLineSpacing() const
Definition eda_text.h:257
double Similarity(const EDA_TEXT &aOther) const
wxString EvaluateText(const wxString &aText) const
Definition eda_text.cpp:642
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
Definition eda_text.cpp:285
const TEXT_ATTRIBUTES & GetAttributes() const
Definition eda_text.h:230
bool IsMirrored() const
Definition eda_text.h:189
int GetEffectiveTextPenWidth(int aDefaultPenWidth=0) const
The EffectiveTextPenWidth uses the text thickness if > 1 or aDefaultPenWidth.
Definition eda_text.cpp:466
double GetTextAngleDegrees() const
Definition eda_text.h:153
std::shared_ptr< SHAPE_COMPOUND > GetEffectiveTextShape(bool aTriangulate=true, const BOX2I &aBBox=BOX2I(), const EDA_ANGLE &aAngle=ANGLE_0) const
build a list of segments (SHAPE_SEGMENT) to describe a text shape.
bool IsBold() const
Definition eda_text.h:183
void SetKeepUpright(bool aKeepUpright)
Definition eda_text.cpp:426
GR_TEXT_V_ALIGN_T GetVertJustify() const
Definition eda_text.h:202
virtual wxString GetShownText(bool aAllowExtraText, int aDepth=0) const
Return the string actually shown after processing of the base text.
Definition eda_text.h:108
virtual void SetText(const wxString &aText)
Definition eda_text.cpp:271
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
Definition eda_text.cpp:300
int GetTextThickness() const
Definition eda_text.h:127
void SetItalic(bool aItalic)
Set the text to be italic - this will also update the font if needed.
Definition eda_text.cpp:308
bool operator==(const EDA_TEXT &aRhs) const
Definition eda_text.h:395
void SetMultilineAllowed(bool aAllow)
Definition eda_text.cpp:402
VECTOR2I GetTextSize() const
Definition eda_text.h:260
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
Definition eda_text.cpp:410
ENUM_MAP & Map(T aValue, const wxString &aName)
Definition property.h:705
static ENUM_MAP< T > & Instance()
Definition property.h:699
wxPGChoices & Choices()
Definition property.h:748
bool ResolveTextVar(wxString *token, int aDepth=0) const
Resolve any references to system tokens supported by the component.
FONT is an abstract base class for both outline and stroke fonts.
Definition font.h:131
static FONT * GetFont(const wxString &aFontName=wxEmptyString, bool aBold=false, bool aItalic=false, const std::vector< wxString > *aEmbeddedFiles=nullptr, bool aForDrawingSheet=false)
Definition font.cpp:147
void Draw(KIGFX::GAL *aGal, const wxString &aText, const VECTOR2I &aPosition, const VECTOR2I &aCursor, const TEXT_ATTRIBUTES &aAttributes, const METRICS &aFontMetrics) const
Draw a string.
Definition font.cpp:250
void LinebreakText(wxString &aText, int aColumnWidth, const VECTOR2I &aGlyphSize, int aThickness, bool aBold, bool aItalic) const
Insert characters into text to ensure that no lines are wider than aColumnWidth.
Definition font.cpp:572
virtual void DrawGlyphs(const std::vector< std::unique_ptr< KIFONT::GLYPH > > &aGlyphs)
Draw polygons representing font glyphs.
Contains methods for drawing PCB-specific items.
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
PCB specific render settings.
Definition pcb_painter.h:81
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
static constexpr double LOD_HIDE
Return this constant from ViewGetLOD() to hide the item unconditionally.
Definition view_item.h:180
static constexpr double LOD_SHOW
Return this constant from ViewGetLOD() to show the item unconditionally.
Definition view_item.h:185
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:66
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition view.h:422
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition view.h:220
Definition kiid.h:49
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition pcb_shape.h:121
virtual void Mirror(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Mirror this object relative to a given horizontal axis the layer is not changed.
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
PCB_SHAPE(BOARD_ITEM *aParent, KICAD_T aItemType, SHAPE_T aShapeType)
Definition pcb_shape.cpp:51
int GetWidth() const override
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
Definition pcb_shape.h:123
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const override
Make a set of SHAPE objects representing the PCB_SHAPE.
void SetPosition(const VECTOR2I &aPos) override
Definition pcb_shape.h:78
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
STROKE_PARAMS GetStroke() const override
Definition pcb_shape.h:91
void StyleFromSettings(const BOARD_DESIGN_SETTINGS &settings) override
void Move(const VECTOR2I &aMoveVector) override
Move this object.
void Normalize() override
Perform any normalization required after a user rotate and/or flip.
VECTOR2I GetPosition() const override
Definition pcb_shape.h:79
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
Definition pcb_shape.h:71
bool HitTest(const VECTOR2I &aPosition, int aAccuracy) const override
Test if aPosition is inside or on the boundary of this item.
virtual void swapData(BOARD_ITEM *aImage) override
void SetBorderWidth(const int aSize)
double Similarity(const BOARD_ITEM &aBoardItem) const override
Return a measure of how likely the other object is to represent the same object.
bool IsBorderEnabled() const
Disables the border, this is done by changing the stroke internally.
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
int GetMarginBottom() const
Definition pcb_textbox.h:92
PCB_TEXTBOX(BOARD_ITEM *aParent, KICAD_T aType=PCB_TEXTBOX_T)
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=false) const override
Convert the shape to a closed polygon.
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
bool m_borderEnabled
Controls drawing the border (as defined by the stroke members)
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
void SetBorderEnabled(bool enabled)
void Mirror(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Mirror this object relative to a given horizontal axis the layer is not changed.
void TransformTextToPolySet(SHAPE_POLY_SET &aBuffer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc) const
Function TransformTextToPolySet Convert the text to a polygonSet describing the actual character stro...
double ViewGetLOD(int aLayer, const KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
EDA_ITEM * Clone() const override
Tests whether the border is disabled, as configured by the stroke.
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const override
Make a set of SHAPE objects representing the PCB_SHAPE.
bool Matches(const EDA_SEARCH_DATA &aSearchData, void *aAuxData) const override
Compare the item against the search criteria in aSearchData.
VECTOR2I GetDrawPos() const override
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
void SetMarginTop(int aTop)
Definition pcb_textbox.h:85
void SetLeft(int aVal) override
int GetMarginLeft() const
Definition pcb_textbox.h:89
void SetMarginLeft(int aLeft)
Definition pcb_textbox.h:84
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
void SetMarginBottom(int aBottom)
Definition pcb_textbox.h:87
int GetMarginRight() const
Definition pcb_textbox.h:91
void SetRight(int aVal) override
std::vector< int > ViewGetLayers() const override
void SetTop(int aVal) override
int GetMarginTop() const
Definition pcb_textbox.h:90
wxString GetShownText(bool aAllowExtraText, int aDepth=0) const override
Return the string actually shown after processing of the base text.
void SetTextAngle(const EDA_ANGLE &aAngle) override
bool operator==(const PCB_TEXTBOX &aOther) const
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void SetMarginRight(int aRight)
Definition pcb_textbox.h:86
void Move(const VECTOR2I &aMoveVector) override
Move this object.
int GetLegacyTextMargin() const
void SetBottom(int aVal) override
VECTOR2I GetTopLeft() const override
VECTOR2I GetBotRight() const override
void CopyFrom(const BOARD_ITEM *aOther) override
int GetBorderWidth() const
void StyleFromSettings(const BOARD_DESIGN_SETTINGS &settings) override
Provide class metadata.Helper macro to map type hashes to names.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
void Mask(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName)
Sets a base class property as masked in a derived class.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
void AddTypeCast(TYPE_CAST_BASE *aCast)
Register a type converter.
Definition seg.h:42
VECTOR2I A
Definition seg.h:49
VECTOR2I B
Definition seg.h:50
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
virtual const VECTOR2I GetPoint(int aIndex) const override
int PointCount() const
Return the number of points (vertices) in this line chain.
virtual const SEG GetSegment(int aIndex) const override
int SegmentCount() const
Return the number of segments in this line chain.
Represent a set of closed polygons.
void Inflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify=false)
Perform outline inflation/deflation.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
void Simplify()
Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections)
int NewOutline()
Creates a new empty polygon in the set and returns its index.
void BooleanSubtract(const SHAPE_POLY_SET &b)
Perform boolean polyset difference.
GR_TEXT_H_ALIGN_T m_Halign
GR_TEXT_V_ALIGN_T m_Valign
KIFONT::FONT * m_Font
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
wxString ExpandTextVars(const wxString &aSource, const PROJECT *aProject, int aFlags)
Definition common.cpp:59
void TransformOvalToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a oblong shape to a polygon, using multiple segments.
@ ROUND_ALL_CORNERS
All angles are rounded.
#define _(s)
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
@ DEGREES_T
Definition eda_angle.h:31
static constexpr EDA_ANGLE ANGLE_270
Definition eda_angle.h:416
static constexpr EDA_ANGLE ANGLE_180
Definition eda_angle.h:415
#define PCB_EDIT_FRAME_NAME
SHAPE_T
Definition eda_shape.h:43
@ RECTANGLE
Use RECTANGLE instead of RECT to avoid collision in a Windows header.
Definition eda_shape.h:46
static FILENAME_RESOLVER * resolver
a few functions useful in geometry calculations.
FLASHING
Enum used during connectivity building to ensure we do not query connectivity while building the data...
Definition layer_ids.h:184
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition layer_ids.h:799
@ LAYER_LOCKED_ITEM_SHADOW
Shadow layer for locked items.
Definition layer_ids.h:306
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
This file contains miscellaneous commonly used macros and functions.
FLIP_DIRECTION
Definition mirror.h:27
@ LEFT_RIGHT
Flip left to right (around the Y axis)
Definition mirror.h:28
KICOMMON_API wxString EllipsizeMenuText(const wxString &aString)
Ellipsize text (at the end) to be no more than 36 characters.
KICOMMON_API wxString EllipsizeStatusText(wxWindow *aWindow, const wxString &aString)
Ellipsize text (at the end) to be no more than 1/3 of the window width.
KICOMMON_API VECTOR2I UnpackVector2(const types::Vector2 &aInput)
Definition api_utils.cpp:85
KICOMMON_API void PackVector2(types::Vector2 &aOutput, const VECTOR2I &aInput)
Definition api_utils.cpp:78
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition eda_angle.h:400
#define _HKI(x)
Definition page_info.cpp:44
static struct PCB_TEXTBOX_DESC _PCB_TEXTBOX_DESC
#define TYPE_HASH(x)
Definition property.h:73
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:62
#define REGISTER_TYPE(x)
wxString UnescapeString(const wxString &aSource)
LINE_STYLE
Dashed line types.
VECTOR2I center
int delta
GR_TEXT_H_ALIGN_T
This is API surface mapped to common.types.HorizontalAlignment.
@ GR_TEXT_H_ALIGN_CENTER
@ GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_H_ALIGN_INDETERMINATE
GR_TEXT_V_ALIGN_T
This is API surface mapped to common.types.VertialAlignment.
@ GR_TEXT_V_ALIGN_BOTTOM
@ GR_TEXT_V_ALIGN_INDETERMINATE
@ GR_TEXT_V_ALIGN_CENTER
@ GR_TEXT_V_ALIGN_TOP
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
Definition trigo.cpp:229
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:78
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition typeinfo.h:93
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695