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 
32 #include <fctsys.h>
33 #include <gr_basic.h>
34 #include <common.h>
35 #include <trigo.h>
36 #include <macros.h>
37 #include <class_drawpanel.h>
38 #include <class_pcb_screen.h>
39 #include <drawtxt.h>
40 #include <colors_selection.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( 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_sketch_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  DISPLAY_OPTIONS* displ_opts = (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();
641 
642  if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )
643  return;
644 
645 #ifdef USE_WX_OVERLAY
646  // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay
647  if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))
648  return;
649 #endif
650 
651  DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*) panel->GetDisplayOptions();
652 
653  if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )
654  {
655  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
656 
657  if( !IsOnLayer( curr_layer ) )
658  color = COLOR4D( DARKDARKGRAY );
659  }
660 
661  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
662  color.SetToLegacyHighlightColor();
663 
664  color.a = 0.588;
665 
666  GRSetDrawMode( aDC, aDrawMode );
667 
668  // Draw track as line if width <= 1pixel:
669  if( aDC->LogicalToDeviceXRel( m_Width ) <= 1 )
670  {
671  GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
672  return;
673  }
674 
675  if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
676  {
677  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
678  }
679  else
680  {
681  GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
682  m_Start.y + aOffset.y,
683  m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );
684  }
685 
686  if( panel->GetScreen()->m_IsPrinting )
687  return;
688 
689  // Show clearance for tracks, not for zone segments
690  if( ShowClearance( displ_opts, this ) )
691  {
692  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset,
693  m_Width + (GetClearance() * 2), color );
694  }
695 
696  DrawShortNetname( panel, aDC, aDrawMode, color );
697 }
698 
699 
700 void SEGZONE::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode,
701  const wxPoint& aOffset )
702 {
703  DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)panel->GetDisplayOptions();
704 
705  if( displ_opts->m_DisplayZonesMode != 0 )
706  return;
707 
708  BOARD* brd = GetBoard();
710 
711  if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )
712  return;
713 
714 #ifdef USE_WX_OVERLAY
715  // If dragged not draw in OnPaint otherwise remains impressed in wxOverlay
716  if( (m_Flags & IS_DRAGGED) && aDC->IsKindOf(wxCLASSINFO(wxPaintDC)))
717  return;
718 #endif
719 
720  if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts->m_ContrastModeDisplay )
721  {
722  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
723 
724  if( !IsOnLayer( curr_layer ) )
725  color = COLOR4D( DARKDARKGRAY );
726  }
727 
728  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
729  color.SetToLegacyHighlightColor();
730 
731  color.a = 0.588;
732 
733  GRSetDrawMode( aDC, aDrawMode );
734 
735  // Draw track as line if width <= 1pixel:
736  if( aDC->LogicalToDeviceXRel( m_Width ) <= 1 )
737  {
738  GRLine( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
739  return;
740  }
741 
742  if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
743  {
744  GRCSegm( panel->GetClipBox(), aDC, m_Start + aOffset, m_End + aOffset, m_Width, color );
745  }
746  else
747  {
748  GRFillCSegm( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
749  m_Start.y + aOffset.y,
750  m_End.x + aOffset.x, m_End.y + aOffset.y, m_Width, color );
751  }
752 
753  // No clearance or netnames for zones
754 }
755 
756 
757 void TRACK::ViewGetLayers( int aLayers[], int& aCount ) const
758 {
759  // Show the track and its netname on different layers
760  aLayers[0] = GetLayer();
761  aLayers[1] = GetNetnameLayer( aLayers[0] );
762  aCount = 2;
763 }
764 
765 
766 unsigned int TRACK::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
767 {
768  // Netnames will be shown only if zoom is appropriate
769  if( IsNetnameLayer( aLayer ) )
770  {
771  return ( 40000000 / ( m_Width + 1 ) );
772  }
773 
774  // Other layers are shown without any conditions
775  return 0;
776 }
777 
778 
779 void VIA::Draw( EDA_DRAW_PANEL* panel, wxDC* aDC, GR_DRAWMODE aDrawMode, const wxPoint& aOffset )
780 {
781  wxCHECK_RET( panel != NULL, wxT( "VIA::Draw panel cannot be NULL." ) );
782 
783  int radius;
784  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
785 
786  int fillvia = 0;
787  PCB_BASE_FRAME* frame = (PCB_BASE_FRAME*) panel->GetParent();
788  PCB_SCREEN* screen = frame->GetScreen();
789  DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)frame->GetDisplayOptions();
790 
791  if( displ_opts->m_DisplayViaFill == FILLED )
792  fillvia = 1;
793 
794  GRSetDrawMode( aDC, aDrawMode );
795 
796  BOARD * brd = GetBoard();
798 
799  if( brd->IsElementVisible( LAYER_VIAS + GetViaType() ) == false
800  && !( aDrawMode & GR_HIGHLIGHT ) )
801  return;
802 
803  // Only draw the via if at least one of the layers it crosses is being displayed
804  if( !( brd->GetVisibleLayers() & GetLayerSet() ).any() )
805  return;
806 
807  if( displ_opts->m_ContrastModeDisplay )
808  {
809  if( !IsOnLayer( curr_layer ) )
810  color = COLOR4D( DARKDARKGRAY );
811  }
812 
813  if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
814  color.SetToLegacyHighlightColor();
815 
816  color.a = 0.588;
817 
818 
819  radius = m_Width >> 1;
820  // for small via size on screen (radius < 4 pixels) draw a simplified shape
821 
822  int radius_in_pixels = aDC->LogicalToDeviceXRel( radius );
823 
824  bool fast_draw = false;
825 
826  // Vias are drawn as a filled circle or a double circle. The hole will be drawn later
827  int drill_radius = GetDrillValue() / 2;
828 
829  int inner_radius = radius - aDC->DeviceToLogicalXRel( 2 );
830 
831  if( radius_in_pixels < MIN_VIA_DRAW_SIZE )
832  {
833  fast_draw = true;
834  fillvia = false;
835  }
836 
837  if( fillvia )
838  {
839  GRFilledCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius, color );
840  }
841  else
842  {
843  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius, 0, color );
844 
845  if ( fast_draw )
846  return;
847 
848  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, inner_radius, 0, color );
849  }
850 
851  if( fillvia )
852  {
853  bool blackpenstate = false;
854 
855  if( screen->m_IsPrinting )
856  {
857  blackpenstate = GetGRForceBlackPenState();
858  GRForceBlackPen( false );
859  color = WHITE;
860  }
861  else
862  {
863  color = BLACK; // or DARKGRAY;
864  }
865 
866  if( (aDrawMode & GR_XOR) == 0)
867  GRSetDrawMode( aDC, GR_COPY );
868 
869  // Draw hole if the radius is > 1pixel.
870  if( aDC->LogicalToDeviceXRel( drill_radius ) > 1 )
871  GRFilledCircle( panel->GetClipBox(), aDC, m_Start.x + aOffset.x,
872  m_Start.y + aOffset.y, drill_radius, 0, color, color );
873 
874  if( screen->m_IsPrinting )
875  GRForceBlackPen( blackpenstate );
876  }
877  else
878  {
879  if( drill_radius < inner_radius ) // We can show the via hole
880  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, drill_radius, 0, color );
881  }
882 
883  if( ShowClearance( displ_opts, this ) )
884  {
885  GRCircle( panel->GetClipBox(), aDC, m_Start + aOffset, radius + GetClearance(), 0, color );
886  }
887 
888  // for Micro Vias, draw a partial cross : X on component layer, or + on copper layer
889  // (so we can see 2 superimposed microvias ):
890  if( GetViaType() == VIA_MICROVIA )
891  {
892  int ax, ay, bx, by;
893 
894  if( IsOnLayer( B_Cu ) )
895  {
896  ax = radius; ay = 0;
897  bx = drill_radius; by = 0;
898  }
899  else
900  {
901  ax = ay = (radius * 707) / 1000;
902  bx = by = (drill_radius * 707) / 1000;
903  }
904 
905  // lines '|' or '\'
906  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
907  m_Start.y + aOffset.y - ay,
908  m_Start.x + aOffset.x - bx,
909  m_Start.y + aOffset.y - by, 0, color );
910  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x + bx,
911  m_Start.y + aOffset.y + by,
912  m_Start.x + aOffset.x + ax,
913  m_Start.y + aOffset.y + ay, 0, color );
914 
915  // lines - or '/'
916  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x + ay,
917  m_Start.y + aOffset.y - ax,
918  m_Start.x + aOffset.x + by,
919  m_Start.y + aOffset.y - bx, 0, color );
920  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - by,
921  m_Start.y + aOffset.y + bx,
922  m_Start.x + aOffset.x - ay,
923  m_Start.y + aOffset.y + ax, 0, color );
924  }
925 
926  // for Buried Vias, draw a partial line : orient depending on layer pair
927  // (so we can see superimposed buried vias ):
928  if( GetViaType() == VIA_BLIND_BURIED )
929  {
930  int ax = 0, ay = radius, bx = 0, by = drill_radius;
931  PCB_LAYER_ID layer_top, layer_bottom;
932 
933  LayerPair( &layer_top, &layer_bottom );
934 
935  // lines for the top layer
936  RotatePoint( &ax, &ay, layer_top * 3600.0 / brd->GetCopperLayerCount( ) );
937  RotatePoint( &bx, &by, layer_top * 3600.0 / brd->GetCopperLayerCount( ) );
938  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
939  m_Start.y + aOffset.y - ay,
940  m_Start.x + aOffset.x - bx,
941  m_Start.y + aOffset.y - by, 0, color );
942 
943  // lines for the bottom layer
944  ax = 0; ay = radius; bx = 0; by = drill_radius;
945  RotatePoint( &ax, &ay, layer_bottom * 3600.0 / brd->GetCopperLayerCount( ) );
946  RotatePoint( &bx, &by, layer_bottom * 3600.0 / brd->GetCopperLayerCount( ) );
947  GRLine( panel->GetClipBox(), aDC, m_Start.x + aOffset.x - ax,
948  m_Start.y + aOffset.y - ay,
949  m_Start.x + aOffset.x - bx,
950  m_Start.y + aOffset.y - by, 0, color );
951  }
952 
953  // Display the short netname:
955  return;
956 
957  if( displ_opts->m_DisplayNetNamesMode == 0 || displ_opts->m_DisplayNetNamesMode == 1 )
958  return;
959 
960  NETINFO_ITEM* net = GetNet();
961 
962  if( net == NULL )
963  return;
964 
965  int len = net->GetShortNetname().Len();
966 
967  if( len > 0 )
968  {
969  // calculate a good size for the text
970  int tsize = m_Width / len;
971 
972  if( aDC->LogicalToDeviceXRel( tsize ) >= MIN_TEXT_SIZE )
973  {
974  tsize = (tsize * 7) / 10; // small reduction to give a better look, inside via
975 
976  if( (aDrawMode & GR_XOR) == 0 )
977  GRSetDrawMode( aDC, GR_COPY );
978 
979  EDA_RECT* clipbox = panel->GetClipBox();
980  DrawGraphicHaloText( clipbox, aDC, m_Start,
981  color, WHITE, BLACK, net->GetShortNetname(), 0,
982  wxSize( tsize, tsize ),
984  tsize / 7, false, false );
985  }
986  }
987 }
988 
989 
990 void VIA::ViewGetLayers( int aLayers[], int& aCount ) const
991 {
992  aLayers[0] = LAYER_VIAS_HOLES;
993  aLayers[1] = LAYER_VIAS_NETNAMES;
994  aCount = 3;
995 
996  // Just show it on common via & via holes layers
997  switch( GetViaType() )
998  {
999  case VIA_THROUGH:
1000  aLayers[2] = LAYER_VIA_THROUGH;
1001  break;
1002 
1003  case VIA_BLIND_BURIED:
1004  aLayers[2] = LAYER_VIA_BBLIND;
1005  aLayers[3] = m_Layer;
1006  aLayers[4] = m_BottomLayer;
1007  aCount += 2;
1008  break;
1009 
1010  case VIA_MICROVIA:
1011  aLayers[2] = LAYER_VIA_MICROVIA;
1012  break;
1013 
1014  default:
1015  aLayers[2] = LAYER_GP_OVERLAY;
1016  wxASSERT( false );
1017  break;
1018  }
1019 }
1020 
1021 
1022 unsigned int VIA::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
1023 {
1024  BOARD* board = GetBoard();
1025 
1026  // Only draw the via if at least one of the layers it crosses is being displayed
1027  if( board && ( board->GetVisibleLayers() & GetLayerSet() ).any() )
1028  return 0;
1029 
1031 }
1032 
1033 
1034 // see class_track.h
1035 void TRACK::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
1036 {
1037  wxString msg;
1038  BOARD* board = GetBoard();
1039 
1040  // Display basic infos
1041  GetMsgPanelInfoBase( aList );
1042 
1043  // Display full track length (in Pcbnew)
1044  if( board )
1045  {
1046  double trackLen = 0;
1047  double lenPadToDie = 0;
1048  board->MarkTrace( this, NULL, &trackLen, &lenPadToDie, false );
1049  msg = ::LengthDoubleToString( trackLen );
1050  aList.push_back( MSG_PANEL_ITEM( _( "Length" ), msg, DARKCYAN ) );
1051 
1052  if( lenPadToDie != 0 )
1053  {
1054  msg = ::LengthDoubleToString( trackLen + lenPadToDie );
1055  aList.push_back( MSG_PANEL_ITEM( _( "Full Length" ), msg, DARKCYAN ) );
1056 
1057  msg = ::LengthDoubleToString( lenPadToDie );
1058  aList.push_back( MSG_PANEL_ITEM( _( "Pad To Die Length" ), msg, DARKCYAN ) );
1059  }
1060  }
1061 
1062  NETCLASSPTR netclass = GetNetClass();
1063 
1064  if( netclass )
1065  {
1066  aList.push_back( MSG_PANEL_ITEM( _( "NC Name" ), netclass->GetName(), DARKMAGENTA ) );
1067  aList.push_back( MSG_PANEL_ITEM( _( "NC Clearance" ),
1068  ::CoordinateToString( netclass->GetClearance(), true ),
1069  DARKMAGENTA ) );
1070  aList.push_back( MSG_PANEL_ITEM( _( "NC Width" ),
1071  ::CoordinateToString( netclass->GetTrackWidth(), true ),
1072  DARKMAGENTA ) );
1073  aList.push_back( MSG_PANEL_ITEM( _( "NC Via Size" ),
1074  ::CoordinateToString( netclass->GetViaDiameter(), true ),
1075  DARKMAGENTA ) );
1076  aList.push_back( MSG_PANEL_ITEM( _( "NC Via Drill"),
1077  ::CoordinateToString( netclass->GetViaDrill(), true ),
1078  DARKMAGENTA ) );
1079  }
1080 }
1081 
1082 void TRACK::GetMsgPanelInfoBase_Common( std::vector< MSG_PANEL_ITEM >& aList )
1083 {
1084  wxString msg;
1085 
1086  // Display Net Name
1087  if( GetBoard() )
1088  {
1089  NETINFO_ITEM* net = GetNet();
1090 
1091  if( net )
1092  msg = net->GetNetname();
1093  else
1094  msg = wxT( "<noname>" );
1095 
1096  aList.push_back( MSG_PANEL_ITEM( _( "NetName" ), msg, RED ) );
1097 
1098  // Display net code : (useful in test or debug)
1099  msg.Printf( wxT( "%d" ), GetNetCode() );
1100  aList.push_back( MSG_PANEL_ITEM( _( "NetCode" ), msg, RED ) );
1101  }
1102 
1103 #if defined(DEBUG)
1104 
1105  // Display the flags
1106  msg.Printf( wxT( "0x%08X" ), m_Flags );
1107  aList.push_back( MSG_PANEL_ITEM( wxT( "Flags" ), msg, BLUE ) );
1108 
1109 #if 0
1110  // Display start and end pointers:
1111  msg.Printf( wxT( "%p" ), start );
1112  aList.push_back( MSG_PANEL_ITEM( wxT( "start ptr" ), msg, BLUE ) );
1113  msg.Printf( wxT( "%p" ), end );
1114  aList.push_back( MSG_PANEL_ITEM( wxT( "end ptr" ), msg, BLUE ) );
1115  // Display this ptr
1116  msg.Printf( wxT( "%p" ), this );
1117  aList.push_back( MSG_PANEL_ITEM( wxT( "this" ), msg, BLUE ) );
1118 #endif
1119 
1120 #if 0
1121  // Display start and end positions:
1122  msg.Printf( wxT( "%d %d" ), m_Start.x, m_Start.y );
1123  aList.push_back( MSG_PANEL_ITEM( wxT( "Start pos" ), msg, BLUE ) );
1124  msg.Printf( wxT( "%d %d" ), m_End.x, m_End.y );
1125  aList.push_back( MSG_PANEL_ITEM( wxT( "End pos" ), msg, BLUE ) );
1126 #endif
1127 
1128 #endif // defined(DEBUG)
1129 
1130  // Display the State member
1131  msg = wxT( ". . " );
1132 
1133  if( GetState( TRACK_LOCKED ) )
1134  msg[0] = 'L';
1135 
1136  if( GetState( TRACK_AR ) )
1137  msg[2] = 'A';
1138 
1139  aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) );
1140 }
1141 
1142 void TRACK::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1143 {
1144  wxString msg;
1145  BOARD* board = GetBoard();
1146 
1147  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), _( "Track" ), DARKCYAN ) );
1148 
1149  GetMsgPanelInfoBase_Common( aList );
1150 
1151  // Display layer
1152  if( board )
1153  msg = board->GetLayerName( m_Layer );
1154  else
1155  msg.Printf(wxT("%d"), m_Layer );
1156 
1157  aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), msg, BROWN ) );
1158 
1159  // Display width
1160  msg = ::CoordinateToString( (unsigned) m_Width );
1161 
1162  aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, DARKCYAN ) );
1163 
1164  // Display segment length
1165  msg = ::LengthDoubleToString( GetLength() );
1166  aList.push_back( MSG_PANEL_ITEM( _( "Segment Length" ), msg, DARKCYAN ) );
1167 }
1168 
1169 void SEGZONE::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1170 {
1171  wxString msg;
1172  BOARD* board = GetBoard();
1173 
1174  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), _( "Zone " ), DARKCYAN ) );
1175 
1176  GetMsgPanelInfoBase_Common( aList );
1177 
1178  // Display layer
1179  if( board )
1180  msg = board->GetLayerName( m_Layer );
1181  else
1182  msg.Printf( wxT( "%d" ), m_Layer );
1183 
1184  aList.push_back( MSG_PANEL_ITEM( _( "Layer" ), msg, BROWN ) );
1185 
1186  // Display width
1187  msg = ::CoordinateToString( (unsigned) m_Width );
1188 
1189  aList.push_back( MSG_PANEL_ITEM( _( "Width" ), msg, DARKCYAN ) );
1190 
1191  // Display segment length
1192  msg = ::LengthDoubleToString( GetLength() );
1193  aList.push_back( MSG_PANEL_ITEM( _( "Segment Length" ), msg, DARKCYAN ) );
1194 }
1195 
1196 void VIA::GetMsgPanelInfoBase( std::vector< MSG_PANEL_ITEM >& aList )
1197 {
1198  wxString msg;
1199  BOARD* board = GetBoard();
1200 
1201  switch( GetViaType() )
1202  {
1203  default:
1204  case VIA_NOT_DEFINED:
1205  msg = wxT( "???" ); // Not used yet, does not exist currently
1206  break;
1207 
1208  case VIA_MICROVIA:
1209  msg = _( "Micro Via" ); // from external layer (TOP or BOTTOM) from
1210  // the near neighbor inner layer only
1211  break;
1212 
1213  case VIA_BLIND_BURIED:
1214  msg = _( "Blind/Buried Via" ); // from inner or external to inner
1215  // or external layer (no restriction)
1216  break;
1217 
1218  case VIA_THROUGH:
1219  msg = _( "Through Via" ); // Usual via (from TOP to BOTTOM layer only )
1220  break;
1221  }
1222 
1223  aList.push_back( MSG_PANEL_ITEM( _( "Type" ), msg, DARKCYAN ) );
1224 
1225  GetMsgPanelInfoBase_Common( aList );
1226 
1227 
1228  // Display layer pair
1229  PCB_LAYER_ID top_layer, bottom_layer;
1230 
1231  LayerPair( &top_layer, &bottom_layer );
1232 
1233  if( board )
1234  msg = board->GetLayerName( top_layer ) + wxT( "/" )
1235  + board->GetLayerName( bottom_layer );
1236  else
1237  msg.Printf( wxT( "%d/%d" ), top_layer, bottom_layer );
1238 
1239  aList.push_back( MSG_PANEL_ITEM( _( "Layers" ), msg, BROWN ) );
1240 
1241  // Display width
1242  msg = ::CoordinateToString( (unsigned) m_Width );
1243 
1244  // Display diameter value:
1245  aList.push_back( MSG_PANEL_ITEM( _( "Diameter" ), msg, DARKCYAN ) );
1246 
1247  // Display drill value
1248  int drill_value = GetDrillValue();
1249 
1250  msg = ::CoordinateToString( drill_value );
1251 
1252  wxString title = _( "Drill" );
1253  title += wxT( " " );
1254 
1255  bool drl_specific = true;
1256 
1257  if( GetBoard() )
1258  {
1259  NETINFO_ITEM* net = GetNet();
1260  int drill_class_value = 0;
1261 
1262  if( net )
1263  {
1264  if( GetViaType() == VIA_MICROVIA )
1265  drill_class_value = net->GetMicroViaDrillSize();
1266  else
1267  drill_class_value = net->GetViaDrillSize();
1268  }
1269 
1270  drl_specific = drill_value != drill_class_value;
1271  }
1272 
1273 
1274  if( drl_specific )
1275  title += _( "(Specific)" );
1276  else
1277  title += _( "(NetClass)" );
1278 
1279  aList.push_back( MSG_PANEL_ITEM( title, msg, RED ) );
1280 }
1281 
1282 
1283 bool TRACK::HitTest( const wxPoint& aPosition ) const
1284 {
1285  return TestSegmentHit( aPosition, m_Start, m_End, m_Width / 2 );
1286 }
1287 
1288 bool VIA::HitTest( const wxPoint& aPosition ) const
1289 {
1290  int max_dist = m_Width / 2;
1291 
1292  // rel_pos is aPosition relative to m_Start (or the center of the via)
1293  wxPoint rel_pos = aPosition - m_Start;
1294  double dist = (double) rel_pos.x * rel_pos.x + (double) rel_pos.y * rel_pos.y;
1295  return dist <= (double) max_dist * max_dist;
1296 }
1297 
1298 
1299 bool TRACK::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
1300 {
1301  EDA_RECT arect = aRect;
1302  arect.Inflate( aAccuracy );
1303 
1304  if( aContained )
1305  /* Tracks are a special case:
1306  * they are considered inside the rect if one end is inside the rect */
1307  return arect.Contains( GetStart() ) || arect.Contains( GetEnd() );
1308  else
1309  return arect.Intersects( GetStart(), GetEnd() );
1310 }
1311 
1312 bool VIA::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
1313 {
1314  EDA_RECT box;
1315  EDA_RECT arect = aRect;
1316  arect.Inflate( aAccuracy );
1317 
1318  box.SetOrigin( GetStart() );
1319  box.Inflate( GetWidth() / 2 );
1320 
1321  if( aContained )
1322  return arect.Contains( box );
1323  else
1324  return arect.Intersects( box );
1325 }
1326 
1327 
1328 VIA* TRACK::GetVia( const wxPoint& aPosition, PCB_LAYER_ID aLayer)
1329 {
1330  for( VIA* via = GetFirstVia( this ); via; via = GetFirstVia( via->Next() ) )
1331  {
1332  if( via->HitTest( aPosition ) &&
1333  !via->GetState( BUSY | IS_DELETED ) &&
1334  ((aLayer == UNDEFINED_LAYER) || (via->IsOnLayer( aLayer ))) )
1335  return via;
1336  }
1337 
1338  return NULL;
1339 }
1340 
1341 
1342 VIA* TRACK::GetVia( TRACK* aEndTrace, const wxPoint& aPosition, LSET aLayerMask )
1343 {
1344  for( VIA* via = GetFirstVia( this, aEndTrace ); via; via = GetFirstVia( via->Next() ) )
1345  {
1346  if( via->HitTest( aPosition ) &&
1347  !via->GetState( BUSY | IS_DELETED ) &&
1348  ( aLayerMask & via->GetLayerSet() ).any()
1349  )
1350  {
1351  return via;
1352  }
1353  }
1354 
1355  return NULL;
1356 }
1357 
1358 
1359 TRACK* TRACK::GetTrack( TRACK* aStartTrace, TRACK* aEndTrace, ENDPOINT_T aEndPoint,
1360  bool aSameNetOnly, bool aSequential )
1361 {
1362  const wxPoint& position = GetEndPoint( aEndPoint );
1363  LSET refLayers = GetLayerSet();
1364  TRACK* previousSegment;
1365  TRACK* nextSegment;
1366 
1367  if( aSequential )
1368  {
1369  // Simple sequential search: from aStartTrace forward to aEndTrace
1370  previousSegment = NULL;
1371  nextSegment = aStartTrace;
1372  }
1373  else
1374  {
1375  /* Local bidirectional search: from this backward to aStartTrace
1376  * AND forward to aEndTrace. The idea is that nearest segments
1377  * are found (on average) faster in this way. In fact same-net
1378  * segments are almost guaranteed to be found faster, in a global
1379  * search, since they are grouped together in the track list */
1380  previousSegment = this;
1381  nextSegment = this;
1382  }
1383 
1384  while( nextSegment || previousSegment )
1385  {
1386  // Terminate the search in the direction if the netcode mis-matches
1387  if( aSameNetOnly )
1388  {
1389  if( nextSegment && (nextSegment->GetNetCode() != GetNetCode()) )
1390  nextSegment = NULL;
1391  if( previousSegment && (previousSegment->GetNetCode() != GetNetCode()) )
1392  previousSegment = NULL;
1393  }
1394 
1395  if( nextSegment )
1396  {
1397  if ( (nextSegment != this) &&
1398  !nextSegment->GetState( BUSY | IS_DELETED ) &&
1399  ( refLayers & nextSegment->GetLayerSet() ).any() )
1400  {
1401  if( (position == nextSegment->m_Start) ||
1402  (position == nextSegment->m_End) )
1403  return nextSegment;
1404  }
1405 
1406  // Keep looking forward
1407  if( nextSegment == aEndTrace )
1408  nextSegment = NULL;
1409  else
1410  nextSegment = nextSegment->Next();
1411  }
1412 
1413  // Same as above, looking back. During sequential search this branch is inactive
1414  if( previousSegment )
1415  {
1416  if( (previousSegment != this) &&
1417  !previousSegment->GetState( BUSY | IS_DELETED ) &&
1418  ( refLayers & previousSegment->GetLayerSet() ).any()
1419  )
1420  {
1421  if( (position == previousSegment->m_Start) ||
1422  (position == previousSegment->m_End) )
1423  return previousSegment;
1424  }
1425 
1426  if( previousSegment == aStartTrace )
1427  previousSegment = NULL;
1428  else
1429  previousSegment = previousSegment->Back();
1430  }
1431  }
1432 
1433  return NULL;
1434 }
1435 
1436 
1437 int TRACK::GetEndSegments( int aCount, TRACK** aStartTrace, TRACK** aEndTrace )
1438 {
1439  TRACK* Track, * via, * segm, * TrackListEnd;
1440  int NbEnds, ii, ok = 0;
1441  LSET layerMask;
1442 
1443  if( aCount <= 1 )
1444  {
1445  *aStartTrace = *aEndTrace = this;
1446  return 1;
1447  }
1448 
1449  // Calculation of the limit analysis.
1450  *aStartTrace = *aEndTrace = NULL;
1451  TrackListEnd = Track = this;
1452  ii = 0;
1453 
1454  for( ; ( Track != NULL ) && ( ii < aCount ); ii++, Track = Track->Next() )
1455  {
1456  TrackListEnd = Track;
1457  Track->m_Param = 0;
1458  }
1459 
1460  // Calculate the extremes.
1461  NbEnds = 0;
1462  Track = this;
1463  ii = 0;
1464 
1465  for( ; ( Track != NULL ) && ( ii < aCount ); ii++, Track = Track->Next() )
1466  {
1467  if( Track->Type() == PCB_VIA_T )
1468  continue;
1469 
1470  layerMask = Track->GetLayerSet();
1471  via = GetVia( TrackListEnd, Track->m_Start, layerMask );
1472 
1473  if( via )
1474  {
1475  layerMask |= via->GetLayerSet();
1476  via->SetState( BUSY, true );
1477  }
1478 
1479  Track->SetState( BUSY, true );
1480  segm = ::GetTrack( this, TrackListEnd, Track->m_Start, layerMask );
1481  Track->SetState( BUSY, false );
1482 
1483  if( via )
1484  via->SetState( BUSY, false );
1485 
1486  if( segm == NULL )
1487  {
1488  switch( NbEnds )
1489  {
1490  case 0:
1491  *aStartTrace = Track; NbEnds++;
1492  break;
1493 
1494  case 1:
1495  int BeginPad, EndPad;
1496  *aEndTrace = Track;
1497 
1498  // Swap ox, oy with fx, fy
1499  BeginPad = Track->GetState( BEGIN_ONPAD );
1500  EndPad = Track->GetState( END_ONPAD );
1501 
1502  Track->SetState( BEGIN_ONPAD | END_ONPAD, false );
1503 
1504  if( BeginPad )
1505  Track->SetState( END_ONPAD, true );
1506 
1507  if( EndPad )
1508  Track->SetState( BEGIN_ONPAD, true );
1509 
1510  std::swap( Track->m_Start, Track->m_End );
1511  std::swap( Track->start, Track->end );
1512  ok = 1;
1513  return ok;
1514  }
1515  }
1516 
1517  layerMask = Track->GetLayerSet();
1518  via = GetVia( TrackListEnd, Track->m_End, layerMask );
1519 
1520  if( via )
1521  {
1522  layerMask |= via->GetLayerSet();
1523  via->SetState( BUSY, true );
1524  }
1525 
1526  Track->SetState( BUSY, true );
1527  segm = ::GetTrack( this, TrackListEnd, Track->m_End, layerMask );
1528  Track->SetState( BUSY, false );
1529 
1530  if( via )
1531  via->SetState( BUSY, false );
1532 
1533  if( segm == NULL )
1534  {
1535  switch( NbEnds )
1536  {
1537  case 0:
1538  int BeginPad, EndPad;
1539  *aStartTrace = Track;
1540  NbEnds++;
1541 
1542  // Swap ox, oy with fx, fy
1543  BeginPad = Track->GetState( BEGIN_ONPAD );
1544  EndPad = Track->GetState( END_ONPAD );
1545 
1546  Track->SetState( BEGIN_ONPAD | END_ONPAD, false );
1547 
1548  if( BeginPad )
1549  Track->SetState( END_ONPAD, true );
1550 
1551  if( EndPad )
1552  Track->SetState( BEGIN_ONPAD, true );
1553 
1554  std::swap( Track->m_Start, Track->m_End );
1555  std::swap( Track->start, Track->end );
1556  break;
1557 
1558  case 1:
1559  *aEndTrace = Track;
1560  ok = 1;
1561  return ok;
1562  }
1563  }
1564  }
1565 
1566  return ok;
1567 }
1568 
1569 
1571 {
1572  wxString text;
1573  wxString netname;
1574  NETINFO_ITEM* net;
1575  BOARD* board = GetBoard();
1576 
1577  // deleting tracks requires all the information we can get to
1578  // disambiguate all the choices under the cursor!
1579  if( board )
1580  {
1581  net = GetNet();
1582 
1583  if( net )
1584  netname = net->GetNetname();
1585  else
1586  netname = _("Not found");
1587  }
1588  else
1589  {
1590  wxFAIL_MSG( wxT( "TRACK::GetSelectMenuText: BOARD is NULL" ) );
1591  netname = wxT( "???" );
1592  }
1593 
1594  text.Printf( _("Track %s, net [%s] (%d) on layer %s, length: %s" ),
1595  GetChars( ShowWidth() ), GetChars( netname ),
1598 
1599  return text;
1600 }
1601 
1602 
1604 {
1605  return showtrack_xpm;
1606 }
1607 
1608 
1609 #if defined(DEBUG)
1610 
1611 wxString TRACK::ShowState( int stateBits )
1612 {
1613  wxString ret;
1614 
1615  if( stateBits & IS_LINKED )
1616  ret << wxT( " | IS_LINKED" );
1617 
1618  if( stateBits & TRACK_AR )
1619  ret << wxT( " | TRACK_AR" );
1620 
1621  if( stateBits & TRACK_LOCKED )
1622  ret << wxT( " | TRACK_LOCKED" );
1623 
1624  if( stateBits & IN_EDIT )
1625  ret << wxT( " | IN_EDIT" );
1626 
1627  if( stateBits & IS_DRAGGED )
1628  ret << wxT( " | IS_DRAGGED" );
1629 
1630  if( stateBits & DO_NOT_DRAW )
1631  ret << wxT( " | DO_NOT_DRAW" );
1632 
1633  if( stateBits & IS_DELETED )
1634  ret << wxT( " | IS_DELETED" );
1635 
1636  if( stateBits & BUSY )
1637  ret << wxT( " | BUSY" );
1638 
1639  if( stateBits & END_ONPAD )
1640  ret << wxT( " | END_ONPAD" );
1641 
1642  if( stateBits & BEGIN_ONPAD )
1643  ret << wxT( " | BEGIN_ONPAD" );
1644 
1645  if( stateBits & FLAG0 )
1646  ret << wxT( " | FLAG0" );
1647 
1648  if( stateBits & FLAG1 )
1649  ret << wxT( " | FLAG1" );
1650 
1651  return ret;
1652 }
1653 
1654 #endif
#define MIN_VIA_DRAW_SIZE
Definition: class_track.h:60
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:639
#define IS_LINKED
Used in calculation to mark linked items (temporary use)
Definition: base_struct.h:110
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:117
COLOR4D GetLayerColor(PCB_LAYER_ID aLayer) const
Function GetLayerColor gets a layer color for any valid layer, including non-copper ones...
#define FLAG1
Pcbnew: flag used in local computations.
Definition: base_struct.h:130
KICAD_T Type() const
Function Type()
Definition: base_struct.h:198
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 IsElementVisible(GAL_LAYER_ID LAYER_aPCB) const
Function IsElementVisible tests whether a given element category is visible.
bool IsMoving() const
Definition: base_struct.h:218
#define IN_EDIT
Item currently edited.
Definition: base_struct.h:111
static bool ShowClearance(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
wxPoint m_Start
Line start point.
Definition: class_track.h:334
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:183
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:133
void GRSetDrawMode(wxDC *DC, GR_DRAWMODE draw_mode)
Definition: gr_basic.cpp:290
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:440
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:216
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
time_t m_TimeStamp
Time stamp used for logical links.
Definition: base_struct.h:169
bool Contains(const wxPoint &aPoint) const
Function Contains.
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color)
Definition: gr_basic.cpp:352
virtual void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
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:196
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:481
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...
#define BUSY
Pcbnew: flag indicating that the structure has.
Definition: base_struct.h:134
COLOR4D GetVisibleElementColor(GAL_LAYER_ID LAYER_aPCB)
Function GetVisibleElementColor returns the color of a pcb visible element.
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:237
void GRFilledCircle(EDA_RECT *ClipBox, wxDC *DC, int x, int y, int r, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:833
#define BEGIN_ONPAD
Pcbnew: flag set for track segment starting on a pad.
Definition: base_struct.h:132
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:99
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:118
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:90
Functions relatives to tracks, vias and segments used to fill zones.
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:107
void * GetDisplayOptions() override
Function GetDisplayOptions returns the display options current in use Display options are relative to...
double m_Param
Definition: class_track.h:92
int m_Width
Thickness of track, or via diameter.
Definition: class_track.h:333
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 of the item.
#define THRESHOLD
const INSPECTOR_FUNC & INSPECTOR
Definition: base_struct.h:104
#define IS_DRAGGED
Item being dragged.
Definition: base_struct.h:115
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...
bool m_DisplayPcbTrackFill
Definition: pcbstruct.h:71
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:284
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:439
#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:271
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:584
#define IS_DELETED
Definition: base_struct.h:116
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:121
virtual void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
wxPoint m_End
Line end point.
Definition: class_track.h:335
to draw usual through hole vias
int m_Drill
Definition: class_track.h:485
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:125
bool m_ContrastModeDisplay
Definition: pcbstruct.h:85
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:144
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:481
EDA_RECT * GetClipBox()
virtual unsigned int ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Function ViewGetLOD() Returns the level of detail 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:122
general purpose overlay
int m_DisplayZonesMode
Definition: pcbstruct.h:77
#define TRACK_LOCKED
Pcbnew: track locked: protected from global deletion.
Definition: base_struct.h:128
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:109
EDA_DRAW_FRAME * GetParent() const
Definition: draw_panel.cpp:175
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 1/10000 inches.
virtual int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
virtual wxString GetSelectMenuText() const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
#define FLAG0
Pcbnew: flag used in local computations.
Definition: base_struct.h:131
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:468
#define TRACK_AR
Pcbnew: autorouted track.
Definition: base_struct.h:129
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.
Class DISPLAY_OPTIONS handles display options like enable/disable some optional drawings.
Definition: pcbstruct.h:62
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.
TRACE_CLEARANCE_DISPLAY_MODE_T m_ShowTrackClearanceMode
How trace clearances are displayed.
Definition: pcbstruct.h:74
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
PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
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:98
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:242
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:115
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:791
STATUS_FLAGS m_Flags
Flag bits for editing and other uses.
Definition: base_struct.h:175
#define ENDPOINT
Definition: base_struct.h:119
Class EDA_RECT handles the component boundary box.
BASE_SCREEN * GetScreen()
Definition: draw_panel.cpp:188
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:151
The common library.
int m_DisplayNetNamesMode
Definition: pcbstruct.h:78
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:171
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:108
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:182
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:68
bool GetGRForceBlackPenState(void)
Function GetGRForceBlackPenState.
Definition: gr_basic.cpp:281
int GetViaDrillSize()
Function GetViaDrillSize returns the size of via drills used to route this net.
Message panel definition file.
bool m_DisplayViaFill
Definition: pcbstruct.h:66
#define FORCE_SKETCH
Definition: pcbnew.h:68
BOARD_CONNECTED_ITEM * end
Definition: class_track.h:90
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:89
EDA_ITEM * Pnext
next in linked list
Definition: base_struct.h:164
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:125
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:118
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:443
bool IsDragging() const
Definition: base_struct.h:219
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:490