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

Werner Almesberger's patches

This commit is contained in:
dickelbeck 2008-02-26 21:12:08 +00:00
parent 5977accf6e
commit 30932a4607
5 changed files with 611 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
pcbnew/class_track.cpp
View File

@ -890,10 +890,8 @@ bool TRACK::HitTest( const wxPoint& ref_pos )
if( Type() == TYPEVIA ) /* VIA rencontree */ if( Type() == TYPEVIA ) /* VIA rencontree */
{ {
if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) ) return (int64_t) spot_cX*spot_cX + (int64_t) spot_cY*spot_cY <=
return true; (int64_t) l_piste*l_piste;
else
return false;
} }
else else
{ {

192
pcbnew/controle.cpp
View File

@ -219,6 +219,152 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
} }
/*
* "Join" finds the point where b0+x*(b1-b0) intersects with a0+y*(a1-a0).
* If that point would be outside of a0-a1, the respective endpoint is used.
* Join returns the point in "res" and "true" if a suitable point was found,
* "false" if both lines are parallel.
*/
static bool Join( wxPoint& res, wxPoint a0, wxPoint a1, wxPoint b0, wxPoint b1 )
{
int64_t denom;
double t;
a1 -= a0;
b1 -= b0;
b0 -= a0;
denom = (int64_t) b1.y*a1.x - (int64_t) b1.x*a1.y;
if (!denom)
return false; // parallel
t = ((int64_t) b1.y*b0.x - (int64_t) b1.x*b0.y)/(double) denom;
t = min( max( t, 0.0 ), 1.0 );
res.x = (int) round(a0.x+t*a1.x);
res.y = (int) round(a0.y+t*a1.y);
return true;
}
/*
* "Project" finds the projection of a grid point on a track. This is the point
* from where we want to draw new orthogonal tracks when starting on a track.
*/
bool Project( wxPoint& res, wxPoint on_grid, const TRACK* track )
{
wxPoint vec;
double t;
if( track->m_Start == track->m_End )
return false;
vec = track->m_End-track->m_Start;
t = (int64_t) (on_grid.x-track->m_Start.x)*vec.x +
(int64_t) (on_grid.y-track->m_Start.y)*vec.y;
t /= (int64_t) vec.x*vec.x + (int64_t) vec.y*vec.y;
t = min( max( t, 0.0 ), 1.0 );
res.x = (int) round( track->m_Start.x + t*vec.x );
res.y = (int) round( track->m_Start.y + t*vec.y );
return true;
}
static bool Magnetize( BOARD* m_Pcb, WinEDA_PcbFrame* frame,
int m_ID_current_state, wxSize grid, wxPoint on_grid, wxPoint& curpos )
{
const D_PAD* pad;
const TRACK* curr = NULL;
const TRACK* via, * track;
int layer, layer_mask;
bool sometimes = g_MagneticPadOption != capture_always && Drc_On;
curr = g_CurrentTrackSegment;
if( frame->GetCurItem() != curr )
curr = NULL;
switch( g_MagneticPadOption )
{
case capture_cursor_in_track_tool:
if( m_ID_current_state != ID_TRACK_BUTT )
return false;
break;
case capture_always:
break;
case no_effect:
default:
return false;
}
pad = Locate_Any_Pad( m_Pcb, CURSEUR_OFF_GRILLE, TRUE );
if( pad )
{
if( curr && curr->GetNet() != pad->GetNet() && sometimes )
return false;
curpos = pad->m_Pos;
return true;
}
layer = ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer;
via = Locate_Via_Area( m_Pcb, curpos, layer );
if( via )
{
if( curr && curr->GetNet() != via->GetNet() && sometimes )
return false;
curpos = via->m_Start;
return true;
}
layer_mask = g_TabOneLayerMask[layer];
if( !curr )
{
track = Locate_Pistes( m_Pcb->m_Track, layer_mask, CURSEUR_OFF_GRILLE );
if( !track || track->Type() != TYPETRACK )
return false;
return Project( curpos, on_grid, track );
}
/*
* In two segment mode, ignore the final segment if it's inside a grid
* square.
*/
if( g_TwoSegmentTrackBuild && curr->Pback
&& curr->m_Start.x - grid.x < curr->m_End.x
&& curr->m_Start.x + grid.x > curr->m_End.x
&& curr->m_Start.y - grid.y < curr->m_End.y
&& curr->m_Start.y + grid.y > curr->m_End.y )
curr = curr->Back();
track = Locate_Pistes( m_Pcb->m_Track, layer_mask, CURSEUR_OFF_GRILLE );
for( ; track; track = track->Next() )
{
if( track->Type() != TYPETRACK )
continue;
if( curr->GetNet() != track->GetNet() && sometimes )
continue;
if( Join( curpos, track->m_Start, track->m_End,
curr->m_Start, curr->m_End ) )
return true;
}
return false;
}
/****************************************************************/ /****************************************************************/
void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse ) void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
/*****************************************************************/ /*****************************************************************/
@ -341,7 +487,6 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
* But if the tool DELETE is active the cursor is left off grid * But if the tool DELETE is active the cursor is left off grid
* this is better to reach items to delete off grid * this is better to reach items to delete off grid
*/ */
D_PAD* pad;
bool keep_on_grid = TRUE; bool keep_on_grid = TRUE;
if( m_ID_current_state == ID_PCB_DELETE_ITEM_BUTT ) if( m_ID_current_state == ID_PCB_DELETE_ITEM_BUTT )
keep_on_grid = FALSE; keep_on_grid = FALSE;
@ -354,34 +499,27 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
if( DrawStruct && DrawStruct->m_Flags ) if( DrawStruct && DrawStruct->m_Flags )
keep_on_grid = TRUE; keep_on_grid = TRUE;
switch( g_MagneticPadOption ) if (keep_on_grid) {
{ wxPoint on_grid = curpos;
case capture_cursor_in_track_tool:
case capture_always:
pad = Locate_Any_Pad( m_Pcb, CURSEUR_OFF_GRILLE, TRUE );
if( (m_ID_current_state != ID_TRACK_BUTT )
&& (g_MagneticPadOption == capture_cursor_in_track_tool) )
pad = NULL;
if( keep_on_grid ) PutOnGrid(&on_grid);
{ if (Magnetize(m_Pcb, (WinEDA_PcbFrame *) this, m_ID_current_state,
if( pad ) // Put cursor on the pad GetScreen()->GetGrid(), on_grid, curpos))
GetScreen()->m_Curseur = curpos = pad->m_Pos; GetScreen()->m_Curseur = curpos;
else else {
// Put cursor on grid extern TRACK *LocateIntrusion(TRACK *start, int net, int width);
PutOnGrid( &GetScreen()->m_Curseur );
/*
* If there's an intrusion and DRC is active, we pass the cursor
* "as is", and let ShowNewTrackWhenMovingCursor figure our what to
* do.
*/
if (!Drc_On || !g_CurrentTrackSegment ||
g_CurrentTrackSegment != this->GetCurItem() ||
!LocateIntrusion(m_Pcb->m_Track, g_CurrentTrackSegment->GetNet(),
g_CurrentTrackSegment->m_Width))
GetScreen()->m_Curseur = on_grid;
} }
break;
case no_effect:
default:
// If we are not in delete function, put cursor on grid
if( keep_on_grid )
{
PutOnGrid( &GetScreen()->m_Curseur );
}
break;
} }
if( oldpos != GetScreen()->m_Curseur ) if( oldpos != GetScreen()->m_Curseur )

151
pcbnew/editrack.cpp
View File

@ -18,7 +18,7 @@
static void Exit_Editrack( WinEDA_DrawPanel* panel, wxDC* DC ); static void Exit_Editrack( WinEDA_DrawPanel* panel, wxDC* DC );
void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel,
wxDC* DC, bool erase ); wxDC* DC, bool erase );
static void ComputeBreakPoint( TRACK* track, int n ); static void ComputeBreakPoint( TRACK* track, int n, wxPoint end );
static TRACK* DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount ); static TRACK* DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount );
static void EnsureEndTrackOnPad( D_PAD* Pad ); static void EnsureEndTrackOnPad( D_PAD* Pad );
@ -493,6 +493,120 @@ void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
SetCurItem( NULL ); SetCurItem( NULL );
} }
/*
* PushTrack detecs if the mouse is pointing into a conflicting track.
* In this case, it tries to push the new track out of the conflicting track's
* clearance zone. This gives us a cheap mechanism for drawing tracks that
* tightly follow others, independent of grid settings.
*
* KNOWN BUGS:
* - we do the same sort of search and calculation up to three times:
* 1) we search for magnetic hits (in controle.cpp)
* 2) we check if there's a DRC violation in the making (also controle.cpp)
* 3) we try to fix the DRC violation (here)
* - if we have a magnetic hit and a DRC violation at the same time, we choose
* the magnetic hit instead of solving the violation
* - should locate conflicting tracks also when we're crossing over them
* - we obviously shouldn't access functions through "extern" or have #includes
* in the middle of the file
*/
#include "trigo.h"
extern bool Project(wxPoint &res, wxPoint on_grid, const TRACK *track);
TRACK *LocateIntrusion(TRACK *start, int net, int width)
{
int layer = ((PCB_SCREEN *) ActiveScreen)->m_Active_Layer;
int layer_mask = g_TabOneLayerMask[layer];
wxPoint ref = ActiveScreen->RefPos(1);
TRACK *track, *found = NULL;
for (track = start; track; track = track->Next()) {
int dist;
wxPoint pos, vec;
int64_t tmp;
/* Locate_Pistes */
if (track->GetState(BUSY | DELETED))
continue;
if (!(g_TabOneLayerMask[track->GetLayer()] & layer_mask))
continue;
if (track->GetNet() == net)
continue;
if (track->Type() == TYPEVIA)
continue;
/* TRACK::HitTest */
dist = width/2 + track->m_Width/2 + g_DesignSettings.m_TrackClearence;
pos = ref-track->m_Start;
vec = track->m_End-track->m_Start;
if (!DistanceTest(dist, vec.x, vec.y, pos.x, pos.y))
continue;
found = track;
/* prefer intrusions from the side, not the end */
tmp = (int64_t) pos.x*vec.x + (int64_t) pos.y*vec.y;
if (tmp >= 0 && tmp <= (int64_t) vec.x*vec.x + (int64_t) vec.y*vec.y)
break;
}
return found;
}
static void PushTrack(WinEDA_DrawPanel *panel)
{
BOARD *pcb = ((WinEDA_BasePcbFrame *) (panel->m_Parent))->m_Pcb;
wxPoint cursor = ActiveScreen->m_Curseur;
wxPoint cv, vec, n;
TRACK *track = g_CurrentTrackSegment;
TRACK *other;
int64_t det;
int dist;
double f;
other = LocateIntrusion(pcb->m_Track, track->GetNet(), track->m_Width);
/* are we currently pointing into a conflicting trace ? */
if (!other)
return;
if (other->GetNet() == track->GetNet())
return;
cv = cursor-other->m_Start;
vec = other->m_End-other->m_Start;
det = (int64_t) cv.x*vec.y - (int64_t) cv.y*vec.x;
/* cursor is right at the center of the old track */
if (!det)
return;
dist = (track->m_Width+1)/2 + (other->m_Width+1)/2 +
g_DesignSettings.m_TrackClearence+2;
/*
* DRC wants >, so +1.
* We may have a quantization error of 1/sqrt(2), so +1 again.
*/
/* Vector "n" is perpendicular to "other", pointing towards the cursor. */
if (det > 0) {
n.x = vec.y;
n.y = -vec.x;
}
else {
n.x = -vec.y;
n.y = vec.x;
}
f = dist/hypot(n.x, n.y);
n.x = (int) round(f*n.x);
n.y = (int) round(f*n.y);
Project(track->m_End, cursor, other);
track->m_End += n;
}
/****************************************************************************/ /****************************************************************************/
void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase ) void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
@ -538,8 +652,13 @@ void ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool erase
if( Track_45_Only ) if( Track_45_Only )
{ {
if( g_TwoSegmentTrackBuild ) if( g_TwoSegmentTrackBuild ) {
ComputeBreakPoint( g_CurrentTrackSegment, g_TrackSegmentCount ); g_CurrentTrackSegment->m_End = ActiveScreen->m_Curseur;
if (Drc_On)
PushTrack(panel);
ComputeBreakPoint( g_CurrentTrackSegment, g_TrackSegmentCount,
g_CurrentTrackSegment->m_End);
}
else else
{ {
/* Calcul de l'extremite de la piste pour orientations permises: /* Calcul de l'extremite de la piste pour orientations permises:
@ -625,7 +744,7 @@ void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy )
/********************************************************/ /********************************************************/
void ComputeBreakPoint( TRACK* track, int SegmentCount ) void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
/********************************************************/ /********************************************************/
/** /**
@ -646,8 +765,8 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
SegmentCount--; SegmentCount--;
if( track ) if( track )
{ {
iDx = ActiveScreen->m_Curseur.x - track->m_Start.x; iDx = end.x - track->m_Start.x;
iDy = ActiveScreen->m_Curseur.y - track->m_Start.y; iDy = end.y - track->m_Start.y;
iDx = abs( iDx ); iDx = abs( iDx );
iDy = abs( iDy ); iDy = abs( iDy );
@ -680,10 +799,10 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
break; break;
case 0: case 0:
if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 ) if( (end.x - track->m_Start.x) < 0 )
track->m_End.x = ActiveScreen->m_Curseur.x + iDy; track->m_End.x = end.x + iDy;
else else
track->m_End.x = ActiveScreen->m_Curseur.x - iDy; track->m_End.x = end.x - iDy;
track->m_End.y = track->m_Start.y; track->m_End.y = track->m_Start.y;
break; break;
@ -691,19 +810,19 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
iDx = MIN( iDx, iDy ); iDx = MIN( iDx, iDy );
iDy = iDx; iDy = iDx;
/* recalcul des signes de deltax et deltay */ /* recalcul des signes de deltax et deltay */
if( (ActiveScreen->m_Curseur.x - track->m_Start.x) < 0 ) if( (end.x - track->m_Start.x) < 0 )
iDx = -iDx; iDx = -iDx;
if( (ActiveScreen->m_Curseur.y - track->m_Start.y) < 0 ) if( (end.y - track->m_Start.y) < 0 )
iDy = -iDy; iDy = -iDy;
track->m_End.x = track->m_Start.x + iDx; track->m_End.x = track->m_Start.x + iDx;
track->m_End.y = track->m_Start.y + iDy; track->m_End.y = track->m_Start.y + iDy;
break; break;
case 90: case 90:
if( (ActiveScreen->m_Curseur.y - track->m_Start.y) < 0 ) if( (end.y - track->m_Start.y) < 0 )
track->m_End.y = ActiveScreen->m_Curseur.y + iDx; track->m_End.y = end.y + iDx;
else else
track->m_End.y = ActiveScreen->m_Curseur.y - iDx; track->m_End.y = end.y - iDx;
track->m_End.x = track->m_Start.x; track->m_End.x = track->m_Start.x;
break; break;
} }
@ -711,10 +830,10 @@ void ComputeBreakPoint( TRACK* track, int SegmentCount )
if( track ) if( track )
{ {
if( track->IsNull() ) if( track->IsNull() )
track->m_End = ActiveScreen->m_Curseur; track->m_End = end;
NewTrack->m_Start = track->m_End; NewTrack->m_Start = track->m_End;
} }
NewTrack->m_End = ActiveScreen->m_Curseur; NewTrack->m_End = end;
} }

28
pcbnew/locate.cpp
View File

@ -111,6 +111,34 @@ TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer )
} }
/*******************************************************************/
TRACK* Locate_Via_Area( BOARD* Pcb, const wxPoint& pos, int layer )
/*******************************************************************/
/*
* Like Locate_Via, but finds any via covering the cursor position
*/
{
TRACK* Track;
for( Track = Pcb->m_Track; Track != NULL; Track = Track->Next() )
{
if( Track->Type() != TYPEVIA )
continue;
if(!Track->HitTest(pos))
continue;
if( Track->GetState( BUSY | DELETED ) )
continue;
if( layer < 0 )
return Track;
if( Track->IsOnLayer( layer ) )
return Track;
}
return NULL;
}
/********************************************************************/ /********************************************************************/
D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_piste, int extr ) D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_piste, int extr )
/********************************************************************/ /********************************************************************/

288
pcbnew/protos.h
View File

@ -9,9 +9,11 @@
/* PAD_CONNECT.CPP */ /* PAD_CONNECT.CPP */
/***************/ /***************/
LISTE_PAD* CreateSortedPadListByXCoord( BOARD* pcb ); LISTE_PAD* CreateSortedPadListByXCoord( BOARD* pcb );
/* Create a sorted list of pointers to pads. /* Create a sorted list of pointers to pads.
This list is sorted by X ccordinate value. * This list is sorted by X ccordinate value.
The list must be freed bu user */ * The list must be freed bu user
*/
/**************/ /**************/
/* PCBCFG.CPP */ /* PCBCFG.CPP */
@ -29,20 +31,28 @@ void Trace_MirePcb(WinEDA_DrawPanel * panel, wxDC * DC, MIREPCB * MirePcb, int m
/***************/ /***************/
void Trace_Pistes( WinEDA_DrawPanel* panel, BOARD* Pcb, wxDC* DC, int drawmode ); void Trace_Pistes( WinEDA_DrawPanel* panel, BOARD* Pcb, wxDC* DC, int drawmode );
void Trace_Une_Piste(WinEDA_DrawPanel * panel, wxDC * DC, TRACK * pt_start_piste,int nbsegment, int mode_color); void Trace_Une_Piste( WinEDA_DrawPanel* panel,
wxDC* DC,
TRACK* pt_start_piste,
int nbsegment,
int mode_color );
/* routine de trace de n segments consecutifs en memoire. /* routine de trace de n segments consecutifs en memoire.
Utile pour monter une piste en cours de trace car les segments de cette * Utile pour monter une piste en cours de trace car les segments de cette
piste sont alors contigus en memoire * piste sont alors contigus en memoire
Parametres : * Parametres :
pt_start_piste = adresse de depart de la liste des segments * pt_start_piste = adresse de depart de la liste des segments
nbsegment = nombre de segments a tracer * nbsegment = nombre de segments a tracer
mode_color = mode ( GrXOR, GrOR..) * mode_color = mode ( GrXOR, GrOR..)
ATTENTION: * ATTENTION:
le point de depart d'une piste suivante DOIT exister: peut etre * le point de depart d'une piste suivante DOIT exister: peut etre
donc mis a 0 avant appel a la routine si la piste a tracer est la derniere * donc mis a 0 avant appel a la routine si la piste a tracer est la derniere
*/ */
void Trace_DrawSegmentPcb(WinEDA_DrawPanel * panel, wxDC * DC, DRAWSEGMENT * PtDrawSegment,int mode_color); void Trace_DrawSegmentPcb( WinEDA_DrawPanel* panel,
wxDC* DC,
DRAWSEGMENT* PtDrawSegment,
int mode_color );
/****************/ /****************/
@ -50,135 +60,152 @@ void Trace_DrawSegmentPcb(WinEDA_DrawPanel * panel, wxDC * DC, DRAWSEGMENT * PtD
/****************/ /****************/
void Trace_Pads_Only( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* Module, int ox, int oy, void Trace_Pads_Only( WinEDA_DrawPanel* panel, wxDC* DC, MODULE* Module, int ox, int oy,
int MasqueLayer, int mode_color ); int MasqueLayer, int mode_color );
/* Trace les pads d'un module en mode SKETCH. /* Trace les pads d'un module en mode SKETCH.
Utilisee pour afficher les pastilles d'un module lorsque celui ci n'est * Utilisee pour afficher les pastilles d'un module lorsque celui ci n'est
pas affiche par les options d'affichage des Modules * pas affiche par les options d'affichage des Modules
Les pads affiches doivent apparaitre sur les couches donnees par * Les pads affiches doivent apparaitre sur les couches donnees par
MasqueLayer */ * MasqueLayer */
/****************/ /****************/
/* LOCATE.CPP : */ /* LOCATE.CPP : */
/****************/ /****************/
MODULE* ReturnModule( BOARD* Pcb, const wxString& name ); MODULE* ReturnModule( BOARD* Pcb, const wxString& name );
/* Recherche d'une empreinte par son nom */ /* Recherche d'une empreinte par son nom */
D_PAD* ReturnPad( MODULE* Module, const wxString& name ); D_PAD* ReturnPad( MODULE* Module, const wxString& name );
/* Recherche d'un pad par son nom, pour le module Module */ /* Recherche d'un pad par son nom, pour le module Module */
TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 ); TRACK* Locate_Via( BOARD* Pcb, const wxPoint& pos, int layer = -1 );
TRACK* Locate_Via_Area( BOARD* Pcb, const wxPoint& pos, int layer = -1 );
TRACK* Fast_Locate_Via( TRACK* start_adr, TRACK* end_adr, TRACK* Fast_Locate_Via( TRACK* start_adr, TRACK* end_adr,
const wxPoint& pos, int masquelayer ); const wxPoint& pos, int masquelayer );
/* Localise la via de centre le point x,y , sur les couches donnees /* Localise la via de centre le point x,y , sur les couches donnees
par masquelayer. * par masquelayer.
la recherche se fait de l'adresse start_adr a end_adr(non comprise) * la recherche se fait de l'adresse start_adr a end_adr(non comprise)
*/ */
TRACK* Fast_Locate_Piste( TRACK* start_adr, TRACK* end_adr, TRACK* Fast_Locate_Piste( TRACK* start_adr, TRACK* end_adr,
const wxPoint& ref_pos, int masquelayer ); const wxPoint& ref_pos, int masquelayer );
/* Localiste le segment dont une extremite coincide avec le point x,y /* Localiste le segment dont une extremite coincide avec le point x,y
sur les couches donnees par masquelayer * sur les couches donnees par masquelayer
la recherche se fait de l'adresse start_adr a end_adr(non comprise) * la recherche se fait de l'adresse start_adr a end_adr(non comprise)
*/ */
TRACK* Locate_Piste_Connectee( TRACK* ptr_piste, TRACK* pt_base, TRACK* Locate_Piste_Connectee( TRACK* ptr_piste, TRACK* pt_base,
TRACK* pt_lim, int extr ); TRACK* pt_lim, int extr );
/* recherche le segment connecte au segment pointe par /* recherche le segment connecte au segment pointe par
ptr_piste: * ptr_piste:
si int = START, le point de debut du segment est utilise * si int = START, le point de debut du segment est utilise
si int = END, le point de fin du segment est utilise * si int = END, le point de fin du segment est utilise
La recherche ne se fait que sur les EXTREMITES des segments * La recherche ne se fait que sur les EXTREMITES des segments
La recherche est limitee a la zone [pt_base...]pt_lim. * La recherche est limitee a la zone [pt_base...]pt_lim.
*/ */
TRACK* Locate_Pistes( TRACK* start_adresse, int layer, int typeloc ); TRACK* Locate_Pistes( TRACK* start_adresse, int layer, int typeloc );
TRACK* Locate_Pistes( TRACK* start_adresse, TRACK* Locate_Pistes( TRACK* start_adresse,
const wxPoint& ref_pos, int layer ); const wxPoint& ref_pos, int layer );
/* /*
1 - routine de localisation du segment de piste pointe par la souris. * 1 - routine de localisation du segment de piste pointe par la souris.
2 - routine de localisation du segment de piste pointe par le point * 2 - routine de localisation du segment de piste pointe par le point
ref_pX , ref_pY. * ref_pX , ref_pY.
*
Si layer < 0 la couche n'est pas testee. * Si layer < 0 la couche n'est pas testee.
*
La recherche commence a l'adresse start_adresse * La recherche commence a l'adresse start_adresse
*/ */
D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_segment, int extr ); D_PAD* Locate_Pad_Connecte( BOARD* Pcb, TRACK* ptr_segment, int extr );
/* localisation de la pastille connectee au debut ou fin du segment /* localisation de la pastille connectee au debut ou fin du segment
entree : pointeur sur le segment, et flag = START ou END * entree : pointeur sur le segment, et flag = START ou END
retourne: * retourne:
un pointeur sur la description de la pastille si localisation * un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee */ * pointeur NULL si pastille non trouvee */
D_PAD* Locate_Any_Pad( BOARD* Pcb, int typeloc, bool OnlyCurrentLayer = FALSE ); D_PAD* Locate_Any_Pad( BOARD* Pcb, int typeloc, bool OnlyCurrentLayer = FALSE );
D_PAD* Locate_Any_Pad( BOARD* Pcb, const wxPoint& ref_pos, bool OnlyCurrentLayer = FALSE ); D_PAD* Locate_Any_Pad( BOARD* Pcb, const wxPoint& ref_pos, bool OnlyCurrentLayer = FALSE );
/* /*
localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou * localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou
par la souris, recherche faite sur toutes les empreintes. * par la souris, recherche faite sur toutes les empreintes.
entree : (OVERHAEAD) * entree : (OVERHAEAD)
- coord souris (Curseur_X et Curseur_Y) * - coord souris (Curseur_X et Curseur_Y)
ou ref_pX, ref_pY * ou ref_pX, ref_pY
retourne: * retourne:
pointeur sur la description de la pastille si localisation * pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee * pointeur NULL si pastille non trouvee
*/ */
D_PAD* Locate_Pads( MODULE* Module, int layer, int typeloc ); D_PAD* Locate_Pads( MODULE* Module, int layer, int typeloc );
D_PAD* Locate_Pads( MODULE* Module, const wxPoint& ref_pos, int layer ); D_PAD* Locate_Pads( MODULE* Module, const wxPoint& ref_pos, int layer );
/* localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou /* localisation de la pastille pointee par la coordonnee ref_pX,,ref_pY, ou
par la souris, concernant l'empreinte en cours. * par la souris, concernant l'empreinte en cours.
entree : * entree :
- parametres generaux de l'empreinte mise a jous par caract() * - parametres generaux de l'empreinte mise a jous par caract()
- layer = couche ou doit se trouver la pastille * - layer = couche ou doit se trouver la pastille
(si layer < 0 ) la couche est ignoree) * (si layer < 0 ) la couche est ignoree)
retourne: * retourne:
un pointeur sur la description de la pastille si localisation * un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee * pointeur NULL si pastille non trouvee
*/ */
MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc ); MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc );
/* localisation d'une empreinte par son rectangle d'encadrement */ /* localisation d'une empreinte par son rectangle d'encadrement */
D_PAD* Locate_Pads( MODULE* Module, int typeloc ); D_PAD* Locate_Pads( MODULE* Module, int typeloc );
/* localisation de la pastille pointee par la souris, concernant l'empreinte /* localisation de la pastille pointee par la souris, concernant l'empreinte
Module. * Module.
entree : * entree :
- parametres generaux de l'empreinte mise a jous par caract() * - parametres generaux de l'empreinte mise a jous par caract()
retourne: * retourne:
un pointeur sur la description de la pastille si localisation * un pointeur sur la description de la pastille si localisation
pointeur NULL si pastille non trouvee * pointeur NULL si pastille non trouvee
*/ */
TRACK* Locate_Pistes( TRACK* start_adresse, int typeloc ); TRACK* Locate_Pistes( TRACK* start_adresse, int typeloc );
/* routine de localisation du segment de piste pointe par la souris /* routine de localisation du segment de piste pointe par la souris
La recherche commence a l'adresse start_adresse */ * La recherche commence a l'adresse start_adresse */
DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc ); DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc );
D_PAD* Fast_Locate_Pad_Connecte( BOARD* Pcb, const wxPoint& ref_pos, int layer ); D_PAD* Fast_Locate_Pad_Connecte( BOARD* Pcb, const wxPoint& ref_pos, int layer );
/* Routine cherchant le pad contenant le point px,py, sur la couche layer
( extremite de piste )
La liste des pads doit deja exister.
retourne : /* Routine cherchant le pad contenant le point px,py, sur la couche layer
NULL si pas de pad localise. * ( extremite de piste )
pointeur sur le pad correspondante si pad trouve * La liste des pads doit deja exister.
(bonne position ET bonne couche). */ *
* retourne :
* NULL si pas de pad localise.
* pointeur sur le pad correspondante si pad trouve
* (bonne position ET bonne couche). */
TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc ); TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc );
TRACK* Locate_Zone( TRACK* start_adresse, const wxPoint& ref_pos, int layer ); TRACK* Locate_Zone( TRACK* start_adresse, const wxPoint& ref_pos, int layer );
/* /*
1 - routine de localisation du segment de zone pointe par la souris. * 1 - routine de localisation du segment de zone pointe par la souris.
2 - routine de localisation du segment de zone pointe par le point * 2 - routine de localisation du segment de zone pointe par le point
ref_pX , ref_pY.r * ref_pX , ref_pY.r
*
Si layer == -1 , le tst de la couche n'est pas fait * Si layer == -1 , le tst de la couche n'est pas fait
*
La recherche commence a l'adresse start_adresse * La recherche commence a l'adresse start_adresse
*/ */
@ -201,52 +228,61 @@ void ShowNewTrackWhenMovingCursor(WinEDA_DrawPanel * panel,
wxDC* DC, bool erase ); wxDC* DC, bool erase );
void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy ); void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy );
/* determine les coord fx et fy d'un segment /* determine les coord fx et fy d'un segment
pour avoir un segment oriente a 0, 90 ou 45 degres, selon position * pour avoir un segment oriente a 0, 90 ou 45 degres, selon position
du point d'origine (ox,oy) et de la souris */ * du point d'origine (ox,oy) et de la souris */
/*****************/ /*****************/
/* TRACK.CPP : */ /* TRACK.CPP : */
/*****************/ /*****************/
TRACK* Marque_Une_Piste( WinEDA_BasePcbFrame* frame, wxDC* DC, TRACK* Marque_Une_Piste( WinEDA_BasePcbFrame* frame, wxDC* DC,
TRACK* pt_segm, int* nb_segm, int flagcolor ); TRACK* pt_segm, int* nb_segm, int flagcolor );
/* Routine de Marquage de 1 piste, a partir du segment pointe par pt_segm. /* Routine de Marquage de 1 piste, a partir du segment pointe par pt_segm.
le segment pointe est marque puis les segments adjacents * le segment pointe est marque puis les segments adjacents
jusqu'a un pad ou un point de jonction de plus de 2 segments * jusqu'a un pad ou un point de jonction de plus de 2 segments
le marquage est la mise a 1 du bit BUSY du parametre .status * le marquage est la mise a 1 du bit BUSY du parametre .status
Les segments sont ensuite reclasses pour etre contigus en memoire * Les segments sont ensuite reclasses pour etre contigus en memoire
Retourne: * Retourne:
adresse du 1er segment de la chaine creee * adresse du 1er segment de la chaine creee
nombre de segments */ * nombre de segments */
int ReturnEndsTrack( TRACK* RefTrack, int NbSegm, int ReturnEndsTrack( TRACK* RefTrack, int NbSegm,
TRACK** StartTrack, TRACK** EndTrack ); TRACK** StartTrack, TRACK** EndTrack );
/* Calcule les coordonnes des extremites d'une piste /* Calcule les coordonnes des extremites d'une piste
retourne 1 si OK, 0 si piste bouclee * retourne 1 si OK, 0 si piste bouclee
Les coord sont retournees en StartTrack->ox, oy * Les coord sont retournees en StartTrack->ox, oy
et EndTrack->fx, fy si OK * et EndTrack->fx, fy si OK
Les segments sont supposes chaines de facon consecutive */ * Les segments sont supposes chaines de facon consecutive */
void ListSetState( EDA_BaseStruct* Start, int Nbitem, int State, int onoff ); void ListSetState( EDA_BaseStruct* Start, int Nbitem, int State, int onoff );
/* Met a jour le membre .state d'une chaine de structures */ /* Met a jour le membre .state d'une chaine de structures */
/*****************/ /*****************/
/* EDITEDGE.CPP : */ /* EDITEDGE.CPP : */
/*****************/ /*****************/
void Trace_1_Edge(WinEDA_DrawPanel * panel, wxDC * DC, TRACK * start_edge, int nbpoint, int mode_color); void Trace_1_Edge( WinEDA_DrawPanel* panel,
wxDC* DC,
TRACK* start_edge,
int nbpoint,
int mode_color );
/************/ /************/
/* DRC.CPP : */ /* DRC.CPP : */
/************/ /************/
int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC, int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
TRACK* pt_segment, TRACK* pt_start_buffer, int show_err ); TRACK* pt_segment, TRACK* pt_start_buffer, int show_err );
/* Teste le segment pointe par pt_segment: /* Teste le segment pointe par pt_segment:
debsegment = adresse du segment a tester * debsegment = adresse du segment a tester
pt_start_buffer = adresse de la zone piste * pt_start_buffer = adresse de la zone piste
show_err (flag) si 0 pas d'affichage d'erreur sur ecran * show_err (flag) si 0 pas d'affichage d'erreur sur ecran
retourne : * retourne :
BAD_DRC (1) si Violation DRC * BAD_DRC (1) si Violation DRC
OK_DRC (0) si OK */ * OK_DRC (0) si OK */
/*****************/ /*****************/
@ -263,8 +299,9 @@ void Modif_Auto_Route(TRACK * pt_debut_new_piste) ;
/**************/ /**************/
int Netliste_Controle_piste( WinEDA_PcbFrame* frame, wxDC* DC, int affiche ); int Netliste_Controle_piste( WinEDA_PcbFrame* frame, wxDC* DC, int affiche );
/* Supprime les segments mal connectes, cad interconnectant des segments /* Supprime les segments mal connectes, cad interconnectant des segments
de net_code differents */ * de net_code differents */
/************/ /************/
@ -272,13 +309,14 @@ int Netliste_Controle_piste(WinEDA_PcbFrame * frame, wxDC * DC, int affiche);
/************/ /************/
void Block_Affiche( int on_off ); /* void Block_Affiche( int on_off ); /*
routine de trace du cadre d'un Block en cours de delimitation * routine de trace du cadre d'un Block en cours de delimitation
Si on_off = 0 : effacement du cadre * Si on_off = 0 : effacement du cadre
Si on_off = 1 : affichage du cadre */ * Si on_off = 1 : affichage du cadre */
void Trace_Block( WinEDA_DrawPanel* panel, wxDC* DC, int ox, int oy, int fx, int fy, int color ); void Trace_Block( WinEDA_DrawPanel* panel, wxDC* DC, int ox, int oy, int fx, int fy, int color );
/* Routine de trace d'un rectangle symbolisant un block /* Routine de trace d'un rectangle symbolisant un block
(toujours en mode XOR) */ * (toujours en mode XOR) */
/***************/ /***************/
/* PLOT_RTN.CPP */ /* PLOT_RTN.CPP */
@ -302,11 +340,12 @@ int Propagation(WinEDA_PcbFrame * frame);
/***************/ /***************/
void MasqueAttributs( int* masque_set, int* masque_clr ); void MasqueAttributs( int* masque_set, int* masque_clr );
/* Calcule les attributs a remettre a 0 (masque_clr) et a mettre a 1
(masque_set), en fonction des options d'attributs
ces attributs sont normalement le membre .flags de la structure TRACK /* Calcule les attributs a remettre a 0 (masque_clr) et a mettre a 1
les pointeurs NULLs sont acceptes * (masque_set), en fonction des options d'attributs
*
* ces attributs sont normalement le membre .flags de la structure TRACK
* les pointeurs NULLs sont acceptes
*/ */
@ -315,28 +354,31 @@ void MasqueAttributs( int * masque_set, int * masque_clr);
/***************/ /***************/
EDA_BaseStruct* LocateLockPoint( BOARD* Pcb, wxPoint pos, int LayerMask ); EDA_BaseStruct* LocateLockPoint( BOARD* Pcb, wxPoint pos, int LayerMask );
/* Routine trouvant le point " d'accrochage " d'une extremite de piste. /* Routine trouvant le point " d'accrochage " d'une extremite de piste.
Ce point peut etre un PAD ou un autre segment de piste * Ce point peut etre un PAD ou un autre segment de piste
Retourne: * Retourne:
- pointeur sur ce PAD ou: * - pointeur sur ce PAD ou:
- pointeur sur le segment ou: * - pointeur sur le segment ou:
- NULL * - NULL
Parametres d'appel: * Parametres d'appel:
coord pX, pY du point tst * coord pX, pY du point tst
masque des couches a tester */ * masque des couches a tester
*/
TRACK* CreateLockPoint( int* pX, int* pY, TRACK* ptsegm, TRACK* refsegm ); TRACK* CreateLockPoint( int* pX, int* pY, TRACK* ptsegm, TRACK* refsegm );
/* Routine de creation d'un point intermediaire sur un segment /* Routine de creation d'un point intermediaire sur un segment
le segment ptsegm est casse en 2 segments se raccordant au point pX, pY * le segment ptsegm est casse en 2 segments se raccordant au point pX, pY
retourne: * retourne:
NULL si pas de nouveau point ( c.a.d si pX, pY correspondait deja * NULL si pas de nouveau point ( c.a.d si pX, pY correspondait deja
a une extremite ou: * a une extremite ou:
pointeur sur le segment cree * pointeur sur le segment cree
si refsegm != NULL refsegm est pointeur sur le segment incident, * si refsegm != NULL refsegm est pointeur sur le segment incident,
et le point cree est l'ntersection des 2 axes des segments ptsegm et * et le point cree est l'ntersection des 2 axes des segments ptsegm et
refsegm * refsegm
retourne la valeur exacte de pX et pY * retourne la valeur exacte de pX et pY
*/ */
/****************/ /****************/
@ -360,9 +402,10 @@ void DisplayBoard(WinEDA_DrawPanel * panel, wxDC * DC); /* routine de Debug */
/* NETLIST.CPP */ /* NETLIST.CPP */
/**************/ /**************/
MODULE* ListAndSelectModuleName( COMMAND* Cmd ); MODULE* ListAndSelectModuleName( COMMAND* Cmd );
/* liste les noms des modules du PCB /* liste les noms des modules du PCB
Retourne un pointeur sur le module selectionne * Retourne un pointeur sur le module selectionne
( ou NULL si pas de selection ) */ * ( ou NULL si pas de selection ) */
/***************/ /***************/
/* LAY2PLOT.CPP */ /* LAY2PLOT.CPP */
@ -376,4 +419,3 @@ void DisplayColorSetupFrame(WinEDA_DrawFrame * parent,
#endif /* #define PROTO_H */ #endif /* #define PROTO_H */