kicad/pcbnew/connect.cpp

849 lines
27 KiB
C++

/*************************************************************/
/******************* editeur de PCB **************************/
/* traitement du Chevelu: routines de calcul des connexions */
/*************************************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "pcbnew.h"
#include "autorout.h"
#include "protos.h"
/* variables locales */
/* routines exportees */
void Recalcule_all_net_connexion( wxDC* DC );
/* Routines locales */
static void propage_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn );
static void calcule_connexite_1_net( TRACK* pt_start_conn, TRACK* pt_end_conn );
static void RebuildTrackChain( BOARD* pcb );
static int tri_par_netcode( TRACK** pt_ref, TRACK** pt_compare );
/*..*/
/*****************************************************************/
static int change_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn,
int old_val, int new_val )
/*****************************************************************/
/*
* Change les num locaux d'equipot old valeur en new valeur
* retourne le nombre de changements
* si pt_end_conn = NULL: recherche jusqu'a fin de chaine
*/
{
TRACK* pt_conn;
int nb_change = 0;
D_PAD* pt_pad;
if( old_val == new_val )
return 0;
if( (old_val > 0) && (old_val < new_val) )
EXCHG( old_val, new_val );
pt_conn = pt_start_conn;
for( ; pt_conn != NULL; pt_conn = (TRACK*) pt_conn->Pnext )
{
if( pt_conn->m_Sous_Netcode != old_val )
{
if( pt_conn == pt_end_conn )
break;
continue;
}
nb_change++;
pt_conn->m_Sous_Netcode = new_val;
if( pt_conn->start && ( pt_conn->start->Type() == TYPEPAD) )
{
pt_pad = (D_PAD*) (pt_conn->start);
if( pt_pad->m_physical_connexion == old_val )
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
if( pt_conn->end && (pt_conn->end->Type() == TYPEPAD) )
{
pt_pad = (D_PAD*) (pt_conn->end);
if( pt_pad->m_physical_connexion == old_val )
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
if( pt_conn == pt_end_conn )
break;
}
return nb_change;
}
/******************************************************************/
static void propage_equipot( TRACK* pt_start_conn, TRACK* pt_end_conn )
/******************************************************************/
/* balaye la liste des SEGMENTS de PISTE
* - debut = pt_start_conn
* - fin = pt_end_conn (pointe le dernier segment a analyser)
* pour attribuer ou propager un numero d'equipotentielle par
* blocs de connexions existantes
* la zone balayee est supposee appartenir au meme net, c'est a dire que
* les segments de pistes sont tries par net_code
*/
{
TRACK* pt_conn;
int sous_net_code;
D_PAD* pt_pad;
TRACK* pt_autre_piste;
BOARD_ITEM* PtStruct;
/* Initialisations prealables */
pt_conn = pt_start_conn;
for( ; pt_conn != NULL; pt_conn = (TRACK*) pt_conn->Pnext )
{
pt_conn->m_Sous_Netcode = 0;
PtStruct = pt_conn->start;
if( PtStruct && (PtStruct->Type() == TYPEPAD) )
( (D_PAD*) PtStruct )->m_physical_connexion = 0;
PtStruct = pt_conn->end;
if( PtStruct && (PtStruct->Type() == TYPEPAD) )
( (D_PAD*) PtStruct )->m_physical_connexion = 0;
if( pt_conn == pt_end_conn )
break;
}
sous_net_code = 1;
pt_start_conn->m_Sous_Netcode = sous_net_code;
/* debut du calcul de propagation */
pt_conn = pt_start_conn;
for( ; pt_conn != NULL; pt_conn = (TRACK*) pt_conn->Pnext )
{
/* Traitement des connexions a pads */
PtStruct = pt_conn->start;
if( PtStruct && (PtStruct->Type() == TYPEPAD) )
/* la connexion debute sur 1 pad */
{
pt_pad = (D_PAD*) PtStruct;
if( pt_conn->m_Sous_Netcode ) /* la connexion fait deja partie d'une chaine */
{
if( pt_pad->m_physical_connexion > 0 ) /* le pad fait aussi partie d'une chaine */
{
change_equipot( pt_start_conn, pt_end_conn,
pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode );
}
else
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
else /* la connexion ne fait pas partie encore d'une chaine */
{
if( pt_pad->m_physical_connexion > 0 )
{
pt_conn->m_Sous_Netcode = pt_pad->m_physical_connexion;
}
else
{
sous_net_code++;
pt_conn->m_Sous_Netcode = sous_net_code;
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
}
}
PtStruct = pt_conn->end;
if( PtStruct && (PtStruct->Type() == TYPEPAD) )
/* la connexion finit sur 1 pad */
{
pt_pad = (D_PAD*) PtStruct;
if( pt_conn->m_Sous_Netcode )
{
if( pt_pad->m_physical_connexion > 0 )
{
change_equipot( pt_start_conn, pt_end_conn,
pt_pad->m_physical_connexion, pt_conn->m_Sous_Netcode );
}
else
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
else
{
if( pt_pad->m_physical_connexion > 0 )
{
pt_conn->m_Sous_Netcode = pt_pad->m_physical_connexion;
}
else
{
sous_net_code++; pt_conn->m_Sous_Netcode = sous_net_code;
pt_pad->m_physical_connexion = pt_conn->m_Sous_Netcode;
}
}
}
/* traitement des connexions entre segments */
PtStruct = pt_conn->start;
if( PtStruct && (PtStruct->Type() != TYPEPAD) )
{
/* debut sur une autre piste */
pt_autre_piste = (TRACK*) PtStruct;
if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */
{
if( pt_autre_piste->m_Sous_Netcode )
{
change_equipot( pt_start_conn, pt_end_conn,
pt_autre_piste->m_Sous_Netcode, pt_conn->m_Sous_Netcode );
}
else
{
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
}
}
else /* La connexion ne fait partie d'aucun block */
{
if( pt_autre_piste->m_Sous_Netcode )
{
pt_conn->m_Sous_Netcode = pt_autre_piste->m_Sous_Netcode;
}
else
{
sous_net_code++; pt_conn->m_Sous_Netcode = sous_net_code;
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
}
}
}
PtStruct = pt_conn->end;
if( PtStruct && (PtStruct->Type() != TYPEPAD) )
{
/* fin connectee a une autre piste */
pt_autre_piste = (TRACK*) PtStruct;
if( pt_conn->m_Sous_Netcode ) /* La connexion fait deja partie d'un block */
{
if( pt_autre_piste->m_Sous_Netcode )
{
change_equipot( pt_start_conn, pt_end_conn,
pt_autre_piste->m_Sous_Netcode, pt_conn->m_Sous_Netcode );
}
else
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
}
else /* La connexion ne fait partie d'aucun block */
{
if( pt_autre_piste->m_Sous_Netcode )
{
pt_conn->m_Sous_Netcode = pt_autre_piste->m_Sous_Netcode;
}
else
{
sous_net_code++; pt_conn->m_Sous_Netcode = sous_net_code;
pt_autre_piste->m_Sous_Netcode = pt_conn->m_Sous_Netcode;
}
}
}
if( pt_conn == pt_end_conn )
break;
}
}
/***************************************************/
void WinEDA_BasePcbFrame::test_connexions( wxDC* DC )
/***************************************************/
/*
* Routine recherchant les connexions deja faites et mettant a jour
* le status du chevelu ( Bit CH_ACTIF mis a 0 si connexion trouvee
* Les pistes sont supposees etre triees par ordre de net_code croissant
*/
{
TRACK* pt_start_conn, * pt_end_conn;
int ii;
LISTE_PAD* pt_pad;
int current_net_code;
/* Etablissement des equipotentielles vraies */
pt_pad = m_Pcb->m_Pads;
for( ii = 0; ii < m_Pcb->m_NbPads; ii++, pt_pad++ )
{
(*pt_pad)->m_physical_connexion = 0;
}
////////////////////////////
// Calcul de la connexite //
////////////////////////////
/* Les pointeurs .start et .end sont mis a jour, si la
* connexion est du type segment a segment
*/
pt_start_conn = m_Pcb->m_Track;
while( pt_start_conn != NULL )
{
current_net_code = pt_start_conn->m_NetCode;
pt_end_conn = pt_start_conn->GetEndNetCode( current_net_code );
/* Calcul des connexions type segment du net courant */
calcule_connexite_1_net( pt_start_conn, pt_end_conn );
pt_start_conn = (TRACK*) pt_end_conn->Pnext;
}
return;
}
/**************************************************************/
void WinEDA_BasePcbFrame::Recalcule_all_net_connexion( wxDC* DC )
/**************************************************************/
/*
* Routine Recalculant les pointeurs sur connexions types piste a piste
* relatives a tous les nets.
* Cette routine est utilisee apres reclassement des segments de piste par
* ordre de net_code, puisque des pointeurs sur connexions deviennent faux
* ( les pointeurs type pad restent bons )
*/
{
TRACK* EndConn;
int net_code, net_code_max;
if( m_Pcb->m_Track == NULL )
return;
/* calcul du net_code max */
EndConn = m_Pcb->m_Track;
while( EndConn->Pnext )
EndConn = (TRACK*) EndConn->Pnext;
net_code_max = EndConn->m_NetCode;
for( net_code = 0; net_code <= net_code_max; net_code++ )
{
test_1_net_connexion( DC, net_code );
}
}
/*************************************************************************/
void WinEDA_BasePcbFrame::test_1_net_connexion( wxDC* DC, int net_code )
/*************************************************************************/
/*
* Routine recherchant les connexions deja faites relatives a 1 net
*/
{
TRACK* pt_start_conn, * pt_end_conn;
int ii, nb_net_noconnect = 0;
LISTE_PAD* pt_pad;
wxString msg;
if( net_code == 0 )
return;
if( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
Compile_Ratsnest( DC, TRUE );
pt_pad = (LISTE_PAD*) m_Pcb->m_Pads;
for( ii = 0; ii < m_Pcb->m_NbPads; ii++, pt_pad++ )
{
int pad_net_code = (*pt_pad)->m_NetCode;
if( pad_net_code < net_code )
continue;
if( pad_net_code > net_code )
break;
(*pt_pad)->m_physical_connexion = 0;
}
/* Determination des limites du net */
if( m_Pcb->m_Track )
{
pt_end_conn = NULL;
pt_start_conn = m_Pcb->m_Track->GetStartNetCode( net_code );
if( pt_start_conn )
pt_end_conn = pt_start_conn->GetEndNetCode( net_code );
if( pt_start_conn && pt_end_conn ) // c.a.d. s'il y a des segments
{
calcule_connexite_1_net( pt_start_conn, pt_end_conn );
}
}
/* Test des chevelus */
nb_net_noconnect = Test_1_Net_Ratsnest( DC, net_code );
/* Affichage des resultats */
msg.Printf( wxT( "links %d nc %d net:nc %d" ),
m_Pcb->m_NbLinks, m_Pcb->GetNumNoconnect(),
nb_net_noconnect );
Affiche_Message( msg );
return;
}
/***************************************************************************/
static void calcule_connexite_1_net( TRACK* pt_start_conn, TRACK* pt_end_conn )
/***************************************************************************/
/* calcule la connexite d'un net constitue de segments de piste consecutifs.
* Entree:
* pt_start_conn = adresse du 1er segment ( debut du net )
* pt_end_conn = adr de fin (dernier segment)
* Les connexions relatives aux pads doivent etre deja calculees, car elles
* ne sont pas ici recalculees ( pour des raisons de temps de calcul, et
* du fait que lors des modif de pistes, les pads ne sont pas touches
*/
{
TRACK* Track;
/* Les pointeurs .start et .end sont mis a jour, si la
* connexion est du type segment a segment.
* la connexion sur pads est supposee etre deja calculee */
/* Raz des pointeurs sur pistes */
for( Track = pt_start_conn; Track != NULL; Track = (TRACK*) Track->Pnext )
{
Track->m_Sous_Netcode = 0;
if( Track->GetState( BEGIN_ONPAD ) == 0 )
Track->start = NULL;
if( Track->GetState( END_ONPAD ) == 0 )
Track->end = NULL;
if( Track == pt_end_conn )
break;
}
/* calcul des connexions */
for( Track = pt_start_conn; Track != NULL; Track = (TRACK*) Track->Pnext )
{
if( Track->Type() == TYPEVIA )
{
TRACK* pt_segm;
int layermask = Track->ReturnMaskLayer();
for( pt_segm = pt_start_conn; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
{
int curlayermask = pt_segm->ReturnMaskLayer();
if( !pt_segm->start && (pt_segm->m_Start == Track->m_Start)
&& ( layermask & curlayermask ) )
{
pt_segm->start = Track;
}
if( !pt_segm->end && (pt_segm->m_End == Track->m_Start)
&& (layermask & curlayermask) )
{
pt_segm->end = Track;
}
if( pt_segm == pt_end_conn )
break;
}
}
if( Track->start == NULL )
{
Track->start = Locate_Piste_Connectee( Track, Track, pt_end_conn, START );
}
if( Track->end == NULL )
{
Track->end = Locate_Piste_Connectee( Track, Track, pt_end_conn, END );
}
if( Track == pt_end_conn )
break;
}
/* Generation des sous equipots du net */
propage_equipot( pt_start_conn, pt_end_conn );
}
/********************************************/
/* Reattribution des net_codes de reference */
/********************************************/
/*
* reattribution des net_codes aux segments de pistes.
* Routine utilisee apres modification generale des noms de nets (apres
* lecrure netliste ou edition de nets sur pads, effacement /ajout de
* modules...)
*
* Elle se fait en 2 passes:
* 1 - reattribution des segments commencant ( et/ou finissant ) sur 1 pad
* les autres segments sont mis a reference NULLE
* 2 - reattribution des segments restantes a ref NULLE
*/
#define POS_AFF_CHREF 62
/* recherche le pad connecte a l'extremite de la piste de coord px, py
* parametres d'appel:
* px, py = coord du point tst
* masque_layer = couche(s) de connexion
* pt_liste = adresse de la liste des pointeurs de pads, tels que
* apparaissant apres build_liste_pad, mais classee par position X
* de pads croissantes.
* retourne : pointeur sur le pad connecte
* la routine travaille par dichotomie sur la liste des pads tries par pos X
* croissante, elle est donc beaucoup plus rapide que Fast_Locate_Pad_connecte,
* mais implique le calcul de cette liste.
*
* (la liste placee en m_Pcb->m_Pads et elle triee par netcodes croissants)
*/
static D_PAD* SuperFast_Locate_Pad_Connecte( BOARD* pcb, LISTE_PAD* pt_liste,
int px, int py, int masque_layer )
{
D_PAD* pad;
LISTE_PAD* ptr_pad, * lim;
int nb_pad = pcb->m_NbPads;
int ii;
lim = pt_liste + (pcb->m_NbPads - 1 );
ptr_pad = pt_liste;
while( nb_pad )
{
pad = *ptr_pad;
ii = nb_pad;
nb_pad >>= 1; if( (ii & 1) && ( ii > 1 ) )
nb_pad++;
if( pad->m_Pos.x < px ) /* on doit chercher plus loin */
{
ptr_pad += nb_pad; if( ptr_pad > lim )
ptr_pad = lim;
continue;
}
if( pad->m_Pos.x > px ) /* on doit chercher moins loin */
{
ptr_pad -= nb_pad;
if( ptr_pad < pt_liste )
ptr_pad = pt_liste;
continue;
}
if( pad->m_Pos.x == px ) /* zone de classement trouvee */
{
/* recherche du debut de la zone */
while( ptr_pad >= pt_liste )
{
pad = *ptr_pad;
if( pad->m_Pos.x == px )
ptr_pad--;
else
break;
}
ptr_pad++; /* pointe depart de zone a pad->m_Pos.x = px */
for( ; ; ptr_pad++ )
{
if( ptr_pad > lim )
return NULL; /* hors zone */
pad = *ptr_pad;
if( pad->m_Pos.x != px )
return NULL; /* hors zone */
if( pad->m_Pos.y != py )
continue;
/* Pad peut-etre trouve ici: il doit etre sur la bonne couche */
if( pad->m_Masque_Layer & masque_layer )
return pad;
}
}
}
return NULL;
}
static int SortPadsByXCoord( void* pt_ref, void* pt_comp )
/* used to Sort a pad list by x coordinate value
*/
{
D_PAD* ref = *(LISTE_PAD*) pt_ref;
D_PAD* comp = *(LISTE_PAD*) pt_comp;
return ref->m_Pos.x - comp->m_Pos.x;
}
/****************************************************/
LISTE_PAD* CreateSortedPadListByXCoord( BOARD* pcb )
/****************************************************/
/* Create a sorted list of pointers to pads.
* This list is sorted by X ccordinate value.
* The list must be freed bu user
*/
{
LISTE_PAD* pad_list = (LISTE_PAD*) MyMalloc( pcb->m_NbPads * sizeof( D_PAD *) );
memcpy( pad_list, pcb->m_Pads, pcb->m_NbPads * sizeof( D_PAD *) );
qsort( pad_list, pcb->m_NbPads, sizeof( D_PAD *),
( int( * ) ( const void*, const void* ) )SortPadsByXCoord );
return pad_list;
}
/******************************************************************/
void WinEDA_BasePcbFrame::reattribution_reference_piste( int affiche )
/******************************************************************/
{
TRACK* pt_piste,
* pt_next;
int a_color;
char new_passe_request = 1, flag;
LISTE_PAD* pt_mem;
BOARD_ITEM* PtStruct;
int masque_layer;
wxString msg;
if( m_Pcb->m_NbPads == 0 )
return;
a_color = CYAN;
if( affiche )
Affiche_1_Parametre( this, POS_AFF_CHREF, wxT( "DataBase" ), wxT( "Netcodes" ), a_color );
recalcule_pad_net_code();
if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( "Gen Pads " ), a_color );
//////////////////////////////////////////////////////
// Connexion des pistes accrochees a 1 pad au moins //
//////////////////////////////////////////////////////
pt_mem = CreateSortedPadListByXCoord( m_Pcb );
if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( "Conn Pads" ), a_color );
/* Raz des flags particuliers des segments de piste */
pt_piste = m_Pcb->m_Track;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{
pt_piste->SetState( BUSY | EDIT | BEGIN_ONPAD | END_ONPAD, OFF );
pt_piste->m_NetCode = 0;
}
pt_piste = m_Pcb->m_Track;
for( ; pt_piste != NULL; pt_piste = (TRACK*) pt_piste->Pnext )
{
flag = 0;
masque_layer = g_TabOneLayerMask[pt_piste->GetLayer()];
/* y a t-il une pastille sur une extremite */
pt_piste->start = SuperFast_Locate_Pad_Connecte( m_Pcb,
pt_mem,
pt_piste->m_Start.x,
pt_piste->m_Start.y,
masque_layer );
if( pt_piste->start != NULL )
{
pt_piste->SetState( BEGIN_ONPAD, ON );
pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->start) )->m_NetCode;
}
pt_piste->end = SuperFast_Locate_Pad_Connecte( m_Pcb,
pt_mem,
pt_piste->m_End.x,
pt_piste->m_End.y,
masque_layer );
if( pt_piste->end != NULL )
{
pt_piste->SetState( END_ONPAD, ON );
pt_piste->m_NetCode = ( (D_PAD*) (pt_piste->end) )->m_NetCode;
}
}
MyFree( pt_mem );
////////////////////////////////////////////////////
// Calcul de la connexite entre segments de piste //
////////////////////////////////////////////////////
/* Les pointeurs .start et .end sont mis a jour, s'ils etaient NULLs.
* La connexion est alors du type segment a segment
*/
if( affiche )
Affiche_1_Parametre( this, POS_AFF_CHREF, wxEmptyString, wxT( "Conn Segm" ), a_color );
for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() )
{
if( pt_piste->start == NULL )
{
pt_piste->start = Locate_Piste_Connectee( pt_piste, m_Pcb->m_Track, NULL, START );
}
if( pt_piste->end == NULL )
{
pt_piste->end = Locate_Piste_Connectee( pt_piste, m_Pcb->m_Track, NULL, END );
}
}
////////////////////////////////
// Reattribution des net_code //
////////////////////////////////
a_color = YELLOW;
while( new_passe_request )
{
bool reset_flag = FALSE;
new_passe_request = 0;
if( affiche )
{
msg.Printf( wxT( "Net->Segm pass %d " ), new_passe_request + 1 );
Affiche_1_Parametre( this, POS_AFF_CHREF, wxEmptyString, msg, a_color );
}
/* look for vias which could be connect many tracks */
for( TRACK* via = m_Pcb->m_Track; via != NULL; via = via->Next() )
{
if( via->Type() != TYPEVIA )
continue;
if( via->m_NetCode > 0 )
continue; // Netcode already known
// Lock for a connection to a track with a known netcode
pt_next = m_Pcb->m_Track;
while( ( pt_next = Locate_Piste_Connectee( via, pt_next, NULL, START ) ) != NULL )
{
if( pt_next->m_NetCode )
{
via->m_NetCode = pt_next->m_NetCode;
break;
}
pt_next->SetState( BUSY, ON );
reset_flag = TRUE;
}
}
if( reset_flag )
for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() )
{
pt_piste->SetState( BUSY, OFF );
}
for( pt_piste = m_Pcb->m_Track; pt_piste != NULL; pt_piste = pt_piste->Next() )
{
/* Traitement du point de debut */
PtStruct = (BOARD_ITEM*) pt_piste->start;
if( PtStruct && (PtStruct->Type() != TYPEPAD) )
{ // Begin on an other track segment
pt_next = (TRACK*) PtStruct;
if( pt_piste->m_NetCode )
{
if( pt_next->m_NetCode == 0 )
{
new_passe_request = 1;
pt_next->m_NetCode = pt_piste->m_NetCode;
}
}
else
{
if( pt_next->m_NetCode != 0 )
{
pt_piste->m_NetCode = pt_next->m_NetCode;
new_passe_request = 1;
}
}
}
/* Localisation du point de fin */
PtStruct = pt_piste->end;
if( PtStruct &&(PtStruct->Type() != TYPEPAD) )
{ // End sur piste
pt_next = (TRACK*) PtStruct;
if( pt_piste->m_NetCode )
{
if( pt_next->m_NetCode == 0 )
{
new_passe_request = 1;
pt_next->m_NetCode = pt_piste->m_NetCode;
}
}
else
{
if( pt_next->m_NetCode != 0 )
{
pt_piste->m_NetCode = pt_next->m_NetCode;
new_passe_request = 1;
}
}
}
}
}
/* Reclassemment des pistes par numero de net: */
if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( "Reorder " ), a_color );
RebuildTrackChain( m_Pcb );
if( affiche )
Affiche_1_Parametre( this, -1, wxEmptyString, wxT( " " ), a_color );
}
/*
* routine de tri de connexion utilisee par la fonction QSORT
* le tri est fait par numero de net
*/
int tri_par_netcode( TRACK** pt_ref, TRACK** pt_compare )
{
int ii;
ii = (*pt_ref)->m_NetCode - (*pt_compare)->m_NetCode;
return ii;
}
/*****************************************/
static void RebuildTrackChain( BOARD* pcb )
/*****************************************/
/* Recalcule le chainage des pistes pour que le chainage soit fait par
* netcodes croissants
*/
{
TRACK* Track, ** Liste;
int ii, nbsegm;
/* Count segments */
nbsegm = pcb->GetNumSegmTrack();
if( pcb->m_Track == NULL )
return;
Liste = (TRACK**) MyZMalloc( (nbsegm + 1) * sizeof(TRACK *) );
ii = 0; Track = pcb->m_Track;
for( ; Track != NULL; ii++, Track = (TRACK*) Track->Pnext )
{
Liste[ii] = Track;
}
qsort( Liste, nbsegm, sizeof(TRACK *),
( int( * ) ( const void*, const void* ) )tri_par_netcode );
/* Update the linked list pointers */
Track = Liste[0];
Track->Pback = pcb; Track->Pnext = Liste[1];
pcb->m_Track = Track;
for( ii = 1; ii < nbsegm; ii++ )
{
Track = Liste[ii];
Track->Pback = Liste[ii - 1];
Track->Pnext = Liste[ii + 1];
}
MyFree( Liste );
}