KiCad PCB EDA Suite
dialog_design_rules.cpp
Go to the documentation of this file.
1 
5 /*
6  * This program source code file is part of KiCad, a free EDA CAD application.
7  *
8  * Copyright (C) 2004-2009 Jean-Pierre Charras, jp.charras at wanadoo.fr
9  * Copyright (C) 2009 Dick Hollenbeck, dick@softplc.com
10  * Copyright (C) 2009-2015 KiCad Developers, see change_log.txt for contributors.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, you may find one here:
24  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
25  * or you may search the http://www.gnu.org website for the version 2 license,
26  * or you may write to the Free Software Foundation, Inc.,
27  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
28  */
29 
30 
31 /* functions relative to the design rules editor
32  */
33 #include <fctsys.h>
34 #include <class_drawpanel.h>
35 #include <base_units.h>
36 #include <confirm.h>
37 #include <pcbnew.h>
38 #include <pcb_edit_frame.h>
39 #include <board_design_settings.h>
40 
41 #include <pcbnew_id.h>
42 #include <class_track.h>
43 #include <macros.h>
44 #include <html_messagebox.h>
45 
46 #include <dialog_design_rules.h>
47 #include <wx/generic/gridctrl.h>
49 
50 // Column labels for net lists
51 #define NET_TITLE _( "Net" )
52 #define CLASS_TITLE _( "Class" )
53 
54 // Field Positions on rules grid
55 enum {
64 };
65 
66 const wxString DIALOG_DESIGN_RULES::wildCard = _( "* (Any)" );
67 
68 // dialog should remember its previously selected tab
70 
71 // methods for the helper class NETS_LIST_CTRL
72 
73 wxString NETS_LIST_CTRL::OnGetItemText( long item, long column ) const
74 {
75  if( column == 0 )
76  {
77  if( item < (long) m_Netnames.GetCount() )
78  return m_Netnames[item];
79  else
80  return wxEmptyString;
81  }
82  else if( item < (long) m_Classnames.GetCount() )
83  return m_Classnames[item];
84 
85  return wxEmptyString;
86 }
87 
88 
89 void NETS_LIST_CTRL::SetRowItems( unsigned aRow,
90  const wxString& aNetname,
91  const wxString& aNetclassName )
92 {
93  // insert blanks if aRow is larger than existing row count
94  unsigned cnt = m_Netnames.GetCount();
95 
96  if( cnt <= aRow )
97  m_Netnames.Add( wxEmptyString, aRow - cnt + 1 );
98 
99  cnt = m_Classnames.GetCount();
100 
101  if( cnt <= aRow )
102  m_Classnames.Add( wxEmptyString, aRow - cnt + 1 );
103 
104  if( (int)aRow <= GetItemCount() )
105  SetItemCount( aRow + 1 );
106 
107  m_Netnames[aRow] = aNetname;
108  m_Classnames[aRow] = aNetclassName;
109 }
110 
111 
119 // @todo: maybe move this to common.cpp if it works.
120 static void EnsureGridColumnWidths( wxWindow* aShower, wxGrid* aGrid )
121 {
122  wxWindowDC sDC( aShower );
123 
124  sDC.SetFont( aGrid->GetLabelFont() );
125 
126  int colCount = aGrid->GetNumberCols();
127 
128  for( int col = 0; col < colCount; ++col )
129  {
130  // add two spaces to the text and size it.
131  wxString colText = aGrid->GetColLabelValue( col ) + wxT( " " );
132 
133  wxSize needed = sDC.GetTextExtent( colText );
134 
135  // set the width of this column
136  aGrid->SetColSize( col, needed.x );
137  }
138 }
139 
140 static void EnsureGridRowTitleWidth( wxWindow* aShower, wxGrid* aGrid, int aMinWidth )
141 {
142  wxWindowDC sDC( aShower );
143  sDC.SetFont( aGrid->GetLabelFont() );
144 
145  int minsize = aMinWidth;
146  int rowCount = aGrid->GetNumberRows();
147 
148  for( int row = 0; row < rowCount; ++row )
149  {
150  // add two spaces to the text and size it.
151  wxString rowText = aGrid->GetRowLabelValue( row ) + wxT( " " );
152 
153  wxSize needed = sDC.GetTextExtent( rowText );
154 
155  minsize = std::max( minsize, needed.x );
156  }
157 
158  // set the width of the row laberls
159  aGrid->SetRowLabelSize( minsize );
160 }
161 
162 
164  DIALOG_DESIGN_RULES_BASE( parent )
165 {
166  m_Parent = parent;
167  SetAutoLayout( true );
168 
169  m_initialRowLabelsSize = m_grid->GetRowLabelSize();
170  EnsureGridColumnWidths( this, m_grid ); // override any column widths set by wxformbuilder.
171 
172  wxListItem column0;
173  wxListItem column1;
174 
175  column0.Clear();
176  column1.Clear();
177 
178  column0.SetMask( wxLIST_MASK_TEXT );
179  column1.SetMask( wxLIST_MASK_TEXT );
180 
181  column0.SetText( NET_TITLE );
182  column1.SetText( CLASS_TITLE );
183 
185 
186  m_leftListCtrl->InsertColumn( 0, column0 );
187  m_leftListCtrl->InsertColumn( 1, column1 );
188  m_leftListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
189  m_leftListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
190 
191  m_rightListCtrl->InsertColumn( 0, column0 );
192  m_rightListCtrl->InsertColumn( 1, column1 );
193  m_rightListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
194  m_rightListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
195 
196  // if user has been into the dialog before, go back to same tab
197  if( s_LastTabSelection != -1 )
198  {
199  m_DRnotebook->SetSelection( s_LastTabSelection );
200  }
201 
202  InitDialogRules();
204 
205  m_sdbSizer1OK->SetDefault();
206 
207  // Allow tabbing out of grid controls.
208  m_grid->SetTabBehaviour( wxGrid::Tab_Leave );
209  m_gridViaSizeList->SetTabBehaviour( wxGrid::Tab_Leave );
210  m_gridTrackWidthList->SetTabBehaviour( wxGrid::Tab_Leave );
211 
212  Layout();
213 
214  // Now all widgets have the size fixed, call FinishDialogSettings
216 }
217 
219 {
220  // Set floating-point validators for numerical inputs
221  wxFloatingPointValidator< double > fpValidator( NULL, wxNUM_VAL_ZERO_AS_BLANK | wxNUM_VAL_NO_TRAILING_ZEROES );
222 
223  int maxDimension = 1000 * IU_PER_MILS; // One-inch
224 
225  fpValidator.SetRange( 0, To_User_Unit( g_UserUnit, maxDimension ) );
226  fpValidator.SetPrecision( 10 );
227 
228  m_SetViasMinSizeCtrl->SetValidator( fpValidator );
229  m_SetViasMinDrillCtrl->SetValidator( fpValidator );
230  m_SetMicroViasMinSizeCtrl->SetValidator( fpValidator );
231  m_SetMicroViasMinDrillCtrl->SetValidator( fpValidator );
232  m_SetTrackMinWidthCtrl->SetValidator( fpValidator );
233 }
234 
235 
237 {
238  // @todo: Move the initialization code into TransferDataToWindow() to follow wxWidgets
239  // dialog data transfer convention.
240  SetFocus();
241  SetReturnCode( 0 );
242 
243  m_Pcb = m_Parent->GetBoard();
245 
246  // Initialize the Rules List
247  InitRulesList();
248 
249  // copy all NETs into m_AllNets by adding them as NETCUPs.
250 
251  // @todo go fix m_Pcb->SynchronizeNetsAndNetClasses() so that the netcode==0 is not
252  // present in the BOARD::m_NetClasses
253  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
254  NETCLASSPTR netclass = netclasses.GetDefault();
255 
256  // Initialize list of nets for Default Net Class
257  for( NETCLASS::iterator name = netclass->begin(); name != netclass->end(); ++name )
258  {
259  m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
260  }
261 
262  // Initialize list of nets for others (custom) Net Classes
263  for( NETCLASSES::const_iterator nc = netclasses.begin(); nc != netclasses.end(); ++nc )
264  {
265  netclass = nc->second;
266 
267  for( NETCLASS::const_iterator name = netclass->begin(); name != netclass->end(); ++name )
268  {
269  m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
270  }
271  }
272 
274  InitGlobalRules();
275 }
276 
277 
279 {
280  // Set unit labels
281  const wxString units = GetAbbreviatedUnitsLabel( g_UserUnit );
282 
283  m_ViaMinUnits->SetLabel( units );
284  m_ViaMinDrillUnits->SetLabel( units );
285  m_MicroViaMinSizeUnits->SetLabel( units );
286  m_MicroViaMinDrillUnits->SetLabel( units );
287  m_TrackMinWidthUnits->SetLabel( units );
288 
291 
295 
299 
300  // Initialize Vias and Tracks sizes lists.
301  // note we display only extra values, never the current netclass value.
302  // (the first value in history list)
304  m_TracksWidthList.erase( m_TracksWidthList.begin() ); // remove the netclass value
306  m_ViasDimensionsList.erase( m_ViasDimensionsList.begin() ); // remove the netclass value
308 }
309 
310 
312 {
313  wxString msg;
314 
315  // Compute the column widths here, after setting texts
316  msg = wxT("000000.000000"); // This is a very long text to display values.
317  // Actual values are shorter.
318  m_gridViaSizeList->SetCellValue( 0, 0, msg );
319  m_gridViaSizeList->SetCellValue( 0, 1, msg );
320  m_gridTrackWidthList->SetCellValue( 0, 0, msg );
321  m_gridViaSizeList->SetColMinimalWidth( 0, 150 );
322  m_gridViaSizeList->SetColMinimalWidth( 1, 150 );
323  m_gridViaSizeList->AutoSizeColumns( true );
324  m_gridTrackWidthList->SetColMinimalWidth( 0, 150 );
325  m_gridTrackWidthList->AutoSizeColumns( true );
326  m_gridViaSizeList->SetColMinimalWidth( 1, 150 );
327 
328  // Fill cells with actual values:
329  m_gridViaSizeList->SetCellValue( 0, 0, wxEmptyString );
330  m_gridViaSizeList->SetCellValue( 0, 1, wxEmptyString );
331  m_gridTrackWidthList->SetCellValue( 0, 0, wxEmptyString );
332 
333  // Give a correct size to row labels column
334  m_gridViaSizeList->SetRowLabelSize( wxGRID_AUTOSIZE );
335  m_gridTrackWidthList->SetRowLabelSize( wxGRID_AUTOSIZE );
336 
337  for( unsigned ii = 0; ii < m_TracksWidthList.size(); ii++ )
338  {
339  msg = StringFromValue( g_UserUnit, m_TracksWidthList[ii], false );
340  m_gridTrackWidthList->SetCellValue( ii, 0, msg );
341  }
342 
343  for( unsigned ii = 0; ii < m_ViasDimensionsList.size(); ii++ )
344  {
345  msg = StringFromValue( g_UserUnit, m_ViasDimensionsList[ii].m_Diameter, false );
346  m_gridViaSizeList->SetCellValue( ii, 0, msg );
347 
348  if( m_ViasDimensionsList[ii].m_Drill > 0 )
349  {
350  msg = StringFromValue( g_UserUnit, m_ViasDimensionsList[ii].m_Drill, false );
351  m_gridViaSizeList->SetCellValue( ii, 1, msg );
352  }
353  }
354 }
355 
356 
357 // Sort comparison function (helper for makePointers() )
358 static bool sortByClassThenName( NETCUP* a, NETCUP* b )
359 {
360  // return a < b
361  if( a->clazz < b->clazz )
362  return true;
363 
364  // inside the same class, sort by net name:
365  if( a->clazz == b->clazz )
366  {
367  if( a->net < b->net )
368  return true;
369  }
370 
371  return false;
372 }
373 
374 
375 void DIALOG_DESIGN_RULES::makePointers( PNETCUPS* aList, const wxString& aNetClassName )
376 {
377  aList->clear();
378 
379  if( wildCard == aNetClassName )
380  {
381  for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
382  {
383  aList->push_back( &*n );
384  }
385 
386  sort( aList->begin(), aList->end(), sortByClassThenName );
387 
388  // could use a different sort order for wildCard case.
389  }
390  else
391  {
392  for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
393  {
394  if( n->clazz == aNetClassName )
395  aList->push_back( &*n );
396  }
397 
398  sort( aList->begin(), aList->end(), sortByClassThenName );
399  }
400 }
401 
402 
404  const wxString& aNetClass )
405 {
406  aListCtrl->ClearList();
407 
408  PNETCUPS ptrList;
409 
410  // get a subset of m_AllNets in pointer form, sorted as desired.
411  makePointers( &ptrList, aNetClass );
412 
413 #if 0 && defined(DEBUG)
414  int r = 0;
415  for( PNETCUPS::iterator i = ptrList.begin(); i!=ptrList.end(); ++i, ++r )
416  {
417  printf( "[%d]: %s %s\n", r, TO_UTF8( (*i)->net ), TO_UTF8( (*i)->clazz ) );
418  }
419 
420 #endif
421 
422  // Add netclass info to m_Netnames and m_Classnames wxArrayString buffers
423  // aListCtrl uses wxLC_VIRTUAL option, so this is fast
424  wxClientDC sDC( aListCtrl );
425  int row = 0;
426  // recompute the column widths here, after setting texts
427  int net_colsize = sDC.GetTextExtent( NET_TITLE ).x;
428  int class_colsize = sDC.GetTextExtent( CLASS_TITLE ).x;
429 
430  for( PNETCUPS::iterator i = ptrList.begin(); i!=ptrList.end(); ++i, ++row )
431  {
432  wxSize net_needed = sDC.GetTextExtent( (*i)->net );
433  wxSize class_needed = sDC.GetTextExtent( (*i)->clazz );
434  net_colsize = std::max( net_colsize, net_needed.x );
435  class_colsize = std::max( class_colsize, class_needed.x );
436  aListCtrl->SetRowItems( row, (*i)->net, (*i)->clazz );
437  }
438 
439  int margin = sDC.GetTextExtent( wxT( "XX" ) ).x;
440  aListCtrl->SetColumnWidth( 0, net_colsize + margin );
441  aListCtrl->SetColumnWidth( 1, class_colsize + margin );
442  aListCtrl->Refresh();
443 }
444 
445 
446 /* Populates combo boxes with the list of existing net classes
447  */
449 {
450  m_rightClassChoice->Clear();
451  m_leftClassChoice->Clear();
452 
453  m_rightClassChoice->Append( wildCard );
454  m_leftClassChoice->Append( wildCard );
455 
456  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
457  {
458  m_rightClassChoice->Append( m_grid->GetRowLabelValue( ii ) );
459  m_leftClassChoice->Append( m_grid->GetRowLabelValue( ii ) );
460  }
461 
462  m_rightClassChoice->Select( 0 );
463  m_leftClassChoice->Select( 0 );
464 
465  m_buttonRightToLeft->Enable( false );
466  m_buttonLeftToRight->Enable( false );
467 
468  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
470 }
471 
472 
473 /* Initialize the rules list from board
474  */
475 
476 static void class2gridRow( wxGrid* grid, int row, const NETCLASSPTR& nc )
477 {
478  wxString msg;
479 
480  // label is netclass name
481  grid->SetRowLabelValue( row, nc->GetName() );
482 
483  msg = StringFromValue( g_UserUnit, nc->GetClearance() );
484  grid->SetCellValue( row, GRID_CLEARANCE, msg );
485 
486  msg = StringFromValue( g_UserUnit, nc->GetTrackWidth() );
487  grid->SetCellValue( row, GRID_TRACKSIZE, msg );
488 
489  msg = StringFromValue( g_UserUnit, nc->GetViaDiameter() );
490  grid->SetCellValue( row, GRID_VIASIZE, msg );
491 
492  msg = StringFromValue( g_UserUnit, nc->GetViaDrill() );
493  grid->SetCellValue( row, GRID_VIADRILL, msg );
494 
495  msg = StringFromValue( g_UserUnit, nc->GetuViaDiameter() );
496  grid->SetCellValue( row, GRID_uVIASIZE, msg );
497 
498  msg = StringFromValue( g_UserUnit, nc->GetuViaDrill() );
499  grid->SetCellValue( row, GRID_uVIADRILL, msg );
500 
501  msg = StringFromValue( g_UserUnit, nc->GetDiffPairGap() );
502  grid->SetCellValue( row, GRID_DIFF_PAIR_GAP, msg );
503 
504  msg = StringFromValue( g_UserUnit, nc->GetDiffPairWidth() );
505  grid->SetCellValue( row, GRID_DIFF_PAIR_WIDTH, msg );
506 
507 }
508 
509 
511 {
512  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
513 
514  // the +1 is for the Default NETCLASS.
515  if( netclasses.GetCount() + 1 > (unsigned) m_grid->GetNumberRows() )
516  {
517  m_grid->AppendRows( netclasses.GetCount() + 1 - m_grid->GetNumberRows() );
518  }
519 
520  // enter the Default NETCLASS.
521  class2gridRow( m_grid, 0, netclasses.GetDefault() );
522 
523  // enter others netclasses
524  int row = 1;
525 
526  for( NETCLASSES::iterator i = netclasses.begin(); i!=netclasses.end(); ++i, ++row )
527  {
528  NETCLASSPTR netclass = i->second;
529 
530  class2gridRow( m_grid, row, netclass );
531  }
532 }
533 
534 
535 static void gridRow2class( wxGrid* grid, int row, const NETCLASSPTR& nc )
536 {
537 #define MYCELL( col ) \
538  ValueFromString( g_UserUnit, grid->GetCellValue( row, col ) )
539 
540  nc->SetClearance( MYCELL( GRID_CLEARANCE ) );
541  nc->SetTrackWidth( MYCELL( GRID_TRACKSIZE ) );
542  nc->SetViaDiameter( MYCELL( GRID_VIASIZE ) );
543  nc->SetViaDrill( MYCELL( GRID_VIADRILL ) );
544  nc->SetuViaDiameter( MYCELL( GRID_uVIASIZE ) );
545  nc->SetuViaDrill( MYCELL( GRID_uVIADRILL ) );
546  nc->SetDiffPairGap( MYCELL( GRID_DIFF_PAIR_GAP ) );
547  nc->SetDiffPairWidth( MYCELL( GRID_DIFF_PAIR_WIDTH ) );
548 
549 }
550 
551 
553 {
554  // Commit any pending in-place edits first
555  m_grid->SaveEditControlValue();
556 
557  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
558 
559  // Remove all netclasses from board. We'll copy new list after
560  netclasses.Clear();
561 
562  // Copy the default NetClass:
563  gridRow2class( m_grid, 0, netclasses.GetDefault() );
564 
565  // Copy other NetClasses :
566  for( int row = 1; row < m_grid->GetNumberRows(); ++row )
567  {
568  NETCLASSPTR nc = std::make_shared<NETCLASS>( m_grid->GetRowLabelValue( row ) );
569 
570  if( !m_BrdSettings->m_NetClasses.Add( nc ) )
571  {
572  // this netclass cannot be added because an other netclass with the same name exists
573  // Should not occur because OnAddNetclassClick() tests for existing NetClass names
574  wxString msg;
575  msg.Printf( wxT( "CopyRulesListToBoard(): The NetClass \"%s\" already exists. Skip" ),
576  GetChars( m_grid->GetRowLabelValue( row ) ) );
577  wxMessageBox( msg );
578 
579  continue;
580  }
581 
582  gridRow2class( m_grid, row, nc );
583  }
584 
585  // Now read all nets and push them in the corresponding netclass net buffer
586  for( NETCUPS::const_iterator netcup = m_AllNets.begin(); netcup != m_AllNets.end(); ++netcup )
587  {
588  NETCLASSPTR nc = netclasses.Find( netcup->clazz );
589  wxASSERT( nc );
590  nc->Add( netcup->net );
591  }
592 
594 }
595 
596 
598 {
600 
601  // Update vias minimum values for DRC
604 
606 
607  // Update microvias minimum values for DRC
610 
611  // Update tracks minimum values for DRC
613 }
614 
615 
617 {
618  wxString msg;
619 
620  // Commit any pending in-place edits from grid controls
621  m_gridTrackWidthList->SaveEditControlValue();
622  m_gridViaSizeList->SaveEditControlValue();
623 
624  // Reinitialize m_TrackWidthList
625  m_TracksWidthList.clear();
626 
627  for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
628  {
629  msg = m_gridTrackWidthList->GetCellValue( row, 0 );
630 
631  if( msg.IsEmpty() )
632  continue;
633 
634  int value = ValueFromString( g_UserUnit, msg );
635  m_TracksWidthList.push_back( value );
636  }
637 
638  // Sort new list by by increasing value
639  sort( m_TracksWidthList.begin(), m_TracksWidthList.end() );
640 
641  // Reinitialize m_ViasDimensionsList
642  m_ViasDimensionsList.clear();
643 
644  for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
645  {
646  msg = m_gridViaSizeList->GetCellValue( row, 0 );
647 
648  if( msg.IsEmpty() )
649  continue;
650 
651  int value = ValueFromString( g_UserUnit, msg );
652  VIA_DIMENSION via_dim;
653  via_dim.m_Diameter = value;
654  msg = m_gridViaSizeList->GetCellValue( row, 1 );
655 
656  if( !msg.IsEmpty() )
657  {
658  value = ValueFromString( g_UserUnit, msg );
659  via_dim.m_Drill = value;
660  }
661 
662  m_ViasDimensionsList.push_back( via_dim );
663  }
664 
665  // Sort new list by by increasing value
666  sort( m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
667 
668  std::vector<int>* tlist = &m_BrdSettings->m_TrackWidthList;
669 
670  // Remove old "custom" sizes
671  tlist->erase( tlist->begin() + 1, tlist->end() );
672 
673  // Add new "custom" sizes
674  tlist->insert( tlist->end(), m_TracksWidthList.begin(), m_TracksWidthList.end() );
675 
676  // Reinitialize m_ViaSizeList
677  std::vector<VIA_DIMENSION>* vialist = &m_BrdSettings->m_ViasDimensionsList;
678  vialist->erase( vialist->begin() + 1, vialist->end() );
679  vialist->insert( vialist->end(), m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
680 }
681 
682 
683 void DIALOG_DESIGN_RULES::OnNotebookPageChanged( wxNotebookEvent& event )
684 {
685  s_LastTabSelection = event.GetSelection();
686 
687  // Skip() allows OSX to properly refresh controls.
688  event.Skip();
689 }
690 
691 
693 {
694  if( !wxDialog::TransferDataFromWindow() )
695  return false;
696 
697  wxString errorMsg;
698 
699  if( !TestDataValidity( &errorMsg ) )
700  {
701  HTML_MESSAGE_BOX dlg( this, _( "Design Rule Setting Error" ) );
702  dlg.MessageSet( errorMsg );
703  dlg.ShowModal();
704  return false;
705  }
706 
711  return true;
712 }
713 
714 
715 void DIALOG_DESIGN_RULES::OnAddNetclassClick( wxCommandEvent& event )
716 {
717  wxString class_name;
718 
719  // @todo set validator to ensure net class name is valid rather than all of the checks
720  // after the OK button has been selected.
721  wxTextEntryDialog dlg( this, _( "New Net Class Name:" ), wxEmptyString, class_name );
722 
723  if( dlg.ShowModal() != wxID_OK )
724  return; // canceled by user
725 
726  class_name = dlg.GetValue();
727  class_name.Trim( true );
728  class_name.Trim( false );
729 
730  if( class_name.IsEmpty() )
731  return; // empty name not allowed
732 
733  // The name must dot exists:
734  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
735  {
736  wxString value;
737  value = m_grid->GetRowLabelValue( ii );
738 
739  if( class_name.CmpNoCase( value ) == 0 ) // Already exists!
740  {
741  DisplayError( this, _( "Duplicate net class names are not allowed." ) );
742  return;
743  }
744  }
745 
746  m_grid->AppendRows();
747  m_grid->SetRowLabelValue( m_grid->GetNumberRows() - 1, class_name );
748 
749  // Copy values of the default class:
750  int irow = m_grid->GetNumberRows() - 1;
751 
752  for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
753  {
754  wxString value;
755  value = m_grid->GetCellValue( 0, icol );
756  m_grid->SetCellValue( irow, icol, value );
757  }
758 
760 
762 }
763 
764 
765 // Sort function for wxArrayInt. Items (ints) are sorted by decreasing value
766 // used in DIALOG_DESIGN_RULES::OnRemoveNetclassClick
767 int sort_int( int* first, int* second )
768 {
769  return *second - *first;
770 }
771 
772 
773 void DIALOG_DESIGN_RULES::OnRemoveNetclassClick( wxCommandEvent& event )
774 {
775  wxArrayInt select = m_grid->GetSelectedRows();
776 
777  // Sort selection by decreasing index order:
778  select.Sort( sort_int );
779  bool reinit = false;
780 
781  // rows labels are not removed when deleting rows: they are not deleted.
782  // So we must store them, remove corresponding labels and reinit them
783  wxArrayString labels;
784 
785  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
786  labels.Add( m_grid->GetRowLabelValue( ii ) );
787 
788  // Delete rows from last to first (this is the order wxArrayInt select after sorting) )
789  // This order is Ok when removing rows
790  for( unsigned ii = 0; ii < select.GetCount(); ii++ )
791  {
792  int grid_row = select[ii];
793 
794  if( grid_row != 0 ) // Do not remove the default class
795  {
796  wxString classname = m_grid->GetRowLabelValue( grid_row );
797  m_grid->DeleteRows( grid_row );
798  labels.RemoveAt( grid_row ); // Remove corresponding row label
799  reinit = true;
800 
801  // reset the net class to default for members of the removed class
802  swapNetClass( classname, NETCLASS::Default );
803  }
804  else
805  wxMessageBox( _( "The default net class cannot be removed" ) );
806  }
807 
808  if( reinit )
809  {
810  // Reinit labels :
811  for( unsigned ii = 1; ii < labels.GetCount(); ii++ )
812  m_grid->SetRowLabelValue( ii, labels[ii] );
813 
816  }
817 }
818 
820 {
821  bool enabled = m_OptAllowMicroVias->GetValue();
822  m_SetMicroViasMinSizeCtrl->Enable( enabled );
823  m_SetMicroViasMinDrillCtrl->Enable( enabled );
824 }
825 
830 void DIALOG_DESIGN_RULES::OnAllowMicroVias( wxCommandEvent& event )
831 {
833 }
834 
836 {
837  // Cannot move up rules if we have 1 or 2 rules only
838  if( m_grid->GetNumberRows() < 3 )
839  return;
840 
841  wxArrayInt select = m_grid->GetSelectedRows();
842  bool reinit = false;
843 
844  for( unsigned irow = 0; irow < select.GetCount(); irow++ )
845  {
846  int ii = select[irow];
847  if( ii < 2 ) // The default netclass *must* be the first netclass
848  continue; // so we cannot move up line 0 and 1
849 
850  // Swap the rule and the previous rule
851  wxString curr_value, previous_value;
852 
853  for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
854  {
855  reinit = true;
856  curr_value = m_grid->GetCellValue( ii, icol );
857  previous_value = m_grid->GetCellValue( ii - 1, icol );
858  m_grid->SetCellValue( ii, icol, previous_value );
859  m_grid->SetCellValue( ii - 1, icol, curr_value );
860  }
861 
862  curr_value = m_grid->GetRowLabelValue( ii );
863  previous_value = m_grid->GetRowLabelValue( ii - 1 );
864  m_grid->SetRowLabelValue( ii, previous_value );
865  m_grid->SetRowLabelValue( ii - 1, curr_value );
866  }
867 
868  if( reinit )
870 }
871 
872 
873 void DIALOG_DESIGN_RULES::OnLeftCBSelection( wxCommandEvent& event )
874 {
875  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
876 
877  if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
878  {
879  m_buttonRightToLeft->Enable( false );
880  m_buttonLeftToRight->Enable( false );
881  }
882  else
883  {
884  m_buttonRightToLeft->Enable( true );
885  m_buttonLeftToRight->Enable( true );
886  }
887 }
888 
889 
890 void DIALOG_DESIGN_RULES::OnRightCBSelection( wxCommandEvent& event )
891 {
893 
894  if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
895  {
896  m_buttonRightToLeft->Enable( false );
897  m_buttonLeftToRight->Enable( false );
898  }
899  else
900  {
901  m_buttonRightToLeft->Enable( true );
902  m_buttonLeftToRight->Enable( true );
903  }
904 }
905 
906 
907 void DIALOG_DESIGN_RULES::moveSelectedItems( NETS_LIST_CTRL* src, const wxString& newClassName )
908 {
909  wxListItem item;
910  wxString netName;
911 
912  item.m_mask |= wxLIST_MASK_TEXT; // Validate the member m_text of the wxListItem item
913 
914  for( int row = 0; row < src->GetItemCount(); ++row )
915  {
916  if( !src->GetItemState( row, wxLIST_STATE_SELECTED ) )
917  continue;
918 
919  item.SetColumn( 0 );
920  item.SetId( row );
921 
922  src->GetItem( item );
923  netName = item.GetText();
924 
925  setNetClass( netName, newClassName == wildCard ? NETCLASS::Default : newClassName );
926  }
927 }
928 
929 
930 void DIALOG_DESIGN_RULES::OnRightToLeftCopyButton( wxCommandEvent& event )
931 {
932  wxString newClassName = m_leftClassChoice->GetStringSelection();
933 
934  moveSelectedItems( m_rightListCtrl, newClassName );
935 
936  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
938 }
939 
940 
941 void DIALOG_DESIGN_RULES::OnLeftToRightCopyButton( wxCommandEvent& event )
942 {
943  wxString newClassName = m_rightClassChoice->GetStringSelection();
944 
945  moveSelectedItems( m_leftListCtrl, newClassName );
946 
947  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
949 }
950 
951 
952 void DIALOG_DESIGN_RULES::OnLeftSelectAllButton( wxCommandEvent& event )
953 {
954  for( int ii = 0; ii < m_leftListCtrl->GetItemCount(); ii++ )
955  m_leftListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
956 }
957 
958 
959 void DIALOG_DESIGN_RULES::OnRightSelectAllButton( wxCommandEvent& event )
960 {
961  for( int ii = 0; ii < m_rightListCtrl->GetItemCount(); ii++ )
962  m_rightListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
963 }
964 
965 
966 void DIALOG_DESIGN_RULES::setNetClass( const wxString& aNetName, const wxString& aClassName )
967 {
968  for( NETCUPS::iterator i = m_AllNets.begin(); i != m_AllNets.end(); ++i )
969  {
970  if( i->net == aNetName )
971  {
972  i->clazz = aClassName;
973  break;
974  }
975  }
976 }
977 
978 
979 bool DIALOG_DESIGN_RULES::TestDataValidity( wxString* aErrorMsg )
980 {
981  bool result = true;
982 
983  wxString msg;
984  wxString errorMsg;
985 
986  wxString netclassLabel; // Name of a given netclass
987  wxString netclassError; // Error message particular to a given netclass
988 
989  wxString units = ReturnUnitSymbol( g_UserUnit, "%s" );
990 
991  int minViaDia = ValueFromTextCtrl( *m_SetViasMinSizeCtrl );
992  int minViaDrill = ValueFromTextCtrl( *m_SetViasMinDrillCtrl );
993  int minUViaDia = ValueFromTextCtrl( *m_SetMicroViasMinSizeCtrl );
994  int minUViaDrill = ValueFromTextCtrl( *m_SetMicroViasMinDrillCtrl );
995  int minTrackWidth = ValueFromTextCtrl( *m_SetTrackMinWidthCtrl );
996  int maxval = 1000 * IU_PER_MILS; // a max value for tracks and vias sizes (1 inch)
997 
998  // @todo Change this code to set the focus to the control where the first error occurs
999  // so the user doesn't have to figure out where the issue is.
1000 
1001  // Test net class parameters.
1002  for( int row = 0; row < m_grid->GetNumberRows(); row++ )
1003  {
1004  netclassLabel = GetChars( m_grid->GetRowLabelValue( row ) );
1005  netclassError.Clear(); // Clear the error for this netclass
1006 
1007  int tracksize = ValueFromString( g_UserUnit,
1008  m_grid->GetCellValue( row, GRID_TRACKSIZE ) );
1009  if( tracksize < minTrackWidth )
1010  {
1011  result = false;
1012  msg.Printf( _( " - <b>Track Size</b> (%f %s) &lt; <b>Min Track Size</b> (%f %s)<br>" ),
1013  To_User_Unit( g_UserUnit, tracksize ), units,
1014  To_User_Unit( g_UserUnit, minTrackWidth ), units );
1015 
1016  netclassError += msg;
1017  }
1018 
1019  int dpsize = ValueFromString( g_UserUnit,
1020  m_grid->GetCellValue( row, GRID_DIFF_PAIR_WIDTH ) );
1021 
1022  if( dpsize < minTrackWidth )
1023  {
1024  result = false;
1025  msg.Printf( _( " - <b>Differential Pair Size</b> (%f %s) &lt; <b>Min Track Size</b> (%f %s)<br>" ),
1026  To_User_Unit( g_UserUnit, dpsize ), units,
1027  To_User_Unit( g_UserUnit, minTrackWidth ), units );
1028  netclassError += msg;
1029  }
1030 
1031 
1032  // Test vias
1033  int viadia = ValueFromString( g_UserUnit,
1034  m_grid->GetCellValue( row, GRID_VIASIZE ) );
1035 
1036  if( viadia < minViaDia )
1037  {
1038  result = false;
1039  msg.Printf( _( " - <b>Via Diameter</b> (%f %s) &lt; <b>Minimum Via Diameter</b> (%f %s)<br>" ),
1040  To_User_Unit( g_UserUnit, viadia ), units,
1041  To_User_Unit( g_UserUnit, minViaDia ), units );
1042  netclassError += msg;
1043  }
1044 
1045  int viadrill = ValueFromString( g_UserUnit,
1046  m_grid->GetCellValue( row, GRID_VIADRILL ) );
1047 
1048  if( viadrill >= viadia )
1049  {
1050  result = false;
1051  msg.Printf( _( " - <b>Via Drill</b> (%f %s) &ge; <b>Via Dia</b> (%f %s)<br>" ),
1052  To_User_Unit( g_UserUnit, viadrill ), units,
1053  To_User_Unit( g_UserUnit, viadia ), units );
1054  netclassError += msg;
1055  }
1056 
1057  if( viadrill < minViaDrill )
1058  {
1059  result = false;
1060  msg.Printf( _( " - <b>Via Drill</b> (%f %s) &lt; <b>Min Via Drill</b> (%f %s)<br>" ),
1061  To_User_Unit( g_UserUnit, viadrill ), units,
1062  To_User_Unit( g_UserUnit, minViaDrill ), units );
1063  netclassError += msg;
1064  }
1065 
1066  // Test Micro vias
1067  int muviadia = ValueFromString( g_UserUnit,
1068  m_grid->GetCellValue( row, GRID_uVIASIZE ) );
1069 
1070  if( muviadia < minUViaDia )
1071  {
1072  result = false;
1073  msg.Printf( _( " - <b>MicroVia Diameter</b> (%f %s) &lt; <b>MicroVia Min Diameter</b> (%f %s)<br>" ),
1074  To_User_Unit( g_UserUnit, muviadia ), units,
1075  To_User_Unit( g_UserUnit, minUViaDia ), units );
1076  netclassError += msg;
1077  }
1078 
1079  int muviadrill = ValueFromString( g_UserUnit,
1080  m_grid->GetCellValue( row, GRID_uVIADRILL ) );
1081 
1082  if( muviadrill >= muviadia )
1083  {
1084  result = false;
1085  msg.Printf( _( " - <b>MicroVia Drill</b> (%f %s) &ge; <b>MicroVia Dia</b> (%f %s)<br>" ),
1086  To_User_Unit( g_UserUnit, muviadrill ), units,
1087  To_User_Unit( g_UserUnit, muviadia ), units );
1088  netclassError += msg;
1089  }
1090 
1091  if( muviadrill < minUViaDrill )
1092  {
1093  result = false;
1094  msg.Printf( _( " - <b>MicroVia Drill</b> (%f %s) &lt; <b>MicroVia Min Drill</b> (%f %s)<br>" ),
1095  To_User_Unit( g_UserUnit, muviadrill ), units,
1096  To_User_Unit( g_UserUnit, minUViaDrill ), units );
1097  netclassError += msg;
1098  }
1099 
1100  // If this netclass contains errors, add it to the error message
1101  if ( !netclassError.IsEmpty() )
1102  {
1103  msg.Printf( _( "Netclass: <b>%s</b><br>" ), netclassLabel );
1104  errorMsg += msg;
1105  errorMsg += netclassError;
1106  errorMsg += "<br>";
1107  }
1108  }
1109 
1110  // Test custom tracks
1111  for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
1112  {
1113  wxString tvalue = m_gridTrackWidthList->GetCellValue( row, 0 );
1114 
1115  if( tvalue.IsEmpty() )
1116  continue;
1117 
1118  int tracksize = ValueFromString( g_UserUnit, tvalue );
1119 
1120  if( tracksize < minTrackWidth )
1121  {
1122  result = false;
1123  msg.Printf( _( "<b>Extra Track %d Size</b> %s &lt; <b>Min Track Size</b><br>" ),
1124  row + 1, GetChars( tvalue ) );
1125 
1126  errorMsg += msg;
1127  }
1128 
1129  if( tracksize > maxval )
1130  {
1131  result = false;
1132  msg.Printf( _( "<b>Extra Track %d Size</b> %s &gt; <b>1 inch!</b><br>" ),
1133  row + 1, GetChars( tvalue ) );
1134 
1135  errorMsg += msg;
1136  }
1137  }
1138 
1139  // Test custom vias
1140  for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
1141  {
1142  wxString tvalue = m_gridViaSizeList->GetCellValue( row, 0 );
1143 
1144  if( tvalue.IsEmpty() )
1145  continue;
1146 
1147  int viadia = ValueFromString( g_UserUnit, tvalue );
1148 
1149  if( viadia < minViaDia )
1150  {
1151  result = false;
1152  msg.Printf( _( "<b>Extra Via %d Size</b> %s &lt; <b>Min Via Size</b><br>" ),
1153  row + 1, GetChars( tvalue ) );
1154  errorMsg += msg;
1155  }
1156 
1157  wxString drlvalue = m_gridViaSizeList->GetCellValue( row, 1 );
1158 
1159  if( drlvalue.IsEmpty() )
1160  {
1161  result = false;
1162  msg.Printf( _( "<b>No via drill size define in row %d</b><br>" ), row + 1 );
1163  errorMsg += msg;
1164  continue;
1165  }
1166 
1167  int viadrill = ValueFromString( g_UserUnit, drlvalue );
1168 
1169  if( viadrill < minViaDrill )
1170  {
1171  result = false;
1172  msg.Printf( _( "<b>Extra Via %d Drill</b> %s &lt; <b>Min Via Drill %s</b><br>" ),
1173  row + 1, GetChars( drlvalue ),
1174  GetChars( m_SetViasMinDrillCtrl->GetValue() ) );
1175  errorMsg += msg;
1176  }
1177 
1178  if( viadia <= viadrill )
1179  {
1180  result = false;
1181  msg.Printf( _( "<b>Extra Via %d Size</b> %s &le; <b> Drill Size</b> %s<br>" ),
1182  row + 1, GetChars( tvalue ), GetChars( drlvalue ) );
1183  errorMsg += msg;
1184  }
1185 
1186  // Test for a reasonable via size:
1187  if( viadia > maxval ) // 1 inch!
1188  {
1189  result = false;
1190  msg.Printf( _( "<b>Extra Via %d Size</b>%s &gt; <b>1 inch!</b><br>" ),
1191  row + 1, GetChars( tvalue ) );
1192  errorMsg += msg;
1193  }
1194  }
1195 
1196  if( !result && aErrorMsg )
1197  *aErrorMsg = errorMsg;
1198 
1199  return result;
1200 }
void OnNotebookPageChanged(wxNotebookEvent &event) override
std::vector< int > m_TracksWidthList
Struct VIA_DIMENSION is a small helper container to handle a stock of specific vias each with unique ...
static void EnsureGridRowTitleWidth(wxWindow *aShower, wxGrid *aGrid, int aMinWidth)
virtual bool TransferDataFromWindow() override
NETCLASSPTR Find(const wxString &aName) const
Function Find searches this container for a NETCLASS given by aName.
Definition: netclass.cpp:144
void OnLeftToRightCopyButton(wxCommandEvent &event) override
Implementation of conversion functions that require both schematic and board internal units...
This file is part of the common library.
wxString clazz
a class name
std::vector< int > m_TrackWidthList
Track width list.
void InitRulesList()
Function InitRulesList Fill the grid showing current rules with values.
wxString ReturnUnitSymbol(EDA_UNITS_T aUnit, const wxString &formatString)
Returns the units symbol.
Definition: base_units.cpp:425
static bool sortByClassThenName(NETCUP *a, NETCUP *b)
void swapNetClass(const wxString &oldClass, const wxString &newClass)
Function swapNetClass replaces one net class name with another in the master list, m_AllNets.
wxString StringFromValue(EDA_UNITS_T aUnit, int aValue, bool aAddUnitSymbol)
Function StringFromValue returns the string from aValue according to units (inch, mm ...
Definition: base_units.cpp:204
void FinishDialogSettings()
In all dialogs, we must call the same functions to fix minimal dlg size, the default position and per...
void moveSelectedItems(NETS_LIST_CTRL *src, const wxString &newClassName)
std::vector< NETCUP * > PNETCUPS
BOARD * GetBoard() const
void OnMoveUpSelectedNetClass(wxCommandEvent &event) override
#define NET_TITLE
iterator end()
Definition: netclass.h:256
static void class2gridRow(wxGrid *grid, int row, const NETCLASSPTR &nc)
std::vector< VIA_DIMENSION > m_ViasDimensionsList
void OnRemoveNetclassClick(wxCommandEvent &event) override
static void gridRow2class(wxGrid *grid, int row, const NETCLASSPTR &nc)
void OnRightSelectAllButton(wxCommandEvent &event) override
NETCLASS_MAP::const_iterator const_iterator
Definition: netclass.h:258
PCB_EDIT_FRAME * m_Parent
Functions relatives to tracks, vias and segments used to fill zones.
This file contains miscellaneous commonly used macros and functions.
void OnRightCBSelection(wxCommandEvent &event) override
#define TO_UTF8(wxstring)
Macro TO_UTF8 converts a wxString to a UTF8 encoded C string for all wxWidgets build modes...
Definition: macros.h:47
void SynchronizeNetsAndNetClasses()
Function SynchronizeNetsAndNetClasses copies NETCLASS info to each NET, based on NET membership in a ...
Definition: netclass.cpp:158
NETCLASS_MAP::iterator iterator
Definition: netclass.h:254
int sort_int(int *first, int *second)
Class DIALOG_DESIGN_RULES_BASE.
STRINGSET::iterator iterator
Definition: netclass.h:141
bool TestDataValidity(wxString *aErrorMsg=NULL)
iterator begin()
Definition: netclass.h:255
Class NETCLASSES is a container for NETCLASS instances.
Definition: netclass.h:231
static const char Default[]
the name of the default NETCLASS
Definition: netclass.h:90
Class NETS_LIST_CTRL is a helper to display lists of nets and associated netclasses used in dialog de...
int m_TrackMinWidth
track min value for width ((min copper size value
int m_ViasMinSize
vias (not micro vias) min diameter
wxString GetAbbreviatedUnitsLabel(EDA_UNITS_T aUnit)
Definition: base_units.cpp:484
Subclass of DIALOG_DISPLAY_HTML_TEXT_BASE, which is generated by wxFormBuilder.
int m_ViasMinDrill
vias (not micro vias) min drill diameter
int ValueFromString(EDA_UNITS_T aUnits, const wxString &aTextValue)
Function ValueFromString converts aTextValue in aUnits to internal units used by the application...
Definition: base_units.cpp:369
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
int m_initialRowLabelsSize
the initial width given by wxFormBuilder
void OnAddNetclassClick(wxCommandEvent &event) override
bool m_BlindBuriedViaAllowed
true to allow blind/buried vias
Class HTML_MESSAGE_BOX.
void makePointers(PNETCUPS *aList, const wxString &aNetClassName)
int m_MicroViasMinSize
micro vias (not vias) min diameter
wxArrayString m_Classnames
column 1: netclasses
int ValueFromTextCtrl(const wxTextCtrl &aTextCtr)
Convert the number Value in a string according to the internal units and the selected unit (g_UserUni...
Definition: base_units.cpp:385
wxString net
a net name
void OnAllowMicroVias(wxCommandEvent &event) override
Function OnAllowMicroVias is called whenever the AllowMicroVias checkbox is toggled.
void MessageSet(const wxString &message)
Function MessageSet adds a message (in bold) to message list.
void OnLeftCBSelection(wxCommandEvent &event) override
unsigned GetCount() const
Function GetCount.
Definition: netclass.h:266
EDA_UNITS_T g_UserUnit
Global variables definitions.
Definition: common.cpp:56
static const wxString wildCard
the name of a fictitious netclass which includes all NETs
#define CLASS_TITLE
bool Add(const NETCLASSPTR &aNetclass)
Function Add takes aNetclass and puts it into this NETCLASSES container.
Definition: netclass.cpp:102
void PutValueInLocalUnits(wxTextCtrl &aTextCtr, int aValue)
Function PutValueInLocalUnits converts aValue from internal units to user units and append the units ...
Definition: base_units.cpp:266
void SetRowItems(unsigned aRow, const wxString &aNetname, const wxString &aNetclassName)
Function SetRowItems sets the net name and the net class name at aRow.
void OnRightToLeftCopyButton(wxCommandEvent &event) override
static void EnsureGridColumnWidths(wxWindow *aShower, wxGrid *aGrid)
Function EnsureGridColumnWidths resizes all the columns in a wxGrid based only on the requirements of...
BOARD_DESIGN_SETTINGS * m_BrdSettings
void setNetClass(const wxString &aNetName, const wxString &aClassName)
bool SetCurrentNetClass(const wxString &aNetClassName)
Function SetCurrentNetClass Must be called after a netclass selection (or after a netclass parameter ...
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
void Clear()
Function Clear destroys any contained NETCLASS instances except the Default one.
Definition: netclass.h:249
const char * name
Definition: DXF_plotter.cpp:61
void OnLeftSelectAllButton(wxCommandEvent &event) override
#define max(a, b)
Definition: auxiliary.h:86
NETCLASSPTR GetDefault() const
Function GetDefault.
Definition: netclass.h:275
static int s_LastTabSelection
which tab user had open last
void FillListBoxWithNetNames(NETS_LIST_CTRL *aListCtrl, const wxString &aNetClass)
Function FillListBoxWithNetNames populates aListCtrl with net names and class names from m_AllNets in...
std::vector< VIA_DIMENSION > m_ViasDimensionsList
Vias size and drill list.
STRINGSET::const_iterator const_iterator
Definition: netclass.h:145
double To_User_Unit(EDA_UNITS_T aUnit, double aValue)
Function To_User_Unit convert aValue in internal units to the appropriate user units defined by aUnit...
Definition: base_units.cpp:91
NETCUPS m_AllNets
A two column table which gets filled once and never loses any elements, so it is basically constant...
bool m_MicroViasAllowed
true to allow micro vias
int m_MicroViasMinDrill
micro vias (not vias) min drill diameter
virtual wxString OnGetItemText(long item, long column) const override
Function OnGetItemText is an overloaded method needed by wxListCtrl with wxLC_VIRTUAL options...
#define MYCELL(col)
void DisplayError(wxWindow *parent, const wxString &text, int displaytime)
Function DisplayError displays an error or warning message box with aMessage.
Definition: confirm.cpp:74
wxArrayString m_Netnames
column 0: nets
DIALOG_DESIGN_RULES(PCB_EDIT_FRAME *parent)
NETCLASSES m_NetClasses
List of current netclasses. There is always the default netclass.