KiCad PCB EDA Suite
class_module.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) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
5  * Copyright (C) 2015 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
6  * Copyright (C) 2015 Wayne Stambaugh <stambaughw@verizon.net>
7  * Copyright (C) 1992-2017 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 <plotter.h>
35 #include <class_drawpanel.h>
36 #include <trigo.h>
37 #include <confirm.h>
38 #include <kicad_string.h>
39 #include <pcbnew.h>
40 #include <richio.h>
41 #include <filter_reader.h>
42 #include <macros.h>
43 #include <msgpanel.h>
44 #include <bitmaps.h>
45 
46 #include <pcb_edit_frame.h>
47 #include <class_board.h>
48 #include <class_edge_mod.h>
49 #include <class_module.h>
51 
52 #include <view/view.h>
53 
54 MODULE::MODULE( BOARD* parent ) :
56  m_initial_comments( 0 )
57 {
59  m_Layer = F_Cu;
60  m_Orient = 0;
62  m_arflag = 0;
63  m_CntRot90 = m_CntRot180 = 0;
64  m_Surface = 0.0;
65  m_Link = 0;
66  m_LastEditTime = 0;
67  m_LocalClearance = 0;
71  m_ZoneConnection = PAD_ZONE_CONN_INHERITED; // Use zone setting by default
72  m_ThermalWidth = 0; // Use zone setting by default
73  m_ThermalGap = 0; // Use zone setting by default
74 
75  // These are special and mandatory text fields
78 
79  m_3D_Drawings.clear();
80 }
81 
82 
83 MODULE::MODULE( const MODULE& aModule ) :
84  BOARD_ITEM_CONTAINER( aModule )
85 {
86  m_Pos = aModule.m_Pos;
87  m_fpid = aModule.m_fpid;
88  m_Attributs = aModule.m_Attributs;
90  m_Orient = aModule.m_Orient;
91  m_BoundaryBox = aModule.m_BoundaryBox;
92  m_CntRot90 = aModule.m_CntRot90;
93  m_CntRot180 = aModule.m_CntRot180;
95  m_Link = aModule.m_Link;
96  m_Path = aModule.m_Path; //is this correct behavior?
97 
103  m_ThermalWidth = aModule.m_ThermalWidth;
104  m_ThermalGap = aModule.m_ThermalGap;
105 
106  // Copy reference and value.
107  m_Reference = new TEXTE_MODULE( *aModule.m_Reference );
108  m_Reference->SetParent( this );
109  m_Value = new TEXTE_MODULE( *aModule.m_Value );
110  m_Value->SetParent( this );
111 
112  // Copy auxiliary data: Pads
113  for( D_PAD* pad = aModule.m_Pads; pad; pad = pad->Next() )
114  {
115  Add( new D_PAD( *pad ) );
116  }
117 
118  // Copy auxiliary data: Drawings
119  for( BOARD_ITEM* item = aModule.m_Drawings; item; item = item->Next() )
120  {
121  switch( item->Type() )
122  {
123  case PCB_MODULE_TEXT_T:
124  case PCB_MODULE_EDGE_T:
125  Add( static_cast<BOARD_ITEM*>( item->Clone() ) );
126  break;
127 
128  default:
129  wxLogMessage( wxT( "Class MODULE copy constructor internal error: unknown type" ) );
130  break;
131  }
132  }
133 
134  // Copy auxiliary data: 3D_Drawings info
135  m_3D_Drawings = aModule.m_3D_Drawings;
136 
137  m_Doc = aModule.m_Doc;
138  m_KeyWord = aModule.m_KeyWord;
139 
140  m_arflag = 0;
141 
142  // Ensure auxiliary data is up to date
144 
146  new wxArrayString( *aModule.m_initial_comments ) : 0;
147 }
148 
149 
151 {
152  delete m_Reference;
153  delete m_Value;
154  delete m_initial_comments;
155 }
156 
157 
158 MODULE& MODULE::operator=( const MODULE& aOther )
159 {
160  BOARD_ITEM::operator=( aOther );
161 
162  m_Pos = aOther.m_Pos;
163  m_fpid = aOther.m_fpid;
164  m_Attributs = aOther.m_Attributs;
166  m_Orient = aOther.m_Orient;
167  m_BoundaryBox = aOther.m_BoundaryBox;
168  m_CntRot90 = aOther.m_CntRot90;
169  m_CntRot180 = aOther.m_CntRot180;
171  m_Link = aOther.m_Link;
172  m_Path = aOther.m_Path; //is this correct behavior?
173 
180  m_ThermalGap = aOther.m_ThermalGap;
181 
182  // Copy reference and value
183  *m_Reference = *aOther.m_Reference;
184  m_Reference->SetParent( this );
185  *m_Value = *aOther.m_Value;
186  m_Value->SetParent( this );
187 
188  // Copy auxiliary data: Pads
189  m_Pads.DeleteAll();
190 
191  for( D_PAD* pad = aOther.m_Pads; pad; pad = pad->Next() )
192  {
193  Add( new D_PAD( *pad ) );
194  }
195 
196  // Copy auxiliary data: Drawings
198 
199  for( BOARD_ITEM* item = aOther.m_Drawings; item; item = item->Next() )
200  {
201  switch( item->Type() )
202  {
203  case PCB_MODULE_TEXT_T:
204  case PCB_MODULE_EDGE_T:
205  Add( static_cast<BOARD_ITEM*>( item->Clone() ) );
206  break;
207 
208  default:
209  wxLogMessage( wxT( "MODULE::operator=() internal error: unknown type" ) );
210  break;
211  }
212  }
213 
214  // Copy auxiliary data: 3D_Drawings info
215  m_3D_Drawings.clear();
216  m_3D_Drawings = aOther.m_3D_Drawings;
217  m_Doc = aOther.m_Doc;
218  m_KeyWord = aOther.m_KeyWord;
219 
220  // Ensure auxiliary data is up to date
222 
223  return *this;
224 }
225 
226 
228 {
229  // Force the ORPHANED dummy net info for all pads.
230  // ORPHANED dummy net does not depend on a board
231  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
232  pad->SetNetCode( NETINFO_LIST::ORPHANED );
233 }
234 
235 
236 void MODULE::DrawAncre( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,
237  int dim_ancre, GR_DRAWMODE draw_mode )
238 {
239  auto frame = (PCB_EDIT_FRAME*) panel->GetParent();
240 
241  GRSetDrawMode( DC, draw_mode );
242 
243  if( GetBoard()->IsElementVisible( LAYER_ANCHOR ) )
244  {
245  GRDrawAnchor( panel->GetClipBox(), DC, m_Pos.x, m_Pos.y,
246  dim_ancre,
247  frame->Settings().Colors().GetItemColor( LAYER_ANCHOR ) );
248  }
249 }
250 
251 
252 void MODULE::Add( BOARD_ITEM* aBoardItem, ADD_MODE aMode )
253 {
254  switch( aBoardItem->Type() )
255  {
256  case PCB_MODULE_TEXT_T:
257  // Only user texts can be added this way. Reference and value are not hold in the DLIST.
258  assert( static_cast<TEXTE_MODULE*>( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS );
259 
260  // no break
261 
262  case PCB_MODULE_EDGE_T:
263  if( aMode == ADD_APPEND )
264  m_Drawings.PushBack( aBoardItem );
265  else
266  m_Drawings.PushFront( aBoardItem );
267  break;
268 
269  case PCB_PAD_T:
270  if( aMode == ADD_APPEND )
271  m_Pads.PushBack( static_cast<D_PAD*>( aBoardItem ) );
272  else
273  m_Pads.PushFront( static_cast<D_PAD*>( aBoardItem ) );
274  break;
275 
276  default:
277  {
278  wxString msg;
279  msg.Printf( wxT( "MODULE::Add() needs work: BOARD_ITEM type (%d) not handled" ),
280  aBoardItem->Type() );
281  wxFAIL_MSG( msg );
282 
283  return;
284  }
285  }
286 
287  aBoardItem->SetParent( this );
288 
289  // Update relative coordinates, it can be done only after there is a parent object assigned
290  switch( aBoardItem->Type() )
291  {
292  case PCB_MODULE_TEXT_T:
293  static_cast<TEXTE_MODULE*>( aBoardItem )->SetLocalCoord();
294  break;
295 
296  case PCB_MODULE_EDGE_T:
297  static_cast<EDGE_MODULE*>( aBoardItem )->SetLocalCoord();
298  break;
299 
300  case PCB_PAD_T:
301  static_cast<D_PAD*>( aBoardItem )->SetLocalCoord();
302  break;
303 
304  default:
305  // Huh? It should have been filtered out by the previous switch
306  assert(false);
307  break;
308  }
309 }
310 
311 
312 void MODULE::Remove( BOARD_ITEM* aBoardItem )
313 {
314  switch( aBoardItem->Type() )
315  {
316  case PCB_MODULE_TEXT_T:
317  // Only user texts can be removed this way. Reference and value are not hold in the DLIST.
318  assert( static_cast<TEXTE_MODULE*>( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS );
319 
320  // no break
321 
322  case PCB_MODULE_EDGE_T:
323  m_Drawings.Remove( aBoardItem );
324  break;
325 
326  case PCB_PAD_T:
327  m_Pads.Remove( static_cast<D_PAD*>( aBoardItem ) );
328  break;
329 
330  default:
331  {
332  wxString msg;
333  msg.Printf( wxT( "MODULE::Remove() needs work: BOARD_ITEM type (%d) not handled" ),
334  aBoardItem->Type() );
335  wxFAIL_MSG( msg );
336  }
337  }
338 }
339 
340 
341 void MODULE::CopyNetlistSettings( MODULE* aModule, bool aCopyLocalSettings )
342 {
343  // Don't do anything foolish like trying to copy to yourself.
344  wxCHECK_RET( aModule != NULL && aModule != this, wxT( "Cannot copy to NULL or yourself." ) );
345 
346  // Not sure what to do with the value field. Use netlist for now.
347  aModule->SetPosition( GetPosition() );
348 
349  if( aModule->GetLayer() != GetLayer() )
350  aModule->Flip( aModule->GetPosition() );
351 
352  if( aModule->GetOrientation() != GetOrientation() )
353  aModule->Rotate( aModule->GetPosition(), GetOrientation() );
354 
355  aModule->SetLocked( IsLocked() );
356 
357  if( aCopyLocalSettings )
358  {
360  aModule->SetLocalClearance( GetLocalClearance() );
363  aModule->SetZoneConnection( GetZoneConnection() );
364  aModule->SetThermalWidth( GetThermalWidth() );
365  aModule->SetThermalGap( GetThermalGap() );
366  }
367 
368  for( D_PAD* pad = aModule->PadsList(); pad; pad = pad->Next() )
369  {
370  // Fix me: if aCopyLocalSettings == true, for "multiple" pads
371  // (set of pads having the same name/number) this is broken
372  // because we copy settings from the first pad found.
373  // When old and new footprints have very few differences, a better
374  // algo can be used.
375  D_PAD* oldPad = FindPadByName( pad->GetName() );
376 
377  if( oldPad )
378  oldPad->CopyNetlistSettings( pad, aCopyLocalSettings );
379  }
380 
381  // Not sure about copying description, keywords, 3D models or any other
382  // local user changes to footprint. Stick with the new footprint settings
383  // called out in the footprint loaded in the netlist.
384  aModule->CalculateBoundingBox();
385 }
386 
387 
388 void MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode,
389  const wxPoint& aOffset )
390 {
391  if( (m_Flags & DO_NOT_DRAW) || (IsMoving()) )
392  return;
393 
394  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
395  {
396  if( pad->IsMoving() )
397  continue;
398 
399  pad->Draw( aPanel, aDC, aDrawMode, aOffset );
400  }
401 
402  BOARD* brd = GetBoard();
403 
404  // Draws footprint anchor
405  DrawAncre( aPanel, aDC, aOffset, DIM_ANCRE_MODULE, aDrawMode );
406 
407  // Draw graphic items
409  {
410  if( !(m_Reference->IsMoving()) )
411  m_Reference->Draw( aPanel, aDC, aDrawMode, aOffset );
412  }
413 
414  if( brd->IsElementVisible( LAYER_MOD_VALUES ) )
415  {
416  if( !(m_Value->IsMoving()) )
417  m_Value->Draw( aPanel, aDC, aDrawMode, aOffset );
418  }
419 
420  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
421  {
422  if( item->IsMoving() )
423  continue;
424 
425  switch( item->Type() )
426  {
427  case PCB_MODULE_TEXT_T:
428  case PCB_MODULE_EDGE_T:
429  item->Draw( aPanel, aDC, aDrawMode, aOffset );
430  break;
431 
432  default:
433  break;
434  }
435  }
436 
437  // Enable these line to draw m_BoundaryBox (debug tests purposes only)
438 #if 0
439  GRRect( aPanel->GetClipBox(), aDC, m_BoundaryBox, 0, BROWN );
440 #endif
441 
442 }
443 
444 
445 void MODULE::DrawEdgesOnly( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,
446  GR_DRAWMODE draw_mode )
447 {
448  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
449  {
450  switch( item->Type() )
451  {
452  case PCB_MODULE_EDGE_T:
453  item->Draw( panel, DC, draw_mode, offset );
454  break;
455 
456  default:
457  break;
458  }
459  }
460 }
461 
462 
464 {
467 }
468 
469 
471 {
472  EDA_RECT area;
473 
474  area.SetOrigin( m_Pos );
475  area.SetEnd( m_Pos );
476  area.Inflate( Millimeter2iu( 0.25 ) ); // Give a min size to the area
477 
478  for( const BOARD_ITEM* item = m_Drawings.GetFirst(); item; item = item->Next() )
479  {
480  const EDGE_MODULE* edge = dyn_cast<const EDGE_MODULE*>( item );
481 
482  if( edge )
483  area.Merge( edge->GetBoundingBox() );
484  }
485 
486  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
487  area.Merge( pad->GetBoundingBox() );
488 
489  return area;
490 }
491 
492 
494 {
495  EDA_RECT area = GetFootprintRect();
496 
497  // Calculate extended area including text fields
498  area.Merge( m_Reference->GetBoundingBox() );
499  area.Merge( m_Value->GetBoundingBox() );
500 
501  // Add the Clearance shape size: (shape around the pads when the
502  // clearance is shown. Not optimized, but the draw cost is small
503  // (perhaps smaller than optimization).
504  BOARD* board = GetBoard();
505  if( board )
506  {
507  int biggest_clearance = board->GetDesignSettings().GetBiggestClearanceValue();
508  area.Inflate( biggest_clearance );
509  }
510 
511  return area;
512 }
513 
514 
530 {
531  SHAPE_POLY_SET poly;
532 
533  double orientation = GetOrientationRadians();
534 
535  MODULE temp = *this;
536  temp.SetOrientation( 0.0 );
537  BOX2I area = temp.GetFootprintRect();
538 
539  poly.NewOutline();
540 
541  VECTOR2I p = area.GetPosition();
542  poly.Append( p );
543  p.x = area.GetRight();
544  poly.Append( p );
545  p.y = area.GetBottom();
546  poly.Append( p );
547  p.x = area.GetX();
548  poly.Append( p );
549 
550  BOARD* board = GetBoard();
551  if( board )
552  {
553  int biggest_clearance = board->GetDesignSettings().GetBiggestClearanceValue();
554  poly.Inflate( biggest_clearance, 4 );
555  }
556 
557  poly.Inflate( Millimeter2iu( 0.01 ), 4 );
558  poly.Rotate( -orientation, m_Pos );
559 
560  return poly;
561 }
562 
563 
564 void MODULE::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
565 {
566  int nbpad;
567  wxString msg;
568 
569  aList.push_back( MSG_PANEL_ITEM( m_Reference->GetShownText(), m_Value->GetShownText(), DARKCYAN ) );
570 
571  // Display last date the component was edited (useful in Module Editor).
572  wxDateTime date( m_LastEditTime );
573 
574  if( m_LastEditTime && date.IsValid() )
575  // Date format: see http://www.cplusplus.com/reference/ctime/strftime
576  msg = date.Format( wxT( "%b %d, %Y" ) ); // Abbreviated_month_name Day, Year
577  else
578  msg = _( "Unknown" );
579 
580  aList.push_back( MSG_PANEL_ITEM( _( "Last Change" ), msg, BROWN ) );
581 
582  // display schematic path
583  aList.push_back( MSG_PANEL_ITEM( _( "Netlist Path" ), m_Path, BROWN ) );
584 
585  // display the board side placement
586  aList.push_back( MSG_PANEL_ITEM( _( "Board Side" ),
587  IsFlipped()? _( "Back (Flipped)" ) : _( "Front" ), RED ) );
588 
589  EDA_ITEM* PtStruct = m_Pads;
590  nbpad = 0;
591 
592  while( PtStruct )
593  {
594  nbpad++;
595  PtStruct = PtStruct->Next();
596  }
597 
598  msg.Printf( wxT( "%d" ), nbpad );
599  aList.push_back( MSG_PANEL_ITEM( _( "Pads" ), msg, BLUE ) );
600 
601  msg = wxT( ".." );
602 
603  if( IsLocked() )
604  msg[0] = 'L';
605 
607  msg[1] = 'P';
608 
609  aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) );
610 
611  msg.Printf( wxT( "%.1f" ), GetOrientationDegrees() );
612  aList.push_back( MSG_PANEL_ITEM( _( "Rotation" ), msg, BROWN ) );
613 
614  // Controls on right side of the dialog
615  switch( m_Attributs & 255 )
616  {
617  case 0:
618  msg = _( "Normal" );
619  break;
620 
621  case MOD_CMS:
622  msg = _( "Insert" );
623  break;
624 
625  case MOD_VIRTUAL:
626  msg = _( "Virtual" );
627  break;
628 
629  default:
630  msg = wxT( "???" );
631  break;
632  }
633 
634  aList.push_back( MSG_PANEL_ITEM( _( "Attributes" ), msg, BROWN ) );
635  aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), FROM_UTF8( m_fpid.Format().c_str() ), BLUE ) );
636 
637  if( m_3D_Drawings.empty() )
638  msg = _( "No 3D shape" );
639  else
640  msg = m_3D_Drawings.front().m_Filename;
641 
642  // Search the first active 3D shape in list
643 
644  aList.push_back( MSG_PANEL_ITEM( _( "3D-Shape" ), msg, RED ) );
645 
646  wxString doc, keyword;
647  doc.Printf( _( "Doc: %s" ), GetChars( m_Doc ) );
648  keyword.Printf( _( "Key Words: %s" ), GetChars( m_KeyWord ) );
649  aList.push_back( MSG_PANEL_ITEM( doc, keyword, BLACK ) );
650 }
651 
652 
653 bool MODULE::HitTest( const wxPoint& aPosition ) const
654 {
655  return m_BoundaryBox.Contains( aPosition );
656 }
657 
658 
659 bool MODULE::HitTestAccurate( const wxPoint& aPosition ) const
660 {
661  auto shape = GetBoundingPoly();
662  return shape.Contains( aPosition, -1, true );
663 }
664 
665 
666 bool MODULE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
667 {
668  EDA_RECT arect = aRect;
669  arect.Inflate( aAccuracy );
670 
671  if( aContained )
672  return arect.Contains( m_BoundaryBox );
673  else
674  {
675  // If the rect does not intersect the bounding box, skip any tests
676  if( !aRect.Intersects( GetBoundingBox() ) )
677  return false;
678 
679  // Determine if any elements in the MODULE intersect the rect
680  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
681  {
682  if( pad->HitTest( arect, false, 0 ) )
683  return true;
684  }
685 
686  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
687  {
688  if( item->HitTest( arect, false, 0 ) )
689  return true;
690  }
691 
692  // No items were hit
693  return false;
694  }
695 }
696 
697 
698 D_PAD* MODULE::FindPadByName( const wxString& aPadName ) const
699 {
700  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
701  {
702  if( pad->GetName().CmpNoCase( aPadName ) == 0 ) // why case insensitive?
703  return pad;
704  }
705 
706  return NULL;
707 }
708 
709 
710 D_PAD* MODULE::GetPad( const wxPoint& aPosition, LSET aLayerMask )
711 {
712  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
713  {
714  // ... and on the correct layer.
715  if( !( pad->GetLayerSet() & aLayerMask ).any() )
716  continue;
717 
718  if( pad->HitTest( aPosition ) )
719  return pad;
720  }
721 
722  return NULL;
723 }
724 
725 
727 {
728  D_PAD* topLeftPad = m_Pads;
729 
730  for( D_PAD* p = m_Pads->Next(); p; p = p->Next() )
731  {
732  wxPoint pnt = p->GetPosition(); // GetPosition() returns the center of the pad
733 
734  if( ( pnt.x < topLeftPad->GetPosition().x ) ||
735  ( ( topLeftPad->GetPosition().x == pnt.x ) &&
736  ( pnt.y < topLeftPad->GetPosition().y ) ) )
737  {
738  topLeftPad = p;
739  }
740  }
741 
742  return topLeftPad;
743 }
744 
745 
746 unsigned MODULE::GetPadCount( INCLUDE_NPTH_T aIncludeNPTH ) const
747 {
748  if( aIncludeNPTH )
749  return m_Pads.GetCount();
750 
751  unsigned cnt = 0;
752 
753  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
754  {
755  if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED )
756  continue;
757 
758  cnt++;
759  }
760 
761  return cnt;
762 }
763 
764 
765 unsigned MODULE::GetUniquePadCount( INCLUDE_NPTH_T aIncludeNPTH ) const
766 {
767  std::set<wxString> usedNames;
768 
769  // Create a set of used pad numbers
770  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
771  {
772  // Skip pads not on copper layers (used to build complex
773  // solder paste shapes for instance)
774  if( ( pad->GetLayerSet() & LSET::AllCuMask() ).none() )
775  continue;
776 
777  // Skip pads with no name, because they are usually "mechanical"
778  // pads, not "electrical" pads
779  if( pad->GetName().IsEmpty() )
780  continue;
781 
782  if( !aIncludeNPTH )
783  {
784  // skip NPTH
785  if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED )
786  {
787  continue;
788  }
789  }
790 
791  usedNames.insert( pad->GetName() );
792  }
793 
794  return usedNames.size();
795 }
796 
797 
799 {
800  if( NULL == a3DModel )
801  return;
802 
803  if( !a3DModel->m_Filename.empty() )
804  m_3D_Drawings.push_back( *a3DModel );
805 
806  delete a3DModel;
807 }
808 
809 
810 // see class_module.h
811 SEARCH_RESULT MODULE::Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] )
812 {
813  KICAD_T stype;
815  const KICAD_T* p = scanTypes;
816  bool done = false;
817 
818 #if 0 && defined(DEBUG)
819  std::cout << GetClass().mb_str() << ' ';
820 #endif
821 
822  while( !done )
823  {
824  stype = *p;
825 
826  switch( stype )
827  {
828  case PCB_MODULE_T:
829  result = inspector( this, testData ); // inspect me
830  ++p;
831  break;
832 
833  case PCB_PAD_T:
834  result = IterateForward( m_Pads, inspector, testData, p );
835  ++p;
836  break;
837 
838  case PCB_MODULE_TEXT_T:
839  result = inspector( m_Reference, testData );
840 
841  if( result == SEARCH_QUIT )
842  break;
843 
844  result = inspector( m_Value, testData );
845 
846  if( result == SEARCH_QUIT )
847  break;
848 
849  // m_Drawings can hold TYPETEXTMODULE also, so fall thru
850 
851  case PCB_MODULE_EDGE_T:
852  result = IterateForward( m_Drawings, inspector, testData, p );
853 
854  // skip over any types handled in the above call.
855  for( ; ; )
856  {
857  switch( stype = *++p )
858  {
859  case PCB_MODULE_TEXT_T:
860  case PCB_MODULE_EDGE_T:
861  continue;
862 
863  default:
864  ;
865  }
866 
867  break;
868  }
869 
870  break;
871 
872  default:
873  done = true;
874  break;
875  }
876 
877  if( result == SEARCH_QUIT )
878  break;
879  }
880 
881  return result;
882 }
883 
884 
886 {
887  wxString text;
888  text.Printf( _( "Footprint %s on %s" ),
889  GetChars ( GetReference() ),
890  GetChars ( GetLayerName() ) );
891 
892  return text;
893 }
894 
895 
897 {
898  return module_xpm;
899 }
900 
901 
903 {
904  return new MODULE( *this );
905 }
906 
907 
908 void MODULE::RunOnChildren( const std::function<void (BOARD_ITEM*)>& aFunction )
909 {
910  try
911  {
912  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
913  aFunction( static_cast<BOARD_ITEM*>( pad ) );
914 
915  for( BOARD_ITEM* drawing = m_Drawings; drawing; drawing = drawing->Next() )
916  aFunction( drawing );
917 
918  aFunction( static_cast<BOARD_ITEM*>( m_Reference ) );
919  aFunction( static_cast<BOARD_ITEM*>( m_Value ) );
920  }
921  catch( std::bad_function_call& )
922  {
923  DisplayError( NULL, wxT( "Error running MODULE::RunOnChildren" ) );
924  }
925 }
926 
927 void MODULE::ViewGetLayers( int aLayers[], int& aCount ) const
928 {
929  aCount = 2;
930  aLayers[0] = LAYER_ANCHOR;
931 
932  switch( m_Layer )
933  {
934 
935  default:
936  wxASSERT_MSG( false, "Illegal layer" ); // do you really have modules placed on other layers?
937  // pass through
938  case F_Cu:
939  aLayers[1] = LAYER_MOD_FR;
940  break;
941 
942  case B_Cu:
943  aLayers[1] = LAYER_MOD_BK;
944  break;
945  }
946 
947  // If there are no pads, and only drawings on a silkscreen layer, then
948  // report the silkscreen layer as well so that the component can be edited
949  // with the silkscreen layer
950  bool f_silk = false, b_silk = false, non_silk = false;
951 
952  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
953  {
954  if( item->GetLayer() == F_SilkS )
955  f_silk = true;
956  else if( item->GetLayer() == B_SilkS )
957  b_silk = true;
958  else
959  non_silk = true;
960  }
961 
962  if( ( f_silk || b_silk ) && !non_silk && m_Pads.GetCount() == 0 )
963  {
964  if( f_silk )
965  aLayers[ aCount++ ] = F_SilkS;
966 
967  if( b_silk )
968  aLayers[ aCount++ ] = B_SilkS;
969  }
970 }
971 
972 
973 unsigned int MODULE::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
974 {
975  int layer = ( m_Layer == F_Cu ) ? LAYER_MOD_FR :
977 
978  // Currently it is only for anchor layer
979  if( aView->IsLayerVisible( layer ) )
980  return 30;
981 
983 }
984 
985 
986 const BOX2I MODULE::ViewBBox() const
987 {
988  EDA_RECT fpRect = GetFootprintRect();
989 
990  return BOX2I( VECTOR2I( fpRect.GetOrigin() ), VECTOR2I( fpRect.GetSize() ) );
991 }
992 
993 
994 bool MODULE::IsLibNameValid( const wxString & aName )
995 {
996  const wxChar * invalids = StringLibNameInvalidChars( false );
997 
998  if( aName.find_first_of( invalids ) != std::string::npos )
999  return false;
1000 
1001  return true;
1002 }
1003 
1004 
1005 const wxChar* MODULE::StringLibNameInvalidChars( bool aUserReadable )
1006 {
1007  static const wxChar invalidChars[] = wxT("%$\t \"\\/");
1008  static const wxChar invalidCharsReadable[] = wxT("% $ 'tab' 'space' \\ \" /");
1009 
1010  if( aUserReadable )
1011  return invalidCharsReadable;
1012  else
1013  return invalidChars;
1014 }
1015 
1016 
1017 void MODULE::Move( const wxPoint& aMoveVector )
1018 {
1019  wxPoint newpos = m_Pos + aMoveVector;
1020  SetPosition( newpos );
1021 }
1022 
1023 
1024 void MODULE::Rotate( const wxPoint& aRotCentre, double aAngle )
1025 {
1026  wxPoint newpos = m_Pos;
1027  RotatePoint( &newpos, aRotCentre, aAngle );
1028  SetPosition( newpos );
1029  SetOrientation( GetOrientation() + aAngle );
1030 }
1031 
1032 
1033 void MODULE::Flip( const wxPoint& aCentre )
1034 {
1035  // Move module to its final position:
1036  wxPoint finalPos = m_Pos;
1037  MIRROR( finalPos.y, aCentre.y );
1038  SetPosition( finalPos );
1039 
1040  // Flip layer
1041  SetLayer( FlipLayer( GetLayer() ) );
1042 
1043  // Reverse mirror orientation.
1044  m_Orient = -m_Orient;
1046 
1047  // Mirror pads to other side of board about the x axis, i.e. vertically.
1048  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1049  pad->Flip( m_Pos );
1050 
1051  // Mirror reference and value.
1052  m_Reference->Flip( m_Pos );
1053  m_Value->Flip( m_Pos );
1054 
1055  // Reverse mirror module graphics and texts.
1056  for( EDA_ITEM* item = m_Drawings; item; item = item->Next() )
1057  {
1058  switch( item->Type() )
1059  {
1060  case PCB_MODULE_EDGE_T:
1061  ( (EDGE_MODULE*) item )->Flip( m_Pos );
1062  break;
1063 
1064  case PCB_MODULE_TEXT_T:
1065  static_cast<TEXTE_MODULE*>( item )->Flip( m_Pos );
1066  break;
1067 
1068  default:
1069  wxMessageBox( wxT( "MODULE::Flip() error: Unknown Draw Type" ) );
1070  break;
1071  }
1072  }
1073 
1075 }
1076 
1077 
1078 void MODULE::SetPosition( const wxPoint& newpos )
1079 {
1080  wxPoint delta = newpos - m_Pos;
1081 
1082  m_Pos += delta;
1083 
1084  m_Reference->EDA_TEXT::Offset( delta );
1085  m_Value->EDA_TEXT::Offset( delta );
1086 
1087  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1088  {
1089  pad->SetPosition( pad->GetPosition() + delta );
1090  }
1091 
1092  for( EDA_ITEM* item = m_Drawings; item; item = item->Next() )
1093  {
1094  switch( item->Type() )
1095  {
1096  case PCB_MODULE_EDGE_T:
1097  {
1098  EDGE_MODULE* pt_edgmod = (EDGE_MODULE*) item;
1099  pt_edgmod->SetDrawCoord();
1100  break;
1101  }
1102 
1103  case PCB_MODULE_TEXT_T:
1104  {
1105  TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
1106  text->EDA_TEXT::Offset( delta );
1107  break;
1108  }
1109 
1110  default:
1111  wxMessageBox( wxT( "Draw type undefined." ) );
1112  break;
1113  }
1114  }
1115 
1117 }
1118 
1119 
1120 void MODULE::MoveAnchorPosition( const wxPoint& aMoveVector )
1121 {
1122  /* Move the reference point of the footprint
1123  * the footprints elements (pads, outlines, edges .. ) are moved
1124  * but:
1125  * - the footprint position is not modified.
1126  * - the relative (local) coordinates of these items are modified
1127  * - Draw coordinates are updated
1128  */
1129 
1130 
1131  // Update (move) the relative coordinates relative to the new anchor point.
1132  wxPoint moveVector = aMoveVector;
1133  RotatePoint( &moveVector, -GetOrientation() );
1134 
1135  // Update of the reference and value.
1136  m_Reference->SetPos0( m_Reference->GetPos0() + moveVector );
1138  m_Value->SetPos0( m_Value->GetPos0() + moveVector );
1139  m_Value->SetDrawCoord();
1140 
1141  // Update the pad local coordinates.
1142  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
1143  {
1144  pad->SetPos0( pad->GetPos0() + moveVector );
1145  pad->SetDrawCoord();
1146  }
1147 
1148  // Update the draw element coordinates.
1149  for( EDA_ITEM* item = GraphicalItemsList(); item; item = item->Next() )
1150  {
1151  switch( item->Type() )
1152  {
1153  case PCB_MODULE_EDGE_T:
1154  {
1155  EDGE_MODULE* edge = static_cast<EDGE_MODULE*>( item );
1156  edge->m_Start0 += moveVector;
1157  edge->m_End0 += moveVector;
1158  edge->SetDrawCoord();
1159  break;
1160  }
1161 
1162  case PCB_MODULE_TEXT_T:
1163  {
1164  TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
1165  text->SetPos0( text->GetPos0() + moveVector );
1166  text->SetDrawCoord();
1167  break;
1168  }
1169 
1170  default:
1171  break;
1172  }
1173  }
1174 
1176 }
1177 
1178 
1179 void MODULE::SetOrientation( double newangle )
1180 {
1181  double angleChange = newangle - m_Orient; // change in rotation
1182 
1183  NORMALIZE_ANGLE_POS( newangle );
1184 
1185  m_Orient = newangle;
1186 
1187  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1188  {
1189  pad->SetOrientation( pad->GetOrientation() + angleChange );
1190  pad->SetDrawCoord();
1191  }
1192 
1193  // Update of the reference and value.
1195  m_Value->SetDrawCoord();
1196 
1197  // Displace contours and text of the footprint.
1198  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
1199  {
1200  if( item->Type() == PCB_MODULE_EDGE_T )
1201  {
1202  static_cast<EDGE_MODULE*>( item )->SetDrawCoord();
1203  }
1204  else if( item->Type() == PCB_MODULE_TEXT_T )
1205  {
1206  static_cast<TEXTE_MODULE*>( item )->SetDrawCoord();
1207  }
1208  }
1209 
1211 }
1212 
1214  bool aIncrementPadNumbers,
1215  bool aAddToModule )
1216 {
1217  BOARD_ITEM* new_item = NULL;
1218  D_PAD* new_pad = NULL;
1219 
1220  switch( aItem->Type() )
1221  {
1222  case PCB_PAD_T:
1223  {
1224  new_pad = new D_PAD( *static_cast<const D_PAD*>( aItem ) );
1225 
1226  if( aAddToModule )
1227  PadsList().PushBack( new_pad );
1228 
1229  new_item = new_pad;
1230  break;
1231  }
1232 
1233  case PCB_MODULE_TEXT_T:
1234  {
1235  const TEXTE_MODULE* old_text = static_cast<const TEXTE_MODULE*>( aItem );
1236 
1237  // do not duplicate value or reference fields
1238  // (there can only be one of each)
1239  if( old_text->GetType() == TEXTE_MODULE::TEXT_is_DIVERS )
1240  {
1241  TEXTE_MODULE* new_text = new TEXTE_MODULE( *old_text );
1242 
1243  if( aAddToModule )
1244  GraphicalItemsList().PushBack( new_text );
1245 
1246  new_item = new_text;
1247  }
1248  break;
1249  }
1250 
1251  case PCB_MODULE_EDGE_T:
1252  {
1253  EDGE_MODULE* new_edge = new EDGE_MODULE(
1254  *static_cast<const EDGE_MODULE*>(aItem) );
1255 
1256  if( aAddToModule )
1257  GraphicalItemsList().PushBack( new_edge );
1258 
1259  new_item = new_edge;
1260  break;
1261  }
1262 
1263  case PCB_MODULE_T:
1264  // Ignore the module itself
1265  break;
1266 
1267  default:
1268  // Un-handled item for duplication
1269  wxASSERT_MSG( false, "Duplication not supported for items of class "
1270  + aItem->GetClass() );
1271  break;
1272  }
1273 
1274  if( aIncrementPadNumbers && new_pad )
1275  {
1276  new_pad->IncrementPadName( true, true );
1277  }
1278 
1279  return new_item;
1280 }
1281 
1282 
1283 wxString MODULE::GetNextPadName( bool aFillSequenceGaps ) const
1284 {
1285  std::set<int> usedNumbers;
1286 
1287  // Create a set of used pad numbers
1288  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
1289  {
1290  int padNumber = getTrailingInt( pad->GetName() );
1291  usedNumbers.insert( padNumber );
1292  }
1293 
1294  const int nextNum = getNextNumberInSequence( usedNumbers, aFillSequenceGaps );
1295 
1296  return wxString::Format( wxT( "%i" ), nextNum );
1297 }
1298 
1299 
1301 {
1302  wxString prefix = GetReference();
1303 
1304  int strIndex = prefix.length() - 1;
1305  while( strIndex >= 0 )
1306  {
1307  const wxUniChar chr = prefix.GetChar( strIndex );
1308 
1309  // numeric suffix
1310  if( chr >= '0' && chr <= '9' )
1311  break;
1312 
1313  strIndex--;
1314  }
1315 
1316  prefix = prefix.Mid( 0, strIndex );
1317 
1318  return prefix;
1319 }
1320 
1321 
1322 // Calculate the area of aPolySet, after fracturation, because
1323 // polygons with no hole are expected.
1324 static double polygonArea( SHAPE_POLY_SET& aPolySet )
1325 {
1326  double area = 0.0;
1327  for( int ii = 0; ii < aPolySet.OutlineCount(); ii++ )
1328  {
1329  SHAPE_LINE_CHAIN& outline = aPolySet.Outline( ii );
1330  // Ensure the curr outline is closed, to calculate area
1331  outline.SetClosed( true );
1332 
1333  area += outline.Area();
1334  }
1335 
1336  return area;
1337 }
1338 
1339 // a helper function to add a rectangular polygon aRect to aPolySet
1340 static void addRect( SHAPE_POLY_SET& aPolySet, wxRect aRect )
1341 {
1342  aPolySet.NewOutline();
1343 
1344  aPolySet.Append( aRect.GetX(), aRect.GetY() );
1345  aPolySet.Append( aRect.GetX()+aRect.width, aRect.GetY() );
1346  aPolySet.Append( aRect.GetX()+aRect.width, aRect.GetY()+aRect.height );
1347  aPolySet.Append( aRect.GetX(), aRect.GetY()+aRect.height );
1348 }
1349 
1350 double MODULE::CoverageRatio( const GENERAL_COLLECTOR& aCollector ) const
1351 {
1352  double moduleArea = GetFootprintRect().GetArea();
1353  SHAPE_POLY_SET coveredRegion;
1354  addRect( coveredRegion, GetFootprintRect() );
1355 
1356  // build list of holes (covered areas not available for selection)
1357  SHAPE_POLY_SET holes;
1358 
1359  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1360  addRect( holes, pad->GetBoundingBox() );
1361 
1362  addRect( holes, m_Reference->GetBoundingBox() );
1363  addRect( holes, m_Value->GetBoundingBox() );
1364 
1365  for( int i = 0; i < aCollector.GetCount(); ++i )
1366  {
1367  BOARD_ITEM* item = aCollector[i];
1368 
1369  switch( item->Type() )
1370  {
1371  case PCB_TEXT_T:
1372  case PCB_MODULE_TEXT_T:
1373  case PCB_TRACE_T:
1374  case PCB_VIA_T:
1375  addRect( holes, item->GetBoundingBox() );
1376  break;
1377  default:
1378  break;
1379  }
1380  }
1381 
1382  SHAPE_POLY_SET uncoveredRegion;
1383  uncoveredRegion.BooleanSubtract( coveredRegion, holes, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1384  uncoveredRegion.Simplify( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1385  uncoveredRegion.Fracture( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
1386 
1387  double uncoveredRegionArea = polygonArea( uncoveredRegion );
1388  double coveredArea = moduleArea - uncoveredRegionArea;
1389  double ratio = ( coveredArea / moduleArea );
1390 
1391  return std::min( ratio, 1.0 );
1392 }
1393 
1394 
1395 // see convert_drawsegment_list_to_polygon.cpp:
1396 extern bool ConvertOutlineToPolygon( std::vector< DRAWSEGMENT* >& aSegList,
1397  SHAPE_POLY_SET& aPolygons, int aSegmentsByCircle,
1398  wxString* aErrorText);
1399 
1401 {
1404  // Build the courtyard area from graphic items on the courtyard.
1405  // Only PCB_MODULE_EDGE_T have meaning, graphic texts are ignored.
1406  // Collect items:
1407  std::vector< DRAWSEGMENT* > list_front;
1408  std::vector< DRAWSEGMENT* > list_back;
1409 
1410  for( BOARD_ITEM* item = GraphicalItemsList(); item; item = item->Next() )
1411  {
1412  if( item->GetLayer() == B_CrtYd && item->Type() == PCB_MODULE_EDGE_T )
1413  list_back.push_back( static_cast< DRAWSEGMENT* > ( item ) );
1414 
1415  if( item->GetLayer() == F_CrtYd && item->Type() == PCB_MODULE_EDGE_T )
1416  list_front.push_back( static_cast< DRAWSEGMENT* > ( item ) );
1417  }
1418 
1419  // Note: if no item found on courtyard layers, return true.
1420  // false is returned only when the shape defined on courtyard layers
1421  // is not convertible to a polygon
1422  if( !list_front.size() && !list_back.size() )
1423  return true;
1424 
1425  wxString error_msg;
1426 
1427  const int STEPS = 36; // for a segmentation of an arc of 360 degrees
1428  bool success = ConvertOutlineToPolygon( list_front, m_poly_courtyard_front,
1429  STEPS, &error_msg );
1430 
1431  if( success )
1432  success = ConvertOutlineToPolygon( list_back, m_poly_courtyard_back,
1433  STEPS, &error_msg );
1434 
1435  if( !error_msg.IsEmpty() )
1436  {
1437  error_msg.Prepend( GetReference() + ": " );
1438  wxLogMessage( error_msg );
1439  }
1440 
1441  return success;
1442 }
1443 
1445 {
1446  assert( aImage->Type() == PCB_MODULE_T );
1447 
1448  std::swap( *((MODULE*) this), *((MODULE*) aImage) );
1449 }
LIB_ID m_fpid
The LIB_ID of the MODULE.
Definition: class_module.h:718
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:673
bool BuildPolyCourtyard()
Used in DRC to build the courtyard area (a complex polygon) from graphic items put on the courtyard...
bool IncrementPadName(bool aSkipUnconnectable, bool aFillSequenceGaps)
Function IncrementPadName.
Definition: class_pad.cpp:515
int GetCount() const
Function GetCount returns the number of objects in the list.
Definition: collector.h:107
KICAD_T Type() const
Function Type()
Definition: base_struct.h:227
virtual const EDA_RECT GetBoundingBox() const
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
static SEARCH_RESULT IterateForward(EDA_ITEM *listStart, INSPECTOR inspector, void *testData, const KICAD_T scanTypes[])
Function IterateForward walks through the object tree calling the inspector() on each object type req...
BOX2< VECTOR2I > BOX2I
Definition: box2.h:468
bool IsMoving() const
Definition: base_struct.h:247
wxString GetReferencePrefix() const
Function GetReference prefix Gets the alphabetic prefix of the module reference - e...
void SetThermalGap(int aGap)
Definition: class_module.h:221
int m_CntRot90
Horizontal automatic placement cost ( 0..10 ).
Definition: class_module.h:734
int GetThermalGap() const
Definition: class_module.h:222
const wxPoint GetOrigin() const
Definition: eda_rect.h:112
void Merge(const EDA_RECT &aRect)
Function Merge modifies the position and size of the rectangle in order to contain aRect...
void RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction)
Function RunOnChildren.
void Rotate(const wxPoint &aRotCentre, double aAngle) override
Function Rotate Rotate this object.
SHAPE_POLY_SET m_poly_courtyard_back
Definition: class_module.h:752
T * Remove(T *aElement)
Function Remove removes aElement from the list, but does not delete it.
Definition: dlist.h:211
PNG memory record (file in memory).
Definition: bitmap_types.h:41
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
void GRSetDrawMode(wxDC *DC, GR_DRAWMODE draw_mode)
Definition: gr_basic.cpp:318
void SetLocalClearance(int aClearance)
Definition: class_module.h:207
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
void PushFront(T *aNewElement)
Function PushFront puts aNewElement at front of list sequence.
Definition: dlist.h:240
wxString m_KeyWord
Search keywords to find module in library.
Definition: class_module.h:727
bool IsLayerVisible(int aLayer) const
Function IsLayerVisible() Returns information about visibility of a particular layer.
Definition: view.h:404
wxString m_Path
Definition: class_module.h:728
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
This file is part of the common library.
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class...
int GetLocalClearance() const
Definition: class_module.h:206
int m_ThermalWidth
Definition: class_module.h:724
const wxSize GetSize() const
Definition: eda_rect.h:101
TEXT_TYPE GetType() const
int GetBiggestClearanceValue()
Function GetBiggestClearanceValue.
bool ConvertOutlineToPolygon(std::vector< DRAWSEGMENT * > &aSegList, SHAPE_POLY_SET &aPolygons, int aSegmentsByCircle, wxString *aErrorText)
Function ConvertOutlineToPolygon build a polygon (with holes) from a DRAWSEGMENT list, which is expected to be a outline, therefore a closed main outline with perhaps closed inner outlines.
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
bool Contains(const wxPoint &aPoint) const
Function Contains.
const wxPoint & GetPos0() const
anchor of items having an anchor point (texts, footprints)
static double polygonArea(SHAPE_POLY_SET &aPolySet)
void CalculateBoundingBox()
Function CalculateBoundingBox calculates the bounding box in board coordinates.
void Draw(EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset=ZeroOffset) override
Function Draw draws the footprint to the aDC.
double m_LocalSolderPasteMarginRatio
Solder mask margin ratio value of pad size.
Definition: class_module.h:743
void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
Class BOARD to handle a board.
Definition: colors.h:61
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount)
Function FlippedLayerNumber.
Definition: lset.cpp:472
D_PAD * FindPadByName(const wxString &aPadName) const
Function FindPadByName returns a D_PAD* with a matching name.
BOARD_ITEM * Duplicate(const BOARD_ITEM *aItem, bool aIncrementPadNumbers, bool aAddToModule=false)
Function Duplicate Duplicate a given item within the module, without adding to the board...
int m_LocalSolderPasteMargin
Solder paste margin absolute value.
Definition: class_module.h:742
int m_ThermalGap
Definition: class_module.h:725
show modules on back
int GetHeight() const
Definition: eda_rect.h:118
Set for modules listed in the automatic insertion list (usually SMD footprints)
Definition: class_module.h:77
coord_type GetRight() const
Definition: box2.h:187
class TEXTE_PCB, text on a layer
Definition: typeinfo.h:92
void SetOrigin(const wxPoint &pos)
Definition: eda_rect.h:124
show modules values (when texts are visibles)
void GRDrawAnchor(EDA_RECT *aClipBox, wxDC *aDC, int x, int y, int aSize, COLOR4D aColor)
Definition: gr_basic.cpp:1288
void SetZoneConnection(ZoneConnection aType)
Definition: class_module.h:215
wxString GetSelectMenuText() const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
MODULE(BOARD *parent)
class D_PAD, a pad in a footprint
Definition: typeinfo.h:90
void Add3DModel(MODULE_3D_SETTINGS *a3DModel)
Function Add3DModel adds a3DModel definition to the end of the 3D model list.
static const wxChar * StringLibNameInvalidChars(bool aUserReadable)
static function StringLibNameInvalidChars Test for validity of the name in a library of the footprint...
EDA_ITEM * Next() const
Definition: base_struct.h:235
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
double m_Surface
Bounding box area.
Definition: class_module.h:732
ZoneConnection GetZoneConnection() const
Definition: class_module.h:216
int OutlineCount() const
Returns the number of outlines in the set
void NORMALIZE_ANGLE_POS(T &Angle)
Definition: trigo.h:241
void DeleteAll()
Function DeleteAll deletes all items on the list and leaves the list empty.
Definition: dlist.cpp:41
virtual wxString GetShownText() const override
Returns the string actually shown after processing of the base text.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:589
void MoveAnchorPosition(const wxPoint &aMoveVector)
Function MoveAnchorPosition Move the reference point of the footprint It looks like a move footprint:...
#define abs(a)
Definition: auxiliary.h:84
wxArrayString * m_initial_comments
leading s-expression comments in the module, lazily allocated only if needed for speed ...
Definition: class_module.h:746
void SetLocalSolderPasteMarginRatio(double aRatio)
Definition: class_module.h:213
wxString GetLayerName() const
Function GetLayerName returns the name of the PCB layer on which the item resides.
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
void DrawAncre(EDA_DRAW_PANEL *panel, wxDC *DC, const wxPoint &offset, int dim_ancre, GR_DRAWMODE draw_mode)
Function DrawAncre Draw the anchor cross (vertical) Must be done after the pads, because drawing the ...
double GetLocalSolderPasteMarginRatio() const
Definition: class_module.h:212
#define MODULE_PADS_LOCKED
In autoplace: module waiting for autoplace.
Definition: class_module.h:260
static const int delta[8][2]
Definition: solve.cpp:112
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:61
static int getNextNumberInSequence(const std::set< int > &aSeq, bool aFillSequenceGaps)
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:78
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
wxString m_Doc
File name and path for documentation file.
Definition: class_module.h:726
#define DIM_ANCRE_MODULE
Definition: pcbnew.h:59
wxPoint m_End0
This file contains miscellaneous commonly used macros and functions.
#define MODULE_is_PLACED
In autoplace: module automatically placed.
Definition: class_module.h:258
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
void GetMsgPanelInfo(std::vector< MSG_PANEL_ITEM > &aList) override
>
show modules on front
BOARD_ITEM * Next() const
int m_LocalClearance
Definition: class_module.h:740
const INSPECTOR_FUNC & INSPECTOR
Definition: base_struct.h:118
PCB_LAYER_ID m_Layer
double m_Orient
Orientation in tenths of a degree, 900=90.0 degrees.
Definition: class_module.h:714
void MIRROR(T &aPoint, const T &aMirrorRef)
Definition: macros.h:111
static void addRect(SHAPE_POLY_SET &aPolySet, wxRect aRect)
class MODULE, a footprint
Definition: typeinfo.h:89
void SetClosed(bool aClosed)
Function SetClosed()
void ClearAllNets()
Function ClearAllNets Clear (i.e.
const EDA_RECT GetBoundingBox() const override
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
void GRRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, COLOR4D aColor)
Definition: gr_basic.cpp:1098
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
>
virtual void ViewGetLayers(int aLayers[], int &aCount) const override
Function ViewGetLayers() Returns the all the layers within the VIEW the object is painted on...
double GetArea() const
Function GetArea returns the area of the rectangle.
EDA_RECT m_BoundaryBox
Bounding box : coordinates on board, real orientation.
Definition: class_module.h:721
Class LSET is a set of PCB_LAYER_IDs.
void Inflate(int aFactor, int aCircleSegmentsCount)
Performs outline inflation/deflation, using round corners.
double GetOrientationDegrees() const
Definition: class_module.h:188
void SetParent(EDA_ITEM *aParent)
Definition: base_struct.h:242
double GetOrientation() const
Definition: class_module.h:187
GR_DRAWMODE
Drawmode. Compositing mode plus a flag or two.
Definition: gr_basic.h:37
Class SHAPE_POLY_SET.
SHAPE_LINE_CHAIN & Outline(int aIndex)
Returns the reference to aIndex-th outline in the set
EDA_RECT GetFootprintRect() const
Function GetFootprintRect() Returns the area of the module footprint excluding any text...
void SetEnd(int x, int y)
Definition: eda_rect.h:134
bool IsFlipped() const
function IsFlipped
Definition: class_module.h:254
virtual const BOX2I ViewBBox() const override
Function ViewBBox() returns the bounding box of the item covering all its layers. ...
const Vec & GetPosition() const
Definition: box2.h:182
T * GetFirst() const
Function GetFirst returns the first T* in the list without removing it, or NULL if the list is empty...
Definition: dlist.h:163
coord_type GetBottom() const
Definition: box2.h:188
D_PAD * Next() const
Definition: class_pad.h:160
timestamp_t m_Link
Temporary logical link used in edition.
Definition: class_module.h:733
void SetThermalWidth(int aWidth)
Definition: class_module.h:218
int m_LocalSolderMaskMargin
Solder mask margin.
Definition: class_module.h:741
std::list< MODULE_3D_SETTINGS > m_3D_Drawings
Linked list of 3D models.
Definition: class_module.h:713
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
int m_arflag
Use to trace ratsnest and auto routing.
Definition: class_module.h:731
EDA_RECT * GetClipBox()
Definition: colors.h:60
void Flip(const wxPoint &aCentre) override
Flip entity during module flip.
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
EDA_ITEM * Clone() const override
Function Clone creates a duplicate of this item with linked list members set to NULL.
const EDA_RECT GetBoundingBox() const override
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
EDA_DRAW_FRAME * GetParent() const
Definition: draw_panel.cpp:181
SHAPE_POLY_SET m_poly_courtyard_front
Used in DRC to test the courtyard area (a polygon which can be not basic Note also a footprint can ha...
Definition: class_module.h:751
virtual void SetPosition(const wxPoint &aPos) override
void Remove(BOARD_ITEM *aItem) override
>
virtual unsigned int ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Function ViewGetLOD() Returns the level of detail (LOD) of the item.
void SetPosition(const wxPoint &aPos) override
int GetLocalSolderMaskMargin() const
Definition: class_module.h:203
void DrawEdgesOnly(EDA_DRAW_PANEL *panel, wxDC *DC, const wxPoint &offset, GR_DRAWMODE draw_mode)
Function DrawEdgesOnly Draws the footprint edges only to the current Device Context.
void Draw(EDA_DRAW_PANEL *aPanel, wxDC *aDC, GR_DRAWMODE aDrawMode, const wxPoint &aOffset=ZeroOffset) override
Function Draw Draw the text according to the footprint pos and orient.
wxString GetNextPadName(bool aFillSequenceGaps) const
Function GetNextPadName returns the next available pad name in the module.
int NewOutline()
Creates a new empty polygon in the set and returns its index
double GetOrientationRadians() const
Definition: class_module.h:189
bool IsLocked() const override
Function IsLocked.
Definition: class_module.h:263
EDA_ITEM & operator=(const EDA_ITEM &aItem)
Operator assignment is used to assign the members of aItem to another object.
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
void SetLocalSolderMaskMargin(int aMargin)
Definition: class_module.h:204
D_PAD * GetTopLeftPad()
void SetPos0(const wxPoint &aPos)
double CoverageRatio(const GENERAL_COLLECTOR &aCollector) const
Function CoverageRatio Calculates the ratio of total area of the footprint pads and graphical items t...
static const int ORPHANED
Constant that forces initialization of a netinfo item to the NETINFO_ITEM ORPHANED (typically -1) whe...
Definition: netinfo.h:465
int GetLocalSolderPasteMargin() const
Definition: class_module.h:209
MODULE & operator=(const MODULE &aOther)
unsigned GetPadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
GetPadCount returns the number of pads.
wxString m_Filename
The 3D shape filename in 3D library.
Definition: class_module.h:102
default
Definition: class_module.h:76
BITMAP_DEF GetMenuImage() const override
Function GetMenuImage returns a pointer to an image to be used in menus.
class TEXTE_MODULE, text in a footprint
Definition: typeinfo.h:93
static bool IsLibNameValid(const wxString &aName)
static function IsLibNameValid Test for validity of a name of a footprint to be used in a footprint l...
time_t m_LastEditTime
Definition: class_module.h:730
bool Intersects(const EDA_RECT &aRect) const
Function Intersects tests for a common area between rectangles.
D_PAD * GetPad(const wxPoint &aPosition, LSET aLayerMask=LSET::AllLayersMask())
Function GetPad get a pad at aPosition on aLayerMask in the footprint.
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Function IsElementVisible tests whether a given element category is visible.
void SetLocalSolderPasteMargin(int aMargin)
Definition: class_module.h:210
bool HitTestAccurate(const wxPoint &aPosition) const
Tests if a point is inside the bounding polygon of the module.
int m_CntRot180
Vertical automatic placement cost ( 0..10 ).
Definition: class_module.h:735
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
virtual wxString GetClass() const =0
Function GetClass returns the class name.
void SetLocked(bool isLocked) override
Function SetLocked sets the MODULE_is_LOCKED bit in the m_ModuleStatus.
Definition: class_module.h:273
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
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...
DLIST< BOARD_ITEM > m_Drawings
Linked list of graphical items.
Definition: class_module.h:712
#define max(a, b)
Definition: auxiliary.h:86
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
const wxString & GetReference() const
Function GetReference.
Definition: class_module.h:458
int m_ModuleStatus
For autoplace: flags (LOCKED, AUTOPLACED)
Definition: class_module.h:720
Class SHAPE_LINE_CHAIN.
double Area() const
void Move(const wxPoint &aMoveVector) override
Function Move move this object.
void SetOrientation(double newangle)
static int getTrailingInt(const wxString &aStr)
Virtual component: when created by copper shapes on board (Like edge card connectors, mounting hole...)
Definition: class_module.h:79
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:232
virtual void SwapData(BOARD_ITEM *aImage) override
Swap data between aItem and aImage.
const char * c_str() const
Definition: utf8.h:107
STATUS_FLAGS m_Flags
Flag bits for editing and other uses.
Definition: base_struct.h:204
wxString GetClass() const override
Function GetClass returns the class name.
Definition: class_module.h:594
void RemoveAllContours()
Removes all outlines & holes (clears) the polygon set.
void SetDrawCoord()
Set absolute coordinates.
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
TEXTE_MODULE * m_Value
Component value (74LS00, 22K..)
Definition: class_module.h:717
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:180
int GetWidth() const
Definition: eda_rect.h:117
wxPoint m_Pos
Position of module on the board in internal units.
Definition: class_module.h:715
UTF8 Format() const
Definition: lib_id.cpp:263
virtual BOARD * GetBoard() const
Function GetBoard returns the BOARD in which this BOARD_ITEM resides, or NULL if none.
unsigned GetCount() const
Function GetCount returns the number of elements in the list.
Definition: dlist.h:126
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:164
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
TEXTE_MODULE * m_Reference
Component reference designator value (U34, R18..)
Definition: class_module.h:716
void CopyNetlistSettings(MODULE *aModule, bool aCopyLocalSettings)
Function CopyNetlistSettings copies the netlist settings to aModule.
DLIST< D_PAD > & PadsList()
Definition: class_module.h:161
unsigned GetUniquePadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
GetUniquePadCount returns the number of unique pads.
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Performs boolean polyset difference For aFastMode meaning, see function booleanOp ...
Module description (excepted pads)
Definition: colors.h:45
Abstract interface for BOARD_ITEMs capable of storing other items inside.
wxPoint m_Start0
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
SEARCH_RESULT
Definition: base_struct.h:82
DLIST< D_PAD > m_Pads
Linked list of pads.
Definition: class_module.h:711
const wxPoint GetPosition() const override
Definition: class_pad.h:220
coord_type GetX() const
Definition: box2.h:178
EDGE_MODULE class definition.
ZoneConnection m_ZoneConnection
Definition: class_module.h:729
Message panel definition file.
void Rotate(double aAngle, const VECTOR2I &aCenter)
Function Rotate rotates all vertices by a given angle.
INCLUDE_NPTH_T
Definition: class_module.h:62
void DisplayError(wxWindow *parent, const wxString &text, int displaytime)
Function DisplayError displays an error or warning message box with aMessage.
Definition: confirm.cpp:241
SHAPE_POLY_SET GetBoundingPoly() const
Returns a bounding polygon for the shapes and pads in the module This operation is slower but more ac...
const wxPoint GetPosition() const override
Definition: class_module.h:182
void CopyNetlistSettings(D_PAD *aPad, bool aCopyLocalSettings)
Function CopyNetlistSettings copies the netlist settings to aPad, and the net name.
Definition: class_pad.cpp:526
show modules references (when texts are visibles)
int GetThermalWidth() const
Definition: class_module.h:219
#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.
#define min(a, b)
Definition: auxiliary.h:85
int m_Attributs
Flag bits ( see Mod_Attribut )
Definition: class_module.h:719
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline) ...
virtual const EDA_RECT GetBoundingBox() const override
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
bool HitTest(const wxPoint &aPosition) const override
Function HitTest tests if aPosition is contained within or on the bounding area of an item...
Definition: colors.h:62