kicad/pcbnew/editrack.cpp

/*******************************/
/* Edition des pistes			*/
/* Routines de trace de pistes */
/*******************************/

#include "fctsys.h"
#include "gr_basic.h"

#include "common.h"
#include "pcbnew.h"
#include "autorout.h"

#include "protos.h"
#include "drc_stuff.h"
#include "trigo.h"



/* Routines Locales */
static void     Exit_Editrack( WinEDA_DrawPanel* panel, wxDC* DC );
void            ShowNewTrackWhenMovingCursor( WinEDA_DrawPanel* panel,
                                              wxDC* DC, bool erase );
static void     ComputeBreakPoint( TRACK* track, int n, wxPoint end );
static TRACK*   DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount );
static void     EnsureEndTrackOnPad( D_PAD* Pad );

/* variables locales */
static int OldNetCodeSurbrillance;
static int OldEtatSurbrillance;


/************************************************************/
static void Exit_Editrack( WinEDA_DrawPanel* Panel, wxDC* DC )
/************************************************************/

/* routine d'annulation de la Commande Begin_Route si une piste est en cours
 *  de tracage, ou de sortie de l'application EDITRACK.
 */
{
    WinEDA_PcbFrame* frame = (WinEDA_PcbFrame*) Panel->m_Parent;
    TRACK*           track = (TRACK*) frame->GetCurItem();

    if( track && ( track->Type()==TYPEVIA || track->Type()==TYPETRACK ) )
    {
        /* Erase the current drawing */
        ShowNewTrackWhenMovingCursor( Panel, DC, FALSE );
        if( g_HightLigt_Status )
            frame->Hight_Light( DC );

        g_HightLigth_NetCode = OldNetCodeSurbrillance;
        if( OldEtatSurbrillance )
            frame->Hight_Light( DC );

        frame->MsgPanel->EraseMsgBox();

        // Delete current (new) track
        TRACK* previoustrack;
        for(  ;   track;   track = previoustrack )
        {
            previoustrack = (TRACK*) track->Pback;
            delete track;
        }
    }

    Panel->ManageCurseur = NULL;
    Panel->ForceCloseManageCurseur = NULL;
    frame->SetCurItem( NULL );
}


/*************************************************************/
TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
/*************************************************************/

/*
 *  Routine d'initialisation d'un trace de piste et/ou de mise en place d'un
 *  nouveau point piste
 *
 *  Si pas de piste en cours de trace:
 *      - Recherche de netname de la nouvelle piste ( pad de depart out netname
 *       de la piste si depart sur une ancienne piste
 *      - Met en surbrillance tout le net
 *      - Initilise les divers pointeurs de trace
 *  Si piste en cours:
 *      - controle DRC
 *      - si DRC OK : addition d'un nouveau point piste
 */
{
    D_PAD*          pt_pad = NULL;
    TRACK*          TrackOnStartPoint = NULL, * Track;
    int             masquelayer = g_TabOneLayerMask[((PCB_SCREEN*)GetScreen())->m_Active_Layer];
    EDA_BaseStruct* LockPoint;
    wxPoint         pos = GetScreen()->m_Curseur;
    static int      InitialTrackWidthValue; /* first track segment width.
                                            * used when we are in the auto tack width mode */

    DrawPanel->ManageCurseur = ShowNewTrackWhenMovingCursor;
    DrawPanel->ForceCloseManageCurseur = Exit_Editrack;

    if( track == NULL )  /* Starting a new track  */
    {
        /* undrw old hightlight */
        OldNetCodeSurbrillance = g_HightLigth_NetCode;
        OldEtatSurbrillance    = g_HightLigt_Status;

        if( g_HightLigt_Status )
            Hight_Light( DC );

        InitialTrackWidthValue = -1;        // Set to "no value"
        g_FirstTrackSegment    = g_CurrentTrackSegment = new TRACK( m_Pcb );
        g_CurrentTrackSegment->m_Flags = IS_NEW;
        g_TrackSegmentCount  = 1;
        g_HightLigth_NetCode = 0;

        /* Search for a pad at starting point of the new track: */
        LockPoint = LocateLockPoint( m_Pcb, pos, masquelayer );

        if( LockPoint ) // An item (pad or track) is found
        {
            if( LockPoint->Type() == TYPEPAD )
            {
                pt_pad = (D_PAD*) LockPoint;

                /* A pad is found: put the starting point on pad centre */
                pos = pt_pad->m_Pos;
                g_HightLigth_NetCode = pt_pad->GetNet();
            }
            else /* A track segment is found */
            {
                TrackOnStartPoint    = (TRACK*) LockPoint;
                g_HightLigth_NetCode = TrackOnStartPoint->GetNet();
                CreateLockPoint( &pos.x, &pos.y, TrackOnStartPoint, NULL );
            }
        }

        build_ratsnest_pad( LockPoint, wxPoint( 0, 0 ), TRUE );
        Hight_Light( DC );

        g_CurrentTrackSegment->m_Flags = IS_NEW;
        g_CurrentTrackSegment->SetLayer( ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
        g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
        if( g_DesignSettings.m_UseConnectedTrackWidth )
        {
            if( TrackOnStartPoint && TrackOnStartPoint->Type() == TYPETRACK )
            {
                InitialTrackWidthValue = TrackOnStartPoint->m_Width;
                g_CurrentTrackSegment->m_Width = InitialTrackWidthValue;
            }
        }
        g_CurrentTrackSegment->m_Start = pos;
        g_CurrentTrackSegment->m_End   = g_CurrentTrackSegment->m_Start;
        g_CurrentTrackSegment->SetNet( g_HightLigth_NetCode );
        if( pt_pad )
        {
            g_CurrentTrackSegment->start = pt_pad;
            g_CurrentTrackSegment->SetState( BEGIN_ONPAD, ON );
        }
        else
            g_CurrentTrackSegment->start = TrackOnStartPoint;

        if( g_TwoSegmentTrackBuild )
        {
            // Create 2 segments
            g_CurrentTrackSegment = g_CurrentTrackSegment->Copy();
            g_TrackSegmentCount++;
            g_CurrentTrackSegment->Pback = g_FirstTrackSegment;
            g_FirstTrackSegment->Pnext   = g_CurrentTrackSegment;
            g_CurrentTrackSegment->start = g_FirstTrackSegment;
            g_FirstTrackSegment->end = g_CurrentTrackSegment;
            g_FirstTrackSegment->SetState( BEGIN_ONPAD | END_ONPAD, OFF );
        }
        g_CurrentTrackSegment->Display_Infos( this );
        SetCurItem( g_CurrentTrackSegment );
        DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );

        if( Drc_On )
        {
            if( BAD_DRC == m_drc->Drc( g_CurrentTrackSegment, m_Pcb->m_Track ) )
            {
                return g_CurrentTrackSegment;
            }
        }
    }
    else    /* Track in progress : segment coordinates are updated by ShowNewTrackWhenMovingCursor*/
    {
        /* Tst for a D.R.C. error: */
        if( Drc_On )
        {
            if( BAD_DRC == m_drc->Drc( g_CurrentTrackSegment, m_Pcb->m_Track ) )
                return NULL;

            if( g_TwoSegmentTrackBuild     // We must handle 2 segments
               && g_CurrentTrackSegment->Back() )
            {
                if( BAD_DRC == m_drc->Drc( g_CurrentTrackSegment->Back(), m_Pcb->m_Track ) )
                    return NULL;
            }
        }

        /* Current track is Ok: current segment is kept, and a new one is created
         *  unless the current segment is null, or 2 last are null if a 2 segments track build
         */
        bool CanCreateNewSegment = TRUE;
        if( !g_TwoSegmentTrackBuild && g_CurrentTrackSegment->IsNull() )
            CanCreateNewSegment = FALSE;
        if( g_TwoSegmentTrackBuild && g_CurrentTrackSegment->IsNull()
           && g_CurrentTrackSegment->Back() && g_CurrentTrackSegment->Back()->IsNull() )
            CanCreateNewSegment = FALSE;
        if( CanCreateNewSegment )
        {
            /* Erase old track on screen */
            ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE );

            if( g_Raccord_45_Auto )
            {
                if( Add_45_degrees_Segment( DC, g_CurrentTrackSegment ) != 0 )
                    g_TrackSegmentCount++;
            }
            Track = g_CurrentTrackSegment->Copy();
            Track->Insert( m_Pcb, g_CurrentTrackSegment );

            Track->SetState( BEGIN_ONPAD | END_ONPAD, OFF );
            g_CurrentTrackSegment->end = Locate_Pad_Connecte( m_Pcb, g_CurrentTrackSegment, END );
            if( g_CurrentTrackSegment->end )
            {
                g_CurrentTrackSegment->SetState( END_ONPAD, ON );
                Track->SetState( BEGIN_ONPAD, ON );
            }
            Track->start = g_CurrentTrackSegment->end;

            g_CurrentTrackSegment = Track;
            g_CurrentTrackSegment->m_Flags = IS_NEW;
            g_TrackSegmentCount++;
            g_CurrentTrackSegment->m_Start = g_CurrentTrackSegment->m_End;
            g_CurrentTrackSegment->SetLayer( ((PCB_SCREEN*)GetScreen())->m_Active_Layer );
            if( !g_DesignSettings.m_UseConnectedTrackWidth )
            {
                g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
            }
            /* Show the new position */
            ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE );
        }
        g_CurrentTrackSegment->Display_Infos( this );
    }

    SetCurItem( g_CurrentTrackSegment );
    return g_CurrentTrackSegment;
}


/**************************************************************************/
int WinEDA_PcbFrame::Add_45_degrees_Segment( wxDC* DC, TRACK* pt_segm )
/***************************************************************************/

/* rectifie un virage a 90 et le modifie par 2 coudes a 45
 *  n'opere que sur des segments horizontaux ou verticaux.
 *
 *  entree : pointeur sur le segment qui vient d'etre trace
 *          On suppose que le segment precedent est celui qui a ete
 *          precedement trace
 *  retourne:
 *      1 si ok
 *      0 si impossible
 */
{
    TRACK* Previous;
    TRACK* NewTrack;
    int    pas_45;
    int    dx0, dy0, dx1, dy1;

    if( g_TrackSegmentCount < 2 )
        return 0;                               /* il faut au moins 2 segments */

    Previous = (TRACK*) pt_segm->Pback;         // pointe le segment precedent

    // Test s'il y a 2 segments consecutifs a raccorder
    if( (pt_segm->Type() != TYPETRACK )
       || (Previous->Type() != TYPETRACK) )
    {
        return 0;
    }

    pas_45 = GetScreen()->GetGrid().x / 2;
    if( pas_45 < pt_segm->m_Width )
        pas_45 = GetScreen()->GetGrid().x;

    while( pas_45 < pt_segm->m_Width )
        pas_45 *= 2;

    // OK : tst si les segments sont a 90 degre et vertic ou horiz
    dx0 = Previous->m_End.x - Previous->m_Start.x;
    dy0 = Previous->m_End.y - Previous->m_Start.y;
    dx1 = pt_segm->m_End.x - pt_segm->m_Start.x;
    dy1 = pt_segm->m_End.y - pt_segm->m_Start.y;

    // les segments doivent etre de longueur suffisante:
    if( MAX( abs( dx0 ), abs( dy0 ) ) < (pas_45 * 2) )
        return 0;

    if( MAX( abs( dx1 ), abs( dy1 ) ) < (pas_45 * 2) )
        return 0;

    /* creation du nouveau segment, raccordant des 2 segm: */
    NewTrack = pt_segm->Copy();

    NewTrack->m_Start.x = Previous->m_End.x;
    NewTrack->m_Start.y = Previous->m_End.y;
    NewTrack->m_End.x   = pt_segm->m_Start.x;
    NewTrack->m_End.y   = pt_segm->m_Start.y;

    if( dx0 == 0 )          // Segment precedent Vertical
    {
        if( dy1 != 0 )      // les 2 segments ne sont pas a 90 ;
        {
            delete NewTrack;
            return 0;
        }

        /* Calcul des coordonnees du point de raccord :
         *  le nouveau segment raccorde le 1er segment Vertical
         *  au 2eme segment Horizontal */

        if( dy0 > 0 )
            NewTrack->m_Start.y -= pas_45;
        else
            NewTrack->m_Start.y += pas_45;

        if( dx1 > 0 )
            NewTrack->m_End.x += pas_45;
        else
            NewTrack->m_End.x -= pas_45;

        if( Drc_On && BAD_DRC==m_drc->Drc( pt_segm, m_Pcb->m_Track ) )
        {
            delete NewTrack;
            return 0;
        }

        Previous->m_End  = NewTrack->m_Start;
        pt_segm->m_Start = NewTrack->m_End;
        NewTrack->Insert( m_Pcb, Previous );
        return 1;
    }

    if( dy0 == 0 )      // Segment precedent Horizontal : dy0 = 0
    {
        if( dx1 != 0 )  // les 2 segments ne sont pas a 90 ;
        {
            delete NewTrack;
            return 0;
        }

        // Segments a 90

        /* Modif des coordonnees du point de raccord :
         *  un nouveau segment a ete cree, raccordant le 1er segment Horizontal
         *  au 2eme segment Vertical */

        if( dx0 > 0 )
            NewTrack->m_Start.x -= pas_45;
        else
            NewTrack->m_Start.x += pas_45;

        if( dy1 > 0 )
            NewTrack->m_End.y += pas_45;
        else
            NewTrack->m_End.y -= pas_45;

        if( Drc_On && BAD_DRC==m_drc->Drc( NewTrack, m_Pcb->m_Track ) )
        {
            delete NewTrack;
            return 0;
        }

        Previous->m_End  = NewTrack->m_Start;
        pt_segm->m_Start = NewTrack->m_End;
        NewTrack->Insert( m_Pcb, Previous );
        return 1;
    }

    return 0;
}


/**************************************************************/
void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
/*************************************************************/

/*
 *  Routine de fin de trace d'une piste (succession de segments)
 */
{
    int             masquelayer = g_TabOneLayerMask[((PCB_SCREEN*)GetScreen())->m_Active_Layer];
    wxPoint         pos;
    EDA_BaseStruct* LockPoint;
    TRACK*          adr_buf;

    if( track == NULL )
        return;

    if( Drc_On && BAD_DRC==m_drc->Drc( g_CurrentTrackSegment, m_Pcb->m_Track ) )
        return;

    /* Sauvegarde des coord du point terminal de la piste */
    pos = g_CurrentTrackSegment->m_End;

    if( Begin_Route( track, DC ) == NULL )
        return;

    ShowNewTrackWhenMovingCursor( DrawPanel, DC, TRUE );    /* mise a jour trace reel */
    ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE );   /* efface trace piste*/
    trace_ratsnest_pad( DC );                               /* efface trace chevelu*/


    // cleanup
    if( g_CurrentTrackSegment->Pnext != NULL )
    {
        delete g_CurrentTrackSegment->Pnext;
        g_CurrentTrackSegment->Pnext = NULL;
    }


    /* La piste est ici non chainee a la liste des segments de piste.
     *  Il faut la replacer dans la zone de net,
     *  le plus pres possible du segment d'attache ( ou de fin ), car
     *  ceci contribue a la reduction du temps de calcul */

    /* Accrochage de la fin de la piste */
    LockPoint = LocateLockPoint( m_Pcb, pos, masquelayer );

    if( LockPoint ) /* La fin de la piste est sur un PAD */
    {
        if( LockPoint->Type() ==  TYPEPAD )
        {
            EnsureEndTrackOnPad( (D_PAD*) LockPoint );
        }
        else    /* la fin de la piste est sur une autre piste: il faudra
                 *  peut-etre creer un point d'ancrage */
        {
            adr_buf = (TRACK*) LockPoint;
            g_HightLigth_NetCode = adr_buf->GetNet();

            /* creation eventuelle d'un point d'accrochage */
            LockPoint = CreateLockPoint( &g_CurrentTrackSegment->m_End.x,
                                         &g_CurrentTrackSegment->m_End.y,
                                         adr_buf,
                                         g_CurrentTrackSegment );
        }
    }


    // Delete Null segments:
    g_FirstTrackSegment = DeleteNullTrackSegments( m_Pcb,
                                                   g_FirstTrackSegment,
                                                   &g_TrackSegmentCount );
    /* Test if no segment left. Can happend on a double click on the start point */
    if( g_FirstTrackSegment != NULL )
    {
        // Put new track in board
        m_Pcb->Add( g_FirstTrackSegment );

        trace_ratsnest_pad( DC );
        Trace_Une_Piste( DrawPanel, DC, g_FirstTrackSegment, g_TrackSegmentCount, GR_OR );

        // Reset flags:
        TRACK* ptr = g_FirstTrackSegment; int ii;
        for( ii = 0; (ptr != NULL) && (ii < g_TrackSegmentCount); ii++ )
        {
            ptr->m_Flags = 0;
            ptr = ptr->Next();
        }

        /* Delete the old track, if exists */
        if( g_AutoDeleteOldTrack )
        {
            EraseOldTrack( this, m_Pcb, DC, g_FirstTrackSegment, g_TrackSegmentCount );
        }

        /* compute the new rastnest : */
        test_1_net_connexion( DC, g_FirstTrackSegment->GetNet() );

        GetScreen()->SetModify();
        m_Pcb->Display_Infos( this );
    }
    /* Finish the work, clear used variables */
    g_FirstTrackSegment = NULL;

    if( g_HightLigt_Status )
        Hight_Light( DC );

    g_HightLigth_NetCode = OldNetCodeSurbrillance;
    if( OldEtatSurbrillance )
        Hight_Light( DC );

    DrawPanel->ManageCurseur = NULL;
    DrawPanel->ForceCloseManageCurseur = NULL;
    SetCurItem( NULL );
}


TRACK* LocateIntrusion( TRACK* start, int net, int width )
{
    int     layer = ( (PCB_SCREEN*) ActiveScreen )->m_Active_Layer;

    wxPoint ref = ActiveScreen->RefPos( true );

    TRACK*  found = NULL;

    for( TRACK* track = start;  track;  track = track->Next() )
    {
        if( track->Type() == TYPETRACK )    // skip vias
        {
            if( track->GetState( BUSY | DELETED ) )
                continue;

            if( layer != track->GetLayer() )
                continue;

            if( track->GetNet() == net )
                continue;

            /* TRACK::HitTest */
            int dist = width / 2 + track->m_Width / 2 + g_DesignSettings.m_TrackClearence;

            wxPoint pos  = ref - track->m_Start;
            wxPoint 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 */
            double tmp = (double) pos.x * vec.x + (double) pos.y * vec.y;
            if( tmp >= 0 && tmp <= (double) vec.x * vec.x + (double) vec.y * vec.y )
                break;
        }
    }

    return found;
}


/**
 * Function PushTrack
 * detects 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
 */
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;
    double  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 = (double) cv.x * vec.y - (double) 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( double(n.x), double(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 )
/****************************************************************************/

/* redessin du contour de la piste  lors des deplacements de la souris
 *  Cette routine est utilisee comme .ManageCurseur()
 *  si ShowIsolDuringCreateTrack_Item.State == RUN la marge d'isolation
 *  est aussi affichee
 */
{
    int         IsolTmp, Track_fill_copy;
    PCB_SCREEN* screen = (PCB_SCREEN*) panel->GetScreen();

    Track_fill_copy = DisplayOpt.DisplayPcbTrackFill;
    DisplayOpt.DisplayPcbTrackFill = SKETCH;
    IsolTmp = DisplayOpt.DisplayTrackIsol;

    if( g_ShowIsolDuringCreateTrack )
        DisplayOpt.DisplayTrackIsol = TRUE;

    /* efface ancienne position si elle a ete deja dessinee */
    if( erase )
    {
        Trace_Une_Piste( panel, DC, g_FirstTrackSegment, g_TrackSegmentCount, GR_XOR );
        ( (WinEDA_BasePcbFrame*) (panel->m_Parent) )->trace_ratsnest_pad( DC );
    }

    /* dessin de la nouvelle piste : mise a jour du point d'arrivee */
    g_CurrentTrackSegment->SetLayer( screen->m_Active_Layer );
    if( ! g_DesignSettings.m_UseConnectedTrackWidth )
        g_CurrentTrackSegment->m_Width = g_DesignSettings.m_CurrentTrackWidth;
    if( g_TwoSegmentTrackBuild )
    {
        TRACK* previous_track = (TRACK*) g_CurrentTrackSegment->Pback;
        if( previous_track && (previous_track->Type() == TYPETRACK) )
        {
            previous_track->SetLayer( screen->m_Active_Layer );
            if( ! g_DesignSettings.m_UseConnectedTrackWidth )
                previous_track->m_Width = g_DesignSettings.m_CurrentTrackWidth;
        }
    }

    if( Track_45_Only )
    {
        if( g_TwoSegmentTrackBuild ) {
        g_CurrentTrackSegment->m_End = ActiveScreen->m_Curseur;
        if (Drc_On)
        PushTrack(panel);
            ComputeBreakPoint( g_CurrentTrackSegment, g_TrackSegmentCount,
           g_CurrentTrackSegment->m_End);
    }
        else
        {
            /* Calcul de l'extremite de la piste pour orientations permises:
             *                              horiz,vertical ou 45 degre */
            Calcule_Coord_Extremite_45( g_CurrentTrackSegment->m_Start.x,
                                        g_CurrentTrackSegment->m_Start.y,
                                        &g_CurrentTrackSegment->m_End.x,
                                        &g_CurrentTrackSegment->m_End.y );
        }
    }
    else    /* ici l'angle d'inclinaison est quelconque */
    {
        g_CurrentTrackSegment->m_End = screen->m_Curseur;
    }

    Trace_Une_Piste( panel, DC, g_FirstTrackSegment, g_TrackSegmentCount, GR_XOR );

    DisplayOpt.DisplayTrackIsol    = IsolTmp;
    DisplayOpt.DisplayPcbTrackFill = Track_fill_copy;

    ( (WinEDA_BasePcbFrame*) (panel->m_Parent) )->
    build_ratsnest_pad( NULL, g_CurrentTrackSegment->m_End, FALSE );

    ( (WinEDA_BasePcbFrame*) (panel->m_Parent) )->trace_ratsnest_pad( DC );
}


/*****************************************************************/
void Calcule_Coord_Extremite_45( int ox, int oy, int* fx, int* fy )
/*****************************************************************/

/* determine les parametres .fx et .fy du segment pointe par pt_segm
 *  pour avoir un segment oriente a 0, 90 ou 45 degres, selon position
 *  du oint d'origine et de la souris
 */
{
    int deltax, deltay, angle;

    deltax = ActiveScreen->m_Curseur.x - ox;
    deltay = ActiveScreen->m_Curseur.y - oy;
    /* calcul de l'angle preferentiel : 0, 45 , 90 degre */
    deltax = abs( deltax ); deltay = abs( deltay ); angle = 45;
    if( deltax >= deltay )
    {
        if( deltax == 0 )
            angle = 0;
        else if( ( (deltay << 6 ) / deltax ) < 26 )
            angle = 0;
    }
    else
    {
        angle = 45;
        if( deltay == 0 )
            angle = 90;
        else if( ( (deltax << 6 ) / deltay ) < 26 )
            angle = 90;
    }

    switch( angle )
    {
    case 0:
        *fx = ActiveScreen->m_Curseur.x;
        *fy = oy;
        break;

    case 45:
        deltax = MIN( deltax, deltay ); deltay = deltax;
        /* recalcul des signes de deltax et deltay */
        if( (ActiveScreen->m_Curseur.x - ox) < 0 )
            deltax = -deltax;
        if( (ActiveScreen->m_Curseur.y - oy) < 0 )
            deltay = -deltay;
        *fx = ox + deltax;
        *fy = oy + deltay;
        break;

    case 90:
        *fx = ox;
        *fy = ActiveScreen->m_Curseur.y;
        break;
    }
}


/********************************************************/
void ComputeBreakPoint( TRACK* track, int SegmentCount, wxPoint end )
/********************************************************/

/**
 * Compute new track angle based on previous track.
 */
{
    int iDx    = 0;
    int iDy    = 0;
    int iAngle = 0;

    if( SegmentCount <= 0 )
        return;
    if( track == NULL )
        return;

    TRACK* NewTrack = track;
    track = (TRACK*) track->Pback;
    SegmentCount--;
    if( track )
    {
        iDx = end.x - track->m_Start.x;
        iDy = end.y - track->m_Start.y;

        iDx = abs( iDx );
        iDy = abs( iDy );
    }

    TRACK* LastTrack = track ? (TRACK*) track->Pback : NULL;
    if( LastTrack )
    {
        if( (LastTrack->m_End.x == LastTrack->m_Start.x)
           || (LastTrack->m_End.y == LastTrack->m_Start.y) )
        {
            iAngle = 45;
        }
    }

    if( iAngle == 0 )
    {
        if( iDx >= iDy )
            iAngle = 0;
        else
            iAngle = 90;
    }

    if( track == NULL )
        iAngle = -1;

    switch( iAngle )
    {
    case - 1:
        break;

    case 0:
        if( (end.x - track->m_Start.x) < 0 )
            track->m_End.x = end.x + iDy;
        else
            track->m_End.x = end.x - iDy;
        track->m_End.y = track->m_Start.y;
        break;

    case 45:
        iDx = MIN( iDx, iDy );
        iDy = iDx;
        /* recalcul des signes de deltax et deltay */
        if( (end.x - track->m_Start.x) < 0 )
            iDx = -iDx;
        if( (end.y - track->m_Start.y) < 0 )
            iDy = -iDy;
        track->m_End.x = track->m_Start.x + iDx;
        track->m_End.y = track->m_Start.y + iDy;
        break;

    case 90:
        if( (end.y - track->m_Start.y) < 0 )
            track->m_End.y = end.y + iDx;
        else
            track->m_End.y = end.y - iDx;
        track->m_End.x = track->m_Start.x;
        break;
    }

    if( track )
    {
        if( track->IsNull() )
            track->m_End = end;
        NewTrack->m_Start = track->m_End;
    }
    NewTrack->m_End = end;
}


/****************************************************************************/
TRACK* DeleteNullTrackSegments( BOARD* pcb, TRACK* track, int* segmcount )
/****************************************************************************/

/* Delete track segments which have len = 0; after creating a new track
 *  return a pointer on the first segment (start of track list)
 */
{
    TRACK*      firsttrack = track;
    TRACK*      oldtrack;
    int         nn = 0;
    BOARD_ITEM* LockPoint;

    if( track == 0 )
        return NULL;
    LockPoint = track->start;
    while( track != NULL )
    {
        oldtrack = track;
        track    = track->Next();
        if( !oldtrack->IsNull() )
        {
            nn++;
            continue;
        }

        // NULL segment, delete it
        if( firsttrack == oldtrack )
            firsttrack = track;
        oldtrack->UnLink();
        delete oldtrack;
    }

    if( segmcount )
        *segmcount = nn;

    if( nn == 0 )
        return NULL; // all the new track segments have been deleted


    // we must set the pointers on connected items and the connection status
    oldtrack = track = firsttrack;
    firsttrack->start = NULL;
    while( track != NULL )
    {
        oldtrack      = track;
        track         = track->Next();
        oldtrack->end = track;
        if( track )
            track->start = oldtrack;
        oldtrack->SetStatus( 0 );
    }

    firsttrack->start = LockPoint;
    if( LockPoint && (LockPoint->Type() == TYPEPAD ) )
        firsttrack->SetState( BEGIN_ONPAD, ON );

    track = firsttrack;
    while( track != NULL )
    {
        TRACK* next_track = track->Next();
        LockPoint = Locate_Pad_Connecte( pcb, track, END );
        if( LockPoint )
        {
            track->end = LockPoint;
            track->SetState( END_ONPAD, ON );
            if( next_track )
            {
                next_track->start = LockPoint;
                next_track->SetState( BEGIN_ONPAD, ON );
            }
        }
        track = next_track;
    }

    return firsttrack;
}


/************************************/
void EnsureEndTrackOnPad( D_PAD* Pad )
/************************************/

/* Ensure the end point of g_CurrentTrackSegment is on the pas "Pad"
 *  if no, create a new track segment if necessary
 *  and move current (or new) end segment on pad
 */
{
    if( g_CurrentTrackSegment->m_End == Pad->m_Pos ) // Ok !
    {
        g_CurrentTrackSegment->end = Pad;
        g_CurrentTrackSegment->SetState( END_ONPAD, ON );
        return;
    }

    TRACK* lasttrack = g_CurrentTrackSegment;
    if( !g_CurrentTrackSegment->IsNull() )
    {
        /* Must create a new segment, from track end to pad center */
        g_CurrentTrackSegment = lasttrack->Copy();
        g_TrackSegmentCount++;
        lasttrack->Pnext = g_CurrentTrackSegment;
        g_CurrentTrackSegment->Pback = lasttrack;
        lasttrack->end = g_CurrentTrackSegment;
    }

    g_CurrentTrackSegment->m_End = Pad->m_Pos;
    g_CurrentTrackSegment->SetState( END_ONPAD, OFF );

    g_CurrentTrackSegment->end = Pad;
    g_CurrentTrackSegment->SetState( END_ONPAD, ON );
}