KiCad PCB EDA Suite
class_track.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
5  * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
6  * Copyright (C) 2012 Wayne Stambaugh <stambaughw@verizon.net>
7  * Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, you may find one here:
21  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22  * or you may search the http://www.gnu.org website for the version 2 license,
23  * or you may write to the Free Software Foundation, Inc.,
24  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25  */
26 
33 #include <fctsys.h>
34 #include <gr_basic.h>
35 #include <common.h>
36 #include <trigo.h>
37 #include <macros.h>
38 #include <class_drawpanel.h>
39 #include <class_pcb_screen.h>
40 #include <drawtxt.h>
41 #include <wxstruct.h>
42 #include <wxBasePcbFrame.h>
43 #include <class_board.h>
44 #include <class_track.h>
45 #include <pcbnew.h>
46 #include <base_units.h>
47 #include <msgpanel.h>
48 #include <bitmaps.h>
49 
55 static bool ShowClearance( PCB_DISPLAY_OPTIONS* aDisplOpts, const TRACK* aTrack )
56 {
57  // maybe return true for tracks and vias, not for zone segments
58  return IsCopperLayer( aTrack->GetLayer() )
59  && ( aTrack->Type() == PCB_TRACE_T || aTrack->Type() == PCB_VIA_T )
61  && ( aTrack->IsDragging() || aTrack->IsMoving() || aTrack->IsNew() ) )
63  );
64 
65 }
66 
67 
68 TRACK* GetTrack( TRACK* aStartTrace, const TRACK* aEndTrace,
69  const wxPoint& aPosition, LSET aLayerMask )
70 {
71  for( TRACK* seg = aStartTrace; seg; seg = seg->Next() )
72  {
73  if( seg->GetState( IS_DELETED | BUSY ) == 0 )
74  {
75  if( aPosition == seg->GetStart() )
76  {
77  if( ( aLayerMask & seg->GetLayerSet() ).any() )
78  return seg;
79  }
80 
81  if( aPosition == seg->GetEnd() )
82  {
83  if( ( aLayerMask & seg->GetLayerSet() ).any() )
84  return seg;
85  }
86  }
87 
88  if( seg == aEndTrace )
89  break;
90  }
91 
92  return NULL;
93 }
94 
95 
96 TRACK::TRACK( BOARD_ITEM* aParent, KICAD_T idtype ) :
97  BOARD_CONNECTED_ITEM( aParent, idtype )
98 {
99  m_Width = Millimeter2iu( 0.2 );
100  start = end = NULL;
101  m_Param = 0;
102 }
103 
104 
106 {
107  return new TRACK( *this );
108 }
109 
110 
111 wxString TRACK::ShowWidth() const
112 {
113  wxString msg = ::CoordinateToString( m_Width );
114  return msg;
115 }
116 
117 
119  TRACK( aParent, PCB_ZONE_T )
120 {
121 }
122 
123 
125 {
126  return new SEGZONE( *this );
127 }
128 
129 
131 {
132  wxString text, nettxt;
133  BOARD* board = GetBoard();
134 
135  if( board )
136  {
137  nettxt = GetNetname();
138  }
139  else
140  {
141  wxFAIL_MSG( wxT( "SEGZONE::GetSelectMenuText: BOARD is NULL" ) );
142  nettxt = wxT( "???" );
143  }
144 
145  text.Printf( _( "Zone (%08lX) [%s] on %s" ),
146  m_TimeStamp, GetChars( nettxt ), GetChars( GetLayerName() ) );
147 
148  return text;
149 }
150 
151 
153 {
154  return add_zone_xpm;
155 }
156 
157 
158 VIA::VIA( BOARD_ITEM* aParent ) :
159  TRACK( aParent, PCB_VIA_T )
160 {
163  SetDrillDefault();
164 }
165 
166 
168 {
169  return new VIA( *this );
170 }
171 
172 
173 wxString VIA::GetSelectMenuText() const
174 {
175  wxString text;
176  wxString format;
177  BOARD* board = GetBoard();
178 
179  switch( GetViaType() )
180  {
181  case VIA_BLIND_BURIED:
182  format = _( "Blind/Buried Via %s, net[%s] (%d) on layers %s/%s" );
183  break;
184  case VIA_MICROVIA:
185  format = _( "Micro Via %s, Net [%s] (%d) on layers %s/%s" );
186  break;
187  // else say nothing about normal (through) vias
188  default:
189  format = _( "Via %s net [%s] (%d) on layers %s/%s" );
190  break;
191  }
192 
193 
194  if( board )
195  {
196  wxString netname = GetNetname();
197 
198  // say which layers, only two for now
199  PCB_LAYER_ID topLayer;
200  PCB_LAYER_ID botLayer;
201  LayerPair( &topLayer, &botLayer );
202  text.Printf( format.GetData(), GetChars( ShowWidth() ),
203  GetChars( netname ), GetNetCode(),
204  GetChars( board->GetLayerName( topLayer ) ),
205  GetChars( board->GetLayerName( botLayer ) ) );
206 
207  }
208  else
209  {
210  wxFAIL_MSG( wxT( "VIA::GetSelectMenuText: BOARD is NULL" ) );
211  text.Printf( format.GetData(), GetChars( ShowWidth() ),
212  wxT( "???" ), 0,
213  wxT( "??" ), wxT( "??" ) );
214  }
215 
216  return text;
217 }
218 
219 
221 {
222  return via_xpm;
223 }
224 
225 
227 {
228  // Currently tracks have no specific clearance parameter on a per track or per
229  // segment basis. The NETCLASS clearance is used.
230  return BOARD_CONNECTED_ITEM::GetClearance( aItem );
231 }
232 
233 
235 {
236  if( m_Drill > 0 ) // Use the specific value.
237  return m_Drill;
238 
239  // Use the default value from the Netclass
240  NETCLASSPTR netclass = GetNetClass();
241 
242  if( GetViaType() == VIA_MICROVIA )
243  return netclass->GetuViaDrill();
244 
245  return netclass->GetViaDrill();
246 }
247 
248 
250 {
251  if( ( Type() != PCB_VIA_T ) && ( m_Start == m_End ) )
252  return true;
253  else
254  return false;
255 }
256 
257 
258 STATUS_FLAGS TRACK::IsPointOnEnds( const wxPoint& point, int min_dist )
259 {
260  STATUS_FLAGS result = 0;
261 
262  if( min_dist < 0 )
263  min_dist = m_Width / 2;
264 
265  if( min_dist == 0 )
266  {
267  if( m_Start == point )
268  result |= STARTPOINT;
269 
270  if( m_End == point )
271  result |= ENDPOINT;
272  }
273  else
274  {
275  double dist = GetLineLength( m_Start, point );
276 
277  if( min_dist >= KiROUND( dist ) )
278  result |= STARTPOINT;
279 
280  dist = GetLineLength( m_End, point );
281 
282  if( min_dist >= KiROUND( dist ) )
283  result |= ENDPOINT;
284  }
285 
286  return result;
287 }
288 
289 
291 {
292  // end of track is round, this is its radius, rounded up
293  int radius;
294 
295  int ymax;
296  int xmax;
297 
298  int ymin;
299  int xmin;
300 
301  if( Type() == PCB_VIA_T )
302  {
303  // Because vias are sometimes drawn larger than their m_Width would
304  // provide, erasing them using a dirty rect must also compensate for this
305  // possibility (that the via is larger on screen than its m_Width would provide).
306  // Because it is cheap to return a larger BoundingBox, do it so that
307  // the via gets erased properly. Do not divide width by 2 for this reason.
308  radius = m_Width;
309 
310  ymax = m_Start.y;
311  xmax = m_Start.x;
312 
313  ymin = m_Start.y;
314  xmin = m_Start.x;
315  }
316  else
317  {
318  radius = ( m_Width + 1 ) / 2;
319 
320  ymax = std::max( m_Start.y, m_End.y );
321  xmax = std::max( m_Start.x, m_End.x );
322 
323  ymin = std::min( m_Start.y, m_End.y );
324  xmin = std::min( m_Start.x, m_End.x );
325  }
326 
327  // + 1 is for the clearance line itself.
328  radius += GetClearance() + 1;
329 
330  ymax += radius;
331  xmax += radius;
332 
333  ymin -= radius;
334  xmin -= radius;
335 
336  // return a rectangle which is [pos,dim) in nature. therefore the +1
337  EDA_RECT ret( wxPoint( xmin, ymin ), wxSize( xmax - xmin + 1, ymax - ymin + 1 ) );
338 
339  return ret;
340 }
341 
342 
343 void TRACK::Rotate( const wxPoint& aRotCentre, double aAngle )
344 {
345  RotatePoint( &m_Start, aRotCentre, aAngle );
346  RotatePoint( &m_End, aRotCentre, aAngle );
347 }
348 
349 
350 void TRACK::Flip( const wxPoint& aCentre )
351 {
352  m_Start.y = aCentre.y - (m_Start.y - aCentre.y);
353  m_End.y = aCentre.y - (m_End.y - aCentre.y);
354  int copperLayerCount = GetBoard()->GetCopperLayerCount();
355  SetLayer( FlipLayer( GetLayer(), copperLayerCount ) );
356 }
357 
358 
359 void VIA::Flip( const wxPoint& aCentre )
360 {
361  m_Start.y = aCentre.y - (m_Start.y - aCentre.y);
362  m_End.y = aCentre.y - (m_End.y - aCentre.y);
363 
364  if( GetViaType() != VIA_THROUGH )
365  {
366  int copperLayerCount = GetBoard()->GetCopperLayerCount();
367  PCB_LAYER_ID top_layer;
368  PCB_LAYER_ID bottom_layer;
369  LayerPair( &top_layer, &bottom_layer );
370  top_layer = FlipLayer( top_layer, copperLayerCount );
371  bottom_layer = FlipLayer( bottom_layer, copperLayerCount );
372  SetLayerPair( top_layer, bottom_layer );
373  }
374 }
375 
376 
377 // see class_track.h
378 SEARCH_RESULT TRACK::Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] )
379 {
380  KICAD_T stype = *scanTypes;
381 
382  // If caller wants to inspect my type
383  if( stype == Type() )
384  {
385  if( SEARCH_QUIT == inspector( this, testData ) )
386  return SEARCH_QUIT;
387  }
388 
389  return SEARCH_CONTINUE;
390 }
391 
392 
393 bool VIA::IsOnLayer( PCB_LAYER_ID layer_number ) const
394 {
395  PCB_LAYER_ID bottom_layer, top_layer;
396 
397  LayerPair( &top_layer, &bottom_layer );
398 
399  wxASSERT( top_layer <= bottom_layer );
400 
401  if( top_layer <= layer_number && layer_number <= bottom_layer )
402  return true;
403  else
404  return false;
405 }
406 
407 
409 {
410  if( GetViaType() == VIA_THROUGH )
411  return LSET::AllCuMask();
412 
413  // VIA_BLIND_BURIED or VIA_MICRVIA:
414 
415  LSET layermask;
416 
417  wxASSERT( m_Layer <= m_BottomLayer );
418 
419  // PCB_LAYER_IDs are numbered from front to back, this is top to bottom.
420  for( LAYER_NUM id = m_Layer; id <= m_BottomLayer; ++id )
421  {
422  layermask.set( id );
423  }
424 
425  return layermask;
426 }
427 
428 
429 void VIA::SetLayerPair( PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer )
430 {
431  if( GetViaType() == VIA_THROUGH )
432  {
433  aTopLayer = F_Cu;
434  aBottomLayer = B_Cu;
435  }
436 
437  if( aBottomLayer < aTopLayer )
438  std::swap( aBottomLayer, aTopLayer );
439 
440  m_Layer = aTopLayer;
441  m_BottomLayer = aBottomLayer;
442 }
443 
444 
445 void VIA::LayerPair( PCB_LAYER_ID* top_layer, PCB_LAYER_ID* bottom_layer ) const
446 {
447  PCB_LAYER_ID t_layer = F_Cu;
448  PCB_LAYER_ID b_layer = B_Cu;
449 
450  if( GetViaType() != VIA_THROUGH )
451  {
452  b_layer = m_BottomLayer;
453  t_layer = m_Layer;
454 
455  if( b_layer < t_layer )
456  std::swap( b_layer, t_layer );
457  }
458 
459  if( top_layer )
460  *top_layer = t_layer;
461 
462  if( bottom_layer )
463  *bottom_layer = b_layer;
464 }
465 
466 
468 {
469  TRACK* track;
470 
471  if( Type() == PCB_ZONE_T )
472  track = aPcb->m_Zone;
473  else
474  track = aPcb->m_Track;
475 
476  for( ; track; track = track->Next() )
477  {
478  if( GetNetCode() <= track->GetNetCode() )
479  return track;
480  }
481 
482  return NULL;
483 }
484 
485 
487 {
488  TRACK* Track = this;
489  int ii = 0;
490 
491  if( NetCode == -1 )
492  NetCode = GetNetCode();
493 
494  while( Track != NULL )
495  {
496  if( Track->GetNetCode() > NetCode )
497  break;
498 
499  if( Track->GetNetCode() == NetCode )
500  {
501  ii++;
502  break;
503  }
504 
505  Track = (TRACK*) Track->Pnext;
506  }
507 
508  if( ii )
509  return Track;
510  else
511  return NULL;
512 }
513 
514 
516 {
517  TRACK* NextS, * Track = this;
518  int ii = 0;
519 
520  if( Track == NULL )
521  return NULL;
522 
523  if( NetCode == -1 )
524  NetCode = GetNetCode();
525 
526  while( Track != NULL )
527  {
528  NextS = (TRACK*) Track->Pnext;
529 
530  if( Track->GetNetCode() == NetCode )
531  ii++;
532 
533  if( NextS == NULL )
534  break;
535 
536  if( NextS->GetNetCode() > NetCode )
537  break;
538 
539  Track = NextS;
540  }
541 
542  if( ii )
543  return Track;
544  else
545  return NULL;
546 }
547 
549  wxDC* aDC, GR_DRAWMODE aDrawMode, COLOR4D aBgColor )
550 {
551  if( ! panel )
552  return;
553 
554  /* we must filter tracks, to avoid a lot of texts.
555  * - only tracks with a length > 10 * thickness are eligible
556  * and, of course, if we are not printing the board
557  */
558  auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );
559 
560  if( displ_opts->m_DisplayNetNamesMode == 0 || displ_opts->m_DisplayNetNamesMode == 1 )
561  return;
562 
563  #define THRESHOLD 10
564 
565  int len = KiROUND( GetLineLength( m_Start, m_End ) );
566 
567  if( len < THRESHOLD * m_Width )
568  return;
569 
570  // no room to display a text inside track
571  if( aDC->LogicalToDeviceXRel( m_Width ) < MIN_TEXT_SIZE )
572  return;
573 
575  return;
576 
577  NETINFO_ITEM* net = GetNet();
578 
579  if( net == NULL )
580  return;
581 
582  int textlen = net->GetShortNetname().Len();
583 
584  if( textlen > 0 )
585  {
586  // calculate a good size for the text
587  int tsize = std::min( m_Width, len / textlen );
588  int dx = m_End.x - m_Start.x ;
589  int dy = m_End.y - m_Start.y ;
590  wxPoint tpos = m_Start + m_End;
591  tpos.x /= 2;
592  tpos.y /= 2;
593 
594  // Calculate angle: if the track segment is vertical, angle = 90 degrees
595  // If horizontal 0 degrees, otherwise compute it
596  double angle; // angle is in 0.1 degree
597 
598  if( dy == 0 ) // Horizontal segment
599  {
600  angle = 0;
601  }
602  else
603  {
604  if( dx == 0 ) // Vertical segment
605  {
606  angle = 900;
607  }
608  else
609  {
610  /* atan2 is *not* the solution here, since it can give upside
611  down text. We want to work only in the first and fourth quadrant */
612  angle = RAD2DECIDEG( -atan( double( dy ) / double( dx ) ) );
613  }
614  }
615 
616  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
617 
618  if( ( aDC->LogicalToDeviceXRel( tsize ) >= MIN_TEXT_SIZE )
619  && ( !(!IsOnLayer( curr_layer )&& displ_opts->m_ContrastModeDisplay) ) )
620  {
621  if( (aDrawMode & GR_XOR) == 0 )
622  GRSetDrawMode( aDC, GR_COPY );
623 
624  tsize = (tsize * 7) / 10; // small reduction to give a better look
625  DrawGraphicHaloText( panel->GetClipBox(), aDC, tpos,
626  aBgColor, BLACK, WHITE, net->GetShortNetname(), angle,
627  wxSize( tsize, tsize ),
629  tsize / 7,
630  false, false );
631  }
632  }
633 }
634 
635 
636 void TRACK::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode,
637  const wxPoint& aOffset )
638 {
639  BOARD* brd = GetBoard();
640 
641  auto frame = static_cast<PCB_BASE_FRAME*> ( panel->GetParent() );
642  auto color = frame->Settings().Colors().GetLayerColor( m_Layer );
643 
644  if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )
645  return;
646 
647 #ifdef USE_WX_OVERLAY
648  // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay
649  if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))
650  return;
651 #endif
652 
653  auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );
654 
655  if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )
656  {
657  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
658 
659  if( !IsOnLayer( curr_layer ) )
661  }
662 
663  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
664  color.SetToLegacyHighlightColor();
665 
666  color.a = 0.588;
667 
668  GRSetDrawMode( aDC, aDrawMode );
669 
670  // Draw track as line if width <= 1pixel:
671  if( aDC->LogicalToDeviceXRel( m_Width ) <= 1 )
672  {
673  GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
674  return;
675  }
676 
677  if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
678  {
679  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
680  }
681  else
682  {
683  GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
684  m_Start.y + aOffset.y,
685  m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );
686  }
687 
688  if( panel->GetScreen()->m_IsPrinting )
689  return;
690 
691  // Show clearance for tracks, not for zone segments
692  if( ShowClearance( displ_opts, this ) )
693  {
694  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset,
695  m_Width + (GetClearance() * 2), color );
696  }
697 
698  DrawShortNetname( panel, aDC, aDrawMode, color );
699 }
700 
701 
702 void SEGZONE::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode,
703  const wxPoint& aOffset )
704 {
705  auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );
706 
707  if( displ_opts->m_DisplayZonesMode != 0 )
708  return;
709 
710  BOARD* brd = GetBoard();
711 
712  auto frame = static_cast<PCB_BASE_FRAME*> ( panel->GetParent() );
713  auto color = frame->Settings().Colors().GetLayerColor( m_Layer );
714 
715  if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )
716  return;
717 
718 #ifdef USE_WX_OVERLAY
719  // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay
720  if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))
721  return;
722 #endif
723 
724  if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )
725  {
726  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
727 
728  if( !IsOnLayer( curr_layer ) )
730  }
731 
732  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
733  color.SetToLegacyHighlightColor();
734 
735  color.a = 0.588;
736 
737  GRSetDrawMode( aDC, aDrawMode );
738 
739  // Draw track as line if width <= 1pixel:
740  if( aDC->LogicalToDeviceXRel( m_Width ) <= 1 )
741  {
742  GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
743  return;
744  }
745 
746  if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
747  {
748  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
749  }
750  else
751  {
752  GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
753  m_Start.y + aOffset.y,
754  m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );
755  }
756 
757  // No clearance or netnames for zones
758 }
759 
760 
761 void TRACK::ViewGetLayers( int aLayers[], int& aCount ) const
762 {
763  // Show the track and its netname on different layers
764  aLayers[0] = GetLayer();
765  aLayers[1] = GetNetnameLayer( aLayers[0] );
766  aCount = 2;
767 }
768 
769 
770 unsigned int TRACK::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
771 {
772  // Netnames will be shown only if zoom is appropriate
773  if( IsNetnameLayer( aLayer ) )
774  {
775  return ( 40000000 / ( m_Width + 1 ) );
776  }
777 
778  // Other layers are shown without any conditions
779  return 0;
780 }
781 
782 
783 void VIA::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode, const wxPoint& aOffset )
784 {
785  wxCHECK_RET( panel != NULL, wxT( "VIA::Draw panel cannot be NULL." ) );
786 
787  int radius;
788  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
789 
790  int fillvia = 0;
791  PCB_BASE_FRAME* frame = (PCB_BASE_FRAME*) panel->GetParent();
792  PCB_SCREEN* screen = frame->GetScreen();
793  auto displ_opts = (PCB_DISPLAY_OPTIONS*)( frame->GetDisplayOptions() );
794 
795  if( displ_opts->m_DisplayViaFill == FILLED )
796  fillvia = 1;
797 
798  GRSetDrawMode( aDC, aDrawMode );
799 
800  BOARD * brd = GetBoard();
802 
803  if( brd->IsElementVisible( LAYER_VIAS + GetViaType() ) == false
804  && !( aDrawMode & GR_HIGHLIGHT ) )
805  return;
806 
807  // Only draw the via if at least one of the layers it crosses is being displayed
808  if( !( brd->GetVisibleLayers() & GetLayerSet() ).any() )
809  return;
810 
811  if( displ_opts->m_ContrastModeDisplay )
812  {
813  if( !IsOnLayer( curr_layer ) )
814  color = COLOR4D( DARKDARKGRAY );
815  }
816 
817  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
818  color.SetToLegacyHighlightColor();
819 
820  color.a = 0.588;
821 
822 
823  radius = m_Width >> 1;
824  // for small via size on screen (radius < 4 pixels) draw a simplified shape
825 
826  int radius_in_pixels = aDC->LogicalToDeviceXRel( radius );
827 
828  bool fast_draw = false;
829 
830  // Vias are drawn as a filled circle or a double circle. The hole will be drawn later
831  int drill_radius = GetDrillValue() / 2;
832 
833  int inner_radius = radius - aDC->DeviceToLogicalXRel( 2 );
834 
835  if( radius_in_pixels < MIN_VIA_DRAW_SIZE )
836  {
837  fast_draw = true;
838  fillvia = false;
839  }
840 
841  if( fillvia )
842  {
843  GRFilledCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius, color );
844  }
845  else
846  {
847  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius, 0, color );
848 
849  if ( fast_draw )
850  return;
851 
852  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, inner_radius, 0, color );
853  }
854 
855  if( fillvia )
856  {
857  bool blackpenstate = false;
858 
859  if( screen->m_IsPrinting )
860  {
861  blackpenstate = GetGRForceBlackPenState();
862  GRForceBlackPen( false );
863  color = WHITE;
864  }
865  else
866  {
867  color = BLACK; // or DARKGRAY;
868  }
869 
870  if( (aDrawMode & GR_XOR) == 0)
871  GRSetDrawMode( aDC, GR_COPY );
872 
873  // Draw hole if the radius is > 1pixel.
874  if( aDC->LogicalToDeviceXRel( drill_radius ) > 1 )
875  GRFilledCircle( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
876  m_Start.y + aOffset.y, drill_radius, 0, color, color );
877 
878  if( screen->m_IsPrinting )
879  GRForceBlackPen( blackpenstate );
880  }
881  else
882  {
883  if( drill_radius < inner_radius ) // We can show the via hole
884  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, drill_radius, 0, color );
885  }
886 
887  if( ShowClearance( displ_opts, this ) )
888  {
889  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius + GetClearance(), 0, color );
890  }
891 
892  // for Micro Vias, draw a partial cross : X on component layer, or + on copper layer
893  // (so we can see 2 superimposed microvias ):
894  if( GetViaType() == VIA_MICROVIA )
895  {
896  int ax, ay, bx, by;
897 
898  if( IsOnLayer( B_Cu ) )
899  {
900  ax = radius; ay = 0;
901  bx = drill_radius; by = 0;
902  }
903  else
904  {
905  ax = ay = (radius * 707) / 1000;
906  bx = by = (drill_radius * 707) / 1000;
907  }
908 
909  // lines '|' or '\'
910  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
911  m_Start.y + aOffset.y - ay,
912  m_Start.x + aOffset.x - bx,
913  m_Start.y + aOffset.y - by, 0, color );
914  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x + bx,
915  m_Start.y + aOffset.y + by,
916  m_Start.x + aOffset.x + ax,
917  m_Start.y + aOffset.y + ay, 0, color );
918 
919  // lines - or '/'
920  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x + ay,
921  m_Start.y + aOffset.y - ax,
922  m_Start.x + aOffset.x + by,
923  m_Start.y + aOffset.y - bx, 0, color );
924  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - by,
925  m_Start.y + aOffset.y + bx,
926  m_Start.x + aOffset.x - ay,
927  m_Start.y + aOffset.y + ax, 0, color );
928  }
929 
930  // for Buried Vias, draw a partial line : orient depending on layer pair
931  // (so we can see superimposed buried vias ):
932  if( GetViaType() == VIA_BLIND_BURIED )
933  {
934  int ax = 0, ay = radius, bx = 0, by = drill_radius;
935  PCB_LAYER_ID layer_top, layer_bottom;
936 
937  LayerPair( &layer_top, &layer_bottom );
938 
939  // lines for the top layer
940  RotatePoint( &ax, &ay, layer_top * 3600.0 / brd->GetCopperLayerCount( ) );
941  RotatePoint( &bx, &by, layer_top * 3600.0 / brd->GetCopperLayerCount( ) );
942  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
943  m_Start.y + aOffset.y - ay,
944  m_Start.x + aOffset.x - bx,
945  m_Start.y + aOffset.y - by, 0, color );
946 
947  // lines for the bottom layer
948  ax = 0; ay = radius; bx = 0; by = drill_radius;
949  RotatePoint( &ax, &ay, layer_bottom * 3600.0 / brd->GetCopperLayerCount( ) );
950  RotatePoint( &bx, &by, layer_bottom * 3600.0 / brd->GetCopperLayerCount( ) );
951  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
952  m_Start.y + aOffset.y - ay,
953  m_Start.x + aOffset.x - bx,
954  m_Start.y + aOffset.y - by, 0, color );
955  }
956 
957  // Display the short netname:
959  return;
960 
961  if( displ_opts->m_DisplayNetNamesMode == 0 || displ_opts->m_DisplayNetNamesMode == 1 )
962  return;
963 
964  NETINFO_ITEM* net = GetNet();
965 
966  if( net == NULL )
967  return;
968 
969  int len = net->GetShortNetname().Len();
970 
971  if( len > 0 )
972  {
973  // calculate a good size for the text
974  int tsize = m_Width / len;
975 
976  if( aDC->LogicalToDeviceXRel( tsize ) >= MIN_TEXT_SIZE )
977  {
978  tsize = (tsize * 7) / 10; // small reduction to give a better look, inside via
979 
980  if( (aDrawMode & GR_XOR) == 0 )
981  GRSetDrawMode( aDC, GR_COPY );
982 
983  EDA_RECT* clipbox = panel->GetClipBox();
984  DrawGraphicHaloText( clipbox, aDC, m_Start,
985  color, WHITE, BLACK, net->GetShortNetname(), 0,
986  wxSize( tsize, tsize ),
988  tsize / 7, false, false );
989  }
990  }
991 }
992 
993 
994 void VIA::ViewGetLayers( int aLayers[], int& aCount ) const
995 {
996  aLayers[0] = LAYER_VIAS_HOLES;
997  aLayers[1] = LAYER_VIAS_NETNAMES;
998  aCount = 3;
999 
1000  // Just show it on common via & via holes layers
1001  switch( GetViaType() )
1002  {
1003  case VIA_THROUGH:
1004  aLayers[2] = LAYER_VIA_THROUGH;
1005  break;
1006 
1007  case VIA_BLIND_BURIED:
1008  aLayers[2] = LAYER_VIA_BBLIND;
1009  aLayers[3] = m_Layer;
1010  aLayers[4] = m_BottomLayer;
1011  aCount += 2;
1012  break;
1013 
1014  case VIA_MICROVIA:
1015  aLayers[2] = LAYER_VIA_MICROVIA;
1016  break;
1017 
1018  default:
1019  aLayers[2] = LAYER_GP_OVERLAY;
1020  wxASSERT( false );
1021  break;
1022  }
1023 }
1024 
1025 
1026 unsigned int VIA::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
1027 {
1028  BOARD* board = GetBoard();
1029 
1030  // Only draw the via if at least one of the layers it crosses is being displayed
1031  if( board && ( board->GetVisibleLayers() & GetLayerSet() ).any() )
1032  return 0;
1033 
1035 }
1036 
1037 
1038 // see class_track.h
1039 void TRACK::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
1040 {
1041  wxString msg;
1042  BOARD* board = GetBoard();
1043 
1044  // Display basic infos
1045  GetMsgPanelInfoBase( aList );
1046 
1047  // Display full track length (in Pcbnew)
1048  if( board )
1049  {
1050  double trackLen = 0;
1051  double lenPadToDie = 0;
1052  board->MarkTrace( this, NULL, &trackLen, &lenPadToDie, false );
1053  msg = ::LengthDoubleToString( trackLen );
1054  aList.push_back( MSG_PANEL_ITEM( _( "Length" ), msg, DARKCYAN ) );
1055 
1056  if( lenPadToDie != 0 )
1057  {
1058  msg = ::LengthDoubleToString( trackLen + lenPadToDie );
1059  aList.push_back( MSG_PANEL_ITEM( _( "Full Length" ), msg, DARKCYAN ) );
1060 
1061  msg = ::LengthDoubleToString( lenPadToDie );
1062  aList.push_back( MSG_PANEL_ITEM( _( "Pad To Die Length" ), msg, DARKCYAN ) );
1063  }
1064  }
1065 
1066  NETCLASSPTR netclass = GetNetClass();
1067 
1068  if( netclass )
1069  {
1070  aList.push_back( MSG_PANEL_ITEM( _( "NC Name" ), netclass->GetName(), DARKMAGENTA ) );
1071  aList.push_back( MSG_PANEL_ITEM( _( "NC Clearance" ),
1072  ::CoordinateToString( netclass->GetClearance(), true ),
1073  DARKMAGENTA ) );
1074  aList.push_back( MSG_PANEL_ITEM( _( "NC Width" ),
1075  ::CoordinateToString( netclass->GetTrackWidth(), true ),
1076  DARKMAGENTA ) );
1077  aList.push_back( MSG_PANEL_ITEM( _( "NC Via Size" ),
1078  ::CoordinateToString( netclass->GetViaDiameter(), true ),
1079  DARKMAGENTA ) );
1080  aList.push_back( MSG_PANEL_ITEM( _( "NC Via Drill"),
1081  ::CoordinateToString( netclass->GetViaDrill(), true ),
1082  DARKMAGENTA ) );
1083  }
1084 }
1085 
1086 void TRACK::GetMsgPanelInfoBase_Common( std::vector< MSG_PANEL_ITEM >& aList )
1087 {
1088  wxString msg;
1089 
1090  // Display Net Name
1091  if( GetBoard() )
1092  {
1093  NETINFO_ITEM* net = GetNet();
1094 
1095  if( net )
1096  msg = net->GetNetname();
1097  else
1098  msg = wxT( "<noname>" );
1099 
1100  aList.push_back( MSG_PANEL_ITEM( _( "NetName" ), msg, RED ) );
1101 
1102  // Display net code : (useful in test or debug)
1103  msg.Printf( wxT( "%d" ), GetNetCode() );
1104  aList.push_back( MSG_PANEL_ITEM( _( "NetCode" ), msg, RED ) );
1105  }
1106 
1107 #if defined(DEBUG)
1108 
1109  // Display the flags
1110  msg.Printf( wxT( "0x%08X" ), m_Flags );
1111  aList.push_back( MSG_PANEL_ITEM( wxT( "Flags" ), msg, BLUE ) );
1112 
1113 #if 0
1114  // Display start and end pointers:
1115  msg.Printf( wxT( "%p" ), start );
1116  aList.push_back( MSG_PANEL_ITEM( wxT( "start ptr" ), msg, BLUE ) );
1117  msg.Printf( wxT( "%p" ), end );
1118  aList.push_back( MSG_PANEL_ITEM( wxT( "end ptr" ), msg, BLUE ) );
1119  // Display this ptr
1120  msg.Printf( wxT( "%p" ), this );
1121  aList.push_back( MSG_PANEL_ITEM( wxT( "this" ), msg, BLUE ) );
1122 #endif
1123 
1124 #if 0
1125  // Display start and end positions:
1126  msg.Printf( wxT( "%d %d" ), m_Start.x, m_Start.y );
1127  aList.push_back( MSG_PANEL_ITEM( wxT( "Start pos" ), msg, BLUE ) );
1128  msg.Printf( wxT( "%d %d" ), m_End.x, m_End.y );
1129  aList.push_back( MSG_PANEL_ITEM( wxT( "End pos" ), msg, BLUE ) );
1130 #endif
1131 
1132 #endif // defined(DEBUG)
1133 
1134  // Display the State member
1135  msg = wxT( ". . " );
1136 
1137  if( GetState( TRACK_LOCKED ) )
1138  msg[0] = 'L';
1139 
1140  if( GetState( TRACK_AR ) )
1141  msg[2] = 'A';
1142 
1143  aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) );
1144 }
1145 
1146 void TRACK::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1147 {
1148  wxString msg;
1149  BOARD* board = GetBoard();
1150 
1151  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), _( "Track" ), DARKCYAN ) );
1152 
1153  GetMsgPanelInfoBase_Common( aList );
1154 
1155  // Display layer
1156  if( board )
1157  msg = board->GetLayerName( m_Layer );
1158  else
1159  msg.Printf(wxT("%d"), m_Layer );
1160 
1161  aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), msg, BROWN ) );
1162 
1163  // Display width
1164  msg = ::CoordinateToString( (unsigned) m_Width );
1165 
1166  aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, DARKCYAN ) );
1167 
1168  // Display segment length
1169  msg = ::LengthDoubleToString( GetLength() );
1170  aList.push_back( MSG_PANEL_ITEM( _( "Segment Length" ), msg, DARKCYAN ) );
1171 }
1172 
1173 void SEGZONE::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1174 {
1175  wxString msg;
1176  BOARD* board = GetBoard();
1177 
1178  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), _( "Zone " ), DARKCYAN ) );
1179 
1180  GetMsgPanelInfoBase_Common( aList );
1181 
1182  // Display layer
1183  if( board )
1184  msg = board->GetLayerName( m_Layer );
1185  else
1186  msg.Printf( wxT( "%d" ), m_Layer );
1187 
1188  aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), msg, BROWN ) );
1189 
1190  // Display width
1191  msg = ::CoordinateToString( (unsigned) m_Width );
1192 
1193  aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, DARKCYAN ) );
1194 
1195  // Display segment length
1196  msg = ::LengthDoubleToString( GetLength() );
1197  aList.push_back( MSG_PANEL_ITEM( _( "Segment Length" ), msg, DARKCYAN ) );
1198 }
1199 
1200 void VIA::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1201 {
1202  wxString msg;
1203  BOARD* board = GetBoard();
1204 
1205  switch( GetViaType() )
1206  {
1207  default:
1208  case VIA_NOT_DEFINED:
1209  msg = wxT( "???" ); // Not used yet, does not exist currently
1210  break;
1211 
1212  case VIA_MICROVIA:
1213  msg = _( "Micro Via" ); // from external layer (TOP or BOTTOM) from
1214  // the near neighbor inner layer only
1215  break;
1216 
1217  case VIA_BLIND_BURIED:
1218  msg = _( "Blind/Buried Via" ); // from inner or external to inner
1219  // or external layer (no restriction)
1220  break;
1221 
1222  case VIA_THROUGH:
1223  msg = _( "Through Via" ); // Usual via (from TOP to BOTTOM layer only )
1224  break;
1225  }
1226 
1227  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), msg, DARKCYAN ) );
1228 
1229  GetMsgPanelInfoBase_Common( aList );
1230 
1231 
1232  // Display layer pair
1233  PCB_LAYER_ID top_layer, bottom_layer;
1234 
1235  LayerPair( &top_layer, &bottom_layer );
1236 
1237  if( board )
1238  msg = board->GetLayerName( top_layer ) + wxT( "/" )
1239  + board->GetLayerName( bottom_layer );
1240  else
1241  msg.Printf( wxT( "%d/%d" ), top_layer, bottom_layer );
1242 
1243  aList.push_back( MSG_PANEL_ITEM( _( "Layers" ), msg, BROWN ) );
1244 
1245  // Display width
1246  msg = ::CoordinateToString( (unsigned) m_Width );
1247 
1248  // Display diameter value:
1249  aList.push_back( MSG_PANEL_ITEM( _( "Diameter" ), msg, DARKCYAN ) );
1250 
1251  // Display drill value
1252  int drill_value = GetDrillValue();
1253 
1254  msg = ::CoordinateToString( drill_value );
1255 
1256  wxString title = _( "Drill" );
1257  title += wxT( " " );
1258 
1259  bool drl_specific = true;
1260 
1261  if( GetBoard() )
1262  {
1263  NETINFO_ITEM* net = GetNet();
1264  int drill_class_value = 0;
1265 
1266  if( net )
1267  {
1268  if( GetViaType() == VIA_MICROVIA )
1269  drill_class_value = net->GetMicroViaDrillSize();
1270  else
1271  drill_class_value = net->GetViaDrillSize();
1272  }
1273 
1274  drl_specific = drill_value != drill_class_value;
1275  }
1276 
1277 
1278  if( drl_specific )
1279  title += _( "(Specific)" );
1280  else
1281  title += _( "(NetClass)" );
1282 
1283  aList.push_back( MSG_PANEL_ITEM( title, msg, RED ) );
1284 }
1285 
1286 
1287 bool TRACK::HitTest( const wxPoint& aPosition ) const
1288 {
1289  return TestSegmentHit( aPosition, m_Start, m_End, m_Width / 2 );
1290 }
1291 
1292 bool VIA::HitTest( const wxPoint& aPosition ) const
1293 {
1294  int max_dist = m_Width / 2;
1295 
1296  // rel_pos is aPosition relative to m_Start (or the center of the via)
1297  wxPoint rel_pos = aPosition - m_Start;
1298  double dist = (double) rel_pos.x * rel_pos.x + (double) rel_pos.y * rel_pos.y;
1299  return dist <= (double) max_dist * max_dist;
1300 }
1301 
1302 
1303 bool TRACK::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
1304 {
1305  EDA_RECT arect = aRect;
1306  arect.Inflate( aAccuracy );
1307 
1308  if( aContained )
1309  /* Tracks are a special case:
1310  * they are considered inside the rect if one end is inside the rect */
1311  return arect.Contains( GetStart() ) || arect.Contains( GetEnd() );
1312  else
1313  return arect.Intersects( GetStart(), GetEnd() );
1314 }
1315 
1316 bool VIA::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
1317 {
1318  EDA_RECT box;
1319  EDA_RECT arect = aRect;
1320  arect.Inflate( aAccuracy );
1321 
1322  box.SetOrigin( GetStart() );
1323  box.Inflate( GetWidth() / 2 );
1324 
1325  if( aContained )
1326  {
1327  return arect.Contains( box );
1328  }
1329  else
1330  {
1331  return arect.IntersectsCircle( GetStart(), GetWidth() / 2 );
1332  }
1333 }
1334 
1335 
1336 VIA* TRACK::GetVia( const wxPoint& aPosition, PCB_LAYER_ID aLayer)
1337 {
1338  for( VIA* via = GetFirstVia( this ); via; via = GetFirstVia( via->Next() ) )
1339  {
1340  if( via->HitTest( aPosition ) &&
1341  !via->GetState( BUSY | IS_DELETED ) &&
1342  ((aLayer == UNDEFINED_LAYER) || (via->IsOnLayer( aLayer ))) )
1343  return via;
1344  }
1345 
1346  return NULL;
1347 }
1348 
1349 
1350 VIA* TRACK::GetVia( TRACK* aEndTrace, const wxPoint& aPosition, LSET aLayerMask )
1351 {
1352  for( VIA* via = GetFirstVia( this, aEndTrace ); via; via = GetFirstVia( via->Next() ) )
1353  {
1354  if( via->HitTest( aPosition ) &&
1355  !via->GetState( BUSY | IS_DELETED ) &&
1356  ( aLayerMask & via->GetLayerSet() ).any()
1357  )
1358  {
1359  return via;
1360  }
1361  }
1362 
1363  return NULL;
1364 }
1365 
1366 
1367 TRACK* TRACK::GetTrack( TRACK* aStartTrace, TRACK* aEndTrace, ENDPOINT_T aEndPoint,
1368  bool aSameNetOnly, bool aSequential )
1369 {
1370  const wxPoint& position = GetEndPoint( aEndPoint );
1371  LSET refLayers = GetLayerSet();
1372  TRACK* previousSegment;
1373  TRACK* nextSegment;
1374 
1375  if( aSequential )
1376  {
1377  // Simple sequential search: from aStartTrace forward to aEndTrace
1378  previousSegment = NULL;
1379  nextSegment = aStartTrace;
1380  }
1381  else
1382  {
1383  /* Local bidirectional search: from this backward to aStartTrace
1384  * AND forward to aEndTrace. The idea is that nearest segments
1385  * are found (on average) faster in this way. In fact same-net
1386  * segments are almost guaranteed to be found faster, in a global
1387  * search, since they are grouped together in the track list */
1388  previousSegment = this;
1389  nextSegment = this;
1390  }
1391 
1392  while( nextSegment || previousSegment )
1393  {
1394  // Terminate the search in the direction if the netcode mis-matches
1395  if( aSameNetOnly )
1396  {
1397  if( nextSegment && (nextSegment->GetNetCode() != GetNetCode()) )
1398  nextSegment = NULL;
1399  if( previousSegment && (previousSegment->GetNetCode() != GetNetCode()) )
1400  previousSegment = NULL;
1401  }
1402 
1403  if( nextSegment )
1404  {
1405  if ( (nextSegment != this) &&
1406  !nextSegment->GetState( BUSY | IS_DELETED ) &&
1407  ( refLayers & nextSegment->GetLayerSet() ).any() )
1408  {
1409  if( (position == nextSegment->m_Start) ||
1410  (position == nextSegment->m_End) )
1411  return nextSegment;
1412  }
1413 
1414  // Keep looking forward
1415  if( nextSegment == aEndTrace )
1416  nextSegment = NULL;
1417  else
1418  nextSegment = nextSegment->Next();
1419  }
1420 
1421  // Same as above, looking back. During sequential search this branch is inactive
1422  if( previousSegment )
1423  {
1424  if( (previousSegment != this) &&
1425  !previousSegment->GetState( BUSY | IS_DELETED ) &&
1426  ( refLayers & previousSegment->GetLayerSet() ).any()
1427  )
1428  {
1429  if( (position == previousSegment->m_Start) ||
1430  (position == previousSegment->m_End) )
1431  return previousSegment;
1432  }
1433 
1434  if( previousSegment == aStartTrace )
1435  previousSegment = NULL;
1436  else
1437  previousSegment = previousSegment->Back();
1438  }
1439  }
1440 
1441  return NULL;
1442 }
1443 
1444 
1445 int TRACK::GetEndSegments( int aCount, TRACK** aStartTrace, TRACK** aEndTrace )
1446 {
1447  TRACK* Track, * via, * segm, * TrackListEnd;
1448  int NbEnds, ii, ok = 0;
1449  LSET layerMask;
1450 
1451  if( aCount <= 1 )
1452  {
1453  *aStartTrace = *aEndTrace = this;
1454  return 1;
1455  }
1456 
1457  // Calculation of the limit analysis.
1458  *aStartTrace = *aEndTrace = NULL;
1459  TrackListEnd = Track = this;
1460  ii = 0;
1461 
1462  for( ; ( Track != NULL ) && ( ii < aCount ); ii++, Track = Track->Next() )
1463  {
1464  TrackListEnd = Track;
1465  Track->m_Param = 0;
1466  }
1467 
1468  // Calculate the extremes.
1469  NbEnds = 0;
1470  Track = this;
1471  ii = 0;
1472 
1473  for( ; ( Track != NULL ) && ( ii < aCount ); ii++, Track = Track->Next() )
1474  {
1475  if( Track->Type() == PCB_VIA_T )
1476  continue;
1477 
1478  layerMask = Track->GetLayerSet();
1479  via = GetVia( TrackListEnd, Track->m_Start, layerMask );
1480 
1481  if( via )
1482  {
1483  layerMask |= via->GetLayerSet();
1484  via->SetState( BUSY, true );
1485  }
1486 
1487  Track->SetState( BUSY, true );
1488  segm = ::GetTrack( this, TrackListEnd, Track->m_Start, layerMask );
1489  Track->SetState( BUSY, false );
1490 
1491  if( via )
1492  via->SetState( BUSY, false );
1493 
1494  if( segm == NULL )
1495  {
1496  switch( NbEnds )
1497  {
1498  case 0:
1499  *aStartTrace = Track; NbEnds++;
1500  break;
1501 
1502  case 1:
1503  int BeginPad, EndPad;
1504  *aEndTrace = Track;
1505 
1506  // Swap ox, oy with fx, fy
1507  BeginPad = Track->GetState( BEGIN_ONPAD );
1508  EndPad = Track->GetState( END_ONPAD );
1509 
1510  Track->SetState( BEGIN_ONPAD | END_ONPAD, false );
1511 
1512  if( BeginPad )
1513  Track->SetState( END_ONPAD, true );
1514 
1515  if( EndPad )
1516  Track->SetState( BEGIN_ONPAD, true );
1517 
1518  std::swap( Track->m_Start, Track->m_End );
1519  std::swap( Track->start, Track->end );
1520  ok = 1;
1521  return ok;
1522  }
1523  }
1524 
1525  layerMask = Track->GetLayerSet();
1526  via = GetVia( TrackListEnd, Track->m_End, layerMask );
1527 
1528  if( via )
1529  {
1530  layerMask |= via->GetLayerSet();
1531  via->SetState( BUSY, true );
1532  }
1533 
1534  Track->SetState( BUSY, true );
1535  segm = ::GetTrack( this, TrackListEnd, Track->m_End, layerMask );
1536  Track->SetState( BUSY, false );
1537 
1538  if( via )
1539  via->SetState( BUSY, false );
1540 
1541  if( segm == NULL )
1542  {
1543  switch( NbEnds )
1544  {
1545  case 0:
1546  int BeginPad, EndPad;
1547  *aStartTrace = Track;
1548  NbEnds++;
1549 
1550  // Swap ox, oy with fx, fy
1551  BeginPad = Track->GetState( BEGIN_ONPAD );
1552  EndPad = Track->GetState( END_ONPAD );
1553 
1554  Track->SetState( BEGIN_ONPAD | END_ONPAD, false );
1555 
1556  if( BeginPad )
1557  Track->SetState( END_ONPAD, true );
1558 
1559  if( EndPad )
1560  Track->SetState( BEGIN_ONPAD, true );
1561 
1562  std::swap( Track->m_Start, Track->m_End );
1563  std::swap( Track->start, Track->end );
1564  break;
1565 
1566  case 1:
1567  *aEndTrace = Track;
1568  ok = 1;
1569  return ok;
1570  }
1571  }
1572  }
1573 
1574  return ok;
1575 }
1576 
1577 
1579 {
1580  wxString text;
1581  wxString netname;
1582  NETINFO_ITEM* net;
1583  BOARD* board = GetBoard();
1584 
1585  // deleting tracks requires all the information we can get to
1586  // disambiguate all the choices under the cursor!
1587  if( board )
1588  {
1589  net = GetNet();
1590 
1591  if( net )
1592  netname = net->GetNetname();
1593  else
1594  netname = _("Not found");
1595  }
1596  else
1597  {
1598  wxFAIL_MSG( wxT( "TRACK::GetSelectMenuText: BOARD is NULL" ) );
1599  netname = wxT( "???" );
1600  }
1601 
1602  text.Printf( _("Track %s, net [%s] (%d) on layer %s, length: %s" ),
1603  GetChars( ShowWidth() ), GetChars( netname ),
1606 
1607  return text;
1608 }
1609 
1610 
1612 {
1613  return add_tracks_xpm;
1614 }
1615 
1617 {
1618  assert( aImage->Type() == PCB_TRACE_T );
1619 
1620  std::swap( *((TRACK*) this), *((TRACK*) aImage) );
1621 }
1622 
1623 void VIA::SwapData( BOARD_ITEM* aImage )
1624 {
1625  assert( aImage->Type() == PCB_VIA_T );
1626 
1627  std::swap( *((VIA*) this), *((VIA*) aImage) );
1628 }
1629 
1630 #if defined(DEBUG)
1631 
1632 wxString TRACK::ShowState( int stateBits )
1633 {
1634  wxString ret;
1635 
1636  if( stateBits & IS_LINKED )
1637  ret << wxT( " | IS_LINKED" );
1638 
1639  if( stateBits & TRACK_AR )
1640  ret << wxT( " | TRACK_AR" );
1641 
1642  if( stateBits & TRACK_LOCKED )
1643  ret << wxT( " | TRACK_LOCKED" );
1644 
1645  if( stateBits & IN_EDIT )
1646  ret << wxT( " | IN_EDIT" );
1647 
1648  if( stateBits & IS_DRAGGED )
1649  ret << wxT( " | IS_DRAGGED" );
1650 
1651  if( stateBits & DO_NOT_DRAW )
1652  ret << wxT( " | DO_NOT_DRAW" );
1653 
1654  if( stateBits & IS_DELETED )
1655  ret << wxT( " | IS_DELETED" );
1656 
1657  if( stateBits & BUSY )
1658  ret << wxT( " | BUSY" );
1659 
1660  if( stateBits & END_ONPAD )
1661  ret << wxT( " | END_ONPAD" );
1662 
1663  if( stateBits & BEGIN_ONPAD )
1664  ret << wxT( " | BEGIN_ONPAD" );
1665 
1666  if( stateBits & FLAG0 )
1667  ret << wxT( " | FLAG0" );
1668 
1669  if( stateBits & FLAG1 )
1670  ret << wxT( " | FLAG1" );
1671 
1672  return ret;
1673 }
1674 
1675 #endif
#define MIN_VIA_DRAW_SIZE
Definition: class_track.h:62
Definition: colors.h:57
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:646
#define IS_LINKED
Used in calculation to mark linked items (temporary use)
Definition: base_struct.h:124
wxString CoordinateToString(int aValue, bool aConvertToMils)
Function CoordinateToString is a helper to convert the integer coordinate aValue to a string in inche...
Definition: base_units.cpp:118
#define FLAG1
Pcbnew: flag used in local computations.
Definition: base_struct.h:144
KICAD_T Type() const
Function Type()
Definition: base_struct.h:225
void DrawGraphicHaloText(EDA_RECT *aClipBox, wxDC *aDC, const wxPoint &aPos, const COLOR4D aBgColor, COLOR4D aColor1, COLOR4D aColor2, const wxString &aText, double aOrient, const wxSize &aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, void(*aCallback)(int x0, int y0, int xf, int yf), PLOTTER *aPlotter)
Draw graphic text with a border, so that it can be read on different backgrounds. ...
Definition: drawtxt.cpp:176
to draw blind/buried vias
TRACK * GetTrack(TRACK *aStartTrace, TRACK *aEndTrace, ENDPOINT_T aEndPoint, bool aSameNetOnly, bool aSequential)
Function GetTrack returns the trace segment connected to the segment at aEndPoint from aStartTrace to...
bool IsNull()
Function IsNull returns true if segment length is zero.
TRACK * GetTrack(TRACK *aStartTrace, const TRACK *aEndTrace, const wxPoint &aPosition, LSET aLayerMask)
Function GetTrack is a helper function to locate a trace segment having an end point at aPosition on ...
Definition: class_track.cpp:68
bool IsMoving() const
Definition: base_struct.h:245
#define IN_EDIT
Item currently edited.
Definition: base_struct.h:125
wxPoint m_Start
Line start point.
Definition: class_track.h:338
timestamp_t m_TimeStamp
Time stamp used for logical links.
Definition: base_struct.h:196
double GetLineLength(const wxPoint &aPointA, const wxPoint &aPointB)
Function GetLineLength returns the length of a line segment defined by aPointA and aPointB...
Definition: trigo.h:191
virtual void SwapData(BOARD_ITEM *aImage) override
Swap data between aItem and aImage.
PNG memory record (file in memory).
Definition: bitmap_types.h:38
#define END_ONPAD
Pcbnew: flag set for track segment ending on a pad.
Definition: base_struct.h:147
void GRSetDrawMode(wxDC *DC, GR_DRAWMODE draw_mode)
Definition: gr_basic.cpp:296
virtual LSET GetLayerSet() const override
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
void SetViaType(VIATYPE_T aViaType)
Definition: class_track.h:444
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
wxString GetSelectMenuText() const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Function IsOnLayer tests to see if this object is on the given layer.
int GetNetnameLayer(int aLayer)
Returns a netname layer corresponding to the given layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
Implementation of conversion functions that require both schematic and board internal units...
bool IsNew() const
Definition: base_struct.h:243
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
bool Contains(const wxPoint &aPoint) const
Function Contains.
virtual void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
bool IntersectsCircle(const wxPoint &aCenter, const int aRadius) const
Function IntersectsCircle tests for a common area between a circle and this rectangle.
Class BOARD to handle a board.
Definition: colors.h:61
STATUS_FLAGS IsPointOnEnds(const wxPoint &point, int min_dist=0)
Function IsPointOnEnds returns STARTPOINT if point if near (dist = min_dist) start point...
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount)
Function FlippedLayerNumber.
Definition: lset.cpp:445
int GetCopperLayerCount() const
Function GetCopperLayerCount.
static const int dist[10][10]
Definition: dist.cpp:57
const EDA_RECT GetBoundingBox() const override
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
virtual void ViewGetLayers(int aLayers[], int &aCount) const override
Function ViewGetLayers() Returns the all the layers within the VIEW the object is painted on...
virtual EDA_ITEM * Clone() const override
Function Clone creates a duplicate of this item with linked list members set to NULL.
to draw via holes (pad holes do not use this layer)
double RAD2DECIDEG(double rad)
Definition: trigo.h:204
void SetOrigin(const wxPoint &pos)
void GRCSegm(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int aPenSize, COLOR4D Color)
Definition: gr_basic.cpp:488
int GetEndSegments(int NbSegm, TRACK **StartTrack, TRACK **EndTrack)
Function GetEndSegments get the segments connected to the end point of the track. ...
DLIST< SEGZONE > m_Zone
Definition: class_board.h:247
void GetMsgPanelInfo(std::vector< MSG_PANEL_ITEM > &aList) override
Function GetMsgPanelInfo populates aList of MSG_PANEL_ITEM objects with it's internal state for displ...
static bool ShowClearance(PCB_DISPLAY_OPTIONS *aDisplOpts, const TRACK *aTrack)
Function ShowClearance tests to see if the clearance border is drawn on the given track...
Definition: class_track.cpp:55
#define BUSY
Pcbnew: flag indicating that the structure has.
Definition: base_struct.h:148
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
VIA(BOARD_ITEM *aParent)
virtual void Rotate(const wxPoint &aRotCentre, double aAngle) override
Function Rotate Rotate this object.
int GetState(int type) const
Definition: base_struct.h:264
void GRFilledCircle(EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:851
#define BEGIN_ONPAD
Pcbnew: flag set for track segment starting on a pad.
Definition: base_struct.h:146
Class BOARD_CONNECTED_ITEM is a base class derived from BOARD_ITEM for items that can be connected an...
TRACK * Back() const
Definition: class_track.h:101
wxString GetLayerName() const
Function GetLayerName returns the name of the PCB layer on which the item resides.
const wxPoint & GetEnd() const
Definition: class_track.h:120
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:78
Functions relatives to tracks, vias and segments used to fill zones.
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
void * GetDisplayOptions() override
Function GetDisplayOptions returns the display options current in use Display options are relative to...
double m_Param
Definition: class_track.h:94
TRACE_CLEARANCE_DISPLAY_MODE_T m_ShowTrackClearanceMode
How trace clearances are displayed.
int m_Width
Thickness of track, or via diameter.
Definition: class_track.h:337
This file contains miscellaneous commonly used macros and functions.
ENDPOINT_T
Flag used in locate routines (from which endpoint work)
Definition: pcbnew.h:54
virtual void GetMsgPanelInfoBase(std::vector< MSG_PANEL_ITEM > &aList) override
Function GetMsgPanelInfoBase Display info about the track segment only, and does not calculate the fu...
virtual unsigned int ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Function ViewGetLOD() Returns the level of detail (LOD) of the item.
#define THRESHOLD
COLOR4D GetItemColor(int aItemIdx) const
Function GetItemColor.
const INSPECTOR_FUNC & INSPECTOR
Definition: base_struct.h:118
#define IS_DRAGGED
Item being dragged.
Definition: base_struct.h:129
PCB_LAYER_ID m_Layer
const wxString & GetShortNetname() const
Function GetShortNetname.
VIA * GetVia(const wxPoint &aPosition, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)
Function GetVia finds the first VIA object at aPosition on aLayer starting at the trace...
Class PCB_DISPLAY_OPTIONS handles display options like enable/disable some optional drawings...
PCB_LAYER_ID
A quick note on layer IDs:
virtual bool HitTest(const wxPoint &aPosition) const override
Function HitTest tests if aPosition is contained within or on the bounding area of an item...
double a
Alpha component.
Definition: color4d.h:294
BITMAP_DEF GetMenuImage() const override
Function GetMenuImage returns a pointer to an image to be used in menus.
Class LSET is a set of PCB_LAYER_IDs.
Classes used in Pcbnew, CvPcb and GerbView.
VIATYPE_T GetViaType() const
Definition: class_track.h:443
#define MIN_TEXT_SIZE
Definition: drawtxt.h:43
std::shared_ptr< NETCLASS > GetNetClass() const
Function GetNetClass returns the NETCLASS for this item.
BITMAP_DEF GetMenuImage() const override
Function GetMenuImage returns a pointer to an image to be used in menus.
void GRForceBlackPen(bool flagforce)
Function GRForceBlackPen.
Definition: gr_basic.cpp:277
GR_DRAWMODE
Drawmode. Compositing mode plus a flag or two.
Definition: gr_basic.h:41
Base window classes and related definitions.
void GRFillCSegm(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
Definition: gr_basic.cpp:591
#define IS_DELETED
Definition: base_struct.h:130
PCB_GENERAL_SETTINGS & Settings()
virtual bool HitTest(const wxPoint &aPosition) const override
Function HitTest tests if aPosition is contained within or on the bounding area of an item...
const wxPoint & GetStart() const
Definition: class_track.h:123
virtual void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
wxPoint m_End
Line end point.
Definition: class_track.h:339
to draw usual through hole vias
int m_Drill
Definition: class_track.h:491
void DrawShortNetname(EDA_DRAW_PANEL *panel, wxDC *aDC, GR_DRAWMODE aDrawMode, COLOR4D aBgColor)
Helper for drawing the short netname in tracks.
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Function GetLayerName returns the name of a layer given by aLayer.
const wxPoint & GetEndPoint(ENDPOINT_T aEndPoint) const
Return the selected endpoint (start or end)
Definition: class_track.h:127
virtual LSET GetLayerSet() const
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
unsigned STATUS_FLAGS
Definition: base_struct.h:158
SEARCH_RESULT Visit(INSPECTOR inspector, void *testData, const KICAD_T scanTypes[]) override
Function Visit may be re-implemented for each derived class in order to handle all the types given by...
PCB_LAYER_ID m_BottomLayer
The bottom layer of the via (the top layer is in m_Layer)
Definition: class_track.h:487
EDA_RECT * GetClipBox()
virtual unsigned int ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Function ViewGetLOD() Returns the level of detail (LOD) of the item.
TRACK * GetEndNetCode(int NetCode)
wxString LengthDoubleToString(double aValue, bool aConvertToMils)
Function LengthDoubleToString is a helper to convert the double length aValue to a string in inches...
Definition: base_units.cpp:123
general purpose overlay
#define TRACK_LOCKED
Pcbnew: track locked: protected from global deletion.
Definition: base_struct.h:142
Definition: colors.h:60
void SetLayerPair(PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)
Function SetLayerPair For a via m_Layer contains the top layer, the other layer is in m_BottomLayer...
class SEGZONE, a segment used to fill a zone area (segment on a copper layer)
Definition: typeinfo.h:97
EDA_DRAW_FRAME * GetParent() const
Definition: draw_panel.cpp:174
TRACK * MarkTrace(TRACK *aTrace, int *aCount, double *aTraceLength, double *aInPackageLength, bool aReorder)
Function MarkTrace marks a chain of trace segments, connected to aTrace.
virtual int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const
Function GetClearance returns the clearance in internal units.
virtual int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
Definition: gr_basic.cpp:358
virtual wxString GetSelectMenuText() const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
virtual void SwapData(BOARD_ITEM *aImage) override
Swap data between aItem and aImage.
#define FLAG0
Pcbnew: flag used in local computations.
Definition: base_struct.h:145
SEGZONE(BOARD_ITEM *aParent)
void Draw(EDA_DRAW_PANEL *panel, wxDC *DC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset=ZeroOffset) override
Function Draw BOARD_ITEMs have their own color information.
void SetDrillDefault()
Function SetDrillDefault sets the drill value for vias to the default value UNDEFINED_DRILL_DIAMETER...
Definition: class_track.h:472
COLORS_DESIGN_SETTINGS & Colors()
#define TRACK_AR
Pcbnew: autorouted track.
Definition: base_struct.h:143
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Function LayerPair Return the 2 layers used by the via (the via actually uses all layers between thes...
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
int GetNetCode() const
Function GetNetCode.
void Draw(EDA_DRAW_PANEL *panel, wxDC *DC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset=ZeroOffset) override
Function Draw BOARD_ITEMs have their own color information.
void Draw(EDA_DRAW_PANEL *panel, wxDC *DC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset=ZeroOffset) override
Function Draw BOARD_ITEMs have their own color information.
wxString GetSelectMenuText() const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
virtual void ViewGetLayers(int aLayers[], int &aCount) const override
Function ViewGetLayers() Returns the all the layers within the VIEW the object is painted on...
bool Intersects(const EDA_RECT &aRect) const
Function Intersects tests for a common area between rectangles.
Class NETINFO_ITEM handles the data for a net.
Definition: class_netinfo.h:69
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
wxString ShowWidth() const
Function ShowWidth returns the width of the track in displayable user units.
TRACK * GetBestInsertPoint(BOARD *aPcb)
Function GetBestInsertPoint searches the "best" insertion point within the track linked list...
BITMAP_DEF GetMenuImage() const override
Function GetMenuImage returns a pointer to an image to be used in menus.
TRACK * Next() const
Definition: class_track.h:100
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
const wxString & GetNetname() const
Function GetNetname.
void SetState(int type, int state)
Definition: base_struct.h:269
EDA_ITEM * Clone() const override
Function Clone creates a duplicate of this item with linked list members set to NULL.
TRACK * GetStartNetCode(int NetCode)
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
#define max(a, b)
Definition: auxiliary.h:86
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
void GetMsgPanelInfoBase_Common(std::vector< MSG_PANEL_ITEM > &aList)
Helper function for the common panel info.
int GetWidth() const
Definition: class_track.h:117
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
LSET GetVisibleLayers() const
Function GetVisibleLayers is a proxy function that calls the correspondent function in m_BoardSetting...
void GRCircle(EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, int r, int width, COLOR4D Color)
Definition: gr_basic.cpp:828
STATUS_FLAGS m_Flags
Flag bits for editing and other uses.
Definition: base_struct.h:202
#define ENDPOINT
Definition: base_struct.h:133
Class EDA_RECT handles the component boundary box.
BASE_SCREEN * GetScreen()
Definition: draw_panel.cpp:187
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:178
The common library.
PCB_SCREEN * GetScreen() const override
Function GetScreen returns a pointer to a BASE_SCREEN or one of its derivatives.
virtual void GetMsgPanelInfoBase(std::vector< MSG_PANEL_ITEM > &aList)
Function GetMsgPanelInfoBase Display info about the track segment only, and does not calculate the fu...
Definition: colors.h:49
int GetMicroViaDrillSize()
Function GetViaDrillSize returns the size of via drills used to route this net.
double GetLength() const
Function GetLength returns the length of the track using the hypotenuse calculation.
Definition: class_track.h:173
virtual BOARD * GetBoard() const
Function GetBoard returns the BOARD in which this BOARD_ITEM resides, or NULL if none.
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
This file is part of the common libary.
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
TRACK(BOARD_ITEM *aParent, KICAD_T idtype=PCB_TRACE_T)
Definition: class_track.cpp:96
DLIST< TRACK > m_Track
Definition: class_board.h:246
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Function IsOnLayer tests to see if this object is on the given layer.
Definition: colors.h:45
const wxString & GetNetname() const
Function GetNetname.
void * GetDisplayOptions()
Function GetDisplayOptions A way to pass info to draw functions.
Definition: draw_panel.cpp:181
Class EDA_MSG_ITEM is used EDA_MSG_PANEL as the item type for displaying messages.
Definition: msgpanel.h:53
Class VIEW.
Definition: view.h:58
bool TestSegmentHit(const wxPoint &aRefPoint, wxPoint aStart, wxPoint aEnd, int aDist)
Function TestSegmentHit test for hit on line segment i.e.
Definition: trigo.cpp:142
SEARCH_RESULT
Definition: base_struct.h:82
bool GetGRForceBlackPenState(void)
Function GetGRForceBlackPenState.
Definition: gr_basic.cpp:287
int GetViaDrillSize()
Function GetViaDrillSize returns the size of via drills used to route this net.
Message panel definition file.
#define FORCE_SKETCH
Definition: pcbnew.h:68
BOARD_CONNECTED_ITEM * end
Definition: class_track.h:92
virtual void GetMsgPanelInfoBase(std::vector< MSG_PANEL_ITEM > &aList) override
Function GetMsgPanelInfoBase Display info about the track segment only, and does not calculate the fu...
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
BOARD_CONNECTED_ITEM * start
Definition: class_track.h:91
EDA_ITEM * Pnext
next in linked list
Definition: base_struct.h:191
class PCB_BASE_FRAME basic PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer...
NETINFO_ITEM * GetNet() const
Function GetNet Returns NET_INFO object for a given item.
#define DO_NOT_DRAW
Used to disable draw function.
Definition: base_struct.h:139
EDA_RECT & Inflate(wxCoord dx, wxCoord dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
EDA_ITEM * Clone() const override
Function Clone creates a duplicate of this item with linked list members set to NULL.
bool IsNetnameLayer(LAYER_NUM aLayer)
Function IsNetnameLayer tests whether a layer is a netname layer.
#define min(a, b)
Definition: auxiliary.h:85
#define STARTPOINT
Definition: base_struct.h:132
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
Function IsLayerVisible is a proxy function that calls the correspondent function in m_BoardSettings ...
Definition: class_board.h:451
bool IsDragging() const
Definition: base_struct.h:246
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
Definition: colors.h:62
VIA * GetFirstVia(TRACK *aTrk, const TRACK *aStopPoint=NULL)
Scan a track list for the first VIA o NULL if not found (or NULL passed)
Definition: class_track.h:496