2011-09-23 20:00:30 +00:00
|
|
|
/*
|
2011-09-30 18:15:37 +00:00
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
2011-09-23 20:00:30 +00:00
|
|
|
*
|
2015-01-07 19:07:15 +00:00
|
|
|
* Copyright (C) 2004-2015 Jean-Pierre Charras, jean-pierre.charras@gpisa-lab.inpg.fr
|
2012-02-06 05:44:19 +00:00
|
|
|
* Copyright (C) 2010-2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
2015-10-14 18:12:17 +00:00
|
|
|
* Copyright (C) 2010-2015 KiCad Developers, see change_log.txt for contributors.
|
2011-09-23 20:00:30 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************************/
|
|
|
|
/* class_pcb_layer_widget.cpp - Pcbnew layers manager */
|
|
|
|
/******************************************************/
|
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <fctsys.h>
|
* KIWAY Milestone A): Make major modules into DLL/DSOs.
! The initial testing of this commit should be done using a Debug build so that
all the wxASSERT()s are enabled. Also, be sure and keep enabled the
USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it
off is senseless anyways. If you want stable code, go back to a prior version,
the one tagged with "stable".
* Relocate all functionality out of the wxApp derivative into more finely
targeted purposes:
a) DLL/DSO specific
b) PROJECT specific
c) EXE or process specific
d) configuration file specific data
e) configuration file manipulations functions.
All of this functionality was blended into an extremely large wxApp derivative
and that was incompatible with the desire to support multiple concurrently
loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects.
An amazing amount of organization come from simply sorting each bit of
functionality into the proper box.
* Switch to wxConfigBase from wxConfig everywhere except instantiation.
* Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD,
PGM_SINGLE_TOP,
* Remove "Return" prefix on many function names.
* Remove obvious comments from CMakeLists.txt files, and from else() and endif()s.
* Fix building boost for use in a DSO on linux.
* Remove some of the assumptions in the CMakeLists.txt files that windows had
to be the host platform when building windows binaries.
* Reduce the number of wxStrings being constructed at program load time via
static construction.
* Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that
these functions are useful even when the wxConfigBase comes from another
source, as is the case in the KICAD_MANAGER_FRAME.
* Move the setting of the KIPRJMOD environment variable into class PROJECT,
so that it can be moved into a project variable soon, and out of FP_LIB_TABLE.
* Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all
its child wxFrames and wxDialogs now have a Kiway() member function which
returns a KIWAY& that that window tree branch is in support of. This is like
wxWindows DNA in that child windows get this member with proper value at time
of construction.
* Anticipate some of the needs for milestones B) and C) and make code
adjustments now in an effort to reduce work in those milestones.
* No testing has been done for python scripting, since milestone C) has that
being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
|
|
|
#include <pgm_base.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_drawpanel.h>
|
2014-04-04 09:56:04 +00:00
|
|
|
#include <class_draw_panel_gal.h>
|
2013-04-02 09:02:35 +00:00
|
|
|
#include <view/view.h>
|
2013-04-04 12:17:40 +00:00
|
|
|
#include <painter.h>
|
2013-07-07 00:30:28 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <confirm.h>
|
|
|
|
#include <wxPcbStruct.h>
|
|
|
|
#include <pcbstruct.h> // enum PCB_VISIBLE
|
|
|
|
#include <layer_widget.h>
|
|
|
|
#include <macros.h>
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_board.h>
|
|
|
|
#include <class_pcb_layer_widget.h>
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <pcbnew.h>
|
|
|
|
#include <collectors.h>
|
|
|
|
#include <pcbnew_id.h>
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2014-03-28 13:06:30 +00:00
|
|
|
#include <gal/graphics_abstraction_layer.h>
|
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2012-03-12 00:40:48 +00:00
|
|
|
/// This is a read only template that is copied and modified before adding to LAYER_WIDGET
|
2012-02-06 05:44:19 +00:00
|
|
|
const LAYER_WIDGET::ROW PCB_LAYER_WIDGET::s_render_rows[] = {
|
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
#define RR LAYER_WIDGET::ROW // Render Row abbreviation to reduce source width
|
2012-02-06 05:44:19 +00:00
|
|
|
|
|
|
|
// text id color tooltip
|
|
|
|
RR( _( "Through Via" ), VIA_THROUGH_VISIBLE, WHITE, _( "Show through vias" ) ),
|
|
|
|
RR( _( "Bl/Buried Via" ), VIA_BBLIND_VISIBLE, WHITE, _( "Show blind or buried vias" ) ),
|
|
|
|
RR( _( "Micro Via" ), VIA_MICROVIA_VISIBLE, WHITE, _( "Show micro vias") ),
|
2013-04-07 16:20:46 +00:00
|
|
|
RR( _( "Non Plated" ), NON_PLATED_VISIBLE, WHITE, _( "Show non plated holes") ),
|
2012-02-06 05:44:19 +00:00
|
|
|
RR( _( "Ratsnest" ), RATSNEST_VISIBLE, WHITE, _( "Show unconnected nets as a ratsnest") ),
|
|
|
|
|
|
|
|
RR( _( "Pads Front" ), PAD_FR_VISIBLE, WHITE, _( "Show footprint pads on board's front" ) ),
|
|
|
|
RR( _( "Pads Back" ), PAD_BK_VISIBLE, WHITE, _( "Show footprint pads on board's back" ) ),
|
|
|
|
|
2014-09-14 15:34:37 +00:00
|
|
|
RR( _( "Text Front" ), MOD_TEXT_FR_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprint text on board's front" ) ),
|
|
|
|
RR( _( "Text Back" ), MOD_TEXT_BK_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprint text on board's back" ) ),
|
2012-02-06 05:44:19 +00:00
|
|
|
RR( _( "Hidden Text" ), MOD_TEXT_INVISIBLE, WHITE, _( "Show footprint text marked as invisible" ) ),
|
|
|
|
|
|
|
|
RR( _( "Anchors" ), ANCHOR_VISIBLE, WHITE, _( "Show footprint and text origins as a cross" ) ),
|
|
|
|
RR( _( "Grid" ), GRID_VISIBLE, WHITE, _( "Show the (x,y) grid dots" ) ),
|
2014-09-14 15:34:37 +00:00
|
|
|
RR( _( "No-Connects" ), NO_CONNECTS_VISIBLE, UNSPECIFIED_COLOR, _( "Show a marker on pads which have no net connected" ) ),
|
2014-10-30 17:31:56 +00:00
|
|
|
RR( _( "Footprints Front" ), MOD_FR_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprints that are on board's front") ),
|
|
|
|
RR( _( "Footprints Back" ), MOD_BK_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprints that are on board's back") ),
|
2014-09-14 15:34:37 +00:00
|
|
|
RR( _( "Values" ), MOD_VALUES_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprint's values") ),
|
|
|
|
RR( _( "References" ), MOD_REFERENCES_VISIBLE, UNSPECIFIED_COLOR, _( "Show footprint's references") ),
|
2012-02-06 05:44:19 +00:00
|
|
|
};
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
static int s_allowed_in_FpEditor[] =
|
|
|
|
{
|
|
|
|
MOD_TEXT_INVISIBLE, PAD_FR_VISIBLE, PAD_BK_VISIBLE,
|
|
|
|
GRID_VISIBLE, MOD_VALUES_VISIBLE, MOD_REFERENCES_VISIBLE
|
|
|
|
};
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
PCB_LAYER_WIDGET::PCB_LAYER_WIDGET( PCB_BASE_FRAME* aParent, wxWindow* aFocusOwner,
|
|
|
|
int aPointSize, bool aFpEditorMode ) :
|
|
|
|
LAYER_WIDGET( aParent, aFocusOwner, aPointSize ),
|
|
|
|
myframe( aParent )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2013-04-05 07:38:00 +00:00
|
|
|
m_alwaysShowActiveCopperLayer = false;
|
2015-01-07 19:07:15 +00:00
|
|
|
m_fp_editor_mode = aFpEditorMode;
|
2011-09-23 20:00:30 +00:00
|
|
|
ReFillRender();
|
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
// Update default tabs labels
|
2012-02-06 05:44:19 +00:00
|
|
|
SetLayersManagerTabsText();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
//-----<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()
|
2013-04-06 12:01:53 +00:00
|
|
|
Connect( ID_SHOW_ALL_COPPERS, ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE,
|
|
|
|
wxEVT_COMMAND_MENU_SELECTED,
|
2011-09-23 20:00:30 +00:00
|
|
|
wxCommandEventHandler( PCB_LAYER_WIDGET::onPopupSelection ), NULL, this );
|
|
|
|
|
|
|
|
// install the right click handler into each control at end of ReFill()
|
|
|
|
// using installRightLayerClickHandler
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
bool PCB_LAYER_WIDGET::isAllowedInFpMode( int aId )
|
|
|
|
{
|
|
|
|
for( unsigned ii = 0; ii < DIM( s_allowed_in_FpEditor ); ii++ )
|
|
|
|
if( s_allowed_in_FpEditor[ii] == aId )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
bool PCB_LAYER_WIDGET::isLayerAllowedInFpMode( LAYER_ID aLayer )
|
|
|
|
{
|
|
|
|
static LSET allowed = LSET::AllTechMask();
|
|
|
|
// Currently not in use because putting a graphic item on a copper layer
|
|
|
|
// is not currently supported by DRC.
|
|
|
|
// allowed.set( F_Cu ).set( B_Cu );
|
|
|
|
return allowed.test( aLayer );
|
|
|
|
}
|
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
void PCB_LAYER_WIDGET::installRightLayerClickHandler()
|
|
|
|
{
|
|
|
|
int rowCount = GetLayerRowCount();
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2013-04-10 13:03:35 +00:00
|
|
|
for( int row=0; row < rowCount; ++row )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2013-04-06 12:01:53 +00:00
|
|
|
for( int col=0; col<LYR_COLUMN_COUNT; ++col )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
wxWindow* w = getLayerComp( row, col );
|
|
|
|
|
|
|
|
w->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler(
|
|
|
|
PCB_LAYER_WIDGET::onRightDownLayers ), NULL, this );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void PCB_LAYER_WIDGET::onRightDownLayers( wxMouseEvent& event )
|
|
|
|
{
|
|
|
|
wxMenu menu;
|
|
|
|
|
|
|
|
// menu text is capitalized:
|
|
|
|
// http://library.gnome.org/devel/hig-book/2.20/design-text-labels.html.en#layout-capitalization
|
2013-04-05 07:38:00 +00:00
|
|
|
menu.Append( new wxMenuItem( &menu, ID_SHOW_ALL_COPPERS,
|
|
|
|
_( "Show All Copper Layers" ) ) );
|
|
|
|
menu.Append( new wxMenuItem( &menu, ID_SHOW_NO_COPPERS_BUT_ACTIVE,
|
|
|
|
_( "Hide All Copper Layers But Active" ) ) );
|
|
|
|
menu.Append( new wxMenuItem( &menu, ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE,
|
|
|
|
_( "Always Hide All Copper Layers But Active" ) ) );
|
|
|
|
menu.Append( new wxMenuItem( &menu, ID_SHOW_NO_COPPERS,
|
|
|
|
_( "Hide All Copper Layers" ) ) );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
PopupMenu( &menu );
|
|
|
|
|
|
|
|
passOnFocus();
|
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
void PCB_LAYER_WIDGET::onPopupSelection( wxCommandEvent& event )
|
|
|
|
{
|
|
|
|
int rowCount;
|
|
|
|
int menuId = event.GetId();
|
|
|
|
bool visible;
|
2013-04-05 07:38:00 +00:00
|
|
|
bool force_active_layer_visible;
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2013-04-06 12:01:53 +00:00
|
|
|
visible = menuId == ID_SHOW_ALL_COPPERS;
|
|
|
|
m_alwaysShowActiveCopperLayer = ( menuId == ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE );
|
|
|
|
force_active_layer_visible = ( menuId == ID_SHOW_NO_COPPERS_BUT_ACTIVE ||
|
|
|
|
menuId == ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
switch( menuId )
|
|
|
|
{
|
|
|
|
case ID_SHOW_ALL_COPPERS:
|
2013-04-05 07:38:00 +00:00
|
|
|
case ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE:
|
2012-02-17 19:43:43 +00:00
|
|
|
case ID_SHOW_NO_COPPERS_BUT_ACTIVE:
|
2011-09-23 20:00:30 +00:00
|
|
|
case ID_SHOW_NO_COPPERS:
|
2013-04-05 07:38:00 +00:00
|
|
|
// Search the last copper layer row index:
|
2011-09-23 20:00:30 +00:00
|
|
|
int lastCu = -1;
|
|
|
|
rowCount = GetLayerRowCount();
|
2013-04-05 07:38:00 +00:00
|
|
|
for( int row = rowCount-1; row>=0; --row )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2014-07-20 17:41:12 +00:00
|
|
|
wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
|
2014-06-29 13:05:51 +00:00
|
|
|
LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2013-04-09 16:00:46 +00:00
|
|
|
if( IsCopperLayer( layer ) )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
lastCu = row;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 13:03:35 +00:00
|
|
|
// Enable/disable the copper layers visibility:
|
2011-09-23 20:00:30 +00:00
|
|
|
for( int row=0; row<rowCount; ++row )
|
|
|
|
{
|
2014-07-20 17:41:12 +00:00
|
|
|
wxCheckBox* cb = (wxCheckBox*) getLayerComp( row, COLUMN_COLOR_LYR_CB );
|
2014-06-29 13:05:51 +00:00
|
|
|
LAYER_ID layer = ToLAYER_ID( getDecodedId( cb->GetId() ) );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2013-04-09 16:00:46 +00:00
|
|
|
if( IsCopperLayer( layer ) )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2012-02-17 19:43:43 +00:00
|
|
|
bool loc_visible = visible;
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2014-03-21 10:17:47 +00:00
|
|
|
if( force_active_layer_visible && (layer == myframe->GetActiveLayer() ) )
|
2012-02-17 19:43:43 +00:00
|
|
|
loc_visible = true;
|
|
|
|
|
|
|
|
cb->SetValue( loc_visible );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
bool isLastCopperLayer = (row==lastCu);
|
2012-02-17 19:43:43 +00:00
|
|
|
OnLayerVisible( layer, loc_visible, isLastCopperLayer );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
if( isLastCopperLayer )
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
|
|
|
void PCB_LAYER_WIDGET::SetLayersManagerTabsText()
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2012-02-06 05:44:19 +00:00
|
|
|
m_notebook->SetPageText( 0, _( "Layer" ) );
|
|
|
|
m_notebook->SetPageText( 1, _( "Render" ) );
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
void PCB_LAYER_WIDGET::ReFillRender()
|
|
|
|
{
|
2014-07-09 09:59:23 +00:00
|
|
|
BOARD* board = myframe->GetBoard();
|
2011-09-23 20:00:30 +00:00
|
|
|
ClearRenderRows();
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
// Add "Render" tab rows to LAYER_WIDGET, after setting color and checkbox state.
|
2015-10-14 18:12:17 +00:00
|
|
|
// Because s_render_rows is created static, we must explicitly call
|
2013-04-16 10:53:23 +00:00
|
|
|
// wxGetTranslation for texts which are internationalized (tool tips
|
|
|
|
// and item names)
|
2012-02-06 05:44:19 +00:00
|
|
|
for( unsigned row=0; row<DIM(s_render_rows); ++row )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2012-02-06 05:44:19 +00:00
|
|
|
LAYER_WIDGET::ROW renderRow = s_render_rows[row];
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2015-01-20 07:01:32 +00:00
|
|
|
if( m_fp_editor_mode && !isAllowedInFpMode( renderRow.id ) )
|
2015-01-07 19:07:15 +00:00
|
|
|
continue;
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
renderRow.tooltip = wxGetTranslation( s_render_rows[row].tooltip );
|
|
|
|
renderRow.rowName = wxGetTranslation( s_render_rows[row].rowName );
|
2012-02-06 05:44:19 +00:00
|
|
|
|
|
|
|
if( renderRow.color != -1 ) // does this row show a color?
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
// this window frame must have an established BOARD, i.e. after SetBoard()
|
2012-02-06 05:44:19 +00:00
|
|
|
renderRow.color = board->GetVisibleElementColor( renderRow.id );
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
renderRow.state = board->IsElementVisible( renderRow.id );
|
|
|
|
|
|
|
|
AppendRenderRow( renderRow );
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
2012-02-06 05:44:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void PCB_LAYER_WIDGET::SyncRenderStates()
|
|
|
|
{
|
|
|
|
BOARD* board = myframe->GetBoard();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
for( unsigned row=0; row<DIM(s_render_rows); ++row )
|
|
|
|
{
|
2012-03-12 00:40:48 +00:00
|
|
|
int rowId = s_render_rows[row].id;
|
|
|
|
|
2015-01-20 07:01:32 +00:00
|
|
|
if( m_fp_editor_mode && !isAllowedInFpMode( rowId ) )
|
2015-01-07 19:07:15 +00:00
|
|
|
continue;
|
|
|
|
|
2012-03-12 00:40:48 +00:00
|
|
|
// this does not fire a UI event
|
|
|
|
SetRenderState( rowId, board->IsElementVisible( rowId ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
2014-07-20 17:41:12 +00:00
|
|
|
wxWindow* w = getLayerComp( row, COLUMN_ICON_ACTIVE );
|
2012-03-12 00:40:48 +00:00
|
|
|
|
2014-06-29 13:05:51 +00:00
|
|
|
LAYER_ID layerId = ToLAYER_ID( getDecodedId( w->GetId() ) );
|
2012-03-12 00:40:48 +00:00
|
|
|
|
|
|
|
// this does not fire a UI event
|
|
|
|
SetLayerVisible( layerId, board->IsLayerVisible( layerId ) );
|
2012-02-06 05:44:19 +00:00
|
|
|
}
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
void PCB_LAYER_WIDGET::ReFill()
|
|
|
|
{
|
|
|
|
BOARD* brd = myframe->GetBoard();
|
2014-06-24 16:17:18 +00:00
|
|
|
LSET enabled = brd->GetEnabledLayers();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
ClearLayerRows();
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
wxString dsc;
|
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
// show all coppers first, with front on top, back on bottom, then technical layers
|
2014-06-24 16:17:18 +00:00
|
|
|
for( LSEQ cu_stack = enabled.CuStack(); cu_stack; ++cu_stack )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2014-06-24 16:17:18 +00:00
|
|
|
LAYER_ID layer = *cu_stack;
|
2013-04-09 16:00:46 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
switch( layer )
|
|
|
|
{
|
|
|
|
case F_Cu:
|
2015-10-14 18:12:17 +00:00
|
|
|
dsc = _( "Front copper layer" );
|
2014-06-24 16:17:18 +00:00
|
|
|
break;
|
2013-04-09 16:00:46 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
case B_Cu:
|
2015-10-14 18:12:17 +00:00
|
|
|
dsc = _( "Back copper layer" );
|
2014-06-24 16:17:18 +00:00
|
|
|
break;
|
2013-04-09 16:00:46 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
default:
|
2015-10-14 18:12:17 +00:00
|
|
|
dsc = _( "Inner copper layer" );
|
2014-06-24 16:17:18 +00:00
|
|
|
break;
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
2014-06-24 16:17:18 +00:00
|
|
|
|
|
|
|
AppendLayerRow( LAYER_WIDGET::ROW(
|
|
|
|
brd->GetLayerName( layer ), layer, brd->GetLayerColor( layer ),
|
|
|
|
dsc, true ) );
|
2015-01-07 19:07:15 +00:00
|
|
|
|
|
|
|
if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
|
|
|
|
{
|
|
|
|
getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
|
|
|
|
getLayerComp( GetLayerRowCount()-1,
|
|
|
|
COLUMN_COLORBM )->SetToolTip( wxEmptyString );
|
|
|
|
}
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// technical layers are shown in this order:
|
2015-10-14 18:12:17 +00:00
|
|
|
// Because they are static, wxGetTranslation must be explicitly
|
2013-04-16 10:53:23 +00:00
|
|
|
// called for tooltips.
|
2011-09-23 20:00:30 +00:00
|
|
|
static const struct {
|
2014-06-24 16:17:18 +00:00
|
|
|
LAYER_ID layerId;
|
2011-09-23 20:00:30 +00:00
|
|
|
wxString tooltip;
|
2014-06-24 16:17:18 +00:00
|
|
|
} 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" ) },
|
2014-07-04 08:55:51 +00:00
|
|
|
{ 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" ) }
|
2011-09-23 20:00:30 +00:00
|
|
|
};
|
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
for( unsigned i=0; i<DIM( non_cu_seq ); ++i )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2014-06-24 16:17:18 +00:00
|
|
|
LAYER_ID layer = non_cu_seq[i].layerId;
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
if( !enabled[layer] )
|
2011-09-23 20:00:30 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
AppendLayerRow( LAYER_WIDGET::ROW(
|
|
|
|
brd->GetLayerName( layer ), layer, brd->GetLayerColor( layer ),
|
2014-06-24 16:17:18 +00:00
|
|
|
wxGetTranslation( non_cu_seq[i].tooltip ), true ) );
|
2015-01-07 19:07:15 +00:00
|
|
|
|
|
|
|
if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
|
|
|
|
{
|
|
|
|
getLayerComp( GetLayerRowCount()-1, COLUMN_COLOR_LYRNAME )->Enable( false );
|
|
|
|
getLayerComp( GetLayerRowCount()-1,
|
|
|
|
COLUMN_COLORBM )->SetToolTip( wxEmptyString );
|
|
|
|
}
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
installRightLayerClickHandler();
|
|
|
|
}
|
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
//-----<LAYER_WIDGET callbacks>-------------------------------------------
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
void PCB_LAYER_WIDGET::OnLayerColorChange( int aLayer, EDA_COLOR_T aColor )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
2014-06-29 13:05:51 +00:00
|
|
|
myframe->GetBoard()->SetLayerColor( ToLAYER_ID( aLayer ), aColor );
|
2014-05-21 21:13:30 +00:00
|
|
|
|
|
|
|
if( myframe->IsGalCanvasActive() )
|
|
|
|
{
|
|
|
|
KIGFX::VIEW* view = myframe->GetGalCanvas()->GetView();
|
|
|
|
view->GetPainter()->GetSettings()->ImportLegacyColors( myframe->GetBoard()->GetColorsSettings() );
|
|
|
|
view->UpdateLayerColor( aLayer );
|
2016-05-02 14:08:50 +00:00
|
|
|
view->UpdateLayerColor( GetNetnameLayer( aLayer ) );
|
2014-05-21 21:13:30 +00:00
|
|
|
}
|
|
|
|
|
2013-09-20 15:29:32 +00:00
|
|
|
myframe->GetCanvas()->Refresh();
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
bool PCB_LAYER_WIDGET::OnLayerSelect( int aLayer )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
// the layer change from the PCB_LAYER_WIDGET can be denied by returning
|
|
|
|
// false from this function.
|
2015-01-07 19:07:15 +00:00
|
|
|
LAYER_ID layer = ToLAYER_ID( aLayer );
|
|
|
|
|
|
|
|
if( m_fp_editor_mode && !isLayerAllowedInFpMode( layer ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
myframe->SetActiveLayer( layer );
|
2015-01-10 10:27:49 +00:00
|
|
|
DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)myframe->GetDisplayOptions();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2013-04-05 07:38:00 +00:00
|
|
|
if( m_alwaysShowActiveCopperLayer )
|
|
|
|
OnLayerSelected();
|
2015-01-10 10:27:49 +00:00
|
|
|
else if( displ_opts->m_ContrastModeDisplay )
|
2013-09-20 15:29:32 +00:00
|
|
|
myframe->GetCanvas()->Refresh();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-02-06 05:44:19 +00:00
|
|
|
|
2015-01-07 19:07:15 +00:00
|
|
|
bool PCB_LAYER_WIDGET::OnLayerSelected()
|
2013-04-05 07:38:00 +00:00
|
|
|
{
|
|
|
|
if( !m_alwaysShowActiveCopperLayer )
|
2013-04-06 12:01:53 +00:00
|
|
|
return false;
|
2013-04-05 07:38:00 +00:00
|
|
|
|
|
|
|
// postprocess after an active layer selection
|
|
|
|
// ensure active layer visible
|
|
|
|
wxCommandEvent event;
|
|
|
|
event.SetId( ID_ALWAYS_SHOW_NO_COPPERS_BUT_ACTIVE );
|
|
|
|
onPopupSelection( event );
|
2013-04-06 12:01:53 +00:00
|
|
|
|
|
|
|
return true;
|
2013-04-05 07:38:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
void PCB_LAYER_WIDGET::OnLayerVisible( int aLayer, bool isVisible, bool isFinal )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
BOARD* brd = myframe->GetBoard();
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
LSET visibleLayers = brd->GetVisibleLayers();
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
visibleLayers.set( aLayer, isVisible );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
brd->SetVisibleLayers( visibleLayers );
|
|
|
|
|
2013-09-06 15:06:02 +00:00
|
|
|
EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
|
2015-10-14 18:12:17 +00:00
|
|
|
|
2013-04-02 09:02:35 +00:00
|
|
|
if( galCanvas )
|
2016-09-14 09:57:03 +00:00
|
|
|
galCanvas->GetView()->SetLayerVisible( aLayer, isVisible );
|
2013-04-02 09:02:35 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
if( isFinal )
|
2013-09-20 15:29:32 +00:00
|
|
|
myframe->GetCanvas()->Refresh();
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
2013-12-26 22:36:43 +00:00
|
|
|
|
2012-09-02 12:06:47 +00:00
|
|
|
void PCB_LAYER_WIDGET::OnRenderColorChange( int aId, EDA_COLOR_T aColor )
|
2011-09-23 20:00:30 +00:00
|
|
|
{
|
|
|
|
myframe->GetBoard()->SetVisibleElementColor( aId, aColor );
|
2016-01-13 18:37:52 +00:00
|
|
|
|
|
|
|
if( myframe->GetGalCanvas() )
|
|
|
|
{
|
|
|
|
KIGFX::VIEW* view = myframe->GetGalCanvas()->GetView();
|
|
|
|
view->GetPainter()->GetSettings()->ImportLegacyColors( myframe->GetBoard()->GetColorsSettings() );
|
2016-01-16 15:23:28 +00:00
|
|
|
view->UpdateLayerColor( aId );
|
2016-01-13 18:37:52 +00:00
|
|
|
}
|
|
|
|
|
2013-09-20 15:29:32 +00:00
|
|
|
myframe->GetCanvas()->Refresh();
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
2013-12-26 22:36:43 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
void PCB_LAYER_WIDGET::OnRenderEnable( int aId, bool isEnabled )
|
|
|
|
{
|
|
|
|
BOARD* brd = myframe->GetBoard();
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2015-10-14 18:12:17 +00:00
|
|
|
LSET visibleLayers = brd->GetVisibleLayers();
|
|
|
|
visibleLayers.set( aId, isEnabled );
|
|
|
|
|
|
|
|
// The layer visibility status is saved in the board file so set the board modified
|
|
|
|
// state so the user has the option to save the changes.
|
|
|
|
if( brd->IsElementVisible( aId ) != isEnabled )
|
|
|
|
myframe->OnModify();
|
|
|
|
|
2013-04-05 07:38:00 +00:00
|
|
|
brd->SetElementVisibility( aId, isEnabled );
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2013-12-26 22:36:43 +00:00
|
|
|
EDA_DRAW_PANEL_GAL* galCanvas = myframe->GetGalCanvas();
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2013-04-02 09:02:35 +00:00
|
|
|
if( galCanvas )
|
|
|
|
{
|
2014-03-28 13:06:30 +00:00
|
|
|
if( aId == GRID_VISIBLE )
|
|
|
|
{
|
|
|
|
galCanvas->GetGAL()->SetGridVisibility( myframe->IsGridVisible() );
|
|
|
|
galCanvas->GetView()->MarkTargetDirty( KIGFX::TARGET_NONCACHED );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
galCanvas->GetView()->SetLayerVisible( ITEM_GAL_LAYER( aId ), isEnabled );
|
2013-04-02 09:02:35 +00:00
|
|
|
}
|
|
|
|
|
2013-12-26 22:36:43 +00:00
|
|
|
if( galCanvas && myframe->IsGalCanvasActive() )
|
2013-04-03 09:19:08 +00:00
|
|
|
galCanvas->Refresh();
|
|
|
|
else
|
2013-09-20 15:29:32 +00:00
|
|
|
myframe->GetCanvas()->Refresh();
|
2011-09-23 20:00:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//-----</LAYER_WIDGET callbacks>------------------------------------------
|