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

All: fix a minor bur annoying issue: incorrect cursor shape after a block command (mainly when a tool is selected)

This commit is contained in:
jean-pierre charras 2011-03-09 21:09:11 +01:00
parent dc24d6fcb2
commit 155a9dbe19
15 changed files with 267 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/block_commande.cpp
View File

@ -305,5 +305,5 @@ void AbortBlockCurrentCommand( EDA_DRAW_PANEL* Panel, wxDC* DC )
screen->m_BlockLocate.m_Command = BLOCK_IDLE; screen->m_BlockLocate.m_Command = BLOCK_IDLE;
Panel->GetParent()->DisplayToolMsg( wxEmptyString ); Panel->GetParent()->DisplayToolMsg( wxEmptyString );
Panel->SetCursor( Panel->GetDefaultCursor() ); Panel->SetCursor( Panel->GetCurrentCursor() );
} }

2
common/drawframe.cpp
View File

@ -440,7 +440,7 @@ void EDA_DRAW_FRAME::SetToolID( int aId, int aCursor, const wxString& aToolMsg )
// Change DrawPanel cursor if requested. // Change DrawPanel cursor if requested.
if( DrawPanel && aCursor >= 0 ) if( DrawPanel && aCursor >= 0 )
DrawPanel->SetCursor( aCursor ); DrawPanel->SetCurrentCursor( aCursor );
DisplayToolMsg( aToolMsg ); DisplayToolMsg( aToolMsg );

25
common/drawpanel.cpp
View File

@ -1,6 +1,6 @@
/*****************/ /**
/* drawpanel.cpp */ * @file drawpanel.cpp
/*****************/ */
#include "fctsys.h" #include "fctsys.h"
#include "appl_wxstruct.h" #include "appl_wxstruct.h"
@ -84,10 +84,10 @@ EDA_DRAW_PANEL::EDA_DRAW_PANEL( EDA_DRAW_FRAME* parent, int id,
m_Block_Enable = false; m_Block_Enable = false;
#ifdef __WXMAC__ #ifdef __WXMAC__
m_defaultCursor = m_cursor = wxCURSOR_CROSS; m_defaultCursor = m_currentCursor = wxCURSOR_CROSS;
m_showCrossHair = false; m_showCrossHair = false;
#else #else
m_defaultCursor = m_cursor = wxCURSOR_ARROW; m_defaultCursor = m_currentCursor = wxCURSOR_ARROW;
m_showCrossHair = true; m_showCrossHair = true;
#endif #endif
@ -1017,7 +1017,7 @@ void EDA_DRAW_PANEL::OnMouseEvent( wxMouseEvent& event )
else else
{ {
m_AutoPAN_Request = true; m_AutoPAN_Request = true;
SetCursor( m_cursor = wxCURSOR_SIZING ); SetCursor( wxCURSOR_SIZING );
} }
} }
} }
@ -1045,20 +1045,19 @@ void EDA_DRAW_PANEL::OnMouseEvent( wxMouseEvent& event )
m_AutoPAN_Request = false; m_AutoPAN_Request = false;
} }
SetCursor( m_cursor = m_defaultCursor ); SetCursor( m_currentCursor );
} }
else if( screen->m_BlockLocate.m_State == STATE_BLOCK_END ) else if( screen->m_BlockLocate.m_State == STATE_BLOCK_END )
{ {
m_AutoPAN_Request = false; m_AutoPAN_Request = false;
GetParent()->HandleBlockEnd( &DC ); GetParent()->HandleBlockEnd( &DC );
SetCursor( m_cursor = m_defaultCursor ); SetCursor( m_currentCursor );
if( screen->m_BlockLocate.m_State == STATE_BLOCK_MOVE ) if( screen->m_BlockLocate.m_State == STATE_BLOCK_MOVE )
{ {
m_AutoPAN_Request = true; m_AutoPAN_Request = true;
SetCursor( wxCURSOR_HAND ); SetCursor( wxCURSOR_HAND );
} }
} }
} }
} }
@ -1106,9 +1105,9 @@ void EDA_DRAW_PANEL::OnKeyEvent( wxKeyEvent& event )
m_AbortRequest = true; m_AbortRequest = true;
if( IsMouseCaptured() ) if( IsMouseCaptured() )
EndMouseCapture( -1, m_defaultCursor ); EndMouseCapture( );
else else
EndMouseCapture( ID_NO_TOOL_SELECTED, m_cursor, wxEmptyString ); EndMouseCapture( ID_NO_TOOL_SELECTED, m_defaultCursor, wxEmptyString );
break; break;
} }

4
eeschema/block.cpp
View File

@ -183,7 +183,7 @@ void SCH_EDIT_FRAME::HandleBlockPlace( wxDC* DC )
} }
DrawPanel->SetMouseCapture( NULL, NULL ); DrawPanel->SetMouseCapture( NULL, NULL );
SetToolID( GetToolId(), DrawPanel->GetDefaultCursor(), wxEmptyString ); SetToolID( GetToolId(), DrawPanel->GetCurrentCursor(), wxEmptyString );
DrawPanel->Refresh(); DrawPanel->Refresh();
} }
@ -317,7 +317,7 @@ bool SCH_EDIT_FRAME::HandleBlockEnd( wxDC* DC )
block->m_Command = BLOCK_IDLE; block->m_Command = BLOCK_IDLE;
GetScreen()->SetCurItem( NULL ); GetScreen()->SetCurItem( NULL );
DrawPanel->SetMouseCapture( NULL, NULL ); DrawPanel->SetMouseCapture( NULL, NULL );
SetToolID( GetToolId(), DrawPanel->GetDefaultCursor(), wxEmptyString ); SetToolID( GetToolId(), DrawPanel->GetCurrentCursor(), wxEmptyString );
} }
if( zoom_command ) if( zoom_command )

6
gerbview/block.cpp
View File

@ -136,7 +136,8 @@ void WinEDA_GerberFrame::HandleBlockPlace( wxDC* DC )
break; break;
} }
DrawPanel->SetMouseCapture( NULL, NULL ); DrawPanel->EndMouseCapture( );
DrawPanel->SetCursor( DrawPanel->GetCurrentCursor() );
GetScreen()->SetModify(); GetScreen()->SetModify();
GetScreen()->ClearBlockCommand(); GetScreen()->ClearBlockCommand();
@ -211,7 +212,8 @@ bool WinEDA_GerberFrame::HandleBlockEnd( wxDC* DC )
if( ! nextcmd ) if( ! nextcmd )
{ {
GetScreen()->ClearBlockCommand(); GetScreen()->ClearBlockCommand();
DrawPanel->SetMouseCapture( NULL, NULL ); DrawPanel->EndMouseCapture( );
DrawPanel->SetCursor( DrawPanel->GetCurrentCursor() );
DisplayToolMsg( wxEmptyString ); DisplayToolMsg( wxEmptyString );
} }

23
include/class_drawpanel.h
View File

@ -30,7 +30,7 @@ typedef void ( *END_MOUSE_CAPTURE_CALLBACK )( EDA_DRAW_PANEL* aPanel, wxDC* aDC
class EDA_DRAW_PANEL : public wxScrolledWindow class EDA_DRAW_PANEL : public wxScrolledWindow
{ {
private: private:
int m_cursor; ///< Current mouse cursor shape id. int m_currentCursor; ///< Current mouse cursor shape id.
int m_defaultCursor; ///< The default mouse cursor shape id. int m_defaultCursor; ///< The default mouse cursor shape id.
bool m_showCrossHair; ///< Indicate if cross hair is to be shown. bool m_showCrossHair; ///< Indicate if cross hair is to be shown.
int m_cursorLevel; ///< Index for cursor redraw in XOR mode. int m_cursorLevel; ///< Index for cursor redraw in XOR mode.
@ -82,6 +82,7 @@ public:
void OnPaint( wxPaintEvent& event ); void OnPaint( wxPaintEvent& event );
/** /**
* Function DrawBackGround * Function DrawBackGround
* @param DC = current Device Context * @param DC = current Device Context
@ -300,8 +301,28 @@ public:
inline bool IsMouseCaptured() const { return m_mouseCaptureCallback != NULL; } inline bool IsMouseCaptured() const { return m_mouseCaptureCallback != NULL; }
/**
* Function SetCurrentCursor
* Set the current cursor shape for drawpanel
*/
void SetCurrentCursor( int aCursor )
{
m_currentCursor = aCursor;
SetCursor( m_currentCursor );
}
/**
* Function GetDefaultCursor
* return the default cursor shape
*/
int GetDefaultCursor() const { return m_defaultCursor; } int GetDefaultCursor() const { return m_defaultCursor; }
/**
* Function GetCurrentCursor
* return the current cursor shape, depending on the current selected tool
*/
int GetCurrentCursor() const { return m_currentCursor; }
DECLARE_EVENT_TABLE() DECLARE_EVENT_TABLE()
}; };

1
pcbnew/ar_protos.h
View File

@ -59,7 +59,6 @@ int GetApxDist( int, int, int, int );
int CalcDist( int, int, int ,int ); int CalcDist( int, int, int ,int );
/* BOARD.CPP */ /* BOARD.CPP */
bool ComputeMatriceSize( BOARD * aPcb, int aGridRouting );
int Build_Work( BOARD * Pcb ); int Build_Work( BOARD * Pcb );
void PlaceCells( BOARD * Pcb, int net_code, int flag = 0 ); void PlaceCells( BOARD * Pcb, int net_code, int flag = 0 );

116
pcbnew/autoplac.cpp
View File

@ -44,7 +44,7 @@ static const float OrientPenality[11] =
static wxPoint CurrPosition; // Current position of the current module static wxPoint CurrPosition; // Current position of the current module
// placement // placement
static bool AutoPlaceShowAll = TRUE; static bool AutoPlaceShowAll = true;
float MinCout; float MinCout;
@ -75,13 +75,13 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
int NbModules = 0; int NbModules = 0;
int NbTotalModules = 0; int NbTotalModules = 0;
float Pas; float Pas;
int lay_tmp_TOP, lay_tmp_BOTTOM, OldPasRoute; int lay_tmp_TOP, lay_tmp_BOTTOM;
if( GetBoard()->m_Modules == NULL ) if( GetBoard()->m_Modules == NULL )
return; return;
DrawPanel->m_AbortRequest = FALSE; DrawPanel->m_AbortRequest = false;
DrawPanel->m_AbortEnable = TRUE; DrawPanel->m_AbortEnable = true;
switch( place_mode ) switch( place_mode )
{ {
@ -109,13 +109,12 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
memopos = CurrPosition; memopos = CurrPosition;
lay_tmp_BOTTOM = Route_Layer_BOTTOM; lay_tmp_BOTTOM = Route_Layer_BOTTOM;
lay_tmp_TOP = Route_Layer_TOP; lay_tmp_TOP = Route_Layer_TOP;
OldPasRoute = g_GridRoutingSize;
g_GridRoutingSize = (int) GetScreen()->GetGridSize().x; Board.m_GridRouting = (int) GetScreen()->GetGridSize().x;
// Ensure g_GridRoutingSize has a reasonnable value: // Ensure Board.m_GridRouting has a reasonnable value:
if( g_GridRoutingSize < 10 ) if( Board.m_GridRouting < 10 )
g_GridRoutingSize = 10; // Min value = 1/1000 inch Board.m_GridRouting = 10; // Min value = 1/1000 inch
/* Compute module parmeters used in auto place */ /* Compute module parmeters used in auto place */
Module = GetBoard()->m_Modules; Module = GetBoard()->m_Modules;
@ -204,7 +203,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
if( ii != 0 ) if( ii != 0 )
{ {
int Angle_Rot_Module = 1800; int Angle_Rot_Module = 1800;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
Module->SetRectangleExinscrit(); Module->SetRectangleExinscrit();
error = RecherchePlacementModule( Module, DC ); error = RecherchePlacementModule( Module, DC );
MinCout *= OrientPenality[ii]; MinCout *= OrientPenality[ii];
@ -216,7 +215,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
else else
{ {
Angle_Rot_Module = -1800; Angle_Rot_Module = -1800;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
} }
if( error == ESC ) if( error == ESC )
goto end_of_tst; goto end_of_tst;
@ -227,7 +226,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
if( ii != 0 ) if( ii != 0 )
{ {
int Angle_Rot_Module = 900; int Angle_Rot_Module = 900;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
error = RecherchePlacementModule( Module, DC ); error = RecherchePlacementModule( Module, DC );
MinCout *= OrientPenality[ii]; MinCout *= OrientPenality[ii];
if( BestScore > MinCout ) /* This orientation is best. */ if( BestScore > MinCout ) /* This orientation is best. */
@ -238,7 +237,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
else else
{ {
Angle_Rot_Module = -900; Angle_Rot_Module = -900;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
} }
if( error == ESC ) if( error == ESC )
goto end_of_tst; goto end_of_tst;
@ -249,7 +248,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
if( ii != 0 ) if( ii != 0 )
{ {
int Angle_Rot_Module = 2700; int Angle_Rot_Module = 2700;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
error = RecherchePlacementModule( Module, DC ); error = RecherchePlacementModule( Module, DC );
MinCout *= OrientPenality[ii]; MinCout *= OrientPenality[ii];
if( BestScore > MinCout ) /* This orientation is best. */ if( BestScore > MinCout ) /* This orientation is best. */
@ -260,7 +259,7 @@ void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
else else
{ {
Angle_Rot_Module = -2700; Angle_Rot_Module = -2700;
Rotate_Module( DC, Module, Angle_Rot_Module, FALSE ); Rotate_Module( DC, Module, Angle_Rot_Module, false );
} }
if( error == ESC ) if( error == ESC )
goto end_of_tst; goto end_of_tst;
@ -291,7 +290,6 @@ end_of_tst:
Route_Layer_TOP = lay_tmp_TOP; Route_Layer_TOP = lay_tmp_TOP;
Route_Layer_BOTTOM = lay_tmp_BOTTOM; Route_Layer_BOTTOM = lay_tmp_BOTTOM;
g_GridRoutingSize = OldPasRoute;
Module = GetBoard()->m_Modules; Module = GetBoard()->m_Modules;
for( ; Module != NULL; Module = Module->Next() ) for( ; Module != NULL; Module = Module->Next() )
@ -301,9 +299,9 @@ end_of_tst:
GetBoard()->m_Status_Pcb = 0; GetBoard()->m_Status_Pcb = 0;
Compile_Ratsnest( DC, true ); Compile_Ratsnest( DC, true );
DrawPanel->ReDraw( DC, TRUE ); DrawPanel->ReDraw( DC, true );
DrawPanel->m_AbortEnable = FALSE; DrawPanel->m_AbortEnable = false;
} }
@ -316,12 +314,12 @@ void PCB_EDIT_FRAME::DrawInfoPlace( wxDC* DC )
GRSetDrawMode( DC, GR_COPY ); GRSetDrawMode( DC, GR_COPY );
for( ii = 0; ii < Board.m_Nrows; ii++ ) for( ii = 0; ii < Board.m_Nrows; ii++ )
{ {
oy = GetBoard()->m_BoundaryBox.m_Pos.y + ( ii * g_GridRoutingSize ); oy = GetBoard()->m_BoundaryBox.m_Pos.y + ( ii * Board.m_GridRouting );
for( jj = 0; jj < Board.m_Ncols; jj++ ) for( jj = 0; jj < Board.m_Ncols; jj++ )
{ {
ox = GetBoard()->m_BoundaryBox.m_Pos.x + ox = GetBoard()->m_BoundaryBox.m_Pos.x +
(jj * g_GridRoutingSize); (jj * Board.m_GridRouting);
color = BLACK; color = BLACK;
top_state = GetCell( ii, jj, TOP ); top_state = GetCell( ii, jj, TOP );
@ -386,19 +384,19 @@ int PCB_EDIT_FRAME::GenPlaceBoard()
/* The boundary box must have its start point on placing grid: */ /* The boundary box must have its start point on placing grid: */
GetBoard()->m_BoundaryBox.m_Pos.x -= GetBoard()->m_BoundaryBox.m_Pos.x % GetBoard()->m_BoundaryBox.m_Pos.x -= GetBoard()->m_BoundaryBox.m_Pos.x %
g_GridRoutingSize; Board.m_GridRouting;
GetBoard()->m_BoundaryBox.m_Pos.y -= GetBoard()->m_BoundaryBox.m_Pos.y % GetBoard()->m_BoundaryBox.m_Pos.y -= GetBoard()->m_BoundaryBox.m_Pos.y %
g_GridRoutingSize; Board.m_GridRouting;
/* The boundary box must have its end point on placing grid: */ /* The boundary box must have its end point on placing grid: */
wxPoint end = GetBoard()->m_BoundaryBox.GetEnd(); wxPoint end = GetBoard()->m_BoundaryBox.GetEnd();
end.x -= end.x % g_GridRoutingSize; end.x -= end.x % Board.m_GridRouting;
end.x += g_GridRoutingSize; end.x += Board.m_GridRouting;
end.y -= end.y % g_GridRoutingSize; end.y -= end.y % Board.m_GridRouting;
end.y += g_GridRoutingSize; end.y += Board.m_GridRouting;
GetBoard()->m_BoundaryBox.SetEnd( end ); GetBoard()->m_BoundaryBox.SetEnd( end );
Nrows = GetBoard()->m_BoundaryBox.GetHeight() / g_GridRoutingSize; Nrows = GetBoard()->m_BoundaryBox.GetHeight() / Board.m_GridRouting;
Ncols = GetBoard()->m_BoundaryBox.GetWidth() / g_GridRoutingSize; Ncols = GetBoard()->m_BoundaryBox.GetWidth() / Board.m_GridRouting;
/* get a small margin for memory allocation: */ /* get a small margin for memory allocation: */
Ncols += 2; Nrows += 2; Ncols += 2; Nrows += 2;
NbCells = Ncols * Nrows; NbCells = Ncols * Nrows;
@ -435,7 +433,7 @@ int PCB_EDIT_FRAME::GenPlaceBoard()
TmpSegm.SetLayer( -1 ); TmpSegm.SetLayer( -1 );
TmpSegm.SetNet( -1 ); TmpSegm.SetNet( -1 );
TmpSegm.m_Width = g_GridRoutingSize / 2; TmpSegm.m_Width = Board.m_GridRouting / 2;
for( ; PtStruct != NULL; PtStruct = PtStruct->Next() ) for( ; PtStruct != NULL; PtStruct = PtStruct->Next() )
{ {
DRAWSEGMENT* DrawSegm; DRAWSEGMENT* DrawSegm;
@ -453,7 +451,7 @@ int PCB_EDIT_FRAME::GenPlaceBoard()
TmpSegm.m_Param = DrawSegm->m_Angle; TmpSegm.m_Param = DrawSegm->m_Angle;
TraceSegmentPcb( GetBoard(), &TmpSegm, HOLE | CELL_is_EDGE, TraceSegmentPcb( GetBoard(), &TmpSegm, HOLE | CELL_is_EDGE,
g_GridRoutingSize, WRITE_CELL ); Board.m_GridRouting, WRITE_CELL );
break; break;
case TYPE_TEXTE: case TYPE_TEXTE:
@ -490,7 +488,7 @@ int PCB_EDIT_FRAME::GenPlaceBoard()
void PCB_EDIT_FRAME::GenModuleOnBoard( MODULE* Module ) void PCB_EDIT_FRAME::GenModuleOnBoard( MODULE* Module )
{ {
int ox, oy, fx, fy, Penalite; int ox, oy, fx, fy, Penalite;
int marge = g_GridRoutingSize / 2; int marge = Board.m_GridRouting / 2;
int masque_layer; int masque_layer;
D_PAD* Pad; D_PAD* Pad;
@ -541,7 +539,7 @@ void PCB_EDIT_FRAME::GenModuleOnBoard( MODULE* Module )
} }
/* Trace clearance. */ /* Trace clearance. */
marge = (g_GridRoutingSize * Module->m_PadNum ) / GAIN; marge = (Board.m_GridRouting * Module->m_PadNum ) / GAIN;
Penalite = PENALITE; Penalite = PENALITE;
TracePenaliteRectangle( GetBoard(), ox, oy, fx, fy, marge, Penalite, TracePenaliteRectangle( GetBoard(), ox, oy, fx, fy, marge, Penalite,
masque_layer ); masque_layer );
@ -582,8 +580,8 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
CurrPosition.x = GetBoard()->m_BoundaryBox.m_Pos.x - ox; CurrPosition.x = GetBoard()->m_BoundaryBox.m_Pos.x - ox;
CurrPosition.y = GetBoard()->m_BoundaryBox.m_Pos.y - oy; CurrPosition.y = GetBoard()->m_BoundaryBox.m_Pos.y - oy;
/* Module placement on grid. */ /* Module placement on grid. */
CurrPosition.x -= CurrPosition.x % g_GridRoutingSize; CurrPosition.x -= CurrPosition.x % Board.m_GridRouting;
CurrPosition.y -= CurrPosition.y % g_GridRoutingSize; CurrPosition.y -= CurrPosition.y % Board.m_GridRouting;
g_Offset_Module.x = cx - CurrPosition.x; g_Offset_Module.x = cx - CurrPosition.x;
g_Offset_Module.y = cy - CurrPosition.y; g_Offset_Module.y = cy - CurrPosition.y;
@ -593,7 +591,7 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
* can become a component on opposite side if there is at least 1 patch * can become a component on opposite side if there is at least 1 patch
* appearing on the other side. * appearing on the other side.
*/ */
TstOtherSide = FALSE; TstOtherSide = false;
if( Nb_Sides == TWO_SIDES ) if( Nb_Sides == TWO_SIDES )
{ {
D_PAD* Pad; int masque_otherlayer; D_PAD* Pad; int masque_otherlayer;
@ -605,7 +603,7 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
{ {
if( ( Pad->m_Masque_Layer & masque_otherlayer ) == 0 ) if( ( Pad->m_Masque_Layer & masque_otherlayer ) == 0 )
continue; continue;
TstOtherSide = TRUE; TstOtherSide = true;
break; break;
} }
} }
@ -617,7 +615,7 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
SetStatusText( wxT( "Score ??, pos ??" ) ); SetStatusText( wxT( "Score ??, pos ??" ) );
for( ; CurrPosition.x < GetBoard()->m_BoundaryBox.GetRight() - fx; for( ; CurrPosition.x < GetBoard()->m_BoundaryBox.GetRight() - fx;
CurrPosition.x += g_GridRoutingSize ) CurrPosition.x += Board.m_GridRouting )
{ {
wxYield(); wxYield();
if( DrawPanel->m_AbortRequest ) if( DrawPanel->m_AbortRequest )
@ -625,7 +623,7 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
if( IsOK( this, _( "Ok to abort?" ) ) ) if( IsOK( this, _( "Ok to abort?" ) ) )
return ESC; return ESC;
else else
DrawPanel->m_AbortRequest = FALSE; DrawPanel->m_AbortRequest = false;
} }
cx = Module->m_Pos.x; cy = Module->m_Pos.y; cx = Module->m_Pos.x; cy = Module->m_Pos.y;
@ -637,12 +635,12 @@ int PCB_EDIT_FRAME::RecherchePlacementModule( MODULE* Module, wxDC* DC )
g_Offset_Module.x = cx - CurrPosition.x; g_Offset_Module.x = cx - CurrPosition.x;
CurrPosition.y = GetBoard()->m_BoundaryBox.m_Pos.y - oy; CurrPosition.y = GetBoard()->m_BoundaryBox.m_Pos.y - oy;
/* Placement on grid. */ /* Placement on grid. */
CurrPosition.y -= CurrPosition.y % g_GridRoutingSize; CurrPosition.y -= CurrPosition.y % Board.m_GridRouting;
DrawModuleOutlines( DrawPanel, DC, Module ); DrawModuleOutlines( DrawPanel, DC, Module );
for( ; CurrPosition.y < GetBoard()->m_BoundaryBox.GetBottom() - fy; for( ; CurrPosition.y < GetBoard()->m_BoundaryBox.GetBottom() - fy;
CurrPosition.y += g_GridRoutingSize ) CurrPosition.y += Board.m_GridRouting )
{ {
/* Erase traces. */ /* Erase traces. */
DrawModuleOutlines( DrawPanel, DC, Module ); DrawModuleOutlines( DrawPanel, DC, Module );
@ -714,13 +712,13 @@ int TstRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1, int side )
ux1 -= Pcb->m_BoundaryBox.m_Pos.x; ux1 -= Pcb->m_BoundaryBox.m_Pos.x;
uy1 -= Pcb->m_BoundaryBox.m_Pos.y; uy1 -= Pcb->m_BoundaryBox.m_Pos.y;
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / g_GridRoutingSize; row_min = uy0 / Board.m_GridRouting;
if( uy0 > row_min * g_GridRoutingSize ) if( uy0 > row_min * Board.m_GridRouting )
row_min++; row_min++;
col_min = ux0 / g_GridRoutingSize; col_min = ux0 / Board.m_GridRouting;
if( ux0 > col_min * g_GridRoutingSize ) if( ux0 > col_min * Board.m_GridRouting )
col_min++; col_min++;
if( row_min < 0 ) if( row_min < 0 )
@ -764,13 +762,13 @@ unsigned int CalculePenaliteRectangle( BOARD* Pcb, int ux0, int uy0,
ux1 -= Pcb->m_BoundaryBox.m_Pos.x; ux1 -= Pcb->m_BoundaryBox.m_Pos.x;
uy1 -= Pcb->m_BoundaryBox.m_Pos.y; uy1 -= Pcb->m_BoundaryBox.m_Pos.y;
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / g_GridRoutingSize; row_min = uy0 / Board.m_GridRouting;
if( uy0 > row_min * g_GridRoutingSize ) if( uy0 > row_min * Board.m_GridRouting )
row_min++; row_min++;
col_min = ux0 / g_GridRoutingSize; col_min = ux0 / Board.m_GridRouting;
if( ux0 > col_min * g_GridRoutingSize ) if( ux0 > col_min * Board.m_GridRouting )
col_min++; col_min++;
if( row_min < 0 ) if( row_min < 0 )
@ -826,7 +824,7 @@ int TstModuleOnBoard( BOARD* Pcb, MODULE* Module, bool TstOtherSide )
return error; return error;
} }
marge = ( g_GridRoutingSize * Module->m_PadNum ) / GAIN; marge = ( Board.m_GridRouting * Module->m_PadNum ) / GAIN;
Penalite = CalculePenaliteRectangle( Pcb, ox - marge, oy - marge, Penalite = CalculePenaliteRectangle( Pcb, ox - marge, oy - marge,
fx + marge, fy + marge, side ); fx + marge, fy + marge, side );
@ -941,15 +939,17 @@ static void TracePenaliteRectangle( BOARD* Pcb,
ux0 -= marge; ux1 += marge; ux0 -= marge; ux1 += marge;
uy0 -= marge; uy1 += marge; uy0 -= marge; uy1 += marge;
pmarge = marge / g_GridRoutingSize; if( pmarge < 1 ) pmarge = marge / Board.m_GridRouting; if( pmarge < 1 )
pmarge = 1; pmarge = 1;
/* Calculate the coordinate limits of the rectangle. */ /* Calculate the coordinate limits of the rectangle. */
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / g_GridRoutingSize; if( uy0 > row_min * g_GridRoutingSize ) row_min = uy0 / Board.m_GridRouting;
if( uy0 > row_min * Board.m_GridRouting )
row_min++; row_min++;
col_min = ux0 / g_GridRoutingSize; if( ux0 > col_min * g_GridRoutingSize ) col_min = ux0 / Board.m_GridRouting;
if( ux0 > col_min * Board.m_GridRouting )
col_min++; col_min++;
if( row_min < 0 ) if( row_min < 0 )

10
pcbnew/autorout.cpp
View File

@ -131,14 +131,14 @@ void PCB_EDIT_FRAME::Autoroute( wxDC* DC, int mode )
start = time( NULL ); start = time( NULL );
/* Calculation of no fixed routing to 5 mils and more. */ /* Calculation of no fixed routing to 5 mils and more. */
g_GridRoutingSize = (int)GetScreen()->GetGridSize().x; Board.m_GridRouting = (int)GetScreen()->GetGridSize().x;
if( g_GridRoutingSize < 50 ) if( Board.m_GridRouting < 50 )
g_GridRoutingSize = 50; Board.m_GridRouting = 50;
E_scale = g_GridRoutingSize / 50; if( E_scale < 1 ) E_scale = Board.m_GridRouting / 50; if( E_scale < 1 )
E_scale = 1; E_scale = 1;
/* Calculated ncol and nrow, matrix size for routing. */ /* Calculated ncol and nrow, matrix size for routing. */
ComputeMatriceSize( GetBoard(), g_GridRoutingSize ); Board.ComputeMatrixSize( GetBoard() );
MsgPanel->EraseMsgBox(); MsgPanel->EraseMsgBox();

5
pcbnew/autorout.h
View File

@ -48,11 +48,8 @@ extern int ClosNodes; /* total number of nodes closed */
extern int MoveNodes; /* total number of nodes moved */ extern int MoveNodes; /* total number of nodes moved */
extern int MaxNodes; /* maximum number of nodes opened at one time */ extern int MaxNodes; /* maximum number of nodes opened at one time */
/* Grid size for automatic routing */
extern int g_GridRoutingSize;
/* Structures useful to the generation of board as bitmap. */ /* Structures useful to the generation of board as bitmap. */
typedef char MATRIX_CELL; typedef char MATRIX_CELL;
typedef int DIST_CELL; typedef int DIST_CELL;
typedef char DIR_CELL; typedef char DIR_CELL;
@ -68,12 +65,14 @@ public:
bool m_InitBoardDone; bool m_InitBoardDone;
int m_Layers; int m_Layers;
int m_GridRouting; // Size of grid for autoplace/autoroute int m_GridRouting; // Size of grid for autoplace/autoroute
EDA_Rect m_BrdBox; // Actual board bouding box
int m_Nrows, m_Ncols; int m_Nrows, m_Ncols;
int m_MemSize; int m_MemSize;
public: public:
MATRIX_ROUTING_HEAD(); MATRIX_ROUTING_HEAD();
~MATRIX_ROUTING_HEAD(); ~MATRIX_ROUTING_HEAD();
bool ComputeMatrixSize( BOARD* aPcb );
int InitBoard(); int InitBoard();
void UnInitBoard(); void UnInitBoard();
}; };

3
pcbnew/block.cpp
View File

@ -94,7 +94,6 @@ static bool InstallBlockCmdFrame( PCB_BASE_FRAME* parent, const wxString& title
parent->GetScreen()->SetCrossHairPosition( oldpos ); parent->GetScreen()->SetCrossHairPosition( oldpos );
parent->DrawPanel->MoveCursorToCrossHair(); parent->DrawPanel->MoveCursorToCrossHair();
parent->DrawPanel->m_IgnoreMouseEvents = false; parent->DrawPanel->m_IgnoreMouseEvents = false;
parent->DrawPanel->SetCursor( parent->DrawPanel->GetDefaultCursor() );
return nocmd ? false : true; return nocmd ? false : true;
} }
@ -253,7 +252,7 @@ void PCB_EDIT_FRAME::HandleBlockPlace( wxDC* DC )
} }
DisplayToolMsg( wxEmptyString ); DisplayToolMsg( wxEmptyString );
DrawPanel->SetCursor( DrawPanel->GetDefaultCursor() ); DrawPanel->SetCursor( DrawPanel->GetCurrentCursor() );
} }

208
pcbnew/board.cpp
View File

@ -11,38 +11,41 @@
* Calculates nrows and ncols, dimensions of the matrix representation of BOARD * Calculates nrows and ncols, dimensions of the matrix representation of BOARD
* for routing and automatic calculation of area. * for routing and automatic calculation of area.
*/ */
bool ComputeMatriceSize( BOARD * aPcb, int aGridRouting ) bool MATRIX_ROUTING_HEAD::ComputeMatrixSize( BOARD* aPcb )
{ {
aPcb->ComputeBoundingBox(); aPcb->ComputeBoundingBox();
/* The boundary box must have its start point on routing grid: */ /* The boundary box must have its start point on routing grid: */
aPcb->m_BoundaryBox.m_Pos.x -= aPcb->m_BoundaryBox.m_Pos.x % aGridRouting; aPcb->m_BoundaryBox.m_Pos.x -= aPcb->m_BoundaryBox.m_Pos.x % m_GridRouting;
aPcb->m_BoundaryBox.m_Pos.y -= aPcb->m_BoundaryBox.m_Pos.y % aGridRouting; aPcb->m_BoundaryBox.m_Pos.y -= aPcb->m_BoundaryBox.m_Pos.y % m_GridRouting;
m_BrdBox = aPcb->m_BoundaryBox;
/* The boundary box must have its end point on routing grid: */ /* The boundary box must have its end point on routing grid: */
wxPoint end = aPcb->m_BoundaryBox.GetEnd(); wxPoint end = m_BrdBox.GetEnd();
end.x -= end.x % aGridRouting; end.x -= end.x % m_GridRouting;
end.x += aGridRouting; end.x += m_GridRouting;
end.y -= end.y % aGridRouting; end.y -= end.y % m_GridRouting;
end.y += aGridRouting; end.y += m_GridRouting;
aPcb->m_BoundaryBox.SetEnd( end ); aPcb->m_BoundaryBox.SetEnd( end );
m_BrdBox.SetEnd(end);
m_Nrows = Nrows = m_BrdBox.m_Size.y / m_GridRouting;
m_Ncols = Ncols = m_BrdBox.m_Size.x / m_GridRouting;
Nrows = aPcb->m_BoundaryBox.m_Size.y / aGridRouting;
Ncols = aPcb->m_BoundaryBox.m_Size.x / aGridRouting;
/* get a small margin for memory allocation: */ /* get a small margin for memory allocation: */
Ncols += 2; Nrows += 2; Ncols += 1; Nrows += 1;
return true; return true;
} }
/* class MATRIX_ROUTING_HEAD /* class MATRIX_ROUTING_HEAD
*/ */
MATRIX_ROUTING_HEAD::MATRIX_ROUTING_HEAD() MATRIX_ROUTING_HEAD::MATRIX_ROUTING_HEAD()
{ {
m_BoardSide[0] = m_BoardSide[1] = NULL; m_BoardSide[0] = m_BoardSide[1] = NULL;
m_DistSide[0] = m_DistSide[1] = NULL; m_DistSide[0] = m_DistSide[1] = NULL;
m_DirSide[0] = m_DirSide[1] = NULL; m_DirSide[0] = m_DirSide[1] = NULL;
m_InitBoardDone = FALSE; m_InitBoardDone = false;
m_Layers = MAX_SIDES_COUNT; m_Layers = MAX_SIDES_COUNT;
m_Nrows = m_Ncols = 0; m_Nrows = m_Ncols = 0;
m_MemSize = 0; m_MemSize = 0;
@ -102,23 +105,23 @@ void MATRIX_ROUTING_HEAD::UnInitBoard()
{ {
int ii; int ii;
m_InitBoardDone = FALSE; m_InitBoardDone = false;
for( ii = 0; ii < 2; ii++ ) for( ii = 0; ii < MAX_SIDES_COUNT; ii++ )
{ {
/***** de-allocate Dir (chars) *****/ /***** de-allocate Dir matrix *****/
if( m_DirSide[ii] ) if( m_DirSide[ii] )
{ {
MyFree( m_DirSide[ii] ); m_DirSide[ii] = NULL; MyFree( m_DirSide[ii] ); m_DirSide[ii] = NULL;
} }
/***** de-allocate Distances *****/ /***** de-allocate Distances matrix *****/
if( m_DistSide[ii] ) if( m_DistSide[ii] )
{ {
MyFree( m_DistSide[ii] ); m_DistSide[ii] = NULL; MyFree( m_DistSide[ii] ); m_DistSide[ii] = NULL;
} }
/**** de-allocate Board *****/ /**** de-allocate cells matrix *****/
if( m_BoardSide[ii] ) if( m_BoardSide[ii] )
{ {
MyFree( m_BoardSide[ii] ); m_BoardSide[ii] = NULL; MyFree( m_BoardSide[ii] ); m_BoardSide[ii] = NULL;
@ -141,27 +144,24 @@ void MATRIX_ROUTING_HEAD::UnInitBoard()
*/ */
void PlaceCells( BOARD* aPcb, int net_code, int flag ) void PlaceCells( BOARD* aPcb, int net_code, int flag )
{ {
int ux0 = 0, uy0 = 0, ux1, uy1, dx, dy; int ux0 = 0, uy0 = 0, ux1, uy1, dx, dy;
int marge, via_marge; int marge, via_marge;
int masque_layer; int masque_layer;
// use the default NETCLASS? // use the default NETCLASS?
NETCLASS* nc = aPcb->m_NetClasses.GetDefault(); NETCLASS* nc = aPcb->m_NetClasses.GetDefault();
int trackWidth = nc->GetTrackWidth(); int trackWidth = nc->GetTrackWidth();
int clearance = nc->GetClearance(); int clearance = nc->GetClearance();
int viaSize = nc->GetViaDiameter(); int viaSize = nc->GetViaDiameter();
marge = clearance + (trackWidth / 2); marge = clearance + (trackWidth / 2);
via_marge = clearance + (viaSize / 2); via_marge = clearance + (viaSize / 2);
////////////////////////// // Place PADS on matrix routing:
// Place PADS on board. // for( unsigned i = 0; i < aPcb->GetPadsCount(); ++i )
//////////////////////////
for( unsigned i=0; i < aPcb->GetPadsCount(); ++i )
{ {
D_PAD* pad = aPcb->m_NetInfo->GetPad(i); D_PAD* pad = aPcb->m_NetInfo->GetPad( i );
if( net_code != pad->GetNet() || (flag & FORCE_PADS) ) if( net_code != pad->GetNet() || (flag & FORCE_PADS) )
{ {
@ -170,38 +170,35 @@ void PlaceCells( BOARD* aPcb, int net_code, int flag )
Place_1_Pad_Board( aPcb, pad, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL ); Place_1_Pad_Board( aPcb, pad, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
} }
//////////////////////////////////////////// // Place outlines of modules on matrix routing, if they are on a copper layer
// Placing the elements of modules on PCB // // or on the edge layer
//////////////////////////////////////////// TRACK tmpSegm( NULL ); // A dummy track used to create segments.
for( MODULE* module = aPcb->m_Modules; module; module = module->Next() ) for( MODULE* module = aPcb->m_Modules; module; module = module->Next() )
{ {
for( BOARD_ITEM* item = module->m_Drawings; item; item = item->Next() ) for( BOARD_ITEM* item = module->m_Drawings; item; item = item->Next() )
{ {
switch( item->Type() ) switch( item->Type() )
{ {
case TYPE_EDGE_MODULE: case TYPE_EDGE_MODULE:
{ {
EDGE_MODULE* edge = (EDGE_MODULE*) item; EDGE_MODULE* edge = (EDGE_MODULE*) item;
TRACK* TmpSegm = new TRACK( NULL ); tmpSegm.SetLayer( edge->GetLayer() );
if( tmpSegm.GetLayer() == EDGE_N )
tmpSegm.SetLayer( -1 );
TmpSegm->SetLayer( edge->GetLayer() ); tmpSegm.m_Start = edge->m_Start;
if( TmpSegm->GetLayer() == EDGE_N ) tmpSegm.m_End = edge->m_End;
TmpSegm->SetLayer( -1 ); tmpSegm.m_Shape = edge->m_Shape;
tmpSegm.m_Width = edge->m_Width;
tmpSegm.m_Param = edge->m_Angle;
tmpSegm.SetNet( -1 );
TmpSegm->m_Start = edge->m_Start; TraceSegmentPcb( aPcb, &tmpSegm, HOLE, marge, WRITE_CELL );
TmpSegm->m_End = edge->m_End; TraceSegmentPcb( aPcb, &tmpSegm, VIA_IMPOSSIBLE, via_marge,
TmpSegm->m_Shape = edge->m_Shape; WRITE_OR_CELL );
TmpSegm->m_Width = edge->m_Width; }
TmpSegm->m_Param = edge->m_Angle; break;
TmpSegm->SetNet( -1 );
TraceSegmentPcb( aPcb, TmpSegm, HOLE, marge, WRITE_CELL );
TraceSegmentPcb( aPcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,
WRITE_OR_CELL );
delete TmpSegm;
}
break;
default: default:
break; break;
@ -209,53 +206,47 @@ void PlaceCells( BOARD* aPcb, int net_code, int flag )
} }
} }
//////////////////////////////////////////// // Place board outlines and texts on copper layers:
// Placement contours and segments on PCB //
////////////////////////////////////////////
for( BOARD_ITEM* item = aPcb->m_Drawings; item; item = item->Next() ) for( BOARD_ITEM* item = aPcb->m_Drawings; item; item = item->Next() )
{ {
switch( item->Type() ) switch( item->Type() )
{ {
case TYPE_DRAWSEGMENT: case TYPE_DRAWSEGMENT:
{
DRAWSEGMENT* DrawSegm;
int type_cell = HOLE;
DrawSegm = (DRAWSEGMENT*) item;
tmpSegm.SetLayer( DrawSegm->GetLayer() );
if( DrawSegm->GetLayer() == EDGE_N )
{ {
DRAWSEGMENT* DrawSegm; tmpSegm.SetLayer( -1 );
type_cell |= CELL_is_EDGE;
int type_cell = HOLE;
TRACK* TmpSegm = new TRACK( NULL );
DrawSegm = (DRAWSEGMENT*) item;
TmpSegm->SetLayer( DrawSegm->GetLayer() );
if( DrawSegm->GetLayer() == EDGE_N )
{
TmpSegm->SetLayer( -1 );
type_cell |= CELL_is_EDGE;
}
TmpSegm->m_Start = DrawSegm->m_Start;
TmpSegm->m_End = DrawSegm->m_End;
TmpSegm->m_Shape = DrawSegm->m_Shape;
TmpSegm->m_Width = DrawSegm->m_Width;
TmpSegm->m_Param = DrawSegm->m_Angle;
TmpSegm->SetNet( -1 );
TraceSegmentPcb( aPcb, TmpSegm, type_cell, marge, WRITE_CELL );
// TraceSegmentPcb(Pcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,WRITE_OR_CELL );
delete TmpSegm;
} }
break;
tmpSegm.m_Start = DrawSegm->m_Start;
tmpSegm.m_End = DrawSegm->m_End;
tmpSegm.m_Shape = DrawSegm->m_Shape;
tmpSegm.m_Width = DrawSegm->m_Width;
tmpSegm.m_Param = DrawSegm->m_Angle;
tmpSegm.SetNet( -1 );
TraceSegmentPcb( aPcb, &tmpSegm, type_cell, marge, WRITE_CELL );
}
break;
case TYPE_TEXTE: case TYPE_TEXTE:
{ {
TEXTE_PCB* PtText; TEXTE_PCB* PtText;
PtText = (TEXTE_PCB*) item; PtText = (TEXTE_PCB*) item;
if( PtText->GetLength() == 0 ) if( PtText->GetLength() == 0 )
break; break;
EDA_Rect textbox = PtText->GetTextBox(-1); EDA_Rect textbox = PtText->GetTextBox( -1 );
ux0 = textbox.GetX(); uy0 = textbox.GetY(); ux0 = textbox.GetX(); uy0 = textbox.GetY();
dx = textbox.GetWidth(); dx = textbox.GetWidth();
dy = textbox.GetHeight(); dy = textbox.GetHeight();
/* Put bounding box (rectangle) on matrix */ /* Put bounding box (rectangle) on matrix */
dx /= 2; dx /= 2;
@ -278,7 +269,7 @@ void PlaceCells( BOARD* aPcb, int net_code, int flag )
(int) (PtText->m_Orient), (int) (PtText->m_Orient),
masque_layer, VIA_IMPOSSIBLE, WRITE_OR_CELL ); masque_layer, VIA_IMPOSSIBLE, WRITE_OR_CELL );
} }
break; break;
default: default:
break; break;
@ -286,7 +277,7 @@ void PlaceCells( BOARD* aPcb, int net_code, int flag )
} }
/* Put tracks and vias on matrix */ /* Put tracks and vias on matrix */
for( TRACK* track = aPcb->m_Track; track; track = track->Next() ) for( TRACK* track = aPcb->m_Track; track; track = track->Next() )
{ {
if( net_code == track->GetNet() ) if( net_code == track->GetNet() )
continue; continue;
@ -294,37 +285,28 @@ void PlaceCells( BOARD* aPcb, int net_code, int flag )
TraceSegmentPcb( aPcb, track, HOLE, marge, WRITE_CELL ); TraceSegmentPcb( aPcb, track, HOLE, marge, WRITE_CELL );
TraceSegmentPcb( aPcb, track, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL ); TraceSegmentPcb( aPcb, track, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
} }
// Put zone filling on matrix
for( SEGZONE* zone = aPcb->m_Zone; zone; zone = zone->Next() )
{
if( net_code == zone->GetNet() )
continue;
TraceSegmentPcb( aPcb, zone, HOLE, marge, WRITE_CELL );
TraceSegmentPcb( aPcb, zone, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
}
} }
int Build_Work( BOARD* Pcb ) int Build_Work( BOARD* Pcb )
{ {
RATSNEST_ITEM* pt_rats; RATSNEST_ITEM* pt_rats;
D_PAD* pt_pad; D_PAD* pt_pad;
int r1, r2, c1, c2, current_net_code; int r1, r2, c1, c2, current_net_code;
RATSNEST_ITEM* pt_ch; RATSNEST_ITEM* pt_ch;
int demi_pas = g_GridRoutingSize / 2; int demi_pas = Board.m_GridRouting / 2;
wxString msg; wxString msg;
InitWork(); /* clear work list */ InitWork(); /* clear work list */
Ntotal = 0; Ntotal = 0;
for( unsigned ii = 0; ii < Pcb->GetRatsnestsCount(); ii++ ) for( unsigned ii = 0; ii < Pcb->GetRatsnestsCount(); ii++ )
{ {
pt_rats = &Pcb->m_FullRatsnest[ii]; pt_rats = &Pcb->m_FullRatsnest[ii];
/* We consider her only ratsnets that are active ( obviously not yet routed) /* We consider her only ratsnets that are active ( obviously not yet routed)
* and routables (that are not yet attempt to be routed and fail * and routables (that are not yet attempt to be routed and fail
*/ */
if( (pt_rats->m_Status & CH_ACTIF) == 0 ) if( (pt_rats->m_Status & CH_ACTIF) == 0 )
continue; continue;
if( pt_rats->m_Status & CH_UNROUTABLE ) if( pt_rats->m_Status & CH_UNROUTABLE )
continue; continue;
@ -336,7 +318,7 @@ int Build_Work( BOARD* Pcb )
pt_ch = pt_rats; pt_ch = pt_rats;
r1 = ( pt_pad->GetPosition().y - Pcb->m_BoundaryBox.m_Pos.y r1 = ( pt_pad->GetPosition().y - Pcb->m_BoundaryBox.m_Pos.y
+ demi_pas ) / g_GridRoutingSize; + demi_pas ) / Board.m_GridRouting;
if( r1 < 0 || r1 >= Nrows ) if( r1 < 0 || r1 >= Nrows )
{ {
msg.Printf( wxT( "error : row = %d ( padY %d pcbY %d) " ), r1, msg.Printf( wxT( "error : row = %d ( padY %d pcbY %d) " ), r1,
@ -345,7 +327,7 @@ int Build_Work( BOARD* Pcb )
return 0; return 0;
} }
c1 = ( pt_pad->GetPosition().x - Pcb->m_BoundaryBox.m_Pos.x c1 = ( pt_pad->GetPosition().x - Pcb->m_BoundaryBox.m_Pos.x
+ demi_pas ) / g_GridRoutingSize; + demi_pas ) / Board.m_GridRouting;
if( c1 < 0 || c1 >= Ncols ) if( c1 < 0 || c1 >= Ncols )
{ {
msg.Printf( wxT( "error : col = %d ( padX %d pcbX %d) " ), c1, msg.Printf( wxT( "error : col = %d ( padX %d pcbX %d) " ), c1,
@ -357,7 +339,7 @@ int Build_Work( BOARD* Pcb )
pt_pad = pt_rats->m_PadEnd; pt_pad = pt_rats->m_PadEnd;
r2 = ( pt_pad->GetPosition().y - Pcb->m_BoundaryBox.m_Pos.y r2 = ( pt_pad->GetPosition().y - Pcb->m_BoundaryBox.m_Pos.y
+ demi_pas ) / g_GridRoutingSize; + demi_pas ) / Board.m_GridRouting;
if( r2 < 0 || r2 >= Nrows ) if( r2 < 0 || r2 >= Nrows )
{ {
msg.Printf( wxT( "error : row = %d ( padY %d pcbY %d) " ), r2, msg.Printf( wxT( "error : row = %d ( padY %d pcbY %d) " ), r2,
@ -366,7 +348,7 @@ int Build_Work( BOARD* Pcb )
return 0; return 0;
} }
c2 = ( pt_pad->GetPosition().x - Pcb->m_BoundaryBox.m_Pos.x c2 = ( pt_pad->GetPosition().x - Pcb->m_BoundaryBox.m_Pos.x
+ demi_pas ) / g_GridRoutingSize; + demi_pas ) / Board.m_GridRouting;
if( c2 < 0 || c2 >= Ncols ) if( c2 < 0 || c2 >= Ncols )
{ {
msg.Printf( wxT( "error : col = %d ( padX %d pcbX %d) " ), c2, msg.Printf( wxT( "error : col = %d ( padX %d pcbX %d) " ), c2,
@ -385,7 +367,7 @@ int Build_Work( BOARD* Pcb )
/* return the value stored in a cell /* return the value stored in a cell
*/ */
MATRIX_CELL GetCell( int aRow, int aCol, int aSide ) MATRIX_CELL GetCell( int aRow, int aCol, int aSide )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;
@ -396,7 +378,7 @@ MATRIX_CELL GetCell( int aRow, int aCol, int aSide )
/* basic cell operation : WRITE operation /* basic cell operation : WRITE operation
*/ */
void SetCell( int aRow, int aCol, int aSide, MATRIX_CELL x ) void SetCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;
@ -407,7 +389,7 @@ void SetCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
/* basic cell operation : OR operation /* basic cell operation : OR operation
*/ */
void OrCell( int aRow, int aCol, int aSide, MATRIX_CELL x ) void OrCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;
@ -418,7 +400,7 @@ void OrCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
/* basic cell operation : XOR operation /* basic cell operation : XOR operation
*/ */
void XorCell( int aRow, int aCol, int aSide, MATRIX_CELL x ) void XorCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;
@ -429,7 +411,7 @@ void XorCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
/* basic cell operation : AND operation /* basic cell operation : AND operation
*/ */
void AndCell( int aRow, int aCol, int aSide, MATRIX_CELL x ) void AndCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;
@ -440,7 +422,7 @@ void AndCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
/* basic cell operation : ADD operation /* basic cell operation : ADD operation
*/ */
void AddCell( int aRow, int aCol, int aSide, MATRIX_CELL x ) void AddCell( int aRow, int aCol, int aSide, MATRIX_CELL x )
{ {
MATRIX_CELL* p; MATRIX_CELL* p;

104
pcbnew/graphpcb.cpp
View File

@ -75,7 +75,7 @@ static void TraceCercle( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
*/ */
int ToMatrixCoordinate( int aPhysicalCoordinate ) int ToMatrixCoordinate( int aPhysicalCoordinate )
{ {
return aPhysicalCoordinate / g_GridRoutingSize; return aPhysicalCoordinate / Board.m_GridRouting;
} }
@ -215,11 +215,11 @@ void TraceFilledCercle( BOARD* Pcb,
uy1 = cy + radius; uy1 = cy + radius;
/* Calculate limit coordinates of cells belonging to the rectangle. */ /* Calculate limit coordinates of cells belonging to the rectangle. */
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / g_GridRoutingSize; // if (uy0 > row_min*g_GridRoutingSize row_min = uy0 / Board.m_GridRouting; // if (uy0 > row_min*Board.m_GridRouting
// ) row_min++; // ) row_min++;
col_min = ux0 / g_GridRoutingSize; // if (ux0 > col_min*g_GridRoutingSize col_min = ux0 / Board.m_GridRouting; // if (ux0 > col_min*Board.m_GridRouting
// ) col_min++; // ) col_min++;
if( row_min < 0 ) if( row_min < 0 )
@ -241,11 +241,11 @@ void TraceFilledCercle( BOARD* Pcb,
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
fdisty = (float) ( cy - ( row * g_GridRoutingSize ) ); fdisty = (float) ( cy - ( row * Board.m_GridRouting ) );
fdisty *= fdisty; fdisty *= fdisty;
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
{ {
fdistx = (float) ( cx - ( col * g_GridRoutingSize ) ); fdistx = (float) ( cx - ( col * Board.m_GridRouting ) );
fdistx *= fdistx; fdistx *= fdistx;
if( fdistmin <= ( fdistx + fdisty ) ) if( fdistmin <= ( fdistx + fdisty ) )
@ -265,17 +265,17 @@ void TraceFilledCercle( BOARD* Pcb,
/* If no cell has been written, it affects the 4 neighboring diagonal /* If no cell has been written, it affects the 4 neighboring diagonal
* (Adverse event: pad off grid in the center of the 4 neighboring * (Adverse event: pad off grid in the center of the 4 neighboring
* diagonal) */ * diagonal) */
distmin = g_GridRoutingSize / 2 + 1; distmin = Board.m_GridRouting / 2 + 1;
fdistmin = ( (float) distmin * distmin ) * 2; /* Distance to center point fdistmin = ( (float) distmin * distmin ) * 2; /* Distance to center point
* diagonally */ * diagonally */
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
fdisty = (float) ( cy - ( row * g_GridRoutingSize ) ); fdisty = (float) ( cy - ( row * Board.m_GridRouting ) );
fdisty *= fdisty; fdisty *= fdisty;
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
{ {
fdistx = (float) ( cx - ( col * g_GridRoutingSize ) ); fdistx = (float) ( cx - ( col * Board.m_GridRouting ) );
fdistx *= fdistx; fdistx *= fdistx;
if( fdistmin <= ( fdistx + fdisty ) ) if( fdistmin <= ( fdistx + fdisty ) )
@ -302,7 +302,7 @@ void TraceSegmentPcb( BOARD* Pcb,
int ux0, uy0, ux1, uy1; int ux0, uy0, ux1, uy1;
demi_pas = g_GridRoutingSize / 2; demi_pas = Board.m_GridRouting / 2;
demi_largeur = ( pt_segm->m_Width / 2 ) + marge; demi_largeur = ( pt_segm->m_Width / 2 ) + marge;
/* Calculate the bounding rectangle of the segment (if H, V or Via) */ /* Calculate the bounding rectangle of the segment (if H, V or Via) */
ux0 = pt_segm->m_Start.x - Pcb->m_BoundaryBox.m_Pos.x; ux0 = pt_segm->m_Start.x - Pcb->m_BoundaryBox.m_Pos.x;
@ -407,9 +407,9 @@ void TraceLignePcb( int x0,
{ {
if( y1 < y0 ) if( y1 < y0 )
EXCHG( y0, y1 ); EXCHG( y0, y1 );
dy = y0 / g_GridRoutingSize; dy = y0 / Board.m_GridRouting;
lim = y1 / g_GridRoutingSize; lim = y1 / Board.m_GridRouting;
dx = x0 / g_GridRoutingSize; dx = x0 / Board.m_GridRouting;
/* Clipping limits of board. */ /* Clipping limits of board. */
if( ( dx < 0 ) || ( dx >= Ncols ) ) if( ( dx < 0 ) || ( dx >= Ncols ) )
return; return;
@ -429,9 +429,9 @@ void TraceLignePcb( int x0,
{ {
if( x1 < x0 ) if( x1 < x0 )
EXCHG( x0, x1 ); EXCHG( x0, x1 );
dx = x0 / g_GridRoutingSize; dx = x0 / Board.m_GridRouting;
lim = x1 / g_GridRoutingSize; lim = x1 / Board.m_GridRouting;
dy = y0 / g_GridRoutingSize; dy = y0 / Board.m_GridRouting;
/* Clipping limits of board. */ /* Clipping limits of board. */
if( ( dy < 0 ) || ( dy >= Nrows ) ) if( ( dy < 0 ) || ( dy >= Nrows ) )
return; return;
@ -455,13 +455,13 @@ void TraceLignePcb( int x0,
EXCHG( x1, x0 ); EXCHG( y1, y0 ); EXCHG( x1, x0 ); EXCHG( y1, y0 );
} }
dx = x0 / g_GridRoutingSize; dx = x0 / Board.m_GridRouting;
lim = x1 / g_GridRoutingSize; lim = x1 / Board.m_GridRouting;
dy = y0 / g_GridRoutingSize; dy = y0 / Board.m_GridRouting;
inc = 1; if( y1 < y0 ) inc = 1; if( y1 < y0 )
inc = -1; inc = -1;
il = lim - dx; cumul = il / 2; il = lim - dx; cumul = il / 2;
delta = abs( y1 - y0 ) / g_GridRoutingSize; delta = abs( y1 - y0 ) / Board.m_GridRouting;
for( ; dx <= lim; ) for( ; dx <= lim; )
{ {
@ -489,15 +489,15 @@ void TraceLignePcb( int x0,
EXCHG( y1, y0 ); EXCHG( y1, y0 );
} }
dy = y0 / g_GridRoutingSize; dy = y0 / Board.m_GridRouting;
lim = y1 / g_GridRoutingSize; lim = y1 / Board.m_GridRouting;
dx = x0 / g_GridRoutingSize; dx = x0 / Board.m_GridRouting;
inc = 1; inc = 1;
if( x1 < x0 ) if( x1 < x0 )
inc = -1; inc = -1;
il = lim - dy; cumul = il / 2; il = lim - dy; cumul = il / 2;
delta = abs( x1 - x0 ) / g_GridRoutingSize; delta = abs( x1 - x0 ) / Board.m_GridRouting;
for( ; dy <= lim; ) for( ; dy <= lim; )
{ {
@ -576,13 +576,13 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
uy1 -= Pcb->m_BoundaryBox.m_Pos.y; uy1 -= Pcb->m_BoundaryBox.m_Pos.y;
/* Calculating limits coord cells belonging to the rectangle. */ /* Calculating limits coord cells belonging to the rectangle. */
row_max = uy1 / g_GridRoutingSize; row_max = uy1 / Board.m_GridRouting;
col_max = ux1 / g_GridRoutingSize; col_max = ux1 / Board.m_GridRouting;
row_min = uy0 / g_GridRoutingSize; row_min = uy0 / Board.m_GridRouting;
if( uy0 > row_min * g_GridRoutingSize ) if( uy0 > row_min * Board.m_GridRouting )
row_min++; row_min++;
col_min = ux0 / g_GridRoutingSize; col_min = ux0 / Board.m_GridRouting;
if( ux0 > col_min * g_GridRoutingSize ) if( ux0 > col_min * Board.m_GridRouting )
col_min++; col_min++;
if( row_min < 0 ) if( row_min < 0 )
@ -673,13 +673,13 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
+ (double) ( cy - uy0 ) * ( cy - uy0 ) ); + (double) ( cy - uy0 ) * ( cy - uy0 ) );
/* Calculating coordinate limits belonging to the rectangle. */ /* Calculating coordinate limits belonging to the rectangle. */
row_max = ( cy + radius ) / g_GridRoutingSize; row_max = ( cy + radius ) / Board.m_GridRouting;
col_max = ( cx + radius ) / g_GridRoutingSize; col_max = ( cx + radius ) / Board.m_GridRouting;
row_min = ( cy - radius ) / g_GridRoutingSize; row_min = ( cy - radius ) / Board.m_GridRouting;
if( uy0 > row_min * g_GridRoutingSize ) if( uy0 > row_min * Board.m_GridRouting )
row_min++; row_min++;
col_min = ( cx - radius ) / g_GridRoutingSize; col_min = ( cx - radius ) / Board.m_GridRouting;
if( ux0 > col_min * g_GridRoutingSize ) if( ux0 > col_min * Board.m_GridRouting )
col_min++; col_min++;
if( row_min < 0 ) if( row_min < 0 )
@ -695,8 +695,8 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
{ {
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
{ {
rotrow = row * g_GridRoutingSize; rotrow = row * Board.m_GridRouting;
rotcol = col * g_GridRoutingSize; rotcol = col * Board.m_GridRouting;
RotatePoint( &rotcol, &rotrow, cx, cy, -angle ); RotatePoint( &rotcol, &rotrow, cx, cy, -angle );
if( rotrow <= uy0 ) if( rotrow <= uy0 )
continue; continue;
@ -715,10 +715,10 @@ void TraceFilledRectangle( BOARD* Pcb, int ux0, int uy0, int ux1, int uy1,
} }
/* Fills all cells BOARD contained in the segment /* Fills all cells inside a segment
* half-width lg, org ux, ux end y0, y1 is set to color. * half-width lg, org ux, ux end y0, y1
* coordinates in PCB units (0.1 million) relating to the origin * is set to color.
* pt_pcb-> m_PcbBox.m_Xmin, Y's board. * coordinates are in PCB units (0.1 mil) are relative to the Board
*/ */
void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer, void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
int color, int op_logique ) int color, int op_logique )
@ -768,24 +768,24 @@ void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
if( uy1 < uy0 ) if( uy1 < uy0 )
inc = -1; inc = -1;
demi_pas = g_GridRoutingSize / 2; demi_pas = Board.m_GridRouting / 2;
col_min = ( ux0 - lg ) / g_GridRoutingSize; col_min = ( ux0 - lg ) / Board.m_GridRouting;
if( col_min < 0 ) if( col_min < 0 )
col_min = 0; col_min = 0;
col_max = ( ux1 + lg + demi_pas ) / g_GridRoutingSize; col_max = ( ux1 + lg + demi_pas ) / Board.m_GridRouting;
if( col_max > ( Ncols - 1 ) ) if( col_max > ( Ncols - 1 ) )
col_max = Ncols - 1; col_max = Ncols - 1;
if( inc > 0 ) if( inc > 0 )
{ {
row_min = ( uy0 - lg ) / g_GridRoutingSize; row_min = ( uy0 - lg ) / Board.m_GridRouting;
row_max = ( uy1 + lg + demi_pas ) / g_GridRoutingSize; row_max = ( uy1 + lg + demi_pas ) / Board.m_GridRouting;
} }
else else
{ {
row_min = ( uy1 - lg ) / g_GridRoutingSize; row_min = ( uy1 - lg ) / Board.m_GridRouting;
row_max = ( uy0 + lg + demi_pas ) / g_GridRoutingSize; row_max = ( uy0 + lg + demi_pas ) / Board.m_GridRouting;
} }
if( row_min < 0 ) if( row_min < 0 )
@ -813,10 +813,10 @@ void DrawSegmentQcq( int ux0, int uy0, int ux1, int uy1, int lg, int layer,
for( col = col_min; col <= col_max; col++ ) for( col = col_min; col <= col_max; col++ )
{ {
int cxr; int cxr;
cxr = ( col * g_GridRoutingSize ) - ux0; cxr = ( col * Board.m_GridRouting ) - ux0;
for( row = row_min; row <= row_max; row++ ) for( row = row_min; row <= row_max; row++ )
{ {
cy = (row * g_GridRoutingSize) - uy0; cy = (row * Board.m_GridRouting) - uy0;
cx = cxr; cx = cxr;
RotatePoint( &cx, &cy, angle ); RotatePoint( &cx, &cy, angle );
if( abs( cy ) > lg ) if( abs( cy ) > lg )

2
pcbnew/ioascii.cpp
View File

@ -649,8 +649,6 @@ static int WriteSetup( FILE* aFile, PCB_BASE_FRAME* aFrame, BOARD* aBoard )
sprintf( text, "InternalUnit %f INCH\n", 1.0 / PCB_INTERNAL_UNIT ); sprintf( text, "InternalUnit %f INCH\n", 1.0 / PCB_INTERNAL_UNIT );
fprintf( aFile, "%s", text ); fprintf( aFile, "%s", text );
fprintf( aFile, "ZoneGridSize %d\n", g_GridRoutingSize );
fprintf( aFile, "Layers %d\n", aBoard->GetCopperLayerCount() ); fprintf( aFile, "Layers %d\n", aBoard->GetCopperLayerCount() );
unsigned layerMask = unsigned layerMask =

24
pcbnew/solve.cpp
View File

@ -280,13 +280,13 @@ int PCB_EDIT_FRAME::Solve( wxDC* DC, int two_sides )
pt_cur_ch = pt_cur_ch; pt_cur_ch = pt_cur_ch;
segm_oX = GetBoard()->m_BoundaryBox.m_Pos.x + segm_oX = GetBoard()->m_BoundaryBox.m_Pos.x +
(g_GridRoutingSize * col_source); (Board.m_GridRouting * col_source);
segm_oY = GetBoard()->m_BoundaryBox.m_Pos.y + segm_oY = GetBoard()->m_BoundaryBox.m_Pos.y +
(g_GridRoutingSize * row_source); (Board.m_GridRouting * row_source);
segm_fX = GetBoard()->m_BoundaryBox.m_Pos.x + segm_fX = GetBoard()->m_BoundaryBox.m_Pos.x +
(g_GridRoutingSize * col_target); (Board.m_GridRouting * col_target);
segm_fY = GetBoard()->m_BoundaryBox.m_Pos.y + segm_fY = GetBoard()->m_BoundaryBox.m_Pos.y +
(g_GridRoutingSize * row_target); (Board.m_GridRouting * row_target);
/* Draw segment. */ /* Draw segment. */
GRLine( &DrawPanel->m_ClipBox, GRLine( &DrawPanel->m_ClipBox,
@ -434,9 +434,9 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe,
* On the routing grid (1 grid point must be in the pad) * On the routing grid (1 grid point must be in the pad)
*/ */
{ {
int cX = ( g_GridRoutingSize * col_source ) int cX = ( Board.m_GridRouting * col_source )
+ pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x; + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x;
int cY = ( g_GridRoutingSize * row_source ) int cY = ( Board.m_GridRouting * row_source )
+ pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y; + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y;
int dx = pt_cur_ch->m_PadStart->m_Size.x / 2; int dx = pt_cur_ch->m_PadStart->m_Size.x / 2;
int dy = pt_cur_ch->m_PadStart->m_Size.y / 2; int dy = pt_cur_ch->m_PadStart->m_Size.y / 2;
@ -448,9 +448,9 @@ static int Autoroute_One_Track( PCB_EDIT_FRAME* pcbframe,
if( ( abs( cX - px ) > dx ) || ( abs( cY - py ) > dy ) ) if( ( abs( cX - px ) > dx ) || ( abs( cY - py ) > dy ) )
goto end_of_route; goto end_of_route;
cX = ( g_GridRoutingSize * col_target ) cX = ( Board.m_GridRouting * col_target )
+ pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x; + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.x;
cY = ( g_GridRoutingSize * row_target ) cY = ( Board.m_GridRouting * row_target )
+ pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y; + pcbframe->GetBoard()->m_BoundaryBox.m_Pos.y;
dx = pt_cur_ch->m_PadEnd->m_Size.x / 2; dx = pt_cur_ch->m_PadEnd->m_Size.x / 2;
dy = pt_cur_ch->m_PadEnd->m_Size.y / 2; dy = pt_cur_ch->m_PadEnd->m_Size.y / 2;
@ -1118,11 +1118,11 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
g_CurrentTrackSegment->m_Start.x = g_CurrentTrackSegment->m_Start.x =
g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x + g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x +
( g_GridRoutingSize * row ); ( Board.m_GridRouting * row );
g_CurrentTrackSegment->m_Start.y = g_CurrentTrackSegment->m_Start.y =
g_CurrentTrackSegment->m_End.y = pcb->m_BoundaryBox.m_Pos.y + g_CurrentTrackSegment->m_End.y = pcb->m_BoundaryBox.m_Pos.y +
( g_GridRoutingSize * col ); ( Board.m_GridRouting * col );
g_CurrentTrackSegment->m_Width = pcb->GetCurrentViaSize(); g_CurrentTrackSegment->m_Width = pcb->GetCurrentViaSize();
g_CurrentTrackSegment->m_Shape = pcb->GetBoardDesignSettings()->m_CurrentViaType; g_CurrentTrackSegment->m_Shape = pcb->GetBoardDesignSettings()->m_CurrentViaType;
@ -1141,9 +1141,9 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
g_CurrentTrackSegment->SetState( TRACK_AR, ON ); g_CurrentTrackSegment->SetState( TRACK_AR, ON );
g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x + g_CurrentTrackSegment->m_End.x = pcb->m_BoundaryBox.m_Pos.x +
( g_GridRoutingSize * row ); ( Board.m_GridRouting * row );
g_CurrentTrackSegment->m_End.y = pcb->m_BoundaryBox.m_Pos.y + g_CurrentTrackSegment->m_End.y = pcb->m_BoundaryBox.m_Pos.y +
( g_GridRoutingSize * col ); ( Board.m_GridRouting * col );
g_CurrentTrackSegment->SetNet( current_net_code ); g_CurrentTrackSegment->SetNet( current_net_code );
if( g_CurrentTrackSegment->Back() == NULL ) /* Start trace. */ if( g_CurrentTrackSegment->Back() == NULL ) /* Start trace. */