diff --git a/3d-viewer/3d_draw.cpp b/3d-viewer/3d_draw.cpp index 99a9230e8e..b1fc59e58f 100644 --- a/3d-viewer/3d_draw.cpp +++ b/3d-viewer/3d_draw.cpp @@ -884,7 +884,7 @@ void EDGE_MODULE::Draw3D( EDA_3D_CANVAS* glcanvas ) } } - +/** @TODO: move D_PAD method to appropriate file */ /* Draw 3D pads. */ void D_PAD::Draw3D( EDA_3D_CANVAS* glcanvas ) { @@ -903,8 +903,8 @@ void D_PAD::Draw3D( EDA_3D_CANVAS* glcanvas ) int color; scale = g_Parm_3D_Visu.m_BoardScale; - holeX = (double) TO_LEGACY_LU_DBL( m_Drill.x ) * scale / 2; - holeY = (double) TO_LEGACY_LU_DBL( m_Drill.y ) * scale / 2; + holeX = (double) TO_LEGACY_LU_DBL( m_Drill.x() ) * scale / 2; + holeY = (double) TO_LEGACY_LU_DBL( m_Drill.y() ) * scale / 2; hole = MIN( holeX, holeY ); /* Calculate the center of the pad. */ @@ -914,12 +914,12 @@ void D_PAD::Draw3D( EDA_3D_CANVAS* glcanvas ) xc = ux0; yc = uy0; - dx = dx0 = TO_LEGACY_LU( m_Size.x ) >> 1; - dy = dy0 = TO_LEGACY_LU( m_Size.y ) >> 1; + dx = dx0 = TO_LEGACY_LU( m_Size.x() ) >> 1; + dy = dy0 = TO_LEGACY_LU( m_Size.y() ) >> 1; angle = m_Orient; - drillx = m_Pos.x * scale; - drilly = m_Pos.y * scale; + drillx = TO_LEGACY_LU( m_Pos.x() ) * scale; + drilly = TO_LEGACY_LU( m_Pos.y() ) * scale; /* Draw the pad hole (TODO: draw OBLONG hole) */ if( holeX && holeY ) @@ -980,13 +980,13 @@ void D_PAD::Draw3D( EDA_3D_CANVAS* glcanvas ) { delta_cx = dx - dy; delta_cy = 0; - w = TO_LEGACY_LU( m_Size.y ) * scale; + w = TO_LEGACY_LU( m_Size.y() ) * scale; } else /* Vertical ellipse */ { delta_cx = 0; delta_cy = dy - dx; - w = TO_LEGACY_LU( m_Size.x ) * scale; + w = TO_LEGACY_LU( m_Size.x() ) * scale; } RotatePoint( &delta_cx, &delta_cy, angle ); diff --git a/bitmap2component/bitmap2component.cpp b/bitmap2component/bitmap2component.cpp index 3da52dfea8..a94fcbae1b 100644 --- a/bitmap2component/bitmap2component.cpp +++ b/bitmap2component/bitmap2component.cpp @@ -37,13 +37,6 @@ #include "auxiliary.h" -#ifndef max - #define max( a, b ) ( ( (a) > (b) ) ? (a) : (b) ) -#endif -#ifndef min - #define min( a, b ) ( ( (a) < (b) ) ? (a) : (b) ) -#endif - // Define some types used here from boost::polygon namespace bpl = boost::polygon; // bpl = boost polygon library using namespace bpl::operators; // +, -, =, ... @@ -476,7 +469,7 @@ void BezierToPolyline( std::vector & aCornersBuffer, * occur at an endpoint. */ dd0 = sq( p1.x - 2 * p2.x + p3.x ) + sq( p1.y - 2 * p2.y + p3.y ); dd1 = sq( p2.x - 2 * p3.x + p4.x ) + sq( p2.y - 2 * p3.y + p4.y ); - dd = 6 * sqrt( max( dd0, dd1 ) ); + dd = 6 * sqrt( fmax( dd0, dd1 ) ); e2 = 8 * delta <= dd ? 8 * delta / dd : 1; epsilon = sqrt( e2 ); /* necessary interval size */ diff --git a/common/common.cpp b/common/common.cpp index 7af9ba3e7c..bfae0c63df 100644 --- a/common/common.cpp +++ b/common/common.cpp @@ -418,7 +418,7 @@ int ReturnValueFromString( EDA_UNITS_T aUnit, const wxString& TextValue, int Int const LENGTH_UNIT_DESC MillimetreDesc = { - LENGTH_UNITS::millimetre(), + LENGTH_UNITS::millimetre(), wxT( "mm" ), 6 }; @@ -426,7 +426,7 @@ const LENGTH_UNIT_DESC MillimetreDesc = const LENGTH_UNIT_DESC InchDesc = { - LENGTH_UNITS::inch(), + LENGTH_UNITS::inch(), wxT( "\"" ), 7 }; @@ -434,7 +434,7 @@ const LENGTH_UNIT_DESC InchDesc = const LENGTH_UNIT_DESC MilDesc = { - LENGTH_UNITS::mil(), + LENGTH_UNITS::mil(), wxT( "mil" ), 5 }; @@ -442,7 +442,7 @@ const LENGTH_UNIT_DESC MilDesc = const LENGTH_UNIT_DESC UnscaledDesc = /* stub */ { - LENGTH_DEF::quantum(), + LENGTH_PCB::quantum(), wxT( "" ), 4 }; @@ -461,7 +461,7 @@ const LENGTH_UNIT_DESC *UnitDescription( EDA_UNITS_T aUnit ) { /* TODO: localisation */ -wxString LengthToString( const LENGTH_UNIT_DESC *aUnit, LENGTH_DEF aValue, +wxString LengthToString( const LENGTH_UNIT_DESC *aUnit, LENGTH_PCB aValue, bool aAdd_unit_symbol ) { wxString StringValue; double value_to_print; @@ -490,11 +490,11 @@ wxString LengthToString( const LENGTH_UNIT_DESC *aUnit, LENGTH_DEF aValue, return StringValue; } -LENGTH_DEF StringToLength( const LENGTH_UNIT_DESC *aUnit, const wxString& TextValue ) +LENGTH_PCB StringToLength( const LENGTH_UNIT_DESC *aUnit, const wxString& TextValue ) { - LENGTH_DEF Value; - double dtmp = 0; + LENGTH_PCB Value; + double dtmp = 0; /* Acquire the 'right' decimal point separator */ const struct lconv* lc = localeconv(); @@ -544,21 +544,21 @@ LENGTH_DEF StringToLength( const LENGTH_UNIT_DESC *aUnit, const wxString& TextVa aUnit = &MilDesc; } - Value = LENGTH_DEF( dtmp * LENGTH< double, 1 >( aUnit->m_Value ) ); + Value = LENGTH_PCB( dtmp * LENGTH< double, 1 >( aUnit->m_Value ) ); return Value; } -void LengthToTextCtrl( wxTextCtrl& TextCtr, LENGTH_DEF Value ) +void LengthToTextCtrl( wxTextCtrl& TextCtr, LENGTH_PCB Value ) { wxString msg = LengthToString( UnitDescription( g_UserUnit ), Value ); TextCtr.SetValue( msg ); } -LENGTH_DEF LengthFromTextCtrl( const wxTextCtrl& TextCtr ) +LENGTH_PCB LengthFromTextCtrl( const wxTextCtrl& TextCtr ) { - LENGTH_DEF value; + LENGTH_PCB value; wxString msg = TextCtr.GetValue(); value = StringToLength( UnitDescription( g_UserUnit ), msg ); diff --git a/common/projet_config.cpp b/common/projet_config.cpp index f382a1d48b..d9900f9467 100644 --- a/common/projet_config.cpp +++ b/common/projet_config.cpp @@ -802,3 +802,85 @@ void PARAM_CFG_LIBNAME_LIST::SaveParam( wxConfigBase* aConfig ) aConfig->Write( configkey, libname ); } } + +/* + * LENGTH_PCB + */ + +PARAM_CFG_LENGTH_PCB::PARAM_CFG_LENGTH_PCB( const wxChar* ident, + LENGTH_PCB* ptparam, + LENGTH_PCB default_val, + LENGTH_PCB min, + LENGTH_PCB max, + const wxChar* group ) : + PARAM_CFG_BASE( ident, PARAM_DOUBLE, group ) +{ + m_Pt_param = ptparam; + m_Default = default_val; + m_Min = min; + m_Max = max; +} + + +PARAM_CFG_LENGTH_PCB::PARAM_CFG_LENGTH_PCB( bool Insetup, + const wxChar* ident, + LENGTH_PCB* ptparam, + LENGTH_PCB default_val, + LENGTH_PCB min, + LENGTH_PCB max, + const wxChar* group ) : + PARAM_CFG_BASE( ident, PARAM_DOUBLE, group ) +{ + m_Pt_param = ptparam; + m_Default = default_val; + m_Min = min; + m_Max = max; + m_Setup = Insetup; +} + + +/** ReadParam + * read the value of parameter this stored in aConfig + * @param aConfig = the wxConfigBase that store the parameter + */ +void PARAM_CFG_LENGTH_PCB::ReadParam( wxConfigBase* aConfig ) +{ + if( m_Pt_param == NULL || aConfig == NULL ) + return; + + LENGTH_PCB ftmp; + wxString msg; + msg = aConfig->Read( m_Ident, wxT( "" ) ); + + if( msg.IsEmpty() ) + { + ftmp = m_Default; + } + else + { + double t; + msg.ToDouble( &t ); + ftmp = FROM_LEGACY_LU( t ); + + if( (ftmp < m_Min) || (ftmp > m_Max) ) + ftmp = m_Default; + } + + *m_Pt_param = ftmp; +} + + +/** SaveParam + * save the the value of parameter this stored in aConfig + * @param aConfig = the wxConfigBase that can store the parameter + */ +void PARAM_CFG_LENGTH_PCB::SaveParam( wxConfigBase* aConfig ) +{ + if( m_Pt_param == NULL || aConfig == NULL ) + return; +#ifdef KICAD_NANOMETRE + aConfig->Write( m_Ident, TO_LEGACY_LU_DBL( *m_Pt_param ) ); +#else // save it as int to mantain compatibility while in transition to nanoscale + aConfig->Write( m_Ident, TO_LEGACY_LU( *m_Pt_param ) ); +#endif +} diff --git a/gerbview/class_gerber_draw_item.h b/gerbview/class_gerber_draw_item.h index 83298c6c0f..a94e94930e 100644 --- a/gerbview/class_gerber_draw_item.h +++ b/gerbview/class_gerber_draw_item.h @@ -167,11 +167,15 @@ public: * @return const wxPoint& - The position of this object. * This function exists mainly to satisfy the virtual GetPosition() in parent class */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Start; // it had to be start or end. } + void SetPosition( const wxPoint& pos ) { + m_Start = pos; + } + /** * Function GetABPosition * returns the image position of aPosition for this object. diff --git a/include/class_board_item.h b/include/class_board_item.h index ead8d83f31..3b27117fc6 100644 --- a/include/class_board_item.h +++ b/include/class_board_item.h @@ -76,9 +76,19 @@ public: /** * Function GetPosition * returns the position of this object. - * @return wxPoint& - The position of this object, non-const so it can be changed + * @return wxPoint - The position of this object + * It seems this function could not return modifiable reference as this + * contradict good design practice: as the class could be able + * doing internal recalculations on reposition. + * @TODO: Check all the GetPosition calls for position assignments. */ - virtual wxPoint& GetPosition() = 0; + virtual const wxPoint GetPosition() const = 0; + + /** + * Sets the position of this object. + * @param pos The position of this object + */ + virtual void SetPosition( const wxPoint& pos ) = 0; /** * Function GetLayer @@ -313,10 +323,9 @@ public: {} //-----< satisfy some virtual functions >------------------------------ - wxPoint& GetPosition() + const wxPoint GetPosition() const { - static wxPoint dummy; - return dummy; + return wxPoint(0, 0); } void Draw( EDA_DRAW_PANEL* DrawPanel, wxDC* DC, diff --git a/include/common.h b/include/common.h index 0dca12e719..7e0560fb91 100644 --- a/include/common.h +++ b/include/common.h @@ -37,7 +37,7 @@ #ifdef KICAD_NANOMETRE -#include "length.h" +#include "lengthpcb.h" #endif class wxAboutDialogInfo; @@ -385,21 +385,21 @@ int ReturnValueFromTextCtrl( const wxTextCtrl& TextCtr, int Internal_Unit ); struct LENGTH_UNIT_DESC { - LENGTH_DEF m_Value; - const wxString m_Symbol; - int m_Precision; + LENGTH_PCB m_Value; + const wxString m_Symbol; + int m_Precision; }; extern const LENGTH_UNIT_DESC MillimetreDesc, InchDesc, MilDesc; const LENGTH_UNIT_DESC *UnitDescription( EDA_UNITS_T aUnit ); -LENGTH_DEF StringToLength( const LENGTH_UNIT_DESC *aUnit, const wxString& TextValue ); -wxString LengthToString( const LENGTH_UNIT_DESC *aUnit, LENGTH_DEF aValue, +LENGTH_PCB StringToLength( const LENGTH_UNIT_DESC *aUnit, const wxString& TextValue ); +wxString LengthToString( const LENGTH_UNIT_DESC *aUnit, LENGTH_PCB aValue, bool aAdd_unit_symbol = false ); -void LengthToTextCtrl( wxTextCtrl& TextCtr, LENGTH_DEF Value ); -LENGTH_DEF LengthFromTextCtrl( const wxTextCtrl& TextCtr ); +void LengthToTextCtrl( wxTextCtrl& TextCtr, LENGTH_PCB Value ); +LENGTH_PCB LengthFromTextCtrl( const wxTextCtrl& TextCtr ); /* transition macros */ #define STR_TO_LENGTH( unit, str, iu ) \ diff --git a/include/length.h b/include/length.h index 65c5266253..a723618c10 100644 --- a/include/length.h +++ b/include/length.h @@ -8,10 +8,64 @@ #ifndef LENGTH_H_INCLUDED #define LENGTH_H_INCLUDED 1 -#include "limited_int.h" +#include -/* type to be used by length units by default */ -typedef LIMITED_INT< int > DEF_LENGTH_VALUE; +template < typename T = double, int P = 1 > class LENGTH; + +template class LENGTH_UNITS; + +/*! + * The template that "inflate" LENGTH< T, 0 > class to T. Used with (*) and (/). + */ +template < typename T, int P > struct LENGTH_TRAITS +{ + typedef LENGTH flat; +}; + +template < typename T > struct LENGTH_TRAITS< T, 0 > +{ + /* length dimension to power 0 is just a number, so LENGTH should be automatically converted to T */ + typedef T flat; +}; + +/*! + * The template for value type conversions + */ +template < typename T > struct LENGTH_CASTS +{ + /*! This function to convert length value to given type T. */ + template< typename X > static T nearest( const X x ) + { + return T( x ); + } +}; + +template <> struct LENGTH_CASTS < int > +{ + static int nearest( const double x ) + { + return floor( x + 0.5 ); + } +}; + +template <> struct LENGTH_CASTS < long > +{ + static long nearest( const double x ) + { + return floor( x + 0.5 ); + } +}; + +/** Forward declaration for LIMITED_INT to use with casts. */ +template < typename T > class LIMITED_INT; + +template < typename T > struct LENGTH_CASTS < LIMITED_INT< T > > +{ + static LIMITED_INT< T > nearest( const double x ) + { + return LIMITED_INT< T > ( floor( x + 0.5 ) ); + } +}; /** * Length template class. @@ -34,7 +88,7 @@ typedef LIMITED_INT< int > DEF_LENGTH_VALUE; * - sqrt and cbrt result type should be instantiated before they used * Be aware when using them in complex formulae, e. g. * LENGTH< double, 1 > len = cbrt(vol) - is ok, but - * LENGTH< double, 2 > vol = sqrt(area*area*area*area)/length - will fail + * LENGTH< double, 3 > vol = sqrt(area*area*area*area)/length - will fail * if LENGTH<..., 4> is not instantiated * - non-integer power values do not supported * they should be implemented carefully using natural fractions, not floats, to be exact @@ -47,62 +101,6 @@ typedef LIMITED_INT< int > DEF_LENGTH_VALUE; * */ -template < typename T = DEF_LENGTH_VALUE, int P = 1 > class LENGTH; - -typedef LENGTH LENGTH_DEF; - -/** - * Length units contained in this class - */ - -template class LENGTH_UNITS; - -/** - * For internal needs - */ -template < typename T, int P > struct LENGTH_TRAITS -{ - typedef LENGTH flat; -}; - -template < typename T > struct LENGTH_CASTS -{ - template< typename X > static T cast( const X x ) - { - return T( x ); - } -}; - -template <> struct LENGTH_CASTS < int > -{ - static int cast( const double x ) - { - return floor( x + 0.5 ); - } -}; - -template <> struct LENGTH_CASTS < long > -{ - static long cast( const double x ) - { - return floor( x + 0.5 ); - } -}; - -template < typename T > struct LENGTH_CASTS < LIMITED_INT< T > > -{ - static LIMITED_INT< T > cast( const double x ) - { - return LIMITED_INT< T > ( floor( x + 0.5 ) ); - } -}; - -template < typename T > struct LENGTH_TRAITS< T, 0 > -{ - /* length dimension to power 0 is just a number, so LENGTH should be automatically converted to T */ - typedef T flat; -}; - template< typename T, int P > class LENGTH { friend class LENGTH_UNITS< T >; @@ -110,38 +108,45 @@ template< typename T, int P > class LENGTH template < typename Y, int R > friend class LENGTH; protected: - T m_U; - LENGTH( T units ) : m_U( units ) + T u; + + /** + * The 'direct' constructor which should not be accessed from outside + */ + LENGTH( T units ) : u( units ) { } - static T RawValue( const LENGTH &x ) - { - return x.m_U; - } - static T RawValue( const T& x ) - { - return x; - } + public: typedef T value_type; + enum { dimension = P }; + template< typename U > LENGTH( const LENGTH< U, P > &orig ) - : m_U( LENGTH_CASTS < T >::cast( orig.m_U ) ) + : u( LENGTH_CASTS < T >::nearest( orig.u ) ) { } - LENGTH( void ) : m_U() + + LENGTH( void ) : u() { } - + + /** + * Zero length of given type + * @return A zero + */ static LENGTH zero ( void ) { return T(0); } - /* Do not use this, please */ + /** + * Internal unit. Service function. Do not use this, please! + * @return An internal unit + */ static LENGTH quantum ( void ) { return T(1); @@ -149,134 +154,196 @@ public: LENGTH & operator = ( const LENGTH & y ) { - this->m_U = y.m_U; + this->u = y.u; return *this; } - template< typename Y > operator LENGTH< Y, P > ( void ) - { - return LENGTH< Y, P >( this->m_U ); - } - /*************************/ - /* comparisons and tests */ - /*************************/ + /** @} */ + + /** + * @defgroup length-comparisons Comparisons and tests + * @{ + */ bool operator ==( const LENGTH < T, P > y ) const { - return m_U == y.m_U; + return u == y.u; } + bool operator !=( const LENGTH < T, P > y ) const { - return m_U != y.m_U; + return u != y.u; } + bool operator <( const LENGTH < T, P > y ) const { - return m_U < y.m_U; + return u < y.u; } + bool operator >=( const LENGTH < T, P > y ) const { - return m_U >= y.m_U; + return u >= y.u; } + bool operator >( const LENGTH < T, P > y ) const { - return m_U > y.m_U; + return u > y.u; } + bool operator <=( const LENGTH < T, P > y ) const { - return m_U <= y.m_U; + return u <= y.u; } + bool operator !( void ) const { - return !m_U; + return !u; } - /*************************/ - /* basic arithmetic */ - /*************************/ + /** @} */ + + /** + * @defgroup length-arithmetic Basic arithmetic + * @{ + */ LENGTH< T, P > operator - ( void ) const { - return LENGTH(-this->m_U); + LENGTH< T, P > z; + z.u = -u; + return z; } - LENGTH< T, P > operator - ( const LENGTH< T, P > y ) const + + LENGTH< T, P >& operator -= ( const LENGTH< T, P > y ) { - return m_U - y.m_U; + u -= y.u; + return *this; } - LENGTH< T, P > operator + ( const LENGTH< T, P > y ) const + + friend LENGTH< T, P > operator - ( const LENGTH< T, P > x, const LENGTH< T, P > y ) { - return m_U + y.m_U; + LENGTH< T, P > z = x; + z -= y; + return z; } + + LENGTH< T, P >& operator += ( const LENGTH< T, P > y ) + { + u += y.u; + return *this; + } + + friend LENGTH< T, P > operator + ( const LENGTH< T, P > x, const LENGTH< T, P > y ) + { + LENGTH< T, P > z = x; + z += y; + return z; + } + + LENGTH< T, P >& operator *= ( const T y ) + { + u *= y; + return *this; + } + + LENGTH< T, P > operator * ( const T & y) const + { + LENGTH< T, P > z = *this; + z *= y; + return z; + } + template < int R > typename LENGTH_TRAITS< T, P + R >::flat operator * ( const LENGTH &y ) const { - return m_U * y.m_U; - } - LENGTH< T, P > operator * ( const T & y) const - { - return m_U * y; + LENGTH< T, P + R > z; + z.u = u * y.u; + return z; } + LENGTH< T, P > friend operator * ( const T &y, const LENGTH &x ) { - return x.m_U * y; - } - - template < int R > - typename LENGTH_TRAITS< T, P - R >::flat operator / ( const LENGTH &y ) const - { - return m_U / y.m_U; - } - LENGTH< T, P > operator / ( const T &y ) const - { - return m_U / y; - } - LENGTH< T, -P > friend operator / ( const T &y, const LENGTH< T, P > &x ) - { - return y / x.m_U; + return x.u * y; } - /*************************/ - /* assignment arithmetic */ - /*************************/ - LENGTH< T, P >& operator -= ( const LENGTH< T, P > y ) - { - m_U -= y.m_U; - return *this; - } - LENGTH< T, P >& operator += ( const LENGTH< T, P > y ) - { - m_U += y.m_U; - return *this; - } - LENGTH< T, P >& operator *= ( const T y ) - { - m_U *= y; - return *this; - } LENGTH< T, P >& operator /= ( const T y ) { - m_U /= y; + u /= y; return *this; } - - /*************************/ - /* more functions */ - /*************************/ + + LENGTH< T, P > operator / ( const T &y ) const + { + return u / y; + } + + template < int R > + typename LENGTH_TRAITS< T, P - R >::flat operator / ( const LENGTH< T, R > &y ) const + { + return u / y.u; + } + + LENGTH< T, -P > friend operator / ( const T &y, const LENGTH< T, P > &x ) + { + return y / x.u; + } + /** @} */ + + /** + * @defgroup length-algebra Algebraic functions + * @{ + */ + /** Absolute value. */ + friend LENGTH< T, P > abs( LENGTH< T, P > y ) + { + return 0 < y.u? y : -y; + } + + /** Maximum of two values. */ + friend LENGTH< T, P > max( LENGTH< T, P > x, LENGTH< T, P > y ) + { + LENGTH< T, P > z; + z.u = max( x.u, y.u ); + return z; + } + + /** Minimum of two values. */ + friend LENGTH< T, P > min( LENGTH< T, P > x, LENGTH< T, P > y ) + { + LENGTH< T, P > z; + z.u = min( x.u, y.u ); + return z; + } + + /** Square root. */ friend LENGTH< T, P > sqrt( LENGTH< T, P*2 > y ) { - return sqrt( y.m_U ); + LENGTH< T, P > z; + z.u = sqrt( y.u ); + return z; } + + /** Cubic root. */ friend LENGTH< T, P > cbrt( LENGTH< T, P*3 > y ) { - return cbrt( y.m_U ); + LENGTH< T, P > z; + z.u = cbrt( y.u ); + return z; } + + /** Hypothenuse of a triangle given katheti. */ friend LENGTH< T, P > hypot( LENGTH< T, P > x, LENGTH< T, P > y ) { - return hypot( x.m_U, y.m_U ); + LENGTH< T, P > z; + z.u = hypot( x.u, y.u ); + return z; } + + /** Direction of vector given cartesian coords. */ friend double atan2( LENGTH< T, P > x, LENGTH< T, P > y ) { - return atan2( double ( x.m_U ), double( y.m_U ) ); + return atan2( double ( x.u ), double( y.u ) ); } - + /** @} */ }; -/** +/*! * Units of length * * How to use them: @@ -293,43 +360,66 @@ public: * is going to use relative units. */ -template < typename T = DEF_LENGTH_VALUE > class LENGTH_UNITS { +template < typename T > class LENGTH_UNITS { protected: enum { - METRE = 1000000000, /* The ONLY constant connecting length to the real world */ - + METRE = 1000000000, /*!< The ONLY constant connecting length to the real world */ INCH = METRE / 10000 * 254 }; - public: - static LENGTH< T, 1 > metre( void ) { + +public: + /** One metre. */ + static LENGTH< T, 1 > metre( void ) + { return T( METRE ); } - static LENGTH< T, 1 > decimetre( void ) { + + /** One decimetre, 0.1 m. */ + static LENGTH< T, 1 > decimetre( void ) + { return T( METRE / 10 ); } - static LENGTH< T, 1 > centimetre( void ) { + + /** One centimetre, 0.01 m. */ + static LENGTH< T, 1 > centimetre( void ) + { return T( METRE / 100 ); } - static LENGTH< T, 1 > millimetre( void ) { + + /** One millimetre, 0.001 m. */ + static LENGTH< T, 1 > millimetre( void ) + { return T( METRE / 1000 ); } - static LENGTH< T, 1 > micrometre( void ) { + + /** One micrometre, 1E-6 m. */ + static LENGTH< T, 1 > micrometre( void ) + { return T( METRE / 1000000 ); } - static LENGTH< T, 1 > foot( void ) { /* do not think this will ever need */ + + /** One foot, 304.8 mm, 12 inch. */ + static LENGTH< T, 1 > foot( void ) + { return T( INCH * 12 ); } - static LENGTH< T, 1 > inch( void ) { + + /** One inch, 25.4 mm, 1/12 feet. */ + static LENGTH< T, 1 > inch( void ) + { return T( INCH ); } - static LENGTH< T, 1 > mil( void ) { + + /** One mil (or thou), 0.001 inch . */ + static LENGTH< T, 1 > mil( void ) + { return T( INCH / 1000 ); } }; /** - * shortcut to get units of given length type + * Shortcut to get units of given length type */ template < typename T, int D > class LENGTH_UNITS< LENGTH< T, D > >: public LENGTH_UNITS< T > { diff --git a/include/lengthpcb.h b/include/lengthpcb.h index 75a021fedb..fb508f330a 100644 --- a/include/lengthpcb.h +++ b/include/lengthpcb.h @@ -8,6 +8,7 @@ #ifdef KICAD_NANOMETRE #include "length.h" +#include "limited_int.h" /* switched type! */ typedef LENGTH< LIMITED_INT< int >, 1 > LENGTH_PCB; @@ -24,18 +25,24 @@ typedef LENGTH< double, 1 > LENGTH_PCB_DBL; #define TO_LEGACY_LU_DBL( x ) \ ( (double) ( LENGTH_PCB_DBL( x ) / PCB_LEGACY_UNIT( LENGTH_PCB_DBL ) ) ) -static LENGTH_PCB from_legacy_lu( int x ) { - return x * PCB_LEGACY_UNIT( LENGTH_PCB ); -} -static LENGTH_PCB from_legacy_lu( long x ) { - return x * PCB_LEGACY_UNIT( LENGTH_PCB ); -} -static LENGTH_PCB from_legacy_lu( double x ) { - return LENGTH_PCB( x * PCB_LEGACY_UNIT( LENGTH_PCB_DBL ) ); +static LENGTH_PCB from_legacy_lu( int x ) +{ + return x * PCB_LEGACY_UNIT( LENGTH_PCB ); } -static LENGTH_PCB_DBL from_legacy_lu_dbl( double x ) { - return x * LENGTH_UNITS< LENGTH_PCB_DBL >::inch() / PCB_LEGACY_INCH_SCALE; +static LENGTH_PCB from_legacy_lu( long x ) +{ + return x * PCB_LEGACY_UNIT( LENGTH_PCB ); +} + +static LENGTH_PCB from_legacy_lu( double x ) +{ + return LENGTH_PCB( x * PCB_LEGACY_UNIT( LENGTH_PCB_DBL ) ); +} + +static LENGTH_PCB_DBL from_legacy_lu_dbl( double x ) +{ + return x * LENGTH_UNITS< LENGTH_PCB_DBL >::inch() / PCB_LEGACY_INCH_SCALE; } #define FROM_LEGACY_LU( x ) ( from_legacy_lu( x ) ) @@ -43,7 +50,6 @@ static LENGTH_PCB_DBL from_legacy_lu_dbl( double x ) { #define ZERO_LENGTH ( LENGTH_PCB::zero() ) - /* SAVE FILE macros */ #define FM_LENSV "%lf" ///< format specifier for saving #define ARG_LENSV( x ) TO_LEGACY_LU_DBL( x ) ///< argument for saving @@ -63,6 +69,7 @@ typedef double LENGTH_PCB_DBL; #define ZERO_LENGTH 0 + /* SAVE FILE macros */ /** @TODO: after transition process this could be wrapped in some class */ #define FM_LENSV "%d" @@ -70,6 +77,7 @@ typedef double LENGTH_PCB_DBL; #endif + /* LOAD FILE macros */ #define FM_LENLD "%lf" ///< scanf format macro for loading #define ARG_LENLD_TYPE double ///< tmp variable for length read @@ -80,55 +88,7 @@ typedef double LENGTH_PCB_DBL; #define LENGTH_LOAD_TMP( x ) ( FROM_LEGACY_LU( x ) ) ///< reads tmp value from above #define LENGTH_LOAD_STR( s ) ( FROM_LEGACY_LU( atof( s ) ) ) ///< reads string - -/// @TODO: nice template and refiling for it -struct VECTOR_PCB -{ - LENGTH_PCB x, y; - VECTOR_PCB() - { - } - VECTOR_PCB( LENGTH_PCB ax, LENGTH_PCB ay ): x( ax ), y( ay ) - { - } - bool operator == ( const VECTOR_PCB &a ) const { - return x == a.x && y == a.y; - } - bool operator != ( const VECTOR_PCB &a ) const { - return x != a.x || y != a.y; - } - VECTOR_PCB & operator = (const VECTOR_PCB &a ) { - x = a.x; - y = a.y; - return *this; - } - VECTOR_PCB & operator += (const VECTOR_PCB &a ) { - x += a.x; - y += a.y; - return *this; - } - VECTOR_PCB & operator -= (const VECTOR_PCB &a ) { - x -= a.x; - y -= a.y; - return *this; - } - VECTOR_PCB operator + (VECTOR_PCB add) const { - return VECTOR_PCB(x + add.x, y + add.y); - } - VECTOR_PCB operator - (VECTOR_PCB add) const { - return VECTOR_PCB(x - add.x, y - add.y); - } - VECTOR_PCB operator * (int factor) const { - return VECTOR_PCB(x * factor, y * factor); - } - VECTOR_PCB operator / (int factor) const { - return VECTOR_PCB(x / factor, y / factor); - } -}; - -#define TO_LEGACY_LU_WXP( p ) ( wxPoint( TO_LEGACY_LU( ( p ).x ), TO_LEGACY_LU( ( p ).y ) ) ) -#define TO_LEGACY_LU_WXS( p ) ( wxSize( TO_LEGACY_LU( ( p ).x ), TO_LEGACY_LU( ( p ).y ) ) ) -#define FROM_LEGACY_LU_VEC( p ) ( VECTOR_PCB( FROM_LEGACY_LU( ( p ).x ), FROM_LEGACY_LU( ( p ).y ) ) ) - +/* used fo loading/saving config */ +#define LENGTH_MAX_CONFIG ( FROM_LEGACY_LU( 393700 ) ) #endif /* def LENGTHPCB_H_INCLUDED */ diff --git a/include/limited_int.h b/include/limited_int.h index f87e33a3bf..474f707417 100644 --- a/include/limited_int.h +++ b/include/limited_int.h @@ -15,21 +15,25 @@ template < typename T = int > class LIMITED_INT { private: T m_Value; + public: LIMITED_INT( void ) : m_Value() { } + template LIMITED_INT( const LIMITED_INT< V >& orig ) : m_Value( orig.m_Value ) { assert(std::numeric_limits::min() <= orig.m_Value); assert(orig.m_Value <= std::numeric_limits::max()); } + template LIMITED_INT( const double v ) : m_Value( floor(v+0.5) ) { assert(std::numeric_limits::min() <= v); assert(v <= std::numeric_limits::max()); } + LIMITED_INT( T v ): m_Value( v ) { } @@ -38,6 +42,7 @@ public: { return m_Value; } + operator double( void ) const { return ( double )m_Value; @@ -48,11 +53,13 @@ public: m_Value = src.m_Value; return *this; } + LIMITED_INT & operator = ( T src ) { m_Value = src; return *this; } + /*************************/ /* comparisons and tests */ /*************************/ @@ -64,10 +71,12 @@ public: { return m_Value == y.m_Value; } + bool operator == ( const T y ) const { return m_Value == y; } + friend bool operator == ( const T x, const LIMITED_INT< T > &y ) { return x == y.m_Value; @@ -77,10 +86,12 @@ public: { return m_Value != y.m_Value; } + bool operator != ( const T y ) const { return m_Value != y; } + friend bool operator != ( const T x, const LIMITED_INT< T > &y ) { return x != y.m_Value; @@ -90,10 +101,12 @@ public: { return m_Value < y.m_Value; } + bool operator < ( const T y ) const { return m_Value < y; } + friend bool operator < ( const T x, const LIMITED_INT< T > &y ) { return x < y.m_Value; @@ -103,10 +116,12 @@ public: { return m_Value >= y.m_Value; } + bool operator >= ( const T y ) const { return m_Value >= y; } + friend bool operator >= ( const T x, const LIMITED_INT &y ) { return x >= y.m_Value; @@ -116,10 +131,12 @@ public: { return m_Value > y.m_Value; } + bool operator > ( const T y ) const { return m_Value > y; } + friend bool operator > ( const T x, const LIMITED_INT< T > &y ) { return x > y.m_Value; @@ -129,10 +146,12 @@ public: { return m_Value <= y.m_Value; } + bool operator <= ( const T y ) const { return m_Value <= y; } + friend bool operator <= ( const T x, const LIMITED_INT< T > &y ) { return x <= y.m_Value; @@ -147,18 +166,22 @@ public: assert( !( m_Value < 0 ) || std::numeric_limits< T >::min() - m_Value <= y.m_Value ); return m_Value + y.m_Value; } + LIMITED_INT< T > operator + ( const T y ) const { return *this + LIMITED_INT< T >( y ); } + friend LIMITED_INT< T > operator + ( const T x, const LIMITED_INT< T > &y ) { return LIMITED_INT< T >( x ) + y; } + double operator + ( const double y ) const { return double( m_Value ) + y; } + friend double operator + ( const double x, const LIMITED_INT< T > &y ) { return x + double( y.m_Value ); @@ -169,24 +192,29 @@ public: assert( -std::numeric_limits< T >::max() <= m_Value ); return -m_Value; } + LIMITED_INT< T > operator - ( const LIMITED_INT< T > &y ) const { assert( !( 0 < m_Value ) || m_Value - std::numeric_limits< T >::max() <= y.m_Value ); assert( !( m_Value < 0 ) || y.m_Value <= m_Value - std::numeric_limits< T >::min() ); return m_Value - y.m_Value; } + LIMITED_INT< T > operator - ( const T y ) const { return *this - LIMITED_INT< T >( y ); } + friend LIMITED_INT< T > operator - ( const T x, const LIMITED_INT< T > &y ) { return LIMITED_INT< T >( x ) - y; } + double operator - ( const double y ) const { return double( m_Value ) - y; } + friend double operator - ( const double x, const LIMITED_INT< T > &y ) { return x - double( y.m_Value ); @@ -204,18 +232,22 @@ public: || std::numeric_limits::max() / m_Value <= y.m_Value ); return m_Value * y.m_Value; } + LIMITED_INT operator * ( const T y) const { return *this * LIMITED_INT< T >( y ); } + friend LIMITED_INT< T > operator *( const T x, const LIMITED_INT< T > &y ) { return LIMITED_INT< T >( x ) * y; } + double operator * ( const double y ) const { return double( m_Value ) * y; } + friend double operator * ( const double x, const LIMITED_INT< T > &y ) { return x * double( y.m_Value ); @@ -227,18 +259,22 @@ public: || -std::numeric_limits< T >::max() <= m_Value ); return m_Value / y.m_Value; } + LIMITED_INT operator / ( const T y ) const { return *this / LIMITED_INT(y); } + friend LIMITED_INT< T > operator / ( const T x, const LIMITED_INT< T > &y ) { return LIMITED_INT< T >( x ) / y; } + double operator / ( const double y ) const { return double( m_Value ) / y; } + friend double operator / ( const double x, const LIMITED_INT< T > &y ) { return x / double( y.m_Value ); @@ -248,62 +284,71 @@ public: { return m_Value % y.m_Value; } + LIMITED_INT operator % ( const T y ) const { return *this % LIMITED_INT(y); } + friend LIMITED_INT< T > operator % ( const T x, const LIMITED_INT< T > &y ) { return LIMITED_INT< T >( x ) % y; } - /*************************/ - /* assignment arithmetic */ - /*************************/ + LIMITED_INT< T >& operator += ( const LIMITED_INT< T > &y ) { *this = *this + y; return *this; } + LIMITED_INT< T >& operator += ( const T y ) { *this = *this + y; return *this; } + LIMITED_INT< T >& operator ++ ( void ) { *this = *this + 1; return *this; } + LIMITED_INT< T >& operator -= ( const LIMITED_INT< T > &y ) { *this = *this - y; return *this; } + LIMITED_INT< T >& operator -= ( const T y ) { *this = *this - y; return *this; } + LIMITED_INT< T >& operator -- ( void ) { *this = *this - 1; return *this; } + LIMITED_INT< T >& operator *= ( const LIMITED_INT< T > &y ) { *this = *this * y; return *this; } + LIMITED_INT< T >& operator *= ( const T y ) { *this = *this * y; return *this; } + LIMITED_INT< T >& operator /= ( const LIMITED_INT< T > &y ) { *this = *this / y; return *this; } + LIMITED_INT< T >& operator /= ( const T y ) { *this = *this / y; diff --git a/include/param_config.h b/include/param_config.h index 436386fc96..a8262305d5 100644 --- a/include/param_config.h +++ b/include/param_config.h @@ -10,6 +10,7 @@ #include "wx/fileconf.h" #include +#include "lengthpcb.h" /** Type of parameter in the configuration file */ enum paramcfg_id { @@ -85,6 +86,35 @@ public: PARAM_CFG_INT( const wxChar* ident, int* ptparam, virtual void SaveParam( wxConfigBase* aConfig ); }; +/** + * Configuration parameter - Length PCB Class + * + */ +class PARAM_CFG_LENGTH_PCB : public PARAM_CFG_BASE +{ +public: + LENGTH_PCB * m_Pt_param; ///< Pointer to the parameter value + LENGTH_PCB m_Min, m_Max; ///< Minimum and maximum values of the param type + LENGTH_PCB m_Default; ///< The default value of the parameter + +public: + PARAM_CFG_LENGTH_PCB( const wxChar* ident, /// @TODO: remove hardcoded constants + LENGTH_PCB* ptparam, + LENGTH_PCB default_val = ZERO_LENGTH, + LENGTH_PCB min = -LENGTH_MAX_CONFIG, + LENGTH_PCB max = LENGTH_MAX_CONFIG, + const wxChar* group = NULL ); + PARAM_CFG_LENGTH_PCB( bool Insetup, + const wxChar* ident, + LENGTH_PCB* ptparam, + LENGTH_PCB default_val = ZERO_LENGTH, + LENGTH_PCB min = -LENGTH_MAX_CONFIG, + LENGTH_PCB max = LENGTH_MAX_CONFIG, + const wxChar* group = NULL ); + + virtual void ReadParam( wxConfigBase* aConfig ); + virtual void SaveParam( wxConfigBase* aConfig ); +}; /** * Configuration parameter - SetColor Class diff --git a/include/vectorpcb.h b/include/vectorpcb.h new file mode 100644 index 0000000000..2a744e27a6 --- /dev/null +++ b/include/vectorpcb.h @@ -0,0 +1,162 @@ +/** + * @file vectorpcb.h + * @brief Planar vector definitions for PCBNEW. + */ + +#ifndef VECTORPCB_H_INCLUDED +#define VECTORPCB_H_INCLUDED 1 + +/// @TODO: nice template and refiling for it +class VECTOR_PCB +{ +public: + LENGTH_PCB data[2]; + + /** A vector from pair of coords. Constructor is avoided in favor to POD-like object. + */ + static VECTOR_PCB fromXY( LENGTH_PCB x, LENGTH_PCB y ) + { + VECTOR_PCB z = { { x, y } }; + return z; + } + + /** @defgroup vector-elements Access individual attributes + * @{ + */ + LENGTH_PCB &operator[]( int i ) + { + return data[i]; + } + + const LENGTH_PCB &operator[]( int i ) const + { + return data[i]; + } + + /** @} */ + + /** @defgroup vector-cartesian Access to cartesian coordinates + * Definitions follow the agreement: + * - methods are named exactly as attributes, thus setter and getter have same name; + * - all methods (setters and getterrs) return actual attribute value; + * - method without argument gets the attribute; + * - method with argument sets it to argument value. + * These methods different than operator[] + * because vector actually may have any storage layout, + * so cartesian coords may be calculated rahter than actually stored. + * E. g. homogeneous coordinates is likely to be used in perspective. + * @{ + */ + + const LENGTH_PCB x() const + { + return data[0]; + } + + const LENGTH_PCB x( LENGTH_PCB nx ) + { + return data[0] = nx; + } + + const LENGTH_PCB y() const + { + return data[1]; + } + + const LENGTH_PCB y( LENGTH_PCB ny ) + { + return data[1] = ny; + } + + /** @} */ + + /** @defgroup vector-comparisons Compare vectors + * @{ + */ + + bool operator == ( const VECTOR_PCB &b ) const + { + return data[0] == b.data[0] && data[1] == b.data[1]; + } + + bool operator != ( const VECTOR_PCB &b ) const + { + return !(*this == b); + } + + /** @} */ + + /** @defgroup vector-arithmetic Arithmetic operations on vectors + * @{ + */ + + VECTOR_PCB & operator -= ( const VECTOR_PCB &b ) + { + data[0] -= b.data[0]; + data[1] -= b.data[1]; + return *this; + } + + VECTOR_PCB operator - ( const VECTOR_PCB &b ) const + { + VECTOR_PCB z = *this; + z -= b; + return z; + } + + VECTOR_PCB & operator += ( const VECTOR_PCB &b ) + { + data[0] += b.data[0]; + data[1] += b.data[1]; + return *this; + } + + VECTOR_PCB operator + ( VECTOR_PCB b ) const + { + VECTOR_PCB z = *this; + z += b; + return z; + } + + VECTOR_PCB & operator *= ( int b ) + { + data[0] *= b; + data[1] *= b; + return *this; + } + + VECTOR_PCB operator * ( int b ) const + { + VECTOR_PCB z = *this; + z *= b; + return z; + } + + VECTOR_PCB & operator /= ( int b ) + { + data[0] /= b; + data[1] /= b; + return *this; + } + + VECTOR_PCB operator / ( int b ) const + { + VECTOR_PCB z = *this; + z /= b; + return z; + } + + /** @} */ +}; + +#define TO_LEGACY_LU_WXP( p ) ( wxPoint( \ + TO_LEGACY_LU( ( p )[0] ), \ + TO_LEGACY_LU( ( p )[1] ) ) ) +#define TO_LEGACY_LU_WXS( p ) ( wxSize( \ + TO_LEGACY_LU( ( p )[0] ), \ + TO_LEGACY_LU( ( p )[1] ) ) ) +#define FROM_LEGACY_LU_VEC( p ) ( VECTOR_PCB::fromXY( \ + FROM_LEGACY_LU( ( p ).x ), \ + FROM_LEGACY_LU( ( p ).y ) ) ) + +#endif /* def VECTORPCB_H_INCLUDED */ diff --git a/pcbnew/block_module_editor.cpp b/pcbnew/block_module_editor.cpp index 0f18df1901..5c10493dfa 100644 --- a/pcbnew/block_module_editor.cpp +++ b/pcbnew/block_module_editor.cpp @@ -538,7 +538,7 @@ void MirrorMarkedItems( MODULE* module, wxPoint offset ) { #define SETMIRROR( z ) (z) -= offset.x; (z) = -(z); (z) += offset.x; EDA_ITEM* item; - + wxPoint tmp; if( module == NULL ) return; @@ -549,10 +549,12 @@ void MirrorMarkedItems( MODULE* module, wxPoint offset ) if( pad->m_Selected == 0 ) continue; - SETMIRROR( pad->GetPosition().x ); - pad->m_Pos0.x = FROM_LEGACY_LU( pad->GetPosition().x ); - NEGATE( pad->m_Offset.x ); - NEGATE( pad->m_DeltaSize.x ); + tmp = pad->GetPosition(); + SETMIRROR( tmp.x ); + pad->SetPosition( tmp ); + pad->m_Pos0.x( FROM_LEGACY_LU( pad->GetPosition().x ) ); + pad->m_Offset.x( -pad->m_Offset.x() ); + pad->m_DeltaSize.x( -pad->m_DeltaSize.x() ); pad->m_Orient = 1800 - pad->m_Orient; NORMALIZE_ANGLE_POS( pad->m_Orient ); } @@ -578,7 +580,9 @@ void MirrorMarkedItems( MODULE* module, wxPoint offset ) break; case PCB_MODULE_TEXT_T: - SETMIRROR( ( (TEXTE_MODULE*) item )->GetPosition().x ); + tmp = ( (TEXTE_MODULE*) item )->GetPosition(); + SETMIRROR( tmp.x ); + ( (TEXTE_MODULE*) item )->SetPosition( tmp ); ( (TEXTE_MODULE*) item )->m_Pos0.x = ( (TEXTE_MODULE*) item )->GetPosition().x; break; @@ -608,8 +612,9 @@ void RotateMarkedItems( MODULE* module, wxPoint offset ) { if( pad->m_Selected == 0 ) continue; - - ROTATE( pad->GetPosition() ); + wxPoint pos = pad->GetPosition(); + ROTATE( pos ); + pad->SetPosition( pos ); pad->m_Pos0 = FROM_LEGACY_LU_VEC( pad->GetPosition() ); pad->m_Orient += 900; NORMALIZE_ANGLE_POS( pad->m_Orient ); @@ -632,7 +637,11 @@ void RotateMarkedItems( MODULE* module, wxPoint offset ) break; case PCB_MODULE_TEXT_T: - ROTATE( ( (TEXTE_MODULE*) item )->GetPosition() ); + { + wxPoint pos = ( (TEXTE_MODULE*) item )->m_Pos; + ROTATE( pos ); + ( (TEXTE_MODULE*) item )->m_Pos = pos; + } ( (TEXTE_MODULE*) item )->m_Pos0 = ( (TEXTE_MODULE*) item )->GetPosition(); ( (TEXTE_MODULE*) item )->m_Orient += 900; break; diff --git a/pcbnew/board_items_to_polygon_shape_transform.cpp b/pcbnew/board_items_to_polygon_shape_transform.cpp index ef6b7d3840..f99d9edac3 100644 --- a/pcbnew/board_items_to_polygon_shape_transform.cpp +++ b/pcbnew/board_items_to_polygon_shape_transform.cpp @@ -328,8 +328,8 @@ void D_PAD:: TransformShapeWithClearanceToPolygon( std:: vector < CPolyPt>& aCor { wxPoint corner_position; int ii, angle; - int dx = TO_LEGACY_LU( m_Size.x / 2 ) + aClearanceValue; - int dy = TO_LEGACY_LU( m_Size.y / 2 ) + aClearanceValue; + int dx = TO_LEGACY_LU( m_Size.x() / 2 ) + aClearanceValue; + int dy = TO_LEGACY_LU( m_Size.y() / 2 ) + aClearanceValue; int delta = 3600 / aCircleToSegmentsCount; // rot angle in 0.1 degree wxPoint PadShapePos = ReturnShapePos(); /* Note: for pad having a shape offset, @@ -437,8 +437,8 @@ void D_PAD:: TransformShapeWithClearanceToPolygon( std:: vector < CPolyPt>& aCor default: case PAD_TRAPEZOID: - psize.x += TO_LEGACY_LU( ABS( m_DeltaSize.y ) ); - psize.y += TO_LEGACY_LU( ABS( m_DeltaSize.x ) ); + psize.x += TO_LEGACY_LU( abs( m_DeltaSize.y() ) ); + psize.y += TO_LEGACY_LU( abs( m_DeltaSize.x() ) ); // fall through case PAD_RECT: @@ -572,8 +572,8 @@ void CreateThermalReliefPadPolygon( std::vector& 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 = TO_LEGACY_LU( aPad.m_Size.x / 2 ); - int dy = TO_LEGACY_LU( aPad.m_Size.y / 2 ); + int dx = TO_LEGACY_LU( aPad.m_Size.x() / 2 ); + int dy = TO_LEGACY_LU( aPad.m_Size.y() / 2 ); int delta = 3600 / aCircleToSegmentsCount; // rot angle in 0.1 degree @@ -684,8 +684,8 @@ void CreateThermalReliefPadPolygon( std::vector& aCornerBuffer, // Oval pad support along the lines of round and rectangular pads std::vector corners_buffer; // Polygon buffer as vector - int dx = TO_LEGACY_LU( aPad.m_Size.x / 2 ) + aThermalGap; // Cutout radius x - int dy = TO_LEGACY_LU( aPad.m_Size.y / 2 ) + aThermalGap; // Cutout radius y + int dx = TO_LEGACY_LU( aPad.m_Size.x() / 2 ) + aThermalGap; // Cutout radius x + int dy = TO_LEGACY_LU( aPad.m_Size.y() / 2 ) + aThermalGap; // Cutout radius y wxPoint shape_offset; @@ -839,8 +839,8 @@ void CreateThermalReliefPadPolygon( std::vector& aCornerBuffer, std::vector corners_buffer; // Polygon buffer as vector - int dx = TO_LEGACY_LU( aPad.m_Size.x / 2 ) + aThermalGap; // Cutout radius x - int dy = TO_LEGACY_LU( aPad.m_Size.y / 2 ) + aThermalGap; // Cutout radius y + int dx = TO_LEGACY_LU( aPad.m_Size.x() / 2 ) + aThermalGap; // Cutout radius x + int dy = TO_LEGACY_LU( 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 diff --git a/pcbnew/class_board.cpp b/pcbnew/class_board.cpp index fd96499355..6560d3e2a7 100644 --- a/pcbnew/class_board.cpp +++ b/pcbnew/class_board.cpp @@ -647,13 +647,13 @@ bool BOARD::IsModuleLayerVisible( int layer ) -wxPoint& BOARD::GetPosition() +const wxPoint BOARD::GetPosition() const { - static wxPoint dummy( 0, 0 ); - - return dummy; // a reference + return wxPoint ( 0, 0 ); } +void BOARD::SetPosition( const wxPoint& pos ) { +} void BOARD::Add( BOARD_ITEM* aBoardItem, int aControl ) { @@ -1668,7 +1668,7 @@ D_PAD* BOARD::GetPadFast( const wxPoint& aPosition, int aLayerMask ) { D_PAD* pad = m_NetInfo->GetPad(i); - if( pad->m_Pos != aPosition ) + if( TO_LEGACY_LU_WXP( pad->m_Pos ) != aPosition ) continue; /* Pad found, it must be on the correct layer */ @@ -1699,7 +1699,7 @@ D_PAD* BOARD::GetPad( std::vector& aPadList, const wxPoint& aPosition, i D_PAD* pad = aPadList[idx]; - if( pad->m_Pos == aPosition ) // candidate found + if( TO_LEGACY_LU_WXP( pad->m_Pos ) == aPosition ) // candidate found { // The pad must match the layer mask: if( (aLayerMask & pad->m_layerMask) != 0 ) @@ -1712,7 +1712,7 @@ D_PAD* BOARD::GetPad( std::vector& aPadList, const wxPoint& aPosition, i for( int ii = idx+1; ii <= idxmax; ii++ ) { pad = aPadList[ii]; - if( pad->m_Pos != aPosition ) + if( TO_LEGACY_LU_WXP( pad->m_Pos ) != aPosition ) break; if( (aLayerMask & pad->m_layerMask) != 0 ) return pad; @@ -1721,7 +1721,7 @@ D_PAD* BOARD::GetPad( std::vector& aPadList, const wxPoint& aPosition, i for( int ii = idx-1 ;ii >=0; ii-- ) { pad = aPadList[ii]; - if( pad->m_Pos != aPosition ) + if( TO_LEGACY_LU_WXP( pad->m_Pos ) != aPosition ) break; if( (aLayerMask & pad->m_layerMask) != 0 ) return pad; @@ -1731,9 +1731,9 @@ D_PAD* BOARD::GetPad( std::vector& aPadList, const wxPoint& aPosition, i return 0; } - if( pad->m_Pos.x == aPosition.x ) // Must search considering Y coordinate + if( TO_LEGACY_LU( pad->m_Pos.x() ) == aPosition.x ) // Must search considering Y coordinate { - if(pad->m_Pos.y < aPosition.y) // Must search after this item + if( TO_LEGACY_LU( pad->m_Pos.y() ) < aPosition.y ) // Must search after this item { idx += delta; if( idx > idxmax ) @@ -1746,7 +1746,7 @@ D_PAD* BOARD::GetPad( std::vector& aPadList, const wxPoint& aPosition, i idx = 0; } } - else if( pad->m_Pos.x < aPosition.x ) // Must search after this item + else if( TO_LEGACY_LU( pad->m_Pos.x() ) < aPosition.x ) // Must search after this item { idx += delta; if( idx > idxmax ) @@ -1770,9 +1770,9 @@ D_PAD* BOARD::GetPad( std::vector& 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 ) - return ref->m_Pos.y < comp->m_Pos.y; - return ref->m_Pos.x < comp->m_Pos.x; + if( ref->m_Pos.x() == comp->m_Pos.x() ) + return ref->m_Pos.y() < comp->m_Pos.y(); + return ref->m_Pos.x() < comp->m_Pos.x(); } diff --git a/pcbnew/class_board.h b/pcbnew/class_board.h index cf17307a17..fd91b05426 100644 --- a/pcbnew/class_board.h +++ b/pcbnew/class_board.h @@ -226,7 +226,9 @@ public: * is a dummy. * @return const wxPoint& of (0,0) */ - wxPoint& GetPosition(); + const wxPoint GetPosition() const; + + void SetPosition( const wxPoint& pos ); /** * Function Add diff --git a/pcbnew/class_dimension.h b/pcbnew/class_dimension.h index e2cc04e175..2d617ae197 100644 --- a/pcbnew/class_dimension.h +++ b/pcbnew/class_dimension.h @@ -37,11 +37,15 @@ public: DIMENSION( BOARD_ITEM* aParent ); ~DIMENSION(); - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Pos; } + void SetPosition( const wxPoint& pos ) { + m_Pos = pos; + } + /** * Function SetLayer * sets the layer this item is on. diff --git a/pcbnew/class_drawsegment.h b/pcbnew/class_drawsegment.h index 4da03f3e62..de1772da16 100644 --- a/pcbnew/class_drawsegment.h +++ b/pcbnew/class_drawsegment.h @@ -44,13 +44,17 @@ public: * Function GetPosition * returns the position of this object. * Required by pure virtual BOARD_ITEM::GetPosition() - * @return const wxPoint& - The position of this object. + * @return const wxPoint - The position of this object. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Start; } + void SetPosition( const wxPoint& pos ) { + m_Start = pos; + } + /** * Function GetStart * returns the starting point of the graphic diff --git a/pcbnew/class_marker_pcb.h b/pcbnew/class_marker_pcb.h index 2396061164..f6c7a2dcb3 100644 --- a/pcbnew/class_marker_pcb.h +++ b/pcbnew/class_marker_pcb.h @@ -81,11 +81,14 @@ public: * Function GetPosition * returns the position of this MARKER_PCB. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { - return (wxPoint&) m_Pos; + return m_Pos; } + void SetPosition( const wxPoint& pos ) { + m_Pos = pos; + } /** * Function HitTest diff --git a/pcbnew/class_mire.h b/pcbnew/class_mire.h index 8106a3874b..4cd6fe29f1 100644 --- a/pcbnew/class_mire.h +++ b/pcbnew/class_mire.h @@ -30,11 +30,14 @@ public: PCB_TARGET* Next() const { return (PCB_TARGET*) Pnext; } PCB_TARGET* Back() const { return (PCB_TARGET*) Pnext; } - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Pos; } + void SetPosition( const wxPoint& pos ) { + m_Pos = pos; + } /** * Function Move diff --git a/pcbnew/class_module.cpp b/pcbnew/class_module.cpp index 9715d74a4e..280a1451b6 100644 --- a/pcbnew/class_module.cpp +++ b/pcbnew/class_module.cpp @@ -534,9 +534,10 @@ int MODULE::ReadDescr( LINE_READER* aReader ) { D_PAD* pad = new D_PAD( this ); pad->ReadDescr( aReader ); - RotatePoint( &pad->m_Pos, m_Orient ); - pad->m_Pos.x += m_Pos.x; - pad->m_Pos.y += m_Pos.y; + wxPoint pos = TO_LEGACY_LU_WXP( pad->m_Pos ); + RotatePoint( &pos, m_Orient ); + pad->m_Pos = FROM_LEGACY_LU_VEC( pos ); + pad->m_Pos += FROM_LEGACY_LU_VEC( m_Pos ); m_Pads.PushBack( pad ); continue; diff --git a/pcbnew/class_module.h b/pcbnew/class_module.h index 881b9d1f3e..5964e61395 100644 --- a/pcbnew/class_module.h +++ b/pcbnew/class_module.h @@ -135,9 +135,9 @@ public: * Function GetPosition * returns the position of this object. * Required by pure virtual BOARD_ITEM::GetPosition() - * @return const wxPoint& - The position of this object. + * @return const wxPoint - The position of this object. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Pos; } diff --git a/pcbnew/class_module_transform_functions.cpp b/pcbnew/class_module_transform_functions.cpp index e6637a957a..79d4eb1a07 100644 --- a/pcbnew/class_module_transform_functions.cpp +++ b/pcbnew/class_module_transform_functions.cpp @@ -183,12 +183,24 @@ void MODULE::Flip(const wxPoint& aCentre ) for( ; pt_pad != NULL; pt_pad = pt_pad->Next() ) { - pt_pad->m_Pos.y -= m_Pos.y; - pt_pad->m_Pos.y = -pt_pad->m_Pos.y; - pt_pad->m_Pos.y += m_Pos.y; - NEGATE( pt_pad->m_Pos0.y ); - NEGATE( pt_pad->m_Offset.y ); - NEGATE( pt_pad->m_DeltaSize.y ); + LENGTH_PCB tmpy = pt_pad->m_Pos.y(); + tmpy -= FROM_LEGACY_LU( m_Pos.y ); + tmpy = -tmpy; + tmpy += FROM_LEGACY_LU( m_Pos.y ); + pt_pad->m_Pos.y( tmpy ); + + tmpy = pt_pad->m_Pos0.y(); + NEGATE( tmpy ); + pt_pad->m_Pos0.y( tmpy ); + + tmpy = pt_pad->m_Offset.y(); + NEGATE( tmpy ); + pt_pad->m_Offset.y( tmpy ); + + pt_pad->m_DeltaSize.y(); + NEGATE( tmpy ); + pt_pad->m_DeltaSize.y( tmpy ); + NEGATE_AND_NORMALIZE_ANGLE_POS( pt_pad->m_Orient ); /* flip pads layers*/ @@ -308,7 +320,7 @@ void MODULE::SetPosition( const wxPoint& newpos ) for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { - pad->m_Pos += delta; + pad->m_Pos += FROM_LEGACY_LU_VEC( delta ); } EDA_ITEM* PtStruct = m_Drawings; @@ -352,15 +364,15 @@ void MODULE::SetOrientation( int newangle ) for( D_PAD* pad = m_Pads; pad; pad = pad->Next() ) { - px = TO_LEGACY_LU( pad->m_Pos0.x ); - py = TO_LEGACY_LU( pad->m_Pos0.y ); + px = TO_LEGACY_LU( pad->m_Pos0.x() ); + py = TO_LEGACY_LU( pad->m_Pos0.y() ); pad->m_Orient += newangle; /* change m_Orientation */ NORMALIZE_ANGLE_POS( pad->m_Orient ); RotatePoint( &px, &py, m_Orient ); - pad->m_Pos.x = m_Pos.x + px; - pad->m_Pos.y = m_Pos.y + py; + pad->m_Pos.x( FROM_LEGACY_LU( m_Pos.x + px ) ); + pad->m_Pos.y( FROM_LEGACY_LU( m_Pos.y + py ) ); } /* Update of the reference and value. */ diff --git a/pcbnew/class_netinfo_item.cpp b/pcbnew/class_netinfo_item.cpp index 486260aa7f..203b30c84d 100644 --- a/pcbnew/class_netinfo_item.cpp +++ b/pcbnew/class_netinfo_item.cpp @@ -224,6 +224,6 @@ void RATSNEST_ITEM::Draw( EDA_DRAW_PANEL* panel, { GRSetDrawMode( DC, aDrawMode ); int color = g_ColorsSettings.GetItemColor(RATSNEST_VISIBLE); - GRLine( &panel->m_ClipBox, DC, m_PadStart->m_Pos - aOffset, - m_PadEnd->m_Pos - aOffset, 0, color ); + GRLine( &panel->m_ClipBox, DC, TO_LEGACY_LU_WXP( m_PadStart->m_Pos ) - aOffset, + TO_LEGACY_LU_WXP( m_PadEnd->m_Pos ) - aOffset, 0, color ); } diff --git a/pcbnew/class_pad.cpp b/pcbnew/class_pad.cpp index bb152cfdf2..71ac87cdd8 100644 --- a/pcbnew/class_pad.cpp +++ b/pcbnew/class_pad.cpp @@ -27,14 +27,14 @@ D_PAD::D_PAD( MODULE* parent ) : BOARD_CONNECTED_ITEM( parent, PCB_PAD_T ) { m_NumPadName = 0; - m_Size.x = m_Size.y = FROM_LEGACY_LU( 500 ); // give it a reasonable size + m_Size[0] = m_Size[1] = FROM_LEGACY_LU( 500 ); // give it a reasonable size /// TODO: remove hardcoded constant m_Orient = 0; // Pad rotation in 1/10 degrees m_LengthDie = ZERO_LENGTH; if( m_Parent && (m_Parent->Type() == PCB_MODULE_T) ) { - m_Pos = ( (MODULE*) m_Parent )->GetPosition(); + m_Pos = FROM_LEGACY_LU_VEC( ( (MODULE*) m_Parent )->GetPosition() ); } m_PadShape = PAD_CIRCLE; // Shape: PAD_CIRCLE, PAD_RECT PAD_OVAL @@ -68,23 +68,23 @@ int D_PAD::GetMaxRadius() const switch( m_PadShape & 0x7F ) { case PAD_CIRCLE: - radius = TO_LEGACY_LU( m_Size.x / 2 ); + radius = TO_LEGACY_LU( m_Size.x() / 2 ); break; case PAD_OVAL: - radius = TO_LEGACY_LU( MAX( m_Size.x, m_Size.y ) / 2 ); + radius = TO_LEGACY_LU( max( m_Size.x(), m_Size.y() ) / 2 ); break; case PAD_RECT: - x = TO_LEGACY_LU( m_Size.x ); - y = TO_LEGACY_LU( m_Size.y ); + x = TO_LEGACY_LU( m_Size.x() ); + y = TO_LEGACY_LU( m_Size.y() ); radius = 1 + (int) ( sqrt( (double) y * y + (double) x * x ) / 2 ); break; case PAD_TRAPEZOID: - x = TO_LEGACY_LU( m_Size.x + ABS( m_DeltaSize.y ) ); // Remember: m_DeltaSize.y is the m_Size.x change - y = TO_LEGACY_LU( m_Size.y + ABS( m_DeltaSize.x ) ); // Remember: m_DeltaSize.x is the m_Size.y change + x = TO_LEGACY_LU( m_Size.x() + abs( m_DeltaSize.y() ) ); // Remember: m_DeltaSize.y is the m_Size.x change + y = TO_LEGACY_LU( m_Size.y() + abs( m_DeltaSize.x() ) ); // Remember: m_DeltaSize.x is the m_Size.y change radius = 1 + (int) ( sqrt( (double) y * y + (double) x * x ) / 2 ); break; @@ -114,7 +114,7 @@ EDA_RECT D_PAD::GetBoundingBox() const EDA_RECT area; int radius = GetMaxRadius(); // Calculate the radius of the area, considered as a circle - area.SetOrigin( m_Pos ); + area.SetOrigin( TO_LEGACY_LU_WXP( m_Pos ) ); area.Inflate( radius ); return area; @@ -124,19 +124,19 @@ EDA_RECT D_PAD::GetBoundingBox() const // Returns the position of the pad. const wxPoint D_PAD::ReturnShapePos() { - if( m_Offset.x == ZERO_LENGTH && m_Offset.y == ZERO_LENGTH ) - return m_Pos; + if( m_Offset[0] == ZERO_LENGTH && m_Offset[0] == ZERO_LENGTH ) + return TO_LEGACY_LU_WXP( m_Pos ); wxPoint shape_pos; int dX, dY; - dX = TO_LEGACY_LU( m_Offset.x ); - dY = TO_LEGACY_LU( m_Offset.y ); + dX = TO_LEGACY_LU( m_Offset[0] ); + dY = TO_LEGACY_LU( m_Offset[1] ); RotatePoint( &dX, &dY, m_Orient ); - shape_pos.x = m_Pos.x + dX; - shape_pos.y = m_Pos.y + dY; + shape_pos.x = TO_LEGACY_LU( m_Pos.x() ) + dX; + shape_pos.y = TO_LEGACY_LU( m_Pos.y() ) + dY; return shape_pos; } @@ -304,7 +304,7 @@ int D_PAD::GetSolderMaskMargin() // ensure mask have a size always >= 0 if( margin < 0 ) { - int minsize = TO_LEGACY_LU( -MIN( m_Size.x, m_Size.y ) / 2 ); + int minsize = TO_LEGACY_LU( -min( m_Size.x(), m_Size.y() ) / 2 ); if( margin < minsize ) minsize = minsize; @@ -349,15 +349,15 @@ wxSize D_PAD::GetSolderPasteMargin() } wxSize pad_margin; - pad_margin.x = margin + wxRound( TO_LEGACY_LU_DBL( m_Size.x ) * mratio ); - pad_margin.y = margin + wxRound( TO_LEGACY_LU_DBL( m_Size.y ) * mratio ); + pad_margin.x = margin + wxRound( TO_LEGACY_LU_DBL( m_Size.x() ) * mratio ); + pad_margin.y = margin + wxRound( TO_LEGACY_LU_DBL( m_Size.y() ) * mratio ); // ensure mask have a size always >= 0 - if( pad_margin.x < TO_LEGACY_LU( -m_Size.x / 2 ) ) - pad_margin.x = TO_LEGACY_LU( -m_Size.x / 2 ); + if( pad_margin.x < TO_LEGACY_LU( -m_Size.x() / 2 ) ) + pad_margin.x = TO_LEGACY_LU( -m_Size.x() / 2 ); - if( pad_margin.y < TO_LEGACY_LU( -m_Size.y / 2 ) ) - pad_margin.y = TO_LEGACY_LU( -m_Size.y / 2 ); + if( pad_margin.y < TO_LEGACY_LU( -m_Size.y() / 2 ) ) + pad_margin.y = TO_LEGACY_LU( -m_Size.y() / 2 ); return pad_margin; } @@ -426,10 +426,10 @@ int D_PAD::ReadDescr( LINE_READER* aReader ) BufCar, &sx, &sy, &dx, &dy, &m_Orient ); - m_Size.x = LENGTH_LOAD_TMP( sx ); - m_Size.y = LENGTH_LOAD_TMP( sy ); - m_DeltaSize.x = LENGTH_LOAD_TMP( dx ); - m_DeltaSize.y = LENGTH_LOAD_TMP( dy ); + m_Size.x( LENGTH_LOAD_TMP( sx ) ); + m_Size.y( LENGTH_LOAD_TMP( sy ) ); + m_DeltaSize.x( LENGTH_LOAD_TMP( dx ) ); + m_DeltaSize.y( LENGTH_LOAD_TMP( dy ) ); ll = 0xFF & BufCar[0]; /* Read pad shape */ @@ -457,17 +457,18 @@ int D_PAD::ReadDescr( LINE_READER* aReader ) BufCar[0] = 0; nn = sscanf( PtLine, FM_LENLD" "FM_LENLD" "FM_LENLD" %s "FM_LENLD" "FM_LENLD, &dr, &ox, &oy, BufCar, &dx, &dy ); - m_Offset.x = LENGTH_LOAD_TMP( ox ); - m_Offset.y = LENGTH_LOAD_TMP( oy ); - m_Drill.y = m_Drill.x = LENGTH_LOAD_TMP( dr ); + m_Offset.x( LENGTH_LOAD_TMP( ox ) ); + m_Offset.y( LENGTH_LOAD_TMP( oy ) ); + m_Drill.x( LENGTH_LOAD_TMP( dr ) ); + m_Drill.y( m_Drill.x() ); m_DrillShape = PAD_CIRCLE; if( nn >= 6 ) // Drill shape = OVAL ? { if( BufCar[0] == 'O' ) { - m_Drill.x = FROM_LEGACY_LU( dx ); - m_Drill.y = FROM_LEGACY_LU( dy ); + m_Drill.x( FROM_LEGACY_LU( dx ) ); + m_Drill.y( FROM_LEGACY_LU( dy ) ); m_DrillShape = PAD_OVAL; } } @@ -503,8 +504,8 @@ int D_PAD::ReadDescr( LINE_READER* aReader ) case 'P': nn = sscanf( PtLine, FM_LENLD" "FM_LENLD, &ox, &oy ); - m_Pos0 = VECTOR_PCB( LENGTH_LOAD_TMP( ox ), LENGTH_LOAD_TMP( oy ) ); - m_Pos = TO_LEGACY_LU_WXP( m_Pos0 ); + m_Pos0 = VECTOR_PCB::fromXY( LENGTH_LOAD_TMP( ox ), LENGTH_LOAD_TMP( oy ) ); + m_Pos = m_Pos0; break; case 'L': @@ -563,14 +564,14 @@ bool D_PAD::Save( FILE* aFile ) const } fprintf( aFile, "Sh \"%.4s\" %c "FM_LENSV" "FM_LENSV" "FM_LENSV" "FM_LENSV" %d\n", // TODO: pad name length limit! - m_Padname, cshape, ARG_LENSV( m_Size.x ), ARG_LENSV( m_Size.y ), - ARG_LENSV( m_DeltaSize.x ), ARG_LENSV( m_DeltaSize.y ), m_Orient ); + m_Padname, cshape, ARG_LENSV( m_Size.x() ), ARG_LENSV( m_Size.y() ), + ARG_LENSV( m_DeltaSize.x() ), ARG_LENSV( m_DeltaSize.y() ), m_Orient ); - fprintf( aFile, "Dr "FM_LENSV" "FM_LENSV" "FM_LENSV, ARG_LENSV( m_Drill.x ), ARG_LENSV( m_Offset.x ), ARG_LENSV( m_Offset.y ) ); + fprintf( aFile, "Dr "FM_LENSV" "FM_LENSV" "FM_LENSV, ARG_LENSV( m_Drill.x() ), ARG_LENSV( m_Offset.x() ), ARG_LENSV( m_Offset.y() ) ); if( m_DrillShape == PAD_OVAL ) { - fprintf( aFile, " %c "FM_LENSV" "FM_LENSV, 'O', ARG_LENSV( m_Drill.x ), ARG_LENSV( m_Drill.y ) ); + fprintf( aFile, " %c "FM_LENSV" "FM_LENSV, 'O', ARG_LENSV( m_Drill.x() ), ARG_LENSV( m_Drill.y() ) ); } fprintf( aFile, "\n" ); @@ -599,7 +600,7 @@ bool D_PAD::Save( FILE* aFile ) const fprintf( aFile, "Ne %d %s\n", GetNet(), EscapedUTF8( m_Netname ).c_str() ); - fprintf( aFile, "Po "FM_LENSV" "FM_LENSV"\n", ARG_LENSV( m_Pos0.x ), ARG_LENSV( m_Pos0.y ) ); + fprintf( aFile, "Po "FM_LENSV" "FM_LENSV"\n", ARG_LENSV( m_Pos0.x() ), ARG_LENSV( m_Pos0.y() ) ); if( m_LengthDie != ZERO_LENGTH ) fprintf( aFile, "Le "FM_LENSV"\n", ARG_LENSV( m_LengthDie ) ); @@ -755,13 +756,13 @@ void D_PAD::DisplayInfo( EDA_DRAW_FRAME* frame ) frame->AppendMsgPanel( ShowPadShape(), ShowPadAttr(), DARKGREEN ); - valeur_param( TO_LEGACY_LU( m_Size.x ), Line ); + valeur_param( TO_LEGACY_LU( m_Size.x() ), Line ); frame->AppendMsgPanel( _( "H Size" ), Line, RED ); - valeur_param( TO_LEGACY_LU( m_Size.y ), Line ); + valeur_param( TO_LEGACY_LU( m_Size.y() ), Line ); frame->AppendMsgPanel( _( "V Size" ), Line, RED ); - valeur_param( (unsigned)(int) TO_LEGACY_LU( m_Drill.x ), Line ); + valeur_param( (unsigned)(int) TO_LEGACY_LU( m_Drill.x() ), Line ); if( m_DrillShape == PAD_CIRCLE ) { @@ -769,9 +770,9 @@ void D_PAD::DisplayInfo( EDA_DRAW_FRAME* frame ) } else { - valeur_param( (unsigned) TO_LEGACY_LU( m_Drill.x ), Line ); + valeur_param( (unsigned) TO_LEGACY_LU( m_Drill.x() ), Line ); wxString msg; - valeur_param( (unsigned) TO_LEGACY_LU( m_Drill.y ), msg ); + valeur_param( (unsigned) TO_LEGACY_LU( m_Drill.y() ), msg ); Line += wxT( " / " ) + msg; frame->AppendMsgPanel( _( "Drill X / Y" ), Line, RED ); } @@ -787,10 +788,10 @@ void D_PAD::DisplayInfo( EDA_DRAW_FRAME* frame ) frame->AppendMsgPanel( _( "Orient" ), Line, LIGHTBLUE ); - valeur_param( m_Pos.x, Line ); + valeur_param( TO_LEGACY_LU( m_Pos.x() ), Line ); frame->AppendMsgPanel( _( "X Pos" ), Line, LIGHTBLUE ); - valeur_param( m_Pos.y, Line ); + valeur_param( TO_LEGACY_LU( m_Pos.y() ), Line ); frame->AppendMsgPanel( _( "Y pos" ), Line, LIGHTBLUE ); if( m_LengthDie != ZERO_LENGTH ) @@ -827,8 +828,8 @@ bool D_PAD::HitTest( const wxPoint& refPos ) if( ( abs( delta.x ) > m_ShapeMaxRadius ) || ( abs( delta.y ) > m_ShapeMaxRadius ) ) return false; - dx = TO_LEGACY_LU( m_Size.x / 2 ); // dx also is the radius for rounded pads - dy = TO_LEGACY_LU( m_Size.y / 2 ); + dx = TO_LEGACY_LU( m_Size.x() / 2 ); // dx also is the radius for rounded pads + dy = TO_LEGACY_LU( m_Size.y() / 2 ); switch( m_PadShape & 0x7F ) { @@ -868,22 +869,22 @@ int D_PAD::Compare( const D_PAD* padref, const D_PAD* padcmp ) if( ( diff = padref->m_PadShape - padcmp->m_PadShape) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_Size.x - padcmp->m_Size.x ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_Size.x() - padcmp->m_Size.x() ) ) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_Size.y - padcmp->m_Size.y ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_Size.y() - padcmp->m_Size.y() ) ) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_Offset.x - padcmp->m_Offset.x ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_Offset.x() - padcmp->m_Offset.x() ) ) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_Offset.y - padcmp->m_Offset.y ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_Offset.y() - padcmp->m_Offset.y() ) ) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_DeltaSize.x - padcmp->m_DeltaSize.x ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_DeltaSize.x() - padcmp->m_DeltaSize.x() ) ) ) return diff; - if( ( diff = TO_LEGACY_LU( padref->m_DeltaSize.y - padcmp->m_DeltaSize.y ) ) ) + if( ( diff = TO_LEGACY_LU( padref->m_DeltaSize.y() - padcmp->m_DeltaSize.y() ) ) ) return diff; // @todo check if export_gencad still works: diff --git a/pcbnew/class_pad.h b/pcbnew/class_pad.h index 9cda1a7eb4..ce8f8d0b0f 100644 --- a/pcbnew/class_pad.h +++ b/pcbnew/class_pad.h @@ -12,7 +12,7 @@ #include "PolyLine.h" #include "lengthpcb.h" - +#include "vectorpcb.h" class LINE_READER; class EDA_3D_CANVAS; @@ -72,8 +72,9 @@ private: wxString m_ShortNetname; // short net name, like vout from /mysheet/mysubsheet/vout -public: - wxPoint m_Pos; // pad Position on board +public: /** TODO: that's not so good if parameters are easily modifiable outside + (e. g. m_Pos, which could be coherent with m_Pos and module orient/pos ) */ + VECTOR_PCB m_Pos; // pad Position on board union { @@ -114,7 +115,7 @@ public: VECTOR_PCB m_DeltaSize; // delta on rectangular shapes - VECTOR_PCB m_Pos0; // Initial Pad position (i.e. pas position relative to the + VECTOR_PCB 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 @@ -177,16 +178,17 @@ public: * Function GetPosition * returns the position of this object. * @return const wxPoint& - The position of this object. + * @TODO: could move virtual method to .c file */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { - return m_Pos; + return TO_LEGACY_LU_WXP( m_Pos ); } void SetPosition( const wxPoint& aPos ) { - m_Pos = aPos; + m_Pos = FROM_LEGACY_LU_VEC( aPos ); } /** @@ -385,7 +387,7 @@ public: */ virtual void Move( const wxPoint& aMoveVector ) { - m_Pos += aMoveVector; + m_Pos += FROM_LEGACY_LU_VEC( aMoveVector ); } diff --git a/pcbnew/class_pad_draw_functions.cpp b/pcbnew/class_pad_draw_functions.cpp index beabb2bf8c..9bb5107184 100644 --- a/pcbnew/class_pad_draw_functions.cpp +++ b/pcbnew/class_pad_draw_functions.cpp @@ -475,8 +475,8 @@ void D_PAD::DrawShape( EDA_RECT* aClipBox, wxDC* aDC, PAD_DRAWINFO& aDrawInfo ) } /* Draw the pad hole */ - wxPoint holepos = m_Pos - aDrawInfo.m_Offset; - int hole = TO_LEGACY_LU( m_Drill.x ) / 2; + wxPoint holepos = TO_LEGACY_LU_WXP( m_Pos ) - aDrawInfo.m_Offset; + int hole = TO_LEGACY_LU( m_Drill.x() ) / 2; bool drawhole = hole > 0; @@ -513,20 +513,20 @@ void D_PAD::DrawShape( EDA_RECT* aClipBox, wxDC* aDC, PAD_DRAWINFO& aDrawInfo ) break; case PAD_OVAL: - halfsize.x = TO_LEGACY_LU( m_Drill.x ) / 2; - halfsize.y = TO_LEGACY_LU( m_Drill.y ) / 2; + halfsize.x = TO_LEGACY_LU( m_Drill.x() ) / 2; + halfsize.y = TO_LEGACY_LU( m_Drill.y() ) / 2; - if( m_Drill.x > m_Drill.y ) /* horizontal */ + if( m_Drill.x() > m_Drill.y() ) /* horizontal */ { delta_cx = halfsize.x - halfsize.y; delta_cy = 0; - seg_width = TO_LEGACY_LU( m_Drill.y ); + seg_width = TO_LEGACY_LU( m_Drill.y() ); } else /* vertical */ { delta_cx = 0; delta_cy = halfsize.y - halfsize.x; - seg_width = TO_LEGACY_LU( m_Drill.x ); + seg_width = TO_LEGACY_LU( m_Drill.x() ); } RotatePoint( &delta_cx, &delta_cy, angle ); @@ -578,11 +578,11 @@ void D_PAD::DrawShape( EDA_RECT* aClipBox, wxDC* aDC, PAD_DRAWINFO& aDrawInfo ) AreaSize = TO_LEGACY_LU_WXS( m_Size ); - if( m_Size.y > m_Size.x ) + if( m_Size.y() > m_Size.x() ) { angle += 900; - AreaSize.x = TO_LEGACY_LU( m_Size.y ); - AreaSize.y = TO_LEGACY_LU( m_Size.x ); + AreaSize.x = TO_LEGACY_LU( m_Size.y() ); + AreaSize.y = TO_LEGACY_LU( m_Size.x() ); } if( shortname_len > 0 ) // if there is a netname, provides room to display this netname @@ -664,23 +664,23 @@ int D_PAD::BuildSegmentFromOvalShape(wxPoint& aSegStart, wxPoint& aSegEnd, int a { int width; - if( m_Size.y < m_Size.x ) // Build an horizontal equiv segment + if( m_Size.y() < m_Size.x() ) // Build an horizontal equiv segment { - int delta = TO_LEGACY_LU( ( m_Size.x - m_Size.y ) / 2 ); + int delta = TO_LEGACY_LU( ( m_Size.x() - m_Size.y() ) / 2 ); aSegStart.x = -delta; aSegStart.y = 0; aSegEnd.x = delta; aSegEnd.y = 0; - width = TO_LEGACY_LU( m_Size.y ); + width = TO_LEGACY_LU( m_Size.y() ); } else // Vertical oval: build a vertical equiv segment { - int delta = TO_LEGACY_LU( ( m_Size.y -m_Size.x ) / 2 ); + int delta = TO_LEGACY_LU( ( m_Size.y() -m_Size.x() ) / 2 ); aSegStart.x = 0; aSegStart.y = -delta; aSegEnd.x = 0; aSegEnd.y = delta; - width = TO_LEGACY_LU( m_Size.x ); + width = TO_LEGACY_LU( m_Size.x() ); } if( aRotation ) @@ -701,8 +701,8 @@ void D_PAD::BuildPadPolygon( wxPoint aCoord[4], wxSize aInflateValue, int aRotat wxSize delta; wxSize halfsize; - halfsize.x = TO_LEGACY_LU( m_Size.x / 2 ); - halfsize.y = TO_LEGACY_LU( m_Size.y / 2 ); + halfsize.x = TO_LEGACY_LU( m_Size.x() / 2 ); + halfsize.y = TO_LEGACY_LU( m_Size.y() / 2 ); /* For rectangular shapes, inflate is easy */ @@ -721,8 +721,8 @@ void D_PAD::BuildPadPolygon( wxPoint aCoord[4], wxSize aInflateValue, int aRotat else { // Trapezoidal pad: verify delta values - delta.x = TO_LEGACY_LU( m_DeltaSize.x / 2 ); - delta.y = TO_LEGACY_LU( m_DeltaSize.y / 2 ); + delta.x = TO_LEGACY_LU( m_DeltaSize.x() / 2 ); + delta.y = TO_LEGACY_LU( m_DeltaSize.y() / 2 ); // be sure delta values are not to large if( (delta.x < 0) && (delta.x <= -halfsize.y) ) @@ -762,7 +762,7 @@ void D_PAD::BuildPadPolygon( wxPoint aCoord[4], wxSize aInflateValue, int aRotat if( delta.y ) // lower and upper segment is horizontal { // Calculate angle of left (or right) segment with vertical axis - angle = atan2( m_DeltaSize.y, m_Size.y ); /// TODO: make atan2 available to LENGTH + angle = atan2( m_DeltaSize.y(), m_Size.y() ); // left and right sides are moved by aInflateValue.x in their perpendicular direction // We must calculate the corresponding displacement on the horizontal axis @@ -778,7 +778,7 @@ void D_PAD::BuildPadPolygon( wxPoint aCoord[4], wxSize aInflateValue, int aRotat else if( delta.x ) // left and right segment is vertical { // Calculate angle of lower (or upper) segment with horizontal axis - angle = atan2( m_DeltaSize.x, m_Size.x ); + angle = atan2( m_DeltaSize.x(), m_Size.x() ); // lower and upper sides are moved by aInflateValue.x in their perpendicular direction // We must calculate the corresponding displacement on the vertical axis diff --git a/pcbnew/class_pcb_text.h b/pcbnew/class_pcb_text.h index 21cd41b90e..c946678ce8 100644 --- a/pcbnew/class_pcb_text.h +++ b/pcbnew/class_pcb_text.h @@ -26,11 +26,15 @@ public: * returns the position of this object. * @return wxPoint& - The position of this object, non-const so it can be changed */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Pos; // within EDA_TEXT } + void SetPosition( const wxPoint& pos ) { + m_Pos = pos; + } + /** * Function Move * move this object. diff --git a/pcbnew/class_text_mod.h b/pcbnew/class_text_mod.h index d1a28b1def..76b775db38 100644 --- a/pcbnew/class_text_mod.h +++ b/pcbnew/class_text_mod.h @@ -51,11 +51,14 @@ public: * Required by pure virtual BOARD_ITEM::GetPosition() * @return const wxPoint& - The position of this object. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Pos; } + void SetPosition( const wxPoint& pos ) { + m_Pos = pos; + } void Copy( TEXTE_MODULE* source ); // copy structure diff --git a/pcbnew/class_track.h b/pcbnew/class_track.h index c360aeefdb..24582b6ac9 100644 --- a/pcbnew/class_track.h +++ b/pcbnew/class_track.h @@ -120,13 +120,21 @@ public: /** * Function GetPosition * returns the position of this object. - * @return const wxPoint& - The position of this object. + * @return const wxPoint - The position of this object. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Start; // it had to be start or end. } + /** + * Sets the position of this object. Virtual function, needed by BOARD_ITEM + * @param pos The position of this object + */ + void SetPosition( const wxPoint& pos ) { + m_Start = pos; + } + EDA_RECT GetBoundingBox() const; /** @@ -470,12 +478,11 @@ public: * returns the position of this object. * @return const wxPoint& - The position of this object. */ - wxPoint& GetPosition() + const wxPoint GetPosition() const { return m_Start; } - void SetPosition( const wxPoint& aPoint ) { m_Start = aPoint; m_End = aPoint; } /** diff --git a/pcbnew/class_zone.cpp b/pcbnew/class_zone.cpp index 2b2c4748d2..e66702803a 100644 --- a/pcbnew/class_zone.cpp +++ b/pcbnew/class_zone.cpp @@ -84,20 +84,13 @@ bool ZONE_CONTAINER::UnFill() } -wxPoint& ZONE_CONTAINER::GetPosition() +const wxPoint ZONE_CONTAINER::GetPosition() const { - static wxPoint pos; - - if( m_Poly ) - { - pos = GetCornerPosition( 0 ); - } - else - pos = wxPoint( 0, 0 ); - - return pos; + return m_Poly? GetCornerPosition( 0 ) : wxPoint( 0, 0 ); } +void ZONE_CONTAINER::SetPosition( const wxPoint& pos ) { +} void ZONE_CONTAINER::SetNet( int aNetCode ) { diff --git a/pcbnew/class_zone.h b/pcbnew/class_zone.h index 114c22be55..319d008f53 100644 --- a/pcbnew/class_zone.h +++ b/pcbnew/class_zone.h @@ -118,8 +118,8 @@ public: * Function GetPosition * @return a wxPoint, position of the first point of the outline */ - wxPoint& GetPosition(); - + const wxPoint GetPosition() const; + void SetPosition( const wxPoint& pos ); /** * Function copy * copy useful data from the source. diff --git a/pcbnew/clean.cpp b/pcbnew/clean.cpp index 746ebf8c06..2f61b41c37 100644 --- a/pcbnew/clean.cpp +++ b/pcbnew/clean.cpp @@ -850,7 +850,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* frame ) 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 != TO_LEGACY_LU_WXP( pad->m_Pos ) ) { if( segment->GetTrace( frame->GetBoard()->m_Track, NULL, START ) == NULL ) { @@ -858,7 +858,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* frame ) frame->GetBoard()->m_Track.Insert( newTrack, segment->Next() ); - newTrack->m_End = pad->m_Pos; + newTrack->m_End = TO_LEGACY_LU_WXP( pad->m_Pos ); newTrack->start = segment; newTrack->end = pad; @@ -872,7 +872,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* frame ) 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 != TO_LEGACY_LU_WXP( pad->m_Pos ) ) { if( segment->GetTrace( frame->GetBoard()->m_Track, NULL, END ) == NULL ) { @@ -880,7 +880,7 @@ void ConnectDanglingEndToPad( PCB_EDIT_FRAME* frame ) frame->GetBoard()->m_Track.Insert( newTrack, segment->Next() ); - newTrack->m_Start = pad->m_Pos; + newTrack->m_Start = TO_LEGACY_LU_WXP( pad->m_Pos ); newTrack->start = pad; newTrack->end = segment; diff --git a/pcbnew/dialogs/dialog_gendrill.cpp b/pcbnew/dialogs/dialog_gendrill.cpp index 7e7b572197..5633751725 100644 --- a/pcbnew/dialogs/dialog_gendrill.cpp +++ b/pcbnew/dialogs/dialog_gendrill.cpp @@ -185,7 +185,7 @@ void DIALOG_GENDRILL::InitDisplayParams( void ) { if( pad->m_DrillShape == PAD_CIRCLE ) { - if( pad->m_Drill.x != ZERO_LENGTH ) + if( pad->m_Drill.x() != ZERO_LENGTH ) { if( pad->m_Attribut == PAD_HOLE_NOT_PLATED ) m_notplatedPadsHoleCount++; @@ -195,7 +195,7 @@ void DIALOG_GENDRILL::InitDisplayParams( void ) } else { - if( MIN( TO_LEGACY_LU( pad->m_Drill.x ), TO_LEGACY_LU( pad->m_Drill.y ) ) != 0 ) + if( min( TO_LEGACY_LU( pad->m_Drill.x() ), TO_LEGACY_LU( pad->m_Drill.y() ) ) != 0 ) { if( pad->m_Attribut == PAD_HOLE_NOT_PLATED ) m_notplatedPadsHoleCount++; diff --git a/pcbnew/dialogs/dialog_pad_properties.cpp b/pcbnew/dialogs/dialog_pad_properties.cpp index 69e3848f76..287201baaf 100644 --- a/pcbnew/dialogs/dialog_pad_properties.cpp +++ b/pcbnew/dialogs/dialog_pad_properties.cpp @@ -117,7 +117,7 @@ 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 = TO_LEGACY_LU_WXP( m_dummyPad->m_Pos ); drawInfo.m_Display_padnum = true; drawInfo.m_Display_netname = true; if( m_dummyPad->m_Attribut == PAD_HOLE_NOT_PLATED ) @@ -130,11 +130,11 @@ void DIALOG_PAD_PROPERTIES::OnPaintShowPanel( wxPaintEvent& event ) dc.SetDeviceOrigin( dc_size.x / 2, dc_size.y / 2 ); // Calculate a suitable scale to fit the available draw area - int dim = TO_LEGACY_LU( m_dummyPad->m_Size.x + ABS( m_dummyPad->m_DeltaSize.y ) ); + int dim = TO_LEGACY_LU( m_dummyPad->m_Size.x() + abs( m_dummyPad->m_DeltaSize.y() ) ); if( m_dummyPad->m_LocalClearance > ZERO_LENGTH ) dim += TO_LEGACY_LU( m_dummyPad->m_LocalClearance * 2 ); double scale = (double) dc_size.x / dim; - dim = TO_LEGACY_LU( m_dummyPad->m_Size.y + ABS( m_dummyPad->m_DeltaSize.x ) ); + dim = TO_LEGACY_LU( m_dummyPad->m_Size.y() + abs( m_dummyPad->m_DeltaSize.x() ) ); if( m_dummyPad->m_LocalClearance > ZERO_LENGTH ) dim += TO_LEGACY_LU( m_dummyPad->m_LocalClearance * 2 ); double altscale = (double) dc_size.y / dim; @@ -207,8 +207,8 @@ void DIALOG_PAD_PROPERTIES::initValues() if( m_isFlipped ) { - NEGATE( m_dummyPad->m_Offset.y ); - NEGATE( m_dummyPad->m_DeltaSize.y ); + m_dummyPad->m_Offset.y( -m_dummyPad->m_Offset.y() ); + m_dummyPad->m_DeltaSize.y( -m_dummyPad->m_DeltaSize.y() ); /* flip pads layers*/ m_dummyPad->m_layerMask = ChangeSideMaskLayer( m_dummyPad->m_layerMask ); } @@ -236,26 +236,26 @@ 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_Y_Ctrl, m_dummyPad->m_Pos.y, internalUnits ); + CTR_PUT_LENGTH( *m_PadPosition_X_Ctrl, m_dummyPad->m_Pos.x(), internalUnits ); + CTR_PUT_LENGTH( *m_PadPosition_Y_Ctrl, m_dummyPad->m_Pos.y(), internalUnits ); - CTR_PUT_LENGTH( *m_PadDrill_X_Ctrl, m_dummyPad->m_Drill.x, internalUnits ); - CTR_PUT_LENGTH( *m_PadDrill_Y_Ctrl, m_dummyPad->m_Drill.y, internalUnits ); + CTR_PUT_LENGTH( *m_PadDrill_X_Ctrl, m_dummyPad->m_Drill.x(), internalUnits ); + CTR_PUT_LENGTH( *m_PadDrill_Y_Ctrl, m_dummyPad->m_Drill.y(), internalUnits ); - CTR_PUT_LENGTH( *m_ShapeSize_X_Ctrl, m_dummyPad->m_Size.x, internalUnits ); - CTR_PUT_LENGTH( *m_ShapeSize_Y_Ctrl, m_dummyPad->m_Size.y, internalUnits ); + CTR_PUT_LENGTH( *m_ShapeSize_X_Ctrl, m_dummyPad->m_Size.x(), internalUnits ); + CTR_PUT_LENGTH( *m_ShapeSize_Y_Ctrl, m_dummyPad->m_Size.y(), internalUnits ); - CTR_PUT_LENGTH( *m_ShapeOffset_X_Ctrl, m_dummyPad->m_Offset.x, internalUnits ); - CTR_PUT_LENGTH( *m_ShapeOffset_Y_Ctrl, m_dummyPad->m_Offset.y, internalUnits ); + CTR_PUT_LENGTH( *m_ShapeOffset_X_Ctrl, m_dummyPad->m_Offset.x(), internalUnits ); + CTR_PUT_LENGTH( *m_ShapeOffset_Y_Ctrl, m_dummyPad->m_Offset.y(), internalUnits ); - if( m_dummyPad->m_DeltaSize.x != ZERO_LENGTH ) + if( m_dummyPad->m_DeltaSize.x() != ZERO_LENGTH ) { - CTR_PUT_LENGTH( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.x, internalUnits ); + CTR_PUT_LENGTH( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.x(), internalUnits ); m_radioBtnDeltaXdir->SetValue(true); } else { - CTR_PUT_LENGTH( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.y, internalUnits ); + CTR_PUT_LENGTH( *m_ShapeDelta_Ctrl, m_dummyPad->m_DeltaSize.y(), internalUnits ); m_radioBtnDeltaYdir->SetValue(true); } @@ -613,7 +613,7 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event ) /* compute the pos 0 value, i.e. pad position for module orient = 0 i.e. * refer to module origin (module position) */ - m_CurrentPad->m_Pos0 = FROM_LEGACY_LU_VEC( m_CurrentPad->m_Pos ); + m_CurrentPad->m_Pos0 = m_CurrentPad->m_Pos; m_CurrentPad->m_Pos0 -= FROM_LEGACY_LU_VEC( Module->m_Pos ); m_CurrentPad->m_Orient = (g_Pad_Master.m_Orient * isign) + Module->m_Orient; wxPoint p = TO_LEGACY_LU_WXP( m_CurrentPad->m_Pos0 ); @@ -621,12 +621,12 @@ void DIALOG_PAD_PROPERTIES::PadPropertiesAccept( wxCommandEvent& event ) m_CurrentPad->m_Pos0 = FROM_LEGACY_LU_VEC( p ); m_CurrentPad->m_Size = g_Pad_Master.m_Size; - 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_DeltaSize = g_Pad_Master.m_DeltaSize; + m_CurrentPad->m_DeltaSize.y( 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( m_CurrentPad->m_Offset.y() * isign ); m_CurrentPad->m_LengthDie = g_Pad_Master.m_LengthDie; @@ -711,26 +711,26 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError aPad->m_LocalSolderPasteMarginRatio = dtmp / 100; // Read pad position: - aPad->m_Pos.x = ReturnValueFromTextCtrl( *m_PadPosition_X_Ctrl, internalUnits ); - aPad->m_Pos.y = ReturnValueFromTextCtrl( *m_PadPosition_Y_Ctrl, internalUnits ); - aPad->m_Pos0 = FROM_LEGACY_LU_VEC( aPad->m_Pos ); + aPad->m_Pos.x( CTR_GET_LENGTH( *m_PadPosition_X_Ctrl, internalUnits ) ); + aPad->m_Pos.y( CTR_GET_LENGTH( *m_PadPosition_Y_Ctrl, internalUnits ) ); + aPad->m_Pos0 = aPad->m_Pos; // Read pad drill: - aPad->m_Drill.x = CTR_GET_LENGTH( *m_PadDrill_X_Ctrl, internalUnits ); - aPad->m_Drill.y = CTR_GET_LENGTH( *m_PadDrill_Y_Ctrl, internalUnits ); + aPad->m_Drill.x( CTR_GET_LENGTH( *m_PadDrill_X_Ctrl, internalUnits ) ); + aPad->m_Drill.y( CTR_GET_LENGTH( *m_PadDrill_Y_Ctrl, internalUnits ) ); if( m_DrillShapeCtrl->GetSelection() == 0 ) { aPad->m_DrillShape = PAD_CIRCLE; - aPad->m_Drill.y = aPad->m_Drill.x; + aPad->m_Drill.y( aPad->m_Drill.x() ); } else aPad->m_DrillShape = PAD_OVAL; // Read pad shape size: - aPad->m_Size.x = CTR_GET_LENGTH( *m_ShapeSize_X_Ctrl, internalUnits ); - aPad->m_Size.y = CTR_GET_LENGTH( *m_ShapeSize_Y_Ctrl, internalUnits ); + aPad->m_Size.x( CTR_GET_LENGTH( *m_ShapeSize_X_Ctrl, internalUnits ) ); + aPad->m_Size.y( CTR_GET_LENGTH( *m_ShapeSize_Y_Ctrl, internalUnits ) ); if( aPad->m_PadShape == PAD_CIRCLE ) - aPad->m_Size.y = aPad->m_Size.x; + aPad->m_Size.y( aPad->m_Size.x() ); // Read pad shape delta size: // m_DeltaSize.x or m_DeltaSize.y must be NULL. for a trapezoid. @@ -738,8 +738,8 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError LENGTH_PCB delta; delta = CTR_GET_LENGTH( *m_ShapeDelta_Ctrl, internalUnits ); aPad->m_DeltaSize = m_radioBtnDeltaXdir->GetValue()? - VECTOR_PCB( delta, ZERO_LENGTH ): - VECTOR_PCB( ZERO_LENGTH, delta ); + VECTOR_PCB::fromXY( delta, ZERO_LENGTH ): + VECTOR_PCB::fromXY( ZERO_LENGTH, delta ); // Read pad lenght die aPad->m_LengthDie = CTR_GET_LENGTH( *m_LengthDieCtrl, internalUnits ); @@ -747,30 +747,30 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError // Test bad values (be sure delta values are not to large) // remember DeltaSize.x is the Y size variation TODO: this can be optimized bool error = false; - if( (aPad->m_DeltaSize.x < ZERO_LENGTH) && (aPad->m_DeltaSize.x <= -aPad->m_Size.y ) ) + if( (aPad->m_DeltaSize.x() < ZERO_LENGTH) && (aPad->m_DeltaSize.x() <= -aPad->m_Size.y() ) ) { - aPad->m_DeltaSize.x = -aPad->m_Size.y + FROM_LEGACY_LU( 2 ); + aPad->m_DeltaSize.x( -aPad->m_Size.y() + FROM_LEGACY_LU( 2 ) ); error = true; } - if( (aPad->m_DeltaSize.x > ZERO_LENGTH) && (aPad->m_DeltaSize.x >= aPad->m_Size.y ) ) + if( (aPad->m_DeltaSize.x() > ZERO_LENGTH) && (aPad->m_DeltaSize.x() >= aPad->m_Size.y() ) ) { - aPad->m_DeltaSize.x = aPad->m_Size.y - FROM_LEGACY_LU( 2 ); + aPad->m_DeltaSize.x( aPad->m_Size.y() - FROM_LEGACY_LU( 2 ) ); error = true; } - if( (aPad->m_DeltaSize.y < ZERO_LENGTH) && (aPad->m_DeltaSize.y <= -aPad->m_Size.x ) ) + if( (aPad->m_DeltaSize.y() < ZERO_LENGTH) && (aPad->m_DeltaSize.y() <= -aPad->m_Size.x() ) ) { - aPad->m_DeltaSize.y = -aPad->m_Size.x + FROM_LEGACY_LU( 2 ); + aPad->m_DeltaSize.y( -aPad->m_Size.x() + FROM_LEGACY_LU( 2 ) ); error = true; } - if( (aPad->m_DeltaSize.y > ZERO_LENGTH) && (aPad->m_DeltaSize.y >= aPad->m_Size.x ) ) + if( (aPad->m_DeltaSize.y() > ZERO_LENGTH) && (aPad->m_DeltaSize.y() >= aPad->m_Size.x() ) ) { - aPad->m_DeltaSize.y = aPad->m_Size.x - FROM_LEGACY_LU( 2 ); + aPad->m_DeltaSize.y( aPad->m_Size.x() - FROM_LEGACY_LU( 2 ) ); error = true; } // Read pad shape offset: - aPad->m_Offset.x = CTR_GET_LENGTH( *m_ShapeOffset_X_Ctrl, internalUnits ); - aPad->m_Offset.y = CTR_GET_LENGTH( *m_ShapeOffset_Y_Ctrl, internalUnits ); + aPad->m_Offset.x( CTR_GET_LENGTH( *m_ShapeOffset_X_Ctrl, internalUnits ) ); + aPad->m_Offset.y( CTR_GET_LENGTH( *m_ShapeOffset_Y_Ctrl, internalUnits ) ); long orient_value = 0; msg = m_PadOrientCtrl->GetValue(); @@ -785,17 +785,17 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError switch( aPad->m_PadShape ) { case PAD_CIRCLE: - aPad->m_Offset = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); // wxSize( 0, 0 ); - aPad->m_DeltaSize = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); - aPad->m_Size.y = aPad->m_Size.x; + aPad->m_Offset = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); // wxSize( 0, 0 ); + aPad->m_DeltaSize = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_Size.y( aPad->m_Size.x() ); break; case PAD_RECT: - aPad->m_DeltaSize = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_DeltaSize = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); break; case PAD_OVAL: - aPad->m_DeltaSize = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_DeltaSize = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); break; case PAD_TRAPEZOID: @@ -809,14 +809,14 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError case PAD_CONN: case PAD_SMD: - aPad->m_Offset = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); - aPad->m_Drill = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_Offset = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_Drill = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); break; case PAD_HOLE_NOT_PLATED: // Mechanical purpose only: // no offset, no net name, no pad name allowed - aPad->m_Offset = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); //wxSize( 0, 0 ); + aPad->m_Offset = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); //wxSize( 0, 0 ); aPad->SetPadName( wxEmptyString ); aPad->SetNetname( wxEmptyString ); break; @@ -873,8 +873,8 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError /* Test for incorrect values */ if( aPromptOnError ) { - if( (aPad->m_Size.x < aPad->m_Drill.x ) - || (aPad->m_Size.y < aPad->m_Drill.y ) ) + if( (aPad->m_Size.x() < aPad->m_Drill.x() ) + || (aPad->m_Size.y() < aPad->m_Drill.y() ) ) { DisplayError( NULL, _( "Incorrect value for pad drill: pad drill bigger than pad size" ) ); return false; @@ -883,7 +883,7 @@ bool DIALOG_PAD_PROPERTIES::TransfertDataToPad( D_PAD* aPad, bool aPromptOnError int padlayers_mask = PadLayerMask & (LAYER_BACK | LAYER_FRONT); if( padlayers_mask == 0 ) { - if( aPad->m_Drill.x != ZERO_LENGTH || aPad->m_Drill.y != ZERO_LENGTH ) + if( aPad->m_Drill.x() != ZERO_LENGTH || aPad->m_Drill.y() != ZERO_LENGTH ) { msg = _( "Error: pad is not on a copper layer and has a hole" ); if( aPad->m_Attribut == PAD_HOLE_NOT_PLATED ) @@ -897,8 +897,8 @@ if you do not want this pad plotted in gerber files"); } } - if( ( aPad->m_Size.x / 2 <= ABS( aPad->m_Offset.x ) ) - || ( aPad->m_Size.y / 2 <= ABS( aPad->m_Offset.y ) ) ) + if( ( aPad->m_Size.x() / 2 <= abs( aPad->m_Offset.x() ) ) + || ( aPad->m_Size.y() / 2 <= abs( aPad->m_Offset.y() ) ) ) { DisplayError( NULL, _( "Incorrect value for pad offset" ) ); return false; diff --git a/pcbnew/dragsegm.cpp b/pcbnew/dragsegm.cpp index f20c389b43..274114f9af 100644 --- a/pcbnew/dragsegm.cpp +++ b/pcbnew/dragsegm.cpp @@ -52,7 +52,7 @@ void DrawSegmentWhileMovingFootprint( EDA_DRAW_PANEL* panel, wxDC* DC ) if( pt_pad ) { - pos = pt_pad->m_Pos - g_Offset_Module; + pos = TO_LEGACY_LU_WXP( pt_pad->m_Pos ) - g_Offset_Module; Track->m_Start = pos; } @@ -60,7 +60,7 @@ void DrawSegmentWhileMovingFootprint( EDA_DRAW_PANEL* panel, wxDC* DC ) if( pt_pad ) { - pos = pt_pad->m_Pos - g_Offset_Module; + pos = TO_LEGACY_LU_WXP( pt_pad->m_Pos ) - g_Offset_Module; Track->m_End = pos; } @@ -105,7 +105,7 @@ void Build_1_Pad_SegmentsToDrag( EDA_DRAW_PANEL* panel, wxDC* DC, D_PAD* PtPad ) Track = pcb->m_Track->GetStartNetCode( net_code ); - pos = PtPad->m_Pos; + pos = TO_LEGACY_LU_WXP( PtPad->m_Pos ); LayerMask = PtPad->m_layerMask; for( ; Track; Track = Track->Next() ) diff --git a/pcbnew/drc.cpp b/pcbnew/drc.cpp index bfe7a4a6d4..d510dc3a27 100644 --- a/pcbnew/drc.cpp +++ b/pcbnew/drc.cpp @@ -592,7 +592,7 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li // We can stop the test when pad->m_Pos.x > x_limit // because the list is sorted by X values - if( pad->m_Pos.x > x_limit ) + if( TO_LEGACY_LU( pad->m_Pos.x() ) > x_limit ) break; // No problem if pads are on different copper layers, @@ -617,7 +617,7 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li /* 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 != ZERO_LENGTH ) + if( pad->m_Drill.x() != ZERO_LENGTH ) { // pad under testing has a hole, test this hole against pad reference dummypad.SetPosition( pad->GetPosition() ); @@ -637,7 +637,7 @@ bool DRC::doPadToPadsDrc( D_PAD* aRefPad, D_PAD** aStart, D_PAD** aEnd, int x_li } } - if( aRefPad->m_Drill.x != ZERO_LENGTH ) // pad reference has a hole + if( aRefPad->m_Drill.x() != ZERO_LENGTH ) // pad reference has a hole { dummypad.SetPosition( aRefPad->GetPosition() ); dummypad.m_Size = aRefPad->m_Drill; diff --git a/pcbnew/drc_clearance_test_functions.cpp b/pcbnew/drc_clearance_test_functions.cpp index ab57d617d7..785a2f3ef3 100644 --- a/pcbnew/drc_clearance_test_functions.cpp +++ b/pcbnew/drc_clearance_test_functions.cpp @@ -290,7 +290,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads ) * checkClearanceSegmToPad(),a pseudo pad is used, with a shape and a * size like the hole */ - if( pad->m_Drill.x == ZERO_LENGTH ) + if( pad->m_Drill.x() == ZERO_LENGTH ) continue; dummypad.m_Size = pad->m_Drill; @@ -633,7 +633,7 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad ) m_segmEnd.x = m_segmEnd.y = 0; m_padToTestPos = relativePadPos; - diag = checkClearanceSegmToPad( aPad, TO_LEGACY_LU( aRefPad->m_Size.x ), dist_min ); + diag = checkClearanceSegmToPad( aPad, TO_LEGACY_LU( aRefPad->m_Size.x() ), dist_min ); break; case PAD_RECT: @@ -664,10 +664,10 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad ) relativePadPos.x = ABS( relativePadPos.x ); relativePadPos.y = ABS( relativePadPos.y ); - if( ( relativePadPos.x - ( (size.x + TO_LEGACY_LU( aRefPad->m_Size.x ) ) / 2 ) ) >= dist_min ) + if( ( relativePadPos.x - ( (size.x + TO_LEGACY_LU( aRefPad->m_Size.x() ) ) / 2 ) ) >= dist_min ) diag = true; - if( ( relativePadPos.y - ( (size.y + TO_LEGACY_LU( aRefPad->m_Size.y) ) / 2 ) ) >= dist_min ) + if( ( relativePadPos.y - ( (size.y + TO_LEGACY_LU( aRefPad->m_Size.y() ) ) / 2 ) ) >= dist_min ) diag = true; } else // at least one pad has any other orient. Test is more tricky @@ -716,15 +716,15 @@ bool DRC::checkClearancePadToPad( D_PAD* aRefPad, D_PAD* aPad ) int segm_width; m_segmAngle = aRefPad->m_Orient; // Segment orient. - if( aRefPad->m_Size.y < aRefPad->m_Size.x ) // Build an horizontal equiv segment + if( aRefPad->m_Size.y() < aRefPad->m_Size.x() ) // Build an horizontal equiv segment { - segm_width = TO_LEGACY_LU( aRefPad->m_Size.y ); - m_segmLength = TO_LEGACY_LU( aRefPad->m_Size.x - aRefPad->m_Size.y ); + segm_width = TO_LEGACY_LU( aRefPad->m_Size.y() ); + m_segmLength = TO_LEGACY_LU( aRefPad->m_Size.x() - aRefPad->m_Size.y() ); } else // Vertical oval: build an horizontal equiv segment and rotate 90.0 deg { - segm_width = TO_LEGACY_LU( aRefPad->m_Size.x ); - m_segmLength = TO_LEGACY_LU( aRefPad->m_Size.y - aRefPad->m_Size.x ); + segm_width = TO_LEGACY_LU( aRefPad->m_Size.x() ); + m_segmLength = TO_LEGACY_LU( aRefPad->m_Size.y() - aRefPad->m_Size.x() ); m_segmAngle += 900; } @@ -796,13 +796,13 @@ bool DRC::checkClearanceSegmToPad( const D_PAD* aPad, int aSegmentWidth, int aMi int segmHalfWidth = aSegmentWidth / 2; seuil = segmHalfWidth + aMinDist; - padHalfsize.x = TO_LEGACY_LU( aPad->m_Size.x / 2 ); - padHalfsize.y = TO_LEGACY_LU( aPad->m_Size.y / 2 ); + padHalfsize.x = TO_LEGACY_LU( aPad->m_Size.x() / 2 ); + padHalfsize.y = TO_LEGACY_LU( aPad->m_Size.y() / 2 ); if( aPad->m_PadShape == PAD_TRAPEZOID ) // The size is bigger, due to m_DeltaSize extra size { - padHalfsize.x += TO_LEGACY_LU( ABS(aPad->m_DeltaSize.y) / 2 ); // Remember: m_DeltaSize.y is the m_Size.x change - padHalfsize.y += TO_LEGACY_LU( ABS(aPad->m_DeltaSize.x) / 2 ); // Remember: m_DeltaSize.x is the m_Size.y change + padHalfsize.x += TO_LEGACY_LU( abs( aPad->m_DeltaSize.y() ) / 2 ); // Remember: m_DeltaSize.y is the m_Size.x change + padHalfsize.y += TO_LEGACY_LU( abs( aPad->m_DeltaSize.x() ) / 2 ); // Remember: m_DeltaSize.x is the m_Size.y change } if( aPad->m_PadShape == PAD_CIRCLE ) diff --git a/pcbnew/editmod.cpp b/pcbnew/editmod.cpp index 45dedac2a3..6c8362bee4 100644 --- a/pcbnew/editmod.cpp +++ b/pcbnew/editmod.cpp @@ -82,7 +82,7 @@ void FOOTPRINT_EDIT_FRAME::Place_Ancre( MODULE* pt_mod ) for( ; pt_pad != NULL; pt_pad = pt_pad->Next() ) { - pt_pad->m_Pos0 += VECTOR_PCB( FROM_LEGACY_LU( moveVector.x ), FROM_LEGACY_LU( moveVector.y ) ); + pt_pad->m_Pos0 += VECTOR_PCB::fromXY( FROM_LEGACY_LU( moveVector.x ), FROM_LEGACY_LU( moveVector.y ) ); } /* Update the draw element coordinates. */ diff --git a/pcbnew/editrack.cpp b/pcbnew/editrack.cpp index 22fc44523f..8c37a12788 100644 --- a/pcbnew/editrack.cpp +++ b/pcbnew/editrack.cpp @@ -125,7 +125,7 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC ) pt_pad = (D_PAD*) LockPoint; /* A pad is found: put the starting point on pad center */ - pos = pt_pad->m_Pos; + pos = TO_LEGACY_LU_WXP( pt_pad->m_Pos ); GetBoard()->SetHighLightNet( pt_pad->GetNet() ); } else /* A track segment is found */ @@ -1067,7 +1067,7 @@ void DeleteNullTrackSegments( BOARD* pcb, DLIST& aTrackList ) */ void EnsureEndTrackOnPad( D_PAD* Pad ) { - if( g_CurrentTrackSegment->m_End == Pad->m_Pos ) // Ok ! + if( g_CurrentTrackSegment->m_End == TO_LEGACY_LU_WXP( Pad->m_Pos ) ) // Ok ! { g_CurrentTrackSegment->end = Pad; g_CurrentTrackSegment->SetState( END_ONPAD, ON ); @@ -1084,7 +1084,7 @@ void EnsureEndTrackOnPad( D_PAD* Pad ) lasttrack->end = g_CurrentTrackSegment; } - g_CurrentTrackSegment->m_End = Pad->m_Pos; + g_CurrentTrackSegment->m_End = TO_LEGACY_LU_WXP( Pad->m_Pos ); g_CurrentTrackSegment->SetState( END_ONPAD, OFF ); g_CurrentTrackSegment->end = Pad; diff --git a/pcbnew/export_gencad.cpp b/pcbnew/export_gencad.cpp index be7882fc42..b2f588342d 100644 --- a/pcbnew/export_gencad.cpp +++ b/pcbnew/export_gencad.cpp @@ -252,70 +252,70 @@ void CreatePadsShapesSection( FILE* file, BOARD* pcb ) fprintf( file, "PAD PAD%d", pad->GetSubRatsnest() ); - int dx = TO_LEGACY_LU( pad->m_Size.x / 2 ); - int dy = TO_LEGACY_LU( pad->m_Size.y / 2 ); + int dx = TO_LEGACY_LU( pad->m_Size.x() / 2 ); + int dy = TO_LEGACY_LU( pad->m_Size.y() / 2 ); switch( pad->m_PadShape ) { default: case PAD_CIRCLE: pad_type = "ROUND"; // how about oval holes? - fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x ) ); + fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x() ) ); fprintf( file, "CIRCLE %d %d %d\n", - TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ), dx ); + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ), dx ); break; case PAD_RECT: pad_type = "RECTANGULAR"; - fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x ) ); + fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x() ) ); fprintf( file, "RECTANGLE %d %d %d %d\n", - TO_LEGACY_LU( pad->m_Offset.x ) - dx, -TO_LEGACY_LU( pad->m_Offset.y ) - dy, - TO_LEGACY_LU( pad->m_Size.x ), TO_LEGACY_LU( pad->m_Size.y ) ); + TO_LEGACY_LU( pad->m_Offset.x() ) - dx, -TO_LEGACY_LU( pad->m_Offset.y() ) - dy, + TO_LEGACY_LU( pad->m_Size.x() ), TO_LEGACY_LU( pad->m_Size.y() ) ); break; case PAD_OVAL: /* Create outline by 2 lines and 2 arcs */ { pad_type = "FINGER"; - fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x ) ); + fprintf( file, " %s %d\n", pad_type, ( int )TO_LEGACY_LU( pad->m_Drill.x() ) ); int dr = dx - dy; if( dr >= 0 ) // Horizontal oval { int radius = dy; fprintf( file, "LINE %d %d %d %d\n", - -dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - radius, - dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - radius ); + -dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - radius, + dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - radius ); fprintf( file, "ARC %d %d %d %d %d %d\n", - dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - radius, - dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + radius, - dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) ); + dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - radius, + dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + radius, + dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) ); fprintf( file, "LINE %d %d %d %d\n", - dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + radius, - -dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + radius ); + dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + radius, + -dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + radius ); fprintf( file, "ARC %d %d %d %d %d %d\n", - -dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + radius, - -dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - radius, - -dr + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) ); + -dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + radius, + -dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - radius, + -dr + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) ); } else // Vertical oval { dr = -dr; int radius = dx; fprintf( file, "LINE %d %d %d %d\n", - -radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - dr, - -radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + dr ); + -radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - dr, + -radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + dr ); fprintf( file, "ARC %d %d %d %d %d %d\n", - -radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + dr, - radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + dr, - TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + dr ); + -radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + dr, + radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + dr, + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + dr ); fprintf( file, "LINE %d %d %d %d\n", - radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) + dr, - radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - dr ); + radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) + dr, + radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - dr ); fprintf( file, "ARC %d %d %d %d %d %d\n", - radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - dr, - -radius + TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - dr, - TO_LEGACY_LU( pad->m_Offset.x ), -TO_LEGACY_LU( pad->m_Offset.y ) - dr ); + radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - dr, + -radius + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - dr, + TO_LEGACY_LU( pad->m_Offset.x() ), -TO_LEGACY_LU( pad->m_Offset.y() ) - dr ); } break; } @@ -410,7 +410,7 @@ void CreateShapesSection( FILE* file, BOARD* pcb ) NORMALIZE_ANGLE_POS( orient ); fprintf( file, "PIN %s PAD%d %d %d %s %d %s", TO_UTF8( pinname ), pad->GetSubRatsnest(), - TO_LEGACY_LU( pad->m_Pos0.x ), TO_LEGACY_LU( -pad->m_Pos0.y ), + TO_LEGACY_LU( pad->m_Pos0.x() ), TO_LEGACY_LU( -pad->m_Pos0.y() ), layer, orient / 10, mirror ); if( orient % 10 ) diff --git a/pcbnew/export_vrml.cpp b/pcbnew/export_vrml.cpp index 8a8925af86..e6aa6a81ae 100644 --- a/pcbnew/export_vrml.cpp +++ b/pcbnew/export_vrml.cpp @@ -881,11 +881,11 @@ static void export_vrml_edge_module( EDGE_MODULE* module ) /*{{{*/ static void export_vrml_pad( BOARD* pcb, D_PAD* pad ) /*{{{*/ { - double hole_drill_w = (double) TO_LEGACY_LU_DBL( pad->m_Drill.x / 2 ); - double hole_drill_h = (double) TO_LEGACY_LU_DBL( pad->m_Drill.y / 2 ); + double hole_drill_w = (double) TO_LEGACY_LU_DBL( pad->m_Drill.x() / 2 ); + double hole_drill_h = (double) TO_LEGACY_LU_DBL( pad->m_Drill.y() / 2 ); double hole_drill = MIN( hole_drill_w, hole_drill_h ); - double hole_x = pad->m_Pos.x; - double hole_y = pad->m_Pos.y; + double hole_x = TO_LEGACY_LU_DBL( pad->m_Pos.x() ); + double hole_y = TO_LEGACY_LU_DBL( pad->m_Pos.y() ); /* Export the hole on the edge layer */ if( hole_drill > 0 ) @@ -916,8 +916,8 @@ static void export_vrml_pad( BOARD* pcb, D_PAD* pad ) /*{{{*/ wxSize pad_delta = TO_LEGACY_LU_WXS( pad->m_DeltaSize ); double pad_dx = pad_delta.x / 2; double pad_dy = pad_delta.y / 2; - double pad_w = TO_LEGACY_LU_DBL( pad->m_Size.x / 2 ); - double pad_h = TO_LEGACY_LU_DBL( pad->m_Size.y / 2 ); + double pad_w = TO_LEGACY_LU_DBL( pad->m_Size.x() / 2 ); + double pad_h = TO_LEGACY_LU_DBL( pad->m_Size.y() / 2 ); for( int layer = FIRST_COPPER_LAYER; layer < copper_layers; layer++ ) { diff --git a/pcbnew/gen_holes_and_tools_lists_for_drill.cpp b/pcbnew/gen_holes_and_tools_lists_for_drill.cpp index fb4e456ce2..fc6927a527 100644 --- a/pcbnew/gen_holes_and_tools_lists_for_drill.cpp +++ b/pcbnew/gen_holes_and_tools_lists_for_drill.cpp @@ -127,22 +127,22 @@ void Build_Holes_List( BOARD* aPcb, if( aGenerateNPTH_list && pad->m_Attribut != PAD_HOLE_NOT_PLATED ) continue; - if( pad->m_Drill.x == ZERO_LENGTH ) + if( pad->m_Drill.x() == ZERO_LENGTH ) continue; new_hole.m_Hole_NotPlated = (pad->m_Attribut == 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_Shape = 0; // hole shape: round - new_hole.m_Hole_Diameter = min( TO_LEGACY_LU( pad->m_Drill.x ), TO_LEGACY_LU( pad->m_Drill.y ) ); + new_hole.m_Hole_Diameter = min( TO_LEGACY_LU( pad->m_Drill.x() ), TO_LEGACY_LU( pad->m_Drill.y() ) ); new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter; if( pad->m_DrillShape != PAD_CIRCLE ) new_hole.m_Hole_Shape = 1; // oval flag set - new_hole.m_Hole_Size.x = TO_LEGACY_LU( pad->m_Drill.x ); - new_hole.m_Hole_Size.y = TO_LEGACY_LU( pad->m_Drill.y ); - new_hole.m_Hole_Pos = pad->m_Pos; // hole position + new_hole.m_Hole_Size.x = TO_LEGACY_LU( pad->m_Drill.x() ); + new_hole.m_Hole_Size.y = TO_LEGACY_LU( pad->m_Drill.y() ); + new_hole.m_Hole_Pos = TO_LEGACY_LU_WXP( pad->m_Pos ); // 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 ); diff --git a/pcbnew/gen_modules_placefile.cpp b/pcbnew/gen_modules_placefile.cpp index 1ffbb1f4aa..0b07d63b04 100644 --- a/pcbnew/gen_modules_placefile.cpp +++ b/pcbnew/gen_modules_placefile.cpp @@ -438,19 +438,20 @@ void PCB_EDIT_FRAME::GenModuleReport( wxCommandEvent& event ) { fprintf( rptfile, "$PAD \"%.4s\"\n", pad->m_Padname ); sprintf( line, "position %9.6f %9.6f\n", - TO_LEGACY_LU_DBL( pad->m_Pos0.x ) * conv_unit, - TO_LEGACY_LU_DBL( pad->m_Pos0.y ) * conv_unit ); + TO_LEGACY_LU_DBL( pad->m_Pos0.x() ) * conv_unit, + TO_LEGACY_LU_DBL( pad->m_Pos0.y() ) * conv_unit ); fputs( line, rptfile ); sprintf( line, "size %9.6f %9.6f\n", - TO_LEGACY_LU_DBL( pad->m_Size.x ) * conv_unit, - TO_LEGACY_LU_DBL( pad->m_Size.y ) * conv_unit ); + TO_LEGACY_LU_DBL( pad->m_Size.x() ) * conv_unit, + TO_LEGACY_LU_DBL( pad->m_Size.y() ) * conv_unit ); fputs( line, rptfile ); - sprintf( line, "drill %9.6f\n", TO_LEGACY_LU_DBL( pad->m_Drill.x ) * conv_unit ); + sprintf( line, "drill %9.6f\n", + TO_LEGACY_LU_DBL( pad->m_Drill.x() ) * conv_unit ); fputs( line, rptfile ); sprintf( line, "shape_offset %9.6f %9.6f\n", - TO_LEGACY_LU_DBL( pad->m_Offset.x ) * conv_unit, - TO_LEGACY_LU_DBL( pad->m_Offset.y ) * conv_unit ); + TO_LEGACY_LU_DBL( pad->m_Offset.x() ) * conv_unit, + TO_LEGACY_LU_DBL( pad->m_Offset.y() ) * conv_unit ); fputs( line, rptfile ); sprintf( line, "orientation %.2f\n", diff --git a/pcbnew/globaleditpad.cpp b/pcbnew/globaleditpad.cpp index 72baa60953..82ecb13d19 100644 --- a/pcbnew/globaleditpad.cpp +++ b/pcbnew/globaleditpad.cpp @@ -254,19 +254,19 @@ void PCB_BASE_FRAME::Global_Import_Pad_Settings( D_PAD* aPad, bool aDraw ) if( pt_pad->m_PadShape != PAD_TRAPEZOID ) { - pt_pad->m_DeltaSize.x = ZERO_LENGTH; - pt_pad->m_DeltaSize.y = ZERO_LENGTH; + pt_pad->m_DeltaSize.x( ZERO_LENGTH ); + pt_pad->m_DeltaSize.y( ZERO_LENGTH ); } if( pt_pad->m_PadShape == PAD_CIRCLE ) - pt_pad->m_Size.y = pt_pad->m_Size.x; + pt_pad->m_Size.y( pt_pad->m_Size.x() ); switch( pt_pad->m_Attribut & 0x7F ) { case PAD_SMD: case PAD_CONN: - pt_pad->m_Drill = VECTOR_PCB(ZERO_LENGTH, ZERO_LENGTH);//wxSize( 0, 0 ); - pt_pad->m_Offset.x = ZERO_LENGTH; - pt_pad->m_Offset.y = ZERO_LENGTH; + pt_pad->m_Drill = VECTOR_PCB::fromXY(ZERO_LENGTH, ZERO_LENGTH);//wxSize( 0, 0 ); + pt_pad->m_Offset.x( ZERO_LENGTH ); + pt_pad->m_Offset.y( ZERO_LENGTH ); break; default: diff --git a/pcbnew/gpcb_exchange.cpp b/pcbnew/gpcb_exchange.cpp index 75ce134ab7..d41f5c96d7 100644 --- a/pcbnew/gpcb_exchange.cpp +++ b/pcbnew/gpcb_exchange.cpp @@ -369,16 +369,14 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName ) { Pad->SetPadName( params[10] ); } - Pad->m_Pos.x = (ibuf[0] + ibuf[2]) / 2; - Pad->m_Pos.y = (ibuf[1] + ibuf[3]) / 2; - Pad->m_Size.x = FROM_LEGACY_LU( ibuf[4] + abs( ibuf[0] - ibuf[2] ) ); - Pad->m_Size.y = FROM_LEGACY_LU( ibuf[4] + abs( ibuf[1] - ibuf[3] ) ); - Pad->m_Pos.x += m_Pos.x; - Pad->m_Pos.y += m_Pos.y; + Pad->m_Size.x( FROM_LEGACY_LU( ibuf[4] + abs( ibuf[0] - ibuf[2] ) ) ); + Pad->m_Size.y( FROM_LEGACY_LU( ibuf[4] + abs( ibuf[1] - ibuf[3] ) ) ); + Pad->m_Pos.x( FROM_LEGACY_LU( (ibuf[0] + ibuf[2]) / 2 + m_Pos.x ) ); + Pad->m_Pos.y( FROM_LEGACY_LU( (ibuf[1] + ibuf[3]) / 2 + m_Pos.y ) ); if( !TestFlags( params[iflgidx], 0x0100, wxT( "square" ) ) ) { - if( Pad->m_Size.x == Pad->m_Size.y ) + if( Pad->m_Size.x() == Pad->m_Size.y() ) Pad->m_PadShape = PAD_ROUND; else Pad->m_PadShape = PAD_OVAL; @@ -428,14 +426,14 @@ bool MODULE::Read_GPCB_Descr( const wxString& CmpFullFileName ) Pad->SetPadName( params[9] ); } - Pad->m_Pos.x = ibuf[0]; - Pad->m_Pos.y = ibuf[1]; - Pad->m_Drill.x = Pad->m_Drill.y = FROM_LEGACY_LU( (int) ibuf[5] ); - Pad->m_Size.x = Pad->m_Size.y = FROM_LEGACY_LU( ibuf[3] ) + Pad->m_Drill.x; - Pad->m_Pos.x += m_Pos.x; - Pad->m_Pos.y += m_Pos.y; + Pad->m_Drill.x( FROM_LEGACY_LU( (int) ibuf[5] ) ); + Pad->m_Drill.y( Pad->m_Drill.x() ); + Pad->m_Size.x( FROM_LEGACY_LU( ibuf[3] ) + Pad->m_Drill.x() ); + Pad->m_Size.y( Pad->m_Size.x() ); + Pad->m_Pos.x( FROM_LEGACY_LU( ibuf[0] + m_Pos.x ) ); + Pad->m_Pos.y( FROM_LEGACY_LU( ibuf[1] + m_Pos.y ) ); - if( (Pad->m_PadShape == PAD_ROUND) && (Pad->m_Size.x != Pad->m_Size.y) ) + if( (Pad->m_PadShape == PAD_ROUND) && (Pad->m_Size.x() != Pad->m_Size.y()) ) Pad->m_PadShape = PAD_OVAL; m_Pads.PushBack( Pad ); diff --git a/pcbnew/graphpcb.cpp b/pcbnew/graphpcb.cpp index 169beeaa6a..ed0753d8f3 100644 --- a/pcbnew/graphpcb.cpp +++ b/pcbnew/graphpcb.cpp @@ -89,7 +89,7 @@ void PlacePad( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logic ) int dx, dy; wxPoint shape_pos = pt_pad->ReturnShapePos(); - dx = TO_LEGACY_LU( pt_pad->m_Size.x / 2 ); + dx = TO_LEGACY_LU( pt_pad->m_Size.x() / 2 ); dx += marge; if( pt_pad->m_PadShape == PAD_CIRCLE ) @@ -100,13 +100,13 @@ void PlacePad( BOARD* Pcb, D_PAD* pt_pad, int color, int marge, int op_logic ) } - dy = TO_LEGACY_LU( pt_pad->m_Size.y / 2 ); + dy = TO_LEGACY_LU( pt_pad->m_Size.y() / 2 ); dy += marge; if( pt_pad->m_PadShape == PAD_TRAPEZOID ) { - dx += TO_LEGACY_LU( ABS( pt_pad->m_DeltaSize.y ) / 2 ); - dy += TO_LEGACY_LU( ABS( pt_pad->m_DeltaSize.x ) / 2 ); + dx += TO_LEGACY_LU( abs( pt_pad->m_DeltaSize.y() ) / 2 ); + dy += TO_LEGACY_LU( abs( pt_pad->m_DeltaSize.x() ) / 2 ); } if( ( pt_pad->m_Orient % 900 ) == 0 ) /* The pad is a rectangle diff --git a/pcbnew/ioascii.cpp b/pcbnew/ioascii.cpp index fca45b6786..590f89339d 100644 --- a/pcbnew/ioascii.cpp +++ b/pcbnew/ioascii.cpp @@ -586,16 +586,16 @@ int PCB_BASE_FRAME::ReadSetup( LINE_READER* aReader ) if( stricmp( line, "PadSize" ) == 0 ) { - g_Pad_Master.m_Size.x = LENGTH_LOAD_STR( data ); + g_Pad_Master.m_Size.x( LENGTH_LOAD_STR( data ) ); data = strtok( NULL, delims ); - g_Pad_Master.m_Size.y = LENGTH_LOAD_STR( data ); + g_Pad_Master.m_Size.y( LENGTH_LOAD_STR( data ) ); continue; } if( stricmp( line, "PadDrill" ) == 0 ) { - g_Pad_Master.m_Drill.x = LENGTH_LOAD_STR( data ); - g_Pad_Master.m_Drill.y = g_Pad_Master.m_Drill.x; + g_Pad_Master.m_Drill.x( LENGTH_LOAD_STR( data ) ); + g_Pad_Master.m_Drill.y( g_Pad_Master.m_Drill.x() ); continue; } @@ -757,8 +757,8 @@ static int WriteSetup( FILE* aFile, PCB_EDIT_FRAME* aFrame, BOARD* aBoard ) fprintf( aFile, "EdgeModWidth %d\n", g_ModuleSegmentWidth ); fprintf( aFile, "TextModSize %d %d\n", g_ModuleTextSize.x, g_ModuleTextSize.y ); fprintf( aFile, "TextModWidth %d\n", g_ModuleTextWidth ); - fprintf( aFile, "PadSize "FM_LENSV" "FM_LENSV"\n", ARG_LENSV( g_Pad_Master.m_Size.x ), ARG_LENSV( g_Pad_Master.m_Size.y ) ); - fprintf( aFile, "PadDrill "FM_LENSV"\n", ARG_LENSV( g_Pad_Master.m_Drill.x ) ); + fprintf( aFile, "PadSize "FM_LENSV" "FM_LENSV"\n", ARG_LENSV( g_Pad_Master.m_Size.x() ), ARG_LENSV( g_Pad_Master.m_Size.y() ) ); + fprintf( aFile, "PadDrill "FM_LENSV"\n", ARG_LENSV( g_Pad_Master.m_Drill.x() ) ); fprintf( aFile, "Pad2MaskClearance %d\n", aBoard->GetBoardDesignSettings()->m_SolderMaskMargin ); diff --git a/pcbnew/magnetic_tracks_functions.cpp b/pcbnew/magnetic_tracks_functions.cpp index a9e4791471..fed6be7779 100644 --- a/pcbnew/magnetic_tracks_functions.cpp +++ b/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 = TO_LEGACY_LU_WXP( pad->m_Pos ); return true; } } diff --git a/pcbnew/modedit.cpp b/pcbnew/modedit.cpp index d0412eab27..adcee931af 100644 --- a/pcbnew/modedit.cpp +++ b/pcbnew/modedit.cpp @@ -708,18 +708,18 @@ void FOOTPRINT_EDIT_FRAME::Transform( MODULE* module, int transform ) for( ; pad != NULL; pad = (D_PAD*) pad->Next() ) { - pad->m_Pos0 = FROM_LEGACY_LU_VEC( pad->m_Pos ); + pad->m_Pos0 = pad->m_Pos; pad->m_Orient -= angle; wxPoint of; - of.x = TO_LEGACY_LU( pad->m_Offset.x ); - of.y = TO_LEGACY_LU( pad->m_Offset.y ); + of.x = TO_LEGACY_LU( pad->m_Offset.x() ); + of.y = TO_LEGACY_LU( pad->m_Offset.y() ); RotatePoint( &of.x, &of.y, angle ); - pad->m_Offset.x = FROM_LEGACY_LU( of.x ); - pad->m_Offset.y = FROM_LEGACY_LU( of.y ); - EXCHG( pad->m_Size.x, pad->m_Size.y ); + pad->m_Offset.x( FROM_LEGACY_LU( of.x ) ); + pad->m_Offset.y( FROM_LEGACY_LU( of.y ) ); + EXCHG( pad->m_Size[0], pad->m_Size[1] ); /// @TODO: make it using geom. transform wxSize delta = TO_LEGACY_LU_WXS( pad->m_DeltaSize ); RotatePoint( &delta.x, &delta.y, -angle ); - pad->m_DeltaSize = VECTOR_PCB( FROM_LEGACY_LU( delta.x ), FROM_LEGACY_LU( delta.y ) ); + pad->m_DeltaSize = VECTOR_PCB::fromXY( FROM_LEGACY_LU( delta.x ), FROM_LEGACY_LU( delta.y ) ); } module->m_Reference->m_Pos0 = module->m_Reference->m_Pos; @@ -756,10 +756,10 @@ void FOOTPRINT_EDIT_FRAME::Transform( MODULE* module, int transform ) case ID_MODEDIT_MODULE_MIRROR: for( ; pad != NULL; pad = (D_PAD*) pad->Next() ) { - NEGATE( pad->m_Pos.y ); - NEGATE( pad->m_Pos0.y ); - NEGATE( pad->m_Offset.y ); - NEGATE( pad->m_DeltaSize.y ); + pad->m_Pos.y( -pad->m_Pos.y() ); + pad->m_Pos0.y( -pad->m_Pos0.y() ); + pad->m_Offset.y( -pad->m_Offset.y() ); + pad->m_DeltaSize.y( -pad->m_DeltaSize.y() ); if( pad->m_Orient ) pad->m_Orient = 3600 - pad->m_Orient; diff --git a/pcbnew/move-drag_pads.cpp b/pcbnew/move-drag_pads.cpp index f3e0787743..dd6951a7b5 100644 --- a/pcbnew/move-drag_pads.cpp +++ b/pcbnew/move-drag_pads.cpp @@ -23,7 +23,7 @@ static D_PAD* s_CurrentSelectedPad; -static wxPoint Pad_OldPos; +static VECTOR_PCB Pad_OldPos; /* Cancel move pad command. @@ -76,7 +76,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->m_Pos = FROM_LEGACY_LU_VEC( screen->GetCrossHairPosition() ); pad->Draw( aPanel, aDC, GR_XOR ); if( !g_Drag_Pistes_On ) @@ -91,12 +91,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 = TO_LEGACY_LU_WXP( pad->m_Pos ); } if( g_DragSegmentList[ii].m_Pad_End ) { - Track->m_End = pad->m_Pos; + Track->m_End = TO_LEGACY_LU_WXP( pad->m_Pos ); } Track->Draw( aPanel, aDC, GR_XOR ); @@ -148,7 +148,7 @@ void PCB_BASE_FRAME::Import_Pad_Settings( D_PAD* aPad, bool aDraw ) aPad->m_Orient = g_Pad_Master.m_Orient + ( (MODULE*) aPad->GetParent() )->m_Orient; aPad->m_Size = g_Pad_Master.m_Size; - aPad->m_DeltaSize = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH );//wxSize( 0, 0 ); + aPad->m_DeltaSize = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH );//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; @@ -160,7 +160,7 @@ void PCB_BASE_FRAME::Import_Pad_Settings( D_PAD* aPad, bool aDraw ) break; case PAD_CIRCLE: - aPad->m_Size.y = aPad->m_Size.x; + aPad->m_Size.y( aPad->m_Size.x() ); break; } @@ -168,8 +168,8 @@ void PCB_BASE_FRAME::Import_Pad_Settings( D_PAD* aPad, bool aDraw ) { case PAD_SMD: case PAD_CONN: - aPad->m_Drill = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); //wxSize( 0, 0 ); - aPad->m_Offset = VECTOR_PCB( ZERO_LENGTH, ZERO_LENGTH ); + aPad->m_Drill = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); //wxSize( 0, 0 ); + aPad->m_Offset = VECTOR_PCB::fromXY( ZERO_LENGTH, ZERO_LENGTH ); } aPad->ComputeShapeMaxRadius(); @@ -200,11 +200,11 @@ void PCB_BASE_FRAME::AddPad( MODULE* Module, bool draw ) Import_Pad_Settings( Pad, false ); Pad->SetNetname( wxEmptyString ); - Pad->m_Pos = GetScreen()->GetCrossHairPosition(); + Pad->m_Pos = FROM_LEGACY_LU_VEC( GetScreen()->GetCrossHairPosition() ); // Set the relative pad position // ( pad position for module orient, 0, and relative to the module position) - Pad->m_Pos0 = FROM_LEGACY_LU_VEC( Pad->m_Pos - Module->m_Pos ); + Pad->m_Pos0 = Pad->m_Pos - FROM_LEGACY_LU_VEC( Module->m_Pos ); wxPoint p = TO_LEGACY_LU_WXP( Pad->m_Pos0 ); RotatePoint( &p, -Module->m_Orient ); Pad->m_Pos0 = FROM_LEGACY_LU_VEC( p ); @@ -317,17 +317,17 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC ) // Set the old state if( g_DragSegmentList[ii].m_Pad_Start ) - Track->m_Start = Pad_OldPos; + Track->m_Start = TO_LEGACY_LU_WXP( Pad_OldPos ); if( g_DragSegmentList[ii].m_Pad_End ) - Track->m_End = Pad_OldPos; + Track->m_End = TO_LEGACY_LU_WXP( Pad_OldPos ); picker.m_PickedItem = Track; pickList.PushItem( picker ); } /* Save old module and old items values */ - wxPoint pad_curr_position = Pad->m_Pos; + wxPoint pad_curr_position = TO_LEGACY_LU_WXP( Pad->m_Pos ); Pad->m_Pos = Pad_OldPos; @@ -340,7 +340,7 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC ) SaveCopyInUndoList( pickList, UR_CHANGED ); } - Pad->m_Pos = pad_curr_position; + Pad->m_Pos = FROM_LEGACY_LU_VEC( pad_curr_position ); Pad->Draw( DrawPanel, DC, GR_XOR ); /* Redraw dragged track segments */ @@ -350,10 +350,10 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC ) // Set the new state if( g_DragSegmentList[ii].m_Pad_Start ) - Track->m_Start = Pad->m_Pos; + Track->m_Start = TO_LEGACY_LU_WXP( Pad->m_Pos ); if( g_DragSegmentList[ii].m_Pad_End ) - Track->m_End = Pad->m_Pos; + Track->m_End = TO_LEGACY_LU_WXP( Pad->m_Pos ); Track->SetState( IN_EDIT, OFF ); @@ -362,12 +362,12 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* Pad, wxDC* DC ) } /* Compute local coordinates (i.e refer to Module position and for Module orient = 0) */ - dX = Pad->m_Pos.x - Pad_OldPos.x; - dY = Pad->m_Pos.y - Pad_OldPos.y; + dX = TO_LEGACY_LU( Pad->m_Pos.x() - Pad_OldPos.x() ); + dY = TO_LEGACY_LU( Pad->m_Pos.y() - Pad_OldPos.y() ); RotatePoint( &dX, &dY, -Module->m_Orient ); - Pad->m_Pos0.x += FROM_LEGACY_LU( dX ); - s_CurrentSelectedPad->m_Pos0.y += FROM_LEGACY_LU( dY ); /// @BUG??? + Pad->m_Pos0.x( Pad->m_Pos0.x() + FROM_LEGACY_LU( dX ) ); + Pad->m_Pos0.y( Pad->m_Pos0.y() + FROM_LEGACY_LU( dY ) ); /// @BUG was it really s_CurrentSelectedPad ??? Pad->m_Flags = 0; @@ -402,13 +402,13 @@ void PCB_BASE_FRAME::RotatePad( D_PAD* Pad, wxDC* DC ) if( DC ) Module->Draw( DrawPanel, DC, GR_XOR ); - EXCHG( Pad->m_Size.x, Pad->m_Size.y ); - EXCHG( Pad->m_Drill.x, Pad->m_Drill.y ); - EXCHG( Pad->m_Offset.x, Pad->m_Offset.y ); - Pad->m_Offset.y = -Pad->m_Offset.y; + EXCHG( Pad->m_Size[0], Pad->m_Size[1] ); /// @TODO: make it using geom. transform + EXCHG( Pad->m_Drill[0], Pad->m_Drill[1] ); + EXCHG( Pad->m_Offset[0], Pad->m_Offset[1] ); + Pad->m_Offset.y( -Pad->m_Offset.y() ); - EXCHG( Pad->m_DeltaSize.x, Pad->m_DeltaSize.y ); - Pad->m_DeltaSize.x = -Pad->m_DeltaSize.x; + EXCHG( Pad->m_DeltaSize[0], Pad->m_DeltaSize[1] ); + Pad->m_DeltaSize.x( -Pad->m_DeltaSize.x() ); Module->CalculateBoundingBox(); Pad->DisplayInfo( this ); diff --git a/pcbnew/muonde.cpp b/pcbnew/muonde.cpp index d84cc0591c..424861ccbc 100644 --- a/pcbnew/muonde.cpp +++ b/pcbnew/muonde.cpp @@ -260,10 +260,11 @@ MODULE* PCB_EDIT_FRAME::Genere_Self( wxDC* DC ) Module->m_Pads.PushFront( PtPad ); PtPad->SetPadName( wxT( "1" ) ); - PtPad->m_Pos = Mself.m_End; - PtPad->m_Pos0 = FROM_LEGACY_LU_VEC( PtPad->m_Pos - Module->m_Pos ); - PtPad->m_Size.x = PtPad->m_Size.y = FROM_LEGACY_LU( Mself.m_Width ); - PtPad->m_layerMask = g_TabOneLayerMask[Module->GetLayer()]; + PtPad->m_Pos = FROM_LEGACY_LU_VEC( Mself.m_End ); + PtPad->m_Pos0 = PtPad->m_Pos - FROM_LEGACY_LU_VEC( Module->m_Pos ); + PtPad->m_Size.x( FROM_LEGACY_LU( Mself.m_Width ) ); + PtPad->m_Size.y( PtPad->m_Size.x() ); + PtPad->m_layerMask = g_TabOneLayerMask[Module->GetLayer()]; PtPad->m_Attribut = PAD_SMD; PtPad->m_PadShape = PAD_CIRCLE; PtPad->ComputeShapeMaxRadius(); @@ -275,8 +276,8 @@ MODULE* PCB_EDIT_FRAME::Genere_Self( wxDC* DC ) PtPad = newpad; PtPad->SetPadName( wxT( "2" ) ); - PtPad->m_Pos = Mself.m_Start; - PtPad->m_Pos0 = FROM_LEGACY_LU_VEC( PtPad->m_Pos - Module->m_Pos ); + PtPad->m_Pos = FROM_LEGACY_LU_VEC( Mself.m_Start ); + PtPad->m_Pos0 = PtPad->m_Pos - FROM_LEGACY_LU_VEC( Module->m_Pos ); /* Modify text positions. */ Module->DisplayInfo( this ); @@ -552,8 +553,9 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveBasicShape( const wxString& name, int pad_c Module->m_Pads.PushFront( pad ); - pad->m_Size.x = pad->m_Size.y = FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ); - pad->m_Pos = Module->m_Pos; + pad->m_Size.x( FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ) ); + pad->m_Size.y( pad->m_Size.x() ); + pad->m_Pos = FROM_LEGACY_LU_VEC( Module->m_Pos ); pad->m_PadShape = PAD_RECT; pad->m_Attribut = PAD_SMD; pad->m_layerMask = LAYER_FRONT; @@ -656,19 +658,19 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveComponent( int shape_type ) switch( shape_type ) { case 0: //Gap : - pad->m_Pos0.x = FROM_LEGACY_LU( oX = -( gap_size + TO_LEGACY_LU( pad->m_Size.x ) ) / 2 ); - pad->m_Pos.x += TO_LEGACY_LU( pad->m_Pos0.x ); + pad->m_Pos0.x( FROM_LEGACY_LU( oX = -( gap_size + TO_LEGACY_LU( pad->m_Size.x() ) ) / 2 ) ); + pad->m_Pos.x( pad->m_Pos.x() + pad->m_Pos0.x() ); pad = pad->Next(); - pad->m_Pos0.x = FROM_LEGACY_LU( oX + gap_size + TO_LEGACY_LU( pad->m_Size.x ) ); - pad->m_Pos.x += TO_LEGACY_LU( pad->m_Pos0.x ); + pad->m_Pos0.x( FROM_LEGACY_LU( oX + gap_size + TO_LEGACY_LU( pad->m_Size.x() ) ) ); + pad->m_Pos.x( pad->m_Pos.x() + pad->m_Pos0.x() ); break; case 1: //Stub : pad->SetPadName( wxT( "1" ) ); pad = pad->Next(); - pad->m_Pos0.y = FROM_LEGACY_LU( -( gap_size + TO_LEGACY_LU( pad->m_Size.y ) ) / 2 ); - pad->m_Size.y = FROM_LEGACY_LU( gap_size ); - pad->m_Pos.y += TO_LEGACY_LU( pad->m_Pos0.y ); + pad->m_Pos0.y( FROM_LEGACY_LU( -( gap_size + TO_LEGACY_LU( pad->m_Size.y() ) ) / 2 ) ); + pad->m_Size.y( FROM_LEGACY_LU( gap_size ) ); + pad->m_Pos.y( pad->m_Pos.y() + pad->m_Pos0.y() ); break; case 2: // Arc Stub created by a polygonal approach: @@ -683,7 +685,7 @@ MODULE* PCB_EDIT_FRAME::Create_MuWaveComponent( int shape_type ) std::vector polyPoints = edge->GetPolyPoints(); polyPoints.reserve( numPoints ); - edge->m_Start0.y = TO_LEGACY_LU( -pad->m_Size.y / 2 ); + edge->m_Start0.y = TO_LEGACY_LU( -pad->m_Size.y() / 2 ); polyPoints.push_back( wxPoint( 0, 0 ) ); @@ -968,12 +970,12 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape() Module = Create_MuWaveBasicShape( cmp_name, pad_count ); pad1 = Module->m_Pads; - pad1->m_Pos0.x = FROM_LEGACY_LU( -ShapeSize.x / 2 ); - pad1->m_Pos.x += TO_LEGACY_LU( pad1->m_Pos0.x ); + pad1->m_Pos0.x( FROM_LEGACY_LU( -ShapeSize.x / 2 ) ); + pad1->m_Pos.x( pad1->m_Pos.x() + pad1->m_Pos0.x() ); pad2 = (D_PAD*) pad1->Next(); - pad2->m_Pos0.x = pad1->m_Pos0.x + FROM_LEGACY_LU( ShapeSize.x ); - pad2->m_Pos.x += TO_LEGACY_LU( pad2->m_Pos0.x ); + pad2->m_Pos0.x( pad1->m_Pos0.x() + FROM_LEGACY_LU( ShapeSize.x ) ); + pad2->m_Pos.x( pad2->m_Pos.x() + pad2->m_Pos0.x() ); edge = new EDGE_MODULE( Module ); @@ -987,13 +989,13 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape() polyPoints.reserve( 2 * PolyEdges.size() + 2 ); // Init start point coord: - polyPoints.push_back( wxPoint( TO_LEGACY_LU( pad1->m_Pos0.x ), 0 ) ); + polyPoints.push_back( wxPoint( TO_LEGACY_LU( pad1->m_Pos0.x() ), 0 ) ); wxPoint first_coordinate, last_coordinate; for( unsigned ii = 0; ii < PolyEdges.size(); ii++ ) // Copy points { - last_coordinate.x = wxRound( PolyEdges[ii] * ShapeScaleX ) + TO_LEGACY_LU( pad1->m_Pos0.x ); + last_coordinate.x = wxRound( PolyEdges[ii] * ShapeScaleX ) + TO_LEGACY_LU( pad1->m_Pos0.x() ); last_coordinate.y = -wxRound( PolyEdges[ii] * ShapeScaleY ); polyPoints.push_back( last_coordinate ); } @@ -1005,15 +1007,17 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape() case 0: // Single case 2: // Single mirrored // Init end point coord: - pad2->m_Pos0.x = FROM_LEGACY_LU( last_coordinate.x ); + pad2->m_Pos0.x( FROM_LEGACY_LU( last_coordinate.x ) ); polyPoints.push_back( wxPoint( last_coordinate.x, 0 ) ); - pad1->m_Size.x = pad1->m_Size.y = FROM_LEGACY_LU( ABS( first_coordinate.y ) ); - pad2->m_Size.x = pad2->m_Size.y = FROM_LEGACY_LU( ABS( last_coordinate.y ) ); - pad1->m_Pos0.y = FROM_LEGACY_LU( first_coordinate.y / 2 ); - pad2->m_Pos0.y = FROM_LEGACY_LU( last_coordinate.y / 2 ); - pad1->m_Pos.y = TO_LEGACY_LU( pad1->m_Pos0.y ) + Module->m_Pos.y; - pad2->m_Pos.y = TO_LEGACY_LU( pad2->m_Pos0.y ) + Module->m_Pos.y; + pad1->m_Size.x( FROM_LEGACY_LU( abs( first_coordinate.y ) ) ); + pad1->m_Size.y( pad1->m_Size.x() ); + pad2->m_Size.x( FROM_LEGACY_LU( abs( last_coordinate.y ) ) ); + pad2->m_Size.y( pad2->m_Size.x() ); + pad1->m_Pos0.y( FROM_LEGACY_LU( first_coordinate.y / 2 ) ); + pad2->m_Pos0.y( FROM_LEGACY_LU( last_coordinate.y / 2 ) ); + pad1->m_Pos.y( pad1->m_Pos0.y() + FROM_LEGACY_LU( Module->m_Pos.y ) ); + pad2->m_Pos.y( pad2->m_Pos0.y() + FROM_LEGACY_LU( Module->m_Pos.y ) ); break; case 1: // Symmetric @@ -1026,8 +1030,10 @@ MODULE* PCB_EDIT_FRAME::Create_MuWavePolygonShape() polyPoints.push_back( pt ); } - pad1->m_Size.x = pad1->m_Size.y = FROM_LEGACY_LU( 2 * ABS( first_coordinate.y ) ); - pad2->m_Size.x = pad2->m_Size.y = FROM_LEGACY_LU( 2 * ABS( last_coordinate.y ) ); + pad1->m_Size.x( FROM_LEGACY_LU( 2 * abs( first_coordinate.y ) ) ); + pad1->m_Size.y( pad1->m_Size.x() ); + pad2->m_Size.x( FROM_LEGACY_LU( 2 * abs( last_coordinate.y ) ) ); + pad2->m_Size.y( pad2->m_Size.x() ); break; } @@ -1073,7 +1079,7 @@ void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* Module ) Module->Draw( DrawPanel, DC, GR_XOR ); /* Calculate the current dimension. */ - gap_size = TO_LEGACY_LU( next_pad->m_Pos0.x - pad->m_Pos0.x - pad->m_Size.x ); + gap_size = TO_LEGACY_LU( next_pad->m_Pos0.x() - pad->m_Pos0.x() - pad->m_Size.x() ); /* Entrer the desired length of the gap. */ msg = ReturnStringFromValue( g_UserUnit, gap_size, GetScreen()->GetInternalUnits() ); @@ -1086,21 +1092,29 @@ void PCB_EDIT_FRAME::Edit_Gap( wxDC* DC, MODULE* Module ) gap_size = ReturnValueFromString( g_UserUnit, msg, GetScreen()->GetInternalUnits() ); /* Updating sizes of pads forming the gap. */ - pad->m_Size.x = pad->m_Size.y = FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ); - pad->m_Pos0.y = ZERO_LENGTH; - pad->m_Pos0.x = FROM_LEGACY_LU( oX = -( ( gap_size + TO_LEGACY_LU( pad->m_Size.x ) ) / 2 ) ); - pad->m_Pos.x = TO_LEGACY_LU( pad->m_Pos0.x ) + Module->m_Pos.x; - pad->m_Pos.y = TO_LEGACY_LU( 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 ); + pad->m_Size.x( FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ) ); + pad->m_Size.y( pad->m_Size.x() ); + pad->m_Pos0.y( ZERO_LENGTH ); + pad->m_Pos0.x( FROM_LEGACY_LU( oX = -( ( gap_size + TO_LEGACY_LU( pad->m_Size.x() ) ) / 2 ) ) ); + pad->m_Pos.x( pad->m_Pos0.x() + FROM_LEGACY_LU( Module->m_Pos.x ) ); + pad->m_Pos.y( pad->m_Pos0.y() + FROM_LEGACY_LU( Module->m_Pos.y ) ); - next_pad->m_Size.x = next_pad->m_Size.y = FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ); - next_pad->m_Pos0.y = ZERO_LENGTH; - next_pad->m_Pos0.x = FROM_LEGACY_LU( oX + gap_size + TO_LEGACY_LU( next_pad->m_Size.x ) ); - next_pad->m_Pos.x = TO_LEGACY_LU( next_pad->m_Pos0.x ) + Module->m_Pos.x; - next_pad->m_Pos.y = TO_LEGACY_LU( next_pad->m_Pos0.y ) + Module->m_Pos.y; - RotatePoint( &next_pad->m_Pos.x, &next_pad->m_Pos.y, + wxPoint pos = TO_LEGACY_LU_WXP( pad->m_Pos ); + RotatePoint( &pos.x, &pos.y, Module->m_Pos.x, Module->m_Pos.y, Module->m_Orient ); + pad->m_Pos = FROM_LEGACY_LU_VEC( pos ); + + next_pad->m_Size.x( FROM_LEGACY_LU( GetBoard()->GetCurrentTrackWidth() ) ); + next_pad->m_Size.y( next_pad->m_Size.x() ); + next_pad->m_Pos0.y( ZERO_LENGTH ); + next_pad->m_Pos0.x( FROM_LEGACY_LU( oX + gap_size + TO_LEGACY_LU( next_pad->m_Size.x() ) ) ); + next_pad->m_Pos.x( next_pad->m_Pos0.x() + FROM_LEGACY_LU( Module->m_Pos.x ) ); + next_pad->m_Pos.y( next_pad->m_Pos0.y() + FROM_LEGACY_LU( Module->m_Pos.y ) ); + + pos = TO_LEGACY_LU_WXP( next_pad->m_Pos ); + RotatePoint( &pos.x, &pos.y, + Module->m_Pos.x, Module->m_Pos.y, Module->m_Orient ); + next_pad->m_Pos = FROM_LEGACY_LU_VEC( pos ); Module->Draw( DrawPanel, DC, GR_OR ); } diff --git a/pcbnew/pcbnew_config.cpp b/pcbnew/pcbnew_config.cpp index 388cc84bcc..3437e087c9 100644 --- a/pcbnew/pcbnew_config.cpp +++ b/pcbnew/pcbnew_config.cpp @@ -217,16 +217,25 @@ PARAM_CFG_ARRAY& PCB_EDIT_FRAME::GetProjectFileParameters() m_projectFileParams.push_back( new PARAM_CFG_LIBNAME_LIST( wxT( "LibName" ), &g_LibraryNames, GROUPLIB ) ); -#ifdef KICAD_NANOMETRE +//#ifdef KICAD_NANOMETRE /* TODO: something should be done here!!! */ -#else - m_projectFileParams.push_back( new PARAM_CFG_INT( wxT( "PadDrlX" ), &g_Pad_Master.m_Drill.x, - 320, 0, 0x7FFF ) ); - m_projectFileParams.push_back( new PARAM_CFG_INT( wxT( "PadDimH" ), &g_Pad_Master.m_Size.x, - 550, 0, 0x7FFF ) ); - m_projectFileParams.push_back( new PARAM_CFG_INT( wxT( "PadDimV" ), &g_Pad_Master.m_Size.y, - 550, 0, 0x7FFF ) ); -#endif +//#else + m_projectFileParams.push_back( new PARAM_CFG_LENGTH_PCB( wxT( "PadDrlX" ), + &g_Pad_Master.m_Drill[0], + FROM_LEGACY_LU( 320 ), + ZERO_LENGTH, + FROM_LEGACY_LU( 0x7FFF ) ) ); + m_projectFileParams.push_back( new PARAM_CFG_LENGTH_PCB( wxT( "PadDimH" ), + &g_Pad_Master.m_Size[0], + FROM_LEGACY_LU( 550 ), + ZERO_LENGTH, + FROM_LEGACY_LU( 0x7FFF ) ) ); + m_projectFileParams.push_back( new PARAM_CFG_LENGTH_PCB( wxT( "PadDimV" ), + &g_Pad_Master.m_Size[1], + FROM_LEGACY_LU( 550 ), + ZERO_LENGTH, + FROM_LEGACY_LU( 0x7FFF ) ) ); +//#endif m_projectFileParams.push_back( new PARAM_CFG_INT( wxT( "BoardThickness" ), &boardDesignSettings.m_BoardThickness, 630, 0, 0xFFFF ) ); diff --git a/pcbnew/plot_rtn.cpp b/pcbnew/plot_rtn.cpp index d3a3ed10c0..2dddfbc1dc 100644 --- a/pcbnew/plot_rtn.cpp +++ b/pcbnew/plot_rtn.cpp @@ -97,7 +97,7 @@ void PCB_BASE_FRAME::PlotSilkScreen( PLOTTER* plotter, int aLayerMask, GRTraceMo switch( pad->m_PadShape & 0x7F ) { case PAD_CIRCLE: - plotter->flash_pad_circle( shape_pos, TO_LEGACY_LU( pad->m_Size.x ), FILAIRE ); + plotter->flash_pad_circle( shape_pos, TO_LEGACY_LU( pad->m_Size.x() ), FILAIRE ); break; case PAD_OVAL: @@ -840,8 +840,8 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER* aPlotter, break; } - size.x = TO_LEGACY_LU( pad->m_Size.x ) + ( 2 * margin.x ); - size.y = TO_LEGACY_LU( pad->m_Size.y ) + ( 2 * margin.y ); + size.x = TO_LEGACY_LU( pad->m_Size.x() ) + ( 2 * margin.x ); + size.y = TO_LEGACY_LU( pad->m_Size.y() ) + ( 2 * margin.y ); /* Don't draw a null size item : */ if( size.x <= 0 || size.y <= 0 ) @@ -851,8 +851,8 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER* aPlotter, { case PAD_CIRCLE: if( aSkipNPTH_Pads && - ( pad->m_Size.x == pad->m_Drill.x ) && - ( pad->m_Size.y == pad->m_Drill.y ) && + ( pad->m_Size.x() == pad->m_Drill.x() ) && + ( pad->m_Size.y() == pad->m_Drill.y() ) && (pad->m_Attribut == PAD_HOLE_NOT_PLATED) ) break; @@ -861,8 +861,8 @@ void PCB_BASE_FRAME::Plot_Standard_Layer( PLOTTER* aPlotter, case PAD_OVAL: if( aSkipNPTH_Pads && - (pad->m_Size.x == pad->m_Drill.x ) && - (pad->m_Size.y == pad->m_Drill.y ) && + (pad->m_Size.x() == pad->m_Drill.x() ) && + (pad->m_Size.y() == pad->m_Drill.y() ) && (pad->m_Attribut == PAD_HOLE_NOT_PLATED) ) break; @@ -1018,21 +1018,21 @@ void PCB_BASE_FRAME::PlotDrillMark( PLOTTER* aPlotter, { for( PtPad = Module->m_Pads; PtPad != NULL; PtPad = PtPad->Next() ) { - if( PtPad->m_Drill.x == ZERO_LENGTH ) + if( PtPad->m_Drill.x() == ZERO_LENGTH ) continue; // Output hole shapes: - pos = PtPad->m_Pos; + pos = TO_LEGACY_LU_WXP( PtPad->m_Pos ); if( PtPad->m_DrillShape == PAD_OVAL ) { - diam.x = TO_LEGACY_LU( PtPad->m_Drill.x ); - diam.y = TO_LEGACY_LU( PtPad->m_Drill.y ); + diam.x = TO_LEGACY_LU( PtPad->m_Drill.x() ); + diam.y = TO_LEGACY_LU( PtPad->m_Drill.y() ); aPlotter->flash_pad_oval( pos, diam, PtPad->m_Orient, aTraceMode ); } else { - diam.x = aSmallDrillShape ? SMALL_DRILL : TO_LEGACY_LU( PtPad->m_Drill.x ); + diam.x = aSmallDrillShape ? SMALL_DRILL : TO_LEGACY_LU( PtPad->m_Drill.x() ); aPlotter->flash_pad_circle( pos, diam.x, aTraceMode ); } } diff --git a/pcbnew/print_board_functions.cpp b/pcbnew/print_board_functions.cpp index 47b31915e6..fa1f44a206 100644 --- a/pcbnew/print_board_functions.cpp +++ b/pcbnew/print_board_functions.cpp @@ -352,17 +352,17 @@ static void Print_Module( EDA_DRAW_PANEL* aPanel, wxDC* aDC, MODULE* aModule, // Manage hole according to the print drill option wxSize drill_tmp; - drill_tmp.x = TO_LEGACY_LU( pt_pad->m_Drill.x ); - drill_tmp.y = TO_LEGACY_LU( pt_pad->m_Drill.y ); + drill_tmp.x = TO_LEGACY_LU( pt_pad->m_Drill.x() ); + drill_tmp.y = TO_LEGACY_LU( pt_pad->m_Drill.y() ); switch ( aDrillShapeOpt ) { case PRINT_PARAMETERS::NO_DRILL_SHAPE: - pt_pad->m_Drill = VECTOR_PCB(ZERO_LENGTH, ZERO_LENGTH); //wxSize(0,0); + pt_pad->m_Drill = VECTOR_PCB::fromXY(ZERO_LENGTH, ZERO_LENGTH); //wxSize(0,0); break; case PRINT_PARAMETERS::SMALL_DRILL_SHAPE: - pt_pad->m_Drill.x = MIN(FROM_LEGACY_LU( SMALL_DRILL ),pt_pad->m_Drill.x ); - pt_pad->m_Drill.y = MIN(FROM_LEGACY_LU( SMALL_DRILL ),pt_pad->m_Drill.y ); + pt_pad->m_Drill.x( min( FROM_LEGACY_LU( SMALL_DRILL ),pt_pad->m_Drill.x() ) ); + pt_pad->m_Drill.y( min( FROM_LEGACY_LU( SMALL_DRILL ),pt_pad->m_Drill.y() ) ); break; case PRINT_PARAMETERS::FULL_DRILL_SHAPE: // Do nothing @@ -370,8 +370,8 @@ static void Print_Module( EDA_DRAW_PANEL* aPanel, wxDC* aDC, MODULE* aModule, } pt_pad->Draw( aPanel, aDC, aDraw_mode ); - pt_pad->m_Drill.x = FROM_LEGACY_LU( drill_tmp.x ); - pt_pad->m_Drill.y = FROM_LEGACY_LU( drill_tmp.y ); + pt_pad->m_Drill.x( FROM_LEGACY_LU( drill_tmp.x ) ); + pt_pad->m_Drill.y( FROM_LEGACY_LU( drill_tmp.y ) ); } /* Print footprint graphic shapes */ diff --git a/pcbnew/ratsnest.cpp b/pcbnew/ratsnest.cpp index 39ddd4446b..b9081a426e 100644 --- a/pcbnew/ratsnest.cpp +++ b/pcbnew/ratsnest.cpp @@ -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 ) + - abs( pad2->m_Pos.y - pad1->m_Pos.y ); + int weight = TO_LEGACY_LU( abs( pad2->m_Pos.x() - pad1->m_Pos.x() ) + + abs( pad2->m_Pos.y() - pad1->m_Pos.y() ) ); return weight + 1; } @@ -667,7 +667,7 @@ 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 = TO_LEGACY_LU_WXP( pad_ref->m_Pos ) - g_Offset_Module; // Search the nearest external pad of this current pad for( unsigned jj = pads_module_count; jj < localPadList.size(); jj++ ) @@ -681,8 +681,8 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule ) if( pad_externe->GetNet() > pad_ref->GetNet() ) // pads are sorted by net code break; - distance = abs( pad_externe->m_Pos.x - pad_pos.x ) + - abs( pad_externe->m_Pos.y - pad_pos.y ); + distance = abs( TO_LEGACY_LU( pad_externe->m_Pos.x() ) - pad_pos.x ) + + abs( TO_LEGACY_LU( pad_externe->m_Pos.y() ) - pad_pos.y ); if( distance < local_rats.m_Lenght ) { @@ -724,8 +724,8 @@ 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; + VECTOR_PCB tmp = rats->m_PadStart->m_Pos; + rats->m_PadStart->m_Pos -= FROM_LEGACY_LU_VEC( g_Offset_Module ); rats->Draw( DrawPanel, DC, GR_XOR, wxPoint( 0, 0 ) ); rats->m_PadStart->m_Pos = tmp; } @@ -827,7 +827,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( TO_LEGACY_LU_WXP( pad->m_Pos ) ); } // Create a list of tracks ends candidates, not already connected to the diff --git a/pcbnew/solve.cpp b/pcbnew/solve.cpp index 7c96855321..a44aa3529d 100644 --- a/pcbnew/solve.cpp +++ b/pcbnew/solve.cpp @@ -464,8 +464,8 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe, + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x; int cY = ( Board.m_GridRouting * row_source ) + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y; - int dx = TO_LEGACY_LU( pt_cur_ch->m_PadStart->m_Size.x / 2 ); - int dy = TO_LEGACY_LU( pt_cur_ch->m_PadStart->m_Size.y / 2 ); + int dx = TO_LEGACY_LU( pt_cur_ch->m_PadStart->m_Size.x() / 2 ); + int dy = TO_LEGACY_LU( pt_cur_ch->m_PadStart->m_Size.y() / 2 ); int px = pt_cur_ch->m_PadStart->GetPosition().x; int py = pt_cur_ch->m_PadStart->GetPosition().y; @@ -479,8 +479,8 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe, + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x; cY = ( Board.m_GridRouting * row_target ) + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y; - dx = TO_LEGACY_LU( pt_cur_ch->m_PadEnd->m_Size.x / 2 ); - dy = TO_LEGACY_LU( pt_cur_ch->m_PadEnd->m_Size.y / 2 ); + dx = TO_LEGACY_LU( pt_cur_ch->m_PadEnd->m_Size.x() / 2 ); + dy = TO_LEGACY_LU( pt_cur_ch->m_PadEnd->m_Size.y() / 2 ); px = pt_cur_ch->m_PadEnd->GetPosition().x; py = pt_cur_ch->m_PadEnd->GetPosition().y; diff --git a/pcbnew/specctra_export.cpp b/pcbnew/specctra_export.cpp index a45e73bb74..5afb05e4e6 100644 --- a/pcbnew/specctra_export.cpp +++ b/pcbnew/specctra_export.cpp @@ -250,7 +250,7 @@ static bool isRoundKeepout( D_PAD* aPad ) { if( aPad->m_PadShape==PAD_CIRCLE ) { - if( aPad->m_Drill.x >= aPad->m_Size.x ) + if( aPad->m_Drill.x() >= aPad->m_Size.x() ) return true; if( (aPad->m_layerMask & ALL_CU_LAYERS) == 0 ) @@ -321,11 +321,11 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) POINT dsnOffset; - if( aPad->m_Offset.x != ZERO_LENGTH || aPad->m_Offset.y != ZERO_LENGTH ) + if( aPad->m_Offset.x() != ZERO_LENGTH || aPad->m_Offset.y() != ZERO_LENGTH ) { char offsetTxt[64]; /// @BUG !!!Unsafe - wxPoint offset( TO_LEGACY_LU( aPad->m_Offset.x ), TO_LEGACY_LU( aPad->m_Offset.y ) ); + wxPoint offset( TO_LEGACY_LU( aPad->m_Offset.x() ), TO_LEGACY_LU( aPad->m_Offset.y() ) ); dsnOffset = mapPt( offset ); @@ -341,7 +341,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) default: case PAD_CIRCLE: { - double diameter = scale( TO_LEGACY_LU( aPad->m_Size.x ) ); + double diameter = scale( TO_LEGACY_LU( aPad->m_Size.x() ) ); for( int ndx=0; ndxm_Size.x ) ) ); + uniqifier.c_str(), scale(TO_LEGACY_LU( aPad->m_Size.x() ) ) ); name[ sizeof(name)-1 ] = 0; padstack->SetPadstackId( name ); @@ -366,8 +366,8 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) case PAD_RECT: { - double dx = scale( TO_LEGACY_LU( aPad->m_Size.x ) ) / 2.0; - double dy = scale( TO_LEGACY_LU( aPad->m_Size.y ) ) / 2.0; + double dx = scale( TO_LEGACY_LU( aPad->m_Size.x() ) ) / 2.0; + double dy = scale( TO_LEGACY_LU( aPad->m_Size.y() ) ) / 2.0; POINT lowerLeft( -dx, -dy ); POINT upperRight( dx, dy ); @@ -388,7 +388,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) } snprintf( name, sizeof(name), "Rect%sPad_%.6gx%.6g_mil", - uniqifier.c_str(), scale( TO_LEGACY_LU( aPad->m_Size.x ) ), scale( TO_LEGACY_LU( aPad->m_Size.y ) ) ); + uniqifier.c_str(), scale( TO_LEGACY_LU( aPad->m_Size.x() ) ), scale( TO_LEGACY_LU( aPad->m_Size.y() ) ) ); name[ sizeof(name)-1 ] = 0; padstack->SetPadstackId( name ); @@ -397,8 +397,8 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) case PAD_OVAL: { - double dx = scale( TO_LEGACY_LU( aPad->m_Size.x ) ) / 2.0; - double dy = scale( TO_LEGACY_LU( aPad->m_Size.y ) ) / 2.0; + double dx = scale( TO_LEGACY_LU( aPad->m_Size.x() ) ) / 2.0; + double dy = scale( TO_LEGACY_LU( aPad->m_Size.y() ) ) / 2.0; double dr = dx - dy; double radius; POINT start; @@ -436,7 +436,7 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) } snprintf( name, sizeof(name), "Oval%sPad_%.6gx%.6g_mil", - uniqifier.c_str(), scale( TO_LEGACY_LU( aPad->m_Size.x ) ), scale( TO_LEGACY_LU( aPad->m_Size.y ) ) ); + uniqifier.c_str(), scale( TO_LEGACY_LU( aPad->m_Size.x() ) ), scale( TO_LEGACY_LU( aPad->m_Size.y() ) ) ); name[ sizeof(name)-1 ] = 0; padstack->SetPadstackId( name ); @@ -445,11 +445,11 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) case PAD_TRAPEZOID: { - double dx = scale( TO_LEGACY_LU( aPad->m_Size.x ) ) / 2.0; - double dy = scale( TO_LEGACY_LU( aPad->m_Size.y ) ) / 2.0; + double dx = scale( TO_LEGACY_LU( aPad->m_Size.x() ) ) / 2.0; + double dy = scale( TO_LEGACY_LU( aPad->m_Size.y() ) ) / 2.0; - double ddx = scale( TO_LEGACY_LU( aPad->m_DeltaSize.x ) ) / 2.0; - double ddy = scale( TO_LEGACY_LU( aPad->m_DeltaSize.y ) ) / 2.0; + double ddx = scale( TO_LEGACY_LU( aPad->m_DeltaSize.x() ) ) / 2.0; + double ddy = scale( TO_LEGACY_LU( aPad->m_DeltaSize.y() ) ) / 2.0; // see class_pad_draw_functions.cpp which draws the trapezoid pad POINT lowerLeft( -dx - ddy, -dy - ddx ); @@ -483,11 +483,11 @@ PADSTACK* SPECCTRA_DB::makePADSTACK( BOARD* aBoard, D_PAD* aPad ) // 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( TO_LEGACY_LU( aPad->m_Size.x ) ), scale( TO_LEGACY_LU( aPad->m_Size.y ) ), - aPad->m_DeltaSize.x < ZERO_LENGTH ? 'n' : 'p', - abs( scale( TO_LEGACY_LU( aPad->m_DeltaSize.x ) )), - aPad->m_DeltaSize.y < ZERO_LENGTH ? 'n' : 'p', - abs( scale( TO_LEGACY_LU( aPad->m_DeltaSize.y ) )) + uniqifier.c_str(), scale( TO_LEGACY_LU( aPad->m_Size.x() ) ), scale( TO_LEGACY_LU( aPad->m_Size.y() ) ), + aPad->m_DeltaSize.x() < ZERO_LENGTH ? 'n' : 'p', + fabs( scale( TO_LEGACY_LU( aPad->m_DeltaSize.x() ) )), + aPad->m_DeltaSize.y() < ZERO_LENGTH ? 'n' : 'p', + fabs( scale( TO_LEGACY_LU( aPad->m_DeltaSize.y() ) )) ); name[ sizeof(name)-1 ] = 0; @@ -527,7 +527,7 @@ 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( TO_LEGACY_LU( pad->m_Drill.x ) ); + double diameter = scale( TO_LEGACY_LU( pad->m_Drill.x() ) ); POINT vertex = mapPt( TO_LEGACY_LU_WXP( pad->m_Pos0 ) ); int layerCount = aBoard->GetCopperLayerCount(); diff --git a/pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp b/pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp index e05d95a8e2..60ff998379 100644 --- a/pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp +++ b/pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp @@ -201,7 +201,7 @@ 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 == ZERO_LENGTH) && (pad->m_Drill.y == ZERO_LENGTH) ) + if( (pad->m_Drill.x() == ZERO_LENGTH) && (pad->m_Drill.y() == ZERO_LENGTH) ) continue; // Use a dummy pad to calculate a hole shape that have the same dimension as diff --git a/pcbnew/zones_convert_to_polygons_aux_functions.cpp b/pcbnew/zones_convert_to_polygons_aux_functions.cpp index a63945c26d..cd357c5541 100644 --- a/pcbnew/zones_convert_to_polygons_aux_functions.cpp +++ b/pcbnew/zones_convert_to_polygons_aux_functions.cpp @@ -68,15 +68,15 @@ void BuildUnconnectedThermalStubsPolygonList( std::vector& 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 = ( TO_LEGACY_LU( pad->m_Size.x / 2 ) ) + aZone->m_ThermalReliefGapValue; - endpoint.y = ( TO_LEGACY_LU( pad->m_Size.y / 2 ) ) + aZone->m_ThermalReliefGapValue; + endpoint.x = ( TO_LEGACY_LU( pad->m_Size.x() / 2 ) ) + aZone->m_ThermalReliefGapValue; + endpoint.y = ( TO_LEGACY_LU( pad->m_Size.y() / 2 ) ) + aZone->m_ThermalReliefGapValue; int copperThickness = aZone->m_ThermalReliefCopperBridgeValue - aZone->m_ZoneMinThickness; if( copperThickness < 0 ) copperThickness = 0; - startpoint.x = min( TO_LEGACY_LU( pad->m_Size.x ), copperThickness ); - startpoint.y = min( TO_LEGACY_LU( pad->m_Size.y ), copperThickness ); + startpoint.x = min( TO_LEGACY_LU( pad->m_Size.x() ), copperThickness ); + startpoint.y = min( TO_LEGACY_LU( pad->m_Size.y() ), copperThickness ); startpoint.x /= 2; startpoint.y /= 2; diff --git a/pcbnew/zones_polygons_insulated_copper_islands.cpp b/pcbnew/zones_polygons_insulated_copper_islands.cpp index 587d19a1a8..be7d1439eb 100644 --- a/pcbnew/zones_polygons_insulated_copper_islands.cpp +++ b/pcbnew/zones_polygons_insulated_copper_islands.cpp @@ -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( TO_LEGACY_LU_WXP( pad->m_Pos ) ); } } diff --git a/pcbnew/zones_polygons_test_connections.cpp b/pcbnew/zones_polygons_test_connections.cpp index 145e57b2e3..65bebde7e7 100644 --- a/pcbnew/zones_polygons_test_connections.cpp +++ b/pcbnew/zones_polygons_test_connections.cpp @@ -111,7 +111,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 = TO_LEGACY_LU_WXP( ( (D_PAD*) item )->m_Pos ); /// @BUG Unsafe type conversion } else if( item->Type() == PCB_VIA_T ) { diff --git a/polygon/math_for_graphics.h b/polygon/math_for_graphics.h index 99271bbe6d..e791f28a01 100644 --- a/polygon/math_for_graphics.h +++ b/polygon/math_for_graphics.h @@ -1,8 +1,8 @@ // math stuff for graphics, from FreePCB -#ifndef abs +/*#ifndef abs #define abs(x) (((x) >=0) ? (x) : (-(x))) -#endif +#endif*/ typedef struct PointTag diff --git a/potrace/auxiliary.h b/potrace/auxiliary.h index 041e2a30b7..e883eb02d2 100644 --- a/potrace/auxiliary.h +++ b/potrace/auxiliary.h @@ -73,6 +73,8 @@ static inline int floordiv( int a, int n ) /* Note: the following work for integers and other numeric types. */ +/* those are bad programming practice because of several issues with +overloading and integer limits #undef sign #undef abs #undef min @@ -84,6 +86,79 @@ static inline int floordiv( int a, int n ) #define min( a, b ) ( (a)<(b) ? (a) : (b) ) #define max( a, b ) ( (a)>(b) ? (a) : (b) ) #define sq( a ) ( (a) * (a) ) -#define cu( a ) ( (a) * (a) * (a) ) +#define cu( a ) ( (a) * (a) * (a) )*/ + +// these functions better than macros because they do not cause double evaluation. +static inline int sign( int x ) +{ + return (0 < x) - (x < 0); +} + +static inline int sign( long x ) +{ + return (0 < x) - (x < 0); +} + +static inline int sign( double x ) +{ + return (0.0 < x) - (x < 0.0); +} + +/*static inline int abs( int x ) is not required because exist in stdlib.h */ + +static inline long abs( long x ) +{ + return x < 0? -x : x; +} + +static inline int max( int x, int y ) +{ + return x < y? y : x; +} + +static inline long max( long x, long y ) +{ + return x < y? y : x; +} + +static inline int min( int x, int y ) +{ + return x < y? x : y; +} + +static inline long min( long x, long y ) +{ + return x < y? x : y; +} + +static inline int sq( int x ) +{ + return x * x; +} + +static inline long sq( long x ) +{ + return x * x; +} + +static inline double sq( double x ) +{ + return x * x; +} + +static inline int cu( int x ) +{ + return x * x * x; +} + +static inline long cu( long x ) +{ + return x * x * x; +} + +static inline double cu( double x ) +{ + return x * x * x; +} #endif /* AUXILIARY_H */ diff --git a/potrace/render.cpp b/potrace/render.cpp index 9f310c399d..01461d1a54 100644 --- a/potrace/render.cpp +++ b/potrace/render.cpp @@ -278,7 +278,7 @@ void render_curveto( render_t* rm, * occur at an endpoint. */ dd0 = sq( x1 - 2 * x2 + x3 ) + sq( y1 - 2 * y2 + y3 ); dd1 = sq( x2 - 2 * x3 + x4 ) + sq( y2 - 2 * y3 + y4 ); - dd = 6 * sqrt( max( dd0, dd1 ) ); + dd = 6 * sqrt( fmax( dd0, dd1 ) ); e2 = 8 * delta <= dd ? 8 * delta / dd : 1; epsilon = sqrt( e2 ); /* necessary interval size */