KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_tablecell.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, see <https://www.gnu.org/licenses/>.
18 */
19
20#include <font/font.h>
21#include <advanced_config.h>
22#include <common.h>
23#include <sch_edit_frame.h>
24#include <widgets/msgpanel.h>
25#include <string_utils.h>
26#include <sch_table.h>
27#include <sch_tablecell.h>
28#include <properties/property.h>
30
31#include <api/api_utils.h>
32#include <api/schematic/schematic_types.pb.h>
33
34
35SCH_TABLECELL::SCH_TABLECELL( int aLineWidth, FILL_T aFillType ) :
36 SCH_TEXTBOX( LAYER_NOTES, aLineWidth, aFillType, wxEmptyString, SCH_TABLECELL_T ),
37 m_colSpan( 1 ),
38 m_rowSpan( 1 )
39{
40}
41
42void SCH_TABLECELL::Serialize( kiapi::schematic::types::SchematicTableCell& aCell ) const
43{
44 aCell.set_column_span( m_colSpan );
45 aCell.set_row_span( m_rowSpan );
46
47 SCH_TEXTBOX::Serialize( *aCell.mutable_text_box(), schIUScale );
48 kiapi::common::PackCustomProperties( aCell.mutable_custom_properties(), *this );
49}
50
51
52void SCH_TABLECELL::Serialize( google::protobuf::Any& aContainer ) const
53{
54 kiapi::schematic::types::SchematicTableCell cell;
55 Serialize( cell );
56
57 if( !aContainer.PackFrom( cell ) )
58 wxFAIL_MSG( wxT( "Failed to pack SCH_TABLECELL" ) );
59}
60
61
62bool SCH_TABLECELL::Deserialize( const kiapi::schematic::types::SchematicTableCell& aCell )
63{
64 if( !aCell.has_text_box() )
65 return false;
66
67 if( !SCH_TEXTBOX::Deserialize( aCell.text_box(), schIUScale ) )
68 return false;
69
70 SetColSpan( aCell.column_span() );
71 SetRowSpan( aCell.row_span() );
72
73 kiapi::common::UnpackCustomProperties( aCell.custom_properties(), *this );
74
75 return true;
76}
77
78
79bool SCH_TABLECELL::Deserialize( const google::protobuf::Any& aContainer )
80{
81 kiapi::schematic::types::SchematicTableCell cell;
82
83 if( !aContainer.UnpackTo( &cell ) )
84 return false;
85
86 return Deserialize( cell );
87}
88
89
90
91
93{
94 SCH_TEXTBOX::swapData( aItem );
95
96 SCH_TABLECELL* cell = static_cast<SCH_TABLECELL*>( aItem );
97
98 std::swap( m_colSpan, cell->m_colSpan );
99 std::swap( m_rowSpan, cell->m_rowSpan );
100}
101
102
103wxString SCH_TABLECELL::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
104{
105 return wxString::Format( _( "Table Cell %s" ), GetAddr() );
106}
107
108
110{
111 const SCH_TABLE* table = static_cast<const SCH_TABLE*>( GetParent() );
112
113 for( int row = 0; row < table->GetRowCount(); ++row )
114 {
115 for( int col = 0; col < table->GetColCount(); ++col )
116 {
117 if( table->GetCell( row, col ) == this )
118 return row;
119 }
120 }
121
122 return -1;
123}
124
125
127{
128 const SCH_TABLE* table = static_cast<const SCH_TABLE*>( GetParent() );
129
130 for( int row = 0; row < table->GetRowCount(); ++row )
131 {
132 for( int col = 0; col < table->GetColCount(); ++col )
133 {
134 if( table->GetCell( row, col ) == this )
135 return col;
136 }
137 }
138
139 return -1;
140}
141
142
144{
145 return wxString::Format( wxT( "%c%d" ), 'A' + GetColumn() % 26, GetRow() );
146}
147
148
159static bool parseCellAddress( const wxString& aAddr, int& aRow, int& aCol )
160{
161 if( aAddr.IsEmpty() )
162 return false;
163
164 // Extract column part (letters) and row part (numbers)
165 size_t i = 0;
166 wxString colPart;
167
168 // Read column letters (A-Z, AA-ZZ, etc.)
169 while( i < aAddr.Length() && wxIsalpha( aAddr[i] ) )
170 {
171 colPart += wxToupper( aAddr[i] );
172 i++;
173 }
174
175 // Must have at least one letter
176 if( colPart.IsEmpty() )
177 return false;
178
179 // Convert column letters to 0-based index (A=0, B=1, ..., Z=25, AA=26, AB=27, etc.)
180 aCol = 0;
181 for( size_t j = 0; j < colPart.Length(); j++ )
182 {
183 aCol = aCol * 26 + ( colPart[j] - 'A' + 1 );
184 }
185 aCol -= 1; // Convert to 0-based
186
187 // Read row number (0-based)
188 wxString rowPart = aAddr.Mid( i );
189 if( rowPart.IsEmpty() )
190 return false;
191
192 // Convert row string to number (already 0-based in address string)
193 long rowNum;
194 if( !rowPart.ToLong( &rowNum ) || rowNum < 0 )
195 return false;
196
197 aRow = rowNum; // Already 0-based
198
199 return true;
200}
201
202
203wxString SCH_TABLECELL::GetShownText( const RENDER_SETTINGS* aSettings, const SCH_SHEET_PATH* aPath,
204 RESOLUTION_CONTEXT aContext, int aDepth ) const
205{
206 // Local depth counter for ResolveTextVars iteration tracking (separate from cross-cell aDepth)
207 int depth = 0;
208
209 SCH_SHEET* sheet = nullptr;
210
211 if( aPath )
212 sheet = aPath->Last();
213
214 // Text variable resolver supporting:
215 // - ${ROW}, ${COL}, ${ADDR} - cell position variables
216 // - @{expression} - math expression evaluation
217 // - ${CELL("A1")} or ${CELL(row,col)} - reference to another cell's evaluated text
218 // - \${...} and \@{...} - escape sequences for literal display
219 std::function<bool( wxString* )> tableCellResolver =
220 [&]( wxString* token ) -> bool
221 {
222 if( token->IsSameAs( wxT( "ROW" ) ) )
223 {
224 *token = wxString::Format( wxT( "%d" ), GetRow() ); // 0-based
225 return true;
226 }
227 else if( token->IsSameAs( wxT( "COL" ) ) )
228 {
229 *token = wxString::Format( wxT( "%d" ), GetColumn() ); // 0-based
230 return true;
231 }
232 else if( token->IsSameAs( wxT( "ADDR" ) ) )
233 {
234 *token = GetAddr();
235 return true;
236 }
237 else if( token->StartsWith( wxT( "CELL(" ) ) && token->EndsWith( wxT( ")" ) ) )
238 {
239 // Handle CELL("A0") or CELL(0, 1) syntax
240 wxString args = token->Mid( 5, token->Length() - 6 ); // Extract arguments
241 args.Trim( true ).Trim( false ); // Remove whitespace
242
243 SCH_TABLE* table = static_cast<SCH_TABLE*>( GetParent() );
244 if( !table )
245 {
246 *token = wxT( "<Unresolved: CELL() requires table context>" );
247 return true;
248 }
249
250 int targetRow = -1;
251 int targetCol = -1;
252
253 // Check if it's cell("A1") format (string argument with quotes)
254 if( args.StartsWith( wxT( "\"" ) ) && args.EndsWith( wxT( "\"" ) ) )
255 {
256 wxString addr = args.Mid( 1, args.Length() - 2 ); // Remove quotes
257 if( !parseCellAddress( addr, targetRow, targetCol ) )
258 {
259 *token = wxString::Format( wxT( "<Unresolved: Invalid cell address: %s>" ), addr );
260 return true;
261 }
262 }
263 // Check if it's cell(row, col) format (two numeric arguments)
264 else if( args.Find( ',' ) != wxNOT_FOUND )
265 {
266 wxString rowStr = args.BeforeFirst( ',' ).Trim( true ).Trim( false );
267 wxString colStr = args.AfterFirst( ',' ).Trim( true ).Trim( false );
268
269 long rowNum, colNum;
270 if( !rowStr.ToLong( &rowNum ) || !colStr.ToLong( &colNum ) )
271 {
272 *token = wxString::Format( wxT( "<Unresolved: Invalid cell coordinates: %s>" ), args );
273 return true;
274 }
275
276 // Arguments are already 0-based
277 targetRow = rowNum;
278 targetCol = colNum;
279 }
280 else
281 {
282 *token = wxString::Format( wxT( "<Unresolved: Invalid CELL() syntax: %s>" ), args );
283 return true;
284 }
285
286 // Check bounds
287 if( targetRow < 0 || targetRow >= table->GetRowCount() || targetCol < 0
288 || targetCol >= table->GetColCount() )
289 {
290 wxString cellAddr;
291 if( targetRow >= 0 && targetCol >= 0 )
292 {
293 char colLetter = 'A' + ( targetCol % 26 );
294 cellAddr = wxString::Format( wxT( "%c%d" ), colLetter, targetRow );
295 }
296 else
297 {
298 cellAddr = args;
299 }
300 *token = wxString::Format( wxT( "<Unresolved: Cell %s not found>" ), cellAddr );
301 return true;
302 }
303
304 // Get the target cell and return its evaluated text
305 SCH_TABLECELL* targetCell = table->GetCell( targetRow, targetCol );
306 if( targetCell )
307 {
308 // Check for excessive recursion depth (circular references)
310 if( aDepth >= maxDepth )
311 {
312 *token = wxT( "<Circular reference>" );
313 return true;
314 }
315
316 *token = targetCell->GetShownText( aSettings, aPath, aContext, aDepth + 1 );
317 return true;
318 }
319 else
320 {
321 *token = wxT( "<Unresolved: Cell not found>" );
322 return true;
323 }
324 }
325
326 // Fall back to sheet variables
327 if( sheet )
328 {
329 if( sheet->ResolveTextVar( aPath, token, depth + 1 ) )
330 return true;
331 }
332
333 return false;
334 };
335
336 wxString text = EDA_TEXT::GetShownText( aContext, depth );
337
338 if( HasTextVars() && aContext != RAW_VALUE )
339 {
340 text = ResolveTextVars( text, &tableCellResolver, depth );
341
342 // Only do this at the top level (aDepth == 0) to avoid premature unescaping in nested CELL() calls
343 if( aDepth == 0 )
344 FinalizeTextVarExpansion( text, aContext );
345 }
346
347 // Only linebreak when at top level
348 if( aDepth == 0 )
349 {
350 VECTOR2I size = GetEnd() - GetStart();
351 int colWidth;
352
353 if( GetTextAngle().IsVertical() )
354 colWidth = abs( size.y ) - ( GetMarginTop() + GetMarginBottom() );
355 else
356 colWidth = abs( size.x ) - ( GetMarginLeft() + GetMarginRight() );
357
359 IsBold(), IsItalic() );
360 }
361
362 return text;
363}
364
365
367{
368 return static_cast<SCH_TABLE*>( GetParent() )->GetColWidth( GetColumn() );
369}
370
371
373{
374 SCH_TABLE* table = static_cast<SCH_TABLE*>( GetParent() );
375
376 table->SetColWidth( GetColumn(), aWidth );
377 table->Normalize();
378}
379
380
382{
383 return static_cast<SCH_TABLE*>( GetParent() )->GetRowHeight( GetRow() );
384}
385
386
388{
389 SCH_TABLE* table = static_cast<SCH_TABLE*>( GetParent() );
390
391 table->SetRowHeight( GetRow(), aHeight );
392 table->Normalize();
393}
394
395
396void SCH_TABLECELL::Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts, int aUnit,
397 int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed )
398{
399 const int cell_body_style = -1; // flag to disable box ouline plotting
400
401 if( m_colSpan >= 1 && m_rowSpan >= 1 )
402 SCH_TEXTBOX::Plot( aPlotter, aBackground, aPlotOpts, aUnit, cell_body_style, aOffset, aDimmed );
403}
404
405
406void SCH_TABLECELL::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
407{
408 aList.emplace_back( _( "Table Cell" ), GetAddr() );
409
410 // Don't use GetShownText() here; we want to show the user the variable references
411 aList.emplace_back( _( "Text" ), KIUI::EllipsizeStatusText( aFrame, GetText() ) );
412
413 aList.emplace_back( _( "Cell Width" ), aFrame->MessageTextFromValue( std::abs( GetEnd().x - GetStart().x ) ) );
414 aList.emplace_back( _( "Cell Height" ), aFrame->MessageTextFromValue( std::abs( GetEnd().y - GetStart().y ) ) );
415
416 aList.emplace_back( _( "Font" ), GetFont() ? GetFont()->GetName() : _( "Default" ) );
417
418 wxString textStyle[] = { _( "Normal" ), _( "Italic" ), _( "Bold" ), _( "Bold Italic" ) };
419 int style = IsBold() && IsItalic() ? 3 : IsBold() ? 2 : IsItalic() ? 1 : 0;
420 aList.emplace_back( _( "Style" ), textStyle[style] );
421
422 aList.emplace_back( _( "Text Size" ), aFrame->MessageTextFromValue( GetTextWidth() ) );
423}
424
425
426double SCH_TABLECELL::Similarity( const SCH_ITEM& aOtherItem ) const
427{
428 if( aOtherItem.Type() != Type() )
429 return 0.0;
430
431 const SCH_TABLECELL& other = static_cast<const SCH_TABLECELL&>( aOtherItem );
432
433 double similarity = 1.0;
434
435 if( m_colSpan != other.m_colSpan )
436 similarity *= 0.9;
437
438 if( m_rowSpan != other.m_rowSpan )
439 similarity *= 0.9;
440
441 similarity *= SCH_TEXTBOX::Similarity( other );
442
443 return similarity;
444}
445
446
447bool SCH_TABLECELL::operator==( const SCH_ITEM& aOtherItem ) const
448{
449 if( aOtherItem.Type() != Type() )
450 return false;
451
452 const SCH_TABLECELL& other = static_cast<const SCH_TABLECELL&>( aOtherItem );
453
454 return *this == other;
455}
456
457
458bool SCH_TABLECELL::operator==( const SCH_TABLECELL& aOtherItem ) const
459{
460 return m_colSpan == aOtherItem.m_colSpan && m_rowSpan == aOtherItem.m_rowSpan
461 && SCH_TEXTBOX::operator==( aOtherItem );
462}
463
464
466{
468 {
471
480
481 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start X" ) );
482 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Start Y" ) );
483 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "End X" ) );
484 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "End Y" ) );
485
486 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Shape" ) );
487 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Width" ) );
488 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Height" ) );
489 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Fill" ) );
490 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Fill Color" ) );
491 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Width" ) );
492 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Style" ) );
493 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Line Color" ) );
494 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_SHAPE ), _HKI( "Corner Radius" ) );
495
496 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Width" ) );
497 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Height" ) );
498 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Thickness" ) );
499 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Orientation" ) );
500 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Mirrored" ) );
501 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Visible" ) );
502 propMgr.Mask( TYPE_HASH( SCH_TABLECELL ), TYPE_HASH( EDA_TEXT ), _HKI( "Hyperlink" ) );
503
504 const wxString tableProps = _( "Table" );
505
506 propMgr.AddProperty( new PROPERTY<SCH_TABLECELL, int>( _HKI( "Column Width" ),
508 tableProps );
509
510 propMgr.AddProperty( new PROPERTY<SCH_TABLECELL, int>( _HKI( "Row Height" ),
512 tableProps );
513
514 const wxString cellProps = _( "Cell Properties" );
515
516 propMgr.AddProperty( new PROPERTY<SCH_TABLECELL, bool, EDA_SHAPE>( _HKI( "Background Fill" ),
518 cellProps );
519
520 propMgr.AddProperty( new PROPERTY<SCH_TABLECELL, COLOR4D, EDA_SHAPE>( _HKI( "Background Fill Color" ),
522 cellProps )
524 }
constexpr EDA_IU_SCALE schIUScale
Definition base_units.h:130
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
The base class for create windows for drawing purpose.
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
EDA_ITEM * GetParent() const
Definition eda_item.h:112
virtual void SetFilled(bool aFlag)
Definition eda_shape.h:145
void SetFillColor(const COLOR4D &aColor)
Definition eda_shape.h:163
bool IsSolidFill() const
Definition eda_shape.h:126
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition eda_shape.h:334
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition eda_shape.h:284
COLOR4D GetFillColor() const
Definition eda_shape.h:162
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition eda_text.h:94
virtual VECTOR2I GetTextSize() const
Definition eda_text.h:301
bool IsItalic() const
Definition eda_text.h:200
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition eda_text.h:118
KIFONT::FONT * GetFont() const
Definition eda_text.h:286
virtual wxString GetShownText(RESOLUTION_CONTEXT aContext, int aDepth=0) const
Return the string actually shown after processing of the base text.
Definition eda_text.h:128
virtual int GetTextWidth() const
Definition eda_text.h:304
bool HasTextVars() const
Indicates the ShownText has text var references which need to be processed.
Definition eda_text.h:139
virtual EDA_ANGLE GetTextAngle() const
Definition eda_text.h:178
int GetEffectiveTextPenWidth(int aDefaultPenWidth=0) const
The EffectiveTextPenWidth uses the text thickness if > 1 or aDefaultPenWidth.
Definition eda_text.cpp:428
bool IsBold() const
Definition eda_text.h:215
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:612
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
Base plotter engine class.
Definition plotter.h:138
PROPERTY_BASE & SetIsHiddenFromRulesEditor(bool aHide=true)
Definition property.h:361
Provide class metadata.
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.
SCH_ITEM(EDA_ITEM *aParent, KICAD_T aType, int aUnit=0, int aBodyStyle=0)
Definition sch_item.cpp:65
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
SCH_SHEET * Last() const
Return a pointer to the last SCH_SHEET of the list.
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition sch_sheet.h:50
bool ResolveTextVar(const SCH_SHEET_PATH *aPath, wxString *token, int aDepth=0) const
Resolve any references to system tokens supported by the sheet.
double Similarity(const SCH_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
int GetRowHeight() const
void swapData(SCH_ITEM *aItem) override
Swap the internal data structures aItem with the schematic item.
wxString GetShownText(const RENDER_SETTINGS *aSettings, const SCH_SHEET_PATH *aPath, RESOLUTION_CONTEXT aContext, int aDepth=0) const override
SCH_TABLECELL(int aLineWidth=0, FILL_T aFillType=FILL_T::NO_FILL)
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
wxString GetAddr() const
bool operator==(const SCH_TABLECELL &aOther) const
void SetRowSpan(int aSpan)
void SetColumnWidth(int aWidth)
int GetColumn() const
void SetColSpan(int aSpan)
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void Plot(PLOTTER *aPlotter, bool aBackground, const SCH_PLOT_OPTS &aPlotOpts, int aUnit, int aBodyStyle, const VECTOR2I &aOffset, bool aDimmed) override
Plot the item to aPlotter.
void SetRowHeight(int aHeight)
int GetColumnWidth() const
int GetRow() const
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.
int GetMarginBottom() const
Definition sch_textbox.h:82
bool operator==(const SCH_ITEM &aOther) const override
int GetMarginLeft() const
Definition sch_textbox.h:79
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
int GetMarginRight() const
Definition sch_textbox.h:81
void Plot(PLOTTER *aPlotter, bool aBackground, const SCH_PLOT_OPTS &aPlotOpts, int aUnit, int aBodyStyle, const VECTOR2I &aOffset, bool aDimmed) override
Plot the item to aPlotter.
int GetMarginTop() const
Definition sch_textbox.h:80
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void swapData(SCH_ITEM *aItem) override
Swap the internal data structures aItem with the schematic item.
KIFONT::FONT * GetDrawFont(const RENDER_SETTINGS *aSettings) const override
SCH_TEXTBOX(SCH_LAYER_ID aLayer=LAYER_NOTES, int aLineWidth=0, FILL_T aFillType=FILL_T::NO_FILL, const wxString &aText=wxEmptyString, KICAD_T aType=SCH_TEXTBOX_T)
double Similarity(const SCH_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
void FinalizeTextVarExpansion(wxString &aText, RESOLUTION_CONTEXT aContext)
Definition common.cpp:88
wxString ResolveTextVars(const wxString &aSource, const std::function< bool(wxString *)> *aResolver, int &aDepth)
Multi-pass text variable expansion and math expression evaluation.
Definition common.cpp:333
RESOLUTION_CONTEXT
Definition common.h:91
@ RAW_VALUE
Definition common.h:98
#define _(s)
FILL_T
Definition eda_fill.h:29
int m_ResolveTextRecursionDepth
The number of recursions to resolve text variables.
@ LAYER_NOTES
Definition layer_ids.h:498
Message panel definition file.
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 void PackCustomProperties(google::protobuf::RepeatedPtrField< types::CustomProperty > *aOutput, const EDA_ITEM &aItem)
KICOMMON_API void UnpackCustomProperties(const google::protobuf::RepeatedPtrField< types::CustomProperty > &aInput, EDA_ITEM &aItem)
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition eda_angle.h:461
#define _HKI(x)
Definition page_info.cpp:40
#define TYPE_HASH(x)
Macro to generate unique identifier for a type.
Definition property.h:74
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:63
#define REGISTER_TYPE(x)
Helper macro to map type hashes to names.
static struct SCH_TABLECELL_DESC _SCH_TABLECELL_DESC
static bool parseCellAddress(const wxString &aAddr, int &aRow, int &aCol)
Parse a cell address string like "A0" or "B12" into 0-based row and column indices.
const std::string table
@ SCH_TABLECELL_T
Definition typeinfo.h:162
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708