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 #include <dialog_text_entry.h>
46 
47 #include <dialog_design_rules.h>
48 #include <wx/generic/gridctrl.h>
50 
51 #include <tool/tool_event.h>
52 #include <tool/tool_manager.h>
53 
54 // Column labels for net lists
55 #define NET_TITLE _( "Net" )
56 #define CLASS_TITLE _( "Class" )
57 
58 // Field Positions on rules grid
59 enum {
68 };
69 
70 const wxString DIALOG_DESIGN_RULES::wildCard = _( "* (Any)" );
71 
72 // dialog should remember its previously selected tab
74 
75 // methods for the helper class NETS_LIST_CTRL
76 
77 wxString NETS_LIST_CTRL::OnGetItemText( long item, long column ) const
78 {
79  if( column == 0 )
80  {
81  if( item < (long) m_Netnames.GetCount() )
82  return m_Netnames[item];
83  else
84  return wxEmptyString;
85  }
86  else if( item < (long) m_Classnames.GetCount() )
87  return m_Classnames[item];
88 
89  return wxEmptyString;
90 }
91 
92 
93 void NETS_LIST_CTRL::SetRowItems( unsigned aRow,
94  const wxString& aNetname,
95  const wxString& aNetclassName )
96 {
97  // insert blanks if aRow is larger than existing row count
98  unsigned cnt = m_Netnames.GetCount();
99 
100  if( cnt <= aRow )
101  m_Netnames.Add( wxEmptyString, aRow - cnt + 1 );
102 
103  cnt = m_Classnames.GetCount();
104 
105  if( cnt <= aRow )
106  m_Classnames.Add( wxEmptyString, aRow - cnt + 1 );
107 
108  if( (int)aRow <= GetItemCount() )
109  SetItemCount( aRow + 1 );
110 
111  m_Netnames[aRow] = aNetname;
112  m_Classnames[aRow] = aNetclassName;
113 }
114 
115 
123 // @todo: maybe move this to common.cpp if it works.
124 static void EnsureGridColumnWidths( wxWindow* aShower, wxGrid* aGrid )
125 {
126  wxWindowDC sDC( aShower );
127 
128  sDC.SetFont( aGrid->GetLabelFont() );
129 
130  int colCount = aGrid->GetNumberCols();
131 
132  for( int col = 0; col < colCount; ++col )
133  {
134  // add two spaces to the text and size it.
135  wxString colText = aGrid->GetColLabelValue( col ) + wxT( " " );
136 
137  wxSize needed = sDC.GetTextExtent( colText );
138 
139  // set the width of this column
140  aGrid->SetColSize( col, needed.x );
141  }
142 }
143 
144 static void EnsureGridRowTitleWidth( wxWindow* aShower, wxGrid* aGrid, int aMinWidth )
145 {
146  wxWindowDC sDC( aShower );
147  sDC.SetFont( aGrid->GetLabelFont() );
148 
149  int minsize = aMinWidth;
150  int rowCount = aGrid->GetNumberRows();
151 
152  for( int row = 0; row < rowCount; ++row )
153  {
154  // add two spaces to the text and size it.
155  wxString rowText = aGrid->GetRowLabelValue( row ) + wxT( " " );
156 
157  wxSize needed = sDC.GetTextExtent( rowText );
158 
159  minsize = std::max( minsize, needed.x );
160  }
161 
162  // set the width of the row laberls
163  aGrid->SetRowLabelSize( minsize );
164 }
165 
166 
168  DIALOG_DESIGN_RULES_BASE( parent )
169 {
170  m_Parent = parent;
171  SetAutoLayout( true );
172 
173  m_initialRowLabelsSize = m_grid->GetRowLabelSize();
174  EnsureGridColumnWidths( this, m_grid ); // override any column widths set by wxformbuilder.
175 
176  wxListItem column0;
177  wxListItem column1;
178 
179  column0.Clear();
180  column1.Clear();
181 
182  column0.SetMask( wxLIST_MASK_TEXT );
183  column1.SetMask( wxLIST_MASK_TEXT );
184 
185  column0.SetText( NET_TITLE );
186  column1.SetText( CLASS_TITLE );
187 
189 
190  m_leftListCtrl->InsertColumn( 0, column0 );
191  m_leftListCtrl->InsertColumn( 1, column1 );
192  m_leftListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
193  m_leftListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
194 
195  m_rightListCtrl->InsertColumn( 0, column0 );
196  m_rightListCtrl->InsertColumn( 1, column1 );
197  m_rightListCtrl->SetColumnWidth( 0, wxLIST_AUTOSIZE );
198  m_rightListCtrl->SetColumnWidth( 1, wxLIST_AUTOSIZE );
199 
200  // if user has been into the dialog before, go back to same tab
201  if( s_LastTabSelection != -1 )
202  {
203  m_DRnotebook->SetSelection( s_LastTabSelection );
204  }
205 
206  InitDialogRules();
208 
209  m_sdbSizer1OK->SetDefault();
210 
211  // Allow tabbing out of grid controls.
212  m_grid->SetTabBehaviour( wxGrid::Tab_Leave );
213  m_gridViaSizeList->SetTabBehaviour( wxGrid::Tab_Leave );
214  m_gridTrackWidthList->SetTabBehaviour( wxGrid::Tab_Leave );
215 
216  Layout();
217 
218  // Now all widgets have the size fixed, call FinishDialogSettings
220 }
221 
223 {
224  // Set floating-point validators for numerical inputs
225  wxFloatingPointValidator< double > fpValidator( NULL, wxNUM_VAL_ZERO_AS_BLANK | wxNUM_VAL_NO_TRAILING_ZEROES );
226 
227  int maxDimension = 1000 * IU_PER_MILS; // One-inch
228 
229  fpValidator.SetRange( 0, To_User_Unit( g_UserUnit, maxDimension ) );
230  fpValidator.SetPrecision( 10 );
231 
232  m_SetViasMinSizeCtrl->SetValidator( fpValidator );
233  m_SetViasMinDrillCtrl->SetValidator( fpValidator );
234  m_SetMicroViasMinSizeCtrl->SetValidator( fpValidator );
235  m_SetMicroViasMinDrillCtrl->SetValidator( fpValidator );
236  m_SetTrackMinWidthCtrl->SetValidator( fpValidator );
237 }
238 
239 
241 {
242  // @todo: Move the initialization code into TransferDataToWindow() to follow wxWidgets
243  // dialog data transfer convention.
244  SetFocus();
245  SetReturnCode( 0 );
246 
247  m_Pcb = m_Parent->GetBoard();
249 
250  // Initialize the Rules List
251  InitRulesList();
252 
253  // Reassure that all nets have net classes assigned
255 
256  // copy all NETs into m_AllNets by adding them as NETCUPs.
257 
258  // @todo go fix m_Pcb->SynchronizeNetsAndNetClasses() so that the netcode==0 is not
259  // present in the BOARD::m_NetClasses
260  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
261  NETCLASSPTR netclass = netclasses.GetDefault();
262 
263  // Initialize list of nets for Default Net Class
264  for( NETCLASS::iterator name = netclass->begin(); name != netclass->end(); ++name )
265  {
266  m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
267  }
268 
269  // Initialize list of nets for others (custom) Net Classes
270  for( NETCLASSES::const_iterator nc = netclasses.begin(); nc != netclasses.end(); ++nc )
271  {
272  netclass = nc->second;
273 
274  for( NETCLASS::const_iterator name = netclass->begin(); name != netclass->end(); ++name )
275  {
276  m_AllNets.push_back( NETCUP( *name, netclass->GetName() ) );
277  }
278  }
279 
281  InitGlobalRules();
282 }
283 
284 
286 {
287  // Set unit labels
288  const wxString units = GetAbbreviatedUnitsLabel( g_UserUnit );
289 
290  m_ViaMinUnits->SetLabel( units );
291  m_ViaMinDrillUnits->SetLabel( units );
292  m_MicroViaMinSizeUnits->SetLabel( units );
293  m_MicroViaMinDrillUnits->SetLabel( units );
294  m_TrackMinWidthUnits->SetLabel( units );
295 
298 
302 
306 
307  // Initialize Vias and Tracks sizes lists.
308  // note we display only extra values, never the current netclass value.
309  // (the first value in history list)
311  m_TracksWidthList.erase( m_TracksWidthList.begin() ); // remove the netclass value
313  m_ViasDimensionsList.erase( m_ViasDimensionsList.begin() ); // remove the netclass value
315 }
316 
317 
319 {
320  wxString msg;
321 
322  // Compute the column widths here, after setting texts
323  msg = wxT("000000.000000"); // This is a very long text to display values.
324  // Actual values are shorter.
325  m_gridViaSizeList->SetCellValue( 0, 0, msg );
326  m_gridViaSizeList->SetCellValue( 0, 1, msg );
327  m_gridTrackWidthList->SetCellValue( 0, 0, msg );
328  m_gridViaSizeList->SetColMinimalWidth( 0, 150 );
329  m_gridViaSizeList->SetColMinimalWidth( 1, 150 );
330  m_gridViaSizeList->AutoSizeColumns( true );
331  m_gridTrackWidthList->SetColMinimalWidth( 0, 150 );
332  m_gridTrackWidthList->AutoSizeColumns( true );
333  m_gridViaSizeList->SetColMinimalWidth( 1, 150 );
334 
335  // Fill cells with actual values:
336  m_gridViaSizeList->SetCellValue( 0, 0, wxEmptyString );
337  m_gridViaSizeList->SetCellValue( 0, 1, wxEmptyString );
338  m_gridTrackWidthList->SetCellValue( 0, 0, wxEmptyString );
339 
340  // Give a correct size to row labels column
341  m_gridViaSizeList->SetRowLabelSize( wxGRID_AUTOSIZE );
342  m_gridTrackWidthList->SetRowLabelSize( wxGRID_AUTOSIZE );
343 
344  for( unsigned ii = 0; ii < m_TracksWidthList.size(); ii++ )
345  {
346  msg = StringFromValue( g_UserUnit, m_TracksWidthList[ii], false );
347  m_gridTrackWidthList->SetCellValue( ii, 0, msg );
348  }
349 
350  for( unsigned ii = 0; ii < m_ViasDimensionsList.size(); ii++ )
351  {
352  msg = StringFromValue( g_UserUnit, m_ViasDimensionsList[ii].m_Diameter, false );
353  m_gridViaSizeList->SetCellValue( ii, 0, msg );
354 
355  if( m_ViasDimensionsList[ii].m_Drill > 0 )
356  {
357  msg = StringFromValue( g_UserUnit, m_ViasDimensionsList[ii].m_Drill, false );
358  m_gridViaSizeList->SetCellValue( ii, 1, msg );
359  }
360  }
361 }
362 
363 
364 // Sort comparison function (helper for makePointers() )
365 static bool sortByClassThenName( NETCUP* a, NETCUP* b )
366 {
367  // return a < b
368  if( a->clazz < b->clazz )
369  return true;
370 
371  // inside the same class, sort by net name:
372  if( a->clazz == b->clazz )
373  {
374  if( a->net < b->net )
375  return true;
376  }
377 
378  return false;
379 }
380 
381 
382 void DIALOG_DESIGN_RULES::makePointers( PNETCUPS* aList, const wxString& aNetClassName )
383 {
384  aList->clear();
385 
386  if( wildCard == aNetClassName )
387  {
388  for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
389  {
390  aList->push_back( &*n );
391  }
392 
393  sort( aList->begin(), aList->end(), sortByClassThenName );
394 
395  // could use a different sort order for wildCard case.
396  }
397  else
398  {
399  for( NETCUPS::iterator n = m_AllNets.begin(); n != m_AllNets.end(); ++n )
400  {
401  if( n->clazz == aNetClassName )
402  aList->push_back( &*n );
403  }
404 
405  sort( aList->begin(), aList->end(), sortByClassThenName );
406  }
407 }
408 
409 
411  const wxString& aNetClass )
412 {
413  aListCtrl->ClearList();
414 
415  PNETCUPS ptrList;
416 
417  // get a subset of m_AllNets in pointer form, sorted as desired.
418  makePointers( &ptrList, aNetClass );
419 
420 #if 0 && defined(DEBUG)
421  int r = 0;
422  for( PNETCUPS::iterator i = ptrList.begin(); i!=ptrList.end(); ++i, ++r )
423  {
424  printf( "[%d]: %s %s\n", r, TO_UTF8( (*i)->net ), TO_UTF8( (*i)->clazz ) );
425  }
426 
427 #endif
428 
429  // Add netclass info to m_Netnames and m_Classnames wxArrayString buffers
430  // aListCtrl uses wxLC_VIRTUAL option, so this is fast
431  wxClientDC sDC( aListCtrl );
432  int row = 0;
433  // recompute the column widths here, after setting texts
434  int net_colsize = sDC.GetTextExtent( NET_TITLE ).x;
435  int class_colsize = sDC.GetTextExtent( CLASS_TITLE ).x;
436 
437  for( PNETCUPS::iterator i = ptrList.begin(); i!=ptrList.end(); ++i, ++row )
438  {
439  wxSize net_needed = sDC.GetTextExtent( (*i)->net );
440  wxSize class_needed = sDC.GetTextExtent( (*i)->clazz );
441  net_colsize = std::max( net_colsize, net_needed.x );
442  class_colsize = std::max( class_colsize, class_needed.x );
443  aListCtrl->SetRowItems( row, (*i)->net, (*i)->clazz );
444  }
445 
446  int margin = sDC.GetTextExtent( wxT( "XX" ) ).x;
447  aListCtrl->SetColumnWidth( 0, net_colsize + margin );
448  aListCtrl->SetColumnWidth( 1, class_colsize + margin );
449  aListCtrl->Refresh();
450 }
451 
452 
453 /* Populates combo boxes with the list of existing net classes
454  */
456 {
457  m_rightClassChoice->Clear();
458  m_leftClassChoice->Clear();
459 
460  m_rightClassChoice->Append( wildCard );
461  m_leftClassChoice->Append( wildCard );
462 
463  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
464  {
465  m_rightClassChoice->Append( m_grid->GetRowLabelValue( ii ) );
466  m_leftClassChoice->Append( m_grid->GetRowLabelValue( ii ) );
467  }
468 
469  m_rightClassChoice->Select( 0 );
470  m_leftClassChoice->Select( 0 );
471 
472  m_buttonRightToLeft->Enable( false );
473  m_buttonLeftToRight->Enable( false );
474 
475  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
477 }
478 
479 
480 /* Initialize the rules list from board
481  */
482 
483 static void class2gridRow( wxGrid* grid, int row, const NETCLASSPTR& nc )
484 {
485  wxString msg;
486 
487  // label is netclass name
488  grid->SetRowLabelValue( row, nc->GetName() );
489 
490  msg = StringFromValue( g_UserUnit, nc->GetClearance() );
491  grid->SetCellValue( row, GRID_CLEARANCE, msg );
492 
493  msg = StringFromValue( g_UserUnit, nc->GetTrackWidth() );
494  grid->SetCellValue( row, GRID_TRACKSIZE, msg );
495 
496  msg = StringFromValue( g_UserUnit, nc->GetViaDiameter() );
497  grid->SetCellValue( row, GRID_VIASIZE, msg );
498 
499  msg = StringFromValue( g_UserUnit, nc->GetViaDrill() );
500  grid->SetCellValue( row, GRID_VIADRILL, msg );
501 
502  msg = StringFromValue( g_UserUnit, nc->GetuViaDiameter() );
503  grid->SetCellValue( row, GRID_uVIASIZE, msg );
504 
505  msg = StringFromValue( g_UserUnit, nc->GetuViaDrill() );
506  grid->SetCellValue( row, GRID_uVIADRILL, msg );
507 
508  msg = StringFromValue( g_UserUnit, nc->GetDiffPairGap() );
509  grid->SetCellValue( row, GRID_DIFF_PAIR_GAP, msg );
510 
511  msg = StringFromValue( g_UserUnit, nc->GetDiffPairWidth() );
512  grid->SetCellValue( row, GRID_DIFF_PAIR_WIDTH, msg );
513 
514 }
515 
516 
518 {
519  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
520 
521  // the +1 is for the Default NETCLASS.
522  if( netclasses.GetCount() + 1 > (unsigned) m_grid->GetNumberRows() )
523  {
524  m_grid->AppendRows( netclasses.GetCount() + 1 - m_grid->GetNumberRows() );
525  }
526 
527  // enter the Default NETCLASS.
528  class2gridRow( m_grid, 0, netclasses.GetDefault() );
529 
530  // enter others netclasses
531  int row = 1;
532 
533  for( NETCLASSES::iterator i = netclasses.begin(); i!=netclasses.end(); ++i, ++row )
534  {
535  NETCLASSPTR netclass = i->second;
536 
537  class2gridRow( m_grid, row, netclass );
538  }
539 }
540 
541 
542 static void gridRow2class( wxGrid* grid, int row, const NETCLASSPTR& nc )
543 {
544 #define MYCELL( col ) \
545  ValueFromString( g_UserUnit, grid->GetCellValue( row, col ) )
546 
547  nc->SetClearance( MYCELL( GRID_CLEARANCE ) );
548  nc->SetTrackWidth( MYCELL( GRID_TRACKSIZE ) );
549  nc->SetViaDiameter( MYCELL( GRID_VIASIZE ) );
550  nc->SetViaDrill( MYCELL( GRID_VIADRILL ) );
551  nc->SetuViaDiameter( MYCELL( GRID_uVIASIZE ) );
552  nc->SetuViaDrill( MYCELL( GRID_uVIADRILL ) );
553  nc->SetDiffPairGap( MYCELL( GRID_DIFF_PAIR_GAP ) );
554  nc->SetDiffPairWidth( MYCELL( GRID_DIFF_PAIR_WIDTH ) );
555 
556 }
557 
558 
560 {
561  // Commit any pending in-place edits first
562  m_grid->SaveEditControlValue();
563 
564  NETCLASSES& netclasses = m_BrdSettings->m_NetClasses;
565 
566  // Remove all netclasses from board. We'll copy new list after
567  netclasses.Clear();
568 
569  // Copy the default NetClass:
570  gridRow2class( m_grid, 0, netclasses.GetDefault() );
571 
572  // Copy other NetClasses :
573  for( int row = 1; row < m_grid->GetNumberRows(); ++row )
574  {
575  NETCLASSPTR nc = std::make_shared<NETCLASS>( m_grid->GetRowLabelValue( row ) );
576 
577  if( !m_BrdSettings->m_NetClasses.Add( nc ) )
578  {
579  // this netclass cannot be added because another netclass with the same name exists
580  // Should not occur because OnAddNetclassClick() tests for existing NetClass names
581  wxString msg;
582  msg.Printf( wxT( "CopyRulesListToBoard(): The NetClass \"%s\" already exists. Skip" ),
583  GetChars( m_grid->GetRowLabelValue( row ) ) );
584  wxMessageBox( msg );
585 
586  continue;
587  }
588 
589  gridRow2class( m_grid, row, nc );
590  }
591 
592  // Now read all nets and push them in the corresponding netclass net buffer
593  for( NETCUPS::const_iterator netcup = m_AllNets.begin(); netcup != m_AllNets.end(); ++netcup )
594  {
595  NETCLASSPTR nc = netclasses.Find( netcup->clazz );
596  wxASSERT( nc );
597  nc->Add( netcup->net );
598  }
599 
601 }
602 
603 
605 {
607 
608  // Update vias minimum values for DRC
611 
613 
614  // Update microvias minimum values for DRC
617 
618  // Update tracks minimum values for DRC
620 }
621 
622 
624 {
625  wxString msg;
626 
627  // Commit any pending in-place edits from grid controls
628  m_gridTrackWidthList->SaveEditControlValue();
629  m_gridViaSizeList->SaveEditControlValue();
630 
631  // Reinitialize m_TrackWidthList
632  m_TracksWidthList.clear();
633 
634  for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
635  {
636  msg = m_gridTrackWidthList->GetCellValue( row, 0 );
637 
638  if( msg.IsEmpty() )
639  continue;
640 
641  int value = ValueFromString( g_UserUnit, msg );
642  m_TracksWidthList.push_back( value );
643  }
644 
645  // Sort new list by by increasing value
646  sort( m_TracksWidthList.begin(), m_TracksWidthList.end() );
647 
648  // Reinitialize m_ViasDimensionsList
649  m_ViasDimensionsList.clear();
650 
651  for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
652  {
653  msg = m_gridViaSizeList->GetCellValue( row, 0 );
654 
655  if( msg.IsEmpty() )
656  continue;
657 
658  int value = ValueFromString( g_UserUnit, msg );
659  VIA_DIMENSION via_dim;
660  via_dim.m_Diameter = value;
661  msg = m_gridViaSizeList->GetCellValue( row, 1 );
662 
663  if( !msg.IsEmpty() )
664  {
665  value = ValueFromString( g_UserUnit, msg );
666  via_dim.m_Drill = value;
667  }
668 
669  m_ViasDimensionsList.push_back( via_dim );
670  }
671 
672  // Sort new list by by increasing value
673  sort( m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
674 
675  std::vector<int>* tlist = &m_BrdSettings->m_TrackWidthList;
676 
677  // Remove old "custom" sizes
678  tlist->erase( tlist->begin() + 1, tlist->end() );
679 
680  // Add new "custom" sizes
681  tlist->insert( tlist->end(), m_TracksWidthList.begin(), m_TracksWidthList.end() );
682 
683  // Reinitialize m_ViaSizeList
684  std::vector<VIA_DIMENSION>* vialist = &m_BrdSettings->m_ViasDimensionsList;
685  vialist->erase( vialist->begin() + 1, vialist->end() );
686  vialist->insert( vialist->end(), m_ViasDimensionsList.begin(), m_ViasDimensionsList.end() );
687 }
688 
689 
690 void DIALOG_DESIGN_RULES::OnNotebookPageChanged( wxNotebookEvent& event )
691 {
692  s_LastTabSelection = event.GetSelection();
693 
694  // Skip() allows OSX to properly refresh controls.
695  event.Skip();
696 }
697 
698 
700 {
701  if( !wxDialog::TransferDataFromWindow() )
702  return false;
703 
704  wxString errorMsg;
705 
706  if( !TestDataValidity( &errorMsg ) )
707  {
708  HTML_MESSAGE_BOX dlg( this, _( "Design Rule Setting Error" ) );
709  dlg.MessageSet( errorMsg );
710  dlg.ShowModal();
711  return false;
712  }
713 
718 
719  //this event causes the routing tool to reload its design rules information
720  TOOL_MANAGER* toolManager = m_Parent->GetToolManager();
722  toolManager->ProcessEvent( event );
723 
724 
725  return true;
726 }
727 
728 
729 void DIALOG_DESIGN_RULES::OnAddNetclassClick( wxCommandEvent& event )
730 {
731  wxString class_name;
732 
733  // @todo set validator to ensure net class name is valid rather than all of the checks
734  // after the OK button has been selected.
735  WX_TEXT_ENTRY_DIALOG dlg( this, _( "New Net Class Name:" ), wxEmptyString, class_name );
736 
737  if( dlg.ShowModal() != wxID_OK )
738  return; // canceled by user
739 
740  class_name = dlg.GetValue();
741  class_name.Trim( true );
742  class_name.Trim( false );
743 
744  if( class_name.IsEmpty() )
745  return; // empty name not allowed
746 
747  // The name must dot exists:
748  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
749  {
750  wxString value;
751  value = m_grid->GetRowLabelValue( ii );
752 
753  if( class_name.CmpNoCase( value ) == 0 ) // Already exists!
754  {
755  DisplayError( this, _( "Duplicate net class names are not allowed." ) );
756  return;
757  }
758  }
759 
760  m_grid->AppendRows();
761  m_grid->SetRowLabelValue( m_grid->GetNumberRows() - 1, class_name );
762 
763  // Copy values of the default class:
764  int irow = m_grid->GetNumberRows() - 1;
765 
766  for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
767  {
768  wxString value;
769  value = m_grid->GetCellValue( 0, icol );
770  m_grid->SetCellValue( irow, icol, value );
771  }
772 
774 
776 }
777 
778 
779 // Sort function for wxArrayInt. Items (ints) are sorted by decreasing value
780 // used in DIALOG_DESIGN_RULES::OnRemoveNetclassClick
781 int sort_int( int* first, int* second )
782 {
783  return *second - *first;
784 }
785 
786 
787 void DIALOG_DESIGN_RULES::OnRemoveNetclassClick( wxCommandEvent& event )
788 {
789  wxArrayInt select = m_grid->GetSelectedRows();
790 
791  // Sort selection by decreasing index order:
792  select.Sort( sort_int );
793  bool reinit = false;
794 
795  // rows labels are not removed when deleting rows: they are not deleted.
796  // So we must store them, remove corresponding labels and reinit them
797  wxArrayString labels;
798 
799  for( int ii = 0; ii < m_grid->GetNumberRows(); ii++ )
800  labels.Add( m_grid->GetRowLabelValue( ii ) );
801 
802  // Delete rows from last to first (this is the order wxArrayInt select after sorting) )
803  // This order is Ok when removing rows
804  for( unsigned ii = 0; ii < select.GetCount(); ii++ )
805  {
806  int grid_row = select[ii];
807 
808  if( grid_row != 0 ) // Do not remove the default class
809  {
810  wxString classname = m_grid->GetRowLabelValue( grid_row );
811  m_grid->DeleteRows( grid_row );
812  labels.RemoveAt( grid_row ); // Remove corresponding row label
813  reinit = true;
814 
815  // reset the net class to default for members of the removed class
816  swapNetClass( classname, NETCLASS::Default );
817  }
818  else
819  wxMessageBox( _( "The default net class cannot be removed" ) );
820  }
821 
822  if( reinit )
823  {
824  // Reinit labels :
825  for( unsigned ii = 1; ii < labels.GetCount(); ii++ )
826  m_grid->SetRowLabelValue( ii, labels[ii] );
827 
830  }
831 }
832 
834 {
835  bool enabled = m_OptAllowMicroVias->GetValue();
836  m_SetMicroViasMinSizeCtrl->Enable( enabled );
837  m_SetMicroViasMinDrillCtrl->Enable( enabled );
838 }
839 
844 void DIALOG_DESIGN_RULES::OnAllowMicroVias( wxCommandEvent& event )
845 {
847 }
848 
850 {
851  // Cannot move up rules if we have 1 or 2 rules only
852  if( m_grid->GetNumberRows() < 3 )
853  return;
854 
855  wxArrayInt select = m_grid->GetSelectedRows();
856  bool reinit = false;
857 
858  for( unsigned irow = 0; irow < select.GetCount(); irow++ )
859  {
860  int ii = select[irow];
861  if( ii < 2 ) // The default netclass *must* be the first netclass
862  continue; // so we cannot move up line 0 and 1
863 
864  // Swap the rule and the previous rule
865  wxString curr_value, previous_value;
866 
867  for( int icol = 0; icol < m_grid->GetNumberCols(); icol++ )
868  {
869  reinit = true;
870  curr_value = m_grid->GetCellValue( ii, icol );
871  previous_value = m_grid->GetCellValue( ii - 1, icol );
872  m_grid->SetCellValue( ii, icol, previous_value );
873  m_grid->SetCellValue( ii - 1, icol, curr_value );
874  }
875 
876  curr_value = m_grid->GetRowLabelValue( ii );
877  previous_value = m_grid->GetRowLabelValue( ii - 1 );
878  m_grid->SetRowLabelValue( ii, previous_value );
879  m_grid->SetRowLabelValue( ii - 1, curr_value );
880  }
881 
882  if( reinit )
884 }
885 
886 
887 void DIALOG_DESIGN_RULES::OnLeftCBSelection( wxCommandEvent& event )
888 {
889  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
890 
891  if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
892  {
893  m_buttonRightToLeft->Enable( false );
894  m_buttonLeftToRight->Enable( false );
895  }
896  else
897  {
898  m_buttonRightToLeft->Enable( true );
899  m_buttonLeftToRight->Enable( true );
900  }
901 }
902 
903 
904 void DIALOG_DESIGN_RULES::OnRightCBSelection( wxCommandEvent& event )
905 {
907 
908  if( m_leftClassChoice->GetStringSelection() == m_rightClassChoice->GetStringSelection() )
909  {
910  m_buttonRightToLeft->Enable( false );
911  m_buttonLeftToRight->Enable( false );
912  }
913  else
914  {
915  m_buttonRightToLeft->Enable( true );
916  m_buttonLeftToRight->Enable( true );
917  }
918 }
919 
920 
921 void DIALOG_DESIGN_RULES::moveSelectedItems( NETS_LIST_CTRL* src, const wxString& newClassName )
922 {
923  wxListItem item;
924  wxString netName;
925 
926  item.m_mask |= wxLIST_MASK_TEXT; // Validate the member m_text of the wxListItem item
927 
928  for( int row = 0; row < src->GetItemCount(); ++row )
929  {
930  if( !src->GetItemState( row, wxLIST_STATE_SELECTED ) )
931  continue;
932 
933  item.SetColumn( 0 );
934  item.SetId( row );
935 
936  src->GetItem( item );
937  netName = item.GetText();
938 
939  setNetClass( netName, newClassName == wildCard ? NETCLASS::Default : newClassName );
940  }
941 }
942 
943 
944 void DIALOG_DESIGN_RULES::OnRightToLeftCopyButton( wxCommandEvent& event )
945 {
946  wxString newClassName = m_leftClassChoice->GetStringSelection();
947 
948  moveSelectedItems( m_rightListCtrl, newClassName );
949 
950  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
952 }
953 
954 
955 void DIALOG_DESIGN_RULES::OnLeftToRightCopyButton( wxCommandEvent& event )
956 {
957  wxString newClassName = m_rightClassChoice->GetStringSelection();
958 
959  moveSelectedItems( m_leftListCtrl, newClassName );
960 
961  FillListBoxWithNetNames( m_leftListCtrl, m_leftClassChoice->GetStringSelection() );
963 }
964 
965 
966 void DIALOG_DESIGN_RULES::OnLeftSelectAllButton( wxCommandEvent& event )
967 {
968  for( int ii = 0; ii < m_leftListCtrl->GetItemCount(); ii++ )
969  m_leftListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
970 }
971 
972 
973 void DIALOG_DESIGN_RULES::OnRightSelectAllButton( wxCommandEvent& event )
974 {
975  for( int ii = 0; ii < m_rightListCtrl->GetItemCount(); ii++ )
976  m_rightListCtrl->SetItemState( ii, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
977 }
978 
979 
980 void DIALOG_DESIGN_RULES::setNetClass( const wxString& aNetName, const wxString& aClassName )
981 {
982  for( NETCUPS::iterator i = m_AllNets.begin(); i != m_AllNets.end(); ++i )
983  {
984  if( i->net == aNetName )
985  {
986  i->clazz = aClassName;
987  break;
988  }
989  }
990 }
991 
992 
993 bool DIALOG_DESIGN_RULES::TestDataValidity( wxString* aErrorMsg )
994 {
995  bool result = true;
996 
997  wxString msg;
998  wxString errorMsg;
999 
1000  wxString netclassLabel; // Name of a given netclass
1001  wxString netclassError; // Error message particular to a given netclass
1002 
1003  wxString units = ReturnUnitSymbol( g_UserUnit, "%s" );
1004 
1005  int minViaDia = ValueFromTextCtrl( *m_SetViasMinSizeCtrl );
1006  int minViaDrill = ValueFromTextCtrl( *m_SetViasMinDrillCtrl );
1007  int minUViaDia = ValueFromTextCtrl( *m_SetMicroViasMinSizeCtrl );
1008  int minUViaDrill = ValueFromTextCtrl( *m_SetMicroViasMinDrillCtrl );
1009  int minTrackWidth = ValueFromTextCtrl( *m_SetTrackMinWidthCtrl );
1010  int maxval = 1000 * IU_PER_MILS; // a max value for tracks and vias sizes (1 inch)
1011 
1012  // @todo Change this code to set the focus to the control where the first error occurs
1013  // so the user doesn't have to figure out where the issue is.
1014 
1015  // Test net class parameters.
1016  for( int row = 0; row < m_grid->GetNumberRows(); row++ )
1017  {
1018  netclassLabel = GetChars( m_grid->GetRowLabelValue( row ) );
1019  netclassError.Clear(); // Clear the error for this netclass
1020 
1021  int tracksize = ValueFromString( g_UserUnit,
1022  m_grid->GetCellValue( row, GRID_TRACKSIZE ) );
1023  if( tracksize < minTrackWidth )
1024  {
1025  result = false;
1026  msg.Printf( _( " - <b>Track Size</b> (%f %s) &lt; <b>Min Track Size</b> (%f %s)<br>" ),
1027  To_User_Unit( g_UserUnit, tracksize ), units,
1028  To_User_Unit( g_UserUnit, minTrackWidth ), units );
1029 
1030  netclassError += msg;
1031  }
1032 
1033  int dpsize = ValueFromString( g_UserUnit,
1034  m_grid->GetCellValue( row, GRID_DIFF_PAIR_WIDTH ) );
1035 
1036  if( dpsize < minTrackWidth )
1037  {
1038  result = false;
1039  msg.Printf( _( " - <b>Differential Pair Size</b> (%f %s) &lt; <b>Min Track Size</b> (%f %s)<br>" ),
1040  To_User_Unit( g_UserUnit, dpsize ), units,
1041  To_User_Unit( g_UserUnit, minTrackWidth ), units );
1042  netclassError += msg;
1043  }
1044 
1045 
1046  // Test vias
1047  int viadia = ValueFromString( g_UserUnit,
1048  m_grid->GetCellValue( row, GRID_VIASIZE ) );
1049 
1050  if( viadia < minViaDia )
1051  {
1052  result = false;
1053  msg.Printf( _( " - <b>Via Diameter</b> (%f %s) &lt; <b>Minimum Via Diameter</b> (%f %s)<br>" ),
1054  To_User_Unit( g_UserUnit, viadia ), units,
1055  To_User_Unit( g_UserUnit, minViaDia ), units );
1056  netclassError += msg;
1057  }
1058 
1059  int viadrill = ValueFromString( g_UserUnit,
1060  m_grid->GetCellValue( row, GRID_VIADRILL ) );
1061 
1062  if( viadrill >= viadia )
1063  {
1064  result = false;
1065  msg.Printf( _( " - <b>Via Drill</b> (%f %s) &ge; <b>Via Dia</b> (%f %s)<br>" ),
1066  To_User_Unit( g_UserUnit, viadrill ), units,
1067  To_User_Unit( g_UserUnit, viadia ), units );
1068  netclassError += msg;
1069  }
1070 
1071  if( viadrill < minViaDrill )
1072  {
1073  result = false;
1074  msg.Printf( _( " - <b>Via Drill</b> (%f %s) &lt; <b>Min Via Drill</b> (%f %s)<br>" ),
1075  To_User_Unit( g_UserUnit, viadrill ), units,
1076  To_User_Unit( g_UserUnit, minViaDrill ), units );
1077  netclassError += msg;
1078  }
1079 
1080  // Test Micro vias
1081  int muviadia = ValueFromString( g_UserUnit,
1082  m_grid->GetCellValue( row, GRID_uVIASIZE ) );
1083 
1084  if( muviadia < minUViaDia )
1085  {
1086  result = false;
1087  msg.Printf( _( " - <b>MicroVia Diameter</b> (%f %s) &lt; <b>MicroVia Min Diameter</b> (%f %s)<br>" ),
1088  To_User_Unit( g_UserUnit, muviadia ), units,
1089  To_User_Unit( g_UserUnit, minUViaDia ), units );
1090  netclassError += msg;
1091  }
1092 
1093  int muviadrill = ValueFromString( g_UserUnit,
1094  m_grid->GetCellValue( row, GRID_uVIADRILL ) );
1095 
1096  if( muviadrill >= muviadia )
1097  {
1098  result = false;
1099  msg.Printf( _( " - <b>MicroVia Drill</b> (%f %s) &ge; <b>MicroVia Dia</b> (%f %s)<br>" ),
1100  To_User_Unit( g_UserUnit, muviadrill ), units,
1101  To_User_Unit( g_UserUnit, muviadia ), units );
1102  netclassError += msg;
1103  }
1104 
1105  if( muviadrill < minUViaDrill )
1106  {
1107  result = false;
1108  msg.Printf( _( " - <b>MicroVia Drill</b> (%f %s) &lt; <b>MicroVia Min Drill</b> (%f %s)<br>" ),
1109  To_User_Unit( g_UserUnit, muviadrill ), units,
1110  To_User_Unit( g_UserUnit, minUViaDrill ), units );
1111  netclassError += msg;
1112  }
1113 
1114  // If this netclass contains errors, add it to the error message
1115  if ( !netclassError.IsEmpty() )
1116  {
1117  msg.Printf( _( "Netclass: <b>%s</b><br>" ), netclassLabel );
1118  errorMsg += msg;
1119  errorMsg += netclassError;
1120  errorMsg += "<br>";
1121  }
1122  }
1123 
1124  // Test custom tracks
1125  for( int row = 0; row < m_gridTrackWidthList->GetNumberRows(); ++row )
1126  {
1127  wxString tvalue = m_gridTrackWidthList->GetCellValue( row, 0 );
1128 
1129  if( tvalue.IsEmpty() )
1130  continue;
1131 
1132  int tracksize = ValueFromString( g_UserUnit, tvalue );
1133 
1134  if( tracksize < minTrackWidth )
1135  {
1136  result = false;
1137  msg.Printf( _( "<b>Extra Track %d Size</b> %s &lt; <b>Min Track Size</b><br>" ),
1138  row + 1, GetChars( tvalue ) );
1139 
1140  errorMsg += msg;
1141  }
1142 
1143  if( tracksize > maxval )
1144  {
1145  result = false;
1146  msg.Printf( _( "<b>Extra Track %d Size</b> %s &gt; <b>1 inch!</b><br>" ),
1147  row + 1, GetChars( tvalue ) );
1148 
1149  errorMsg += msg;
1150  }
1151  }
1152 
1153  // Test custom vias
1154  for( int row = 0; row < m_gridViaSizeList->GetNumberRows(); ++row )
1155  {
1156  wxString tvalue = m_gridViaSizeList->GetCellValue( row, 0 );
1157 
1158  if( tvalue.IsEmpty() )
1159  continue;
1160 
1161  int viadia = ValueFromString( g_UserUnit, tvalue );
1162 
1163  if( viadia < minViaDia )
1164  {
1165  result = false;
1166  msg.Printf( _( "<b>Extra Via %d Size</b> %s &lt; <b>Min Via Size</b><br>" ),
1167  row + 1, GetChars( tvalue ) );
1168  errorMsg += msg;
1169  }
1170 
1171  wxString drlvalue = m_gridViaSizeList->GetCellValue( row, 1 );
1172 
1173  if( drlvalue.IsEmpty() )
1174  {
1175  result = false;
1176  msg.Printf( _( "<b>No via drill size define in row %d</b><br>" ), row + 1 );
1177  errorMsg += msg;
1178  continue;
1179  }
1180 
1181  int viadrill = ValueFromString( g_UserUnit, drlvalue );
1182 
1183  if( viadrill < minViaDrill )
1184  {
1185  result = false;
1186  msg.Printf( _( "<b>Extra Via %d Drill</b> %s &lt; <b>Min Via Drill %s</b><br>" ),
1187  row + 1, GetChars( drlvalue ),
1188  GetChars( m_SetViasMinDrillCtrl->GetValue() ) );
1189  errorMsg += msg;
1190  }
1191 
1192  if( viadia <= viadrill )
1193  {
1194  result = false;
1195  msg.Printf( _( "<b>Extra Via %d Size</b> %s &le; <b> Drill Size</b> %s<br>" ),
1196  row + 1, GetChars( tvalue ), GetChars( drlvalue ) );
1197  errorMsg += msg;
1198  }
1199 
1200  // Test for a reasonable via size:
1201  if( viadia > maxval ) // 1 inch!
1202  {
1203  result = false;
1204  msg.Printf( _( "<b>Extra Via %d Size</b>%s &gt; <b>1 inch!</b><br>" ),
1205  row + 1, GetChars( tvalue ) );
1206  errorMsg += msg;
1207  }
1208  }
1209 
1210  if( !result && aErrorMsg )
1211  *aErrorMsg = errorMsg;
1212 
1213  return result;
1214 }
1215 
1216 
1217 
1218 
void OnNotebookPageChanged(wxNotebookEvent &event) override
std::vector< int > m_TracksWidthList
void BuildListOfNets()
Definition: class_board.h:726
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:426
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:205
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
Class TOOL_MANAGER.
Definition: tool_manager.h:49
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
Action belongs to a particular tool (i.e. a part of a pop-up menu)
Definition: tool_event.h:137
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...
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagates an event to tools that requested events of matching type(s).
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:485
Class TOOL_EVENT.
Definition: tool_event.h:162
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:370
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:535
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:386
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:57
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:267
TOOL_MANAGER * GetToolManager() const
Function GetToolManager returns the tool manager instance, if any.
Definition: draw_frame.h:910
void SetRowItems(unsigned aRow, const wxString &aNetname, const wxString &aNetclassName)
Function SetRowItems sets the net name and the net class name at aRow.
wxString GetValue()
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
size_t i
Definition: json11.cpp:597
static int s_LastTabSelection
which tab user had open last
Class PCB_EDIT_FRAME is the main frame for Pcbnew.
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:185
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.