2012-01-14 19:50:32 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2004 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
|
|
|
|
* Copyright (C) 1992-2011 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
|
|
|
|
*/
|
|
|
|
|
2011-09-17 15:31:21 +00:00
|
|
|
/**
|
|
|
|
* @file class_pad.h
|
|
|
|
* @brief Pad object description
|
|
|
|
*/
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
#ifndef PAD_H_
|
|
|
|
#define PAD_H_
|
2011-08-01 15:29:27 +00:00
|
|
|
|
|
|
|
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_board_item.h>
|
|
|
|
#include <class_board_connected_item.h>
|
|
|
|
#include <pad_shapes.h>
|
|
|
|
#include <PolyLine.h>
|
* 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
|
|
|
#include <config_params.h> // PARAM_CFG_ARRAY
|
2012-02-24 23:23:46 +00:00
|
|
|
#include "zones.h"
|
2011-09-17 15:31:21 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
|
2011-09-23 13:57:12 +00:00
|
|
|
class LINE_READER;
|
2011-09-17 15:31:21 +00:00
|
|
|
class EDA_3D_CANVAS;
|
2011-09-23 13:57:12 +00:00
|
|
|
class EDA_DRAW_PANEL;
|
|
|
|
class MODULE;
|
2011-11-30 11:45:49 +00:00
|
|
|
class TRACK;
|
2013-01-12 17:32:24 +00:00
|
|
|
class MSG_PANEL_INFO;
|
2011-09-17 15:31:21 +00:00
|
|
|
|
|
|
|
|
2011-07-14 15:42:44 +00:00
|
|
|
// Helper class to store parameters used to draw a pad
|
2010-09-11 16:33:43 +00:00
|
|
|
class PAD_DRAWINFO
|
|
|
|
{
|
|
|
|
public:
|
2011-09-17 15:31:21 +00:00
|
|
|
EDA_DRAW_PANEL* m_DrawPanel; // the EDA_DRAW_PANEL used to draw a PAD ; can be null
|
2012-09-01 13:38:27 +00:00
|
|
|
GR_DRAWMODE m_DrawMode; // the draw mode
|
2012-09-02 12:06:47 +00:00
|
|
|
EDA_COLOR_T m_Color; // color used to draw the pad shape , from pad layers and
|
2011-09-17 15:31:21 +00:00
|
|
|
// visible layers
|
2012-09-02 12:06:47 +00:00
|
|
|
EDA_COLOR_T m_HoleColor; // color used to draw the pad hole
|
|
|
|
EDA_COLOR_T m_NPHoleColor; // color used to draw a pad Not Plated hole
|
2011-09-17 15:31:21 +00:00
|
|
|
int m_PadClearance; // clearance value, used to draw the pad area outlines
|
|
|
|
wxSize m_Mask_margin; // margin, used to draw solder paste when only one layer is shown
|
|
|
|
bool m_Display_padnum; // true to show pad number
|
|
|
|
bool m_Display_netname; // true to show net name
|
|
|
|
bool m_ShowPadFilled; // true to show pad as solid area, false to show pas in
|
|
|
|
// sketch mode
|
|
|
|
bool m_ShowNCMark; // true to show pad not connected mark
|
|
|
|
bool m_ShowNotPlatedHole; // true when the pad hole in not plated, to draw a specific
|
|
|
|
// pad shape
|
|
|
|
bool m_IsPrinting; // true to print, false to display on screen.
|
|
|
|
wxPoint m_Offset; // general draw offset
|
|
|
|
|
|
|
|
PAD_DRAWINFO();
|
2010-09-11 16:33:43 +00:00
|
|
|
};
|
|
|
|
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2008-11-18 18:13:55 +00:00
|
|
|
class D_PAD : public BOARD_CONNECTED_ITEM
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2011-12-16 17:03:25 +00:00
|
|
|
public:
|
2012-02-19 04:02:19 +00:00
|
|
|
static int m_PadSketchModePenSize; ///< Pen size used to draw pads in sketch mode
|
|
|
|
///< (mode used to print pads on silkscreen layer)
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2007-06-05 12:10:51 +00:00
|
|
|
public:
|
2007-08-06 20:26:59 +00:00
|
|
|
D_PAD( MODULE* parent );
|
2012-01-14 19:50:32 +00:00
|
|
|
|
|
|
|
// Do not create a copy constructor. The one generated by the compiler is adequate.
|
2012-05-24 15:00:59 +00:00
|
|
|
// D_PAD( const D_PAD& o );
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
/* Default layers used for pads, according to the pad type.
|
|
|
|
* this is default values only, they can be changed for a given pad
|
|
|
|
*/
|
2014-07-02 13:08:28 +00:00
|
|
|
static LSET StandardMask(); ///< layer set for a through hole pad
|
|
|
|
static LSET SMDMask(); ///< layer set for a SMD pad on Front layer
|
|
|
|
static LSET ConnSMDMask(); ///< layer set for a SMD pad on Front layer
|
|
|
|
///< used for edge board connectors
|
|
|
|
static LSET UnplatedHoleMask(); ///< layer set for a mechanical unplated through hole pad
|
2014-06-24 16:17:18 +00:00
|
|
|
|
2009-03-23 19:54:15 +00:00
|
|
|
void Copy( D_PAD* source );
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2014-04-30 19:16:22 +00:00
|
|
|
D_PAD* Next() const { return static_cast<D_PAD*>( Pnext ); }
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
MODULE* GetParent() const { return (MODULE*) m_Parent; }
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2011-12-16 17:03:25 +00:00
|
|
|
void SetPadName( const wxString& name ); // Change pad name
|
|
|
|
const wxString GetPadName() const;
|
|
|
|
|
|
|
|
bool PadNameEqual( const D_PAD* other ) const
|
|
|
|
{
|
|
|
|
return m_NumPadName == other->m_NumPadName; // hide tricks behind sensible API
|
|
|
|
}
|
|
|
|
|
2008-12-14 19:45:05 +00:00
|
|
|
/**
|
|
|
|
* Function GetShape
|
|
|
|
* @return the shape of this pad.
|
|
|
|
*/
|
2014-01-26 14:20:58 +00:00
|
|
|
PAD_SHAPE_T GetShape() const { return m_padShape; }
|
|
|
|
void SetShape( PAD_SHAPE_T aShape ) { m_padShape = aShape; m_boundingRadius = -1; }
|
2008-12-14 19:45:05 +00:00
|
|
|
|
2012-02-20 04:33:54 +00:00
|
|
|
void SetPosition( const wxPoint& aPos ) { m_Pos = aPos; } // was overload
|
|
|
|
const wxPoint& GetPosition() const { return m_Pos; } // was overload
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
void SetY( int y ) { m_Pos.y = y; }
|
|
|
|
void SetX( int x ) { m_Pos.x = x; }
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2011-12-01 06:04:23 +00:00
|
|
|
void SetPos0( const wxPoint& aPos ) { m_Pos0 = aPos; }
|
2011-12-12 08:37:05 +00:00
|
|
|
const wxPoint& GetPos0() const { return m_Pos0; }
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
void SetY0( int y ) { m_Pos0.y = y; }
|
|
|
|
void SetX0( int x ) { m_Pos0.x = x; }
|
|
|
|
|
|
|
|
void SetSize( const wxSize& aSize ) { m_Size = aSize; m_boundingRadius = -1; }
|
2011-12-12 08:37:05 +00:00
|
|
|
const wxSize& GetSize() const { return m_Size; }
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
void SetDelta( const wxSize& aSize ) { m_DeltaSize = aSize; m_boundingRadius = -1; }
|
2011-12-12 08:37:05 +00:00
|
|
|
const wxSize& GetDelta() const { return m_DeltaSize; }
|
|
|
|
|
2011-12-01 06:04:23 +00:00
|
|
|
void SetDrillSize( const wxSize& aSize ) { m_Drill = aSize; }
|
2011-12-12 08:37:05 +00:00
|
|
|
const wxSize& GetDrillSize() const { return m_Drill; }
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
void SetOffset( const wxPoint& aOffset ) { m_Offset = aOffset; }
|
|
|
|
const wxPoint& GetOffset() const { return m_Offset; }
|
|
|
|
|
2014-02-13 17:27:48 +00:00
|
|
|
void Flip( const wxPoint& aCentre ); // Virtual function
|
2011-12-02 21:56:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function SetOrientation
|
|
|
|
* sets the rotation angle of the pad.
|
2012-02-19 04:02:19 +00:00
|
|
|
* @param aAngle is tenths of degrees, but will soon be degrees. If it is
|
|
|
|
* outside of 0 - 3600, then it will be normalized before being saved.
|
2011-12-02 21:56:47 +00:00
|
|
|
*/
|
2012-02-19 04:02:19 +00:00
|
|
|
void SetOrientation( double aAngle );
|
2011-12-02 21:56:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetOrientation
|
2012-04-01 20:51:56 +00:00
|
|
|
* returns the rotation angle of the pad in tenths of degrees, but soon degrees.
|
2011-12-02 21:56:47 +00:00
|
|
|
*/
|
2014-07-09 09:59:24 +00:00
|
|
|
double GetOrientation() const { return m_Orient; }
|
2011-12-02 21:56:47 +00:00
|
|
|
|
2014-01-26 14:20:58 +00:00
|
|
|
void SetDrillShape( PAD_DRILL_SHAPE_T aDrillShape )
|
|
|
|
{ m_drillShape = aDrillShape; }
|
|
|
|
PAD_DRILL_SHAPE_T GetDrillShape() const { return m_drillShape; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2014-05-17 19:29:15 +00:00
|
|
|
/**
|
|
|
|
* Function GetOblongDrillGeometry calculates the start point, end point and width
|
|
|
|
* of an equivalent segment which have the same position and width as the hole
|
|
|
|
* Usefull to plot/draw oblong holes like segments with rounded ends
|
|
|
|
* used in draw and plot functions
|
|
|
|
* @param aStartPoint = first point of the equivalent segment, relative to the pad position.
|
|
|
|
* @param aEndPoint = second point of the equivalent segment, relative to the pad position.
|
|
|
|
* @param aWidth = width equivalent segment.
|
|
|
|
*/
|
|
|
|
void GetOblongDrillGeometry( wxPoint& aStartPoint, wxPoint& aEndPoint, int& aWidth ) const;
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
void SetLayerSet( LSET aLayerMask ) { m_layerMask = aLayerMask; }
|
|
|
|
LSET GetLayerSet() const { return m_layerMask; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2013-02-13 01:01:22 +00:00
|
|
|
void SetAttribute( PAD_ATTR_T aAttribute );
|
2012-02-19 04:02:19 +00:00
|
|
|
PAD_ATTR_T GetAttribute() const { return m_Attribute; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2013-05-03 17:51:10 +00:00
|
|
|
void SetPadToDieLength( int aLength ) { m_LengthPadToDie = aLength; }
|
|
|
|
int GetPadToDieLength() const { return m_LengthPadToDie; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
int GetLocalSolderMaskMargin() const { return m_LocalSolderMaskMargin; }
|
2011-12-12 08:37:05 +00:00
|
|
|
void SetLocalSolderMaskMargin( int aMargin ) { m_LocalSolderMaskMargin = aMargin; }
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
int GetLocalClearance() const { return m_LocalClearance; }
|
|
|
|
void SetLocalClearance( int aClearance ) { m_LocalClearance = aClearance; }
|
2011-12-12 08:37:05 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
int GetLocalSolderPasteMargin() const { return m_LocalSolderPasteMargin; }
|
2011-12-12 08:37:05 +00:00
|
|
|
void SetLocalSolderPasteMargin( int aMargin ) { m_LocalSolderPasteMargin = aMargin; }
|
|
|
|
|
|
|
|
double GetLocalSolderPasteMarginRatio() const { return m_LocalSolderPasteMarginRatio; }
|
|
|
|
void SetLocalSolderPasteMarginRatio( double aRatio ) { m_LocalSolderPasteMarginRatio = aRatio; }
|
2011-12-01 06:04:23 +00:00
|
|
|
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function TransformShapeWithClearanceToPolygon
|
2009-11-14 19:47:52 +00:00
|
|
|
* Convert the pad shape to a closed polygon
|
|
|
|
* Used in filling zones calculations
|
|
|
|
* Circles and arcs are approximated by segments
|
|
|
|
* @param aCornerBuffer = a buffer to store the polygon
|
|
|
|
* @param aClearanceValue = the clearance around the pad
|
|
|
|
* @param aCircleToSegmentsCount = the number of segments to approximate a circle
|
|
|
|
* @param aCorrectionFactor = the correction to apply to circles radius to keep
|
2011-07-14 15:42:44 +00:00
|
|
|
* clearance when the circle is approximated by segment bigger or equal
|
2009-11-14 19:47:52 +00:00
|
|
|
* to the real clearance value (usually near from 1.0)
|
|
|
|
*/
|
2013-05-03 17:51:10 +00:00
|
|
|
void TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer,
|
2011-08-01 15:29:27 +00:00
|
|
|
int aClearanceValue,
|
|
|
|
int aCircleToSegmentsCount,
|
2015-01-17 08:01:16 +00:00
|
|
|
double aCorrectionFactor ) const;
|
2009-03-23 19:54:15 +00:00
|
|
|
|
2009-11-05 20:59:42 +00:00
|
|
|
/**
|
|
|
|
* Function GetClearance
|
2010-04-08 11:33:43 +00:00
|
|
|
* returns the clearance in internal units. If \a aItem is not NULL then the
|
|
|
|
* returned clearance is the greater of this object's clearance and
|
|
|
|
* aItem's clearance. If \a aItem is NULL, then this objects clearance
|
2009-11-05 20:59:42 +00:00
|
|
|
* is returned.
|
|
|
|
* @param aItem is another BOARD_CONNECTED_ITEM or NULL
|
2010-04-08 11:33:43 +00:00
|
|
|
* @return int - the clearance in internal units.
|
2009-11-05 20:59:42 +00:00
|
|
|
*/
|
2012-03-26 23:47:08 +00:00
|
|
|
int GetClearance( BOARD_CONNECTED_ITEM* aItem = NULL ) const;
|
2009-11-05 20:59:42 +00:00
|
|
|
|
|
|
|
// Mask margins handling:
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function GetSolderMaskMargin
|
2009-11-04 19:08:08 +00:00
|
|
|
* @return the margin for the solder mask layer
|
|
|
|
* usually > 0 (mask shape bigger than pad
|
|
|
|
* value is
|
|
|
|
* 1 - the local value
|
|
|
|
* 2 - if null, the parent footprint value
|
|
|
|
* 1 - if null, the global value
|
|
|
|
*/
|
2013-07-26 16:15:11 +00:00
|
|
|
int GetSolderMaskMargin() const;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function GetSolderPasteMargin
|
2009-11-04 19:08:08 +00:00
|
|
|
* @return the margin for the solder mask layer
|
|
|
|
* usually < 0 (mask shape smaller than pad
|
2009-11-12 15:43:38 +00:00
|
|
|
* because the margin can be dependent on the pad size, the margin has a x and a y value
|
2009-11-04 19:08:08 +00:00
|
|
|
* value is
|
|
|
|
* 1 - the local value
|
|
|
|
* 2 - if null, the parent footprint value
|
|
|
|
* 1 - if null, the global value
|
|
|
|
*/
|
2013-07-31 12:51:20 +00:00
|
|
|
wxSize GetSolderPasteMargin() const;
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2012-02-24 23:23:46 +00:00
|
|
|
void SetZoneConnection( ZoneConnection aType ) { m_ZoneConnection = aType; }
|
|
|
|
ZoneConnection GetZoneConnection() const;
|
|
|
|
|
2012-03-08 20:44:03 +00:00
|
|
|
void SetThermalWidth( int aWidth ) { m_ThermalWidth = aWidth; }
|
|
|
|
int GetThermalWidth() const;
|
|
|
|
|
|
|
|
void SetThermalGap( int aGap ) { m_ThermalGap = aGap; }
|
|
|
|
int GetThermalGap() const;
|
|
|
|
|
2007-08-06 20:26:59 +00:00
|
|
|
/* drawing functions */
|
2011-09-17 15:31:21 +00:00
|
|
|
void Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC,
|
2012-09-01 13:38:27 +00:00
|
|
|
GR_DRAWMODE aDrawMode, const wxPoint& aOffset = ZeroOffset );
|
2008-04-01 05:21:50 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function DrawShape
|
2010-09-11 16:33:43 +00:00
|
|
|
* basic function to draw a pad.
|
2011-10-17 20:01:27 +00:00
|
|
|
* <p>
|
|
|
|
* This function is used by Draw after calculation of parameters (color, ) final
|
|
|
|
* orientation transforms are set. It can also be called to draw a pad on any panel
|
|
|
|
* even if this panel is not a EDA_DRAW_PANEL for instance on a wxPanel inside the
|
|
|
|
* pad editor.
|
|
|
|
* </p>
|
2010-09-11 16:33:43 +00:00
|
|
|
*/
|
2011-09-17 15:31:21 +00:00
|
|
|
void DrawShape( EDA_RECT* aClipBox, wxDC* aDC, PAD_DRAWINFO& aDrawInfo );
|
2010-09-11 16:33:43 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function BuildPadPolygon
|
2010-09-20 16:21:47 +00:00
|
|
|
* Has meaning only for polygonal pads (trapezoid and rectangular)
|
2010-09-11 16:33:43 +00:00
|
|
|
* Build the Corner list of the polygonal shape,
|
|
|
|
* depending on shape, extra size (clearance ...) and orientation
|
2010-12-29 17:47:32 +00:00
|
|
|
* @param aCoord = a buffer to fill (4 corners).
|
2011-08-01 15:29:27 +00:00
|
|
|
* @param aInflateValue = wxSize: the clearance or margin value. value > 0:
|
|
|
|
* inflate, < 0 deflate
|
2010-09-11 16:33:43 +00:00
|
|
|
* @param aRotation = full rotation of the polygon
|
|
|
|
*/
|
2013-05-05 07:17:48 +00:00
|
|
|
void BuildPadPolygon( wxPoint aCoord[4], wxSize aInflateValue, double aRotation ) const;
|
2010-09-20 16:21:47 +00:00
|
|
|
|
2013-05-01 19:01:14 +00:00
|
|
|
/**
|
|
|
|
* Function BuildPadShapePolygon
|
|
|
|
* Build the Corner list of the polygonal shape,
|
|
|
|
* depending on shape, extra size (clearance ...) pad and orientation
|
|
|
|
* This function is similar to TransformShapeWithClearanceToPolygon,
|
|
|
|
* but the difference is BuildPadShapePolygon creates a polygon shape exactly
|
|
|
|
* similar to pad shape, which a size inflated by aInflateValue
|
|
|
|
* and TransformShapeWithClearanceToPolygon creates a more complex shape (for instance
|
|
|
|
* a rectangular pad is converted in a rectangulr shape with ronded corners)
|
|
|
|
* @param aCornerBuffer = a buffer to fill.
|
|
|
|
* @param aInflateValue = the clearance or margin value.
|
|
|
|
* value > 0: inflate, < 0 deflate, = 0 : no change
|
|
|
|
* the clearance can have different values for x and y directions
|
|
|
|
* (relative to the pad)
|
|
|
|
* @param aSegmentsPerCircle = number of segments to approximate a circle
|
|
|
|
* (used for round and oblong shapes only (16 to 32 is a good value)
|
|
|
|
* @param aCorrectionFactor = the correction to apply to circles radius to keep
|
|
|
|
* the pad size when the circle is approximated by segments
|
|
|
|
*/
|
2013-05-03 17:51:10 +00:00
|
|
|
void BuildPadShapePolygon( CPOLYGONS_LIST& aCornerBuffer,
|
2013-05-01 19:01:14 +00:00
|
|
|
wxSize aInflateValue, int aSegmentsPerCircle,
|
|
|
|
double aCorrectionFactor ) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function BuildPadDrillShapePolygon
|
|
|
|
* Build the Corner list of the polygonal drill shape,
|
|
|
|
* depending on shape pad hole and orientation
|
|
|
|
* @param aCornerBuffer = a buffer to fill.
|
|
|
|
* @param aInflateValue = the clearance or margin value.
|
|
|
|
* value > 0: inflate, < 0 deflate, = 0 : no change
|
|
|
|
* @param aSegmentsPerCircle = number of segments to approximate a circle
|
|
|
|
* (used for round and oblong shapes only(16 to 32 is a good value)
|
|
|
|
* @return false if the pad has no hole, true otherwise
|
|
|
|
*/
|
2013-05-03 17:51:10 +00:00
|
|
|
bool BuildPadDrillShapePolygon( CPOLYGONS_LIST& aCornerBuffer,
|
2013-05-01 19:01:14 +00:00
|
|
|
int aInflateValue, int aSegmentsPerCircle ) const;
|
2010-09-20 16:21:47 +00:00
|
|
|
|
2010-11-12 15:17:10 +00:00
|
|
|
/**
|
|
|
|
* Function BuildSegmentFromOvalShape
|
2010-09-20 16:21:47 +00:00
|
|
|
* Has meaning only for OVAL (and ROUND) pads
|
|
|
|
* Build an equivalent segment having the same shape as the OVAL shape,
|
|
|
|
* Useful in draw function and in DRC and HitTest functions,
|
|
|
|
* because segments are already well handled by track tests
|
2011-08-01 15:29:27 +00:00
|
|
|
* @param aSegStart = the starting point of the equivalent segment relative to the shape
|
|
|
|
* position.
|
2010-09-20 16:21:47 +00:00
|
|
|
* @param aSegEnd = the ending point of the equivalent segment, relative to the shape position
|
|
|
|
* @param aRotation = full rotation of the segment
|
2013-06-27 19:12:01 +00:00
|
|
|
* @param aRotation = full rotation of the segment
|
|
|
|
* @param aMargin = a margin around the shape (for instance mask margin)
|
2010-09-20 16:21:47 +00:00
|
|
|
* @return the width of the segment
|
|
|
|
*/
|
2013-06-27 19:12:01 +00:00
|
|
|
int BuildSegmentFromOvalShape( wxPoint& aSegStart, wxPoint& aSegEnd,
|
|
|
|
double aRotation, const wxSize& aMargin ) const;
|
2010-09-11 16:33:43 +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
|
|
|
void StringPadName( wxString& text ) const; // Return pad name as string in a buffer
|
2010-12-10 19:47:44 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
/**
|
|
|
|
* Function GetBoundingRadius
|
|
|
|
* returns the radius of a minimum sized circle which fully encloses this pad.
|
|
|
|
*/
|
2014-05-04 17:08:36 +00:00
|
|
|
int GetBoundingRadius() const
|
2012-02-19 04:02:19 +00:00
|
|
|
{
|
|
|
|
// Any member function which would affect this calculation should set
|
|
|
|
// m_boundingRadius to -1 to re-trigger the calculation from here.
|
2014-01-26 14:20:58 +00:00
|
|
|
// Currently that is only m_Size, m_DeltaSize, and m_padShape accessors.
|
2012-02-19 04:02:19 +00:00
|
|
|
if( m_boundingRadius == -1 )
|
|
|
|
{
|
|
|
|
m_boundingRadius = boundingRadius();
|
|
|
|
}
|
2012-03-15 14:31:16 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
return m_boundingRadius;
|
|
|
|
}
|
2010-12-10 19:47: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
|
|
|
const wxPoint ShapePos() const;
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2007-10-13 06:18:44 +00:00
|
|
|
/**
|
2012-02-19 04:02:19 +00:00
|
|
|
* Function GetSubRatsnest
|
2007-10-13 06:18:44 +00:00
|
|
|
* @return int - the netcode
|
|
|
|
*/
|
2014-06-24 16:17:18 +00:00
|
|
|
int GetSubRatsnest() const { return m_SubRatsnest; }
|
|
|
|
void SetSubRatsnest( int aSubRatsnest ) { m_SubRatsnest = aSubRatsnest; }
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2013-01-12 17:32:24 +00:00
|
|
|
void GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList );
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
bool IsOnLayer( LAYER_ID aLayer ) const
|
|
|
|
{
|
|
|
|
return m_layerMask[aLayer];
|
|
|
|
}
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2014-05-04 17:08:36 +00:00
|
|
|
bool HitTest( const wxPoint& aPosition ) const;
|
2007-08-30 08:15:05 +00:00
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
wxString GetClass() const
|
2007-08-07 06:21:19 +00:00
|
|
|
{
|
|
|
|
return wxT( "PAD" );
|
|
|
|
}
|
2008-01-28 18:44:14 +00:00
|
|
|
|
2013-11-24 17:48:14 +00:00
|
|
|
// Virtual function:
|
|
|
|
const EDA_RECT GetBoundingBox() const;
|
2008-04-18 13:28:56 +00:00
|
|
|
|
2014-07-09 09:59:24 +00:00
|
|
|
///> Set absolute coordinates.
|
|
|
|
void SetDrawCoord();
|
|
|
|
|
|
|
|
///> Set relative coordinates.
|
|
|
|
void SetLocalCoord();
|
|
|
|
|
2008-01-24 21:50:12 +00:00
|
|
|
/**
|
|
|
|
* Function Compare
|
|
|
|
* compares two pads and return 0 if they are equal.
|
|
|
|
* @return int - <0 if left less than right, 0 if equal, >0 if left greater than right.
|
|
|
|
*/
|
2008-01-28 18:44:14 +00:00
|
|
|
static int Compare( const D_PAD* padref, const D_PAD* padcmp );
|
2008-01-24 21:50:12 +00:00
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
void Move( const wxPoint& aMoveVector )
|
2009-08-01 19:26:05 +00:00
|
|
|
{
|
2011-11-24 17:32:51 +00:00
|
|
|
m_Pos += aMoveVector;
|
2014-07-09 09:59:24 +00:00
|
|
|
SetLocalCoord();
|
2009-08-01 19:26:05 +00:00
|
|
|
}
|
2007-08-07 06:21:19 +00:00
|
|
|
|
2014-07-09 11:50:27 +00:00
|
|
|
void Rotate( const wxPoint& aRotCentre, double aAngle );
|
2009-11-04 19:08:08 +00:00
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
wxString GetSelectMenuText() const;
|
2011-07-14 15:42:44 +00:00
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
BITMAP_DEF GetMenuImage() const { return pad_xpm; }
|
2011-08-01 15:29:27 +00:00
|
|
|
|
2011-07-14 19:41:20 +00:00
|
|
|
/**
|
|
|
|
* Function ShowPadShape
|
|
|
|
* @return the name of the shape
|
|
|
|
*/
|
|
|
|
wxString ShowPadShape() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function ShowPadAttr
|
|
|
|
* @return the name of the pad type (attribute) : STD, SMD ...
|
|
|
|
*/
|
|
|
|
wxString ShowPadAttr() const;
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
/**
|
|
|
|
* Function AppendConfigs
|
|
|
|
* appends to @a aResult the configuration setting accessors which will later
|
|
|
|
* allow reading or writing of configuration file information directly into
|
|
|
|
* this object.
|
|
|
|
*/
|
|
|
|
void AppendConfigs( PARAM_CFG_ARRAY* aResult );
|
|
|
|
|
2012-03-26 23:47:08 +00:00
|
|
|
EDA_ITEM* Clone() const;
|
2012-03-17 14:39:27 +00:00
|
|
|
|
2014-07-02 13:08:28 +00:00
|
|
|
/**
|
|
|
|
* same as Clone, but returns a D_PAD item.
|
|
|
|
* Useful mainly for pythons scripts, because Clone (virtual function)
|
|
|
|
* returns an EDA_ITEM.
|
|
|
|
*/
|
|
|
|
D_PAD* Duplicate() const
|
|
|
|
{
|
|
|
|
return (D_PAD*) Clone();
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/// @copydoc VIEW_ITEM::ViewGetLayers()
|
|
|
|
virtual void ViewGetLayers( int aLayers[], int& aCount ) const;
|
|
|
|
|
2013-07-08 09:30:50 +00:00
|
|
|
/// @copydoc VIEW_ITEM::ViewGetLOD()
|
|
|
|
virtual unsigned int ViewGetLOD( int aLayer ) const;
|
|
|
|
|
2013-07-26 16:15:11 +00:00
|
|
|
/// @copydoc VIEW_ITEM::ViewBBox()
|
|
|
|
virtual const BOX2I ViewBBox() const;
|
|
|
|
|
2013-04-25 16:29:35 +00:00
|
|
|
/**
|
|
|
|
* Function CopyNetlistSettings
|
|
|
|
* copies the netlist settings to \a aPad.
|
|
|
|
*
|
|
|
|
* The netlist settings are all of the #D_PAD settings not define by a #D_PAD in
|
|
|
|
* a netlist. These setting include local clearances, net names, etc. The pad
|
|
|
|
* physical geometry settings are not copied.
|
|
|
|
*
|
|
|
|
* @param aPad is the #D_PAD to copy the settings to.
|
|
|
|
*/
|
|
|
|
void CopyNetlistSettings( D_PAD* aPad );
|
|
|
|
|
2009-03-23 19:54:15 +00:00
|
|
|
#if defined(DEBUG)
|
2013-05-05 10:23:18 +00:00
|
|
|
virtual void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); } // override
|
2007-08-07 06:21:19 +00:00
|
|
|
#endif
|
2012-01-14 19:50:32 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
|
2012-01-14 19:50:32 +00:00
|
|
|
private:
|
2012-02-19 04:02:19 +00:00
|
|
|
/**
|
|
|
|
* Function boundingRadius
|
|
|
|
* returns a calculated radius of a bounding circle for this pad.
|
|
|
|
*/
|
|
|
|
int boundingRadius() const;
|
|
|
|
|
2014-05-04 17:08:36 +00:00
|
|
|
// Actually computed and cached on demand by the accessor
|
|
|
|
mutable int m_boundingRadius; ///< radius of the circle containing the pad shape
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
/// Pad name (4 char) or a long identifier (used in pad name
|
|
|
|
/// comparisons because this is faster than string comparison)
|
|
|
|
union
|
|
|
|
{
|
|
|
|
#define PADNAMEZ 4
|
|
|
|
char m_Padname[PADNAMEZ]; // zero padded at end to full size
|
|
|
|
wxUint32 m_NumPadName; // same number of bytes as m_Padname[]
|
|
|
|
};
|
|
|
|
|
|
|
|
wxPoint m_Pos; ///< pad Position on board
|
|
|
|
|
2014-01-26 14:20:58 +00:00
|
|
|
PAD_SHAPE_T m_padShape; ///< Shape: PAD_CIRCLE, PAD_RECT, PAD_OVAL, PAD_TRAPEZOID
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
|
|
|
|
int m_SubRatsnest; ///< variable used in rats nest computations
|
|
|
|
///< handle subnet (block) number in ratsnest connection
|
|
|
|
|
|
|
|
wxSize m_Drill; ///< Drill diam (drill shape = PAD_CIRCLE) or drill size
|
|
|
|
///< (shape = OVAL) for drill shape = PAD_CIRCLE, drill
|
|
|
|
///< diam = m_Drill.x
|
|
|
|
|
|
|
|
wxSize m_Size; ///< X and Y size ( relative to orient 0)
|
|
|
|
|
2014-01-26 14:20:58 +00:00
|
|
|
PAD_DRILL_SHAPE_T m_drillShape; ///< PAD_DRILL_NONE, PAD_DRILL_CIRCLE, PAD_DRILL_OBLONG
|
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* m_Offset is useful only for oblong pads (it can be used for other
|
|
|
|
* shapes, but without any interest).
|
2012-03-17 02:11:44 +00:00
|
|
|
* This is the offset between the pad hole and the pad shape (you must
|
2012-02-19 04:02:19 +00:00
|
|
|
* understand here pad shape = copper area around the hole)
|
|
|
|
* Most of cases, the hole is the center of the shape (m_Offset = 0).
|
|
|
|
* But some board designers use oblong pads with a hole moved to one of the
|
|
|
|
* oblong pad shape ends.
|
|
|
|
* In all cases the pad position is the pad hole.
|
|
|
|
* The physical shape position (used to draw it for instance) is pad
|
|
|
|
* position (m_Pos) + m_Offset.
|
* 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
|
|
|
* D_PAD::ShapePos() returns the physical shape position according to
|
2012-02-19 04:02:19 +00:00
|
|
|
* the offset and the pad rotation.
|
|
|
|
*/
|
|
|
|
wxPoint m_Offset;
|
|
|
|
|
2014-06-24 16:17:18 +00:00
|
|
|
LSET m_layerMask; ///< Bitwise layer :1= copper layer, 15= cmp,
|
2012-02-19 04:02:19 +00:00
|
|
|
///< 2..14 = internal layers
|
|
|
|
///< 16 .. 31 = technical layers
|
|
|
|
|
|
|
|
wxSize m_DeltaSize; ///< delta on rectangular shapes
|
|
|
|
|
|
|
|
wxPoint m_Pos0; ///< Initial Pad position (i.e. pad position relative to the
|
|
|
|
///< module anchor, orientation 0)
|
|
|
|
|
|
|
|
PAD_ATTR_T m_Attribute; ///< NORMAL, PAD_SMD, PAD_CONN, PAD_HOLE_NOT_PLATED
|
|
|
|
double m_Orient; ///< in 1/10 degrees
|
|
|
|
|
2012-12-12 11:57:17 +00:00
|
|
|
int m_LengthPadToDie; ///< Length net from pad to die, inside the package
|
2012-02-19 04:02:19 +00:00
|
|
|
|
|
|
|
/// Local clearance. When null, the module default value is used.
|
|
|
|
/// when the module default value is null, the netclass value is used
|
|
|
|
/// Usually the local clearance is null
|
|
|
|
int m_LocalClearance;
|
|
|
|
|
|
|
|
// Local mask margins: when 0, the parent footprint design values are used
|
|
|
|
|
|
|
|
int m_LocalSolderMaskMargin; ///< Local solder mask margin
|
|
|
|
int m_LocalSolderPasteMargin; ///< Local solder paste margin absolute value
|
|
|
|
|
|
|
|
double m_LocalSolderPasteMarginRatio; ///< Local solder mask margin ratio value of pad size
|
|
|
|
///< The final margin is the sum of these 2 values
|
2012-02-24 23:23:46 +00:00
|
|
|
ZoneConnection m_ZoneConnection;
|
2012-05-24 15:00:59 +00:00
|
|
|
int m_ThermalWidth;
|
|
|
|
int m_ThermalGap;
|
2012-02-19 04:02:19 +00:00
|
|
|
};
|
2011-08-01 15:29:27 +00:00
|
|
|
|
2012-02-19 04:02:19 +00:00
|
|
|
#endif // PAD_H_
|