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 <wxstruct.h>
35 #include <plot_common.h>
36 #include <class_drawpanel.h>
37 #include <trigo.h>
38 #include <confirm.h>
39 #include <kicad_string.h>
40 #include <pcbnew.h>
41 #include <richio.h>
42 #include <filter_reader.h>
43 #include <macros.h>
44 #include <msgpanel.h>
45 #include <bitmaps.h>
46 
47 #include <wxPcbStruct.h>
48 #include <class_board.h>
49 #include <class_edge_mod.h>
50 #include <class_module.h>
52 
53 #include <view/view.h>
54 
55 MODULE::MODULE( BOARD* parent ) :
57  m_initial_comments( 0 )
58 {
60  m_Layer = F_Cu;
61  m_Orient = 0;
63  m_arflag = 0;
64  m_CntRot90 = m_CntRot180 = 0;
65  m_Surface = 0.0;
66  m_Link = 0;
67  m_LastEditTime = 0;
68  m_LocalClearance = 0;
72  m_ZoneConnection = PAD_ZONE_CONN_INHERITED; // Use zone setting by default
73  m_ThermalWidth = 0; // Use zone setting by default
74  m_ThermalGap = 0; // Use zone setting by default
75 
76  // These are special and mandatory text fields
79 
80  m_3D_Drawings.clear();
81 }
82 
83 
84 MODULE::MODULE( const MODULE& aModule ) :
85  BOARD_ITEM_CONTAINER( aModule )
86 {
87  m_Pos = aModule.m_Pos;
88  m_fpid = aModule.m_fpid;
89  m_Attributs = aModule.m_Attributs;
91  m_Orient = aModule.m_Orient;
92  m_BoundaryBox = aModule.m_BoundaryBox;
93  m_CntRot90 = aModule.m_CntRot90;
94  m_CntRot180 = aModule.m_CntRot180;
96  m_Link = aModule.m_Link;
97  m_Path = aModule.m_Path; //is this correct behavior?
98 
104  m_ThermalWidth = aModule.m_ThermalWidth;
105  m_ThermalGap = aModule.m_ThermalGap;
106 
107  // Copy reference and value.
108  m_Reference = new TEXTE_MODULE( *aModule.m_Reference );
109  m_Reference->SetParent( this );
110  m_Value = new TEXTE_MODULE( *aModule.m_Value );
111  m_Value->SetParent( this );
112 
113  // Copy auxiliary data: Pads
114  for( D_PAD* pad = aModule.m_Pads; pad; pad = pad->Next() )
115  {
116  Add( new D_PAD( *pad ) );
117  }
118 
119  // Copy auxiliary data: Drawings
120  for( BOARD_ITEM* item = aModule.m_Drawings; item; item = item->Next() )
121  {
122  switch( item->Type() )
123  {
124  case PCB_MODULE_TEXT_T:
125  case PCB_MODULE_EDGE_T:
126  Add( static_cast<BOARD_ITEM*>( item->Clone() ) );
127  break;
128 
129  default:
130  wxLogMessage( wxT( "Class MODULE copy constructor internal error: unknown type" ) );
131  break;
132  }
133  }
134 
135  // Copy auxiliary data: 3D_Drawings info
136  m_3D_Drawings = aModule.m_3D_Drawings;
137 
138  m_Doc = aModule.m_Doc;
139  m_KeyWord = aModule.m_KeyWord;
140 
141  m_arflag = 0;
142 
143  // Ensure auxiliary data is up to date
145 
147  new wxArrayString( *aModule.m_initial_comments ) : 0;
148 }
149 
150 
152 {
153  delete m_Reference;
154  delete m_Value;
155  delete m_initial_comments;
156 }
157 
158 
159 MODULE& MODULE::operator=( const MODULE& aOther )
160 {
161  BOARD_ITEM::operator=( aOther );
162 
163  m_Pos = aOther.m_Pos;
164  m_fpid = aOther.m_fpid;
165  m_Attributs = aOther.m_Attributs;
167  m_Orient = aOther.m_Orient;
168  m_BoundaryBox = aOther.m_BoundaryBox;
169  m_CntRot90 = aOther.m_CntRot90;
170  m_CntRot180 = aOther.m_CntRot180;
172  m_Link = aOther.m_Link;
173  m_Path = aOther.m_Path; //is this correct behavior?
174 
181  m_ThermalGap = aOther.m_ThermalGap;
182 
183  // Copy reference and value
184  *m_Reference = *aOther.m_Reference;
185  m_Reference->SetParent( this );
186  *m_Value = *aOther.m_Value;
187  m_Value->SetParent( this );
188 
189  // Copy auxiliary data: Pads
190  m_Pads.DeleteAll();
191 
192  for( D_PAD* pad = aOther.m_Pads; pad; pad = pad->Next() )
193  {
194  Add( new D_PAD( *pad ) );
195  }
196 
197  // Copy auxiliary data: Drawings
199 
200  for( BOARD_ITEM* item = aOther.m_Drawings; item; item = item->Next() )
201  {
202  switch( item->Type() )
203  {
204  case PCB_MODULE_TEXT_T:
205  case PCB_MODULE_EDGE_T:
206  Add( static_cast<BOARD_ITEM*>( item->Clone() ) );
207  break;
208 
209  default:
210  wxLogMessage( wxT( "MODULE::operator=() internal error: unknown type" ) );
211  break;
212  }
213  }
214 
215  // Copy auxiliary data: 3D_Drawings info
216  m_3D_Drawings.clear();
217  m_3D_Drawings = aOther.m_3D_Drawings;
218  m_Doc = aOther.m_Doc;
219  m_KeyWord = aOther.m_KeyWord;
220 
221  // Ensure auxiliary data is up to date
223 
224  return *this;
225 }
226 
227 
229 {
230  // Force the ORPHANED dummy net info for all pads.
231  // ORPHANED dummy net does not depend on a board
232  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
233  pad->SetNetCode( NETINFO_LIST::ORPHANED );
234 }
235 
236 
237 void MODULE::DrawAncre( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,
238  int dim_ancre, GR_DRAWMODE draw_mode )
239 {
240  auto frame = (PCB_EDIT_FRAME*) panel->GetParent();
241 
242  GRSetDrawMode( DC, draw_mode );
243 
244  if( GetBoard()->IsElementVisible( LAYER_ANCHOR ) )
245  {
246  GRDrawAnchor( panel->GetClipBox(), DC, m_Pos.x, m_Pos.y,
247  dim_ancre,
248  frame->Settings().Colors().GetItemColor( LAYER_ANCHOR ) );
249  }
250 }
251 
252 
253 void MODULE::Add( BOARD_ITEM* aBoardItem, ADD_MODE aMode )
254 {
255  switch( aBoardItem->Type() )
256  {
257  case PCB_MODULE_TEXT_T:
258  // Only user texts can be added this way. Reference and value are not hold in the DLIST.
259  assert( static_cast<TEXTE_MODULE*>( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS );
260 
261  // no break
262 
263  case PCB_MODULE_EDGE_T:
264  if( aMode == ADD_APPEND )
265  m_Drawings.PushBack( aBoardItem );
266  else
267  m_Drawings.PushFront( aBoardItem );
268  break;
269 
270  case PCB_PAD_T:
271  if( aMode == ADD_APPEND )
272  m_Pads.PushBack( static_cast<D_PAD*>( aBoardItem ) );
273  else
274  m_Pads.PushFront( static_cast<D_PAD*>( aBoardItem ) );
275  break;
276 
277  default:
278  {
279  wxString msg;
280  msg.Printf( wxT( "MODULE::Add() needs work: BOARD_ITEM type (%d) not handled" ),
281  aBoardItem->Type() );
282  wxFAIL_MSG( msg );
283 
284  return;
285  }
286  }
287 
288  aBoardItem->SetParent( this );
289 
290  // Update relative coordinates, it can be done only after there is a parent object assigned
291  switch( aBoardItem->Type() )
292  {
293  case PCB_MODULE_TEXT_T:
294  static_cast<TEXTE_MODULE*>( aBoardItem )->SetLocalCoord();
295  break;
296 
297  case PCB_MODULE_EDGE_T:
298  static_cast<EDGE_MODULE*>( aBoardItem )->SetLocalCoord();
299  break;
300 
301  case PCB_PAD_T:
302  static_cast<D_PAD*>( aBoardItem )->SetLocalCoord();
303  break;
304 
305  default:
306  // Huh? It should have been filtered out by the previous switch
307  assert(false);
308  break;
309  }
310 }
311 
312 
313 void MODULE::Remove( BOARD_ITEM* aBoardItem )
314 {
315  switch( aBoardItem->Type() )
316  {
317  case PCB_MODULE_TEXT_T:
318  // Only user texts can be removed this way. Reference and value are not hold in the DLIST.
319  assert( static_cast<TEXTE_MODULE*>( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS );
320 
321  // no break
322 
323  case PCB_MODULE_EDGE_T:
324  m_Drawings.Remove( aBoardItem );
325  break;
326 
327  case PCB_PAD_T:
328  m_Pads.Remove( static_cast<D_PAD*>( aBoardItem ) );
329  break;
330 
331  default:
332  {
333  wxString msg;
334  msg.Printf( wxT( "MODULE::Remove() needs work: BOARD_ITEM type (%d) not handled" ),
335  aBoardItem->Type() );
336  wxFAIL_MSG( msg );
337  }
338  }
339 }
340 
341 
342 void MODULE::CopyNetlistSettings( MODULE* aModule, bool aCopyLocalSettings )
343 {
344  // Don't do anything foolish like trying to copy to yourself.
345  wxCHECK_RET( aModule != NULL && aModule != this, wxT( "Cannot copy to NULL or yourself." ) );
346 
347  // Not sure what to do with the value field. Use netlist for now.
348  aModule->SetPosition( GetPosition() );
349 
350  if( aModule->GetLayer() != GetLayer() )
351  aModule->Flip( aModule->GetPosition() );
352 
353  if( aModule->GetOrientation() != GetOrientation() )
354  aModule->Rotate( aModule->GetPosition(), GetOrientation() );
355 
356  aModule->SetLocked( IsLocked() );
357 
358  if( aCopyLocalSettings )
359  {
361  aModule->SetLocalClearance( GetLocalClearance() );
364  aModule->SetZoneConnection( GetZoneConnection() );
365  aModule->SetThermalWidth( GetThermalWidth() );
366  aModule->SetThermalGap( GetThermalGap() );
367  }
368 
369  for( D_PAD* pad = aModule->PadsList(); pad; pad = pad->Next() )
370  {
371  // Fix me: if aCopyLocalSettings == true, for "multiple" pads
372  // (set of pads having the same name/number) this is broken
373  // because we copy settings from the first pad found.
374  // When old and new footprints have very few differences, a better
375  // algo can be used.
376  D_PAD* oldPad = FindPadByName( pad->GetName() );
377 
378  if( oldPad )
379  oldPad->CopyNetlistSettings( pad, aCopyLocalSettings );
380  }
381 
382  // Not sure about copying description, keywords, 3D models or any other
383  // local user changes to footprint. Stick with the new footprint settings
384  // called out in the footprint loaded in the netlist.
385  aModule->CalculateBoundingBox();
386 }
387 
388 
389 void MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode,
390  const wxPoint& aOffset )
391 {
392  if( (m_Flags & DO_NOT_DRAW) || (IsMoving()) )
393  return;
394 
395  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
396  {
397  if( pad->IsMoving() )
398  continue;
399 
400  pad->Draw( aPanel, aDC, aDrawMode, aOffset );
401  }
402 
403  BOARD* brd = GetBoard();
404 
405  // Draws footprint anchor
406  DrawAncre( aPanel, aDC, aOffset, DIM_ANCRE_MODULE, aDrawMode );
407 
408  // Draw graphic items
410  {
411  if( !(m_Reference->IsMoving()) )
412  m_Reference->Draw( aPanel, aDC, aDrawMode, aOffset );
413  }
414 
415  if( brd->IsElementVisible( LAYER_MOD_VALUES ) )
416  {
417  if( !(m_Value->IsMoving()) )
418  m_Value->Draw( aPanel, aDC, aDrawMode, aOffset );
419  }
420 
421  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
422  {
423  if( item->IsMoving() )
424  continue;
425 
426  switch( item->Type() )
427  {
428  case PCB_MODULE_TEXT_T:
429  case PCB_MODULE_EDGE_T:
430  item->Draw( aPanel, aDC, aDrawMode, aOffset );
431  break;
432 
433  default:
434  break;
435  }
436  }
437 
438  // Enable these line to draw m_BoundaryBox (debug tests purposes only)
439 #if 0
440  GRRect( aPanel->GetClipBox(), aDC, m_BoundaryBox, 0, BROWN );
441 #endif
442 
443 }
444 
445 
446 void MODULE::DrawEdgesOnly( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,
447  GR_DRAWMODE draw_mode )
448 {
449  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
450  {
451  switch( item->Type() )
452  {
453  case PCB_MODULE_EDGE_T:
454  item->Draw( panel, DC, draw_mode, offset );
455  break;
456 
457  default:
458  break;
459  }
460  }
461 }
462 
463 
465 {
468 }
469 
470 
472 {
473  EDA_RECT area;
474 
475  area.SetOrigin( m_Pos );
476  area.SetEnd( m_Pos );
477  area.Inflate( Millimeter2iu( 0.25 ) ); // Give a min size to the area
478 
479  for( const BOARD_ITEM* item = m_Drawings.GetFirst(); item; item = item->Next() )
480  {
481  const EDGE_MODULE* edge = dyn_cast<const EDGE_MODULE*>( item );
482 
483  if( edge )
484  area.Merge( edge->GetBoundingBox() );
485  }
486 
487  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
488  area.Merge( pad->GetBoundingBox() );
489 
490  return area;
491 }
492 
493 
495 {
496  EDA_RECT area = GetFootprintRect();
497 
498  // Calculate extended area including text fields
499  area.Merge( m_Reference->GetBoundingBox() );
500  area.Merge( m_Value->GetBoundingBox() );
501 
502  // Add the Clearance shape size: (shape around the pads when the
503  // clearance is shown. Not optimized, but the draw cost is small
504  // (perhaps smaller than optimization).
505  BOARD* board = GetBoard();
506  if( board )
507  {
508  int biggest_clearance = board->GetDesignSettings().GetBiggestClearanceValue();
509  area.Inflate( biggest_clearance );
510  }
511 
512  return area;
513 }
514 
515 
516 void MODULE::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
517 {
518  int nbpad;
519  wxString msg;
520 
521  aList.push_back( MSG_PANEL_ITEM( m_Reference->GetShownText(), m_Value->GetShownText(), DARKCYAN ) );
522 
523  // Display last date the component was edited (useful in Module Editor).
524  wxDateTime date( m_LastEditTime );
525 
526  if( m_LastEditTime && date.IsValid() )
527  // Date format: see http://www.cplusplus.com/reference/ctime/strftime
528  msg = date.Format( wxT( "%b %d, %Y" ) ); // Abbreviated_month_name Day, Year
529  else
530  msg = _( "Unknown" );
531 
532  aList.push_back( MSG_PANEL_ITEM( _( "Last Change" ), msg, BROWN ) );
533 
534  // display schematic path
535  aList.push_back( MSG_PANEL_ITEM( _( "Netlist Path" ), m_Path, BROWN ) );
536 
537  // display the board side placement
538  aList.push_back( MSG_PANEL_ITEM( _( "Board Side" ),
539  IsFlipped()? _( "Back (Flipped)" ) : _( "Front" ), RED ) );
540 
541  EDA_ITEM* PtStruct = m_Pads;
542  nbpad = 0;
543 
544  while( PtStruct )
545  {
546  nbpad++;
547  PtStruct = PtStruct->Next();
548  }
549 
550  msg.Printf( wxT( "%d" ), nbpad );
551  aList.push_back( MSG_PANEL_ITEM( _( "Pads" ), msg, BLUE ) );
552 
553  msg = wxT( ".." );
554 
555  if( IsLocked() )
556  msg[0] = 'L';
557 
559  msg[1] = 'P';
560 
561  aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) );
562 
563  msg.Printf( wxT( "%.1f" ), GetOrientationDegrees() );
564  aList.push_back( MSG_PANEL_ITEM( _( "Rotation" ), msg, BROWN ) );
565 
566  // Controls on right side of the dialog
567  switch( m_Attributs & 255 )
568  {
569  case 0:
570  msg = _( "Normal" );
571  break;
572 
573  case MOD_CMS:
574  msg = _( "Insert" );
575  break;
576 
577  case MOD_VIRTUAL:
578  msg = _( "Virtual" );
579  break;
580 
581  default:
582  msg = wxT( "???" );
583  break;
584  }
585 
586  aList.push_back( MSG_PANEL_ITEM( _( "Attributes" ), msg, BROWN ) );
587  aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), FROM_UTF8( m_fpid.Format().c_str() ), BLUE ) );
588 
589  if( m_3D_Drawings.empty() )
590  msg = _( "No 3D shape" );
591  else
592  msg = m_3D_Drawings.front().m_Filename;
593 
594  // Search the first active 3D shape in list
595 
596  aList.push_back( MSG_PANEL_ITEM( _( "3D-Shape" ), msg, RED ) );
597 
598  wxString doc, keyword;
599  doc.Printf( _( "Doc: %s" ), GetChars( m_Doc ) );
600  keyword.Printf( _( "Key Words: %s" ), GetChars( m_KeyWord ) );
601  aList.push_back( MSG_PANEL_ITEM( doc, keyword, BLACK ) );
602 }
603 
604 
605 bool MODULE::HitTest( const wxPoint& aPosition ) const
606 {
607  return m_BoundaryBox.Contains( aPosition );
608 }
609 
610 
611 bool MODULE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
612 {
613  EDA_RECT arect = aRect;
614  arect.Inflate( aAccuracy );
615 
616  if( aContained )
617  return arect.Contains( m_BoundaryBox );
618  else
619  {
620  // If the rect does not intersect the bounding box, skip any tests
621  if( !aRect.Intersects( GetBoundingBox() ) )
622  return false;
623 
624  // Determine if any elements in the MODULE intersect the rect
625  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
626  {
627  if( pad->HitTest( arect, false, 0 ) )
628  return true;
629  }
630 
631  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
632  {
633  if( item->HitTest( arect, false, 0 ) )
634  return true;
635  }
636 
637  // No items were hit
638  return false;
639  }
640 }
641 
642 
643 D_PAD* MODULE::FindPadByName( const wxString& aPadName ) const
644 {
645  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
646  {
647  if( pad->GetName().CmpNoCase( aPadName ) == 0 ) // why case insensitive?
648  return pad;
649  }
650 
651  return NULL;
652 }
653 
654 
655 D_PAD* MODULE::GetPad( const wxPoint& aPosition, LSET aLayerMask )
656 {
657  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
658  {
659  // ... and on the correct layer.
660  if( !( pad->GetLayerSet() & aLayerMask ).any() )
661  continue;
662 
663  if( pad->HitTest( aPosition ) )
664  return pad;
665  }
666 
667  return NULL;
668 }
669 
670 
672 {
673  D_PAD* topLeftPad = m_Pads;
674 
675  for( D_PAD* p = m_Pads->Next(); p; p = p->Next() )
676  {
677  wxPoint pnt = p->GetPosition(); // GetPosition() returns the center of the pad
678 
679  if( ( pnt.x < topLeftPad->GetPosition().x ) ||
680  ( ( topLeftPad->GetPosition().x == pnt.x ) &&
681  ( pnt.y < topLeftPad->GetPosition().y ) ) )
682  {
683  topLeftPad = p;
684  }
685  }
686 
687  return topLeftPad;
688 }
689 
690 
691 unsigned MODULE::GetPadCount( INCLUDE_NPTH_T aIncludeNPTH ) const
692 {
693  if( aIncludeNPTH )
694  return m_Pads.GetCount();
695 
696  unsigned cnt = 0;
697 
698  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
699  {
700  if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED )
701  continue;
702 
703  cnt++;
704  }
705 
706  return cnt;
707 }
708 
709 
710 unsigned MODULE::GetUniquePadCount( INCLUDE_NPTH_T aIncludeNPTH ) const
711 {
712  std::set<wxString> usedNames;
713 
714  // Create a set of used pad numbers
715  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
716  {
717  // Skip pads not on copper layers (used to build complex
718  // solder paste shapes for instance)
719  if( ( pad->GetLayerSet() & LSET::AllCuMask() ).none() )
720  continue;
721 
722  // Skip pads with no name, because they are usually "mechanical"
723  // pads, not "electrical" pads
724  if( pad->GetName().IsEmpty() )
725  continue;
726 
727  if( !aIncludeNPTH )
728  {
729  // skip NPTH
730  if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED )
731  {
732  continue;
733  }
734  }
735 
736  usedNames.insert( pad->GetName() );
737  }
738 
739  return usedNames.size();
740 }
741 
742 
743 void MODULE::Add3DModel( S3D_INFO* a3DModel )
744 {
745  if( NULL == a3DModel )
746  return;
747 
748  if( !a3DModel->m_Filename.empty() )
749  m_3D_Drawings.push_back( *a3DModel );
750 
751  delete a3DModel;
752 }
753 
754 
755 // see class_module.h
756 SEARCH_RESULT MODULE::Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] )
757 {
758  KICAD_T stype;
760  const KICAD_T* p = scanTypes;
761  bool done = false;
762 
763 #if 0 && defined(DEBUG)
764  std::cout << GetClass().mb_str() << ' ';
765 #endif
766 
767  while( !done )
768  {
769  stype = *p;
770 
771  switch( stype )
772  {
773  case PCB_MODULE_T:
774  result = inspector( this, testData ); // inspect me
775  ++p;
776  break;
777 
778  case PCB_PAD_T:
779  result = IterateForward( m_Pads, inspector, testData, p );
780  ++p;
781  break;
782 
783  case PCB_MODULE_TEXT_T:
784  result = inspector( m_Reference, testData );
785 
786  if( result == SEARCH_QUIT )
787  break;
788 
789  result = inspector( m_Value, testData );
790 
791  if( result == SEARCH_QUIT )
792  break;
793 
794  // m_Drawings can hold TYPETEXTMODULE also, so fall thru
795 
796  case PCB_MODULE_EDGE_T:
797  result = IterateForward( m_Drawings, inspector, testData, p );
798 
799  // skip over any types handled in the above call.
800  for( ; ; )
801  {
802  switch( stype = *++p )
803  {
804  case PCB_MODULE_TEXT_T:
805  case PCB_MODULE_EDGE_T:
806  continue;
807 
808  default:
809  ;
810  }
811 
812  break;
813  }
814 
815  break;
816 
817  default:
818  done = true;
819  break;
820  }
821 
822  if( result == SEARCH_QUIT )
823  break;
824  }
825 
826  return result;
827 }
828 
829 
831 {
832  wxString text;
833  text.Printf( _( "Footprint %s on %s" ),
834  GetChars ( GetReference() ),
835  GetChars ( GetLayerName() ) );
836 
837  return text;
838 }
839 
840 
842 {
843  return module_xpm;
844 }
845 
846 
848 {
849  return new MODULE( *this );
850 }
851 
852 
853 void MODULE::RunOnChildren( std::function<void (BOARD_ITEM*)> aFunction )
854 {
855  try
856  {
857  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
858  aFunction( static_cast<BOARD_ITEM*>( pad ) );
859 
860  for( BOARD_ITEM* drawing = m_Drawings; drawing; drawing = drawing->Next() )
861  aFunction( drawing );
862 
863  aFunction( static_cast<BOARD_ITEM*>( m_Reference ) );
864  aFunction( static_cast<BOARD_ITEM*>( m_Value ) );
865  }
866  catch( std::bad_function_call& )
867  {
868  DisplayError( NULL, wxT( "Error running MODULE::RunOnChildren" ) );
869  }
870 }
871 
872 void MODULE::ViewGetLayers( int aLayers[], int& aCount ) const
873 {
874  aCount = 2;
875  aLayers[0] = LAYER_ANCHOR;
876 
877  switch( m_Layer )
878  {
879 
880  default:
881  wxASSERT_MSG( false, "Illegal layer" ); // do you really have modules placed on other layers?
882  // pass through
883  case F_Cu:
884  aLayers[1] = LAYER_MOD_FR;
885  break;
886 
887  case B_Cu:
888  aLayers[1] = LAYER_MOD_BK;
889  break;
890  }
891 }
892 
893 
894 unsigned int MODULE::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
895 {
896  int layer = ( m_Layer == F_Cu ) ? LAYER_MOD_FR :
898 
899  // Currently it is only for anchor layer
900  if( aView->IsLayerVisible( layer ) )
901  return 30;
902 
904 }
905 
906 
907 const BOX2I MODULE::ViewBBox() const
908 {
909  EDA_RECT fpRect = GetFootprintRect();
910 
911  return BOX2I( VECTOR2I( fpRect.GetOrigin() ), VECTOR2I( fpRect.GetSize() ) );
912 }
913 
914 
915 bool MODULE::IsLibNameValid( const wxString & aName )
916 {
917  const wxChar * invalids = StringLibNameInvalidChars( false );
918 
919  if( aName.find_first_of( invalids ) != std::string::npos )
920  return false;
921 
922  return true;
923 }
924 
925 
926 const wxChar* MODULE::StringLibNameInvalidChars( bool aUserReadable )
927 {
928  static const wxChar invalidChars[] = wxT("%$\t \"\\/");
929  static const wxChar invalidCharsReadable[] = wxT("% $ 'tab' 'space' \\ \" /");
930 
931  if( aUserReadable )
932  return invalidCharsReadable;
933  else
934  return invalidChars;
935 }
936 
937 
938 void MODULE::Move( const wxPoint& aMoveVector )
939 {
940  wxPoint newpos = m_Pos + aMoveVector;
941  SetPosition( newpos );
942 }
943 
944 
945 void MODULE::Rotate( const wxPoint& aRotCentre, double aAngle )
946 {
947  wxPoint newpos = m_Pos;
948  RotatePoint( &newpos, aRotCentre, aAngle );
949  SetPosition( newpos );
950  SetOrientation( GetOrientation() + aAngle );
951 }
952 
953 
954 void MODULE::Flip( const wxPoint& aCentre )
955 {
956  // Move module to its final position:
957  wxPoint finalPos = m_Pos;
958  MIRROR( finalPos.y, aCentre.y );
959  SetPosition( finalPos );
960 
961  // Flip layer
962  SetLayer( FlipLayer( GetLayer() ) );
963 
964  // Reverse mirror orientation.
965  m_Orient = -m_Orient;
967 
968  // Mirror pads to other side of board about the x axis, i.e. vertically.
969  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
970  pad->Flip( m_Pos );
971 
972  // Mirror reference and value.
973  m_Reference->Flip( m_Pos );
974  m_Value->Flip( m_Pos );
975 
976  // Reverse mirror module graphics and texts.
977  for( EDA_ITEM* item = m_Drawings; item; item = item->Next() )
978  {
979  switch( item->Type() )
980  {
981  case PCB_MODULE_EDGE_T:
982  ( (EDGE_MODULE*) item )->Flip( m_Pos );
983  break;
984 
985  case PCB_MODULE_TEXT_T:
986  static_cast<TEXTE_MODULE*>( item )->Flip( m_Pos );
987  break;
988 
989  default:
990  wxMessageBox( wxT( "MODULE::Flip() error: Unknown Draw Type" ) );
991  break;
992  }
993  }
994 
996 }
997 
998 
999 void MODULE::SetPosition( const wxPoint& newpos )
1000 {
1001  wxPoint delta = newpos - m_Pos;
1002 
1003  m_Pos += delta;
1004 
1005  m_Reference->EDA_TEXT::Offset( delta );
1006  m_Value->EDA_TEXT::Offset( delta );
1007 
1008  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1009  {
1010  pad->SetPosition( pad->GetPosition() + delta );
1011  }
1012 
1013  for( EDA_ITEM* item = m_Drawings; item; item = item->Next() )
1014  {
1015  switch( item->Type() )
1016  {
1017  case PCB_MODULE_EDGE_T:
1018  {
1019  EDGE_MODULE* pt_edgmod = (EDGE_MODULE*) item;
1020  pt_edgmod->SetDrawCoord();
1021  break;
1022  }
1023 
1024  case PCB_MODULE_TEXT_T:
1025  {
1026  TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
1027  text->EDA_TEXT::Offset( delta );
1028  break;
1029  }
1030 
1031  default:
1032  wxMessageBox( wxT( "Draw type undefined." ) );
1033  break;
1034  }
1035  }
1036 
1038 }
1039 
1040 
1041 void MODULE::MoveAnchorPosition( const wxPoint& aMoveVector )
1042 {
1043  /* Move the reference point of the footprint
1044  * the footprints elements (pads, outlines, edges .. ) are moved
1045  * but:
1046  * - the footprint position is not modified.
1047  * - the relative (local) coordinates of these items are modified
1048  * - Draw coordinates are updated
1049  */
1050 
1051 
1052  // Update (move) the relative coordinates relative to the new anchor point.
1053  wxPoint moveVector = aMoveVector;
1054  RotatePoint( &moveVector, -GetOrientation() );
1055 
1056  // Update of the reference and value.
1057  m_Reference->SetPos0( m_Reference->GetPos0() + moveVector );
1059  m_Value->SetPos0( m_Value->GetPos0() + moveVector );
1060  m_Value->SetDrawCoord();
1061 
1062  // Update the pad local coordinates.
1063  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
1064  {
1065  pad->SetPos0( pad->GetPos0() + moveVector );
1066  pad->SetDrawCoord();
1067  }
1068 
1069  // Update the draw element coordinates.
1070  for( EDA_ITEM* item = GraphicalItemsList(); item; item = item->Next() )
1071  {
1072  switch( item->Type() )
1073  {
1074  case PCB_MODULE_EDGE_T:
1075  {
1076  EDGE_MODULE* edge = static_cast<EDGE_MODULE*>( item );
1077  edge->m_Start0 += moveVector;
1078  edge->m_End0 += moveVector;
1079  edge->SetDrawCoord();
1080  break;
1081  }
1082 
1083  case PCB_MODULE_TEXT_T:
1084  {
1085  TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
1086  text->SetPos0( text->GetPos0() + moveVector );
1087  text->SetDrawCoord();
1088  break;
1089  }
1090 
1091  default:
1092  break;
1093  }
1094  }
1095 
1097 }
1098 
1099 
1100 void MODULE::SetOrientation( double newangle )
1101 {
1102  double angleChange = newangle - m_Orient; // change in rotation
1103 
1104  NORMALIZE_ANGLE_POS( newangle );
1105 
1106  m_Orient = newangle;
1107 
1108  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1109  {
1110  pad->SetOrientation( pad->GetOrientation() + angleChange );
1111  pad->SetDrawCoord();
1112  }
1113 
1114  // Update of the reference and value.
1116  m_Value->SetDrawCoord();
1117 
1118  // Displace contours and text of the footprint.
1119  for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() )
1120  {
1121  if( item->Type() == PCB_MODULE_EDGE_T )
1122  {
1123  static_cast<EDGE_MODULE*>( item )->SetDrawCoord();
1124  }
1125  else if( item->Type() == PCB_MODULE_TEXT_T )
1126  {
1127  static_cast<TEXTE_MODULE*>( item )->SetDrawCoord();
1128  }
1129  }
1130 
1132 }
1133 
1135  bool aIncrementPadNumbers,
1136  bool aAddToModule )
1137 {
1138  BOARD_ITEM* new_item = NULL;
1139  D_PAD* new_pad = NULL;
1140 
1141  switch( aItem->Type() )
1142  {
1143  case PCB_PAD_T:
1144  {
1145  new_pad = new D_PAD( *static_cast<const D_PAD*>( aItem ) );
1146 
1147  if( aAddToModule )
1148  PadsList().PushBack( new_pad );
1149 
1150  new_item = new_pad;
1151  break;
1152  }
1153 
1154  case PCB_MODULE_TEXT_T:
1155  {
1156  const TEXTE_MODULE* old_text = static_cast<const TEXTE_MODULE*>( aItem );
1157 
1158  // do not duplicate value or reference fields
1159  // (there can only be one of each)
1160  if( old_text->GetType() == TEXTE_MODULE::TEXT_is_DIVERS )
1161  {
1162  TEXTE_MODULE* new_text = new TEXTE_MODULE( *old_text );
1163 
1164  if( aAddToModule )
1165  GraphicalItemsList().PushBack( new_text );
1166 
1167  new_item = new_text;
1168  }
1169  break;
1170  }
1171 
1172  case PCB_MODULE_EDGE_T:
1173  {
1174  EDGE_MODULE* new_edge = new EDGE_MODULE(
1175  *static_cast<const EDGE_MODULE*>(aItem) );
1176 
1177  if( aAddToModule )
1178  GraphicalItemsList().PushBack( new_edge );
1179 
1180  new_item = new_edge;
1181  break;
1182  }
1183 
1184  case PCB_MODULE_T:
1185  // Ignore the module itself
1186  break;
1187 
1188  default:
1189  // Un-handled item for duplication
1190  wxASSERT_MSG( false, "Duplication not supported for items of class "
1191  + aItem->GetClass() );
1192  break;
1193  }
1194 
1195  if( aIncrementPadNumbers && new_pad )
1196  {
1197  new_pad->IncrementPadName( true, true );
1198  }
1199 
1200  return new_item;
1201 }
1202 
1203 
1204 wxString MODULE::GetNextPadName( bool aFillSequenceGaps ) const
1205 {
1206  std::set<int> usedNumbers;
1207 
1208  // Create a set of used pad numbers
1209  for( D_PAD* pad = PadsList(); pad; pad = pad->Next() )
1210  {
1211  int padNumber = getTrailingInt( pad->GetName() );
1212  usedNumbers.insert( padNumber );
1213  }
1214 
1215  const int nextNum = getNextNumberInSequence( usedNumbers, aFillSequenceGaps );
1216 
1217  return wxString::Format( wxT( "%i" ), nextNum );
1218 }
1219 
1220 
1222 {
1223  wxString prefix = GetReference();
1224 
1225  int strIndex = prefix.length() - 1;
1226  while( strIndex >= 0 )
1227  {
1228  const wxUniChar chr = prefix.GetChar( strIndex );
1229 
1230  // numeric suffix
1231  if( chr >= '0' && chr <= '9' )
1232  break;
1233 
1234  strIndex--;
1235  }
1236 
1237  prefix = prefix.Mid( 0, strIndex );
1238 
1239  return prefix;
1240 }
1241 
1242 
1244 {
1245  double padArea = 0.0;
1246  double moduleArea = GetFootprintRect().GetArea();
1247 
1248  for( D_PAD* pad = m_Pads; pad; pad = pad->Next() )
1249  padArea += pad->GetBoundingBox().GetArea();
1250 
1251  if( moduleArea == 0.0 )
1252  return 1.0;
1253 
1254  double ratio = padArea / moduleArea;
1255 
1256  return std::min( ratio, 1.0 );
1257 }
1258 
1259 // see convert_drawsegment_list_to_polygon.cpp:
1260 extern bool ConvertOutlineToPolygon( std::vector< DRAWSEGMENT* >& aSegList,
1261  SHAPE_POLY_SET& aPolygons, int aSegmentsByCircle,
1262  wxString* aErrorText);
1263 
1265 {
1268  // Build the courtyard area from graphic items on the courtyard.
1269  // Only PCB_MODULE_EDGE_T have meaning, graphic texts are ignored.
1270  // Collect items:
1271  std::vector< DRAWSEGMENT* > list_front;
1272  std::vector< DRAWSEGMENT* > list_back;
1273 
1274  for( BOARD_ITEM* item = GraphicalItemsList(); item; item = item->Next() )
1275  {
1276  if( item->GetLayer() == B_CrtYd && item->Type() == PCB_MODULE_EDGE_T )
1277  list_back.push_back( static_cast< DRAWSEGMENT* > ( item ) );
1278 
1279  if( item->GetLayer() == F_CrtYd && item->Type() == PCB_MODULE_EDGE_T )
1280  list_front.push_back( static_cast< DRAWSEGMENT* > ( item ) );
1281  }
1282 
1283  // Note: if no item found on courtyard layers, return true.
1284  // false is returned only when the shape defined on courtyard layers
1285  // is not convertible to a polygon
1286  if( !list_front.size() && !list_back.size() )
1287  return true;
1288 
1289  wxString error_msg;
1290 
1291  const int STEPS = 36; // for a segmentation of an arc of 360 degrees
1292  bool success = ConvertOutlineToPolygon( list_front, m_poly_courtyard_front,
1293  STEPS, &error_msg );
1294 
1295  if( success )
1296  success = ConvertOutlineToPolygon( list_back, m_poly_courtyard_back,
1297  STEPS, &error_msg );
1298 
1299  if( !error_msg.IsEmpty() )
1300  {
1301  error_msg.Prepend( GetReference() + ": " );
1302  wxLogMessage( error_msg );
1303  }
1304 
1305  return success;
1306 }
LIB_ID m_fpid
The LIB_ID of the MODULE.
Definition: class_module.h:677
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
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
KICAD_T Type() const
Function Type()
Definition: base_struct.h:212
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 IsElementVisible(GAL_LAYER_ID LAYER_aPCB) const
Function IsElementVisible tests whether a given element category is visible.
void RunOnChildren(std::function< void(BOARD_ITEM *)> aFunction)
Function RunOnChildren.
bool IsMoving() const
Definition: base_struct.h:232
wxString GetReferencePrefix() const
Function GetReference prefix Gets the alphabetic prefix of the module reference - e...
void SetThermalGap(int aGap)
Definition: class_module.h:194
int m_CntRot90
Horizontal automatic placement cost ( 0..10 ).
Definition: class_module.h:693
int GetThermalGap() const
Definition: class_module.h:195
void Merge(const EDA_RECT &aRect)
Function Merge modifies the position and size of the rectangle in order to contain aRect...
void Rotate(const wxPoint &aRotCentre, double aAngle) override
Function Rotate Rotate this object.
SHAPE_POLY_SET m_poly_courtyard_back
Definition: class_module.h:711
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:38
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:290
void SetLocalClearance(int aClearance)
Definition: class_module.h:180
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:686
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:687
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:179
int m_ThermalWidth
Definition: class_module.h:683
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.
bool Contains(const wxPoint &aPoint) const
Function Contains.
const wxPoint & GetPos0() const
anchor of items having an anchor point (texts, footprints)
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:702
void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
Class BOARD to handle a board.
const wxPoint & GetPosition() const override
Definition: class_module.h:155
Definition: colors.h:61
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount)
Function FlippedLayerNumber.
Definition: lset.cpp:445
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:701
int m_ThermalGap
Definition: class_module.h:684
show modules on back
int GetHeight() const
Set for modules listed in the automatic insertion list (usually SMD footprints)
Definition: class_module.h:77
void SetOrigin(const wxPoint &pos)
std::list< S3D_INFO > m_3D_Drawings
Linked list of 3D models.
Definition: class_module.h:672
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:1267
void SetZoneConnection(ZoneConnection aType)
Definition: class_module.h:188
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:102
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:220
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
double m_Surface
Bounding box area.
Definition: class_module.h:691
ZoneConnection GetZoneConnection() const
Definition: class_module.h:189
time_t m_Link
Temporary logical link used in edition.
Definition: class_module.h:692
void NORMALIZE_ANGLE_POS(T &Angle)
Definition: trigo.h:222
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:590
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:705
void SetLocalSolderPasteMarginRatio(double aRatio)
Definition: class_module.h:186
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:106
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:185
#define MODULE_PADS_LOCKED
In autoplace: module waiting for autoplace.
Definition: class_module.h:233
static const int delta[8][2]
Definition: solve.cpp:112
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:73
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:90
wxString m_Doc
File name and path for documentation file.
Definition: class_module.h:685
#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:231
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:699
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:673
const wxPoint & GetOrigin() const
void MIRROR(T &aPoint, const T &aMirrorRef)
Definition: macros.h:111
class MODULE, a footprint
Definition: typeinfo.h:101
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...
static int getTrailingInt(wxString aStr)
void GRRect(EDA_RECT *aClipBox, wxDC *aDC, int x1, int y1, int x2, int y2, COLOR4D aColor)
Definition: gr_basic.cpp:1077
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:680
Class LSET is a set of PCB_LAYER_IDs.
double GetOrientationDegrees() const
Definition: class_module.h:161
void SetParent(EDA_ITEM *aParent)
Definition: base_struct.h:227
double GetOrientation() const
Definition: class_module.h:160
GR_DRAWMODE
Drawmode. Compositing mode plus a flag or two.
Definition: gr_basic.h:41
Class SHAPE_POLY_SET.
Base window classes and related definitions.
EDA_RECT GetFootprintRect() const
Function GetFootprintRect() Returns the area of the module footprint excluding any text...
const wxPoint & GetPosition() const override
Definition: class_pad.h:205
void SetEnd(int x, int y)
bool IsFlipped() const
function IsFlipped
Definition: class_module.h:227
virtual const BOX2I ViewBBox() const override
Function ViewBBox() returns the bounding box of the item covering all its layers. ...
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
D_PAD * Next() const
Definition: class_pad.h:145
void SetThermalWidth(int aWidth)
Definition: class_module.h:191
int m_LocalSolderMaskMargin
Solder mask margin.
Definition: class_module.h:700
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:690
EDA_RECT * GetClipBox()
Common plot library Plot settings, and plotting engines (Postscript, Gerber, HPGL and DXF) ...
Definition: colors.h:60
void Flip(const wxPoint &aCentre) override
Flip entity during module flip.
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:174
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:710
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 of the item.
void SetPosition(const wxPoint &aPos) override
int GetLocalSolderMaskMargin() const
Definition: class_module.h:176
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.
bool IsLocked() const override
Function IsLocked.
Definition: class_module.h:236
EDA_ITEM & operator=(const EDA_ITEM &aItem)
Operator assignment is used to assign the members of aItem to another object.
void SetLocalSolderMaskMargin(int aMargin)
Definition: class_module.h:177
D_PAD * GetTopLeftPad()
void SetPos0(const wxPoint &aPos)
static const int ORPHANED
Constant that forces initialization of a netinfo item to the NETINFO_ITEM ORPHANED (typically -1) whe...
int GetLocalSolderPasteMargin() const
Definition: class_module.h:182
MODULE & operator=(const MODULE &aOther)
unsigned GetPadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
GetPadCount returns the number of pads.
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:105
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:689
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.
PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
void SetLocalSolderPasteMargin(int aMargin)
Definition: class_module.h:183
int m_CntRot180
Vertical automatic placement cost ( 0..10 ).
Definition: class_module.h:694
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:246
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:671
#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:419
int m_ModuleStatus
For autoplace: flags (LOCKED, AUTOPLACED)
Definition: class_module.h:679
void Move(const wxPoint &aMoveVector) override
Function Move move this object.
void SetOrientation(double newangle)
Virtual component: when created by copper shapes on board (Like edge card connectors, mounting hole...)
Definition: class_module.h:79
double PadCoverageRatio() const
Function PadCoverageRatio Calculates the ratio of total area of the footprint pads to the area of the...
const char * c_str() const
Definition: utf8.h:107
void Add3DModel(S3D_INFO *a3DModel)
Function Add3DModel adds a3DModel definition to the end of the 3D model list.
STATUS_FLAGS m_Flags
Flag bits for editing and other uses.
Definition: base_struct.h:189
wxString GetClass() const override
Function GetClass returns the class name.
Definition: class_module.h:555
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.
TEXTE_MODULE * m_Value
Component value (74LS00, 22K..)
Definition: class_module.h:676
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:165
int GetWidth() const
wxPoint m_Pos
Position of module on the board in internal units.
Definition: class_module.h:674
UTF8 Format() const
Function Format.
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:137
TEXTE_MODULE * m_Reference
Component reference designator value (U34, R18..)
Definition: class_module.h:675
void CopyNetlistSettings(MODULE *aModule, bool aCopyLocalSettings)
Function CopyNetlistSettings copies the netlist settings to aModule.
DLIST< D_PAD > & PadsList()
Definition: class_module.h:134
unsigned GetUniquePadCount(INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) const
GetUniquePadCount returns the number of unique pads.
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:670
EDGE_MODULE class definition.
ZoneConnection m_ZoneConnection
Definition: class_module.h:688
Message panel definition file.
const wxSize & GetSize() const
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:71
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:192
#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:678
wxString m_Filename
The 3D shape filename in 3D library.
Definition: 3d_info.h:45
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