haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

protect data in class_track.h, switch to using member accessors

This commit is contained in:
Heikki Pulkkinen 2013-01-12 18:04:00 -06:00 committed by Dick Hollenbeck
parent f8a56d446f
commit 3e18fa422c
33 changed files with 398 additions and 401 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
3d-viewer/3d_draw.cpp
View File

@ -464,8 +464,8 @@ void EDA_3D_CANVAS::Draw3D_Track( TRACK* aTrack )
SetGLColor( color );
glNormal3f( 0.0, 0.0, Get3DLayer_Z_Orientation( layer ) );
Draw3D_SolidSegment( aTrack->m_Start, aTrack->m_End,
aTrack->m_Width, thickness, zpos,
Draw3D_SolidSegment( aTrack->GetStart(), aTrack->GetEnd(),
aTrack->GetWidth(), thickness, zpos,
g_Parm_3D_Visu.m_BiuTo3Dunits );
}
@ -475,7 +475,7 @@ void EDA_3D_CANVAS::Draw3D_Via( SEGVIA* via )
int color;
double biu_to_3Dunits = g_Parm_3D_Visu.m_BiuTo3Dunits ;
int outer_radius = via->m_Width / 2;
int outer_radius = via->GetWidth() / 2;
int inner_radius = via->GetDrillValue() / 2;
int thickness = g_Parm_3D_Visu.GetCopperThicknessBIU();
@ -504,7 +504,7 @@ void EDA_3D_CANVAS::Draw3D_Via( SEGVIA* via )
SetGLColor( color );
glNormal3f( 0.0, 0.0, Get3DLayer_Z_Orientation( layer ) );
Draw3D_ZaxisCylinder( via->m_Start, (outer_radius + inner_radius)/2,
Draw3D_ZaxisCylinder( via->GetStart(), (outer_radius + inner_radius)/2,
thickness, outer_radius - inner_radius,
zpos, biu_to_3Dunits );
if( layer >= top_layer )
@ -512,13 +512,13 @@ void EDA_3D_CANVAS::Draw3D_Via( SEGVIA* via )
}
// Drawing via hole:
color = g_ColorsSettings.GetItemColor( VIAS_VISIBLE + via->m_Shape );
color = g_ColorsSettings.GetItemColor( VIAS_VISIBLE + via->GetShape() );
SetGLColor( color );
int height = g_Parm_3D_Visu.GetLayerZcoordBIU(top_layer) -
g_Parm_3D_Visu.GetLayerZcoordBIU( bottom_layer );
int zpos = g_Parm_3D_Visu.GetLayerZcoordBIU(bottom_layer) + thickness/2;
Draw3D_ZaxisCylinder( via->m_Start, inner_radius + thickness/2, height,
Draw3D_ZaxisCylinder( via->GetStart(), inner_radius + thickness/2, height,
thickness, zpos, biu_to_3Dunits );
}

2
pcbnew/autorouter/autoplac.cpp
View File

@ -462,7 +462,7 @@ int PCB_EDIT_FRAME::GenPlaceBoard()
TmpSegm.SetLayer( -1 );
TmpSegm.SetNet( -1 );
TmpSegm.m_Width = RoutingMatrix.m_GridRouting / 2;
TmpSegm.SetWidth( RoutingMatrix.m_GridRouting / 2 );
EDA_ITEM* PtStruct = GetBoard()->m_Drawings;

16
pcbnew/autorouter/graphpcb.cpp
View File

@ -262,13 +262,13 @@ void TraceSegmentPcb( TRACK* pt_segm, int color, int marge, int op_logic )
int half_width;
int ux0, uy0, ux1, uy1;
half_width = ( pt_segm->m_Width / 2 ) + marge;
half_width = ( pt_segm->GetWidth() / 2 ) + marge;
// Calculate the bounding rectangle of the segment (if H, V or Via)
ux0 = pt_segm->m_Start.x - RoutingMatrix.GetBrdCoordOrigin().x;
uy0 = pt_segm->m_Start.y - RoutingMatrix.GetBrdCoordOrigin().y;
ux1 = pt_segm->m_End.x - RoutingMatrix.GetBrdCoordOrigin().x;
uy1 = pt_segm->m_End.y - RoutingMatrix.GetBrdCoordOrigin().y;
ux0 = pt_segm->GetStart().x - RoutingMatrix.GetBrdCoordOrigin().x;
uy0 = pt_segm->GetStart().y - RoutingMatrix.GetBrdCoordOrigin().y;
ux1 = pt_segm->GetEnd().x - RoutingMatrix.GetBrdCoordOrigin().x;
uy1 = pt_segm->GetEnd().y - RoutingMatrix.GetBrdCoordOrigin().y;
// Test if VIA (filled circle was drawn)
if( pt_segm->Type() == PCB_VIA_T )
@ -290,7 +290,7 @@ void TraceSegmentPcb( TRACK* pt_segm, int color, int marge, int op_logic )
mask_layer = -1;
if( mask_layer )
TraceFilledCircle( pt_segm->m_Start.x, pt_segm->m_Start.y,
TraceFilledCircle( pt_segm->GetStart().x, pt_segm->GetStart().y,
half_width, mask_layer, color, op_logic );
return;
}
@ -301,13 +301,13 @@ void TraceSegmentPcb( TRACK* pt_segm, int color, int marge, int op_logic )
layer = -1;
// The segment is here a straight line or a circle or an arc.:
if( pt_segm->m_Shape == S_CIRCLE )
if( pt_segm->GetShape() == S_CIRCLE )
{
TraceCircle( ux0, uy0, ux1, uy1, half_width, layer, color, op_logic );
return;
}
if( pt_segm->m_Shape == S_ARC )
if( pt_segm->GetShape() == S_ARC )
{
TraceArc( ux0, uy0, ux1, uy1, pt_segm->m_Param, half_width, layer, color, op_logic );
return;

73
pcbnew/autorouter/solve.cpp
View File

@ -1169,16 +1169,14 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
g_CurrentTrackSegment->SetState( TRACK_AR, ON );
g_CurrentTrackSegment->SetLayer( 0x0F );
g_CurrentTrackSegment->m_Start.x =
g_CurrentTrackSegment->m_End.x = pcb->GetBoundingBox().GetX() +
( RoutingMatrix.m_GridRouting * row );
g_CurrentTrackSegment->m_Start.y =
g_CurrentTrackSegment->m_End.y = pcb->GetBoundingBox().GetY() +
( RoutingMatrix.m_GridRouting * col );
g_CurrentTrackSegment->m_Width = pcb->GetCurrentViaSize();
g_CurrentTrackSegment->m_Shape = pcb->GetDesignSettings().m_CurrentViaType;
g_CurrentTrackSegment->SetStart(wxPoint( pcb->GetBoundingBox().GetX() +
( RoutingMatrix.m_GridRouting * row ),
pcb->GetBoundingBox().GetY() +
( RoutingMatrix.m_GridRouting * col )));
g_CurrentTrackSegment->SetEnd( g_CurrentTrackSegment->GetStart() );
g_CurrentTrackSegment->SetWidth( pcb->GetCurrentViaSize() );
g_CurrentTrackSegment->SetShape( pcb->GetDesignSettings().m_CurrentViaType );
g_CurrentTrackSegment->SetNet( current_net_code );
}
@ -1194,35 +1192,34 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
g_CurrentTrackSegment->SetLayer( Route_Layer_TOP );
g_CurrentTrackSegment->SetState( TRACK_AR, ON );
g_CurrentTrackSegment->m_End.x = pcb->GetBoundingBox().GetX() +
( RoutingMatrix.m_GridRouting * row );
g_CurrentTrackSegment->m_End.y = pcb->GetBoundingBox().GetY() +
( RoutingMatrix.m_GridRouting * col );
g_CurrentTrackSegment->SetEnd( wxPoint( pcb->GetBoundingBox().GetX() +
( RoutingMatrix.m_GridRouting * row ),
pcb->GetBoundingBox().GetY() +
( RoutingMatrix.m_GridRouting * col )));
g_CurrentTrackSegment->SetNet( current_net_code );
if( g_CurrentTrackSegment->Back() == NULL ) /* Start trace. */
{
g_CurrentTrackSegment->m_Start.x = segm_fX;
g_CurrentTrackSegment->m_Start.y = segm_fY;
g_CurrentTrackSegment->SetStart( wxPoint( segm_fX, segm_fY ) );
/* Placement on the center of the pad if outside grid. */
dx1 = g_CurrentTrackSegment->m_End.x - g_CurrentTrackSegment->m_Start.x;
dy1 = g_CurrentTrackSegment->m_End.y - g_CurrentTrackSegment->m_Start.y;
dx1 = g_CurrentTrackSegment->GetEnd().x - g_CurrentTrackSegment->GetStart().x;
dy1 = g_CurrentTrackSegment->GetEnd().y - g_CurrentTrackSegment->GetStart().y;
dx0 = pt_cur_ch->m_PadEnd->GetPosition().x - g_CurrentTrackSegment->m_Start.x;
dy0 = pt_cur_ch->m_PadEnd->GetPosition().y - g_CurrentTrackSegment->m_Start.y;
dx0 = pt_cur_ch->m_PadEnd->GetPosition().x - g_CurrentTrackSegment->GetStart().x;
dy0 = pt_cur_ch->m_PadEnd->GetPosition().y - g_CurrentTrackSegment->GetStart().y;
/* If aligned, change the origin point. */
if( abs( dx0 * dy1 ) == abs( dx1 * dy0 ) )
{
g_CurrentTrackSegment->m_Start = pt_cur_ch->m_PadEnd->GetPosition();
g_CurrentTrackSegment->SetStart( pt_cur_ch->m_PadEnd->GetPosition() );
}
else // Creation of a supplemental segment
{
g_CurrentTrackSegment->m_Start = pt_cur_ch->m_PadEnd->GetPosition();
g_CurrentTrackSegment->SetStart( pt_cur_ch->m_PadEnd->GetPosition() );
newTrack = (TRACK*)g_CurrentTrackSegment->Clone();
newTrack->m_Start = g_CurrentTrackSegment->m_End;
newTrack->SetStart( g_CurrentTrackSegment->GetEnd());
g_CurrentTrackList.PushBack( newTrack );
}
@ -1231,28 +1228,28 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
{
if( g_CurrentTrackSegment->Back() )
{
g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->Back()->m_End;
g_CurrentTrackSegment->SetStart( g_CurrentTrackSegment->Back()->GetEnd() );
}
}
g_CurrentTrackSegment->m_Width = pcb->GetCurrentTrackWidth();
g_CurrentTrackSegment->SetWidth( pcb->GetCurrentTrackWidth() );
if( g_CurrentTrackSegment->m_Start != g_CurrentTrackSegment->m_End )
if( g_CurrentTrackSegment->GetStart() != g_CurrentTrackSegment->GetEnd() )
{
/* Reduce aligned segments by one. */
TRACK* oldTrack = g_CurrentTrackSegment->Back();
if( oldTrack && oldTrack->Type() != PCB_VIA_T )
{
dx1 = g_CurrentTrackSegment->m_End.x - g_CurrentTrackSegment->m_Start.x;
dy1 = g_CurrentTrackSegment->m_End.y - g_CurrentTrackSegment->m_Start.y;
dx1 = g_CurrentTrackSegment->GetEnd().x - g_CurrentTrackSegment->GetStart().x;
dy1 = g_CurrentTrackSegment->GetEnd().y - g_CurrentTrackSegment->GetStart().y;
dx0 = oldTrack->m_End.x - oldTrack->m_Start.x;
dy0 = oldTrack->m_End.y - oldTrack->m_Start.y;
dx0 = oldTrack->GetEnd().x - oldTrack->GetStart().x;
dy0 = oldTrack->GetEnd().y - oldTrack->GetStart().y;
if( abs( dx0 * dy1 ) == abs( dx1 * dy0 ) )
{
oldTrack->m_End = g_CurrentTrackSegment->m_End;
oldTrack->SetEnd( g_CurrentTrackSegment->GetEnd() );
delete g_CurrentTrackList.PopBack();
}
@ -1280,24 +1277,24 @@ static void AddNewTrace( PCB_EDIT_FRAME* pcbframe, wxDC* DC )
marge = s_Clearance + ( pcbframe->GetBoard()->GetCurrentTrackWidth() / 2 );
via_marge = s_Clearance + ( pcbframe->GetBoard()->GetCurrentViaSize() / 2 );
dx1 = g_CurrentTrackSegment->m_End.x - g_CurrentTrackSegment->m_Start.x;
dy1 = g_CurrentTrackSegment->m_End.y - g_CurrentTrackSegment->m_Start.y;
dx1 = g_CurrentTrackSegment->GetEnd().x - g_CurrentTrackSegment->GetStart().x;
dy1 = g_CurrentTrackSegment->GetEnd().y - g_CurrentTrackSegment->GetStart().y;
/* Place on center of pad if off grid. */
dx0 = pt_cur_ch->m_PadStart->GetPosition().x - g_CurrentTrackSegment->m_Start.x;
dy0 = pt_cur_ch->m_PadStart->GetPosition().y - g_CurrentTrackSegment->m_Start.y;
dx0 = pt_cur_ch->m_PadStart->GetPosition().x - g_CurrentTrackSegment->GetStart().x;
dy0 = pt_cur_ch->m_PadStart->GetPosition().y - g_CurrentTrackSegment->GetStart().y;
/* If aligned, change the origin point. */
if( abs( dx0 * dy1 ) == abs( dx1 * dy0 ) )
{
g_CurrentTrackSegment->m_End = pt_cur_ch->m_PadStart->GetPosition();
g_CurrentTrackSegment->SetEnd( pt_cur_ch->m_PadStart->GetPosition() );
}
else
{
TRACK* newTrack = (TRACK*)g_CurrentTrackSegment->Clone();
newTrack->m_End = pt_cur_ch->m_PadStart->GetPosition();
newTrack->m_Start = g_CurrentTrackSegment->m_End;
newTrack->SetEnd( pt_cur_ch->m_PadStart->GetPosition() );
newTrack->SetStart( g_CurrentTrackSegment->GetEnd() );
g_CurrentTrackList.PushBack( newTrack );
}

13
pcbnew/board_undo_redo.cpp
View File

@ -245,11 +245,14 @@ void SwapData( BOARD_ITEM* aItem, BOARD_ITEM* aImage )
{
TRACK* track = (TRACK*) aItem;
TRACK* image = (TRACK*) aImage;
EXCHG( track->m_Start, image->m_Start );
EXCHG( track->m_End, image->m_End );
EXCHG( track->m_Width, image->m_Width );
EXCHG( track->m_Shape, image->m_Shape );
int atmp = track->GetDrillValue();
// swap start, end, width and shape for track and image.
wxPoint exchp = track->GetStart(); track->SetStart( image->GetStart() ); image->SetStart( exchp );
exchp = track->GetEnd(); track->SetEnd( image->GetEnd() ); image->SetEnd( exchp );
int atmp = track->GetWidth(); track->SetWidth( image->GetWidth() ); image->SetWidth( atmp );
atmp = track->GetShape(); track->SetShape( image->GetShape() ); image->SetShape( atmp );
atmp = track->GetDrillValue();
if( track->IsDrillDefault() )
atmp = -1;

46
pcbnew/class_board.cpp
View File

@ -214,13 +214,13 @@ void BOARD::chainMarkedSegments( wxPoint aPosition, int aLayerMask, TRACK_PTRS*
*/
aLayerMask = candidate->ReturnMaskLayer();
if( aPosition == candidate->m_Start )
if( aPosition == candidate->GetStart() )
{
aPosition = candidate->m_End;
aPosition = candidate->GetEnd();
}
else
{
aPosition = candidate->m_Start;
aPosition = candidate->GetStart();
}
segment = m_Track; /* restart list of tracks to analyze */
@ -1586,7 +1586,7 @@ TRACK* BOARD::GetViaByPosition( const wxPoint& aPosition, int aLayerMask )
if( track->Type() != PCB_VIA_T )
continue;
if( track->m_Start != aPosition )
if( track->GetStart() != aPosition )
continue;
if( track->GetState( BUSY | IS_DELETED ) )
@ -1628,11 +1628,11 @@ D_PAD* BOARD::GetPad( TRACK* aTrace, int aEndPoint )
if( aEndPoint == FLG_START )
{
aPosition = aTrace->m_Start;
aPosition = aTrace->GetStart();
}
else
{
aPosition = aTrace->m_End;
aPosition = aTrace->GetEnd();
}
for( MODULE* module = m_Modules; module; module = module->Next() )
@ -1852,16 +1852,16 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace, int* aCount,
if( aTrace->Type() == PCB_VIA_T )
{
TRACK* Segm1, * Segm2 = NULL, * Segm3 = NULL;
Segm1 = ::GetTrace( m_Track, NULL, aTrace->m_Start, layerMask );
Segm1 = ::GetTrace( m_Track, NULL, aTrace->GetStart(), layerMask );
if( Segm1 )
{
Segm2 = ::GetTrace( Segm1->Next(), NULL, aTrace->m_Start, layerMask );
Segm2 = ::GetTrace( Segm1->Next(), NULL, aTrace->GetStart(), layerMask );
}
if( Segm2 )
{
Segm3 = ::GetTrace( Segm2->Next(), NULL, aTrace->m_Start, layerMask );
Segm3 = ::GetTrace( Segm2->Next(), NULL, aTrace->GetStart(), layerMask );
}
if( Segm3 ) // More than 2 segments are connected to this via. the track" is only this via
@ -1875,19 +1875,19 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace, int* aCount,
if( Segm1 ) // search for others segments connected to the initial segment start point
{
layerMask = Segm1->ReturnMaskLayer();
chainMarkedSegments( aTrace->m_Start, layerMask, &trackList );
chainMarkedSegments( aTrace->GetStart(), layerMask, &trackList );
}
if( Segm2 ) // search for others segments connected to the initial segment end point
{
layerMask = Segm2->ReturnMaskLayer();
chainMarkedSegments( aTrace->m_Start, layerMask, &trackList );
chainMarkedSegments( aTrace->GetStart(), layerMask, &trackList );
}
}
else // mark the chain using both ends of the initial segment
{
chainMarkedSegments( aTrace->m_Start, layerMask, &trackList );
chainMarkedSegments( aTrace->m_End, layerMask, &trackList );
chainMarkedSegments( aTrace->GetStart(), layerMask, &trackList );
chainMarkedSegments( aTrace->GetEnd(), layerMask, &trackList );
}
// Now examine selected vias and flag them if they are on the track
@ -1909,7 +1909,7 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace, int* aCount,
layerMask = via->ReturnMaskLayer();
TRACK* track = ::GetTrace( m_Track, NULL, via->m_Start, layerMask );
TRACK* track = ::GetTrace( m_Track, NULL, via->GetStart(), layerMask );
// GetTrace does not consider tracks flagged BUSY.
// So if no connected track found, this via is on the current track
@ -1931,7 +1931,7 @@ TRACK* BOARD::MarkTrace( TRACK* aTrace, int* aCount,
*/
int layer = track->GetLayer();
while( ( track = ::GetTrace( track->Next(), NULL, via->m_Start, layerMask ) ) != NULL )
while( ( track = ::GetTrace( track->Next(), NULL, via->GetStart(), layerMask ) ) != NULL )
{
if( layer != track->GetLayer() )
{
@ -2159,21 +2159,21 @@ TRACK* BOARD::CreateLockPoint( wxPoint& aPosition, TRACK* aSegment, PICKED_ITEMS
* The new segment starts from aPosition and ends at the end point of
* aSegment. The original segment now ends at aPosition.
*/
if( aSegment->m_Start == aPosition || aSegment->m_End == aPosition )
if( aSegment->GetStart() == aPosition || aSegment->GetEnd() == aPosition )
return NULL;
/* A via is a good lock point */
if( aSegment->Type() == PCB_VIA_T )
{
aPosition = aSegment->m_Start;
aPosition = aSegment->GetStart();
return aSegment;
}
// Calculation coordinate of intermediate point relative to the start point of aSegment
wxPoint delta = aSegment->m_End - aSegment->m_Start;
wxPoint delta = aSegment->GetEnd() - aSegment->GetStart();
// calculate coordinates of aPosition relative to aSegment->m_Start
wxPoint lockPoint = aPosition - aSegment->m_Start;
// calculate coordinates of aPosition relative to aSegment->GetStart()
wxPoint lockPoint = aPosition - aSegment->GetStart();
// lockPoint must be on aSegment:
// Ensure lockPoint.y/lockPoint.y = delta.y/delta.x
@ -2185,11 +2185,11 @@ TRACK* BOARD::CreateLockPoint( wxPoint& aPosition, TRACK* aSegment, PICKED_ITEMS
/* Create the intermediate point (that is to say creation of a new
* segment, beginning at the intermediate point.
*/
lockPoint += aSegment->m_Start;
lockPoint += aSegment->GetStart();
TRACK* newTrack = (TRACK*)aSegment->Clone();
// The new segment begins at the new point,
newTrack->m_Start = lockPoint;
newTrack->SetStart(lockPoint);
newTrack->start = aSegment;
newTrack->SetState( BEGIN_ONPAD, OFF );
@ -2211,7 +2211,7 @@ TRACK* BOARD::CreateLockPoint( wxPoint& aPosition, TRACK* aSegment, PICKED_ITEMS
}
// Old track segment now ends at new point.
aSegment->m_End = lockPoint;
aSegment->SetEnd(lockPoint);
aSegment->end = newTrack;
aSegment->SetState( END_ONPAD, OFF );

4
pcbnew/class_track.cpp
View File

@ -98,13 +98,13 @@ TRACK* GetTrace( TRACK* aStartTrace, TRACK* aEndTrace, const wxPoint& aPosition,
{
if( PtSegm->GetState( IS_DELETED | BUSY ) == 0 )
{
if( aPosition == PtSegm->m_Start )
if( aPosition == PtSegm->GetStart() )
{
if( aLayerMask & PtSegm->ReturnMaskLayer() )
return PtSegm;
}
if( aPosition == PtSegm->m_End )
if( aPosition == PtSegm->GetEnd() )
{
if( aLayerMask & PtSegm->ReturnMaskLayer() )
return PtSegm;

12
pcbnew/class_track.h
View File

@ -79,14 +79,12 @@ private:
void SetNext( EDA_ITEM* aNext ) { Pnext = aNext; }
void SetBack( EDA_ITEM* aBack ) { Pback = aBack; }
public:
protected:
int m_Width; // Thickness of track, or via diameter
wxPoint m_Start; // Line start point
wxPoint m_End; // Line end point
int m_Shape; // vias: shape and type, Track = shape..
protected:
int m_Drill; // for vias: via drill (- 1 for default value)
public:
@ -95,7 +93,6 @@ public:
double m_Param; // Auxiliary variable ( used in some computations )
public:
TRACK( BOARD_ITEM* aParent, KICAD_T idtype = PCB_TRACE_T );
// Do not create a copy constructor. The one generated by the compiler is adequate.
@ -125,6 +122,9 @@ public:
void SetStart( const wxPoint& aStart ) { m_Start = aStart; }
const wxPoint& GetStart() const { return m_Start; }
int GetShape() const { return m_Shape; }
void SetShape( int aShape ) { m_Shape = aShape; }
EDA_RECT GetBoundingBox() const;
/**
@ -164,10 +164,6 @@ public:
void Draw( EDA_DRAW_PANEL* panel, wxDC* DC,
GR_DRAWMODE aDrawMode, const wxPoint& aOffset = ZeroOffset );
/* divers */
int GetShape() const { return m_Shape & 0xFF; }
void SetShape( int aShape ) { m_Shape = aShape; }
/**
* Function TransformShapeWithClearanceToPolygon
* Convert the track shape to a closed polygon

64
pcbnew/clean.cpp
View File

@ -218,8 +218,8 @@ bool TRACKS_CLEANER::clean_vias()
// Correct via m_End defects (if any)
if( track->Type() == PCB_VIA_T )
{
if( track->m_Start != track->m_End )
track->m_End = track->m_Start;
if( track->GetStart() != track->GetEnd() )
track->SetEnd( track->GetStart() );
}
if( track->GetShape() != VIA_THROUGH )
@ -232,10 +232,10 @@ bool TRACKS_CLEANER::clean_vias()
{
next_track = alt_track->Next();
if( alt_track->m_Shape != VIA_THROUGH )
if( alt_track->GetShape() != VIA_THROUGH )
continue;
if( alt_track->m_Start != track->m_Start )
if( alt_track->GetStart() != track->GetStart() )
continue;
// delete via
@ -250,7 +250,7 @@ bool TRACKS_CLEANER::clean_vias()
{
next_track = track->Next();
if( track->m_Shape != VIA_THROUGH )
if( track->GetShape() != VIA_THROUGH )
continue;
// Examine the list of connected pads:
@ -319,13 +319,13 @@ bool TRACKS_CLEANER::deleteUnconnectedTracks()
{
if( track->Type() != PCB_VIA_T )
{
zone = m_Brd->HitTestForAnyFilledArea( track->m_Start,
zone = m_Brd->HitTestForAnyFilledArea( track->GetStart(),
track->GetLayer() );
}
else
{
((SEGVIA*)track)->ReturnLayerPair( &top_layer, &bottom_layer );
zone = m_Brd->HitTestForAnyFilledArea( track->m_Start,
zone = m_Brd->HitTestForAnyFilledArea( track->GetStart(),
top_layer, bottom_layer );
}
}
@ -352,7 +352,7 @@ bool TRACKS_CLEANER::deleteUnconnectedTracks()
if( other == NULL )
{
via->ReturnLayerPair( &top_layer, &bottom_layer );
zone = m_Brd->HitTestForAnyFilledArea( via->m_Start,
zone = m_Brd->HitTestForAnyFilledArea( via->GetStart(),
bottom_layer, top_layer );
}
@ -374,13 +374,13 @@ bool TRACKS_CLEANER::deleteUnconnectedTracks()
{
if( track->Type() != PCB_VIA_T )
{
zone = m_Brd->HitTestForAnyFilledArea( track->m_End,
zone = m_Brd->HitTestForAnyFilledArea( track->GetEnd(),
track->GetLayer() );
}
else
{
((SEGVIA*)track)->ReturnLayerPair( &top_layer, &bottom_layer );
zone = m_Brd->HitTestForAnyFilledArea( track->m_End,
zone = m_Brd->HitTestForAnyFilledArea( track->GetEnd(),
top_layer, bottom_layer );
}
}
@ -408,7 +408,7 @@ bool TRACKS_CLEANER::deleteUnconnectedTracks()
if( other == NULL )
{
via->ReturnLayerPair( &top_layer, &bottom_layer );
zone = m_Brd->HitTestForAnyFilledArea( via->m_End,
zone = m_Brd->HitTestForAnyFilledArea( via->GetEnd(),
bottom_layer, top_layer );
}
@ -472,12 +472,12 @@ bool TRACKS_CLEANER::clean_segments()
if( segment->GetNet() != other->GetNet() )
break;
if( ( segment->m_Start == other->m_Start ) &&
( segment->m_End == other->m_End ) )
if( ( segment->GetStart() == other->GetStart() ) &&
( segment->GetEnd() == other->GetEnd() ) )
erase = true;
if( ( segment->m_Start == other->m_End ) &&
( segment->m_End == other->m_Start ) )
if( ( segment->GetStart() == other->GetEnd() ) &&
( segment->GetEnd() == other->GetStart() ) )
erase = true;
// Delete redundant point
@ -511,7 +511,7 @@ bool TRACKS_CLEANER::clean_segments()
if( segStart )
{
// the two segments must have the same width
if( segment->m_Width != segStart->m_Width )
if( segment->GetWidth() != segStart->GetWidth() )
break;
// it cannot be a via
@ -550,7 +550,7 @@ bool TRACKS_CLEANER::clean_segments()
if( segEnd )
{
if( segment->m_Width != segEnd->m_Width )
if( segment->GetWidth() != segEnd->GetWidth() )
break;
if( segEnd->Type() != PCB_TRACE_T )
@ -607,7 +607,7 @@ bool TRACKS_CLEANER::clean_segments()
TRACK* TRACKS_CLEANER::mergeCollinearSegmentIfPossible( TRACK* aTrackRef, TRACK* aCandidate,
int aEndType )
{
if( aTrackRef->m_Width != aCandidate->m_Width )
if( aTrackRef->GetWidth() != aCandidate->GetWidth() )
return NULL;
bool is_colinear = false;
@ -615,20 +615,20 @@ TRACK* TRACKS_CLEANER::mergeCollinearSegmentIfPossible( TRACK* aTrackRef, TRACK*
// Trivial case: superimposed tracks ( tracks, not vias ):
if( aTrackRef->Type() == PCB_TRACE_T && aCandidate->Type() == PCB_TRACE_T )
{
if( ( aTrackRef->m_Start == aCandidate->m_Start ) &&
( aTrackRef->m_End == aCandidate->m_End ) )
if( ( aTrackRef->GetStart() == aCandidate->GetStart() ) &&
( aTrackRef->GetEnd() == aCandidate->GetEnd() ) )
return aCandidate;
if( ( aTrackRef->m_Start == aCandidate->m_End ) &&
( aTrackRef->m_End == aCandidate->m_Start ) )
if( ( aTrackRef->GetStart() == aCandidate->GetEnd() ) &&
( aTrackRef->GetEnd() == aCandidate->GetStart() ) )
return aCandidate;
}
int refdx = aTrackRef->m_End.x - aTrackRef->m_Start.x;
int refdy = aTrackRef->m_End.y - aTrackRef->m_Start.y;
int refdx = aTrackRef->GetEnd().x - aTrackRef->GetStart().x;
int refdy = aTrackRef->GetEnd().y - aTrackRef->GetStart().y;
int segmdx = aCandidate->m_End.x - aCandidate->m_Start.x;
int segmdy = aCandidate->m_End.y - aCandidate->m_Start.y;
int segmdx = aCandidate->GetEnd().x - aCandidate->GetStart().x;
int segmdy = aCandidate->GetEnd().y - aCandidate->GetStart().y;
// test for vertical alignment (easy to handle)
if( refdx == 0 )
@ -673,16 +673,16 @@ TRACK* TRACKS_CLEANER::mergeCollinearSegmentIfPossible( TRACK* aTrackRef, TRACK*
/* change the common point coordinate of pt_segm to use the other point
* of pt_segm (pt_segm will be removed later) */
if( aTrackRef->m_Start == aCandidate->m_Start )
if( aTrackRef->GetStart() == aCandidate->GetStart() )
{
aTrackRef->m_Start = aCandidate->m_End;
aTrackRef->SetStart( aCandidate->GetEnd());
aTrackRef->start = aCandidate->end;
aTrackRef->SetState( START_ON_PAD, aCandidate->GetState( END_ON_PAD) );
return aCandidate;
}
else
{
aTrackRef->m_Start = aCandidate->m_Start;
aTrackRef->SetStart( aCandidate->GetStart() );
aTrackRef->start = aCandidate->start;
aTrackRef->SetState( START_ON_PAD, aCandidate->GetState( START_ON_PAD) );
return aCandidate;
@ -696,16 +696,16 @@ TRACK* TRACKS_CLEANER::mergeCollinearSegmentIfPossible( TRACK* aTrackRef, TRACK*
/* change the common point coordinate of pt_segm to use the other point
* of pt_segm (pt_segm will be removed later) */
if( aTrackRef->m_End == aCandidate->m_Start )
if( aTrackRef->GetEnd() == aCandidate->GetStart() )
{
aTrackRef->m_End = aCandidate->m_End;
aTrackRef->SetEnd( aCandidate->GetEnd() );
aTrackRef->end = aCandidate->end;
aTrackRef->SetState( END_ON_PAD, aCandidate->GetState( END_ON_PAD) );
return aCandidate;
}
else
{
aTrackRef->m_End = aCandidate->m_Start;
aTrackRef->SetEnd( aCandidate->GetStart() );
aTrackRef->end = aCandidate->start;
aTrackRef->SetState( END_ON_PAD, aCandidate->GetState( START_ON_PAD) );
return aCandidate;

8
pcbnew/connect.cpp
View File

@ -264,11 +264,11 @@ void CONNECTIONS::BuildTracksCandidatesList( TRACK * aBegin, TRACK * aEnd)
m_candidates.reserve( ii );
for( TRACK* track = aBegin; track; track = track->Next() )
{
CONNECTED_POINT candidate( track, track->m_Start);
CONNECTED_POINT candidate( track, track->GetStart());
m_candidates.push_back( candidate );
if( track->Type() != PCB_VIA_T )
{
CONNECTED_POINT candidate2( track, track->m_End);
CONNECTED_POINT candidate2( track, track->GetEnd());
m_candidates.push_back( candidate2 );
}
@ -304,7 +304,7 @@ int CONNECTIONS::SearchConnectedTracks( const TRACK * aTrack )
int dist_max = aTrack->GetWidth() / 2;
static std::vector<CONNECTED_POINT*> tracks_candidates;
#endif
wxPoint position = aTrack->m_Start;
wxPoint position = aTrack->GetStart();
for( int kk = 0; kk < 2; kk++ )
{
#ifndef USE_EXTENDED_SEARCH
@ -361,7 +361,7 @@ int CONNECTIONS::SearchConnectedTracks( const TRACK * aTrack )
if( aTrack->Type() == PCB_VIA_T )
break;
position = aTrack->m_End;
position = aTrack->GetEnd();
}
return count;

2
pcbnew/drag.h
View File

@ -176,7 +176,7 @@ void EraseDragList();
* @param aNetCode = the net code to consider
* @param aMaxDist = max distance from aRefPos to a track end candidate to collect the track
*/
void Collect_TrackSegmentsToDrag( BOARD* aPcb, wxPoint& aRefPos, int aLayerMask,
void Collect_TrackSegmentsToDrag( BOARD* aPcb, const wxPoint& aRefPos, int aLayerMask,
int aNetCode, int aMaxDist );
/* Add aTrack to the drag list

14
pcbnew/dragsegm.cpp
View File

@ -51,8 +51,8 @@ std::vector<DRAG_SEGM_PICKER> g_DragSegmentList;
DRAG_SEGM_PICKER::DRAG_SEGM_PICKER( TRACK* aTrack )
{
m_Track = aTrack;
m_startInitialValue = m_Track->m_Start;
m_endInitialValue = m_Track->m_End;
m_startInitialValue = m_Track->GetStart();
m_endInitialValue = m_Track->GetEnd();
m_Pad_Start = m_Track->GetState( START_ON_PAD ) ? (D_PAD*)m_Track->start : NULL;
m_Pad_End = m_Track->GetState( END_ON_PAD ) ? (D_PAD*)m_Track->end : NULL;
m_Flag = 0;
@ -133,7 +133,7 @@ void DRAG_SEGM_PICKER::SetTrackEndsCoordinates(wxPoint aOffset)
if( flip )
NEGATE( padoffset.y );
m_Track->m_Start = m_Pad_Start->GetPosition() - aOffset + padoffset;
m_Track->SetStart( m_Pad_Start->GetPosition() - aOffset + padoffset );
}
if( m_Pad_End )
@ -146,7 +146,7 @@ void DRAG_SEGM_PICKER::SetTrackEndsCoordinates(wxPoint aOffset)
if( flip )
NEGATE( padoffset.y );
m_Track->m_End = m_Pad_End->GetPosition() - aOffset + padoffset;
m_Track->SetEnd( m_Pad_End->GetPosition() - aOffset + padoffset );
}
}
@ -349,7 +349,7 @@ void AddSegmentToDragList( int flag, TRACK* aTrack )
* aNetCode = the net code to consider
* aMaxDist = max distance from aRefPos to a track end candidate to collect the track
*/
void Collect_TrackSegmentsToDrag( BOARD* aPcb, wxPoint& aRefPos, int aLayerMask,
void Collect_TrackSegmentsToDrag( BOARD* aPcb, const wxPoint& aRefPos, int aLayerMask,
int aNetCode, int aMaxDist )
{
TRACK* track = aPcb->m_Track->GetStartNetCode( aNetCode );
@ -370,7 +370,7 @@ void Collect_TrackSegmentsToDrag( BOARD* aPcb, wxPoint& aRefPos, int aLayerMask,
if( (track->GetFlags() & STARTPOINT) == 0 )
{
wxPoint delta = track->m_Start - aRefPos;
wxPoint delta = track->GetStart() - aRefPos;
if( std::abs( delta.x ) <= maxdist && std::abs( delta.y ) <= maxdist )
{
int dist = (int) hypot( (double) delta.x, (double) delta.y );
@ -385,7 +385,7 @@ void Collect_TrackSegmentsToDrag( BOARD* aPcb, wxPoint& aRefPos, int aLayerMask,
if( (track->GetFlags() & ENDPOINT) == 0 )
{
wxPoint delta = track->m_End - aRefPos;
wxPoint delta = track->GetEnd() - aRefPos;
if( std::abs( delta.x ) <= maxdist && std::abs( delta.y ) <= maxdist )
{
int dist = (int) hypot( (double) delta.x, (double) delta.y );

34
pcbnew/drc_clearance_test_functions.cpp
View File

@ -165,9 +165,9 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
/* In order to make some calculations more easier or faster,
* pads and tracks coordinates will be made relative to the reference segment origin
*/
wxPoint origin = aRefSeg->m_Start; // origin will be the origin of other coordinates
wxPoint origin = aRefSeg->GetStart(); // origin will be the origin of other coordinates
m_segmEnd = delta = aRefSeg->m_End - origin;
m_segmEnd = delta = aRefSeg->GetEnd() - origin;
m_segmAngle = 0;
layerMask = aRefSeg->ReturnMaskLayer();
@ -179,7 +179,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
// test if the via size is smaller than minimum
if( aRefSeg->GetShape() == VIA_MICROVIA )
{
if( aRefSeg->m_Width < netclass->GetuViaMinDiameter() )
if( aRefSeg->GetWidth() < netclass->GetuViaMinDiameter() )
{
m_currentMarker = fillMarker( aRefSeg, NULL,
DRCE_TOO_SMALL_MICROVIA, m_currentMarker );
@ -188,7 +188,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
}
else
{
if( aRefSeg->m_Width < netclass->GetViaMinDiameter() )
if( aRefSeg->GetWidth() < netclass->GetViaMinDiameter() )
{
m_currentMarker = fillMarker( aRefSeg, NULL,
DRCE_TOO_SMALL_VIA, m_currentMarker );
@ -199,7 +199,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
// test if via's hole is bigger than its diameter
// This test is necessary since the via hole size and width can be modified
// and a default via hole can be bigger than some vias sizes
if( aRefSeg->GetDrillValue() > aRefSeg->m_Width )
if( aRefSeg->GetDrillValue() > aRefSeg->GetWidth() )
{
m_currentMarker = fillMarker( aRefSeg, NULL,
DRCE_VIA_HOLE_BIGGER, m_currentMarker );
@ -237,7 +237,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
}
else // This is a track segment
{
if( aRefSeg->m_Width < netclass->GetTrackMinWidth() )
if( aRefSeg->GetWidth() < netclass->GetTrackMinWidth() )
{
m_currentMarker = fillMarker( aRefSeg, NULL,
DRCE_TOO_SMALL_TRACK_WIDTH, m_currentMarker );
@ -303,7 +303,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
m_padToTestPos = dummypad.GetPosition() - origin;
if( !checkClearanceSegmToPad( &dummypad, aRefSeg->m_Width,
if( !checkClearanceSegmToPad( &dummypad, aRefSeg->GetWidth(),
netclass->GetClearance() ) )
{
m_currentMarker = fillMarker( aRefSeg, pad,
@ -324,7 +324,7 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
shape_pos = pad->ReturnShapePos();
m_padToTestPos = shape_pos - origin;
if( !checkClearanceSegmToPad( pad, aRefSeg->m_Width, aRefSeg->GetClearance( pad ) ) )
if( !checkClearanceSegmToPad( pad, aRefSeg->GetWidth(), aRefSeg->GetClearance( pad ) ) )
{
m_currentMarker = fillMarker( aRefSeg, pad,
DRCE_TRACK_NEAR_PAD, m_currentMarker );
@ -355,15 +355,15 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
// the minimum distance = clearance plus half the reference track
// width plus half the other track's width
int w_dist = aRefSeg->GetClearance( track );
w_dist += (aRefSeg->m_Width + track->m_Width) / 2;
w_dist += (aRefSeg->GetWidth() + track->GetWidth()) / 2;
// If the reference segment is a via, we test it here
if( aRefSeg->Type() == PCB_VIA_T )
{
int angle = 0; // angle du segment a tester;
delta = track->m_End - track->m_Start;
segStartPoint = aRefSeg->m_Start - track->m_Start;
delta = track->GetEnd() - track->GetStart();
segStartPoint = aRefSeg->GetStart() - track->GetStart();
if( track->Type() == PCB_VIA_T )
{
@ -399,8 +399,8 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
* the segment to test in the new axis : the new X axis is the
* reference segment. We must translate and rotate the segment to test
*/
segStartPoint = track->m_Start - origin;
segEndPoint = track->m_End - origin;
segStartPoint = track->GetStart() - origin;
segEndPoint = track->GetEnd() - origin;
RotatePoint( &segStartPoint, m_segmAngle );
RotatePoint( &segEndPoint, m_segmAngle );
if( track->Type() == PCB_VIA_T )
@ -529,8 +529,8 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
else // The drc error is due to the starting or the ending point of the reference segment
{
// Test the starting and the ending point
segStartPoint = track->m_Start;
segEndPoint = track->m_End;
segStartPoint = track->GetStart();
segEndPoint = track->GetEnd();
delta = segEndPoint - segStartPoint;
/* Compute the segment orientation (angle) en 0,1 degre */
@ -542,8 +542,8 @@ bool DRC::doTrackDrc( TRACK* aRefSeg, TRACK* aStart, bool testPads )
/* Comute the reference segment coordinates relatives to a
* X axis = current tested segment
*/
wxPoint relStartPos = aRefSeg->m_Start - segStartPoint;
wxPoint relEndPos = aRefSeg->m_End - segStartPoint;
wxPoint relStartPos = aRefSeg->GetStart() - segStartPoint;
wxPoint relEndPos = aRefSeg->GetEnd() - segStartPoint;
RotatePoint( &relStartPos, angle );
RotatePoint( &relEndPos, angle );

12
pcbnew/drc_marker_functions.cpp
View File

@ -70,17 +70,17 @@ MARKER_PCB* DRC::fillMarker( TRACK* aTrack, BOARD_ITEM* aItem, int aErrorCode, M
posB = track->GetPosition();
wxPoint endPos = track->m_End;
wxPoint endPos = track->GetEnd();
// either of aItem's start or end will be used for the marker position
// first assume start, then switch at end if needed. decision made on
// distance from end of aTrack.
position = track->m_Start;
position = track->GetStart();
double dToEnd = hypot( endPos.x - aTrack->m_End.x,
endPos.y - aTrack->m_End.y );
double dToStart = hypot( position.x - aTrack->m_End.x,
position.y - aTrack->m_End.y );
double dToEnd = hypot( endPos.x - aTrack->GetEnd().x,
endPos.y - aTrack->GetEnd().y );
double dToStart = hypot( position.x - aTrack->GetEnd().x,
position.y - aTrack->GetEnd().y );
if( dToEnd < dToStart )
position = endPos;

12
pcbnew/edit_track_width.cpp
View File

@ -38,7 +38,7 @@ bool PCB_EDIT_FRAME::SetTrackSegmentWidth( TRACK* aTrackItem,
if( aUseNetclassValue )
net = GetBoard()->FindNet( aTrackItem->GetNet() );
initial_width = aTrackItem->m_Width;
initial_width = aTrackItem->GetWidth();
if( net )
new_width = net->GetTrackWidth();
@ -60,7 +60,7 @@ bool PCB_EDIT_FRAME::SetTrackSegmentWidth( TRACK* aTrackItem,
new_drill = GetBoard()->GetCurrentViaDrill();
}
if( aTrackItem->m_Shape == VIA_MICROVIA )
if( aTrackItem->GetShape() == VIA_MICROVIA )
{
if( net )
new_width = net->GetViaSize();
@ -69,7 +69,7 @@ bool PCB_EDIT_FRAME::SetTrackSegmentWidth( TRACK* aTrackItem,
}
}
aTrackItem->m_Width = new_width;
aTrackItem->SetWidth( new_width );
// make a DRC test because the new size is bigger than the old size
if( initial_width < new_width )
@ -98,11 +98,11 @@ bool PCB_EDIT_FRAME::SetTrackSegmentWidth( TRACK* aTrackItem,
if( aItemsListPicker )
{
aTrackItem->m_Width = initial_width;
aTrackItem->SetWidth( initial_width );
ITEM_PICKER picker( aTrackItem, UR_CHANGED );
picker.SetLink( aTrackItem->Clone() );
aItemsListPicker->PushItem( picker );
aTrackItem->m_Width = new_width;
aTrackItem->SetWidth( new_width );
if( aTrackItem->Type() == PCB_VIA_T )
{
@ -116,7 +116,7 @@ bool PCB_EDIT_FRAME::SetTrackSegmentWidth( TRACK* aTrackItem,
}
else
{
aTrackItem->m_Width = initial_width;
aTrackItem->SetWidth( initial_width );
}
return change_ok;

16
pcbnew/editrack-part2.cpp
View File

@ -62,13 +62,13 @@ bool PCB_EDIT_FRAME::Other_Layer_Route( TRACK* aTrack, wxDC* DC )
}
// Avoid more than one via on the current location:
if( GetBoard()->GetViaByPosition( g_CurrentTrackSegment->m_End,
if( GetBoard()->GetViaByPosition( g_CurrentTrackSegment->GetEnd(),
g_CurrentTrackSegment->GetLayer() ) )
return false;
for( TRACK* segm = g_FirstTrackSegment; segm; segm = segm->Next() )
{
if( segm->Type() == PCB_VIA_T && g_CurrentTrackSegment->m_End == segm->m_Start )
if( segm->Type() == PCB_VIA_T && g_CurrentTrackSegment->GetEnd() == segm->GetStart() )
return false;
}
@ -98,10 +98,11 @@ bool PCB_EDIT_FRAME::Other_Layer_Route( TRACK* aTrack, wxDC* DC )
// create the via
SEGVIA* via = new SEGVIA( GetBoard() );
via->SetFlags( IS_NEW );
via->m_Shape = GetDesignSettings().m_CurrentViaType;
via->m_Width = GetBoard()->GetCurrentViaSize();
via->SetShape( GetDesignSettings().m_CurrentViaType );
via->SetWidth( GetBoard()->GetCurrentViaSize());
via->SetNet( GetBoard()->GetHighLightNetCode() );
via->m_Start = via->m_End = g_CurrentTrackSegment->m_End;
via->SetEnd( g_CurrentTrackSegment->GetEnd() );
via->SetStart( g_CurrentTrackSegment->GetEnd() );
// Usual via is from copper to component.
// layer pair is LAYER_N_BACK and LAYER_N_FRONT.
@ -140,7 +141,7 @@ bool PCB_EDIT_FRAME::Other_Layer_Route( TRACK* aTrack, wxDC* DC )
via->SetLayerPair( first_layer, last_layer );
{
NETINFO_ITEM* net = GetBoard()->FindNet( via->GetNet() );
via->m_Width = net->GetMicroViaSize();
via->SetWidth( net->GetMicroViaSize() );
}
}
break;
@ -198,7 +199,8 @@ bool PCB_EDIT_FRAME::Other_Layer_Route( TRACK* aTrack, wxDC* DC )
/* the start point is the via position and the end point is the cursor
* which also is on the via (will change when moving mouse)
*/
track->m_Start = track->m_End = via->m_Start;
track->SetEnd( via->GetStart() );
track->SetStart( via->GetStart() );
g_CurrentTrackList.PushBack( track );

152
pcbnew/editrack.cpp
View File

@ -153,11 +153,11 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
GetBoard()->SetHighLightNet( zone->GetNet() );
}
D( g_CurrentTrackList.VerifyListIntegrity(); );
D( g_CurrentTrackList.VerifyListIntegrity() );
BuildAirWiresTargetsList( LockPoint, wxPoint( 0, 0 ), true );
D( g_CurrentTrackList.VerifyListIntegrity(); );
D( g_CurrentTrackList.VerifyListIntegrity() );
GetBoard()->HighLightON();
GetBoard()->DrawHighLight( m_canvas, aDC, GetBoard()->GetHighLightNetCode() );
@ -167,16 +167,16 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
GetBoard()->SetCurrentNetClass( g_CurrentTrackSegment->GetNetClassName() );
g_CurrentTrackSegment->SetLayer( GetScreen()->m_Active_Layer );
g_CurrentTrackSegment->m_Width = GetBoard()->GetCurrentTrackWidth();
g_CurrentTrackSegment->SetWidth( GetBoard()->GetCurrentTrackWidth() );
if( GetBoard()->GetDesignSettings().m_UseConnectedTrackWidth )
{
if( TrackOnStartPoint && TrackOnStartPoint->Type() == PCB_TRACE_T )
g_CurrentTrackSegment->m_Width = TrackOnStartPoint->m_Width;
g_CurrentTrackSegment->SetWidth( TrackOnStartPoint->GetWidth());
}
g_CurrentTrackSegment->m_Start = pos;
g_CurrentTrackSegment->m_End = pos;
g_CurrentTrackSegment->SetStart( pos );
g_CurrentTrackSegment->SetEnd( pos );
if( pad )
{
@ -275,12 +275,12 @@ TRACK* PCB_EDIT_FRAME::Begin_Route( TRACK* aTrack, wxDC* aDC )
D( g_CurrentTrackList.VerifyListIntegrity(); );
newTrack->m_Start = newTrack->m_End;
newTrack->SetStart( newTrack->GetEnd() );
newTrack->SetLayer( GetScreen()->m_Active_Layer );
if( !GetBoard()->GetDesignSettings().m_UseConnectedTrackWidth )
newTrack->m_Width = GetBoard()->GetCurrentTrackWidth();
newTrack->SetWidth( GetBoard()->GetCurrentTrackWidth() );
D( g_CurrentTrackList.VerifyListIntegrity(); );
@ -312,15 +312,15 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
int segm_step_45 = KiROUND( GetScreen()->GetGridSize().x / 2 );
if( segm_step_45 < ( curTrack->m_Width * 2 ) )
segm_step_45 = curTrack->m_Width * 2;
if( segm_step_45 < ( curTrack->GetWidth() * 2 ) )
segm_step_45 = curTrack->GetWidth() * 2;
// Test if the segments are horizontal or vertical.
dx0 = prevTrack->m_End.x - prevTrack->m_Start.x;
dy0 = prevTrack->m_End.y - prevTrack->m_Start.y;
dx0 = prevTrack->GetEnd().x - prevTrack->GetStart().x;
dy0 = prevTrack->GetEnd().y - prevTrack->GetStart().y;
dx1 = curTrack->m_End.x - curTrack->m_Start.x;
dy1 = curTrack->m_End.y - curTrack->m_Start.y;
dx1 = curTrack->GetEnd().x - curTrack->GetStart().x;
dy1 = curTrack->GetEnd().y - curTrack->GetStart().y;
// Segments should have a min length.
if( std::max( abs( dx0 ), abs( dy0 ) ) < ( segm_step_45 * 2 ) )
@ -332,8 +332,8 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
// Create a new segment and connect it with the previous 2 segments.
TRACK* newTrack = (TRACK*)curTrack->Clone();
newTrack->m_Start = prevTrack->m_End;
newTrack->m_End = curTrack->m_Start;
newTrack->SetStart( prevTrack->GetEnd() );
newTrack->SetEnd( curTrack->GetStart() );
if( dx0 == 0 ) // Previous segment is Vertical
{
@ -348,14 +348,14 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
* horizontal segment.
*/
if( dy0 > 0 )
newTrack->m_Start.y -= segm_step_45;
newTrack->SetStart( wxPoint(newTrack->GetStart().x, newTrack->GetStart().y -segm_step_45) );
else
newTrack->m_Start.y += segm_step_45;
newTrack->SetStart( wxPoint(newTrack->GetStart().x, newTrack->GetStart().y + segm_step_45) );
if( dx1 > 0 )
newTrack->m_End.x += segm_step_45;
newTrack->SetEnd( wxPoint(newTrack->GetEnd().x + segm_step_45, newTrack->GetEnd().y) );
else
newTrack->m_End.x -= segm_step_45;
newTrack->SetEnd( wxPoint(newTrack->GetEnd().x - segm_step_45, newTrack->GetEnd().y) );
if( Drc_On && BAD_DRC == m_drc->Drc( curTrack, GetBoard()->m_Track ) )
{
@ -363,8 +363,8 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
return false;
}
prevTrack->m_End = newTrack->m_Start;
curTrack->m_Start = newTrack->m_End;
prevTrack->SetEnd( newTrack->GetStart());
curTrack->SetStart( newTrack->GetEnd());
g_CurrentTrackList.Insert( newTrack, curTrack );
return true;
@ -383,14 +383,14 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
* (horizontal) and segment 2 (vertical)
*/
if( dx0 > 0 )
newTrack->m_Start.x -= segm_step_45;
newTrack->SetStart( wxPoint(newTrack->GetStart().x - segm_step_45 , newTrack->GetStart().y));
else
newTrack->m_Start.x += segm_step_45;
newTrack->SetStart( wxPoint(newTrack->GetStart().x + segm_step_45, newTrack->GetStart().y) );
if( dy1 > 0 )
newTrack->m_End.y += segm_step_45;
newTrack->SetEnd( wxPoint(newTrack->GetEnd().x, newTrack->GetEnd().y + segm_step_45) );
else
newTrack->m_End.y -= segm_step_45;
newTrack->SetEnd( wxPoint(newTrack->GetEnd().x, newTrack->GetEnd().y - segm_step_45) );
if( Drc_On && BAD_DRC==m_drc->Drc( newTrack, GetBoard()->m_Track ) )
{
@ -398,8 +398,8 @@ bool PCB_EDIT_FRAME::Add45DegreeSegment( wxDC* aDC )
return false;
}
prevTrack->m_End = newTrack->m_Start;
curTrack->m_Start = newTrack->m_End;
prevTrack->SetEnd( newTrack->GetStart());
curTrack->SetStart( newTrack->GetEnd());
g_CurrentTrackList.Insert( newTrack, curTrack );
return true;
@ -420,7 +420,7 @@ bool PCB_EDIT_FRAME::End_Route( TRACK* aTrack, wxDC* aDC )
return false;
// Saving the coordinate of end point of the trace
wxPoint pos = g_CurrentTrackSegment->m_End;
wxPoint pos = g_CurrentTrackSegment->GetEnd();
D( g_CurrentTrackList.VerifyListIntegrity(); );
@ -460,9 +460,9 @@ bool PCB_EDIT_FRAME::End_Route( TRACK* aTrack, wxDC* aDC )
// creates a lock point if not exists
{
// Creates a lock point, if not already exists:
LockPoint = GetBoard()->CreateLockPoint( g_CurrentTrackSegment->m_End,
(TRACK*) LockPoint,
&s_ItemsListPicker );
wxPoint hp = g_CurrentTrackSegment->GetEnd();
LockPoint = GetBoard()->CreateLockPoint( hp, (TRACK*) LockPoint, &s_ItemsListPicker );
g_CurrentTrackSegment->SetEnd(hp);
}
}
@ -538,7 +538,7 @@ bool PCB_EDIT_FRAME::End_Route( TRACK* aTrack, wxDC* aDC )
TRACK* LocateIntrusion( TRACK* listStart, TRACK* aTrack, int aLayer, const wxPoint& aRef )
{
int net = aTrack->GetNet();
int width = aTrack->m_Width;
int width = aTrack->GetWidth();
TRACK* found = NULL;
@ -556,16 +556,16 @@ TRACK* LocateIntrusion( TRACK* listStart, TRACK* aTrack, int aLayer, const wxPoi
continue;
// TRACK::HitTest
int dist = (width + track->m_Width) / 2 + aTrack->GetClearance( track );
int dist = (width + track->GetWidth()) / 2 + aTrack->GetClearance( track );
if( !TestSegmentHit( aRef, track->m_Start, track->m_End, dist ) )
if( !TestSegmentHit( aRef, track->GetStart(), track->GetEnd(), dist ) )
continue;
found = track;
// prefer intrusions from the side, not the end
wxPoint pos = aRef - track->m_Start;
wxPoint vec = track->m_End - track->m_Start;
wxPoint pos = aRef - track->GetStart();
wxPoint vec = track->GetEnd() - track->GetStart();
double tmp = (double) pos.x * vec.x + (double) pos.y * vec.y;
if( tmp >= 0 && tmp <= (double) vec.x * vec.x + (double) vec.y * vec.y )
@ -614,8 +614,8 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
if( other->GetNet() == track->GetNet() )
return;
cv = cursor - other->m_Start;
vec = other->m_End - other->m_Start;
cv = cursor - other->GetStart();
vec = other->GetEnd() - other->GetStart();
det = (double) cv.x * vec.y - (double) cv.y * vec.x;
@ -623,7 +623,7 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
if( !det )
return;
dist = (track->m_Width + 1) / 2 + (other->m_Width + 1) / 2 + track->GetClearance( other ) + 2;
dist = (track->GetWidth() + 1) / 2 + (other->GetWidth() + 1) / 2 + track->GetClearance( other ) + 2;
/*
* DRC wants >, so +1.
@ -646,8 +646,9 @@ static void PushTrack( EDA_DRAW_PANEL* panel )
n.x = KiROUND( f * n.x );
n.y = KiROUND( f * n.y );
Project( &track->m_End, cursor, other );
track->m_End += n;
wxPoint hp = track->GetEnd();
Project( &hp, cursor, other );
track->SetEnd( hp + n );
}
@ -702,7 +703,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
if( showTrackClearanceMode >= SHOW_CLEARANCE_NEW_TRACKS_AND_VIA_AREAS )
{
EDA_COLOR_T color = g_ColorsSettings.GetLayerColor( g_CurrentTrackSegment->GetLayer() );
DrawViaCirclesWhenEditingNewTrack( panelClipBox, aDC, g_CurrentTrackSegment->m_End,
DrawViaCirclesWhenEditingNewTrack( panelClipBox, aDC, g_CurrentTrackSegment->GetEnd(),
boardViaRadius, viaRadiusWithClearence, color);
}
}
@ -715,7 +716,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
g_CurrentTrackSegment->SetLayer( screen->m_Active_Layer );
if( !frame->GetBoard()->GetDesignSettings().m_UseConnectedTrackWidth )
g_CurrentTrackSegment->m_Width = frame->GetBoard()->GetCurrentTrackWidth();
g_CurrentTrackSegment->SetWidth( frame->GetBoard()->GetCurrentTrackWidth() );
if( g_TwoSegmentTrackBuild )
{
@ -726,7 +727,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
previous_track->SetLayer( screen->m_Active_Layer );
if( !frame->GetBoard()->GetDesignSettings().m_UseConnectedTrackWidth )
previous_track->m_Width = frame->GetBoard()->GetCurrentTrackWidth();
previous_track->SetWidth( frame->GetBoard()->GetCurrentTrackWidth() );
}
}
@ -734,30 +735,32 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
{
if( g_TwoSegmentTrackBuild )
{
g_CurrentTrackSegment->m_End = screen->GetCrossHairPosition();
g_CurrentTrackSegment->SetEnd( screen->GetCrossHairPosition() );
if( Drc_On )
PushTrack( aPanel );
ComputeBreakPoint( g_CurrentTrackSegment,
g_CurrentTrackList.GetCount(),
g_CurrentTrackSegment->m_End );
g_CurrentTrackSegment->GetEnd() );
}
else
{
/* Calculate of the end of the path for the permitted directions:
* horizontal, vertical or 45 degrees.
*/
wxPoint hp = g_CurrentTrackSegment->GetEnd();
CalculateSegmentEndPoint( screen->GetCrossHairPosition(),
g_CurrentTrackSegment->m_Start.x,
g_CurrentTrackSegment->m_Start.y,
&g_CurrentTrackSegment->m_End.x,
&g_CurrentTrackSegment->m_End.y );
g_CurrentTrackSegment->GetStart().x,
g_CurrentTrackSegment->GetStart().y,
&hp.x,
&hp.y );
g_CurrentTrackSegment->SetEnd(hp);
}
}
else // Here the angle is arbitrary
{
g_CurrentTrackSegment->m_End = screen->GetCrossHairPosition();
g_CurrentTrackSegment->SetEnd( screen->GetCrossHairPosition() );
}
// Redraw the new track
@ -769,7 +772,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
EDA_COLOR_T color = g_ColorsSettings.GetLayerColor(g_CurrentTrackSegment->GetLayer());
//Via diameter must have taken what we are using, rather than netclass value.
DrawViaCirclesWhenEditingNewTrack( panelClipBox, aDC, g_CurrentTrackSegment->m_End,
DrawViaCirclesWhenEditingNewTrack( panelClipBox, aDC, g_CurrentTrackSegment->GetEnd(),
boardViaRadius, viaRadiusWithClearence, color);
}
@ -821,7 +824,7 @@ void ShowNewTrackWhenMovingCursor( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPo
DisplayOpt.ShowTrackClearanceMode = showTrackClearanceMode;
DisplayOpt.DisplayPcbTrackFill = Track_fill_copy;
frame->BuildAirWiresTargetsList( NULL, g_CurrentTrackSegment->m_End, false );
frame->BuildAirWiresTargetsList( NULL, g_CurrentTrackSegment->GetEnd(), false );
frame->TraceAirWiresToTargets( aDC );
}
@ -908,8 +911,8 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
if( track )
{
iDx = end.x - track->m_Start.x;
iDy = end.y - track->m_Start.y;
iDx = end.x - track->GetStart().x;
iDy = end.y - track->GetStart().y;
iDx = abs( iDx );
iDy = abs( iDy );
@ -919,8 +922,8 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
if( lastTrack )
{
if(( (lastTrack->m_End.x == lastTrack->m_Start.x)
|| (lastTrack->m_End.y == lastTrack->m_Start.y) )
if(( (lastTrack->GetEnd().x == lastTrack->GetStart().x)
|| (lastTrack->GetEnd().y == lastTrack->GetStart().y) )
&& !g_Alternate_Track_Posture)
{
iAngle = 45;
@ -951,12 +954,10 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
break;
case 0:
if( ( end.x - track->m_Start.x ) < 0 )
track->m_End.x = end.x + iDy;
if( ( end.x - track->GetStart().x ) < 0 )
track->SetEnd(wxPoint( end.x + iDy, track->GetStart().y));
else
track->m_End.x = end.x - iDy;
track->m_End.y = track->m_Start.y;
track->SetEnd(wxPoint( end.x - iDy, track->GetStart().y));
break;
case 45:
@ -964,35 +965,32 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
iDy = iDx;
// Recalculate the signs for deltax and deltaY.
if( ( end.x - track->m_Start.x ) < 0 )
if( ( end.x - track->GetStart().x ) < 0 )
iDx = -iDx;
if( ( end.y - track->m_Start.y ) < 0 )
if( ( end.y - track->GetStart().y ) < 0 )
iDy = -iDy;
track->m_End.x = track->m_Start.x + iDx;
track->m_End.y = track->m_Start.y + iDy;
track->SetEnd(wxPoint(track->GetStart().x + iDx, track->GetStart().y + iDy));
break;
case 90:
if( ( end.y - track->m_Start.y ) < 0 )
track->m_End.y = end.y + iDx;
if( ( end.y - track->GetStart().y ) < 0 )
track->SetEnd(wxPoint(track->GetStart().x , end.y + iDx));
else
track->m_End.y = end.y - iDx;
track->m_End.x = track->m_Start.x;
track->SetEnd(wxPoint(track->GetStart().x , end.y - iDx));
break;
}
if( track )
{
if( track->IsNull() )
track->m_End = end;
track->SetEnd( end );
newTrack->m_Start = track->m_End;
newTrack->SetStart( track->GetEnd() );
}
newTrack->m_End = end;
newTrack->SetEnd( end );
}
@ -1081,7 +1079,7 @@ void DeleteNullTrackSegments( BOARD* pcb, DLIST<TRACK>& aTrackList )
*/
void EnsureEndTrackOnPad( D_PAD* aPad )
{
if( g_CurrentTrackSegment->m_End == aPad->GetPosition() ) // Ok !
if( g_CurrentTrackSegment->GetEnd() == aPad->GetPosition() ) // Ok !
{
g_CurrentTrackSegment->end = aPad;
g_CurrentTrackSegment->SetState( END_ONPAD, ON );
@ -1098,7 +1096,7 @@ void EnsureEndTrackOnPad( D_PAD* aPad )
lasttrack->end = g_CurrentTrackSegment;
}
g_CurrentTrackSegment->m_End = aPad->GetPosition();
g_CurrentTrackSegment->SetEnd( aPad->GetPosition() );
g_CurrentTrackSegment->SetState( END_ONPAD, OFF );
g_CurrentTrackSegment->end = aPad;

7
pcbnew/event_handlers_tracks_vias_sizes.cpp
View File

@ -111,9 +111,12 @@ void PCB_EDIT_FRAME::Tracks_and_Vias_Size_Event( wxCommandEvent& event )
// Refresh track in progress, if any, by forcing a mouse event,
// to call the current function attached to the mouse
if( m_canvas->IsMouseCaptured() )
/*if( m_canvas->IsMouseCaptured() )
{
wxMouseEvent event(wxEVT_MOTION);
wxPostEvent( m_canvas, event );
}
}*/
//+hp
//Refresh canvas, that we can see changes instantly. I use this because it dont,t throw mouse up-left corner.
m_canvas->Refresh();
}

44
pcbnew/export_gencad.cpp
View File

@ -225,8 +225,8 @@ static int ViaSort( const void* aRefptr, const void* aObjptr )
TRACK* padref = *(TRACK**) aRefptr;
TRACK* padcmp = *(TRACK**) aObjptr;
if( padref->m_Width != padcmp->m_Width )
return padref->m_Width - padcmp->m_Width;
if( padref->GetWidth() != padcmp->GetWidth() )
return padref->GetWidth() - padcmp->GetWidth();
if( padref->GetDrillValue() != padcmp->GetDrillValue() )
return padref->GetDrillValue() - padcmp->GetDrillValue();
@ -292,10 +292,10 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
old_via = via;
viastacks.push_back( via );
fprintf( aFile, "PAD V%d.%d.%X ROUND %g\nCIRCLE 0 0 %g\n",
via->m_Width, via->GetDrillValue(),
via->GetWidth(), via->GetDrillValue(),
via->ReturnMaskLayer(),
via->GetDrillValue() / SCALE_FACTOR,
via->m_Width / (SCALE_FACTOR * 2) );
via->GetWidth() / (SCALE_FACTOR * 2) );
}
// Emit component pads
@ -436,7 +436,7 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
TRACK* via = viastacks[i];
unsigned mask = via->ReturnMaskLayer() & master_layermask;
fprintf( aFile, "PADSTACK VIA%d.%d.%X %g\n",
via->m_Width, via->GetDrillValue(), mask,
via->GetWidth(), via->GetDrillValue(), mask,
via->GetDrillValue() / SCALE_FACTOR );
for( int layer = 0; layer < 32; layer++ )
@ -444,7 +444,7 @@ static void CreatePadsShapesSection( FILE* aFile, BOARD* aPcb )
if( mask & (1 << layer) )
{
fprintf( aFile, "PAD V%d.%d.%X %s 0 0\n",
via->m_Width, via->GetDrillValue(),
via->GetWidth(), via->GetDrillValue(),
mask,
TO_UTF8( GenCADLayerName[layer] ) );
}
@ -736,7 +736,7 @@ static int TrackListSortByNetcode( const void* refptr, const void* objptr )
if( ( diff = ref->GetNet() - cmp->GetNet() ) )
return diff;
if( ( diff = ref->m_Width - cmp->m_Width ) )
if( ( diff = ref->GetWidth() - cmp->GetWidth() ) )
return diff;
if( ( diff = ref->GetLayer() - cmp->GetLayer() ) )
@ -814,10 +814,10 @@ static void CreateRoutesSection( FILE* aFile, BOARD* aPcb )
fprintf( aFile, "ROUTE %s\n", TO_UTF8( netname ) );
}
if( old_width != track->m_Width )
if( old_width != track->GetWidth() )
{
old_width = track->m_Width;
fprintf( aFile, "TRACK TRACK%d\n", track->m_Width );
old_width = track->GetWidth();
fprintf( aFile, "TRACK TRACK%d\n", track->GetWidth() );
}
if( (track->Type() == PCB_TRACE_T) || (track->Type() == PCB_ZONE_T) )
@ -830,15 +830,15 @@ static void CreateRoutesSection( FILE* aFile, BOARD* aPcb )
}
fprintf( aFile, "LINE %g %g %g %g\n",
MapXTo( track->m_Start.x ), MapYTo( track->m_Start.y ),
MapXTo( track->m_End.x ), MapYTo( track->m_End.y ) );
MapXTo( track->GetStart().x ), MapYTo( track->GetStart().y ),
MapXTo( track->GetEnd().x ), MapYTo( track->GetEnd().y ) );
}
if( track->Type() == PCB_VIA_T )
{
fprintf( aFile, "VIA VIA%d.%d.%X %g %g ALL %g via%d\n",
track->m_Width, track->GetDrillValue(),
track->GetWidth(), track->GetDrillValue(),
track->ReturnMaskLayer() & master_layermask,
MapXTo( track->m_Start.x ), MapYTo( track->m_Start.y ),
MapXTo( track->GetStart().x ), MapYTo( track->GetStart().y ),
track->GetDrillValue() / SCALE_FACTOR, vianum++ );
}
}
@ -931,35 +931,35 @@ static void CreateTracksInfoData( FILE* aFile, BOARD* aPcb )
for( track = aPcb->m_Track; track != NULL; track = track->Next() )
{
if( last_width != track->m_Width ) // Find a thickness already used.
if( last_width != track->GetWidth() ) // Find a thickness already used.
{
for( ii = 0; ii < trackinfo.size(); ii++ )
{
if( trackinfo[ii] == track->m_Width )
if( trackinfo[ii] == track->GetWidth() )
break;
}
if( ii == trackinfo.size() ) // not found
trackinfo.push_back( track->m_Width );
trackinfo.push_back( track->GetWidth() );
last_width = track->m_Width;
last_width = track->GetWidth();
}
}
for( track = aPcb->m_Zone; track != NULL; track = track->Next() )
{
if( last_width != track->m_Width ) // Find a thickness already used.
if( last_width != track->GetWidth() ) // Find a thickness already used.
{
for( ii = 0; ii < trackinfo.size(); ii++ )
{
if( trackinfo[ii] == track->m_Width )
if( trackinfo[ii] == track->GetWidth() )
break;
}
if( ii == trackinfo.size() ) // not found
trackinfo.push_back( track->m_Width );
trackinfo.push_back( track->GetWidth() );
last_width = track->m_Width;
last_width = track->GetWidth();
}
}

12
pcbnew/export_vrml.cpp
View File

@ -825,17 +825,17 @@ static void export_vrml_via( BOARD* pcb, SEGVIA* via ) //{{{
double x, y, r, hole;
int top_layer, bottom_layer;
r = via->m_Width / 2;
r = via->GetWidth() / 2;
hole = via->GetDrillValue() / 2;
x = via->m_Start.x;
y = via->m_Start.y;
x = via->GetStart().x;
y = via->GetStart().y;
via->ReturnLayerPair( &top_layer, &bottom_layer );
// Export the via padstack
export_round_padstack( pcb, x, y, r, bottom_layer, top_layer );
// Drill a hole
export_vrml_hole( via_triangles[via->m_Shape], top_layer, bottom_layer, x, y, hole );
export_vrml_hole( via_triangles[via->GetShape()], top_layer, bottom_layer, x, y, hole );
}
@ -846,8 +846,8 @@ static void export_vrml_tracks( BOARD* pcb ) //{{{
if( track->Type() == PCB_VIA_T )
export_vrml_via( pcb, (SEGVIA*) track );
else
export_vrml_line( track->GetLayer(), track->m_Start.x, track->m_Start.y,
track->m_End.x, track->m_End.y, track->m_Width, 4 );
export_vrml_line( track->GetLayer(), track->GetStart().x, track->GetStart().y,
track->GetEnd().x, track->GetEnd().y, track->GetWidth(), 4 );
}
}

2
pcbnew/gendrill_Excellon_writer.cpp
View File

@ -480,7 +480,7 @@ void EXCELLON_WRITER::BuildHolesList( int aFirstLayer,
new_hole.m_Hole_Size.x = new_hole.m_Hole_Size.y = new_hole.m_Hole_Diameter;
new_hole.m_Hole_Shape = 0; // hole shape: round
new_hole.m_Hole_Pos = via->m_Start;
new_hole.m_Hole_Pos = via->GetStart();
via->ReturnLayerPair( &new_hole.m_Hole_Top_Layer, &new_hole.m_Hole_Bottom_Layer );
// ReturnLayerPair return params with m_Hole_Bottom_Layer < m_Hole_Top_Layer

42
pcbnew/magnetic_tracks_functions.cpp
View File

@ -74,19 +74,19 @@ static bool Join( wxPoint* aIntersectPoint, wxPoint a0, wxPoint a1, wxPoint b0,
*/
bool Project( wxPoint* aNearPos, wxPoint on_grid, const TRACK* track )
{
if( track->m_Start == track->m_End )
if( track->GetStart ()== track->GetEnd() )
return false;
wxPoint vec = track->m_End - track->m_Start;
wxPoint vec = track->GetEnd() - track->GetStart();
double t = double( on_grid.x - track->m_Start.x ) * vec.x +
double( on_grid.y - track->m_Start.y ) * vec.y;
double t = double( on_grid.x - track->GetStart().x ) * vec.x +
double( on_grid.y - track->GetStart().y ) * vec.y;
t /= (double) vec.x * vec.x + (double) vec.y * vec.y;
t = std::min( std::max( t, 0.0 ), 1.0 );
aNearPos->x = KiROUND( track->m_Start.x + t * vec.x );
aNearPos->y = KiROUND( track->m_Start.y + t * vec.y );
aNearPos->x = KiROUND( track->GetStart().x + t * vec.x );
aNearPos->y = KiROUND( track->GetStart().y + t * vec.y );
return true;
}
@ -183,7 +183,7 @@ bool Magnetize( PCB_EDIT_FRAME* frame, int aCurrentTool, wxSize aGridSize,
{
if( !doCheckNet || !currTrack || currTrack->GetNet() == via->GetNet() )
{
*curpos = via->m_Start;
*curpos = via->GetStart();
// D(printf("via hit\n");)
return true;
}
@ -210,10 +210,10 @@ bool Magnetize( PCB_EDIT_FRAME* frame, int aCurrentTool, wxSize aGridSize,
* In two segment mode, ignore the final segment if it's inside a grid square.
*/
if( !amMovingVia && currTrack && g_TwoSegmentTrackBuild && currTrack->Back()
&& currTrack->m_Start.x - aGridSize.x < currTrack->m_End.x
&& currTrack->m_Start.x + aGridSize.x > currTrack->m_End.x
&& currTrack->m_Start.y - aGridSize.y < currTrack->m_End.y
&& currTrack->m_Start.y + aGridSize.y > currTrack->m_End.y )
&& currTrack->GetStart().x - aGridSize.x < currTrack->GetEnd().x
&& currTrack->GetStart().x + aGridSize.x > currTrack->GetEnd().x
&& currTrack->GetStart().y - aGridSize.y < currTrack->GetEnd().y
&& currTrack->GetStart().y + aGridSize.y > currTrack->GetEnd().y )
{
currTrack = currTrack->Back();
}
@ -239,7 +239,7 @@ bool Magnetize( PCB_EDIT_FRAME* frame, int aCurrentTool, wxSize aGridSize,
// D(printf( "have track prospect\n");)
if( Join( curpos, track->m_Start, track->m_End, currTrack->m_Start, currTrack->m_End ) )
if( Join( curpos, track->GetStart(), track->GetEnd(), currTrack->GetStart(), currTrack->GetEnd() ) )
{
// D(printf( "join currTrack->Type()=%d\n", currTrack->Type() );)
return true;
@ -251,27 +251,27 @@ bool Magnetize( PCB_EDIT_FRAME* frame, int aCurrentTool, wxSize aGridSize,
// a new track and that new track is parallel to the track the
// mouse is on. Find the nearest end point of the track under mouse
// to the mouse and return that.
double distStart = hypot( double( curpos->x - track->m_Start.x ),
double( curpos->y - track->m_Start.y ));
double distStart = hypot( double( curpos->x - track->GetStart().x ),
double( curpos->y - track->GetStart().y ));
double distEnd = hypot( double( curpos->x - track->m_End.x ),
double( curpos->y - track->m_End.y ));
double distEnd = hypot( double( curpos->x - track->GetEnd().x ),
double( curpos->y - track->GetEnd().y ));
// if track not via, or if its a via dragging but not with its adjacent track
if( currTrack->Type() != PCB_VIA_T
|| ( currTrack->m_Start != track->m_Start && currTrack->m_Start != track->m_End ))
|| ( currTrack->GetStart() != track->GetStart() && currTrack->GetStart() != track->GetEnd() ))
{
if( distStart <= currTrack->m_Width/2 )
if( distStart <= currTrack->GetWidth()/2 )
{
// D(printf("nearest end is start\n");)
*curpos = track->m_Start;
*curpos = track->GetStart();
return true;
}
if( distEnd <= currTrack->m_Width/2 )
if( distEnd <= currTrack->GetWidth()/2 )
{
// D(printf("nearest end is end\n");)
*curpos = track->m_End;
*curpos = track->GetEnd();
return true;
}

8
pcbnew/move-drag_pads.cpp
View File

@ -139,10 +139,10 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* aPad, wxDC* DC )
// Set the old state
if( g_DragSegmentList[ii].m_Pad_Start )
Track->m_Start = Pad_OldPos;
Track->SetStart( Pad_OldPos );
if( g_DragSegmentList[ii].m_Pad_End )
Track->m_End = Pad_OldPos;
Track->SetEnd( Pad_OldPos );
picker.SetItem( Track );
pickList.PushItem( picker );
@ -172,10 +172,10 @@ void PCB_BASE_FRAME::PlacePad( D_PAD* aPad, wxDC* DC )
// Set the new state
if( g_DragSegmentList[ii].m_Pad_Start )
Track->m_Start = aPad->GetPosition();
Track->SetStart( aPad->GetPosition() );
if( g_DragSegmentList[ii].m_Pad_End )
Track->m_End = aPad->GetPosition();
Track->SetEnd( aPad->GetPosition() );
Track->SetState( IN_EDIT, OFF );

106
pcbnew/move_or_drag_track.cpp
View File

@ -134,13 +134,13 @@ static void Show_MoveNode( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aPo
track->Draw( aPanel, aDC, draw_mode );
if( track->GetFlags() & STARTPOINT )
track->m_Start += moveVector;
track->SetStart( track->GetStart() + moveVector );
if( track->GetFlags() & ENDPOINT )
track->m_End += moveVector;
track->SetEnd( track->GetEnd() + moveVector );
if( track->Type() == PCB_VIA_T )
track->m_End = track->m_Start;
track->SetEnd( track->GetStart() );
track->Draw( aPanel, aDC, draw_mode );
}
@ -265,10 +265,10 @@ static void Show_Drag_Track_Segment_With_Cte_Slope( EDA_DRAW_PANEL* aPanel, wxDC
dy = Pos.y - s_LastPos.y;
//move the line by dx and dy
tx1 = (double) ( Track->m_Start.x + dx );
ty1 = (double) ( Track->m_Start.y + dy );
tx2 = (double) ( Track->m_End.x + dx );
ty2 = (double) ( Track->m_End.y + dy );
tx1 = (double) ( Track->GetStart().x + dx );
ty1 = (double) ( Track->GetStart().y + dy );
tx2 = (double) ( Track->GetEnd().x + dx );
ty2 = (double) ( Track->GetEnd().y + dy );
// recalculate the segments new parameters and intersection points
// only the intercept will change, segment slopes does not change
@ -393,25 +393,23 @@ static void Show_Drag_Track_Segment_With_Cte_Slope( EDA_DRAW_PANEL* aPanel, wxDC
if( update )
{
s_LastPos = Pos;
Track->m_Start.x = KiROUND( xi1 );
Track->m_Start.y = KiROUND( yi1 );
Track->m_End.x = KiROUND( xi2 );
Track->m_End.y = KiROUND( yi2 );
Track->SetStart( wxPoint( KiROUND( xi1 ), KiROUND( yi1 ) ) );
Track->SetEnd( wxPoint( KiROUND( xi2 ), KiROUND( yi2 ) ) );
if( tSegmentToEnd )
{
if( tSegmentToEnd->GetFlags() & STARTPOINT )
tSegmentToEnd->m_Start = Track->m_End;
tSegmentToEnd->SetStart( Track->GetEnd() );
else
tSegmentToEnd->m_End = Track->m_End;
tSegmentToEnd->SetEnd( Track->GetEnd() );
}
if( tSegmentToStart )
{
if( tSegmentToStart->GetFlags() & STARTPOINT )
tSegmentToStart->m_Start = Track->m_Start;
tSegmentToStart->SetStart( Track->GetStart() );
else
tSegmentToStart->m_End = Track->m_Start;
tSegmentToStart->SetEnd( Track->GetStart() );
}
}
@ -489,25 +487,25 @@ bool InitialiseDragParameters()
{
if( tSegmentToStart->GetFlags() & ENDPOINT )
{
tx1 = (double) tSegmentToStart->m_Start.x;
ty1 = (double) tSegmentToStart->m_Start.y;
tx2 = (double) tSegmentToStart->m_End.x;
ty2 = (double) tSegmentToStart->m_End.y;
tx1 = (double) tSegmentToStart->GetStart().x;
ty1 = (double) tSegmentToStart->GetStart().y;
tx2 = (double) tSegmentToStart->GetEnd().x;
ty2 = (double) tSegmentToStart->GetEnd().y;
}
else
{
tx1 = (double) tSegmentToStart->m_End.x;
ty1 = (double) tSegmentToStart->m_End.y;
tx2 = (double) tSegmentToStart->m_Start.x;
ty2 = (double) tSegmentToStart->m_Start.y;
tx1 = (double) tSegmentToStart->GetEnd().x;
ty1 = (double) tSegmentToStart->GetEnd().y;
tx2 = (double) tSegmentToStart->GetStart().x;
ty2 = (double) tSegmentToStart->GetStart().y;
}
}
else // move the start point on a line starting at Track->m_Start, and perpendicular to Track
else // move the start point on a line starting at Track->GetStart(), and perpendicular to Track
{
tx1 = (double) Track->m_Start.x;
ty1 = (double) Track->m_Start.y;
tx2 = (double) Track->m_End.x;
ty2 = (double) Track->m_End.y;
tx1 = (double) Track->GetStart().x;
ty1 = (double) Track->GetStart().y;
tx2 = (double) Track->GetEnd().x;
ty2 = (double) Track->GetEnd().y;
RotatePoint( &tx2, &ty2, tx1, ty1, 900 );
}
@ -532,25 +530,25 @@ bool InitialiseDragParameters()
//check if second line is vertical
if( tSegmentToEnd->GetFlags() & STARTPOINT )
{
tx1 = (double) tSegmentToEnd->m_Start.x;
ty1 = (double) tSegmentToEnd->m_Start.y;
tx2 = (double) tSegmentToEnd->m_End.x;
ty2 = (double) tSegmentToEnd->m_End.y;
tx1 = (double) tSegmentToEnd->GetStart().x;
ty1 = (double) tSegmentToEnd->GetStart().y;
tx2 = (double) tSegmentToEnd->GetEnd().x;
ty2 = (double) tSegmentToEnd->GetEnd().y;
}
else
{
tx1 = (double) tSegmentToEnd->m_End.x;
ty1 = (double) tSegmentToEnd->m_End.y;
tx2 = (double) tSegmentToEnd->m_Start.x;
ty2 = (double) tSegmentToEnd->m_Start.y;
tx1 = (double) tSegmentToEnd->GetEnd().x;
ty1 = (double) tSegmentToEnd->GetEnd().y;
tx2 = (double) tSegmentToEnd->GetStart().x;
ty2 = (double) tSegmentToEnd->GetStart().y;
}
}
else // move the start point on a line starting at Track->m_End, and perpendicular to Track
else // move the start point on a line starting at Track->GetEnd(), and perpendicular to Track
{
tx1 = (double) Track->m_End.x;
ty1 = (double) Track->m_End.y;
tx2 = (double) Track->m_Start.x;
ty2 = (double) Track->m_Start.y;
tx1 = (double) Track->GetEnd().x;
ty1 = (double) Track->GetEnd().y;
tx2 = (double) Track->GetStart().x;
ty2 = (double) Track->GetStart().y;
RotatePoint( &tx2, &ty2, tx1, ty1, -900 );
}
@ -570,10 +568,10 @@ bool InitialiseDragParameters()
}
// Init parameters for the moved segment
tx1 = (double) Track->m_Start.x;
ty1 = (double) Track->m_Start.y;
tx2 = (double) Track->m_End.x;
ty2 = (double) Track->m_End.y;
tx1 = (double) Track->GetStart().x;
ty1 = (double) Track->GetStart().y;
tx2 = (double) Track->GetEnd().x;
ty2 = (double) Track->GetEnd().y;
if( tx2 != tx1 )
{
@ -630,12 +628,12 @@ void PCB_EDIT_FRAME::StartMoveOneNodeOrSegment( TRACK* aTrack, wxDC* aDC, int aC
if( aCommand != ID_POPUP_PCB_MOVE_TRACK_SEGMENT )
{
Collect_TrackSegmentsToDrag( GetBoard(), aTrack->m_Start,
Collect_TrackSegmentsToDrag( GetBoard(), aTrack->GetStart(),
aTrack->ReturnMaskLayer(),
aTrack->GetNet(), aTrack->GetWidth() / 2 );
}
PosInit = aTrack->m_Start;
PosInit = aTrack->GetStart();
}
else
{
@ -650,17 +648,17 @@ void PCB_EDIT_FRAME::StartMoveOneNodeOrSegment( TRACK* aTrack, wxDC* aDC, int aC
break;
case ID_POPUP_PCB_DRAG_TRACK_SEGMENT: // drag a segment
pos = aTrack->m_Start;
pos = aTrack->GetStart();
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->ReturnMaskLayer(),
aTrack->GetNet(), aTrack->GetWidth() / 2 );
pos = aTrack->m_End;
pos = aTrack->GetEnd();
aTrack->SetFlags( IS_DRAGGED | ENDPOINT | STARTPOINT );
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->ReturnMaskLayer(),
aTrack->GetNet(), aTrack->GetWidth() / 2 );
break;
case ID_POPUP_PCB_MOVE_TRACK_NODE: // Drag via or move node
pos = (diag & STARTPOINT) ? aTrack->m_Start : aTrack->m_End;
pos = (diag & STARTPOINT) ? aTrack->GetStart() : aTrack->GetEnd();
Collect_TrackSegmentsToDrag( GetBoard(), pos, aTrack->ReturnMaskLayer(),
aTrack->GetNet(), aTrack->GetWidth() / 2 );
PosInit = pos;
@ -770,7 +768,7 @@ void PCB_EDIT_FRAME::Start_DragTrackSegmentAndKeepSlope( TRACK* track, wxDC* DC
{
int flag = STARTPOINT;
if( track->m_Start != TrackToStartPoint->m_Start )
if( track->GetStart() != TrackToStartPoint->GetStart() )
flag = ENDPOINT;
AddSegmentToDragList( flag, TrackToStartPoint );
@ -781,7 +779,7 @@ void PCB_EDIT_FRAME::Start_DragTrackSegmentAndKeepSlope( TRACK* track, wxDC* DC
{
int flag = STARTPOINT;
if( track->m_End != TrackToEndPoint->m_Start )
if( track->GetEnd() != TrackToEndPoint->GetStart() )
flag = ENDPOINT;
AddSegmentToDragList( flag, TrackToEndPoint );
@ -868,14 +866,14 @@ bool PCB_EDIT_FRAME::PlaceDraggedOrMovedTrackSegment( TRACK* Track, wxDC* DC )
* (only pad connection must be tested, track connection will be
* tested by TestNetConnection() ) */
int layerMask = GetLayerMask( Track->GetLayer() );
Track->start = GetBoard()->GetPadFast( Track->m_Start, layerMask );
Track->start = GetBoard()->GetPadFast( Track->GetStart(), layerMask );
if( Track->start )
Track->SetState( BEGIN_ONPAD, ON );
else
Track->SetState( BEGIN_ONPAD, OFF );
Track->end = GetBoard()->GetPadFast( Track->m_End, layerMask );
Track->end = GetBoard()->GetPadFast( Track->GetEnd(), layerMask );
if( Track->end )
Track->SetState( END_ONPAD, ON );

16
pcbnew/plot_board_layers.cpp
View File

@ -137,7 +137,7 @@ void PlotSilkScreen( BOARD *aBoard, PLOTTER* aPlotter, long aLayerMask,
if( ( ( 1 << seg->GetLayer() ) & aLayerMask ) == 0 )
continue;
aPlotter->ThickSegment( seg->m_Start, seg->m_End, seg->m_Width,
aPlotter->ThickSegment( seg->GetStart(), seg->GetEnd(), seg->GetWidth(),
itemplotter.GetMode() );
}
}
@ -392,17 +392,17 @@ void PlotStandardLayer( BOARD *aBoard, PLOTTER* aPlotter,
if( aLayerMask & ALL_CU_LAYERS )
width_adj = itemplotter.getFineWidthAdj();
int diameter = Via->m_Width + 2 * via_margin + width_adj;
int diameter = Via->GetWidth() + 2 * via_margin + width_adj;
// Don't draw a null size item :
if( diameter <= 0 )
continue;
EDA_COLOR_T color = aBoard->GetVisibleElementColor(VIAS_VISIBLE + Via->m_Shape);
EDA_COLOR_T color = aBoard->GetVisibleElementColor(VIAS_VISIBLE + Via->GetShape());
// Set plot color (change WHITE to LIGHTGRAY because
// the white items are not seen on a white paper or screen
aPlotter->SetColor( color != WHITE ? color : LIGHTGRAY);
aPlotter->FlashPadCircle( Via->m_Start, diameter, plotMode );
aPlotter->FlashPadCircle( Via->GetStart(), diameter, plotMode );
}
// Plot tracks (not vias) :
@ -414,9 +414,9 @@ void PlotStandardLayer( BOARD *aBoard, PLOTTER* aPlotter,
if( (GetLayerMask( track->GetLayer() ) & aLayerMask) == 0 )
continue;
int width = track->m_Width + itemplotter.getFineWidthAdj();
int width = track->GetWidth() + itemplotter.getFineWidthAdj();
aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
aPlotter->ThickSegment( track->m_Start, track->m_End, width, plotMode );
aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode );
}
// Plot zones (outdated, for old boards compatibility):
@ -425,9 +425,9 @@ void PlotStandardLayer( BOARD *aBoard, PLOTTER* aPlotter,
if( (GetLayerMask( track->GetLayer() ) & aLayerMask) == 0 )
continue;
int width = track->m_Width + itemplotter.getFineWidthAdj();
int width = track->GetWidth() + itemplotter.getFineWidthAdj();
aPlotter->SetColor( itemplotter.getColor( track->GetLayer() ) );
aPlotter->ThickSegment( track->m_Start, track->m_End, width, plotMode );
aPlotter->ThickSegment( track->GetStart(), track->GetEnd(), width, plotMode );
}
// Plot filled ares

4
pcbnew/plot_brditems_plotter.cpp
View File

@ -711,8 +711,8 @@ void BRDITEMS_PLOTTER::PlotDrillMarks()
continue;
plotOneDrillMark(PAD_CIRCLE,
pts->m_Start, wxSize( pts->GetDrillValue(), 0 ),
wxSize( pts->m_Width, 0 ), 0, small_drill );
pts->GetStart(), wxSize( pts->GetDrillValue(), 0 ),
wxSize( pts->GetWidth(), 0 ), 0, small_drill );
}
for( MODULE *Module = m_board->m_Modules; Module != NULL; Module = Module->Next() )

10
pcbnew/print_board_functions.cpp
View File

@ -231,12 +231,12 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
if( pt_trace->Type() == PCB_VIA_T ) // VIA encountered.
{
int radius = pt_trace->m_Width >> 1;
EDA_COLOR_T color = g_ColorsSettings.GetItemColor( VIAS_VISIBLE + pt_trace->m_Shape );
int radius = pt_trace->GetWidth() >> 1;
EDA_COLOR_T color = g_ColorsSettings.GetItemColor( VIAS_VISIBLE + pt_trace->GetShape() );
GRSetDrawMode( aDC, drawmode );
GRFilledCircle( m_canvas->GetClipBox(), aDC,
pt_trace->m_Start.x,
pt_trace->m_Start.y,
pt_trace->GetStart().x,
pt_trace->GetStart().y,
radius,
0, color, color );
}
@ -305,7 +305,7 @@ void PCB_EDIT_FRAME::PrintPage( wxDC* aDC,
diameter = pt_trace->GetDrillValue();
GRFilledCircle( m_canvas->GetClipBox(), aDC,
pt_trace->m_Start.x, pt_trace->m_Start.y,
pt_trace->GetStart().x, pt_trace->GetStart().y,
diameter/2,
0, color, color );
}

8
pcbnew/ratsnest.cpp
View File

@ -847,10 +847,10 @@ void PCB_BASE_FRAME::BuildAirWiresTargetsList( BOARD_CONNECTED_ITEM* aItemRef,
if( !track->GetSubNet() || (track->GetSubNet() != subnet) )
{
if( aPosition != track->m_Start )
s_TargetsLocations.push_back( track->m_Start );
if( aPosition != track->m_End && track->m_Start != track->m_End )
s_TargetsLocations.push_back( track->m_End );
if( aPosition != track->GetStart() )
s_TargetsLocations.push_back( track->GetStart() );
if( aPosition != track->GetEnd() && track->GetStart() != track->GetEnd() )
s_TargetsLocations.push_back( track->GetEnd() );
}
}

12
pcbnew/specctra_export.cpp
View File

@ -761,7 +761,7 @@ PADSTACK* SPECCTRA_DB::makeVia( const SEGVIA* aVia )
if( topLayer > botLayer )
EXCHG( topLayer, botLayer );
return makeVia( aVia->m_Width, aVia->GetDrillValue(), topLayer, botLayer );
return makeVia( aVia->GetWidth(), aVia->GetDrillValue(), topLayer, botLayer );
}
@ -1493,12 +1493,12 @@ void SPECCTRA_DB::FromBOARD( BOARD* aBoard ) throw( IO_ERROR )
continue;
if( old_netcode != netcode
|| old_width != track->m_Width
|| old_width != track->GetWidth()
|| old_layer != track->GetLayer()
|| (path && path->points.back() != mapPt(track->m_Start) )
|| (path && path->points.back() != mapPt(track->GetStart()) )
)
{
old_width = track->m_Width;
old_width = track->GetWidth();
old_layer = track->GetLayer();
if( old_netcode != netcode )
@ -1524,10 +1524,10 @@ void SPECCTRA_DB::FromBOARD( BOARD* aBoard ) throw( IO_ERROR )
path->layer_id = layerIds[pcbLayer];
path->aperture_width = scale( old_width );
path->AppendPoint( mapPt( track->m_Start ) );
path->AppendPoint( mapPt( track->GetStart() ) );
}
path->AppendPoint( mapPt( track->m_End ) );
path->AppendPoint( mapPt( track->GetEnd() ) );
}
}

20
pcbnew/specctra_import.cpp
View File

@ -235,10 +235,10 @@ TRACK* SPECCTRA_DB::makeTRACK( PATH* aPath, int aPointIndex, int aNetcode ) thro
TRACK* track = new TRACK( sessionBoard );
track->m_Start = mapPt( aPath->points[aPointIndex+0], routeResolution );
track->m_End = mapPt( aPath->points[aPointIndex+1], routeResolution );
track->SetStart( mapPt( aPath->points[aPointIndex+0], routeResolution ) );
track->SetEnd( mapPt( aPath->points[aPointIndex+1], routeResolution ) );
track->SetLayer( pcbLayer2kicad[layerNdx] );
track->m_Width = scale( aPath->aperture_width, routeResolution );
track->SetWidth( scale( aPath->aperture_width, routeResolution ) );
track->SetNet( aNetcode );
return track;
@ -295,8 +295,8 @@ SEGVIA* SPECCTRA_DB::makeVIA( PADSTACK* aPadstack, const POINT& aPoint, int aNet
via = new SEGVIA( sessionBoard );
via->SetPosition( mapPt( aPoint, routeResolution ) );
via->SetDrill( drillDiam );
via->m_Shape = VIA_THROUGH;
via->m_Width = viaDiam;
via->SetShape( VIA_THROUGH );
via->SetWidth( viaDiam );
via->SetLayerPair( LAYER_N_FRONT, LAYER_N_BACK );
}
else if( shapeCount == copperLayerCount )
@ -313,8 +313,8 @@ SEGVIA* SPECCTRA_DB::makeVIA( PADSTACK* aPadstack, const POINT& aPoint, int aNet
via = new SEGVIA( sessionBoard );
via->SetPosition( mapPt( aPoint, routeResolution ) );
via->SetDrill( drillDiam );
via->m_Shape = VIA_THROUGH;
via->m_Width = viaDiam;
via->SetShape( VIA_THROUGH );
via->SetWidth( viaDiam );
via->SetLayerPair( LAYER_N_FRONT, LAYER_N_BACK );
}
else // VIA_MICROVIA or VIA_BLIND_BURIED
@ -357,11 +357,11 @@ SEGVIA* SPECCTRA_DB::makeVIA( PADSTACK* aPadstack, const POINT& aPoint, int aNet
if( (topLayerNdx==0 && botLayerNdx==1)
|| (topLayerNdx==copperLayerCount-2 && botLayerNdx==copperLayerCount-1))
via->m_Shape = VIA_MICROVIA;
via->SetShape( VIA_MICROVIA );
else
via->m_Shape = VIA_BLIND_BURIED;
via->SetShape( VIA_BLIND_BURIED );
via->m_Width = viaDiam;
via->SetWidth( viaDiam );
topLayerNdx = pcbLayer2kicad[topLayerNdx];
botLayerNdx = pcbLayer2kicad[botLayerNdx];

6
pcbnew/tr_modif.cpp
View File

@ -126,8 +126,8 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC* aDC,
if( ( StartTrack == NULL ) || ( EndTrack == NULL ) )
return 0;
start = StartTrack->m_Start;
end = EndTrack->m_End;
start = StartTrack->GetStart();
end = EndTrack->GetEnd();
// The start and end points cannot be the same.
if( start == end )
@ -248,7 +248,7 @@ int PCB_EDIT_FRAME::EraseRedundantTrack( wxDC* aDC,
if( pt_segm->GetState( BUSY ) == 0 )
break;
if( pt_segm->m_Start == start || pt_segm->m_End == start )
if( pt_segm->GetStart() == start || pt_segm->GetEnd() == start )
{
// Marked track can be erased.
TRACK* NextS;

4
pcbnew/zones_polygons_insulated_copper_islands.cpp
View File

@ -74,10 +74,10 @@ void ZONE_CONTAINER::Test_For_Copper_Island_And_Remove_Insulated_Islands( BOARD
if( track->GetNet() != GetNet() )
continue;
listPointsCandidates.push_back( track->m_Start );
listPointsCandidates.push_back( track->GetStart() );
if( track->Type() != PCB_VIA_T )
listPointsCandidates.push_back( track->m_End );
listPointsCandidates.push_back( track->GetEnd() );
}
// test if a point is inside

6
pcbnew/zones_polygons_test_connections.cpp
View File

@ -169,12 +169,12 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
}
else if( item->Type() == PCB_VIA_T )
{
pos1 = pos2 = ( (SEGVIA*) item )->m_Start;
pos1 = pos2 = ( (SEGVIA*) item )->GetStart();
}
else if( item->Type() == PCB_TRACE_T )
{
pos1 = ( (TRACK*) item )->m_Start;
pos2 = ( (TRACK*) item )->m_End;
pos1 = ( (TRACK*) item )->GetStart();
pos2 = ( (TRACK*) item )->GetEnd();
}
else
{