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>
37
38
39SCH_TABLE::SCH_TABLE( int aLineWidth ) :
40 SCH_ITEM( nullptr, SCH_TABLE_T ),
41 m_strokeExternal( true ),
44 m_strokeRows( true ),
45 m_strokeColumns( true ),
47 m_colCount( 0 )
48{
50}
51
52
54 SCH_ITEM( aTable )
55{
62
63 m_colCount = aTable.m_colCount;
64 m_colWidths = aTable.m_colWidths;
66
67 for( SCH_TABLECELL* src : aTable.m_cells )
68 AddCell( new SCH_TABLECELL( *src ) );
69}
70
71
73{
74 // We own our cells; delete them
75 for( SCH_TABLECELL* cell : m_cells )
76 delete cell;
77}
78
79
81{
82 wxCHECK_RET( aItem != nullptr && aItem->Type() == SCH_TABLE_T,
83 wxT( "Cannot swap data with invalid table." ) );
84
85 SCH_TABLE* table = static_cast<SCH_TABLE*>( aItem );
86
87 std::swap( m_strokeExternal, table->m_strokeExternal );
88 std::swap( m_StrokeHeaderSeparator, table->m_StrokeHeaderSeparator );
89 std::swap( m_borderStroke, table->m_borderStroke );
90 std::swap( m_strokeRows, table->m_strokeRows );
91 std::swap( m_strokeColumns, table->m_strokeColumns );
92 std::swap( m_separatorsStroke, table->m_separatorsStroke );
93
94 std::swap( m_colCount, table->m_colCount );
95 std::swap( m_colWidths, table->m_colWidths );
96 std::swap( m_rowHeights, table->m_rowHeights );
97
98 std::swap( m_cells, table->m_cells );
99
100 for( SCH_TABLECELL* cell : m_cells )
101 cell->SetParent( this );
102
103 for( SCH_TABLECELL* cell : table->m_cells )
104 cell->SetParent( table );
105}
106
107
109{
110 Move( aPos - GetPosition() );
111}
112
113
115{
116 return m_cells[0]->GetPosition();
117}
118
119
121{
122 BOX2I bbox;
123
124 for( SCH_TABLECELL* cell : m_cells )
125 {
126 bbox.Merge( cell->GetPosition() );
127 bbox.Merge( cell->GetEnd() );
128 }
129
130 return bbox.GetCenter();
131}
132
133
135{
136 VECTOR2I tableSize;
137
138 for( int ii = 0; ii < GetColCount(); ++ii )
139 tableSize.x += GetColWidth( ii );
140
141 for( int ii = 0; ii < GetRowCount(); ++ii )
142 tableSize.y += GetRowHeight( ii );
143
144 return GetPosition() + tableSize;
145}
146
147
149{
150 int y = GetPosition().y;
151
152 for( int row = 0; row < GetRowCount(); ++row )
153 {
154 int x = GetPosition().x;
155 int rowHeight = m_rowHeights[ row ];
156
157 for( int col = 0; col < GetColCount(); ++col )
158 {
159 int colWidth = m_colWidths[ col ];
160
161 SCH_TABLECELL* cell = GetCell( row, col );
162 VECTOR2I pos( x, y );
163
164 RotatePoint( pos, GetPosition(), cell->GetTextAngle() );
165
166 if( cell->GetPosition() != pos )
167 {
168 cell->SetPosition( pos );
169 cell->ClearRenderCache();
170 }
171
172 VECTOR2I end = VECTOR2I( x + colWidth, y + rowHeight );
173
174 if( cell->GetColSpan() > 1 || cell->GetRowSpan() > 1 )
175 {
176 for( int ii = col + 1; ii < col + cell->GetColSpan(); ++ii )
177 end.x += m_colWidths[ii];
178
179 for( int ii = row + 1; ii < row + cell->GetRowSpan(); ++ii )
180 end.y += m_rowHeights[ii];
181 }
182
184
185 if( cell->GetEnd() != end )
186 {
187 cell->SetEnd( end );
188 cell->ClearRenderCache();
189 }
190
191 x += colWidth;
192 }
193
194 y += rowHeight;
195 }
196}
197
198
199void SCH_TABLE::Move( const VECTOR2I& aMoveVector )
200{
201 for( SCH_TABLECELL* cell : m_cells )
202 cell->Move( aMoveVector );
203}
204
205
207{
208 // We could mirror all the cells, but it doesn't seem useful....
209}
210
211
213{
214 // We could mirror all the cells, but it doesn't seem useful....
215}
216
217
218void SCH_TABLE::Rotate( const VECTOR2I& aCenter, bool aRotateCCW )
219{
220 for( SCH_TABLECELL* cell : m_cells )
221 cell->Rotate( aCenter, aRotateCCW );
222
223 Normalize();
224}
225
226
227bool SCH_TABLE::operator<( const SCH_ITEM& aItem ) const
228{
229 if( Type() != aItem.Type() )
230 return Type() < aItem.Type();
231
232 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aItem );
233
234 if( m_cells.size() != other.m_cells.size() )
235 return m_cells.size() < other.m_cells.size();
236
237 if( GetPosition().x != other.GetPosition().x )
238 return GetPosition().x < GetPosition().x;
239
240 if( GetPosition().y != GetPosition().y )
241 return GetPosition().y < GetPosition().y;
242
243 return m_cells[0] < other.m_cells[0];
244}
245
246
247void SCH_TABLE::RunOnChildren( const std::function<void( SCH_ITEM* )>& aFunction, RECURSE_MODE aMode )
248{
249 for( SCH_TABLECELL* cell : m_cells )
250 aFunction( cell );
251}
252
253
255{
256 // Note: a table with no cells is not allowed
257 BOX2I bbox = m_cells[0]->GetBoundingBox();
258
259 bbox.Merge( m_cells[ m_cells.size() - 1 ]->GetBoundingBox() );
260
261 return bbox;
262}
263
264
265INSPECT_RESULT SCH_TABLE::Visit( INSPECTOR aInspector, void* aTestData,
266 const std::vector<KICAD_T>& aScanTypes )
267{
268 for( KICAD_T scanType : aScanTypes )
269 {
270 if( scanType == SCH_LOCATE_ANY_T || scanType == SCH_TABLE_T )
271 {
272 if( INSPECT_RESULT::QUIT == aInspector( this, aTestData ) )
274 }
275
276 if( scanType == SCH_LOCATE_ANY_T || scanType == SCH_TABLECELL_T )
277 {
278 for( SCH_TABLECELL* cell : m_cells )
279 {
280 if( INSPECT_RESULT::QUIT == aInspector( cell, (void*) this ) )
282 }
283 }
284 }
285
287}
288
289
290wxString SCH_TABLE::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
291{
292 return wxString::Format( _( "%d Column Table" ), m_colCount );
293}
294
295
297{
298 return BITMAPS::spreadsheet; // JEY TODO
299}
300
301
302std::vector<int> SCH_TABLE::ViewGetLayers() const
303{
305}
306
307
308bool SCH_TABLE::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
309{
310 BOX2I rect = GetBoundingBox();
311
312 rect.Inflate( aAccuracy );
313
314 return rect.Contains( aPosition );
315}
316
317
318bool SCH_TABLE::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
319{
320 BOX2I rect = aRect;
321
322 rect.Inflate( aAccuracy );
323
324 if( aContained )
325 return rect.Contains( GetBoundingBox() );
326
327 return rect.Intersects( GetBoundingBox() );
328}
329
330
331bool SCH_TABLE::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
332{
333 return KIGEOM::BoxHitTest( aPoly, GetBoundingBox(), aContained );
334}
335
336
337void SCH_TABLE::DrawBorders( const std::function<void( const VECTOR2I& aPt1, const VECTOR2I& aPt2,
338 const STROKE_PARAMS& aStroke )>& aCallback ) const
339{
340 EDA_ANGLE drawAngle = GetCell( 0, 0 )->GetTextAngle();
341
342 std::vector<VECTOR2I> topLeft = GetCell( 0, 0 )->GetCornersInSequence( drawAngle );
343 std::vector<VECTOR2I> bottomLeft = GetCell( GetRowCount() - 1, 0 )->GetCornersInSequence( drawAngle );
344 std::vector<VECTOR2I> topRight = GetCell( 0, GetColCount() - 1 )->GetCornersInSequence( drawAngle );
345 std::vector<VECTOR2I> bottomRight =
346 GetCell( GetRowCount() - 1, GetColCount() - 1 )->GetCornersInSequence( drawAngle );
347 STROKE_PARAMS stroke;
348
349 for( int col = 0; col < GetColCount() - 1; ++col )
350 {
351 if( StrokeColumns() )
352 stroke = GetSeparatorsStroke();
353 else
354 continue;
355
356 for( int row = 0; row < GetRowCount(); ++row )
357 {
358 SCH_TABLECELL* cell = GetCell( row, col );
359
360 if( cell->GetColSpan() == 0 )
361 continue;
362
363 if( col + cell->GetColSpan() == GetColCount() )
364 continue;
365
366 std::vector<VECTOR2I> corners = cell->GetCornersInSequence( drawAngle );
367
368 if( corners.size() == 4 )
369 aCallback( corners[1], corners[2], stroke );
370 }
371 }
372
373 for( int row = 0; row < GetRowCount() - 1; ++row )
374 {
375 if( row == 0 && StrokeHeaderSeparator() )
376 stroke = GetBorderStroke();
377 else if( StrokeRows() )
378 stroke = GetSeparatorsStroke();
379 else
380 continue;
381
382 for( int col = 0; col < GetColCount(); ++col )
383 {
384 SCH_TABLECELL* cell = GetCell( row, col );
385
386 if( cell->GetRowSpan() == 0 )
387 continue;
388
389 if( row + cell->GetRowSpan() == GetRowCount() )
390 continue;
391
392 std::vector<VECTOR2I> corners = cell->GetCornersInSequence( drawAngle );
393
394 if( corners.size() == 4 )
395 aCallback( corners[2], corners[3], stroke );
396 }
397 }
398
399 if( StrokeExternal() && GetBorderStroke().GetWidth() >= 0 )
400 {
401 aCallback( topLeft[0], topRight[1], GetBorderStroke() );
402 aCallback( topRight[1], bottomRight[2], GetBorderStroke() );
403 aCallback( bottomRight[2], bottomLeft[3], GetBorderStroke() );
404 aCallback( bottomLeft[3], topLeft[0], GetBorderStroke() );
405 }
406}
407
408
409void SCH_TABLE::Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
410 int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed )
411{
412 for( SCH_TABLECELL* cell : m_cells )
413 cell->Plot( aPlotter, aBackground, aPlotOpts, aUnit, aBodyStyle, aOffset, aDimmed );
414
415 if( aBackground )
416 return;
417
418 RENDER_SETTINGS* settings = aPlotter->RenderSettings();
419
421 [&]( const VECTOR2I& ptA, const VECTOR2I& ptB, const STROKE_PARAMS& stroke )
422 {
423 int lineWidth = stroke.GetWidth();
424 COLOR4D color = stroke.GetColor();
425 LINE_STYLE lineStyle = stroke.GetLineStyle();
426
427 if( lineWidth == 0 )
428 {
429 if( SCHEMATIC* schematic = Schematic() )
430 lineWidth = schematic->Settings().m_DefaultLineWidth;
431 else
432 lineWidth = schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS );
433 }
434
435 if( lineWidth < settings->GetMinPenWidth() )
436 lineWidth = settings->GetMinPenWidth();
437
438 if( !aPlotter->GetColorMode() || color == COLOR4D::UNSPECIFIED )
439 color = settings->GetLayerColor( m_layer );
440
441 if( lineStyle == LINE_STYLE::DEFAULT )
442 lineStyle = LINE_STYLE::SOLID;
443
444 aPlotter->SetColor( color );
445 aPlotter->SetDash( lineWidth, lineStyle );
446
447 aPlotter->MoveTo( ptA );
448 aPlotter->FinishTo( ptB );
449 } );
450}
451
452
453void SCH_TABLE::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
454{
455 // Don't use GetShownText() here; we want to show the user the variable references
456 aList.emplace_back( _( "Table" ), wxString::Format( _( "%d Columns" ), m_colCount ) );
457
458 SCH_ITEM::GetMsgPanelInfo( aFrame, aList );
459}
460
461
462bool SCH_TABLE::operator==( const SCH_ITEM& aOther ) const
463{
464 if( Type() != aOther.Type() )
465 return false;
466
467 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aOther );
468
469 if( m_cells.size() != other.m_cells.size() )
470 return false;
471
472 if( m_colWidths != other.m_colWidths )
473 return false;
474
475 if( m_rowHeights != other.m_rowHeights )
476 return false;
477
478 for( int ii = 0; ii < (int) m_cells.size(); ++ii )
479 {
480 if( !( *m_cells[ii] == *other.m_cells[ii] ) )
481 return false;
482 }
483
484 return true;
485}
486
487
488double SCH_TABLE::Similarity( const SCH_ITEM& aOther ) const
489{
490 if( aOther.Type() != Type() )
491 return 0.0;
492
493 const SCH_TABLE& other = static_cast<const SCH_TABLE&>( aOther );
494
495 if( m_cells.size() != other.m_cells.size() )
496 return 0.1;
497
498 double similarity = 1.0;
499
500 for( int ii = 0; ii < (int) m_cells.size(); ++ii )
501 similarity *= m_cells[ii]->Similarity( *other.m_cells[ii] );
502
503 return similarity;
504}
505
506
507static struct SCH_TABLE_DESC
508{
510 {
513
516
517 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Start X" ),
520 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Start Y" ),
523
524 const wxString tableProps = _( "Table Properties" );
525
526 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "External Border" ),
528 tableProps );
529
530 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Header Border" ),
532 tableProps );
533
534 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Border Width" ),
537 tableProps );
538
539 propMgr.AddProperty( new PROPERTY_ENUM<SCH_TABLE, LINE_STYLE>( _HKI( "Border Style" ),
541 tableProps );
542
543 propMgr.AddProperty( new PROPERTY<SCH_TABLE, COLOR4D>( _HKI( "Border Color" ),
545 tableProps );
546
547 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Row Separators" ),
549 tableProps );
550
551 propMgr.AddProperty( new PROPERTY<SCH_TABLE, bool>( _HKI( "Cell Separators" ),
553 tableProps );
554
555 propMgr.AddProperty( new PROPERTY<SCH_TABLE, int>( _HKI( "Separators Width" ),
558 tableProps );
559
560 propMgr.AddProperty( new PROPERTY_ENUM<SCH_TABLE, LINE_STYLE>( _HKI( "Separators Style" ),
562 tableProps );
563
564 propMgr.AddProperty( new PROPERTY<SCH_TABLE, COLOR4D>( _HKI( "Separators Color" ),
566 tableProps );
567 }
int color
constexpr EDA_IU_SCALE schIUScale
Definition base_units.h:114
BITMAPS
A list of all bitmap identifiers.
BOX2< VECTOR2I > BOX2I
Definition box2.h:922
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
static const COLOR4D UNSPECIFIED
For legacy support; used as a value to indicate color hasn't been set yet.
Definition color4d.h:398
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
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:146
virtual void ClearRenderCache()
Definition eda_text.cpp:672
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:262
virtual void SetDash(int aLineWidth, LINE_STYLE aLineStyle)=0
void FinishTo(const VECTOR2I &pos)
Definition plotter.h:272
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.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
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.
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:167
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:637
SCHEMATIC * Schematic() const
Search the item hierarchy to find a SCHEMATIC.
Definition sch_item.cpp:217
void SetLayer(SCH_LAYER_ID aLayer)
Definition sch_item.h:310
SCH_ITEM(EDA_ITEM *aParent, KICAD_T aType, int aUnit=0, int aBodyStyle=0)
Definition sch_item.cpp:51
SCH_LAYER_ID m_layer
Definition sch_item.h:739
void SetPosition(const VECTOR2I &aPos) override
Definition sch_shape.h:86
VECTOR2I GetPosition() const override
Definition sch_shape.h:85
int GetColSpan() const
int GetRowSpan() const
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)
double Similarity(const SCH_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
bool operator<(const SCH_ITEM &aItem) const override
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.
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
void MirrorHorizontally(int aCenter) override
Mirror item horizontally about aCenter.
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.
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
COLOR4D GetSeparatorsColor() const
Definition sch_table.h:96
SCH_TABLE(int aLineWidth=0)
Definition sch_table.cpp:39
void MirrorVertically(int aCenter) override
Mirror item vertically about aCenter.
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...
void DrawBorders(const std::function< void(const VECTOR2I &aPt1, const VECTOR2I &aPt2, const STROKE_PARAMS &aStroke)> &aCallback) const
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
int m_colCount
Definition sch_table.h:251
VECTOR2I GetPosition() const override
void swapData(SCH_ITEM *aItem) override
Swap the internal data structures aItem with the schematic item.
Definition sch_table.cpp:80
void SetStrokeExternal(bool aDoStroke)
Definition sch_table.h:52
VECTOR2I GetEnd() const
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 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.
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
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.
bool operator==(const SCH_ITEM &aOther) const override
int GetBorderWidth() const
Definition sch_table.h:62
void Normalize()
void Move(const VECTOR2I &aMoveVector) override
Move the item by aMoveVector to a new position.
void Rotate(const VECTOR2I &aCenter, bool aRotateCCW) override
Rotate the item around aCenter 90 degrees in the clockwise direction.
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Simple container to manage line stroke parameters.
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 _(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
a few functions useful in geometry calculations.
@ LAYER_NOTES
Definition layer_ids.h:466
@ LAYER_NOTES_BACKGROUND
Definition layer_ids.h:468
@ LAYER_SELECTION_SHADOWS
Definition layer_ids.h:493
bool BoxHitTest(const VECTOR2I &aHitPoint, const BOX2I &aHittee, int aAccuracy)
Perform a point-to-box hit test.
#define _HKI(x)
Definition page_info.cpp:44
see class PGM_BASE
#define TYPE_HASH(x)
Definition property.h:73
@ PT_COORD
Coordinate expressed in distance units (mm/inch)
Definition property.h:64
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:62
#define REGISTER_TYPE(x)
static struct SCH_TABLE_DESC _SCH_TABLE_DESC
LINE_STYLE
Dashed line types.
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:167
@ SCH_TABLECELL_T
Definition typeinfo.h:168
@ SCH_LOCATE_ANY_T
Definition typeinfo.h:201
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695