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 <callback_gal.h>
38#include <macros.h>
39#include <core/ignore.h>
40#include <api/api_enums.h>
41#include <api/api_utils.h>
42#include <api/board/board_types.pb.h>
43
45 PCB_SHAPE( aParent, aType, SHAPE_T::RECTANGLE ),
47 m_borderEnabled( true )
48{
51 SetMultilineAllowed( true );
52
53 int defaultMargin = GetLegacyTextMargin();
54 m_marginLeft = defaultMargin;
55 m_marginTop = defaultMargin;
56 m_marginRight = defaultMargin;
57 m_marginBottom = defaultMargin;
58}
59
61{
62}
63
64
65void PCB_TEXTBOX::CopyFrom( const BOARD_ITEM* aOther )
66{
67 wxCHECK( aOther && aOther->Type() == PCB_TEXTBOX_T, /* void */ );
68 *this = *static_cast<const PCB_TEXTBOX*>( aOther );
69}
70
71
72void PCB_TEXTBOX::Serialize( google::protobuf::Any &aContainer ) const
73{
74 using namespace kiapi::common::types;
75 using namespace kiapi::board;
76 types::BoardTextBox boardText;
77 boardText.set_layer( ToProtoEnum<PCB_LAYER_ID, types::BoardLayer>( GetLayer() ) );
78 boardText.mutable_id()->set_value( m_Uuid.AsStdString() );
79 boardText.set_locked( IsLocked() ? LockedState::LS_LOCKED : LockedState::LS_UNLOCKED );
80
81 TextBox& text = *boardText.mutable_textbox();
82
83 kiapi::common::PackVector2( *text.mutable_top_left(), GetPosition() );
84 kiapi::common::PackVector2( *text.mutable_bottom_right(), GetEnd() );
85 text.set_text( GetText().ToStdString() );
86 //text.set_hyperlink( GetHyperlink().ToStdString() );
87
88 TextAttributes* attrs = text.mutable_attributes();
89
90 if( GetFont() )
91 attrs->set_font_name( GetFont()->GetName().ToStdString() );
92
93 attrs->set_horizontal_alignment(
94 ToProtoEnum<GR_TEXT_H_ALIGN_T, HorizontalAlignment>( GetHorizJustify() ) );
95
96 attrs->set_vertical_alignment(
97 ToProtoEnum<GR_TEXT_V_ALIGN_T, VerticalAlignment>( GetVertJustify() ) );
98
99 attrs->mutable_angle()->set_value_degrees( GetTextAngleDegrees() );
100 attrs->set_line_spacing( GetLineSpacing() );
101 attrs->mutable_stroke_width()->set_value_nm( GetTextThickness() );
102 attrs->set_italic( IsItalic() );
103 attrs->set_bold( IsBold() );
104 attrs->set_underlined( GetAttributes().m_Underlined );
105 attrs->set_mirrored( IsMirrored() );
106 attrs->set_multiline( IsMultilineAllowed() );
107 attrs->set_keep_upright( IsKeepUpright() );
108 kiapi::common::PackVector2( *attrs->mutable_size(), GetTextSize() );
109
110 aContainer.PackFrom( boardText );
111}
112
113
114bool PCB_TEXTBOX::Deserialize( const google::protobuf::Any &aContainer )
115{
116 using namespace kiapi::board;
117 types::BoardTextBox boardText;
118
119 if( !aContainer.UnpackTo( &boardText ) )
120 return false;
121
122 const_cast<KIID&>( m_Uuid ) = KIID( boardText.id().value() );
123 SetLayer( FromProtoEnum<PCB_LAYER_ID, types::BoardLayer>( boardText.layer() ) );
124 SetLocked( boardText.locked() == kiapi::common::types::LockedState::LS_LOCKED );
125
126 const kiapi::common::types::TextBox& text = boardText.textbox();
127
129 SetEnd( kiapi::common::UnpackVector2( text.bottom_right() ) );
130 SetText( wxString( text.text().c_str(), wxConvUTF8 ) );
131 //SetHyperlink( wxString::FromUTF8( text.hyperlink() );
132
133 if( text.has_attributes() )
134 {
136
137 attrs.m_Bold = text.attributes().bold();
138 attrs.m_Italic = text.attributes().italic();
139 attrs.m_Underlined = text.attributes().underlined();
140 attrs.m_Mirrored = text.attributes().mirrored();
141 attrs.m_Multiline = text.attributes().multiline();
142 attrs.m_KeepUpright = text.attributes().keep_upright();
143 attrs.m_Size = kiapi::common::UnpackVector2( text.attributes().size() );
144
145 if( !text.attributes().font_name().empty() )
146 {
148 wxString( text.attributes().font_name().c_str(), wxConvUTF8 ), attrs.m_Bold,
149 attrs.m_Italic );
150 }
151
152 attrs.m_Angle = EDA_ANGLE( text.attributes().angle().value_degrees(), DEGREES_T );
153 attrs.m_LineSpacing = text.attributes().line_spacing();
154 attrs.m_StrokeWidth = text.attributes().stroke_width().value_nm();
155 attrs.m_Halign =
156 FromProtoEnum<GR_TEXT_H_ALIGN_T, kiapi::common::types::HorizontalAlignment>(
157 text.attributes().horizontal_alignment() );
158
159 attrs.m_Valign = FromProtoEnum<GR_TEXT_V_ALIGN_T, kiapi::common::types::VerticalAlignment>(
160 text.attributes().vertical_alignment() );
161
162 SetAttributes( attrs );
163 }
164
165 return true;
166}
167
168
170{
172
173 SetTextSize( settings.GetTextSize( GetLayer() ) );
175 SetItalic( settings.GetTextItalic( GetLayer() ) );
176 SetKeepUpright( settings.GetTextUpright( GetLayer() ) );
178}
179
180
182{
183 return KiROUND( GetStroke().GetWidth() / 2.0 ) + KiROUND( GetTextSize().y * 0.75 );
184}
185
186
188{
189 EDA_ANGLE rotation = GetDrawRotation();
190
191 if( rotation == ANGLE_90 )
192 return VECTOR2I( GetStartX(), GetEndY() );
193 else if( rotation == ANGLE_180 )
194 return GetEnd();
195 else if( rotation == ANGLE_270 )
196 return VECTOR2I( GetEndX(), GetStartY() );
197 else
198 return GetStart();
199}
200
201
203{
204 EDA_ANGLE rotation = GetDrawRotation();
205
206 if( rotation == ANGLE_90 )
207 return VECTOR2I( GetEndX(), GetStartY() );
208 else if( rotation == ANGLE_180 )
209 return GetStart();
210 else if( rotation == ANGLE_270 )
211 return VECTOR2I( GetStartX(), GetEndY() );
212 else
213 return GetEnd();
214}
215
216
217void PCB_TEXTBOX::SetTop( int aVal )
218{
219 EDA_ANGLE rotation = GetDrawRotation();
220
221 if( rotation == ANGLE_90 || rotation == ANGLE_180 )
222 SetEndY( aVal );
223 else
224 SetStartY( aVal );
225}
226
227
229{
230 EDA_ANGLE rotation = GetDrawRotation();
231
232 if( rotation == ANGLE_90 || rotation == ANGLE_180 )
233 SetStartY( aVal );
234 else
235 SetEndY( aVal );
236}
237
238
239void PCB_TEXTBOX::SetLeft( int aVal )
240{
241 EDA_ANGLE rotation = GetDrawRotation();
242
243 if( rotation == ANGLE_180 || rotation == ANGLE_270 )
244 SetEndX( aVal );
245 else
246 SetStartX( aVal );
247}
248
249
250void PCB_TEXTBOX::SetRight( int aVal )
251{
252 EDA_ANGLE rotation = GetDrawRotation();
253
254 if( rotation == ANGLE_180 || rotation == ANGLE_270 )
255 SetStartX( aVal );
256 else
257 SetEndX( aVal );
258}
259
260
262{
263 EDA_ANGLE delta = aAngle.Normalized() - GetTextAngle();
265}
266
267
269{
270 return GetDrawPos( false );
271}
272
273
274VECTOR2I PCB_TEXTBOX::GetDrawPos( bool aIsFlipped ) const
275{
276 EDA_ANGLE drawAngle = GetDrawRotation();
277 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
278 GR_TEXT_H_ALIGN_T horizontalAlignment = GetHorizJustify();
279 GR_TEXT_V_ALIGN_T verticalAlignment = GetVertJustify();
280 VECTOR2I textAnchor;
281 VECTOR2I offset;
282
283 // Calculate midpoints
284 VECTOR2I midTop = ( corners[0] + corners[1] ) / 2;
285 VECTOR2I midBottom = ( corners[3] + corners[2] ) / 2;
286 VECTOR2I midLeft = ( corners[0] + corners[3] ) / 2;
287 VECTOR2I midRight = ( corners[1] + corners[2] ) / 2;
288 VECTOR2I center = ( corners[0] + corners[1] + corners[2] + corners[3] ) / 4;
289
290 if( IsMirrored() != aIsFlipped )
291 {
292 switch( GetHorizJustify() )
293 {
294 case GR_TEXT_H_ALIGN_LEFT: horizontalAlignment = GR_TEXT_H_ALIGN_RIGHT; break;
295 case GR_TEXT_H_ALIGN_CENTER: horizontalAlignment = GR_TEXT_H_ALIGN_CENTER; break;
296 case GR_TEXT_H_ALIGN_RIGHT: horizontalAlignment = GR_TEXT_H_ALIGN_LEFT; break;
298 horizontalAlignment = GR_TEXT_H_ALIGN_INDETERMINATE;
299 break;
300 }
301 }
302
303 wxASSERT_MSG(
304 horizontalAlignment != GR_TEXT_H_ALIGN_INDETERMINATE
305 && verticalAlignment != GR_TEXT_V_ALIGN_INDETERMINATE,
306 wxS( "Indeterminate state legal only in dialogs. Horizontal and vertical alignment "
307 "must be set before calling PCB_TEXTBOX::GetDrawPos." ) );
308
309 if( horizontalAlignment == GR_TEXT_H_ALIGN_INDETERMINATE
310 || verticalAlignment == GR_TEXT_V_ALIGN_INDETERMINATE )
311 {
312 return center;
313 }
314
315 if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
316 {
317 textAnchor = corners[0];
318 }
319 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
320 && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
321 {
322 textAnchor = midTop;
323 }
324 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
325 && verticalAlignment == GR_TEXT_V_ALIGN_TOP )
326 {
327 textAnchor = corners[1];
328 }
329 else if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT
330 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
331 {
332 textAnchor = midLeft;
333 }
334 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
335 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
336 {
337 textAnchor = center;
338 }
339 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
340 && verticalAlignment == GR_TEXT_V_ALIGN_CENTER )
341 {
342 textAnchor = midRight;
343 }
344 else if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT
345 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
346 {
347 textAnchor = corners[3];
348 }
349 else if( horizontalAlignment == GR_TEXT_H_ALIGN_CENTER
350 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
351 {
352 textAnchor = midBottom;
353 }
354 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT
355 && verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
356 {
357 textAnchor = corners[2];
358 }
359
360 int marginLeft = GetMarginLeft();
361 int marginRight = GetMarginRight();
362 int marginTop = GetMarginTop();
363 int marginBottom = GetMarginBottom();
364
365 if( horizontalAlignment == GR_TEXT_H_ALIGN_LEFT )
366 offset.x = marginLeft;
367 else if( horizontalAlignment == GR_TEXT_H_ALIGN_RIGHT )
368 offset.x = -marginRight;
369
370 if( verticalAlignment == GR_TEXT_V_ALIGN_TOP )
371 offset.y = marginTop;
372 else if( verticalAlignment == GR_TEXT_V_ALIGN_BOTTOM )
373 offset.y = -marginBottom;
374
375 RotatePoint( offset, GetDrawRotation() );
376 return textAnchor + offset;
377}
378
379
380double PCB_TEXTBOX::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
381{
382 KIGFX::PCB_PAINTER& painter = static_cast<KIGFX::PCB_PAINTER&>( *aView->GetPainter() );
383 KIGFX::PCB_RENDER_SETTINGS& renderSettings = *painter.GetSettings();
384
385 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
386 {
387 // Hide shadow if the main layer is not shown
388 if( !aView->IsLayerVisible( m_layer ) )
389 return LOD_HIDE;
390
391 // Hide shadow on dimmed tracks
392 if( renderSettings.GetHighContrast() )
393 {
394 if( m_layer != renderSettings.GetPrimaryHighContrastLayer() )
395 return LOD_HIDE;
396 }
397 }
398
399 return LOD_SHOW;
400}
401
402
403std::vector<int> PCB_TEXTBOX::ViewGetLayers() const
404{
407
408 return { GetLayer() };
409}
410
411
412wxString PCB_TEXTBOX::GetShownText( bool aAllowExtraText, int aDepth ) const
413{
414 const FOOTPRINT* parentFootprint = GetParentFootprint();
415 const BOARD* board = GetBoard();
416
417 std::function<bool( wxString* )> resolver = [&]( wxString* token ) -> bool
418 {
419 if( token->IsSameAs( wxT( "LAYER" ) ) )
420 {
421 *token = GetLayerName();
422 return true;
423 }
424
425 if( parentFootprint && parentFootprint->ResolveTextVar( token, aDepth + 1 ) )
426 return true;
427
428 if( board->ResolveTextVar( token, aDepth + 1 ) )
429 return true;
430
431 return false;
432 };
433
434 wxString text = EDA_TEXT::GetShownText( aAllowExtraText, aDepth );
435
436 if( HasTextVars() )
437 {
438 if( aDepth < ADVANCED_CFG::GetCfg().m_ResolveTextRecursionDepth )
440 }
441
442 KIFONT::FONT* font = getDrawFont();
443 EDA_ANGLE drawAngle = GetDrawRotation();
444 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
445 int colWidth = ( corners[1] - corners[0] ).EuclideanNorm();
446
447 if( GetTextAngle().IsHorizontal() )
448 colWidth -= ( GetMarginLeft() + GetMarginRight() );
449 else
450 colWidth -= ( GetMarginTop() + GetMarginBottom() );
451
452 font->LinebreakText( text, colWidth, GetTextSize(), GetTextThickness(), IsBold(), IsItalic() );
453
454 return text;
455}
456
457
458bool PCB_TEXTBOX::Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const
459{
460 return BOARD_ITEM::Matches( UnescapeString( GetText() ), aSearchData );
461}
462
463
464void PCB_TEXTBOX::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
465{
466 // Don't use GetShownText() here; we want to show the user the variable references
467 aList.emplace_back( _( "Text Box" ), KIUI::EllipsizeStatusText( aFrame, GetText() ) );
468
469 if( aFrame->GetName() == PCB_EDIT_FRAME_NAME && IsLocked() )
470 aList.emplace_back( _( "Status" ), _( "Locked" ) );
471
472 aList.emplace_back( _( "Layer" ), GetLayerName() );
473 aList.emplace_back( _( "Mirror" ), IsMirrored() ? _( "Yes" ) : _( "No" ) );
474 aList.emplace_back( _( "Angle" ), wxString::Format( "%g", GetTextAngle().AsDegrees() ) );
475
476 aList.emplace_back( _( "Font" ), GetFont() ? GetFont()->GetName() : _( "Default" ) );
477
478 if( GetTextThickness() )
479 aList.emplace_back( _( "Text Thickness" ), aFrame->MessageTextFromValue( GetEffectiveTextPenWidth() ) );
480 else
481 aList.emplace_back( _( "Text Thickness" ), _( "Auto" ) );
482
483 aList.emplace_back( _( "Text Width" ), aFrame->MessageTextFromValue( GetTextWidth() ) );
484 aList.emplace_back( _( "Text Height" ), aFrame->MessageTextFromValue( GetTextHeight() ) );
485
486 aList.emplace_back( _( "Box Width" ),
487 aFrame->MessageTextFromValue( std::abs( GetEnd().x - GetStart().x ) ) );
488
489 aList.emplace_back( _( "Box Height" ),
490 aFrame->MessageTextFromValue( std::abs( GetEnd().y - GetStart().y ) ));
491
492 m_stroke.GetMsgPanelInfo( aFrame, aList );
493}
494
495
496void PCB_TEXTBOX::Move( const VECTOR2I& aMoveVector )
497{
498 PCB_SHAPE::Move( aMoveVector );
499 EDA_TEXT::Offset( aMoveVector );
500}
501
502
503void PCB_TEXTBOX::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
504{
505 PCB_SHAPE::Rotate( aRotCentre, aAngle );
507
508 if( GetTextAngle().IsCardinal() && GetShape() != SHAPE_T::RECTANGLE )
509 {
510 // To convert the polygon to its equivalent rectangle, we use GetCornersInSequence( drawAngle )
511 // but this method uses the polygon bounding box.
512 // set the line thickness to 0 to get the actual rectangle corner
513 int lineWidth = GetWidth();
514 SetWidth( 0 );
515 EDA_ANGLE drawAngle = GetDrawRotation();
516 std::vector<VECTOR2I> corners = GetCornersInSequence( drawAngle );
517 SetWidth( lineWidth );
518 VECTOR2I diag = corners[2] - corners[0];
519 EDA_ANGLE angle = GetTextAngle();
520
521 SetShape( SHAPE_T::RECTANGLE );
522 SetStart( corners[0] );
523
524 if( angle == ANGLE_90 )
525 SetEnd( VECTOR2I( corners[0].x + abs( diag.x ), corners[0].y - abs( diag.y ) ) );
526 else if( angle == ANGLE_180 )
527 SetEnd( VECTOR2I( corners[0].x - abs( diag.x ), corners[0].y - abs( diag.y ) ) );
528 else if( angle == ANGLE_270 )
529 SetEnd( VECTOR2I( corners[0].x - abs( diag.x ), corners[0].y + abs( diag.y ) ) );
530 else
531 SetEnd( VECTOR2I( corners[0].x + abs( diag.x ), corners[0].y + abs( diag.y ) ) );
532 }
533}
534
535
536void PCB_TEXTBOX::Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
537{
538 // the position and angle are mirrored, but not the text (or its justification)
539 PCB_SHAPE::Mirror( aCentre, aFlipDirection );
540
541 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
543 else
545}
546
547
548void PCB_TEXTBOX::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
549{
550 PCB_SHAPE::Flip( aCentre, aFlipDirection );
551
553
554 if( IsSideSpecific() )
556}
557
558
559bool PCB_TEXTBOX::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
560{
561 BOX2I rect = GetBoundingBox();
562
563 rect.Inflate( aAccuracy );
564
565 return rect.Contains( aPosition );
566}
567
568
569bool PCB_TEXTBOX::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
570{
571 BOX2I rect = aRect;
572
573 rect.Inflate( aAccuracy );
574
575 if( aContained )
576 return rect.Contains( GetBoundingBox() );
577
578 return rect.Intersects( GetBoundingBox() );
579}
580
581
582wxString PCB_TEXTBOX::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
583{
584 return wxString::Format( _( "PCB Text Box '%s' on %s" ),
585 aFull ? GetShownText( false ) : KIUI::EllipsizeMenuText( GetText() ),
586 GetLayerName() );
587}
588
589
591{
592 return BITMAPS::add_textbox;
593}
594
595
597{
598 return new PCB_TEXTBOX( *this );
599}
600
601
603{
604 wxASSERT( aImage->Type() == PCB_TEXTBOX_T );
605
606 std::swap( *((PCB_TEXTBOX*) this), *((PCB_TEXTBOX*) aImage) );
607}
608
609
610std::shared_ptr<SHAPE> PCB_TEXTBOX::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING aFlash ) const
611{
612 std::shared_ptr<SHAPE_COMPOUND> shape = GetEffectiveTextShape();
613
614 if( PCB_SHAPE::GetStroke().GetWidth() >= 0 )
615 shape->AddShape( PCB_SHAPE::GetEffectiveShape( aLayer, aFlash ) );
616
617 return shape;
618}
619
620
621void PCB_TEXTBOX::TransformTextToPolySet( SHAPE_POLY_SET& aBuffer, int aClearance, int aMaxError,
622 ERROR_LOC aErrorLoc ) const
623{
625 KIFONT::FONT* font = getDrawFont();
626 int penWidth = GetEffectiveTextPenWidth();
628 wxString shownText = GetShownText( true );
629
630 // The polygonal shape of a text can have many basic shapes, so combining these shapes can
631 // be very useful to create a final shape with a lot less vertices to speedup calculations.
632 // Simplify shapes is not usually always efficient, but in this case it is.
633 SHAPE_POLY_SET textShape;
634
635 CALLBACK_GAL callback_gal( empty_opts,
636 // Stroke callback
637 [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2 )
638 {
639 TransformOvalToPolygon( textShape, aPt1, aPt2, penWidth, aMaxError, aErrorLoc );
640 },
641 // Triangulation callback
642 [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2, const VECTOR2I& aPt3 )
643 {
644 textShape.NewOutline();
645
646 for( const VECTOR2I& point : { aPt1, aPt2, aPt3 } )
647 textShape.Append( point.x, point.y );
648 } );
649
650 if( auto* cache = GetRenderCache( font, shownText ) )
651 callback_gal.DrawGlyphs( *cache );
652 else
653 font->Draw( &callback_gal, shownText, GetDrawPos(), attrs, GetFontMetrics() );
654
655 textShape.Simplify();
656
657 if( IsKnockout() )
658 {
659 SHAPE_POLY_SET finalPoly;
660
661 TransformShapeToPolygon( finalPoly, GetLayer(), aClearance, aMaxError, aErrorLoc );
662 finalPoly.BooleanSubtract( textShape );
663
664 aBuffer.Append( finalPoly );
665 }
666 else
667 {
668 if( aClearance > 0 || aErrorLoc == ERROR_OUTSIDE )
669 {
670 if( aErrorLoc == ERROR_OUTSIDE )
671 aClearance += aMaxError;
672
673 textShape.Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError, true );
674 }
675
676 aBuffer.Append( textShape );
677 }
678}
679
680
682 int aClearance, int aMaxError, ERROR_LOC aErrorLoc,
683 bool aIgnoreLineWidth ) const
684{
685 // Don't use PCB_SHAPE::TransformShapeToPolygon. We want to treat the textbox as filled even
686 // if there's no background colour.
687
688 int width = GetWidth() + ( 2 * aClearance );
689
690 if( GetShape() == SHAPE_T::RECTANGLE )
691 {
692 std::vector<VECTOR2I> pts = GetRectCorners();
693
694 aBuffer.NewOutline();
695
696 for( const VECTOR2I& pt : pts )
697 aBuffer.Append( pt );
698
699 if( m_borderEnabled && width > 0 )
700 {
701 // Add in segments
702 TransformOvalToPolygon( aBuffer, pts[0], pts[1], width, aMaxError, aErrorLoc );
703 TransformOvalToPolygon( aBuffer, pts[1], pts[2], width, aMaxError, aErrorLoc );
704 TransformOvalToPolygon( aBuffer, pts[2], pts[3], width, aMaxError, aErrorLoc );
705 TransformOvalToPolygon( aBuffer, pts[3], pts[0], width, aMaxError, aErrorLoc );
706 }
707 }
708 else if( GetShape() == SHAPE_T::POLY ) // Non-cardinally-rotated rect
709 {
710 aBuffer.NewOutline();
711
712 const SHAPE_LINE_CHAIN& poly = m_poly.Outline( 0 );
713
714 for( int ii = 0; ii < poly.PointCount(); ++ii )
715 aBuffer.Append( poly.GetPoint( ii ) );
716
717 if( m_borderEnabled && width > 0 )
718 {
719 for( int ii = 0; ii < poly.SegmentCount(); ++ii )
720 {
721 const SEG& seg = poly.GetSegment( ii );
722 TransformOvalToPolygon( aBuffer, seg.A, seg.B, width, aMaxError, aErrorLoc );
723 }
724 }
725 }
726}
727
728
730{
731 return m_borderEnabled;
732}
733
734
736{
737 m_borderEnabled = enabled;
738}
739
740
741void PCB_TEXTBOX::SetBorderWidth( const int aSize )
742{
743 m_stroke.SetWidth( aSize );
744}
745
746
747bool PCB_TEXTBOX::operator==( const BOARD_ITEM& aBoardItem ) const
748{
749 if( aBoardItem.Type() != Type() )
750 return false;
751
752 const PCB_TEXTBOX& other = static_cast<const PCB_TEXTBOX&>( aBoardItem );
753
754 return *this == other;
755}
756
757
758bool PCB_TEXTBOX::operator==( const PCB_TEXTBOX& aOther ) const
759{
760 return m_borderEnabled == aOther.m_borderEnabled
761 && EDA_TEXT::operator==( aOther );
762}
763
764
765double PCB_TEXTBOX::Similarity( const BOARD_ITEM& aBoardItem ) const
766{
767 if( aBoardItem.Type() != Type() )
768 return 0.0;
769
770 const PCB_TEXTBOX& other = static_cast<const PCB_TEXTBOX&>( aBoardItem );
771
772 double similarity = 1.0;
773
774 if( m_borderEnabled != other.m_borderEnabled )
775 similarity *= 0.9;
776
777 if( GetMarginLeft() != other.GetMarginLeft() )
778 similarity *= 0.9;
779
780 if( GetMarginTop() != other.GetMarginTop() )
781 similarity *= 0.9;
782
783 if( GetMarginRight() != other.GetMarginRight() )
784 similarity *= 0.9;
785
786 if( GetMarginBottom() != other.GetMarginBottom() )
787 similarity *= 0.9;
788
789 similarity *= EDA_TEXT::Similarity( other );
790
791 return similarity;
792}
793
794
795static struct PCB_TEXTBOX_DESC
796{
798 {
800
801 if( lineStyleEnum.Choices().GetCount() == 0 )
802 {
803 lineStyleEnum.Map( LINE_STYLE::SOLID, _HKI( "Solid" ) )
804 .Map( LINE_STYLE::DASH, _HKI( "Dashed" ) )
805 .Map( LINE_STYLE::DOT, _HKI( "Dotted" ) )
806 .Map( LINE_STYLE::DASHDOT, _HKI( "Dash-Dot" ) )
807 .Map( LINE_STYLE::DASHDOTDOT, _HKI( "Dash-Dot-Dot" ) );
808 }
809
816
817 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Shape" ) );
818 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start X" ) );
819 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start Y" ) );
820 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "End X" ) );
821 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "End Y" ) );
822 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Width" ) );
823 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Height" ) );
824 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Width" ) );
825 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Style" ) );
826 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_SHAPE ), _HKI( "Filled" ) );
827 propMgr.Mask( TYPE_HASH( PCB_TEXTBOX ), TYPE_HASH( EDA_TEXT ), _HKI( "Color" ) );
828
829 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, bool, BOARD_ITEM>( _HKI( "Knockout" ),
831 _HKI( "Text Properties" ) );
832
833 const wxString borderProps = _( "Border Properties" );
834
835 void ( PCB_TEXTBOX::*lineStyleSetter )( LINE_STYLE ) = &PCB_TEXTBOX::SetLineStyle;
836 LINE_STYLE ( PCB_TEXTBOX::*lineStyleGetter )() const = &PCB_TEXTBOX::GetLineStyle;
837
838 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, bool>( _HKI( "Border" ),
840 borderProps );
841
842 propMgr.AddProperty( new PROPERTY_ENUM<PCB_TEXTBOX, LINE_STYLE>( _HKI( "Border Style" ),
843 lineStyleSetter, lineStyleGetter ),
844 borderProps );
845
846 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Border Width" ),
848 PROPERTY_DISPLAY::PT_SIZE ),
849 borderProps );
850
851 const wxString marginProps = _( "Margins" );
852
853 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Left" ),
855 PROPERTY_DISPLAY::PT_SIZE ),
856 marginProps );
857 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Top" ),
859 PROPERTY_DISPLAY::PT_SIZE ),
860 marginProps );
861 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Right" ),
863 PROPERTY_DISPLAY::PT_SIZE ),
864 marginProps );
865 propMgr.AddProperty( new PROPERTY<PCB_TEXTBOX, int>( _HKI( "Margin Bottom" ),
867 PROPERTY_DISPLAY::PT_SIZE ),
868 marginProps );
869
870 propMgr.Mask( TYPE_HASH( PCB_TEXT ), TYPE_HASH( EDA_TEXT ), _HKI( "Hyperlink" ) );
871 }
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
Definition: approximation.h:32
@ ERROR_OUTSIDE
Definition: approximation.h:33
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:112
BITMAPS
A list of all bitmap identifiers.
Definition: bitmaps_list.h:33
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.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
void SetLocked(bool aLocked) override
Definition: board_item.h:326
PCB_LAYER_ID m_layer
Definition: board_item.h:454
virtual bool IsKnockout() const
Definition: board_item.h:322
bool IsLocked() const override
Definition: board_item.cpp:103
virtual void SetIsKnockout(bool aKnockout)
Definition: board_item.h:323
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
Definition: board_item.cpp:79
FOOTPRINT * GetParentFootprint() const
Definition: board_item.cpp:97
const KIFONT::METRICS & GetFontMetrics() const
Definition: board_item.cpp:132
bool IsSideSpecific() const
Definition: board_item.cpp:190
wxString GetLayerName() const
Return the name of the PCB layer on which the item resides.
Definition: board_item.cpp:180
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:317
bool ResolveTextVar(wxString *token, int aDepth) const
Definition: board.cpp:499
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
bool IsHorizontal() const
Definition: eda_angle.h:141
EDA_ANGLE Normalized() const
Definition: eda_angle.h:235
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:97
const KIID m_Uuid
Definition: eda_item.h:502
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:109
virtual bool Matches(const EDA_SEARCH_DATA &aSearchData, void *aAuxData) const
Compare the item against the search criteria in aSearchData.
Definition: eda_item.h:388
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)
Definition: eda_shape.cpp:2373
void SetStartY(int y)
Definition: eda_shape.h:184
std::vector< VECTOR2I > GetCornersInSequence(EDA_ANGLE angle) const
Definition: eda_shape.cpp:1605
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
Definition: eda_shape.cpp:2379
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
Definition: eda_shape.cpp:1590
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:512
STROKE_PARAMS m_stroke
Definition: eda_shape.h:489
void SetWidth(int aWidth)
Definition: eda_shape.cpp:2366
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:264
bool IsItalic() const
Definition: eda_text.h:166
const EDA_ANGLE & GetTextAngle() const
Definition: eda_text.h:144
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
Definition: eda_text.cpp:533
bool IsMultilineAllowed() const
Definition: eda_text.h:194
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:203
KIFONT::FONT * GetFont() const
Definition: eda_text.h:244
void SetAttributes(const EDA_TEXT &aSrc, bool aSetPosition=true)
Set the text attributes from another instance.
Definition: eda_text.cpp:433
void SetMirrored(bool isMirrored)
Definition: eda_text.cpp:393
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:671
virtual EDA_ANGLE GetDrawRotation() const
Definition: eda_text.h:373
int GetTextWidth() const
Definition: eda_text.h:261
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
Definition: eda_text.cpp:417
void Offset(const VECTOR2I &aOffset)
Definition: eda_text.cpp:596
GR_TEXT_H_ALIGN_T GetHorizJustify() const
Definition: eda_text.h:197
bool HasTextVars() const
Indicates the ShownText has text var references which need to be processed.
Definition: eda_text.h:116
virtual KIFONT::FONT * getDrawFont() const
Definition: eda_text.cpp:641
double GetLineSpacing() const
Definition: eda_text.h:255
double Similarity(const EDA_TEXT &aOther) const
Definition: eda_text.cpp:1280
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
Definition: eda_text.cpp:284
const TEXT_ATTRIBUTES & GetAttributes() const
Definition: eda_text.h:228
bool IsMirrored() const
Definition: eda_text.h:187
int GetEffectiveTextPenWidth(int aDefaultPenWidth=0) const
The EffectiveTextPenWidth uses the text thickness if > 1 or aDefaultPenWidth.
Definition: eda_text.cpp:465
double GetTextAngleDegrees() const
Definition: eda_text.h:151
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.
Definition: eda_text.cpp:1121
bool IsBold() const
Definition: eda_text.h:181
void SetKeepUpright(bool aKeepUpright)
Definition: eda_text.cpp:425
GR_TEXT_V_ALIGN_T GetVertJustify() const
Definition: eda_text.h:200
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:270
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
Definition: eda_text.cpp:299
int GetTextThickness() const
Definition: eda_text.h:125
void SetItalic(bool aItalic)
Set the text to be italic - this will also update the font if needed.
Definition: eda_text.cpp:307
bool operator==(const EDA_TEXT &aRhs) const
Definition: eda_text.h:390
void SetMultilineAllowed(bool aAllow)
Definition: eda_text.cpp:401
VECTOR2I GetTextSize() const
Definition: eda_text.h:258
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
Definition: eda_text.cpp:409
ENUM_MAP & Map(T aValue, const wxString &aName)
Definition: property.h:687
static ENUM_MAP< T > & Instance()
Definition: property.h:681
wxPGChoices & Choices()
Definition: property.h:730
bool ResolveTextVar(wxString *token, int aDepth=0) const
Resolve any references to system tokens supported by the component.
Definition: footprint.cpp:999
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.
Definition: pcb_painter.h:182
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
Definition: pcb_painter.h:187
PCB specific render settings.
Definition: pcb_painter.h:80
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
bool GetHighContrast() const
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:67
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:418
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:216
Definition: kiid.h:49
std::string AsStdString() const
Definition: kiid.cpp:252
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.
Definition: pcb_shape.cpp:578
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
Definition: pcb_shape.cpp:564
int GetWidth() const override
Definition: pcb_shape.cpp:385
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.
Definition: pcb_shape.cpp:775
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.
Definition: pcb_shape.cpp:570
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
Definition: pcb_shape.cpp:176
STROKE_PARAMS GetStroke() const override
Definition: pcb_shape.h:91
void StyleFromSettings(const BOARD_DESIGN_SETTINGS &settings) override
Definition: pcb_shape.cpp:395
void Move(const VECTOR2I &aMoveVector) override
Move this object.
Definition: pcb_shape.cpp:471
void Normalize() override
Perform any normalization required after a user rotate and/or flip.
Definition: pcb_shape.cpp:483
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)
Definition: pcb_textbox.cpp:44
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)
Definition: pcb_textbox.h:174
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
int m_marginLeft
Definition: pcb_textbox.h:177
int m_marginBottom
Definition: pcb_textbox.h:180
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...
int m_marginRight
Definition: pcb_textbox.h:179
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.
Definition: pcb_textbox.cpp:72
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
Definition: pcb_textbox.cpp:65
int GetBorderWidth() const
Definition: pcb_textbox.h:159
void StyleFromSettings(const BOARD_DESIGN_SETTINGS &settings) override
Provide class metadata.Helper macro to map type hashes to names.
Definition: property_mgr.h:85
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()
Definition: property_mgr.h:87
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)
SHAPE_LINE_CHAIN & Outline(int aIndex)
Return the reference to aIndex-th outline in the set.
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.
void SetWidth(int aWidth)
void GetMsgPanelInfo(UNITS_PROVIDER *aUnitsProvider, std::vector< MSG_PANEL_ITEM > &aList, bool aIncludeStyle=true, bool aIncludeWidth=true)
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.
#define _HKI(x)
#define _(s)
static constexpr EDA_ANGLE ANGLE_90
Definition: eda_angle.h:406
@ DEGREES_T
Definition: eda_angle.h:31
static constexpr EDA_ANGLE ANGLE_270
Definition: eda_angle.h:409
static constexpr EDA_ANGLE ANGLE_180
Definition: eda_angle.h:408
#define PCB_EDIT_FRAME_NAME
SHAPE_T
Definition: eda_shape.h:43
static FILENAME_RESOLVER * resolver
Definition: export_idf.cpp:53
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:789
@ 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
KICOMMON_API wxString EllipsizeMenuText(const wxString &aString)
Ellipsize text (at the end) to be no more than 36 characters.
Definition: ui_common.cpp:221
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.
Definition: ui_common.cpp:203
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:393
static struct PCB_TEXTBOX_DESC _PCB_TEXTBOX_DESC
#define TYPE_HASH(x)
Definition: property.h:72
#define REGISTER_TYPE(x)
Definition: property_mgr.h:371
wxString UnescapeString(const wxString &aSource)
LINE_STYLE
Dashed line types.
Definition: stroke_params.h:46
VECTOR2I center
constexpr 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