kicad/pcbnew/class_pad.cpp

1338 lines
35 KiB
C++
Raw Normal View History

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
2016-04-06 18:15:49 +00:00
* Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
2016-04-06 18:15:49 +00:00
* 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_pad.cpp
* D_PAD class implementation.
*/
#include <fctsys.h>
#include <PolyLine.h>
#include <trigo.h>
#include <wxstruct.h>
#include <macros.h>
#include <msgpanel.h>
#include <base_units.h>
#include <bitmaps.h>
#include <pcbnew.h>
#include <class_board.h>
#include <class_module.h>
#include <polygon_test_point_inside.h>
#include <convert_to_biu.h>
2016-04-06 18:15:49 +00:00
#include <convert_basic_shapes_to_polygon.h>
/**
* Helper function
* Return a string (to be shown to the user) describing a layer mask.
* Useful for showing where is a pad.
* The BOARD is needed because layer names are (somewhat) customizable
*/
static wxString LayerMaskDescribe( const BOARD* aBoard, LSET aMask );
int D_PAD::m_PadSketchModePenSize = 0; // Pen size used to draw pads in sketch mode
2012-02-19 04:02:19 +00:00
D_PAD::D_PAD( MODULE* parent ) :
BOARD_CONNECTED_ITEM( parent, PCB_PAD_T )
{
m_NumPadName = 0;
m_Size.x = m_Size.y = Mils2iu( 60 ); // Default pad size 60 mils.
m_Drill.x = m_Drill.y = Mils2iu( 30 ); // Default drill size 30 mils.
m_Orient = 0; // Pad rotation in 1/10 degrees.
m_LengthPadToDie = 0;
2012-02-19 04:02:19 +00:00
if( m_Parent && m_Parent->Type() == PCB_MODULE_T )
{
2012-02-19 04:02:19 +00:00
m_Pos = GetParent()->GetPosition();
}
SetShape( PAD_SHAPE_CIRCLE ); // Default pad shape is PAD_CIRCLE.
SetDrillShape( PAD_DRILL_SHAPE_CIRCLE ); // Default pad drill shape is a circle.
m_Attribute = PAD_ATTRIB_STANDARD; // Default pad type is NORMAL (thru hole)
m_LocalClearance = 0;
m_LocalSolderMaskMargin = 0;
m_LocalSolderPasteMargin = 0;
m_LocalSolderPasteMarginRatio = 0.0;
2016-04-06 18:15:49 +00:00
// Parameters for round rect only:
m_padRoundRectRadiusScale = 0.25; // from IPC-7351C standard
m_ZoneConnection = PAD_ZONE_CONN_INHERITED; // Use parent setting by default
m_ThermalWidth = 0; // Use parent setting by default
m_ThermalGap = 0; // Use parent setting by default
// Set layers mask to default for a standard thru hole pad.
m_layerMask = StandardMask();
SetSubRatsnest( 0 ); // used in ratsnest calculations
m_boundingRadius = -1;
}
LSET D_PAD::StandardMask()
{
static LSET saved = LSET::AllCuMask() | LSET( 2, B_Mask, F_Mask );
return saved;
}
LSET D_PAD::SMDMask()
{
static LSET saved( 3, F_Cu, F_Paste, F_Mask );
return saved;
}
LSET D_PAD::ConnSMDMask()
{
static LSET saved( 2, F_Cu, F_Mask );
return saved;
}
LSET D_PAD::UnplatedHoleMask()
{
static LSET saved = LSET::AllCuMask() | LSET( 2, B_Mask, F_Mask );
return saved;
}
bool D_PAD::IsFlipped() const
2016-04-06 18:15:49 +00:00
{
if( GetParent() && GetParent()->GetLayer() == B_Cu )
return true;
return false;
}
2012-02-19 04:02:19 +00:00
int D_PAD::boundingRadius() const
{
int x, y;
int radius;
2012-02-19 04:02:19 +00:00
switch( GetShape() )
{
case PAD_SHAPE_CIRCLE:
radius = m_Size.x / 2;
break;
case PAD_SHAPE_OVAL:
radius = std::max( m_Size.x, m_Size.y ) / 2;
break;
case PAD_SHAPE_RECT:
2013-05-04 11:57:09 +00:00
radius = 1 + KiROUND( EuclideanNorm( m_Size ) / 2 );
break;
case PAD_SHAPE_TRAPEZOID:
x = m_Size.x + std::abs( m_DeltaSize.y ); // Remember: m_DeltaSize.y is the m_Size.x change
y = m_Size.y + std::abs( m_DeltaSize.x ); // Remember: m_DeltaSize.x is the m_Size.y change
2013-05-04 11:57:09 +00:00
radius = 1 + KiROUND( hypot( x, y ) / 2 );
break;
2016-04-06 18:15:49 +00:00
case PAD_SHAPE_ROUNDRECT:
radius = GetRoundRectCornerRadius();
x = m_Size.x >> 1;
y = m_Size.y >> 1;
radius += 1 + KiROUND( EuclideanNorm( wxSize( x - radius, y - radius )));
break;
default:
2012-02-19 04:02:19 +00:00
radius = 0;
}
return radius;
}
2016-04-06 18:15:49 +00:00
int D_PAD::GetRoundRectCornerRadius( const wxSize& aSize ) const
{
// radius of rounded corners, usually 25% of shorter pad edge for now
int r = aSize.x > aSize.y ? aSize.y : aSize.x;
r = int( r * m_padRoundRectRadiusScale );
return r;
}
const EDA_RECT D_PAD::GetBoundingBox() const
2008-04-18 13:28:56 +00:00
{
EDA_RECT area;
wxPoint quadrant1, quadrant2, quadrant3, quadrant4;
int x, y, r, dx, dy;
wxPoint center = ShapePos();
wxPoint endPoint;
EDA_RECT endRect;
2012-02-19 04:02:19 +00:00
switch( GetShape() )
{
case PAD_SHAPE_CIRCLE:
area.SetOrigin( center );
area.Inflate( m_Size.x / 2 );
break;
case PAD_SHAPE_OVAL:
/* To get the BoundingBox of an oval pad:
* a) If the pad is ROUND, see method for PAD_SHAPE_CIRCLE above
* OTHERWISE:
* b) Construct EDA_RECT for portion between circular ends
* c) Rotate that EDA_RECT
* d) Add the circular ends to the EDA_RECT
*/
// Test if the shape is circular
if( m_Size.x == m_Size.y )
{
area.SetOrigin( center );
area.Inflate( m_Size.x / 2 );
break;
}
if( m_Size.x > m_Size.y )
{
// Pad is horizontal
dx = ( m_Size.x - m_Size.y ) / 2;
dy = m_Size.y / 2;
// Location of end-points
x = dx;
y = 0;
r = dy;
}
else
{
// Pad is vertical
dx = m_Size.x / 2;
dy = ( m_Size.y - m_Size.x ) / 2;
2016-04-06 18:15:49 +00:00
x = 0;
y = dy;
r = dx;
}
2016-04-06 18:15:49 +00:00
// Construct the center rectangle and rotate
area.SetOrigin( center );
2016-04-06 18:15:49 +00:00
area.Inflate( dx, dy );
area = area.GetBoundingBoxRotated( center, m_Orient );
endPoint = wxPoint( x, y );
RotatePoint( &endPoint, m_Orient );
// Add points at each quadrant of circular regions
endRect.SetOrigin( center + endPoint );
endRect.Inflate( r );
area.Merge( endRect );
endRect.SetSize( 0, 0 );
endRect.SetOrigin( center - endPoint );
endRect.Inflate( r );
area.Merge( endRect );
break;
case PAD_SHAPE_RECT:
2016-04-06 18:15:49 +00:00
case PAD_SHAPE_ROUNDRECT:
// Use two opposite corners and track their rotation
// (use symmetry for other points)
quadrant1.x = m_Size.x/2;
quadrant1.y = m_Size.y/2;
quadrant2.x = -m_Size.x/2;
quadrant2.y = m_Size.y/2;
RotatePoint( &quadrant1, m_Orient );
RotatePoint( &quadrant2, m_Orient );
dx = std::max( std::abs( quadrant1.x ) , std::abs( quadrant2.x ) );
dy = std::max( std::abs( quadrant1.y ) , std::abs( quadrant2.y ) );
2016-04-06 18:15:49 +00:00
// Set the bbox
area.SetOrigin( ShapePos() );
2016-04-06 18:15:49 +00:00
area.Inflate( dx, dy );
break;
case PAD_SHAPE_TRAPEZOID:
2017-04-26 09:05:44 +00:00
// Use the four corners and track their rotation
// (Trapezoids will not be symmetric)
2017-04-26 09:05:44 +00:00
quadrant1.x = (m_Size.x + m_DeltaSize.y)/2;
quadrant1.y = (m_Size.y - m_DeltaSize.x)/2;
2017-04-26 09:05:44 +00:00
quadrant2.x = -(m_Size.x + m_DeltaSize.y)/2;
quadrant2.y = (m_Size.y + m_DeltaSize.x)/2;
2017-04-26 09:05:44 +00:00
quadrant3.x = -(m_Size.x - m_DeltaSize.y)/2;
quadrant3.y = -(m_Size.y + m_DeltaSize.x)/2;
2017-04-26 09:05:44 +00:00
quadrant4.x = (m_Size.x - m_DeltaSize.y)/2;
quadrant4.y = -(m_Size.y - m_DeltaSize.x)/2;
RotatePoint( &quadrant1, m_Orient );
RotatePoint( &quadrant2, m_Orient );
RotatePoint( &quadrant3, m_Orient );
RotatePoint( &quadrant4, m_Orient );
x = std::min( quadrant1.x, std::min( quadrant2.x, std::min( quadrant3.x, quadrant4.x) ) );
y = std::min( quadrant1.y, std::min( quadrant2.y, std::min( quadrant3.y, quadrant4.y) ) );
dx = std::max( quadrant1.x, std::max( quadrant2.x, std::max( quadrant3.x, quadrant4.x) ) );
dy = std::max( quadrant1.y, std::max( quadrant2.y, std::max( quadrant3.y, quadrant4.y) ) );
2017-04-26 09:05:44 +00:00
area.SetOrigin( ShapePos().x + x, ShapePos().y + y );
area.SetSize( dx-x, dy-y );
break;
default:
break;
}
return area;
2008-04-18 13:28:56 +00:00
}
void D_PAD::SetDrawCoord()
{
MODULE* module = (MODULE*) m_Parent;
m_Pos = m_Pos0;
if( module == NULL )
return;
double angle = module->GetOrientation();
RotatePoint( &m_Pos.x, &m_Pos.y, angle );
m_Pos += module->GetPosition();
}
void D_PAD::SetLocalCoord()
{
MODULE* module = (MODULE*) m_Parent;
if( module == NULL )
{
m_Pos0 = m_Pos;
return;
}
m_Pos0 = m_Pos - module->GetPosition();
2014-07-09 12:01:06 +00:00
RotatePoint( &m_Pos0.x, &m_Pos0.y, -module->GetOrientation() );
}
void D_PAD::SetAttribute( PAD_ATTR_T aAttribute )
{
m_Attribute = aAttribute;
if( aAttribute == PAD_ATTRIB_SMD )
m_Drill = wxSize( 0, 0 );
}
2012-02-19 04:02:19 +00:00
void D_PAD::SetOrientation( double aAngle )
{
NORMALIZE_ANGLE_POS( aAngle );
m_Orient = aAngle;
}
void D_PAD::Flip( const wxPoint& aCentre )
2012-02-19 04:02:19 +00:00
{
2016-04-06 18:15:49 +00:00
int y = GetPosition().y;
MIRROR( y, aCentre.y ); // invert about x axis.
2012-02-19 04:02:19 +00:00
SetY( y );
2016-04-06 18:15:49 +00:00
MIRROR( m_Pos0.y, 0 );
MIRROR( m_Offset.y, 0 );
MIRROR( m_DeltaSize.y, 0 );
2012-02-19 04:02:19 +00:00
SetOrientation( -GetOrientation() );
// flip pads layers
// PADS items are currently on all copper layers, or
// currently, only on Front or Back layers.
// So the copper layers count is not taken in account
SetLayerSet( FlipLayerMask( m_layerMask ) );
2012-02-19 04:02:19 +00:00
// m_boundingRadius = -1; the shape has not been changed
}
void D_PAD::AppendConfigs( PARAM_CFG_ARRAY* aResult )
{
// Parameters stored in config are only significant parameters
// for a template.
// So not all parameters are stored, just few.
aResult->push_back( new PARAM_CFG_INT_WITH_SCALE( wxT( "PadDrill" ),
&m_Drill.x,
Millimeter2iu( 0.6 ),
Millimeter2iu( 0.1 ), Millimeter2iu( 10.0 ),
NULL, MM_PER_IU ) );
aResult->push_back( new PARAM_CFG_INT_WITH_SCALE( wxT( "PadDrillOvalY" ),
&m_Drill.y,
Millimeter2iu( 0.6 ),
Millimeter2iu( 0.1 ), Millimeter2iu( 10.0 ),
NULL, MM_PER_IU ) );
aResult->push_back( new PARAM_CFG_INT_WITH_SCALE( wxT( "PadSizeH" ),
&m_Size.x,
Millimeter2iu( 1.4 ),
Millimeter2iu( 0.1 ), Millimeter2iu( 20.0 ),
NULL, MM_PER_IU ) );
aResult->push_back( new PARAM_CFG_INT_WITH_SCALE( wxT( "PadSizeV" ),
&m_Size.y,
Millimeter2iu( 1.4 ),
Millimeter2iu( 0.1 ), Millimeter2iu( 20.0 ),
NULL, MM_PER_IU ) );
2012-02-19 04:02:19 +00:00
}
// Returns the position of the pad.
wxPoint D_PAD::ShapePos() const
{
if( m_Offset.x == 0 && m_Offset.y == 0 )
return m_Pos;
wxPoint loc_offset = m_Offset;
RotatePoint( &loc_offset, m_Orient );
wxPoint shape_pos = m_Pos + loc_offset;
return shape_pos;
}
wxString D_PAD::GetPadName() const
{
2011-12-16 17:03:25 +00:00
wxString name;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
StringPadName( name );
2011-12-16 17:03:25 +00:00
return name;
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
void D_PAD::StringPadName( wxString& text ) const
{
2011-12-16 17:03:25 +00:00
text.Empty();
for( int ii = 0; ii < PADNAMEZ && m_Padname[ii]; ii++ )
2011-12-16 17:03:25 +00:00
{
// m_Padname is 8 bit KiCad font junk, do not sign extend
2011-12-16 17:03:25 +00:00
text.Append( (unsigned char) m_Padname[ii] );
}
}
// Change pad name
void D_PAD::SetPadName( const wxString& name )
{
int ii, len;
len = name.Length();
2011-12-16 17:03:25 +00:00
if( len > PADNAMEZ )
len = PADNAMEZ;
2011-12-16 17:03:25 +00:00
// m_Padname[] is not UTF8, it is an 8 bit character that matches the KiCad font,
// so only copy the lower 8 bits of each character.
2011-12-16 17:03:25 +00:00
for( ii = 0; ii < len; ii++ )
m_Padname[ii] = (char) name.GetChar( ii );
2011-12-16 17:03:25 +00:00
for( ii = len; ii < PADNAMEZ; ii++ )
m_Padname[ii] = '\0';
}
bool D_PAD::IncrementPadName( bool aSkipUnconnectable, bool aFillSequenceGaps )
{
bool skip = aSkipUnconnectable && ( GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED );
if( !skip )
SetPadName( GetParent()->GetNextPadName( aFillSequenceGaps ) );
return !skip;
}
void D_PAD::CopyNetlistSettings( D_PAD* aPad, bool aCopyLocalSettings )
{
// Don't do anything foolish like trying to copy to yourself.
wxCHECK_RET( aPad != NULL && aPad != this, wxT( "Cannot copy to NULL or yourself." ) );
aPad->SetNetCode( GetNetCode() );
if( aCopyLocalSettings )
{
aPad->SetLocalClearance( m_LocalClearance );
aPad->SetLocalSolderMaskMargin( m_LocalSolderMaskMargin );
aPad->SetLocalSolderPasteMargin( m_LocalSolderPasteMargin );
aPad->SetLocalSolderPasteMarginRatio( m_LocalSolderPasteMarginRatio );
aPad->SetZoneConnection( m_ZoneConnection );
aPad->SetThermalWidth( m_ThermalWidth );
aPad->SetThermalGap( m_ThermalGap );
}
}
int D_PAD::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
{
// A pad can have specific clearance parameters that
// overrides its NETCLASS clearance value
int clearance = m_LocalClearance;
if( clearance == 0 )
{
// If local clearance is 0, use the parent footprint clearance value
if( GetParent() && GetParent()->GetLocalClearance() )
clearance = GetParent()->GetLocalClearance();
}
if( clearance == 0 ) // If the parent footprint clearance value = 0, use NETCLASS value
return BOARD_CONNECTED_ITEM::GetClearance( aItem );
// We have a specific clearance.
// if aItem, return the biggest clearance
if( aItem )
{
int hisClearance = aItem->GetClearance();
2012-08-03 15:43:15 +00:00
return std::max( hisClearance, clearance );
}
// Return the specific clearance.
return clearance;
}
// Mask margins handling:
2013-07-26 16:15:11 +00:00
int D_PAD::GetSolderMaskMargin() const
{
int margin = m_LocalSolderMaskMargin;
MODULE* module = GetParent();
if( module )
{
if( margin == 0 )
{
if( module->GetLocalSolderMaskMargin() )
margin = module->GetLocalSolderMaskMargin();
}
if( margin == 0 )
{
BOARD* brd = GetBoard();
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
margin = brd->GetDesignSettings().m_SolderMaskMargin;
}
}
// ensure mask have a size always >= 0
if( margin < 0 )
{
int minsize = -std::min( m_Size.x, m_Size.y ) / 2;
if( margin < minsize )
margin = minsize;
}
return margin;
}
wxSize D_PAD::GetSolderPasteMargin() const
{
int margin = m_LocalSolderPasteMargin;
double mratio = m_LocalSolderPasteMarginRatio;
MODULE* module = GetParent();
if( module )
{
if( margin == 0 )
margin = module->GetLocalSolderPasteMargin();
BOARD * brd = GetBoard();
if( margin == 0 )
++PCBNew * Removed Pcb_Frame argument from BOARD() constructor, since it precludes having a BOARD being edited by more than one editor, it was a bad design. And this meant removing m_PcbFrame from BOARD. * removed BOARD::SetWindowFrame(), and BOARD::m_PcbFrame * Removed the global BOARD_DESIGN_SETTINGS which was in class_board.cpp * added BOARD_DESIGN_SETTINGS to the BOARD class, a full instance * a couple dialogs now only change BOARD_DESIGN_SETTINGS when OK is pressed, such as dialog_mask_clearance, dialog_drc, etc. * Removed common/pcbcommon.cpp's int g_CurrentVersionPCB = 1 and replaced it with build_version.h's #define BOARD_FILE_VERSION, although there may be a better place for this constant. * Made the public functions in PARAM_CFG_ARRAY be type const. void SaveParam(..) const and void ReadParam(..) const * PARAM_CFG_BASE now has virtual destructor since we have various way of destroying the derived class and boost::ptr_vector must be told about this. * Pass const PARAM_CFG_ARRAY& instead of PARAM_CFG_ARRAY so that we can use an automatic PARAM_CFG_ARRAY which is on the stack.\ * PCB_EDIT_FRAME::GetProjectFileParameters() may no longer cache the array, since it has to access the current BOARD and the BOARD can change. Remember BOARD_DESIGN_SETTINGS are now in the BOARD. * Made the m_BoundingBox member private, this was a brutally hard task, and indicative of the lack of commitment to accessors and object oriented design on the part of KiCad developers. We must do better. Added BOARD::GetBoundingBox, SetBoundingBox(), ComputeBoundingBox(). * Added PCB_BASE_FRAME::GetBoardBoundingBox() which calls BOARD::ComputeBoundingBox()
2011-12-05 06:15:33 +00:00
margin = brd->GetDesignSettings().m_SolderPasteMargin;
if( mratio == 0.0 )
mratio = module->GetLocalSolderPasteMarginRatio();
if( mratio == 0.0 )
{
mratio = brd->GetDesignSettings().m_SolderPasteMarginRatio;
}
}
wxSize pad_margin;
// Dick Hollenbeck's KiROUND R&D // This provides better project control over rounding to int from double // than wxRound() did. This scheme provides better logging in Debug builds // and it provides for compile time calculation of constants. #include <stdio.h> #include <assert.h> #include <limits.h> //-----<KiROUND KIT>------------------------------------------------------------ /** * KiROUND * rounds a floating point number to an int using * "round halfway cases away from zero". * In Debug build an assert fires if will not fit into an int. */ #if defined( DEBUG ) // DEBUG: a macro to capture line and file, then calls this inline static inline int KiRound( double v, int line, const char* filename ) { v = v < 0 ? v - 0.5 : v + 0.5; if( v > INT_MAX + 0.5 ) { printf( "%s: in file %s on line %d, val: %.16g too ' > 0 ' for int\n", __FUNCTION__, filename, line, v ); } else if( v < INT_MIN - 0.5 ) { printf( "%s: in file %s on line %d, val: %.16g too ' < 0 ' for int\n", __FUNCTION__, filename, line, v ); } return int( v ); } #define KiROUND( v ) KiRound( v, __LINE__, __FILE__ ) #else // RELEASE: a macro so compile can pre-compute constants. #define KiROUND( v ) int( (v) < 0 ? (v) - 0.5 : (v) + 0.5 ) #endif //-----</KiROUND KIT>----------------------------------------------------------- // Only a macro is compile time calculated, an inline function causes a static constructor // in a situation like this. // Therefore the Release build is best done with a MACRO not an inline function. int Computed = KiROUND( 14.3 * 8 ); int main( int argc, char** argv ) { for( double d = double(INT_MAX)-1; d < double(INT_MAX)+8; d += 2.0 ) { int i = KiROUND( d ); printf( "t: %d %.16g\n", i, d ); } return 0; }
2012-04-19 06:55:45 +00:00
pad_margin.x = margin + KiROUND( m_Size.x * mratio );
pad_margin.y = margin + KiROUND( m_Size.y * mratio );
// ensure mask have a size always >= 0
if( pad_margin.x < -m_Size.x / 2 )
pad_margin.x = -m_Size.x / 2;
if( pad_margin.y < -m_Size.y / 2 )
pad_margin.y = -m_Size.y / 2;
return pad_margin;
}
ZoneConnection D_PAD::GetZoneConnection() const
{
MODULE* module = GetParent();
if( m_ZoneConnection == PAD_ZONE_CONN_INHERITED && module )
return module->GetZoneConnection();
else
return m_ZoneConnection;
}
int D_PAD::GetThermalWidth() const
{
MODULE* module = GetParent();
if( m_ThermalWidth == 0 && module )
return module->GetThermalWidth();
else
return m_ThermalWidth;
}
int D_PAD::GetThermalGap() const
{
MODULE* module = GetParent();
if( m_ThermalGap == 0 && module )
return module->GetThermalGap();
else
return m_ThermalGap;
}
void D_PAD::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM>& aList )
{
MODULE* module;
wxString Line;
BOARD* board;
2008-02-19 00:30:10 +00:00
module = (MODULE*) m_Parent;
2008-02-19 00:30:10 +00:00
if( module )
{
2008-02-19 00:30:10 +00:00
wxString msg = module->GetReference();
aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), msg, DARKCYAN ) );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
StringPadName( Line );
aList.push_back( MSG_PANEL_ITEM( _( "Pad" ), Line, BROWN ) );
}
2014-01-14 09:41:52 +00:00
aList.push_back( MSG_PANEL_ITEM( _( "Net" ), GetNetname(), DARKCYAN ) );
board = GetBoard();
2008-02-19 00:30:10 +00:00
aList.push_back( MSG_PANEL_ITEM( _( "Layer" ),
LayerMaskDescribe( board, m_layerMask ), DARKGREEN ) );
aList.push_back( MSG_PANEL_ITEM( ShowPadShape(), ShowPadAttr(), DARKGREEN ) );
Line = ::CoordinateToString( m_Size.x );
aList.push_back( MSG_PANEL_ITEM( _( "Width" ), Line, RED ) );
Line = ::CoordinateToString( m_Size.y );
aList.push_back( MSG_PANEL_ITEM( _( "Height" ), Line, RED ) );
Line = ::CoordinateToString( (unsigned) m_Drill.x );
if( GetDrillShape() == PAD_DRILL_SHAPE_CIRCLE )
{
aList.push_back( MSG_PANEL_ITEM( _( "Drill" ), Line, RED ) );
}
else
{
Line = ::CoordinateToString( (unsigned) m_Drill.x );
wxString msg;
msg = ::CoordinateToString( (unsigned) m_Drill.y );
Line += wxT( "/" ) + msg;
aList.push_back( MSG_PANEL_ITEM( _( "Drill X / Y" ), Line, RED ) );
}
double module_orient_degrees = module ? module->GetOrientationDegrees() : 0;
if( module_orient_degrees != 0.0 )
Line.Printf( wxT( "%3.1f(+%3.1f)" ),
GetOrientationDegrees() - module_orient_degrees,
module_orient_degrees );
else
Line.Printf( wxT( "%3.1f" ), GetOrientationDegrees() );
aList.push_back( MSG_PANEL_ITEM( _( "Angle" ), Line, LIGHTBLUE ) );
Line = ::CoordinateToString( m_Pos.x ) + wxT( ", " ) + ::CoordinateToString( m_Pos.y );
aList.push_back( MSG_PANEL_ITEM( _( "Position" ), Line, LIGHTBLUE ) );
if( GetPadToDieLength() )
{
Line = ::CoordinateToString( GetPadToDieLength() );
aList.push_back( MSG_PANEL_ITEM( _( "Length in package" ), Line, CYAN ) );
}
}
2007-08-08 03:50:44 +00:00
2014-05-17 19:29:15 +00:00
void D_PAD::GetOblongDrillGeometry( wxPoint& aStartPoint,
wxPoint& aEndPoint, int& aWidth ) const
{
// calculates the start point, end point and width
// of an equivalent segment which have the same position and width as the hole
int delta_cx, delta_cy;
wxSize halfsize = GetDrillSize();
2014-05-17 19:29:15 +00:00
halfsize.x /= 2;
halfsize.y /= 2;
if( m_Drill.x > m_Drill.y ) // horizontal
{
delta_cx = halfsize.x - halfsize.y;
delta_cy = 0;
aWidth = m_Drill.y;
}
else // vertical
{
delta_cx = 0;
delta_cy = halfsize.y - halfsize.x;
aWidth = m_Drill.x;
}
RotatePoint( &delta_cx, &delta_cy, m_Orient );
aStartPoint.x = delta_cx;
aStartPoint.y = delta_cy;
aEndPoint.x = - delta_cx;
aEndPoint.y = - delta_cy;
}
2017-05-10 09:40:49 +00:00
bool D_PAD::HitTest( const wxPoint& aPosition ) const
2007-08-08 03:50:44 +00:00
{
2017-04-24 12:54:44 +00:00
int dx, dy;
2007-08-08 03:50:44 +00:00
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
wxPoint shape_pos = ShapePos();
2007-08-08 03:50:44 +00:00
wxPoint delta = aPosition - shape_pos;
2007-08-08 03:50:44 +00:00
2012-02-19 04:02:19 +00:00
// first test: a test point must be inside a minimum sized bounding circle.
int radius = GetBoundingRadius();
if( ( abs( delta.x ) > radius ) || ( abs( delta.y ) > radius ) )
2007-08-08 03:50:44 +00:00
return false;
dx = m_Size.x >> 1; // dx also is the radius for rounded pads
dy = m_Size.y >> 1;
2007-08-08 03:50:44 +00:00
switch( GetShape() )
2007-08-08 03:50:44 +00:00
{
case PAD_SHAPE_CIRCLE:
if( KiROUND( EuclideanNorm( delta ) ) <= dx )
2007-08-08 03:50:44 +00:00
return true;
2007-08-08 03:50:44 +00:00
break;
case PAD_SHAPE_TRAPEZOID:
{
wxPoint poly[4];
BuildPadPolygon( poly, wxSize(0,0), 0 );
RotatePoint( &delta, -m_Orient );
2017-04-26 09:05:44 +00:00
return TestPointInsidePolygon( poly, 4, delta );
}
case PAD_SHAPE_OVAL:
{
RotatePoint( &delta, -m_Orient );
// An oval pad has the same shape as a segment with rounded ends
// After rotation, the test point is relative to an horizontal pad
int dist;
wxPoint offset;
if( dy > dx ) // shape is a vertical oval
{
offset.y = dy - dx;
dist = dx;
}
else //if( dy <= dx ) shape is an horizontal oval
{
offset.x = dy - dx;
dist = dy;
}
return TestSegmentHit( delta, - offset, offset, dist );
}
break;
case PAD_SHAPE_RECT:
RotatePoint( &delta, -m_Orient );
if( (abs( delta.x ) <= dx ) && (abs( delta.y ) <= dy) )
2007-08-08 03:50:44 +00:00
return true;
2007-08-08 03:50:44 +00:00
break;
2016-04-06 18:15:49 +00:00
case PAD_SHAPE_ROUNDRECT:
{
// Check for hit in polygon
SHAPE_POLY_SET outline;
const int segmentToCircleCount = 32;
TransformRoundRectToPolygon( outline, wxPoint(0,0), GetSize(), m_Orient,
GetRoundRectCornerRadius(), segmentToCircleCount );
const SHAPE_LINE_CHAIN &poly = outline.COutline( 0 );
return TestPointInsidePolygon( (const wxPoint*)&poly.CPoint(0), poly.PointCount(), delta );
}
break;
2007-08-08 03:50:44 +00:00
}
2007-08-08 03:50:44 +00:00
return false;
}
2017-05-10 09:40:49 +00:00
2017-04-22 06:49:15 +00:00
bool D_PAD::HitTest( const EDA_RECT& aRect, bool aContained, int aAccuracy ) const
{
EDA_RECT arect = aRect;
arect.Normalize();
arect.Inflate( aAccuracy );
wxPoint shapePos = ShapePos();
2017-04-22 06:49:15 +00:00
EDA_RECT shapeRect;
2017-04-24 12:54:44 +00:00
int r;
EDA_RECT bb = GetBoundingBox();
wxPoint endCenter;
int radius;
if( !arect.Intersects( bb ) )
return false;
// This covers total containment for all test cases
if( arect.Contains( bb ) )
return true;
2017-04-22 06:49:15 +00:00
switch( GetShape() )
{
case PAD_SHAPE_CIRCLE:
return arect.IntersectsCircle( GetPosition(), GetBoundingRadius() );
case PAD_SHAPE_RECT:
shapeRect.SetOrigin( shapePos );
shapeRect.Inflate( m_Size.x / 2, m_Size.y / 2 );
return arect.Intersects( shapeRect, m_Orient );
2017-04-22 06:49:15 +00:00
case PAD_SHAPE_OVAL:
// Circlular test if dimensions are equal
if( m_Size.x == m_Size.y )
return arect.IntersectsCircle( shapePos, GetBoundingRadius() );
shapeRect.SetOrigin( shapePos );
// Horizontal dimension is greater
if( m_Size.x > m_Size.y )
{
radius = m_Size.y / 2;
shapeRect.Inflate( m_Size.x / 2 - radius, radius );
endCenter = wxPoint( m_Size.x / 2 - radius, 0 );
RotatePoint( &endCenter, m_Orient );
// Test circular ends
if( arect.IntersectsCircle( shapePos + endCenter, radius ) ||
arect.IntersectsCircle( shapePos - endCenter, radius ) )
{
return true;
}
}
else
{
radius = m_Size.x / 2;
shapeRect.Inflate( radius, m_Size.y / 2 - radius );
endCenter = wxPoint( 0, m_Size.y / 2 - radius );
RotatePoint( &endCenter, m_Orient );
// Test circular ends
if( arect.IntersectsCircle( shapePos + endCenter, radius ) ||
arect.IntersectsCircle( shapePos - endCenter, radius ) )
{
return true;
}
}
// Test rectangular portion between rounded ends
if( arect.Intersects( shapeRect, m_Orient ) )
{
return true;
}
2017-04-22 06:49:15 +00:00
break;
case PAD_SHAPE_TRAPEZOID:
2017-04-26 09:05:44 +00:00
/* Trapezoid intersection tests:
* A) Any points of rect inside trapezoid
* B) Any points of trapezoid inside rect
* C) Any sides of trapezoid cross rect
*/
{
wxPoint poly[4];
BuildPadPolygon( poly, wxSize( 0, 0 ), 0 );
wxPoint corners[4];
corners[0] = wxPoint( arect.GetLeft(), arect.GetTop() );
corners[1] = wxPoint( arect.GetRight(), arect.GetTop() );
corners[2] = wxPoint( arect.GetRight(), arect.GetBottom() );
corners[3] = wxPoint( arect.GetLeft(), arect.GetBottom() );
for( int i=0; i<4; i++ )
{
RotatePoint( &poly[i], m_Orient );
poly[i] += shapePos;
}
for( int ii=0; ii<4; ii++ )
{
if( TestPointInsidePolygon( poly, 4, corners[ii] ) )
{
return true;
}
if( arect.Contains( poly[ii] ) )
{
return true;
}
if( arect.Intersects( poly[ii], poly[(ii+1) % 4] ) )
{
return true;
}
}
return false;
}
2017-04-22 06:49:15 +00:00
case PAD_SHAPE_ROUNDRECT:
2017-04-24 12:54:44 +00:00
/* RoundRect intersection can be broken up into simple tests:
* a) Test intersection of horizontal rect
* b) Test intersection of vertical rect
* c) Test intersection of each corner
*/
r = GetRoundRectCornerRadius();
/* Test A - intersection of horizontal rect */
shapeRect.SetSize( 0, 0 );
shapeRect.SetOrigin( shapePos );
shapeRect.Inflate( m_Size.x / 2, m_Size.y / 2 - r );
// Short-circuit test for zero width or height
if( shapeRect.GetWidth() > 0 && shapeRect.GetHeight() > 0 &&
arect.Intersects( shapeRect, m_Orient ) )
{
return true;
}
/* Test B - intersection of vertical rect */
shapeRect.SetSize( 0, 0 );
shapeRect.SetOrigin( shapePos );
shapeRect.Inflate( m_Size.x / 2 - r, m_Size.y / 2 );
// Short-circuit test for zero width or height
if( shapeRect.GetWidth() > 0 && shapeRect.GetHeight() > 0 &&
arect.Intersects( shapeRect, m_Orient ) )
{
return true;
}
/* Test C - intersection of each corner */
endCenter = wxPoint( m_Size.x / 2 - r, m_Size.y / 2 - r );
RotatePoint( &endCenter, m_Orient );
if( arect.IntersectsCircle( shapePos + endCenter, r ) ||
arect.IntersectsCircle( shapePos - endCenter, r ) )
{
return true;
}
endCenter = wxPoint( m_Size.x / 2 - r, -m_Size.y / 2 + r );
RotatePoint( &endCenter, m_Orient );
if( arect.IntersectsCircle( shapePos + endCenter, r ) ||
arect.IntersectsCircle( shapePos - endCenter, r ) )
{
return true;
}
2017-04-22 06:49:15 +00:00
break;
default:
break;
}
return false;
}
2007-08-08 03:50:44 +00:00
2008-02-19 00:30:10 +00:00
int D_PAD::Compare( const D_PAD* padref, const D_PAD* padcmp )
2008-01-24 21:50:12 +00:00
{
int diff;
2008-01-24 21:50:12 +00:00
if( ( diff = padref->GetShape() - padcmp->GetShape() ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
if( ( diff = padref->GetDrillShape() - padcmp->GetDrillShape() ) != 0)
2008-01-24 21:50:12 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Drill.x - padcmp->m_Drill.x ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Drill.y - padcmp->m_Drill.y ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Size.x - padcmp->m_Size.x ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Size.y - padcmp->m_Size.y ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Offset.x - padcmp->m_Offset.x ) != 0 )
2011-12-02 15:09:57 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_Offset.y - padcmp->m_Offset.y ) != 0 )
2011-12-02 15:09:57 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_DeltaSize.x - padcmp->m_DeltaSize.x ) != 0 )
2011-12-02 15:09:57 +00:00
return diff;
2011-12-02 16:55:31 +00:00
if( ( diff = padref->m_DeltaSize.y - padcmp->m_DeltaSize.y ) != 0 )
2008-01-24 21:50:12 +00:00
return diff;
2016-04-06 18:15:49 +00:00
// TODO: test custom shapes
2011-12-02 16:55:31 +00:00
// Dick: specctra_export needs this
// Lorenzo: gencad also needs it to implement padstacks!
#if __cplusplus >= 201103L
long long d = padref->m_layerMask.to_ullong() - padcmp->m_layerMask.to_ullong();
if( d < 0 )
return -1;
else if( d > 0 )
return 1;
2008-01-24 21:50:12 +00:00
return 0;
#else
// these strings are not typically constructed, since we don't get here often.
std::string s1 = padref->m_layerMask.to_string();
std::string s2 = padcmp->m_layerMask.to_string();
return s1.compare( s2 );
#endif
2008-01-24 21:50:12 +00:00
}
2014-07-09 11:50:27 +00:00
void D_PAD::Rotate( const wxPoint& aRotCentre, double aAngle )
{
RotatePoint( &m_Pos, aRotCentre, aAngle );
m_Orient = NormalizeAngle360( m_Orient + aAngle );
SetLocalCoord();
2014-07-09 11:50:27 +00:00
}
wxString D_PAD::ShowPadShape() const
2008-01-24 21:50:12 +00:00
{
switch( GetShape() )
2008-01-24 21:50:12 +00:00
{
case PAD_SHAPE_CIRCLE:
return _( "Circle" );
case PAD_SHAPE_OVAL:
return _( "Oval" );
case PAD_SHAPE_RECT:
return _( "Rect" );
case PAD_SHAPE_TRAPEZOID:
return _( "Trap" );
2016-04-06 18:15:49 +00:00
case PAD_SHAPE_ROUNDRECT:
return _( "Roundrect" );
default:
return wxT( "???" );
2008-01-24 21:50:12 +00:00
}
}
wxString D_PAD::ShowPadAttr() const
2008-01-24 21:50:12 +00:00
{
2012-02-19 04:02:19 +00:00
switch( GetAttribute() )
2008-01-24 21:50:12 +00:00
{
case PAD_ATTRIB_STANDARD:
return _( "Std" );
case PAD_ATTRIB_SMD:
return _( "SMD" );
case PAD_ATTRIB_CONN:
return _( "Conn" );
case PAD_ATTRIB_HOLE_NOT_PLATED:
return _( "Not Plated" );
default:
return wxT( "???" );
2008-01-24 21:50:12 +00:00
}
}
wxString D_PAD::GetSelectMenuText() const
{
wxString text;
wxString padlayers( LayerMaskDescribe( GetBoard(), m_layerMask ) );
wxString padname( GetPadName() );
if( padname.IsEmpty() )
{
text.Printf( _( "Pad on %s of %s" ),
GetChars( padlayers ),
GetChars(GetParent()->GetReference() ) );
}
else
{
text.Printf( _( "Pad %s on %s of %s" ),
GetChars(GetPadName() ), GetChars( padlayers ),
GetChars(GetParent()->GetReference() ) );
}
return text;
}
BITMAP_DEF D_PAD::GetMenuImage() const
{
return pad_xpm;
}
EDA_ITEM* D_PAD::Clone() const
{
return new D_PAD( *this );
}
Introduction of Graphics Abstraction Layer based rendering for pcbnew. New classes: - VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.) - VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes). - EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL). - GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries. - WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc. - PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods. - STROKE_FONT - Implements stroke font drawing using GAL methods. Most important changes to Kicad original code: * EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects. * EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime. * There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew) * Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom. * Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime. * Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods. * Removed tools/class_painter.h, as now it is extended and included in source code. Build changes: * GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL. * When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required. * GAL-related code is compiled into a static library (common/libgal). * Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS). More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
void D_PAD::ViewGetLayers( int aLayers[], int& aCount ) const
{
2013-07-08 09:30:50 +00:00
aCount = 0;
2013-07-26 16:15:11 +00:00
// These types of pads contain a hole
if( m_Attribute == PAD_ATTRIB_STANDARD || m_Attribute == PAD_ATTRIB_HOLE_NOT_PLATED )
aLayers[aCount++] = LAYER_PADS_HOLES;
2013-07-26 16:15:11 +00:00
if( IsOnLayer( F_Cu ) && IsOnLayer( B_Cu ) )
Introduction of Graphics Abstraction Layer based rendering for pcbnew. New classes: - VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.) - VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes). - EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL). - GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries. - WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc. - PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods. - STROKE_FONT - Implements stroke font drawing using GAL methods. Most important changes to Kicad original code: * EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects. * EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime. * There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew) * Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom. * Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime. * Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods. * Removed tools/class_painter.h, as now it is extended and included in source code. Build changes: * GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL. * When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required. * GAL-related code is compiled into a static library (common/libgal). * Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS). More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
{
// Multi layer pad
aLayers[aCount++] = LAYER_PADS;
aLayers[aCount++] = LAYER_PADS_NETNAMES;
Introduction of Graphics Abstraction Layer based rendering for pcbnew. New classes: - VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.) - VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes). - EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL). - GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries. - WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc. - PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods. - STROKE_FONT - Implements stroke font drawing using GAL methods. Most important changes to Kicad original code: * EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects. * EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime. * There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew) * Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom. * Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime. * Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods. * Removed tools/class_painter.h, as now it is extended and included in source code. Build changes: * GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL. * When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required. * GAL-related code is compiled into a static library (common/libgal). * Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS). More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
}
else if( IsOnLayer( F_Cu ) )
Introduction of Graphics Abstraction Layer based rendering for pcbnew. New classes: - VIEW - represents view that is seen by user, takes care of layer ordering & visibility and how it is displayed (which location, how much zoomed, etc.) - VIEW_ITEM - Base class for every item that can be displayed on VIEW (the biggest change is that now it may be necessary to override ViewBBox & ViewGetLayers method for derived classes). - EDA_DRAW_PANEL_GAL - Inherits after EDA_DRAW_PANEL, displays VIEW output, right now it is not editable (in opposite to usual EDA_DRAW_PANEL). - GAL/OPENGL_GAL/CAIRO_GAL - Base Graphics Abstraction Layer class + two different flavours (Cairo is not fully supported yet), that offers methods to draw primitives using different libraries. - WX_VIEW_CONTROLS - Controller for VIEW, handles user events, allows zooming, panning, etc. - PAINTER/PCB_PAINTER - Classes that uses GAL interface to draw items (as you may have already guessed - PCB_PAINTER is a class for drawing PCB specific object, PAINTER is an abstract class). Its methods are invoked by VIEW, when an item has to be drawn. To display a new type of item - you need to implement draw(ITEM_TYPE*) method that draws it using GAL methods. - STROKE_FONT - Implements stroke font drawing using GAL methods. Most important changes to Kicad original code: * EDA_ITEM now inherits from VIEW_ITEM, which is a base class for all drawable objects. * EDA_DRAW_FRAME contains both usual EDA_DRAW_PANEL and new EDA_DRAW_PANEL_GAL, that can be switched anytime. * There are some new layers for displaying multilayer pads, vias & pads holes (these are not shown yet on the right sidebar in pcbnew) * Display order of layers is different than in previous versions (if you are curious - you may check m_galLayerOrder@pcbnew/basepcbframe.cpp). Preserving usual order would result in not very natural display, such as showing silkscreen texts on the bottom. * Introduced new hotkey (Alt+F12) and new menu option (View->Switch canvas) for switching canvas during runtime. * Some of classes (mostly derived from BOARD_ITEM) now includes ViewBBox & ViewGetLayers methods. * Removed tools/class_painter.h, as now it is extended and included in source code. Build changes: * GAL-based rendering option is turned on by a new compilation CMake option KICAD_GAL. * When compiling with CMake option KICAD_GAL=ON, GLEW and Cairo libraries are required. * GAL-related code is compiled into a static library (common/libgal). * Build with KICAD_GAL=OFF should not need any new libraries and should come out as a standard version of Kicad Currently most of items in pcbnew can be displayed using OpenGL (to be done are DIMENSIONS and MARKERS). More details about GAL can be found in: http://www.ohwr.org/attachments/1884/view-spec.pdf
2013-04-02 06:54:03 +00:00
{
aLayers[aCount++] = LAYER_PAD_FR;
aLayers[aCount++] = LAYER_PAD_FR_NETNAMES;
}
else if( IsOnLayer( B_Cu ) )
{
aLayers[aCount++] = LAYER_PAD_BK;
aLayers[aCount++] = LAYER_PAD_BK_NETNAMES;
}
// Check non-copper layers. This list should include all the layers that the
// footprint editor allows a pad to be placed on.
static const PCB_LAYER_ID layers_mech[] = { F_Mask, B_Mask, F_Paste, B_Paste,
F_Adhes, B_Adhes, F_SilkS, B_SilkS, Dwgs_User, Eco1_User, Eco2_User };
for( PCB_LAYER_ID each_layer : layers_mech )
{
if( IsOnLayer( each_layer ) )
aLayers[aCount++] = each_layer;
}
#ifdef __WXDEBUG__
if( aCount == 0 ) // Should not occur
{
wxString msg;
msg.Printf( wxT( "footprint %s, pad %s: could not find valid layer for pad" ),
GetParent() ? GetParent()->GetReference() : "<null>",
GetPadName().IsEmpty() ? "(unnamed)" : GetPadName() );
wxLogWarning( msg );
}
#endif
2013-07-08 09:30:50 +00:00
}
2016-12-09 11:04:32 +00:00
unsigned int D_PAD::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
2013-07-08 09:30:50 +00:00
{
2014-07-09 09:22:42 +00:00
// Netnames will be shown only if zoom is appropriate
if( IsNetnameLayer( aLayer ) )
2013-07-08 09:30:50 +00:00
{
int divisor = std::max( m_Size.x, m_Size.y );
// Pad sizes can be zero briefly when someone is typing a number like "0.5"
// in the pad properties dialog
if( divisor == 0 )
return UINT_MAX;
return ( Millimeter2iu( 100 ) / divisor );
2013-07-08 09:30:50 +00:00
}
// Other layers are shown without any conditions
return 0;
}
2013-07-26 16:15:11 +00:00
const BOX2I D_PAD::ViewBBox() const
{
// Bounding box includes soldermask too
int solderMaskMargin = GetSolderMaskMargin();
VECTOR2I solderPasteMargin = VECTOR2D( GetSolderPasteMargin() );
EDA_RECT bbox = GetBoundingBox();
// Look for the biggest possible bounding box
int xMargin = std::max( solderMaskMargin, solderPasteMargin.x );
int yMargin = std::max( solderMaskMargin, solderPasteMargin.y );
2013-07-26 16:15:11 +00:00
return BOX2I( VECTOR2I( bbox.GetOrigin() ) - VECTOR2I( xMargin, yMargin ),
VECTOR2I( bbox.GetSize() ) + VECTOR2I( 2 * xMargin, 2 * yMargin ) );
2013-07-26 16:15:11 +00:00
}
wxString LayerMaskDescribe( const BOARD *aBoard, LSET aMask )
{
// Try the single or no- layer case (easy)
PCB_LAYER_ID layer = aMask.ExtractLayer();
switch( (int) layer )
{
case UNSELECTED_LAYER:
return _( "No layers" );
case UNDEFINED_LAYER:
break;
default:
return aBoard->GetLayerName( layer );
}
// Try to be smart and useful, starting with outer copper
// (which are more important than internal ones)
wxString layerInfo;
if( aMask[F_Cu] )
AccumulateDescription( layerInfo, aBoard->GetLayerName( F_Cu ) );
if( aMask[B_Cu] )
AccumulateDescription( layerInfo, aBoard->GetLayerName( B_Cu ) );
if( ( aMask & LSET::InternalCuMask() ).any() )
AccumulateDescription( layerInfo, _("Internal" ) );
if( ( aMask & LSET::AllNonCuMask() ).any() )
AccumulateDescription( layerInfo, _("Non-copper" ) );
return layerInfo;
}
void D_PAD::ImportSettingsFromMaster( const D_PAD& aMasterPad )
{
SetShape( aMasterPad.GetShape() );
SetLayerSet( aMasterPad.GetLayerSet() );
SetAttribute( aMasterPad.GetAttribute() );
// The pad orientation, for historical reasons is the
// pad rotation + parent rotation.
// So we have to manage this parent rotation
double pad_rot = aMasterPad.GetOrientation();
if( aMasterPad.GetParent() )
pad_rot -= aMasterPad.GetParent()->GetOrientation();
if( GetParent() )
pad_rot += GetParent()->GetOrientation();
SetOrientation( pad_rot );
SetSize( aMasterPad.GetSize() );
SetDelta( wxSize( 0, 0 ) );
SetOffset( aMasterPad.GetOffset() );
SetDrillSize( aMasterPad.GetDrillSize() );
SetDrillShape( aMasterPad.GetDrillShape() );
SetRoundRectRadiusRatio( aMasterPad.GetRoundRectRadiusRatio() );
switch( aMasterPad.GetShape() )
{
case PAD_SHAPE_TRAPEZOID:
SetDelta( aMasterPad.GetDelta() );
break;
case PAD_SHAPE_CIRCLE:
// ensure size.y == size.x
SetSize( wxSize( GetSize().x, GetSize().x ) );
break;
default:
;
}
switch( aMasterPad.GetAttribute() )
{
case PAD_ATTRIB_SMD:
case PAD_ATTRIB_CONN:
// These pads do not have hole (they are expected to be only on one
// external copper layer)
SetDrillSize( wxSize( 0, 0 ) );
break;
default:
;
}
}