KiCad PCB EDA Suite
Loading...
Searching...
No Matches
panel_fp_editor_defaults.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 (C) 1992-2024 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>
27#include <widgets/wx_grid.h>
28#include <template_fieldnames.h>
30#include <grid_tricks.h>
31#include <eda_base_frame.h>
32#include <eda_text.h>
35#include <bitmaps.h>
36#include <confirm.h>
37
38class TEXT_ITEMS_GRID_TABLE : public wxGridTableBase
39{
41 std::vector<TEXT_ITEM_INFO> m_items;
42
43public:
44 TEXT_ITEMS_GRID_TABLE( bool aForFieldProps ) :
45 m_forFieldProps( aForFieldProps )
46 { }
47
48 int GetNumberRows() override { return m_items.size(); }
49 int GetNumberCols() override { return 3; }
50
51 wxString GetColLabelValue( int aCol ) override
52 {
53 switch( aCol )
54 {
55 case 0: return m_forFieldProps ? _( "Value" ) : _( "Text Items" );
56 case 1: return _( "Show" );
57 case 2: return _( "Layer" );
58 default: return wxEmptyString;
59 }
60 }
61
62 wxString GetRowLabelValue( int aRow ) override
63 {
64 switch( aRow )
65 {
66 case 0: return _( "Reference designator" );
67 case 1: return _( "Value" );
68 default: return wxEmptyString;
69 }
70 }
71
72 bool CanGetValueAs( int aRow, int aCol, const wxString& aTypeName ) override
73 {
74 switch( aCol )
75 {
76 case 0: return aTypeName == wxGRID_VALUE_STRING;
77 case 1: return aTypeName == wxGRID_VALUE_BOOL;
78 case 2: return aTypeName == wxGRID_VALUE_NUMBER;
79 default: wxFAIL; return false;
80 }
81 }
82
83 bool CanSetValueAs( int aRow, int aCol, const wxString& aTypeName ) override
84 {
85 return CanGetValueAs( aRow, aCol, aTypeName );
86 }
87
88 wxString GetValue( int row, int col ) override
89 {
90 return m_items[row].m_Text;
91 }
92 void SetValue( int row, int col, const wxString& value ) override
93 {
94 if( col == 0 )
95 m_items[row].m_Text = value;
96 }
97
98 bool GetValueAsBool( int row, int col ) override
99 {
100 return m_items[row].m_Visible;
101 }
102 void SetValueAsBool( int row, int col, bool value ) override
103 {
104 if( col == 1 )
105 m_items[row].m_Visible = value;
106 }
107
108 long GetValueAsLong( int row, int col ) override
109 {
110 return m_items[row].m_Layer;
111 }
112 void SetValueAsLong( int row, int col, long value ) override
113 {
114 if( col == 2 )
115 m_items[row].m_Layer = (int) value;
116 }
117
118 bool AppendRows( size_t aNumRows = 1 ) override
119 {
120 for( size_t i = 0; i < aNumRows; ++i )
121 m_items.emplace_back( wxT( "" ), true, F_SilkS );
122
123 if( GetView() )
124 {
125 wxGridTableMessage msg( this, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, aNumRows );
126 GetView()->ProcessTableMessage( msg );
127 }
128
129 return true;
130 }
131
132 bool DeleteRows( size_t aPos, size_t aNumRows ) override
133 {
134 // aPos may be a large positive, e.g. size_t(-1), and the sum of
135 // aPos+aNumRows may wrap here, so both ends of the range are tested.
136 if( aPos < m_items.size() && aPos + aNumRows <= m_items.size() )
137 {
138 m_items.erase( m_items.begin() + aPos, m_items.begin() + aPos + aNumRows );
139
140 if( GetView() )
141 {
142 wxGridTableMessage msg( this, wxGRIDTABLE_NOTIFY_ROWS_DELETED, aPos, aNumRows );
143 GetView()->ProcessTableMessage( msg );
144 }
145 return true;
146 }
147
148 return false;
149 }
150};
151
152
153// Columns of graphics grid
154enum
155{
162
163enum
164{
171
174
175
177 UNITS_PROVIDER* aUnitsProvider ) :
179{
180 m_unitProvider = aUnitsProvider;
181 m_fieldPropsGrid->SetDefaultRowSize( m_fieldPropsGrid->GetDefaultRowSize() + 4 );
182
183 m_fieldPropsGrid->SetTable( new TEXT_ITEMS_GRID_TABLE( true ), true );
184 m_fieldPropsGrid->PushEventHandler( new GRID_TRICKS( m_fieldPropsGrid ) );
185 m_fieldPropsGrid->SetSelectionMode( wxGrid::wxGridSelectRows );
186
187 wxGridCellAttr* attr = new wxGridCellAttr;
188 attr->SetRenderer( new wxGridCellBoolRenderer() );
189 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
190 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
191 m_fieldPropsGrid->SetColAttr( 1, attr );
192
193 attr = new wxGridCellAttr;
194 attr->SetRenderer( new GRID_CELL_LAYER_RENDERER( nullptr ) );
195 attr->SetEditor( new GRID_CELL_LAYER_SELECTOR( nullptr, {} ) );
196 m_fieldPropsGrid->SetColAttr( 2, attr );
197
198 m_textItemsGrid->SetDefaultRowSize( m_textItemsGrid->GetDefaultRowSize() + 4 );
199
200 m_textItemsGrid->SetTable( new TEXT_ITEMS_GRID_TABLE( false ), true );
201 m_textItemsGrid->PushEventHandler( new GRID_TRICKS( m_textItemsGrid ) );
202 m_textItemsGrid->SetSelectionMode( wxGrid::wxGridSelectRows );
203
204 attr = new wxGridCellAttr;
205 attr->SetRenderer( new wxGridCellBoolRenderer() );
206 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
207 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
208 m_textItemsGrid->SetColAttr( 1, attr );
209
210 attr = new wxGridCellAttr;
211 attr->SetRenderer( new GRID_CELL_LAYER_RENDERER( nullptr ) );
212 attr->SetEditor( new GRID_CELL_LAYER_SELECTOR( nullptr, {} ) );
213 m_textItemsGrid->SetColAttr( 2, attr );
214
215 m_graphicsGrid->SetUnitsProvider( aUnitsProvider );
220
221 m_graphicsGrid->SetDefaultRowSize( m_graphicsGrid->GetDefaultRowSize() + 4 );
222
223 // Work around a bug in wxWidgets where it fails to recalculate the grid height
224 // after changing the default row size
225 m_graphicsGrid->AppendRows( 1 );
226 m_graphicsGrid->DeleteRows( m_graphicsGrid->GetNumberRows() - 1, 1 );
227
228 m_graphicsGrid->PushEventHandler( new GRID_TRICKS( m_graphicsGrid ) );
229}
230
231
233{
234 // destroy GRID_TRICKS before grids.
235 m_fieldPropsGrid->PopEventHandler( true );
236 m_textItemsGrid->PopEventHandler( true );
237 m_graphicsGrid->PopEventHandler( true );
238}
239
240
242{
243 wxColour disabledColour = wxSystemSettings::GetColour( wxSYS_COLOUR_FRAMEBK );
244
245 auto disableCell =
246 [&]( int row, int col )
247 {
248 m_graphicsGrid->SetReadOnly( row, col );
249 m_graphicsGrid->SetCellBackgroundColour( row, col, disabledColour );
250 };
251
252 for( int i = 0; i < ROW_COUNT; ++i )
253 {
255
256 if( i == ROW_EDGES || i == ROW_COURTYARD )
257 {
258 disableCell( i, COL_TEXT_WIDTH );
259 disableCell( i, COL_TEXT_HEIGHT );
260 disableCell( i, COL_TEXT_THICKNESS );
261 disableCell( i, COL_TEXT_ITALIC );
262 }
263 else
264 {
268 m_graphicsGrid->SetCellValue( i, COL_TEXT_ITALIC, aCfg->m_DesignSettings.m_TextItalic[ i ] ? wxT( "1" ) : wxT( "" ) );
269
270 auto attr = new wxGridCellAttr;
271 attr->SetRenderer( new wxGridCellBoolRenderer() );
272 attr->SetReadOnly(); // not really; we delegate interactivity to GRID_TRICKS
273 attr->SetAlignment( wxALIGN_CENTER, wxALIGN_CENTER );
274 m_graphicsGrid->SetAttr( i, COL_TEXT_ITALIC, attr );
275 }
276 }
277
278 // Footprint defaults
279 m_fieldPropsGrid->GetTable()->DeleteRows( 0, m_textItemsGrid->GetNumberRows() );
280 m_fieldPropsGrid->GetTable()->AppendRows( 2 );
281
282 for( int i : { REFERENCE_FIELD, VALUE_FIELD } )
283 {
285
286 m_fieldPropsGrid->GetTable()->SetValue( i, 0, item.m_Text );
287 m_fieldPropsGrid->GetTable()->SetValueAsBool( i, 1, item.m_Visible );
288 m_fieldPropsGrid->GetTable()->SetValueAsLong( i, 2, item.m_Layer );
289 }
290
291 m_textItemsGrid->GetTable()->DeleteRows( 0, m_textItemsGrid->GetNumberRows() );
292 m_textItemsGrid->GetTable()->AppendRows( aCfg->m_DesignSettings.m_DefaultFPTextItems.size() - 2 );
293
294 for( int i = 2; i < (int) aCfg->m_DesignSettings.m_DefaultFPTextItems.size(); ++i )
295 {
297
298 m_textItemsGrid->GetTable()->SetValue( i - 2, 0, item.m_Text );
299 m_textItemsGrid->GetTable()->SetValueAsBool( i - 2, 1, item.m_Visible );
300 m_textItemsGrid->GetTable()->SetValueAsLong( i - 2, 2, item.m_Layer );
301 }
302
303 for( int col = 0; col < m_graphicsGrid->GetNumberCols(); col++ )
304 {
305 // Set the minimal width to the column label size.
306 m_graphicsGrid->SetColMinimalWidth( col, m_graphicsGrid->GetVisibleWidth( col, true, false ) );
307
308 // Set the width to see the full contents
309 if( m_graphicsGrid->IsColShown( col ) )
310 m_graphicsGrid->SetColSize( col, m_graphicsGrid->GetVisibleWidth( col, true, true, true ) );
311 }
312
313 m_graphicsGrid->SetRowLabelSize( m_graphicsGrid->GetVisibleWidth( -1, true, true, true ) );
314
315 Layout();
316}
317
318
320{
321 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
323
324 loadFPSettings( cfg );
325
326 return true;
327}
328
329
331{
332 bool retVal = wxPanel::Show( aShow );
333
334 if( aShow )
335 {
336 // These *should* work in the constructor, and indeed they do if this panel is the
337 // first displayed. However, on OSX 3.0.5 (at least), if another panel is displayed
338 // first then the icons will be blank unless they're set here.
339 m_bpAdd->SetBitmap( KiBitmapBundle( BITMAPS::small_plus ) );
340 m_bpDelete->SetBitmap( KiBitmapBundle( BITMAPS::small_trash ) );
341 }
342
343 if( aShow && m_firstShow )
344 {
345 m_graphicsGrid->SetColSize( 0, m_graphicsGrid->GetColSize( 0 ) + 1 );
346 m_firstShow = false;
347 }
348
349 return retVal;
350}
351
352
354{
356 return false;
357
358 SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
359 BOARD_DESIGN_SETTINGS& cfg = mgr.GetAppSettings<FOOTPRINT_EDITOR_SETTINGS>()->m_DesignSettings;
360
361 // A minimal value for sizes and thickness:
362 const int minWidth = pcbIUScale.mmToIU( MINIMUM_LINE_WIDTH_MM );
363 const int maxWidth = pcbIUScale.mmToIU( MAXIMUM_LINE_WIDTH_MM );
365 const int maxSize = pcbIUScale.MilsToIU( TEXT_MAX_SIZE_MILS );
366 wxString errorsMsg;
367
368 for( int i = 0; i < ROW_COUNT; ++i )
369 {
370 bool badParam = false;
371
372 int lineWidth = m_graphicsGrid->GetUnitValue( i, COL_LINE_THICKNESS );
373
374 if( lineWidth < minWidth || lineWidth > maxWidth )
375 {
376 if( !errorsMsg.IsEmpty() )
377 errorsMsg += wxT( "\n\n" );
378
379 errorsMsg += wxString::Format( _( "%s: Incorrect line width.\n"
380 "It must be between %s and %s" ),
381 m_graphicsGrid->GetRowLabelValue( i ),
382 m_unitProvider->StringFromValue( minWidth , true),
383 m_unitProvider->StringFromValue( maxWidth , true) );
384 badParam = true;
385 }
386
387 if( !badParam )
388 cfg.m_LineThickness[ i ] = lineWidth;
389
390 if( i == ROW_EDGES || i == ROW_COURTYARD )
391 continue;
392
393 badParam = false;
394 int textWidth = m_graphicsGrid->GetUnitValue( i, COL_TEXT_WIDTH );
395 int textHeight = m_graphicsGrid->GetUnitValue( i, COL_TEXT_HEIGHT );
396 int textThickness = m_graphicsGrid->GetUnitValue( i, COL_TEXT_THICKNESS );
397
398 if( textWidth < minSize || textHeight < minSize
399 || textWidth > maxSize || textHeight > maxSize )
400 {
401 if( !errorsMsg.IsEmpty() )
402 errorsMsg += wxT( "\n\n" );
403
404 errorsMsg += wxString::Format( _( "%s: Text size is incorrect.\n"
405 "Size must be between %s and %s" ),
406 m_graphicsGrid->GetRowLabelValue( i ),
408 m_unitProvider->StringFromValue( maxSize , true) );
409 badParam = true;
410 }
411
412 // Text thickness cannot be > text size /4 to be readable
413 int textMinDim = std::min( textWidth, textHeight );
414 int textMaxThickness = std::min( maxWidth, textMinDim /4);
415
416 if( !badParam && ( textThickness < minWidth || textThickness > textMaxThickness ) )
417 {
418 if( !errorsMsg.IsEmpty() )
419 errorsMsg += wxT( "\n\n" );
420
421 if( textThickness > textMaxThickness )
422 errorsMsg += wxString::Format( _( "%s: Text thickness is too large.\n"
423 "It will be truncated to %s" ),
424 m_graphicsGrid->GetRowLabelValue( i ),
425 m_unitProvider->StringFromValue( textMaxThickness , true) );
426
427 else if( textThickness < minWidth )
428 errorsMsg += wxString::Format( _( "%s: Text thickness is too small.\n"
429 "It will be truncated to %s" ),
430 m_graphicsGrid->GetRowLabelValue( i ),
431 m_unitProvider->StringFromValue( minWidth , true ) );
432
433 textThickness = std::min( textThickness, textMaxThickness );
434 textThickness = std::max( textThickness, minWidth );
435 m_graphicsGrid->SetUnitValue( i, COL_TEXT_THICKNESS, textThickness );
436 }
437
438 if( !badParam )
439 {
440 cfg.m_TextSize[i] = VECTOR2I( textWidth, textHeight );
441 cfg.m_TextThickness[ i ] = textThickness;
442 }
443
444 wxString msg = m_graphicsGrid->GetCellValue( i, COL_TEXT_ITALIC );
445 cfg.m_TextItalic[ i ] = wxGridCellBoolEditor::IsTrueValue( msg );
446 }
447
448 // Footprint defaults
449 cfg.m_DefaultFPTextItems.clear();
450
451 wxGridTableBase* table = m_fieldPropsGrid->GetTable();
452
453 for( int i : { REFERENCE_FIELD, VALUE_FIELD } )
454 {
455 wxString text = table->GetValue( i, 0 );
456 bool visible = table->GetValueAsBool( i, 1 );
457 int layer = (int) table->GetValueAsLong( i, 2 );
458
459 cfg.m_DefaultFPTextItems.emplace_back( text, visible, layer );
460 }
461
462 table = m_textItemsGrid->GetTable();
463
464 for( int i = 0; i < m_textItemsGrid->GetNumberRows(); ++i )
465 {
466 wxString text = table->GetValue( i, 0 );
467 bool visible = table->GetValueAsBool( i, 1 );
468 int layer = (int) table->GetValueAsLong( i, 2 );
469
470 cfg.m_DefaultFPTextItems.emplace_back( text, visible, layer );
471 }
472
473 if( errorsMsg.IsEmpty() )
474 return true;
475
476 KIDIALOG dlg( wxGetTopLevelParent( this ), errorsMsg, KIDIALOG::KD_ERROR,
477 _( "Parameter error" ) );
478 dlg.ShowModal();
479
480 return false;
481}
482
483
484void PANEL_FP_EDITOR_DEFAULTS::OnAddTextItem( wxCommandEvent& event )
485{
487 return;
488
489 wxGridTableBase* table = m_textItemsGrid->GetTable();
490
491 int newRow = m_textItemsGrid->GetNumberRows();
492 table->AppendRows( 1 );
493 table->SetValueAsBool( newRow, 1, table->GetValueAsBool( newRow - 1, 1 ) );
494 table->SetValueAsLong( newRow, 2, table->GetValueAsLong( newRow - 1, 2 ) );
495
496 m_textItemsGrid->MakeCellVisible( newRow, 0 );
497 m_textItemsGrid->SetGridCursor( newRow, 0 );
498
499 m_textItemsGrid->EnableCellEditControl( true );
500 m_textItemsGrid->ShowCellEditControl();
501}
502
503
505{
506 wxArrayInt selectedRows = m_textItemsGrid->GetSelectedRows();
507
508 if( selectedRows.empty() && m_textItemsGrid->GetGridCursorRow() >= 0 )
509 selectedRows.push_back( m_textItemsGrid->GetGridCursorRow() );
510
511 if( selectedRows.empty() )
512 return;
513
514 for( int row : selectedRows )
515 {
516 if( row < 2 )
517 {
518 DisplayError( nullptr, _( "Reference and value are mandatory." ) );
519 return;
520 }
521 }
522
524 return;
525
526 // Reverse sort so deleting a row doesn't change the indexes of the other rows.
527 selectedRows.Sort( []( int* first, int* second ) { return *second - *first; } );
528
529 for( int row : selectedRows )
530 {
531 m_textItemsGrid->GetTable()->DeleteRows( row, 1 );
532
533 if( m_textItemsGrid->GetNumberRows() > 0 )
534 {
535 m_textItemsGrid->MakeCellVisible( std::max( 0, row-1 ),
536 m_textItemsGrid->GetGridCursorCol() );
537 m_textItemsGrid->SetGridCursor( std::max( 0, row-1 ),
538 m_textItemsGrid->GetGridCursorCol() );
539 }
540 }
541}
542
543
545{
547 cfg.Load(); // Loading without a file will init to defaults
548
549 loadFPSettings( &cfg );
550}
551
552
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
wxBitmapBundle KiBitmapBundle(BITMAPS aBitmap)
Definition: bitmap.cpp:110
#define MINIMUM_LINE_WIDTH_MM
#define MAXIMUM_LINE_WIDTH_MM
Container for design settings for a BOARD object.
std::vector< TEXT_ITEM_INFO > m_DefaultFPTextItems
int m_TextThickness[LAYER_CLASS_COUNT]
int m_LineThickness[LAYER_CLASS_COUNT]
VECTOR2I m_TextSize[LAYER_CLASS_COUNT]
bool m_TextItalic[LAYER_CLASS_COUNT]
BOARD_DESIGN_SETTINGS m_DesignSettings
Only some of these settings are actually used for footprint editing.
Add mouse and command handling (such as cut, copy, and paste) to a WX_GRID instance.
Definition: grid_tricks.h:61
virtual void Load()
Updates the parameters of this object based on the current JSON document contents.
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition: confirm.h:47
@ KD_ERROR
Definition: confirm.h:50
int ShowModal() override
Definition: confirm.cpp:100
Class PANEL_FP_EDITOR_DEFAULTS_BASE.
virtual void OnAddTextItem(wxCommandEvent &event) override
void ResetPanel() override
Reset the contents of this panel.
bool Show(bool aShow) override
PANEL_FP_EDITOR_DEFAULTS(wxWindow *aParent, UNITS_PROVIDER *aUnitsProvider)
virtual void OnDeleteTextItem(wxCommandEvent &event) override
void loadFPSettings(FOOTPRINT_EDITOR_SETTINGS *aCfg)
T * GetAppSettings()
Returns a handle to the a given settings by type If the settings have already been loaded,...
void SetBitmap(const wxBitmapBundle &aBmp)
std::vector< TEXT_ITEM_INFO > m_items
bool DeleteRows(size_t aPos, size_t aNumRows) override
wxString GetRowLabelValue(int aRow) override
TEXT_ITEMS_GRID_TABLE(bool aForFieldProps)
void SetValueAsLong(int row, int col, long value) override
void SetValue(int row, int col, const wxString &value) override
wxString GetValue(int row, int col) override
void SetValueAsBool(int row, int col, bool value) override
wxString GetColLabelValue(int aCol) override
bool CanSetValueAs(int aRow, int aCol, const wxString &aTypeName) override
bool GetValueAsBool(int row, int col) override
bool AppendRows(size_t aNumRows=1) override
bool CanGetValueAs(int aRow, int aCol, const wxString &aTypeName) override
long GetValueAsLong(int row, int col) override
wxString StringFromValue(double aValue, bool aAddUnitLabel=false, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
Converts aValue in internal units into a united string.
int GetVisibleWidth(int aCol, bool aHeader=true, bool aContents=true, bool aKeep=false)
Calculates the specified column based on the actual size of the text on screen.
Definition: wx_grid.cpp:559
void SetTable(wxGridTableBase *table, bool aTakeOwnership=false)
Hide wxGrid's SetTable() method with one which doesn't mess up the grid column widths when setting th...
Definition: wx_grid.cpp:156
void SetUnitValue(int aRow, int aCol, int aValue)
Set a unitized cell's value.
Definition: wx_grid.cpp:541
int GetUnitValue(int aRow, int aCol)
Apply standard KiCad unit and eval services to a numeric cell.
Definition: wx_grid.cpp:520
void SetAutoEvalCols(const std::vector< int > &aCols)
Definition: wx_grid.h:104
void SetUnitsProvider(UNITS_PROVIDER *aProvider, int aCol=0)
Set a UNITS_PROVIDER to enable use of unit- and eval-based Getters.
Definition: wx_grid.cpp:511
bool CommitPendingChanges(bool aQuietMode=false)
Close any open cell edit controls.
Definition: wx_grid.cpp:462
void DisplayError(wxWindow *aParent, const wxString &aText, int aDisplayTime)
Display an error or warning message box with aMessage.
Definition: confirm.cpp:280
This file is part of the common library.
const int minSize
Push and Shove router track width and via size dialog.
#define _(s)
Base window classes and related definitions.
#define TEXT_MIN_SIZE_MILS
Minimum text size in mils.
Definition: eda_text.h:42
#define TEXT_MAX_SIZE_MILS
Maximum text size in mils (10 inches)
Definition: eda_text.h:43
@ F_SilkS
Definition: layer_ids.h:105
see class PGM_BASE
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:119
constexpr int MilsToIU(int mils) const
Definition: base_units.h:94
constexpr int mmToIU(double mm) const
Definition: base_units.h:89
@ VALUE_FIELD
Field Value of part, i.e. "3.3K".
@ REFERENCE_FIELD
Field Reference of part, i.e. "IC21".
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588