KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_table.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 <pgm_base.h>
25#include <sch_edit_frame.h>
26#include <plotters/plotter.h>
28#include <geometry/shape_rect.h>
29#include <bitmaps.h>
30#include <string_utils.h>
31#include <schematic.h>
33#include <sch_painter.h>
34#include <wx/log.h>
35#include <sch_table.h>
36
37
38SCH_TABLE::SCH_TABLE( int aLineWidth ) :
39 SCH_ITEM( nullptr, SCH_TABLE_T ),
40 m_strokeExternal( true ),
41 m_StrokeHeaderSeparator( true ),
42 m_borderStroke( aLineWidth, LINE_STYLE::DEFAULT, COLOR4D::UNSPECIFIED ),
43 m_strokeRows( true ),
44 m_strokeColumns( true ),
45 m_separatorsStroke( aLineWidth, LINE_STYLE::DEFAULT, COLOR4D::UNSPECIFIED ),
46 m_colCount( 0 )
47{
49}
50
51
53 SCH_ITEM( aTable )
54{
61
62 m_colCount = aTable.m_colCount;
63 m_colWidths = aTable.m_colWidths;
65
66 for( SCH_TABLECELL* src : aTable.m_cells )
67 AddCell( new SCH_TABLECELL( *src ) );
68}
69
70
72{
73 // We own our cells; delete them
74 for( SCH_TABLECELL* cell : m_cells )
75 delete cell;
76}
77
78
80{
81 wxCHECK_RET( aItem != nullptr && aItem->Type() == SCH_TABLE_T,
82 wxT( "Cannot swap data with invalid table." ) );
83
84 SCH_TABLE* table = static_cast<SCH_TABLE*>( aItem );
85
86 std::swap( m_strokeExternal, table->m_strokeExternal );
87 std::swap( m_StrokeHeaderSeparator, table->m_StrokeHeaderSeparator );
88 std::swap( m_borderStroke, table->m_borderStroke );
89 std::swap( m_strokeRows, table->m_strokeRows );
90 std::swap( m_strokeColumns, table->m_strokeColumns );
91 std::swap( m_separatorsStroke, table->m_separatorsStroke );
92
93 std::swap( m_colCount, table->m_colCount );
94 std::swap( m_colWidths, table->m_colWidths );
95 std::swap( m_rowHeights, table->m_rowHeights );
96
97 std::swap( m_cells, table->m_cells );
98
99 for( SCH_TABLECELL* cell : m_cells )
100 cell->SetParent( this );
101
102 for( SCH_TABLECELL* cell : table->m_cells )
103 cell->SetParent( table );
104}
105
106
108{
109 Move( aPos - GetPosition() );
110}
111
112
114{
115 return m_cells[0]->GetPosition();
116}
117
118
120{
121 BOX2I bbox;
122
123 for( SCH_TABLECELL* cell : m_cells )
124 {
125 bbox.Merge( cell->GetPosition() );
126 bbox.Merge( cell->GetEnd() );
127 }
128
129 return bbox.GetCenter();
130}
131
132
134{
135 VECTOR2I tableSize;
136
137 for( int ii = 0; ii < GetColCount(); ++ii )
138 tableSize.x += GetColWidth( ii );
139
140 for( int ii = 0; ii < GetRowCount(); ++ii )
141 tableSize.y += GetRowHeight( ii );
142
143 return GetPosition() + tableSize;
144}
145
146
148{
149 int y = GetPosition().y;
150
151 for( int row = 0; row < GetRowCount(); ++row )
152 {
153 int x = GetPosition().x;
154 int rowHeight = m_rowHeights[ row ];
155
156 for( int col = 0; col < GetColCount(); ++col )
157 {
158 int colWidth = m_colWidths[ col ];
159
160 SCH_TABLECELL* cell = GetCell( row, col );
161 VECTOR2I pos( x, y );
162
163 RotatePoint( pos, GetPosition(), cell->GetTextAngle() );
164
165 if( cell->GetPosition() != pos )
166 {
167 cell->SetPosition( pos );
168 cell->ClearRenderCache();
169 }
170
171 VECTOR2I end = VECTOR2I( x + colWidth, y + rowHeight );
172
173 if( cell->GetColSpan() > 1 || cell->GetRowSpan() > 1 )
174 {
175 for( int ii = col + 1; ii < col + cell->GetColSpan(); ++ii )
176 end.x += m_colWidths[ii];
177
178 for( int ii = row + 1; ii < row + cell->GetRowSpan(); ++ii )
179 end.y += m_rowHeights[ii];
180 }
181
183
184 if( cell->GetEnd() != end )
185 {
186 cell->SetEnd( end );
187 cell->ClearRenderCache();
188 }
189
190 x += colWidth;
191 }
192
193 y += rowHeight;
194 }
195}
196
197
198void SCH_TABLE::Move( const VECTOR2I& aMoveVector )
199{
200 for( SCH_TABLECELL* cell : m_cells )
201 cell->Move( aMoveVector );
202}
203
204
206{
207 // We could mirror all the cells, but it doesn't seem useful....
208}
209
210
212{
213 // We could mirror all the cells, but it doesn't seem useful....
214}
215
216
217void SCH_TABLE::Rotate( const VECTOR2I& aCenter, bool aRotateCCW )
218{
219 for( SCH_TABLECELL* cell : m_cells )
220 cell->Rotate( aCenter, aRotateCCW );
221
222 Normalize();
223}
224
225
226bool SCH_TABLE::operator<( const SCH_ITEM& aItem ) const
227{
228 if( Type() != aItem.Type() )
229 return Type() < aItem.Type();
230
231 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aItem );
232
233 if( m_cells.size() != other.m_cells.size() )
234 return m_cells.size() < other.m_cells.size();
235
236 if( GetPosition().x != other.GetPosition().x )
237 return GetPosition().x < GetPosition().x;
238
239 if( GetPosition().y != GetPosition().y )
240 return GetPosition().y < GetPosition().y;
241
242 return m_cells[0] < other.m_cells[0];
243}
244
245
246void SCH_TABLE::RunOnChildren( const std::function<void( SCH_ITEM* )>& aFunction, RECURSE_MODE aMode )
247{
248 for( SCH_TABLECELL* cell : m_cells )
249 aFunction( cell );
250}
251
252
254{
255 // Note: a table with no cells is not allowed
256 BOX2I bbox = m_cells[0]->GetBoundingBox();
257
258 bbox.Merge( m_cells[ m_cells.size() - 1 ]->GetBoundingBox() );
259
260 return bbox;
261}
262
263
264INSPECT_RESULT SCH_TABLE::Visit( INSPECTOR aInspector, void* aTestData,
265 const std::vector<KICAD_T>& aScanTypes )
266{
267 for( KICAD_T scanType : aScanTypes )
268 {
269 if( scanType == SCH_LOCATE_ANY_T || scanType == SCH_TABLE_T )
270 {
271 if( INSPECT_RESULT::QUIT == aInspector( this, aTestData ) )
272 return INSPECT_RESULT::QUIT;
273 }
274
275 if( scanType == SCH_LOCATE_ANY_T || scanType == SCH_TABLECELL_T )
276 {
277 for( SCH_TABLECELL* cell : m_cells )
278 {
279 if( INSPECT_RESULT::QUIT == aInspector( cell, (void*) this ) )
280 return INSPECT_RESULT::QUIT;
281 }
282 }
283 }
284
285 return INSPECT_RESULT::CONTINUE;
286}
287
288
289wxString SCH_TABLE::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
290{
291 return wxString::Format( _( "%d Column Table" ), m_colCount );
292}
293
294
296{
297 return BITMAPS::spreadsheet; // JEY TODO
298}
299
300
301std::vector<int> SCH_TABLE::ViewGetLayers() const
302{
304}
305
306
307bool SCH_TABLE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
308{
309 BOX2I rect = GetBoundingBox();
310
311 rect.Inflate( aAccuracy );
312
313 return rect.Contains( aPosition );
314}
315
316
317bool SCH_TABLE::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
318{
319 BOX2I rect = aRect;
320
321 rect.Inflate( aAccuracy );
322
323 if( aContained )
324 return rect.Contains( GetBoundingBox() );
325
326 return rect.Intersects( GetBoundingBox() );
327}
328
329
330void SCH_TABLE::DrawBorders( const std::function<void( const VECTOR2I& aPt1, const VECTOR2I& aPt2,
331 const STROKE_PARAMS& aStroke )>& aCallback ) const
332{
333 EDA_ANGLE drawAngle = GetCell( 0, 0 )->GetTextAngle();
334
335 std::vector<VECTOR2I> topLeft = GetCell( 0, 0 )->GetCornersInSequence( drawAngle );
336 std::vector<VECTOR2I> bottomLeft = GetCell( GetRowCount() - 1, 0 )->GetCornersInSequence( drawAngle );
337 std::vector<VECTOR2I> topRight = GetCell( 0, GetColCount() - 1 )->GetCornersInSequence( drawAngle );
338 std::vector<VECTOR2I> bottomRight =
339 GetCell( GetRowCount() - 1, GetColCount() - 1 )->GetCornersInSequence( drawAngle );
340 STROKE_PARAMS stroke;
341
342 for( int col = 0; col < GetColCount() - 1; ++col )
343 {
344 if( StrokeColumns() )
345 stroke = GetSeparatorsStroke();
346 else
347 continue;
348
349 for( int row = 0; row < GetRowCount(); ++row )
350 {
351 SCH_TABLECELL* cell = GetCell( row, col );
352
353 if( cell->GetColSpan() == 0 )
354 continue;
355
356 if( col + cell->GetColSpan() == GetColCount() )
357 continue;
358
359 std::vector<VECTOR2I> corners = cell->GetCornersInSequence( drawAngle );
360
361 if( corners.size() == 4 )
362 aCallback( corners[1], corners[2], stroke );
363 }
364 }
365
366 for( int row = 0; row < GetRowCount() - 1; ++row )
367 {
368 if( row == 0 && StrokeHeaderSeparator() )
369 stroke = GetBorderStroke();
370 else if( StrokeRows() )
371 stroke = GetSeparatorsStroke();
372 else
373 continue;
374
375 for( int col = 0; col < GetColCount(); ++col )
376 {
377 SCH_TABLECELL* cell = GetCell( row, col );
378
379 if( cell->GetRowSpan() == 0 )
380 continue;
381
382 if( row + cell->GetRowSpan() == GetRowCount() )
383 continue;
384
385 std::vector<VECTOR2I> corners = cell->GetCornersInSequence( drawAngle );
386
387 if( corners.size() == 4 )
388 aCallback( corners[2], corners[3], stroke );
389 }
390 }
391
392 if( StrokeExternal() && GetBorderStroke().GetWidth() >= 0 )
393 {
394 aCallback( topLeft[0], topRight[1], GetBorderStroke() );
395 aCallback( topRight[1], bottomRight[2], GetBorderStroke() );
396 aCallback( bottomRight[2], bottomLeft[3], GetBorderStroke() );
397 aCallback( bottomLeft[3], topLeft[0], GetBorderStroke() );
398 }
399}
400
401
402void SCH_TABLE::Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
403 int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed )
404{
405 for( SCH_TABLECELL* cell : m_cells )
406 cell->Plot( aPlotter, aBackground, aPlotOpts, aUnit, aBodyStyle, aOffset, aDimmed );
407
408 if( aBackground )
409 return;
410
411 RENDER_SETTINGS* settings = aPlotter->RenderSettings();
412
414 [&]( const VECTOR2I& ptA, const VECTOR2I& ptB, const STROKE_PARAMS& stroke )
415 {
416 int lineWidth = stroke.GetWidth();
417 COLOR4D color = stroke.GetColor();
418 LINE_STYLE lineStyle = stroke.GetLineStyle();
419
420 if( lineWidth == 0 )
421 {
422 if( SCHEMATIC* schematic = Schematic() )
423 lineWidth = schematic->Settings().m_DefaultLineWidth;
424 else
426 }
427
428 if( lineWidth < settings->GetMinPenWidth() )
429 lineWidth = settings->GetMinPenWidth();
430
431 if( !aPlotter->GetColorMode() || color == COLOR4D::UNSPECIFIED )
432 color = settings->GetLayerColor( m_layer );
433
434 if( lineStyle == LINE_STYLE::DEFAULT )
435 lineStyle = LINE_STYLE::SOLID;
436
437 aPlotter->SetColor( color );
438 aPlotter->SetDash( lineWidth, lineStyle );
439
440 aPlotter->MoveTo( ptA );
441 aPlotter->FinishTo( ptB );
442 } );
443}
444
445
446void SCH_TABLE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
447{
448 // Don't use GetShownText() here; we want to show the user the variable references
449 aList.emplace_back( _( "Table" ), wxString::Format( _( "%d Columns" ), m_colCount ) );
450
451 SCH_ITEM::GetMsgPanelInfo( aFrame, aList );
452}
453
454
455bool SCH_TABLE::operator==( const SCH_ITEM& aOther ) const
456{
457 if( Type() != aOther.Type() )
458 return false;
459
460 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aOther );
461
462 if( m_cells.size() != other.m_cells.size() )
463 return false;
464
465 if( m_colWidths != other.m_colWidths )
466 return false;
467
468 if( m_rowHeights != other.m_rowHeights )
469 return false;
470
471 for( int ii = 0; ii < (int) m_cells.size(); ++ii )
472 {
473 if( !( *m_cells[ii] == *other.m_cells[ii] ) )
474 return false;
475 }
476
477 return true;
478}
479
480
481double SCH_TABLE::Similarity( const SCH_ITEM& aOther ) const
482{
483 if( aOther.Type() != Type() )
484 return 0.0;
485
486 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aOther );
487
488 if( m_cells.size() != other.m_cells.size() )
489 return 0.1;
490
491 double similarity = 1.0;
492
493 for( int ii = 0; ii < (int) m_cells.size(); ++ii )
494 similarity *= m_cells[ii]->Similarity( *other.m_cells[ii] );
495
496 return similarity;
497}
498
499
500static struct SCH_TABLE_DESC
501{
503 {
506
509
510 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Start X" ),
511 &SCH_TABLE::SetPositionX, &SCH_TABLE::GetPositionX, PROPERTY_DISPLAY::PT_COORD,
513 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Start Y" ),
514 &SCH_TABLE::SetPositionY, &SCH_TABLE::GetPositionY, PROPERTY_DISPLAY::PT_COORD,
516
517 const wxString tableProps = _( "Table Properties" );
518
519 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "External Border" ),
521 tableProps );
522
523 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Header Border" ),
525 tableProps );
526
527 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Border Width" ),
529 PROPERTY_DISPLAY::PT_SIZE ),
530 tableProps );
531
532 propMgr.AddProperty( new PROPERTY_ENUM<SCH_TABLE, LINE_STYLE>( _HKI( "Border Style" ),
534 tableProps );
535
536 propMgr.AddProperty( new PROPERTY<SCH_TABLE, COLOR4D>( _HKI( "Border Color" ),
538 tableProps );
539
540 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Row Separators" ),
542 tableProps );
543
544 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Cell Separators" ),
546 tableProps );
547
548 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Separators Width" ),
550 PROPERTY_DISPLAY::PT_SIZE ),
551 tableProps );
552
553 propMgr.AddProperty( new PROPERTY_ENUM<SCH_TABLE, LINE_STYLE>( _HKI( "Separators Style" ),
555 tableProps );
556
557 propMgr.AddProperty( new PROPERTY<SCH_TABLE, COLOR4D>( _HKI( "Separators Color" ),
559 tableProps );
560 }
int color
Definition: DXF_plotter.cpp:63
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:114
BITMAPS
A list of all bitmap identifiers.
Definition: bitmaps_list.h:33
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 BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:658
constexpr const Vec GetCenter() const
Definition: box2.h:230
constexpr bool Contains(const Vec &aPoint) const
Definition: box2.h:168
constexpr bool Intersects(const BOX2< Vec > &aRect) const
Definition: box2.h:311
The base class for create windows for drawing purpose.
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:110
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:113
std::vector< VECTOR2I > GetCornersInSequence(EDA_ANGLE angle) const
Definition: eda_shape.cpp:1614
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:215
void SetEnd(const VECTOR2I &aEnd)
Definition: eda_shape.h:219
const EDA_ANGLE & GetTextAngle() const
Definition: eda_text.h:144
virtual void ClearRenderCache()
Definition: eda_text.cpp:663
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
Base plotter engine class.
Definition: plotter.h:121
void MoveTo(const VECTOR2I &pos)
Definition: plotter.h:261
virtual void SetDash(int aLineWidth, LINE_STYLE aLineStyle)=0
void FinishTo(const VECTOR2I &pos)
Definition: plotter.h:271
RENDER_SETTINGS * RenderSettings()
Definition: plotter.h:152
bool GetColorMode() const
Definition: plotter.h:149
virtual void SetColor(const COLOR4D &color)=0
Provide class metadata.Helper macro to map type hashes to names.
Definition: property_mgr.h:74
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
static PROPERTY_MANAGER & Instance()
Definition: property_mgr.h:76
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
void AddTypeCast(TYPE_CAST_BASE *aCast)
Register a type converter.
Holds all the data relating to one schematic.
Definition: schematic.h:88
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:168
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.
Definition: sch_item.cpp:661
SCHEMATIC * Schematic() const
Search the item hierarchy to find a SCHEMATIC.
Definition: sch_item.cpp:246
void SetLayer(SCH_LAYER_ID aLayer)
Definition: sch_item.h:314
SCH_LAYER_ID m_layer
Definition: sch_item.h:744
void SetPosition(const VECTOR2I &aPos) override
Definition: sch_shape.h:85
VECTOR2I GetPosition() const override
Definition: sch_shape.h:84
int GetColSpan() const
Definition: sch_tablecell.h:64
int GetRowSpan() const
Definition: sch_tablecell.h:67
void SetBorderWidth(int aWidth)
Definition: sch_table.h:61
void SetSeparatorsStyle(const LINE_STYLE aStyle)
Definition: sch_table.h:82
LINE_STYLE GetSeparatorsStyle() const
Definition: sch_table.h:87
std::vector< int > ViewGetLayers() const override
Return the layers the item is drawn on (which may be more than its "home" layer)
Definition: sch_table.cpp:301
double Similarity(const SCH_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
Definition: sch_table.cpp:481
bool operator<(const SCH_ITEM &aItem) const override
Definition: sch_table.cpp:226
std::vector< SCH_TABLECELL * > m_cells
Definition: sch_table.h:254
const STROKE_PARAMS & GetSeparatorsStroke() const
Definition: sch_table.h:77
std::map< int, int > m_rowHeights
Definition: sch_table.h:253
bool m_strokeColumns
Definition: sch_table.h:248
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
Definition: sch_table.cpp:307
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: sch_table.cpp:253
void MirrorHorizontally(int aCenter) override
Mirror item horizontally about aCenter.
Definition: sch_table.cpp:205
bool StrokeExternal() const
Definition: sch_table.h:53
void SetBorderColor(const COLOR4D &aColor)
Definition: sch_table.h:73
bool m_strokeRows
Definition: sch_table.h:247
int GetPositionY() const
Definition: sch_table.h:117
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
Definition: sch_table.cpp:289
void SetPositionX(int x)
Definition: sch_table.h:114
LINE_STYLE GetBorderStyle() const
Definition: sch_table.h:65
void SetSeparatorsColor(const COLOR4D &aColor)
Definition: sch_table.h:95
int GetRowHeight(int aRow) const
Definition: sch_table.h:139
void RunOnChildren(const std::function< void(SCH_ITEM *)> &aFunction, RECURSE_MODE aMode) override
Definition: sch_table.cpp:246
COLOR4D GetSeparatorsColor() const
Definition: sch_table.h:96
SCH_TABLE(int aLineWidth=0)
Definition: sch_table.cpp:38
void MirrorVertically(int aCenter) override
Mirror item vertically about aCenter.
Definition: sch_table.cpp:211
INSPECT_RESULT Visit(INSPECTOR inspector, void *testData, const std::vector< KICAD_T > &aScanTypes) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
Definition: sch_table.cpp:264
void DrawBorders(const std::function< void(const VECTOR2I &aPt1, const VECTOR2I &aPt2, const STROKE_PARAMS &aStroke)> &aCallback) const
Definition: sch_table.cpp:330
int GetColWidth(int aCol) const
Definition: sch_table.h:129
void SetStrokeHeaderSeparator(bool aDoStroke)
Definition: sch_table.h:55
void AddCell(SCH_TABLECELL *aCell)
Definition: sch_table.h:162
void SetSeparatorsWidth(int aWidth)
Definition: sch_table.h:79
const STROKE_PARAMS & GetBorderStroke() const
Definition: sch_table.h:59
bool m_StrokeHeaderSeparator
Definition: sch_table.h:245
VECTOR2I GetCenter() const
Definition: sch_table.cpp:119
int m_colCount
Definition: sch_table.h:251
VECTOR2I GetPosition() const override
Definition: sch_table.cpp:113
void swapData(SCH_ITEM *aItem) override
Swap the internal data structures aItem with the schematic item.
Definition: sch_table.cpp:79
void SetStrokeExternal(bool aDoStroke)
Definition: sch_table.h:52
VECTOR2I GetEnd() const
Definition: sch_table.cpp:133
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.
Definition: sch_table.cpp:446
void SetPositionY(int y)
Definition: sch_table.h:115
STROKE_PARAMS m_separatorsStroke
Definition: sch_table.h:249
int GetColCount() const
Definition: sch_table.h:120
bool StrokeHeaderSeparator() const
Definition: sch_table.h:56
bool m_strokeExternal
Definition: sch_table.h:244
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.
Definition: sch_table.cpp:402
std::map< int, int > m_colWidths
Definition: sch_table.h:252
void SetStrokeColumns(bool aDoStroke)
Definition: sch_table.h:98
SCH_TABLECELL * GetCell(int aRow, int aCol) const
Definition: sch_table.h:147
int GetSeparatorsWidth() const
Definition: sch_table.h:80
bool StrokeColumns() const
Definition: sch_table.h:99
void SetPosition(const VECTOR2I &aPos) override
Definition: sch_table.cpp:107
int GetPositionX() const
Definition: sch_table.h:116
bool StrokeRows() const
Definition: sch_table.h:102
STROKE_PARAMS m_borderStroke
Definition: sch_table.h:246
int GetRowCount() const
Definition: sch_table.h:122
void SetStrokeRows(bool aDoStroke)
Definition: sch_table.h:101
void SetBorderStyle(const LINE_STYLE aStyle)
Definition: sch_table.h:64
COLOR4D GetBorderColor() const
Definition: sch_table.h:74
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
Definition: sch_table.cpp:295
bool operator==(const SCH_ITEM &aOther) const override
Definition: sch_table.cpp:455
int GetBorderWidth() const
Definition: sch_table.h:62
void Normalize()
Definition: sch_table.cpp:147
void Move(const VECTOR2I &aMoveVector) override
Move the item by aMoveVector to a new position.
Definition: sch_table.cpp:198
void Rotate(const VECTOR2I &aCenter, bool aRotateCCW) override
Rotate the item around aCenter 90 degrees in the clockwise direction.
Definition: sch_table.cpp:217
Simple container to manage line stroke parameters.
Definition: stroke_params.h:94
int GetWidth() const
LINE_STYLE GetLineStyle() const
KIGFX::COLOR4D GetColor() const
#define DEFAULT_LINE_WIDTH_MILS
The default wire width in mils. (can be changed in preference menu)
#define _HKI(x)
#define _(s)
RECURSE_MODE
Definition: eda_item.h:50
INSPECT_RESULT
Definition: eda_item.h:44
const INSPECTOR_FUNC & INSPECTOR
std::function passed to nested users by ref, avoids copying std::function.
Definition: eda_item.h:91
@ LAYER_NOTES
Definition: layer_ids.h:457
@ LAYER_NOTES_BACKGROUND
Definition: layer_ids.h:459
@ LAYER_SELECTION_SHADOWS
Definition: layer_ids.h:484
see class PGM_BASE
#define TYPE_HASH(x)
Definition: property.h:72
#define REGISTER_TYPE(x)
Definition: property_mgr.h:351
static struct SCH_TABLE_DESC _SCH_TABLE_DESC
LINE_STYLE
Dashed line types.
Definition: stroke_params.h:46
constexpr int MilsToIU(int mils) const
Definition: base_units.h:97
VECTOR2I end
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
@ SCH_TABLE_T
Definition: typeinfo.h:166
@ SCH_TABLECELL_T
Definition: typeinfo.h:167
@ SCH_LOCATE_ANY_T
Definition: typeinfo.h:200
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695