KiCad PCB EDA Suite
Loading...
Searching...
No Matches
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 The 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
22
23#include <common.h>
24#include <layer_ids.h>
25#include <lset.h>
26#include <pgm_base.h>
27#include <eda_text.h>
28#include <pcb_dimension.h>
31#include <settings/parameters.h>
33#include <base_units.h>
34
35#include <wx/config.h>
36#include <wx/log.h>
37
38
40const int fpEditSchemaVersion = 5;
41
42
45 m_DesignSettings( nullptr, "fpedit.settings" ),
47 m_Display(),
48 m_UserGrid(),
49 m_PolarCoords( false ),
50 m_DisplayInvertXAxis( false ),
51 m_DisplayInvertYAxis( false ),
55 m_LibWidth( 250 ),
58{
61 m_MagneticItems.graphics = true;
62 m_MagneticItems.allLayers = false;
63
64 m_AuiPanels.appearance_panel_tab = 0;
65 m_AuiPanels.right_panel_width = -1;
66 m_AuiPanels.show_layer_manager = true;
67
68 m_params.emplace_back( new PARAM<int>( "window.lib_width",
69 &m_LibWidth, 250 ) );
70
71 m_params.emplace_back( new PARAM<bool>( "aui.show_layer_manager",
72 &m_AuiPanels.show_layer_manager, true ) );
73
74 m_params.emplace_back( new PARAM<int>( "aui.right_panel_width",
75 &m_AuiPanels.right_panel_width, -1 ) );
76
77 m_params.emplace_back( new PARAM<int>( "aui.appearance_panel_tab",
78 &m_AuiPanels.appearance_panel_tab, 0, 0, 2 ) );
79
80 m_params.emplace_back( new PARAM<int>( "aui.properties_panel_width",
81 &m_AuiPanels.properties_panel_width, -1 ) );
82
83 m_params.emplace_back( new PARAM<float>( "aui.properties_splitter_proportion",
84 &m_AuiPanels.properties_splitter, 0.5f ) );
85
86 m_params.emplace_back( new PARAM<bool>( "aui.show_properties",
87 &m_AuiPanels.show_properties, false ) );
88
89 m_params.emplace_back( new PARAM<int>( "library.sort_mode",
90 &m_LibrarySortMode, 0 ) );
91
92 m_params.emplace_back( new PARAM<wxString>( "system.last_import_export_path",
93 &m_LastExportPath, "" ) );
94
95 m_params.emplace_back( new PARAM<bool>( "pcb_display.graphics_fill",
96 &m_ViewersDisplay.m_DisplayGraphicsFill, true ) );
97
98 m_params.emplace_back( new PARAM<bool>( "pcb_display.text_fill",
99 &m_ViewersDisplay.m_DisplayTextFill, true ) );
100
101 m_params.emplace_back( new PARAM<bool>( "pcb_display.pad_fill",
102 &m_ViewersDisplay.m_DisplayPadFill, true ) );
103
104 m_params.emplace_back( new PARAM<bool>( "pcb_display.pad_numbers",
105 &m_ViewersDisplay.m_DisplayPadNumbers, true ) );
106
107 m_params.emplace_back( new PARAM<wxString>( "window.footprint_text_shown_columns",
108 &m_FootprintTextShownColumns, "0 1 2 3 4 5 7" ) );
109
110 m_params.emplace_back( new PARAM<int>( "editing.magnetic_pads",
111 reinterpret_cast<int*>( &m_MagneticItems.pads ),
112 static_cast<int>( MAGNETIC_OPTIONS::CAPTURE_ALWAYS ) ) );
113
114 m_params.emplace_back( new PARAM<bool>( "editing.magnetic_graphics",
115 &m_MagneticItems.graphics, true ) );
116
117 m_params.emplace_back( new PARAM<bool>( "editing.magnetic_all_layers",
118 &m_MagneticItems.allLayers, false ) );
119
120 m_params.emplace_back( new PARAM<bool>( "editing.polar_coords",
121 &m_PolarCoords, false ) );
122
123 m_params.emplace_back( new PARAM<bool>( "origin_invert_x_axis",
124 &m_DisplayInvertXAxis, false ) );
125
126 m_params.emplace_back( new PARAM<bool>( "origin_invert_y_axis",
127 &m_DisplayInvertYAxis, false ) );
128
129 m_params.emplace_back( new PARAM_LAMBDA<int>( "editing.rotation_angle",
130 [this] () -> int
131 {
132 return m_RotationAngle.AsTenthsOfADegree();
133 },
134 [this] ( int aVal )
135 {
136 if( aVal )
137 m_RotationAngle = EDA_ANGLE( aVal, TENTHS_OF_A_DEGREE_T );
138 },
139 900 ) );
140
141 m_params.emplace_back( new PARAM<int>( "editing.fp_angle_snap_mode",
142 reinterpret_cast<int*>( &m_AngleSnapMode ),
143 static_cast<int>( LEADER_MODE::DEG45 ) ) );
144
145 m_params.emplace_back( new PARAM_LAYER_PRESET( "pcb_display.layer_presets", &m_LayerPresets ) );
146
147 m_params.emplace_back( new PARAM<wxString>( "pcb_display.active_layer_preset",
148 &m_ActiveLayerPreset, "" ) );
149
150 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>(
151 "design_settings.default_footprint_text_items",
152 [&] () -> nlohmann::json
153 {
154 nlohmann::json js = nlohmann::json::array();
155
156 for( const TEXT_ITEM_INFO& item : m_DesignSettings.m_DefaultFPTextItems )
157 {
158 js.push_back( nlohmann::json( { item.m_Text.ToUTF8(),
159 item.m_Visible,
160 LSET::Name( item.m_Layer ) } ) );
161 }
162
163 return js;
164 },
165 [&] ( const nlohmann::json& aObj )
166 {
167 m_DesignSettings.m_DefaultFPTextItems.clear();
168
169 if( !aObj.is_array() )
170 return;
171
172 for( const nlohmann::json& entry : aObj )
173 {
174 if( entry.empty() || !entry.is_array() )
175 continue;
176
177 TEXT_ITEM_INFO textInfo( wxT( "" ), true, F_SilkS );
178
179 textInfo.m_Text = entry.at(0).get<wxString>();
180 textInfo.m_Visible = entry.at(1).get<bool>();
181 wxString layerName = entry.at(2).get<wxString>();
182 int candidateLayer = LSET::NameToLayer( layerName );
183 textInfo.m_Layer = candidateLayer >= 0
184 ? static_cast<PCB_LAYER_ID>(candidateLayer)
185 : F_SilkS;
186
187 m_DesignSettings.m_DefaultFPTextItems.push_back( std::move( textInfo ) );
188 }
189 },
190 nlohmann::json::array( {
191 { "REF**", true, LSET::Name( F_SilkS ) },
192 { "", true, LSET::Name( F_Fab ) },
193 { "${REFERENCE}", true, LSET::Name( F_Fab ) }
194 } ) ) );
195
196 m_params.emplace_back( new PARAM_MAP<wxString>( "design_settings.default_footprint_layer_names",
197 &m_DesignSettings.m_UserLayerNames, {} ) );
198
199 int minTextSize = pcbIUScale.mmToIU( TEXT_MIN_SIZE_MM );
200 int maxTextSize = pcbIUScale.mmToIU( TEXT_MAX_SIZE_MM );
201 int minStroke = 1;
202 int maxStroke = pcbIUScale.mmToIU( 100 );
203
204 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_line_width",
205 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_SILK ],
206 pcbIUScale.mmToIU( DEFAULT_SILK_LINE_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
207
208 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_size_h",
209 &m_DesignSettings.m_TextSize[ LAYER_CLASS_SILK ].x,
210 pcbIUScale.mmToIU( DEFAULT_SILK_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
211
212 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_size_v",
213 &m_DesignSettings.m_TextSize[ LAYER_CLASS_SILK ].y,
214 pcbIUScale.mmToIU( DEFAULT_SILK_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
215
216 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.silk_text_thickness",
217 &m_DesignSettings.m_TextThickness[ LAYER_CLASS_SILK ],
218 pcbIUScale.mmToIU( DEFAULT_SILK_TEXT_WIDTH ), 1, maxTextSize, pcbIUScale.MM_PER_IU ) );
219
220 m_params.emplace_back( new PARAM<bool>( "design_settings.silk_text_italic",
221 &m_DesignSettings.m_TextItalic[ LAYER_CLASS_SILK ], false ) );
222
223 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_line_width",
224 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_COPPER ],
225 pcbIUScale.mmToIU( DEFAULT_COPPER_LINE_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
226
227 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_size_h",
228 &m_DesignSettings.m_TextSize[ LAYER_CLASS_COPPER ].x,
229 pcbIUScale.mmToIU( DEFAULT_COPPER_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
230
231 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_size_v",
232 &m_DesignSettings.m_TextSize[ LAYER_CLASS_COPPER ].y,
233 pcbIUScale.mmToIU( DEFAULT_COPPER_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
234
235 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.copper_text_thickness",
236 &m_DesignSettings.m_TextThickness[ LAYER_CLASS_COPPER ],
237 pcbIUScale.mmToIU( DEFAULT_COPPER_TEXT_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
238
239 m_params.emplace_back( new PARAM<bool>( "design_settings.copper_text_italic",
240 &m_DesignSettings.m_TextItalic[ LAYER_CLASS_COPPER ], false ) );
241
242 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.edge_line_width",
243 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_EDGES ],
244 pcbIUScale.mmToIU( DEFAULT_EDGE_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
245
246 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.courtyard_line_width",
247 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_COURTYARD ],
248 pcbIUScale.mmToIU( DEFAULT_COURTYARD_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
249
250 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_line_width",
251 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_FAB ],
252 pcbIUScale.mmToIU( DEFAULT_LINE_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
253
254 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_size_h",
255 &m_DesignSettings.m_TextSize[ LAYER_CLASS_FAB ].x,
256 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
257
258 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_size_v",
259 &m_DesignSettings.m_TextSize[ LAYER_CLASS_FAB ].y,
260 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
261
262 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.fab_text_thickness",
263 &m_DesignSettings.m_TextThickness[ LAYER_CLASS_FAB ],
264 pcbIUScale.mmToIU( DEFAULT_TEXT_WIDTH ), 1, maxTextSize, pcbIUScale.MM_PER_IU ) );
265
266 m_params.emplace_back( new PARAM<bool>( "design_settings.fab_text_italic",
267 &m_DesignSettings.m_TextItalic[ LAYER_CLASS_FAB ], false ) );
268
269 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_line_width",
270 &m_DesignSettings.m_LineThickness[ LAYER_CLASS_OTHERS ],
271 pcbIUScale.mmToIU( DEFAULT_LINE_WIDTH ), minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
272
273 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_size_h",
274 &m_DesignSettings.m_TextSize[ LAYER_CLASS_OTHERS ].x,
275 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
276
277 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_size_v",
278 &m_DesignSettings.m_TextSize[ LAYER_CLASS_OTHERS ].y,
279 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ), minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
280
281 m_params.emplace_back( new PARAM_SCALED<int>( "design_settings.others_text_thickness",
282 &m_DesignSettings.m_TextThickness[ LAYER_CLASS_OTHERS ],
283 pcbIUScale.mmToIU( DEFAULT_TEXT_WIDTH ), 1, maxTextSize, pcbIUScale.MM_PER_IU ) );
284
285 m_params.emplace_back( new PARAM<bool>( "design_settings.others_text_italic",
286 &m_DesignSettings.m_TextItalic[ LAYER_CLASS_OTHERS ], false ) );
287
288
289 // ---------------------------------------------------------------------------------------------
290 // Dimension settings
291
292 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_MODE>( "design_settings.dimensions.units",
295
296 m_params.emplace_back( new PARAM_ENUM<DIM_PRECISION>( "design_settings.dimensions.precision",
298
299 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_FORMAT>( "design_settings.dimensions.units_format",
302
303 m_params.emplace_back( new PARAM<bool>( "design_settings.dimensions.suppress_zeroes",
304 &m_DesignSettings.m_DimensionSuppressZeroes, true ) );
305
306 // NOTE: excluding DIM_TEXT_POSITION::MANUAL from the valid range here
307 m_params.emplace_back( new PARAM_ENUM<DIM_TEXT_POSITION>( "design_settings.dimensions.text_position",
310
311 m_params.emplace_back( new PARAM<bool>( "design_settings.dimensions.keep_text_aligned",
312 &m_DesignSettings.m_DimensionKeepTextAligned, true ) );
313
314 m_params.emplace_back( new PARAM<int>( "design_settings.dimensions.arrow_length",
315 &m_DesignSettings.m_DimensionArrowLength,
317
318 m_params.emplace_back( new PARAM<int>( "design_settings.dimensions.extension_offset",
319 &m_DesignSettings.m_DimensionExtensionOffset,
321
322 // ---------------------------------------------------------------------------------------------
323
324 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "editing.selection_filter",
325 [&]() -> nlohmann::json
326 {
327 nlohmann::json ret;
328
329 ret["lockedItems"] = m_SelectionFilter.lockedItems;
330 ret["footprints"] = m_SelectionFilter.footprints;
331 ret["text"] = m_SelectionFilter.text;
332 ret["tracks"] = m_SelectionFilter.tracks;
333 ret["vias"] = m_SelectionFilter.vias;
334 ret["pads"] = m_SelectionFilter.pads;
335 ret["graphics"] = m_SelectionFilter.graphics;
336 ret["zones"] = m_SelectionFilter.zones;
337 ret["keepouts"] = m_SelectionFilter.keepouts;
338 ret["dimensions"] = m_SelectionFilter.dimensions;
339 ret["points"] = m_SelectionFilter.points;
340 ret["otherItems"] = m_SelectionFilter.otherItems;
341
342 return ret;
343 },
344 [&]( const nlohmann::json& aVal )
345 {
346 if( aVal.empty() || !aVal.is_object() )
347 return;
348
349 SetIfPresent( aVal, "lockedItems", m_SelectionFilter.lockedItems );
350 SetIfPresent( aVal, "footprints", m_SelectionFilter.footprints );
351 SetIfPresent( aVal, "text", m_SelectionFilter.text );
352 SetIfPresent( aVal, "tracks", m_SelectionFilter.tracks );
353 SetIfPresent( aVal, "vias", m_SelectionFilter.vias );
354 SetIfPresent( aVal, "pads", m_SelectionFilter.pads );
355 SetIfPresent( aVal, "graphics", m_SelectionFilter.graphics );
356 SetIfPresent( aVal, "zones", m_SelectionFilter.zones );
357 SetIfPresent( aVal, "keepouts", m_SelectionFilter.keepouts );
358 SetIfPresent( aVal, "dimensions", m_SelectionFilter.dimensions );
359 SetIfPresent( aVal, "points", m_SelectionFilter.points );
360 SetIfPresent( aVal, "otherItems", m_SelectionFilter.otherItems );
361 },
362 {
363 { "lockedItems", false },
364 { "footprints", true },
365 { "text", true },
366 { "tracks", true },
367 { "vias", true },
368 { "pads", true },
369 { "graphics", true },
370 { "zones", true },
371 { "keepouts", true },
372 { "dimensions", true },
373 { "points", true },
374 { "otherItems", true }
375 } ) );
376
377 registerMigration( 0, 1, std::bind( &FOOTPRINT_EDITOR_SETTINGS::migrateSchema0to1, this ) );
378
379 registerMigration( 1, 2,
380 [&]() -> bool
381 {
382 // This is actually a migration for APP_SETTINGS_BASE::m_LibTree
383 return migrateLibTreeWidth();
384 } );
385
386 registerMigration( 2, 3, std::bind( &FOOTPRINT_EDITOR_SETTINGS::migrateSchema2To3, this ) );
387 registerMigration( 3, 4, std::bind( &FOOTPRINT_EDITOR_SETTINGS::migrateSchema3To4, this ) );
388 registerMigration( 4, 5, std::bind( &FOOTPRINT_EDITOR_SETTINGS::migrateSchema4To5, this ) );
389}
390
391
393{
394 bool ret = APP_SETTINGS_BASE::MigrateFromLegacy( aCfg );
395
396 //
397 // NOTE: there's no value in line-wrapping these; it just makes the table unreadable.
398 //
399 ret &= fromLegacy<int>( aCfg, "ModeditLibWidth", "window.lib_width" );
400 ret &= fromLegacyString( aCfg, "import_last_path", "system.last_import_export_path" );
401 ret &= fromLegacyString( aCfg, "LibFootprintTextShownColumns", "window.footprint_text_shown_columns" );
402
403 ret &= fromLegacy<int>( aCfg, "FpEditorMagneticPads", "editing.magnetic_pads" );
404 ret &= fromLegacy<bool>( aCfg, "FpEditorDisplayPolarCoords", "editing.polar_coords" );
405 ret &= fromLegacy<int>( aCfg, "FpEditorUse45DegreeGraphicSegments", "editing.use_45_degree_graphic_segments" );
406
407 ret &= fromLegacy<bool>( aCfg, "FpEditorGraphicLinesDisplayMode", "pcb_display.graphic_items_fill" );
408 ret &= fromLegacy<bool>( aCfg, "FpEditorPadDisplayMode", "pcb_display.pad_fill" );
409 ret &= fromLegacy<bool>( aCfg, "FpEditorTextsDisplayMode", "pcb_display.footprint_text" );
410
411 ret &= fromLegacy<double>( aCfg, "FpEditorSilkLineWidth", "design_settings.silk_line_width" );
412 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextSizeH", "design_settings.silk_text_size_h" );
413 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextSizeV", "design_settings.silk_text_size_v" );
414 ret &= fromLegacy<double>( aCfg, "FpEditorSilkTextThickness", "design_settings.silk_text_thickness" );
415 ret &= fromLegacy<bool>( aCfg, "FpEditorSilkTextItalic", "design_settings.silk_text_italic" );
416 ret &= fromLegacy<double>( aCfg, "FpEditorCopperLineWidth", "design_settings.copper_line_width" );
417 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextSizeH", "design_settings.copper_text_size_h" );
418 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextSizeV", "design_settings.copper_text_size_v" );
419 ret &= fromLegacy<double>( aCfg, "FpEditorCopperTextThickness", "design_settings.copper_text_thickness" );
420 ret &= fromLegacy<bool>( aCfg, "FpEditorCopperTextItalic", "design_settings.copper_text_italic" );
421 ret &= fromLegacy<double>( aCfg, "FpEditorEdgeCutLineWidth", "design_settings.edge_line_width" );
422 ret &= fromLegacy<double>( aCfg, "FpEditorCourtyardLineWidth", "design_settings.courtyard_line_width" );
423 ret &= fromLegacy<double>( aCfg, "FpEditorOthersLineWidth", "design_settings.others_line_width" );
424 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextSizeH", "design_settings.others_text_size_h" );
425 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextSizeV", "design_settings.others_text_size_v" );
426 ret &= fromLegacy<double>( aCfg, "FpEditorOthersTextThickness", "design_settings.others_text_thickness" );
427 ret &= fromLegacy<bool>( aCfg, "FpEditorOthersTextItalic", "design_settings.others_text_italic" );
428
429 nlohmann::json textItems = nlohmann::json::array( {
430 { "REF**", true, F_SilkS },
431 { "", true, F_Fab }
432 } );
433
434 Set( "design_settings.default_footprint_text_items", std::move( textItems ) );
435
436 ret &= fromLegacyString( aCfg, "FpEditorRefDefaultText", "design_settings.default_footprint_text_items.0.0" );
437 ret &= fromLegacy<bool>( aCfg, "FpEditorRefDefaultVisibility", "design_settings.default_footprint_text_items.0.1" );
438 ret &= fromLegacy<int>( aCfg, "FpEditorRefDefaultLayer", "design_settings.default_footprint_text_items.0.2" );
439 ret &= fromLegacyString( aCfg, "FpEditorValueDefaultText", "design_settings.default_footprint_text_items.1.0" );
440 ret &= fromLegacy<bool>( aCfg, "FpEditorValueDefaultVisibility", "design_settings.default_footprint_text_items.1.1" );
441 ret &= fromLegacy<int>( aCfg, "FpEditorValueDefaultLayer", "design_settings.default_footprint_text_items.1.2" );
442
443
444 std::string f = "ModEdit";
445
446 // Migrate color settings that were stored in the pcbnew config file
447 // We create a copy of the user scheme for the footprint editor context
448
450 COLOR_SETTINGS* cs = manager.AddNewColorSettings( "user_footprints" );
451
452 cs->SetName( wxT( "User (Footprints)" ) );
453 manager.Save( cs );
454
455 auto migrateLegacyColor = [&] ( const std::string& aKey, int aLayerId )
456 {
457 wxString str;
458
459 if( aCfg->Read( aKey, &str ) )
460 cs->SetColor( aLayerId, COLOR4D( str ) );
461 };
462
463 for( int i = 0; i < PCB_LAYER_ID_COUNT; ++i )
464 {
465 wxString layer = LSET::Name( PCB_LAYER_ID( i ) );
466 migrateLegacyColor( f + "Color4DPCBLayer_" + layer.ToStdString(), PCB_LAYER_ID( i ) );
467 }
468
469 migrateLegacyColor( f + "Color4DAnchorEx", LAYER_ANCHOR );
470 migrateLegacyColor( f + "Color4DAuxItems", LAYER_AUX_ITEMS );
471 migrateLegacyColor( f + "Color4DGrid", LAYER_GRID );
472 migrateLegacyColor( f + "Color4DNonPlatedEx", LAYER_NON_PLATEDHOLES );
473 migrateLegacyColor( f + "Color4DPCBBackground", LAYER_PCB_BACKGROUND );
474 migrateLegacyColor( f + "Color4DPCBCursor", LAYER_CURSOR );
475 migrateLegacyColor( f + "Color4DRatsEx", LAYER_RATSNEST );
476 migrateLegacyColor( f + "Color4DViaBBlindEx", LAYER_VIA_BBLIND );
477 migrateLegacyColor( f + "Color4DViaMicroEx", LAYER_VIA_MICROVIA );
478 migrateLegacyColor( f + "Color4DViaThruEx", LAYER_VIA_THROUGH );
479 migrateLegacyColor( f + "Color4DWorksheet", LAYER_DRAWINGSHEET );
480
481 manager.SaveColorSettings( cs, "board" );
482
483 ( *m_internals )[m_internals->PointerFromString( "appearance.color_theme" )] = "user_footprints";
484
485 double x = 0, y = 0;
486 f = "ModEditFrame";
487
488 if( aCfg->Read( f + "PcbUserGrid_X", &x ) && aCfg->Read( f + "PcbUserGrid_Y", &y ) )
489 {
490 EDA_UNITS u = static_cast<EDA_UNITS>( aCfg->ReadLong( f + "PcbUserGrid_Unit",
491 static_cast<long>( EDA_UNITS::INCH ) ) );
492
493 // Convert to internal units
496
497 Set( "window.grid.user_grid_x", EDA_UNIT_UTILS::UI::StringFromValue( pcbIUScale, u, x ) );
498 Set( "window.grid.user_grid_y", EDA_UNIT_UTILS::UI::StringFromValue( pcbIUScale, u, y ) );
499 }
500
501 return ret;
502}
503
504
506{
513
514 if( !m_manager )
515 {
516 wxLogTrace( traceSettings,
517 wxT( "Error: FOOTPRINT_EDITOR_SETTINGS migration cannot run unmanaged!" ) );
518 return false;
519 }
520
521 std::string theme_ptr( "appearance.color_theme" );
522
523 if( !Contains( theme_ptr ) )
524 return true;
525
526 wxString selected = At( theme_ptr ).get<wxString>();
527 wxString search = selected + wxT( "_footprints" );
528
529 for( COLOR_SETTINGS* settings : Pgm().GetSettingsManager().GetColorSettingsList() )
530 {
531 if( settings->GetFilename() == search )
532 {
533 wxLogTrace( traceSettings, wxT( "Updating footprint editor theme from %s to %s" ),
534 selected, search );
535 Set( theme_ptr, search );
536 return true;
537 }
538 }
539
540 return true;
541}
542
543
549{
550 auto p( "/pcb_display/layer_presets"_json_pointer );
551
552 if( !m_internals->contains( p ) || !m_internals->at( p ).is_array() )
553 return true;
554
555 nlohmann::json& presets = m_internals->at( p );
556
557 for( nlohmann::json& entry : presets )
559
560 return true;
561}
562
563
568{
569 auto p( "/pcb_display/layer_presets"_json_pointer );
570
571 if( !m_internals->contains( p ) || !m_internals->at( p ).is_array() )
572 return true;
573
574 nlohmann::json& presets = m_internals->at( p );
575
576 for( nlohmann::json& entry : presets )
578
579 return true;
580}
581
582
587{
588 auto p( "/design_settings/default_footprint_text_items"_json_pointer );
589
590 if( !m_internals->contains( p ) || !m_internals->at( p ).is_array() )
591 return true;
592
593 nlohmann::json& defaults = m_internals->at( p );
594
595 bool reset = false;
596
597 for( nlohmann::json& entry : defaults )
598 {
599 TEXT_ITEM_INFO textInfo( wxT( "" ), true, F_SilkS );
600
601 textInfo.m_Text = entry.at(0).get<wxString>();
602 textInfo.m_Visible = entry.at(1).get<bool>();
603 textInfo.m_Layer = static_cast<PCB_LAYER_ID>( entry.at(2).get<int>() );
604
605 if( textInfo.m_Layer == Rescue || textInfo.m_Layer >= User_5 )
606 {
607 // KiCad pre-9.0 nightlies would write buggy preferences out with invalid layers.
608 // If we detect that, reset to defaults
609 reset = true;
610 }
611 else
612 {
613 // Coming from 8.0 or earlier, just migrate to named layers
614 entry.at(2) = LSET::Name( textInfo.m_Layer );
615 }
616 }
617
618 if( reset )
619 {
620 defaults = nlohmann::json::array( {
621 { "REF**", true, LSET::Name( F_SilkS ) },
622 { "", true, LSET::Name( F_Fab ) },
623 { "${REFERENCE}", true, LSET::Name( F_Fab ) }
624 } );
625 }
626
627 return true;
628}
ARC_EDIT_MODE
Settings for arc editing.
@ KEEP_CENTER_ADJUST_ANGLE_RADIUS
When editing endpoints, the angle and radius are adjusted.
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
@ LAYER_CLASS_OTHERS
@ LAYER_CLASS_FAB
@ LAYER_CLASS_COURTYARD
@ LAYER_CLASS_SILK
@ LAYER_CLASS_COPPER
@ LAYER_CLASS_EDGES
#define DEFAULT_TEXT_WIDTH
#define DEFAULT_COPPER_TEXT_WIDTH
#define DEFAULT_DIMENSION_EXTENSION_OFFSET
#define DEFAULT_DIMENSION_ARROW_LENGTH
#define DEFAULT_SILK_TEXT_SIZE
#define DEFAULT_COPPER_LINE_WIDTH
#define DEFAULT_SILK_LINE_WIDTH
#define DEFAULT_SILK_TEXT_WIDTH
#define DEFAULT_EDGE_WIDTH
#define DEFAULT_COPPER_TEXT_SIZE
#define DEFAULT_LINE_WIDTH
#define DEFAULT_COURTYARD_WIDTH
virtual bool MigrateFromLegacy(wxConfigBase *aCfg) override
Migrates from wxConfig to JSON-based configuration.
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)
bool migrateSchema3To4()
Schema version 4: move layer presets to use named render layers.
BOARD_DESIGN_SETTINGS m_DesignSettings
Only some of these settings are actually used for footprint editing.
bool migrateSchema2To3()
Schema version 2: Bump for KiCad 9 layer numbering changes Migrate layer presets to use new enum valu...
std::vector< LAYER_PRESET > m_LayerPresets
bool migrateSchema4To5()
Schema version 5: move text defaults to used named layers.
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.
bool fromLegacy(wxConfigBase *aConfig, const std::string &aKey, const std::string &aDest)
Translates a legacy wxConfig value to a given JSON pointer value.
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...
SETTINGS_MANAGER * m_manager
A pointer to the settings manager managing this file (may be null)
bool Contains(const std::string &aPath) const
std::vector< PARAM_BASE * > m_params
The list of parameters (owned by this object)
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
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
static int NameToLayer(wxString &aName)
Return the layer number from a layer name.
Definition lset.cpp:117
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition lset.cpp:188
Stores an enum as an integer.
Definition parameters.h:229
Like a normal param, but with custom getter and setter functions.
Definition parameters.h:296
static void MigrateToV9Layers(nlohmann::json &aJson)
static void MigrateToNamedRenderLayers(nlohmann::json &aJson)
Represents a map of <std::string, Value>.
Definition parameters.h:735
Represents a parameter that has a scaling factor between the value in the file and the value used int...
Definition parameters.h:393
PCB_VIEWERS_SETTINGS_BASE(const std::string &aFilename, int aSchemaVersion)
VIEWERS_DISPLAY_OPTIONS m_ViewersDisplay
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition pgm_base.h:125
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely save a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.
COLOR_SETTINGS * AddNewColorSettings(const wxString &aFilename)
Register 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.
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
#define TEXT_MIN_SIZE_MM
Minimum text size (1 micron).
Definition eda_text.h:46
#define TEXT_MAX_SIZE_MM
Maximum text size in mm (~10 inches)
Definition eda_text.h:47
EDA_UNITS
Definition eda_units.h:48
const int fpEditSchemaVersion
! Update the schema version whenever a migration is required
LEADER_MODE
The kind of the leader line.
@ DEG45
45 Degree only
#define traceSettings
@ LAYER_GRID
Definition layer_ids.h:253
@ LAYER_NON_PLATEDHOLES
Draw usual through hole vias.
Definition layer_ids.h:238
@ LAYER_DRAWINGSHEET
Sheet frame and title block.
Definition layer_ids.h:277
@ LAYER_PCB_BACKGROUND
PCB background color.
Definition layer_ids.h:280
@ LAYER_CURSOR
PCB cursor.
Definition layer_ids.h:281
@ LAYER_AUX_ITEMS
Auxiliary items (guides, rule, etc).
Definition layer_ids.h:282
@ LAYER_RATSNEST
Definition layer_ids.h:252
@ LAYER_ANCHOR
Anchor of items having an anchor point (texts, footprints).
Definition layer_ids.h:247
@ LAYER_VIA_MICROVIA
Definition layer_ids.h:233
@ LAYER_VIA_THROUGH
Draw blind/buried vias.
Definition layer_ids.h:235
@ LAYER_VIA_BBLIND
Draw micro vias.
Definition layer_ids.h:234
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
@ User_5
Definition layer_ids.h:128
@ F_Fab
Definition layer_ids.h:119
@ F_SilkS
Definition layer_ids.h:100
@ Rescue
Definition layer_ids.h:121
@ PCB_LAYER_ID_COUNT
Definition layer_ids.h:171
KICOMMON_API double FromUserUnit(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnit, double aValue)
Return in internal units the value aValue given in a real unit such as "in", "mm",...
KICOMMON_API wxString StringFromValue(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, double aValue, bool aAddUnitsText=false, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Return the string from aValue according to aUnits (inch, mm ...) for display.
@ OUTSIDE
Text appears outside the dimension line (default)
@ INLINE
Text appears in line with the dimension line.
SETTINGS_MANAGER * GetSettingsManager()
PGM_BASE & Pgm()
The global program "get" accessor.
Definition pgm_base.cpp:913
see class PGM_BASE