* remove global g_Pad_Master global and put it into BOARD_DESIGN_SETTINGS

which is in turn already within BOARD.
  * encapsulate class D_PAD with accessors, making data private.
  * make D_PAD::GetBoundingRadius() do its longer calculation lazily, based on
    m_boundingRadius == -1.

CHANGELOG.txt

@@ -4,6 +4,16 @@ KiCad ChangeLog 2012
 Please add newer entries at the top, list the date and your name with
 email address.
 
+2012-Feb-19 UPDATE Dick Hollenbeck <dick@softplc.com>
+================================================================================
+++pcbnew
+  * remove global g_Pad_Master global and put it into BOARD_DESIGN_SETTINGS
+    which is in turn already within BOARD.
+  * encapsulate class D_PAD with accessors, making data private.
+  * make D_PAD::GetBoundingRadius() do its longer calculation lazily, based on
+    m_boundingRadius == -1.
+
+
 2012-Feb-5 UPDATE Dick Hollenbeck <dick@softplc.com>
 ================================================================================
 ++pcbnew

common/pcbcommon.cpp

@@ -108,4 +108,3 @@ int    g_PadCMPColor        = RED;
  */
 DLIST<TRACK> g_CurrentTrackList;
 
-D_PAD g_Pad_Master( (MODULE*) NULL );

common/trigo.cpp

@@ -273,19 +273,6 @@ void RotatePoint( int* pX, int* pY, int cx, int cy, double angle )
 }
 
 
-void RotatePoint( wxPoint* point, double angle )
-{
-    int ox, oy;
-
-    ox = point->x;
-    oy = point->y;
-
-    RotatePoint( &ox, &oy, angle );
-    point->x = ox;
-    point->y = oy;
-}
-
-
 void RotatePoint( wxPoint* point, const wxPoint& centre, double angle )
 {
     int ox, oy;

include/class_board_design_settings.h

@@ -6,8 +6,14 @@
 #define BOARD_DESIGN_SETTINGS_H_
 
 #include <pcbstruct.h>      // NB_COLORS
+#include <class_pad.h>
+#include <param_config.h>
 
-// Class for handle current printed board design settings
+
+/**
+ * Class BOARD_DESIGN_SETTINGS
+ * contains design settings for a BOARD object.
+ */
 class BOARD_DESIGN_SETTINGS
 {
 public:
@@ -38,6 +44,8 @@ public:
     int     m_ModuleTextWidth;
     int     m_ModuleSegmentWidth;
 
+    D_PAD   m_Pad_Master;
+
 public:
     BOARD_DESIGN_SETTINGS();
 
@@ -172,6 +180,13 @@ public:
      */
     void SetCopperLayerCount( int aNewLayerCount );
 
+    /**
+     * 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 );
 
 private:
     int     m_CopperLayerCount;     ///< Number of copper layers for this design

include/pad_shapes.h

@@ -5,25 +5,36 @@
 #ifndef PAD_SHAPES_H_
 #define PAD_SHAPES_H_
 
-/* Pad shape id : ( .m_PadShape member) */
+/**
-#define	PAD_NONE        0
+ * Enum PAD_SHAPE_T
-#define PAD_CIRCLE      1
+ * is the set of pad shapes, used with D_PAD::{Set,Get}Shape()
-#define PAD_ROUND       PAD_CIRCLE
+ */
-#define PAD_RECT        2
+enum PAD_SHAPE_T
-#define PAD_OVAL        3
+{
-#define PAD_TRAPEZOID   4       // trapezoid
+    PAD_NONE,
-#define PAD_RRECT       5
+    PAD_CIRCLE,
-#define PAD_OCTAGON     6
+    PAD_ROUND = PAD_CIRCLE,
-#define PAD_SQUARE      7
+    PAD_RECT,
+    PAD_OVAL,
+    PAD_TRAPEZOID,
+    PAD_RRECT,
+    PAD_OCTAGON,
+    PAD_SQUARE,
+};
 
 
-/* PADS attributes */
+/**
-#define PAD_STANDARD    0       // Usual pad
+ * Enum PAD_ATTR_T
-#define PAD_SMD         1       // Smd pad, appears on the solder paste layer (default)
+ * is the set of pad shapes, used with D_PAD::{Set,Get}Attribute()
-#define PAD_CONN        2       // Like smd, does not appear on the solder paste layer (default)
+ */
-#define PAD_HOLE_NOT_PLATED 3   // like PAD_STANDARD, but not plated
+enum PAD_ATTR_T
-                                // mechanical used only
+{
-                                // no connection allowed
+    PAD_STANDARD,           ///< Usual pad
+    PAD_SMD,                ///< Smd pad, appears on the solder paste layer (default)
+    PAD_CONN,               ///< Like smd, does not appear on the solder paste layer (default)
+    PAD_HOLE_NOT_PLATED,    ///< like PAD_STANDARD, but not plated
+                            ///< mechanical use only, no connection allowed
+};
 
 
-#endif  /* #ifndef PAD_SHAPES_H_ */
+#endif  // PAD_SHAPES_H_

include/pcbcommon.h

@@ -52,8 +52,5 @@ extern DLIST<TRACK> g_CurrentTrackList;
 
 #define g_FirstTrackSegment   g_CurrentTrackList.GetFirst()   ///< first segment created
 
-/// Pad editing
-extern D_PAD g_Pad_Master;
-
 
 #endif  // PCBCOMMON_H_

include/trigo.h

@@ -22,7 +22,10 @@ void RotatePoint( int *pX, int *pY, int cx, int cy, double angle );
  * Calculates the new coord point point
  * for a rotation angle in (1 / 10 degree)
  */
-void RotatePoint( wxPoint* point, double angle );
+static inline void RotatePoint( wxPoint* point, double angle )
+{
+    RotatePoint( &point->x, &point->y, angle );
+}
 
 /*
  * Calculates the new coord point point

pcbnew/autoplac.cpp

@@ -666,7 +666,7 @@ int PCB_EDIT_FRAME::GetOptimalModulePlacement( MODULE* aModule, wxDC* aDC )
 
         for( Pad = aModule->m_Pads; Pad != NULL; Pad = Pad->Next() )
         {
-            if( ( Pad->m_layerMask & otherLayerMask ) == 0 )
+            if( ( Pad->GetLayerMask() & otherLayerMask ) == 0 )
                 continue;
 
             TstOtherSide = true;

pcbnew/block_module_editor.cpp

@@ -443,7 +443,7 @@ void MoveMarkedItems( MODULE* module, wxPoint offset )
             continue;
 
         pad->SetPosition( pad->GetPosition() + offset );
-        pad->m_Pos0 += offset;
+        pad->SetPos0( pad->GetPos0() + offset );
     }
 
     item = module->m_Drawings;
@@ -526,29 +526,38 @@ void MirrorMarkedItems( MODULE* module, wxPoint offset )
 {
 #define SETMIRROR( z ) (z) -= offset.x; (z) = -(z); (z) += offset.x;
     wxPoint     tmp;
+    wxSize      tmpz;
 
     if( module == NULL )
         return;
 
     for( D_PAD* pad = module->m_Pads;  pad;  pad = pad->Next() )
     {
-        if( pad->IsSelected() )
+        // @JP why allow some pads to stay behind?  Do not understand
+        // why this test is here.
+        if( !pad->IsSelected() )
             continue;
 
         tmp = pad->GetPosition();
         SETMIRROR( tmp.x );
         pad->SetPosition( tmp );
 
-        pad->m_Pos0.x = pad->GetPosition().x;
+        pad->SetX0( pad->GetPosition().x );
-        NEGATE( pad->m_Offset.x );
+
-        NEGATE( pad->m_DeltaSize.x );
+        tmp = pad->GetOffset();
-        pad->m_Orient      = 1800 - pad->m_Orient;
+        NEGATE( tmp.x );
-        NORMALIZE_ANGLE_POS( pad->m_Orient );
+        pad->SetOffset( tmp );
+
+        tmpz = pad->GetDelta();
+        NEGATE( tmpz.x );
+        pad->SetDelta( tmpz );
+
+        pad->SetOrientation( 1800 - pad->GetOrientation() );
     }
 
     for( EDA_ITEM* item = module->m_Drawings;  item;  item = item->Next() )
     {
-        if( !item->IsSelected() )
+        if( !item->IsSelected() )   // @JP why allow some graphics to stay behind?
             continue;
 
         switch( item->Type() )
@@ -609,9 +618,8 @@ void RotateMarkedItems( MODULE* module, wxPoint offset )
         ROTATE( pos );
         pad->SetPosition( pos );
 
-        pad->m_Pos0    = pad->GetPosition();
+        pad->SetPos0( pad->GetPosition() );
-        pad->m_Orient += 900;
+        pad->SetOrientation( pad->GetOrientation() + 900 );
-        NORMALIZE_ANGLE_POS( pad->m_Orient );
     }
 
     for( EDA_ITEM* item = module->m_Drawings;  item;  item = item->Next() )

pcbnew/board_items_to_polygon_shape_transform.cpp

@@ -21,7 +21,7 @@
 #include <class_zone.h>
 
 
-/* Exported functions */
+// Exported functions
 
 /**
  * Function TransformRoundedEndsSegmentToPolygon
@@ -640,8 +640,9 @@ void    CreateThermalReliefPadPolygon( std::vector<CPolyPt>& aCornerBuffer,
     wxPoint PadShapePos = aPad.ReturnShapePos();    /* Note: for pad having a shape offset,
                                                      * the pad position is NOT the shape position */
     wxSize  copper_thickness;
-    int     dx = aPad.m_Size.x / 2;
+
-    int     dy = aPad.m_Size.y / 2;
+    int     dx = aPad.GetSize().x / 2;
+    int     dy = aPad.GetSize().y / 2;
 
     int     delta = 3600 / aCircleToSegmentsCount; // rot angle in 0.1 degree
 
@@ -663,320 +664,327 @@ void    CreateThermalReliefPadPolygon( std::vector<CPolyPt>& aCornerBuffer,
     copper_thickness.x = min( dx, aCopperThickness );
     copper_thickness.y = min( dy, aCopperThickness );
 
-    switch( aPad.m_PadShape )
+    switch( aPad.GetShape() )
     {
     case PAD_CIRCLE:    // Add 4 similar holes
-    {
-        /* we create 4 copper holes and put them in position 1, 2, 3 and 4
-         * here is the area of the rectangular pad + its thermal gap
-         * the 4 copper holes remove the copper in order to create the thermal gap
-         * 4 ------ 1
-         * |        |
-         * |        |
-         * |        |
-         * |        |
-         * 3 ------ 2
-         * holes 2, 3, 4 are the same as hole 1, rotated 90, 180, 270 deg
-         */
-
-        // Build the hole pattern, for the hole in the X >0, Y > 0 plane:
-        // The pattern roughtly is a 90 deg arc pie
-        std::vector <wxPoint> corners_buffer;
-
-        // Radius of outer arcs of the shape corrected for arc approximation by lines
-        int outer_radius = (int) ( (dx + aThermalGap) * aCorrectionFactor );
-
-        // Crosspoint of thermal spoke sides, the first point of polygon buffer
-        corners_buffer.push_back( wxPoint( copper_thickness.x / 2, copper_thickness.y / 2 ) );
-
-        // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
-        // and first seg of arc approx
-        corner.x = copper_thickness.x / 2;
-        int y = outer_radius - (aThermalGap / 4);
-        corner.y = (int) sqrt( ( ( (double) y * y ) - (double) corner.x * corner.x ) );
-
-        if( aThermalRot != 0 )
-            corners_buffer.push_back( corner );
-
-        // calculate the starting point of the outter arc
-        corner.x = copper_thickness.x / 2;
-
-        double dtmp = sqrt( ( (double) outer_radius * outer_radius ) -
-                            ( (double) corner.x * corner.x ) );
-        corner.y = (int) dtmp;
-        RotatePoint( &corner, 90 );
-
-        // calculate the ending point of the outter arc
-        corner_end.x = corner.y;
-        corner_end.y = corner.x;
-
-        // calculate intermediate points (y coordinate from corner.y to corner_end.y
-        while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
         {
-            corners_buffer.push_back( corner );
+            /* we create 4 copper holes and put them in position 1, 2, 3 and 4
-            RotatePoint( &corner, delta );
+             * here is the area of the rectangular pad + its thermal gap
-        }
+             * the 4 copper holes remove the copper in order to create the thermal gap
+             * 4 ------ 1
+             * |        |
+             * |        |
+             * |        |
+             * |        |
+             * 3 ------ 2
+             * holes 2, 3, 4 are the same as hole 1, rotated 90, 180, 270 deg
+             */
 
-        corners_buffer.push_back( corner_end );
+            // Build the hole pattern, for the hole in the X >0, Y > 0 plane:
+            // The pattern roughtly is a 90 deg arc pie
+            std::vector <wxPoint> corners_buffer;
 
-        /* add an intermediate point, to avoid angles < 90 deg between last arc approx line
+            // Radius of outer arcs of the shape corrected for arc approximation by lines
-         * and radius line
+            int outer_radius = (int) ( (dx + aThermalGap) * aCorrectionFactor );
-         */
-        corner.x = corners_buffer[1].y;
-        corner.y = corners_buffer[1].x;
-        corners_buffer.push_back( corner );
 
-        // Now, add the 4 holes ( each is the pattern, rotated by 0, 90, 180 and 270  deg
+            // Crosspoint of thermal spoke sides, the first point of polygon buffer
-        // aThermalRot = 450 (45.0 degrees orientation) work fine.
+            corners_buffer.push_back( wxPoint( copper_thickness.x / 2, copper_thickness.y / 2 ) );
-        int angle_pad = aPad.GetOrientation();              // Pad orientation
-        int th_angle  = aThermalRot;
 
-        for( unsigned ihole = 0; ihole < 4; ihole++ )
+            // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
-        {
+            // and first seg of arc approx
-            for( unsigned ii = 0; ii < corners_buffer.size(); ii++ )
+            corner.x = copper_thickness.x / 2;
+            int y = outer_radius - (aThermalGap / 4);
+            corner.y = (int) sqrt( ( ( (double) y * y ) - (double) corner.x * corner.x ) );
+
+            if( aThermalRot != 0 )
+                corners_buffer.push_back( corner );
+
+            // calculate the starting point of the outter arc
+            corner.x = copper_thickness.x / 2;
+
+            double dtmp = sqrt( ( (double) outer_radius * outer_radius ) -
+                                ( (double) corner.x * corner.x ) );
+            corner.y = (int) dtmp;
+            RotatePoint( &corner, 90 );
+
+            // calculate the ending point of the outter arc
+            corner_end.x = corner.y;
+            corner_end.y = corner.x;
+
+            // calculate intermediate points (y coordinate from corner.y to corner_end.y
+            while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
             {
-                corner = corners_buffer[ii];
+                corners_buffer.push_back( corner );
-                RotatePoint( &corner, th_angle + angle_pad );          // Rotate by segment angle and pad orientation
+                RotatePoint( &corner, delta );
-                corner += PadShapePos;
-                aCornerBuffer.push_back( CPolyPt( corner.x, corner.y ) );
             }
 
-            aCornerBuffer.back().end_contour = true;
+            corners_buffer.push_back( corner_end );
-            th_angle += 900;       // Note: th_angle in in 0.1 deg.
+
+            /* add an intermediate point, to avoid angles < 90 deg between last arc approx line
+             * and radius line
+             */
+            corner.x = corners_buffer[1].y;
+            corner.y = corners_buffer[1].x;
+            corners_buffer.push_back( corner );
+
+            // Now, add the 4 holes ( each is the pattern, rotated by 0, 90, 180 and 270  deg
+            // aThermalRot = 450 (45.0 degrees orientation) work fine.
+            int angle_pad = aPad.GetOrientation();              // Pad orientation
+            int th_angle  = aThermalRot;
+
+            for( unsigned ihole = 0; ihole < 4; ihole++ )
+            {
+                for( unsigned ii = 0; ii < corners_buffer.size(); ii++ )
+                {
+                    corner = corners_buffer[ii];
+                    RotatePoint( &corner, th_angle + angle_pad );          // Rotate by segment angle and pad orientation
+                    corner += PadShapePos;
+                    aCornerBuffer.push_back( CPolyPt( corner.x, corner.y ) );
+                }
+
+                aCornerBuffer.back().end_contour = true;
+                th_angle += 900;       // Note: th_angle in in 0.1 deg.
+            }
         }
-    }
+        break;
-    break;
 
     case PAD_OVAL:
-    {
-        // Oval pad support along the lines of round and rectangular pads
-        std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
-
-        int     dx = (aPad.m_Size.x / 2) + aThermalGap;     // Cutout radius x
-        int     dy = (aPad.m_Size.y / 2) + aThermalGap;     // Cutout radius y
-
-        wxPoint shape_offset;
-
-        // We want to calculate an oval shape with dx > dy.
-        // if this is not the case, exchange dx and dy, and rotate the shape 90 deg.
-        int supp_angle = 0;
-
-        if( dx < dy )
         {
-            EXCHG( dx, dy );
+            // Oval pad support along the lines of round and rectangular pads
-            supp_angle = 900;
+            std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
-            EXCHG( copper_thickness.x, copper_thickness.y );
-        }
 
-        int deltasize = dx - dy;        // = distance between shape position and the 2 demi-circle ends centre
+            int     dx = (aPad.GetSize().x / 2) + aThermalGap;     // Cutout radius x
-        // here we have dx > dy
+            int     dy = (aPad.GetSize().y / 2) + aThermalGap;     // Cutout radius y
-        // Radius of outer arcs of the shape:
-        int outer_radius = dy;     // The radius of the outer arc is radius end + aThermalGap
 
-        // Some coordinate fiddling, depending on the shape offset direction
+            wxPoint shape_offset;
-        shape_offset = wxPoint( deltasize, 0 );
 
-        // Crosspoint of thermal spoke sides, the first point of polygon buffer
+            // We want to calculate an oval shape with dx > dy.
-        corners_buffer.push_back( wxPoint( copper_thickness.x / 2, copper_thickness.y / 2 ) );
+            // if this is not the case, exchange dx and dy, and rotate the shape 90 deg.
+            int supp_angle = 0;
 
-        // Arc start point calculation, the intersecting point of cutout arc and thermal spoke edge
+            if( dx < dy )
-        if( copper_thickness.x > deltasize )          // If copper thickness is more than shape offset, we need to calculate arc intercept point.
+            {
-        {
+                EXCHG( dx, dy );
-            corner.x = copper_thickness.x / 2;
+                supp_angle = 900;
-            corner.y =  (int) sqrt( ( (double) outer_radius * outer_radius ) -
+                EXCHG( copper_thickness.x, copper_thickness.y );
-                                    ( (double) ( corner.x - delta ) * ( corner.x - deltasize ) ) );
+            }
-            corner.x -= deltasize;
 
-            /* creates an intermediate point, to have a > 90 deg angle
+            int deltasize = dx - dy;        // = distance between shape position and the 2 demi-circle ends centre
-             * between the side and the first segment of arc approximation
+            // here we have dx > dy
+            // Radius of outer arcs of the shape:
+            int outer_radius = dy;     // The radius of the outer arc is radius end + aThermalGap
+
+            // Some coordinate fiddling, depending on the shape offset direction
+            shape_offset = wxPoint( deltasize, 0 );
+
+            // Crosspoint of thermal spoke sides, the first point of polygon buffer
+            corners_buffer.push_back( wxPoint( copper_thickness.x / 2, copper_thickness.y / 2 ) );
+
+            // Arc start point calculation, the intersecting point of cutout arc and thermal spoke edge
+            if( copper_thickness.x > deltasize )          // If copper thickness is more than shape offset, we need to calculate arc intercept point.
+            {
+                corner.x = copper_thickness.x / 2;
+                corner.y =  (int) sqrt( ( (double) outer_radius * outer_radius ) -
+                                        ( (double) ( corner.x - delta ) * ( corner.x - deltasize ) ) );
+                corner.x -= deltasize;
+
+                /* creates an intermediate point, to have a > 90 deg angle
+                 * between the side and the first segment of arc approximation
+                 */
+                wxPoint intpoint = corner;
+                intpoint.y -= aThermalGap / 4;
+                corners_buffer.push_back( intpoint + shape_offset );
+                RotatePoint( &corner, 90 );
+            }
+            else
+            {
+                corner.x = copper_thickness.x / 2;
+                corner.y = outer_radius;
+                corners_buffer.push_back( corner );
+                corner.x = ( deltasize - copper_thickness.x ) / 2;
+            }
+
+            // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
+            // and first seg of arc approx
+            wxPoint last_corner;
+            last_corner.y = copper_thickness.y / 2;
+            int     px = outer_radius - (aThermalGap / 4);
+            last_corner.x =
+                (int) sqrt( ( ( (double) px * px ) - (double) last_corner.y * last_corner.y ) );
+
+            // Arc stop point calculation, the intersecting point of cutout arc and thermal spoke edge
+            corner_end.y = copper_thickness.y / 2;
+            corner_end.x =
+                (int) sqrt( ( (double) outer_radius *
+                             outer_radius ) - ( (double) corner_end.y * corner_end.y ) );
+            RotatePoint( &corner_end, -90 );
+
+            // calculate intermediate arc points till limit is reached
+            while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
+            {
+                corners_buffer.push_back( corner + shape_offset );
+                RotatePoint( &corner, delta );
+            }
+
+            //corners_buffer.push_back(corner + shape_offset);      // TODO: about one mil geometry error forms somewhere.
+            corners_buffer.push_back( corner_end + shape_offset );
+            corners_buffer.push_back( last_corner + shape_offset );         // Enabling the line above shows intersection point.
+
+            /* Create 2 holes, rotated by pad rotation.
              */
-            wxPoint intpoint = corner;
+            int angle = aPad.GetOrientation() + supp_angle;
-            intpoint.y -= aThermalGap / 4;
-            corners_buffer.push_back( intpoint + shape_offset );
-            RotatePoint( &corner, 90 );
-        }
-        else
-        {
-            corner.x = copper_thickness.x / 2;
-            corner.y = outer_radius;
-            corners_buffer.push_back( corner );
-            corner.x = ( deltasize - copper_thickness.x ) / 2;
-        }
 
-        // Add an intermediate point on spoke sides, to allow a > 90 deg angle between side
+            for( int irect = 0; irect < 2; irect++ )
-        // and first seg of arc approx
-        wxPoint last_corner;
-        last_corner.y = copper_thickness.y / 2;
-        int     px = outer_radius - (aThermalGap / 4);
-        last_corner.x =
-            (int) sqrt( ( ( (double) px * px ) - (double) last_corner.y * last_corner.y ) );
-
-        // Arc stop point calculation, the intersecting point of cutout arc and thermal spoke edge
-        corner_end.y = copper_thickness.y / 2;
-        corner_end.x =
-            (int) sqrt( ( (double) outer_radius *
-                         outer_radius ) - ( (double) corner_end.y * corner_end.y ) );
-        RotatePoint( &corner_end, -90 );
-
-        // calculate intermediate arc points till limit is reached
-        while( (corner.y > corner_end.y)  && (corner.x < corner_end.x) )
-        {
-            corners_buffer.push_back( corner + shape_offset );
-            RotatePoint( &corner, delta );
-        }
-
-        //corners_buffer.push_back(corner + shape_offset);      // TODO: about one mil geometry error forms somewhere.
-        corners_buffer.push_back( corner_end + shape_offset );
-        corners_buffer.push_back( last_corner + shape_offset );         // Enabling the line above shows intersection point.
-
-        /* Create 2 holes, rotated by pad rotation.
-         */
-        int angle = aPad.GetOrientation() + supp_angle;
-
-        for( int irect = 0; irect < 2; irect++ )
-        {
-            for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
             {
-                wxPoint cpos = corners_buffer[ic];
+                for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
-                RotatePoint( &cpos, angle );
+                {
-                cpos += PadShapePos;
+                    wxPoint cpos = corners_buffer[ic];
-                aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                    RotatePoint( &cpos, angle );
+                    cpos += PadShapePos;
+                    aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                }
+
+                aCornerBuffer.back().end_contour = true;
+                angle += 1800;       // this is calculate hole 3
+
+                if( angle >= 3600 )
+                    angle -= 3600;
             }
 
-            aCornerBuffer.back().end_contour = true;
+            // Create holes, that are the mirrored from the previous holes
-            angle += 1800;       // this is calculate hole 3
-
-            if( angle >= 3600 )
-                angle -= 3600;
-        }
-
-        // Create holes, that are the mirrored from the previous holes
-        for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
-        {
-            wxPoint swap = corners_buffer[ic];
-            swap.x = -swap.x;
-            corners_buffer[ic] = swap;
-        }
-
-        // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
-        angle = aPad.GetOrientation() + supp_angle;
-
-        for( int irect = 0; irect < 2; irect++ )
-        {
             for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
             {
-                wxPoint cpos = corners_buffer[ic];
+                wxPoint swap = corners_buffer[ic];
-                RotatePoint( &cpos, angle );
+                swap.x = -swap.x;
-                cpos += PadShapePos;
+                corners_buffer[ic] = swap;
-                aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
             }
 
-            aCornerBuffer.back().end_contour = true;
+            // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
-            angle += 1800;
+            angle = aPad.GetOrientation() + supp_angle;
 
-            if( angle >= 3600 )
+            for( int irect = 0; irect < 2; irect++ )
-                angle -= 3600;
+            {
+                for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
+                {
+                    wxPoint cpos = corners_buffer[ic];
+                    RotatePoint( &cpos, angle );
+                    cpos += PadShapePos;
+                    aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                }
+
+                aCornerBuffer.back().end_contour = true;
+                angle += 1800;
+
+                if( angle >= 3600 )
+                    angle -= 3600;
+            }
         }
-    }
+        break;
-    break;
 
     case PAD_RECT:       // draw 4 Holes
-    {
-        /* we create 4 copper holes and put them in position 1, 2, 3 and 4
-         * here is the area of the rectangular pad + its thermal gap
-         * the 4 copper holes remove the copper in order to create the thermal gap
-         * 4 ------ 1
-         * |        |
-         * |        |
-         * |        |
-         * |        |
-         * 3 ------ 2
-         * hole 3 is the same as hole 1, rotated 180 deg
-         * hole 4 is the same as hole 2, rotated 180 deg and is the same as hole 1, mirrored
-         */
-
-        // First, create a rectangular hole for position 1 :
-        // 2 ------- 3
-        //  |        |
-        //  |        |
-        //  |        |
-        // 1  -------4
-
-        // Modified rectangles with one corner rounded. TODO: merging with oval thermals
-        // and possibly round too.
-
-        std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
-
-        int dx = (aPad.m_Size.x / 2) + aThermalGap;         // Cutout radius x
-        int dy = (aPad.m_Size.y / 2) + aThermalGap;         // Cutout radius y
-
-        // The first point of polygon buffer is left lower corner, second the crosspoint of
-        // thermal spoke sides, the third is upper right corner and the rest are rounding
-        // vertices going anticlockwise. Note the inveted Y-axis in CG.
-        corners_buffer.push_back( wxPoint( -dx, -(aThermalGap / 4 + copper_thickness.y / 2) ) );    // Adds small miters to zone
-        corners_buffer.push_back( wxPoint( -(dx - aThermalGap / 4), -copper_thickness.y / 2 ) );    // fill and spoke corner
-        corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -copper_thickness.y / 2 ) );
-        corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -(dy - aThermalGap / 4) ) );
-        corners_buffer.push_back( wxPoint( -(aThermalGap / 4 + copper_thickness.x / 2), -dy ) );
-
-        int angle = aPad.GetOrientation();
-        int rounding_radius = (int) ( aThermalGap * aCorrectionFactor );            // Corner rounding radius
-        int angle_pg;                                                               // Polygon increment angle
-
-        for( int i = 0; i < aCircleToSegmentsCount / 4 + 1; i++ )
         {
-            wxPoint corner_position = wxPoint( 0, -rounding_radius );
+            /* we create 4 copper holes and put them in position 1, 2, 3 and 4
-            RotatePoint( &corner_position, 1800 / aCircleToSegmentsCount );         // Start at half increment offset
+             * here is the area of the rectangular pad + its thermal gap
-            angle_pg = i * delta;
+             * the 4 copper holes remove the copper in order to create the thermal gap
-            RotatePoint( &corner_position, angle_pg );                              // Rounding vector rotation
+             * 4 ------ 1
-            corner_position -= aPad.m_Size / 2;                                     // Rounding vector + Pad corner offset
+             * |        |
-            corners_buffer.push_back( wxPoint( corner_position.x, corner_position.y ) );
+             * |        |
-        }
+             * |        |
+             * |        |
+             * 3 ------ 2
+             * hole 3 is the same as hole 1, rotated 180 deg
+             * hole 4 is the same as hole 2, rotated 180 deg and is the same as hole 1, mirrored
+             */
 
-        for( int irect = 0; irect < 2; irect++ )
+            // First, create a rectangular hole for position 1 :
-        {
+            // 2 ------- 3
-            for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
+            //  |        |
+            //  |        |
+            //  |        |
+            // 1  -------4
+
+            // Modified rectangles with one corner rounded. TODO: merging with oval thermals
+            // and possibly round too.
+
+            std::vector <wxPoint> corners_buffer;               // Polygon buffer as vector
+
+            int dx = (aPad.GetSize().x / 2) + aThermalGap;         // Cutout radius x
+            int dy = (aPad.GetSize().y / 2) + aThermalGap;         // Cutout radius y
+
+            // The first point of polygon buffer is left lower corner, second the crosspoint of
+            // thermal spoke sides, the third is upper right corner and the rest are rounding
+            // vertices going anticlockwise. Note the inveted Y-axis in CG.
+            corners_buffer.push_back( wxPoint( -dx, -(aThermalGap / 4 + copper_thickness.y / 2) ) );    // Adds small miters to zone
+            corners_buffer.push_back( wxPoint( -(dx - aThermalGap / 4), -copper_thickness.y / 2 ) );    // fill and spoke corner
+            corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -copper_thickness.y / 2 ) );
+            corners_buffer.push_back( wxPoint( -copper_thickness.x / 2, -(dy - aThermalGap / 4) ) );
+            corners_buffer.push_back( wxPoint( -(aThermalGap / 4 + copper_thickness.x / 2), -dy ) );
+
+            int angle = aPad.GetOrientation();
+            int rounding_radius = (int) ( aThermalGap * aCorrectionFactor );    // Corner rounding radius
+            int angle_pg;                                                       // Polygon increment angle
+
+            for( int i = 0; i < aCircleToSegmentsCount / 4 + 1; i++ )
             {
-                wxPoint cpos = corners_buffer[ic];
+                wxPoint corner_position = wxPoint( 0, -rounding_radius );
-                RotatePoint( &cpos, angle );            // Rotate according to module orientation
+
-                cpos += PadShapePos;                    // Shift origin to position
+                // Start at half increment offset
-                aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                RotatePoint( &corner_position, 1800 / aCircleToSegmentsCount );
+                angle_pg = i * delta;
+
+                RotatePoint( &corner_position, angle_pg );          // Rounding vector rotation
+                corner_position -= aPad.GetSize() / 2;              // Rounding vector + Pad corner offset
+
+                corners_buffer.push_back( wxPoint( corner_position.x, corner_position.y ) );
             }
 
-            aCornerBuffer.back().end_contour = true;
+            for( int irect = 0; irect < 2; irect++ )
-            angle += 1800;       // this is calculate hole 3
-
-            if( angle >= 3600 )
-                angle -= 3600;
-        }
-
-        // Create holes, that are the mirrored from the previous holes
-        for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
-        {
-            wxPoint swap = corners_buffer[ic];
-            swap.x = -swap.x;
-            corners_buffer[ic] = swap;
-        }
-
-        // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
-        for( int irect = 0; irect < 2; irect++ )
-        {
-            for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
             {
-                wxPoint cpos = corners_buffer[ic];
+                for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
-                RotatePoint( &cpos, angle );
+                {
-                cpos += PadShapePos;
+                    wxPoint cpos = corners_buffer[ic];
-                aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                    RotatePoint( &cpos, angle );            // Rotate according to module orientation
+                    cpos += PadShapePos;                    // Shift origin to position
+                    aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                }
+
+                aCornerBuffer.back().end_contour = true;
+                angle += 1800;       // this is calculate hole 3
+
+                if( angle >= 3600 )
+                    angle -= 3600;
             }
 
-            aCornerBuffer.back().end_contour = true;
+            // Create holes, that are the mirrored from the previous holes
-            angle += 1800;
+            for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
+            {
+                wxPoint swap = corners_buffer[ic];
+                swap.x = -swap.x;
+                corners_buffer[ic] = swap;
+            }
+
+            // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
+            for( int irect = 0; irect < 2; irect++ )
+            {
+                for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
+                {
+                    wxPoint cpos = corners_buffer[ic];
+                    RotatePoint( &cpos, angle );
+                    cpos += PadShapePos;
+                    aCornerBuffer.push_back( CPolyPt( cpos.x, cpos.y ) );
+                }
+
+                aCornerBuffer.back().end_contour = true;
+                angle += 1800;
+
+                if( angle >= 3600 )
+                    angle -= 3600;
+            }
 
-            if( angle >= 3600 )
-                angle -= 3600;
         }
-
         break;
-    }
+
+    default:
+        ;
     }
 }

pcbnew/class_board.cpp

@@ -1181,7 +1181,7 @@ SEARCH_RESULT BOARD::Visit( INSPECTOR* inspector, const void* testData,
  *               D_PAD*  pad = (D_PAD*) item;
  *               if( pad->HitTest( refPos ) )
  *               {
- *                   if( layer_mask & pad->m_layerMask )
+ *                   if( layer_mask & pad->GetLayerMask() )
  *                   {
  *                       found = item;
  *                       return SEARCH_QUIT;
@@ -1572,11 +1572,11 @@ D_PAD* BOARD::GetPadFast( const wxPoint& aPosition, int aLayerMask )
     {
         D_PAD* pad = m_NetInfo.GetPad(i);
 
-        if( pad->m_Pos != aPosition )
+        if( pad->GetPosition() != aPosition )
             continue;
 
         /* Pad found, it must be on the correct layer */
-        if( pad->m_layerMask & aLayerMask )
+        if( pad->GetLayerMask() & aLayerMask )
             return pad;
     }
 
@@ -1603,10 +1603,10 @@ D_PAD* BOARD::GetPad( std::vector<D_PAD*>& aPadList, const wxPoint& aPosition, i
 
         D_PAD* pad = aPadList[idx];
 
-        if( pad->m_Pos == aPosition )       // candidate found
+        if( pad->GetPosition() == aPosition )       // candidate found
         {
             // The pad must match the layer mask:
-            if( (aLayerMask & pad->m_layerMask) != 0 )
+            if( (aLayerMask & pad->GetLayerMask()) != 0 )
                 return pad;
 
             // More than one pad can be at aPosition
@@ -1616,18 +1616,18 @@ D_PAD* BOARD::GetPad( std::vector<D_PAD*>& aPadList, const wxPoint& aPosition, i
             for( int ii = idx+1; ii <= idxmax; ii++ )
             {
                 pad = aPadList[ii];
-                if( pad->m_Pos != aPosition )
+                if( pad->GetPosition() != aPosition )
                     break;
-                if( (aLayerMask & pad->m_layerMask) != 0 )
+                if( (aLayerMask & pad->GetLayerMask()) != 0 )
                     return pad;
             }
             // search previous
             for(  int ii = idx-1 ;ii >=0; ii-- )
             {
                 pad = aPadList[ii];
-                if( pad->m_Pos != aPosition )
+                if( pad->GetPosition() != aPosition )
                     break;
-                if( (aLayerMask & pad->m_layerMask) != 0 )
+                if( (aLayerMask & pad->GetLayerMask()) != 0 )
                     return pad;
             }
 
@@ -1635,9 +1635,9 @@ D_PAD* BOARD::GetPad( std::vector<D_PAD*>& aPadList, const wxPoint& aPosition, i
             return 0;
         }
 
-        if( pad->m_Pos.x == aPosition.x )   // Must search considering Y coordinate
+        if( pad->GetPosition().x == aPosition.x )   // Must search considering Y coordinate
         {
-            if(pad->m_Pos.y < aPosition.y)  // Must search after this item
+            if(pad->GetPosition().y < aPosition.y)  // Must search after this item
             {
                 idx += delta;
                 if( idx > idxmax )
@@ -1650,7 +1650,7 @@ D_PAD* BOARD::GetPad( std::vector<D_PAD*>& aPadList, const wxPoint& aPosition, i
                     idx = 0;
             }
         }
-        else if( pad->m_Pos.x < aPosition.x ) // Must search after this item
+        else if( pad->GetPosition().x < aPosition.x ) // Must search after this item
         {
             idx += delta;
             if( idx > idxmax )
@@ -1674,9 +1674,9 @@ D_PAD* BOARD::GetPad( std::vector<D_PAD*>& aPadList, const wxPoint& aPosition, i
  */
 static bool sortPadsByXthenYCoord( D_PAD* const & ref, D_PAD* const & comp )
 {
-    if( ref->m_Pos.x == comp->m_Pos.x )
+    if( ref->GetPosition().x == comp->GetPosition().x )
-        return ref->m_Pos.y < comp->m_Pos.y;
+        return ref->GetPosition().y < comp->GetPosition().y;
-    return ref->m_Pos.x < comp->m_Pos.x;
+    return ref->GetPosition().x < comp->GetPosition().x;
 }
 
 
@@ -1919,13 +1919,13 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace,
                     if( track->GetState( BEGIN_ONPAD ) )
                     {
                         D_PAD * pad = (D_PAD *) track->start;
-                        lenDie += (double) pad->m_LengthDie;
+                        lenDie += (double) pad->GetDieLength();
                     }
 
                     if( track->GetState( END_ONPAD ) )
                     {
                         D_PAD * pad = (D_PAD *) track->end;
-                        lenDie += (double) pad->m_LengthDie;
+                        lenDie += (double) pad->GetDieLength();
                     }
                 }
             }
@@ -1949,13 +1949,13 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace,
                 if( track->GetState( BEGIN_ONPAD ) )
                 {
                     D_PAD * pad = (D_PAD *) track->start;
-                    lenDie += (double) pad->m_LengthDie;
+                    lenDie += (double) pad->GetDieLength();
                 }
 
                 if( track->GetState( END_ONPAD ) )
                 {
                     D_PAD * pad = (D_PAD *) track->end;
-                    lenDie += (double) pad->m_LengthDie;
+                    lenDie += (double) pad->GetDieLength();
                 }
             }
         }

pcbnew/class_board_design_settings.cpp

@@ -13,7 +13,8 @@
 #include <class_track.h>
 
 
-BOARD_DESIGN_SETTINGS::BOARD_DESIGN_SETTINGS()
+BOARD_DESIGN_SETTINGS::BOARD_DESIGN_SETTINGS() :
+    m_Pad_Master( 0 )
 {
     m_EnabledLayers = ALL_LAYERS;               // All layers enabled at first.
                                                 // SetCopperLayerCount() will adjust this.
@@ -59,6 +60,48 @@ BOARD_DESIGN_SETTINGS::BOARD_DESIGN_SETTINGS()
 }
 
 
+void BOARD_DESIGN_SETTINGS::AppendConfigs( PARAM_CFG_ARRAY* aResult )
+{
+    m_Pad_Master.AppendConfigs( aResult );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "BoardThickness" ),
+                                                      &m_BoardThickness,
+                                                      630, 0, 0xFFFF ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtPcbV" ),
+                                                      &m_PcbTextSize.y,
+                                                      600, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtPcbH" ),
+                                                      &m_PcbTextSize.x,
+                                                      600, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtModV" ), &m_ModuleTextSize.y,
+                                                      500, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtModH" ), &m_ModuleTextSize.x,
+                                                      500, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtModW" ), &m_ModuleTextWidth,
+                                                      100, 1, TEXTS_MAX_WIDTH ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "VEgarde" ),
+                                                      &m_SolderMaskMargin,
+                                                      100, 0, 10000 ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "DrawLar" ),
+                                                      &m_DrawSegmentWidth,
+                                                      120, 0, 0xFFFF ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "EdgeLar" ),
+                                                      &m_EdgeSegmentWidth,
+                                                      120, 0, 0xFFFF ) );
+    aResult->push_back( new PARAM_CFG_INT( wxT( "TxtLar" ),
+                                                      &m_PcbTextWidth,
+                                                      120, 0, 0xFFFF ) );
+    aResult->push_back( new PARAM_CFG_INT( wxT( "MSegLar" ), &m_ModuleSegmentWidth,
+                                                      120, 0, 0xFFFF ) );
+}
+
+
 // see pcbstruct.h
 int BOARD_DESIGN_SETTINGS::GetVisibleLayers() const
 {
@@ -123,11 +166,6 @@ void BOARD_DESIGN_SETTINGS::SetCopperLayerCount( int aNewLayerCount )
 }
 
 
-/**
- * Function SetEnabledLayers
- * changes the bit-mask of enabled layers
- * @param aMask = The new bit-mask of enabled layers
- */
 void BOARD_DESIGN_SETTINGS::SetEnabledLayers( int aMask )
 {
     // Back and front layers are always enabled.

pcbnew/class_module.cpp

@@ -102,13 +102,13 @@ MODULE::MODULE( const MODULE& aModule ) :
     m_LocalSolderPasteMargin = aModule.m_LocalSolderPasteMargin;
     m_LocalSolderPasteMarginRatio = aModule.m_LocalSolderPasteMarginRatio;
 
-    /* Copy reference and value. */
+    // Copy reference and value.
     m_Reference = new TEXTE_MODULE( *aModule.m_Reference );
     m_Reference->SetParent( this );
     m_Value = new TEXTE_MODULE( *aModule.m_Value );
     m_Value->SetParent( this );
 
-    /* Copy auxiliary data: Pads */
+    // Copy auxiliary data: Pads
     m_Pads.DeleteAll();
 
     for( D_PAD* pad = aModule.m_Pads;  pad;  pad = pad->Next() )
@@ -118,7 +118,7 @@ MODULE::MODULE( const MODULE& aModule ) :
         m_Pads.PushBack( newpad );
     }
 
-    /* Copy auxiliary data: Drawings */
+    // Copy auxiliary data: Drawings
     m_Drawings.DeleteAll();
 
     for( BOARD_ITEM* item = aModule.m_Drawings;  item;  item = item->Next() )
@@ -138,7 +138,7 @@ MODULE::MODULE( const MODULE& aModule ) :
         }
     }
 
-    /* Copy auxiliary data: 3D_Drawings info */
+    // Copy auxiliary data: 3D_Drawings info
     m_3D_Drawings.DeleteAll();
 
     for( S3D_MASTER* item = aModule.m_3D_Drawings;  item;  item = item->Next() )
@@ -217,11 +217,11 @@ void MODULE::Copy( MODULE* aModule )
     m_LocalSolderPasteMargin        = aModule->m_LocalSolderPasteMargin;
     m_LocalSolderPasteMarginRatio   = aModule->m_LocalSolderPasteMarginRatio;
 
-    /* Copy reference and value. */
+    // Copy reference and value.
     m_Reference->Copy( aModule->m_Reference );
     m_Value->Copy( aModule->m_Value );
 
-    /* Copy auxiliary data: Pads */
+    // Copy auxiliary data: Pads
     m_Pads.DeleteAll();
 
     for( D_PAD* pad = aModule->m_Pads;  pad;  pad = pad->Next() )
@@ -231,7 +231,7 @@ void MODULE::Copy( MODULE* aModule )
         m_Pads.PushBack( newpad );
     }
 
-    /* Copy auxiliary data: Drawings */
+    // Copy auxiliary data: Drawings
     m_Drawings.DeleteAll();
 
     for( BOARD_ITEM* item = aModule->m_Drawings;  item;  item = item->Next() )
@@ -258,7 +258,7 @@ void MODULE::Copy( MODULE* aModule )
         }
     }
 
-    /* Copy auxiliary data: 3D_Drawings info */
+    // Copy auxiliary data: 3D_Drawings info
     m_3D_Drawings.DeleteAll();
 
     // Ensure there is one (or more) item in m_3D_Drawings
@@ -314,7 +314,7 @@ void MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, int aDrawMode, const wxPoi
     // Draws footprint anchor
     DrawAncre( aPanel, aDC, aOffset, DIM_ANCRE_MODULE, aDrawMode );
 
-    /* Draw graphic items */
+    // Draw graphic items
     if( brd->IsElementVisible( MOD_REFERENCES_VISIBLE ) )
     {
         if( !(m_Reference->IsMoving()) )
@@ -549,8 +549,8 @@ D_PAD* MODULE::GetPad( const wxPoint& aPosition, int aLayerMask )
 {
     for( D_PAD* pad = m_Pads;   pad;   pad = pad->Next() )
     {
-        /* ... and on the correct layer. */
+        // ... and on the correct layer.
-        if( ( pad->m_layerMask & aLayerMask ) == 0 )
+        if( ( pad->GetLayerMask() & aLayerMask ) == 0 )
             continue;
 
         if( pad->HitTest( aPosition ) )

pcbnew/class_module.h

@@ -29,8 +29,8 @@
  */
 
 
-#ifndef _MODULE_H_
+#ifndef MODULE_H_
-#define _MODULE_H_
+#define MODULE_H_
 
 
 #include <dlist.h>
@@ -420,4 +420,4 @@ private:
 };
 
 
-#endif     // _MODULE_H_
+#endif     // MODULE_H_

pcbnew/class_module_transform_functions.cpp

@@ -161,22 +161,9 @@ void MODULE::Flip( const wxPoint& aCentre )
     NEGATE( m_Orient );
     NORMALIZE_ANGLE_POS( m_Orient );
 
-    // Mirror inversion layers pads.
+    // Mirror pads to other side of board about the x axis, i.e. vertically.
     for( D_PAD* pad = m_Pads;  pad;  pad = pad->Next() )
-    {
+        pad->Flip( m_Pos.y );
-        pad->m_Pos.y  -= m_Pos.y;
-        pad->m_Pos.y   = -pad->m_Pos.y;
-        pad->m_Pos.y  += m_Pos.y;
-
-        NEGATE( pad->m_Pos0.y );
-        NEGATE( pad->m_Offset.y );
-        NEGATE( pad->m_DeltaSize.y );
-
-        NEGATE_AND_NORMALIZE_ANGLE_POS( pad->m_Orient );
-
-        // flip pads layers
-        pad->m_layerMask = ChangeSideMaskLayer( pad->m_layerMask );
-    }
 
     // Mirror reference.
     pt_texte = m_Reference;
@@ -301,7 +288,7 @@ void MODULE::SetPosition( const wxPoint& newpos )
 
     for( D_PAD* pad = m_Pads;  pad;  pad = pad->Next() )
     {
-        pad->m_Pos += delta;
+        pad->SetPosition( pad->GetPosition() + delta );
     }
 
     for( EDA_ITEM* item = m_Drawings;  item;  item = item->Next() )
@@ -334,25 +321,22 @@ void MODULE::SetPosition( const wxPoint& newpos )
 
 void MODULE::SetOrientation( double newangle )
 {
-    int px, py;
+    double  angleChange = newangle - m_Orient;  // change in rotation
+    wxPoint pt;
 
-    newangle -= m_Orient;       // = Change in rotation
+    NORMALIZE_ANGLE_POS( newangle );
 
-    m_Orient += newangle;
+    m_Orient = newangle;
-
-    NORMALIZE_ANGLE_POS( m_Orient );
 
     for( D_PAD* pad = m_Pads;  pad;  pad = pad->Next() )
     {
-        px = pad->m_Pos0.x;
+        pt = pad->GetPos0();
-        py = pad->m_Pos0.y;
 
-        pad->m_Orient += newangle;  // change m_Orientation
+        pad->SetOrientation( pad->GetOrientation() + angleChange );
-        NORMALIZE_ANGLE_POS( pad->m_Orient );
 
-        RotatePoint( &px, &py, m_Orient );
+        RotatePoint( &pt, m_Orient );
-        pad->m_Pos.x = m_Pos.x + px;
+
-        pad->m_Pos.y = m_Pos.y + py;
+        pad->SetPosition( GetPosition() + pt );
     }
 
     // Update of the reference and value.

pcbnew/class_netinfo_item.cpp

@@ -100,7 +100,7 @@ void NETINFO_ITEM::DisplayInfo( EDA_DRAW_FRAME* frame )
             if( pad->GetNet() == GetNet() )
             {
                 count++;
-                lengthdie += pad->m_LengthDie;
+                lengthdie += pad->GetDieLength();
             }
         }
     }
@@ -172,6 +172,7 @@ void RATSNEST_ITEM::Draw( EDA_DRAW_PANEL* panel,
 
     int color = g_ColorsSettings.GetItemColor(RATSNEST_VISIBLE);
 
-    GRLine( panel->GetClipBox(), DC, m_PadStart->m_Pos - aOffset,
+    GRLine( panel->GetClipBox(), DC,
-            m_PadEnd->m_Pos - aOffset, 0, color );
+            m_PadStart->GetPosition() - aOffset,
+            m_PadEnd->GetPosition() - aOffset, 0, color );
 }

pcbnew/class_pad.cpp

@@ -33,6 +33,7 @@
 #include <confirm.h>
 #include <kicad_string.h>
 #include <trigo.h>
+#include <protos.h>
 #include <richio.h>
 #include <wxstruct.h>
 #include <macros.h>
@@ -47,7 +48,8 @@
 int D_PAD::m_PadSketchModePenSize = 0;      // Pen size used to draw pads in sketch mode
 
 
-D_PAD::D_PAD( MODULE* parent ) : BOARD_CONNECTED_ITEM( parent, PCB_PAD_T )
+D_PAD::D_PAD( MODULE* parent ) :
+    BOARD_CONNECTED_ITEM( parent, PCB_PAD_T )
 {
     m_NumPadName = 0;
 
@@ -55,40 +57,35 @@ D_PAD::D_PAD( MODULE* parent ) : BOARD_CONNECTED_ITEM( parent, PCB_PAD_T )
     m_Orient = 0;                       // Pad rotation in 1/10 degrees
     m_LengthDie = 0;
 
-    if( m_Parent && (m_Parent->Type()  == PCB_MODULE_T) )
+    if( m_Parent  &&  m_Parent->Type() == PCB_MODULE_T )
     {
-        m_Pos = ( (MODULE*) m_Parent )->GetPosition();
+        m_Pos = GetParent()->GetPosition();
     }
 
-    m_PadShape = PAD_CIRCLE;                        // Shape: PAD_CIRCLE, PAD_RECT PAD_OVAL
+    m_PadShape = PAD_CIRCLE;            // Shape: PAD_CIRCLE, PAD_RECT PAD_OVAL
-                                                    // PAD_TRAPEZOID
+                                        // PAD_TRAPEZOID
-    m_Attribut = PAD_STANDARD;                      // Type: NORMAL, PAD_SMD, PAD_CONN
+    m_Attribute      = PAD_STANDARD;    // Type: NORMAL, PAD_SMD, PAD_CONN
-    m_DrillShape     = PAD_CIRCLE;                  // Drill shape = circle
+    m_DrillShape     = PAD_CIRCLE;      // Drill shape = circle
     m_LocalClearance = 0;
     m_LocalSolderMaskMargin  = 0;
     m_LocalSolderPasteMargin = 0;
     m_LocalSolderPasteMarginRatio = 0.0;
-    m_layerMask = PAD_STANDARD_DEFAULT_LAYERS;      // set layers mask to
-                                                    // default for a standard pad
 
-    SetSubRatsnest( 0 );                            // used in ratsnest calculations
+    // set layers mask to default for a standard pad
-    ComputeShapeMaxRadius();
+    m_layerMask = PAD_STANDARD_DEFAULT_LAYERS;
+
+    SetSubRatsnest( 0 );                // used in ratsnest calculations
+
+    m_boundingRadius = -1;
 }
 
 
-D_PAD::~D_PAD()
+int D_PAD::boundingRadius() const
-{
-}
-
-
-/* Calculate the radius of the circle containing the pad.
- */
-int D_PAD::GetMaxRadius() const
 {
     int x, y;
     int radius;
 
-    switch( m_PadShape & 0x7F )
+    switch( GetShape() )
     {
     case PAD_CIRCLE:
         radius = m_Size.x / 2;
@@ -110,30 +107,19 @@ int D_PAD::GetMaxRadius() const
         break;
 
     default:
-        radius = 0;     // quiet compiler
+        radius = 0;
     }
 
     return radius;
 }
 
 
-/* Calculate the radius of the circle containing the pad.
- */
-void D_PAD::ComputeShapeMaxRadius()
-{
-    m_ShapeMaxRadius = GetMaxRadius();
-}
-
-
-/**
- * Function GetBoundingBox
- * returns the bounding box of this pad
- * Mainly used to redraw the screen area occupied by the pad
- */
 EDA_RECT D_PAD::GetBoundingBox() const
 {
     EDA_RECT area;
-    int radius = GetMaxRadius();     // Calculate the radius of the area, considered as a circle
+
+    // radius of pad area, enclosed in minimum sized circle
+    int     radius = boundingRadius();
 
     area.SetOrigin( m_Pos );
     area.Inflate( radius );
@@ -142,6 +128,49 @@ EDA_RECT D_PAD::GetBoundingBox() const
 }
 
 
+void D_PAD::SetOrientation( double aAngle )
+{
+    NORMALIZE_ANGLE_POS( aAngle );
+    m_Orient = aAngle;
+}
+
+
+void D_PAD::Flip( int aTranslationY )
+{
+    int y = GetPosition().y - aTranslationY;
+
+    y = -y;         // invert about x axis.
+
+    y += aTranslationY;
+
+    SetY( y );
+
+    NEGATE( m_Pos0.y );
+    NEGATE( m_Offset.y );
+    NEGATE( m_DeltaSize.y );
+
+    SetOrientation( -GetOrientation() );
+
+    // flip pads layers
+    SetLayerMask( ChangeSideMaskLayer( m_layerMask ) );
+
+    // m_boundingRadius = -1;  the shape has not been changed
+}
+
+
+void D_PAD::AppendConfigs( PARAM_CFG_ARRAY* aResult )
+{
+    aResult->push_back( new PARAM_CFG_INT( wxT( "PadDrlX" ), &m_Drill.x,
+                                                      320, 0, 0x7FFF ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "PadDimH" ), &m_Size.x,
+                                                      550, 0, 0x7FFF ) );
+
+    aResult->push_back( new PARAM_CFG_INT( wxT( "PadDimV" ), &m_Size.y,
+                                                      550, 0, 0x7FFF ) );
+}
+
+
 // Returns the position of the pad.
 const wxPoint D_PAD::ReturnShapePos()
 {
@@ -265,9 +294,9 @@ void D_PAD::Copy( D_PAD* source )
     m_Size = source->m_Size;
     m_DeltaSize = source->m_DeltaSize;
     m_Pos0     = source->m_Pos0;
-    m_ShapeMaxRadius    = source->m_ShapeMaxRadius;
+    m_boundingRadius    = source->m_boundingRadius;
     m_PadShape = source->m_PadShape;
-    m_Attribut = source->m_Attribut;
+    m_Attribute = source->m_Attribute;
     m_Orient   = source->m_Orient;
     m_LengthDie = source->m_LengthDie;
     m_LocalClearance = source->m_LocalClearance;
@@ -581,9 +610,9 @@ void D_PAD::DisplayInfo( EDA_DRAW_FRAME* frame )
     valeur_param( m_Pos.y, Line );
     frame->AppendMsgPanel( _( "Y pos" ), Line, LIGHTBLUE );
 
-    if( m_LengthDie )
+    if( GetDieLength() )
     {
-        valeur_param( m_LengthDie, Line );
+        valeur_param( GetDieLength(), Line );
         frame->AppendMsgPanel( _( "Length on die" ), Line, CYAN );
     }
 }
@@ -596,12 +625,6 @@ bool D_PAD::IsOnLayer( int aLayer ) const
 }
 
 
-/**
- * Function HitTest
- * tests if the given wxPoint is within the bounds of this object.
- * @param refPos A wxPoint to test
- * @return bool - true if a hit, else false
- */
 bool D_PAD::HitTest( const wxPoint& refPos )
 {
     int     dx, dy;
@@ -611,8 +634,10 @@ bool D_PAD::HitTest( const wxPoint& refPos )
 
     wxPoint delta = refPos - shape_pos;
 
-    /* Quick test: a test point must be inside the circle. */
+    // first test: a test point must be inside a minimum sized bounding circle.
-    if( ( abs( delta.x ) > m_ShapeMaxRadius ) || ( abs( delta.y ) > m_ShapeMaxRadius ) )
+    int radius = GetBoundingRadius();
+
+    if( ( abs( delta.x ) > radius ) || ( abs( delta.y ) > radius ) )
         return false;
 
     dx = m_Size.x >> 1; // dx also is the radius for rounded pads
@@ -716,7 +741,7 @@ wxString D_PAD::ShowPadShape() const
 
 wxString D_PAD::ShowPadAttr() const
 {
-    switch( m_Attribut & 0x0F )
+    switch( GetAttribute() )
     {
     case PAD_STANDARD:
         return _( "Std" );

pcbnew/class_pad.h

@@ -27,14 +27,15 @@
  * @brief Pad object description
  */
 
-#ifndef _PAD_H_
+#ifndef PAD_H_
-#define _PAD_H_
+#define PAD_H_
 
 
 #include <class_board_item.h>
 #include <class_board_connected_item.h>
 #include <pad_shapes.h>
 #include <PolyLine.h>
+#include <param_config.h>       // PARAM_CFG_ARRAY
 
 
 class LINE_READER;
@@ -91,86 +92,20 @@ public:
 
 class D_PAD : public BOARD_CONNECTED_ITEM
 {
-private:
-    wxString m_Netname;         // Full net name like /mysheet/mysubsheet/vout used by Eeschema
-    wxString m_ShortNetname;    // short net name, like vout from /mysheet/mysubsheet/vout
-
-    /// 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[]
-    };
-
-    int m_SubRatsnest;                  // variable used in rats nest computations
-                                        // handle subnet (block) number in ratsnest connection
-
 public:
-    wxPoint m_Pos;                  // pad Position on board
+    static int  m_PadSketchModePenSize; ///< Pen size used to draw pads in sketch mode
-
+                                        ///< (mode used to print pads on silkscreen layer)
-    int m_layerMask;                // Bitwise layer :1= copper layer, 15= cmp,
-                                    // 2..14 = internal layers
-                                    // 16 .. 31 = technical layers
-
-    int    m_PadShape;              // Shape: PAD_CIRCLE, PAD_RECT, PAD_OVAL, PAD_TRAPEZOID
-    int    m_DrillShape;            // Shape PAD_CIRCLE, PAD_OVAL
-
-    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_Offset;    /* This parameter is useful only for oblong pads (it can be used for other
-                         * shapes, but without any interest).
-                         * this is the offset between the pad hole and the pad shape (you must
-                         * 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.
-                         * D_PAD::ReturnShapePos() returns the physical shape position according to
-                         * the offset and the pad rotation.*/
-
-    wxSize  m_Size;                 // X and Y size ( relative to orient 0)
-
-    wxSize  m_DeltaSize;            // delta on rectangular shapes
-
-    wxPoint m_Pos0;                 // Initial Pad position (i.e. pad position relative to the
-                                    // module anchor, orientation 0
-
-    int     m_ShapeMaxRadius;       // radius of the circle containing the pad shape
-    int     m_Attribut;             // NORMAL, PAD_SMD, PAD_CONN, PAD_HOLE_NOT_PLATED
-    double  m_Orient;               // in 1/10 degrees
-
-    static int m_PadSketchModePenSize;  // Pen size used to draw pads in sketch mode
-                                        // (mode used to print pads on silkscreen layer)
-
-    int     m_LengthDie;            // Length net from pad to die on chip
-
-    // 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 NULL, 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
 
 public:
     D_PAD( MODULE* parent );
 
     // Do not create a copy constructor.  The one generated by the compiler is adequate.
 
-    ~D_PAD();
-
     void Copy( D_PAD* source );
 
-    D_PAD* Next() { return (D_PAD*) Pnext; }
+    D_PAD* Next() const       { return (D_PAD*) Pnext; }
+
+    MODULE* GetParent() const { return (MODULE*) m_Parent; }
 
     void SetPadName( const wxString& name );    // Change pad name
     const wxString GetPadName() const;
@@ -202,36 +137,50 @@ public:
      * Function GetShape
      * @return the shape of this pad.
      */
-    int GetShape() const { return m_PadShape & 0xFF;  }
+    PAD_SHAPE_T GetShape() const                { return m_PadShape; }
-    void SetShape( int aShape )  { m_PadShape = aShape; }
+    void SetShape( PAD_SHAPE_T aShape )         { m_PadShape = aShape; m_boundingRadius = -1; }
 
     void SetPosition( const wxPoint& aPos )     { m_Pos = aPos; }   // overload
-    const wxPoint GetPosition() const   // overload
+    const wxPoint GetPosition() const           { return m_Pos; }   // overload
-    {
+
-        return m_Pos;
+    void SetY( int y )                          { m_Pos.y = y; }
-    }
+    void SetX( int x )                          { m_Pos.x = x; }
 
     void SetPos0( const wxPoint& aPos )         { m_Pos0 = aPos; }
     const wxPoint& GetPos0() const              { return m_Pos0; }
 
-    void SetSize( const wxSize& aSize )         { m_Size = aSize; }
+    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; }
     const wxSize& GetSize() const               { return m_Size; }
 
-    void SetDelta( const wxSize& aSize )        { m_DeltaSize = aSize; }
+    void SetDelta( const wxSize& aSize )        { m_DeltaSize = aSize;  m_boundingRadius = -1; }
     const wxSize& GetDelta() const              { return m_DeltaSize; }
 
     void SetDrillSize( const wxSize& aSize )    { m_Drill = aSize; }
     const wxSize& GetDrillSize() const          { return m_Drill; }
 
-    void SetOffset( const wxSize& aOffset )     { m_Offset = aOffset; }
+    void SetOffset( const wxPoint& aOffset )    { m_Offset = aOffset; }
-    const wxSize& GetOffset() const             { return m_Offset; }
+    const wxPoint& GetOffset() const            { return m_Offset; }
+
+    /**
+     * Function Flip
+     * flips this pad to the other outter most copper layer, back to front or
+     * vice versa, and does this vertically, so the x coordinate is not affected.
+     *
+     * @param aTranslationY is the contribution of my 'y' position provided by
+     *  my parent module.
+     */
+    void Flip( int aTranslationY );
 
     /**
      * Function SetOrientation
      * sets the rotation angle of the pad.
-     * @param aAngle is tenths of degrees, but will soon be degrees.
+     * @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.
      */
-    void SetOrientation( double aAngle )        { m_Orient = aAngle; }    // manage migration to degrees
+    void SetOrientation( double aAngle );
 
     /**
      * Function GetOrientation
@@ -239,25 +188,25 @@ public:
      */
     double  GetOrientation() const { return m_Orient; }
 
-    void SetDrillShape( int aDrillShape )       { m_DrillShape = aDrillShape; }
+    void SetDrillShape( PAD_SHAPE_T aDrillShape ) { m_DrillShape = aDrillShape; }
-    int GetDrillShape() const                   { return m_DrillShape; }
+    PAD_SHAPE_T GetDrillShape() const           { return m_DrillShape; }
 
     void SetLayerMask( int aLayerMask )         { m_layerMask = aLayerMask; }
     int GetLayerMask() const                    { return m_layerMask; }
 
-    void SetAttribute( int aAttribute )         { m_Attribut = aAttribute; }
+    void SetAttribute( PAD_ATTR_T aAttribute )  { m_Attribute = aAttribute; }
-    int GetAttribute() const                    { return m_Attribut; }
+    PAD_ATTR_T GetAttribute() const             { return m_Attribute; }
 
     void SetDieLength( int aLength )            { m_LengthDie = aLength; }
     int GetDieLength() const                    { return m_LengthDie; }
 
-    int GetLocalSolderMaskMargin() const { return m_LocalSolderMaskMargin; }
+    int GetLocalSolderMaskMargin() const        { return m_LocalSolderMaskMargin; }
     void SetLocalSolderMaskMargin( int aMargin ) { m_LocalSolderMaskMargin = aMargin; }
 
-    int GetLocalClearance() const { return m_LocalClearance; }
+    int GetLocalClearance() const               { return m_LocalClearance; }
-    void SetLocalClearance( int aClearance ) { m_LocalClearance = aClearance; }
+    void SetLocalClearance( int aClearance )    { m_LocalClearance = aClearance; }
 
-    int GetLocalSolderPasteMargin() const { return m_LocalSolderPasteMargin; }
+    int GetLocalSolderPasteMargin() const       { return m_LocalSolderPasteMargin; }
     void SetLocalSolderPasteMargin( int aMargin ) { m_LocalSolderPasteMargin = aMargin; }
 
     double GetLocalSolderPasteMarginRatio() const { return m_LocalSolderPasteMarginRatio; }
@@ -382,18 +331,29 @@ public:
 
     void ReturnStringPadName( wxString& text ) const; // Return pad name as string in a buffer
 
-    void ComputeShapeMaxRadius();                           // compute radius
+    /**
-
+     * Function GetBoundingRadius
-    int GetMaxRadius() const;
+     * returns the radius of a minimum sized circle which fully encloses this pad.
+     */
+    int GetBoundingRadius()
+    {
+        // Any member function which would affect this calculation should set
+        // m_boundingRadius to -1 to re-trigger the calculation from here.
+        // Currently that is only m_Size, m_DeltaSize, and m_PadShape accessors.
+        if( m_boundingRadius == -1 )
+        {
+            m_boundingRadius = boundingRadius();
+        }
+        return m_boundingRadius;
+    }
 
     const wxPoint ReturnShapePos();
 
     /**
-     * Function GetNet
+     * Function GetSubRatsnest
      * @return int - the netcode
      */
     int GetSubRatsnest() const { return m_SubRatsnest; }
-
     void SetSubRatsnest( int aSubRatsnest ) { m_SubRatsnest = aSubRatsnest; }
 
 
@@ -475,13 +435,101 @@ public:
      */
     wxString ShowPadAttr() const;
 
+    /**
+     * 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 );
+
 #if defined(DEBUG)
     void Show( int nestLevel, std::ostream& os ) const;     // overload
 #endif
 
+
 private:
     virtual EDA_ITEM* doClone() const;
+
+    /**
+     * Function boundingRadius
+     * returns a calculated radius of a bounding circle for this pad.
+     */
+    int boundingRadius() const;
+
+    int         m_boundingRadius;  ///< radius of the circle containing the pad shape
+
+
+    wxString    m_Netname;         ///< Full net name like /mysheet/mysubsheet/vout used by Eeschema
+    wxString    m_ShortNetname;    ///< short net name, like vout from /mysheet/mysubsheet/vout
+
+    /// 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
+
+    PAD_SHAPE_T m_PadShape;         ///< Shape: PAD_CIRCLE, PAD_RECT, PAD_OVAL, PAD_TRAPEZOID
+
+
+    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)
+
+    PAD_SHAPE_T m_DrillShape;       ///< Shape PAD_CIRCLE, PAD_OVAL
+
+    /**
+     * m_Offset is useful only for oblong pads (it can be used for other
+     * shapes, but without any interest).
+     * this is the offset between the pad hole and the pad shape (you must
+     * 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.
+     * D_PAD::ReturnShapePos() returns the physical shape position according to
+     * the offset and the pad rotation.
+     */
+    wxPoint     m_Offset;
+
+    int         m_layerMask;        ///< Bitwise layer :1= copper layer, 15= cmp,
+                                    ///< 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
+
+    int         m_LengthDie;            ///< Length net from pad to die on chip
+
+    /// 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
 };
 
-
+#endif  // PAD_H_
-#endif     // _PAD_H_

pcbnew/class_pad_draw_functions.cpp

@@ -234,7 +234,7 @@ void D_PAD::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, int aDraw_mode, const wxPoi
     }
 
     // if PAD_SMD pad and high contrast mode
-    if( ( m_Attribut == PAD_SMD || m_Attribut == PAD_CONN ) && DisplayOpt.ContrastModeDisplay )
+    if( ( GetAttribute() == PAD_SMD || GetAttribute() == PAD_CONN ) && DisplayOpt.ContrastModeDisplay )
     {
         // when routing tracks
         if( frame && frame->GetToolId() == ID_TRACK_BUTT )
@@ -346,7 +346,7 @@ void D_PAD::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, int aDraw_mode, const wxPoi
     if( ( m_layerMask & ALL_CU_LAYERS ) == 0 )
         DisplayIsol = false;
 
-    if( m_Attribut == PAD_HOLE_NOT_PLATED )
+    if( GetAttribute() == PAD_HOLE_NOT_PLATED )
         drawInfo.m_ShowNotPlatedHole = true;
 
     drawInfo.m_DrawMode    = aDraw_mode;

pcbnew/clean.cpp

@@ -37,7 +37,7 @@
 #include <class_board.h>
 #include <class_track.h>
 
-/* local functions : */
+// local functions :
 static void     clean_segments( PCB_EDIT_FRAME* aFrame );
 static void     clean_vias( BOARD* aPcb );
 static void     DeleteUnconnectedTracks( PCB_EDIT_FRAME* aFrame );
@@ -93,7 +93,7 @@ void CleanupTracks( PCB_EDIT_FRAME* aFrame,
     aFrame->GetScreen()->ClearUndoRedoList();
     aFrame->SetCurItem( NULL );
 
-    /* Rebuild the pad infos (pad list and netcodes) to ensure an up to date info */
+    // Rebuild the pad infos (pad list and netcodes) to ensure an up to date info
     aFrame->GetBoard()->m_Status_Pcb = 0;
     aFrame->GetBoard()->BuildListOfNets();
 
@@ -110,22 +110,22 @@ void CleanupTracks( PCB_EDIT_FRAME* aFrame,
     {
         aFrame->SetStatusText( _( "Reconnect pads" ) );
 
-        /* Create missing segments when a track end covers a pad, but is not on the pad center */
+        // Create missing segments when a track end covers a pad, but is not on the pad center
         ConnectDanglingEndToPad( aFrame );
 
-        /* Create missing segments when a track end covers a via, but is not on the via center */
+        // Create missing segments when a track end covers a via, but is not on the via center
         ConnectDanglingEndToVia( aFrame->GetBoard() );
     }
 #endif
 
-    /* Remove null segments and intermediate points on aligned segments */
+    // Remove null segments and intermediate points on aligned segments
     if( aMergeSegments )
     {
         aFrame->SetStatusText( _( "Merge track segments" ) );
         clean_segments( aFrame );
     }
 
-    /* Delete dangling tracks */
+    // Delete dangling tracks
     if( aDeleteUnconnectedSegm )
     {
         aFrame->SetStatusText( _( "Delete unconnected tracks" ) );
@@ -163,13 +163,13 @@ void clean_vias( BOARD * aPcb )
             if( alt_track->m_Start != track->m_Start )
                 continue;
 
-            /* delete via */
+            // delete via
             alt_track->UnLink();
             delete alt_track;
         }
     }
 
-    /* Delete Via on pads at same location */
+    // Delete Via on pads at same location
     for( track = aPcb->m_Track; track != NULL; track = next_track )
     {
         next_track = track->Next();
@@ -179,9 +179,9 @@ void clean_vias( BOARD * aPcb )
 
         D_PAD* pad = aPcb->GetPadFast( track->m_Start, ALL_CU_LAYERS );
 
-        if( pad && (pad->m_layerMask & EXTERNAL_LAYERS) == EXTERNAL_LAYERS )    // redundant Via
+        if( pad && (pad->GetLayerMask() & EXTERNAL_LAYERS) == EXTERNAL_LAYERS )    // redundant Via
         {
-            /* delete via */
+            // delete via
             track->UnLink();
             delete track;
         }
@@ -243,7 +243,7 @@ static void DeleteUnconnectedTracks( PCB_EDIT_FRAME* aFrame )
         flag_erase = 0; //Not connected indicator
         type_end = 0;
 
-        /* Is a pad found on a track end ? */
+        // Is a pad found on a track end ?
 
         masklayer = segment->ReturnMaskLayer();
 
@@ -403,7 +403,7 @@ static void DeleteUnconnectedTracks( PCB_EDIT_FRAME* aFrame )
 }
 
 
-/* Delete null length segments, and intermediate points .. */
+// Delete null length segments, and intermediate points ..
 static void clean_segments( PCB_EDIT_FRAME* aFrame )
 {
     TRACK*          segment, * nextsegment;
@@ -422,11 +422,11 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
         if( !segment->IsNull() )
             continue;
 
-        /* Length segment = 0; delete it */
+        // Length segment = 0; delete it
         segment->DeleteStructure();
     }
 
-    /* Delete redundant segments */
+    // Delete redundant segments
     for( segment  = aFrame->GetBoard()->m_Track, ii = 0;  segment;  segment = segment->Next(), ii++ )
     {
         for( other = segment->Next(); other; other = nextsegment )
@@ -455,7 +455,7 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
                     erase = 1;
             }
 
-            /* Delete redundant point */
+            // Delete redundant point
             if( erase )
             {
                 ii--;
@@ -464,7 +464,7 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
         }
     }
 
-    /* delete intermediate points  */
+    // delete intermediate points
     ii = 0;
 
     for( segment = aFrame->GetBoard()->m_Track;  segment;  segment = nextsegment )
@@ -498,13 +498,13 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
                 if( segStart->Type() != PCB_TRACE_T )
                     break;
 
-                /* We must have only one segment connected */
+                // We must have only one segment connected
                 segStart->SetState( BUSY, ON );
                 other = segment->GetTrace( aFrame->GetBoard()->m_Track, NULL, START );
                 segStart->SetState( BUSY, OFF );
 
                 if( other == NULL )
-                    flag = 1;           /* OK */
+                    flag = 1;           // OK
 
                 break;
             }
@@ -523,7 +523,7 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
             }
         }
 
-        /* search for a possible point that connects on the END point of the segment: */
+        // search for a possible point that connects on the END point of the segment:
         for( segEnd = segment->Next(); ; )
         {
             segEnd = segment->GetTrace( segEnd, NULL, END );
@@ -536,13 +536,13 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
                 if( segEnd->Type() != PCB_TRACE_T )
                     break;
 
-                /* We must have only one segment connected */
+                // We must have only one segment connected
                 segEnd->SetState( BUSY, ON );
                 other = segment->GetTrace( aFrame->GetBoard()->m_Track, NULL, END );
                 segEnd->SetState( BUSY, OFF );
 
                 if( other == NULL )
-                    flag |= 2;          /* Ok */
+                    flag |= 2;          // Ok
 
                 break;
             }
@@ -563,7 +563,7 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
             }
         }
 
-        if( no_inc ) /* The current segment was modified, retry to merge it */
+        if( no_inc ) // The current segment was modified, retry to merge it
             nextsegment = segment->Next();
     }
 
@@ -571,7 +571,7 @@ static void clean_segments( PCB_EDIT_FRAME* aFrame )
 }
 
 
-/* Function used by clean_segments.
+/** Function used by clean_segments.
  *  Test alignment of aTrackRef and aCandidate (which must have a common end).
  *  and see if the common point is not on a pad (i.e. if this common point can be removed).
  *  the ending point of pt_ref is the start point (aEndType == START)
@@ -876,15 +876,15 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* aFrame )
         if( pad )
         {
             // test if the track start point is not exactly starting on the pad
-            if( segment->m_Start != pad->m_Pos )
+            if( segment->m_Start != pad->GetPosition() )
             {
                 if( segment->GetTrace( aFrame->GetBoard()->m_Track, NULL, START ) == NULL )
                 {
-                    TRACK* newTrack = (TRACK*)segment->Clone();
+                    TRACK* newTrack = (TRACK*) segment->Clone();
 
                     aFrame->GetBoard()->m_Track.Insert( newTrack, segment->Next() );
 
-                    newTrack->m_End = pad->m_Pos;
+                    newTrack->m_End = pad->GetPosition();
                     newTrack->start = segment;
                     newTrack->end   = pad;
 
@@ -898,7 +898,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* aFrame )
         if( pad )
         {
             // test if the track end point is not exactly on the pad
-            if( segment->m_End != pad->m_Pos )
+            if( segment->m_End != pad->GetPosition() )
             {
                 if( segment->GetTrace( aFrame->GetBoard()->m_Track, NULL, END ) == NULL )
                 {
@@ -906,7 +906,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* aFrame )
 
                     aFrame->GetBoard()->m_Track.Insert( newTrack, segment->Next() );
 
-                    newTrack->m_Start = pad->m_Pos;
+                    newTrack->m_Start = pad->GetPosition();
 
                     newTrack->start = pad;
                     newTrack->end   = segment;

pcbnew/collectors.cpp

@@ -235,8 +235,8 @@ SEARCH_RESULT GENERAL_COLLECTOR::Inspect( EDA_ITEM* testItem, const void* testDa
         // for through pads: pads on Front or Back board sides must be seen
         pad = (D_PAD*) item;
 
-        if( (pad->m_Attribut != PAD_SMD) &&
+        if( (pad->GetAttribute() != PAD_SMD) &&
-            (pad->m_Attribut != PAD_CONN) )    // a hole is present, so multiple layers
+            (pad->GetAttribute() != PAD_CONN) )    // a hole is present, so multiple layers
         {
             // proceed to the common tests below, but without the parent module test,
             // by leaving module==NULL, but having pad != null

pcbnew/connect.cpp

@@ -42,7 +42,7 @@
 extern void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb );
 extern void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb, int aNetcode );
 
-/* Local functions */
+// Local functions
 static void RebuildTrackChain( BOARD* pcb );
 
 
@@ -276,7 +276,9 @@ void CONNECTIONS::SearchConnectionsPadsToIntersectingPads()
         D_PAD * pad = m_sortedPads[ii];
         pad->m_PadsConnected.clear();
         candidates.clear();
-        CollectItemsNearTo( candidates, pad->ReturnShapePos(), pad->m_ShapeMaxRadius );
+
+        CollectItemsNearTo( candidates, pad->ReturnShapePos(), pad->GetBoundingRadius() );
+
         // add pads to pad.m_PadsConnected, if they are connected
         for( unsigned jj = 0; jj < candidates.size(); jj++ )
         {
@@ -285,7 +287,7 @@ void CONNECTIONS::SearchConnectionsPadsToIntersectingPads()
             if( pad == candidate_pad )
                 continue;
 
-            if( (pad->m_layerMask & candidate_pad->m_layerMask) == 0 )
+            if( (pad->GetLayerMask() & candidate_pad->GetLayerMask()) == 0 )
                 continue;
             if( pad->HitTest( item->GetPoint() ) )
             {
@@ -311,14 +313,16 @@ void CONNECTIONS::SearchTracksConnectedToPads()
         pad->m_TracksConnected.clear();
         candidates.clear();
 
-        CollectItemsNearTo( candidates, pad->GetPosition(), pad->m_ShapeMaxRadius );
+        CollectItemsNearTo( candidates, pad->GetPosition(), pad->GetBoundingRadius() );
 
         // add this pad to track.m_PadsConnected, if it is connected
         for( unsigned jj = 0; jj < candidates.size(); jj++ )
         {
-            CONNECTED_POINT * cp_item = candidates[jj];
+            CONNECTED_POINT* cp_item = candidates[jj];
-            if( (pad->m_layerMask & cp_item->GetTrack()->ReturnMaskLayer()) == 0 )
+
+            if( (pad->GetLayerMask() & cp_item->GetTrack()->ReturnMaskLayer()) == 0 )
                 continue;
+
             if( pad->HitTest( cp_item->GetPoint() ) )
             {
                 cp_item->GetTrack()->m_PadsConnected.push_back( pad );
@@ -731,7 +735,7 @@ void CONNECTIONS::Propagate_SubNets()
                     pad->SetSubNet( curr_pad->GetSubNet() );
                 }
             }
-            else                              /* the track segment is not attached to a cluster */
+            else                              // the track segment is not attached to a cluster
             {
                 if( pad->GetSubNet() > 0 )
                 {
@@ -758,16 +762,16 @@ void CONNECTIONS::Propagate_SubNets()
     // Examine connections between trcaks and pads
     for( ; curr_track != NULL; curr_track = curr_track->Next() )
     {
-        /* First: handling connections to pads */
+        // First: handling connections to pads
         for( unsigned ii = 0; ii < curr_track->m_PadsConnected.size(); ii++ )
         {
             D_PAD * pad = curr_track->m_PadsConnected[ii];
 
-            if( curr_track->GetSubNet() )        /* the track segment is already a cluster member */
+            if( curr_track->GetSubNet() )        // the track segment is already a cluster member
             {
                 if( pad->GetSubNet() > 0 )
                 {
-                    /* The pad is already a cluster member, so we can merge the 2 clusters */
+                    // The pad is already a cluster member, so we can merge the 2 clusters
                     Merge_SubNets( pad->GetSubNet(), curr_track->GetSubNet() );
                 }
                 else
@@ -777,11 +781,11 @@ void CONNECTIONS::Propagate_SubNets()
                     pad->SetSubNet( curr_track->GetSubNet() );
                 }
             }
-            else                              /* the track segment is not attached to a cluster */
+            else                              // the track segment is not attached to a cluster
             {
                 if( pad->GetSubNet() > 0 )
                 {
-                    /* it is connected to a pad in a cluster, merge this track */
+                    // it is connected to a pad in a cluster, merge this track
                     curr_track->SetSubNet( pad->GetSubNet() );
                 }
                 else
@@ -795,13 +799,13 @@ void CONNECTIONS::Propagate_SubNets()
             }
         }
 
-        /* Test connections between segments */
+        // Test connections between segments
         for( unsigned ii = 0; ii < curr_track->m_TracksConnected.size(); ii++ )
         {
             BOARD_CONNECTED_ITEM* track = curr_track->m_TracksConnected[ii];
             if( curr_track->GetSubNet() )   // The current track is already a cluster member
             {
-                /* The other track is already a cluster member, so we can merge the 2 clusters */
+                // The other track is already a cluster member, so we can merge the 2 clusters
                 if( track->GetSubNet() )
                 {
                     Merge_SubNets( track->GetSubNet(), curr_track->GetSubNet() );
@@ -920,7 +924,7 @@ void PCB_BASE_FRAME::TestNetConnection( wxDC* aDC, int aNetCode )
 
     m_Pcb->Test_Connections_To_Copper_Areas( aNetCode );
 
-    /* Search for the first and the last segment relative to the given net code */
+    // Search for the first and the last segment relative to the given net code
     if( m_Pcb->m_Track )
     {
         CONNECTIONS connections( m_Pcb );
@@ -939,12 +943,12 @@ void PCB_BASE_FRAME::TestNetConnection( wxDC* aDC, int aNetCode )
 
     Merge_SubNets_Connected_By_CopperAreas( m_Pcb, aNetCode );
 
-    /* rebuild the active ratsnest for this net */
+    // rebuild the active ratsnest for this net
     DrawGeneralRatsnest( aDC, aNetCode );
     TestForActiveLinksInRatsnest( aNetCode );
     DrawGeneralRatsnest( aDC, aNetCode );
 
-    /* Display results */
+    // Display results
     int net_notconnected_count = 0;
     NETINFO_ITEM* net = m_Pcb->FindNet( aNetCode );
     if( net )       // Should not occur, but ...
@@ -1058,7 +1062,7 @@ void PCB_BASE_FRAME::RecalculateAllTracksNetcode()
         }
     }
 
-    /* Sort the track list by net codes: */
+    // Sort the track list by net codes:
     RebuildTrackChain( m_Pcb );
 }
 

pcbnew/dialogs/dialog_edit_module_for_BoardEditor.cpp

@@ -120,14 +120,14 @@ void DIALOG_MODULE_BOARD_EDITOR::InitBoardProperties()
     // These 2 parameters are usually < 0, so prepare entering a negative
     // value, if current is 0
     PutValueInLocalUnits( *m_SolderPasteMarginCtrl,
-                          m_CurrentModule->m_LocalSolderPasteMargin,
+                          m_CurrentModule->GetLocalSolderPasteMargin(),
                           internalUnit );
-    if( m_CurrentModule->m_LocalSolderPasteMargin == 0 )
+    if( m_CurrentModule->GetLocalSolderPasteMargin() == 0 )
         m_SolderPasteMarginCtrl->SetValue( wxT( "-" ) +
                                            m_SolderPasteMarginCtrl->GetValue() );
     msg.Printf( wxT( "%.1f" ),
-                    m_CurrentModule->m_LocalSolderPasteMarginRatio * 100.0 );
+                    m_CurrentModule->GetLocalSolderPasteMarginRatio() * 100.0 );
-    if( m_CurrentModule->m_LocalSolderPasteMarginRatio == 0.0 &&
+    if( m_CurrentModule->GetLocalSolderPasteMarginRatio() == 0.0 &&
         msg[0] == '0')  // Sometimes Printf add a sign if the value is small
         m_SolderPasteMarginRatioCtrl->SetValue( wxT("-") + msg );
     else
@@ -462,12 +462,13 @@ void DIALOG_MODULE_BOARD_EDITOR::OnOkClick( wxCommandEvent& event )
     }
 
     // Initialize masks clearances
-    m_CurrentModule->m_LocalClearance =
+    m_CurrentModule->SetLocalClearance(
-        ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl, m_Parent->GetInternalUnits() );
+        ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl, m_Parent->GetInternalUnits() ) );
-    m_CurrentModule->m_LocalSolderMaskMargin =
+    m_CurrentModule->SetLocalSolderMaskMargin(
-        ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl, m_Parent->GetInternalUnits() );
+        ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl, m_Parent->GetInternalUnits() ) );
-    m_CurrentModule->m_LocalSolderPasteMargin =
+    m_CurrentModule->SetLocalSolderPasteMargin(
-        ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl, m_Parent->GetInternalUnits() );
+        ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl, m_Parent->GetInternalUnits() ) );
+
     double dtmp = 0.0;
     msg = m_SolderPasteMarginRatioCtrl->GetValue();
     msg.ToDouble( &dtmp );
@@ -479,7 +480,7 @@ void DIALOG_MODULE_BOARD_EDITOR::OnOkClick( wxCommandEvent& event )
     if( dtmp > +100 )
         dtmp = +100;
 
-    m_CurrentModule->m_LocalSolderPasteMarginRatio = dtmp / 100;
+    m_CurrentModule->SetLocalSolderPasteMarginRatio( dtmp / 100 );
 
     // Set Module Position
     modpos.x = ReturnValueFromTextCtrl( *m_ModPositionX, PCB_INTERNAL_UNIT );

pcbnew/dialogs/dialog_edit_module_for_Modedit.cpp

@@ -61,7 +61,7 @@ void DIALOG_MODULE_MODULE_EDITOR::InitModeditProperties()
 
     m_LastSelected3DShapeIndex = -1;
 
-    /* Init 3D shape list */
+    // Init 3D shape list
     S3D_MASTER* draw3D = m_CurrentModule->m_3D_Drawings;
 
     while( draw3D )
@@ -97,7 +97,7 @@ void DIALOG_MODULE_MODULE_EDITOR::InitModeditProperties()
                                         "Use this attribute for \"virtual\" components drawn on board (like a old ISA PC bus connector)" ) );
 #endif
 
-    /* Controls on right side of the dialog */
+    // Controls on right side of the dialog
     switch( m_CurrentModule->m_Attributs & 255 )
     {
     case 0:
@@ -154,13 +154,13 @@ void DIALOG_MODULE_MODULE_EDITOR::InitModeditProperties()
                           m_CurrentModule->m_LocalSolderMaskMargin, internalUnit );
     // These 2 parameters are usually < 0, so prepare entering a negative value, if current is 0
     PutValueInLocalUnits( *m_SolderPasteMarginCtrl,
-                          m_CurrentModule->m_LocalSolderPasteMargin, internalUnit );
+                          m_CurrentModule->GetLocalSolderPasteMargin(), internalUnit );
-    if( m_CurrentModule->m_LocalSolderPasteMargin == 0 )
+    if( m_CurrentModule->GetLocalSolderPasteMargin() == 0 )
         m_SolderPasteMarginCtrl->SetValue( wxT("-") + m_SolderPasteMarginCtrl->GetValue() );
-    if( m_CurrentModule->m_LocalSolderPasteMarginRatio == 0.0 )
+    if( m_CurrentModule->GetLocalSolderPasteMarginRatio() == 0.0 )
-        msg.Printf( wxT( "-%.1f" ), m_CurrentModule->m_LocalSolderPasteMarginRatio * 100.0 );
+        msg.Printf( wxT( "-%.1f" ), m_CurrentModule->GetLocalSolderPasteMarginRatio() * 100.0 );
     else
-        msg.Printf( wxT( "%.1f" ), m_CurrentModule->m_LocalSolderPasteMarginRatio * 100.0 );
+        msg.Printf( wxT( "%.1f" ), m_CurrentModule->GetLocalSolderPasteMarginRatio() * 100.0 );
     m_SolderPasteMarginRatioCtrl->SetValue( msg );
 
     // if m_3D_ShapeNameListBox is not empty, preselect first 3D shape
@@ -369,21 +369,26 @@ void DIALOG_MODULE_MODULE_EDITOR::OnOkClick( wxCommandEvent& event )
 
     // Initialize masks clearances
     int internalUnit = m_Parent->GetInternalUnits();
-    m_CurrentModule->m_LocalClearance =
+
-        ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl, internalUnit );
+    m_CurrentModule->SetLocalClearance(
-    m_CurrentModule->m_LocalSolderMaskMargin =
+        ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl, internalUnit ) );
-        ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl, internalUnit );
+
-    m_CurrentModule->m_LocalSolderPasteMargin =
+    m_CurrentModule->SetLocalSolderMaskMargin(
-        ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl, internalUnit );
+        ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl, internalUnit ) );
+
+    m_CurrentModule->SetLocalSolderPasteMargin(
+        ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl, internalUnit ) );
     double   dtmp;
     wxString msg = m_SolderPasteMarginRatioCtrl->GetValue();
     msg.ToDouble( &dtmp );
+
     // A margin ratio de -50% means no paste on a pad, the ratio must be >= 50 %
     if( dtmp < -50 )
         dtmp = -50;
-    m_CurrentModule->m_LocalSolderPasteMarginRatio = dtmp / 100;
 
-    /* Update 3D shape list */
+    m_CurrentModule->SetLocalSolderPasteMarginRatio( dtmp / 100 );
+
+    // Update 3D shape list
     int ii = m_3D_ShapeNameListBox->GetSelection();
     if ( ii >= 0 )
         TransfertDisplayTo3DValues( ii  );

pcbnew/dialogs/dialog_gendrill.cpp

@@ -174,8 +174,7 @@ void DIALOG_GENDRILL::InitDisplayParams( void )
 
     m_MicroViaDrillValue->Enable( m_microViasCount );
 
-    /* Count plated pad holes and not plated pad holes:
+    // Count plated pad holes and not plated pad holes:
-     */
     m_platedPadsHoleCount    = 0;
     m_notplatedPadsHoleCount = 0;
 
@@ -183,11 +182,11 @@ void DIALOG_GENDRILL::InitDisplayParams( void )
     {
         for( D_PAD* pad = module->m_Pads; pad != NULL; pad = pad->Next() )
         {
-            if( pad->m_DrillShape == PAD_CIRCLE )
+            if( pad->GetDrillShape() == PAD_CIRCLE )
             {
-                if( pad->m_Drill.x != 0 )
+                if( pad->GetDrillSize().x != 0 )
                 {
-                    if( pad->m_Attribut == PAD_HOLE_NOT_PLATED )
+                    if( pad->GetAttribute() == PAD_HOLE_NOT_PLATED )
                         m_notplatedPadsHoleCount++;
                     else
                         m_platedPadsHoleCount++;
@@ -195,9 +194,9 @@ void DIALOG_GENDRILL::InitDisplayParams( void )
             }
             else
             {
-                if( min( pad->m_Drill.x, pad->m_Drill.y ) != 0 )
+                if( min( pad->GetDrillSize().x, pad->GetDrillSize().y ) != 0 )
                 {
-                    if( pad->m_Attribut == PAD_HOLE_NOT_PLATED )
+                    if( pad->GetAttribute() == PAD_HOLE_NOT_PLATED )
                         m_notplatedPadsHoleCount++;
                     else
                         m_platedPadsHoleCount++;
@@ -229,7 +228,7 @@ void DIALOG_GENDRILL::InitDisplayParams( void )
 }
 
 
-/* Save drill options: */
+// Save drill options:
 void DIALOG_GENDRILL::UpdateConfig()
 {
     SetParams();
@@ -275,7 +274,7 @@ void DIALOG_GENDRILL::OnOkClick( wxCommandEvent& event )
 
 void DIALOG_GENDRILL::OnCancelClick( wxCommandEvent& event )
 {
-    UpdateConfig();                 /* Save drill options: */
+    UpdateConfig();                 // Save drill options:
     EndModal( wxID_CANCEL );        // Process the default cancel event (close dialog)
 }
 
@@ -294,13 +293,13 @@ void DIALOG_GENDRILL::UpdatePrecisionOptions()
 {
     if( m_Choice_Unit->GetSelection()== 1 )     // Units = inches
     {
-        /* inch options   */
+        // inch options
         m_Choice_Precision->SetString( 0, precisionListForInches[0].GetPrecisionString() );
         m_Choice_Precision->SetString( 1, precisionListForInches[1].GetPrecisionString() );
     }
     else
     {
-        /* metric options */
+        // metric options
         m_Choice_Precision->SetString( 0, precisionListForMetric[0].GetPrecisionString() );
         m_Choice_Precision->SetString( 1, precisionListForMetric[1].GetPrecisionString() );
     }

pcbnew/dialogs/dialog_pad_properties.cpp

@@ -15,6 +15,7 @@
 #include <pcbcommon.h>
 
 #include <wx/dcbuffer.h>
+#include <protos.h>
 
 #include <class_board.h>
 #include <class_module.h>
@@ -22,16 +23,14 @@
 #include <dialog_pad_properties_base.h>
 
 
-#define NBSHAPES 4
+// list of pad shapes.
-int CodeShape[NBSHAPES] = // list of pad shapes.
+static PAD_SHAPE_T CodeShape[] = {
-{
     PAD_CIRCLE, PAD_OVAL, PAD_RECT, PAD_TRAPEZOID
 };
 
 
 #define NBTYPES 4
-int CodeType[NBTYPES] =
+static PAD_ATTR_T CodeType[NBTYPES] = {
-{
     PAD_STANDARD, PAD_SMD, PAD_CONN, PAD_HOLE_NOT_PLATED
 };
 
@@ -52,34 +51,35 @@ static long Std_Pad_Layers[NBTYPES] =
 };
 
 
-extern int ChangeSideMaskLayer( int masque );
-
-
 /**
  * class DIALOG_PAD_PROPERTIES, derived from DIALOG_PAD_PROPERTIES_BASE,
  * created by wxFormBuilder
  */
 class DIALOG_PAD_PROPERTIES : public DIALOG_PAD_PROPERTIES_BASE
 {
-private:
-    PCB_BASE_FRAME* m_Parent;
-    D_PAD* m_CurrentPad;            // Pad currently edited
-    D_PAD* m_dummyPad;              // a working copy used to show changes
-    BOARD* m_Board;
-    bool   m_isFlipped;             /* true if the parent footprint (therefore pads) is flipped (mirrored)
-                                     *  in this case, some Y coordinates values must be negated
-                                     */
-    bool   m_canUpdate;
-
 public:
-    DIALOG_PAD_PROPERTIES( PCB_BASE_FRAME* parent, D_PAD* Pad );
+    DIALOG_PAD_PROPERTIES( PCB_BASE_FRAME* aParent, D_PAD* aPad );
     ~DIALOG_PAD_PROPERTIES()
     {
         delete m_dummyPad;
     }
 
-
 private:
+    PCB_BASE_FRAME* m_Parent;
+
+    D_PAD*  m_CurrentPad;            // pad currently being edited
+
+    D_PAD*  m_dummyPad;              // a working copy used to show changes
+
+    BOARD*  m_Board;
+
+    D_PAD&  m_Pad_Master;
+
+    bool    m_isFlipped;            // true if the parent footprint (therefore pads) is flipped (mirrored)
+                                    // in this case, some Y coordinates values must be negated
+
+    bool    m_canUpdate;
+
     void initValues();
     void OnPadShapeSelection( wxCommandEvent& event );
     void OnDrillShapeSelected( wxCommandEvent& event );
@@ -95,6 +95,30 @@ private:
 };
 
 
+DIALOG_PAD_PROPERTIES::DIALOG_PAD_PROPERTIES( PCB_BASE_FRAME* aParent, D_PAD* aPad ) :
+    DIALOG_PAD_PROPERTIES_BASE( aParent ),
+    m_Pad_Master( aParent->GetBoard()->GetDesignSettings().m_Pad_Master )
+{
+    m_canUpdate  = false;
+    m_Parent     = aParent;
+    m_CurrentPad = aPad;
+    m_Board      = m_Parent->GetBoard();
+    m_dummyPad   = new D_PAD( (MODULE*) NULL );
+
+    if( aPad )
+        m_dummyPad->Copy( aPad );
+    else
+        m_dummyPad->Copy( &m_Pad_Master );
+
+    initValues();
+
+    m_sdbSizer1OK->SetDefault();
+    GetSizer()->SetSizeHints( this );
+    Center();
+    m_canUpdate = true;
+}
+
+
 void DIALOG_PAD_PROPERTIES::OnPaintShowPanel( wxPaintEvent& event )
 {
     wxPaintDC    dc( m_panelShowPad );
@@ -102,12 +126,12 @@ void DIALOG_PAD_PROPERTIES::OnPaintShowPanel( wxPaintEvent& event )
 
     int          color = 0;
 
-    if( m_dummyPad->m_layerMask & LAYER_FRONT )
+    if( m_dummyPad->GetLayerMask() & LAYER_FRONT )
     {
         color = m_Board->GetVisibleElementColor( PAD_FR_VISIBLE );
     }
 
-    if( m_dummyPad->m_layerMask & LAYER_BACK )
+    if( m_dummyPad->GetLayerMask() & LAYER_BACK )
     {
         color |= m_Board->GetVisibleElementColor( PAD_BK_VISIBLE );
     }
@@ -117,26 +141,30 @@ void DIALOG_PAD_PROPERTIES::OnPaintShowPanel( wxPaintEvent& event )
 
     drawInfo.m_Color     = color;
     drawInfo.m_HoleColor = DARKGRAY;
-    drawInfo.m_Offset    = m_dummyPad->m_Pos;
+    drawInfo.m_Offset    = m_dummyPad->GetPosition();
     drawInfo.m_Display_padnum  = true;
     drawInfo.m_Display_netname = true;
-    if( m_dummyPad->m_Attribut == PAD_HOLE_NOT_PLATED )
+    if( m_dummyPad->GetAttribute() == PAD_HOLE_NOT_PLATED )
         drawInfo.m_ShowNotPlatedHole = true;
 
     // Shows the local pad clearance
-    drawInfo.m_PadClearance = m_dummyPad->m_LocalClearance;
+    drawInfo.m_PadClearance = m_dummyPad->GetLocalClearance();
 
     wxSize dc_size = dc.GetSize();
     dc.SetDeviceOrigin( dc_size.x / 2, dc_size.y / 2 );
 
     // Calculate a suitable scale to fit the available draw area
-    int dim = m_dummyPad->m_Size.x + ABS( m_dummyPad->m_DeltaSize.y);
+    int dim = m_dummyPad->GetSize().x + ABS( m_dummyPad->GetDelta().y);
-    if( m_dummyPad->m_LocalClearance > 0 )
+
-        dim += m_dummyPad->m_LocalClearance * 2;
+    if( m_dummyPad->GetLocalClearance() > 0 )
-    double scale    = (double) dc_size.x / dim;
+        dim += m_dummyPad->GetLocalClearance() * 2;
-    dim = m_dummyPad->m_Size.y + ABS( m_dummyPad->m_DeltaSize.x);
+
-    if( m_dummyPad->m_LocalClearance > 0 )
+    double scale = (double) dc_size.x / dim;
-        dim += m_dummyPad->m_LocalClearance * 2;
+
+    dim = m_dummyPad->GetSize().y + ABS( m_dummyPad->GetDelta().x);
+    if( m_dummyPad->GetLocalClearance() > 0 )
+        dim += m_dummyPad->GetLocalClearance() * 2;
+
     double altscale = (double) dc_size.y / dim;
     scale = MIN( scale, altscale );
 
@@ -151,31 +179,6 @@ void DIALOG_PAD_PROPERTIES::OnPaintShowPanel( wxPaintEvent& event )
 }
 
 
-/*******************************************************************************************/
-DIALOG_PAD_PROPERTIES::DIALOG_PAD_PROPERTIES( PCB_BASE_FRAME* parent, D_PAD* Pad ) :
-    DIALOG_PAD_PROPERTIES_BASE( parent )
-/*******************************************************************************************/
-{
-    m_canUpdate  = false;
-    m_Parent     = parent;
-    m_CurrentPad = Pad;
-    m_Board    = m_Parent->GetBoard();
-    m_dummyPad = new D_PAD( (MODULE*) NULL );
-
-    if( m_CurrentPad )
-        m_dummyPad->Copy( m_CurrentPad );
-    else
-        m_dummyPad->Copy( &g_Pad_Master );
-
-    initValues();
-
-    m_sdbSizer1OK->SetDefault();
-    GetSizer()->SetSizeHints( this );
-    Center();
-    m_canUpdate = true;
-}
-
-
 void PCB_BASE_FRAME::InstallPadOptionsFrame( D_PAD* Pad )
 {
     DIALOG_PAD_PROPERTIES dlg( this, Pad );
@@ -188,30 +191,42 @@ void PCB_BASE_FRAME::InstallPadOptionsFrame( D_PAD* Pad )
 void DIALOG_PAD_PROPERTIES::initValues()
 /***************************************/
 {
-    SetFocus();     // Required under wxGTK if we want to demiss the dialog with the ESC key
+    SetFocus();     // Required under wxGTK if we want to dismiss the dialog with the ESC key
+
+    int         internalUnits = m_Parent->GetInternalUnits();
+    wxString    msg;
+    double      angle;
 
-    int internalUnits = m_Parent->GetInternalUnits();
-    wxString msg;
     m_isFlipped = false;
+
     if( m_CurrentPad )
     {
-        MODULE* Module = (MODULE*) m_CurrentPad->GetParent();
+        MODULE* module = m_CurrentPad->GetParent();
-        if( Module->GetLayer() ==  LAYER_N_BACK )
+
+        if( module->GetLayer() == LAYER_N_BACK )
         {
             m_isFlipped = true;
             m_staticModuleSideValue->SetLabel( _( "Back side (footprint is mirrored)" ) );
         }
-        msg.Printf( wxT( "%.1f" ), (double) Module->m_Orient / 10 );
+
+        msg.Printf( wxT( "%.1f" ), (double) module->GetOrientation() / 10 );
         m_staticModuleRotValue->SetLabel( msg );
     }
 
     if( m_isFlipped )
     {
-        NEGATE( m_dummyPad->m_Offset.y );
+        wxPoint pt = m_dummyPad->GetOffset();
-        NEGATE( m_dummyPad->m_DeltaSize.y );
+        NEGATE( pt.y );
-        /* flip pads layers*/
+        m_dummyPad->SetOffset( pt );
-        m_dummyPad->m_layerMask = ChangeSideMaskLayer( m_dummyPad->m_layerMask );
+
+        wxSize sz = m_dummyPad->GetDelta();
+        NEGATE( sz.y );
+        m_dummyPad->SetDelta( sz );
+
+        // flip pad's layers
+        m_dummyPad->SetLayerMask( ChangeSideMaskLayer( m_dummyPad->GetLayerMask() ) );
     }
+
     m_staticTextWarningPadFlipped->Show(m_isFlipped);
 
     m_PadNumCtrl->SetValue( m_dummyPad->GetPadName() );
@@ -236,70 +251,73 @@ void DIALOG_PAD_PROPERTIES::initValues()
     m_SolderPasteMarginUnits->SetLabel( GetUnitsLabel( g_UserUnit ) );
 
     // Display current pad parameters units:
-    PutValueInLocalUnits( *m_PadPosition_X_Ctrl, m_dummyPad->m_Pos.x, internalUnits );
+    PutValueInLocalUnits( *m_PadPosition_X_Ctrl, m_dummyPad->GetPosition().x, internalUnits );
-    PutValueInLocalUnits( *m_PadPosition_Y_Ctrl, m_dummyPad->m_Pos.y, internalUnits );
+    PutValueInLocalUnits( *m_PadPosition_Y_Ctrl, m_dummyPad->GetPosition().y, internalUnits );
 
-    PutValueInLocalUnits( *m_PadDrill_X_Ctrl, m_dummyPad->m_Drill.x, internalUnits );
+    PutValueInLocalUnits( *m_PadDrill_X_Ctrl, m_dummyPad->GetDrillSize().x, internalUnits );
-    PutValueInLocalUnits( *m_PadDrill_Y_Ctrl, m_dummyPad->m_Drill.y, internalUnits );
+    PutValueInLocalUnits( *m_PadDrill_Y_Ctrl, m_dummyPad->GetDrillSize().y, internalUnits );
 
-    PutValueInLocalUnits( *m_ShapeSize_X_Ctrl, m_dummyPad->m_Size.x, internalUnits );
+    PutValueInLocalUnits( *m_ShapeSize_X_Ctrl, m_dummyPad->GetSize().x, internalUnits );
-    PutValueInLocalUnits( *m_ShapeSize_Y_Ctrl, m_dummyPad->m_Size.y, internalUnits );
+    PutValueInLocalUnits( *m_ShapeSize_Y_Ctrl, m_dummyPad->GetSize().y, internalUnits );
 
-    PutValueInLocalUnits( *m_ShapeOffset_X_Ctrl, m_dummyPad->m_Offset.x, internalUnits );
+    PutValueInLocalUnits( *m_ShapeOffset_X_Ctrl, m_dummyPad->GetOffset().x, internalUnits );
-    PutValueInLocalUnits( *m_ShapeOffset_Y_Ctrl, m_dummyPad->m_Offset.y, internalUnits );
+    PutValueInLocalUnits( *m_ShapeOffset_Y_Ctrl, m_dummyPad->GetOffset().y, internalUnits );
 
-    if( m_dummyPad->m_DeltaSize.x )
+    if( m_dummyPad->GetDelta().x )
     {
-        PutValueInLocalUnits( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.x, internalUnits );
+        PutValueInLocalUnits( *m_ShapeDelta_Ctrl, m_dummyPad->GetDelta().x, internalUnits );
         m_radioBtnDeltaXdir->SetValue(true);
     }
     else
     {
-        PutValueInLocalUnits( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.y, internalUnits );
+        PutValueInLocalUnits( *m_ShapeDelta_Ctrl, m_dummyPad->GetDelta().y, internalUnits );
         m_radioBtnDeltaYdir->SetValue(true);
     }
 
-    PutValueInLocalUnits( *m_LengthDieCtrl, m_dummyPad->m_LengthDie, internalUnits );
+    PutValueInLocalUnits( *m_LengthDieCtrl, m_dummyPad->GetDieLength(), internalUnits );
 
-    PutValueInLocalUnits( *m_NetClearanceValueCtrl, m_dummyPad->m_LocalClearance, internalUnits );
+    PutValueInLocalUnits( *m_NetClearanceValueCtrl, m_dummyPad->GetLocalClearance(), internalUnits );
     PutValueInLocalUnits( *m_SolderMaskMarginCtrl,
-                          m_dummyPad->m_LocalSolderMaskMargin,
+                          m_dummyPad->GetLocalSolderMaskMargin(),
                           internalUnits );
 
     // These 2 parameters are usually < 0, so prepare entering a negative value, if current is 0
     PutValueInLocalUnits( *m_SolderPasteMarginCtrl,
-                          m_dummyPad->m_LocalSolderPasteMargin,
+                          m_dummyPad->GetLocalSolderPasteMargin(),
                           internalUnits );
-    if( m_dummyPad->m_LocalSolderPasteMargin == 0 )
-        m_SolderPasteMarginCtrl->SetValue( wxT( "-" ) + m_SolderPasteMarginCtrl->GetValue() );
-    msg.Printf( wxT( "%.1f" ), m_dummyPad->m_LocalSolderPasteMarginRatio * 100.0 );
 
-    if( m_dummyPad->m_LocalSolderPasteMarginRatio == 0.0
+    if( m_dummyPad->GetLocalSolderPasteMargin() == 0 )
-        && msg[0] == '0' ) // Sometimes Printf add a sign if the value is small
+        m_SolderPasteMarginCtrl->SetValue( wxT( "-" ) + m_SolderPasteMarginCtrl->GetValue() );
+
+    msg.Printf( wxT( "%.1f" ), m_dummyPad->GetLocalSolderPasteMarginRatio() * 100.0 );
+
+    if( m_dummyPad->GetLocalSolderPasteMarginRatio() == 0.0 && msg[0] == '0' )
+        // Sometimes Printf adds a sign if the value is small
         m_SolderPasteMarginRatioCtrl->SetValue( wxT( "-" ) + msg );
     else
         m_SolderPasteMarginRatioCtrl->SetValue( msg );
 
     if( m_CurrentPad )
     {
-        MODULE* Module = (MODULE*) m_CurrentPad->GetParent();
+        MODULE* module = m_CurrentPad->GetParent();
-        m_dummyPad->m_Orient = m_CurrentPad->m_Orient - Module->m_Orient;
+
+        angle = m_CurrentPad->GetOrientation() - module->GetOrientation();
+
         if( m_isFlipped )
-            NEGATE( m_dummyPad->m_Orient );
+            NEGATE( angle );
+
+        m_dummyPad->SetOrientation( angle );
     }
 
-    // adjust rotation agngle to -1800 to 1800 in internal units (0.1 deg)
+    angle = m_dummyPad->GetOrientation();
-    NORMALIZE_ANGLE_180( m_dummyPad->m_Orient );
+
+    NORMALIZE_ANGLE_180( angle );    // ? normalizing is in D_PAD::SetOrientation()
 
     // Set layers used by this pad: :
-    SetPadLayersList( m_dummyPad->m_layerMask );
+    SetPadLayersList( m_dummyPad->GetLayerMask() );
-
-    msg.Clear();
-    msg << m_dummyPad->m_Orient;
-    m_PadOrientCtrl->SetValue( msg );
 
     // Pad Orient
-    switch( int( m_dummyPad->GetOrientation() ) )
+    switch( int( angle ) )
     {
     case 0:
         m_PadOrient->SetSelection( 0 );
@@ -323,7 +341,7 @@ void DIALOG_PAD_PROPERTIES::initValues()
         break;
     }
 
-    switch( m_dummyPad->m_PadShape )
+    switch( m_dummyPad->GetShape() )
     {
     default:
     case PAD_CIRCLE:
@@ -343,14 +361,15 @@ void DIALOG_PAD_PROPERTIES::initValues()
         break;
     }
 
-    msg.Printf( wxT( "%g" ), m_dummyPad->GetOrientation() );
+    msg.Printf( wxT( "%g" ), angle );
     m_PadOrientCtrl->SetValue( msg );
 
     // Type of pad selection
     m_PadType->SetSelection( 0 );
+
     for( int ii = 0; ii < NBTYPES; ii++ )
     {
-        if( CodeType[ii] == m_dummyPad->m_Attribut )
+        if( CodeType[ii] == m_dummyPad->GetAttribute() )
         {
             m_PadType->SetSelection( ii );
             break;
@@ -359,12 +378,13 @@ void DIALOG_PAD_PROPERTIES::initValues()
 
     // Enable/disable Pad name,and pad length die
     // (disable for NPTH pads (mechanical pads)
-    bool enable = m_dummyPad->m_Attribut != PAD_HOLE_NOT_PLATED;
+    bool enable = m_dummyPad->GetAttribute() != PAD_HOLE_NOT_PLATED;
+
     m_PadNumCtrl->Enable( enable );
     m_PadNetNameCtrl->Enable( enable );
     m_LengthDieCtrl->Enable( enable );
 
-    if( m_dummyPad->m_DrillShape != PAD_OVAL )
+    if( m_dummyPad->GetDrillShape() != PAD_OVAL )
         m_DrillShapeCtrl->SetSelection( 0 );
     else
         m_DrillShapeCtrl->SetSelection( 1 );
@@ -386,9 +406,7 @@ void DIALOG_PAD_PROPERTIES::initValues()
     m_PadLayerECO2->SetLabel( m_Board->GetLayerName( ECO2_N ) );
     m_PadLayerDraft->SetLabel( m_Board->GetLayerName( DRAW_N ) );
 
-    /* All init are done,
+    // Update some dialog widgets state (Enable/disable options):
-     * Update some dialog widgets state (Enable/disable options):
-     */
     wxCommandEvent cmd_event;
     OnPadShapeSelection( cmd_event );
     OnDrillShapeSelected( cmd_event );
@@ -439,7 +457,7 @@ void DIALOG_PAD_PROPERTIES::OnPadShapeSelection( wxCommandEvent& event )
 void DIALOG_PAD_PROPERTIES::OnDrillShapeSelected( wxCommandEvent& event )
 /**********************************************************************/
 {
-    if( (m_PadType->GetSelection() == 1) || (m_PadType->GetSelection() == 2) )
+    if( m_PadType->GetSelection() == 1 || m_PadType->GetSelection() == 2 )
     {
         // pad type = SMD or CONN: no hole allowed
         m_PadDrill_X_Ctrl->Enable( false );
@@ -473,19 +491,19 @@ void DIALOG_PAD_PROPERTIES::PadOrientEvent( wxCommandEvent& event )
     switch( m_PadOrient->GetSelection() )
     {
     case 0:
-        m_dummyPad->m_Orient = 0;
+        m_dummyPad->SetOrientation( 0 );
         break;
 
     case 1:
-        m_dummyPad->m_Orient = 900;
+        m_dummyPad->SetOrientation( 900 );
         break;
 
     case 2:
-        m_dummyPad->m_Orient = -900;
+        m_dummyPad->SetOrientation( -900 );
         break;
 
     case 3:
-        m_dummyPad->m_Orient = 1800;
+        m_dummyPad->SetOrientation( 1800 );
         break;
 
     default:
@@ -590,13 +608,15 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event )
     if( !success )  // An error on parameters has occured
         return;
 
-    TransfertDataToPad( &g_Pad_Master, false );
+    TransfertDataToPad( &m_Pad_Master, false );
 
     if( m_CurrentPad )   // Set current Pad parameters
     {
-        MODULE* Module = (MODULE*) m_CurrentPad->GetParent();
+        wxSize  size;
-        m_Parent->SaveCopyInUndoList( Module, UR_CHANGED );
+        MODULE* module = m_CurrentPad->GetParent();
-        Module->m_LastEdit_Time = time( NULL );
+
+        m_Parent->SaveCopyInUndoList( module, UR_CHANGED );
+        module->m_LastEdit_Time = time( NULL );
 
         // redraw the area where the pad was, without pad (delete pad on screen)
         m_CurrentPad->SetFlags( DO_NOT_DRAW );
@@ -604,45 +624,54 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event )
         m_CurrentPad->ClearFlags( DO_NOT_DRAW );
 
         // Update values
-        m_CurrentPad->m_PadShape = g_Pad_Master.m_PadShape;
+        m_CurrentPad->SetShape( m_Pad_Master.GetShape() );
-        m_CurrentPad->m_Attribut = g_Pad_Master.m_Attribut;
+        m_CurrentPad->SetAttribute( m_Pad_Master.GetAttribute() );
 
-        if( m_CurrentPad->m_Pos != g_Pad_Master.m_Pos )
+        if( m_CurrentPad->GetPosition() != m_Pad_Master.GetPosition() )
         {
-            m_CurrentPad->m_Pos = g_Pad_Master.m_Pos;
+            m_CurrentPad->SetPosition( m_Pad_Master.GetPosition() );
-            rastnestIsChanged   = true;
+            rastnestIsChanged = true;
         }
 
-        /* compute the pos 0 value, i.e. pad position for module orient = 0 i.e.
+        // compute the pos 0 value, i.e. pad position for module with orientation = 0
-         *  refer to module origin (module position) */
+        // i.e. relative to module origin (module position)
-        m_CurrentPad->m_Pos0   = m_CurrentPad->m_Pos;
+        wxPoint pt = m_CurrentPad->GetPosition() - module->GetPosition();
-        m_CurrentPad->m_Pos0  -= Module->m_Pos;
-        m_CurrentPad->m_Orient = (g_Pad_Master.m_Orient * isign) + Module->m_Orient;
-        RotatePoint( &m_CurrentPad->m_Pos0.x, &m_CurrentPad->m_Pos0.y, -Module->m_Orient );
 
-        m_CurrentPad->m_Size = g_Pad_Master.m_Size;
+        RotatePoint( &pt, -module->GetOrientation() );
-        m_CurrentPad->m_DeltaSize    = g_Pad_Master.m_DeltaSize;
-        m_CurrentPad->m_DeltaSize.y *= isign;
-        m_CurrentPad->m_Drill = g_Pad_Master.m_Drill;
-        m_CurrentPad->m_DrillShape = g_Pad_Master.m_DrillShape;
-        m_CurrentPad->m_Offset     = g_Pad_Master.m_Offset;
-        m_CurrentPad->m_Offset.y  *= isign;
 
-        m_CurrentPad->m_LengthDie = g_Pad_Master.m_LengthDie;
+        m_CurrentPad->SetPos0( pt );
 
-        if( m_CurrentPad->m_layerMask != g_Pad_Master.m_layerMask )
+        m_CurrentPad->SetOrientation( m_Pad_Master.GetOrientation() * isign + module->GetOrientation() );
+
+        m_CurrentPad->SetSize(  m_Pad_Master.GetSize() );
+
+        size = m_Pad_Master.GetDelta();
+        size.y *= isign;
+        m_CurrentPad->SetDelta( size );
+
+        m_CurrentPad->SetDrillSize( m_Pad_Master.GetDrillSize() );
+        m_CurrentPad->SetDrillShape( m_Pad_Master.GetDrillShape() );
+
+        wxPoint offset = m_Pad_Master.GetOffset();
+        offset.y *= isign;
+        m_CurrentPad->SetOffset( offset );
+
+        m_CurrentPad->SetDieLength( m_Pad_Master.GetDieLength() );
+
+        if( m_CurrentPad->GetLayerMask() != m_Pad_Master.GetLayerMask() )
         {
             rastnestIsChanged = true;
-            m_CurrentPad->m_layerMask = g_Pad_Master.m_layerMask;
+            m_CurrentPad->SetLayerMask( m_Pad_Master.GetLayerMask() );
         }
+
         if( m_isFlipped )
-            m_CurrentPad->m_layerMask = ChangeSideMaskLayer( m_CurrentPad->m_layerMask );
+            m_CurrentPad->SetLayerMask( ChangeSideMaskLayer( m_CurrentPad->GetLayerMask() ) );
 
-        m_CurrentPad->SetPadName( g_Pad_Master.GetPadName() );
+        m_CurrentPad->SetPadName( m_Pad_Master.GetPadName() );
 
-        if( m_CurrentPad->GetNetname() != g_Pad_Master.GetNetname() )
+        if( m_CurrentPad->GetNetname() != m_Pad_Master.GetNetname() )
         {
-            if( g_Pad_Master.GetNetname().IsEmpty() )
+            if( m_Pad_Master.GetNetname().IsEmpty() )
             {
                 rastnestIsChanged = true;
                 m_CurrentPad->SetNet( 0 );
@@ -650,11 +679,11 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event )
             }
             else
             {
-                const NETINFO_ITEM* net = m_Parent->GetBoard()->FindNet( g_Pad_Master.GetNetname() );
+                const NETINFO_ITEM* net = m_Parent->GetBoard()->FindNet( m_Pad_Master.GetNetname() );
                 if( net )
                 {
                     rastnestIsChanged = true;
-                    m_CurrentPad->SetNetname( g_Pad_Master.GetNetname() );
+                    m_CurrentPad->SetNetname( m_Pad_Master.GetNetname() );
                     m_CurrentPad->SetNet( net->GetNet() );
                 }
                 else
@@ -662,14 +691,12 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event )
             }
         }
 
-        m_CurrentPad->m_LocalClearance = g_Pad_Master.m_LocalClearance;
+        m_CurrentPad->SetLocalClearance( m_Pad_Master.GetLocalClearance() );
-        m_CurrentPad->m_LocalSolderMaskMargin  = g_Pad_Master.m_LocalSolderMaskMargin;
+        m_CurrentPad->SetLocalSolderMaskMargin( m_Pad_Master.GetLocalSolderMaskMargin() );
-        m_CurrentPad->m_LocalSolderPasteMargin = g_Pad_Master.m_LocalSolderPasteMargin;
+        m_CurrentPad->SetLocalSolderPasteMargin( m_Pad_Master.GetLocalSolderPasteMargin() );
-        m_CurrentPad->m_LocalSolderPasteMarginRatio = g_Pad_Master.m_LocalSolderPasteMarginRatio;
+        m_CurrentPad->SetLocalSolderPasteMarginRatio( m_Pad_Master.GetLocalSolderPasteMarginRatio() );
 
-        m_CurrentPad->ComputeShapeMaxRadius();
+        module->CalculateBoundingBox();
-
-        Module->CalculateBoundingBox();
         m_CurrentPad->DisplayInfo( m_Parent );
 
         // redraw the area where the pad was
@@ -688,92 +715,108 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event )
 // user will be prompted for an error
 bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError )
 {
-    long     PadLayerMask;
+    long        padLayerMask;
-    int      internalUnits = m_Parent->GetInternalUnits();
+    int         internalUnits = m_Parent->GetInternalUnits();
-    wxString msg;
+    wxString    msg;
+    int         x, y;
 
-    aPad->m_Attribut = CodeType[m_PadType->GetSelection()];
+    aPad->SetAttribute( CodeType[m_PadType->GetSelection()] );
-    aPad->m_PadShape = CodeShape[m_PadShape->GetSelection()];
+    aPad->SetShape( CodeShape[m_PadShape->GetSelection()] );
 
     // Read pad clearances values:
-    aPad->m_LocalClearance = ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl,
+    aPad->SetLocalClearance( ReturnValueFromTextCtrl( *m_NetClearanceValueCtrl,
-                                                      internalUnits );
+                                                      internalUnits ) );
-    aPad->m_LocalSolderMaskMargin = ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl,
+    aPad->SetLocalSolderMaskMargin( ReturnValueFromTextCtrl( *m_SolderMaskMarginCtrl,
-                                                             internalUnits );
+                                                             internalUnits ) );
-    aPad->m_LocalSolderPasteMargin = ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl,
+    aPad->SetLocalSolderPasteMargin( ReturnValueFromTextCtrl( *m_SolderPasteMarginCtrl,
-                                                              internalUnits );
+                                                              internalUnits ) );
     double dtmp = 0.0;
     msg = m_SolderPasteMarginRatioCtrl->GetValue();
     msg.ToDouble( &dtmp );
 
-    // A margin ratio de -50% means no paste on a pad, the ratio must be >= 50 %
+    // A margin ratio of -50% means no paste on a pad, the ratio must be >= 50 %
     if( dtmp < -50 )
         dtmp = -50;
     if( dtmp > +100 )
         dtmp = +100;
-    aPad->m_LocalSolderPasteMarginRatio = dtmp / 100;
+
+    aPad->SetLocalSolderPasteMarginRatio( dtmp / 100 );
 
     // Read pad position:
-    aPad->m_Pos.x = ReturnValueFromTextCtrl( *m_PadPosition_X_Ctrl, internalUnits );
+    x = ReturnValueFromTextCtrl( *m_PadPosition_X_Ctrl, internalUnits );
-    aPad->m_Pos.y = ReturnValueFromTextCtrl( *m_PadPosition_Y_Ctrl, internalUnits );
+    y = ReturnValueFromTextCtrl( *m_PadPosition_Y_Ctrl, internalUnits );
-    aPad->m_Pos0  = aPad->m_Pos;
+
+    aPad->SetPosition( wxPoint( x, y ) );
+    aPad->SetPos0( wxPoint( x, y ) );
 
     // Read pad drill:
-    aPad->m_Drill.x = ReturnValueFromTextCtrl( *m_PadDrill_X_Ctrl, internalUnits );
+    x = ReturnValueFromTextCtrl( *m_PadDrill_X_Ctrl, internalUnits );
-    aPad->m_Drill.y = ReturnValueFromTextCtrl( *m_PadDrill_Y_Ctrl, internalUnits );
+    y = ReturnValueFromTextCtrl( *m_PadDrill_Y_Ctrl, internalUnits );
+
     if( m_DrillShapeCtrl->GetSelection() == 0 )
     {
-        aPad->m_DrillShape = PAD_CIRCLE;
+        aPad->SetDrillShape( PAD_CIRCLE );
-        aPad->m_Drill.y    = aPad->m_Drill.x;
+        y = x;
     }
     else
-        aPad->m_DrillShape = PAD_OVAL;
+        aPad->SetDrillShape( PAD_OVAL );
+
+    aPad->SetDrillSize( wxSize( x, y ) );
 
     // Read pad shape size:
-    aPad->m_Size.x = ReturnValueFromTextCtrl( *m_ShapeSize_X_Ctrl, internalUnits );
+    x = ReturnValueFromTextCtrl( *m_ShapeSize_X_Ctrl, internalUnits );
-    aPad->m_Size.y = ReturnValueFromTextCtrl( *m_ShapeSize_Y_Ctrl, internalUnits );
+    y = ReturnValueFromTextCtrl( *m_ShapeSize_Y_Ctrl, internalUnits );
-    if( aPad->m_PadShape == PAD_CIRCLE )
+    if( aPad->GetShape() == PAD_CIRCLE )
-        aPad->m_Size.y = aPad->m_Size.x;
+        y = x;
+
+    aPad->SetSize( wxSize( x, y ) );
+
+    // Read pad length die
+    aPad->SetDieLength( ReturnValueFromTextCtrl( *m_LengthDieCtrl, internalUnits ) );
 
     // Read pad shape delta size:
     // m_DeltaSize.x or m_DeltaSize.y must be NULL. for a trapezoid.
     wxSize delta;
+
     if( m_radioBtnDeltaXdir->GetValue() )
         delta.x = ReturnValueFromTextCtrl( *m_ShapeDelta_Ctrl, internalUnits );
     else
         delta.y = ReturnValueFromTextCtrl( *m_ShapeDelta_Ctrl, internalUnits );
-    aPad->m_DeltaSize = delta;
 
-    // Read pad lenght die
+    // Test bad values (be sure delta values are not too large)
-    aPad->m_LengthDie = ReturnValueFromTextCtrl( *m_LengthDieCtrl, internalUnits );
-
-    // Test bad values (be sure delta values are not to large)
     // remember DeltaSize.x is the Y size variation
     bool   error    = false;
-    if( (aPad->m_DeltaSize.x < 0) && (aPad->m_DeltaSize.x <= -aPad->m_Size.y) )
+
+    if( delta.x < 0 && delta.x <= -aPad->GetSize().y )
     {
-        aPad->m_DeltaSize.x = -aPad->m_Size.y + 2;
+        delta.x = -aPad->GetSize().y + 2;
-        error = true;
-    }
-    if( (aPad->m_DeltaSize.x > 0) && (aPad->m_DeltaSize.x >= aPad->m_Size.y) )
-    {
-        aPad->m_DeltaSize.x = aPad->m_Size.y - 2;
-        error = true;
-    }
-    if( (aPad->m_DeltaSize.y < 0) && (aPad->m_DeltaSize.y <= -aPad->m_Size.x) )
-    {
-        aPad->m_DeltaSize.y = -aPad->m_Size.x + 2;
-        error = true;
-    }
-    if( (aPad->m_DeltaSize.y > 0) && (aPad->m_DeltaSize.y >= aPad->m_Size.x) )
-    {
-        aPad->m_DeltaSize.y = aPad->m_Size.x - 2;
         error = true;
     }
 
+    if( delta.x > 0 && delta.x >= aPad->GetSize().y )
+    {
+        delta.x = aPad->GetSize().y - 2;
+        error = true;
+    }
+
+    if( delta.y < 0 && delta.y <= -aPad->GetSize().x )
+    {
+        delta.y = -aPad->GetSize().x + 2;
+        error = true;
+    }
+
+    if( delta.y > 0 && delta.y >= aPad->GetSize().x )
+    {
+        delta.y = aPad->GetSize().x - 2;
+        error = true;
+    }
+
+    aPad->SetDelta( delta );
+
     // Read pad shape offset:
-    aPad->m_Offset.x = ReturnValueFromTextCtrl( *m_ShapeOffset_X_Ctrl, internalUnits );
+    x = ReturnValueFromTextCtrl( *m_ShapeOffset_X_Ctrl, internalUnits );
-    aPad->m_Offset.y = ReturnValueFromTextCtrl( *m_ShapeOffset_Y_Ctrl, internalUnits );
+    y = ReturnValueFromTextCtrl( *m_ShapeOffset_Y_Ctrl, internalUnits );
+    aPad->SetOffset( wxPoint( x, y ) );
 
     double orient_value = 0;
     msg = m_PadOrientCtrl->GetValue();
@@ -786,41 +829,45 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError
     aPad->SetNetname( m_PadNetNameCtrl->GetValue() );
 
     // Clear some values, according to the pad type and shape
-    switch( aPad->m_PadShape )
+    switch( aPad->GetShape() )
     {
     case PAD_CIRCLE:
-        aPad->m_Offset    = wxSize( 0, 0 );
+        aPad->SetOffset( wxPoint( 0, 0 ) );
-        aPad->m_DeltaSize = wxSize( 0, 0 );
+        aPad->SetDelta( wxSize( 0, 0 ) );
-        aPad->m_Size.y    = aPad->m_Size.x;
+        x = aPad->GetSize().x;
+        aPad->SetSize( wxSize( x, x ) );
         break;
 
     case PAD_RECT:
-        aPad->m_DeltaSize = wxSize( 0, 0 );
+        aPad->SetDelta( wxSize( 0, 0 ) );
         break;
 
     case PAD_OVAL:
-        aPad->m_DeltaSize = wxSize( 0, 0 );
+        aPad->SetDelta( wxSize( 0, 0 ) );
         break;
 
     case PAD_TRAPEZOID:
         break;
+
+    default:
+        ;
     }
 
-    switch( aPad->m_Attribut )
+    switch( aPad->GetAttribute() )
     {
     case PAD_STANDARD:
         break;
 
     case PAD_CONN:
     case PAD_SMD:
-        aPad->m_Offset = wxSize( 0, 0 );
+        aPad->SetOffset( wxPoint( 0, 0 ) );
-        aPad->m_Drill  = wxSize( 0, 0 );
+        aPad->SetDrillSize( wxSize( 0, 0 ) );
         break;
 
     case PAD_HOLE_NOT_PLATED:
         // Mechanical purpose only:
         // no offset, no net name, no pad name allowed
-        aPad->m_Offset = wxSize( 0, 0 );
+        aPad->SetOffset( wxPoint( 0, 0 ) );
         aPad->SetPadName( wxEmptyString );
         aPad->SetNetname( wxEmptyString );
         break;
@@ -830,67 +877,67 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError
         break;
     }
 
-    PadLayerMask = 0;
+    padLayerMask = 0;
+
     switch( m_rbCopperLayersSel->GetSelection() )
     {
-        case 0:
+    case 0:
-            PadLayerMask |= LAYER_FRONT;
+        padLayerMask |= LAYER_FRONT;
-            break;
+        break;
 
-        case 1:
+    case 1:
-            PadLayerMask |= LAYER_BACK;
+        padLayerMask |= LAYER_BACK;
-            break;
+        break;
 
-        case 2:
+    case 2:
-            PadLayerMask |= ALL_CU_LAYERS;
+        padLayerMask |= ALL_CU_LAYERS;
-            break;
+        break;
 
-        case 3:     // No copper layers
+    case 3:     // No copper layers
-            break;
+        break;
     }
 
     if( m_PadLayerAdhCmp->GetValue() )
-        PadLayerMask |= ADHESIVE_LAYER_FRONT;
+        padLayerMask |= ADHESIVE_LAYER_FRONT;
     if( m_PadLayerAdhCu->GetValue() )
-        PadLayerMask |= ADHESIVE_LAYER_BACK;
+        padLayerMask |= ADHESIVE_LAYER_BACK;
     if( m_PadLayerPateCmp->GetValue() )
-        PadLayerMask |= SOLDERPASTE_LAYER_FRONT;
+        padLayerMask |= SOLDERPASTE_LAYER_FRONT;
     if( m_PadLayerPateCu->GetValue() )
-        PadLayerMask |= SOLDERPASTE_LAYER_BACK;
+        padLayerMask |= SOLDERPASTE_LAYER_BACK;
     if( m_PadLayerSilkCmp->GetValue() )
-        PadLayerMask |= SILKSCREEN_LAYER_FRONT;
+        padLayerMask |= SILKSCREEN_LAYER_FRONT;
     if( m_PadLayerSilkCu->GetValue() )
-        PadLayerMask |= SILKSCREEN_LAYER_BACK;
+        padLayerMask |= SILKSCREEN_LAYER_BACK;
     if( m_PadLayerMaskCmp->GetValue() )
-        PadLayerMask |= SOLDERMASK_LAYER_FRONT;
+        padLayerMask |= SOLDERMASK_LAYER_FRONT;
     if( m_PadLayerMaskCu->GetValue() )
-        PadLayerMask |= SOLDERMASK_LAYER_BACK;
+        padLayerMask |= SOLDERMASK_LAYER_BACK;
     if( m_PadLayerECO1->GetValue() )
-        PadLayerMask |= ECO1_LAYER;
+        padLayerMask |= ECO1_LAYER;
     if( m_PadLayerECO2->GetValue() )
-        PadLayerMask |= ECO2_LAYER;
+        padLayerMask |= ECO2_LAYER;
     if( m_PadLayerDraft->GetValue() )
-        PadLayerMask |= DRAW_LAYER;
+        padLayerMask |= DRAW_LAYER;
 
-    aPad->m_layerMask = PadLayerMask;
+    aPad->SetLayerMask( padLayerMask );
 
-    /* Test for incorrect values */
+    // Test for incorrect values
     if( aPromptOnError )
     {
-        if( (aPad->m_Size.x < aPad->m_Drill.x)
+        if( (aPad->GetSize().x < aPad->GetDrillSize().x) || (aPad->GetSize().y < aPad->GetDrillSize().y) )
-           || (aPad->m_Size.y < aPad->m_Drill.y) )
         {
             DisplayError( NULL, _( "Incorrect value for pad drill: pad drill bigger than pad size" ) );
             return false;
         }
 
-        int padlayers_mask = PadLayerMask & (LAYER_BACK | LAYER_FRONT);
+        int padlayers_mask = padLayerMask & (LAYER_BACK | LAYER_FRONT);
         if( padlayers_mask == 0 )
         {
-            if( aPad->m_Drill.x || aPad->m_Drill.y )
+            if( aPad->GetDrillSize().x || aPad->GetDrillSize().y )
             {
                 msg = _( "Error: pad is not on a copper layer and has a hole" );
-                if( aPad->m_Attribut == PAD_HOLE_NOT_PLATED )
+                if( aPad->GetAttribute() == PAD_HOLE_NOT_PLATED )
                 {
                     msg += wxT("\n");
                     msg += _( "For NPTH pad, set pad drill value to pad size value,\n\
@@ -901,8 +948,8 @@ if you do not want this pad plotted in gerber files");
             }
         }
 
-        if( ( aPad->m_Size.x / 2 <= ABS( aPad->m_Offset.x ) )
+        if(  aPad->GetSize().x / 2 <= ABS( aPad->GetOffset().x ) ||
-           || ( aPad->m_Size.y / 2 <= ABS( aPad->m_Offset.y ) ) )
+             aPad->GetSize().y / 2 <= ABS( aPad->GetOffset().y ) )
         {
             DisplayError( NULL, _( "Incorrect value for pad offset" ) );
             return false;

pcbnew/dialogs/dialog_pad_properties_base.cpp

@@ -11,511 +11,511 @@
 
 DIALOG_PAD_PROPERTIES_BASE::DIALOG_PAD_PROPERTIES_BASE( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )
 {
-	this->SetSizeHints( wxDefaultSize, wxDefaultSize );
+    this->SetSizeHints( wxDefaultSize, wxDefaultSize );
 
-	wxBoxSizer* m_MainSizer;
+    wxBoxSizer* m_MainSizer;
-	m_MainSizer = new wxBoxSizer( wxVERTICAL );
+    m_MainSizer = new wxBoxSizer( wxVERTICAL );
 
-	wxBoxSizer* bGeneralSizer;
+    wxBoxSizer* bGeneralSizer;
-	bGeneralSizer = new wxBoxSizer( wxHORIZONTAL );
+    bGeneralSizer = new wxBoxSizer( wxHORIZONTAL );
 
-	wxBoxSizer* m_LeftBoxSizer;
+    wxBoxSizer* m_LeftBoxSizer;
-	m_LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
+    m_LeftBoxSizer = new wxBoxSizer( wxVERTICAL );
 
-	m_PadNumText = new wxStaticText( this, wxID_ANY, _("Pad Num :"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadNumText = new wxStaticText( this, wxID_ANY, _("Pad Num :"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadNumText->Wrap( -1 );
+    m_PadNumText->Wrap( -1 );
-	m_LeftBoxSizer->Add( m_PadNumText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    m_LeftBoxSizer->Add( m_PadNumText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadNumCtrl = new wxTextCtrl( this, wxID_PADNUMCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadNumCtrl = new wxTextCtrl( this, wxID_PADNUMCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	m_LeftBoxSizer->Add( m_PadNumCtrl, 0, wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND, 5 );
+    m_LeftBoxSizer->Add( m_PadNumCtrl, 0, wxBOTTOM|wxRIGHT|wxLEFT|wxEXPAND, 5 );
 
-	m_PadNameText = new wxStaticText( this, wxID_ANY, _("Pad Net Name :"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadNameText = new wxStaticText( this, wxID_ANY, _("Pad Net Name :"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadNameText->Wrap( -1 );
+    m_PadNameText->Wrap( -1 );
-	m_LeftBoxSizer->Add( m_PadNameText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    m_LeftBoxSizer->Add( m_PadNameText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadNetNameCtrl = new wxTextCtrl( this, wxID_PADNETNAMECTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadNetNameCtrl = new wxTextCtrl( this, wxID_PADNETNAMECTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	m_LeftBoxSizer->Add( m_PadNetNameCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+    m_LeftBoxSizer->Add( m_PadNetNameCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 
-	wxStaticBoxSizer* sbSizer2;
+    wxStaticBoxSizer* sbSizer2;
-	sbSizer2 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Pad Geometry:") ), wxVERTICAL );
+    sbSizer2 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Pad Geometry:") ), wxVERTICAL );
 
-	wxFlexGridSizer* fgSizerGeometry;
+    wxFlexGridSizer* fgSizerGeometry;
-	fgSizerGeometry = new wxFlexGridSizer( 14, 3, 0, 0 );
+    fgSizerGeometry = new wxFlexGridSizer( 14, 3, 0, 0 );
-	fgSizerGeometry->SetFlexibleDirection( wxBOTH );
+    fgSizerGeometry->SetFlexibleDirection( wxBOTH );
-	fgSizerGeometry->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
+    fgSizerGeometry->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 
-	m_staticText4 = new wxStaticText( this, wxID_ANY, _("Pad pos X"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText4 = new wxStaticText( this, wxID_ANY, _("Pad pos X"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText4->Wrap( -1 );
+    m_staticText4->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText4, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_staticText4, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 
-	m_PadPosition_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadPosition_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_PadPosition_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_PadPosition_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadPosX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadPosX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadPosX_Unit->Wrap( -1 );
+    m_PadPosX_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadPosX_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
+    fgSizerGeometry->Add( m_PadPosX_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 
-	m_staticText41 = new wxStaticText( this, wxID_ANY, _("Pad pos Y"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText41 = new wxStaticText( this, wxID_ANY, _("Pad pos Y"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText41->Wrap( -1 );
+    m_staticText41->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText41, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_staticText41, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_PadPosition_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadPosition_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_PadPosition_Y_Ctrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_PadPosition_Y_Ctrl, 0, wxALL, 5 );
 
-	m_PadPosY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadPosY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadPosY_Unit->Wrap( -1 );
+    m_PadPosY_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadPosY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadPosY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticline7 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline7 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline7, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline7, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline8 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline8 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline8, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline8, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline9 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline9 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline9, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline9, 0, wxEXPAND | wxALL, 5 );
 
-	m_textPadDrillX = new wxStaticText( this, wxID_ANY, _("Pad drill X"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_textPadDrillX = new wxStaticText( this, wxID_ANY, _("Pad drill X"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_textPadDrillX->Wrap( -1 );
+    m_textPadDrillX->Wrap( -1 );
-	fgSizerGeometry->Add( m_textPadDrillX, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_textPadDrillX, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxALIGN_RIGHT, 5 );
 
-	m_PadDrill_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadDrill_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_PadDrill_X_Ctrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_PadDrill_X_Ctrl, 0, wxALL, 5 );
 
-	m_PadDrill_X_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadDrill_X_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadDrill_X_Unit->Wrap( -1 );
+    m_PadDrill_X_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadDrill_X_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadDrill_X_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_textPadDrillY = new wxStaticText( this, wxID_ANY, _("Pad drill Y"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_textPadDrillY = new wxStaticText( this, wxID_ANY, _("Pad drill Y"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_textPadDrillY->Wrap( -1 );
+    m_textPadDrillY->Wrap( -1 );
-	fgSizerGeometry->Add( m_textPadDrillY, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_textPadDrillY, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 
-	m_PadDrill_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadDrill_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_PadDrill_Y_Ctrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_PadDrill_Y_Ctrl, 0, wxALL, 5 );
 
-	m_PadDrill_Y_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadDrill_Y_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadDrill_Y_Unit->Wrap( -1 );
+    m_PadDrill_Y_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadDrill_Y_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
+    fgSizerGeometry->Add( m_PadDrill_Y_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 
-	m_staticline4 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline4 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline4, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline4, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline5 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline5 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline5, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline5, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline6 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline6 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline6, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline6, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticText12 = new wxStaticText( this, wxID_ANY, _("Shape size X"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText12 = new wxStaticText( this, wxID_ANY, _("Shape size X"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText12->Wrap( -1 );
+    m_staticText12->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText12, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_staticText12, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_ShapeSize_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_ShapeSize_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_ShapeSize_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_ShapeSize_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadShapeSizeX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadShapeSizeX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadShapeSizeX_Unit->Wrap( -1 );
+    m_PadShapeSizeX_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadShapeSizeX_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
+    fgSizerGeometry->Add( m_PadShapeSizeX_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 
-	m_staticText15 = new wxStaticText( this, wxID_ANY, _("Shape size Y"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText15 = new wxStaticText( this, wxID_ANY, _("Shape size Y"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText15->Wrap( -1 );
+    m_staticText15->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText15, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_staticText15, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_ShapeSize_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_ShapeSize_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_ShapeSize_Y_Ctrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_ShapeSize_Y_Ctrl, 0, wxALL, 5 );
 
-	m_PadShapeSizeY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadShapeSizeY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadShapeSizeY_Unit->Wrap( -1 );
+    m_PadShapeSizeY_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadShapeSizeY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadShapeSizeY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticText17 = new wxStaticText( this, wxID_ANY, _("Shape offset X"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText17 = new wxStaticText( this, wxID_ANY, _("Shape offset X"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText17->Wrap( -1 );
+    m_staticText17->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText17, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_staticText17, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );
 
-	m_ShapeOffset_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_ShapeOffset_X_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_ShapeOffset_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_ShapeOffset_X_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadShapeOffsetX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadShapeOffsetX_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadShapeOffsetX_Unit->Wrap( -1 );
+    m_PadShapeOffsetX_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadShapeOffsetX_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadShapeOffsetX_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticText19 = new wxStaticText( this, wxID_ANY, _("Shape offset Y"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText19 = new wxStaticText( this, wxID_ANY, _("Shape offset Y"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText19->Wrap( -1 );
+    m_staticText19->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText19, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_staticText19, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_ShapeOffset_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_ShapeOffset_Y_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_ShapeOffset_Y_Ctrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_ShapeOffset_Y_Ctrl, 0, wxALL, 5 );
 
-	m_PadShapeOffsetY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadShapeOffsetY_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadShapeOffsetY_Unit->Wrap( -1 );
+    m_PadShapeOffsetY_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadShapeOffsetY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadShapeOffsetY_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticText21 = new wxStaticText( this, wxID_ANY, _("Shape delta dim"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText21 = new wxStaticText( this, wxID_ANY, _("Shape delta dim"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText21->Wrap( -1 );
+    m_staticText21->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText21, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_staticText21, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxLEFT, 5 );
 
-	m_ShapeDelta_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_ShapeDelta_Ctrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_ShapeDelta_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_ShapeDelta_Ctrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadShapeDelta_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadShapeDelta_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadShapeDelta_Unit->Wrap( -1 );
+    m_PadShapeDelta_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadShapeDelta_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgSizerGeometry->Add( m_PadShapeDelta_Unit, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticText23 = new wxStaticText( this, wxID_ANY, _("Trap. direction"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText23 = new wxStaticText( this, wxID_ANY, _("Trap. direction"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText23->Wrap( -1 );
+    m_staticText23->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticText23, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgSizerGeometry->Add( m_staticText23, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	wxBoxSizer* bSizerbdir;
+    wxBoxSizer* bSizerbdir;
-	bSizerbdir = new wxBoxSizer( wxHORIZONTAL );
+    bSizerbdir = new wxBoxSizer( wxHORIZONTAL );
 
-	m_radioBtnDeltaXdir = new wxRadioButton( this, wxID_DDIRX, _(">"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
+    m_radioBtnDeltaXdir = new wxRadioButton( this, wxID_DDIRX, _(">"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
-	m_radioBtnDeltaXdir->SetValue( true ); 
+    m_radioBtnDeltaXdir->SetValue( true );
-	bSizerbdir->Add( m_radioBtnDeltaXdir, 0, wxALL, 5 );
+    bSizerbdir->Add( m_radioBtnDeltaXdir, 0, wxALL, 5 );
 
-	m_radioBtnDeltaYdir = new wxRadioButton( this, wxID_DDIRY, _("^"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_radioBtnDeltaYdir = new wxRadioButton( this, wxID_DDIRY, _("^"), wxDefaultPosition, wxDefaultSize, 0 );
-	bSizerbdir->Add( m_radioBtnDeltaYdir, 0, wxALL, 5 );
+    bSizerbdir->Add( m_radioBtnDeltaYdir, 0, wxALL, 5 );
 
-	fgSizerGeometry->Add( bSizerbdir, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );
+    fgSizerGeometry->Add( bSizerbdir, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );
 
-	m_staticTextDDirInfo = new wxStaticText( this, wxID_ANY, _("Rot 0"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextDDirInfo = new wxStaticText( this, wxID_ANY, _("Rot 0"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextDDirInfo->Wrap( -1 );
+    m_staticTextDDirInfo->Wrap( -1 );
-	fgSizerGeometry->Add( m_staticTextDDirInfo, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
+    fgSizerGeometry->Add( m_staticTextDDirInfo, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 
-	m_staticline10 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline10 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline10, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline10, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline101 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline101 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline101, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline101, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticline1011 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline1011 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgSizerGeometry->Add( m_staticline1011, 0, wxEXPAND | wxALL, 5 );
+    fgSizerGeometry->Add( m_staticline1011, 0, wxEXPAND | wxALL, 5 );
 
-	m_staticText38 = new wxStaticText( this, wxID_ANY, _("Length die"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticText38 = new wxStaticText( this, wxID_ANY, _("Length die"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticText38->Wrap( -1 );
+    m_staticText38->Wrap( -1 );
-	m_staticText38->SetToolTip( _("Wire length from pad to die on chip ( used to calculate actual track length)") );
+    m_staticText38->SetToolTip( _("Wire length from pad to die on chip ( used to calculate actual track length)") );
 
-	fgSizerGeometry->Add( m_staticText38, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxLEFT, 5 );
+    fgSizerGeometry->Add( m_staticText38, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxLEFT, 5 );
 
-	m_LengthDieCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_LengthDieCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgSizerGeometry->Add( m_LengthDieCtrl, 0, wxALL, 5 );
+    fgSizerGeometry->Add( m_LengthDieCtrl, 0, wxALL, 5 );
 
-	m_PadLengthDie_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLengthDie_Unit = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadLengthDie_Unit->Wrap( -1 );
+    m_PadLengthDie_Unit->Wrap( -1 );
-	fgSizerGeometry->Add( m_PadLengthDie_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
+    fgSizerGeometry->Add( m_PadLengthDie_Unit, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );
 
-	sbSizer2->Add( fgSizerGeometry, 1, wxEXPAND, 5 );
+    sbSizer2->Add( fgSizerGeometry, 1, wxEXPAND, 5 );
 
-	m_LeftBoxSizer->Add( sbSizer2, 1, wxEXPAND, 5 );
+    m_LeftBoxSizer->Add( sbSizer2, 1, wxEXPAND, 5 );
 
-	bGeneralSizer->Add( m_LeftBoxSizer, 0, wxBOTTOM|wxLEFT|wxEXPAND, 5 );
+    bGeneralSizer->Add( m_LeftBoxSizer, 0, wxBOTTOM|wxLEFT|wxEXPAND, 5 );
 
-	wxBoxSizer* bMiddleSizer;
+    wxBoxSizer* bMiddleSizer;
-	bMiddleSizer = new wxBoxSizer( wxVERTICAL );
+    bMiddleSizer = new wxBoxSizer( wxVERTICAL );
 
-	wxBoxSizer* bMiddleUpperSizer;
+    wxBoxSizer* bMiddleUpperSizer;
-	bMiddleUpperSizer = new wxBoxSizer( wxHORIZONTAL );
+    bMiddleUpperSizer = new wxBoxSizer( wxHORIZONTAL );
 
-	m_DrillShapeBoxSizer = new wxBoxSizer( wxVERTICAL );
+    m_DrillShapeBoxSizer = new wxBoxSizer( wxVERTICAL );
 
-	wxString m_PadShapeChoices[] = { _("Circle"), _("Oval"), _("Rect"), _("Trapezoidal") };
+    wxString m_PadShapeChoices[] = { _("Circle"), _("Oval"), _("Rect"), _("Trapezoidal") };
-	int m_PadShapeNChoices = sizeof( m_PadShapeChoices ) / sizeof( wxString );
+    int m_PadShapeNChoices = sizeof( m_PadShapeChoices ) / sizeof( wxString );
-	m_PadShape = new wxRadioBox( this, ID_LISTBOX_SHAPE_PAD, _("Pad Shape:"), wxDefaultPosition, wxDefaultSize, m_PadShapeNChoices, m_PadShapeChoices, 1, wxRA_SPECIFY_COLS );
+    m_PadShape = new wxRadioBox( this, ID_LISTBOX_SHAPE_PAD, _("Pad Shape:"), wxDefaultPosition, wxDefaultSize, m_PadShapeNChoices, m_PadShapeChoices, 1, wxRA_SPECIFY_COLS );
-	m_PadShape->SetSelection( 0 );
+    m_PadShape->SetSelection( 0 );
-	m_DrillShapeBoxSizer->Add( m_PadShape, 0, wxALL|wxEXPAND, 5 );
+    m_DrillShapeBoxSizer->Add( m_PadShape, 0, wxALL|wxEXPAND, 5 );
 
-	wxString m_DrillShapeCtrlChoices[] = { _("Circle"), _("Oval") };
+    wxString m_DrillShapeCtrlChoices[] = { _("Circle"), _("Oval") };
-	int m_DrillShapeCtrlNChoices = sizeof( m_DrillShapeCtrlChoices ) / sizeof( wxString );
+    int m_DrillShapeCtrlNChoices = sizeof( m_DrillShapeCtrlChoices ) / sizeof( wxString );
-	m_DrillShapeCtrl = new wxRadioBox( this, ID_RADIOBOX_DRILL_SHAPE, _("Drill Shape:"), wxDefaultPosition, wxDefaultSize, m_DrillShapeCtrlNChoices, m_DrillShapeCtrlChoices, 1, wxRA_SPECIFY_COLS );
+    m_DrillShapeCtrl = new wxRadioBox( this, ID_RADIOBOX_DRILL_SHAPE, _("Drill Shape:"), wxDefaultPosition, wxDefaultSize, m_DrillShapeCtrlNChoices, m_DrillShapeCtrlChoices, 1, wxRA_SPECIFY_COLS );
-	m_DrillShapeCtrl->SetSelection( 0 );
+    m_DrillShapeCtrl->SetSelection( 0 );
-	m_DrillShapeBoxSizer->Add( m_DrillShapeCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+    m_DrillShapeBoxSizer->Add( m_DrillShapeCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 
-	bMiddleUpperSizer->Add( m_DrillShapeBoxSizer, 0, wxBOTTOM, 5 );
+    bMiddleUpperSizer->Add( m_DrillShapeBoxSizer, 0, wxBOTTOM, 5 );
 
-	wxBoxSizer* m_MiddleRightBoxSizer;
+    wxBoxSizer* m_MiddleRightBoxSizer;
-	m_MiddleRightBoxSizer = new wxBoxSizer( wxVERTICAL );
+    m_MiddleRightBoxSizer = new wxBoxSizer( wxVERTICAL );
 
-	wxString m_PadOrientChoices[] = { _("0"), _("90"), _("-90"), _("180"), _("Custom") };
+    wxString m_PadOrientChoices[] = { _("0"), _("90"), _("-90"), _("180"), _("Custom") };
-	int m_PadOrientNChoices = sizeof( m_PadOrientChoices ) / sizeof( wxString );
+    int m_PadOrientNChoices = sizeof( m_PadOrientChoices ) / sizeof( wxString );
-	m_PadOrient = new wxRadioBox( this, ID_LISTBOX_ORIENT_PAD, _("Pad Orient:"), wxDefaultPosition, wxDefaultSize, m_PadOrientNChoices, m_PadOrientChoices, 1, wxRA_SPECIFY_COLS );
+    m_PadOrient = new wxRadioBox( this, ID_LISTBOX_ORIENT_PAD, _("Pad Orient:"), wxDefaultPosition, wxDefaultSize, m_PadOrientNChoices, m_PadOrientChoices, 1, wxRA_SPECIFY_COLS );
-	m_PadOrient->SetSelection( 0 );
+    m_PadOrient->SetSelection( 0 );
-	m_MiddleRightBoxSizer->Add( m_PadOrient, 0, wxALL|wxEXPAND, 5 );
+    m_MiddleRightBoxSizer->Add( m_PadOrient, 0, wxALL|wxEXPAND, 5 );
 
-	m_PadOrientText = new wxStaticText( this, wxID_ANY, _("Pad Orient (0.1 deg)"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadOrientText = new wxStaticText( this, wxID_ANY, _("Pad Orient (0.1 deg)"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_PadOrientText->Wrap( -1 );
+    m_PadOrientText->Wrap( -1 );
-	m_MiddleRightBoxSizer->Add( m_PadOrientText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    m_MiddleRightBoxSizer->Add( m_PadOrientText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadOrientCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadOrientCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	m_MiddleRightBoxSizer->Add( m_PadOrientCtrl, 0, wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+    m_MiddleRightBoxSizer->Add( m_PadOrientCtrl, 0, wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 
-	bMiddleUpperSizer->Add( m_MiddleRightBoxSizer, 0, wxBOTTOM, 5 );
+    bMiddleUpperSizer->Add( m_MiddleRightBoxSizer, 0, wxBOTTOM, 5 );
 
-	m_panelShowPad = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE|wxSIMPLE_BORDER|wxTAB_TRAVERSAL );
+    m_panelShowPad = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE|wxSIMPLE_BORDER|wxTAB_TRAVERSAL );
-	m_panelShowPad->SetBackgroundColour( wxColour( 0, 0, 0 ) );
+    m_panelShowPad->SetBackgroundColour( wxColour( 0, 0, 0 ) );
 
-	bMiddleUpperSizer->Add( m_panelShowPad, 1, wxEXPAND, 5 );
+    bMiddleUpperSizer->Add( m_panelShowPad, 1, wxEXPAND, 5 );
 
-	bMiddleSizer->Add( bMiddleUpperSizer, 1, wxEXPAND, 5 );
+    bMiddleSizer->Add( bMiddleUpperSizer, 1, wxEXPAND, 5 );
 
-	wxStaticBoxSizer* sbSizeModuleInfo;
+    wxStaticBoxSizer* sbSizeModuleInfo;
-	sbSizeModuleInfo = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Footprint orientation") ), wxHORIZONTAL );
+    sbSizeModuleInfo = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Footprint orientation") ), wxHORIZONTAL );
 
-	wxFlexGridSizer* fgSizer4;
+    wxFlexGridSizer* fgSizer4;
-	fgSizer4 = new wxFlexGridSizer( 2, 2, 0, 0 );
+    fgSizer4 = new wxFlexGridSizer( 2, 2, 0, 0 );
-	fgSizer4->AddGrowableCol( 1 );
+    fgSizer4->AddGrowableCol( 1 );
-	fgSizer4->SetFlexibleDirection( wxBOTH );
+    fgSizer4->SetFlexibleDirection( wxBOTH );
-	fgSizer4->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
+    fgSizer4->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 
-	m_staticTitleModuleRot = new wxStaticText( this, wxID_ANY, _("Rotation:"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTitleModuleRot = new wxStaticText( this, wxID_ANY, _("Rotation:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTitleModuleRot->Wrap( -1 );
+    m_staticTitleModuleRot->Wrap( -1 );
-	fgSizer4->Add( m_staticTitleModuleRot, 0, wxALIGN_RIGHT|wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgSizer4->Add( m_staticTitleModuleRot, 0, wxALIGN_RIGHT|wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_staticModuleRotValue = new wxStaticText( this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticModuleRotValue = new wxStaticText( this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticModuleRotValue->Wrap( -1 );
+    m_staticModuleRotValue->Wrap( -1 );
-	fgSizer4->Add( m_staticModuleRotValue, 0, wxTOP|wxRIGHT|wxLEFT|wxEXPAND, 5 );
+    fgSizer4->Add( m_staticModuleRotValue, 0, wxTOP|wxRIGHT|wxLEFT|wxEXPAND, 5 );
 
-	m_staticTitleModuleSide = new wxStaticText( this, wxID_ANY, _("Board side:"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTitleModuleSide = new wxStaticText( this, wxID_ANY, _("Board side:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTitleModuleSide->Wrap( -1 );
+    m_staticTitleModuleSide->Wrap( -1 );
-	fgSizer4->Add( m_staticTitleModuleSide, 0, wxALL|wxALIGN_RIGHT, 5 );
+    fgSizer4->Add( m_staticTitleModuleSide, 0, wxALL|wxALIGN_RIGHT, 5 );
 
-	m_staticModuleSideValue = new wxStaticText( this, wxID_ANY, _("Front side"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticModuleSideValue = new wxStaticText( this, wxID_ANY, _("Front side"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticModuleSideValue->Wrap( -1 );
+    m_staticModuleSideValue->Wrap( -1 );
-	fgSizer4->Add( m_staticModuleSideValue, 0, wxALL|wxEXPAND, 5 );
+    fgSizer4->Add( m_staticModuleSideValue, 0, wxALL|wxEXPAND, 5 );
 
-	sbSizeModuleInfo->Add( fgSizer4, 1, wxEXPAND, 5 );
+    sbSizeModuleInfo->Add( fgSizer4, 1, wxEXPAND, 5 );
 
-	m_staticTextWarningPadFlipped = new wxStaticText( this, wxID_ANY, _("Warning:\nThis pad is flipped on board.\nBack and front layers will be swapped."), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextWarningPadFlipped = new wxStaticText( this, wxID_ANY, _("Warning:\nThis pad is flipped on board.\nBack and front layers will be swapped."), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextWarningPadFlipped->Wrap( -1 );
+    m_staticTextWarningPadFlipped->Wrap( -1 );
-	m_staticTextWarningPadFlipped->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
+    m_staticTextWarningPadFlipped->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
 
-	sbSizeModuleInfo->Add( m_staticTextWarningPadFlipped, 0, wxALIGN_CENTER_VERTICAL, 5 );
+    sbSizeModuleInfo->Add( m_staticTextWarningPadFlipped, 0, wxALIGN_CENTER_VERTICAL, 5 );
 
-	bMiddleSizer->Add( sbSizeModuleInfo, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+    bMiddleSizer->Add( sbSizeModuleInfo, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 
-	wxStaticBoxSizer* sbClearancesSizer;
+    wxStaticBoxSizer* sbClearancesSizer;
-	sbClearancesSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Clearances:") ), wxVERTICAL );
+    sbClearancesSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Clearances:") ), wxVERTICAL );
 
-	m_staticTextWarning = new wxStaticText( this, wxID_ANY, _("Set these values to 0\nto use Parent footprint or global values"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextWarning = new wxStaticText( this, wxID_ANY, _("Set these values to 0\nto use Parent footprint or global values"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextWarning->Wrap( -1 );
+    m_staticTextWarning->Wrap( -1 );
-	m_staticTextWarning->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
+    m_staticTextWarning->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 92, false, wxEmptyString ) );
 
-	sbClearancesSizer->Add( m_staticTextWarning, 0, wxALIGN_CENTER_HORIZONTAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+    sbClearancesSizer->Add( m_staticTextWarning, 0, wxALIGN_CENTER_HORIZONTAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 
-	wxFlexGridSizer* fgClearancesGridSizer;
+    wxFlexGridSizer* fgClearancesGridSizer;
-	fgClearancesGridSizer = new wxFlexGridSizer( 5, 3, 0, 0 );
+    fgClearancesGridSizer = new wxFlexGridSizer( 5, 3, 0, 0 );
-	fgClearancesGridSizer->SetFlexibleDirection( wxBOTH );
+    fgClearancesGridSizer->SetFlexibleDirection( wxBOTH );
-	fgClearancesGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
+    fgClearancesGridSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 
-	m_staticTextNetClearance = new wxStaticText( this, wxID_ANY, _("Net pad clearance"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextNetClearance = new wxStaticText( this, wxID_ANY, _("Net pad clearance"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextNetClearance->Wrap( -1 );
+    m_staticTextNetClearance->Wrap( -1 );
-	m_staticTextNetClearance->SetToolTip( _("This is the local net clearance for  pad.\nIf 0, the footprint local value or the Netclass value is used") );
+    m_staticTextNetClearance->SetToolTip( _("This is the local net clearance for  pad.\nIf 0, the footprint local value or the Netclass value is used") );
 
-	fgClearancesGridSizer->Add( m_staticTextNetClearance, 0, wxLEFT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_staticTextNetClearance, 0, wxLEFT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_NetClearanceValueCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_NetClearanceValueCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgClearancesGridSizer->Add( m_NetClearanceValueCtrl, 0, wxALL, 5 );
+    fgClearancesGridSizer->Add( m_NetClearanceValueCtrl, 0, wxALL, 5 );
 
-	m_NetClearanceUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_NetClearanceUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_NetClearanceUnits->Wrap( -1 );
+    m_NetClearanceUnits->Wrap( -1 );
-	fgClearancesGridSizer->Add( m_NetClearanceUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_NetClearanceUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgClearancesGridSizer->Add( m_staticline1, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
+    fgClearancesGridSizer->Add( m_staticline1, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 
-	m_staticline2 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline2 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgClearancesGridSizer->Add( m_staticline2, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
+    fgClearancesGridSizer->Add( m_staticline2, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 
-	m_staticline3 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
+    m_staticline3 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
-	fgClearancesGridSizer->Add( m_staticline3, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
+    fgClearancesGridSizer->Add( m_staticline3, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 
-	m_MaskClearanceTitle = new wxStaticText( this, wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_MaskClearanceTitle = new wxStaticText( this, wxID_ANY, _("Solder mask clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_MaskClearanceTitle->Wrap( -1 );
+    m_MaskClearanceTitle->Wrap( -1 );
-	m_MaskClearanceTitle->SetToolTip( _("This is the local clearance between this  pad and the solder mask\nIf 0, the footprint local value or the global value is used") );
+    m_MaskClearanceTitle->SetToolTip( _("This is the local clearance between this  pad and the solder mask\nIf 0, the footprint local value or the global value is used") );
 
-	fgClearancesGridSizer->Add( m_MaskClearanceTitle, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgClearancesGridSizer->Add( m_MaskClearanceTitle, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_SolderMaskMarginCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderMaskMarginCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgClearancesGridSizer->Add( m_SolderMaskMarginCtrl, 0, wxALL, 5 );
+    fgClearancesGridSizer->Add( m_SolderMaskMarginCtrl, 0, wxALL, 5 );
 
-	m_SolderMaskMarginUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderMaskMarginUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_SolderMaskMarginUnits->Wrap( -1 );
+    m_SolderMaskMarginUnits->Wrap( -1 );
-	fgClearancesGridSizer->Add( m_SolderMaskMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_SolderMaskMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticTextSolderPaste = new wxStaticText( this, wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextSolderPaste = new wxStaticText( this, wxID_ANY, _("Solder paste clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextSolderPaste->Wrap( -1 );
+    m_staticTextSolderPaste->Wrap( -1 );
-	m_staticTextSolderPaste->SetToolTip( _("This is the local clearance between this pad and the solder paste.\nIf 0 the footprint value or the global value is used..\nThe final clearance value is the sum of this value and the clearance value ratio\nA negative value means a smaller mask size than pad size") );
+    m_staticTextSolderPaste->SetToolTip( _("This is the local clearance between this pad and the solder paste.\nIf 0 the footprint value or the global value is used..\nThe final clearance value is the sum of this value and the clearance value ratio\nA negative value means a smaller mask size than pad size") );
 
-	fgClearancesGridSizer->Add( m_staticTextSolderPaste, 0, wxLEFT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_staticTextSolderPaste, 0, wxLEFT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_SolderPasteMarginCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderPasteMarginCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgClearancesGridSizer->Add( m_SolderPasteMarginCtrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    fgClearancesGridSizer->Add( m_SolderPasteMarginCtrl, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_SolderPasteMarginUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderPasteMarginUnits = new wxStaticText( this, wxID_ANY, _("Inch"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_SolderPasteMarginUnits->Wrap( -1 );
+    m_SolderPasteMarginUnits->Wrap( -1 );
-	fgClearancesGridSizer->Add( m_SolderPasteMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_SolderPasteMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	m_staticTextRatio = new wxStaticText( this, wxID_ANY, _("Solder mask ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_staticTextRatio = new wxStaticText( this, wxID_ANY, _("Solder mask ratio clearance:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_staticTextRatio->Wrap( -1 );
+    m_staticTextRatio->Wrap( -1 );
-	m_staticTextRatio->SetToolTip( _("This is the local clearance ratio in per cent between this pad and the solder paste.\nA value of 10 means the clearance value is 10 per cent of the pad size\nIf 0 the footprint value or the global value is used..\nThe final clearance value is the sum of this value and the clearance value\nA negative value means a smaller mask size than pad size.") );
+    m_staticTextRatio->SetToolTip( _("This is the local clearance ratio in per cent between this pad and the solder paste.\nA value of 10 means the clearance value is 10 per cent of the pad size\nIf 0 the footprint value or the global value is used..\nThe final clearance value is the sum of this value and the clearance value\nA negative value means a smaller mask size than pad size.") );
 
-	fgClearancesGridSizer->Add( m_staticTextRatio, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
+    fgClearancesGridSizer->Add( m_staticTextRatio, 0, wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );
 
-	m_SolderPasteMarginRatioCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderPasteMarginRatioCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	fgClearancesGridSizer->Add( m_SolderPasteMarginRatioCtrl, 0, wxALL, 5 );
+    fgClearancesGridSizer->Add( m_SolderPasteMarginRatioCtrl, 0, wxALL, 5 );
 
-	m_SolderPasteRatioMarginUnits = new wxStaticText( this, wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_SolderPasteRatioMarginUnits = new wxStaticText( this, wxID_ANY, _("%"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_SolderPasteRatioMarginUnits->Wrap( -1 );
+    m_SolderPasteRatioMarginUnits->Wrap( -1 );
-	fgClearancesGridSizer->Add( m_SolderPasteRatioMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
+    fgClearancesGridSizer->Add( m_SolderPasteRatioMarginUnits, 0, wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );
 
-	sbClearancesSizer->Add( fgClearancesGridSizer, 1, wxEXPAND, 5 );
+    sbClearancesSizer->Add( fgClearancesGridSizer, 1, wxEXPAND, 5 );
 
-	bMiddleSizer->Add( sbClearancesSizer, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
+    bMiddleSizer->Add( sbClearancesSizer, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );
 
-	bGeneralSizer->Add( bMiddleSizer, 1, wxEXPAND, 5 );
+    bGeneralSizer->Add( bMiddleSizer, 1, wxEXPAND, 5 );
 
-	wxBoxSizer* m_RightBoxSizer;
+    wxBoxSizer* m_RightBoxSizer;
-	m_RightBoxSizer = new wxBoxSizer( wxVERTICAL );
+    m_RightBoxSizer = new wxBoxSizer( wxVERTICAL );
 
-	wxString m_PadTypeChoices[] = { _("Standard"), _("SMD"), _("Conn"), _("NPTH, Mechanical") };
+    wxString m_PadTypeChoices[] = { _("Standard"), _("SMD"), _("Conn"), _("NPTH, Mechanical") };
-	int m_PadTypeNChoices = sizeof( m_PadTypeChoices ) / sizeof( wxString );
+    int m_PadTypeNChoices = sizeof( m_PadTypeChoices ) / sizeof( wxString );
-	m_PadType = new wxRadioBox( this, ID_LISTBOX_TYPE_PAD, _("Pad Type:"), wxDefaultPosition, wxDefaultSize, m_PadTypeNChoices, m_PadTypeChoices, 1, wxRA_SPECIFY_COLS );
+    m_PadType = new wxRadioBox( this, ID_LISTBOX_TYPE_PAD, _("Pad Type:"), wxDefaultPosition, wxDefaultSize, m_PadTypeNChoices, m_PadTypeChoices, 1, wxRA_SPECIFY_COLS );
-	m_PadType->SetSelection( 0 );
+    m_PadType->SetSelection( 0 );
-	m_RightBoxSizer->Add( m_PadType, 0, wxALL|wxEXPAND, 5 );
+    m_RightBoxSizer->Add( m_PadType, 0, wxALL|wxEXPAND, 5 );
 
-	wxStaticBoxSizer* m_LayersSizer;
+    wxStaticBoxSizer* m_LayersSizer;
-	m_LayersSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Layers:") ), wxVERTICAL );
+    m_LayersSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Layers:") ), wxVERTICAL );
 
-	wxString m_rbCopperLayersSelChoices[] = { _("Front Layer"), _("Back Layer"), _("All Copper Layers"), _("No Copper Layers") };
+    wxString m_rbCopperLayersSelChoices[] = { _("Front Layer"), _("Back Layer"), _("All Copper Layers"), _("No Copper Layers") };
-	int m_rbCopperLayersSelNChoices = sizeof( m_rbCopperLayersSelChoices ) / sizeof( wxString );
+    int m_rbCopperLayersSelNChoices = sizeof( m_rbCopperLayersSelChoices ) / sizeof( wxString );
-	m_rbCopperLayersSel = new wxRadioBox( this, wxID_ANY, _("Copper Layers:"), wxDefaultPosition, wxDefaultSize, m_rbCopperLayersSelNChoices, m_rbCopperLayersSelChoices, 1, wxRA_SPECIFY_COLS );
+    m_rbCopperLayersSel = new wxRadioBox( this, wxID_ANY, _("Copper Layers:"), wxDefaultPosition, wxDefaultSize, m_rbCopperLayersSelNChoices, m_rbCopperLayersSelChoices, 1, wxRA_SPECIFY_COLS );
-	m_rbCopperLayersSel->SetSelection( 0 );
+    m_rbCopperLayersSel->SetSelection( 0 );
-	m_LayersSizer->Add( m_rbCopperLayersSel, 0, wxALL, 5 );
+    m_LayersSizer->Add( m_rbCopperLayersSel, 0, wxALL, 5 );
 
-	wxStaticBoxSizer* sbSizerTechlayers;
+    wxStaticBoxSizer* sbSizerTechlayers;
-	sbSizerTechlayers = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Technical Layers:") ), wxVERTICAL );
+    sbSizerTechlayers = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Technical Layers:") ), wxVERTICAL );
 
-	m_PadLayerAdhCmp = new wxCheckBox( this, wxID_ANY, _("Adhesive Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerAdhCmp = new wxCheckBox( this, wxID_ANY, _("Adhesive Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerAdhCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerAdhCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerAdhCu = new wxCheckBox( this, wxID_ANY, _("Adhesive Copper"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerAdhCu = new wxCheckBox( this, wxID_ANY, _("Adhesive Copper"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerAdhCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerAdhCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerPateCmp = new wxCheckBox( this, wxID_ANY, _("Solder paste Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerPateCmp = new wxCheckBox( this, wxID_ANY, _("Solder paste Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerPateCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerPateCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerPateCu = new wxCheckBox( this, wxID_ANY, _("Solder paste Copper"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerPateCu = new wxCheckBox( this, wxID_ANY, _("Solder paste Copper"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerPateCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerPateCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerSilkCmp = new wxCheckBox( this, wxID_ANY, _("Silkscreen Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerSilkCmp = new wxCheckBox( this, wxID_ANY, _("Silkscreen Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerSilkCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerSilkCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerSilkCu = new wxCheckBox( this, wxID_ANY, _("Silkscreen Copper"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerSilkCu = new wxCheckBox( this, wxID_ANY, _("Silkscreen Copper"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerSilkCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerSilkCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerMaskCmp = new wxCheckBox( this, wxID_ANY, _("Solder mask Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerMaskCmp = new wxCheckBox( this, wxID_ANY, _("Solder mask Cmp"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerMaskCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerMaskCmp, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerMaskCu = new wxCheckBox( this, wxID_ANY, _("Solder mask Copper"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerMaskCu = new wxCheckBox( this, wxID_ANY, _("Solder mask Copper"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerMaskCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerMaskCu, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerDraft = new wxCheckBox( this, wxID_ANY, _("Draft layer"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerDraft = new wxCheckBox( this, wxID_ANY, _("Draft layer"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerDraft, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerDraft, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerECO1 = new wxCheckBox( this, wxID_ANY, _("E.C.O.1 layer"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerECO1 = new wxCheckBox( this, wxID_ANY, _("E.C.O.1 layer"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerECO1, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
+    sbSizerTechlayers->Add( m_PadLayerECO1, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 
-	m_PadLayerECO2 = new wxCheckBox( this, wxID_ANY, _("E.C.O.2 layer"), wxDefaultPosition, wxDefaultSize, 0 );
+    m_PadLayerECO2 = new wxCheckBox( this, wxID_ANY, _("E.C.O.2 layer"), wxDefaultPosition, wxDefaultSize, 0 );
-	sbSizerTechlayers->Add( m_PadLayerECO2, 0, wxALL, 5 );
+    sbSizerTechlayers->Add( m_PadLayerECO2, 0, wxALL, 5 );
 
-	m_LayersSizer->Add( sbSizerTechlayers, 1, wxEXPAND, 5 );
+    m_LayersSizer->Add( sbSizerTechlayers, 1, wxEXPAND, 5 );
 
-	m_RightBoxSizer->Add( m_LayersSizer, 0, 0, 5 );
+    m_RightBoxSizer->Add( m_LayersSizer, 0, 0, 5 );
 
-	bGeneralSizer->Add( m_RightBoxSizer, 0, wxBOTTOM|wxRIGHT|wxEXPAND, 5 );
+    bGeneralSizer->Add( m_RightBoxSizer, 0, wxBOTTOM|wxRIGHT|wxEXPAND, 5 );
 
-	m_MainSizer->Add( bGeneralSizer, 1, wxEXPAND, 5 );
+    m_MainSizer->Add( bGeneralSizer, 1, wxEXPAND, 5 );
 
-	m_sdbSizer1 = new wxStdDialogButtonSizer();
+    m_sdbSizer1 = new wxStdDialogButtonSizer();
-	m_sdbSizer1OK = new wxButton( this, wxID_OK );
+    m_sdbSizer1OK = new wxButton( this, wxID_OK );
-	m_sdbSizer1->AddButton( m_sdbSizer1OK );
+    m_sdbSizer1->AddButton( m_sdbSizer1OK );
-	m_sdbSizer1Cancel = new wxButton( this, wxID_CANCEL );
+    m_sdbSizer1Cancel = new wxButton( this, wxID_CANCEL );
-	m_sdbSizer1->AddButton( m_sdbSizer1Cancel );
+    m_sdbSizer1->AddButton( m_sdbSizer1Cancel );
-	m_sdbSizer1->Realize();
+    m_sdbSizer1->Realize();
-	m_MainSizer->Add( m_sdbSizer1, 0, wxTOP|wxBOTTOM|wxEXPAND, 5 );
+    m_MainSizer->Add( m_sdbSizer1, 0, wxTOP|wxBOTTOM|wxEXPAND, 5 );
 
-	this->SetSizer( m_MainSizer );
+    this->SetSizer( m_MainSizer );
-	this->Layout();
+    this->Layout();
-	
+
-	this->Centre( wxBOTH );
+    this->Centre( wxBOTH );
-	
+
-	// Connect Events
+    // Connect Events
-	m_PadNumCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadNumCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadNetNameCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadNetNameCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadDrill_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadDrill_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadDrill_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadDrill_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeSize_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeSize_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeSize_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeSize_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeOffset_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeOffset_X_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeOffset_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeOffset_Y_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeDelta_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeDelta_Ctrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_radioBtnDeltaXdir->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_radioBtnDeltaXdir->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_radioBtnDeltaYdir->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_radioBtnDeltaYdir->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadShape->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPadShapeSelection ), NULL, this );
+    m_PadShape->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPadShapeSelection ), NULL, this );
-	m_DrillShapeCtrl->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnDrillShapeSelected ), NULL, this );
+    m_DrillShapeCtrl->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnDrillShapeSelected ), NULL, this );
-	m_PadOrient->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadOrientEvent ), NULL, this );
+    m_PadOrient->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadOrientEvent ), NULL, this );
-	m_PadOrientCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadOrientCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_panelShowPad->Connect( wxEVT_PAINT, wxPaintEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPaintShowPanel ), NULL, this );
+    m_panelShowPad->Connect( wxEVT_PAINT, wxPaintEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPaintShowPanel ), NULL, this );
-	m_NetClearanceValueCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_NetClearanceValueCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadType->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadTypeSelected ), NULL, this );
+    m_PadType->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadTypeSelected ), NULL, this );
-	m_rbCopperLayersSel->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_rbCopperLayersSel->Connect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerAdhCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerAdhCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerAdhCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerAdhCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerPateCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerPateCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerPateCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerPateCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerSilkCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerSilkCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerSilkCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerSilkCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerMaskCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerMaskCmp->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerMaskCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerMaskCu->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerDraft->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerDraft->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerECO1->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerECO1->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerECO2->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerECO2->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_sdbSizer1Cancel->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnCancelButtonClick ), NULL, this );
+    m_sdbSizer1Cancel->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnCancelButtonClick ), NULL, this );
-	m_sdbSizer1OK->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadPropertiesAccept ), NULL, this );
+    m_sdbSizer1OK->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadPropertiesAccept ), NULL, this );
 }
 
 DIALOG_PAD_PROPERTIES_BASE::~DIALOG_PAD_PROPERTIES_BASE()
 {
-	// Disconnect Events
+    // Disconnect Events
-	m_PadNumCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadNumCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadNetNameCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadNetNameCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadDrill_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadDrill_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadDrill_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadDrill_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeSize_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeSize_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeSize_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeSize_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeOffset_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeOffset_X_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeOffset_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeOffset_Y_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_ShapeDelta_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_ShapeDelta_Ctrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_radioBtnDeltaXdir->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_radioBtnDeltaXdir->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_radioBtnDeltaYdir->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_radioBtnDeltaYdir->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadShape->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPadShapeSelection ), NULL, this );
+    m_PadShape->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPadShapeSelection ), NULL, this );
-	m_DrillShapeCtrl->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnDrillShapeSelected ), NULL, this );
+    m_DrillShapeCtrl->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnDrillShapeSelected ), NULL, this );
-	m_PadOrient->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadOrientEvent ), NULL, this );
+    m_PadOrient->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadOrientEvent ), NULL, this );
-	m_PadOrientCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_PadOrientCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_panelShowPad->Disconnect( wxEVT_PAINT, wxPaintEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPaintShowPanel ), NULL, this );
+    m_panelShowPad->Disconnect( wxEVT_PAINT, wxPaintEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnPaintShowPanel ), NULL, this );
-	m_NetClearanceValueCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
+    m_NetClearanceValueCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnValuesChanged ), NULL, this );
-	m_PadType->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadTypeSelected ), NULL, this );
+    m_PadType->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadTypeSelected ), NULL, this );
-	m_rbCopperLayersSel->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_rbCopperLayersSel->Disconnect( wxEVT_COMMAND_RADIOBOX_SELECTED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerAdhCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerAdhCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerAdhCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerAdhCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerPateCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerPateCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerPateCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerPateCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerSilkCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerSilkCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerSilkCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerSilkCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerMaskCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerMaskCmp->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerMaskCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerMaskCu->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerDraft->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerDraft->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerECO1->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerECO1->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_PadLayerECO2->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
+    m_PadLayerECO2->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnSetLayers ), NULL, this );
-	m_sdbSizer1Cancel->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnCancelButtonClick ), NULL, this );
+    m_sdbSizer1Cancel->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::OnCancelButtonClick ), NULL, this );
-	m_sdbSizer1OK->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadPropertiesAccept ), NULL, this );
+    m_sdbSizer1OK->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PAD_PROPERTIES_BASE::PadPropertiesAccept ), NULL, this );
 
 }

pcbnew/dragsegm.cpp

@@ -35,36 +35,36 @@ DRAG_SEGM::DRAG_SEGM( TRACK* segm )
 /* Redraw the list of segments starting in g_DragSegmentList, while moving a footprint */
 void DrawSegmentWhileMovingFootprint( EDA_DRAW_PANEL* panel, wxDC* DC )
 {
-    D_PAD* pt_pad;
-    TRACK* Track;
-
     if( g_DragSegmentList.size() == 0 )
         return;
 
     for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
     {
         wxPoint pos;
-        Track = g_DragSegmentList[ii].m_Segm;
+
+        TRACK* track = g_DragSegmentList[ii].m_Segm;
+
 #ifndef USE_WX_OVERLAY
-        Track->Draw( panel, DC, GR_XOR );   // erase from screen at old position
+        track->Draw( panel, DC, GR_XOR );   // erase from screen at old position
 #endif
-        pt_pad = g_DragSegmentList[ii].m_Pad_Start;
 
-        if( pt_pad )
+        D_PAD* pad = g_DragSegmentList[ii].m_Pad_Start;
+
+        if( pad )
         {
-            pos = pt_pad->m_Pos - g_Offset_Module;
+            pos = pad->GetPosition() - g_Offset_Module;
-            Track->m_Start = pos;
+            track->m_Start = pos;
         }
 
-        pt_pad = g_DragSegmentList[ii].m_Pad_End;
+        pad = g_DragSegmentList[ii].m_Pad_End;
 
-        if( pt_pad )
+        if( pad )
         {
-            pos = pt_pad->m_Pos - g_Offset_Module;
+            pos = pad->GetPosition() - g_Offset_Module;
-            Track->m_End = pos;
+            track->m_End = pos;
         }
 
-        Track->Draw( panel, DC, GR_XOR );
+        track->Draw( panel, DC, GR_XOR );
     }
 }
 
@@ -74,15 +74,11 @@ void DrawSegmentWhileMovingFootprint( EDA_DRAW_PANEL* panel, wxDC* DC )
  *  For each selected track segment set the EDIT flag
  *  and redraw them in EDIT mode (sketch mode)
  */
-void Build_Drag_Liste( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* Module )
+void Build_Drag_Liste( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* aModule )
 {
-    D_PAD* pt_pad;
+    for( D_PAD* pad = aModule->m_Pads;  pad;  pad = pad->Next() )
-
-    pt_pad = Module->m_Pads;
-
-    for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Next() )
     {
-        Build_1_Pad_SegmentsToDrag( panel, DC, pt_pad );
+        Build_1_Pad_SegmentsToDrag( panel, DC, pad );
     }
 
     return;
@@ -95,37 +91,36 @@ void Build_Drag_Liste( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* Module )
  *  and redraw them in EDIT mode (sketch mode)
  *  Net codes must be OK.
  */
-void Build_1_Pad_SegmentsToDrag( EDA_DRAW_PANEL* panel, wxDC* DC, D_PAD* PtPad )
+void Build_1_Pad_SegmentsToDrag( EDA_DRAW_PANEL* panel, wxDC* DC, D_PAD* aPad )
 {
-    TRACK*  Track;
-    int     net_code = PtPad->GetNet();
-    int     LayerMask;
-    wxPoint pos;
     BOARD*  pcb = ( (PCB_BASE_FRAME*)( panel->GetParent() ) )->GetBoard();
 
-    Track = pcb->m_Track->GetStartNetCode( net_code );
+    int     net_code = aPad->GetNet();
 
-    pos = PtPad->m_Pos;
+    TRACK*  track = pcb->m_Track->GetStartNetCode( net_code );
-    LayerMask = PtPad->m_layerMask;
 
-    for( ; Track; Track = Track->Next() )
+    wxPoint pos = aPad->GetPosition();
+
+    int     layerMask = aPad->GetLayerMask();
+
+    for( ; track; track = track->Next() )
     {
-        if( Track->GetNet() != net_code )
+        if( track->GetNet() != net_code )
             break;
 
-        if( ( LayerMask & Track->ReturnMaskLayer() ) == 0 )
+        if( ( layerMask & track->ReturnMaskLayer() ) == 0 )
             continue;
 
-        if( pos == Track->m_Start )
+        if( pos == track->m_Start )
         {
-            AddSegmentToDragList( panel, DC, STARTPOINT, Track );
+            AddSegmentToDragList( panel, DC, STARTPOINT, track );
-            g_DragSegmentList.back().m_Pad_Start = PtPad;
+            g_DragSegmentList.back().m_Pad_Start = aPad;
         }
 
-        if( pos == Track->m_End )
+        if( pos == track->m_End )
         {
-            AddSegmentToDragList( panel, DC, ENDPOINT, Track );
+            AddSegmentToDragList( panel, DC, ENDPOINT, track );
-            g_DragSegmentList.back().m_Pad_End = PtPad;
+            g_DragSegmentList.back().m_Pad_End = aPad;
         }
     }
 }

pcbnew/drc.cpp

@@ -422,9 +422,10 @@ void DRC::testPad2Pad()
     {
         D_PAD* pad = sortedPads[i];
 
-        // m_ShapeMaxRadius is the radius value of the circle containing the pad
+        // GetBoundingRadius() is the radius of the minimum sized circle fully containing the pad
-        if( pad->m_ShapeMaxRadius > max_size )
+        int radius = pad->GetBoundingRadius();
-            max_size = pad->m_ShapeMaxRadius;
+        if( radius > max_size )
+            max_size = radius;
     }
 
     // Test the pads
@@ -435,7 +436,7 @@ void DRC::testPad2Pad()
         D_PAD* pad = sortedPads[i];
 
         int    x_limit = max_size + pad->GetClearance() +
-                         pad->m_ShapeMaxRadius + pad->GetPosition().x;
+                         pad->GetBoundingRadius() + pad->GetPosition().x;
 
         if( !doPadToPadsDrc( pad, &sortedPads[i], listEnd, x_limit ) )
         {
@@ -559,7 +560,7 @@ void DRC::testZones()
 
 bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_limit )
 {
-    int layerMask = aRefPad->m_layerMask & ALL_CU_LAYERS;
+    int layerMask = aRefPad->GetLayerMask() & ALL_CU_LAYERS;
 
     /* used to test DRC pad to holes: this dummy pad has the size and shape of the hole
      * to test pad to pad hole DRC, using the pad to pad DRC test function.
@@ -569,12 +570,14 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
      */
     MODULE dummymodule( m_pcb );    // Creates a dummy parent
     D_PAD dummypad( &dummymodule );
-    dummypad.m_layerMask   |= ALL_CU_LAYERS;  // Ensure the hole is on all copper layers
+
-    dummypad.m_LocalClearance = 1;   /* Use the minimal local clearance value for the dummy pad
+    // Ensure the hole is on all copper layers
-                                      *  the clearance of the active pad will be used
+    dummypad.SetLayerMask( ALL_CU_LAYERS | dummypad.GetLayerMask() );
-                                      *  as minimum distance to a hole
+
-                                      *  (a value = 0 means use netclass value)
+    // Use the minimal local clearance value for the dummy pad.
-                                      */
+    // The clearance of the active pad will be used as minimum distance to a hole
+    // (a value = 0 means use netclass value)
+    dummypad.SetLocalClearance( 1 );
 
     for( D_PAD** pad_list = aStart;  pad_list<aEnd;  ++pad_list )
     {
@@ -583,43 +586,40 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
         if( pad == aRefPad )
             continue;
 
-        // We can stop the test when pad->m_Pos.x > x_limit
+        // We can stop the test when pad->GetPosition().x > x_limit
         // because the list is sorted by X values
-        if( pad->m_Pos.x > x_limit )
+        if( pad->GetPosition().x > x_limit )
             break;
 
         // No problem if pads are on different copper layers,
         // but their hole (if any ) can create DRC error because they are on all
         // copper layers, so we test them
-        if( ( pad->m_layerMask & layerMask ) == 0 )
+        if( ( pad->GetLayerMask() & layerMask ) == 0 )
         {
             // if holes are in the same location and have the same size and shape,
             // this can be accepted
             if( pad->GetPosition() == aRefPad->GetPosition()
-                && pad->m_Drill == aRefPad->m_Drill
+                && pad->GetDrillSize() == aRefPad->GetDrillSize()
-                && pad->m_DrillShape == aRefPad->m_DrillShape )
+                && pad->GetDrillShape() == aRefPad->GetDrillShape() )
             {
-                if( aRefPad->m_DrillShape == PAD_CIRCLE )
+                if( aRefPad->GetDrillShape() == PAD_CIRCLE )
                     continue;
 
                 // for oval holes: must also have the same orientation
-                if( pad->m_Orient == aRefPad->m_Orient )
+                if( pad->GetOrientation() == aRefPad->GetOrientation() )
                     continue;
             }
 
             /* Here, we must test clearance between holes and pads
              * dummy pad size and shape is adjusted to pad drill size and shape
              */
-            if( pad->m_Drill.x )
+            if( pad->GetDrillSize().x )
             {
                 // pad under testing has a hole, test this hole against pad reference
                 dummypad.SetPosition( pad->GetPosition() );
-                dummypad.m_Size     = pad->m_Drill;
+                dummypad.SetSize( pad->GetDrillSize() );
-                dummypad.m_PadShape = (pad->m_DrillShape == PAD_OVAL) ? PAD_OVAL : PAD_CIRCLE;
+                dummypad.SetShape( pad->GetDrillShape() == PAD_OVAL ? PAD_OVAL : PAD_CIRCLE );
-                dummypad.m_Orient   = pad->m_Orient;
+                dummypad.SetOrientation( pad->GetOrientation() );
-
-                // compute the radius of the circle containing this pad
-                dummypad.ComputeShapeMaxRadius();
 
                 if( !checkClearancePadToPad( aRefPad, &dummypad ) )
                 {
@@ -630,15 +630,12 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
                 }
             }
 
-            if( aRefPad->m_Drill.x ) // pad reference has a hole
+            if( aRefPad->GetDrillSize().x ) // pad reference has a hole
             {
                 dummypad.SetPosition( aRefPad->GetPosition() );
-                dummypad.m_Size     = aRefPad->m_Drill;
+                dummypad.SetSize( aRefPad->GetDrillSize() );
-                dummypad.m_PadShape = (aRefPad->m_DrillShape == PAD_OVAL) ? PAD_OVAL : PAD_CIRCLE;
+                dummypad.SetShape( aRefPad->GetDrillShape() == PAD_OVAL ? PAD_OVAL : PAD_CIRCLE );
-                dummypad.m_Orient   = aRefPad->m_Orient;
+                dummypad.SetOrientation( aRefPad->GetOrientation() );
-
-                // compute the radius of the circle containing this pad
-                dummypad.ComputeShapeMaxRadius();
 
                 if( !checkClearancePadToPad( pad, &dummypad ) )
                 {
@@ -652,7 +649,6 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li
             continue;
         }
 
-
         // The pad must be in a net (i.e pt_pad->GetNet() != 0 ),
         // But no problem if pads have the same netcode (same net)
         if( pad->GetNet() && ( aRefPad->GetNet() == pad->GetNet() ) )

pcbnew/drc_clearance_test_functions.cpp

@@ -271,7 +271,8 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
      */
     MODULE dummymodule( m_pcb );    // Creates a dummy parent
     D_PAD dummypad( &dummymodule );
-    dummypad.m_layerMask = ALL_CU_LAYERS;    // Ensure the hole is on all layers
+
+    dummypad.SetLayerMask( ALL_CU_LAYERS );     // Ensure the hole is on all layers
 
     // Compute the min distance to pads
     if( testPads )
@@ -284,20 +285,20 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
              * But if a drill hole exists	(a pad on a single layer can have a hole!)
              * we must test the hole
              */
-            if( (pad->m_layerMask & layerMask ) == 0 )
+            if( (pad->GetLayerMask() & layerMask ) == 0 )
             {
                 /* We must test the pad hole. In order to use the function
                  * checkClearanceSegmToPad(),a pseudo pad is used, with a shape and a
                  * size like the hole
                  */
-                if( pad->m_Drill.x == 0 )
+                if( pad->GetDrillSize().x == 0 )
                     continue;
 
-                dummypad.m_Size = pad->m_Drill;
+                dummypad.SetSize( pad->GetDrillSize() );
                 dummypad.SetPosition( pad->GetPosition() );
-                dummypad.m_PadShape = pad->m_DrillShape;
+                dummypad.SetShape( pad->GetDrillShape() );
-                dummypad.m_Orient   = pad->m_Orient;
+                dummypad.SetOrientation( pad->GetOrientation() );
-                dummypad.ComputeShapeMaxRadius();      // compute the radius of the circle containing this pad
+
                 m_padToTestPos = dummypad.GetPosition() - origin;
 
                 if( !checkClearanceSegmToPad( &dummypad, aRefSeg->m_Width,
@@ -311,9 +312,8 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
                 continue;
             }
 
-            /* The pad must be in a net (i.e pt_pad->GetNet() != 0 )
+            // The pad must be in a net (i.e pt_pad->GetNet() != 0 )
-             * but no problem if the pad netcode is the current netcode (same net)
+            // but no problem if the pad netcode is the current netcode (same net)
-             */
             if( pad->GetNet()                       // the pad must be connected
                && net_code_ref == pad->GetNet() )   // the pad net is the same as current net -> Ok
                 continue;
@@ -587,7 +587,7 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
     dist = (int) hypot( relativePadPos.x, relativePadPos.y );
 
     // Quick test: Clearance is OK if the bounding circles are further away than "dist_min"
-    if( (dist - aRefPad->m_ShapeMaxRadius - aPad->m_ShapeMaxRadius) >= dist_min )
+    if( (dist - aRefPad->GetBoundingRadius() - aPad->GetBoundingRadius()) >= dist_min )
         return true;
 
     /* Here, pads are near and DRC depend on the pad shapes
@@ -600,11 +600,11 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
     bool swap_pads;
     swap_pads = false;
 
-    if( (aRefPad->m_PadShape != PAD_CIRCLE) && (aPad->m_PadShape == PAD_CIRCLE) )
+    if( aRefPad->GetShape() != PAD_CIRCLE  &&  aPad->GetShape() == PAD_CIRCLE )
         swap_pads = true;
-    else if( (aRefPad->m_PadShape != PAD_OVAL) && (aPad->m_PadShape == PAD_OVAL) )
+    else if(  aRefPad->GetShape() != PAD_OVAL  &&  aPad->GetShape() == PAD_OVAL )
         swap_pads = true;
-    else if( (aRefPad->m_PadShape != PAD_RECT) && (aPad->m_PadShape == PAD_RECT) )
+    else if(  aRefPad->GetShape() != PAD_RECT  &&  aPad->GetShape() == PAD_RECT )
         swap_pads = true;
 
     if( swap_pads )
@@ -620,12 +620,12 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
      */
     bool diag = true;
 
-    switch( aRefPad->m_PadShape )
+    switch( aRefPad->GetShape() )
     {
     case PAD_CIRCLE:
 
         /* One can use checkClearanceSegmToPad to test clearance
-         * aRefPad is like a track segment with a null length and a witdth = m_Size.x
+         * aRefPad is like a track segment with a null length and a witdth = GetSize().x
          */
         m_segmLength = 0;
         m_segmAngle  = 0;
@@ -633,25 +633,25 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
         m_segmEnd.x = m_segmEnd.y = 0;
 
         m_padToTestPos = relativePadPos;
-        diag = checkClearanceSegmToPad( aPad, aRefPad->m_Size.x, dist_min );
+        diag = checkClearanceSegmToPad( aPad, aRefPad->GetSize().x, dist_min );
         break;
 
     case PAD_RECT:
 
         // pad_angle = pad orient relative to the aRefPad orient
-        pad_angle = aRefPad->m_Orient + aPad->m_Orient;
+        pad_angle = aRefPad->GetOrientation() + aPad->GetOrientation();
         NORMALIZE_ANGLE_POS( pad_angle );
 
-        if( aPad->m_PadShape == PAD_RECT )
+        if( aPad->GetShape() == PAD_RECT )
         {
-            wxSize size = aPad->m_Size;
+            wxSize size = aPad->GetSize();
 
             // The trivial case is if both rects are rotated by multiple of 90 deg
             // Most of time this is the case, and the test is fast
-            if( ( (aRefPad->m_Orient == 0) || (aRefPad->m_Orient == 900)
+            if( ( (aRefPad->GetOrientation() == 0) || (aRefPad->GetOrientation() == 900)
-                 || (aRefPad->m_Orient == 1800) || (aRefPad->m_Orient == 2700) )
+                 || (aRefPad->GetOrientation() == 1800) || (aRefPad->GetOrientation() == 2700) )
-               && ( (aPad->m_Orient == 0) || (aPad->m_Orient == 900) || (aPad->m_Orient == 1800)
+               && ( (aPad->GetOrientation() == 0) || (aPad->GetOrientation() == 900) || (aPad->GetOrientation() == 1800)
-                   || (aPad->m_Orient == 2700) ) )
+                   || (aPad->GetOrientation() == 2700) ) )
             {
                 if( (pad_angle == 900) || (pad_angle == 2700) )
                 {
@@ -660,22 +660,22 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
 
                 // Test DRC:
                 diag = false;
-                RotatePoint( &relativePadPos, aRefPad->m_Orient );
+                RotatePoint( &relativePadPos, aRefPad->GetOrientation() );
                 relativePadPos.x = ABS( relativePadPos.x );
                 relativePadPos.y = ABS( relativePadPos.y );
 
-                if( ( relativePadPos.x - ( (size.x + aRefPad->m_Size.x) / 2 ) ) >= dist_min )
+                if( ( relativePadPos.x - ( (size.x + aRefPad->GetSize().x) / 2 ) ) >= dist_min )
                     diag = true;
 
-                if( ( relativePadPos.y - ( (size.y + aRefPad->m_Size.y) / 2 ) ) >= dist_min )
+                if( ( relativePadPos.y - ( (size.y + aRefPad->GetSize().y) / 2 ) ) >= dist_min )
                     diag = true;
             }
             else    // at least one pad has any other orient. Test is more tricky
             {   // Use the trapezoid2trapezoidDRC which also compare 2 rectangles with any orientation
                 wxPoint polyref[4];         // Shape of aRefPad
                 wxPoint polycompare[4];     // Shape of aPad
-                aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->m_Orient );
+                aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->GetOrientation() );
-                aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->m_Orient );
+                aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->GetOrientation() );
 
                 // Move aPad shape to relativePadPos
                 for( int ii = 0; ii < 4; ii++ )
@@ -686,12 +686,12 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
                     diag = false;
             }
         }
-        else if( aPad->m_PadShape == PAD_TRAPEZOID )
+        else if( aPad->GetShape() == PAD_TRAPEZOID )
         {
             wxPoint polyref[4];         // Shape of aRefPad
             wxPoint polycompare[4];     // Shape of aPad
-            aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->m_Orient );
+            aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->GetOrientation() );
-            aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->m_Orient );
+            aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->GetOrientation() );
 
             // Move aPad shape to relativePadPos
             for( int ii = 0; ii < 4; ii++ )
@@ -715,17 +715,17 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
          * and use checkClearanceSegmToPad function to test aPad to aRefPad clearance
          */
         int segm_width;
-        m_segmAngle = aRefPad->m_Orient;                // Segment orient.
+        m_segmAngle = aRefPad->GetOrientation();                // Segment orient.
 
-        if( aRefPad->m_Size.y < aRefPad->m_Size.x )     // Build an horizontal equiv segment
+        if( aRefPad->GetSize().y < aRefPad->GetSize().x )     // Build an horizontal equiv segment
         {
-            segm_width   = aRefPad->m_Size.y;
+            segm_width   = aRefPad->GetSize().y;
-            m_segmLength = aRefPad->m_Size.x - aRefPad->m_Size.y;
+            m_segmLength = aRefPad->GetSize().x - aRefPad->GetSize().y;
         }
         else        // Vertical oval: build an horizontal equiv segment and rotate 90.0 deg
         {
-            segm_width   = aRefPad->m_Size.x;
+            segm_width   = aRefPad->GetSize().x;
-            m_segmLength = aRefPad->m_Size.y - aRefPad->m_Size.x;
+            m_segmLength = aRefPad->GetSize().y - aRefPad->GetSize().x;
             m_segmAngle += 900;
         }
 
@@ -755,12 +755,12 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad )
 
         // at this point, aPad is also a trapezoid, because all other shapes
         // have priority, and are already tested
-        wxASSERT( aPad->m_PadShape == PAD_TRAPEZOID );
+        wxASSERT( aPad->GetShape() == PAD_TRAPEZOID );
         {
             wxPoint polyref[4];         // Shape of aRefPad
             wxPoint polycompare[4];     // Shape of aPad
-            aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->m_Orient );
+            aRefPad->BuildPadPolygon( polyref, wxSize( 0, 0 ), aRefPad->GetOrientation() );
-            aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->m_Orient );
+            aPad->BuildPadPolygon( polycompare, wxSize( 0, 0 ), aPad->GetOrientation() );
 
             // Move aPad shape to relativePadPos
             for( int ii = 0; ii < 4; ii++ )
@@ -797,16 +797,16 @@ bool DRC::checkClearanceSegmToPad( const D_PAD* aPad, int aSegmentWidth, int aMi
     int     segmHalfWidth = aSegmentWidth / 2;
 
     seuil = segmHalfWidth + aMinDist;
-    padHalfsize.x = aPad->m_Size.x >> 1;
+    padHalfsize.x = aPad->GetSize().x >> 1;
-    padHalfsize.y = aPad->m_Size.y >> 1;
+    padHalfsize.y = aPad->GetSize().y >> 1;
 
-    if( aPad->m_PadShape == PAD_TRAPEZOID ) // The size is bigger, due to m_DeltaSize extra size
+    if( aPad->GetShape() == PAD_TRAPEZOID ) // The size is bigger, due to GetDelta() extra size
     {
-        padHalfsize.x += ABS(aPad->m_DeltaSize.y) / 2;   // Remember: m_DeltaSize.y is the m_Size.x change
+        padHalfsize.x += ABS(aPad->GetDelta().y) / 2;   // Remember: GetDelta().y is the GetSize().x change
-        padHalfsize.y += ABS(aPad->m_DeltaSize.x) / 2;   // Remember: m_DeltaSize.x is the m_Size.y change
+        padHalfsize.y += ABS(aPad->GetDelta().x) / 2;   // Remember: GetDelta().x is the GetSize().y change
     }
 
-    if( aPad->m_PadShape == PAD_CIRCLE )
+    if( aPad->GetShape() == PAD_CIRCLE )
     {
         /* Easy case: just test the distance between segment and pad centre
          * calculate pad coordinates in the X,Y axis with X axis = segment to test
@@ -828,7 +828,7 @@ bool DRC::checkClearanceSegmToPad( const D_PAD* aPad, int aSegmentWidth, int aMi
     startPoint.x = startPoint.y = 0;
     endPoint     = m_segmEnd;
 
-    orient = aPad->m_Orient;
+    orient = aPad->GetOrientation();
 
     RotatePoint( &startPoint, m_padToTestPos, -orient );
     RotatePoint( &endPoint, m_padToTestPos, -orient );
@@ -839,7 +839,7 @@ bool DRC::checkClearanceSegmToPad( const D_PAD* aPad, int aSegmentWidth, int aMi
     /* segment intersects the bounding box. But there is not always a DRC error.
      * A fine analysis of the pad shape must be done.
      */
-    switch( aPad->m_PadShape )
+    switch( aPad->GetShape() )
     {
     default:
         return false;

pcbnew/editmod.cpp

@@ -59,36 +59,30 @@ void PCB_EDIT_FRAME::InstallModuleOptionsFrame( MODULE* Module, wxDC* DC )
 /*
  * Move the footprint anchor position to the current cursor position.
  */
-void FOOTPRINT_EDIT_FRAME::Place_Ancre( MODULE* pt_mod )
+void FOOTPRINT_EDIT_FRAME::Place_Ancre( MODULE* aModule )
 {
     wxPoint   moveVector;
-    EDA_ITEM* item;
-    D_PAD*    pad;
 
-    if( pt_mod == NULL )
+    if( aModule == NULL )
         return;
 
-    moveVector = pt_mod->m_Pos - GetScreen()->GetCrossHairPosition();
+    moveVector = aModule->m_Pos - GetScreen()->GetCrossHairPosition();
 
-    pt_mod->m_Pos = GetScreen()->GetCrossHairPosition();
+    aModule->m_Pos = GetScreen()->GetCrossHairPosition();
 
     /* Update the relative coordinates:
      * The coordinates are relative to the anchor point.
      * Calculate deltaX and deltaY from the anchor. */
-    RotatePoint( &moveVector, -pt_mod->m_Orient );
+    RotatePoint( &moveVector, -aModule->m_Orient );
 
-    /* Update the pad coordinates. */
+    // Update the pad coordinates.
-    pad = (D_PAD*) pt_mod->m_Pads;
+    for( D_PAD* pad = (D_PAD*) aModule->m_Pads;  pad;  pad = pad->Next() )
-
-    for( ; pad != NULL; pad = pad->Next() )
     {
-        pad->m_Pos0 += moveVector;
+        pad->SetPos0( pad->GetPos0() + moveVector );
     }
 
-    /* Update the draw element coordinates. */
+    // Update the draw element coordinates.
-    item = pt_mod->m_Drawings;
+    for( EDA_ITEM* item = aModule->m_Drawings;  item;  item = item->Next() )
-
-    for( ; item != NULL; item = item->Next() )
     {
         switch( item->Type() )
         {
@@ -110,7 +104,7 @@ void FOOTPRINT_EDIT_FRAME::Place_Ancre( MODULE* pt_mod )
         }
     }
 
-    pt_mod->CalculateBoundingBox();
+    aModule->CalculateBoundingBox();
 }
 
 

pcbnew/editrack.cpp

@@ -65,7 +65,7 @@ static void Abort_Create_Track( EDA_DRAW_PANEL* Panel, wxDC* DC )
 
     if( track && ( track->Type()==PCB_VIA_T || track->Type()==PCB_TRACE_T ) )
     {
-        /* Erase the current drawing */
+        // Erase the current drawing
         ShowNewTrackWhenMovingCursor( Panel, DC, wxDefaultPosition, false );
 
         if( pcb->IsHighLightNetON() )
@@ -102,7 +102,7 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
     BOARD_CONNECTED_ITEM* LockPoint;
     wxPoint     pos = GetScreen()->GetCrossHairPosition();
 
-    if( aTrack == NULL )  /* Starting a new track segment */
+    if( aTrack == NULL )  // Starting a new track segment
     {
         m_canvas->SetMouseCapture( ShowNewTrackWhenMovingCursor, Abort_Create_Track );
 
@@ -130,11 +130,11 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
             {
                 pad = (D_PAD*) LockPoint;
 
-                /* A pad is found: put the starting point on pad center */
+                // A pad is found: put the starting point on pad center
-                pos = pad->m_Pos;
+                pos = pad->GetPosition();
                 GetBoard()->SetHighLightNet( pad->GetNet() );
             }
-            else /* A track segment is found */
+            else // A track segment is found
             {
                 TrackOnStartPoint    = (TRACK*) LockPoint;
                 GetBoard()->SetHighLightNet( TrackOnStartPoint->GetNet() );
@@ -214,7 +214,7 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
     }
     else   // Track in progress : segment coordinates are updated by ShowNewTrackWhenMovingCursor.
     {
-        /* Test for a D.R.C. error: */
+        // Test for a D.R.C. error:
         if( Drc_On )
         {
             if( BAD_DRC == m_drc->Drc( g_CurrentTrackSegment, GetBoard()->m_Track ) )
@@ -244,7 +244,7 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
 
         if( CanCreateNewSegment )
         {
-            /* Erase old track on screen */
+            // Erase old track on screen
             D( g_CurrentTrackList.VerifyListIntegrity(); );
 
             ShowNewTrackWhenMovingCursor( m_canvas, aDC, wxDefaultPosition, false );
@@ -283,7 +283,7 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
 
             D( g_CurrentTrackList.VerifyListIntegrity(); );
 
-            /* Show the new position */
+            // Show the new position
             ShowNewTrackWhenMovingCursor( m_canvas, aDC, wxDefaultPosition, false );
         }
     }
@@ -298,7 +298,7 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
     int dx0, dy0, dx1, dy1;
 
     if( g_CurrentTrackList.GetCount() < 2 )
-        return false;                         /* There must be 2 segments. */
+        return false;                         // There must be 2 segments.
 
     TRACK* curTrack  = g_CurrentTrackSegment;
     TRACK* prevTrack = curTrack->Back();
@@ -328,7 +328,7 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
     if( max( abs( dx1 ), abs( dy1 ) ) < ( segm_step_45 * 2 ) )
         return false;
 
-    /* Create a new segment and connect it with the previous 2 segments. */
+    // Create a new segment and connect it with the previous 2 segments.
     TRACK* newTrack = (TRACK*)curTrack->Clone();
 
     newTrack->m_Start = prevTrack->m_End;
@@ -418,7 +418,7 @@ bool PCB_EDIT_FRAME::End_Route( TRACK* aTrack, wxDC* aDC )
     if( Drc_On && BAD_DRC == m_drc->Drc( g_CurrentTrackSegment, GetBoard()->m_Track ) )
         return false;
 
-    /* Saving the coordinate of end point of the trace */
+    // Saving the coordinate of end point of the trace
     wxPoint pos = g_CurrentTrackSegment->m_End;
 
     D( g_CurrentTrackList.VerifyListIntegrity(); );
@@ -554,7 +554,7 @@ TRACK* LocateIntrusion( TRACK* listStart, TRACK* aTrack, int aLayer, const wxPoi
             if( track->GetNet() == net )
                 continue;
 
-            /* TRACK::HitTest */
+            // TRACK::HitTest
             int     dist = (width + track->m_Width) / 2 + aTrack->GetClearance( track );
 
             wxPoint pos = aRef - track->m_Start;
@@ -565,7 +565,7 @@ TRACK* LocateIntrusion( TRACK* listStart, TRACK* aTrack, int aLayer, const wxPoi
 
             found = track;
 
-            /* prefer intrusions from the side, not the end */
+            // prefer intrusions from the side, not the end
             double tmp = (double) pos.x * vec.x + (double) pos.y * vec.y;
 
             if( tmp >= 0 && tmp <= (double) vec.x * vec.x + (double) vec.y * vec.y )
@@ -607,7 +607,7 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
 
     other = LocateIntrusion( pcb->m_Track, track, screen->m_Active_Layer, screen->RefPos( true ) );
 
-    /* are we currently pointing into a conflicting trace ? */
+    // are we currently pointing into a conflicting trace ?
     if( !other )
         return;
 
@@ -619,7 +619,7 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
 
     det = (double) cv.x * vec.y - (double) cv.y * vec.x;
 
-    /* cursor is right at the center of the old track */
+    // cursor is right at the center of the old track
     if( !det )
         return;
 
@@ -630,7 +630,7 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
      * We may have a quantization error of 1/sqrt(2), so +1 again.
      */
 
-    /* Vector "n" is perpendicular to "other", pointing towards the cursor. */
+    // Vector "n" is perpendicular to "other", pointing towards the cursor.
     if( det > 0 )
     {
         n.x = vec.y;
@@ -674,7 +674,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
         DisplayOpt.ShowTrackClearanceMode = SHOW_CLEARANCE_ALWAYS;
 
 #ifndef USE_WX_OVERLAY
-    /* Erase old track */
+    // Erase old track
     if( aErase )
     {
         DrawTraces( aPanel, aDC, g_FirstTrackSegment, g_CurrentTrackList.GetCount(), GR_XOR );
@@ -740,12 +740,12 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
                                       &g_CurrentTrackSegment->m_End.y );
         }
     }
-    else    /* Here the angle is arbitrary */
+    else    // Here the angle is arbitrary
     {
         g_CurrentTrackSegment->m_End = screen->GetCrossHairPosition();
     }
 
-    /* Redraw the new track */
+    // Redraw the new track
     D( g_CurrentTrackList.VerifyListIntegrity(); );
     DrawTraces( aPanel, aDC, g_FirstTrackSegment, g_CurrentTrackList.GetCount(), GR_XOR );
 
@@ -782,7 +782,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
     if( g_FirstTrackSegment->GetState( BEGIN_ONPAD ) )
     {
         D_PAD * pad = (D_PAD *) g_FirstTrackSegment->start;
-        lenDie = (double) pad->m_LengthDie;
+        lenDie = (double) pad->GetDieLength();
     }
 
     // calculate track len on board:
@@ -853,7 +853,7 @@ void CalculateSegmentEndPoint( const wxPoint& aPosition, int ox, int oy, int* fx
         deltax = min( deltax, deltay );
         deltay = deltax;
 
-        /* Recalculate the signs for deltax and deltaY. */
+        // Recalculate the signs for deltax and deltaY.
         if( ( aPosition.x - ox ) < 0 )
             deltax = -deltax;
 
@@ -948,7 +948,7 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
         iDx = min( iDx, iDy );
         iDy = iDx;
 
-        /* Recalculate the signs for deltax and deltaY. */
+        // Recalculate the signs for deltax and deltaY.
         if( ( end.x - track->m_Start.x ) < 0 )
             iDx = -iDx;
 
@@ -1064,11 +1064,11 @@ void DeleteNullTrackSegments( BOARD* pcb, DLIST<TRACK>& aTrackList )
  *  if no, create a new track segment if necessary
  *  and move current (or new) end segment on pad
  */
-void EnsureEndTrackOnPad( D_PAD* Pad )
+void EnsureEndTrackOnPad( D_PAD* aPad )
 {
-    if( g_CurrentTrackSegment->m_End == Pad->m_Pos ) // Ok !
+    if( g_CurrentTrackSegment->m_End == aPad->GetPosition() ) // Ok !
     {
-        g_CurrentTrackSegment->end = Pad;
+        g_CurrentTrackSegment->end = aPad;
         g_CurrentTrackSegment->SetState( END_ONPAD, ON );
         return;
     }
@@ -1077,15 +1077,15 @@ void EnsureEndTrackOnPad( D_PAD* Pad )
 
     if( !g_CurrentTrackSegment->IsNull() )
     {
-        /* Must create a new segment, from track end to pad center */
+        // Must create a new segment, from track end to pad center
         g_CurrentTrackList.PushBack( (TRACK*)lasttrack->Clone() );
 
         lasttrack->end = g_CurrentTrackSegment;
     }
 
-    g_CurrentTrackSegment->m_End = Pad->m_Pos;
+    g_CurrentTrackSegment->m_End = aPad->GetPosition();
     g_CurrentTrackSegment->SetState( END_ONPAD, OFF );
 
-    g_CurrentTrackSegment->end = Pad;
+    g_CurrentTrackSegment->end = aPad;
     g_CurrentTrackSegment->SetState( END_ONPAD, ON );
 }

pcbnew/export_gencad.cpp

@@ -317,30 +317,30 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
         fprintf( aFile, "PAD P%d", pad->GetSubRatsnest() );
 
         padstacks.push_back( pad ); // Will have its own padstack later
-        int dx = pad->m_Size.x / 2;
+        int dx = pad->GetSize().x / 2;
-        int dy = pad->m_Size.y / 2;
+        int dy = pad->GetSize().y / 2;
 
-        switch( pad->m_PadShape )
+        switch( pad->GetShape() )
         {
         default:
         case PAD_CIRCLE:
             fprintf( aFile, " ROUND %g\n",
-                     pad->m_Drill.x / SCALE_FACTOR );
+                     pad->GetDrillSize().x / SCALE_FACTOR );
             /* Circle is center, radius */
             fprintf( aFile, "CIRCLE %g %g %g\n",
-                    pad->m_Offset.x / SCALE_FACTOR,
+                    pad->GetOffset().x / SCALE_FACTOR,
-                    -pad->m_Offset.y / SCALE_FACTOR,
+                    -pad->GetOffset().y / SCALE_FACTOR,
-                    pad->m_Size.x / (SCALE_FACTOR * 2) );
+                    pad->GetSize().x / (SCALE_FACTOR * 2) );
             break;
 
         case PAD_RECT:
             fprintf( aFile, " RECTANGULAR %g\n",
-                     pad->m_Drill.x / SCALE_FACTOR );
+                     pad->GetDrillSize().x / SCALE_FACTOR );
 
             // Rectangle is begin, size *not* begin, end!
             fprintf( aFile, "RECTANGLE %g %g %g %g\n",
-                    (-dx + pad->m_Offset.x ) / SCALE_FACTOR,
+                    (-dx + pad->GetOffset().x ) / SCALE_FACTOR,
-                    (-dy - pad->m_Offset.y ) / SCALE_FACTOR,
+                    (-dy - pad->GetOffset().y ) / SCALE_FACTOR,
                     dx / (SCALE_FACTOR / 2), dy / (SCALE_FACTOR / 2) );
             break;
 
@@ -348,76 +348,76 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
         {
             // OrCAD Layout call them OVAL or OBLONG - GenCAD call them FINGERs
             fprintf( aFile, " FINGER %g\n",
-                     pad->m_Drill.x / SCALE_FACTOR );
+                     pad->GetDrillSize().x / SCALE_FACTOR );
             int dr = dx - dy;
 
             if( dr >= 0 )       // Horizontal oval
             {
                 int radius = dy;
                 fprintf( aFile, "LINE %g %g %g %g\n",
-                         (-dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - radius) / SCALE_FACTOR,
-                         (dr + pad->m_Offset.x ) / SCALE_FACTOR,
+                         (dr + pad->GetOffset().x ) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - radius) / SCALE_FACTOR );
+                         (-pad->GetOffset().y - radius) / SCALE_FACTOR );
 
                 // GenCAD arcs are (start, end, center)
                 fprintf( aFile, "ARC %g %g %g %g %g %g\n",
-                         (dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - radius) / SCALE_FACTOR,
-                         (dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + radius) / SCALE_FACTOR,
-                         (dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         -pad->m_Offset.y / SCALE_FACTOR );
+                         -pad->GetOffset().y / SCALE_FACTOR );
 
                 fprintf( aFile, "LINE %g %g %g %g\n",
-                         (dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + radius) / SCALE_FACTOR,
-                         (-dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + radius) / SCALE_FACTOR );
+                         (-pad->GetOffset().y + radius) / SCALE_FACTOR );
                 fprintf( aFile, "ARC %g %g %g %g %g %g\n",
-                         (-dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + radius) / SCALE_FACTOR,
-                         (-dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - radius) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - radius) / SCALE_FACTOR,
-                         (-dr + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-dr + pad->GetOffset().x) / SCALE_FACTOR,
-                         -pad->m_Offset.y / SCALE_FACTOR );
+                         -pad->GetOffset().y / SCALE_FACTOR );
             }
             else        // Vertical oval
             {
                 dr = -dr;
                 int radius = dx;
                 fprintf( aFile, "LINE %g %g %g %g\n",
-                         (-radius + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-radius + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - dr) / SCALE_FACTOR,
-                         (-radius + pad->m_Offset.x ) / SCALE_FACTOR,
+                         (-radius + pad->GetOffset().x ) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + dr) / SCALE_FACTOR );
+                         (-pad->GetOffset().y + dr) / SCALE_FACTOR );
                 fprintf( aFile, "ARC %g %g %g %g %g %g\n",
-                         (-radius + pad->m_Offset.x ) / SCALE_FACTOR,
+                         (-radius + pad->GetOffset().x ) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + dr) / SCALE_FACTOR,
-                         (radius + pad->m_Offset.x ) / SCALE_FACTOR,
+                         (radius + pad->GetOffset().x ) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + dr) / SCALE_FACTOR,
-                         pad->m_Offset.x / SCALE_FACTOR,
+                         pad->GetOffset().x / SCALE_FACTOR,
-                         (-pad->m_Offset.y + dr) / SCALE_FACTOR );
+                         (-pad->GetOffset().y + dr) / SCALE_FACTOR );
 
                 fprintf( aFile, "LINE %g %g %g %g\n",
-                         (radius + pad->m_Offset.x) / SCALE_FACTOR,
+                         (radius + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y + dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y + dr) / SCALE_FACTOR,
-                         (radius + pad->m_Offset.x) / SCALE_FACTOR,
+                         (radius + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - dr) / SCALE_FACTOR );
+                         (-pad->GetOffset().y - dr) / SCALE_FACTOR );
                 fprintf( aFile, "ARC %g %g %g %g %g %g\n",
-                         (radius + pad->m_Offset.x) / SCALE_FACTOR,
+                         (radius + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - dr) / SCALE_FACTOR,
-                         (-radius + pad->m_Offset.x) / SCALE_FACTOR,
+                         (-radius + pad->GetOffset().x) / SCALE_FACTOR,
-                         (-pad->m_Offset.y - dr) / SCALE_FACTOR,
+                         (-pad->GetOffset().y - dr) / SCALE_FACTOR,
-                         pad->m_Offset.x / SCALE_FACTOR,
+                         pad->GetOffset().x / SCALE_FACTOR,
-                         (-pad->m_Offset.y - dr) / SCALE_FACTOR );
+                         (-pad->GetOffset().y - dr) / SCALE_FACTOR );
             }
             break;
         }
 
         case PAD_TRAPEZOID:
             fprintf( aFile, " POLYGON %g\n",
-                     pad->m_Drill.x / SCALE_FACTOR );
+                     pad->GetDrillSize().x / SCALE_FACTOR );
 
             // XXX TO BE IMPLEMENTED! and I don't know if it could be actually imported by something
             break;
@@ -461,10 +461,10 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
 
         // Straight padstack
         fprintf( aFile, "PADSTACK PAD%d %g\n", i,
-                 pad->m_Drill.x / SCALE_FACTOR );
+                 pad->GetDrillSize().x / SCALE_FACTOR );
         for( int layer = 0; layer < 32; layer++ )
         {
-            if( pad->m_layerMask & (1 << layer) & master_layermask )
+            if( pad->GetLayerMask() & (1 << layer) & master_layermask )
             {
                 fprintf( aFile, "PAD P%d %s 0 0\n", i,
                         TO_UTF8( GenCADLayerName[layer] ) );
@@ -473,10 +473,10 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
 
         // Flipped padstack
         fprintf( aFile, "PADSTACK PAD%dF %g\n", i,
-                 pad->m_Drill.x / SCALE_FACTOR );
+                 pad->GetDrillSize().x / SCALE_FACTOR );
         for( int layer = 0; layer < 32; layer++ )
         {
-            if( pad->m_layerMask & (1 << layer) & master_layermask )
+            if( pad->GetLayerMask() & (1 << layer) & master_layermask )
             {
                 fprintf( aFile, "PAD P%d %s 0 0\n", i,
                         TO_UTF8( GenCADLayerNameFlipped[layer] ) );
@@ -516,11 +516,11 @@ static void CreateShapesSection( FILE* aFile, BOARD* aPcb )
              *  if the spec explicitly says it's not... */
             layer = "ALL";
 
-            if( ( pad->m_layerMask & ALL_CU_LAYERS ) == LAYER_BACK )
+            if( ( pad->GetLayerMask() & ALL_CU_LAYERS ) == LAYER_BACK )
             {
                 layer = ( module->flag ) ? "TOP" : "BOTTOM";
             }
-            else if( ( pad->m_layerMask & ALL_CU_LAYERS ) == LAYER_FRONT )
+            else if( ( pad->GetLayerMask() & ALL_CU_LAYERS ) == LAYER_FRONT )
             {
                 layer = ( module->flag ) ? "BOTTOM" : "TOP";
             }
@@ -530,7 +530,7 @@ static void CreateShapesSection( FILE* aFile, BOARD* aPcb )
             if( pinname.IsEmpty() )
                 pinname = wxT( "none" );
 
-            orient = pad->m_Orient - module->m_Orient;
+            orient = pad->GetOrientation() - module->GetOrientation();
             NORMALIZE_ANGLE_POS( orient );
 
             // Bottom side modules use the flipped padstack
@@ -538,8 +538,8 @@ static void CreateShapesSection( FILE* aFile, BOARD* aPcb )
                      "PIN %s PAD%dF %g %g %s %g %s\n" :
                      "PIN %s PAD%d %g %g %s %g %s\n",
                      TO_UTF8( pinname ), pad->GetSubRatsnest(),
-                     pad->m_Pos0.x / SCALE_FACTOR,
+                     pad->GetPos0().x / SCALE_FACTOR,
-                     -pad->m_Pos0.y / SCALE_FACTOR,
+                     -pad->GetPos0().y / SCALE_FACTOR,
                      layer, orient / 10.0, mirror );
         }
     }
@@ -562,7 +562,7 @@ static void CreateComponentsSection( FILE* aFile, BOARD* aPcb )
         TEXTE_MODULE* textmod;
         const char*   mirror;
         const char*   flip;
-        int           orient = module->m_Orient;
+        int           orient = module->GetOrientation();
 
         if( module->flag )
         {
@@ -597,14 +597,14 @@ static void CreateComponentsSection( FILE* aFile, BOARD* aPcb )
 
         for( int ii = 0; ii < 2; ii++ )
         {
-            int      orient = textmod->m_Orient;
+            int      orient = textmod->GetOrientation();
             wxString layer  = GenCADLayerName[(module->flag) ?
                                               SILKSCREEN_N_BACK : SILKSCREEN_N_FRONT];
 
             fprintf( aFile, "TEXT %g %g %g %g %s %s \"%s\"",
                     textmod->GetPos0().x / SCALE_FACTOR,
                     -textmod->GetPos0().y / SCALE_FACTOR,
-                    textmod->m_Size.x / SCALE_FACTOR,
+                    textmod->GetSize().x / SCALE_FACTOR,
                     orient / 10.0,
                     mirror,
                     TO_UTF8( layer ),
@@ -612,9 +612,9 @@ static void CreateComponentsSection( FILE* aFile, BOARD* aPcb )
 
             // Please note, the width is approx
             fprintf( aFile, " 0 0 %g %g\n",
-                     ( textmod->m_Size.x * textmod->m_Text.Len() )
+                     ( textmod->GetSize().x * textmod->m_Text.Len() )
                      / SCALE_FACTOR,
-                     textmod->m_Size.y / SCALE_FACTOR );
+                     textmod->GetSize().y / SCALE_FACTOR );
 
             textmod = module->m_Value; // Dirty trick for the second iteration
         }

pcbnew/export_vrml.cpp

@@ -94,10 +94,10 @@ public:
     }
 };
 
-/* I use this a lot... */
+// I use this a lot...
 static const double PI2 = M_PI / 2;
 
-/* Absolutely not optimized triangle bag :D */
+// Absolutely not optimized triangle bag :D
 struct VRMLPt
 {
     double x, y, z;
@@ -122,7 +122,7 @@ struct Triangle
 };
 typedef std::vector<Triangle> TriangleBag;
 
-/* A flat triangle fan */
+// A flat triangle fan
 struct FlatFan
 {
     FlatPt              c;
@@ -134,7 +134,7 @@ struct FlatFan
     void bag( int layer, bool close = true );
 };
 
-/* A flat quad ring */
+// A flat quad ring
 struct FlatRing
 {
     std::vector<FlatPt> inner;
@@ -152,7 +152,7 @@ struct FlatRing
     void bag( int layer, bool close = true );
 };
 
-/* A vertical quad loop */
+// A vertical quad loop
 struct VLoop
 {
     std::vector<FlatPt> pts;
@@ -165,12 +165,12 @@ struct VLoop
     void bag( TriangleBag& triangles, bool close = true );
 };
 
-/* The bags for all the layers */
+// The bags for all the layers
 static TriangleBag layer_triangles[LAYER_COUNT];
 static TriangleBag via_triangles[4];
 static double      layer_z[LAYER_COUNT];
 
-static void bag_flat_triangle( int layer, /*{{{*/
+static void bag_flat_triangle( int layer, //{{{
                                double x1, double y1,
                                double x2, double y2,
                                double x3, double y3 )
@@ -181,7 +181,7 @@ static void bag_flat_triangle( int layer, /*{{{*/
 }
 
 
-void FlatFan::bag( int layer, bool close ) /*{{{*/
+void FlatFan::bag( int layer, bool close ) //{{{
 {
     unsigned i;
 
@@ -193,7 +193,7 @@ void FlatFan::bag( int layer, bool close ) /*{{{*/
 }
 
 
-static void bag_flat_quad( int layer, /*{{{*/
+static void bag_flat_quad( int layer, //{{{
                            double x1, double y1,
                            double x2, double y2,
                            double x3, double y3,
@@ -204,7 +204,7 @@ static void bag_flat_quad( int layer, /*{{{*/
 }
 
 
-void FlatRing::bag( int layer, bool close ) /*{{{*/
+void FlatRing::bag( int layer, bool close ) //{{{
 {
     unsigned i;
 
@@ -224,7 +224,7 @@ void FlatRing::bag( int layer, bool close ) /*{{{*/
 }
 
 
-static void bag_vquad( TriangleBag& triangles, /*{{{*/
+static void bag_vquad( TriangleBag& triangles, //{{{
                        double x1, double y1, double x2, double y2,
                        double z1, double z2 )
 {
@@ -237,7 +237,7 @@ static void bag_vquad( TriangleBag& triangles, /*{{{*/
 }
 
 
-void VLoop::bag( TriangleBag& triangles, bool close ) /*{{{*/
+void VLoop::bag( TriangleBag& triangles, bool close ) //{{{
 {
     unsigned i;
 
@@ -253,7 +253,7 @@ void VLoop::bag( TriangleBag& triangles, bool close ) /*{{{*/
 }
 
 
-static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
+static void write_triangle_bag( FILE* output_file, int color_index, //{{{
                                 const TriangleBag& triangles )
 {
     /* A lot of nodes are not required, but blender sometimes chokes
@@ -270,7 +270,7 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
         "        Shape {\n",
         "          appearance Appearance {\n",
         "            material Material {\n",
-        0,                                          /* Material marker */
+        0,                                          // Material marker
         "              ambientIntensity 0.8\n",
         "              transparency 0.2\n",
         "              shininess 0.2\n",
@@ -280,11 +280,11 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
         "            solid true\n",
         "            coord Coordinate {\n",
         "              point [\n",
-        0,                                          /* Coordinates marker */
+        0,                                          // Coordinates marker
         "              ]\n",
         "            }\n",
         "            coordIndex [\n",
-        0,                                          /* Index marker */
+        0,                                          // Index marker
         "            ]\n",
         "          }\n",
         "        }\n",
@@ -292,7 +292,7 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
         "    }\n",
         "  ]\n",
         "}\n",
-        0 /* End marker */
+        0 // End marker
     };
     int marker_found = 0, lineno = 0;
 
@@ -305,7 +305,7 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
             marker_found++;
             switch( marker_found )
             {
-            case 1: /* Material marker */
+            case 1: // Material marker
                 fprintf( output_file,
                          "              diffuseColor %g %g %g\n",
                          (double) ColorRefs[color_index].m_Red / 255.0,
@@ -325,7 +325,7 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
 
             case 2:
             {
-                /* Coordinates marker */
+                // Coordinates marker
                 for( TriangleBag::const_iterator i = triangles.begin();
                      i != triangles.end();
                      i++ )
@@ -342,8 +342,8 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
 
             case 3:
             {
-                /* Index marker */
+                // Index marker
-                /* OK, that's sick ... */
+                // OK, that's sick ...
                 int j = 0;
                 for( TriangleBag::const_iterator i = triangles.begin();
                      i != triangles.end();
@@ -364,7 +364,7 @@ static void write_triangle_bag( FILE* output_file, int color_index, /*{{{*/
 }
 
 
-static void compute_layer_Zs( BOARD* pcb ) /*{{{*/
+static void compute_layer_Zs( BOARD* pcb ) //{{{
 {
     int    copper_layers = pcb->GetCopperLayerCount( );
 
@@ -372,18 +372,18 @@ static void compute_layer_Zs( BOARD* pcb ) /*{{{*/
     double board_thickness = pcb->GetDesignSettings().m_BoardThickness;
     double half_thickness  = board_thickness / 2;
 
-    /* Compute each layer's Z value, more or less like the 3d view */
+    // Compute each layer's Z value, more or less like the 3d view
     for( int i = 0; i <= LAYER_N_FRONT; i++ )
     {
         if( i < copper_layers )
             layer_z[i] = board_thickness * i / (copper_layers - 1) - half_thickness;
         else
-            layer_z[i] = half_thickness; /* The component layer... */
+            layer_z[i] = half_thickness; // The component layer...
     }
 
     /* To avoid rounding interference, we apply an epsilon to each
      * successive layer */
-    const double epsilon_z = 10; /* That's 1 mils, about 1/50 mm */
+    const double epsilon_z = 10; // That's 1 mils, about 1/50 mm
     layer_z[SOLDERPASTE_N_BACK]  = -half_thickness - epsilon_z * 4;
     layer_z[ADHESIVE_N_BACK]     = -half_thickness - epsilon_z * 3;
     layer_z[SILKSCREEN_N_BACK]   = -half_thickness - epsilon_z * 2;
@@ -400,7 +400,7 @@ static void compute_layer_Zs( BOARD* pcb ) /*{{{*/
 }
 
 
-static void export_vrml_line( int layer, double startx, double starty, /*{{{*/
+static void export_vrml_line( int layer, double startx, double starty, //{{{
                               double endx, double endy, double width, int divisions )
 {
     double  r     = width / 2;
@@ -408,28 +408,28 @@ static void export_vrml_line( int layer, double startx, double starty, /*{{{*/
     double  alpha;
     FlatFan fan;
 
-    /* Output the 'bone' as a triangle fan, this is the fan centre */
+    // Output the 'bone' as a triangle fan, this is the fan centre
     fan.c.x = (startx + endx) / 2;
     fan.c.y = (starty + endy) / 2;
 
-    /* The 'end' side cap */
+    // The 'end' side cap
     for( alpha = angle - PI2; alpha < angle + PI2; alpha += PI2 / divisions )
         fan.add( endx + r * cos( alpha ), endy + r * sin( alpha ) );
 
     alpha = angle + PI2;
     fan.add( endx + r * cos( alpha ), endy + r * sin( alpha ) );
-    /* The 'start' side cap */
+    // The 'start' side cap
     for( alpha = angle + PI2; alpha < angle + 3 * PI2; alpha += PI2 / divisions )
         fan.add( startx + r * cos( alpha ), starty + r * sin( alpha ) );
 
     alpha = angle + 3 * PI2;
     fan.add( startx + r * cos( alpha ), starty + r * sin( alpha ) );
-    /* Export the fan */
+    // Export the fan
     fan.bag( layer );
 }
 
 
-static void export_vrml_circle( int layer, double startx, double starty, /*{{{*/
+static void export_vrml_circle( int layer, double startx, double starty, //{{{
                                 double endx, double endy, double width, int divisions )
 {
     double   hole, radius;
@@ -448,11 +448,11 @@ static void export_vrml_circle( int layer, double startx, double starty, /*{{{*/
 }
 
 
-static void export_vrml_slot( TriangleBag& triangles, /*{{{*/
+static void export_vrml_slot( TriangleBag& triangles, //{{{
                               int top_layer, int bottom_layer, double xc, double yc,
                               double dx, double dy, int orient, int divisions )
 {
-    double capx, capy; /* Cap center */
+    double capx, capy; // Cap center
     VLoop  loop;
 
     loop.z_top    = layer_z[top_layer];
@@ -465,10 +465,10 @@ static void export_vrml_slot( TriangleBag& triangles, /*{{{*/
         angle += PI2;
     }
 
-    /* The exchange above means that cutter radius is alvays dy/2 */
+    // The exchange above means that cutter radius is alvays dy/2
     double r = dy / 2;
     double alpha;
-    /* The first side cap */
+    // The first side cap
     capx = xc + cos( angle ) * dx / 2;
     capy = yc + sin( angle ) * dx / 2;
 
@@ -478,7 +478,7 @@ static void export_vrml_slot( TriangleBag& triangles, /*{{{*/
     alpha = angle + PI2;
     loop.add( capx + r * cos( alpha ), capy + r * sin( alpha ) );
 
-    /* The other side cap */
+    // The other side cap
     capx = xc - cos( angle ) * dx / 2;
     capy = yc - sin( angle ) * dx / 2;
 
@@ -491,7 +491,7 @@ static void export_vrml_slot( TriangleBag& triangles, /*{{{*/
 }
 
 
-static void export_vrml_hole( TriangleBag& triangles, /*{{{*/
+static void export_vrml_hole( TriangleBag& triangles, //{{{
                               int top_layer, int bottom_layer, double xc, double yc, double hole,
                               int divisions )
 {
@@ -507,7 +507,7 @@ static void export_vrml_hole( TriangleBag& triangles, /*{{{*/
 }
 
 
-static void export_vrml_varc( TriangleBag& triangles, /*{{{*/
+static void export_vrml_varc( TriangleBag& triangles, //{{{
                               int top_layer, int bottom_layer, double startx, double starty,
                               double endx, double endy, int divisions )
 {
@@ -527,11 +527,11 @@ static void export_vrml_varc( TriangleBag& triangles, /*{{{*/
 }
 
 
-static void export_vrml_oval_pad( int layer, /*{{{*/
+static void export_vrml_oval_pad( int layer, //{{{
                                   double xc, double yc,
                                   double dx, double dy, int orient, int divisions )
 {
-    double  capx, capy; /* Cap center */
+    double  capx, capy; // Cap center
     FlatFan fan;
 
     fan.c.x = xc;
@@ -544,11 +544,11 @@ static void export_vrml_oval_pad( int layer, /*{{{*/
         angle += PI2;
     }
 
-    /* The exchange above means that cutter radius is alvays dy/2 */
+    // The exchange above means that cutter radius is alvays dy/2
     double r = dy / 2;
     double alpha;
 
-    /* The first side cap */
+    // The first side cap
     capx = xc + cos( angle ) * dx / 2;
     capy = yc + sin( angle ) * dx / 2;
 
@@ -557,7 +557,7 @@ static void export_vrml_oval_pad( int layer, /*{{{*/
 
     alpha = angle + PI2;
     fan.add( capx + r * cos( alpha ), capy + r * sin( alpha ) );
-    /* The other side cap */
+    // The other side cap
     capx = xc - cos( angle ) * dx / 2;
     capy = yc - sin( angle ) * dx / 2;
 
@@ -570,7 +570,7 @@ static void export_vrml_oval_pad( int layer, /*{{{*/
 }
 
 
-static void export_vrml_arc( int layer, double startx, double starty, /*{{{*/
+static void export_vrml_arc( int layer, double startx, double starty, //{{{
                              double endx, double endy, double width, int divisions )
 {
     FlatRing ring;
@@ -590,7 +590,7 @@ static void export_vrml_arc( int layer, double startx, double starty, /*{{{*/
 }
 
 
-static void export_vrml_drawsegment( DRAWSEGMENT* drawseg ) /*{{{*/
+static void export_vrml_drawsegment( DRAWSEGMENT* drawseg ) //{{{
 {
     int    layer = drawseg->GetLayer();
     double w     = drawseg->GetWidth();
@@ -599,19 +599,19 @@ static void export_vrml_drawsegment( DRAWSEGMENT* drawseg ) /*{{{*/
     double xf    = drawseg->GetEnd().x;
     double yf    = drawseg->GetEnd().y;
 
-    /* Items on the edge layer are high, not thick */
+    // Items on the edge layer are high, not thick
     if( layer == EDGE_N )
     {
         switch( drawseg->GetShape() )
         {
-        /* There is a special 'varc' primitive for this */
+        // There is a special 'varc' primitive for this
         case S_ARC:
             export_vrml_varc( layer_triangles[layer],
                               FIRST_COPPER_LAYER, LAST_COPPER_LAYER,
                               x, y, xf, yf, 4 );
             break;
 
-        /* Circles on edge are usually important holes */
+        // Circles on edge are usually important holes
         case S_CIRCLE:
             export_vrml_hole( layer_triangles[layer],
                               FIRST_COPPER_LAYER, LAST_COPPER_LAYER, x, y,
@@ -620,7 +620,7 @@ static void export_vrml_drawsegment( DRAWSEGMENT* drawseg ) /*{{{*/
 
         default:
         {
-            /* Simply a quad */
+            // Simply a quad
             double z_top    = layer_z[FIRST_COPPER_LAYER];
             double z_bottom = layer_z[LAST_COPPER_LAYER];
             bag_vquad( layer_triangles[layer], x, y, xf, yf, z_top, z_bottom );
@@ -661,7 +661,7 @@ static void vrml_text_callback( int x0, int y0, int xf, int yf )
 
 static void export_vrml_pcbtext( TEXTE_PCB* text )
 {
-    /* Coupling by globals! Ewwww... */
+    // Coupling by globals! Ewwww...
     s_text_layer = text->GetLayer();
     s_text_width = text->m_Thickness;
 
@@ -677,12 +677,12 @@ static void export_vrml_pcbtext( TEXTE_PCB* text )
 
         offset.y = text->GetInterline();
 
-        RotatePoint( &offset, text->m_Orient );
+        RotatePoint( &offset, text->GetOrientation() );
         for( unsigned i = 0; i<list->Count(); i++ )
         {
             wxString txt = list->Item( i );
             DrawGraphicText( NULL, NULL, pos, (EDA_Colors) 0,
-                             txt, text->m_Orient, size,
+                             txt, text->GetOrientation(), size,
                              text->m_HJustify, text->m_VJustify,
                              text->m_Thickness, text->m_Italic,
                              true,
@@ -695,7 +695,7 @@ static void export_vrml_pcbtext( TEXTE_PCB* text )
     else
     {
         DrawGraphicText( NULL, NULL, text->m_Pos, (EDA_Colors) 0,
-                         text->m_Text, text->m_Orient, size,
+                         text->m_Text, text->GetOrientation(), size,
                          text->m_HJustify, text->m_VJustify,
                          text->m_Thickness, text->m_Italic,
                          true,
@@ -704,9 +704,9 @@ static void export_vrml_pcbtext( TEXTE_PCB* text )
 }
 
 
-static void export_vrml_drawings( BOARD* pcb ) /*{{{*/
+static void export_vrml_drawings( BOARD* pcb ) //{{{
 {
-    /* draw graphic items */
+    // draw graphic items
     for( EDA_ITEM* drawing = pcb->m_Drawings;  drawing != 0;  drawing = drawing->Next() )
     {
         switch( drawing->Type() )
@@ -726,14 +726,14 @@ static void export_vrml_drawings( BOARD* pcb ) /*{{{*/
 }
 
 
-static void export_round_padstack( BOARD* pcb, double x, double y, double r, /*{{{*/
+static void export_round_padstack( BOARD* pcb, double x, double y, double r, //{{{
                                    int bottom_layer, int top_layer, int divisions )
 {
     int copper_layers = pcb->GetCopperLayerCount( );
 
     for( int layer = bottom_layer; layer < copper_layers; layer++ )
     {
-        /* The last layer is always the component one, unless it's single face */
+        // The last layer is always the component one, unless it's single face
         if( (layer > FIRST_COPPER_LAYER) && (layer == copper_layers - 1) )
             layer = LAST_COPPER_LAYER;
 
@@ -743,7 +743,7 @@ static void export_round_padstack( BOARD* pcb, double x, double y, double r, /*{
 }
 
 
-static void export_vrml_via( BOARD* pcb, SEGVIA* via ) /*{{{*/
+static void export_vrml_via( BOARD* pcb, SEGVIA* via ) //{{{
 {
     double x, y, r, hole;
     int    top_layer, bottom_layer;
@@ -754,15 +754,15 @@ static void export_vrml_via( BOARD* pcb, SEGVIA* via ) /*{{{*/
     y    = via->m_Start.y;
     via->ReturnLayerPair( &top_layer, &bottom_layer );
 
-    /* Export the via padstack */
+    // Export the via padstack
     export_round_padstack( pcb, x, y, r, bottom_layer, top_layer, 8 );
 
-    /* Drill a rough hole */
+    // Drill a rough hole
     export_vrml_hole( via_triangles[via->m_Shape], top_layer, bottom_layer, x, y, hole, 8 );
 }
 
 
-static void export_vrml_tracks( BOARD* pcb ) /*{{{*/
+static void export_vrml_tracks( BOARD* pcb ) //{{{
 {
     for( TRACK* track = pcb->m_Track; track != NULL; track = track->Next() )
     {
@@ -832,7 +832,7 @@ static void export_vrml_zones( BOARD* pcb )
 }
 */
 
-static void export_vrml_text_module( TEXTE_MODULE* module ) /*{{{*/
+static void export_vrml_text_module( TEXTE_MODULE* module ) //{{{
 {
     if( module->IsVisible() )
     {
@@ -853,7 +853,7 @@ static void export_vrml_text_module( TEXTE_MODULE* module ) /*{{{*/
 }
 
 
-static void export_vrml_edge_module( EDGE_MODULE* module ) /*{{{*/
+static void export_vrml_edge_module( EDGE_MODULE* module ) //{{{
 {
     int    layer = module->GetLayer();
     double x     = module->GetStart().x;
@@ -879,23 +879,23 @@ static void export_vrml_edge_module( EDGE_MODULE* module ) /*{{{*/
 }
 
 
-static void export_vrml_pad( BOARD* pcb, D_PAD* pad ) /*{{{*/
+static void export_vrml_pad( BOARD* pcb, D_PAD* aPad ) //{{{
 {
-    double hole_drill_w = (double) pad->m_Drill.x / 2;
+    double hole_drill_w = (double) aPad->GetDrillSize().x / 2;
-    double hole_drill_h = (double) pad->m_Drill.y / 2;
+    double hole_drill_h = (double) aPad->GetDrillSize().y / 2;
     double hole_drill   = MIN( hole_drill_w, hole_drill_h );
-    double hole_x = pad->m_Pos.x;
+    double hole_x = aPad->GetPosition().x;
-    double hole_y = pad->m_Pos.y;
+    double hole_y = aPad->GetPosition().y;
 
-    /* Export the hole on the edge layer */
+    // Export the hole on the edge layer
     if( hole_drill > 0 )
     {
-        if( pad->m_DrillShape == PAD_OVAL )
+        if( aPad->GetDrillShape() == PAD_OVAL )
         {
-            /* Oblong hole (slot) */
+            // Oblong hole (slot)
             export_vrml_slot( layer_triangles[EDGE_N],
                               FIRST_COPPER_LAYER, LAST_COPPER_LAYER,
-                              hole_x, hole_y, hole_drill_w, hole_drill_h, pad->m_Orient, 6 );
+                              hole_x, hole_y, hole_drill_w, hole_drill_h, aPad->GetOrientation(), 6 );
         }
         else
         {
@@ -906,29 +906,32 @@ static void export_vrml_pad( BOARD* pcb, D_PAD* pad ) /*{{{*/
         }
     }
 
-    /* The pad proper, on the selected layers */
+    // The pad proper, on the selected layers
-    unsigned long layer_mask    = pad->m_layerMask;
+    int         layer_mask    = aPad->GetLayerMask();
-    int           copper_layers = pcb->GetCopperLayerCount( );
+    int         copper_layers = pcb->GetCopperLayerCount( );
-    /* The (maybe offseted) pad position */
+
-    wxPoint       pad_pos   = pad->ReturnShapePos();
+    // The (maybe offseted) pad position
-    double        pad_x     = pad_pos.x;
+    wxPoint     pad_pos   = aPad->ReturnShapePos();
-    double        pad_y     = pad_pos.y;
+    double      pad_x     = pad_pos.x;
-    wxSize        pad_delta = pad->m_DeltaSize;
+    double      pad_y     = pad_pos.y;
-    double        pad_dx    = pad_delta.x / 2;
+    wxSize      pad_delta = aPad->GetDelta();
-    double        pad_dy    = pad_delta.y / 2;
+
-    double        pad_w     = pad->m_Size.x / 2;
+    double      pad_dx    = pad_delta.x / 2;
-    double        pad_h     = pad->m_Size.y / 2;
+    double      pad_dy    = pad_delta.y / 2;
+
+    double      pad_w     = aPad->GetSize().x / 2;
+    double      pad_h     = aPad->GetSize().y / 2;
 
     for( int layer = FIRST_COPPER_LAYER; layer < copper_layers; layer++ )
     {
-        /* The last layer is always the component one, unless it's single face */
+        // The last layer is always the component one, unless it's single face
         if( (layer > FIRST_COPPER_LAYER) && (layer == copper_layers - 1) )
             layer = LAST_COPPER_LAYER;
 
         if( layer_mask & (1 << layer) )
         {
-            /* OK, the pad is on this layer, export it */
+            // OK, the pad is on this layer, export it
-            switch( pad->m_PadShape & 0x7F ) /* What is the masking for? */
+            switch( aPad->GetShape() )
             {
             case PAD_CIRCLE:
                 export_vrml_circle( layer, pad_x, pad_y,
@@ -938,44 +941,47 @@ static void export_vrml_pad( BOARD* pcb, D_PAD* pad ) /*{{{*/
             case PAD_OVAL:
                 export_vrml_oval_pad( layer,
                                       pad_x, pad_y,
-                                      pad_w * 2, pad_h * 2, pad->m_Orient, 4 );
+                                      pad_w * 2, pad_h * 2, aPad->GetOrientation(), 4 );
                 break;
 
             case PAD_RECT:
-                /* Just to be sure :D */
+                // Just to be sure :D
                 pad_dx = 0;
                 pad_dy = 0;
 
             case PAD_TRAPEZOID:
-            {
-                int coord[8] =
                 {
-                    wxRound(-pad_w - pad_dy), wxRound(+pad_h + pad_dx),
+                    int coord[8] =
-                    wxRound(-pad_w + pad_dy), wxRound(-pad_h - pad_dx),
+                    {
-                    wxRound(+pad_w - pad_dy), wxRound(+pad_h - pad_dx),
+                        wxRound(-pad_w - pad_dy), wxRound(+pad_h + pad_dx),
-                    wxRound(+pad_w + pad_dy), wxRound(-pad_h + pad_dx),
+                        wxRound(-pad_w + pad_dy), wxRound(-pad_h - pad_dx),
-                };
+                        wxRound(+pad_w - pad_dy), wxRound(+pad_h - pad_dx),
+                        wxRound(+pad_w + pad_dy), wxRound(-pad_h + pad_dx),
+                    };
 
-                for( int i = 0; i < 4; i++ )
+                    for( int i = 0; i < 4; i++ )
-                {
+                    {
-                    RotatePoint( &coord[i * 2], &coord[i * 2 + 1], pad->m_Orient );
+                        RotatePoint( &coord[i * 2], &coord[i * 2 + 1], aPad->GetOrientation() );
-                    coord[i * 2]     += wxRound( pad_x );
+                        coord[i * 2]     += wxRound( pad_x );
-                    coord[i * 2 + 1] += wxRound( pad_y );
+                        coord[i * 2 + 1] += wxRound( pad_y );
+                    }
+
+                    bag_flat_quad( layer, coord[0], coord[1],
+                                   coord[2], coord[3],
+                                   coord[4], coord[5],
+                                   coord[6], coord[7] );
                 }
+                break;
 
-                bag_flat_quad( layer, coord[0], coord[1],
+            default:
-                               coord[2], coord[3],
+                ;
-                               coord[4], coord[5],
-                               coord[6], coord[7] );
-            }
-            break;
             }
         }
     }
 }
 
 
-/* From axis/rot to quaternion */
+// From axis/rot to quaternion
 static void build_quat( double x, double y, double z, double a, double q[4] )
 {
     double sina = sin( a / 2 );
@@ -987,7 +993,7 @@ static void build_quat( double x, double y, double z, double a, double q[4] )
 }
 
 
-/* From quaternion to axis/rot */
+// From quaternion to axis/rot
 static void from_quat( double q[4], double rot[4] )
 {
     rot[3] = acos( q[3] ) * 2;
@@ -999,7 +1005,7 @@ static void from_quat( double q[4], double rot[4] )
 }
 
 
-/* Quaternion composition */
+// Quaternion composition
 static void compose_quat( double q1[4], double q2[4], double qr[4] )
 {
     double tmp[4];
@@ -1017,11 +1023,11 @@ static void export_vrml_module( BOARD* aPcb, MODULE* aModule,
                                 FILE* aOutputFile, double aScalingFactor,
                                 bool aExport3DFiles, const wxString & a3D_Subdir )
 {
-    /* Reference and value */
+    // Reference and value
     export_vrml_text_module( aModule->m_Reference );
     export_vrml_text_module( aModule->m_Value );
 
-    /* Export module edges */
+    // Export module edges
     for( EDA_ITEM* item = aModule->m_Drawings;  item != NULL;  item = item->Next() )
     {
         switch( item->Type() )
@@ -1039,13 +1045,13 @@ static void export_vrml_module( BOARD* aPcb, MODULE* aModule,
         }
     }
 
-    /* Export pads */
+    // Export pads
-    for( D_PAD* pad = aModule->m_Pads; pad != 0; pad = pad->Next() )
+    for( D_PAD* pad = aModule->m_Pads;  pad; pad = pad->Next() )
         export_vrml_pad( aPcb, pad );
 
     bool isFlipped = aModule->GetLayer() == LAYER_N_BACK;
 
-    /* Export the object VRML model(s) */
+    // Export the object VRML model(s)
     for( S3D_MASTER* vrmlm = aModule->m_3D_Drawings; vrmlm != 0; vrmlm = vrmlm->Next() )
     {
         wxString fname = vrmlm->m_Shape3DName;
@@ -1090,21 +1096,21 @@ static void export_vrml_module( BOARD* aPcb, MODULE* aModule,
             NEGATE(rotz);
         }
 
-        /* Do some quaternion munching */
+        // Do some quaternion munching
         double q1[4], q2[4], rot[4];
         build_quat( 1, 0, 0, rotx / 180.0 * M_PI, q1 );
         build_quat( 0, 1, 0, roty / 180.0 * M_PI, q2 );
         compose_quat( q1, q2, q1 );
         build_quat( 0, 0, 1, rotz / 180.0 * M_PI, q2 );
         compose_quat( q1, q2, q1 );
-        // Note here aModule->m_Orient is in 0.1 degrees,
+        // Note here aModule->GetOrientation() is in 0.1 degrees,
-        // so module rotation is aModule->m_Orient / 1800.0
+        // so module rotation is aModule->GetOrientation() / 1800.0
-        build_quat( 0, 0, 1, aModule->m_Orient / 1800.0 * M_PI, q2 );
+        build_quat( 0, 0, 1, aModule->GetOrientation() / 1800.0 * M_PI, q2 );
         compose_quat( q1, q2, q1 );
         from_quat( q1, rot );
 
         fprintf( aOutputFile, "Transform {\n" );
-        /* A null rotation would fail the acos! */
+        // A null rotation would fail the acos!
         if( rot[3] != 0.0 )
         {
             fprintf( aOutputFile, "  rotation %g %g %g %g\n", rot[0], rot[1], rot[2], rot[3] );
@@ -1115,7 +1121,7 @@ static void export_vrml_module( BOARD* aPcb, MODULE* aModule,
                  vrmlm->m_MatScale.y * aScalingFactor,
                  vrmlm->m_MatScale.z * aScalingFactor );
 
-        /* adjust 3D shape offset position (offset is given inch) */
+        // adjust 3D shape offset position (offset is given inch)
         #define UNITS_3D_TO_PCB_UNITS PCB_INTERNAL_UNIT
         int offsetx = wxRound( vrmlm->m_MatPosition.x * UNITS_3D_TO_PCB_UNITS );
         int offsety = wxRound( vrmlm->m_MatPosition.y * UNITS_3D_TO_PCB_UNITS );
@@ -1126,7 +1132,7 @@ static void export_vrml_module( BOARD* aPcb, MODULE* aModule,
         else    // In normal mode, Y axis is reversed in Pcbnew.
             NEGATE(offsety);
 
-        RotatePoint(&offsetx, &offsety, aModule->m_Orient);
+        RotatePoint(&offsetx, &offsety, aModule->GetOrientation());
 
         fprintf( aOutputFile, "  translation %g %g %g\n",
                  (double) (offsetx + aModule->m_Pos.x),
@@ -1220,7 +1226,7 @@ bool PCB_EDIT_FRAME::ExportVRML_File( const wxString & aFullFileName,
     // Switch the locale to standard C (needed to print floating point numbers like 1.3)
     SetLocaleTo_C_standard();
 
-    /* Begin with the usual VRML boilerplate */
+    // Begin with the usual VRML boilerplate
     wxString name = aFullFileName;
 
     name.Replace(wxT("\\"), wxT("/" ) );
@@ -1266,20 +1272,20 @@ bool PCB_EDIT_FRAME::ExportVRML_File( const wxString & aFullFileName,
      */
 
     double wrml_3D_models_scaling_factor = 0.1 / board_scaling_factor;
-    /* Preliminary computation: the z value for each layer */
+    // Preliminary computation: the z value for each layer
     compute_layer_Zs( pcb );
 
-    /* Drawing and text on the board, and edges which are special */
+    // Drawing and text on the board, and edges which are special
     export_vrml_drawings( pcb );
 
-    /* Export vias and trackage */
+    // Export vias and trackage
     export_vrml_tracks( pcb );
 
-    /* Export zone fills */
+    // Export zone fills
 /* TODO    export_vrml_zones(pcb);
 */
 
-    /* Export footprints */
+    // Export footprints
     for( MODULE* module = pcb->m_Modules; module != 0; module = module->Next() )
         export_vrml_module( pcb, module, output_file,
                             wrml_3D_models_scaling_factor,
@@ -1292,13 +1298,13 @@ bool PCB_EDIT_FRAME::ExportVRML_File( const wxString & aFullFileName,
                                       layer_triangles[layer],
                                       pcb->GetLayerColor(layer) );
 
-    /* Same thing for the via layers */
+    // Same thing for the via layers
     for( int i = 0; i < 4; i++ )
         write_and_empty_triangle_bag( output_file,
                                       via_triangles[i],
                                       pcb->GetVisibleElementColor( VIAS_VISIBLE + i ) );
 
-    /* Close the outer 'transform' node */
+    // Close the outer 'transform' node
     fputs( "]\n}\n", output_file );
 
     // End of work

pcbnew/gen_holes_and_tools_lists_for_drill.cpp

@@ -18,7 +18,7 @@
 #include <gendrill.h>
 
 
-/* Local Functions */
+// Local Functions
 
 /* Compare function used for sorting holes  by increasing diameter value
  * and X value
@@ -109,39 +109,35 @@ void Build_Holes_List( BOARD* aPcb,
         }
     }
 
-    /* build hole list for pads (assumed always through holes) */
+    // build hole list for pads (assumed always through holes)
     if( !aExcludeThroughHoles || aGenerateNPTH_list )
     {
-        MODULE* Module = aPcb->m_Modules;
+        for( MODULE* module = aPcb->m_Modules;  module;  module->Next() )
-
-        for( ; Module != NULL; Module = Module->Next() )
         {
-            /* Read and analyse pads */
+            // Read and analyse pads
-            D_PAD* pad = Module->m_Pads;
+            for( D_PAD* pad = module->m_Pads;  pad;  pad = pad->Next() )
-
-            for( ; pad != NULL; pad = pad->Next() )
             {
-                if( ! aGenerateNPTH_list && pad->m_Attribut == PAD_HOLE_NOT_PLATED )
+                if( ! aGenerateNPTH_list && pad->GetAttribute() == PAD_HOLE_NOT_PLATED )
                     continue;
 
-                if( aGenerateNPTH_list && pad->m_Attribut != PAD_HOLE_NOT_PLATED )
+                if( aGenerateNPTH_list && pad->GetAttribute() != PAD_HOLE_NOT_PLATED )
                     continue;
 
-                if( pad->m_Drill.x == 0 )
+                if( pad->GetDrillSize().x == 0 )
                     continue;
 
-                new_hole.m_Hole_NotPlated = (pad->m_Attribut == PAD_HOLE_NOT_PLATED);
+                new_hole.m_Hole_NotPlated = (pad->GetAttribute() == PAD_HOLE_NOT_PLATED);
                 new_hole.m_Tool_Reference = -1;         // Flag is: Not initialized
-                new_hole.m_Hole_Orient    = pad->m_Orient;
+                new_hole.m_Hole_Orient    = pad->GetOrientation();
                 new_hole.m_Hole_Shape    = 0;           // hole shape: round
-                new_hole.m_Hole_Diameter = min( pad->m_Drill.x, pad->m_Drill.y );
+                new_hole.m_Hole_Diameter = min( pad->GetDrillSize().x, pad->GetDrillSize().y );
                 new_hole.m_Hole_Size.x    = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
 
-                if( pad->m_DrillShape != PAD_CIRCLE )
+                if( pad->GetDrillShape() != PAD_CIRCLE )
                     new_hole.m_Hole_Shape = 1; // oval flag set
 
-                new_hole.m_Hole_Size = pad->m_Drill;
+                new_hole.m_Hole_Size = pad->GetDrillSize();
-                new_hole.m_Hole_Pos = pad->m_Pos;               // hole position
+                new_hole.m_Hole_Pos = pad->GetPosition();               // hole position
                 new_hole.m_Hole_Bottom_Layer = LAYER_N_BACK;
                 new_hole.m_Hole_Top_Layer    = LAYER_N_FRONT;// pad holes are through holes
                 aHoleListBuffer.push_back( new_hole );

pcbnew/gen_modules_placefile.cpp

@@ -312,7 +312,7 @@ static bool HasNonSMDPins( MODULE* aModule )
 
     for( pad = aModule->m_Pads;  pad;  pad = pad->Next() )
     {
-        if( pad->m_Attribut != PAD_SMD )
+        if( pad->GetAttribute() != PAD_SMD )
             return true;
     }
 
@@ -630,37 +630,42 @@ bool PCB_EDIT_FRAME::DoGenFootprintsReport( const wxString& aFullFilename, bool
         {
             fprintf( rptfile, "$PAD \"%s\"\n", TO_UTF8( pad->GetPadName() ) );
             sprintf( line, "position %9.6f %9.6f\n",
-                     pad->m_Pos0.x * conv_unit,
+                     pad->GetPos0().x * conv_unit,
-                     pad->m_Pos0.y * conv_unit );
+                     pad->GetPos0().y * conv_unit );
             fputs( line, rptfile );
 
             sprintf( line, "size %9.6f %9.6f\n",
-                     pad->m_Size.x * conv_unit,
+                     pad->GetSize().x * conv_unit,
-                     pad->m_Size.y * conv_unit );
+                     pad->GetSize().y * conv_unit );
             fputs( line, rptfile );
-            sprintf( line, "drill %9.6f\n", pad->m_Drill.x * conv_unit );
+
+            sprintf( line, "drill %9.6f\n", pad->GetDrillSize().x * conv_unit );
             fputs( line, rptfile );
+
             sprintf( line, "shape_offset %9.6f %9.6f\n",
-                     pad->m_Offset.x * conv_unit,
+                     pad->GetOffset().x * conv_unit,
-                     pad->m_Offset.y * conv_unit );
+                     pad->GetOffset().y * conv_unit );
             fputs( line, rptfile );
 
             sprintf( line, "orientation  %.2f\n",
-                     double(pad->m_Orient - Module->m_Orient) / 10 );
+                     double(pad->GetOrientation() - Module->GetOrientation()) / 10 );
             fputs( line, rptfile );
-            const char* shape_name[6] = { "??? ", "Circ", "Rect", "Oval", "trap", "spec" };
+
-            sprintf( line, "Shape  %s\n", shape_name[pad->m_PadShape] );
+            static const char* shape_name[6] = { "??? ", "Circ", "Rect", "Oval", "trap", "spec" };
+
+            sprintf( line, "Shape  %s\n", shape_name[pad->GetShape()] );
             fputs( line, rptfile );
 
             int layer = 0;
 
-            if( pad->m_layerMask & LAYER_BACK )
+            if( pad->GetLayerMask() & LAYER_BACK )
                 layer = 1;
 
-            if( pad->m_layerMask & LAYER_FRONT )
+            if( pad->GetLayerMask() & LAYER_FRONT )
                 layer |= 2;
 
-            const char* layer_name[4] = { "??? ", "copper", "component", "all" };
+            static const char* layer_name[4] = { "??? ", "copper", "component", "all" };
+
             sprintf( line, "Layer  %s\n", layer_name[layer] );
             fputs( line, rptfile );
             fprintf( rptfile, "$EndPAD\n" );

pcbnew/globaleditpad.cpp

@@ -33,8 +33,7 @@ public:
     static bool m_Pad_Orient_Filter;
 
 public:
-    DIALOG_GLOBAL_PADS_EDITION( PCB_BASE_FRAME* parent, D_PAD* Pad );
+    DIALOG_GLOBAL_PADS_EDITION( PCB_BASE_FRAME* aParent, D_PAD* aPad );
-    ~DIALOG_GLOBAL_PADS_EDITION() { }
 
 private:
     void InstallPadEditor( wxCommandEvent& event );
@@ -43,11 +42,11 @@ private:
 };
 
 
-DIALOG_GLOBAL_PADS_EDITION::DIALOG_GLOBAL_PADS_EDITION( PCB_BASE_FRAME* parent, D_PAD* Pad ) :
+DIALOG_GLOBAL_PADS_EDITION::DIALOG_GLOBAL_PADS_EDITION( PCB_BASE_FRAME* aParent, D_PAD* aPad ) :
-    DIALOG_GLOBAL_PADS_EDITION_BASE( parent )
+    DIALOG_GLOBAL_PADS_EDITION_BASE( aParent )
 {
-    m_Parent     = parent;
+    m_Parent     = aParent;
-    m_CurrentPad = Pad;
+    m_CurrentPad = aPad;
 
     // Pad filter selection.
     m_Pad_Shape_Filter_CB->SetValue( m_Pad_Shape_Filter );
@@ -61,7 +60,7 @@ DIALOG_GLOBAL_PADS_EDITION::DIALOG_GLOBAL_PADS_EDITION( PCB_BASE_FRAME* parent,
 }
 
 
-/* Class DIALOG_GLOBAL_PADS_EDITION static variables */
+// Class DIALOG_GLOBAL_PADS_EDITION static variables
 bool DIALOG_GLOBAL_PADS_EDITION::m_Pad_Shape_Filter  = true;
 bool DIALOG_GLOBAL_PADS_EDITION::m_Pad_Layer_Filter  = true;
 bool DIALOG_GLOBAL_PADS_EDITION::m_Pad_Orient_Filter = true;
@@ -119,22 +118,23 @@ void PCB_EDIT_FRAME::DlgGlobalChange_PadSettings( D_PAD* aPad, bool aRedraw )
     int     diag;
 
     if( aPad == NULL )
-        aPad = &g_Pad_Master;
+        aPad = &GetDesignSettings().m_Pad_Master;
 
-    MODULE* Module = (MODULE*) aPad->GetParent();
+    MODULE* module = aPad->GetParent();
 
-    if( Module == NULL )
+    if( module == NULL )
     {
         DisplayError( this, wxT( "Global_Import_Pad_Settings() Error: NULL module" ) );
         return;
     }
 
-    Module->DisplayInfo( this );
+    module->DisplayInfo( this );
 
-    DIALOG_GLOBAL_PADS_EDITION* dlg = new DIALOG_GLOBAL_PADS_EDITION( this, aPad );
+    {
+        DIALOG_GLOBAL_PADS_EDITION dlg( this, aPad );
 
-    diag = dlg->ShowModal();
+        diag = dlg.ShowModal();
-    dlg->Destroy();
+    }
 
     if( diag == -1 )
         return;
@@ -162,23 +162,25 @@ void FOOTPRINT_EDIT_FRAME::DlgGlobalChange_PadSettings( D_PAD* aPad )
     int     diag;
 
     if( aPad == NULL )
-        aPad = &g_Pad_Master;
+        aPad = &GetDesignSettings().m_Pad_Master;
 
-    MODULE* Module = (MODULE*) aPad->GetParent();
+    MODULE* module = aPad->GetParent();
 
-    if( Module == NULL )
+    if( module == NULL )
     {
         DisplayError( this, wxT( "Global_Import_Pad_Settings() Error: NULL module" ) );
         return;
     }
 
-    Module->DisplayInfo( this );
+    module->DisplayInfo( this );
 
-    DIALOG_GLOBAL_PADS_EDITION* dlg = new DIALOG_GLOBAL_PADS_EDITION( this, aPad );
+    {
-    dlg->m_buttonIdModules->Enable( false );
+        DIALOG_GLOBAL_PADS_EDITION dlg( this, aPad );
 
-    diag = dlg->ShowModal();
+        dlg.m_buttonIdModules->Enable( false );
-    dlg->Destroy();
+
+        diag = dlg.ShowModal();
+    }
 
     if( diag == -1 )
         return;
@@ -187,7 +189,7 @@ void FOOTPRINT_EDIT_FRAME::DlgGlobalChange_PadSettings( D_PAD* aPad )
     if( diag == 1 )
         edit_Same_Modules = true;
 
-    GlobalChange_PadSettings( aPad,edit_Same_Modules,
+    GlobalChange_PadSettings( aPad, edit_Same_Modules,
                               DIALOG_GLOBAL_PADS_EDITION::m_Pad_Shape_Filter,
                               DIALOG_GLOBAL_PADS_EDITION::m_Pad_Orient_Filter,
                               DIALOG_GLOBAL_PADS_EDITION::m_Pad_Layer_Filter,
@@ -215,48 +217,47 @@ void PCB_BASE_FRAME::GlobalChange_PadSettings( D_PAD* aPad,
                                                bool aRedraw, bool aSaveForUndo )
 {
     if( aPad == NULL )
-        aPad = &g_Pad_Master;
+        aPad = &GetDesignSettings().m_Pad_Master;
 
-    MODULE* Module = (MODULE*) aPad->GetParent();
+    MODULE* module = aPad->GetParent();
 
-    if( Module == NULL )
+    if( module == NULL )
     {
         DisplayError( this, wxT( "Global_Import_Pad_Settings() Error: NULL module" ) );
         return;
     }
 
-    /* Search and copy the name of library reference. */
+    // Search and copy the name of library reference.
-    MODULE* Module_Ref = Module;
+    MODULE* Module_Ref = module;
-    int pad_orient = aPad->m_Orient - Module_Ref->m_Orient;
+    int pad_orient = aPad->GetOrientation() - Module_Ref->GetOrientation();
 
     // Prepare an undo list:
     if( aSaveForUndo )
     {
         PICKED_ITEMS_LIST itemsList;
-        Module = (MODULE*) m_Pcb->m_Modules;
+
-        for( ; Module != NULL; Module = Module->Next() )
+        for( module = m_Pcb->m_Modules;  module;  module = module->Next() )
         {
-            if( !aSameFootprints && (Module != Module_Ref) )
+            if( !aSameFootprints && (module != Module_Ref) )
                 continue;
 
-            if( Module->m_LibRef != Module_Ref->m_LibRef )
+            if( module->m_LibRef != Module_Ref->m_LibRef )
                 continue;
 
             bool   saveMe = false;
-            D_PAD* pt_pad = (D_PAD*) Module->m_Pads;
 
-            for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
+            for( D_PAD* pad = module->m_Pads;  pad;  pad = pad->Next() )
             {
-                /* Filters changes prohibited. */
+                // Filters changes prohibited.
-                if( aPadShapeFilter && ( pt_pad->m_PadShape != aPad->m_PadShape ) )
+                if( aPadShapeFilter && ( pad->GetShape() != aPad->GetShape() ) )
                     continue;
 
-                int currpad_orient = pt_pad->m_Orient - Module->m_Orient;
+                int currpad_orient = pad->GetOrientation() - module->GetOrientation();
+
                 if( aPadOrientFilter && ( currpad_orient != pad_orient ) )
                     continue;
 
-                if( aPadLayerFilter
+                if( aPadLayerFilter  &&  pad->GetLayerMask() != aPad->GetLayerMask() )
-                   && ( pt_pad->m_layerMask != aPad->m_layerMask ) )
                     continue;
 
                 saveMe = true;
@@ -264,7 +265,8 @@ void PCB_BASE_FRAME::GlobalChange_PadSettings( D_PAD* aPad,
 
             if( saveMe )
             {
-                ITEM_PICKER itemWrapper( Module, UR_CHANGED );
+                ITEM_PICKER itemWrapper( module, UR_CHANGED );
+
                 itemsList.PushItem( itemWrapper );
             }
         }
@@ -272,96 +274,86 @@ void PCB_BASE_FRAME::GlobalChange_PadSettings( D_PAD* aPad,
         SaveCopyInUndoList( itemsList, UR_CHANGED );
     }
 
-    /* Update the current module and same others modules if requested. */
+    // Update the current module and same others modules if requested.
-    Module = m_Pcb->m_Modules;
+    for( module = m_Pcb->m_Modules;  module;  module = module->Next() )
-
-    for( ; Module != NULL; Module = Module->Next() )
     {
-        if( !aSameFootprints && (Module != Module_Ref) )
+        if( !aSameFootprints && (module != Module_Ref) )
             continue;
 
-        if( Module->m_LibRef != Module_Ref->m_LibRef )
+        if( module->m_LibRef != Module_Ref->m_LibRef )
             continue;
 
-        /* Erase module on screen */
+        // Erase module on screen
         if( aRedraw )
         {
-            Module->SetFlags( DO_NOT_DRAW );
+            module->SetFlags( DO_NOT_DRAW );
-            m_canvas->RefreshDrawingRect( Module->GetBoundingBox() );
+            m_canvas->RefreshDrawingRect( module->GetBoundingBox() );
-            Module->ClearFlags( DO_NOT_DRAW );
+            module->ClearFlags( DO_NOT_DRAW );
         }
 
-        D_PAD* pt_pad = Module->m_Pads;
+        for( D_PAD* pad = module->m_Pads;  pad;  pad = pad->Next() )
-
-        for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
         {
             // Filters changes prohibited.
-            if( aPadShapeFilter && ( pt_pad->m_PadShape != aPad->m_PadShape ) )
+            if( aPadShapeFilter && ( pad->GetShape() != aPad->GetShape() ) )
                 continue;
 
-            if( aPadOrientFilter
+            if( aPadOrientFilter &&  (pad->GetOrientation() - module->GetOrientation()) != pad_orient )
-               && ( (pt_pad->m_Orient - Module->m_Orient) != pad_orient ) )
                 continue;
 
             if( aPadLayerFilter )
             {
-                if( pt_pad->m_layerMask != aPad->m_layerMask )
+                if( pad->GetLayerMask() != aPad->GetLayerMask() )
                     continue;
                 else
                     m_Pcb->m_Status_Pcb &= ~( LISTE_RATSNEST_ITEM_OK | CONNEXION_OK);
             }
 
             // Change characteristics:
-            pt_pad->m_Attribut = aPad->m_Attribut;
+            pad->SetAttribute( aPad->GetAttribute() );
-            pt_pad->m_PadShape = aPad->m_PadShape;
+            pad->SetShape( aPad->GetShape() );
 
-            pt_pad->m_layerMask = aPad->m_layerMask;
+            pad->SetLayerMask( aPad->GetLayerMask() );
 
-            pt_pad->m_Size = aPad->m_Size;
+            pad->SetSize( aPad->GetSize() );
-            pt_pad->m_DeltaSize = aPad->m_DeltaSize;
+            pad->SetDelta( aPad->GetDelta() );
-            pt_pad->m_Offset    = aPad->m_Offset;
+            pad->SetOffset( aPad->GetOffset() );
 
-            pt_pad->m_Drill = aPad->m_Drill;
+            pad->SetDrillSize( aPad->GetDrillSize() );
-            pt_pad->m_DrillShape = aPad->m_DrillShape;
+            pad->SetDrillShape( aPad->GetDrillShape() );
 
-            pt_pad->m_Orient = pad_orient + Module->m_Orient;
+            pad->SetOrientation( pad_orient + module->GetOrientation() );
 
-            // copy also local mask margins,
+            // copy also local mask margins, because these parameters usually depend on
-            // because these parameters usually depend on
+            // pad sizes and layers
-            // pads sizes and layers
+            pad->SetLocalSolderMaskMargin( aPad->GetLocalSolderMaskMargin() );
-            pt_pad->m_LocalSolderMaskMargin  = aPad->m_LocalSolderMaskMargin;
+            pad->SetLocalSolderPasteMargin( aPad->GetLocalSolderPasteMargin() );
-            pt_pad->m_LocalSolderPasteMargin = aPad->m_LocalSolderPasteMargin;
+            pad->SetLocalSolderPasteMarginRatio( aPad->GetLocalSolderPasteMarginRatio() );
-            pt_pad->m_LocalSolderPasteMarginRatio = aPad->m_LocalSolderPasteMarginRatio;
 
-
+            if( pad->GetShape() != PAD_TRAPEZOID )
-            if( pt_pad->m_PadShape != PAD_TRAPEZOID )
             {
-                pt_pad->m_DeltaSize.x = 0;
+                pad->SetDelta( wxSize( 0, 0 ) );
-                pt_pad->m_DeltaSize.y = 0;
             }
-            if( pt_pad->m_PadShape == PAD_CIRCLE )
-                pt_pad->m_Size.y = pt_pad->m_Size.x;
 
-            switch( pt_pad->m_Attribut & 0x7F )
+            if( pad->GetShape() == PAD_CIRCLE )
+                pad->SetY( pad->GetSize().x );
+
+            switch( pad->GetAttribute() )
             {
             case PAD_SMD:
             case PAD_CONN:
-                pt_pad->m_Drill    = wxSize( 0, 0 );
+                pad->SetDrillSize( wxSize( 0, 0 ) );
-                pt_pad->m_Offset.x = 0;
+                pad->SetOffset( wxPoint( 0, 0 ) );
-                pt_pad->m_Offset.y = 0;
                 break;
 
             default:
                 break;
             }
-
-            pt_pad->ComputeShapeMaxRadius();
         }
 
-        Module->CalculateBoundingBox();
+        module->CalculateBoundingBox();
 
         if( aRedraw )
-            m_canvas->RefreshDrawingRect( Module->GetBoundingBox() );
+            m_canvas->RefreshDrawingRect( module->GetBoundingBox() );
     }
 
     OnModify();

pcbnew/gpcb_exchange.cpp

@@ -167,7 +167,7 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
     char*         line;
     long          ibuf[100];
     EDGE_MODULE*  drawSeg;
-    D_PAD*        Pad;
+    D_PAD*        pad;
     wxArrayString params;
     int           iprmcnt, icnt_max, iflgidx;
 
@@ -257,6 +257,7 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
     // real size is:  default * ibuf[idx+3] / 100 (size in gpcb is given in percent of default size
     int tsize = ( ibuf[idx+3] * TEXT_DEFAULT_SIZE ) / 100;
     int thickness = m_Reference->m_Size.x / 6;
+
     tsize = MAX( 40, tsize );
     m_Reference->SetSize( wxSize( tsize, tsize ) );
     m_Reference->m_Thickness  = thickness;
@@ -369,16 +370,17 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
         }
 
         if( params[0].CmpNoCase( wxT( "Pad" ) ) == 0 )      // Pad with no hole (smd pad)
-        {   //  format: Pad [x1 y1 x2 y2 thickness clearance mask "name" "pad_number" flags]
+        {
-            Pad = new D_PAD( this );
+            //  format: Pad [x1 y1 x2 y2 thickness clearance mask "name" "pad_number" flags]
-            Pad->m_PadShape  = PAD_RECT;
+            pad = new D_PAD( this );
-            Pad->m_layerMask = LAYER_FRONT | SOLDERMASK_LAYER_FRONT | SOLDERPASTE_LAYER_FRONT;
+            pad->SetShape( PAD_RECT );
+            pad->SetLayerMask( LAYER_FRONT | SOLDERMASK_LAYER_FRONT | SOLDERPASTE_LAYER_FRONT );
 
             // Set shape from flags
             iflgidx = params.GetCount() - 2;
 
             if( TestFlags( params[iflgidx], 0x0080, wxT( "onsolder" ) ) )
-                Pad->m_layerMask = LAYER_BACK | SOLDERMASK_LAYER_BACK | SOLDERPASTE_LAYER_BACK;
+                pad->SetLayerMask( LAYER_BACK | SOLDERMASK_LAYER_BACK | SOLDERPASTE_LAYER_BACK );
 
             for( unsigned ii = 0; ii < 5; ii++ )
             {
@@ -401,11 +403,11 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
             // Read pad number:
             if( params[1] == wxT( "(" ) )
             {
-                Pad->SetPadName( params[8] );
+                pad->SetPadName( params[8] );
             }
             else
             {
-                Pad->SetPadName( params[10] );
+                pad->SetPadName( params[10] );
             }
             // Calculate the Pad parameters.
             // In Pcb the shape is a segment
@@ -418,43 +420,50 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
             wxPoint delta;
             delta.x = ibuf[2] - ibuf[0];
             delta.y = ibuf[3] - ibuf[1];
+
             double angle = atan2( (double)delta.y, (double)delta.x );
+
             // Negate angle (due to Y reversed axis) and convert it to internal units
             angle = - angle * 1800.0 / M_PI;
-            Pad->SetOrientation( wxRound( angle ) );
+            pad->SetOrientation( wxRound( angle ) );
-            wxPoint padPos;
+
-            padPos.x  = (ibuf[0] + ibuf[2]) / 2;
+            wxPoint padPos( (ibuf[0] + ibuf[2]) / 2, (ibuf[1] + ibuf[3]) / 2 );
-            padPos.y  = (ibuf[1] + ibuf[3]) / 2;
+
-            Pad->m_Size.x = wxRound( hypot( (double)delta.x, (double)delta.y ) ) + ibuf[4];
+            pad->SetSize( wxSize(
-            Pad->m_Size.y = ibuf[4];
+                    wxRound( hypot( (double)delta.x, (double)delta.y ) ) + ibuf[4],
+                    ibuf[4] ) );
+
             padPos += m_Pos;
-            Pad->SetPos0( padPos );
+            pad->SetPos0( padPos );
-            Pad->SetPosition( padPos );
+            pad->SetPosition( padPos );
 
             if( !TestFlags( params[iflgidx], 0x0100, wxT( "square" ) ) )
             {
-                if( Pad->m_Size.x == Pad->m_Size.y )
+                if( pad->GetSize().x == pad->GetSize().y )
-                    Pad->m_PadShape = PAD_ROUND;
+                    pad->SetShape( PAD_ROUND );
                 else
-                    Pad->m_PadShape = PAD_OVAL;
+                    pad->SetShape( PAD_OVAL );
             }
 
-            m_Pads.PushBack( Pad );
+            m_Pads.PushBack( pad );
             continue;
         }
 
         if( params[0].CmpNoCase( wxT( "Pin" ) ) == 0 )      // Pad with hole (trough pad)
-        {   // format: Pin[x y Thickness Clearance Mask DrillHole Name Number Flags]
+        {
-            Pad = new D_PAD( this );
+            // format: Pin[x y Thickness Clearance Mask DrillHole Name Number Flags]
-            Pad->m_PadShape     = PAD_ROUND;
+            pad = new D_PAD( this );
-            Pad->m_layerMask = ALL_CU_LAYERS |
+            pad->SetShape( PAD_ROUND );
+
+            pad->SetLayerMask(    ALL_CU_LAYERS |
                                   SILKSCREEN_LAYER_FRONT |
                                   SOLDERMASK_LAYER_FRONT |
-                                  SOLDERMASK_LAYER_BACK;
+                                  SOLDERMASK_LAYER_BACK );
+
             iflgidx = params.GetCount() - 2;
 
             if( TestFlags( params[iflgidx], 0x0100, wxT( "square" ) ) )
-                Pad->m_PadShape = PAD_RECT;
+                pad->SetShape( PAD_RECT );
 
             for( unsigned ii = 0; ii < 6; ii++ )
             {
@@ -476,25 +485,30 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
             // Read pad number:
             if( params[1] == wxT( "(" ) )
             {
-                Pad->SetPadName( params[7] );
+                pad->SetPadName( params[7] );
             }
             else
             {
-                Pad->SetPadName( params[9] );
+                pad->SetPadName( params[9] );
             }
-            wxPoint padPos;
+
-            padPos.x = ibuf[0];
+            wxPoint padPos( ibuf[0], ibuf[1] );
-            padPos.y = ibuf[1];
+
-            Pad->m_Drill.x = Pad->m_Drill.y = ibuf[5];
+            pad->SetDrillSize( wxSize( ibuf[5], ibuf[5] ) );
-            Pad->m_Size.x  = Pad->m_Size.y = ibuf[3] + Pad->m_Drill.x;
+
+            int sz = ibuf[3] + pad->GetDrillSize().x;
+
+            pad->SetSize( wxSize( sz, sz ) );
+
             padPos += m_Pos;
-            Pad->SetPos0( padPos );
-            Pad->SetPosition( padPos );
 
-            if( (Pad->m_PadShape == PAD_ROUND) && (Pad->m_Size.x != Pad->m_Size.y) )
+            pad->SetPos0( padPos );
-                Pad->m_PadShape = PAD_OVAL;
+            pad->SetPosition( padPos );
 
-            m_Pads.PushBack( Pad );
+            if( pad->GetShape() == PAD_ROUND  &&  pad->GetSize().x != pad->GetSize().y )
+                pad->SetShape( PAD_OVAL );
+
+            m_Pads.PushBack( pad );
             continue;
         }
     }
@@ -508,7 +522,7 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName )
         m_Reference->m_Text = filename.GetName();
     }
 
-    /* Recalculate the bounding box */
+    // Recalculate the bounding box
     CalculateBoundingBox();
     return success;
 }

pcbnew/graphpcb.cpp

@@ -41,7 +41,7 @@ static void DrawSegmentQcq( int ux0,
                             int color,
                             int op_logic );
 
-static void TraceFilledCircle( BOARD* Pcb,
+static void TraceFilledCircle( BOARD* aPcb,
                                int    cx,
                                int    cy,
                                int    radius,
@@ -84,50 +84,49 @@ int ToMatrixCoordinate( int aPhysicalCoordinate )
 }
 
 
-void PlacePad( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logic )
+void PlacePad( BOARD* aPcb, D_PAD* aPad, int color, int marge, int op_logic )
 {
     int     dx, dy;
-    wxPoint shape_pos = pt_pad->ReturnShapePos();
+    wxPoint shape_pos = aPad->ReturnShapePos();
 
-    dx = pt_pad->m_Size.x / 2;
+    dx = aPad->GetSize().x / 2;
     dx += marge;
 
-    if( pt_pad->m_PadShape == PAD_CIRCLE )
+    if( aPad->GetShape() == PAD_CIRCLE )
     {
-        TraceFilledCircle( Pcb, shape_pos.x, shape_pos.y, dx,
+        TraceFilledCircle( aPcb, shape_pos.x, shape_pos.y, dx,
-                           pt_pad->m_layerMask, color, op_logic );
+                           aPad->GetLayerMask(), color, op_logic );
         return;
     }
 
-
+    dy = aPad->GetSize().y / 2;
-    dy = pt_pad->m_Size.y / 2;
     dy += marge;
 
-    if( pt_pad->m_PadShape == PAD_TRAPEZOID )
+    if( aPad->GetShape() == PAD_TRAPEZOID )
     {
-        dx += abs( pt_pad->m_DeltaSize.y ) / 2;
+        dx += abs( aPad->GetDelta().y ) / 2;
-        dy += abs( pt_pad->m_DeltaSize.x ) / 2;
+        dy += abs( aPad->GetDelta().x ) / 2;
     }
 
     // The pad is a rectangle horizontally or vertically.
-    if( int( pt_pad->GetOrientation() ) % 900 == 0 )
+    if( int( aPad->GetOrientation() ) % 900 == 0 )
     {
         // Orientation turned 90 deg.
-        if( ( pt_pad->m_Orient == 900 ) || ( pt_pad->m_Orient == 2700 ) )
+        if( aPad->GetOrientation() == 900  ||  aPad->GetOrientation() == 2700 )
         {
             EXCHG( dx, dy );
         }
 
-        TraceFilledRectangle( Pcb, shape_pos.x - dx, shape_pos.y - dy,
+        TraceFilledRectangle( aPcb, shape_pos.x - dx, shape_pos.y - dy,
                               shape_pos.x + dx, shape_pos.y + dy,
-                              pt_pad->m_layerMask, color, op_logic );
+                              aPad->GetLayerMask(), color, op_logic );
     }
     else
     {
-        TraceFilledRectangle( Pcb, shape_pos.x - dx, shape_pos.y - dy,
+        TraceFilledRectangle( aPcb, shape_pos.x - dx, shape_pos.y - dy,
                               shape_pos.x + dx, shape_pos.y + dy,
-                              (int) pt_pad->m_Orient,
+                              (int) aPad->GetOrientation(),
-                              pt_pad->m_layerMask, color, op_logic );
+                              aPad->GetLayerMask(), color, op_logic );
     }
 }
 
@@ -140,7 +139,7 @@ void PlacePad( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logic )
  * color: mask write in cells
  * op_logic: type of writing in the cell (WRITE, OR)
  */
-void TraceFilledCircle( BOARD* Pcb,
+void TraceFilledCircle( BOARD* aPcb,
                         int    cx,
                         int    cy,
                         int    radius,
@@ -197,8 +196,8 @@ void TraceFilledCircle( BOARD* Pcb,
         break;
     }
 
-    cx -= Pcb->GetBoundingBox().GetX();
+    cx -= aPcb->GetBoundingBox().GetX();
-    cy -= Pcb->GetBoundingBox().GetY();
+    cy -= aPcb->GetBoundingBox().GetY();
 
     distmin = radius;
 
@@ -290,7 +289,7 @@ void TraceFilledCircle( BOARD* Pcb,
 }
 
 
-void TraceSegmentPcb( BOARD* Pcb, TRACK* pt_segm, int color, int marge, int op_logic )
+void TraceSegmentPcb( BOARD* aPcb, TRACK* pt_segm, int color, int marge, int op_logic )
 {
     int half_width;
     int ux0, uy0, ux1, uy1;
@@ -298,10 +297,10 @@ void TraceSegmentPcb( BOARD* Pcb, TRACK* pt_segm, int color, int marge, int op_l
     half_width = ( pt_segm->m_Width / 2 ) + marge;
 
     // Calculate the bounding rectangle of the segment (if H, V or Via)
-    ux0 = pt_segm->m_Start.x - Pcb->GetBoundingBox().GetX();
+    ux0 = pt_segm->m_Start.x - aPcb->GetBoundingBox().GetX();
-    uy0 = pt_segm->m_Start.y - Pcb->GetBoundingBox().GetY();
+    uy0 = pt_segm->m_Start.y - aPcb->GetBoundingBox().GetY();
-    ux1 = pt_segm->m_End.x - Pcb->GetBoundingBox().GetX();
+    ux1 = pt_segm->m_End.x - aPcb->GetBoundingBox().GetX();
-    uy1 = pt_segm->m_End.y - Pcb->GetBoundingBox().GetY();
+    uy1 = pt_segm->m_End.y - aPcb->GetBoundingBox().GetY();
 
     // Test if VIA (filled circle was drawn)
     if( pt_segm->Type() == PCB_VIA_T )
@@ -323,7 +322,7 @@ void TraceSegmentPcb( BOARD* Pcb, TRACK* pt_segm, int color, int marge, int op_l
             mask_layer = -1;
 
         if( mask_layer )
-            TraceFilledCircle( Pcb, pt_segm->m_Start.x, pt_segm->m_Start.y,
+            TraceFilledCircle( aPcb, pt_segm->m_Start.x, pt_segm->m_Start.y,
                                half_width, mask_layer, color, op_logic );
         return;
     }
@@ -516,7 +515,7 @@ void TracePcbLine( int x0, int y0, int x1, int y1, int layer, int color, int op_
 }
 
 
-void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
+void TraceFilledRectangle( BOARD* aPcb, int ux0, int uy0, int ux1, int uy1,
                            int aLayerMask, int color, int op_logic )
 {
     int  row, col;
@@ -558,10 +557,10 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
         break;
     }
 
-    ux0 -= Pcb->GetBoundingBox().GetX();
+    ux0 -= aPcb->GetBoundingBox().GetX();
-    uy0 -= Pcb->GetBoundingBox().GetY();
+    uy0 -= aPcb->GetBoundingBox().GetY();
-    ux1 -= Pcb->GetBoundingBox().GetX();
+    ux1 -= aPcb->GetBoundingBox().GetX();
-    uy1 -= Pcb->GetBoundingBox().GetY();
+    uy1 -= aPcb->GetBoundingBox().GetY();
 
     // Calculating limits coord cells belonging to the rectangle.
     row_max = uy1 / Board.m_GridRouting;
@@ -602,7 +601,7 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
 }
 
 
-void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
+void TraceFilledRectangle( BOARD* aPcb, int ux0, int uy0, int ux1, int uy1,
                            int angle, int aLayerMask, int color, int op_logic )
 {
     int  row, col;
@@ -650,10 +649,10 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
         break;
     }
 
-    ux0 -= Pcb->GetBoundingBox().GetX();
+    ux0 -= aPcb->GetBoundingBox().GetX();
-    uy0 -= Pcb->GetBoundingBox().GetY();
+    uy0 -= aPcb->GetBoundingBox().GetY();
-    ux1 -= Pcb->GetBoundingBox().GetX();
+    ux1 -= aPcb->GetBoundingBox().GetX();
-    uy1 -= Pcb->GetBoundingBox().GetY();
+    uy1 -= aPcb->GetBoundingBox().GetY();
 
     cx    = (ux0 + ux1) / 2;
     cy    = (uy0 + uy1) / 2;

pcbnew/ioascii.cpp

@@ -334,6 +334,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
     NETCLASS* netclass_default = GetBoard()->m_NetClasses.GetDefault();
     ZONE_SETTINGS zoneInfo = GetBoard()->GetZoneSettings();
+    BOARD_DESIGN_SETTINGS bds = GetBoard()->GetDesignSettings();
 
     while( aReader->ReadLine() )
     {
@@ -456,7 +457,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
         if( stricmp( line, "TrackMinWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_TrackMinWidth = atoi( data );
+            bds.m_TrackMinWidth = atoi( data );
             continue;
         }
 
@@ -468,13 +469,13 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
         if( stricmp( line, "DrawSegmWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_DrawSegmentWidth = atoi( data );
+            bds.m_DrawSegmentWidth = atoi( data );
             continue;
         }
 
         if( stricmp( line, "EdgeSegmWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_EdgeSegmentWidth = atoi( data );
+            bds.m_EdgeSegmentWidth = atoi( data );
             continue;
         }
 
@@ -485,7 +486,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
         if( stricmp( line, "ViaMinSize" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_ViasMinSize = atoi( data );
+            bds.m_ViasMinSize = atoi( data );
             continue;
         }
 
@@ -496,7 +497,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
         if( stricmp( line, "MicroViaMinSize" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_MicroViasMinSize = atoi( data );
+            bds.m_MicroViasMinSize = atoi( data );
             continue;
         }
 
@@ -526,7 +527,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
         if( stricmp( line, "ViaMinDrill" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_ViasMinDrill = atoi( data );
+            bds.m_ViasMinDrill = atoi( data );
             continue;
         }
 
@@ -540,80 +541,81 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
         if( stricmp( line, "MicroViaMinDrill" ) == 0 )
         {
             int diameter = atoi( data );
-            GetBoard()->GetDesignSettings().m_MicroViasMinDrill = diameter;
+            bds.m_MicroViasMinDrill = diameter;
             continue;
         }
 
         if( stricmp( line, "MicroViasAllowed" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_MicroViasAllowed = atoi( data );
+            bds.m_MicroViasAllowed = atoi( data );
             continue;
         }
 
         if( stricmp( line, "TextPcbWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_PcbTextWidth = atoi( data );
+            bds.m_PcbTextWidth = atoi( data );
             continue;
         }
 
         if( stricmp( line, "TextPcbSize" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_PcbTextSize.x = atoi( data );
+            bds.m_PcbTextSize.x = atoi( data );
             data = strtok( NULL, delims );
-            GetBoard()->GetDesignSettings().m_PcbTextSize.y = atoi( data );
+            bds.m_PcbTextSize.y = atoi( data );
             continue;
         }
 
         if( stricmp( line, "EdgeModWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_ModuleSegmentWidth = atoi( data );
+            bds.m_ModuleSegmentWidth = atoi( data );
             continue;
         }
 
         if( stricmp( line, "TextModWidth" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_ModuleTextWidth = atoi( data );
+            bds.m_ModuleTextWidth = atoi( data );
             continue;
         }
 
         if( stricmp( line, "TextModSize" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_ModuleTextSize.x = atoi( data );
+            bds.m_ModuleTextSize.x = atoi( data );
             data = strtok( NULL, delims );
-            GetBoard()->GetDesignSettings().m_ModuleTextSize.y = atoi( data );
+            bds.m_ModuleTextSize.y = atoi( data );
             continue;
         }
 
         if( stricmp( line, "PadSize" ) == 0 )
         {
-            g_Pad_Master.m_Size.x = atoi( data );
+            int x = atoi( data );
             data = strtok( NULL, delims );
-            g_Pad_Master.m_Size.y = atoi( data );
+            int y = atoi( data );
+            bds.m_Pad_Master.SetSize( wxSize( x, y ) );
             continue;
         }
 
         if( stricmp( line, "PadDrill" ) == 0 )
         {
-            g_Pad_Master.m_Drill.x = atoi( data );
+            int sz = atoi( data );
-            g_Pad_Master.m_Drill.y = g_Pad_Master.m_Drill.x;
+            bds.m_Pad_Master.SetSize( wxSize( sz, sz ) );
             continue;
         }
 
         if( stricmp( line, "Pad2MaskClearance" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_SolderMaskMargin = atoi( data );
+            bds.m_SolderMaskMargin = atoi( data );
             continue;
         }
 
         if( stricmp( line, "Pad2PasteClearance" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_SolderPasteMargin = atoi( data );
+            bds.m_SolderPasteMargin = atoi( data );
             continue;
         }
 
         if( stricmp( line, "Pad2PasteClearanceRatio" ) == 0 )
         {
-            GetBoard()->GetDesignSettings().m_SolderPasteMarginRatio = atof( data );
+            bds.m_SolderPasteMarginRatio = atof( data );
             continue;
         }
 
@@ -670,6 +672,7 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader )
 
 static int WriteSetup( FILE* aFile, PCB_EDIT_FRAME* aFrame, BOARD* aBoard )
 {
+    const BOARD_DESIGN_SETTINGS& bds = aBoard->GetDesignSettings();
     NETCLASS* netclass_default = aBoard->m_NetClasses.GetDefault();
     char      text[1024];
 
@@ -701,16 +704,16 @@ static int WriteSetup( FILE* aFile, PCB_EDIT_FRAME* aFrame, BOARD* aBoard )
 
     fprintf( aFile, "TrackClearence %d\n", netclass_default->GetClearance() );
     fprintf( aFile, "ZoneClearence %d\n", aBoard->GetZoneSettings().m_ZoneClearance );
-    fprintf( aFile, "TrackMinWidth %d\n", aBoard->GetDesignSettings().m_TrackMinWidth );
+    fprintf( aFile, "TrackMinWidth %d\n", bds.m_TrackMinWidth );
 
-    fprintf( aFile, "DrawSegmWidth %d\n", aBoard->GetDesignSettings().m_DrawSegmentWidth );
+    fprintf( aFile, "DrawSegmWidth %d\n", bds.m_DrawSegmentWidth );
-    fprintf( aFile, "EdgeSegmWidth %d\n", aBoard->GetDesignSettings().m_EdgeSegmentWidth );
+    fprintf( aFile, "EdgeSegmWidth %d\n", bds.m_EdgeSegmentWidth );
 
     // Save current default via size, for compatibility with older Pcbnew version;
     fprintf( aFile, "ViaSize %d\n", netclass_default->GetViaDiameter() );
     fprintf( aFile, "ViaDrill %d\n", netclass_default->GetViaDrill() );
-    fprintf( aFile, "ViaMinSize %d\n", aBoard->GetDesignSettings().m_ViasMinSize );
+    fprintf( aFile, "ViaMinSize %d\n", bds.m_ViasMinSize );
-    fprintf( aFile, "ViaMinDrill %d\n", aBoard->GetDesignSettings().m_ViasMinDrill );
+    fprintf( aFile, "ViaMinDrill %d\n", bds.m_ViasMinDrill );
 
     // Save custom vias diameters list (the first is not saved here: this is
     // the netclass value
@@ -724,38 +727,41 @@ static int WriteSetup( FILE* aFile, PCB_EDIT_FRAME* aFrame, BOARD* aBoard )
     fprintf( aFile, "MicroViaDrill %d\n", netclass_default->GetuViaDrill() );
     fprintf( aFile,
              "MicroViasAllowed %d\n",
-             aBoard->GetDesignSettings().m_MicroViasAllowed );
+             bds.m_MicroViasAllowed );
     fprintf( aFile,
              "MicroViaMinSize %d\n",
-             aBoard->GetDesignSettings().m_MicroViasMinSize );
+             bds.m_MicroViasMinSize );
     fprintf( aFile,
              "MicroViaMinDrill %d\n",
-             aBoard->GetDesignSettings().m_MicroViasMinDrill );
+             bds.m_MicroViasMinDrill );
 
-    fprintf( aFile, "TextPcbWidth %d\n", aBoard->GetDesignSettings().m_PcbTextWidth );
+    fprintf( aFile, "TextPcbWidth %d\n", bds.m_PcbTextWidth );
     fprintf( aFile,
              "TextPcbSize %d %d\n",
-             aBoard->GetDesignSettings().m_PcbTextSize.x,
+             bds.m_PcbTextSize.x,
-             aBoard->GetDesignSettings().m_PcbTextSize.y );
+             bds.m_PcbTextSize.y );
 
-    fprintf( aFile, "EdgeModWidth %d\n", aBoard->GetDesignSettings().m_ModuleSegmentWidth );
+    fprintf( aFile, "EdgeModWidth %d\n", bds.m_ModuleSegmentWidth );
-    fprintf( aFile, "TextModSize %d %d\n", aBoard->GetDesignSettings().m_ModuleTextSize.x, aBoard->GetDesignSettings().m_ModuleTextSize.y );
+    fprintf( aFile, "TextModSize %d %d\n", bds.m_ModuleTextSize.x, bds.m_ModuleTextSize.y );
-    fprintf( aFile, "TextModWidth %d\n", aBoard->GetDesignSettings().m_ModuleTextWidth );
+    fprintf( aFile, "TextModWidth %d\n", bds.m_ModuleTextWidth );
-    fprintf( aFile, "PadSize %d %d\n", g_Pad_Master.m_Size.x, g_Pad_Master.m_Size.y );
+
-    fprintf( aFile, "PadDrill %d\n", g_Pad_Master.m_Drill.x );
+    fprintf( aFile, "PadSize %d %d\n", bds.m_Pad_Master.GetSize().x,
+                                       bds.m_Pad_Master.GetSize().y );
+
+    fprintf( aFile, "PadDrill %d\n", bds.m_Pad_Master.GetDrillSize().x );
     fprintf( aFile,
              "Pad2MaskClearance %d\n",
-             aBoard->GetDesignSettings().m_SolderMaskMargin );
+             bds.m_SolderMaskMargin );
 
-    if( aBoard->GetDesignSettings().m_SolderPasteMargin != 0 )
+    if( bds.m_SolderPasteMargin != 0 )
         fprintf( aFile,
                  "Pad2PasteClearance %d\n",
-                 aBoard->GetDesignSettings().m_SolderPasteMargin );
+                 bds.m_SolderPasteMargin );
 
-    if( aBoard->GetDesignSettings().m_SolderPasteMarginRatio != 0 )
+    if( bds.m_SolderPasteMarginRatio != 0 )
         fprintf( aFile,
                  "Pad2PasteClearanceRatio %g\n",
-                 aBoard->GetDesignSettings().m_SolderPasteMarginRatio );
+                 bds.m_SolderPasteMarginRatio );
 
     if ( aFrame->GetScreen()->m_GridOrigin != wxPoint( 0, 0 ) )
     {

pcbnew/item_io.cpp

@@ -40,7 +40,7 @@
 #include <pcbnew.h>
 #include <drawtxt.h>
 
-#define MAX_WIDTH 10000  /* Thickness (in 1 / 10000 ") of maximum reasonable features, text... */
+#define MAX_WIDTH 10000  // Thickness (in 1 / 10000 ") of maximum reasonable features, text...
 
 
 #if 1 || !defined(USE_NEW_PCBNEW_SAVE)
@@ -678,7 +678,7 @@ bool D_PAD::Save( FILE* aFile ) const
 
     fprintf( aFile, "\n" );
 
-    switch( m_Attribut )
+    switch( GetAttribute() )
     {
     case PAD_STANDARD:
         texttype = "STD"; break;
@@ -704,20 +704,20 @@ bool D_PAD::Save( FILE* aFile ) const
 
     fprintf( aFile, "Po %d %d\n", m_Pos0.x, m_Pos0.y );
 
-    if( m_LengthDie != 0 )
+    if( GetDieLength() != 0 )
-        fprintf( aFile, "Le %d\n", m_LengthDie );
+        fprintf( aFile, "Le %d\n", GetDieLength() );
 
-    if( m_LocalSolderMaskMargin != 0 )
+    if( GetLocalSolderMaskMargin() != 0 )
-        fprintf( aFile, ".SolderMask %d\n", m_LocalSolderMaskMargin );
+        fprintf( aFile, ".SolderMask %d\n", GetLocalSolderMaskMargin() );
 
-    if( m_LocalSolderPasteMargin != 0 )
+    if( GetLocalSolderPasteMargin() != 0 )
-        fprintf( aFile, ".SolderPaste %d\n", m_LocalSolderPasteMargin );
+        fprintf( aFile, ".SolderPaste %d\n", GetLocalSolderPasteMargin() );
 
-    if( m_LocalSolderPasteMarginRatio != 0 )
+    if( GetLocalSolderPasteMarginRatio() != 0 )
-        fprintf( aFile, ".SolderPasteRatio %g\n", m_LocalSolderPasteMarginRatio );
+        fprintf( aFile, ".SolderPasteRatio %g\n", GetLocalSolderPasteMarginRatio() );
 
-    if( m_LocalClearance != 0 )
+    if( GetLocalClearance() != 0 )
-        fprintf( aFile, ".LocalClearance %d\n", m_LocalClearance );
+        fprintf( aFile, ".LocalClearance %d\n", GetLocalClearance() );
 
     if( fprintf( aFile, "$EndPAD\n" ) != sizeof("$EndPAD\n") - 1 )
         return false;
@@ -767,17 +767,17 @@ bool MODULE::Save( FILE* aFile ) const
     fprintf( aFile, "AR %s\n", TO_UTF8( m_Path ) );
     fprintf( aFile, "Op %X %X 0\n", m_CntRot90, m_CntRot180 );
 
-    if( m_LocalSolderMaskMargin != 0 )
+    if( GetLocalSolderMaskMargin() != 0 )
-        fprintf( aFile, ".SolderMask %d\n", m_LocalSolderMaskMargin );
+        fprintf( aFile, ".SolderMask %d\n", GetLocalSolderMaskMargin() );
 
     if( m_LocalSolderPasteMargin != 0 )
-        fprintf( aFile, ".SolderPaste %d\n", m_LocalSolderPasteMargin );
+        fprintf( aFile, ".SolderPaste %d\n", GetLocalSolderPasteMargin() );
 
-    if( m_LocalSolderPasteMarginRatio != 0 )
+    if( GetLocalSolderPasteMarginRatio() != 0 )
-        fprintf( aFile, ".SolderPasteRatio %g\n", m_LocalSolderPasteMarginRatio );
+        fprintf( aFile, ".SolderPasteRatio %g\n", GetLocalSolderPasteMarginRatio() );
 
     if( m_LocalClearance != 0 )
-        fprintf( aFile, ".LocalClearance %d\n", m_LocalClearance );
+        fprintf( aFile, ".LocalClearance %d\n", GetLocalClearance() );
 
     // attributes
     if( m_Attributs != MOD_DEFAULT )
@@ -892,10 +892,10 @@ int MODULE::Write_3D_Descr( FILE* File ) const
  */
 int D_PAD::ReadDescr( LINE_READER* aReader )
 {
-    char* Line;
+    char*   Line;
-    char  BufLine[1024], BufCar[256];
+    char    BufLine[1024], BufCar[256];
-    char* PtLine;
+    char*   PtLine;
-    int   nn, ll, dx, dy;
+    int     nn, ll, dx, dy;
 
     while( aReader->ReadLine() )
     {
@@ -911,7 +911,7 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
         switch( Line[0] )
         {
         case 'S': // = Sh
-            /* Read pad name */
+            // Read pad name
             nn = 0;
 
             while( (*PtLine != '"') && *PtLine )
@@ -944,25 +944,19 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
 
             ll = 0xFF & BufCar[0];
 
-            /* Read pad shape */
+            // Read pad shape
-            m_PadShape = PAD_CIRCLE;
+            PAD_SHAPE_T shape;
 
             switch( ll )
             {
-            case 'C':
+            default:
-                m_PadShape = PAD_CIRCLE; break;
+            case 'C':   shape = PAD_CIRCLE;     break;
-
+            case 'R':   shape = PAD_RECT;       break;
-            case 'R':
+            case 'O':   shape = PAD_OVAL;       break;
-                m_PadShape = PAD_RECT; break;
+            case 'T':   shape = PAD_TRAPEZOID;  break;
-
-            case 'O':
-                m_PadShape = PAD_OVAL; break;
-
-            case 'T':
-                m_PadShape = PAD_TRAPEZOID; break;
             }
 
-            ComputeShapeMaxRadius();
+            SetShape( shape );  // sets m_boundingRadius = -1
             break;
 
         case 'D':
@@ -976,7 +970,9 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
             {
                 if( BufCar[0] == 'O' )
                 {
-                    m_Drill.x    = dx; m_Drill.y = dy;
+                    m_Drill.x = dx;
+                    m_Drill.y = dy;
+
                     m_DrillShape = PAD_OVAL;
                 }
             }
@@ -987,25 +983,25 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
             nn = sscanf( PtLine, "%s %s %X", BufLine, BufCar,
                          &m_layerMask );
 
-            /* BufCar is not used now update attributes */
+            // BufCar is not used now update attributes
-            m_Attribut = PAD_STANDARD;
+            SetAttribute( PAD_STANDARD );
             if( strncmp( BufLine, "SMD", 3 ) == 0 )
-                m_Attribut = PAD_SMD;
+                SetAttribute( PAD_SMD );
 
             if( strncmp( BufLine, "CONN", 4 ) == 0 )
-                m_Attribut = PAD_CONN;
+                SetAttribute( PAD_CONN );
 
             if( strncmp( BufLine, "HOLE", 4 ) == 0 )
-                m_Attribut = PAD_HOLE_NOT_PLATED;
+                SetAttribute( PAD_HOLE_NOT_PLATED );
 
             break;
 
-        case 'N':       /* Read Netname */
+        case 'N':       // Read Netname
             int netcode;
             nn = sscanf( PtLine, "%d", &netcode );
             SetNet( netcode );
 
-            /* read Netname */
+            // read Netname
             ReadDelimitedText( BufLine, PtLine, sizeof(BufLine) );
             SetNetname( FROM_UTF8( StrPurge( BufLine ) ) );
         break;
@@ -1018,18 +1014,18 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
         case 'L':
             int lengthdie;
             nn    = sscanf( PtLine, "%d", &lengthdie );
-            m_LengthDie = lengthdie;
+            SetDieLength( lengthdie );
             break;
 
-        case '.':    /* Read specific data */
+        case '.':    // Read specific data
             if( strnicmp( Line, ".SolderMask ", 12 ) == 0 )
-                m_LocalSolderMaskMargin = atoi( Line + 12 );
+                SetLocalSolderMaskMargin( atoi( Line + 12 ) );
             else if( strnicmp( Line, ".SolderPaste ", 13 )  == 0 )
-                m_LocalSolderPasteMargin = atoi( Line + 13 );
+                SetLocalSolderPasteMargin( atoi( Line + 13 ) );
             else if( strnicmp( Line, ".SolderPasteRatio ", 18 ) == 0 )
-                m_LocalSolderPasteMarginRatio = atoi( Line + 18 );
+                SetLocalSolderPasteMarginRatio( atoi( Line + 18 ) );
             else if( strnicmp( Line, ".LocalClearance ", 16 ) == 0 )
-                m_LocalClearance = atoi( Line + 16 );
+                SetLocalClearance( atoi( Line + 16 ) );
             break;
 
         default:
@@ -1038,7 +1034,7 @@ int D_PAD::ReadDescr( LINE_READER* aReader )
         }
     }
 
-    return 2;   /* error : EOF */
+    return 2;   // error : EOF
 }
 
 
@@ -1133,10 +1129,14 @@ int MODULE::ReadDescr( LINE_READER* aReader )
             if( Line[1] == 'P' )
             {
                 D_PAD* pad = new D_PAD( this );
+
                 pad->ReadDescr( aReader );
-                RotatePoint( &pad->m_Pos, m_Orient );
+
-                pad->m_Pos.x += m_Pos.x;
+                wxPoint padpos = pad->GetPosition();
-                pad->m_Pos.y += m_Pos.y;
+
+                RotatePoint( &padpos, m_Orient );
+
+                pad->SetPosition( padpos + m_Pos );
 
                 m_Pads.PushBack( pad );
                 continue;
@@ -1176,7 +1176,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
 
             break;
 
-        case 'L':       /* Li = read the library name of the footprint */
+        case 'L':       // Li = read the library name of the footprint
             *BufLine = 0;
             sscanf( PtLine, " %s", BufLine );
             m_LibRef = FROM_UTF8( BufLine );
@@ -1187,7 +1187,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
             break;
 
 
-        case 'O':       /* (Op)tions for auto placement */
+        case 'O':       // (Op)tions for auto placement
             itmp1 = itmp2 = 0;
             sscanf( PtLine, " %X %X", &itmp1, &itmp2 );
 
@@ -1212,7 +1212,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
         case 'A':
             if( Line[1] == 't' )
             {
-                /* At = (At)tributes of module */
+                // At = (At)tributes of module
                 if( strstr( PtLine, "SMD" ) )
                     m_Attributs |= MOD_CMS;
 
@@ -1238,7 +1238,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
                 textm = m_Reference;
             else if( itmp1 == TEXT_is_VALUE )
                 textm = m_Value;
-            else        /* text is a drawing */
+            else        // text is a drawing
             {
                 textm = new TEXTE_MODULE( this );
                 m_Drawings.PushBack( textm );
@@ -1246,7 +1246,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
             textm->ReadDescr( aReader );
             break;
 
-        case 'D':    /* read a drawing item */
+        case 'D':    // read a drawing item
             EDGE_MODULE * edge;
             edge = new EDGE_MODULE( this );
             m_Drawings.PushBack( edge );
@@ -1254,23 +1254,23 @@ int MODULE::ReadDescr( LINE_READER* aReader )
             edge->SetDrawCoord();
             break;
 
-        case 'C':    /* read documentation data */
+        case 'C':    // read documentation data
             m_Doc = FROM_UTF8( StrPurge( PtLine ) );
             break;
 
-        case 'K':    /* Read key words */
+        case 'K':    // Read key words
             m_KeyWord = FROM_UTF8( StrPurge( PtLine ) );
             break;
 
-        case '.':    /* Read specific data */
+        case '.':    // Read specific data
             if( strnicmp( Line, ".SolderMask ", 12 ) == 0 )
-                m_LocalSolderMaskMargin = atoi( Line + 12 );
+                SetLocalSolderMaskMargin( atoi( Line + 12 ) );
             else if( strnicmp( Line, ".SolderPaste ", 13 )  == 0 )
-                m_LocalSolderPasteMargin = atoi( Line + 13 );
+                SetLocalSolderPasteMargin( atoi( Line + 13 ) );
             else if( strnicmp( Line, ".SolderPasteRatio ", 18 ) == 0 )
-                m_LocalSolderPasteMarginRatio = atof( Line + 18 );
+                SetLocalSolderPasteMarginRatio( atof( Line + 18 ) );
             else if( strnicmp( Line, ".LocalClearance ", 16 ) == 0 )
-                m_LocalClearance = atoi( Line + 16 );
+                SetLocalClearance( atoi( Line + 16 ) );
 
             break;
 
@@ -1279,7 +1279,7 @@ int MODULE::ReadDescr( LINE_READER* aReader )
         }
     }
 
-    /* Recalculate the bounding box */
+    // Recalculate the bounding box
     CalculateBoundingBox();
     return 0;
 }
@@ -1555,7 +1555,7 @@ bool DRAWSEGMENT::ReadDrawSegmentDescr( LINE_READER* aReader )
         Line = aReader->Line();
 
         if( strnicmp( Line, "$End", 4 ) == 0 )
-            return true; /* End of description */
+            return true; // End of description
 
         if( Line[0] == 'P' )
         {
@@ -1595,7 +1595,7 @@ bool DRAWSEGMENT::ReadDrawSegmentDescr( LINE_READER* aReader )
                 case 4:
                     sscanf( token,"%X",&status );
                     break;
-                    /* Bezier Control Points*/
+                    // Bezier Control Points
                 case 5:
                     sscanf( token,"%d",&m_BezierC1.x );
                     break;
@@ -1794,7 +1794,7 @@ int ZONE_CONTAINER::ReadDescr( LINE_READER* aReader )
                     break;
                 }
             }
-            /* Set hatch mode later, after reading outlines corners data */
+            // Set hatch mode later, after reading outlines corners data
         }
 
         else if( strnicmp( Line, "ZPriority", 9 ) == 0 )
@@ -1950,7 +1950,7 @@ int ZONE_CONTAINER::ReadDescr( LINE_READER* aReader )
         SetNet( 0 );
     }
 
-    /* Set hatch here, when outlines corners are read */
+    // Set hatch here, when outlines corners are read
     m_Poly->SetHatch( outline_hatch );
 
     return error ? 0 : 1;
@@ -2065,13 +2065,13 @@ int TEXTE_PCB::ReadTextePcbDescr( LINE_READER* aReader )
         line = aReader->Line();
         if( strnicmp( line, "$EndTEXTPCB", 11 ) == 0 )
             return 0;
-        if( strncmp( line, "Te", 2 ) == 0 ) /* Text line (first line for multi line texts */
+        if( strncmp( line, "Te", 2 ) == 0 ) // Text line (first line for multi line texts
         {
             ReadDelimitedText( text, line + 2, sizeof(text) );
             m_Text = FROM_UTF8( text );
             continue;
         }
-        if( strncmp( line, "nl", 2 ) == 0 ) /* next line of the current text */
+        if( strncmp( line, "nl", 2 ) == 0 ) // next line of the current text
         {
             ReadDelimitedText( text, line + 2, sizeof(text) );
             m_Text.Append( '\n' );

pcbnew/kicad_plugin.cpp

@@ -755,18 +755,14 @@ void KICAD_PLUGIN::loadSETUP()
         {
             BIU x = biuParse( line + SZ( "PadSize" ), &data );
             BIU y = biuParse( data );
-            /* @todo
+
-            g_Pad_Master.m_Size = wxSize( x, y );
+            bds.m_Pad_Master.SetSize( wxSize( x, y ) );
-            */
         }
 
         else if( TESTLINE( "PadDrill" ) )
         {
             BIU tmp = biuParse( line + SZ( "PadDrill" ) );
-            /* @todo
+            bds.m_Pad_Master.SetDrillSize( wxSize( tmp, tmp ) );
-            g_Pad_Master.m_Drill.x( tmp );
-            g_Pad_Master.m_Drill.y( tmp );
-            */
         }
 
         else if( TESTLINE( "Pad2MaskClearance" ) )
@@ -1102,11 +1098,10 @@ void KICAD_PLUGIN::loadPAD( MODULE* aModule )
             // chances are both were ASCII, but why take chances?
 
             pad->SetPadName( padname );
-            pad->SetShape( padshape );
+            pad->SetShape( PAD_SHAPE_T( padshape ) );
             pad->SetSize( wxSize( size_x, size_y ) );
             pad->SetDelta( wxSize( delta_x, delta_y ) );
             pad->SetOrientation( orient );
-            pad->ComputeShapeMaxRadius();
         }
 
         else if( TESTLINE( "Dr" ) )         // (Dr)ill
@@ -1118,7 +1113,8 @@ void KICAD_PLUGIN::loadPAD( MODULE* aModule )
             BIU drill_y = drill_x;
             BIU offs_x  = biuParse( data, &data );
             BIU offs_y  = biuParse( data, &data );
-            int drShape = PAD_CIRCLE;
+
+            PAD_SHAPE_T drShape = PAD_CIRCLE;
 
             data = strtok( (char*) data, delims );
             if( data )  // optional shape
@@ -1136,7 +1132,7 @@ void KICAD_PLUGIN::loadPAD( MODULE* aModule )
             }
 
             pad->SetDrillShape( drShape );
-            pad->SetOffset( wxSize( offs_x, offs_y ) );
+            pad->SetOffset( wxPoint( offs_x, offs_y ) );
             pad->SetDrillSize( wxSize( drill_x, drill_y ) );
         }
 
@@ -1145,8 +1141,8 @@ void KICAD_PLUGIN::loadPAD( MODULE* aModule )
             // e.g. "At SMD N 00888000"
             // sscanf( PtLine, "%s %s %X", BufLine, BufCar, &m_layerMask );
 
-            int attribute;
+            PAD_ATTR_T  attribute;
-            int layer_mask;
+            int         layer_mask;
 
             data = strtok( line + SZ( "At" ), delims );
 
@@ -1226,9 +1222,11 @@ void KICAD_PLUGIN::loadPAD( MODULE* aModule )
 
         else if( TESTLINE( "$EndPAD" ) )
         {
-            RotatePoint( &pad->m_Pos, aModule->GetOrientation() );
+            wxPoint padpos = pad->GetPosition();
 
-            pad->m_Pos += aModule->GetPosition();
+            RotatePoint( &padpos, aModule->GetOrientation() );
+
+            pad->SetPosition( padpos + aModule->GetPosition() );
 
             aModule->m_Pads.PushBack( pad.release() );
             return;     // preferred exit
@@ -2849,10 +2847,8 @@ void KICAD_PLUGIN::saveSETUP() const
     fprintf( m_fp, "TextModSize %s\n", fmtBIUSize( bds.m_ModuleTextSize ).c_str() );
     fprintf( m_fp, "TextModWidth %s\n", fmtBIU( bds.m_ModuleTextWidth ).c_str() );
 
-    /* @todo
+    fprintf( m_fp, "PadSize %s\n", fmtBIUSize( bds.m_Pad_Master.GetSize() ).c_str() );
-    fprintf( m_fp, "PadSize %d %d\n", g_Pad_Master.m_Size.x, g_Pad_Master.m_Size.y );
+    fprintf( m_fp, "PadDrill %s\n", fmtBIU( bds.m_Pad_Master.GetDrillSize().x ).c_str() );
-    fprintf( m_fp, "PadDrill %d\n", g_Pad_Master.m_Drill.x );
-    */
 
     fprintf( m_fp, "Pad2MaskClearance %s\n", fmtBIU( bds.m_SolderMaskMargin ).c_str() );
 
@@ -3138,7 +3134,7 @@ void KICAD_PLUGIN::savePAD( const D_PAD* me ) const
 
     fprintf( m_fp,  "Dr %s %s",
                     fmtBIU( me->GetDrillSize().x ).c_str(),
-                    fmtBIUSize( me->GetOffset() ).c_str() );
+                    fmtBIUPoint( me->GetOffset() ).c_str() );
 
     if( me->GetDrillShape() == PAD_OVAL )
     {

pcbnew/magnetic_tracks_functions.cpp

@@ -165,7 +165,7 @@ bool Magnetize( BOARD* m_Pcb, PCB_EDIT_FRAME* frame, int aCurrentTool, wxSize gr
             if( doCheckNet && currTrack && currTrack->GetNet() != pad->GetNet() )
                 return false;
 
-            *curpos = pad->m_Pos;
+            *curpos = pad->GetPosition();
             return true;
         }
     }

pcbnew/modedit.cpp

@@ -724,11 +724,13 @@ void FOOTPRINT_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
 
 void FOOTPRINT_EDIT_FRAME::Transform( MODULE* module, int transform )
 {
-    D_PAD*        pad = module->m_Pads;
+    D_PAD*          pad = module->m_Pads;
-    EDA_ITEM*     item = module->m_Drawings;
+    EDA_ITEM*       item = module->m_Drawings;
-    TEXTE_MODULE* textmod;
+    TEXTE_MODULE*   textmod;
-    EDGE_MODULE*  edgemod;
+    EDGE_MODULE*    edgemod;
-    double        angle = 900; // Necessary +- 900 (+- 90 degrees) )
+    wxPoint         pt;
+    wxSize          size;
+    double          angle = 900; // Necessary +- 900 (+- 90 degrees) )
 
     switch( transform )
     {
@@ -737,11 +739,20 @@ void FOOTPRINT_EDIT_FRAME::Transform( MODULE* module, int transform )
 
         for( ;  pad;  pad = pad->Next() )
         {
-            pad->SetPos0( pad->m_Pos );
+            pad->SetPos0( pad->GetPosition() );
-            pad->m_Orient -= angle;
+            pad->SetOrientation( pad->GetOrientation() - angle );
-            RotatePoint( &pad->m_Offset.x, &pad->m_Offset.y, angle );
+
-            EXCHG( pad->m_Size.x, pad->m_Size.y );
+            pt = pad->GetOffset();
-            RotatePoint( &pad->m_DeltaSize.x, &pad->m_DeltaSize.y, -angle );
+            RotatePoint( &pt, angle );
+            pad->SetOffset( pt );
+
+            size = pad->GetSize();
+            EXCHG( size.x, size.y );
+            pad->SetSize( size );
+
+            size = pad->GetDelta();
+            RotatePoint( &size.x, &size.y, -angle );
+            pad->SetDelta( size );
         }
 
         module->m_Reference->SetPos0( module->m_Reference->m_Pos );
@@ -778,13 +789,22 @@ void FOOTPRINT_EDIT_FRAME::Transform( MODULE* module, int transform )
     case ID_MODEDIT_MODULE_MIRROR:
         for( ;  pad;  pad = pad->Next() )
         {
-            NEGATE( pad->m_Pos.y );
+            pad->SetY( -pad->GetPosition().y );
-            NEGATE( pad->m_Pos0.y );
-            NEGATE( pad->m_Offset.y );
-            NEGATE( pad->m_DeltaSize.y );
 
-            if( pad->m_Orient )
+            pt = pad->GetPos0();
-                pad->m_Orient = 3600 - pad->m_Orient;
+            NEGATE( pt.y );
+            pad->SetPos0( pt );
+
+            pt = pad->GetOffset();
+            NEGATE( pt.y );
+            pad->SetOffset( pt );
+
+            size = pad->GetDelta();
+            NEGATE( size.y );
+            pad->SetDelta( size );
+
+            if( pad->GetOrientation() )
+                pad->SetOrientation( 3600 - pad->GetOrientation() );
         }
 
         // Reverse mirror of reference.

pcbnew/module_editor_frame.h

@@ -124,9 +124,9 @@ public:
     void ToPrinter( wxCommandEvent& event );
 
     /**
-     * Virtual function PrintPage
+     * Function PrintPage
-     * used to print a page
+     * is used to print a page. Prints the page pointed by ActiveScreen,
-     * Print the page pointed by ActiveScreen, set by the calling print function
+     * set by the calling print function.
      * @param aDC = wxDC given by the calling print function
      * @param aPrintMaskLayer = not used here
      * @param aPrintMirrorMode = not used here (Set when printing in mirror mode)
@@ -348,8 +348,8 @@ public:
 
     /**
      * Function DlgGlobalChange_PadSettings
-     * Function to change pad caracteristics for the given footprint
+     * changes pad caracteristics for the given footprint
-     * or all footprints which look like the given footprint
+     * or all footprints which look like the given footprint.
      * Options are set by the opened dialog.
      * @param aPad is the pattern. The given footprint is the parent of this pad
      */

pcbnew/move-drag_pads.cpp

@@ -1,3 +1,5 @@
+
+
 /**
  * @file move-drag_pads.cpp
  * @brief Edit footprint pads.
@@ -39,10 +41,10 @@ static void Abort_Move_Pad( EDA_DRAW_PANEL* Panel, wxDC* DC )
 
     pad->Draw( Panel, DC, GR_XOR );
     pad->ClearFlags();
-    pad->m_Pos   = Pad_OldPos;
+    pad->SetPosition( Pad_OldPos );
     pad->Draw( Panel, DC, GR_XOR );
 
-    /* Pad move in progress: the restore origin. */
+    // Pad move in progress: the restore origin.
     if( g_Drag_Pistes_On )
     {
         for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
@@ -76,7 +78,7 @@ static void Show_Pad_Move( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aPo
     if( aErase )
         pad->Draw( aPanel, aDC, GR_XOR );
 
-    pad->m_Pos = screen->GetCrossHairPosition();
+    pad->SetPosition( screen->GetCrossHairPosition() );
     pad->Draw( aPanel, aDC, GR_XOR );
 
     if( !g_Drag_Pistes_On )
@@ -91,12 +93,12 @@ static void Show_Pad_Move( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aPo
 
         if( g_DragSegmentList[ii].m_Pad_Start )
         {
-            Track->m_Start = pad->m_Pos;
+            Track->m_Start = pad->GetPosition();
         }
 
         if( g_DragSegmentList[ii].m_Pad_End )
         {
-            Track->m_End = pad->m_Pos;
+            Track->m_End = pad->GetPosition();
         }
 
         Track->Draw( aPanel, aDC, GR_XOR );
@@ -106,29 +108,31 @@ static void Show_Pad_Move( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aPo
 
 /* Load list of features for default pad selection.
  */
-void PCB_BASE_FRAME::Export_Pad_Settings( D_PAD* pt_pad )
+void PCB_BASE_FRAME::Export_Pad_Settings( D_PAD* aPad )
 {
-    if( pt_pad == NULL )
+    if( aPad == NULL )
         return;
 
-    pt_pad->DisplayInfo( this );
+    aPad->DisplayInfo( this );
 
-    g_Pad_Master.m_PadShape     = pt_pad->m_PadShape;
+    D_PAD& mp = GetDesignSettings().m_Pad_Master;
-    g_Pad_Master.m_Attribut     = pt_pad->m_Attribut;
-    g_Pad_Master.m_layerMask = pt_pad->m_layerMask;
-    g_Pad_Master.m_Orient = pt_pad->m_Orient -
-                            ( (MODULE*) pt_pad->GetParent() )->m_Orient;
-    g_Pad_Master.m_Size = pt_pad->m_Size;
-    g_Pad_Master.m_DeltaSize = pt_pad->m_DeltaSize;
-    pt_pad->ComputeShapeMaxRadius();
 
-    g_Pad_Master.m_Offset     = pt_pad->m_Offset;
+    mp.SetShape( aPad->GetShape() );
-    g_Pad_Master.m_Drill      = pt_pad->m_Drill;
+    mp.SetAttribute( aPad->GetAttribute() );
-    g_Pad_Master.m_DrillShape = pt_pad->m_DrillShape;
+    mp.SetLayerMask( aPad->GetLayerMask() );
+
+    mp.SetOrientation( aPad->GetOrientation() - aPad->GetParent()->GetOrientation() );
+
+    mp.SetSize( aPad->GetSize() );
+    mp.SetDelta( aPad->GetDelta() );
+
+    mp.SetOffset( aPad->GetOffset() );
+    mp.SetDrillSize( aPad->GetDrillSize() );
+    mp.SetDrillShape( aPad->GetDrillShape() );
 }
 
 
-/* Imports the new values of dimensions of the pad edge by pt_pad
+/* Imports the new values of dimensions of the pad edge by aPad
  * - Source: selected values of general characteristics
  * - Measurements are modified
  * - The position, names, and keys are not.
@@ -142,72 +146,77 @@ void PCB_BASE_FRAME::Import_Pad_Settings( D_PAD* aPad, bool aDraw )
         aPad->ClearFlags( DO_NOT_DRAW );
     }
 
-    aPad->m_PadShape = g_Pad_Master.m_PadShape;
+    D_PAD& mp = GetDesignSettings().m_Pad_Master;
-    aPad->m_layerMask = g_Pad_Master.m_layerMask;
-    aPad->m_Attribut = g_Pad_Master.m_Attribut;
-    aPad->m_Orient = g_Pad_Master.m_Orient + ( (MODULE*) aPad->GetParent() )->m_Orient;
-    aPad->m_Size = g_Pad_Master.m_Size;
-    aPad->m_DeltaSize  = wxSize( 0, 0 );
-    aPad->m_Offset     = g_Pad_Master.m_Offset;
-    aPad->m_Drill      = g_Pad_Master.m_Drill;
-    aPad->m_DrillShape = g_Pad_Master.m_DrillShape;
 
-    switch( g_Pad_Master.m_PadShape )
+    aPad->SetShape( mp.GetShape() );
+    aPad->SetLayerMask( mp.GetLayerMask() );
+    aPad->SetAttribute( mp.GetAttribute() );
+    aPad->SetOrientation( mp.GetOrientation() + aPad->GetParent()->GetOrientation() );
+    aPad->SetSize( mp.GetSize() );
+    aPad->SetDelta( wxSize( 0, 0 ) );
+    aPad->SetOffset( mp.GetOffset() );
+    aPad->SetDrillSize( mp.GetDrillSize() );
+    aPad->SetDrillShape( mp.GetDrillShape() );
+
+    switch( mp.GetShape() )
     {
     case PAD_TRAPEZOID:
-        aPad->m_DeltaSize = g_Pad_Master.m_DeltaSize;
+        aPad->SetDelta( mp.GetDelta() );
         break;
 
     case PAD_CIRCLE:
-        aPad->m_Size.y = aPad->m_Size.x;
+        // set size.y to size.x
+        aPad->SetSize( wxSize( aPad->GetSize().x, aPad->GetSize().x ) );
         break;
+
+    default:
+        ;
     }
 
-    switch( g_Pad_Master.m_Attribut & 0x7F )
+    switch( mp.GetAttribute() )
     {
     case PAD_SMD:
     case PAD_CONN:
-        aPad->m_Drill    = wxSize( 0, 0 );
+        aPad->SetDrillSize( wxSize( 0, 0 ) );
-        aPad->m_Offset.x = 0;
+        aPad->SetOffset( wxPoint( 0, 0 ) );
-        aPad->m_Offset.y = 0;
     }
 
-    aPad->ComputeShapeMaxRadius();
-
     if( aDraw )
         m_canvas->RefreshDrawingRect( aPad->GetBoundingBox() );
 
-    ( (MODULE*) aPad->GetParent() )->m_LastEdit_Time = time( NULL );
+    aPad->GetParent()->m_LastEdit_Time = time( NULL );
 }
 
 
 /* Add a pad on the selected module.
  */
-void PCB_BASE_FRAME::AddPad( MODULE* Module, bool draw )
+void PCB_BASE_FRAME::AddPad( MODULE* aModule, bool draw )
 {
-    wxString lastPadName;   // Last used pad name (pad num)
+    // Last used pad name (pad num)
-    lastPadName = g_Pad_Master.GetPadName();
+    wxString lastPadName = GetDesignSettings().m_Pad_Master.GetPadName();
 
     m_Pcb->m_Status_Pcb     = 0;
-    Module->m_LastEdit_Time = time( NULL );
+    aModule->m_LastEdit_Time = time( NULL );
 
-    D_PAD* Pad = new D_PAD( Module );
+    D_PAD* pad = new D_PAD( aModule );
 
-    /* Add the new pad to end of the module pad list. */
+    // Add the new pad to end of the module pad list.
-    Module->m_Pads.PushBack( Pad );
+    aModule->m_Pads.PushBack( pad );
 
-    /* Update the pad properties. */
+    // Update the pad properties.
-    Import_Pad_Settings( Pad, false );
+    Import_Pad_Settings( pad, false );
-    Pad->SetNetname( wxEmptyString );
+    pad->SetNetname( wxEmptyString );
 
-    Pad->m_Pos = GetScreen()->GetCrossHairPosition();
+    pad->SetPosition( GetScreen()->GetCrossHairPosition() );
 
     // Set the relative pad position
     // ( pad position for module orient, 0, and relative to the module position)
-    Pad->m_Pos0 = Pad->m_Pos - Module->m_Pos;
-    RotatePoint( &Pad->m_Pos0, -Module->m_Orient );
 
-    /* Automatically increment the current pad number. */
+    wxPoint pos0 = pad->GetPosition() - aModule->GetPosition();
+    RotatePoint( &pos0, -aModule->GetOrientation() );
+    pad->SetPos0( pos0 );
+
+    // Automatically increment the current pad number.
     long num    = 0;
     int  ponder = 1;
 
@@ -220,14 +229,15 @@ void PCB_BASE_FRAME::AddPad( MODULE* Module, bool draw )
 
     num++;  // Use next number for the new pad
     lastPadName << num;
-    Pad->SetPadName( lastPadName );
+    pad->SetPadName( lastPadName );
-    g_Pad_Master.SetPadName(lastPadName);
 
-    Module->CalculateBoundingBox();
+    GetDesignSettings().m_Pad_Master.SetPadName(lastPadName);
-    Pad->DisplayInfo( this );
+
+    aModule->CalculateBoundingBox();
+    pad->DisplayInfo( this );
 
     if( draw )
-        m_canvas->RefreshDrawingRect( Module->GetBoundingBox() );
+        m_canvas->RefreshDrawingRect( aModule->GetBoundingBox() );
 }
 
 
@@ -241,20 +251,20 @@ void PCB_BASE_FRAME::AddPad( MODULE* Module, bool draw )
  */
 void PCB_BASE_FRAME::DeletePad( D_PAD* aPad, bool aQuery )
 {
-    MODULE*  Module;
+    MODULE*  module;
 
     if( aPad == NULL )
         return;
 
-    Module = (MODULE*) aPad->GetParent();
+    module = (MODULE*) aPad->GetParent();
-    Module->m_LastEdit_Time = time( NULL );
+    module->m_LastEdit_Time = time( NULL );
 
     if( aQuery )
     {
         wxString msg;
         msg.Printf( _( "Delete Pad (module %s %s) " ),
-                    GetChars( Module->m_Reference->m_Text ),
+                    GetChars( module->m_Reference->m_Text ),
-                    GetChars( Module->m_Value->m_Text ) );
+                    GetChars( module->m_Value->m_Text ) );
 
         if( !IsOK( this, msg ) )
             return;
@@ -262,53 +272,54 @@ void PCB_BASE_FRAME::DeletePad( D_PAD* aPad, bool aQuery )
 
     m_Pcb->m_Status_Pcb = 0;
     aPad->DeleteStructure();
-    m_canvas->RefreshDrawingRect( Module->GetBoundingBox() );
+    m_canvas->RefreshDrawingRect( module->GetBoundingBox() );
-    Module->CalculateBoundingBox();
+    module->CalculateBoundingBox();
 
     OnModify();
 }
 
 
-/* Function to initialize the "move pad" command */
+// Function to initialize the "move pad" command
-void PCB_BASE_FRAME::StartMovePad( D_PAD* Pad, wxDC* DC )
+void PCB_BASE_FRAME::StartMovePad( D_PAD* aPad, wxDC* DC )
 {
-    if( Pad == NULL )
+    if( aPad == NULL )
         return;
 
-    s_CurrentSelectedPad = Pad;
+    s_CurrentSelectedPad = aPad;
-    Pad_OldPos = Pad->m_Pos;
+
-    Pad->DisplayInfo( this );
+    Pad_OldPos = aPad->GetPosition();
+
+    aPad->DisplayInfo( this );
     m_canvas->SetMouseCapture( Show_Pad_Move, Abort_Move_Pad );
 
-    /* Draw the pad  (SKETCH mode) */
+    // Draw the pad  (SKETCH mode)
-    Pad->Draw( m_canvas, DC, GR_XOR );
+    aPad->Draw( m_canvas, DC, GR_XOR );
-    Pad->SetFlags( IS_MOVED );
+    aPad->SetFlags( IS_MOVED );
-    Pad->Draw( m_canvas, DC, GR_XOR );
+    aPad->Draw( m_canvas, DC, GR_XOR );
 
-    /* Build the list of track segments to drag if the command is a drag pad*/
+    // Build the list of track segments to drag if the command is a drag pad
     if( g_Drag_Pistes_On )
-        Build_1_Pad_SegmentsToDrag( m_canvas, DC, Pad );
+        Build_1_Pad_SegmentsToDrag( m_canvas, DC, aPad );
     else
         EraseDragList();
 }
 
 
-/* Routine to place a moved pad. */
+// Routine to place a moved pad.
-void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC )
+void PCB_BASE_FRAME::PlacePad( D_PAD* aPad, wxDC* DC )
 {
     int     dX, dY;
     TRACK*  Track;
-    MODULE* Module;
 
-    if( Pad == NULL )
+    if( aPad == NULL )
         return;
 
-    Module = (MODULE*) Pad->GetParent();
+    MODULE* module = aPad->GetParent();
 
     ITEM_PICKER       picker( NULL, UR_CHANGED );
     PICKED_ITEMS_LIST pickList;
 
-    /* Save dragged track segments in undo list */
+    // Save dragged track segments in undo list
     for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
     {
         Track = g_DragSegmentList[ii].m_Segm;
@@ -324,34 +335,34 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC )
         pickList.PushItem( picker );
     }
 
-    /* Save old module and old items values */
+    // Save old module and old items values
-    wxPoint pad_curr_position = Pad->m_Pos;
+    wxPoint pad_curr_position = aPad->GetPosition();
 
-    Pad->m_Pos = Pad_OldPos;
+    aPad->SetPosition( Pad_OldPos );
 
     if( g_DragSegmentList.size() == 0 )
-        SaveCopyInUndoList( Module, UR_CHANGED );
+        SaveCopyInUndoList( module, UR_CHANGED );
     else
     {
-        picker.SetItem( Module );
+        picker.SetItem( module );
         pickList.PushItem( picker );
         SaveCopyInUndoList( pickList, UR_CHANGED );
     }
 
-    Pad->m_Pos = pad_curr_position;
+    aPad->SetPosition( pad_curr_position );
-    Pad->Draw( m_canvas, DC, GR_XOR );
+    aPad->Draw( m_canvas, DC, GR_XOR );
 
-    /* Redraw dragged track segments */
+    // Redraw dragged track segments
     for( unsigned ii = 0; ii < g_DragSegmentList.size(); ii++ )
     {
         Track = g_DragSegmentList[ii].m_Segm;
 
         // Set the new state
         if( g_DragSegmentList[ii].m_Pad_Start )
-            Track->m_Start = Pad->m_Pos;
+            Track->m_Start = aPad->GetPosition();
 
         if( g_DragSegmentList[ii].m_Pad_End )
-            Track->m_End = Pad->m_Pos;
+            Track->m_End = aPad->GetPosition();
 
         Track->SetState( IN_EDIT, OFF );
 
@@ -359,21 +370,23 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC )
             Track->Draw( m_canvas, DC, GR_OR );
     }
 
-    /* Compute local coordinates (i.e refer to Module position and for Module orient = 0) */
+    // Compute local coordinates (i.e refer to module position and for module orient = 0)
-    dX = Pad->m_Pos.x - Pad_OldPos.x;
+    dX = aPad->GetPosition().x - Pad_OldPos.x;
-    dY = Pad->m_Pos.y - Pad_OldPos.y;
+    dY = aPad->GetPosition().y - Pad_OldPos.y;
-    RotatePoint( &dX, &dY, -Module->m_Orient );
 
-    Pad->m_Pos0.x += dX;
+    RotatePoint( &dX, &dY, -module->GetOrientation() );
-    s_CurrentSelectedPad->m_Pos0.y += dY;
 
-    Pad->ClearFlags();
+    aPad->SetX0( dX + aPad->GetPos0().x );
+
+    s_CurrentSelectedPad->SetY0( dY + s_CurrentSelectedPad->GetPos0().y );
+
+    aPad->ClearFlags();
 
     if( DC )
-        Pad->Draw( m_canvas, DC, GR_OR );
+        aPad->Draw( m_canvas, DC, GR_OR );
 
-    Module->CalculateBoundingBox();
+    module->CalculateBoundingBox();
-    Module->m_LastEdit_Time = time( NULL );
+    module->m_LastEdit_Time = time( NULL );
 
     EraseDragList();
 
@@ -383,33 +396,43 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC )
 }
 
 
-/* Rotate selected pad 90 degrees.
+// Rotate selected pad 90 degrees.
- */
+void PCB_BASE_FRAME::RotatePad( D_PAD* aPad, wxDC* DC )
-void PCB_BASE_FRAME::RotatePad( D_PAD* Pad, wxDC* DC )
 {
-    MODULE* Module;
+    if( aPad == NULL )
-
-    if( Pad == NULL )
         return;
 
-    Module = (MODULE*) Pad->GetParent();
+    MODULE* module = aPad->GetParent();
-    Module->m_LastEdit_Time = time( NULL );
+
+    module->m_LastEdit_Time = time( NULL );
 
     OnModify();
 
     if( DC )
-        Module->Draw( m_canvas, DC, GR_XOR );
+        module->Draw( m_canvas, DC, GR_XOR );
 
-    EXCHG( Pad->m_Size.x, Pad->m_Size.y );
+    wxSize  sz = aPad->GetSize();
-    EXCHG( Pad->m_Drill.x, Pad->m_Drill.y );
+    EXCHG( sz.x, sz.y );
-    EXCHG( Pad->m_Offset.x, Pad->m_Offset.y );
+    aPad->SetSize( sz );
-    Pad->m_Offset.y = -Pad->m_Offset.y;
 
-    EXCHG( Pad->m_DeltaSize.x, Pad->m_DeltaSize.y );
+    sz = aPad->GetDrillSize();
-    Pad->m_DeltaSize.x = -Pad->m_DeltaSize.x;
+    EXCHG( sz.x, sz.y );
-    Module->CalculateBoundingBox();
+    aPad->SetDrillSize( sz );
-    Pad->DisplayInfo( this );
+
+    wxPoint pt = aPad->GetOffset();
+    EXCHG( pt.x, pt.y );
+    aPad->SetOffset( pt );
+
+    aPad->SetOffset( wxPoint( aPad->GetOffset().x, -aPad->GetOffset().y ) );
+
+    sz = aPad->GetDelta();
+    EXCHG( sz.x, sz.y );
+    sz.x = -sz.x;
+    aPad->SetDelta( sz );
+
+    module->CalculateBoundingBox();
+    aPad->DisplayInfo( this );
 
     if( DC )
-        Module->Draw( m_canvas, DC, GR_OR );
+        module->Draw( m_canvas, DC, GR_OR );
 }

pcbnew/muonde.cpp

@@ -164,7 +164,7 @@ void PCB_EDIT_FRAME::Begin_Self( wxDC* DC )
 
     Self_On = 1;
 
-    /* Update the initial coordinates. */
+    // Update the initial coordinates.
     GetScreen()->m_O_Curseur = GetScreen()->GetCrossHairPosition();
     UpdateStatusBar();
 
@@ -175,7 +175,7 @@ void PCB_EDIT_FRAME::Begin_Self( wxDC* DC )
 
 MODULE* PCB_EDIT_FRAME::Genere_Self( wxDC* DC )
 {
-    D_PAD*   PtPad;
+    D_PAD*   pad;
     int      ll;
     wxString msg;
 
@@ -254,27 +254,28 @@ MODULE* PCB_EDIT_FRAME::Genere_Self( wxDC* DC )
     }
 
     // Place a pad on each end of coil.
-    PtPad = new D_PAD( module );
+    pad = new D_PAD( module );
 
-    module->m_Pads.PushFront( PtPad );
+    module->m_Pads.PushFront( pad );
 
-    PtPad->SetPadName( wxT( "1" ) );
+    pad->SetPadName( wxT( "1" ) );
-    PtPad->m_Pos    = Mself.m_End;
+    pad->SetPosition( Mself.m_End );
-    PtPad->m_Pos0   = PtPad->m_Pos - module->m_Pos;
+    pad->SetPos0( pad->GetPosition() - module->GetPosition() );
-    PtPad->m_Size.x = PtPad->m_Size.y = Mself.m_Width;
-    PtPad->m_layerMask = GetLayerMask( module->GetLayer() );
-    PtPad->m_Attribut     = PAD_SMD;
-    PtPad->m_PadShape     = PAD_CIRCLE;
-    PtPad->ComputeShapeMaxRadius();
 
-    D_PAD* newpad = new D_PAD( *PtPad );
+    pad->SetSize( wxSize( Mself.m_Width, Mself.m_Width ) );
 
-    module->m_Pads.Insert( newpad, PtPad->Next() );
+    pad->SetLayerMask( GetLayerMask( module->GetLayer() ) );
+    pad->SetAttribute( PAD_SMD );
+    pad->SetShape( PAD_CIRCLE );
 
-    PtPad = newpad;
+    D_PAD* newpad = new D_PAD( *pad );
-    PtPad->SetPadName( wxT( "2" ) );
+
-    PtPad->m_Pos  = Mself.m_Start;
+    module->m_Pads.Insert( newpad, pad->Next() );
-    PtPad->m_Pos0 = PtPad->m_Pos - module->m_Pos;
+
+    pad = newpad;
+    pad->SetPadName( wxT( "2" ) );
+    pad->SetPosition( Mself.m_Start );
+    pad->SetPos0( pad->GetPosition() - module->GetPosition() );
 
     // Modify text positions.
     module->DisplayInfo( this );
@@ -381,7 +382,7 @@ int BuildCornersList_S_Shape( std::vector <wxPoint>& aBuffer,
  */
     wxSize size;
 
-    // This scale factor adjust the arc lenght to handle
+    // This scale factor adjusts the arc length to handle
     // the arc to segment approximation.
     // because we use SEGM_COUNT_PER_360DEG segment to approximate a circle,
     // the trace len must be corrected when calculated using arcs
@@ -468,7 +469,7 @@ int BuildCornersList_S_Shape( std::vector <wxPoint>& aBuffer,
         aBuffer.push_back( pt );
     }
 
-    /* Create shape. */
+    // Create shape.
     int ii;
     int sign = 1;
     segm_count += 1;    // increase segm_count to create the last half_size segment
@@ -477,7 +478,7 @@ int BuildCornersList_S_Shape( std::vector <wxPoint>& aBuffer,
     {
         int arc_angle;
 
-        if( ii & 1 ) /* odd order arcs are greater than 0 */
+        if( ii & 1 ) // odd order arcs are greater than 0
             sign = -1;
         else
             sign = 1;
@@ -548,21 +549,22 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveBasicShape( const wxString& name, int pad_c
 
     module->m_Reference->m_Thickness  = DEFAULT_SIZE / 4;
 
-    /* Create 2 pads used in gaps and stubs.
+    // Create 2 pads used in gaps and stubs.  The gap is between these 2 pads
-     *  The gap is between these 2 pads
+    // the stub is the pad 2
-     * the stub is the pad 2
-     */
     while( pad_count-- )
     {
         D_PAD* pad = new D_PAD( module );
 
         module->m_Pads.PushFront( pad );
 
-        pad->m_Size.x    = pad->m_Size.y = GetBoard()->GetCurrentTrackWidth();
+        int tw = GetBoard()->GetCurrentTrackWidth();
-        pad->m_Pos       = module->m_Pos;
+        pad->SetSize( wxSize( tw, tw ) );
-        pad->m_PadShape  = PAD_RECT;
+
-        pad->m_Attribut  = PAD_SMD;
+        pad->SetPosition( module->GetPosition() );
-        pad->m_layerMask = LAYER_FRONT;
+        pad->SetShape( PAD_RECT );
+        pad->SetAttribute( PAD_SMD );
+        pad->SetLayerMask( LAYER_FRONT );
+
         Line.Printf( wxT( "%d" ), pad_num );
         pad->SetPadName( Line );
         pad_num++;
@@ -581,7 +583,7 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveComponent( int shape_type )
     int      pad_count = 2;
     int      angle     = 0;
 
-    /* Enter the size of the gap or stub*/
+    // Enter the size of the gap or stub
     int      gap_size = GetBoard()->GetCurrentTrackWidth();
 
     switch( shape_type )
@@ -662,57 +664,61 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveComponent( int shape_type )
     switch( shape_type )
     {
     case 0:     //Gap :
-        oX = pad->m_Pos0.x = -( gap_size + pad->m_Size.x ) / 2;
+        oX = -( gap_size + pad->GetSize().x ) / 2;
-        pad->m_Pos.x += pad->m_Pos0.x;
+        pad->SetX0( oX );
+
+        pad->SetX( pad->GetPos0().x + pad->GetPosition().x );
+
         pad = pad->Next();
-        pad->m_Pos0.x = oX + gap_size + pad->m_Size.x;
+
-        pad->m_Pos.x += pad->m_Pos0.x;
+        pad->SetX0( oX + gap_size + pad->GetSize().x );
+        pad->SetX( pad->GetPos0().x + pad->GetPosition().x );
         break;
 
     case 1:     //Stub :
         pad->SetPadName( wxT( "1" ) );
         pad = pad->Next();
-        pad->m_Pos0.y = -( gap_size + pad->m_Size.y ) / 2;
+        pad->SetY0( -( gap_size + pad->GetSize().y ) / 2 );
-        pad->m_Size.y = gap_size;
+        pad->SetSize( wxSize( pad->GetSize().x, gap_size ) );
-        pad->m_Pos.y += pad->m_Pos0.y;
+        pad->SetY( pad->GetPos0().y + pad->GetPosition().y );
         break;
 
     case 2:     // Arc Stub created by a polygonal approach:
-    {
-        EDGE_MODULE* edge = new EDGE_MODULE( module );
-        module->m_Drawings.PushFront( edge );
-
-        edge->SetShape( S_POLYGON );
-        edge->SetLayer( LAYER_N_FRONT );
-
-        int numPoints = angle / 50 + 3;     // Note: angles are in 0.1 degrees
-        std::vector<wxPoint> polyPoints = edge->GetPolyPoints();
-        polyPoints.reserve( numPoints );
-
-        edge->m_Start0.y = -pad->m_Size.y / 2;
-
-        polyPoints.push_back( wxPoint( 0, 0 ) );
-
-        int theta = -angle / 2;
-
-        for( int ii = 1; ii<numPoints - 1; ii++ )
         {
-            wxPoint pt( 0, -gap_size );
+            EDGE_MODULE* edge = new EDGE_MODULE( module );
+            module->m_Drawings.PushFront( edge );
 
-            RotatePoint( &pt.x, &pt.y, theta );
+            edge->SetShape( S_POLYGON );
+            edge->SetLayer( LAYER_N_FRONT );
 
-            polyPoints.push_back( pt );
+            int numPoints = angle / 50 + 3;     // Note: angles are in 0.1 degrees
+            std::vector<wxPoint> polyPoints = edge->GetPolyPoints();
+            polyPoints.reserve( numPoints );
 
-            theta += 50;
+            edge->m_Start0.y = -pad->GetSize().y / 2;
 
-            if( theta > angle / 2 )
+            polyPoints.push_back( wxPoint( 0, 0 ) );
-                theta = angle / 2;
+
+            int theta = -angle / 2;
+
+            for( int ii = 1; ii<numPoints - 1; ii++ )
+            {
+                wxPoint pt( 0, -gap_size );
+
+                RotatePoint( &pt.x, &pt.y, theta );
+
+                polyPoints.push_back( pt );
+
+                theta += 50;
+
+                if( theta > angle / 2 )
+                    theta = angle / 2;
+            }
+
+            // Close the polygon:
+            polyPoints.push_back( polyPoints[0] );
         }
-
+        break;
-        // Close the polygon:
-        polyPoints.push_back( polyPoints[0] );
-    }
-    break;
 
     default:
         break;
@@ -873,7 +879,7 @@ void WinEDA_SetParamShapeFrame::ReadDataShapeDescr( wxCommandEvent& event )
 
     FILTER_READER reader( fileReader );
 
-    SetLocaleTo_C_standard();
+    LOCALE_IO   toggle;
 
     while( reader.ReadLine() )
     {
@@ -920,8 +926,6 @@ void WinEDA_SetParamShapeFrame::ReadDataShapeDescr( wxCommandEvent& event )
         }
     }
 
-    SetLocaleTo_Default();       // revert to the current locale
-
     ShapeScaleX *= unitconv;
     ShapeScaleY *= unitconv;
 
@@ -973,12 +977,12 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape()
     module = Create_MuWaveBasicShape( cmp_name, pad_count );
     pad1   = module->m_Pads;
 
-    pad1->m_Pos0.x = -ShapeSize.x / 2;
+    pad1->SetX0( -ShapeSize.x / 2 );
-    pad1->m_Pos.x += pad1->m_Pos0.x;
+    pad1->SetX( pad1->GetPos0().x + pad1->GetPosition().x );
 
     pad2 = (D_PAD*) pad1->Next();
-    pad2->m_Pos0.x = pad1->m_Pos0.x + ShapeSize.x;
+    pad2->SetX0( pad1->GetPos0().x + ShapeSize.x );
-    pad2->m_Pos.x += pad2->m_Pos0.x;
+    pad2->SetX( pad2->GetPos0().x + pad2->GetPosition().x );
 
     edge = new EDGE_MODULE( module );
 
@@ -991,13 +995,13 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape()
     polyPoints.reserve( 2 * PolyEdges.size() + 2 );
 
     // Init start point coord:
-    polyPoints.push_back( wxPoint( pad1->m_Pos0.x, 0 ) );
+    polyPoints.push_back( wxPoint( pad1->GetPos0().x, 0 ) );
 
     wxPoint first_coordinate, last_coordinate;
 
     for( unsigned ii = 0; ii < PolyEdges.size(); ii++ )  // Copy points
     {
-        last_coordinate.x = wxRound( PolyEdges[ii] * ShapeScaleX ) + pad1->m_Pos0.x;
+        last_coordinate.x = wxRound( PolyEdges[ii] * ShapeScaleX ) + pad1->GetPos0().x;
         last_coordinate.y = -wxRound( PolyEdges[ii] * ShapeScaleY );
         polyPoints.push_back( last_coordinate );
     }
@@ -1008,16 +1012,19 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape()
     {
     case 0:     // Single
     case 2:     // Single mirrored
+
         // Init end point coord:
-        pad2->m_Pos0.x = last_coordinate.x;
+        pad2->SetX0( last_coordinate.x );
         polyPoints.push_back( wxPoint( last_coordinate.x, 0 ) );
 
-        pad1->m_Size.x = pad1->m_Size.y = ABS( first_coordinate.y );
+        pad1->SetSize( wxSize( ABS( first_coordinate.y ), ABS( first_coordinate.y ) ) );
-        pad2->m_Size.x = pad2->m_Size.y = ABS( last_coordinate.y );
+        pad2->SetSize( wxSize( ABS( last_coordinate.y ),  ABS( last_coordinate.y ) ) );
-        pad1->m_Pos0.y = first_coordinate.y / 2;
+
-        pad2->m_Pos0.y = last_coordinate.y / 2;
+        pad1->SetY0( first_coordinate.y / 2 );
-        pad1->m_Pos.y  = pad1->m_Pos0.y + module->m_Pos.y;
+        pad2->SetY0( last_coordinate.y / 2 );
-        pad2->m_Pos.y  = pad2->m_Pos0.y + module->m_Pos.y;
+
+        pad1->SetY( pad1->GetPos0().y + module->GetPosition().y );
+        pad2->SetY( pad2->GetPos0().y + module->GetPosition().y );
         break;
 
     case 1:     // Symmetric
@@ -1030,8 +1037,8 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape()
             polyPoints.push_back( pt );
         }
 
-        pad1->m_Size.x = pad1->m_Size.y = 2 * ABS( first_coordinate.y );
+        pad1->SetSize( wxSize( 2 * ABS( first_coordinate.y ), 2 * ABS( first_coordinate.y ) ) );
-        pad2->m_Size.x = pad2->m_Size.y = 2 * ABS( last_coordinate.y );
+        pad2->SetSize( wxSize( 2 * ABS( last_coordinate.y ),  2 * ABS( last_coordinate.y ) ) );
         break;
     }
 
@@ -1043,22 +1050,22 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape()
 }
 
 
-void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* Module )
+void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* aModule )
 {
     int      gap_size, oX;
     D_PAD*   pad, * next_pad;
     wxString msg;
 
-    if( Module == NULL )
+    if( aModule == NULL )
         return;
 
-    /* Test if module is a gap type (name begins with GAP, and has 2 pads). */
+    // Test if module is a gap type (name begins with GAP, and has 2 pads).
-    msg = Module->m_Reference->m_Text.Left( 3 );
+    msg = aModule->m_Reference->m_Text.Left( 3 );
 
     if( msg != wxT( "GAP" ) )
         return;
 
-    pad = Module->m_Pads;
+    pad = aModule->m_Pads;
 
     if( pad == NULL )
     {
@@ -1074,12 +1081,12 @@ void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* Module )
         return;
     }
 
-    Module->Draw( m_canvas, DC, GR_XOR );
+    aModule->Draw( m_canvas, DC, GR_XOR );
 
-    /* Calculate the current dimension. */
+    // Calculate the current dimension.
-    gap_size = next_pad->m_Pos0.x - pad->m_Pos0.x - pad->m_Size.x;
+    gap_size = next_pad->GetPos0().x - pad->GetPos0().x - pad->GetSize().x;
 
-    /* Entrer the desired length of the gap. */
+    // Entrer the desired length of the gap.
     msg = ReturnStringFromValue( g_UserUnit, gap_size, GetScreen()->GetInternalUnits() );
     wxTextEntryDialog dlg( this, _( "Gap:" ), _( "Create Microwave Gap" ), msg );
 
@@ -1089,22 +1096,33 @@ void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* Module )
     msg = dlg.GetValue();
     gap_size = ReturnValueFromString( g_UserUnit, msg, GetScreen()->GetInternalUnits() );
 
-    /* Updating sizes of pads forming the gap. */
+    // Updating sizes of pads forming the gap.
-    pad->m_Size.x = pad->m_Size.y = GetBoard()->GetCurrentTrackWidth();
+    int tw = GetBoard()->GetCurrentTrackWidth();
-    pad->m_Pos0.y = 0;
+    pad->SetSize( wxSize( tw, tw ) );
-    oX = pad->m_Pos0.x = -( (gap_size + pad->m_Size.x) / 2 );
-    pad->m_Pos.x = pad->m_Pos0.x + Module->m_Pos.x;
-    pad->m_Pos.y = pad->m_Pos0.y + Module->m_Pos.y;
-    RotatePoint( &pad->m_Pos.x, &pad->m_Pos.y,
-                 Module->m_Pos.x, Module->m_Pos.y, Module->m_Orient );
 
-    next_pad->m_Size.x = next_pad->m_Size.y = GetBoard()->GetCurrentTrackWidth();
+    pad->SetY0( 0 );
-    next_pad->m_Pos0.y = 0;
+    oX = -( gap_size + pad->GetSize().x ) / 2;
-    next_pad->m_Pos0.x = oX + gap_size + next_pad->m_Size.x;
+    pad->SetX0( oX );
-    next_pad->m_Pos.x  = next_pad->m_Pos0.x + Module->m_Pos.x;
-    next_pad->m_Pos.y  = next_pad->m_Pos0.y + Module->m_Pos.y;
-    RotatePoint( &next_pad->m_Pos.x, &next_pad->m_Pos.y,
-                 Module->m_Pos.x, Module->m_Pos.y, Module->m_Orient );
 
-    Module->Draw( m_canvas, DC, GR_OR );
+    wxPoint padpos = pad->GetPos0() + aModule->GetPosition();
+
+    RotatePoint( &padpos.x, &padpos.y,
+                 aModule->m_Pos.x, aModule->m_Pos.y, aModule->GetOrientation() );
+
+    pad->SetPosition( padpos );
+
+    tw = GetBoard()->GetCurrentTrackWidth();
+    next_pad->SetSize( wxSize( tw, tw ) );
+
+    next_pad->SetY0( 0 );
+    next_pad->SetX0( oX + gap_size + next_pad->GetSize().x );
+
+    padpos = next_pad->GetPos0() + aModule->GetPosition();
+
+    RotatePoint( &padpos.x, &padpos.y,
+                 aModule->m_Pos.x, aModule->m_Pos.y, aModule->GetOrientation() );
+
+    next_pad->SetPosition( padpos );
+
+    aModule->Draw( m_canvas, DC, GR_OR );
 }

pcbnew/pcbnew_config.cpp

@@ -219,57 +219,18 @@ void PCB_EDIT_FRAME::SaveProjectSettings()
 PARAM_CFG_ARRAY PCB_EDIT_FRAME::GetProjectFileParameters()
 {
     PARAM_CFG_ARRAY         pca;
-    BOARD_DESIGN_SETTINGS&  bds = GetBoard()->GetDesignSettings();
 
     pca.push_back( new PARAM_CFG_FILENAME( wxT( "LibDir" ),&g_UserLibDirBuffer,
                                                            GROUPLIB ) );
     pca.push_back( new PARAM_CFG_LIBNAME_LIST( wxT( "LibName" ),
                                                                &g_LibraryNames,
                                                                GROUPLIB ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "PadDrlX" ), &g_Pad_Master.m_Drill.x,
-                                                      320, 0, 0x7FFF ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "PadDimH" ), &g_Pad_Master.m_Size.x,
-                                                      550, 0, 0x7FFF ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "PadDimV" ), &g_Pad_Master.m_Size.y,
-                                                      550, 0, 0x7FFF ) );
 
-    pca.push_back( new PARAM_CFG_INT( wxT( "BoardThickness" ),
-                                                      &bds.m_BoardThickness,
-                                                      630, 0, 0xFFFF ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtPcbV" ),
-                                                      &bds.m_PcbTextSize.y,
-                                                      600, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtPcbH" ),
-                                                      &bds.m_PcbTextSize.x,
-                                                      600, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtModV" ), &bds.m_ModuleTextSize.y,
-                                                      500, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtModH" ), &bds.m_ModuleTextSize.x,
-                                                      500, TEXTS_MIN_SIZE, TEXTS_MAX_SIZE ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtModW" ), &bds.m_ModuleTextWidth,
-                                                      100, 1, TEXTS_MAX_WIDTH ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "VEgarde" ),
-                                                      &bds.m_SolderMaskMargin,
-                                                      100, 0, 10000 ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "DrawLar" ),
-                                                      &bds.m_DrawSegmentWidth,
-                                                      120, 0, 0xFFFF ) );
-
-    pca.push_back( new PARAM_CFG_INT( wxT( "EdgeLar" ),
-                                                      &bds.m_EdgeSegmentWidth,
-                                                      120, 0, 0xFFFF ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "TxtLar" ),
-                                                      &bds.m_PcbTextWidth,
-                                                      120, 0, 0xFFFF ) );
-    pca.push_back( new PARAM_CFG_INT( wxT( "MSegLar" ), &bds.m_ModuleSegmentWidth,
-                                                      120, 0, 0xFFFF ) );
     pca.push_back( new PARAM_CFG_FILENAME( wxT( "LastNetListRead" ),
                                                            &m_lastNetListRead ) );
+
+    GetBoard()->GetDesignSettings().AppendConfigs( &pca );
+
     return pca;
 }
 

pcbnew/plot_rtn.cpp

@@ -3,29 +3,29 @@
  * @brief Common plot routines.
  */
 
-#include "fctsys.h"
+#include <fctsys.h>
-#include "common.h"
+#include <common.h>
-#include "plot_common.h"
+#include <plot_common.h>
-#include "base_struct.h"
+#include <base_struct.h>
-#include "drawtxt.h"
+#include <drawtxt.h>
-#include "confirm.h"
+#include <confirm.h>
-#include "trigo.h"
+#include <trigo.h>
-#include "wxBasePcbFrame.h"
+#include <wxBasePcbFrame.h>
-#include "pcbcommon.h"
+#include <pcbcommon.h>
-#include "macros.h"
+#include <macros.h>
 
-#include "class_board.h"
+#include <class_board.h>
-#include "class_module.h"
+#include <class_module.h>
-#include "class_track.h"
+#include <class_track.h>
-#include "class_edge_mod.h"
+#include <class_edge_mod.h>
-#include "class_pcb_text.h"
+#include <class_pcb_text.h>
-#include "class_zone.h"
+#include <class_zone.h>
-#include "class_drawsegment.h"
+#include <class_drawsegment.h>
-#include "class_mire.h"
+#include <class_mire.h>
-#include "class_dimension.h"
+#include <class_dimension.h>
 
-#include "pcbnew.h"
+#include <pcbnew.h>
-#include "pcbplot.h"
+#include <pcbplot.h>
 
 static void Plot_Edges_Modules( PLOTTER* plotter, BOARD* pcb, int aLayerMask,
                                 EDA_DRAW_MODE_T trace_mode );
@@ -45,28 +45,27 @@ void PCB_BASE_FRAME::PlotSilkScreen( PLOTTER* plotter, int aLayerMask, EDA_DRAW_
 {
     bool          trace_val, trace_ref;
     TEXTE_MODULE* pt_texte;
-    EDA_ITEM*     PtStruct;
 
-    /* Plot edge layer and graphic items */
+    // Plot edge layer and graphic items
 
-    for( PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Next() )
+    for( EDA_ITEM*  item = m_Pcb->m_Drawings;  item;  item = item->Next() )
     {
-        switch( PtStruct->Type() )
+        switch( item->Type() )
         {
         case PCB_LINE_T:
-            PlotDrawSegment( plotter, (DRAWSEGMENT*) PtStruct, aLayerMask, trace_mode );
+            PlotDrawSegment( plotter, (DRAWSEGMENT*) item, aLayerMask, trace_mode );
             break;
 
         case PCB_TEXT_T:
-            PlotTextePcb( plotter, (TEXTE_PCB*) PtStruct, aLayerMask, trace_mode );
+            PlotTextePcb( plotter, (TEXTE_PCB*) item, aLayerMask, trace_mode );
             break;
 
         case PCB_DIMENSION_T:
-            PlotDimension( plotter, (DIMENSION*) PtStruct, aLayerMask, trace_mode );
+            PlotDimension( plotter, (DIMENSION*) item, aLayerMask, trace_mode );
             break;
 
         case PCB_TARGET_T:
-            PlotPcbTarget( plotter, (PCB_TARGET*) PtStruct, aLayerMask, trace_mode );
+            PlotPcbTarget( plotter, (PCB_TARGET*) item, aLayerMask, trace_mode );
             break;
 
         case PCB_MARKER_T:
@@ -78,10 +77,10 @@ void PCB_BASE_FRAME::PlotSilkScreen( PLOTTER* plotter, int aLayerMask, EDA_DRAW_
         }
     }
 
-    /* Plot footprint outlines : */
+    // Plot footprint outlines :
     Plot_Edges_Modules( plotter, m_Pcb, aLayerMask, trace_mode );
 
-    /* Plot pads (creates pads outlines, for pads on silkscreen layers) */
+    // Plot pads (creates pads outlines, for pads on silkscreen layers)
     int layersmask_plotpads = aLayerMask;
     // Calculate the mask layers of allowed layers for pads
 
@@ -94,43 +93,43 @@ void PCB_BASE_FRAME::PlotSilkScreen( PLOTTER* plotter, int aLayerMask, EDA_DRAW_
         {
             for( D_PAD * pad = Module->m_Pads; pad != NULL; pad = pad->Next() )
             {
-                /* See if the pad is on this layer */
+                // See if the pad is on this layer
-                if( (pad->m_layerMask & layersmask_plotpads) == 0 )
+                if( (pad->GetLayerMask() & layersmask_plotpads) == 0 )
                     continue;
 
                 wxPoint shape_pos = pad->ReturnShapePos();
 
-                switch( pad->m_PadShape & 0x7F )
+                switch( pad->GetShape() )
                 {
                 case PAD_CIRCLE:
-                    plotter->flash_pad_circle( shape_pos, pad->m_Size.x, LINE );
+                    plotter->flash_pad_circle( shape_pos, pad->GetSize().x, LINE );
                     break;
 
                 case PAD_OVAL:
-                    plotter->flash_pad_oval( shape_pos, pad->m_Size, pad->m_Orient, LINE );
+                    plotter->flash_pad_oval( shape_pos, pad->GetSize(), pad->GetOrientation(), LINE );
                     break;
 
                 case PAD_TRAPEZOID:
-                {
+                    {
-                    wxPoint coord[4];
+                        wxPoint coord[4];
-                    pad->BuildPadPolygon( coord, wxSize(0,0), 0 );
+                        pad->BuildPadPolygon( coord, wxSize(0,0), 0 );
-                    plotter->flash_pad_trapez( shape_pos, coord, pad->m_Orient, LINE );
+                        plotter->flash_pad_trapez( shape_pos, coord, pad->GetOrientation(), LINE );
+                    }
                     break;
-                }
 
                 case PAD_RECT:
                 default:
-                    plotter->flash_pad_rect( shape_pos, pad->m_Size, pad->m_Orient, LINE );
+                    plotter->flash_pad_rect( shape_pos, pad->GetSize(), pad->GetOrientation(), LINE );
                     break;
                 }
             }
         }
     }
 
-    /* Plot footprints fields (ref, value ...) */
+    // Plot footprints fields (ref, value ...)
     for( MODULE* Module = m_Pcb->m_Modules; Module; Module = Module->Next() )
     {
-        /* see if we want to plot VALUE and REF fields */
+        // see if we want to plot VALUE and REF fields
         trace_val = g_PcbPlotOptions.m_PlotValue;
         trace_ref = g_PcbPlotOptions.m_PlotReference;
 
@@ -174,7 +173,7 @@ module\n %s's \"value\" text." ),
         if( !text->IsVisible() && !g_PcbPlotOptions.m_PlotInvisibleTexts )
             trace_val = false;
 
-        /* Plot text fields, if allowed */
+        // Plot text fields, if allowed
         if( trace_ref )
             PlotTextModule( plotter, Module->m_Reference, trace_mode );
 
@@ -215,7 +214,7 @@ for module\n %s's \"module text\" text of %s." ),
         }
     }
 
-    /* Plot filled areas */
+    // Plot filled areas
     for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
     {
         ZONE_CONTAINER* edge_zone = m_Pcb->GetArea( ii );
@@ -244,7 +243,7 @@ static void PlotTextModule( PLOTTER* plotter, TEXTE_MODULE* pt_texte, EDA_DRAW_M
     wxPoint pos;
     int     orient, thickness;
 
-    /* calculate some text parameters :*/
+    // calculate some text parameters :
     size = pt_texte->m_Size;
     pos  = pt_texte->m_Pos;
 
@@ -360,7 +359,7 @@ void PlotPcbTarget( PLOTTER* plotter, PCB_TARGET* aMire, int aLayerMask,
 }
 
 
-/* Plot footprints graphic items (outlines) */
+// Plot footprints graphic items (outlines)
 void Plot_Edges_Modules( PLOTTER* plotter, BOARD* pcb, int aLayerMask, EDA_DRAW_MODE_T trace_mode )
 {
     for( MODULE* module = pcb->m_Modules; module; module = module->Next() )
@@ -381,7 +380,7 @@ void Plot_Edges_Modules( PLOTTER* plotter, BOARD* pcb, int aLayerMask, EDA_DRAW_
 }
 
 
-/** Plot a graphic item (outline) relative to a footprint */
+//* Plot a graphic item (outline) relative to a footprint
 void Plot_1_EdgeModule( PLOTTER* plotter, EDGE_MODULE* aEdge, EDA_DRAW_MODE_T trace_mode, int masque_layer )
 {
     int     type_trace;         // Type of item to plot.
@@ -419,7 +418,7 @@ void Plot_1_EdgeModule( PLOTTER* plotter, EDGE_MODULE* aEdge, EDA_DRAW_MODE_T tr
             double endAngle = startAngle + aEdge->GetAngle();
 
             if ( ( g_PcbPlotOptions.GetPlotFormat() == PLOT_FORMAT_DXF ) &&
-    	       ( masque_layer & ( SILKSCREEN_LAYER_BACK | DRAW_LAYER | COMMENT_LAYER ) ) )
+               ( masque_layer & ( SILKSCREEN_LAYER_BACK | DRAW_LAYER | COMMENT_LAYER ) ) )
                 plotter->thick_arc( pos,
                                 -startAngle,
                                 -endAngle,
@@ -471,7 +470,7 @@ void Plot_1_EdgeModule( PLOTTER* plotter, EDGE_MODULE* aEdge, EDA_DRAW_MODE_T tr
 }
 
 
-/* Plot a PCB Text, i;e. a text found on a copper or technical layer */
+// Plot a PCB Text, i;e. a text found on a copper or technical layer
 void PlotTextePcb( PLOTTER* plotter, TEXTE_PCB* pt_texte, int aLayerMask,
                    EDA_DRAW_MODE_T trace_mode )
 {
@@ -791,7 +790,7 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
         }
     }
 
-    /* Draw footprint shapes without pads (pads will plotted later) */
+    // Draw footprint shapes without pads (pads will plotted later)
     for( MODULE* module = m_Pcb->m_Modules; module; module = module->Next() )
     {
         for( BOARD_ITEM* item = module->m_Drawings; item; item = item->Next() )
@@ -810,14 +809,14 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
         }
     }
 
-    /* Plot footprint pads */
+    // Plot footprint pads
     for( MODULE* module = m_Pcb->m_Modules; module; module = module->Next() )
     {
         for( D_PAD* pad = module->m_Pads; pad; pad = pad->Next() )
         {
             wxPoint shape_pos;
 
-            if( (pad->m_layerMask & aLayerMask) == 0 )
+            if( (pad->GetLayerMask() & aLayerMask) == 0 )
                 continue;
 
             shape_pos = pad->ReturnShapePos();
@@ -848,19 +847,19 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
                 break;
             }
 
-            size.x = pad->m_Size.x + ( 2 * margin.x ) + width_adj;
+            size.x = pad->GetSize().x + ( 2 * margin.x ) + width_adj;
-            size.y = pad->m_Size.y + ( 2 * margin.y ) + width_adj;
+            size.y = pad->GetSize().y + ( 2 * margin.y ) + width_adj;
 
-            /* Don't draw a null size item : */
+            // Don't draw a null size item :
             if( size.x <= 0 || size.y <= 0 )
                 continue;
 
-            switch( pad->m_PadShape )
+            switch( pad->GetShape() )
             {
             case PAD_CIRCLE:
                 if( aSkipNPTH_Pads &&
-                    (pad->m_Size == pad->m_Drill) &&
+                    (pad->GetSize() == pad->GetDrillSize()) &&
-                    (pad->m_Attribut == PAD_HOLE_NOT_PLATED) )
+                    (pad->GetAttribute() == PAD_HOLE_NOT_PLATED) )
                     break;
 
                 aPlotter->flash_pad_circle( pos, size.x, aPlotMode );
@@ -868,30 +867,30 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
 
             case PAD_OVAL:
                 if( aSkipNPTH_Pads &&
-                    (pad->m_Size == pad->m_Drill) &&
+                    (pad->GetSize() == pad->GetDrillSize()) &&
-                    (pad->m_Attribut == PAD_HOLE_NOT_PLATED) )
+                    (pad->GetAttribute() == PAD_HOLE_NOT_PLATED) )
                     break;
 
-                aPlotter->flash_pad_oval( pos, size, pad->m_Orient, aPlotMode );
+                aPlotter->flash_pad_oval( pos, size, pad->GetOrientation(), aPlotMode );
                 break;
 
             case PAD_TRAPEZOID:
             {
                 wxPoint coord[4];
                 pad->BuildPadPolygon( coord, margin, 0 );
-                aPlotter->flash_pad_trapez( pos, coord, pad->m_Orient, aPlotMode );
+                aPlotter->flash_pad_trapez( pos, coord, pad->GetOrientation(), aPlotMode );
             }
             break;
 
             case PAD_RECT:
             default:
-                aPlotter->flash_pad_rect( pos, size, pad->m_Orient, aPlotMode );
+                aPlotter->flash_pad_rect( pos, size, pad->GetOrientation(), aPlotMode );
                 break;
             }
         }
     }
 
-    /* Plot vias : */
+    // Plot vias :
     if( aPlotVia )
     {
         for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
@@ -931,7 +930,7 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
             pos    = Via->m_Start;
             size.x = size.y = Via->m_Width + 2 * via_margin + width_adj;
 
-            /* Don't draw a null size item : */
+            // Don't draw a null size item :
             if( size.x <= 0 )
                 continue;
 
@@ -939,7 +938,7 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
         }
     }
 
-    /* Plot tracks (not vias) : */
+    // Plot tracks (not vias) :
     for( TRACK* track = m_Pcb->m_Track; track; track = track->Next() )
     {
         wxPoint end;
@@ -957,7 +956,7 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
         aPlotter->thick_segment( pos, end, size.x, aPlotMode );
     }
 
-    /* Plot zones (outdated, for old boards compatibility): */
+    // Plot zones (outdated, for old boards compatibility):
     for( TRACK* track = m_Pcb->m_Zone; track; track = track->Next() )
     {
         wxPoint end;
@@ -972,7 +971,7 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER*        aPlotter,
         aPlotter->thick_segment( pos, end, size.x, aPlotMode );
     }
 
-    /* Plot filled ares */
+    // Plot filled ares
     for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
     {
         ZONE_CONTAINER* edge_zone = m_Pcb->GetArea( ii );
@@ -1003,7 +1002,7 @@ void PCB_BASE_FRAME::PlotDrillMark( PLOTTER*        aPlotter,
     wxPoint   pos;
     wxSize    diam;
     MODULE*   Module;
-    D_PAD*    PtPad;
+    D_PAD*    pad;
     TRACK*    pts;
 
     if( aTraceMode == FILLED )
@@ -1031,29 +1030,29 @@ void PCB_BASE_FRAME::PlotDrillMark( PLOTTER*        aPlotter,
 
     for( Module = m_Pcb->m_Modules; Module != NULL; Module = Module->Next() )
     {
-        for( PtPad = Module->m_Pads; PtPad != NULL; PtPad = PtPad->Next() )
+        for( pad = Module->m_Pads; pad != NULL; pad = pad->Next() )
         {
-            if( PtPad->m_Drill.x == 0 )
+            if( pad->GetDrillSize().x == 0 )
                 continue;
 
             // Output hole shapes:
-            pos = PtPad->m_Pos;
+            pos = pad->GetPosition();
 
-            if( PtPad->m_DrillShape == PAD_OVAL )
+            if( pad->GetDrillShape() == PAD_OVAL )
             {
-                diam = PtPad->m_Drill;
+                diam = pad->GetDrillSize();
                 diam.x -= aPlotter->get_plot_width_adj();
-                diam.x = doIntValueFitToBand( diam.x, 1, PtPad->m_Size.x - 1 );
+                diam.x = doIntValueFitToBand( diam.x, 1, pad->GetSize().x - 1 );
                 diam.y -= aPlotter->get_plot_width_adj();
-                diam.y = doIntValueFitToBand( diam.y, 1, PtPad->m_Size.y - 1 );
+                diam.y = doIntValueFitToBand( diam.y, 1, pad->GetSize().y - 1 );
-                aPlotter->flash_pad_oval( pos, diam, PtPad->m_Orient, aTraceMode );
+                aPlotter->flash_pad_oval( pos, diam, pad->GetOrientation(), aTraceMode );
             }
             else
             {
                 // It is quite possible that the real pad drill value is less then small drill value.
-                diam.x = aSmallDrillShape ? MIN( SMALL_DRILL, PtPad->m_Drill.x ) : PtPad->m_Drill.x;
+                diam.x = aSmallDrillShape ? MIN( SMALL_DRILL, pad->GetDrillSize().x ) : pad->GetDrillSize().x;
                 diam.x -= aPlotter->get_plot_width_adj();
-                diam.x = doIntValueFitToBand( diam.x, 1, PtPad->m_Size.x - 1 );
+                diam.x = doIntValueFitToBand( diam.x, 1, pad->GetSize().x - 1 );
                 aPlotter->flash_pad_circle( pos, diam.x, aTraceMode );
             }
         }

pcbnew/print_board_functions.cpp

@@ -198,7 +198,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
     if( GetGRForceBlackPenState() == false )
         drawmode = GR_OR;
 
-    /* Print the pcb graphic items (texts, ...) */
+    // Print the pcb graphic items (texts, ...)
     GRSetDrawMode( aDC, drawmode );
 
     for( BOARD_ITEM* item = Pcb->m_Drawings; item; item = item->Next() )
@@ -221,7 +221,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
         }
     }
 
-    /* Print tracks */
+    // Print tracks
     pt_trace = Pcb->m_Track;
 
     for( ; pt_trace != NULL; pt_trace = pt_trace->Next() )
@@ -229,7 +229,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
         if( ( aPrintMaskLayer & pt_trace->ReturnMaskLayer() ) == 0 )
             continue;
 
-        if( pt_trace->Type() == PCB_VIA_T ) /* VIA encountered. */
+        if( pt_trace->Type() == PCB_VIA_T ) // VIA encountered.
         {
             int radius = pt_trace->m_Width >> 1;
             int color = g_ColorsSettings.GetItemColor( VIAS_VISIBLE + pt_trace->m_Shape );
@@ -256,7 +256,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
         pt_trace->Draw( m_canvas, aDC, drawmode );
     }
 
-    /* Draw filled areas (i.e. zones) */
+    // Draw filled areas (i.e. zones)
     for( int ii = 0; ii < Pcb->GetAreaCount(); ii++ )
     {
         ZONE_CONTAINER* zone = Pcb->GetArea( ii );
@@ -295,7 +295,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
             if( ( aPrintMaskLayer & pt_trace->ReturnMaskLayer() ) == 0 )
                 continue;
 
-            if( pt_trace->Type() == PCB_VIA_T ) /* VIA encountered. */
+            if( pt_trace->Type() == PCB_VIA_T ) // VIA encountered.
             {
                 int diameter;
 
@@ -332,43 +332,41 @@ static void Print_Module( EDA_DRAW_PANEL* aPanel, wxDC* aDC, MODULE* aModule,
                           int aDraw_mode, int aMasklayer,
                           PRINT_PARAMETERS::DrillShapeOptT aDrillShapeOpt )
 {
-    D_PAD*        pt_pad;
+    // Print pads
-    EDA_ITEM*     PtStruct;
+    for( D_PAD* pad = aModule->m_Pads;  pad;  pad = pad->Next() )
-    TEXTE_MODULE* TextMod;
-    int           mlayer;
-
-    /* Print pads */
-    pt_pad = aModule->m_Pads;
-
-    for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
     {
-        if( (pt_pad->m_layerMask & aMasklayer ) == 0 )
+        if( (pad->GetLayerMask() & aMasklayer ) == 0 )
             continue;
 
         // Manage hole according to the print drill option
-        wxSize drill_tmp = pt_pad->m_Drill;
+        wxSize drill_tmp = pad->GetDrillSize();
 
-        switch ( aDrillShapeOpt )
+        switch( aDrillShapeOpt )
         {
-            case PRINT_PARAMETERS::NO_DRILL_SHAPE:
+        case PRINT_PARAMETERS::NO_DRILL_SHAPE:
-                pt_pad->m_Drill = wxSize(0,0);
+            pad->SetDrillSize( wxSize(0,0) );
-                break;
+            break;
-            case PRINT_PARAMETERS::SMALL_DRILL_SHAPE:
+
-                pt_pad->m_Drill.x = min(SMALL_DRILL,pt_pad->m_Drill.x);
+        case PRINT_PARAMETERS::SMALL_DRILL_SHAPE:
-                pt_pad->m_Drill.y = min(SMALL_DRILL,pt_pad->m_Drill.y);
+            {
-                break;
+                wxSize sz(  min( SMALL_DRILL, pad->GetDrillSize().x ),
-            case PRINT_PARAMETERS::FULL_DRILL_SHAPE:
+                            min( SMALL_DRILL, pad->GetDrillSize().y ) );
-                // Do nothing
+
-                break;
+                pad->SetDrillSize( sz );
+            }
+            break;
+
+        case PRINT_PARAMETERS::FULL_DRILL_SHAPE:
+            // Do nothing
+            break;
         }
 
-        pt_pad->Draw( aPanel, aDC, aDraw_mode );
+        pad->Draw( aPanel, aDC, aDraw_mode );
-        pt_pad->m_Drill = drill_tmp;
+        pad->SetDrillSize( drill_tmp );
     }
 
-    /* Print footprint graphic shapes */
+    // Print footprint graphic shapes
-    PtStruct = aModule->m_Drawings;
+    int mlayer   = GetLayerMask( aModule->GetLayer() );
-    mlayer   = GetLayerMask( aModule->GetLayer() );
 
     if( aModule->GetLayer() == LAYER_N_BACK )
         mlayer = SILKSCREEN_LAYER_BACK;
@@ -384,28 +382,29 @@ static void Print_Module( EDA_DRAW_PANEL* aPanel, wxDC* aDC, MODULE* aModule,
             aModule->m_Value->Draw( aPanel, aDC, aDraw_mode );
     }
 
-    for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
+    for( EDA_ITEM* item = aModule->m_Drawings;  item;  item = item->Next() )
     {
-        switch( PtStruct->Type() )
+        switch( item->Type() )
         {
         case PCB_MODULE_TEXT_T:
             if( ( mlayer & aMasklayer ) == 0 )
                 break;
 
-            TextMod = (TEXTE_MODULE*) PtStruct;
+            TEXTE_MODULE* textMod;
-            TextMod->Draw( aPanel, aDC, aDraw_mode );
+            textMod = (TEXTE_MODULE*) item;
+            textMod->Draw( aPanel, aDC, aDraw_mode );
             break;
 
         case PCB_MODULE_EDGE_T:
-        {
+            {
-            EDGE_MODULE* edge = (EDGE_MODULE*) PtStruct;
+                EDGE_MODULE* edge = (EDGE_MODULE*) item;
 
-            if( ( GetLayerMask( edge->GetLayer() ) & aMasklayer ) == 0 )
+                if( ( GetLayerMask( edge->GetLayer() ) & aMasklayer ) == 0 )
-                break;
+                    break;
 
-            edge->Draw( aPanel, aDC, aDraw_mode );
+                edge->Draw( aPanel, aDC, aDraw_mode );
+            }
             break;
-        }
 
         default:
             break;

pcbnew/protos.h

@@ -55,7 +55,21 @@ void DrawTraces( EDA_DRAW_PANEL* panel,
 /*************/
 /* MODULES.C */
 /*************/
+
+/**
+ * Function ChangeSideMaskLayer
+ * calculates the mask layer when flipping a footprint.
+ * BACK and FRONT copper layers , mask, paste, solder layers are swapped.
+ */
+int ChangeSideMaskLayer( int aMask );
+
+/**
+ * Function ChangeSideNumLayer
+ * calculates the layer number for changing cu / cmp layers for Cu / CMP.
+ * (Copper, Mask, Paste, solder)
+ */
 int ChangeSideNumLayer( int oldlayer );
+
 void DrawModuleOutlines( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* module );
 void MoveFootprint( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aPosition, bool aErase );
 

pcbnew/ratsnest.cpp

@@ -78,7 +78,7 @@ void MIN_SPAN_TREE_PADS::AddTreeToRatsnest( std::vector<RATSNEST_ITEM> &aRatsnes
     // The first edge (i.e. rastnest) starts at index 1
     for( int ii = 1; ii < m_Size; ii++ )
     {
-        /* Create the new ratsnest */
+        // Create the new ratsnest
         RATSNEST_ITEM net;
         net.SetNet( netcode );
         net.m_Status   = CH_ACTIF | CH_VISIBLE;
@@ -107,8 +107,8 @@ int MIN_SPAN_TREE_PADS::GetWeight( int aItem1, int aItem2 )
 
     if( pad1 == pad2 )
         return 0;
-    int weight = abs( pad2->m_Pos.x - pad1->m_Pos.x ) +
+    int weight = abs( pad2->GetPosition().x - pad1->GetPosition().x ) +
-                 abs( pad2->m_Pos.y - pad1->m_Pos.y );
+                 abs( pad2->GetPosition().y - pad1->GetPosition().y );
     return weight + 1;
 }
 
@@ -209,7 +209,7 @@ void PCB_BASE_FRAME::Build_Board_Ratsnest()
     if( m_Pcb->GetPadCount() == 0 )
         return;
 
-    /* Created pad list and the net_codes if needed */
+    // Created pad list and the net_codes if needed
     if( (m_Pcb->m_Status_Pcb & NET_CODES_OK) == 0 )
         m_Pcb->BuildListOfNets();
 
@@ -220,9 +220,9 @@ void PCB_BASE_FRAME::Build_Board_Ratsnest()
     }
 
     if( m_Pcb->GetNodesCount() == 0 )
-        return;                       /* No useful connections. */
+        return;                       // No useful connections.
 
-    /* Ratsnest computation */
+    // Ratsnest computation
     unsigned current_net_code = 1;      // First net code is analyzed.
                                         // (net_code = 0 -> no connect)
     noconn = 0;
@@ -309,7 +309,7 @@ static int tst_links_between_blocks( NETINFO_ITEM*          aNetinfo,
     int            subratsnest_id, min_id;
     RATSNEST_ITEM* link, * best_link;
 
-    /* Search a link from a block to an other block */
+    // Search a link from a block to an other block
     best_link = NULL;
 
     for( unsigned ii = aNetinfo->m_RatsnestStartIdx; ii < aNetinfo->m_RatsnestEndIdx; ii++ )
@@ -544,11 +544,11 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
         pads_module_count = localPadList.size();
 
         if( pads_module_count == 0 )
-            return;  /* no connection! */
+            return;  // no connection!
 
         sort( localPadList.begin(), localPadList.end(), sortByNetcode );
 
-        /* Build the list of pads linked to the current footprint pads */
+        // Build the list of pads linked to the current footprint pads
         current_net_code = 0;
 
         for( unsigned ii = 0; ii < pads_module_count; ii++ )
@@ -581,7 +581,7 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
             }
         }
 
-        /* Sort the pad list by net_code */
+        // Sort the pad list by net_code
         sort( localPadList.begin() + pads_module_count, localPadList.end(),
                sortByNetcode );
 
@@ -596,7 +596,7 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
         std::vector<D_PAD*> padsBuffer;     // contains pads of only one net
         for( unsigned ii = 0; ii < pads_module_count; ii++ )
         {
-            /* Search the end of pad list relative to the current net */
+            // Search the end of pad list relative to the current net
             unsigned jj = ii + 1;
 
             for( ; jj <= pads_module_count; jj++ )
@@ -656,7 +656,7 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
 
         if( pad_ref->GetNet() != current_net_code )
         {
-            /* if needed, creates a new ratsnest for the old net */
+            // if needed, creates a new ratsnest for the old net
             if( addRats )
             {
                 m_Pcb->m_LocalRatsnest.push_back( local_rats );
@@ -667,22 +667,22 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
             local_rats.m_Lenght = INT_MAX;
         }
 
-        pad_pos = pad_ref->m_Pos - g_Offset_Module;
+        pad_pos = pad_ref->GetPosition() - g_Offset_Module;
 
         // Search the nearest external pad of this current pad
         for( unsigned jj = pads_module_count; jj < localPadList.size(); jj++ )
         {
             pad_externe = localPadList[jj];
 
-            /* we search pads having the same net code */
+            // we search pads having the same net code
             if( pad_externe->GetNet() < pad_ref->GetNet() )
                 continue;
 
             if( pad_externe->GetNet() > pad_ref->GetNet() ) // pads are sorted by net code
                 break;
 
-            distance = abs( pad_externe->m_Pos.x - pad_pos.x ) +
+            distance = abs( pad_externe->GetPosition().x - pad_pos.x ) +
-                       abs( pad_externe->m_Pos.y - pad_pos.y );
+                       abs( pad_externe->GetPosition().y - pad_pos.y );
 
             if( distance < local_rats.m_Lenght )
             {
@@ -724,10 +724,13 @@ void PCB_BASE_FRAME::TraceModuleRatsNest( wxDC* DC )
         else
         {
             g_ColorsSettings.SetItemColor(RATSNEST_VISIBLE, tmpcolor);
-            wxPoint tmp = rats->m_PadStart->m_Pos;
+
-            rats->m_PadStart->m_Pos -= g_Offset_Module;
+            wxPoint tmp = rats->m_PadStart->GetPosition();
+
+            rats->m_PadStart->SetPosition( tmp - g_Offset_Module );
             rats->Draw( m_canvas, DC, GR_XOR, wxPoint( 0, 0 ) );
-            rats->m_PadStart->m_Pos = tmp;
+
+            rats->m_PadStart->SetPosition( tmp );
         }
     }
 
@@ -827,7 +830,7 @@ void PCB_BASE_FRAME::BuildAirWiresTargetsList( BOARD_CONNECTED_ITEM* aItemRef,
                 continue;
 
             if( !pad->GetSubNet() || (pad->GetSubNet() != subnet) )
-                s_TargetsLocations.push_back( pad->m_Pos );
+                s_TargetsLocations.push_back( pad->GetPosition() );
         }
 
         // Create a list of tracks ends candidates, not already connected to the
@@ -851,10 +854,11 @@ void PCB_BASE_FRAME::BuildAirWiresTargetsList( BOARD_CONNECTED_ITEM* aItemRef,
         // Remove duplicate targets, using the C++ unique algorithm
         sort( s_TargetsLocations.begin(), s_TargetsLocations.end(), sort_by_point );
         std::vector< wxPoint >::iterator it = unique( s_TargetsLocations.begin(), s_TargetsLocations.end() );
+
         // Using the C++ unique algorithm only moves the duplicate entries to the end of
         // of the array.  This removes the duplicate entries from the array.
         s_TargetsLocations.resize( it - s_TargetsLocations.begin() );
-    }   /* end if Init */
+    }   // end if Init
 
     // in all cases, sort by distances:
     sort( s_TargetsLocations.begin(), s_TargetsLocations.end(), sort_by_distance );

pcbnew/solve.cpp

@@ -447,9 +447,11 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe,
     routeLayerMask = topLayerMask | bottomLayerMask;
 
     pt_cur_ch = pt_rat;
-    current_net_code   = pt_rat->GetNet();
+
-    padLayerMaskStart = pt_cur_ch->m_PadStart->m_layerMask;
+    current_net_code  = pt_rat->GetNet();
-    padLayerMaskEnd = pt_cur_ch->m_PadEnd->m_layerMask;
+    padLayerMaskStart = pt_cur_ch->m_PadStart->GetLayerMask();
+
+    padLayerMaskEnd = pt_cur_ch->m_PadEnd->GetLayerMask();
 
 
     /* First Test if routing possible ie if the pads are accessible
@@ -469,12 +471,12 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe,
                  + pcbframe->GetBoard()->GetBoundingBox().GetX();
         int cY = ( Board.m_GridRouting * row_source )
                  + pcbframe->GetBoard()->GetBoundingBox().GetY();
-        int dx = pt_cur_ch->m_PadStart->m_Size.x / 2;
+        int dx = pt_cur_ch->m_PadStart->GetSize().x / 2;
-        int dy = pt_cur_ch->m_PadStart->m_Size.y / 2;
+        int dy = pt_cur_ch->m_PadStart->GetSize().y / 2;
         int px = pt_cur_ch->m_PadStart->GetPosition().x;
         int py = pt_cur_ch->m_PadStart->GetPosition().y;
 
-        if( ( ( int( pt_cur_ch->m_PadStart->m_Orient ) / 900 ) & 1 ) != 0 )
+        if( ( ( int( pt_cur_ch->m_PadStart->GetOrientation() ) / 900 ) & 1 ) != 0 )
             EXCHG( dx, dy );
 
         if( ( abs( cX - px ) > dx ) || ( abs( cY - py ) > dy ) )
@@ -484,12 +486,12 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe,
              + pcbframe->GetBoard()->GetBoundingBox().GetX();
         cY = ( Board.m_GridRouting * row_target )
              + pcbframe->GetBoard()->GetBoundingBox().GetY();
-        dx = pt_cur_ch->m_PadEnd->m_Size.x / 2;
+        dx = pt_cur_ch->m_PadEnd->GetSize().x / 2;
-        dy = pt_cur_ch->m_PadEnd->m_Size.y / 2;
+        dy = pt_cur_ch->m_PadEnd->GetSize().y / 2;
         px = pt_cur_ch->m_PadEnd->GetPosition().x;
         py = pt_cur_ch->m_PadEnd->GetPosition().y;
 
-        if( ( ( int( pt_cur_ch->m_PadEnd->m_Orient ) / 900) & 1 ) != 0 )
+        if( ( ( int( pt_cur_ch->m_PadEnd->GetOrientation() ) / 900) & 1 ) != 0 )
             EXCHG( dx, dy );
 
         if( ( abs( cX - px ) > dx ) || ( abs( cY - py ) > dy ) )

pcbnew/specctra_export.cpp

@@ -259,12 +259,12 @@ static DRAWSEGMENT* findPoint( const wxPoint& aPoint, TYPE_COLLECTOR* items )
  */
 static bool isRoundKeepout( D_PAD* aPad )
 {
-    if( aPad->m_PadShape==PAD_CIRCLE )
+    if( aPad->GetShape()==PAD_CIRCLE )
     {
-        if( aPad->m_Drill.x >= aPad->m_Size.x )
+        if( aPad->GetDrillSize().x >= aPad->GetSize().x )
             return true;
 
-        if( (aPad->m_layerMask & ALL_CU_LAYERS) == 0 )
+        if( (aPad->GetLayerMask() & ALL_CU_LAYERS) == 0 )
             return true;
     }
 
@@ -302,7 +302,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
 
     uniqifier = '[';
 
-    bool onAllCopperLayers = ( (aPad->m_layerMask & ALL_CU_LAYERS) == ALL_CU_LAYERS );
+    bool onAllCopperLayers = ( (aPad->GetLayerMask() & ALL_CU_LAYERS) == ALL_CU_LAYERS );
 
     if( onAllCopperLayers )
         uniqifier += 'A';               // A for all layers
@@ -332,11 +332,11 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
 
     POINT   dsnOffset;
 
-    if( aPad->m_Offset.x || aPad->m_Offset.y )
+    if( aPad->GetOffset().x || aPad->GetOffset().y )
     {
         char offsetTxt[64];
 
-        wxPoint offset( aPad->m_Offset.x, aPad->m_Offset.y );
+        wxPoint offset( aPad->GetOffset().x, aPad->GetOffset().y );
 
         dsnOffset = mapPt( offset );
 
@@ -347,12 +347,12 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
         uniqifier += offsetTxt;
     }
 
-    switch( aPad->m_PadShape )
+    switch( aPad->GetShape() )
     {
     default:
     case PAD_CIRCLE:
         {
-            double  diameter = scale(aPad->m_Size.x);
+            double  diameter = scale(aPad->GetSize().x);
 
             for( int ndx=0;  ndx<reportedLayers;  ++ndx )
             {
@@ -368,7 +368,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
             }
 
             snprintf( name, sizeof(name), "Round%sPad_%.6g_mil",
-                     uniqifier.c_str(), scale(aPad->m_Size.x) );
+                     uniqifier.c_str(), scale(aPad->GetSize().x) );
             name[ sizeof(name)-1 ] = 0;
 
             padstack->SetPadstackId( name );
@@ -377,8 +377,8 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
 
     case PAD_RECT:
         {
-            double dx = scale( aPad->m_Size.x ) / 2.0;
+            double dx = scale( aPad->GetSize().x ) / 2.0;
-            double dy = scale( aPad->m_Size.y ) / 2.0;
+            double dy = scale( aPad->GetSize().y ) / 2.0;
 
             POINT   lowerLeft( -dx, -dy );
             POINT   upperRight( dx, dy );
@@ -399,7 +399,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
             }
 
             snprintf( name, sizeof(name),  "Rect%sPad_%.6gx%.6g_mil",
-                     uniqifier.c_str(), scale(aPad->m_Size.x), scale(aPad->m_Size.y)  );
+                     uniqifier.c_str(), scale(aPad->GetSize().x), scale(aPad->GetSize().y)  );
             name[ sizeof(name)-1 ] = 0;
 
             padstack->SetPadstackId( name );
@@ -408,8 +408,8 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
 
     case PAD_OVAL:
         {
-            double  dx = scale( aPad->m_Size.x ) / 2.0;
+            double  dx = scale( aPad->GetSize().x ) / 2.0;
-            double  dy = scale( aPad->m_Size.y ) / 2.0;
+            double  dy = scale( aPad->GetSize().y ) / 2.0;
             double  dr = dx - dy;
             double  radius;
             POINT   start;
@@ -447,7 +447,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
             }
 
             snprintf( name, sizeof(name),  "Oval%sPad_%.6gx%.6g_mil",
-                     uniqifier.c_str(), scale(aPad->m_Size.x), scale(aPad->m_Size.y)  );
+                     uniqifier.c_str(), scale(aPad->GetSize().x), scale(aPad->GetSize().y)  );
             name[ sizeof(name)-1 ] = 0;
 
             padstack->SetPadstackId( name );
@@ -456,11 +456,11 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
 
     case PAD_TRAPEZOID:
         {
-            double dx = scale( aPad->m_Size.x ) / 2.0;
+            double dx = scale( aPad->GetSize().x ) / 2.0;
-            double dy = scale( aPad->m_Size.y ) / 2.0;
+            double dy = scale( aPad->GetSize().y ) / 2.0;
 
-            double ddx = scale( aPad->m_DeltaSize.x ) / 2.0;
+            double ddx = scale( aPad->GetDelta().x ) / 2.0;
-            double ddy = scale( aPad->m_DeltaSize.y ) / 2.0;
+            double ddy = scale( aPad->GetDelta().y ) / 2.0;
 
             // see class_pad_draw_functions.cpp which draws the trapezoid pad
             POINT   lowerLeft(  -dx - ddy, -dy - ddx );
@@ -490,15 +490,15 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad )
                 polygon->AppendPoint( lowerRight );
             }
 
-            D(printf( "m_DeltaSize: %d,%d\n", aPad->m_DeltaSize.x, aPad->m_DeltaSize.y );)
+            D(printf( "m_DeltaSize: %d,%d\n", aPad->GetDelta().x, aPad->GetDelta().y );)
 
             // this string _must_ be unique for a given physical shape
             snprintf( name, sizeof(name), "Trapz%sPad_%.6gx%.6g_%c%.6gx%c%.6g_mil",
-                     uniqifier.c_str(), scale(aPad->m_Size.x), scale(aPad->m_Size.y),
+                     uniqifier.c_str(), scale(aPad->GetSize().x), scale(aPad->GetSize().y),
-                     aPad->m_DeltaSize.x < 0 ? 'n' : 'p',
+                     aPad->GetDelta().x < 0 ? 'n' : 'p',
-                     abs( scale( aPad->m_DeltaSize.x )),
+                     abs( scale( aPad->GetDelta().x )),
-                     aPad->m_DeltaSize.y < 0 ? 'n' : 'p',
+                     aPad->GetDelta().y < 0 ? 'n' : 'p',
-                     abs( scale( aPad->m_DeltaSize.y ))
+                     abs( scale( aPad->GetDelta().y ))
                      );
             name[ sizeof(name)-1 ] = 0;
 
@@ -538,8 +538,8 @@ IMAGE* SPECCTRA_DB::makeIMAGE( BOARD* aBoard, MODULE* aModule )
         // see if this pad is a through hole with no copper on its perimeter
         if( isRoundKeepout( pad ) )
         {
-            double  diameter = scale( pad->m_Drill.x );
+            double  diameter = scale( pad->GetDrillSize().x );
-            POINT   vertex   = mapPt( pad->m_Pos0 );
+            POINT   vertex   = mapPt( pad->GetPos0() );
 
             int layerCount = aBoard->GetCopperLayerCount();
             for( int layer=0;  layer<layerCount;  ++layer )
@@ -600,14 +600,14 @@ IMAGE* SPECCTRA_DB::makeIMAGE( BOARD* aBoard, MODULE* aModule )
 
             pin->padstack_id = padstack->padstack_id;
 
-            int angle = pad->m_Orient - aModule->m_Orient;   // tenths of degrees
+            int angle = pad->GetOrientation() - aModule->GetOrientation();   // tenths of degrees
             if( angle )
             {
                 NORMALIZE_ANGLE_POS(angle);
                 pin->SetRotation( angle / 10.0 );
             }
 
-            wxPoint pos( pad->m_Pos0 );
+            wxPoint pos( pad->GetPos0() );
 
             pin->SetVertex( mapPt( pos )  );
         }
@@ -1255,7 +1255,7 @@ void SPECCTRA_DB::FromBOARD( BOARD* aBoard ) throw( IO_ERROR )
             PLACE* place = new PLACE( comp );
             comp->places.push_back( place );
 
-            place->SetRotation( module->m_Orient/10.0 );
+            place->SetRotation( module->GetOrientation()/10.0 );
             place->SetVertex( mapPt( module->m_Pos ) );
             place->component_id = componentId;
             place->part_number  = TO_UTF8( module->GetValue() );
@@ -1263,7 +1263,7 @@ void SPECCTRA_DB::FromBOARD( BOARD* aBoard ) throw( IO_ERROR )
             // module is flipped from bottom side, set side to T_back
             if( module->flag )
             {
-                int angle = 1800 - module->m_Orient;
+                int angle = 1800 - module->GetOrientation();
                 NORMALIZE_ANGLE_POS(angle);
                 place->SetRotation( angle/10.0 );
 

pcbnew/tr_modif.cpp

@@ -77,7 +77,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
     wxASSERT( aNewTrack );
 
 #if 0 && defined(DEBUG)
-    TRACK* EndNewTrack;      /* The last segment of the list chained to the track */
+    TRACK* EndNewTrack;      // The last segment of the list chained to the track
 
     EndNewTrack = aNewTrack;
 
@@ -99,7 +99,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
     TRACK* bufStart = m_Pcb->m_Track->GetStartNetCode( netcode ); // Beginning of tracks of the net
     TRACK* bufEnd = bufStart->GetEndNetCode( netcode );           // End of tracks of the net
 
-    /* Flags for cleaning the net. */
+    // Flags for cleaning the net.
     for( pt_del = bufStart;  pt_del;  pt_del = pt_del->Next() )
     {
 //        D( std::cout<<"track "<<pt_del<<" turning off BUSY | IN_EDIT | IS_LINKED"<<std::endl; )
@@ -118,15 +118,15 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
     start = StartTrack->m_Start;
     end   = EndTrack->m_End;
 
-    /* The start and end points cannot be the same. */
+    // The start and end points cannot be the same.
     if( start == end )
         return 0;
 
-    /* Determine layers interconnected these points. */
+    // Determine layers interconnected these points.
     startmasklayer = StartTrack->ReturnMaskLayer();
     endmasklayer   = EndTrack->ReturnMaskLayer();
 
-    /* There may be a via or a pad on the end points. */
+    // There may be a via or a pad on the end points.
     pt_segm = m_Pcb->m_Track->GetVia( NULL, start, startmasklayer );
 
     if( pt_segm )
@@ -134,9 +134,9 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
 
     if( StartTrack->start && ( StartTrack->start->Type() == PCB_PAD_T ) )
     {
-        /* Start on pad. */
+        // Start on pad.
-        D_PAD* pt_pad = (D_PAD*)(StartTrack->start);
+        D_PAD* pad = (D_PAD*) StartTrack->start;
-        startmasklayer |= pt_pad->m_layerMask;
+        startmasklayer |= pad->GetLayerMask();
     }
 
     pt_segm = m_Pcb->m_Track->GetVia( NULL, end, endmasklayer );
@@ -146,8 +146,8 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
 
     if( EndTrack->end && ( EndTrack->end->Type() == PCB_PAD_T ) )
     {
-        D_PAD* pt_pad = (D_PAD*)(EndTrack->end);
+        D_PAD* pad = (D_PAD*) EndTrack->end;
-        endmasklayer |= pt_pad->m_layerMask;
+        endmasklayer |= pad->GetLayerMask();
     }
 
     // Mark as deleted a new track (which is not involved in the search for other connections)
@@ -158,9 +158,9 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
      */
     pt_segm = GetTrace( bufStart, bufEnd, start, startmasklayer );
 
-    if( pt_segm == NULL )     /* Not connected to the track starting point. */
+    if( pt_segm == NULL )     // Not connected to the track starting point.
     {
-        /* Clear the delete flag. */
+        // Clear the delete flag.
         ListSetState( aNewTrack, aNewTrackSegmentsCount, IS_DELETED, OFF );
         return 0;
     }
@@ -193,7 +193,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
 
     if( nbconnect == 0 )
     {
-        /* Clear used flags */
+        // Clear used flags
         for( pt_del = bufStart; pt_del; pt_del = pt_del->Next() )
         {
             pt_del->SetState( BUSY | IS_DELETED | IN_EDIT | IS_LINKED, OFF );
@@ -209,7 +209,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
     ListSetState( aNewTrack, aNewTrackSegmentsCount, IS_DELETED, OFF );
     ListSetState( aNewTrack, aNewTrackSegmentsCount, IN_EDIT, ON );
 
-    /* Test all marked segments. */
+    // Test all marked segments.
     while( nbconnect )
     {
         for( pt_del = bufStart; pt_del; pt_del = pt_del->Next() )
@@ -239,7 +239,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
 
             if( pt_segm->m_Start == start || pt_segm->m_End == start )
             {
-                /* Marked track can be erased. */
+                // Marked track can be erased.
                 TRACK* NextS;
 
                 DrawTraces( m_canvas, aDC, pt_del, nb_segm, GR_XOR | GR_HIGHLIGHT );
@@ -262,7 +262,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
                     }
                 }
 
-                /* Clean up flags. */
+                // Clean up flags.
                 for( pt_del = m_Pcb->m_Track; pt_del != NULL; pt_del = pt_del->Next() )
                 {
                     if( pt_del->GetState( IN_EDIT ) )
@@ -284,7 +284,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC*              aDC,
         ListSetState( pt_del, nb_segm, BUSY, OFF );
     }
 
-    /* Clear used flags */
+    // Clear used flags
     for( pt_del = m_Pcb->m_Track; pt_del; pt_del = pt_del->Next() )
     {
         pt_del->SetState( BUSY | IS_DELETED | IN_EDIT | IS_LINKED, OFF );

pcbnew/tracepcb.cpp

@@ -71,7 +71,7 @@ void FOOTPRINT_EDIT_FRAME::RedrawActiveWindow( wxDC* DC, bool EraseBg )
     m_canvas->DrawBackGround( DC );
     TraceWorkSheet( DC, screen, 0 );
 
-    /* Redraw the footprints */
+    // Redraw the footprints
     for( MODULE* module = GetBoard()->m_Modules;  module;  module = module->Next() )
     {
         module->Draw( m_canvas, DC, GR_OR );
@@ -89,7 +89,7 @@ void FOOTPRINT_EDIT_FRAME::RedrawActiveWindow( wxDC* DC, bool EraseBg )
     if( m_canvas->IsMouseCaptured() )
         m_canvas->CallMouseCapture( DC, wxDefaultPosition, false );
 
-    /* Redraw the cursor */
+    // Redraw the cursor
     m_canvas->DrawCrossHair( DC );
 }
 
@@ -130,7 +130,7 @@ void PCB_EDIT_FRAME::RedrawActiveWindow( wxDC* DC, bool EraseBg )
 }
 
 
-/* Redraw the BOARD items but not cursors, axis or grid */
+// Redraw the BOARD items but not cursors, axis or grid
 void BOARD::Draw( EDA_DRAW_PANEL* aPanel, wxDC* DC, int aDrawMode, const wxPoint& offset )
 {
     /* The order of drawing is flexible on some systems and not on others.  For
@@ -178,7 +178,7 @@ void BOARD::Draw( EDA_DRAW_PANEL* aPanel, wxDC* DC, int aDrawMode, const wxPoint
         }
     }
 
-    /* Draw areas (i.e. zones) */
+    // Draw areas (i.e. zones)
     for( int ii = 0; ii < GetAreaCount(); ii++ )
     {
         ZONE_CONTAINER* zone = GetArea(ii);
@@ -280,21 +280,19 @@ void BOARD::DrawHighLight( EDA_DRAW_PANEL* am_canvas, wxDC* DC, int aNetCode )
  * and we want to see pad through.
  * The pads must appear on the layers selected in LayerMask
  */
-void Trace_Pads_Only( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* Module,
+void Trace_Pads_Only( EDA_DRAW_PANEL* panel, wxDC* DC, MODULE* aModule,
-                      int ox, int oy, int LayerMask, int draw_mode )
+                      int ox, int oy, int aLayerMask, int draw_mode )
 {
-    int             tmp;
+    PCB_BASE_FRAME* frame = (PCB_BASE_FRAME*) panel->GetParent();
-    PCB_BASE_FRAME* frame;
 
-    frame  = (PCB_BASE_FRAME*) panel->GetParent();
+    int tmp = frame->m_DisplayPadFill;
 
-    tmp = frame->m_DisplayPadFill;
     frame->m_DisplayPadFill = false;
 
-    /* Draw pads. */
+    // Draw pads.
-    for( D_PAD* pad = Module->m_Pads;  pad;  pad = pad->Next() )
+    for( D_PAD* pad = aModule->m_Pads;  pad;  pad = pad->Next() )
     {
-        if( (pad->m_layerMask & LayerMask) == 0 )
+        if( (pad->GetLayerMask() & aLayerMask) == 0 )
             continue;
 
         pad->Draw( panel, DC, draw_mode, wxPoint( ox, oy ) );

pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp

@@ -71,7 +71,7 @@ static int  CopyPolygonsFromFilledPolysListTotKPolygonList( ZONE_CONTAINER* aZon
 // Local Variables:
 static int s_thermalRot = 450;  // angle of stubs in thermal reliefs for round pads
 
-/* how many segments are used to create a polygon from a circle: */
+// how many segments are used to create a polygon from a circle:
 static int s_CircleToSegmentsCount = ARC_APPROX_SEGMENTS_COUNT_LOW_DEF;   /* default value. the real value will be changed to
                                                                            * ARC_APPROX_SEGMENTS_COUNT_HIGHT_DEF
                                                                            * if m_ArcToSegmentsCount == ARC_APPROX_SEGMENTS_COUNT_HIGHT_DEF
@@ -201,15 +201,16 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb )
                  * inside the board (in fact inside the hole. Some photo diodes and Leds are
                  * like this)
                  */
-                if( (pad->m_Drill.x == 0) && (pad->m_Drill.y == 0) )
+                if( pad->GetDrillSize().x == 0 && pad->GetDrillSize().y == 0 )
                     continue;
 
                 // Use a dummy pad to calculate a hole shape that have the same dimension as
                 // the pad hole
-                dummypad.m_Size     = pad->m_Drill;
+                dummypad.SetSize( pad->GetDrillSize() );
-                dummypad.m_Orient   = pad->m_Orient;
+                dummypad.SetOrientation( pad->GetOrientation() );
-                dummypad.m_PadShape = pad->m_DrillShape;
+                dummypad.SetShape( pad->GetDrillShape() );
-                dummypad.m_Pos = pad->m_Pos;
+                dummypad.SetPosition( pad->GetPosition() );
+
                 pad = &dummypad;
             }
 
@@ -233,7 +234,7 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb )
             int gap = zone_clearance;
 
             if( (m_PadOption == PAD_NOT_IN_ZONE)
-               || (GetNet() == 0) || pad->m_PadShape == PAD_TRAPEZOID )
+               || (GetNet() == 0) || pad->GetShape() == PAD_TRAPEZOID )
 
             // PAD_TRAPEZOID shapes are not in zones because they are used in microwave apps
             // and i think it is good that shapes are not changed by thermal pads or others
@@ -407,18 +408,19 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb )
     if( m_PadOption == THERMAL_PAD )
     {
         cornerBufferPolysToSubstract.clear();
+
         // Test thermal stubs connections and add polygons to remove unconnected stubs.
         BuildUnconnectedThermalStubsPolygonList( cornerBufferPolysToSubstract, aPcb, this,
                                                  s_Correction, s_thermalRot );
 
-        /* remove copper areas */
+        // remove copper areas
         if( cornerBufferPolysToSubstract.size() )
         {
             KPolygonSet polyset_holes;
             AddPolygonCornersToKPolygonList( cornerBufferPolysToSubstract, polyset_holes );
             polyset_zone_solid_areas -= polyset_holes;
 
-            /* put these areas in m_FilledPolysList */
+            // put these areas in m_FilledPolysList
             m_FilledPolysList.clear();
             CopyPolygonsFromKPolygonListToFilledPolysList( this, polyset_zone_solid_areas );
 

pcbnew/zones_convert_to_polygons_aux_functions.cpp

@@ -68,21 +68,21 @@ void BuildUnconnectedThermalStubsPolygonList( std::vector<CPolyPt>& aCornerBuffe
             // Thermal bridges are like a segment from a starting point inside the pad
             // to an ending point outside the pad
             wxPoint startpoint, endpoint;
-            endpoint.x = ( pad->m_Size.x / 2 ) + aZone->m_ThermalReliefGap;
+            endpoint.x = ( pad->GetSize().x / 2 ) + aZone->m_ThermalReliefGap;
-            endpoint.y = ( pad->m_Size.y / 2 ) + aZone->m_ThermalReliefGap;
+            endpoint.y = ( pad->GetSize().y / 2 ) + aZone->m_ThermalReliefGap;
 
             int copperThickness = aZone->m_ThermalReliefCopperBridge - aZone->m_ZoneMinThickness;
             if( copperThickness < 0 )
                 copperThickness = 0;
 
-            startpoint.x = min( pad->m_Size.x, copperThickness );
+            startpoint.x = min( pad->GetSize().x, copperThickness );
-            startpoint.y = min( pad->m_Size.y, copperThickness );
+            startpoint.y = min( pad->GetSize().y, copperThickness );
             startpoint.x /= 2;
             startpoint.y /= 2;
 
             // This is CIRCLE pad tweak (for circle pads the thermal stubs are at 45 deg)
-            int fAngle = pad->m_Orient;
+            int fAngle = pad->GetOrientation();
-            if( pad->m_PadShape == PAD_CIRCLE )
+            if( pad->GetShape() == PAD_CIRCLE )
             {
                 endpoint.x     = (int) ( endpoint.x * aArcCorrection );
                 endpoint.y     = endpoint.x;

pcbnew/zones_polygons_insulated_copper_islands.cpp

@@ -28,7 +28,7 @@ void ZONE_CONTAINER::Test_For_Copper_Island_And_Remove_Insulated_Islands( BOARD
 
     // Build a list of points connected to the net:
     // list of coordinates of pads and vias on this layer and on this net.
-    std::vector <wxPoint> ListPointsCandidates;
+    std::vector <wxPoint> listPointsCandidates;
 
     for( MODULE* module = aPcb->m_Modules; module; module = module->Next() )
     {
@@ -40,7 +40,7 @@ void ZONE_CONTAINER::Test_For_Copper_Island_And_Remove_Insulated_Islands( BOARD
             if( pad->GetNet() != GetNet() )
                 continue;
 
-            ListPointsCandidates.push_back( pad->m_Pos );
+            listPointsCandidates.push_back( pad->GetPosition() );
         }
     }
 
@@ -52,10 +52,10 @@ void ZONE_CONTAINER::Test_For_Copper_Island_And_Remove_Insulated_Islands( BOARD
         if( track->GetNet() != GetNet() )
             continue;
 
-        ListPointsCandidates.push_back( track->m_Start );
+        listPointsCandidates.push_back( track->m_Start );
 
         if( track->Type() != PCB_VIA_T )
-            ListPointsCandidates.push_back( track->m_End );
+            listPointsCandidates.push_back( track->m_End );
     }
 
     // test if a point is inside
@@ -68,10 +68,10 @@ void ZONE_CONTAINER::Test_For_Copper_Island_And_Remove_Insulated_Islands( BOARD
         {
             EDA_RECT bbox = CalculateSubAreaBoundaryBox( indexstart, indexend );
 
-            for( unsigned ic = 0; ic < ListPointsCandidates.size(); ic++ )
+            for( unsigned ic = 0; ic < listPointsCandidates.size(); ic++ )
             {
                 // test if this area is connected to a board item:
-                wxPoint pos = ListPointsCandidates[ic];
+                wxPoint pos = listPointsCandidates[ic];
 
                 if( !bbox.Contains( pos ) )
                     continue;

pcbnew/zones_polygons_test_connections.cpp

@@ -142,7 +142,7 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
 
                     if( item->Type() == PCB_PAD_T )
                     {
-                        pos1 = pos2 = ( (D_PAD*) item )->m_Pos;
+                        pos1 = pos2 = ( (D_PAD*) item )->GetPosition();
                     }
                     else if( item->Type() == PCB_VIA_T )
                     {