haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update layer names to current terminology. 

Also fixes some out-of-date tooltips/names.
This commit is contained in:
Jeff Young 2023-08-04 11:13:20 +01:00
parent 29f2afedbd
commit c697a934b2
22 changed files with 167 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
common/layer_id.cpp
View File

@ -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" );

20
common/lset.cpp
View File

@ -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,

4
common/settings/builtin_color_themes.h
View File

@ -155,7 +155,7 @@ static const std::map<int, COLOR4D> 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<int, COLOR4D> 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 ) },

2
common/settings/color_settings.cpp
View File

@ -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 );

4
common/view/view_group.cpp
View File

@ -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:

26
include/layer_ids.h
View File

@ -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<int> netCopperLayers =
{
LAYER_PAD_FR,
LAYER_PAD_BK,
LAYER_PADS_SMD_FR,
LAYER_PADS_SMD_BK,
LAYER_PADS_TH,
LAYER_PAD_HOLEWALLS,
LAYER_VIA_THROUGH,

12
pcbnew/board.cpp
View File

@ -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 ) );
}
}

14
pcbnew/dialogs/panel_pcbnew_color_settings.cpp
View File

@ -354,14 +354,14 @@ std::set<int> 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,

24
pcbnew/footprint.cpp
View File

@ -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<double>::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<double>::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.

2
pcbnew/footprint_editor_settings.cpp
View File

@ -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 );

12
pcbnew/pad.cpp
View File

@ -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();

18
pcbnew/pcb_base_frame.cpp
View File

@ -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 ) );

34
pcbnew/pcb_draw_panel_gal.cpp
View File

@ -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<int> 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<int> 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 ) ;

4
pcbnew/pcb_field.cpp
View File

@ -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 );

6
pcbnew/pcb_painter.cpp
View File

@ -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.

4
pcbnew/pcb_shape.cpp
View File

@ -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;
}

14
pcbnew/pcb_text.cpp
View File

@ -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<KIGFX::PCB_PAINTER*>( 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;
}

33
pcbnew/pcbnew_printout.cpp
View File

@ -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 )

2
pcbnew/pcbnew_settings.cpp
View File

@ -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 );

34
pcbnew/tools/pcb_selection_tool.cpp
View File

@ -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<const PCB_FIELD*>( 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() )

42
pcbnew/widgets/appearance_controls.cpp
View File

@ -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<int> 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 ) )

4
pcbnew/zone.cpp
View File

@ -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;
}