KiCad PCB EDA Suite
footprint_editor_settings.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) 2020 Jon Evans <[email protected]>
5 * Copyright (C) 2020-2022 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include <common.h>
23#include <layer_ids.h>
24#include <pgm_base.h>
27#include <settings/parameters.h>
29#include <wx/config.h>
30#include <base_units.h>
31#include <widgets/ui_common.h>
32#include <wx/log.h>
33#include <pcbnew.h>
34
35
37const int fpEditSchemaVersion = 2;
38
39
42 m_DesignSettings( nullptr, "fpedit.settings" ),
43 m_MagneticItems(),
44 m_Display(),
45 m_UserGrid(),
46 m_PolarCoords( false ),
47 m_RotationAngle( ANGLE_90 ),
48 m_Use45Limit( true ),
49 m_LibWidth( 250 ),
50 m_LastImportExportPath(),
51 m_FootprintTextShownColumns()
52{
56
60
61 m_params.emplace_back( new PARAM<int>( "window.lib_width",
62 &m_LibWidth, 250 ) );
63
64 m_params.emplace_back( new PARAM<bool>( "aui.show_layer_manager",
66
67 m_params.emplace_back( new PARAM<int>( "aui.right_panel_width",
69
70 m_params.emplace_back( new PARAM<int>( "aui.appearance_panel_tab",
72
73 m_params.emplace_back( new PARAM<wxString>( "system.last_import_export_path",
75
76 m_params.emplace_back( new PARAM<wxString>( "window.footprint_text_shown_columns",
77 &m_FootprintTextShownColumns, "0 1 2 3 4 5 6" ) );
78
79 m_params.emplace_back( new PARAM<int>( "editing.magnetic_pads",
80 reinterpret_cast<int*>( &m_MagneticItems.pads ),
81 static_cast<int>( MAGNETIC_OPTIONS::CAPTURE_ALWAYS ) ) );
82
83 m_params.emplace_back( new PARAM<bool>( "editing.magnetic_graphics",
84 &m_MagneticItems.graphics, true ) );
85
86 m_params.emplace_back( new PARAM<bool>( "editing.polar_coords",
87 &m_PolarCoords, false ) );
88
89 m_params.emplace_back( new PARAM_LAMBDA<int>( "editing.rotation_angle",
90 [this] () -> int
91 {
93 },
94 [this] ( int aVal )
95 {
96 if( aVal )
98 },
99 900 ) );
100
101 m_params.emplace_back( new PARAM<bool>( "editing.fp_use_45_degree_limit",
102 &m_Use45Limit, false ) );
103
104 m_params.emplace_back( new PARAM_LAYER_PRESET( "pcb_display.layer_presets", &m_LayerPresets ) );
105
106 m_params.emplace_back( new PARAM<wxString>( "pcb_display.active_layer_preset",
107 &m_ActiveLayerPreset, "" ) );
108
109 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>(
110 "design_settings.default_footprint_text_items",
111 [&] () -> nlohmann::json
112 {
113 nlohmann::json js = nlohmann::json::array();
114
116 {
117 js.push_back( nlohmann::json( { item.m_Text.ToUTF8(),
118 item.m_Visible,
119 item.m_Layer } ) );
120 }
121
122 return js;
123 },
124 [&] ( const nlohmann::json& aObj )
125 {
127
128 if( !aObj.is_array() )
129 return;
130
131 for( const nlohmann::json& entry : aObj )
132 {
133 if( entry.empty() || !entry.is_array() )
134 continue;
135
136 TEXT_ITEM_INFO textInfo( wxT( "" ), true, F_SilkS );
137
138 textInfo.m_Text = entry.at(0).get<wxString>();
139 textInfo.m_Visible = entry.at(1).get<bool>();
140 textInfo.m_Layer = entry.at(2).get<int>();
141
142 m_DesignSettings.m_DefaultFPTextItems.push_back( std::move( textInfo ) );
143 }
144 },
145 nlohmann::json::array( {
146 { "REF**", true, F_SilkS },
147 { "", true, F_Fab },
148 { "${REFERENCE}", true, F_Fab }
149 } ) ) );
150
151 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_line_width",
155
156 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_size_h",
159
160 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_size_v",
163
164 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_thickness",
167
168 m_params.emplace_back( new PARAM<bool>( "design_settings.silk_text_italic",
170
171 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_line_width",
175
176 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_size_h",
180
181 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_size_v",
185
186 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_thickness",
190
191 m_params.emplace_back( new PARAM<bool>( "design_settings.copper_text_italic",
193
194 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.edge_line_width",
198
199 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.courtyard_line_width",
203
204 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_line_width",
208
209 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_size_h",
212
213 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_size_v",
216
217 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_thickness",
220
221 m_params.emplace_back( new PARAM<bool>( "design_settings.fab_text_italic",
223
224 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_line_width",
228
229 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_size_h",
232
233 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_size_v",
236
237 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_thickness",
240
241 m_params.emplace_back( new PARAM<bool>( "design_settings.others_text_italic",
243
244 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "editing.selection_filter",
245 [&]() -> nlohmann::json
246 {
247 nlohmann::json ret;
248
249 ret["lockedItems"] = m_SelectionFilter.lockedItems;
250 ret["footprints"] = m_SelectionFilter.footprints;
251 ret["text"] = m_SelectionFilter.text;
252 ret["tracks"] = m_SelectionFilter.tracks;
253 ret["vias"] = m_SelectionFilter.vias;
254 ret["pads"] = m_SelectionFilter.pads;
255 ret["graphics"] = m_SelectionFilter.graphics;
256 ret["zones"] = m_SelectionFilter.zones;
257 ret["keepouts"] = m_SelectionFilter.keepouts;
258 ret["dimensions"] = m_SelectionFilter.dimensions;
259 ret["otherItems"] = m_SelectionFilter.otherItems;
260
261 return ret;
262 },
263 [&]( const nlohmann::json& aVal )
264 {
265 if( aVal.empty() || !aVal.is_object() )
266 return;
267
268 SetIfPresent( aVal, "lockedItems", m_SelectionFilter.lockedItems );
269 SetIfPresent( aVal, "footprints", m_SelectionFilter.footprints );
270 SetIfPresent( aVal, "text", m_SelectionFilter.text );
271 SetIfPresent( aVal, "tracks", m_SelectionFilter.tracks );
272 SetIfPresent( aVal, "vias", m_SelectionFilter.vias );
273 SetIfPresent( aVal, "pads", m_SelectionFilter.pads );
274 SetIfPresent( aVal, "graphics", m_SelectionFilter.graphics );
275 SetIfPresent( aVal, "zones", m_SelectionFilter.zones );
276 SetIfPresent( aVal, "keepouts", m_SelectionFilter.keepouts );
277 SetIfPresent( aVal, "dimensions", m_SelectionFilter.dimensions );
278 SetIfPresent( aVal, "otherItems", m_SelectionFilter.otherItems );
279 },
280 {
281 { "lockedItems", true },
282 { "footprints", true },
283 { "text", true },
284 { "tracks", true },
285 { "vias", true },
286 { "pads", true },
287 { "graphics", true },
288 { "zones", true },
289 { "keepouts", true },
290 { "dimensions", true },
291 { "otherItems", true }
292 } ) );
293
295
296 registerMigration( 1, 2,
297 [&]() -> bool
298 {
299 // This is actually a migration for APP_SETTINGS_BASE::m_LibTree
300 return migrateLibTreeWidth();
301 } );
302}
303
304
306{
307 bool ret = APP_SETTINGS_BASE::MigrateFromLegacy( aCfg );
308
309 //
310 // NOTE: there's no value in line-wrapping these; it just makes the table unreadable.
311 //
312 ret &= fromLegacy<int>( aCfg, "ModeditLibWidth", "window.lib_width" );
313 ret &= fromLegacyString( aCfg, "import_last_path", "system.last_import_export_path" );
314 ret &= fromLegacyString( aCfg, "LibFootprintTextShownColumns", "window.footprint_text_shown_columns" );
315
316 ret &= fromLegacy<int>( aCfg, "FpEditorMagneticPads", "editing.magnetic_pads" );
317 ret &= fromLegacy<bool>( aCfg, "FpEditorDisplayPolarCoords", "editing.polar_coords" );
318 ret &= fromLegacy<int>( aCfg, "FpEditorUse45DegreeGraphicSegments", "editing.use_45_degree_graphic_segments" );
319
320 ret &= fromLegacy<bool>( aCfg, "FpEditorGraphicLinesDisplayMode", "pcb_display.graphic_items_fill" );
321 ret &= fromLegacy<bool>( aCfg, "FpEditorPadDisplayMode", "pcb_display.pad_fill" );
322 ret &= fromLegacy<bool>( aCfg, "FpEditorTextsDisplayMode", "pcb_display.footprint_text" );
323
324 ret &= fromLegacy<double>( aCfg, "FpEditorSilkLineWidth", "design_settings.silk_line_width" );
325 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextSizeH", "design_settings.silk_text_size_h" );
326 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextSizeV", "design_settings.silk_text_size_v" );
327 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextThickness", "design_settings.silk_text_thickness" );
328 ret &= fromLegacy<bool>( aCfg, "FpEditorSilkTextItalic", "design_settings.silk_text_italic" );
329 ret &= fromLegacy<double>( aCfg, "FpEditorCopperLineWidth", "design_settings.copper_line_width" );
330 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextSizeH", "design_settings.copper_text_size_h" );
331 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextSizeV", "design_settings.copper_text_size_v" );
332 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextThickness", "design_settings.copper_text_thickness" );
333 ret &= fromLegacy<bool>( aCfg, "FpEditorCopperTextItalic", "design_settings.copper_text_italic" );
334 ret &= fromLegacy<double>( aCfg, "FpEditorEdgeCutLineWidth", "design_settings.edge_line_width" );
335 ret &= fromLegacy<double>( aCfg, "FpEditorCourtyardLineWidth", "design_settings.courtyard_line_width" );
336 ret &= fromLegacy<double>( aCfg, "FpEditorOthersLineWidth", "design_settings.others_line_width" );
337 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextSizeH", "design_settings.others_text_size_h" );
338 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextSizeV", "design_settings.others_text_size_v" );
339 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextThickness", "design_settings.others_text_thickness" );
340 ret &= fromLegacy<bool>( aCfg, "FpEditorOthersTextItalic", "design_settings.others_text_italic" );
341
342 nlohmann::json textItems = nlohmann::json::array( {
343 { "REF**", true, F_SilkS },
344 { "", true, F_Fab }
345 } );
346
347 Set( "design_settings.default_footprint_text_items", textItems );
348
349 ret &= fromLegacyString( aCfg, "FpEditorRefDefaultText", "design_settings.default_footprint_text_items.0.0" );
350 ret &= fromLegacy<bool>( aCfg, "FpEditorRefDefaultVisibility", "design_settings.default_footprint_text_items.0.1" );
351 ret &= fromLegacy<int>( aCfg, "FpEditorRefDefaultLayer", "design_settings.default_footprint_text_items.0.2" );
352 ret &= fromLegacyString( aCfg, "FpEditorValueDefaultText", "design_settings.default_footprint_text_items.1.0" );
353 ret &= fromLegacy<bool>( aCfg, "FpEditorValueDefaultVisibility", "design_settings.default_footprint_text_items.1.1" );
354 ret &= fromLegacy<int>( aCfg, "FpEditorValueDefaultLayer", "design_settings.default_footprint_text_items.1.2" );
355
356
357 std::string f = "ModEdit";
358
359 // Migrate color settings that were stored in the pcbnew config file
360 // We create a copy of the user scheme for the footprint editor context
361
362 SETTINGS_MANAGER& manager = Pgm().GetSettingsManager();
363 COLOR_SETTINGS* cs = manager.AddNewColorSettings( "user_footprints" );
364
365 cs->SetName( wxT( "User (Footprints)" ) );
366 manager.Save( cs );
367
368 auto migrateLegacyColor = [&] ( const std::string& aKey, int aLayerId )
369 {
370 wxString str;
371
372 if( aCfg->Read( aKey, &str ) )
373 cs->SetColor( aLayerId, COLOR4D( str ) );
374 };
375
376 for( int i = 0; i < PCB_LAYER_ID_COUNT; ++i )
377 {
378 wxString layer = LSET::Name( PCB_LAYER_ID( i ) );
379 migrateLegacyColor( f + "Color4DPCBLayer_" + layer.ToStdString(), PCB_LAYER_ID( i ) );
380 }
381
382 migrateLegacyColor( f + "Color4DAnchorEx", LAYER_ANCHOR );
383 migrateLegacyColor( f + "Color4DAuxItems", LAYER_AUX_ITEMS );
384 migrateLegacyColor( f + "Color4DGrid", LAYER_GRID );
385 migrateLegacyColor( f + "Color4DNonPlatedEx", LAYER_NON_PLATEDHOLES );
386 migrateLegacyColor( f + "Color4DPadThruHoleEx", LAYER_PADS_TH );
387 migrateLegacyColor( f + "Color4DPCBBackground", LAYER_PCB_BACKGROUND );
388 migrateLegacyColor( f + "Color4DPCBCursor", LAYER_CURSOR );
389 migrateLegacyColor( f + "Color4DRatsEx", LAYER_RATSNEST );
390 migrateLegacyColor( f + "Color4DTxtInvisEx", LAYER_MOD_TEXT_INVISIBLE );
391 migrateLegacyColor( f + "Color4DViaBBlindEx", LAYER_VIA_BBLIND );
392 migrateLegacyColor( f + "Color4DViaMicroEx", LAYER_VIA_MICROVIA );
393 migrateLegacyColor( f + "Color4DViaThruEx", LAYER_VIA_THROUGH );
394 migrateLegacyColor( f + "Color4DWorksheet", LAYER_DRAWINGSHEET );
395
396 manager.SaveColorSettings( cs, "board" );
397
398 ( *m_internals )[m_internals->PointerFromString( "appearance.color_theme" )] = "user_footprints";
399
400 double x, y;
401 f = "ModEditFrame";
402
403 if( aCfg->Read( f + "PcbUserGrid_X", &x ) && aCfg->Read( f + "PcbUserGrid_Y", &y ) )
404 {
405 EDA_UNITS u = static_cast<EDA_UNITS>( aCfg->ReadLong( f + "PcbUserGrid_Unit",
406 static_cast<long>( EDA_UNITS::INCHES ) ) );
407
408 // Convert to internal units
411
412 Set( "window.grid.user_grid_x", EDA_UNIT_UTILS::UI::StringFromValue( pcbIUScale, u, x ) );
413 Set( "window.grid.user_grid_y", EDA_UNIT_UTILS::UI::StringFromValue( pcbIUScale, u, y ) );
414 }
415
416 return ret;
417}
418
419
421{
429 if( !m_manager )
430 {
431 wxLogTrace( traceSettings,
432 wxT( "Error: FOOTPRINT_EDITOR_SETTINGS migration cannot run unmanaged!" ) );
433 return false;
434 }
435
436 std::string theme_ptr( "appearance.color_theme" );
437
438 if( !Count( theme_ptr ) )
439 return true;
440
441 wxString selected = At( theme_ptr ).get<wxString>();
442 wxString search = selected + wxT( "_footprints" );
443
444 for( COLOR_SETTINGS* settings : Pgm().GetSettingsManager().GetColorSettingsList() )
445 {
446 if( settings->GetFilename() == search )
447 {
448 wxLogTrace( traceSettings, wxT( "Updating footprint editor theme from %s to %s" ),
449 selected, search );
450 Set( theme_ptr, search );
451 return true;
452 }
453 }
454
455 return true;
456}
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
#define DEFAULT_TEXT_WIDTH
#define DEFAULT_COPPER_TEXT_WIDTH
#define DEFAULT_SILK_TEXT_SIZE
#define DEFAULT_COPPER_LINE_WIDTH
#define DEFAULT_SILK_LINE_WIDTH
@ LAYER_CLASS_OTHERS
@ LAYER_CLASS_FAB
@ LAYER_CLASS_COURTYARD
@ LAYER_CLASS_SILK
@ LAYER_CLASS_COPPER
@ LAYER_CLASS_EDGES
#define DEFAULT_SILK_TEXT_WIDTH
#define DEFAULT_EDGE_WIDTH
#define DEFAULT_COPPER_TEXT_SIZE
#define DEFAULT_LINE_WIDTH
#define DEFAULT_COURTYARD_WIDTH
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Definition: app_settings.h:101
virtual bool MigrateFromLegacy(wxConfigBase *aCfg) override
Migrates from wxConfig to JSON-based configuration.
bool migrateLibTreeWidth()
Migrates the library tree width setting from a single column (Item) to multi-column.
std::vector< TEXT_ITEM_INFO > m_DefaultFPTextItems
int m_TextThickness[LAYER_CLASS_COUNT]
int m_LineThickness[LAYER_CLASS_COUNT]
wxSize m_TextSize[LAYER_CLASS_COUNT]
bool m_TextItalic[LAYER_CLASS_COUNT]
Color settings are a bit different than most of the settings objects in that there can be more than o...
void SetName(const wxString &aName)
void SetColor(int aLayer, const COLOR4D &aColor)
int AsTenthsOfADegree() const
Definition: eda_angle.h:151
BOARD_DESIGN_SETTINGS m_DesignSettings
Only some of these settings are actually used for footprint editing.
std::vector< LAYER_PRESET > m_LayerPresets
SELECTION_FILTER_OPTIONS m_SelectionFilter
virtual bool MigrateFromLegacy(wxConfigBase *aLegacyConfig) override
Migrates from wxConfig to JSON-based configuration.
bool fromLegacyString(wxConfigBase *aConfig, const std::string &aKey, const std::string &aDest)
Translates a legacy wxConfig string value to a given JSON pointer value.
SETTINGS_MANAGER * m_manager
A pointer to the settings manager managing this file (may be null)
static bool SetIfPresent(const nlohmann::json &aObj, const std::string &aPath, wxString &aTarget)
Sets the given string if the given key/path is present.
size_t Count(const std::string &aPath) const
std::vector< PARAM_BASE * > m_params
The list of parameters (owned by this object)
void registerMigration(int aOldSchemaVersion, int aNewSchemaVersion, std::function< bool(void)> aMigrator)
Registers a migration from one schema version to another.
nlohmann::json & At(const std::string &aPath)
Wrappers for the underlying JSON API so that most consumers don't need json.hpp All of these function...
std::unique_ptr< JSON_SETTINGS_INTERNALS > m_internals
void Set(const std::string &aPath, ValueType aVal)
Stores a value into the JSON document Will throw an exception if ValueType isn't something that the l...
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
static const wxChar * Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition: lset.cpp:82
Like a normal param, but with custom getter and setter functions.
Definition: parameters.h:281
Represents a parameter that has a scaling factor between the value in the file and the value used int...
Definition: parameters.h:334
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely saves a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.
COLOR_SETTINGS * AddNewColorSettings(const wxString &aFilename)
Registers a new color settings object with the given filename.
The common library.
#define DEFAULT_TEXT_SIZE
Ratio of the font height to the baseline of the text above the wire.
@ TENTHS_OF_A_DEGREE_T
Definition: eda_angle.h:30
static constexpr EDA_ANGLE & ANGLE_90
Definition: eda_angle.h:414
EDA_UNITS
Definition: eda_units.h:43
const int fpEditSchemaVersion
! Update the schema version whenever a migration is required
nlohmann::json json
Definition: gerbview.cpp:44
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
@ LAYER_GRID
Definition: layer_ids.h:205
@ LAYER_MOD_TEXT_INVISIBLE
text marked as invisible
Definition: layer_ids.h:200
@ LAYER_NON_PLATEDHOLES
handle color for not plated holes (holes, not pads)
Definition: layer_ids.h:197
@ LAYER_DRAWINGSHEET
drawingsheet frame and titleblock
Definition: layer_ids.h:217
@ LAYER_PCB_BACKGROUND
PCB background color.
Definition: layer_ids.h:220
@ LAYER_CURSOR
PCB cursor.
Definition: layer_ids.h:221
@ LAYER_AUX_ITEMS
Auxiliary items (guides, rule, etc)
Definition: layer_ids.h:222
@ LAYER_RATSNEST
Definition: layer_ids.h:204
@ LAYER_ANCHOR
anchor of items having an anchor point (texts, footprints)
Definition: layer_ids.h:201
@ LAYER_PADS_TH
multilayer pads, usually with holes
Definition: layer_ids.h:213
@ LAYER_VIA_MICROVIA
to draw micro vias
Definition: layer_ids.h:194
@ LAYER_VIA_THROUGH
to draw usual through hole vias
Definition: layer_ids.h:196
@ LAYER_VIA_BBLIND
to draw blind/buried vias
Definition: layer_ids.h:195
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:59
@ F_Fab
Definition: layer_ids.h:120
@ F_SilkS
Definition: layer_ids.h:104
@ PCB_LAYER_ID_COUNT
Definition: layer_ids.h:137
double FromUserUnit(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnit, double aValue)
Return in internal units the value "val" given in a real unit such as "in", "mm" or "deg".
Definition: eda_units.cpp:393
wxString StringFromValue(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=false, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Returns the string from aValue according to aUnits (inch, mm ...) for display.
Definition: eda_units.cpp:233
#define TEXTS_MAX_SIZE
Maximum text size in internal units (10 inches)
Definition: pcbnew.h:32
#define TEXTS_MIN_SIZE
Minimum text size in internal units (1 mil)
Definition: pcbnew.h:31
#define TEXTS_MAX_WIDTH
Maximum text width in internal units (10 inches)
Definition: pcbnew.h:33
SETTINGS_MANAGER * GetSettingsManager()
see class PGM_BASE
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:111
const double MM_PER_IU
Definition: base_units.h:79
constexpr int mmToIU(double mm) const
Definition: base_units.h:89
MAGNETIC_OPTIONS tracks
MAGNETIC_OPTIONS pads
bool graphics
Graphic lines, shapes, polygons.
bool text
Text (free or attached to a footprint)
bool lockedItems
Allow selecting locked items.
bool footprints
Allow selecting entire footprints.
bool dimensions
Dimension items.
bool otherItems
Anything not fitting one of the above categories.
Functions to provide common constants and other functions to assist in making a consistent UI.