2012-01-14 19:50:32 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2018-05-02 08:31:10 +00:00
|
|
|
* Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2012-06-08 09:56:42 +00:00
|
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
2019-03-23 18:26:44 +00:00
|
|
|
* Copyright (C) 1992-2019 KiCad Developers, see AUTHORS.txt for contributors.
|
2012-01-14 19:50:32 +00:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2011-09-23 13:57:12 +00:00
|
|
|
/**
|
|
|
|
* @file class_pad.cpp
|
|
|
|
* D_PAD class implementation.
|
|
|
|
*/
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <fctsys.h>
|
|
|
|
#include <trigo.h>
|
|
|
|
#include <macros.h>
|
2013-01-12 17:32:24 +00:00
|
|
|
#include <msgpanel.h>
|
|
|
|
#include <base_units.h>
|
2017-02-20 12:20:39 +00:00
|
|
|
#include <bitmaps.h>
|
2020-01-07 17:12:59 +00:00
|
|
|
#include <math/util.h> // for KiROUND
|
2020-04-24 13:36:10 +00:00
|
|
|
#include <eda_draw_frame.h>
|
2020-06-22 19:35:09 +00:00
|
|
|
#include <geometry/shape_circle.h>
|
|
|
|
#include <geometry/shape_segment.h>
|
|
|
|
#include <geometry/shape_simple.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <pcbnew.h>
|
2019-05-14 12:39:34 +00:00
|
|
|
#include <view/view.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_board.h>
|
|
|
|
#include <class_module.h>
|
2020-06-24 11:12:39 +00:00
|
|
|
#include <class_drawsegment.h>
|
2020-01-07 17:12:59 +00:00
|
|
|
#include <geometry/polygon_test_point_inside.h>
|
2016-06-05 11:49:25 +00:00
|
|
|
#include <convert_to_biu.h>
|
2016-04-06 18:15:49 +00:00
|
|
|
#include <convert_basic_shapes_to_polygon.h>
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
#include <memory>
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
D_PAD::D_PAD( MODULE* parent ) :
|
|
|
|
BOARD_CONNECTED_ITEM( parent, PCB_PAD_T )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2016-06-05 11:49:25 +00:00
|
|
|
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.
|
2013-02-12 01:07:04 +00:00
|
|
|
m_LengthPadToDie = 0;
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
if( m_Parent && m_Parent->Type() == PCB_MODULE_T )
|
2007-08-07 06:21:19 +00:00
|
|
|
{
|
2012-02-19 04:02:19 +00:00
|
|
|
m_Pos = GetParent()->GetPosition();
|
2007-08-07 06:21:19 +00:00
|
|
|
}
|
|
|
|
|
2015-08-23 19:40:33 +00:00
|
|
|
SetShape( PAD_SHAPE_CIRCLE ); // Default pad shape is PAD_CIRCLE.
|
2017-01-13 17:51:22 +00:00
|
|
|
SetAnchorPadShape( PAD_SHAPE_CIRCLE ); // Default shape for custom shaped pads
|
|
|
|
// is PAD_CIRCLE.
|
2015-08-23 19:40:33 +00:00
|
|
|
SetDrillShape( PAD_DRILL_SHAPE_CIRCLE ); // Default pad drill shape is a circle.
|
|
|
|
m_Attribute = PAD_ATTRIB_STANDARD; // Default pad type is NORMAL (thru hole)
|
2019-12-11 10:36:45 +00:00
|
|
|
SetProperty( PAD_PROP_NONE ); // no special fabrication property
|
2013-02-12 01:07:04 +00:00
|
|
|
m_LocalClearance = 0;
|
2011-11-24 17:32:51 +00:00
|
|
|
m_LocalSolderMaskMargin = 0;
|
|
|
|
m_LocalSolderPasteMargin = 0;
|
2009-11-04 19:08:08 +00:00
|
|
|
m_LocalSolderPasteMarginRatio = 0.0;
|
2016-04-06 18:15:49 +00:00
|
|
|
// Parameters for round rect only:
|
2018-08-29 07:13:07 +00:00
|
|
|
m_padRoundRectRadiusScale = 0.25; // from IPC-7351C standard
|
|
|
|
// Parameters for chamfered rect only:
|
|
|
|
m_padChamferRectScale = 0.2; // Size of chamfer: ratio of smallest of X,Y size
|
|
|
|
m_chamferPositions = RECT_NO_CHAMFER; // No chamfered corner
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
m_ZoneConnection = ZONE_CONNECTION::INHERITED; // Use parent setting by default
|
2018-08-29 07:13:07 +00:00
|
|
|
m_ThermalWidth = 0; // Use parent setting by default
|
|
|
|
m_ThermalGap = 0; // Use parent setting by default
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
m_customShapeClearanceArea = CUST_PAD_SHAPE_IN_ZONE_OUTLINE;
|
|
|
|
|
2013-02-12 01:07:04 +00:00
|
|
|
// Set layers mask to default for a standard thru hole pad.
|
2014-06-24 16:17:18 +00:00
|
|
|
m_layerMask = StandardMask();
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2013-02-12 01:07:04 +00:00
|
|
|
SetSubRatsnest( 0 ); // used in ratsnest calculations
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
|
|
|
m_effectiveBoundingRadius = 0;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
|
|
|
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
LSET D_PAD::StandardMask()
|
|
|
|
{
|
2016-08-01 22:52:54 +00:00
|
|
|
static LSET saved = LSET::AllCuMask() | LSET( 2, B_Mask, F_Mask );
|
2014-06-24 16:17:18 +00:00
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-06-30 18:14:06 +00:00
|
|
|
LSET D_PAD::SMDMask()
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
|
|
|
static LSET saved( 3, F_Cu, F_Paste, F_Mask );
|
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-02 13:08:28 +00:00
|
|
|
LSET D_PAD::ConnSMDMask()
|
2014-06-24 16:17:18 +00:00
|
|
|
{
|
|
|
|
static LSET saved( 2, F_Cu, F_Mask );
|
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LSET D_PAD::UnplatedHoleMask()
|
|
|
|
{
|
2016-08-01 22:52:54 +00:00
|
|
|
static LSET saved = LSET::AllCuMask() | LSET( 2, B_Mask, F_Mask );
|
2014-06-24 16:17:18 +00:00
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
2018-07-24 13:56:20 +00:00
|
|
|
|
|
|
|
LSET D_PAD::ApertureMask()
|
|
|
|
{
|
2020-05-05 15:40:18 +00:00
|
|
|
static LSET saved( 1, F_Paste );
|
2018-07-24 13:56:20 +00:00
|
|
|
return saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-21 20:19:46 +00:00
|
|
|
bool D_PAD::IsFlipped() const
|
2016-04-06 18:15:49 +00:00
|
|
|
{
|
|
|
|
if( GetParent() && GetParent()->GetLayer() == B_Cu )
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
int D_PAD::calcBoundingRadius() const
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
int radius = 0;
|
|
|
|
SHAPE_POLY_SET polygons;
|
|
|
|
TransformShapeWithClearanceToPolygon( polygons, 0 );
|
2010-12-10 19:47:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
for( int cnt = 0; cnt < polygons.OutlineCount(); ++cnt )
|
2007-08-07 06:21:19 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
const SHAPE_LINE_CHAIN& poly = polygons.COutline( cnt );
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
for( int ii = 0; ii < poly.PointCount(); ++ii )
|
|
|
|
{
|
|
|
|
int dist = KiROUND( ( poly.CPoint( ii ) - m_Pos ).EuclideanNorm() );
|
|
|
|
radius = std::max( radius, dist );
|
|
|
|
}
|
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
return radius + 1;
|
|
|
|
}
|
2010-09-18 17:55:08 +00:00
|
|
|
|
2010-12-12 02:29:33 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
int D_PAD::GetRoundRectCornerRadius() const
|
|
|
|
{
|
|
|
|
return KiROUND( std::min( m_Size.x, m_Size.y ) * m_padRoundRectRadiusScale );
|
|
|
|
}
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2018-08-29 07:13:07 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
void D_PAD::SetRoundRectCornerRadius( double aRadius )
|
|
|
|
{
|
|
|
|
int min_r = std::min( m_Size.x, m_Size.y );
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( min_r > 0 )
|
|
|
|
SetRoundRectRadiusRatio( aRadius / min_r );
|
|
|
|
}
|
2017-01-13 17:51:22 +00:00
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
void D_PAD::SetRoundRectRadiusRatio( double aRadiusScale )
|
|
|
|
{
|
|
|
|
m_padRoundRectRadiusScale = std::max( 0.0, std::min( aRadiusScale, 0.5 ) );
|
2010-12-10 19:47:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
2010-12-10 19:47:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
void D_PAD::SetChamferRectRatio( double aChamferScale )
|
2016-04-06 18:15:49 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
m_padChamferRectScale = std::max( 0.0, std::min( aChamferScale, 0.5 ) );
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
2016-04-06 18:15:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
const std::vector<std::shared_ptr<SHAPE>>& D_PAD::GetEffectiveShapes() const
|
2018-09-09 19:19:21 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
if( m_shapesDirty )
|
|
|
|
buildEffectiveShapes();
|
2018-09-09 19:19:21 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
return m_effectiveShapes;
|
2018-09-09 19:19:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
const std::shared_ptr<SHAPE_SEGMENT>& D_PAD::GetEffectiveHoleShape() const
|
2020-04-22 21:50:15 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
if( m_shapesDirty )
|
|
|
|
buildEffectiveShapes();
|
2020-04-22 21:50:15 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
return m_effectiveHoleShape;
|
|
|
|
}
|
2020-04-22 21:50:15 +00:00
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
int D_PAD::GetBoundingRadius() const
|
|
|
|
{
|
|
|
|
if( m_shapesDirty )
|
|
|
|
buildEffectiveShapes();
|
|
|
|
|
|
|
|
return m_effectiveBoundingRadius;
|
2020-04-22 21:50:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
void D_PAD::buildEffectiveShapes() const
|
2008-04-18 13:28:56 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
m_effectiveShapes.clear();
|
|
|
|
m_effectiveHoleShape = nullptr;
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
auto add = [this]( SHAPE* aShape )
|
|
|
|
{
|
|
|
|
m_effectiveShapes.emplace_back( aShape );
|
|
|
|
};
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
wxPoint shapePos = ShapePos(); // Fetch only once; rotation involves trig
|
|
|
|
PAD_SHAPE_T effectiveShape = GetShape();
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( GetShape() == PAD_SHAPE_CUSTOM )
|
|
|
|
effectiveShape = GetAnchorPadShape();
|
|
|
|
|
|
|
|
switch( effectiveShape )
|
2013-07-26 21:29:16 +00:00
|
|
|
{
|
2015-08-23 19:40:33 +00:00
|
|
|
case PAD_SHAPE_CIRCLE:
|
2020-06-22 19:35:09 +00:00
|
|
|
add( new SHAPE_CIRCLE( shapePos, m_Size.x / 2 ) );
|
2013-07-26 21:29:16 +00:00
|
|
|
break;
|
2010-12-10 19:47:44 +00:00
|
|
|
|
2015-08-23 19:40:33 +00:00
|
|
|
case PAD_SHAPE_OVAL:
|
2020-06-22 19:35:09 +00:00
|
|
|
{
|
|
|
|
wxSize half_size = m_Size / 2;
|
|
|
|
int half_width = std::min( half_size.x, half_size.y );
|
|
|
|
wxPoint half_len( half_size.x - half_width, half_size.y - half_width );
|
2013-07-26 21:29:16 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
RotatePoint( &half_len, m_Orient );
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
add( new SHAPE_SEGMENT( shapePos - half_len, shapePos + half_len, half_width * 2 ) );
|
|
|
|
}
|
|
|
|
break;
|
2016-04-06 18:15:49 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
case PAD_SHAPE_RECT:
|
|
|
|
case PAD_SHAPE_TRAPEZOID:
|
|
|
|
case PAD_SHAPE_ROUNDRECT:
|
|
|
|
{
|
|
|
|
int r = GetRoundRectCornerRadius();
|
|
|
|
wxPoint half_size( m_Size.x / 2, m_Size.y / 2 );
|
|
|
|
wxSize trap_delta( 0, 0 );
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( effectiveShape == PAD_SHAPE_ROUNDRECT )
|
|
|
|
half_size -= wxPoint( r, r );
|
|
|
|
else if( effectiveShape == PAD_SHAPE_TRAPEZOID )
|
|
|
|
trap_delta = m_DeltaSize / 2;
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
SHAPE_LINE_CHAIN corners;
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
corners.Append( -half_size.x + trap_delta.y, -half_size.y - trap_delta.x );
|
|
|
|
corners.Append( half_size.x - trap_delta.y, -half_size.y + trap_delta.x );
|
|
|
|
corners.Append( half_size.x + trap_delta.y, half_size.y - trap_delta.x );
|
|
|
|
corners.Append( -half_size.x - trap_delta.y, half_size.y + trap_delta.x );
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
corners.Rotate( -DECIDEG2RAD( m_Orient ) );
|
|
|
|
corners.Move( shapePos );
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
add( new SHAPE_SIMPLE( corners ) );
|
2017-04-24 11:54:53 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( effectiveShape == PAD_SHAPE_ROUNDRECT )
|
|
|
|
{
|
|
|
|
add( new SHAPE_SEGMENT( corners.CPoint( 0 ), corners.CPoint( 1 ), r * 2 ) );
|
|
|
|
add( new SHAPE_SEGMENT( corners.CPoint( 1 ), corners.CPoint( 2 ), r * 2 ) );
|
|
|
|
add( new SHAPE_SEGMENT( corners.CPoint( 2 ), corners.CPoint( 3 ), r * 2 ) );
|
|
|
|
add( new SHAPE_SEGMENT( corners.CPoint( 3 ), corners.CPoint( 0 ), r * 2 ) );
|
|
|
|
}
|
|
|
|
}
|
2013-07-26 21:29:16 +00:00
|
|
|
break;
|
|
|
|
|
2018-08-29 07:13:07 +00:00
|
|
|
case PAD_SHAPE_CHAMFERED_RECT:
|
2020-06-22 19:35:09 +00:00
|
|
|
{
|
|
|
|
SHAPE_POLY_SET outline;
|
|
|
|
auto board = GetBoard();
|
|
|
|
int maxError = ARC_HIGH_DEF;
|
2013-07-26 21:29:16 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( board )
|
|
|
|
maxError = board->GetDesignSettings().m_MaxError;
|
|
|
|
|
|
|
|
TransformRoundChamferedRectToPolygon( outline, wxPoint(0,0), GetSize(), m_Orient,
|
|
|
|
GetRoundRectCornerRadius(), GetChamferRectRatio(),
|
|
|
|
GetChamferPositions(), maxError );
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
add( new SHAPE_SIMPLE( outline.COutline( 0 ) ) );
|
|
|
|
}
|
|
|
|
break;
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
default:
|
|
|
|
wxFAIL_MSG( "D_PAD::buildEffectiveShapes: Unsupported pad shape" );
|
|
|
|
break;
|
|
|
|
}
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( GetShape() == PAD_SHAPE_CUSTOM )
|
|
|
|
{
|
|
|
|
SHAPE_POLY_SET* poly = new SHAPE_POLY_SET();
|
|
|
|
MergePrimitivesAsPolygon( poly );
|
|
|
|
poly->Rotate( -DECIDEG2RAD( m_Orient ) );
|
|
|
|
poly->Move( shapePos );
|
|
|
|
add( poly );
|
|
|
|
}
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
// Bounding radius
|
|
|
|
//
|
|
|
|
m_effectiveBoundingRadius = calcBoundingRadius();
|
2013-07-26 21:29:16 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
// Hole shape
|
|
|
|
//
|
|
|
|
wxSize half_size = m_Drill / 2;
|
|
|
|
int half_width = std::min( half_size.x, half_size.y );
|
|
|
|
wxPoint half_len( half_size.x - half_width, half_size.y - half_width );
|
2013-07-26 21:29:16 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
RotatePoint( &half_len, m_Orient );
|
2017-04-23 00:06:56 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_effectiveHoleShape = std::make_shared<SHAPE_SEGMENT>( m_Pos - half_len, m_Pos + half_len,
|
|
|
|
half_width * 2 );
|
2013-07-26 21:29:16 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
// All done
|
|
|
|
//
|
|
|
|
m_shapesDirty = false;
|
|
|
|
}
|
2017-01-13 17:51:22 +00:00
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
const EDA_RECT D_PAD::GetBoundingBox() const
|
|
|
|
{
|
|
|
|
EDA_RECT bbox;
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
for( const std::shared_ptr<SHAPE>& shape : GetEffectiveShapes() )
|
|
|
|
{
|
|
|
|
BOX2I r = shape->BBox();
|
|
|
|
bbox.Merge( EDA_RECT( (wxPoint) r.GetOrigin(), wxSize( r.GetWidth(), r.GetHeight() ) ) );
|
2013-07-26 21:29:16 +00:00
|
|
|
}
|
2008-07-31 15:30:57 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
return bbox;
|
2008-04-18 13:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-09 09:59:24 +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() );
|
2014-07-09 09:59:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-13 01:01:22 +00:00
|
|
|
void D_PAD::SetAttribute( PAD_ATTR_T aAttribute )
|
|
|
|
{
|
|
|
|
m_Attribute = aAttribute;
|
|
|
|
|
2015-08-23 19:40:33 +00:00
|
|
|
if( aAttribute == PAD_ATTRIB_SMD )
|
2013-02-13 01:01:22 +00:00
|
|
|
m_Drill = wxSize( 0, 0 );
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
m_shapesDirty = true;
|
2013-02-13 01:01:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-11 10:36:45 +00:00
|
|
|
void D_PAD::SetProperty( PAD_PROP_T aProperty )
|
|
|
|
{
|
|
|
|
m_Property = aProperty;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
m_shapesDirty = true;
|
2019-12-11 10:36:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
void D_PAD::SetOrientation( double aAngle )
|
|
|
|
{
|
|
|
|
NORMALIZE_ANGLE_POS( aAngle );
|
|
|
|
m_Orient = aAngle;
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
m_shapesDirty = true;
|
2012-02-19 04:02:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-07-12 21:02:10 +00:00
|
|
|
void D_PAD::Flip( const wxPoint& aCentre, bool aFlipLeftRight )
|
2012-02-19 04:02:19 +00:00
|
|
|
{
|
2019-07-12 21:02:10 +00:00
|
|
|
if( aFlipLeftRight )
|
|
|
|
{
|
|
|
|
MIRROR( m_Pos.x, aCentre.x );
|
|
|
|
MIRROR( m_Pos0.x, 0 );
|
|
|
|
MIRROR( m_Offset.x, 0 );
|
|
|
|
MIRROR( m_DeltaSize.x, 0 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
MIRROR( m_Pos.y, aCentre.y );
|
|
|
|
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
|
2015-12-27 15:51:13 +00:00
|
|
|
// 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
|
2014-06-24 16:17:18 +00:00
|
|
|
SetLayerSet( FlipLayerMask( m_layerMask ) );
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
// Flip the basic shapes, in custom pads
|
2017-09-20 08:28:52 +00:00
|
|
|
FlipPrimitives();
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
2012-02-19 04:02:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
// Flip the basic shapes, in custom pads
|
2017-09-20 08:28:52 +00:00
|
|
|
void D_PAD::FlipPrimitives()
|
2017-01-13 17:51:22 +00:00
|
|
|
{
|
2020-06-24 11:12:39 +00:00
|
|
|
for( std::shared_ptr<DRAWSEGMENT>& primitive : m_editPrimitives )
|
|
|
|
primitive->Flip( wxPoint( 0, 0 ), false );
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
2017-01-13 17:51:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-01-17 04:55:40 +00:00
|
|
|
void D_PAD::MirrorXPrimitives( int aX )
|
|
|
|
{
|
2020-06-24 11:12:39 +00:00
|
|
|
for( std::shared_ptr<DRAWSEGMENT>& primitive : m_editPrimitives )
|
|
|
|
primitive->Flip( wxPoint( aX, 0 ), true );
|
2019-01-17 04:55:40 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
m_shapesDirty = true;
|
2019-01-17 04:55:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-01-12 18:40:50 +00:00
|
|
|
void D_PAD::AppendConfigs( std::vector<PARAM_CFG*>* aResult )
|
2012-02-19 04:02:19 +00:00
|
|
|
{
|
2013-03-30 09:28:59 +00:00
|
|
|
// Parameters stored in config are only significant parameters
|
|
|
|
// for a template.
|
|
|
|
// So not all parameters are stored, just few.
|
2020-01-12 18:40:50 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-12 15:43:38 +00:00
|
|
|
// Returns the position of the pad.
|
2017-01-21 20:19:46 +00:00
|
|
|
wxPoint D_PAD::ShapePos() const
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2011-11-24 17:32:51 +00:00
|
|
|
if( m_Offset.x == 0 && m_Offset.y == 0 )
|
|
|
|
return m_Pos;
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2015-12-27 15:51:13 +00:00
|
|
|
wxPoint loc_offset = m_Offset;
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2015-12-27 15:51:13 +00:00
|
|
|
RotatePoint( &loc_offset, m_Orient );
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2015-12-27 15:51:13 +00:00
|
|
|
wxPoint shape_pos = m_Pos + loc_offset;
|
2007-06-05 12:10:51 +00:00
|
|
|
|
|
|
|
return shape_pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-29 12:36:45 +00:00
|
|
|
int D_PAD::GetLocalClearanceOverrides( wxString* aSource ) const
|
2009-11-05 20:59:42 +00:00
|
|
|
{
|
2020-04-26 12:21:37 +00:00
|
|
|
// A pad can have specific clearance that overrides its NETCLASS clearance value
|
2020-05-29 12:36:45 +00:00
|
|
|
if( GetLocalClearance() )
|
|
|
|
return GetLocalClearance( aSource );
|
2009-11-05 20:59:42 +00:00
|
|
|
|
2020-04-26 12:21:37 +00:00
|
|
|
// A footprint can have a specific clearance value
|
2020-05-23 21:48:24 +00:00
|
|
|
if( GetParent() && GetParent()->GetLocalClearance() )
|
2020-05-29 12:36:45 +00:00
|
|
|
return GetParent()->GetLocalClearance( aSource );
|
2009-11-05 20:59:42 +00:00
|
|
|
|
2020-05-29 12:36:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int D_PAD::GetLocalClearance( wxString* aSource ) const
|
|
|
|
{
|
|
|
|
if( aSource )
|
|
|
|
*aSource = wxString::Format( _( "pad %s" ), GetName() );
|
2009-11-05 20:59:42 +00:00
|
|
|
|
2020-05-29 12:36:45 +00:00
|
|
|
return m_LocalClearance;
|
2009-11-05 20:59:42 +00:00
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2009-11-12 15:43:38 +00:00
|
|
|
|
2009-11-04 19:08:08 +00:00
|
|
|
// Mask margins handling:
|
|
|
|
|
2013-07-26 16:15:11 +00:00
|
|
|
int D_PAD::GetSolderMaskMargin() const
|
2009-11-04 19:08:08 +00:00
|
|
|
{
|
2018-05-02 08:31:10 +00:00
|
|
|
// The pad inherits the margin only to calculate a default shape,
|
|
|
|
// therefore only if it is also a copper layer
|
|
|
|
// Pads defined only on mask layers (and perhaps on other tech layers) use the shape
|
|
|
|
// defined by the pad settings only
|
|
|
|
bool isOnCopperLayer = ( m_layerMask & LSET::AllCuMask() ).any();
|
|
|
|
|
|
|
|
if( !isOnCopperLayer )
|
|
|
|
return 0;
|
|
|
|
|
2012-02-02 17:45:37 +00:00
|
|
|
int margin = m_LocalSolderMaskMargin;
|
2018-05-02 08:31:10 +00:00
|
|
|
|
2012-04-17 01:35:43 +00:00
|
|
|
MODULE* module = GetParent();
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2010-01-31 20:01:46 +00:00
|
|
|
if( module )
|
2009-11-04 19:08:08 +00:00
|
|
|
{
|
2010-01-31 20:01:46 +00:00
|
|
|
if( margin == 0 )
|
|
|
|
{
|
2012-04-17 01:35:43 +00:00
|
|
|
if( module->GetLocalSolderMaskMargin() )
|
|
|
|
margin = module->GetLocalSolderMaskMargin();
|
2010-01-31 20:01:46 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2010-01-31 20:01:46 +00:00
|
|
|
if( margin == 0 )
|
|
|
|
{
|
2012-02-02 17:45:37 +00:00
|
|
|
BOARD* brd = GetBoard();
|
2020-05-07 21:33:50 +00:00
|
|
|
|
2019-01-18 01:50:50 +00:00
|
|
|
if( brd )
|
2019-01-18 03:17:34 +00:00
|
|
|
margin = brd->GetDesignSettings().m_SolderMaskMargin;
|
2010-01-31 20:01:46 +00:00
|
|
|
}
|
2009-11-04 19:08:08 +00:00
|
|
|
}
|
|
|
|
|
2009-11-12 15:43:38 +00:00
|
|
|
// ensure mask have a size always >= 0
|
2009-11-04 19:08:08 +00:00
|
|
|
if( margin < 0 )
|
|
|
|
{
|
2012-09-22 11:19:37 +00:00
|
|
|
int minsize = -std::min( m_Size.x, m_Size.y ) / 2;
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2009-11-12 15:43:38 +00:00
|
|
|
if( margin < minsize )
|
2013-07-31 16:41:32 +00:00
|
|
|
margin = minsize;
|
2009-11-04 19:08:08 +00:00
|
|
|
}
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2009-11-04 19:08:08 +00:00
|
|
|
return margin;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-31 12:51:20 +00:00
|
|
|
wxSize D_PAD::GetSolderPasteMargin() const
|
2009-11-04 19:08:08 +00:00
|
|
|
{
|
2018-05-02 08:31:10 +00:00
|
|
|
// The pad inherits the margin only to calculate a default shape,
|
|
|
|
// therefore only if it is also a copper layer.
|
|
|
|
// Pads defined only on mask layers (and perhaps on other tech layers) use the shape
|
|
|
|
// defined by the pad settings only
|
|
|
|
bool isOnCopperLayer = ( m_layerMask & LSET::AllCuMask() ).any();
|
|
|
|
|
|
|
|
if( !isOnCopperLayer )
|
|
|
|
return wxSize( 0, 0 );
|
|
|
|
|
2012-04-17 01:35:43 +00:00
|
|
|
int margin = m_LocalSolderPasteMargin;
|
|
|
|
double mratio = m_LocalSolderPasteMarginRatio;
|
2018-05-02 08:31:10 +00:00
|
|
|
|
2012-04-17 01:35:43 +00:00
|
|
|
MODULE* module = GetParent();
|
2009-11-12 15:43:38 +00:00
|
|
|
|
2010-01-31 20:01:46 +00:00
|
|
|
if( module )
|
|
|
|
{
|
2012-04-17 01:35:43 +00:00
|
|
|
if( margin == 0 )
|
|
|
|
margin = module->GetLocalSolderPasteMargin();
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2019-01-20 03:32:50 +00:00
|
|
|
auto brd = GetBoard();
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2019-01-20 03:32:50 +00:00
|
|
|
if( margin == 0 && brd )
|
|
|
|
{
|
|
|
|
margin = brd->GetDesignSettings().m_SolderPasteMargin;
|
|
|
|
}
|
2010-01-31 20:01:46 +00:00
|
|
|
|
|
|
|
if( mratio == 0.0 )
|
2012-04-17 01:35:43 +00:00
|
|
|
mratio = module->GetLocalSolderPasteMarginRatio();
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2019-01-20 03:32:50 +00:00
|
|
|
if( mratio == 0.0 && brd )
|
2010-01-31 20:01:46 +00:00
|
|
|
{
|
2012-04-17 01:35:43 +00:00
|
|
|
mratio = brd->GetDesignSettings().m_SolderPasteMarginRatio;
|
2010-01-31 20:01:46 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-04 19:08:08 +00:00
|
|
|
|
|
|
|
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 );
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2009-11-12 15:43:38 +00:00
|
|
|
// ensure mask have a size always >= 0
|
2011-11-24 17:32:51 +00:00
|
|
|
if( pad_margin.x < -m_Size.x / 2 )
|
|
|
|
pad_margin.x = -m_Size.x / 2;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2011-11-24 17:32:51 +00:00
|
|
|
if( pad_margin.y < -m_Size.y / 2 )
|
|
|
|
pad_margin.y = -m_Size.y / 2;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
|
|
|
return pad_margin;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
ZONE_CONNECTION D_PAD::GetEffectiveZoneConnection() const
|
2012-02-24 23:23:46 +00:00
|
|
|
{
|
2015-11-04 08:48:34 +00:00
|
|
|
MODULE* module = GetParent();
|
2012-02-24 23:23:46 +00:00
|
|
|
|
2019-12-28 00:55:11 +00:00
|
|
|
if( m_ZoneConnection == ZONE_CONNECTION::INHERITED && module )
|
2012-02-24 23:23:46 +00:00
|
|
|
return module->GetZoneConnection();
|
|
|
|
else
|
|
|
|
return m_ZoneConnection;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-08 20:44:03 +00:00
|
|
|
int D_PAD::GetThermalWidth() const
|
|
|
|
{
|
2015-11-04 08:48:34 +00:00
|
|
|
MODULE* module = GetParent();
|
2012-03-08 20:44:03 +00:00
|
|
|
|
|
|
|
if( m_ThermalWidth == 0 && module )
|
|
|
|
return module->GetThermalWidth();
|
|
|
|
else
|
|
|
|
return m_ThermalWidth;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int D_PAD::GetThermalGap() const
|
|
|
|
{
|
2015-11-04 08:48:34 +00:00
|
|
|
MODULE* module = GetParent();
|
2012-03-08 20:44:03 +00:00
|
|
|
|
|
|
|
if( m_ThermalGap == 0 && module )
|
|
|
|
return module->GetThermalGap();
|
|
|
|
else
|
|
|
|
return m_ThermalGap;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-24 13:36:10 +00:00
|
|
|
void D_PAD::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2020-05-21 17:42:42 +00:00
|
|
|
EDA_UNITS units = aFrame->GetUserUnits();
|
|
|
|
wxString msg, msg2;
|
|
|
|
BOARD* board = GetBoard();
|
|
|
|
BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
|
|
|
|
MODULE* module = (MODULE*) m_Parent;
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2008-02-19 00:30:10 +00:00
|
|
|
if( module )
|
2019-12-05 15:41:21 +00:00
|
|
|
aList.emplace_back( _( "Footprint" ), module->GetReference(), DARKCYAN );
|
2009-12-07 03:46:13 +00:00
|
|
|
|
2019-12-05 15:41:21 +00:00
|
|
|
aList.emplace_back( _( "Pad" ), m_name, BROWN );
|
2019-11-17 09:11:29 +00:00
|
|
|
|
|
|
|
if( !GetPinFunction().IsEmpty() )
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( _( "Pin Name" ), GetPinFunction(), BROWN );
|
2019-11-17 09:11:29 +00:00
|
|
|
|
2019-12-05 15:41:21 +00:00
|
|
|
aList.emplace_back( _( "Net" ), UnescapeString( GetNetname() ), DARKCYAN );
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
// Display the netclass name (a pad having a netcode = 0 (no net) use the
|
|
|
|
// default netclass for clearance):
|
|
|
|
if( m_netinfo->GetNet() <= 0 )
|
|
|
|
msg = bds.GetDefault()->GetName();
|
|
|
|
else
|
|
|
|
msg = GetNetClassName();
|
|
|
|
|
|
|
|
aList.emplace_back( _( "NetClass" ), msg, CYAN );
|
2008-02-19 00:30:10 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( _( "Layer" ), LayerMaskDescribe( board, m_layerMask ), DARKGREEN );
|
2019-12-11 10:36:45 +00:00
|
|
|
|
|
|
|
// Show the pad shape, attribute and property
|
|
|
|
wxString props = ShowPadAttr();
|
|
|
|
|
|
|
|
if( GetProperty() != PAD_PROP_NONE )
|
|
|
|
props += ',';
|
|
|
|
|
|
|
|
switch( GetProperty() )
|
|
|
|
{
|
|
|
|
case PAD_PROP_NONE: break;
|
|
|
|
case PAD_PROP_BGA: props += _("BGA" ); break;
|
|
|
|
case PAD_PROP_FIDUCIAL_GLBL: props += _("Fiducial global" ); break;
|
|
|
|
case PAD_PROP_FIDUCIAL_LOCAL: props += _("Fiducial local" ); break;
|
|
|
|
case PAD_PROP_TESTPOINT: props += _("Test point" ); break;
|
|
|
|
case PAD_PROP_HEATSINK: props += _("Heat sink" ); break;
|
|
|
|
case PAD_PROP_CASTELLATED: props += _("Castellated" ); break;
|
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2019-12-11 10:36:45 +00:00
|
|
|
aList.emplace_back( ShowPadShape(), props, DARKGREEN );
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
if( (GetShape() == PAD_SHAPE_CIRCLE || GetShape() == PAD_SHAPE_OVAL )
|
|
|
|
&& m_Size.x == m_Size.y )
|
|
|
|
{
|
|
|
|
msg = MessageTextFromValue( units, m_Size.x, true );
|
|
|
|
aList.emplace_back( _( "Diameter" ), msg, RED );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
msg = MessageTextFromValue( units, m_Size.x, true );
|
|
|
|
aList.emplace_back( _( "Width" ), msg, RED );
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
msg = MessageTextFromValue( units, m_Size.y, true );
|
|
|
|
aList.emplace_back( _( "Height" ), msg, RED );
|
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
if( GetPadToDieLength() )
|
|
|
|
{
|
|
|
|
msg = MessageTextFromValue(units, GetPadToDieLength(), true );
|
|
|
|
aList.emplace_back( _( "Length in Package" ), msg, CYAN );
|
|
|
|
}
|
|
|
|
|
|
|
|
msg = MessageTextFromValue( units, m_Drill.x, true );
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2015-08-23 19:40:33 +00:00
|
|
|
if( GetDrillShape() == PAD_DRILL_SHAPE_CIRCLE )
|
2007-08-07 06:21:19 +00:00
|
|
|
{
|
2019-12-05 15:41:21 +00:00
|
|
|
aList.emplace_back( _( "Drill" ), msg, RED );
|
2007-08-07 06:21:19 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-05-21 17:42:42 +00:00
|
|
|
msg = MessageTextFromValue( units, m_Drill.x, true )
|
2018-04-10 10:52:12 +00:00
|
|
|
+ wxT( "/" )
|
2020-05-21 17:42:42 +00:00
|
|
|
+ MessageTextFromValue( units, m_Drill.y, true );
|
2019-12-05 15:41:21 +00:00
|
|
|
aList.emplace_back( _( "Drill X / Y" ), msg, RED );
|
2007-08-07 06:21:19 +00:00
|
|
|
}
|
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
wxString source;
|
|
|
|
int clearance = GetClearance( nullptr, &source );
|
2020-04-30 14:57:24 +00:00
|
|
|
|
2020-05-21 17:42:42 +00:00
|
|
|
msg.Printf( _( "Min Clearance: %s" ), MessageTextFromValue( units, clearance, true ) );
|
2020-05-22 10:31:14 +00:00
|
|
|
msg2.Printf( _( "(from %s)" ), source );
|
2020-05-21 17:42:42 +00:00
|
|
|
aList.emplace_back( msg, msg2, BLACK );
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2007-08-08 03:50:44 +00:00
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
void D_PAD::GetOblongGeometry( const wxSize& aDrillOrPadSize,
|
|
|
|
wxPoint* aStartPoint, wxPoint* aEndPoint, int* aWidth ) const
|
2014-05-17 19:29:15 +00:00
|
|
|
{
|
|
|
|
// calculates the start point, end point and width
|
2020-04-27 16:22:42 +00:00
|
|
|
// of an equivalent segment which have the same position and width as the pad or hole
|
2014-05-17 19:29:15 +00:00
|
|
|
int delta_cx, delta_cy;
|
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
wxSize halfsize = aDrillOrPadSize / 2;
|
|
|
|
wxPoint offset;
|
2014-05-17 19:29:15 +00:00
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
if( aDrillOrPadSize.x > aDrillOrPadSize.y ) // horizontal
|
2014-05-17 19:29:15 +00:00
|
|
|
{
|
|
|
|
delta_cx = halfsize.x - halfsize.y;
|
|
|
|
delta_cy = 0;
|
2020-04-27 16:22:42 +00:00
|
|
|
*aWidth = aDrillOrPadSize.y;
|
2014-05-17 19:29:15 +00:00
|
|
|
}
|
2020-04-27 16:22:42 +00:00
|
|
|
else // vertical
|
2014-05-17 19:29:15 +00:00
|
|
|
{
|
|
|
|
delta_cx = 0;
|
|
|
|
delta_cy = halfsize.y - halfsize.x;
|
2020-04-27 16:22:42 +00:00
|
|
|
*aWidth = aDrillOrPadSize.x;
|
2014-05-17 19:29:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RotatePoint( &delta_cx, &delta_cy, m_Orient );
|
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
aStartPoint->x = delta_cx + offset.x;
|
|
|
|
aStartPoint->y = delta_cy + offset.y;
|
2014-05-17 19:29:15 +00:00
|
|
|
|
2020-04-27 16:22:42 +00:00
|
|
|
aEndPoint->x = - delta_cx + offset.x;
|
|
|
|
aEndPoint->y = - delta_cy + offset.y;
|
2014-05-17 19:29:15 +00:00
|
|
|
}
|
|
|
|
|
2017-05-10 09:40:49 +00:00
|
|
|
|
2019-05-05 10:33:34 +00:00
|
|
|
bool D_PAD::HitTest( const wxPoint& aPosition, int aAccuracy ) const
|
2007-08-08 03:50:44 +00:00
|
|
|
{
|
2020-06-22 19:35:09 +00:00
|
|
|
VECTOR2I delta = aPosition - GetPosition();
|
|
|
|
int boundingRadius = GetBoundingRadius() + aAccuracy;
|
2007-08-08 03:50:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( delta.SquaredEuclideanNorm() > SEG::Square( boundingRadius ) )
|
2007-08-08 03:50:44 +00:00
|
|
|
return false;
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
SHAPE_POLY_SET polySet;
|
|
|
|
TransformShapeWithClearanceToPolygon( polySet, aAccuracy );
|
2007-08-08 03:50:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
return polySet.Contains( aPosition );
|
2007-08-08 03:50:44 +00:00
|
|
|
}
|
|
|
|
|
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 );
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
EDA_RECT bbox = GetBoundingBox();
|
2017-04-22 06:49:15 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( !arect.Intersects( bbox ) )
|
2017-04-24 11:54:53 +00:00
|
|
|
return false;
|
2017-04-23 00:06:56 +00:00
|
|
|
|
|
|
|
// This covers total containment for all test cases
|
2020-06-22 19:35:09 +00:00
|
|
|
if( arect.Contains( bbox ) )
|
2017-04-23 00:06:56 +00:00
|
|
|
return true;
|
2017-04-22 06:49:15 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
SHAPE_POLY_SET selRect;
|
|
|
|
selRect.NewOutline();
|
|
|
|
selRect.Append( arect.GetOrigin() );
|
|
|
|
selRect.Append( VECTOR2I( arect.GetRight(), arect.GetTop() ) );
|
|
|
|
selRect.Append( VECTOR2I( arect.GetRight(), arect.GetBottom() ) );
|
|
|
|
selRect.Append( VECTOR2I( arect.GetLeft(), arect.GetBottom() ) );
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
SHAPE_POLY_SET padPoly;
|
|
|
|
TransformShapeWithClearanceToPolygon( padPoly, aAccuracy );
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
selRect.BooleanIntersection( padPoly, SHAPE_POLY_SET::PM_FAST );
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
double padArea = padPoly.Outline( 0 ).Area();
|
|
|
|
double intersection = selRect.Outline( 0 ).Area();
|
2017-04-26 09:05:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
if( intersection > ( padArea * 0.99 ) )
|
|
|
|
return true;
|
|
|
|
else
|
|
|
|
return !aContained && intersection > 0;
|
2017-04-22 06:49:15 +00:00
|
|
|
}
|
2007-08-08 03:50:44 +00:00
|
|
|
|
2020-06-22 19:35:09 +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
|
|
|
{
|
2008-12-14 19:45:05 +00:00
|
|
|
int diff;
|
2008-01-24 21:50:12 +00:00
|
|
|
|
2014-01-26 14:20:58 +00:00
|
|
|
if( ( diff = padref->GetShape() - padcmp->GetShape() ) != 0 )
|
2008-01-24 21:50:12 +00:00
|
|
|
return diff;
|
2011-09-07 19:41:04 +00:00
|
|
|
|
2014-01-26 14:20:58 +00:00
|
|
|
if( ( diff = padref->GetDrillShape() - padcmp->GetDrillShape() ) != 0)
|
2008-01-24 21:50:12 +00:00
|
|
|
return diff;
|
2011-09-07 19:41:04 +00:00
|
|
|
|
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-09-07 19:41:04 +00:00
|
|
|
|
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-09-07 19:41:04 +00:00
|
|
|
|
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-09-07 19:41:04 +00:00
|
|
|
|
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-09-07 19:41:04 +00:00
|
|
|
|
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!
|
2014-06-24 16:17:18 +00:00
|
|
|
|
|
|
|
#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;
|
2014-06-24 16:17:18 +00:00
|
|
|
#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 );
|
2017-01-23 20:30:11 +00:00
|
|
|
|
2017-10-23 13:35:03 +00:00
|
|
|
m_Orient = NormalizeAngle360Min( m_Orient + aAngle );
|
2015-02-28 17:39:05 +00:00
|
|
|
|
|
|
|
SetLocalCoord();
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
m_shapesDirty = true;
|
2014-07-09 11:50:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-14 19:41:20 +00:00
|
|
|
wxString D_PAD::ShowPadShape() const
|
2008-01-24 21:50:12 +00:00
|
|
|
{
|
2014-01-26 14:20:58 +00:00
|
|
|
switch( GetShape() )
|
2008-01-24 21:50:12 +00:00
|
|
|
{
|
2020-05-21 17:42:42 +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" );
|
|
|
|
case PAD_SHAPE_ROUNDRECT: return _( "Roundrect" );
|
|
|
|
case PAD_SHAPE_CHAMFERED_RECT: return _( "Chamferedrect" );
|
|
|
|
case PAD_SHAPE_CUSTOM: return _( "CustomShape" );
|
|
|
|
default: return wxT( "???" );
|
2008-01-24 21:50:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-14 19:41:20 +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
|
|
|
{
|
2020-05-21 17:42:42 +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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-20 14:11:39 +00:00
|
|
|
wxString D_PAD::GetSelectMenuText( EDA_UNITS aUnits ) const
|
2011-07-14 15:42:44 +00:00
|
|
|
{
|
2018-04-10 10:52:12 +00:00
|
|
|
if( GetName().IsEmpty() )
|
2013-04-07 11:55:18 +00:00
|
|
|
{
|
2018-04-10 10:52:12 +00:00
|
|
|
return wxString::Format( _( "Pad of %s on %s" ),
|
|
|
|
GetParent()->GetReference(),
|
|
|
|
LayerMaskDescribe( GetBoard(), m_layerMask ) );
|
2013-04-07 11:55:18 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-04-10 10:52:12 +00:00
|
|
|
return wxString::Format( _( "Pad %s of %s on %s" ),
|
|
|
|
GetName(),
|
|
|
|
GetParent()->GetReference(),
|
|
|
|
LayerMaskDescribe( GetBoard(), m_layerMask ) );
|
2013-04-07 11:55:18 +00:00
|
|
|
}
|
2011-07-14 15:42:44 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 16:29:35 +00:00
|
|
|
|
2017-02-20 12:20:39 +00:00
|
|
|
BITMAP_DEF D_PAD::GetMenuImage() const
|
|
|
|
{
|
|
|
|
return pad_xpm;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-17 14:39:27 +00:00
|
|
|
EDA_ITEM* D_PAD::Clone() const
|
2012-01-14 19:50:32 +00:00
|
|
|
{
|
|
|
|
return new D_PAD( *this );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-04 09:46:38 +00:00
|
|
|
bool D_PAD::PadShouldBeNPTH() const
|
|
|
|
{
|
|
|
|
return( m_Attribute == PAD_ATTRIB_STANDARD
|
|
|
|
&& m_Drill.x >= m_Size.x && m_Drill.y >= m_Size.y );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2017-11-29 08:48:41 +00:00
|
|
|
// These 2 types of pads contain a hole
|
|
|
|
if( m_Attribute == PAD_ATTRIB_STANDARD )
|
|
|
|
aLayers[aCount++] = LAYER_PADS_PLATEDHOLES;
|
|
|
|
|
|
|
|
if( m_Attribute == PAD_ATTRIB_HOLE_NOT_PLATED )
|
|
|
|
aLayers[aCount++] = LAYER_NON_PLATEDHOLES;
|
2013-07-26 16:15:11 +00:00
|
|
|
|
2014-06-24 16:17:18 +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
|
|
|
{
|
2013-07-16 11:40:53 +00:00
|
|
|
// Multi layer pad
|
2017-11-29 08:48:41 +00:00
|
|
|
aLayers[aCount++] = LAYER_PADS_TH;
|
2017-03-13 03:19:33 +00:00
|
|
|
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
|
|
|
}
|
2014-06-24 16:17:18 +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
|
|
|
{
|
2017-03-13 03:19:33 +00:00
|
|
|
aLayers[aCount++] = LAYER_PAD_FR;
|
2019-05-27 15:23:40 +00:00
|
|
|
|
|
|
|
// Is this a PTH pad that has only front copper? If so, we need to also display the
|
|
|
|
// net name on the PTH netname layer so that it isn't blocked by the drill hole.
|
|
|
|
if( m_Attribute == PAD_ATTRIB_STANDARD )
|
|
|
|
aLayers[aCount++] = LAYER_PADS_NETNAMES;
|
|
|
|
else
|
|
|
|
aLayers[aCount++] = LAYER_PAD_FR_NETNAMES;
|
2013-07-16 11:40:53 +00:00
|
|
|
}
|
2014-06-24 16:17:18 +00:00
|
|
|
else if( IsOnLayer( B_Cu ) )
|
2013-07-16 11:40:53 +00:00
|
|
|
{
|
2017-03-13 03:19:33 +00:00
|
|
|
aLayers[aCount++] = LAYER_PAD_BK;
|
2019-05-27 15:23:40 +00:00
|
|
|
|
|
|
|
// Is this a PTH pad that has only back copper? If so, we need to also display the
|
|
|
|
// net name on the PTH netname layer so that it isn't blocked by the drill hole.
|
|
|
|
if( m_Attribute == PAD_ATTRIB_STANDARD )
|
|
|
|
aLayers[aCount++] = LAYER_PADS_NETNAMES;
|
|
|
|
else
|
|
|
|
aLayers[aCount++] = LAYER_PAD_BK_NETNAMES;
|
2014-03-08 19:07:35 +00:00
|
|
|
}
|
2020-05-02 17:10:22 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// Internal layers only. (Not yet supported in GUI, but is being used by Python
|
|
|
|
// footprint generators and will be needed anyway once pad stacks are supported.)
|
|
|
|
for ( int internal = In1_Cu; internal < In30_Cu; ++internal )
|
|
|
|
{
|
|
|
|
if( IsOnLayer( (PCB_LAYER_ID) internal ) )
|
|
|
|
aLayers[aCount++] = internal;
|
|
|
|
}
|
|
|
|
}
|
2014-03-08 19:07:35 +00:00
|
|
|
|
2015-05-26 14:33:46 +00:00
|
|
|
// Check non-copper layers. This list should include all the layers that the
|
|
|
|
// footprint editor allows a pad to be placed on.
|
2017-03-13 03:19:33 +00:00
|
|
|
static const PCB_LAYER_ID layers_mech[] = { F_Mask, B_Mask, F_Paste, B_Paste,
|
2015-05-26 14:33:46 +00:00
|
|
|
F_Adhes, B_Adhes, F_SilkS, B_SilkS, Dwgs_User, Eco1_User, Eco2_User };
|
2014-03-08 19:07:35 +00:00
|
|
|
|
2017-03-13 03:19:33 +00:00
|
|
|
for( PCB_LAYER_ID each_layer : layers_mech )
|
2015-05-26 14:33:46 +00:00
|
|
|
{
|
|
|
|
if( IsOnLayer( each_layer ) )
|
|
|
|
aLayers[aCount++] = each_layer;
|
|
|
|
}
|
2014-03-08 19:07:35 +00:00
|
|
|
|
2013-06-21 10:02:17 +00:00
|
|
|
#ifdef __WXDEBUG__
|
2014-03-08 19:07:35 +00:00
|
|
|
if( aCount == 0 ) // Should not occur
|
2013-07-16 11:40:53 +00:00
|
|
|
{
|
2015-05-26 14:33:46 +00:00
|
|
|
wxString msg;
|
|
|
|
msg.Printf( wxT( "footprint %s, pad %s: could not find valid layer for pad" ),
|
2015-10-01 14:03:20 +00:00
|
|
|
GetParent() ? GetParent()->GetReference() : "<null>",
|
2017-08-11 09:22:13 +00:00
|
|
|
GetName().IsEmpty() ? "(unnamed)" : GetName() );
|
2015-05-26 14:33:46 +00:00
|
|
|
wxLogWarning( msg );
|
2013-07-16 11:40:53 +00:00
|
|
|
}
|
2013-06-21 10:02:17 +00:00
|
|
|
#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
|
|
|
{
|
2018-12-22 12:44:49 +00:00
|
|
|
if( aView->GetPrintMode() > 0 ) // In printing mode the pad is always drawable
|
|
|
|
return 0;
|
|
|
|
|
2018-02-17 18:03:22 +00:00
|
|
|
const int HIDE = std::numeric_limits<unsigned int>::max();
|
2018-02-17 22:53:44 +00:00
|
|
|
BOARD* board = GetBoard();
|
2018-02-17 18:03:22 +00:00
|
|
|
|
|
|
|
// Handle Render tab switches
|
|
|
|
if( ( GetAttribute() == PAD_ATTRIB_STANDARD || GetAttribute() == PAD_ATTRIB_HOLE_NOT_PLATED )
|
|
|
|
&& !aView->IsLayerVisible( LAYER_PADS_TH ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
if( !IsFlipped() && !aView->IsLayerVisible( LAYER_MOD_FR ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
if( IsFlipped() && !aView->IsLayerVisible( LAYER_MOD_BK ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
if( IsFrontLayer( ( PCB_LAYER_ID )aLayer ) && !aView->IsLayerVisible( LAYER_PAD_FR ) )
|
|
|
|
return HIDE;
|
|
|
|
|
|
|
|
if( IsBackLayer( ( PCB_LAYER_ID )aLayer ) && !aView->IsLayerVisible( LAYER_PAD_BK ) )
|
|
|
|
return HIDE;
|
|
|
|
|
2018-02-17 22:53:44 +00:00
|
|
|
// Only draw the pad if at least one of the layers it crosses is being displayed
|
|
|
|
if( board && !( board->GetVisibleLayers() & GetLayerSet() ).any() )
|
|
|
|
return HIDE;
|
|
|
|
|
2014-07-09 09:22:42 +00:00
|
|
|
// Netnames will be shown only if zoom is appropriate
|
2013-07-16 11:40:53 +00:00
|
|
|
if( IsNetnameLayer( aLayer ) )
|
2013-07-08 09:30:50 +00:00
|
|
|
{
|
2017-02-11 08:18:02 +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 )
|
2018-02-17 18:03:22 +00:00
|
|
|
return HIDE;
|
2014-07-27 19:00:39 +00:00
|
|
|
|
2018-11-03 13:30:34 +00:00
|
|
|
return ( Millimeter2iu( 10 ) / 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
|
2013-07-31 12:51:20 +00:00
|
|
|
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
|
|
|
|
2013-07-31 12:51:20 +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
|
|
|
}
|
2016-12-31 11:56:00 +00:00
|
|
|
|
|
|
|
|
2019-06-13 13:34:38 +00:00
|
|
|
void D_PAD::ImportSettingsFrom( const D_PAD& aMasterPad )
|
2017-02-10 19:44:02 +00:00
|
|
|
{
|
|
|
|
SetShape( aMasterPad.GetShape() );
|
|
|
|
SetLayerSet( aMasterPad.GetLayerSet() );
|
|
|
|
SetAttribute( aMasterPad.GetAttribute() );
|
2019-12-11 10:36:45 +00:00
|
|
|
SetProperty( aMasterPad.GetProperty() );
|
2017-02-10 19:44:02 +00:00
|
|
|
|
|
|
|
// 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() );
|
2019-03-12 10:28:07 +00:00
|
|
|
SetChamferRectRatio( aMasterPad.GetChamferRectRatio() );
|
|
|
|
SetChamferPositions( aMasterPad.GetChamferPositions() );
|
2017-02-10 19:44:02 +00:00
|
|
|
|
|
|
|
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:
|
|
|
|
;
|
|
|
|
}
|
2017-01-13 17:51:22 +00:00
|
|
|
|
2018-07-05 16:14:19 +00:00
|
|
|
// copy also local settings:
|
|
|
|
SetLocalClearance( aMasterPad.GetLocalClearance() );
|
|
|
|
SetLocalSolderMaskMargin( aMasterPad.GetLocalSolderMaskMargin() );
|
|
|
|
SetLocalSolderPasteMargin( aMasterPad.GetLocalSolderPasteMargin() );
|
|
|
|
SetLocalSolderPasteMarginRatio( aMasterPad.GetLocalSolderPasteMarginRatio() );
|
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
SetZoneConnection( aMasterPad.GetEffectiveZoneConnection() );
|
2018-07-05 16:14:19 +00:00
|
|
|
SetThermalWidth( aMasterPad.GetThermalWidth() );
|
|
|
|
SetThermalGap( aMasterPad.GetThermalGap() );
|
|
|
|
|
2017-01-13 17:51:22 +00:00
|
|
|
// Add or remove custom pad shapes:
|
2017-09-20 08:28:52 +00:00
|
|
|
SetPrimitives( aMasterPad.GetPrimitives() );
|
2017-01-13 17:51:22 +00:00
|
|
|
SetAnchorPadShape( aMasterPad.GetAnchorPadShape() );
|
2020-06-22 19:35:09 +00:00
|
|
|
|
|
|
|
m_shapesDirty = true;
|
2017-02-10 19:44:02 +00:00
|
|
|
}
|
2017-10-31 13:59:03 +00:00
|
|
|
|
2020-06-22 19:35:09 +00:00
|
|
|
|
2017-10-31 13:59:03 +00:00
|
|
|
void D_PAD::SwapData( BOARD_ITEM* aImage )
|
|
|
|
{
|
|
|
|
assert( aImage->Type() == PCB_PAD_T );
|
|
|
|
|
|
|
|
std::swap( *((MODULE*) this), *((MODULE*) aImage) );
|
|
|
|
}
|