From c697a934b2509a59602235eb697dc17c12b6af8b Mon Sep 17 00:00:00 2001 From: Jeff Young Date: Fri, 4 Aug 2023 11:13:20 +0100 Subject: [PATCH] Update layer names to current terminology. Also fixes some out-of-date tooltips/names. --- common/layer_id.cpp | 16 +++---- common/lset.cpp | 20 ++++----- common/settings/builtin_color_themes.h | 4 +- common/settings/color_settings.cpp | 2 +- common/view/view_group.cpp | 4 +- include/layer_ids.h | 26 ++++++------ pcbnew/board.cpp | 12 +++--- .../dialogs/panel_pcbnew_color_settings.cpp | 14 +++---- pcbnew/footprint.cpp | 24 +++++------ pcbnew/footprint_editor_settings.cpp | 2 +- pcbnew/pad.cpp | 12 +++--- pcbnew/pcb_base_frame.cpp | 18 ++++---- pcbnew/pcb_draw_panel_gal.cpp | 34 +++++++-------- pcbnew/pcb_field.cpp | 4 +- pcbnew/pcb_painter.cpp | 6 +-- pcbnew/pcb_shape.cpp | 4 +- pcbnew/pcb_text.cpp | 14 +++---- pcbnew/pcbnew_printout.cpp | 33 ++++++++------- pcbnew/pcbnew_settings.cpp | 2 +- pcbnew/tools/pcb_selection_tool.cpp | 34 +++++++-------- pcbnew/widgets/appearance_controls.cpp | 42 +++++++++---------- pcbnew/zone.cpp | 4 +- 22 files changed, 167 insertions(+), 164 deletions(-) diff --git a/common/layer_id.cpp b/common/layer_id.cpp index cfee608577..fb86c6045a 100644 --- a/common/layer_id.cpp +++ b/common/layer_id.cpp @@ -153,14 +153,14 @@ wxString LayerName( int aLayer ) // GAL_LAYER_ID - case LAYER_MOD_FR: return _( "Footprints front" ); - case LAYER_MOD_BK: return _( "Footprints back" ); - case LAYER_MOD_VALUES: return _( "Values" ); - case LAYER_MOD_REFERENCES: return _( "Reference designators" ); - case LAYER_MOD_TEXT: return _( "Footprint text" ); - case LAYER_MOD_TEXT_INVISIBLE: return _( "Hidden text" ); - case LAYER_PAD_FR: return _( "SMD pads front" ); - case LAYER_PAD_BK: return _( "SMD pads back" ); + case LAYER_FOOTPRINTS_FR: return _( "Footprints front" ); + case LAYER_FOOTPRINTS_BK: return _( "Footprints back" ); + case LAYER_FP_VALUES: return _( "Values" ); + case LAYER_FP_REFERENCES: return _( "Reference designators" ); + case LAYER_FP_TEXT: return _( "Footprint text" ); + case LAYER_HIDDEN_TEXT: return _( "Hidden text" ); + case LAYER_PADS_SMD_FR: return _( "SMD pads front" ); + case LAYER_PADS_SMD_BK: return _( "SMD pads back" ); case LAYER_PADS_TH: return _( "Through-hole pads" ); case LAYER_TRACKS: return _( "Tracks" ); case LAYER_VIA_THROUGH: return _( "Through vias" ); diff --git a/common/lset.cpp b/common/lset.cpp index 9267ec3b04..ec86155d94 100644 --- a/common/lset.cpp +++ b/common/lset.cpp @@ -964,28 +964,28 @@ GAL_SET GAL_SET::DefaultVisible() LAYER_VIA_MICROVIA, LAYER_VIA_BBLIND, LAYER_VIA_THROUGH, - LAYER_NON_PLATEDHOLES, - LAYER_MOD_TEXT, - // LAYER_MOD_TEXT_INVISIBLE, // Invisible text hidden by default + // LAYER_HIDDEN_TEXT, // Invisible text hidden by default LAYER_ANCHOR, - LAYER_PAD_FR, - LAYER_PAD_BK, + LAYER_PADS_SMD_FR, + LAYER_PADS_SMD_BK, LAYER_RATSNEST, LAYER_GRID, LAYER_GRID_AXES, - LAYER_MOD_FR, - LAYER_MOD_BK, - LAYER_MOD_VALUES, - LAYER_MOD_REFERENCES, + LAYER_FOOTPRINTS_FR, + LAYER_FOOTPRINTS_BK, + LAYER_FP_TEXT, + LAYER_FP_VALUES, + LAYER_FP_REFERENCES, LAYER_TRACKS, LAYER_PADS_TH, LAYER_PAD_PLATEDHOLES, + LAYER_NON_PLATEDHOLES, LAYER_PAD_HOLEWALLS, LAYER_VIA_HOLES, LAYER_VIA_HOLEWALLS, LAYER_DRC_ERROR, LAYER_DRC_WARNING, - // LAYER_DRC_EXCLUSION, // DRC exclusions hidden by default + // LAYER_DRC_EXCLUSION, // DRC exclusions hidden by default LAYER_DRAWINGSHEET, LAYER_GP_OVERLAY, LAYER_SELECT_OVERLAY, diff --git a/common/settings/builtin_color_themes.h b/common/settings/builtin_color_themes.h index 6ef0ae90a8..92f9641412 100644 --- a/common/settings/builtin_color_themes.h +++ b/common/settings/builtin_color_themes.h @@ -155,7 +155,7 @@ static const std::map s_defaultTheme = { LAYER_DRC_ERROR, CSS_COLOR( 215, 91, 107, 0.8 ) }, { LAYER_DRC_WARNING, CSS_COLOR( 255, 208, 66, 0.8 ) }, { LAYER_DRC_EXCLUSION, CSS_COLOR( 255, 255, 255, 0.8 ) }, - { LAYER_MOD_TEXT_INVISIBLE, CSS_COLOR( 132, 132, 132, 1 ) }, + { LAYER_HIDDEN_TEXT, CSS_COLOR( 132, 132, 132, 1 ) }, { LAYER_GRID, CSS_COLOR( 132, 132, 132, 1 ) }, { LAYER_GRID_AXES, CSS_COLOR( 194, 194, 194, 1 ) }, { LAYER_PAD_PLATEDHOLES, CSS_COLOR( 194, 194, 0, 1 ) }, @@ -372,7 +372,7 @@ static const std::map s_classicTheme = { LAYER_DRC_ERROR, COLOR4D( PURERED ).WithAlpha( 0.8 ) }, { LAYER_DRC_WARNING, COLOR4D( PUREGREEN ).WithAlpha( 0.8 ) }, { LAYER_DRC_EXCLUSION, COLOR4D( WHITE ) }, - { LAYER_MOD_TEXT_INVISIBLE, COLOR4D( LIGHTGRAY ) }, + { LAYER_HIDDEN_TEXT, COLOR4D( LIGHTGRAY ) }, { LAYER_GRID, COLOR4D( DARKGRAY ) }, { LAYER_GRID_AXES, COLOR4D( BLUE ) }, { LAYER_PAD_PLATEDHOLES, COLOR4D( YELLOW ) }, diff --git a/common/settings/color_settings.cpp b/common/settings/color_settings.cpp index fc94ebf829..31c98808ed 100644 --- a/common/settings/color_settings.cpp +++ b/common/settings/color_settings.cpp @@ -124,7 +124,7 @@ COLOR_SETTINGS::COLOR_SETTINGS( const wxString& aFilename, bool aAbsolutePath ) CLR( "board.drc_error", LAYER_DRC_ERROR ); CLR( "board.drc_warning", LAYER_DRC_WARNING ); CLR( "board.drc_exclusion", LAYER_DRC_EXCLUSION ); - CLR( "board.footprint_text_invisible", LAYER_MOD_TEXT_INVISIBLE ); + CLR( "board.footprint_text_invisible", LAYER_HIDDEN_TEXT ); CLR( "board.grid", LAYER_GRID ); CLR( "board.grid_axes", LAYER_GRID_AXES ); CLR( "board.pad_plated_hole", LAYER_PAD_PLATEDHOLES ); diff --git a/common/view/view_group.cpp b/common/view/view_group.cpp index 714b8ae94a..dd0b2666ac 100644 --- a/common/view/view_group.cpp +++ b/common/view/view_group.cpp @@ -155,8 +155,8 @@ void VIEW_GROUP::ViewDraw( int aLayer, VIEW* aView ) const case LAYER_PADS_TH: case LAYER_PAD_PLATEDHOLES: case LAYER_PAD_HOLEWALLS: - case LAYER_PAD_FR: - case LAYER_PAD_BK: + case LAYER_PADS_SMD_FR: + case LAYER_PADS_SMD_BK: draw = true; break; default: diff --git a/include/layer_ids.h b/include/layer_ids.h index dab72e5b78..2ec5d2dca6 100644 --- a/include/layer_ids.h +++ b/include/layer_ids.h @@ -195,20 +195,20 @@ enum GAL_LAYER_ID: int LAYER_VIA_BBLIND = GAL_LAYER_ID_START + 2, ///< to draw blind/buried vias LAYER_VIA_THROUGH = GAL_LAYER_ID_START + 3, ///< to draw usual through hole vias LAYER_NON_PLATEDHOLES = GAL_LAYER_ID_START + 4, ///< handle color for not plated holes (holes, not pads) - LAYER_MOD_TEXT = GAL_LAYER_ID_START + 5, + LAYER_FP_TEXT = GAL_LAYER_ID_START + 5, // LAYER_MOD_TEXT_BK deprecated + 6, - LAYER_MOD_TEXT_INVISIBLE = GAL_LAYER_ID_START + 7, ///< text marked as invisible + LAYER_HIDDEN_TEXT = GAL_LAYER_ID_START + 7, ///< text marked as invisible LAYER_ANCHOR = GAL_LAYER_ID_START + 8, ///< anchor of items having an anchor point (texts, footprints) - LAYER_PAD_FR = GAL_LAYER_ID_START + 9, ///< smd pads, front layer - LAYER_PAD_BK = GAL_LAYER_ID_START + 10, ///< smd pads, back layer + LAYER_PADS_SMD_FR = GAL_LAYER_ID_START + 9, ///< smd pads, front layer + LAYER_PADS_SMD_BK = GAL_LAYER_ID_START + 10, ///< smd pads, back layer LAYER_RATSNEST = GAL_LAYER_ID_START + 11, LAYER_GRID = GAL_LAYER_ID_START + 12, LAYER_GRID_AXES = GAL_LAYER_ID_START + 13, // LAYER_NO_CONNECTS deprecated + 14, ///< show a marker on pads with no nets - LAYER_MOD_FR = GAL_LAYER_ID_START + 15, ///< show footprints on front - LAYER_MOD_BK = GAL_LAYER_ID_START + 16, ///< show footprints on back - LAYER_MOD_VALUES = GAL_LAYER_ID_START + 17, ///< show footprints values (when texts are visible) - LAYER_MOD_REFERENCES = GAL_LAYER_ID_START + 18, ///< show footprints references (when texts are visible) + LAYER_FOOTPRINTS_FR = GAL_LAYER_ID_START + 15, ///< show footprints on front + LAYER_FOOTPRINTS_BK = GAL_LAYER_ID_START + 16, ///< show footprints on back + LAYER_FP_VALUES = GAL_LAYER_ID_START + 17, ///< show footprints values (when texts are visible) + LAYER_FP_REFERENCES = GAL_LAYER_ID_START + 18, ///< show footprints references (when texts are visible) LAYER_TRACKS = GAL_LAYER_ID_START + 19, LAYER_PADS_TH = GAL_LAYER_ID_START + 20, ///< multilayer pads, usually with holes LAYER_PAD_PLATEDHOLES = GAL_LAYER_ID_START + 21, ///< to draw pad holes (plated) @@ -847,7 +847,7 @@ inline bool IsNonCopperLayer( int aLayerId ) /** * Tests whether a layer is a copper layer, optionally including synthetic copper layers such - * as LAYER_VIA_THROUGH, LAYER_PAD_FR, etc. + * as LAYER_VIA_THROUGH, LAYER_PADS_SMD_FR, etc. * * @param aLayerId * @param aIncludeSyntheticCopperLayers @@ -976,9 +976,9 @@ inline int GetNetnameLayer( int aLayer ) return NETNAMES_LAYER_INDEX( aLayer ); else if( aLayer == LAYER_PADS_TH ) return LAYER_PAD_NETNAMES; - else if( aLayer == LAYER_PAD_FR ) + else if( aLayer == LAYER_PADS_SMD_FR ) return LAYER_PAD_FR_NETNAMES; - else if( aLayer == LAYER_PAD_BK ) + else if( aLayer == LAYER_PADS_SMD_BK ) return LAYER_PAD_BK_NETNAMES; else if( IsViaPadLayer( aLayer ) ) return LAYER_VIA_NETNAMES; @@ -1022,8 +1022,8 @@ inline bool IsNetCopperLayer( int aLayer ) { static std::set netCopperLayers = { - LAYER_PAD_FR, - LAYER_PAD_BK, + LAYER_PADS_SMD_FR, + LAYER_PADS_SMD_BK, LAYER_PADS_TH, LAYER_PAD_HOLEWALLS, LAYER_VIA_THROUGH, diff --git a/pcbnew/board.cpp b/pcbnew/board.cpp index 411bc40070..5be124bcfb 100644 --- a/pcbnew/board.cpp +++ b/pcbnew/board.cpp @@ -720,8 +720,8 @@ bool BOARD::IsFootprintLayerVisible( PCB_LAYER_ID aLayer ) const { switch( aLayer ) { - case F_Cu: return IsElementVisible( LAYER_MOD_FR ); - case B_Cu: return IsElementVisible( LAYER_MOD_BK ); + case F_Cu: return IsElementVisible( LAYER_FOOTPRINTS_FR ); + case B_Cu: return IsElementVisible( LAYER_FOOTPRINTS_BK ); default: wxFAIL_MSG( wxT( "BOARD::IsModuleLayerVisible(): bad layer" ) ); return true; } } @@ -1330,8 +1330,10 @@ BOX2I BOARD::ComputeBoundingBox( bool aBoardEdgesOnly ) const { BOX2I bbox; LSET visible = GetVisibleLayers(); - bool showInvisibleText = IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) - && PgmOrNull() && !PgmOrNull()->m_Printing; + bool showHiddenText = IsElementVisible( LAYER_HIDDEN_TEXT ); + + if( PgmOrNull() && PgmOrNull()->m_Printing ) + showHiddenText = false; // If the board is just showing a footprint, we want all footprint layers // included in the bounding box @@ -1367,7 +1369,7 @@ BOX2I BOARD::ComputeBoundingBox( bool aBoardEdgesOnly ) const } else { - bbox.Merge( footprint->GetBoundingBox( true, showInvisibleText ) ); + bbox.Merge( footprint->GetBoundingBox( true, showHiddenText ) ); } } diff --git a/pcbnew/dialogs/panel_pcbnew_color_settings.cpp b/pcbnew/dialogs/panel_pcbnew_color_settings.cpp index 1067f13337..892baf5b52 100644 --- a/pcbnew/dialogs/panel_pcbnew_color_settings.cpp +++ b/pcbnew/dialogs/panel_pcbnew_color_settings.cpp @@ -354,14 +354,14 @@ std::set g_excludedLayers = { LAYER_VIAS, LAYER_VIA_HOLEWALLS, - LAYER_MOD_FR, - LAYER_MOD_BK, - LAYER_PAD_FR, - LAYER_PAD_BK, - LAYER_MOD_VALUES, - LAYER_MOD_REFERENCES, + LAYER_FOOTPRINTS_FR, + LAYER_FOOTPRINTS_BK, + LAYER_PADS_SMD_FR, + LAYER_PADS_SMD_BK, + LAYER_FP_VALUES, + LAYER_FP_REFERENCES, LAYER_TRACKS, - LAYER_MOD_TEXT, + LAYER_FP_TEXT, GAL_LAYER_ID_START + 6, // where LAYER_MOD_TEXT_BK (deprecated) used to be GAL_LAYER_ID_START + 14, // where LAYER_NO_CONNECTS (deprecated) used to be LAYER_PAD_PLATEDHOLES, diff --git a/pcbnew/footprint.cpp b/pcbnew/footprint.cpp index 6b0f32a674..1648184e39 100644 --- a/pcbnew/footprint.cpp +++ b/pcbnew/footprint.cpp @@ -1052,12 +1052,12 @@ const BOX2I FOOTPRINT::GetBoundingBox( bool aIncludeText, bool aIncludeInvisible // footprint text can also be turned off via the GAL meta-layers, so the 2nd and // 3rd "&&" conditionals handle that. valueLayerIsVisible = board->IsLayerVisible( Value().GetLayer() ) - && board->IsElementVisible( LAYER_MOD_VALUES ) - && board->IsElementVisible( LAYER_MOD_TEXT ); + && board->IsElementVisible( LAYER_FP_VALUES ) + && board->IsElementVisible( LAYER_FP_TEXT ); refLayerIsVisible = board->IsLayerVisible( Reference().GetLayer() ) - && board->IsElementVisible( LAYER_MOD_REFERENCES ) - && board->IsElementVisible( LAYER_MOD_TEXT ); + && board->IsElementVisible( LAYER_FP_REFERENCES ) + && board->IsElementVisible( LAYER_FP_TEXT ); } @@ -1707,11 +1707,11 @@ void FOOTPRINT::ViewGetLayers( int aLayers[], int& aCount ) const KI_FALLTHROUGH; case F_Cu: - aLayers[1] = LAYER_MOD_FR; + aLayers[1] = LAYER_FOOTPRINTS_FR; break; case B_Cu: - aLayers[1] = LAYER_MOD_BK; + aLayers[1] = LAYER_FOOTPRINTS_BK; break; } @@ -1751,10 +1751,10 @@ double FOOTPRINT::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const if( aLayer == LAYER_LOCKED_ITEM_SHADOW ) { // The locked shadow shape is shown only if the footprint itself is visible - if( ( m_layer == F_Cu ) && aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( ( m_layer == F_Cu ) && aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return 0.0; - if( ( m_layer == B_Cu ) && aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( ( m_layer == B_Cu ) && aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return 0.0; return std::numeric_limits::max(); @@ -1763,17 +1763,17 @@ double FOOTPRINT::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const if( aLayer == LAYER_CONFLICTS_SHADOW && IsConflicting() ) { // The locked shadow shape is shown only if the footprint itself is visible - if( ( m_layer == F_Cu ) && aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( ( m_layer == F_Cu ) && aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return 0.0; - if( ( m_layer == B_Cu ) && aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( ( m_layer == B_Cu ) && aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return 0.0; return std::numeric_limits::max(); } - int layer = ( m_layer == F_Cu ) ? LAYER_MOD_FR : - ( m_layer == B_Cu ) ? LAYER_MOD_BK : LAYER_ANCHOR; + int layer = ( m_layer == F_Cu ) ? LAYER_FOOTPRINTS_FR : + ( m_layer == B_Cu ) ? LAYER_FOOTPRINTS_BK : LAYER_ANCHOR; // Currently this is only pertinent for the anchor layer; everything else is drawn from the // children. diff --git a/pcbnew/footprint_editor_settings.cpp b/pcbnew/footprint_editor_settings.cpp index 16e4cdce24..e8fce04df2 100644 --- a/pcbnew/footprint_editor_settings.cpp +++ b/pcbnew/footprint_editor_settings.cpp @@ -395,7 +395,7 @@ bool FOOTPRINT_EDITOR_SETTINGS::MigrateFromLegacy( wxConfigBase* aCfg ) migrateLegacyColor( f + "Color4DPCBBackground", LAYER_PCB_BACKGROUND ); migrateLegacyColor( f + "Color4DPCBCursor", LAYER_CURSOR ); migrateLegacyColor( f + "Color4DRatsEx", LAYER_RATSNEST ); - migrateLegacyColor( f + "Color4DTxtInvisEx", LAYER_MOD_TEXT_INVISIBLE ); + migrateLegacyColor( f + "Color4DTxtInvisEx", LAYER_HIDDEN_TEXT ); migrateLegacyColor( f + "Color4DViaBBlindEx", LAYER_VIA_BBLIND ); migrateLegacyColor( f + "Color4DViaMicroEx", LAYER_VIA_MICROVIA ); migrateLegacyColor( f + "Color4DViaThruEx", LAYER_VIA_THROUGH ); diff --git a/pcbnew/pad.cpp b/pcbnew/pad.cpp index d8e0daa686..790cec7643 100644 --- a/pcbnew/pad.cpp +++ b/pcbnew/pad.cpp @@ -1324,7 +1324,7 @@ void PAD::ViewGetLayers( int aLayers[], int& aCount ) const } else if( IsOnLayer( F_Cu ) ) { - aLayers[aCount++] = LAYER_PAD_FR; + aLayers[aCount++] = LAYER_PADS_SMD_FR; // Is this a PTH pad that has only front copper? If so, we need to also display the // net name on the PTH netname layer so that it isn't blocked by the drill hole. @@ -1335,7 +1335,7 @@ void PAD::ViewGetLayers( int aLayers[], int& aCount ) const } else if( IsOnLayer( B_Cu ) ) { - aLayers[aCount++] = LAYER_PAD_BK; + aLayers[aCount++] = LAYER_PADS_SMD_BK; // Is this a PTH pad that has only back copper? If so, we need to also display the // net name on the PTH netname layer so that it isn't blocked by the drill hole. @@ -1387,16 +1387,16 @@ double PAD::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const return HIDE; } - if( !IsFlipped() && !aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( !IsFlipped() && !aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return HIDE; - if( IsFlipped() && !aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( IsFlipped() && !aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return HIDE; - if( IsFrontLayer( (PCB_LAYER_ID) aLayer ) && !aView->IsLayerVisible( LAYER_PAD_FR ) ) + if( IsFrontLayer( (PCB_LAYER_ID) aLayer ) && !aView->IsLayerVisible( LAYER_PADS_SMD_FR ) ) return HIDE; - if( IsBackLayer( (PCB_LAYER_ID) aLayer ) && !aView->IsLayerVisible( LAYER_PAD_BK ) ) + if( IsBackLayer( (PCB_LAYER_ID) aLayer ) && !aView->IsLayerVisible( LAYER_PADS_SMD_BK ) ) return HIDE; LSET visible = board->GetVisibleLayers() & board->GetEnabledLayers(); diff --git a/pcbnew/pcb_base_frame.cpp b/pcbnew/pcb_base_frame.cpp index fe68e29f20..1f29f6a17c 100644 --- a/pcbnew/pcb_base_frame.cpp +++ b/pcbnew/pcb_base_frame.cpp @@ -786,16 +786,16 @@ GENERAL_COLLECTORS_GUIDE PCB_BASE_FRAME::GetCollectorsGuide() GetCanvas()->GetView() ); // account for the globals - guide.SetIgnoreMTextsMarkedNoShow( ! m_pcb->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) ); - guide.SetIgnoreMTextsOnBack( ! m_pcb->IsElementVisible( LAYER_MOD_TEXT ) ); - guide.SetIgnoreMTextsOnFront( ! m_pcb->IsElementVisible( LAYER_MOD_TEXT ) ); - guide.SetIgnoreModulesOnBack( ! m_pcb->IsElementVisible( LAYER_MOD_BK ) ); - guide.SetIgnoreModulesOnFront( ! m_pcb->IsElementVisible( LAYER_MOD_FR ) ); - guide.SetIgnorePadsOnBack( ! m_pcb->IsElementVisible( LAYER_PAD_BK ) ); - guide.SetIgnorePadsOnFront( ! m_pcb->IsElementVisible( LAYER_PAD_FR ) ); + guide.SetIgnoreMTextsMarkedNoShow( ! m_pcb->IsElementVisible( LAYER_HIDDEN_TEXT ) ); + guide.SetIgnoreMTextsOnBack( ! m_pcb->IsElementVisible( LAYER_FP_TEXT ) ); + guide.SetIgnoreMTextsOnFront( ! m_pcb->IsElementVisible( LAYER_FP_TEXT ) ); + guide.SetIgnoreModulesOnBack( ! m_pcb->IsElementVisible( LAYER_FOOTPRINTS_BK ) ); + guide.SetIgnoreModulesOnFront( ! m_pcb->IsElementVisible( LAYER_FOOTPRINTS_FR ) ); + guide.SetIgnorePadsOnBack( ! m_pcb->IsElementVisible( LAYER_PADS_SMD_BK ) ); + guide.SetIgnorePadsOnFront( ! m_pcb->IsElementVisible( LAYER_PADS_SMD_FR ) ); guide.SetIgnoreThroughHolePads( ! m_pcb->IsElementVisible( LAYER_PADS_TH ) ); - guide.SetIgnoreModulesVals( ! m_pcb->IsElementVisible( LAYER_MOD_VALUES ) ); - guide.SetIgnoreModulesRefs( ! m_pcb->IsElementVisible( LAYER_MOD_REFERENCES ) ); + guide.SetIgnoreModulesVals( ! m_pcb->IsElementVisible( LAYER_FP_VALUES ) ); + guide.SetIgnoreModulesRefs( ! m_pcb->IsElementVisible( LAYER_FP_REFERENCES ) ); guide.SetIgnoreThroughVias( ! m_pcb->IsElementVisible( LAYER_VIAS ) ); guide.SetIgnoreBlindBuriedVias( ! m_pcb->IsElementVisible( LAYER_VIAS ) ); guide.SetIgnoreMicroVias( ! m_pcb->IsElementVisible( LAYER_VIAS ) ); diff --git a/pcbnew/pcb_draw_panel_gal.cpp b/pcbnew/pcb_draw_panel_gal.cpp index bb2a8a1288..0524f57677 100644 --- a/pcbnew/pcb_draw_panel_gal.cpp +++ b/pcbnew/pcb_draw_panel_gal.cpp @@ -79,7 +79,7 @@ const int GAL_LAYER_ORDER[] = User_8, ZONE_LAYER_FOR( User_8 ), User_9, ZONE_LAYER_FOR( User_9 ), - LAYER_MOD_TEXT, LAYER_MOD_REFERENCES, LAYER_MOD_VALUES, + LAYER_FP_TEXT, LAYER_FP_REFERENCES, LAYER_FP_VALUES, LAYER_RATSNEST, LAYER_ANCHOR, @@ -89,7 +89,7 @@ const int GAL_LAYER_ORDER[] = LAYER_VIA_THROUGH, LAYER_VIA_BBLIND, LAYER_VIA_MICROVIA, LAYER_PADS_TH, - LAYER_PAD_FR_NETNAMES, LAYER_PAD_FR, + LAYER_PAD_FR_NETNAMES, LAYER_PADS_SMD_FR, NETNAMES_LAYER_INDEX( F_Cu ), F_Cu, ZONE_LAYER_FOR( F_Cu ), F_Mask, ZONE_LAYER_FOR( F_Mask ), F_SilkS, ZONE_LAYER_FOR( F_SilkS ), @@ -129,7 +129,7 @@ const int GAL_LAYER_ORDER[] = NETNAMES_LAYER_INDEX( In29_Cu ), In29_Cu, ZONE_LAYER_FOR( In29_Cu ), NETNAMES_LAYER_INDEX( In30_Cu ), In30_Cu, ZONE_LAYER_FOR( In30_Cu ), - LAYER_PAD_BK_NETNAMES, LAYER_PAD_BK, + LAYER_PAD_BK_NETNAMES, LAYER_PADS_SMD_BK, NETNAMES_LAYER_INDEX( B_Cu ), B_Cu, ZONE_LAYER_FOR( B_Cu ), B_Mask, ZONE_LAYER_FOR( B_Mask ), B_SilkS, ZONE_LAYER_FOR( B_SilkS ), @@ -361,13 +361,13 @@ void PCB_DRAW_PANEL_GAL::SetHighContrastLayer( PCB_LAYER_ID aLayer ) // Pads should be shown too if( aLayer == B_Cu ) { - rSettings->SetLayerIsHighContrast( LAYER_PAD_BK ); - rSettings->SetLayerIsHighContrast( LAYER_MOD_BK ); + rSettings->SetLayerIsHighContrast( LAYER_PADS_SMD_BK ); + rSettings->SetLayerIsHighContrast( LAYER_FOOTPRINTS_BK ); } else if( aLayer == F_Cu ) { - rSettings->SetLayerIsHighContrast( LAYER_PAD_FR ); - rSettings->SetLayerIsHighContrast( LAYER_MOD_FR ); + rSettings->SetLayerIsHighContrast( LAYER_PADS_SMD_FR ); + rSettings->SetLayerIsHighContrast( LAYER_FOOTPRINTS_FR ); } } @@ -398,12 +398,12 @@ void PCB_DRAW_PANEL_GAL::SetTopLayer( PCB_LAYER_ID aLayer ) // Extra layers that are brought to the top if a F.* or B.* is selected const std::vector frontLayers = { - F_Cu, F_Adhes, F_Paste, F_SilkS, F_Mask, F_Fab, F_CrtYd, LAYER_PAD_FR, + F_Cu, F_Adhes, F_Paste, F_SilkS, F_Mask, F_Fab, F_CrtYd, LAYER_PADS_SMD_FR, LAYER_PAD_FR_NETNAMES, NETNAMES_LAYER_INDEX( F_Cu ) }; const std::vector backLayers = { - B_Cu, B_Adhes, B_Paste, B_SilkS, B_Mask, B_Fab, B_CrtYd, LAYER_PAD_BK, + B_Cu, B_Adhes, B_Paste, B_SilkS, B_Mask, B_Fab, B_CrtYd, LAYER_PADS_SMD_BK, LAYER_PAD_BK_NETNAMES, NETNAMES_LAYER_INDEX( B_Cu ) }; @@ -470,8 +470,8 @@ void PCB_DRAW_PANEL_GAL::SyncLayersVisibility( const BOARD* aBoard ) m_view->SetLayerVisible( LAYER_VIA_THROUGH, true ); // Pad layers controlled by dependencies - m_view->SetLayerVisible( LAYER_PAD_FR, true ); - m_view->SetLayerVisible( LAYER_PAD_BK, true ); + m_view->SetLayerVisible( LAYER_PADS_SMD_FR, true ); + m_view->SetLayerVisible( LAYER_PADS_SMD_BK, true ); // Always enable netname layers, as their visibility is controlled by layer dependencies for( int i = NETNAMES_LAYER_ID_START; i < NETNAMES_LAYER_ID_END; ++i ) @@ -672,16 +672,16 @@ void PCB_DRAW_PANEL_GAL::setDefaultLayerDeps() // Pad visibility m_view->SetRequired( LAYER_PADS_TH, LAYER_PADS ); - m_view->SetRequired( LAYER_PAD_FR, LAYER_PADS ); - m_view->SetRequired( LAYER_PAD_BK, LAYER_PADS ); + m_view->SetRequired( LAYER_PADS_SMD_FR, LAYER_PADS ); + m_view->SetRequired( LAYER_PADS_SMD_BK, LAYER_PADS ); // Front footprints - m_view->SetRequired( LAYER_PAD_FR, F_Cu ); - m_view->SetRequired( LAYER_PAD_FR_NETNAMES, LAYER_PAD_FR ); + m_view->SetRequired( LAYER_PADS_SMD_FR, F_Cu ); + m_view->SetRequired( LAYER_PAD_FR_NETNAMES, LAYER_PADS_SMD_FR ); // Back footprints - m_view->SetRequired( LAYER_PAD_BK, B_Cu ); - m_view->SetRequired( LAYER_PAD_BK_NETNAMES, LAYER_PAD_BK ); + m_view->SetRequired( LAYER_PADS_SMD_BK, B_Cu ); + m_view->SetRequired( LAYER_PAD_BK_NETNAMES, LAYER_PADS_SMD_BK ); m_view->SetLayerTarget( LAYER_SELECT_OVERLAY, KIGFX::TARGET_OVERLAY ); m_view->SetLayerDisplayOnly( LAYER_SELECT_OVERLAY ) ; diff --git a/pcbnew/pcb_field.cpp b/pcbnew/pcb_field.cpp index 66d3b16429..4a48636333 100644 --- a/pcbnew/pcb_field.cpp +++ b/pcbnew/pcb_field.cpp @@ -132,10 +132,10 @@ double PCB_FIELD::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const return 0.0; // Handle Render tab switches - if( IsValue() && !aView->IsLayerVisible( LAYER_MOD_VALUES ) ) + if( IsValue() && !aView->IsLayerVisible( LAYER_FP_VALUES ) ) return HIDE; - if( IsReference() && !aView->IsLayerVisible( LAYER_MOD_REFERENCES ) ) + if( IsReference() && !aView->IsLayerVisible( LAYER_FP_REFERENCES ) ) return HIDE; return PCB_TEXT::ViewGetLOD( aLayer, aView ); diff --git a/pcbnew/pcb_painter.cpp b/pcbnew/pcb_painter.cpp index acb01bee23..51960a21e4 100644 --- a/pcbnew/pcb_painter.cpp +++ b/pcbnew/pcb_painter.cpp @@ -143,8 +143,8 @@ void PCB_RENDER_SETTINGS::LoadColors( const COLOR_SETTINGS* aSettings ) m_layerColors[LAYER_PAD_PLATEDHOLES] = aSettings->GetColor( LAYER_PCB_BACKGROUND ); m_layerColors[LAYER_VIA_NETNAMES] = COLOR4D( 0.2, 0.2, 0.2, 0.9 ); m_layerColors[LAYER_PAD_NETNAMES] = COLOR4D( 1.0, 1.0, 1.0, 0.9 ); - m_layerColors[LAYER_PAD_FR] = aSettings->GetColor( F_Cu ); - m_layerColors[LAYER_PAD_BK] = aSettings->GetColor( B_Cu ); + m_layerColors[LAYER_PADS_SMD_FR] = aSettings->GetColor( F_Cu ); + m_layerColors[LAYER_PADS_SMD_BK] = aSettings->GetColor( B_Cu ); m_layerColors[LAYER_PAD_FR_NETNAMES] = COLOR4D( 1.0, 1.0, 1.0, 0.9 ); m_layerColors[LAYER_PAD_BK_NETNAMES] = COLOR4D( 1.0, 1.0, 1.0, 0.9 ); @@ -1592,7 +1592,7 @@ void PCB_PAINTER::draw( const PAD* aPad, int aLayer ) } if( pcbconfig() && pcbconfig()->m_Display.m_PadClearance - && ( aLayer == LAYER_PAD_FR || aLayer == LAYER_PAD_BK || aLayer == LAYER_PADS_TH ) + && ( aLayer == LAYER_PADS_SMD_FR || aLayer == LAYER_PADS_SMD_BK || aLayer == LAYER_PADS_TH ) && !m_pcbSettings.m_isPrinting ) { /* Showing the clearance area is not obvious. diff --git a/pcbnew/pcb_shape.cpp b/pcbnew/pcb_shape.cpp index ab4334f167..b65dc9c3f1 100644 --- a/pcbnew/pcb_shape.cpp +++ b/pcbnew/pcb_shape.cpp @@ -318,10 +318,10 @@ double PCB_SHAPE::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const if( FOOTPRINT* parent = GetParentFootprint() ) { - if( parent->GetLayer() == F_Cu && !aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( parent->GetLayer() == F_Cu && !aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return HIDE; - if( parent->GetLayer() == B_Cu && !aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( parent->GetLayer() == B_Cu && !aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return HIDE; } diff --git a/pcbnew/pcb_text.cpp b/pcbnew/pcb_text.cpp index e46ad744f4..afa4e6a17b 100644 --- a/pcbnew/pcb_text.cpp +++ b/pcbnew/pcb_text.cpp @@ -149,7 +149,7 @@ void PCB_TEXT::ViewGetLayers( int aLayers[], int& aCount ) const if( GetParentFootprint() == nullptr || IsVisible() ) aLayers[0] = GetLayer(); else - aLayers[0] = LAYER_MOD_TEXT_INVISIBLE; + aLayers[0] = LAYER_HIDDEN_TEXT; aCount = 1; } @@ -165,7 +165,7 @@ double PCB_TEXT::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const KIGFX::PCB_PAINTER* painter = static_cast( aView->GetPainter() ); KIGFX::PCB_RENDER_SETTINGS* renderSettings = painter->GetSettings(); - // Hidden text gets put on the LAYER_MOD_TEXT_INVISIBLE for rendering, but + // Hidden text gets put on the LAYER_HIDDEN_TEXT for rendering, but // should only render if its native layer is visible. if( !aView->IsLayerVisible( GetLayer() ) ) return HIDE; @@ -185,23 +185,23 @@ double PCB_TEXT::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const // Handle Render tab switches if( GetText() == wxT( "${VALUE}" ) ) { - if( !aView->IsLayerVisible( LAYER_MOD_VALUES ) ) + if( !aView->IsLayerVisible( LAYER_FP_VALUES ) ) return HIDE; } if( GetText() == wxT( "${REFERENCE}" ) ) { - if( !aView->IsLayerVisible( LAYER_MOD_REFERENCES ) ) + if( !aView->IsLayerVisible( LAYER_FP_REFERENCES ) ) return HIDE; } - if( parentFP->GetLayer() == F_Cu && !aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( parentFP->GetLayer() == F_Cu && !aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return HIDE; - if( parentFP->GetLayer() == B_Cu && !aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( parentFP->GetLayer() == B_Cu && !aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return HIDE; - if( !aView->IsLayerVisible( LAYER_MOD_TEXT ) ) + if( !aView->IsLayerVisible( LAYER_FP_TEXT ) ) return HIDE; } diff --git a/pcbnew/pcbnew_printout.cpp b/pcbnew/pcbnew_printout.cpp index 2540821de4..fd28d2b53a 100644 --- a/pcbnew/pcbnew_printout.cpp +++ b/pcbnew/pcbnew_printout.cpp @@ -161,15 +161,15 @@ void PCBNEW_PRINTOUT::setupViewLayers( KIGFX::VIEW& aView, const LSET& aLayerSet renderSettings->SetLayerColor( aLayer, invisible_color ); }; - setVisibility( LAYER_MOD_FR ); - setVisibility( LAYER_MOD_BK ); - setVisibility( LAYER_MOD_VALUES ); - setVisibility( LAYER_MOD_REFERENCES ); - setVisibility( LAYER_MOD_TEXT ); - setVisibility( LAYER_MOD_TEXT_INVISIBLE ); + setVisibility( LAYER_FOOTPRINTS_FR ); + setVisibility( LAYER_FOOTPRINTS_BK ); + setVisibility( LAYER_FP_VALUES ); + setVisibility( LAYER_FP_REFERENCES ); + setVisibility( LAYER_FP_TEXT ); + setVisibility( LAYER_HIDDEN_TEXT ); setVisibility( LAYER_PADS ); - setVisibility( LAYER_PAD_FR ); - setVisibility( LAYER_PAD_BK ); + setVisibility( LAYER_PADS_SMD_FR ); + setVisibility( LAYER_PADS_SMD_BK ); setVisibility( LAYER_PADS_TH ); setVisibility( LAYER_TRACKS ); @@ -189,14 +189,14 @@ void PCBNEW_PRINTOUT::setupViewLayers( KIGFX::VIEW& aView, const LSET& aLayerSet else { // Draw layers that must be not visible on printing are set to an invisible layer - // LAYER_PAD_FR, LAYER_PAD_BK and LAYER_PADS_TH must be enabled to print pads on + // LAYER_PADS_SMD_FR, LAYER_PADS_SMD_BK and LAYER_PADS_TH must be enabled to print pads on // technical layers, but not the pad on copper layer(s) if they are not enabled if( !aLayerSet.test( F_Cu ) ) - renderSettings->SetLayerColor( LAYER_PAD_FR, invisible_color ); + renderSettings->SetLayerColor( LAYER_PADS_SMD_FR, invisible_color ); if( !aLayerSet.test( B_Cu ) ) - renderSettings->SetLayerColor( LAYER_PAD_BK, invisible_color ); + renderSettings->SetLayerColor( LAYER_PADS_SMD_BK, invisible_color ); // Enable items on copper layers, but do not draw holes for( GAL_LAYER_ID layer : { LAYER_PADS_TH, LAYER_VIA_THROUGH, LAYER_VIA_MICROVIA, LAYER_VIA_BBLIND } ) @@ -208,14 +208,15 @@ void PCBNEW_PRINTOUT::setupViewLayers( KIGFX::VIEW& aView, const LSET& aLayerSet } // Keep certain items always enabled/disabled and just rely on the layer visibility - // Note LAYER_PAD_FR, LAYER_PAD_BK, LAYER_PADS_TH are enabled here because paths must + // Note LAYER_PADS_SMD_FR, LAYER_PADS_SMD_BK, LAYER_PADS_TH are enabled here because paths must // be drawn on some other (technical) layers. const int alwaysEnabled[] = { - LAYER_MOD_TEXT, LAYER_MOD_FR, LAYER_MOD_BK, - LAYER_MOD_VALUES, LAYER_MOD_REFERENCES, LAYER_TRACKS, LAYER_ZONES, LAYER_PADS, - LAYER_VIAS, - LAYER_PAD_FR, LAYER_PAD_BK, LAYER_PADS_TH + LAYER_FP_TEXT, LAYER_FP_VALUES, LAYER_FP_REFERENCES, + LAYER_FOOTPRINTS_FR, LAYER_FOOTPRINTS_BK, + LAYER_TRACKS, LAYER_VIAS, + LAYER_ZONES, + LAYER_PADS, LAYER_PADS_SMD_FR, LAYER_PADS_SMD_BK, LAYER_PADS_TH }; for( int layer : alwaysEnabled ) diff --git a/pcbnew/pcbnew_settings.cpp b/pcbnew/pcbnew_settings.cpp index d0ad54fe0d..33b92b5f88 100644 --- a/pcbnew/pcbnew_settings.cpp +++ b/pcbnew/pcbnew_settings.cpp @@ -900,7 +900,7 @@ bool PCBNEW_SETTINGS::MigrateFromLegacy( wxConfigBase* aCfg ) migrateLegacyColor( "Color4DPCBBackground", LAYER_PCB_BACKGROUND ); migrateLegacyColor( "Color4DPCBCursor", LAYER_CURSOR ); migrateLegacyColor( "Color4DRatsEx", LAYER_RATSNEST ); - migrateLegacyColor( "Color4DTxtInvisEx", LAYER_MOD_TEXT_INVISIBLE ); + migrateLegacyColor( "Color4DTxtInvisEx", LAYER_HIDDEN_TEXT ); migrateLegacyColor( "Color4DViaBBlindEx", LAYER_VIA_BBLIND ); migrateLegacyColor( "Color4DViaMicroEx", LAYER_VIA_MICROVIA ); migrateLegacyColor( "Color4DViaThruEx", LAYER_VIA_THROUGH ); diff --git a/pcbnew/tools/pcb_selection_tool.cpp b/pcbnew/tools/pcb_selection_tool.cpp index 0bf6c57c9b..77a0502750 100644 --- a/pcbnew/tools/pcb_selection_tool.cpp +++ b/pcbnew/tools/pcb_selection_tool.cpp @@ -679,16 +679,16 @@ const GENERAL_COLLECTORS_GUIDE PCB_SELECTION_TOOL::getCollectorsGuide() const bool padsDisabled = !board()->IsElementVisible( LAYER_PADS ); // account for the globals - guide.SetIgnoreMTextsMarkedNoShow( ! board()->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) ); - guide.SetIgnoreMTextsOnBack( ! board()->IsElementVisible( LAYER_MOD_TEXT ) ); - guide.SetIgnoreMTextsOnFront( ! board()->IsElementVisible( LAYER_MOD_TEXT ) ); - guide.SetIgnoreModulesOnBack( ! board()->IsElementVisible( LAYER_MOD_BK ) ); - guide.SetIgnoreModulesOnFront( ! board()->IsElementVisible( LAYER_MOD_FR ) ); - guide.SetIgnorePadsOnBack( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_BK ) ); - guide.SetIgnorePadsOnFront( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_FR ) ); + guide.SetIgnoreMTextsMarkedNoShow( ! board()->IsElementVisible( LAYER_HIDDEN_TEXT ) ); + guide.SetIgnoreMTextsOnBack( ! board()->IsElementVisible( LAYER_FP_TEXT ) ); + guide.SetIgnoreMTextsOnFront( ! board()->IsElementVisible( LAYER_FP_TEXT ) ); + guide.SetIgnoreModulesOnBack( ! board()->IsElementVisible( LAYER_FOOTPRINTS_BK ) ); + guide.SetIgnoreModulesOnFront( ! board()->IsElementVisible( LAYER_FOOTPRINTS_FR ) ); + guide.SetIgnorePadsOnBack( padsDisabled || ! board()->IsElementVisible( LAYER_PADS_SMD_BK ) ); + guide.SetIgnorePadsOnFront( padsDisabled || ! board()->IsElementVisible( LAYER_PADS_SMD_FR ) ); guide.SetIgnoreThroughHolePads( padsDisabled || ! board()->IsElementVisible( LAYER_PADS_TH ) ); - guide.SetIgnoreModulesVals( ! board()->IsElementVisible( LAYER_MOD_VALUES ) ); - guide.SetIgnoreModulesRefs( ! board()->IsElementVisible( LAYER_MOD_REFERENCES ) ); + guide.SetIgnoreModulesVals( ! board()->IsElementVisible( LAYER_FP_VALUES ) ); + guide.SetIgnoreModulesRefs( ! board()->IsElementVisible( LAYER_FP_REFERENCES ) ); guide.SetIgnoreThroughVias( ! board()->IsElementVisible( LAYER_VIAS ) ); guide.SetIgnoreBlindBuriedVias( ! board()->IsElementVisible( LAYER_VIAS ) ); guide.SetIgnoreMicroVias( ! board()->IsElementVisible( LAYER_VIAS ) ); @@ -2585,10 +2585,10 @@ bool PCB_SELECTION_TOOL::Selectable( const BOARD_ITEM* aItem, bool checkVisibili case PCB_FIELD_T: field = static_cast( aItem ); - if( field->IsReference() && !view()->IsLayerVisible( LAYER_MOD_REFERENCES ) ) + if( field->IsReference() && !view()->IsLayerVisible( LAYER_FP_REFERENCES ) ) return false; - if( field->IsValue() && !view()->IsLayerVisible( LAYER_MOD_VALUES ) ) + if( field->IsValue() && !view()->IsLayerVisible( LAYER_FP_VALUES ) ) return false; // Handle all other fields with normal text visibility controls @@ -2598,7 +2598,7 @@ bool PCB_SELECTION_TOOL::Selectable( const BOARD_ITEM* aItem, bool checkVisibili if( m_isFootprintEditor ) { - if( !text->IsVisible() && !view()->IsLayerVisible( LAYER_MOD_TEXT_INVISIBLE ) ) + if( !text->IsVisible() && !view()->IsLayerVisible( LAYER_HIDDEN_TEXT ) ) return false; if( !view()->IsLayerVisible( text->GetLayer() ) ) @@ -2612,12 +2612,12 @@ bool PCB_SELECTION_TOOL::Selectable( const BOARD_ITEM* aItem, bool checkVisibili if( !board()->IsLayerVisible( text->GetLayer() ) ) return false; - int controlLayer = LAYER_MOD_TEXT; + int controlLayer = LAYER_FP_TEXT; if( text->GetText() == wxT( "${REFERENCE}" ) ) - controlLayer = LAYER_MOD_REFERENCES; + controlLayer = LAYER_FP_REFERENCES; else if( text->GetText() == wxT( "${VALUE}" ) ) - controlLayer = LAYER_MOD_VALUES; + controlLayer = LAYER_FP_VALUES; if( !view()->IsLayerVisible( controlLayer ) ) return false; @@ -2661,9 +2661,9 @@ bool PCB_SELECTION_TOOL::Selectable( const BOARD_ITEM* aItem, bool checkVisibili else { // Check render mode (from the Items tab) first - if( pad->IsOnLayer( F_Cu ) && !board()->IsElementVisible( LAYER_PAD_FR ) ) + if( pad->IsOnLayer( F_Cu ) && !board()->IsElementVisible( LAYER_PADS_SMD_FR ) ) return false; - else if( pad->IsOnLayer( B_Cu ) && !board()->IsElementVisible( LAYER_PAD_BK ) ) + else if( pad->IsOnLayer( B_Cu ) && !board()->IsElementVisible( LAYER_PADS_SMD_BK ) ) return false; if( !( pad->GetLayerSet() & visibleLayers() ).any() ) diff --git a/pcbnew/widgets/appearance_controls.cpp b/pcbnew/widgets/appearance_controls.cpp index a217c7672f..7b6d4171d0 100644 --- a/pcbnew/widgets/appearance_controls.cpp +++ b/pcbnew/widgets/appearance_controls.cpp @@ -329,13 +329,13 @@ const APPEARANCE_CONTROLS::APPEARANCE_SETTING APPEARANCE_CONTROLS::s_objectSetti RR( _HKI( "Zones" ), LAYER_ZONES, _HKI( "Show copper zones" ), true ), RR( _HKI( "Images" ), LAYER_DRAW_BITMAPS, _HKI( "Show user images" ), true ), RR(), - RR( _HKI( "Footprints Front" ), LAYER_MOD_FR, _HKI( "Show footprints that are on board's front" ) ), - RR( _HKI( "Footprints Back" ), LAYER_MOD_BK, _HKI( "Show footprints that are on board's back" ) ), + RR( _HKI( "Footprints Front" ), LAYER_FOOTPRINTS_FR, _HKI( "Show footprints that are on board's front" ) ), + RR( _HKI( "Footprints Back" ), LAYER_FOOTPRINTS_BK, _HKI( "Show footprints that are on board's back" ) ), RR( _HKI( "Through-hole Pads" ), LAYER_PADS_TH, _HKI( "Show through-hole pads" ) ), - RR( _HKI( "Values" ), LAYER_MOD_VALUES, _HKI( "Show footprint values" ) ), - RR( _HKI( "References" ), LAYER_MOD_REFERENCES, _HKI( "Show footprint references" ) ), - RR( _HKI( "Footprint Text" ), LAYER_MOD_TEXT, _HKI( "Show all footprint text" ) ), - RR( _HKI( "Hidden Text" ), LAYER_MOD_TEXT_INVISIBLE, _HKI( "Show footprint text marked as invisible" ) ), + RR( _HKI( "Values" ), LAYER_FP_VALUES, _HKI( "Show footprint values" ) ), + RR( _HKI( "References" ), LAYER_FP_REFERENCES, _HKI( "Show footprint references" ) ), + RR( _HKI( "Footprint Text" ), LAYER_FP_TEXT, _HKI( "Show all footprint text" ) ), + RR( _HKI( "Hidden Text" ), LAYER_HIDDEN_TEXT, _HKI( "Show text marked as hidden" ) ), RR(), RR(), RR( _HKI( "Ratsnest" ), LAYER_RATSNEST, _HKI( "Show unconnected nets as a ratsnest") ), @@ -356,10 +356,10 @@ static std::set s_allowedInFpEditor = LAYER_PADS, LAYER_ZONES, LAYER_PADS_TH, - LAYER_MOD_VALUES, - LAYER_MOD_REFERENCES, - LAYER_MOD_TEXT, - LAYER_MOD_TEXT_INVISIBLE, + LAYER_FP_VALUES, + LAYER_FP_REFERENCES, + LAYER_FP_TEXT, + LAYER_HIDDEN_TEXT, LAYER_DRAW_BITMAPS, LAYER_GRID }; @@ -2049,28 +2049,28 @@ void APPEARANCE_CONTROLS::onObjectVisibilityChanged( GAL_LAYER_ID aLayer, bool i syncLayerPresetSelection(); break; - case LAYER_MOD_TEXT: + case LAYER_FP_TEXT: // Because Footprint Text is a meta-control that also can disable values/references, // drag them along here so that the user is less likely to be confused. if( isFinal ) { // Should only trigger when you actually click the Footprint Text button // Otherwise it goes into infinite recursive loop with the following case section - onObjectVisibilityChanged( LAYER_MOD_REFERENCES, isVisible, false ); - onObjectVisibilityChanged( LAYER_MOD_VALUES, isVisible, false ); - m_objectSettingsMap[LAYER_MOD_REFERENCES]->ctl_visibility->SetValue( isVisible ); - m_objectSettingsMap[LAYER_MOD_VALUES]->ctl_visibility->SetValue( isVisible ); + onObjectVisibilityChanged( LAYER_FP_REFERENCES, isVisible, false ); + onObjectVisibilityChanged( LAYER_FP_VALUES, isVisible, false ); + m_objectSettingsMap[LAYER_FP_REFERENCES]->ctl_visibility->SetValue( isVisible ); + m_objectSettingsMap[LAYER_FP_VALUES]->ctl_visibility->SetValue( isVisible ); } break; - case LAYER_MOD_REFERENCES: - case LAYER_MOD_VALUES: + case LAYER_FP_REFERENCES: + case LAYER_FP_VALUES: // In case that user changes Footprint Value/References when the Footprint Text // meta-control is disabled, we should put it back on. if( isVisible ) { - onObjectVisibilityChanged( LAYER_MOD_TEXT, isVisible, false ); - m_objectSettingsMap[LAYER_MOD_TEXT]->ctl_visibility->SetValue( isVisible ); + onObjectVisibilityChanged( LAYER_FP_TEXT, isVisible, false ); + m_objectSettingsMap[LAYER_FP_TEXT]->ctl_visibility->SetValue( isVisible ); } break; @@ -2924,9 +2924,9 @@ void APPEARANCE_CONTROLS::OnColorSwatchChanged( wxCommandEvent& aEvent ) view->UpdateLayerColor( ZONE_LAYER_FOR( layer ) ); if( layer == F_Cu ) - view->UpdateLayerColor( LAYER_PAD_FR ); + view->UpdateLayerColor( LAYER_PADS_SMD_FR ); else if( layer == B_Cu ) - view->UpdateLayerColor( LAYER_PAD_BK ); + view->UpdateLayerColor( LAYER_PADS_SMD_BK ); // Update the bitmap of the layer box if( m_frame->IsType( FRAME_PCB_EDITOR ) ) diff --git a/pcbnew/zone.cpp b/pcbnew/zone.cpp index 1e97f07b0d..2b93f3f52e 100644 --- a/pcbnew/zone.cpp +++ b/pcbnew/zone.cpp @@ -330,10 +330,10 @@ double ZONE::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const bool flipped = parentFP->GetLayer() == B_Cu; // Handle Render tab switches - if( !flipped && !aView->IsLayerVisible( LAYER_MOD_FR ) ) + if( !flipped && !aView->IsLayerVisible( LAYER_FOOTPRINTS_FR ) ) return HIDE; - if( flipped && !aView->IsLayerVisible( LAYER_MOD_BK ) ) + if( flipped && !aView->IsLayerVisible( LAYER_FOOTPRINTS_BK ) ) return HIDE; }