class_module.h 21.1 KB
Newer Older
1 2 3
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
4 5
 * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 1992-2013 KiCad Developers, see AUTHORS.txt for contributors.
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * 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
 */

25 26 27 28
/**
 * @file class_module.h
 * @brief Module description (excepted pads)
 */
29 30


Dick Hollenbeck's avatar
Dick Hollenbeck committed
31 32
#ifndef MODULE_H_
#define MODULE_H_
33 34


35 36 37
#include <dlist.h>
#include <layers_id_colors_and_visibility.h>       // ALL_LAYERS definition.
#include <class_board_item.h>
38
#include <fpid.h>
39

40
#include <class_text_mod.h>
41
#include <PolyLine.h>
42
#include "zones.h"
43

44
#include <boost/function.hpp>
45

46
class LINE_READER;
47 48
class EDA_3D_CANVAS;
class S3D_MASTER;
49 50 51
class EDA_DRAW_PANEL;
class D_PAD;
class BOARD;
52
class MSG_PANEL_ITEM;
53 54


Dick Hollenbeck's avatar
Dick Hollenbeck committed
55 56 57 58
/**
 * Enum MODULE_ATTR_T
 * is the set of attributes allowed within a MODULE, using MODULE::SetAttributes()
 * and MODULE::GetAttributes().  These are to be ORed together when calling
59
 * MODULE::SetAttributes()
Dick Hollenbeck's avatar
Dick Hollenbeck committed
60 61
 */
enum MODULE_ATTR_T
62
{
Dick Hollenbeck's avatar
Dick Hollenbeck committed
63
    MOD_DEFAULT = 0,    ///< default
64
    MOD_CMS     = 1,    ///< Set for modules listed in the automatic insertion list
Dick Hollenbeck's avatar
Dick Hollenbeck committed
65 66 67
                        ///< (usually SMD footprints)
    MOD_VIRTUAL = 2     ///< Virtual component: when created by copper shapes on
                        ///<  board (Like edge card connectors, mounting hole...)
68
};
69

70

71
class MODULE : public BOARD_ITEM
72 73
{
public:
74
    MODULE( BOARD* parent );
75 76 77

    MODULE( const MODULE& aModule );

78
    ~MODULE();
79

80 81
    MODULE* Next() const { return (MODULE*) Pnext; }
    MODULE* Back() const { return (MODULE*) Pback; }
82

83
    void Copy( MODULE* Module );        // Copy structure
84

85
    /*
86 87 88 89
     * Function Add
     * adds the given item to this MODULE and takes ownership of its memory.
     * @param aBoardItem The item to add to this board.
     * @param doInsert If true, then insert, else append
90
     *  void    Add( BOARD_ITEM* aBoardItem, bool doInsert = true );
91 92 93
     */

    /**
94
     * Function CalculateBoundingBox
95
     * calculates the bounding box in board coordinates.
96
     */
97
    void CalculateBoundingBox();
98

99
    /**
100
     * Function GetFootprintRect()
101
     * Returns the area of the module footprint excluding any text.
102
     * @return EDA_RECT - The rectangle containing the footprint.
103
     */
104
    EDA_RECT GetFootprintRect() const;
105

106 107
    // Virtual function
    const EDA_RECT GetBoundingBox() const;
108

109 110 111 112 113 114 115 116 117
    DLIST<D_PAD>& Pads()                        { return m_Pads; }
    const DLIST<D_PAD>& Pads() const            { return m_Pads; }

    DLIST<BOARD_ITEM>& GraphicalItems()         { return m_Drawings; }
    const DLIST<BOARD_ITEM>& GraphicalItems() const { return m_Drawings; }

    DLIST<S3D_MASTER>& Models()                 { return m_3D_Drawings; }
    const DLIST<S3D_MASTER>& Models() const     { return m_3D_Drawings; }

Dick Hollenbeck's avatar
Dick Hollenbeck committed
118 119
    void SetPosition( const wxPoint& aPos );                        // was overload
    const wxPoint& GetPosition() const          { return m_Pos; }   // was overload
120

Dick Hollenbeck's avatar
Dick Hollenbeck committed
121 122
    void SetOrientation( double newangle );
    double GetOrientation() const { return m_Orient; }
123

124 125
    const FPID& GetFPID() const { return m_fpid; }
    void SetFPID( const FPID& aFPID ) { m_fpid = aFPID; }
Dick Hollenbeck's avatar
Dick Hollenbeck committed
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147

    const wxString& GetDescription() const { return m_Doc; }
    void SetDescription( const wxString& aDoc ) { m_Doc = aDoc; }

    const wxString& GetKeywords() const { return m_KeyWord; }
    void SetKeywords( const wxString& aKeywords ) { m_KeyWord = aKeywords; }

    const wxString& GetPath() const { return m_Path; }
    void SetPath( const wxString& aPath ) { m_Path = aPath; }

    int GetLocalSolderMaskMargin() const { return m_LocalSolderMaskMargin; }
    void SetLocalSolderMaskMargin( int aMargin ) { m_LocalSolderMaskMargin = aMargin; }

    int GetLocalClearance() const { return m_LocalClearance; }
    void SetLocalClearance( int aClearance ) { m_LocalClearance = aClearance; }

    int GetLocalSolderPasteMargin() const { return m_LocalSolderPasteMargin; }
    void SetLocalSolderPasteMargin( int aMargin ) { m_LocalSolderPasteMargin = aMargin; }

    double GetLocalSolderPasteMarginRatio() const { return m_LocalSolderPasteMarginRatio; }
    void SetLocalSolderPasteMarginRatio( double aRatio ) { m_LocalSolderPasteMarginRatio = aRatio; }

148 149 150
    void SetZoneConnection( ZoneConnection aType ) { m_ZoneConnection = aType; }
    ZoneConnection GetZoneConnection() const { return m_ZoneConnection; }

151 152 153 154 155 156
    void SetThermalWidth( int aWidth ) { m_ThermalWidth = aWidth; }
    int GetThermalWidth() const { return m_ThermalWidth; }

    void SetThermalGap( int aGap ) { m_ThermalGap = aGap; }
    int GetThermalGap() const { return m_ThermalGap; }

Dick Hollenbeck's avatar
Dick Hollenbeck committed
157 158 159
    int GetAttributes() const { return m_Attributs; }
    void SetAttributes( int aAttributes ) { m_Attributs = aAttributes; }

160 161 162 163
    void SetFlag( int aFlag ) { flag = aFlag; }
    void IncrementFlag() { flag += 1; }
    int GetFlag() const { return flag; }

164
    void Move( const wxPoint& aMoveVector );
165

166
    void Rotate( const wxPoint& aRotCentre, double aAngle );
167

168
    void Flip( const wxPoint& aCentre );
169

170 171 172 173 174 175 176 177 178 179 180 181 182
    /**
     * Function MoveAnchorPosition
     * Move the reference point of the footprint
     * It looks like a move footprint:
     * the footprints elements (pads, outlines, edges .. ) are moved
     * However:
     * - the footprint position is not modified.
     * - the relative (local) coordinates of these items are modified
     * (a move footprint does not change these local coordinates,
     * but changes the footprint position)
     */
    void MoveAnchorPosition( const wxPoint& aMoveVector );

183 184 185 186 187 188
    /**
     * function IsFlipped
     * @return true if the module is flipped, i.e. on the back side of the board
     */
    bool IsFlipped() const {return GetLayer() == LAYER_N_BACK; }

189 190 191 192 193 194
// m_ModuleStatus bits:
#define MODULE_is_LOCKED    0x01        ///< module LOCKED: no autoplace allowed
#define MODULE_is_PLACED    0x02        ///< In autoplace: module automatically placed
#define MODULE_to_PLACE     0x04        ///< In autoplace: module waiting for autoplace


195
    bool IsLocked() const
196 197 198 199 200 201 202
    {
        return (m_ModuleStatus & MODULE_is_LOCKED) != 0;
    }

    /**
     * Function SetLocked
     * sets the MODULE_is_LOCKED bit in the m_ModuleStatus
Dick Hollenbeck's avatar
Dick Hollenbeck committed
203
     * @param isLocked When true means turn on locked status, else unlock
204
     */
Dick Hollenbeck's avatar
Dick Hollenbeck committed
205
    void SetLocked( bool isLocked )
206
    {
Dick Hollenbeck's avatar
Dick Hollenbeck committed
207
        if( isLocked )
208 209 210 211 212
            m_ModuleStatus |= MODULE_is_LOCKED;
        else
            m_ModuleStatus &= ~MODULE_is_LOCKED;
    }

213 214 215 216 217 218 219 220 221
    bool IsPlaced() const   { return (m_ModuleStatus & MODULE_is_PLACED); }
    void SetIsPlaced( bool isPlaced )
    {
        if( isPlaced )
            m_ModuleStatus |= MODULE_is_PLACED;
        else
            m_ModuleStatus &= ~MODULE_is_PLACED;
    }

222 223 224 225 226 227 228 229 230 231 232 233
    bool NeedsPlaced() const  { return (m_ModuleStatus & MODULE_to_PLACE); }
    void SetNeedsPlaced( bool needsPlaced )
    {
        if( needsPlaced )
            m_ModuleStatus |= MODULE_to_PLACE;
        else
            m_ModuleStatus &= ~MODULE_to_PLACE;
    }

    void SetLastEditTime( time_t aTime ) { m_LastEditTime = aTime; }
    void SetLastEditTime( ) { m_LastEditTime = time( NULL ); }
    time_t GetLastEditTime() const { return m_LastEditTime; }
234

235
    /* drawing functions */
236

237 238 239 240 241 242 243 244
    /**
     * Function Draw
     * draws the footprint to the \a aDC.
     * @param aPanel = draw panel, Used to know the clip box
     * @param aDC = Current Device Context
     * @param aDrawMode = GR_OR, GR_XOR..
     * @param aOffset = draw offset (usually wxPoint(0,0)
     */
245 246
    void Draw( EDA_DRAW_PANEL* aPanel,
               wxDC*           aDC,
247
               GR_DRAWMODE     aDrawMode,
248
               const wxPoint&  aOffset = ZeroOffset );
dickelbeck's avatar
dickelbeck committed
249

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
    /**
     * function ReadandInsert3DComponentShape
     * read the 3D component shape(s) of the footprint (physical shape)
     * and insert mesh in gl list
     */
    void ReadAndInsert3DComponentShape( EDA_3D_CANVAS* glcanvas );

    /**
     * function TransformPadsShapesWithClearanceToPolygon
     * generate pads shapes on layer aLayer as polygons,
     * and adds these polygons to aCornerBuffer
     * Useful to generate a polygonal representation of a footprint
     * in 3D view and plot functions, when a full polygonal approach is needed
     * @param aLayer = the current layer: pads on this layer are considered
     * @param aCornerBuffer = the buffer to store polygons
     * @param aInflateValue = an additionnal size to add to pad shapes
     *          aInflateValue = 0 to have the exact pad size
     * @param aCircleToSegmentsCount = number of segments to generate a circle
     * @param aCorrectionFactor = the correction to apply to a circle radius
     *  to approximate a circle by the polygon.
     *  if aCorrectionFactor = 1.0, the polygon is inside the circle
     *  the radius of circle approximated by segments is
     *  initial radius * aCorrectionFactor
     */
    void TransformPadsShapesWithClearanceToPolygon( LAYER_NUM aLayer,
275 276 277 278
                            CPOLYGONS_LIST& aCornerBuffer,
                            int             aInflateValue,
                            int             aCircleToSegmentsCount,
                            double          aCorrectionFactor );
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298

    /**
     * function TransformGraphicShapesWithClearanceToPolygonSet
     * generate shapes of graphic items (outlines) on layer aLayer as polygons,
     * and adds these polygons to aCornerBuffer
     * Useful to generate a polygonal representation of a footprint
     * in 3D view and plot functions, when a full polygonal approach is needed
     * @param aLayer = the current layer: items on this layer are considered
     * @param aCornerBuffer = the buffer to store polygons
     * @param aInflateValue = a value to inflate shapes
     *          aInflateValue = 0 to have the exact shape size
     * @param aCircleToSegmentsCount = number of segments to generate a circle
     * @param aCorrectionFactor = the correction to apply to a circle radius
     *  to approximate a circle by the polygon.
     *  if aCorrectionFactor = 1.0, the polygon is inside the circle
     *  the radius of circle approximated by segments is
     *  initial radius * aCorrectionFactor
     */
    void TransformGraphicShapesWithClearanceToPolygonSet(
                            LAYER_NUM aLayer,
299 300 301 302
                            CPOLYGONS_LIST& aCornerBuffer,
                            int             aInflateValue,
                            int             aCircleToSegmentsCount,
                            double          aCorrectionFactor );
303

304

305 306 307 308 309 310 311 312
    /**
     * Function DrawEdgesOnly
     *  Draws the footprint edges only to the current Device Context
     *  @param panel = The active Draw Panel (used to know the clip box)
     *  @param DC = current Device Context
     *  @param offset = draw offset (usually wxPoint(0,0)
     *  @param draw_mode =  GR_OR, GR_XOR, GR_AND
     */
313 314
    void DrawEdgesOnly( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& offset,
                        GR_DRAWMODE draw_mode );
315

316
    void DrawAncre( EDA_DRAW_PANEL* panel, wxDC* DC,
317
                    const wxPoint& offset, int dim_ancre, GR_DRAWMODE draw_mode );
318

319
    void GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList );
320

321
    bool HitTest( const wxPoint& aPosition );
322

323 324 325 326
    /** @copydoc BOARD_ITEM::HitTest(const EDA_RECT& aRect,
     *                               bool aContained = true, int aAccuracy ) const
     */
    bool HitTest( const EDA_RECT& aRect, bool aContained = true, int aAccuracy = 0 ) const;
327

328
    /**
329
     * Function GetReference
330
     * @return const wxString& - the reference designator text.
331
     */
332
    const wxString& GetReference() const
333 334 335
    {
        return m_Reference->m_Text;
    }
336

337 338
    /**
     * Function SetReference
339 340
     * @param aReference A reference to a wxString object containing the reference designator
     *                   text.
341
     */
342
    void SetReference( const wxString& aReference )
343 344 345
    {
        m_Reference->m_Text = aReference;
    }
346

347 348 349 350 351 352 353 354
    /**
     * Function GetValue
     * @return const wxString& - the value text.
     */
    const wxString& GetValue()
    {
        return m_Value->m_Text;
    }
355

356 357
    /**
     * Function SetValue
358
     * @param aValue A reference to a wxString object containing the value text.
359 360 361 362 363
     */
    void SetValue( const wxString& aValue )
    {
        m_Value->m_Text = aValue;
    }
dickelbeck's avatar
dickelbeck committed
364

Dick Hollenbeck's avatar
Dick Hollenbeck committed
365 366 367 368
    /// read/write accessors:
    TEXTE_MODULE& Value()       { return *m_Value; }
    TEXTE_MODULE& Reference()   { return *m_Reference; }

369 370 371 372
    /// The const versions to keep the compiler happy.
    TEXTE_MODULE& Value() const       { return *m_Value; }
    TEXTE_MODULE& Reference() const   { return *m_Reference; }

Dick Hollenbeck's avatar
Dick Hollenbeck committed
373

dickelbeck's avatar
dickelbeck committed
374 375 376 377
    /**
     * Function FindPadByName
     * returns a D_PAD* with a matching name.  Note that names may not be
     * unique, depending on how the foot print was created.
378
     * @param aPadName the pad name to find
stambaughw's avatar
stambaughw committed
379 380
     * @return D_PAD* - The first matching name is returned, or NULL if not
     *                  found.
dickelbeck's avatar
dickelbeck committed
381
     */
382
    D_PAD* FindPadByName( const wxString& aPadName ) const;
dickelbeck's avatar
dickelbeck committed
383

384 385
    /**
     * Function GetPad
386
     * get a pad at \a aPosition on \a aLayerMask in the footprint.
387 388 389 390 391
     *
     * @param aPosition A wxPoint object containing the position to hit test.
     * @param aLayerMask A layer or layers to mask the hit test.
     * @return A pointer to a D_PAD object if found otherwise NULL.
     */
392
    D_PAD* GetPad( const wxPoint& aPosition, LAYER_MSK aLayerMask = ALL_LAYERS );
dickelbeck's avatar
dickelbeck committed
393

394 395 396 397 398 399
    enum INCLUDE_NPTH_T
    {
        DO_NOT_INCLUDE_NPTH = false,
        INCLUDE_NPTH = true
    };

400 401 402
    /**
     * GetPadCount
     * returns the number of pads.
403 404 405 406
     *
     * @param aIncludeNPTH includes non-plated through holes when true.  Does not include
     *                     non-plated through holes when false.
     * @return the number of pads according to \a aIncludeNPTH.
407
     */
408
    unsigned GetPadCount( INCLUDE_NPTH_T aIncludeNPTH = INCLUDE_NPTH ) const;
409

410 411 412 413 414 415 416 417 418 419 420
    double GetArea() const                  { return m_Surface; }

    time_t GetLink() const                  { return m_Link; }
    void SetLink( time_t aLink )            { m_Link = aLink; }

    int GetPlacementCost180() const         { return m_CntRot180; }
    void SetPlacementCost180( int aCost )   { m_CntRot180 = aCost; }

    int GetPlacementCost90() const          { return m_CntRot90; }
    void SetPlacementCost90( int aCost )    { m_CntRot90 = aCost; }

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
    /**
     * Function Add3DModel
     * adds \a a3DModel definition to the end of the 3D model list.
     *
     * @param a3DModel A pointer to a #S3D_MASTER to add to the list.
     */
    void Add3DModel( S3D_MASTER* a3DModel );

    /**
     * Function AddPad
     * adds \a aPad to the end of the pad list.
     *
     * @param aPad A pointer to a #D_PAD to add to the list.
     */
    void AddPad( D_PAD* aPad );

437 438 439
    SEARCH_RESULT Visit( INSPECTOR* inspector, const void* testData,
                         const KICAD_T scanTypes[] );

440
    wxString GetClass() const
441 442 443 444
    {
        return wxT( "MODULE" );
    }

445
    wxString GetSelectMenuText() const;
446

447
    BITMAP_DEF GetMenuImage() const { return  module_xpm; }
448

449
    EDA_ITEM* Clone() const;
450

451 452 453 454 455 456 457 458
    /**
     * Function RunOnChildren
     *
     * Invokes a function on all BOARD_ITEMs that belong to the module (pads, drawings, texts).
     * @param aFunction is the function to be invoked.
     */
    void RunOnChildren( boost::function<void (BOARD_ITEM*)> aFunction );

459 460 461
    /// @copydoc VIEW_ITEM::ViewUpdate()
    void ViewUpdate( int aUpdateFlags );

462 463 464 465 466 467 468 469 470 471 472 473 474
    /**
     * Function CopyNetlistSettings
     * copies the netlist settings to \a aModule.
     *
     * The netlist settings are all of the #MODULE settings not define by a #MODULE in
     * a netlist.  These setting include position, orientation, local clearances, ets.
     * The reference designator, value, path, and physical geometry settings are not
     * copied.
     *
     * @param aModule is the #MODULE to copy the settings to.
     */
    void CopyNetlistSettings( MODULE* aModule );

475 476 477 478 479 480 481 482 483 484 485 486 487
    /**
     * static function IsLibNameValid
     * Test for validity of a name of a footprint to be used in a footprint library
     * ( no spaces, dir separators ... )
     * @param aName = the name in library to validate
     * @return true if the given name is valid
     */
    static bool IsLibNameValid( const wxString & aName );

    /**
     * static function ReturnStringLibNameInvalidChars
     * Test for validity of the name in a library of the footprint
     * ( no spaces, dir separators ... )
Wayne Stambaugh's avatar
Wayne Stambaugh committed
488 489
     * @param aUserReadable = false to get the list of invalid chars
     *        true to get a readable form (i.e ' ' = 'space' '\\t'= 'tab')
490 491 492 493
     * @return a constant std::string giving the list of invalid chars in lib name
     */
    static const wxChar* ReturnStringLibNameInvalidChars( bool aUserReadable );

494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
    /**
     * Function SetInitialComments
     * takes ownership of caller's heap allocated aInitialComments block.  The comments
     * are single line strings already containing the s-expression comments with
     * optional leading whitespace and then a '#' character followed by optional
     * single line text (text with no line endings, not even one).
     * This block of single line comments will be output upfront of any generated
     * s-expression text in the PCBIO::Format() function.
     * <p>
     * Note that a block of single line comments constitutes a multiline block of
     * single line comments.  That is, the block is made of consecutive single line
     * comments.
     * @param aInitialComments is a heap allocated wxArrayString or NULL, which the caller
     *  gives up ownership of over to this MODULE.
     */
    void SetInitialComments( wxArrayString* aInitialComments )
    {
        delete m_initial_comments;
        m_initial_comments = aInitialComments;
    }

    /// Return the initial comments block or NULL if none, without transfer of ownership.
516
    const wxArrayString* GetInitialComments() const { return m_initial_comments; }
517

Dick Hollenbeck's avatar
Dick Hollenbeck committed
518
#if defined(DEBUG)
519
    virtual void Show( int nestLevel, std::ostream& os ) const { ShowDummy( os ); }    // override
520
#endif
521

522
private:
523 524 525
    DLIST<D_PAD>      m_Pads;           ///< Linked list of pads.
    DLIST<BOARD_ITEM> m_Drawings;       ///< Linked list of graphical items.
    DLIST<S3D_MASTER> m_3D_Drawings;    ///< Linked list of 3D models.
526 527 528 529
    double            m_Orient;         ///< Orientation in tenths of a degree, 900=90.0 degrees.
    wxPoint           m_Pos;            ///< Position of module on the board in internal units.
    TEXTE_MODULE*     m_Reference;      ///< Component reference designator value (U34, R18..)
    TEXTE_MODULE*     m_Value;          ///< Component value (74LS00, 22K..)
530
    FPID              m_fpid;           ///< The #FPID of the MODULE.
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
    int               m_Attributs;      ///< Flag bits ( see Mod_Attribut )
    int               m_ModuleStatus;   ///< For autoplace: flags (LOCKED, AUTOPLACED)
    EDA_RECT          m_BoundaryBox;    ///< Bounding box : coordinates on board, real orientation.

    // The final margin is the sum of these 2 values
    int               m_ThermalWidth;
    int               m_ThermalGap;
    wxString          m_Doc;            ///< File name and path for documentation file.
    wxString          m_KeyWord;        ///< Search keywords to find module in library.
    wxString          m_Path;
    ZoneConnection    m_ZoneConnection;
    time_t            m_LastEditTime;
    int               flag;             ///< Use to trace ratsnest and auto routing.
    double            m_Surface;        ///< Bounding box area
    time_t            m_Link;           ///< Temporary logical link used in edition
    int               m_CntRot90;       ///< Horizontal automatic placement cost ( 0..10 ).
    int               m_CntRot180;      ///< Vertical automatic placement cost ( 0..10 ).

549 550 551
    // Local tolerances. When zero, this means the corresponding netclass value
    // is used. Usually theses local tolerances zero, in deference to the
    // corresponding netclass values.
552 553 554 555
    int               m_LocalClearance;
    int               m_LocalSolderMaskMargin;    ///< Solder mask margin
    int               m_LocalSolderPasteMargin;   ///< Solder paste margin absolute value
    double            m_LocalSolderPasteMarginRatio;   ///< Solder mask margin ratio
556
                                                       ///< value of pad size
557 558 559

    wxArrayString*    m_initial_comments;   ///< leading s-expression comments in the module,
                                            ///< lazily allocated only if needed for speed
560
};
561

Dick Hollenbeck's avatar
Dick Hollenbeck committed
562
#endif     // MODULE_H_