/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr * Copyright (C) 2015 SoftPLC Corporation, Dick Hollenbeck * Copyright (C) 2015 Wayne Stambaugh * Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, you may find one here: * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html * or you may search the http://www.gnu.org website for the version 2 license, * or you may write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ /** * @file class_module.cpp * @brief MODULE class implementation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include MODULE::MODULE( BOARD* parent ) : BOARD_ITEM( (BOARD_ITEM*) parent, PCB_MODULE_T ), m_initial_comments( 0 ) { m_Attributs = MOD_DEFAULT; m_Layer = F_Cu; m_Orient = 0; m_ModuleStatus = MODULE_PADS_LOCKED; m_arflag = 0; m_CntRot90 = m_CntRot180 = 0; m_Surface = 0.0; m_Link = 0; m_LastEditTime = 0; m_LocalClearance = 0; m_LocalSolderMaskMargin = 0; m_LocalSolderPasteMargin = 0; m_LocalSolderPasteMarginRatio = 0.0; m_ZoneConnection = PAD_ZONE_CONN_INHERITED; // Use zone setting by default m_ThermalWidth = 0; // Use zone setting by default m_ThermalGap = 0; // Use zone setting by default // These are special and mandatory text fields m_Reference = new TEXTE_MODULE( this, TEXTE_MODULE::TEXT_is_REFERENCE ); m_Value = new TEXTE_MODULE( this, TEXTE_MODULE::TEXT_is_VALUE ); m_3D_Drawings.clear(); } MODULE::MODULE( const MODULE& aModule ) : BOARD_ITEM( aModule ) { m_Pos = aModule.m_Pos; m_fpid = aModule.m_fpid; m_Layer = aModule.m_Layer; m_Attributs = aModule.m_Attributs; m_ModuleStatus = aModule.m_ModuleStatus; m_Orient = aModule.m_Orient; m_BoundaryBox = aModule.m_BoundaryBox; m_CntRot90 = aModule.m_CntRot90; m_CntRot180 = aModule.m_CntRot180; m_LastEditTime = aModule.m_LastEditTime; m_Link = aModule.m_Link; m_Path = aModule.m_Path; //is this correct behavior? m_LocalClearance = aModule.m_LocalClearance; m_LocalSolderMaskMargin = aModule.m_LocalSolderMaskMargin; m_LocalSolderPasteMargin = aModule.m_LocalSolderPasteMargin; m_LocalSolderPasteMarginRatio = aModule.m_LocalSolderPasteMarginRatio; m_ZoneConnection = aModule.m_ZoneConnection; m_ThermalWidth = aModule.m_ThermalWidth; m_ThermalGap = aModule.m_ThermalGap; // Copy reference and value. m_Reference = new TEXTE_MODULE( *aModule.m_Reference ); m_Reference->SetParent( this ); m_Value = new TEXTE_MODULE( *aModule.m_Value ); m_Value->SetParent( this ); // Copy auxiliary data: Pads for( D_PAD* pad = aModule.m_Pads; pad; pad = pad->Next() ) { D_PAD* newpad = new D_PAD( *pad ); assert( newpad->GetNet() == pad->GetNet() ); newpad->SetParent( this ); m_Pads.PushBack( newpad ); } // Copy auxiliary data: Drawings for( BOARD_ITEM* item = aModule.m_Drawings; item; item = item->Next() ) { BOARD_ITEM* newItem; switch( item->Type() ) { case PCB_MODULE_TEXT_T: case PCB_MODULE_EDGE_T: newItem = static_cast( item->Clone() ); newItem->SetParent( this ); m_Drawings.PushBack( newItem ); break; default: wxLogMessage( wxT( "MODULE::Copy() Internal Err: unknown type" ) ); break; } } // Copy auxiliary data: 3D_Drawings info m_3D_Drawings = aModule.m_3D_Drawings; m_Doc = aModule.m_Doc; m_KeyWord = aModule.m_KeyWord; m_arflag = 0; // Ensure auxiliary data is up to date CalculateBoundingBox(); m_initial_comments = aModule.m_initial_comments ? new wxArrayString( *aModule.m_initial_comments ) : 0; } MODULE::~MODULE() { delete m_Reference; delete m_Value; delete m_initial_comments; } /** * Function ClearAllNets * Clear (i.e. force the ORPHANED dummy net info) the net info which * depends on a given board for all pads of the footprint. * This is needed when a footprint is copied between the fp editor and * the board editor for instance, because net info become fully broken */ void MODULE::ClearAllNets() { // Force the ORPHANED dummy net info for all pads. // ORPHANED dummy net does not depend on a board for( D_PAD* pad = Pads(); pad; pad = pad->Next() ) pad->SetNetCode( NETINFO_LIST::ORPHANED ); } /* Draw the anchor cross (vertical) * Must be done after the pads, because drawing the hole will erase overwrite * every thing already drawn. */ void MODULE::DrawAncre( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset, int dim_ancre, GR_DRAWMODE draw_mode ) { GRSetDrawMode( DC, draw_mode ); if( GetBoard()->IsElementVisible( ANCHOR_VISIBLE ) ) { GRDrawAnchor( panel->GetClipBox(), DC, m_Pos.x, m_Pos.y, dim_ancre, g_ColorsSettings.GetItemColor( ANCHOR_VISIBLE ) ); } } void MODULE::Copy( MODULE* aModule ) { m_Pos = aModule->m_Pos; m_Layer = aModule->m_Layer; m_fpid = aModule->m_fpid; m_Attributs = aModule->m_Attributs; m_ModuleStatus = aModule->m_ModuleStatus; m_Orient = aModule->m_Orient; m_BoundaryBox = aModule->m_BoundaryBox; m_CntRot90 = aModule->m_CntRot90; m_CntRot180 = aModule->m_CntRot180; m_LastEditTime = aModule->m_LastEditTime; m_Link = aModule->m_Link; m_Path = aModule->m_Path; //is this correct behavior? SetTimeStamp( GetNewTimeStamp() ); m_LocalClearance = aModule->m_LocalClearance; m_LocalSolderMaskMargin = aModule->m_LocalSolderMaskMargin; m_LocalSolderPasteMargin = aModule->m_LocalSolderPasteMargin; m_LocalSolderPasteMarginRatio = aModule->m_LocalSolderPasteMarginRatio; m_ZoneConnection = aModule->m_ZoneConnection; m_ThermalWidth = aModule->m_ThermalWidth; m_ThermalGap = aModule->m_ThermalGap; // Copy reference and value. m_Reference->Copy( aModule->m_Reference ); m_Value->Copy( aModule->m_Value ); // Copy auxiliary data: Pads m_Pads.DeleteAll(); for( D_PAD* pad = aModule->m_Pads; pad; pad = pad->Next() ) { D_PAD* newpad = new D_PAD( this ); newpad->Copy( pad ); m_Pads.PushBack( newpad ); } // Copy auxiliary data: Drawings m_Drawings.DeleteAll(); for( BOARD_ITEM* item = aModule->m_Drawings; item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_TEXT_T: { TEXTE_MODULE* textm = new TEXTE_MODULE( this ); textm->Copy( static_cast( item ) ); m_Drawings.PushBack( textm ); break; } case PCB_MODULE_EDGE_T: { EDGE_MODULE * edge; edge = new EDGE_MODULE( this ); edge->Copy( (EDGE_MODULE*) item ); m_Drawings.PushBack( edge ); break; } default: wxLogMessage( wxT( "MODULE::Copy() Internal Err: unknown type" ) ); break; } } // Copy auxiliary data: 3D_Drawings info m_3D_Drawings.clear(); m_3D_Drawings = aModule->m_3D_Drawings; m_Doc = aModule->m_Doc; m_KeyWord = aModule->m_KeyWord; // Ensure auxiliary data is up to date CalculateBoundingBox(); } void MODULE::Add( BOARD_ITEM* aBoardItem, bool doAppend ) { switch( aBoardItem->Type() ) { case PCB_MODULE_TEXT_T: // Only user texts can be added this way. Reference and value are not hold in the DLIST. assert( static_cast( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS ); // no break case PCB_MODULE_EDGE_T: if( doAppend ) m_Drawings.PushBack( aBoardItem ); else m_Drawings.PushFront( aBoardItem ); break; case PCB_PAD_T: if( doAppend ) m_Pads.PushBack( static_cast( aBoardItem ) ); else m_Pads.PushFront( static_cast( aBoardItem ) ); break; default: { wxString msg; msg.Printf( wxT( "MODULE::Add() needs work: BOARD_ITEM type (%d) not handled" ), aBoardItem->Type() ); wxFAIL_MSG( msg ); return; } } aBoardItem->SetParent( this ); } BOARD_ITEM* MODULE::Remove( BOARD_ITEM* aBoardItem ) { switch( aBoardItem->Type() ) { case PCB_MODULE_TEXT_T: // Only user texts can be removed this way. Reference and value are not hold in the DLIST. assert( static_cast( aBoardItem )->GetType() == TEXTE_MODULE::TEXT_is_DIVERS ); // no break case PCB_MODULE_EDGE_T: return m_Drawings.Remove( aBoardItem ); case PCB_PAD_T: return m_Pads.Remove( static_cast( aBoardItem ) ); default: { wxString msg; msg.Printf( wxT( "MODULE::Remove() needs work: BOARD_ITEM type (%d) not handled" ), aBoardItem->Type() ); wxFAIL_MSG( msg ); } } return NULL; } void MODULE::CopyNetlistSettings( MODULE* aModule, bool aCopyLocalSettings ) { // Don't do anything foolish like trying to copy to yourself. wxCHECK_RET( aModule != NULL && aModule != this, wxT( "Cannot copy to NULL or yourself." ) ); // Not sure what to do with the value field. Use netlist for now. aModule->SetPosition( GetPosition() ); if( aModule->GetLayer() != GetLayer() ) aModule->Flip( aModule->GetPosition() ); if( aModule->GetOrientation() != GetOrientation() ) aModule->Rotate( aModule->GetPosition(), GetOrientation() ); aModule->SetLocked( IsLocked() ); if( aCopyLocalSettings ) { aModule->SetLocalSolderMaskMargin( GetLocalSolderMaskMargin() ); aModule->SetLocalClearance( GetLocalClearance() ); aModule->SetLocalSolderPasteMargin( GetLocalSolderPasteMargin() ); aModule->SetLocalSolderPasteMarginRatio( GetLocalSolderPasteMarginRatio() ); aModule->SetZoneConnection( GetZoneConnection() ); aModule->SetThermalWidth( GetThermalWidth() ); aModule->SetThermalGap( GetThermalGap() ); } for( D_PAD* pad = aModule->Pads(); pad; pad = pad->Next() ) { // Fix me: if aCopyLocalSettings == true, for "multiple" pads // (set of pads having the same name/number) this is broken // because we copy settings from the first pad found. // When old and new footprints have very few differences, a better // algo can be used. D_PAD* oldPad = FindPadByName( pad->GetPadName() ); if( oldPad ) oldPad->CopyNetlistSettings( pad, aCopyLocalSettings ); } // Not sure about copying description, keywords, 3D models or any other // local user changes to footprint. Stick with the new footprint settings // called out in the footprint loaded in the netlist. aModule->CalculateBoundingBox(); } void MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode, const wxPoint& aOffset ) { if( (m_Flags & DO_NOT_DRAW) || (IsMoving()) ) return; for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { if( pad->IsMoving() ) continue; pad->Draw( aPanel, aDC, aDrawMode, aOffset ); } BOARD* brd = GetBoard(); // Draws footprint anchor DrawAncre( aPanel, aDC, aOffset, DIM_ANCRE_MODULE, aDrawMode ); // Draw graphic items if( brd->IsElementVisible( MOD_REFERENCES_VISIBLE ) ) { if( !(m_Reference->IsMoving()) ) m_Reference->Draw( aPanel, aDC, aDrawMode, aOffset ); } if( brd->IsElementVisible( MOD_VALUES_VISIBLE ) ) { if( !(m_Value->IsMoving()) ) m_Value->Draw( aPanel, aDC, aDrawMode, aOffset ); } for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { if( item->IsMoving() ) continue; switch( item->Type() ) { case PCB_MODULE_TEXT_T: case PCB_MODULE_EDGE_T: item->Draw( aPanel, aDC, aDrawMode, aOffset ); break; default: break; } } // Enable these line to draw m_BoundaryBox (debug tests purposes only) #if 0 GRRect( aPanel->GetClipBox(), aDC, m_BoundaryBox, 0, BROWN ); #endif } void MODULE::DrawEdgesOnly( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset, GR_DRAWMODE draw_mode ) { for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_EDGE_T: item->Draw( panel, DC, draw_mode, offset ); break; default: break; } } } void MODULE::CalculateBoundingBox() { m_BoundaryBox = GetFootprintRect(); m_Surface = std::abs( (double) m_BoundaryBox.GetWidth() * m_BoundaryBox.GetHeight() ); } EDA_RECT MODULE::GetFootprintRect() const { EDA_RECT area; area.SetOrigin( m_Pos ); area.SetEnd( m_Pos ); area.Inflate( Millimeter2iu( 0.25 ) ); // Give a min size to the area for( const BOARD_ITEM* item = m_Drawings.GetFirst(); item; item = item->Next() ) { const EDGE_MODULE* edge = dyn_cast( item ); if( edge ) area.Merge( edge->GetBoundingBox() ); } for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) area.Merge( pad->GetBoundingBox() ); return area; } const EDA_RECT MODULE::GetBoundingBox() const { EDA_RECT area = GetFootprintRect(); // Calculate extended area including text fields area.Merge( m_Reference->GetBoundingBox() ); area.Merge( m_Value->GetBoundingBox() ); // Add the Clearance shape size: (shape around the pads when the // clearance is shown. Not optimized, but the draw cost is small // (perhaps smaller than optimization). BOARD* board = GetBoard(); if( board ) { int biggest_clearance = board->GetDesignSettings().GetBiggestClearanceValue(); area.Inflate( biggest_clearance ); } return area; } /* Virtual function, from EDA_ITEM. * display module info on MsgPanel */ void MODULE::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList ) { int nbpad; wxString msg; aList.push_back( MSG_PANEL_ITEM( m_Reference->GetShownText(), m_Value->GetShownText(), DARKCYAN ) ); // Display last date the component was edited (useful in Module Editor). wxDateTime date( m_LastEditTime ); if( m_LastEditTime && date.IsValid() ) // Date format: see http://www.cplusplus.com/reference/ctime/strftime msg = date.Format( wxT( "%b %d, %Y" ) ); // Abbreviated_month_name Day, Year else msg = _( "Unknown" ); aList.push_back( MSG_PANEL_ITEM( _( "Last Change" ), msg, BROWN ) ); // display schematic path aList.push_back( MSG_PANEL_ITEM( _( "Netlist Path" ), m_Path, BROWN ) ); // display the board side placement aList.push_back( MSG_PANEL_ITEM( _( "Board Side" ), IsFlipped()? _( "Back (Flipped)" ) : _( "Front" ), RED ) ); EDA_ITEM* PtStruct = m_Pads; nbpad = 0; while( PtStruct ) { nbpad++; PtStruct = PtStruct->Next(); } msg.Printf( wxT( "%d" ), nbpad ); aList.push_back( MSG_PANEL_ITEM( _( "Pads" ), msg, BLUE ) ); msg = wxT( ".." ); if( IsLocked() ) msg[0] = 'L'; if( m_ModuleStatus & MODULE_is_PLACED ) msg[1] = 'P'; aList.push_back( MSG_PANEL_ITEM( _( "Status" ), msg, MAGENTA ) ); msg.Printf( wxT( "%.1f" ), GetOrientationDegrees() ); aList.push_back( MSG_PANEL_ITEM( _( "Rotation" ), msg, BROWN ) ); // Controls on right side of the dialog switch( m_Attributs & 255 ) { case 0: msg = _( "Normal" ); break; case MOD_CMS: msg = _( "Insert" ); break; case MOD_VIRTUAL: msg = _( "Virtual" ); break; default: msg = wxT( "???" ); break; } aList.push_back( MSG_PANEL_ITEM( _( "Attributes" ), msg, BROWN ) ); aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), FROM_UTF8( m_fpid.Format().c_str() ), BLUE ) ); if( m_3D_Drawings.empty() ) msg = _( "No 3D shape" ); else msg = m_3D_Drawings.front().m_Filename; // Search the first active 3D shape in list aList.push_back( MSG_PANEL_ITEM( _( "3D-Shape" ), msg, RED ) ); wxString doc, keyword; doc.Printf( _( "Doc: %s" ), GetChars( m_Doc ) ); keyword.Printf( _( "Key Words: %s" ), GetChars( m_KeyWord ) ); aList.push_back( MSG_PANEL_ITEM( doc, keyword, BLACK ) ); } bool MODULE::HitTest( const wxPoint& aPosition ) const { return m_BoundaryBox.Contains( aPosition ); } bool MODULE::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const { EDA_RECT arect = aRect; arect.Inflate( aAccuracy ); if( aContained ) return arect.Contains( m_BoundaryBox ); else return m_BoundaryBox.Intersects( arect ); } D_PAD* MODULE::FindPadByName( const wxString& aPadName ) const { wxString buf; for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { pad->StringPadName( buf ); #if 1 if( buf.CmpNoCase( aPadName ) == 0 ) // why case insensitive? #else if( buf == aPadName ) #endif return pad; } return NULL; } D_PAD* MODULE::GetPad( const wxPoint& aPosition, LSET aLayerMask ) { for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { // ... and on the correct layer. if( !( pad->GetLayerSet() & aLayerMask ).any() ) continue; if( pad->HitTest( aPosition ) ) return pad; } return NULL; } unsigned MODULE::GetPadCount( INCLUDE_NPTH_T aIncludeNPTH ) const { if( aIncludeNPTH ) return m_Pads.GetCount(); unsigned cnt = 0; for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED ) continue; cnt++; } return cnt; } unsigned MODULE::GetUniquePadCount( INCLUDE_NPTH_T aIncludeNPTH ) const { std::set usedNames; // Create a set of used pad numbers for( D_PAD* pad = Pads(); pad; pad = pad->Next() ) { // Skip pads not on copper layers (used to build complex // solder paste shapes for instance) if( ( pad->GetLayerSet() & LSET::AllCuMask() ).none() ) continue; // Skip pads with no name, because they are usually "mechanical" // pads, not "electrical" pads if( pad->GetPadName().IsEmpty() ) continue; if( !aIncludeNPTH ) { // skip NPTH if( pad->GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED ) { continue; } } usedNames.insert( pad->GetPackedPadName() ); } return usedNames.size(); } void MODULE::Add3DModel( S3D_INFO* a3DModel ) { if( NULL == a3DModel ) return; if( !a3DModel->m_Filename.empty() ) m_3D_Drawings.push_back( *a3DModel ); delete a3DModel; } // see class_module.h SEARCH_RESULT MODULE::Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] ) { KICAD_T stype; SEARCH_RESULT result = SEARCH_CONTINUE; const KICAD_T* p = scanTypes; bool done = false; #if 0 && defined(DEBUG) std::cout << GetClass().mb_str() << ' '; #endif while( !done ) { stype = *p; switch( stype ) { case PCB_MODULE_T: result = inspector( this, testData ); // inspect me ++p; break; case PCB_PAD_T: result = IterateForward( m_Pads, inspector, testData, p ); ++p; break; case PCB_MODULE_TEXT_T: result = inspector( m_Reference, testData ); if( result == SEARCH_QUIT ) break; result = inspector( m_Value, testData ); if( result == SEARCH_QUIT ) break; // m_Drawings can hold TYPETEXTMODULE also, so fall thru case PCB_MODULE_EDGE_T: result = IterateForward( m_Drawings, inspector, testData, p ); // skip over any types handled in the above call. for( ; ; ) { switch( stype = *++p ) { case PCB_MODULE_TEXT_T: case PCB_MODULE_EDGE_T: continue; default: ; } break; } break; default: done = true; break; } if( result == SEARCH_QUIT ) break; } return result; } wxString MODULE::GetSelectMenuText() const { wxString text; text.Printf( _( "Footprint %s on %s" ), GetChars ( GetReference() ), GetChars ( GetLayerName() ) ); return text; } EDA_ITEM* MODULE::Clone() const { return new MODULE( *this ); } void MODULE::RunOnChildren( std::function aFunction ) { try { for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) aFunction( static_cast( pad ) ); for( BOARD_ITEM* drawing = m_Drawings; drawing; drawing = drawing->Next() ) aFunction( drawing ); aFunction( static_cast( m_Reference ) ); aFunction( static_cast( m_Value ) ); } catch( std::bad_function_call& e ) { DisplayError( NULL, wxT( "Error running MODULE::RunOnChildren" ) ); } } void MODULE::ViewUpdate( int aUpdateFlags ) { if( !m_view ) return; // Update the module itself VIEW_ITEM::ViewUpdate( aUpdateFlags ); // Update pads for( D_PAD* pad = m_Pads.GetFirst(); pad; pad = pad->Next() ) pad->ViewUpdate( aUpdateFlags ); // Update module's drawing (mostly silkscreen) for( BOARD_ITEM* drawing = m_Drawings.GetFirst(); drawing; drawing = drawing->Next() ) drawing->ViewUpdate( aUpdateFlags ); // Update module's texts m_Reference->ViewUpdate( aUpdateFlags ); m_Value->ViewUpdate( aUpdateFlags ); } void MODULE::ViewGetLayers( int aLayers[], int& aCount ) const { aCount = 2; aLayers[0] = ITEM_GAL_LAYER( ANCHOR_VISIBLE ); switch( m_Layer ) { default: wxASSERT_MSG( false, "Illegal layer" ); // do you really have modules placed on other layers? // pass through case F_Cu: aLayers[1] = ITEM_GAL_LAYER( MOD_FR_VISIBLE ); break; case B_Cu: aLayers[1] = ITEM_GAL_LAYER( MOD_BK_VISIBLE ); break; } } unsigned int MODULE::ViewGetLOD( int aLayer ) const { int layer = ( m_Layer == F_Cu ) ? MOD_FR_VISIBLE : ( m_Layer == B_Cu ) ? MOD_BK_VISIBLE : ANCHOR_VISIBLE; // Currently it is only for anchor layer if( m_view->IsLayerVisible( ITEM_GAL_LAYER( layer ) ) ) return 30; return std::numeric_limits::max(); } const BOX2I MODULE::ViewBBox() const { EDA_RECT fpRect = GetFootprintRect(); return BOX2I( VECTOR2I( fpRect.GetOrigin() ), VECTOR2I( fpRect.GetSize() ) ); } /* Test for validity of the name in a library of the footprint * ( no spaces, dir separators ... ) * return true if the given name is valid * static function */ bool MODULE::IsLibNameValid( const wxString & aName ) { const wxChar * invalids = StringLibNameInvalidChars( false ); if( aName.find_first_of( invalids ) != std::string::npos ) return false; return true; } /* Test for validity of the name of a footprint to be used in a footprint library * ( no spaces, dir separators ... ) * param bool aUserReadable = false to get the list of invalid chars * true to get a readable form (i.e ' ' = 'space' '\t'= 'tab') * return a constant string giving the list of invalid chars in lib name * static function */ const wxChar* MODULE::StringLibNameInvalidChars( bool aUserReadable ) { static const wxChar invalidChars[] = wxT("%$\t \"\\/"); static const wxChar invalidCharsReadable[] = wxT("% $ 'tab' 'space' \\ \" /"); if( aUserReadable ) return invalidCharsReadable; else return invalidChars; } void MODULE::Move( const wxPoint& aMoveVector ) { wxPoint newpos = m_Pos + aMoveVector; SetPosition( newpos ); } void MODULE::Rotate( const wxPoint& aRotCentre, double aAngle ) { wxPoint newpos = m_Pos; RotatePoint( &newpos, aRotCentre, aAngle ); SetPosition( newpos ); SetOrientation( GetOrientation() + aAngle ); } void MODULE::Flip( const wxPoint& aCentre ) { // Move module to its final position: wxPoint finalPos = m_Pos; MIRROR( finalPos.y, aCentre.y ); /// Mirror the Y position SetPosition( finalPos ); // Flip layer SetLayer( FlipLayer( GetLayer() ) ); // Reverse mirror orientation. m_Orient = -m_Orient; NORMALIZE_ANGLE_POS( m_Orient ); // Mirror pads to other side of board about the x axis, i.e. vertically. for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) pad->Flip( m_Pos ); // Mirror reference and value. m_Reference->Flip( m_Pos ); m_Value->Flip( m_Pos ); // Reverse mirror module graphics and texts. for( EDA_ITEM* item = m_Drawings; item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_EDGE_T: ( (EDGE_MODULE*) item )->Flip( m_Pos ); break; case PCB_MODULE_TEXT_T: static_cast( item )->Flip( m_Pos ); break; default: wxMessageBox( wxT( "MODULE::Flip() error: Unknown Draw Type" ) ); break; } } CalculateBoundingBox(); } void MODULE::SetPosition( const wxPoint& newpos ) { wxPoint delta = newpos - m_Pos; m_Pos += delta; m_Reference->SetTextPosition( m_Reference->GetTextPosition() + delta ); m_Value->SetTextPosition( m_Value->GetTextPosition() + delta ); for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { pad->SetPosition( pad->GetPosition() + delta ); } for( EDA_ITEM* item = m_Drawings; item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_EDGE_T: { EDGE_MODULE* pt_edgmod = (EDGE_MODULE*) item; pt_edgmod->SetDrawCoord(); break; } case PCB_MODULE_TEXT_T: { TEXTE_MODULE* text = static_cast( item ); text->SetTextPosition( text->GetTextPosition() + delta ); break; } default: wxMessageBox( wxT( "Draw type undefined." ) ); break; } } CalculateBoundingBox(); } void MODULE::MoveAnchorPosition( const wxPoint& aMoveVector ) { /* Move the reference point of the footprint * the footprints elements (pads, outlines, edges .. ) are moved * but: * - the footprint position is not modified. * - the relative (local) coordinates of these items are modified * - Draw coordinates are updated */ // Update (move) the relative coordinates relative to the new anchor point. wxPoint moveVector = aMoveVector; RotatePoint( &moveVector, -GetOrientation() ); // Update of the reference and value. m_Reference->SetPos0( m_Reference->GetPos0() + moveVector ); m_Reference->SetDrawCoord(); m_Value->SetPos0( m_Value->GetPos0() + moveVector ); m_Value->SetDrawCoord(); // Update the pad local coordinates. for( D_PAD* pad = Pads(); pad; pad = pad->Next() ) { pad->SetPos0( pad->GetPos0() + moveVector ); pad->SetDrawCoord(); } // Update the draw element coordinates. for( EDA_ITEM* item = GraphicalItems(); item; item = item->Next() ) { switch( item->Type() ) { case PCB_MODULE_EDGE_T: { EDGE_MODULE* edge = static_cast( item ); edge->m_Start0 += moveVector; edge->m_End0 += moveVector; edge->SetDrawCoord(); break; } case PCB_MODULE_TEXT_T: { TEXTE_MODULE* text = static_cast( item ); text->SetPos0( text->GetPos0() + moveVector ); text->SetDrawCoord(); break; } default: break; } } CalculateBoundingBox(); } void MODULE::SetOrientation( double newangle ) { double angleChange = newangle - m_Orient; // change in rotation NORMALIZE_ANGLE_POS( newangle ); m_Orient = newangle; for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { pad->SetOrientation( pad->GetOrientation() + angleChange ); pad->SetDrawCoord(); } // Update of the reference and value. m_Reference->SetDrawCoord(); m_Value->SetDrawCoord(); // Displace contours and text of the footprint. for( BOARD_ITEM* item = m_Drawings; item; item = item->Next() ) { if( item->Type() == PCB_MODULE_EDGE_T ) { static_cast( item )->SetDrawCoord(); } else if( item->Type() == PCB_MODULE_TEXT_T ) { static_cast( item )->SetDrawCoord(); } } CalculateBoundingBox(); } BOARD_ITEM* MODULE::DuplicateAndAddItem( const BOARD_ITEM* aItem, bool aIncrementPadNumbers ) { BOARD_ITEM* new_item = NULL; D_PAD* new_pad = NULL; switch( aItem->Type() ) { case PCB_PAD_T: { new_pad = new D_PAD( *static_cast( aItem ) ); Pads().PushBack( new_pad ); new_item = new_pad; break; } case PCB_MODULE_TEXT_T: { const TEXTE_MODULE* old_text = static_cast( aItem ); // do not duplicate value or reference fields // (there can only be one of each) if( old_text->GetType() == TEXTE_MODULE::TEXT_is_DIVERS ) { TEXTE_MODULE* new_text = new TEXTE_MODULE( *old_text ); GraphicalItems().PushBack( new_text ); new_item = new_text; } break; } case PCB_MODULE_EDGE_T: { EDGE_MODULE* new_edge = new EDGE_MODULE( *static_cast(aItem) ); GraphicalItems().PushBack( new_edge ); new_item = new_edge; break; } case PCB_MODULE_T: // Ignore the module itself break; default: // Un-handled item for duplication wxASSERT_MSG( false, "Duplication not supported for items of class " + aItem->GetClass() ); break; } if( aIncrementPadNumbers && new_pad ) { new_pad->IncrementPadName( true, true ); } return new_item; } wxString MODULE::GetNextPadName( bool aFillSequenceGaps ) const { std::set usedNumbers; // Create a set of used pad numbers for( D_PAD* pad = Pads(); pad; pad = pad->Next() ) { int padNumber = getTrailingInt( pad->GetPadName() ); usedNumbers.insert( padNumber ); } const int nextNum = getNextNumberInSequence( usedNumbers, aFillSequenceGaps ); return wxString::Format( wxT( "%i" ), nextNum ); } wxString MODULE::GetReferencePrefix() const { wxString prefix = GetReference(); int strIndex = prefix.length() - 1; while( strIndex >= 0 ) { const wxUniChar chr = prefix.GetChar( strIndex ); // numeric suffix if( chr >= '0' && chr <= '9' ) break; strIndex--; } prefix = prefix.Mid( 0, strIndex ); return prefix; } double MODULE::PadCoverageRatio() const { double padArea = 0.0; double moduleArea = GetFootprintRect().GetArea(); for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) padArea += pad->GetBoundingBox().GetArea(); if( moduleArea == 0.0 ) return 1.0; double ratio = padArea / moduleArea; return std::min( ratio, 1.0 ); }