haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/pcbnew/dialogs/dialog_design_rules.cpp

1106 lines
35 KiB
C++
Raw Blame History

/**
* @file dialog_design_rules.cpp
*/
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2004-2009 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2009 Dick Hollenbeck, dick@softplc.com
* Copyright (C) 2009-2018 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
*/
/* functions relative to the design rules editor
*/
#include <fctsys.h>
#include <class_drawpanel.h>
#include <base_units.h>
#include <confirm.h>
#include <pcbnew.h>
#include <pcb_edit_frame.h>
#include <board_design_settings.h>
#include <bitmaps.h>
#include <pcbnew_id.h>
#include <class_track.h>
#include <macros.h>
#include <html_messagebox.h>
#include <dialog_text_entry.h>
#include <dialog_design_rules.h>
#include <wx/generic/gridctrl.h>
#include <dialog_design_rules_aux_helper_class.h>
#include <tool/tool_event.h>
#include <tool/tool_manager.h>
// Column labels for net lists
#define NET_TITLE _( "Net" )
#define CLASS_TITLE _( "Class" )
// Field Positions on rules grid
enum {
GRID_NAME = 0,
GRID_CLEARANCE,
GRID_TRACKSIZE,
GRID_VIASIZE,
GRID_VIADRILL,
GRID_uVIASIZE,
GRID_uVIADRILL,
GRID_DIFF_PAIR_WIDTH,
GRID_DIFF_PAIR_GAP
};
const wxString DIALOG_DESIGN_RULES::wildCard = _( "* (Any)" );
// dialog should remember its previously selected tab
int DIALOG_DESIGN_RULES::s_LastTabSelection = -1;
// methods for the helper class NETS_LIST_CTRL
wxString NETS_LIST_CTRL::OnGetItemText( long item, long column ) const
{
if( column == 0 )
{
if( item < (long) m_Netnames.GetCount() )
return m_Netnames[item];
else
return wxEmptyString;
}
else if( item < (long) m_Classnames.GetCount() )
return m_Classnames[item];
return wxEmptyString;
}
void NETS_LIST_CTRL::SetRowItems( unsigned aRow,
const wxString& aNetname,
const wxString& aNetclassName )
{
// insert blanks if aRow is larger than existing row count
unsigned cnt = m_Netnames.GetCount();
if( cnt <= aRow )
m_Netnames.Add( wxEmptyString, aRow - cnt + 1 );
cnt = m_Classnames.GetCount();
if( cnt <= aRow )
m_Classnames.Add( wxEmptyString, aRow - cnt + 1 );
if( (int)aRow <= GetItemCount() )
SetItemCount( aRow + 1 );
m_Netnames[aRow] = aNetname;
m_Classnames[aRow] = aNetclassName;
}
DIALOG_DESIGN_RULES::DIALOG_DESIGN_RULES( PCB_EDIT_FRAME* parent ) :
DIALOG_DESIGN_RULES_BASE( parent ),
m_trackMinWidth( parent, m_TrackMinWidthTitle, m_SetTrackMinWidthCtrl, m_TrackMinWidthUnits, true, 0 ),
m_viaMinDiameter( parent, m_ViaMinTitle, m_SetViasMinSizeCtrl, m_ViaMinUnits, true, 0 ),
m_viaMinDrill( parent, m_ViaMinDrillTitle, m_SetViasMinDrillCtrl, m_ViaMinDrillUnits, true, 0 ),
m_microViaMinDiameter( parent, m_MicroViaMinSizeTitle, m_SetMicroViasMinSizeCtrl, m_MicroViaMinSizeUnits, true, 0 ),
m_microViaMinDrill( parent, m_MicroViaMinDrillTitle, m_SetMicroViasMinDrillCtrl, m_MicroViaMinDrillUnits, true, 0 )
{
m_Parent = parent;
m_gridErrorGrid = nullptr;
// Loading the grid messes up the column widths set in wxFormBuilder
m_originalColWidths = new int[ m_grid->GetNumberCols() ];
for( int i = 0; i < m_grid->GetNumberCols(); ++i )
m_originalColWidths[ i ] = m_grid->GetColSize( i );
wxListItem column0;
wxListItem column1;
column0.Clear();
column1.Clear();
column0.SetMask( wxLIST_MASK_TEXT );
column1.SetMask( wxLIST_MASK_TEXT );
column0.SetText( NET_TITLE );
column1.SetText( CLASS_TITLE );
m_leftListCtrl->InsertColumn( 0, column0 );
m_leftListCtrl->InsertColumn( 1, column1 );
m_leftListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
m_leftListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
m_rightListCtrl->InsertColumn( 0, column0 );
m_rightListCtrl->InsertColumn( 1, column1 );
m_rightListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
m_rightListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
// if user has been into the dialog before, go back to same tab
if( s_LastTabSelection != -1 )
{
m_DRnotebook->SetSelection( s_LastTabSelection );
}
m_addButton->SetBitmap( KiBitmap( small_plus_xpm ) );
m_removeButton->SetBitmap( KiBitmap( trash_xpm ) );
m_moveUpButton->SetBitmap( KiBitmap( small_up_xpm ) );
m_moveDownButton->SetBitmap( KiBitmap( small_down_xpm ) );
m_sdbSizer1OK->SetDefault();
// Allow tabbing out of grid controls.
m_grid->SetTabBehaviour( wxGrid::Tab_Leave );
m_gridViaSizeList->SetTabBehaviour( wxGrid::Tab_Leave );
m_gridTrackWidthList->SetTabBehaviour( wxGrid::Tab_Leave );
// wxFormBuilder doesn't include this event...
m_grid->Connect( wxEVT_GRID_CELL_CHANGING, wxGridEventHandler( DIALOG_DESIGN_RULES::OnNetclassGridCellChanging ), NULL, this );
m_panelNetClassesEditor->Layout();
m_panelGolbalDesignRules->Layout();
Fit();
// Now all widgets have the size fixed, call FinishDialogSettings
FinishDialogSettings();
}
DIALOG_DESIGN_RULES::~DIALOG_DESIGN_RULES()
{
delete [] m_originalColWidths;
m_grid->Disconnect( wxEVT_GRID_CELL_CHANGING, wxGridEventHandler( DIALOG_DESIGN_RULES::OnNetclassGridCellChanging ), NULL, this );
}
bool DIALOG_DESIGN_RULES::TransferDataToWindow()
{
if( !wxDialog::TransferDataToWindow() )
return false;
m_Pcb = m_Parent->GetBoard();
m_BrdSettings = &m_Pcb->GetDesignSettings();
// Initialize the Rules List
transferNetclassesToWindow();
// Reassure that all nets have net classes assigned
m_Pcb->BuildListOfNets();
// copy all NETs into m_AllNets by adding them as NETCUPs.
// @todo go fix m_Pcb->SynchronizeNetsAndNetClasses() so that the netcode==0 is not
// present in the BOARD::m_NetClasses
NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
NETCLASSPTR netclass = netclasses.GetDefault();
// Initialize list of nets for Default Net Class
for( NETCLASS::iterator name = netclass->begin(); name != netclass->end(); ++name )
{
m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
}
// Initialize list of nets for others (custom) Net Classes
for( NETCLASSES::const_iterator nc = netclasses.begin(); nc != netclasses.end(); ++nc )
{
netclass = nc->second;
for( NETCLASS::const_iterator name = netclass->begin(); name != netclass->end(); ++name )
{
m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
}
}
rebuildNetclassDropdowns();
transferGlobalRulesToWindow();
return true;
}
void DIALOG_DESIGN_RULES::transferGlobalRulesToWindow()
{
m_trackMinWidth.SetValue( m_BrdSettings->m_TrackMinWidth );
m_viaMinDiameter.SetValue(m_BrdSettings->m_ViasMinSize );
m_viaMinDrill.SetValue( m_BrdSettings->m_ViasMinDrill );
m_OptAllowBlindBuriedVias->SetValue( m_BrdSettings->m_BlindBuriedViaAllowed );
m_OptAllowMicroVias->SetValue( m_BrdSettings->m_MicroViasAllowed );
CheckAllowMicroVias();
m_microViaMinDiameter.SetValue( m_BrdSettings->m_MicroViasMinSize );
m_microViaMinDrill.SetValue( m_BrdSettings->m_MicroViasMinDrill );
// Initialize Vias and Tracks sizes lists.
// note we display only extra values, never the current netclass value.
// (the first value in history list)
m_TracksWidthList = m_BrdSettings->m_TrackWidthList;
m_TracksWidthList.erase( m_TracksWidthList.begin() ); // remove the netclass value
m_ViasDimensionsList = m_BrdSettings->m_ViasDimensionsList;
m_ViasDimensionsList.erase( m_ViasDimensionsList.begin() ); // remove the netclass value
InitDimensionsLists();
}
void DIALOG_DESIGN_RULES::InitDimensionsLists()
{
wxString msg;
// Fill cells with actual values:
m_gridViaSizeList->SetCellValue( 0, 0, wxEmptyString );
m_gridViaSizeList->SetCellValue( 0, 1, wxEmptyString );
m_gridTrackWidthList->SetCellValue( 0, 0, wxEmptyString );
for( unsigned ii = 0; ii < m_TracksWidthList.size(); ii++ )
{
msg = StringFromValue( GetUserUnits(), m_TracksWidthList[ii], true, true );
m_gridTrackWidthList->SetCellValue( ii, 0, msg );
}
for( unsigned ii = 0; ii < m_ViasDimensionsList.size(); ii++ )
{
msg = StringFromValue( GetUserUnits(), m_ViasDimensionsList[ii].m_Diameter, true, true );
m_gridViaSizeList->SetCellValue( ii, 0, msg );
if( m_ViasDimensionsList[ii].m_Drill > 0 )
{
msg = StringFromValue( GetUserUnits(), m_ViasDimensionsList[ii].m_Drill, true, true );
m_gridViaSizeList->SetCellValue( ii, 1, msg );
}
}
}
// Sort comparison function (helper for makePointers() )
static bool sortByClassThenName( NETCUP* a, NETCUP* b )
{
// return a < b
if( a->clazz < b->clazz )
return true;
// inside the same class, sort by net name:
if( a->clazz == b->clazz )
{
if( a->net < b->net )
return true;
}
return false;
}
void DIALOG_DESIGN_RULES::makePointers( PNETCUPS* aList, const wxString& aNetClassName )
{
aList->clear();
if( wildCard == aNetClassName )
{
for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
{
aList->push_back( &*n );
}
sort( aList->begin(), aList->end(), sortByClassThenName );
// could use a different sort order for wildCard case.
}
else
{
for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
{
if( n->clazz == aNetClassName )
aList->push_back( &*n );
}
sort( aList->begin(), aList->end(), sortByClassThenName );
}
}
void DIALOG_DESIGN_RULES::FillListBoxWithNetNames( NETS_LIST_CTRL* aListCtrl,
const wxString& aNetClass )
{
aListCtrl->ClearList();
PNETCUPS ptrList;
// get a subset of m_AllNets in pointer form, sorted as desired.
makePointers( &ptrList, aNetClass );
// Add netclass info to m_Netnames and m_Classnames wxArrayString buffers
// aListCtrl uses wxLC_VIRTUAL option, so this is fast
wxClientDC sDC( aListCtrl );
int row = 0;
// recompute the column widths here, after setting texts
int net_colsize = sDC.GetTextExtent( NET_TITLE ).x;
int class_colsize = sDC.GetTextExtent( CLASS_TITLE ).x;
for( PNETCUPS::iterator i = ptrList.begin(); i!=ptrList.end(); ++i, ++row )
{
wxSize net_needed = sDC.GetTextExtent( (*i)->net );
wxSize class_needed = sDC.GetTextExtent( (*i)->clazz );
net_colsize = std::max( net_colsize, net_needed.x );
class_colsize = std::max( class_colsize, class_needed.x );
aListCtrl->SetRowItems( row, (*i)->net, (*i)->clazz );
}
int margin = sDC.GetTextExtent( wxT( "XX" ) ).x;
aListCtrl->SetColumnWidth( 0, net_colsize + margin );
aListCtrl->SetColumnWidth( 1, class_colsize + margin );
aListCtrl->Refresh();
}
/* Populates drop-downs with the list of net classes
*/
void DIALOG_DESIGN_RULES::rebuildNetclassDropdowns()
{
wxString rightSelected = m_rightClassChoice->GetStringSelection();
wxString leftSelected = m_leftClassChoice->GetStringSelection();
m_rightClassChoice->Clear();
m_leftClassChoice->Clear();
m_rightClassChoice->Append( wildCard );
m_leftClassChoice->Append( wildCard );
for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
{
m_rightClassChoice->Append( m_grid->GetCellValue( ii, GRID_NAME ) );
m_leftClassChoice->Append( m_grid->GetCellValue( ii, GRID_NAME ) );
}
// Reselect previous choice if still available; otherwise the wildcard
m_rightClassChoice->Select( std::max( 0, m_rightClassChoice->FindString( rightSelected ) ) );
m_leftClassChoice->Select( std::max( 0, m_leftClassChoice->FindString( leftSelected ) ) );
FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
FillListBoxWithNetNames( m_rightListCtrl, m_rightClassChoice->GetStringSelection() );
}
/* Initialize the rules list from board
*/
static void class2gridRow( EDA_UNITS_T aUnits, wxGrid* grid, int row, const NETCLASSPTR& nc )
{
wxString msg;
grid->SetCellValue( row, GRID_NAME, nc->GetName() );
msg = StringFromValue( aUnits, nc->GetClearance(), true, true );
grid->SetCellValue( row, GRID_CLEARANCE, msg );
msg = StringFromValue( aUnits, nc->GetTrackWidth(), true, true );
grid->SetCellValue( row, GRID_TRACKSIZE, msg );
msg = StringFromValue( aUnits, nc->GetViaDiameter(), true, true );
grid->SetCellValue( row, GRID_VIASIZE, msg );
msg = StringFromValue( aUnits, nc->GetViaDrill(), true, true );
grid->SetCellValue( row, GRID_VIADRILL, msg );
msg = StringFromValue( aUnits, nc->GetuViaDiameter(), true, true );
grid->SetCellValue( row, GRID_uVIASIZE, msg );
msg = StringFromValue( aUnits, nc->GetuViaDrill(), true, true );
grid->SetCellValue( row, GRID_uVIADRILL, msg );
msg = StringFromValue( aUnits, nc->GetDiffPairGap(), true, true );
grid->SetCellValue( row, GRID_DIFF_PAIR_GAP, msg );
msg = StringFromValue( aUnits, nc->GetDiffPairWidth(),true, true );
grid->SetCellValue( row, GRID_DIFF_PAIR_WIDTH, msg );
}
void DIALOG_DESIGN_RULES::transferNetclassesToWindow()
{
NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
// the +1 is for the Default NETCLASS.
if( netclasses.GetCount() + 1 > (unsigned) m_grid->GetNumberRows() )
m_grid->AppendRows( netclasses.GetCount() + 1 - m_grid->GetNumberRows() );
// enter the Default NETCLASS.
class2gridRow( GetUserUnits(), m_grid, 0, netclasses.GetDefault() );
// make the Default NETCLASS name read-only
wxGridCellAttr* cellAttr = m_grid->GetOrCreateCellAttr( 0, GRID_NAME );
cellAttr->SetReadOnly();
cellAttr->DecRef();
// enter other netclasses
int row = 1;
for( NETCLASSES::iterator i = netclasses.begin(); i != netclasses.end(); ++i, ++row )
class2gridRow( GetUserUnits(), m_grid, row, i->second );
}
static void gridRow2class( EDA_UNITS_T aUnits, wxGrid* grid, int row, const NETCLASSPTR& nc )
{
nc->SetName( grid->GetCellValue( row, GRID_NAME ) );
#define MYCELL( col ) \
ValueFromString( aUnits, grid->GetCellValue( row, col ) )
nc->SetClearance( MYCELL( GRID_CLEARANCE ) );
nc->SetTrackWidth( MYCELL( GRID_TRACKSIZE ) );
nc->SetViaDiameter( MYCELL( GRID_VIASIZE ) );
nc->SetViaDrill( MYCELL( GRID_VIADRILL ) );
nc->SetuViaDiameter( MYCELL( GRID_uVIASIZE ) );
nc->SetuViaDrill( MYCELL( GRID_uVIADRILL ) );
nc->SetDiffPairGap( MYCELL( GRID_DIFF_PAIR_GAP ) );
nc->SetDiffPairWidth( MYCELL( GRID_DIFF_PAIR_WIDTH ) );
}
void DIALOG_DESIGN_RULES::CopyNetclassesToBoard()
{
// Commit any pending in-place edits and close the editor
m_grid->DisableCellEditControl();
NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
// Remove all netclasses from board. We'll copy new list after
netclasses.Clear();
// Copy the default NetClass:
gridRow2class( GetUserUnits(), m_grid, 0, netclasses.GetDefault() );
// Copy other NetClasses :
for( int row = 1; row < m_grid->GetNumberRows(); ++row )
{
NETCLASSPTR nc = std::make_shared<NETCLASS>( m_grid->GetCellValue( row, GRID_NAME ) );
if( m_BrdSettings->m_NetClasses.Add( nc ) )
gridRow2class( GetUserUnits(), m_grid, row, nc );
}
// Now read all nets and push them in the corresponding netclass net buffer
for( NETCUPS::const_iterator netcup = m_AllNets.begin(); netcup != m_AllNets.end(); ++netcup )
{
NETCLASSPTR nc = netclasses.Find( netcup->clazz );
wxASSERT( nc );
nc->Add( netcup->net );
}
m_Pcb->SynchronizeNetsAndNetClasses();
}
void DIALOG_DESIGN_RULES::CopyGlobalRulesToBoard()
{
// Update tracks minimum values for DRC
m_BrdSettings->m_TrackMinWidth = m_trackMinWidth.GetValue();
// Update vias minimum values for DRC
m_BrdSettings->m_ViasMinSize = m_viaMinDiameter.GetValue();
m_BrdSettings->m_ViasMinDrill = m_viaMinDrill.GetValue();
m_BrdSettings->m_BlindBuriedViaAllowed = m_OptAllowBlindBuriedVias->GetValue();
m_BrdSettings->m_MicroViasAllowed = m_OptAllowMicroVias->GetValue();
// Update microvias minimum values for DRC
m_BrdSettings->m_MicroViasMinSize = m_microViaMinDiameter.GetValue();
m_BrdSettings->m_MicroViasMinDrill = m_microViaMinDrill.GetValue();
}
void DIALOG_DESIGN_RULES::CopyDimensionsListsToBoard()
{
wxString msg;
// Commit any pending in-place edits and close editors from grid controls
m_gridTrackWidthList->DisableCellEditControl();
m_gridViaSizeList->DisableCellEditControl();
// Reinitialize m_TrackWidthList
m_TracksWidthList.clear();
for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
{
msg = m_gridTrackWidthList->GetCellValue( row, 0 );
if( msg.IsEmpty() )
continue;
int value = ValueFromString( GetUserUnits(), msg );
m_TracksWidthList.push_back( value );
}
// Sort new list by by increasing value
sort( m_TracksWidthList.begin(), m_TracksWidthList.end() );
// Reinitialize m_ViasDimensionsList
m_ViasDimensionsList.clear();
for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
{
msg = m_gridViaSizeList->GetCellValue( row, 0 );
if( msg.IsEmpty() )
continue;
int value = ValueFromString( GetUserUnits(), msg );
VIA_DIMENSION via_dim;
via_dim.m_Diameter = value;
msg = m_gridViaSizeList->GetCellValue( row, 1 );
if( !msg.IsEmpty() )
{
value = ValueFromString( g_UserUnit, msg );
via_dim.m_Drill = value;
}
m_ViasDimensionsList.push_back( via_dim );
}
// Sort new list by by increasing value
sort( m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
std::vector<int>* tlist = &m_BrdSettings->m_TrackWidthList;
// Remove old "custom" sizes
tlist->erase( tlist->begin() + 1, tlist->end() );
// Add new "custom" sizes
tlist->insert( tlist->end(), m_TracksWidthList.begin(), m_TracksWidthList.end() );
// Reinitialize m_ViaSizeList
std::vector<VIA_DIMENSION>* vialist = &m_BrdSettings->m_ViasDimensionsList;
vialist->erase( vialist->begin() + 1, vialist->end() );
vialist->insert( vialist->end(), m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
}
void DIALOG_DESIGN_RULES::OnNotebookPageChanged( wxNotebookEvent& event )
{
s_LastTabSelection = event.GetSelection();
// Skip() allows OSX to properly refresh controls.
event.Skip();
}
bool DIALOG_DESIGN_RULES::TransferDataFromWindow()
{
if( !wxDialog::TransferDataFromWindow() )
return false;
if( !validateData() )
return false;
CopyNetclassesToBoard();
CopyGlobalRulesToBoard();
CopyDimensionsListsToBoard();
m_BrdSettings->SetCurrentNetClass( NETCLASS::Default );
//this event causes the routing tool to reload its design rules information
TOOL_MANAGER* toolManager = m_Parent->GetToolManager();
TOOL_EVENT event( TC_COMMAND, TA_MODEL_CHANGE, AS_ACTIVE );
toolManager->ProcessEvent( event );
return true;
}
bool DIALOG_DESIGN_RULES::validateNetclassName( int aRow, wxString aName, bool focusFirst )
{
aName.Trim( true );
aName.Trim( false );
if( aName.IsEmpty() )
{
setGridError( m_grid, _( "Netclass name cannot be empty." ), aRow, GRID_NAME );
return false;
}
for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
{
if( ii != aRow && m_grid->GetRowLabelValue( ii ).CmpNoCase( aName ) == 0 )
{
if( focusFirst )
setGridError( m_grid, _( "Netclass name already in use." ), aRow, GRID_NAME );
else
setGridError( m_grid, _( "Netclass name already in use." ), ii, GRID_NAME );
return false;
}
}
return true;
}
void DIALOG_DESIGN_RULES::OnNetclassGridCellChanging( wxGridEvent& event )
{
if( event.GetCol() == GRID_NAME )
{
if( validateNetclassName( event.GetRow(), event.GetString() ) )
m_netclassesDirty = true;
else
event.Veto();
}
}
void DIALOG_DESIGN_RULES::OnAddNetclassClick( wxCommandEvent& event )
{
m_grid->AppendRows();
// Copy values of the default class:
int irow = m_grid->GetNumberRows() - 1;
for( int icol = 1; icol < m_grid->GetNumberCols(); icol++ )
{
wxString value;
value = m_grid->GetCellValue( 0, icol );
m_grid->SetCellValue( irow, icol, value );
}
rebuildNetclassDropdowns();
}
void DIALOG_DESIGN_RULES::OnRemoveNetclassClick( wxCommandEvent& event )
{
int curRow = m_grid->GetGridCursorRow();
if( curRow == 0 )
{
DisplayErrorMessage( this, _( "The default net class is required." ) );
return;
}
// reset the net class to default for members of the removed class
wxString classname = m_grid->GetCellValue( curRow, GRID_NAME );
swapNetClass( classname, NETCLASS::Default );
m_grid->DeleteRows( curRow, 1 );
rebuildNetclassDropdowns();
}
void DIALOG_DESIGN_RULES::AdjustNetclassGridColumns( int aWidth )
{
int fixedColsWidth = 0;
for( int i = 1; i < m_grid->GetNumberCols(); i++ )
{
m_grid->SetColSize( i, m_originalColWidths[ i ] );
fixedColsWidth += m_originalColWidths[ i ];
}
m_grid->SetColSize( 0, aWidth - fixedColsWidth - 4 );
}
void DIALOG_DESIGN_RULES::OnSizeNetclassGrid( wxSizeEvent& event )
{
AdjustNetclassGridColumns( event.GetSize().GetX() );
event.Skip();
}
void DIALOG_DESIGN_RULES::setGridError( wxGrid* aGrid, const wxString& aMsg, int aRow, int aCol )
{
m_gridErrorGrid = aGrid;
m_gridErrorMsg = aMsg;
m_gridErrorRow = aRow;
m_gridErrorCol = aCol;
if( m_gridErrorGrid->GetParent() != m_DRnotebook->GetCurrentPage() )
m_DRnotebook->AdvanceSelection();
}
void DIALOG_DESIGN_RULES::OnUpdateUI( wxUpdateUIEvent& event )
{
if( m_netclassesDirty )
{
rebuildNetclassDropdowns();
m_netclassesDirty = false;
}
// Handle a grid error. This is delayed to OnUpdateUI so that we can change focus
// even when the original validation was triggered from a killFocus event, and so
// that the corresponding notebook page can be shown in the background when triggered
// from an OK.
if( m_gridErrorGrid )
{
// We will re-enter this routine when the error dialog is displayed, so make
// sure we don't keep putting up more dialogs.
wxGrid* grid = m_gridErrorGrid;
m_gridErrorGrid = nullptr;
DisplayErrorMessage( this, m_gridErrorMsg );
grid->GoToCell( m_gridErrorRow, m_gridErrorCol );
grid->SetFocus();
}
}
void DIALOG_DESIGN_RULES::CheckAllowMicroVias()
{
bool enabled = m_OptAllowMicroVias->GetValue();
m_microViaMinDiameter.Enable( enabled );
m_microViaMinDrill.Enable( enabled );
}
/**
* Function OnAllowMicroVias
* is called whenever the AllowMicroVias checkbox is toggled
*/
void DIALOG_DESIGN_RULES::OnAllowMicroVias( wxCommandEvent& event )
{
CheckAllowMicroVias();
}
void DIALOG_DESIGN_RULES::OnMoveUpSelectedNetClass( wxCommandEvent& event )
{
// Commit any pending in-place edits and close the editor
m_grid->DisableCellEditControl();
int curRow = m_grid->GetGridCursorRow();
if( curRow < 2 )
{
wxBell();
return;
}
// Swap the rule and the previous rule
for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
{
wxString curr_value = m_grid->GetCellValue( curRow, icol );
wxString previous_value = m_grid->GetCellValue( curRow - 1, icol );
m_grid->SetCellValue( curRow, icol, previous_value );
m_grid->SetCellValue( curRow - 1, icol, curr_value );
}
m_grid->SetGridCursor( curRow - 1, m_grid->GetGridCursorCol() );
m_grid->MakeCellVisible( m_grid->GetGridCursorRow(), m_grid->GetGridCursorCol() );
m_netclassesDirty = true;
}
void DIALOG_DESIGN_RULES::OnMoveDownSelectedNetClass( wxCommandEvent& event )
{
// Commit any pending in-place edits and close the editor
m_grid->DisableCellEditControl();
int curRow = m_grid->GetGridCursorRow();
if( curRow == 0 || curRow == m_grid->GetNumberRows() - 1 )
{
wxBell();
return;
}
// Swap the rule and the next rule
for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
{
wxString curr_value = m_grid->GetCellValue( curRow, icol );
wxString next_value = m_grid->GetCellValue( curRow + 1, icol );
m_grid->SetCellValue( curRow, icol, next_value );
m_grid->SetCellValue( curRow + 1, icol, curr_value );
}
m_grid->SetGridCursor( curRow + 1, m_grid->GetGridCursorCol() );
m_grid->MakeCellVisible( m_grid->GetGridCursorRow(), m_grid->GetGridCursorCol() );
m_netclassesDirty = true;
}
void DIALOG_DESIGN_RULES::OnLeftCBSelection( wxCommandEvent& event )
{
FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
{
m_buttonRightToLeft->Enable( false );
m_buttonLeftToRight->Enable( false );
}
else
{
m_buttonRightToLeft->Enable( true );
m_buttonLeftToRight->Enable( true );
}
}
void DIALOG_DESIGN_RULES::OnRightCBSelection( wxCommandEvent& event )
{
FillListBoxWithNetNames( m_rightListCtrl, m_rightClassChoice->GetStringSelection() );
if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
{
m_buttonRightToLeft->Enable( false );
m_buttonLeftToRight->Enable( false );
}
else
{
m_buttonRightToLeft->Enable( true );
m_buttonLeftToRight->Enable( true );
}
}
void DIALOG_DESIGN_RULES::moveSelectedItems( NETS_LIST_CTRL* src, const wxString& newClassName )
{
wxListItem item;
wxString netName;
item.m_mask |= wxLIST_MASK_TEXT; // Validate the member m_text of the wxListItem item
for( int row = 0; row < src->GetItemCount(); ++row )
{
if( !src->GetItemState( row, wxLIST_STATE_SELECTED ) )
continue;
item.SetColumn( 0 );
item.SetId( row );
src->GetItem( item );
netName = item.GetText();
setNetClass( netName, newClassName == wildCard ? NETCLASS::Default : newClassName );
}
}
void DIALOG_DESIGN_RULES::OnRightToLeftCopyButton( wxCommandEvent& event )
{
wxString newClassName = m_leftClassChoice->GetStringSelection();
moveSelectedItems( m_rightListCtrl, newClassName );
FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
FillListBoxWithNetNames( m_rightListCtrl, m_rightClassChoice->GetStringSelection() );
}
void DIALOG_DESIGN_RULES::OnLeftToRightCopyButton( wxCommandEvent& event )
{
wxString newClassName = m_rightClassChoice->GetStringSelection();
moveSelectedItems( m_leftListCtrl, newClassName );
FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
FillListBoxWithNetNames( m_rightListCtrl, m_rightClassChoice->GetStringSelection() );
}
void DIALOG_DESIGN_RULES::OnLeftSelectAllButton( wxCommandEvent& event )
{
for( int ii = 0; ii < m_leftListCtrl->GetItemCount(); ii++ )
m_leftListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
}
void DIALOG_DESIGN_RULES::OnRightSelectAllButton( wxCommandEvent& event )
{
for( int ii = 0; ii < m_rightListCtrl->GetItemCount(); ii++ )
m_rightListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
}
void DIALOG_DESIGN_RULES::setNetClass( const wxString& aNetName, const wxString& aClassName )
{
for( NETCUPS::iterator i = m_AllNets.begin(); i != m_AllNets.end(); ++i )
{
if( i->net == aNetName )
{
i->clazz = aClassName;
break;
}
}
}
bool DIALOG_DESIGN_RULES::validateData()
{
wxString msg;
int minViaDia = ValueFromTextCtrl( *m_SetViasMinSizeCtrl );
int minViaDrill = ValueFromTextCtrl( *m_SetViasMinDrillCtrl );
int minUViaDia = ValueFromTextCtrl( *m_SetMicroViasMinSizeCtrl );
int minUViaDrill = ValueFromTextCtrl( *m_SetMicroViasMinDrillCtrl );
int minTrackWidth = ValueFromTextCtrl( *m_SetTrackMinWidthCtrl );
// Test net class parameters.
for( int row = 0; row < m_grid->GetNumberRows(); row++ )
{
wxString netclassName = m_grid->GetCellValue( row, GRID_NAME );
netclassName.Trim( true );
netclassName.Trim( false );
if( !validateNetclassName( row, netclassName, false ) )
return false;
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_TRACKSIZE ) )
< minTrackWidth )
{
msg.Printf( _( "Track width less than minimum track width (%s)." ),
StringFromValue( GetUserUnits(), minTrackWidth, true, true ) );
setGridError( m_grid, msg, row, GRID_TRACKSIZE );
return false;
}
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_DIFF_PAIR_WIDTH ) )
< minTrackWidth )
{
msg.Printf( _( "Differential pair width less than minimum track width (%s)." ),
StringFromValue( GetUserUnits(), minTrackWidth, true, true ) );
setGridError( m_grid, msg, row, GRID_DIFF_PAIR_WIDTH );
return false;
}
// Test vias
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_VIASIZE ) )
< minViaDia )
{
msg.Printf( _( "Via diameter less than minimum via diameter (%s)." ),
StringFromValue( GetUserUnits(), minViaDia, true, true ) );
setGridError( m_grid, msg, row, GRID_VIASIZE );
return false;
}
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_VIADRILL ) )
>= ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_VIASIZE ) ) )
{
msg = _( "Via drill larger than via diameter." );
setGridError( m_grid, msg, row, GRID_VIADRILL );
return false;
}
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_VIADRILL ) )
< minViaDrill )
{
msg.Printf( _( "Via drill less than minimum via drill (%s)." ),
StringFromValue( GetUserUnits(), minViaDrill, true, true ) );
setGridError( m_grid, msg, row, GRID_VIADRILL );
return false;
}
// Test Micro vias
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_uVIASIZE ) )
< minUViaDia )
{
msg.Printf( _( "Microvia diameter less than minimum microvia diameter (%s)." ),
StringFromValue( GetUserUnits(), minUViaDia, true, true ) );
setGridError( m_grid, msg, row, GRID_uVIASIZE );
return false;
}
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_uVIADRILL ) )
>= ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_uVIASIZE ) ) )
{
msg = _( "Microvia drill larger than microvia diameter." );
setGridError( m_grid, msg, row, GRID_uVIADRILL );
return false;
}
if( ValueFromString( GetUserUnits(), m_grid->GetCellValue( row, GRID_uVIADRILL ) )
< minUViaDrill )
{
msg.Printf( _( "Microvia drill less than minimum microvia drill (%s)." ),
StringFromValue( GetUserUnits(), minUViaDrill, true, true ) );
setGridError( m_grid, msg, row, GRID_uVIADRILL );
return false;
}
}
// Test custom tracks
for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
{
wxString tvalue = m_gridTrackWidthList->GetCellValue( row, 0 );
if( tvalue.IsEmpty() )
continue;
if( ValueFromString( GetUserUnits(), tvalue ) < minTrackWidth )
{
msg.Printf( _( "Track width less than minimum track width (%s)." ),
StringFromValue( GetUserUnits(), minTrackWidth, true, true ) );
setGridError( m_gridTrackWidthList, msg, row, 0 );
return false;
}
}
// Test custom vias
for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
{
wxString viaDia = m_gridViaSizeList->GetCellValue( row, 0 );
if( viaDia.IsEmpty() )
continue;
if( ValueFromString( GetUserUnits(), viaDia ) < minViaDia )
{
msg.Printf( _( "Via diameter less than minimum via diameter (%s)." ),
StringFromValue( GetUserUnits(), minViaDia, true, true ) );
setGridError( m_gridViaSizeList, msg, row, 0 );
return false;
}
wxString viaDrill = m_gridViaSizeList->GetCellValue( row, 1 );
if( viaDrill.IsEmpty() )
{
msg = _( "No via drill defined." );
setGridError( m_gridViaSizeList, msg, row, 1 );
return false;
}
if( ValueFromString( GetUserUnits(), viaDrill ) < minViaDrill )
{
msg.Printf( _( "Via drill less than minimum via drill (%s)." ),
StringFromValue( GetUserUnits(), minViaDrill, true, true ) );
setGridError( m_gridViaSizeList, msg, row, 1 );
return false;
}
if( ValueFromString( GetUserUnits(), viaDrill )
>= ValueFromString( GetUserUnits(), viaDia ) )
{
msg = _( "Via drill larger than via diameter." );
setGridError( m_gridViaSizeList, msg, row, 1 );
return false;
}
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink