Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

Remove PCB_LAYER_WIDGET

pull/16/head
Jon Evans 5 years ago
parent
b0e05ad9bf
commit
6f54a9982c
8 changed files with 4 additions and 886 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      pcbnew/CMakeLists.txt
  2. 1
      pcbnew/pcb_base_edit_frame.h
  3. 9
      pcbnew/pcb_edit_frame.cpp
  4. 3
      pcbnew/pcb_edit_frame.h
  5. 703
      pcbnew/pcb_layer_widget.cpp
  6. 166
      pcbnew/pcb_layer_widget.h
  7. 1
      pcbnew/router/router_tool.cpp
  8. 5
      pcbnew/widgets/appearance_controls.cpp

2
pcbnew/CMakeLists.txt
View File

@ -297,14 +297,12 @@ set( PCBNEW_CLASS_SRCS
grid_layer_box_helpers.cpp
grid_layer_box_helpers.h
initpcb.cpp
layer_widget.cpp
load_select_footprint.cpp
menubar_footprint_editor.cpp
menubar_pcb_editor.cpp
pad_naming.cpp
pcb_base_edit_frame.cpp
pcb_layer_box_selector.cpp
pcb_layer_widget.cpp
# pcb_draw_panel_gal.cpp
# pcb_view.cpp
pcb_edit_frame.cpp

1
pcbnew/pcb_base_edit_frame.h
View File

@ -30,7 +30,6 @@
class APPEARANCE_CONTROLS;
class BOARD_ITEM_CONTAINER;
class PCB_LAYER_WIDGET;
class PANEL_SELECTION_FILTER;
/**

9
pcbnew/pcb_edit_frame.cpp
View File

@ -32,7 +32,6 @@
#include <pcbnew_id.h>
#include <pcbnew_settings.h>
#include <pcb_layer_box_selector.h>
#include <pcb_layer_widget.h>
#include <footprint_edit_frame.h>
#include <dialog_plot.h>
#include <dialog_edit_footprint_for_BoardEditor.h>
@ -168,8 +167,6 @@ BEGIN_EVENT_TABLE( PCB_EDIT_FRAME, PCB_BASE_FRAME )
PCB_EDIT_FRAME::OnUpdateSelectTrackWidth )
EVT_UPDATE_UI_RANGE( ID_POPUP_PCB_SELECT_VIASIZE1, ID_POPUP_PCB_SELECT_VIASIZE8,
PCB_EDIT_FRAME::OnUpdateSelectViaSize )
EVT_COMMAND( wxID_ANY, LAYER_WIDGET::EVT_LAYER_COLOR_CHANGE, PCB_EDIT_FRAME::OnLayerColorChange )
END_EVENT_TABLE()
@ -1238,12 +1235,6 @@ void PCB_EDIT_FRAME::ScriptingConsoleEnableDisable()
#endif
void PCB_EDIT_FRAME::OnLayerColorChange( wxCommandEvent& aEvent )
{
ReCreateLayerBox();
}
void PCB_EDIT_FRAME::SwitchCanvas( EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType )
{
// switches currently used canvas (Cairo / OpenGL).

3
pcbnew/pcb_edit_frame.h
View File

@ -52,7 +52,6 @@ class ZONE_CONTAINER;
class DRAWSEGMENT;
class GENERAL_COLLECTOR;
class GENERAL_COLLECTORS_GUIDE;
class PCB_LAYER_WIDGET;
class SELECTION;
class MARKER_PCB;
class BOARD_ITEM;
@ -79,7 +78,6 @@ namespace PCB { struct IFACE; } // KIFACE_I is in pcbnew.cpp
class PCB_EDIT_FRAME : public PCB_BASE_EDIT_FRAME
{
friend struct PCB::IFACE;
friend class PCB_LAYER_WIDGET;
friend class APPEARANCE_CONTROLS;
/// The auxiliary right vertical tool bar used to access the microwave tools.
@ -330,7 +328,6 @@ public:
bool MicrowaveToolbarShown();
void OnUpdateSelectViaSize( wxUpdateUIEvent& aEvent );
void OnUpdateSelectTrackWidth( wxUpdateUIEvent& aEvent );
void OnLayerColorChange( wxCommandEvent& aEvent );
void RunEeschema();

703
pcbnew/pcb_layer_widget.cpp
View File

@ -1,703 +0,0 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2004-2017 Jean-Pierre Charras, jean-pierre.charras@gpisa-lab.inpg.fr
* Copyright (C) 2010-2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2010-2020 KiCad Developers, see change_log.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <class_board.h>
#include <fctsys.h>
#include <gal/graphics_abstraction_layer.h>
#include <layer_widget.h>
#include <macros.h>
#include <menus_helpers.h>
#include <pcb_display_options.h>
#include <pcb_edit_frame.h>
#include <pcb_layer_widget.h>
#include <pcb_painter.h>
#include <pcbnew_id.h>
#include <pcbnew_settings.h>
#include <pgm_base.h>
#include <settings/color_settings.h>
#include <tool/tool_manager.h>
#include <view/view.h>
#include <widgets/indicator_icon.h>
/// This is a read only template that is copied and modified before adding to LAYER_WIDGET
const LAYER_WIDGET::ROW PCB_LAYER_WIDGET::s_render_rows[] = {
#define RR LAYER_WIDGET::ROW // Render Row abbreviation to reduce source width
#define NOCOLOR COLOR4D::UNSPECIFIED // specify rows that do not have a color selector icon
// text id color tooltip
RR( _( "Footprints Front" ), LAYER_MOD_FR, NOCOLOR, _( "Show footprints that are on board's front") ),
RR( _( "Footprints Back" ), LAYER_MOD_BK, NOCOLOR, _( "Show footprints that are on board's back") ),
RR( _( "Values" ), LAYER_MOD_VALUES, NOCOLOR, _( "Show footprint values") ),
RR( _( "Reference Designators" ),LAYER_MOD_REFERENCES, NOCOLOR, _( "Show footprint reference designators") ),
RR( _( "Footprint Text Front" ), LAYER_MOD_TEXT_FR, NOCOLOR, _( "Show footprint text on board's front" ) ),
RR( _( "Footprint Text Back" ), LAYER_MOD_TEXT_BK, NOCOLOR, _( "Show footprint text on board's back" ) ),
RR( _( "Hidden Text" ), LAYER_MOD_TEXT_INVISIBLE, WHITE, _( "Show footprint text marked as invisible" ) ),
RR( _( "Pads Front" ), LAYER_PAD_FR, WHITE, _( "Show footprint pads on board's front" ) ),
RR( _( "Pads Back" ), LAYER_PAD_BK, WHITE, _( "Show footprint pads on board's back" ) ),
RR( _( "Through Hole Pads" ), LAYER_PADS_TH, YELLOW, _( "Show through hole pads in specific color") ),
RR(),
RR( _( "Tracks" ), LAYER_TRACKS, NOCOLOR, _( "Show tracks" ) ),
RR( _( "Through Via" ), LAYER_VIA_THROUGH, WHITE, _( "Show through vias" ) ),
RR( _( "Bl/Buried Via" ), LAYER_VIA_BBLIND, WHITE, _( "Show blind or buried vias" ) ),
RR( _( "Micro Via" ), LAYER_VIA_MICROVIA, WHITE, _( "Show micro vias") ),
RR( _( "Non Plated Holes" ), LAYER_NON_PLATEDHOLES, WHITE, _( "Show non plated holes in specific color") ),
RR(),
RR( _( "Ratsnest" ), LAYER_RATSNEST, WHITE, _( "Show unconnected nets as a ratsnest") ),
RR( _( "No-Connects" ), LAYER_NO_CONNECTS, BLUE, _( "Show a marker on pads which have no net connected" ) ),
RR( _( "DRC Warnings" ), LAYER_DRC_WARNING, YELLOW, _( "DRC violations with a Warning severity" ) ),
RR( _( "DRC Errors" ), LAYER_DRC_ERROR, PURERED, _( "DRC violations with an Error severity" ) ),
RR( _( "DRC Exclusions" ), LAYER_DRC_EXCLUSION, WHITE, _( "DRC violations which have been individually excluded" ) ),
RR( _( "Anchors" ), LAYER_ANCHOR, WHITE, _( "Show footprint and text origins as a cross" ) ),
RR( _( "Worksheet" ), LAYER_WORKSHEET, DARKRED, _( "Show worksheet") ),
RR( _( "Cursor" ), LAYER_CURSOR, WHITE, _( "PCB Cursor" ), true, false ),
RR( _( "Aux Items" ), LAYER_AUX_ITEMS, WHITE, _( "Auxiliary items (rulers, assistants, axes, etc.)" ), true, false ),
RR( _( "Grid" ), LAYER_GRID, WHITE, _( "Show the (x,y) grid dots" ) ),
RR( _( "Background" ), LAYER_PCB_BACKGROUND, BLACK, _( "PCB Background" ), true, false )
};
static int s_allowed_in_FpEditor[] =
{
LAYER_MOD_TEXT_INVISIBLE,
LAYER_NON_PLATEDHOLES,
LAYER_PADS_TH,
LAYER_PAD_FR,
LAYER_PAD_BK,
LAYER_MOD_VALUES,
LAYER_MOD_REFERENCES,
LAYER_CURSOR,
LAYER_AUX_ITEMS,
LAYER_GRID,
LAYER_PCB_BACKGROUND
};
PCB_LAYER_WIDGET::PCB_LAYER_WIDGET( PCB_BASE_FRAME* aParent, wxWindow* aFocusOwner,
bool aFpEditorMode ) :
LAYER_WIDGET( aParent, aFocusOwner ),
myframe( aParent )
{
m_alwaysShowActiveCopperLayer = false;
m_fp_editor_mode = aFpEditorMode;
// Update default tabs labels
SetLayersManagerTabsText();
//-----<Popup menu>-------------------------------------------------
// handle the popup menu over the layer window.
m_LayerScrolledWindow->Connect( wxEVT_RIGHT_DOWN,
wxMouseEventHandler( PCB_LAYER_WIDGET::onRightDownLayers ), NULL, this );
// since Popupmenu() calls this->ProcessEvent() we must call this->Connect()
// and not m_LayerScrolledWindow->Connect()
Connect( ID_SHOW_ALL_COPPER_LAYERS, ID_LAST_VALUE - 1,
wxEVT_COMMAND_MENU_SELECTED,
wxCommandEventHandler( PCB_LAYER_WIDGET::onPopupSelection ), NULL, this );
}
COLOR4D PCB_LAYER_WIDGET::getBackgroundLayerColor()
{
return myframe->GetColorSettings()->GetColor( LAYER_PCB_BACKGROUND );
}
bool PCB_LAYER_WIDGET::isAllowedInFpMode( int aId )
{
for( unsigned ii = 0; ii < arrayDim( s_allowed_in_FpEditor ); ii++ )
if( s_allowed_in_FpEditor[ii] == aId )
return true;
return false;
}
void PCB_LAYER_WIDGET::AddRightClickMenuItems( wxMenu& menu )
{
AddMenuItem( &menu, ID_SHOW_ALL_COPPER_LAYERS,
_( "Show All Copper Layers" ),
KiBitmap( select_layer_pair_xpm ) );
AddMenuItem( &menu, ID_HIDE_ALL_COPPER_LAYERS,
_( "Hide All Copper Layers" ),
KiBitmap( show_no_copper_layers_xpm ) );
menu.AppendSeparator();
AddMenuItem( &menu, ID_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE,
_( "Hide All Copper Layers But Active" ),
KiBitmap( select_w_layer_xpm ) );
AddMenuItem( &menu, ID_ALWAYS_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE,
_( "Always Hide All Copper Layers But Active" ),
KiBitmap( select_w_layer_xpm ) );
menu.AppendSeparator();
AddMenuItem( &menu, ID_SHOW_ALL_NON_COPPER,
_( "Show All Non Copper Layers" ),
KiBitmap( select_w_layer_xpm ) );
AddMenuItem( &menu, ID_HIDE_ALL_NON_COPPER,
_( "Hide All Non Copper Layers" ),
KiBitmap( show_no_copper_layers_xpm ) );
menu.AppendSeparator();
AddMenuItem( &menu, ID_SHOW_ALL_LAYERS, _( "Show All Layers" ),
KiBitmap( show_all_layers_xpm ) );
AddMenuItem( &menu, ID_SHOW_NO_LAYERS, _( "Hide All Layers" ),
KiBitmap( show_no_layers_xpm ) );
menu.AppendSeparator();
AddMenuItem( &menu, ID_SHOW_ONLY_FRONT_ASSEMBLY, _( "Show Only Front Assembly Layers" ),
KiBitmap( shape_3d_xpm ) );
AddMenuItem( &menu, ID_SHOW_ONLY_FRONT, _( "Show Only Front Layers" ),
KiBitmap( show_all_front_layers_xpm ) );
// Only show the internal layer option if internal layers are enabled
if( myframe->GetBoard()->GetCopperLayerCount() > 2 )
{
AddMenuItem( &menu, ID_SHOW_ONLY_INNER, _( "Show Only Inner Layers" ),
KiBitmap( show_all_copper_layers_xpm ) );
}
AddMenuItem( &menu, ID_SHOW_ONLY_BACK, _( "Show Only Back Layers" ),
KiBitmap( show_all_back_layers_xpm ) );
AddMenuItem( &menu, ID_SHOW_ONLY_BACK_ASSEMBLY, _( "Show Only Back Assembly Layers" ),
KiBitmap( shape_3d_back_xpm ) );
}
void PCB_LAYER_WIDGET::onRightDownLayers( wxMouseEvent& event )
{
wxMenu menu;
AddRightClickMenuItems( menu );
PopupMenu( &menu );
passOnFocus();
}
void PCB_LAYER_WIDGET::onPopupSelection( wxCommandEvent& event )
{
// Force the active layer to be visible
bool forceActiveLayer = false;
// Reset the always show property
m_alwaysShowActiveCopperLayer = false;
// Make a distinction between the layers we want to enable and those we
// want to disable explictly. That way we can either or the current layerset
// or operate on all layers.
LSET layersToShow;
LSET layersToHide;
switch( event.GetId() )
{
case ID_SHOW_NO_LAYERS:
layersToHide = LSET::AllLayersMask();
break;
case ID_SHOW_ALL_LAYERS:
layersToShow = LSET::AllLayersMask();
break;
case ID_SHOW_ALL_COPPER_LAYERS:
layersToShow = LSET::AllCuMask();
break;
case ID_ALWAYS_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE:
m_alwaysShowActiveCopperLayer = true;
KI_FALLTHROUGH;
case ID_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE:
forceActiveLayer = true;
KI_FALLTHROUGH;
case ID_HIDE_ALL_COPPER_LAYERS:
layersToHide = LSET::AllCuMask();
break;
case ID_HIDE_ALL_NON_COPPER:
layersToHide = LSET::AllNonCuMask();
break;
case ID_SHOW_ALL_NON_COPPER:
layersToShow = LSET::AllNonCuMask();
break;
case ID_SHOW_ONLY_FRONT_ASSEMBLY:
// Include the edgecuts layer as well as the front assembly layers and hide the other layers
layersToShow = LSET::FrontAssembly().set( Edge_Cuts );
layersToHide = ~layersToShow;
myframe->SetActiveLayer( F_SilkS );
break;
case ID_SHOW_ONLY_FRONT:
// Include the edgecuts layer as well as the front layers and hide the other layers
layersToShow = LSET::FrontMask().set( Edge_Cuts );
layersToHide = ~layersToShow;
break;
case ID_SHOW_ONLY_INNER:
// Include the edgecuts layer as well as the internal layers and hide the other layers
layersToShow = LSET::InternalCuMask().set( Edge_Cuts );
layersToHide = ~layersToShow;
break;
case ID_SHOW_ONLY_BACK:
// Include the edgecuts layer as well as the back layers and hide the other layers
layersToShow = LSET::BackMask().set( Edge_Cuts );
layersToHide = ~layersToShow;
break;
case ID_SHOW_ONLY_BACK_ASSEMBLY:
// Include the edgecuts layer as well as the back assembly layers and hide the other layers
layersToShow = LSET::BackAssembly().set( Edge_Cuts );
layersToHide = ~layersToShow;
myframe->SetActiveLayer( B_SilkS );
break;
}
int rowCount = GetLayerRowCount();
for( int row = 0; row < rowCount; ++row )
{
wxCheckBox* cb = static_cast<wxCheckBox*>( getLayerComp( row, COLUMN_COLOR_LYR_CB ) );
PCB_LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
bool visible = cb->GetValue();
if( layersToShow.Contains( layer ) )
visible = true;
if( layersToHide.Contains( layer ) )
visible = false;
// Force the active layer in the editor to be visible
if( forceActiveLayer && ( layer == myframe->GetActiveLayer() ) )
visible = true;
cb->SetValue( visible );
OnLayerVisible( layer, visible, false );
}
// Refresh the drawing canvas
myframe->GetCanvas()->Refresh();
}
void PCB_LAYER_WIDGET::SetLayersManagerTabsText()
{
m_notebook->SetPageText( 0, _( "Layers" ) );
m_notebook->SetPageText( 1, _( "Items" ) );
}
void PCB_LAYER_WIDGET::ReFillRender()
{
BOARD* board = myframe->GetBoard();
ClearRenderRows();
// Add "Items" tab rows to LAYER_WIDGET, after setting color and checkbox state.
// Because s_render_rows is created static, we must explicitly call
// wxGetTranslation for texts which are internationalized (tool tips
// and item names)
for( unsigned row=0; row<arrayDim(s_render_rows); ++row )
{
LAYER_WIDGET::ROW renderRow = s_render_rows[row];
if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
continue;
if( !renderRow.spacer )
{
renderRow.tooltip = wxGetTranslation( s_render_rows[row].tooltip );
renderRow.rowName = wxGetTranslation( s_render_rows[row].rowName );
if( renderRow.color != COLOR4D::UNSPECIFIED ) // does this row show a color?
{
// this window frame must have an established BOARD, i.e. after SetBoard()
renderRow.color = myframe->GetColorSettings()->GetColor(
static_cast<GAL_LAYER_ID>( renderRow.id ) );
renderRow.defaultColor = myframe->GetColorSettings()->GetDefaultColor(
static_cast<GAL_LAYER_ID>( renderRow.id ) );
}
if( renderRow.id == LAYER_RATSNEST )
renderRow.state = myframe->GetDisplayOptions().m_ShowGlobalRatsnest;
else if( renderRow.id == LAYER_GRID )
renderRow.state = myframe->IsGridVisible();
else
renderRow.state = board->IsElementVisible(
static_cast<GAL_LAYER_ID>( renderRow.id ) );
}
AppendRenderRow( renderRow );
}
UpdateLayouts();
}
void PCB_LAYER_WIDGET::SyncLayerVisibilities()
{
BOARD* board = myframe->GetBoard();
int count = GetLayerRowCount();
for( int row=0; row<count; ++row )
{
// this utilizes more implementation knowledge than ideal, eventually
// add member ROW getRow() or similar to base LAYER_WIDGET.
wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
// this does not fire a UI event
setLayerCheckbox( layerId, board->IsLayerVisible( layerId ) );
}
}
#define ALPHA_EPSILON 0.04
void PCB_LAYER_WIDGET::SyncLayerAlphaIndicators()
{
int count = GetLayerRowCount();
TOOL_MANAGER* mgr = myframe->GetToolManager();
KIGFX::PCB_PAINTER* painter = static_cast<KIGFX::PCB_PAINTER*>( mgr->GetView()->GetPainter() );
KIGFX::PCB_RENDER_SETTINGS* settings = painter->GetSettings();
for( int row = 0; row < count; ++row )
{
// this utilizes more implementation knowledge than ideal, eventually
// add member ROW getRow() or similar to base LAYER_WIDGET.
wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
PCB_LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
KIGFX::COLOR4D screenColor = settings->GetLayerColor( layerId );
COLOR_SWATCH* swatch = static_cast<COLOR_SWATCH*>( getLayerComp( row, COLUMN_COLORBM ) );
KIGFX::COLOR4D layerColor = swatch->GetSwatchColor();
INDICATOR_ICON* indicator = static_cast<INDICATOR_ICON*>( getLayerComp( row, COLUMN_ALPHA_INDICATOR ) );
if( std::abs( screenColor.a - layerColor.a ) > ALPHA_EPSILON )
{
if( screenColor.a < layerColor.a )
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::DOWN );
else
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::UP );
}
else
indicator->SetIndicatorState( ROW_ICON_PROVIDER::STATE::OFF );
}
}
void PCB_LAYER_WIDGET::SyncLayerColors()
{
COLOR_SETTINGS* cs = myframe->GetColorSettings();
COLOR4D bg = cs->GetColor( LAYER_PCB_BACKGROUND );
int count = GetLayerRowCount();
int row;
int col = 1; // bitmap button is column 1 in layers tab
for( row = 0; row < count; ++row )
{
COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getLayerComp( row, col ) );
if( swatch )
{
swatch->SetSwatchBackground( bg );
swatch->SetSwatchColor( cs->GetColor( getDecodedId( swatch->GetId() ) ), false );
}
}
count = GetRenderRowCount();
col = 0; // bitmap button is column 0 in render tab
for( row = 0; row < count; ++row )
{
COLOR_SWATCH* swatch = dynamic_cast<COLOR_SWATCH*>( getRenderComp( row, col ) );
if( swatch )
{
swatch->SetSwatchBackground( bg );
swatch->SetSwatchColor( cs->GetColor( getDecodedId( swatch->GetId() ) ), false );
}
}
}
void PCB_LAYER_WIDGET::ReFill()
{
BOARD* brd = myframe->GetBoard();
LSET enabled = brd->GetEnabledLayers();
ClearLayerRows();
wxString dsc;
// show all coppers first, with front on top, back on bottom, then technical layers
for( LSEQ cu_stack = enabled.CuStack(); cu_stack; ++cu_stack )
{
PCB_LAYER_ID layer = *cu_stack;
switch( layer )
{
case F_Cu:
dsc = _( "Front copper layer" );
break;
case B_Cu:
dsc = _( "Back copper layer" );
break;
default:
dsc = _( "Inner copper layer" );
break;
}
AppendLayerRow( LAYER_WIDGET::ROW( brd->GetLayerName( layer ), layer,
myframe->GetColorSettings()->GetColor( layer ), dsc, true, true,
myframe->GetColorSettings()->GetDefaultColor( layer ) ) );
if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
{
getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
}
}
// technical layers are shown in this order:
// Because they are static, wxGetTranslation must be explicitly
// called for tooltips.
static const struct {
PCB_LAYER_ID layerId;
wxString tooltip;
} non_cu_seq[] = {
{ F_Adhes, _( "Adhesive on board's front" ) },
{ B_Adhes, _( "Adhesive on board's back" ) },
{ F_Paste, _( "Solder paste on board's front" ) },
{ B_Paste, _( "Solder paste on board's back" ) },
{ F_SilkS, _( "Silkscreen on board's front" ) },
{ B_SilkS, _( "Silkscreen on board's back" ) },
{ F_Mask, _( "Solder mask on board's front" ) },
{ B_Mask, _( "Solder mask on board's back" ) },
{ Dwgs_User, _( "Explanatory drawings" ) },
{ Cmts_User, _( "Explanatory comments" ) },
{ Eco1_User, _( "User defined meaning" ) },
{ Eco2_User, _( "User defined meaning" ) },
{ Edge_Cuts, _( "Board's perimeter definition" ) },
{ Margin, _( "Board's edge setback outline" ) },
{ F_CrtYd, _( "Footprint courtyards on board's front" ) },
{ B_CrtYd, _( "Footprint courtyards on board's back" ) },
{ F_Fab, _( "Footprint assembly on board's front" ) },
{ B_Fab, _( "Footprint assembly on board's back" ) },
};
for( unsigned i=0; i<arrayDim( non_cu_seq ); ++i )
{
PCB_LAYER_ID layer = non_cu_seq[i].layerId;
if( !enabled[layer] )
{
wxLogDebug( "Layer widget: layer %s not enabled.", LSET::Name( layer ) );
continue;
}
AppendLayerRow( LAYER_WIDGET::ROW( brd->GetLayerName( layer ), layer,
myframe->GetColorSettings()->GetColor( layer ),
wxGetTranslation( non_cu_seq[i].tooltip ), true, true,
myframe->GetColorSettings()->GetDefaultColor( layer ) ) );
if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
{
getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
getLayerComp( GetLayerRowCount()-1, COLUMN_COLORBM )->SetToolTip( wxEmptyString );
}
}
UpdateLayouts();
}
//-----<LAYER_WIDGET callbacks>-------------------------------------------
void PCB_LAYER_WIDGET::OnLayerColorChange( int aLayer, COLOR4D aColor )
{
COLOR_SETTINGS* cs = myframe->GetColorSettings();
cs->SetColor( aLayer, aColor );
myframe->GetCanvas()->UpdateColors();
KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
view->UpdateLayerColor( aLayer );
view->UpdateLayerColor( GetNetnameLayer( aLayer ) );
myframe->ReCreateHToolbar();
myframe->GetCanvas()->Refresh();
if( aLayer == LAYER_PCB_BACKGROUND )
myframe->SetDrawBgColor( aColor );
}
bool PCB_LAYER_WIDGET::OnLayerSelect( int aLayer )
{
// the layer change from the PCB_LAYER_WIDGET can be denied by returning
// false from this function.
PCB_LAYER_ID layer = ToLAYER_ID( aLayer );
if( m_fp_editor_mode && LSET::ForbiddenFootprintLayers().test( layer ) )
return false;
myframe->SetActiveLayer( layer );
bool hcm = ( myframe->GetDisplayOptions().m_ContrastModeDisplay !=
HIGH_CONTRAST_MODE::NORMAL );
if( m_alwaysShowActiveCopperLayer )
OnLayerSelected();
else if( hcm )
myframe->GetCanvas()->Refresh();
return true;
}
bool PCB_LAYER_WIDGET::OnLayerSelected()
{
if( !m_alwaysShowActiveCopperLayer )
return false;
// postprocess after an active layer selection
// ensure active layer visible
wxCommandEvent event;
event.SetId( ID_ALWAYS_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE );
onPopupSelection( event );
return true;
}
void PCB_LAYER_WIDGET::OnLayerVisible( int aLayer, bool isVisible, bool isFinal )
{
// In other frames than board editor, the board is a dummy board.
// so changing board settings makes sense (and works) only for the board editor frame
if( myframe->IsType( FRAME_PCB_EDITOR ) )
{
BOARD* brd = myframe->GetBoard();
LSET visibleLayers = brd->GetVisibleLayers();
if( visibleLayers.test( aLayer ) != isVisible )
{
visibleLayers.set( aLayer, isVisible );
brd->SetVisibleLayers( visibleLayers );
if( myframe->GetCanvas() )
myframe->GetCanvas()->GetView()->SetLayerVisible( aLayer, isVisible );
}
}
else
{
if( myframe->GetCanvas() )
myframe->GetCanvas()->GetView()->SetLayerVisible( aLayer, isVisible );
}
if( isFinal )
myframe->GetCanvas()->Refresh();
}
void PCB_LAYER_WIDGET::OnLayerRightClick( wxMenu& aMenu )
{
AddRightClickMenuItems( aMenu );
}
void PCB_LAYER_WIDGET::OnRenderColorChange( int aId, COLOR4D aColor )
{
wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
myframe->GetColorSettings()->SetColor( aId, aColor );
myframe->GetCanvas()->UpdateColors();
KIGFX::VIEW* view = myframe->GetCanvas()->GetView();
view->MarkTargetDirty( KIGFX::TARGET_NONCACHED ); // useful to update rastnest
view->UpdateLayerColor( aId );
// plated-through-holes don't have their own color; they use the background color
if( aId == LAYER_PCB_BACKGROUND )
view->UpdateLayerColor( LAYER_PADS_PLATEDHOLES );
myframe->ReCreateHToolbar();
myframe->GetCanvas()->ForceRefresh();
}
void PCB_LAYER_WIDGET::OnRenderEnable( int aId, bool isEnabled )
{
BOARD* brd = myframe->GetBoard();
wxASSERT( aId > GAL_LAYER_ID_START && aId < GAL_LAYER_ID_END );
// Grid is not set through the board visibility
if( aId == LAYER_GRID )
myframe->SetGridVisibility( isEnabled );
else
brd->SetElementVisibility( static_cast<GAL_LAYER_ID>( aId ), isEnabled );
if( aId == LAYER_RATSNEST )
{
// don't touch the layers. ratsnest is enabled on per-item basis.
myframe->GetCanvas()->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
myframe->GetCanvas()->GetView()->SetLayerVisible( aId, true );
if( myframe->IsType( FRAME_PCB_EDITOR ) )
{
PCB_DISPLAY_OPTIONS opt = myframe->GetDisplayOptions();
opt.m_ShowGlobalRatsnest = isEnabled;
myframe->SetDisplayOptions( opt );
}
}
else if( aId != LAYER_GRID )
myframe->GetCanvas()->GetView()->SetLayerVisible( aId, isEnabled );
myframe->GetCanvas()->Refresh();
}
//-----</LAYER_WIDGET callbacks>------------------------------------------

166
pcbnew/pcb_layer_widget.h
View File

@ -1,166 +0,0 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
* Copyright (C) 2010-2018 KiCad Developers, see cAUTHORS.txt for contributors.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/************************************************************/
/* pcb_layer_widget.h : header for the layers manager */
/************************************************************/
#ifndef PCB_LAYER_WIDGET_H
#define PCB_LAYER_WIDGET_H
#include <layer_widget.h>
/**
* PCB_LAYER_WIDGET
* is here to implement the abstract functions of LAYER_WIDGET so they
* may be tied into the PCB_EDIT_FRAME's data and so we can add a popup
* menu which is specific to PCBNEW's needs.
*/
class PCB_LAYER_WIDGET : public LAYER_WIDGET
{
public:
/**
* Constructor
* @param aParent is the parent window
* @param aFocusOwner is the window that should be sent the focus after
* @param aFpEditorMode false for the board editor (default), true for fp editor
* when true, some options or layers which cannot be used in editor mode are not
* displayed
*/
PCB_LAYER_WIDGET( PCB_BASE_FRAME* aParent, wxWindow* aFocusOwner, bool aFpEditorMode = false );
void ReFill();
/**
* Function ReFillRender
* rebuilds Render for instance after the config is read
*/
void ReFillRender();
/**
* Function SyncLayerVisibilities
* updates each "Layer" checkbox in this layer widget according
* to each layer's current visibility determined by IsLayerVisible(), and is
* helpful immediately after loading a BOARD which may have state information in it.
*/
void SyncLayerVisibilities();
/**
* Function SyncLayerAlphaIndicators
* updates each "Layer"s alpha indicator to show if the board is currently being
* rendered with more transparency or less.
*/
void SyncLayerAlphaIndicators();
/**
* Updates the color for each layer and item from the active color theme
*/
void SyncLayerColors();
/**
* Function SetLayersManagerTabsText
* Update the layer manager tabs labels
* Useful when changing Language or to set labels to a non default value
*/
void SetLayersManagerTabsText();
//-----<implement LAYER_WIDGET abstract callback functions>-----------
void OnLayerColorChange( int aLayer, COLOR4D aColor ) override;
bool OnLayerSelect( int aLayer ) override;
void OnLayerVisible( int aLayer, bool isVisible, bool isFinal ) override;
void OnLayerRightClick( wxMenu& aMenu ) override;
void OnRenderColorChange( int aId, COLOR4D aColor ) override;
void OnRenderEnable( int aId, bool isEnabled ) override;
//-----</implement LAYER_WIDGET abstract callback functions>----------
/**
* Function OnLayerSelected
* ensure the active layer is visible, and other layers not visible
* when m_alwaysShowActiveLayer is true
* Otherwise do nothing.
* @return true m_alwaysShowActiveLayer is true and the canvas is refreshed,
* and false if do nothing
*/
bool OnLayerSelected(); // postprocess after an active layer selection
// ensure active layer visible if
// m_alwaysShowActiveCopperLayer is true;
/**
* Function addRightClickMenuItems
* add menu items to a menu that should be shown when right-clicking
* the PCB layer widget.
*/
void AddRightClickMenuItems( wxMenu& menu );
protected:
static const LAYER_WIDGET::ROW s_render_rows[];
bool m_alwaysShowActiveCopperLayer; // If true: Only shows the current active layer
// even if it is changed
bool m_fp_editor_mode;
PCB_BASE_FRAME* myframe;
// popup menu ids.
enum POPUP_ID
{
ID_SHOW_ALL_COPPER_LAYERS = LAYER_WIDGET::ID_LAST_VALUE,
ID_HIDE_ALL_COPPER_LAYERS,
ID_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE,
ID_ALWAYS_HIDE_ALL_COPPER_LAYERS_BUT_ACTIVE,
ID_SHOW_NO_LAYERS,
ID_SHOW_ALL_LAYERS,
ID_SHOW_ONLY_FRONT,
ID_SHOW_ONLY_INNER,
ID_SHOW_ONLY_BACK,
ID_SHOW_ONLY_FRONT_ASSEMBLY,
ID_SHOW_ONLY_BACK_ASSEMBLY,
ID_HIDE_ALL_NON_COPPER,
ID_SHOW_ALL_NON_COPPER,
ID_LAST_VALUE
};
virtual COLOR4D getBackgroundLayerColor() override;
/**
* Function isAllowedInFpMode
* @return true if item aId has meaning in footprint editor mode.
* and therefore is shown in render panel
*/
bool isAllowedInFpMode( int aId );
/**
* Function OnRightDownLayers
* puts up a popup menu for the layer panel.
*/
void onRightDownLayers( wxMouseEvent& event );
void onPopupSelection( wxCommandEvent& event );
};
#endif // PCB_LAYER_WIDGET_H

1
pcbnew/router/router_tool.cpp
View File

@ -29,7 +29,6 @@ using namespace std::placeholders;
#include <class_pad.h>
#include <pcb_edit_frame.h>
#include <pcbnew_id.h>
#include <pcb_layer_widget.h>
#include <dialogs/dialog_pns_settings.h>
#include <dialogs/dialog_pns_diff_pair_dimensions.h>
#include <dialogs/dialog_track_via_size.h>

5
pcbnew/widgets/appearance_controls.cpp
View File

@ -2325,7 +2325,10 @@ void APPEARANCE_CONTROLS::OnColorSwatchChanged( wxCommandEvent& aEvent )
view->UpdateLayerColor( layer );
view->UpdateLayerColor( GetNetnameLayer( layer ) );
m_frame->ReCreateHToolbar();
// Update the bitmap of the layer box
if( m_frame->IsType( FRAME_PCB_EDITOR ) )
static_cast<PCB_EDIT_FRAME*>( m_frame )->ReCreateLayerBox( false );
m_frame->GetCanvas()->Refresh();
if( layer == LAYER_PCB_BACKGROUND )

Write Preview
Loading…
Cancel
Save