kicad/pcbnew/drc.cpp

/****************************/
/* DRC control				*/
/****************************/

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

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

#include "protos.h"

/* variables locales */
class WinEDA_DrcFrame;
WinEDA_DrcFrame* DrcFrame;

/* saving drc options */
static bool      s_Pad2PadTestOpt     = true;
static bool      s_UnconnectedTestOpt = true;
static bool      s_ZonesTestOpt     = false;
static bool      s_CreateRptFileOpt = false;
static FILE*     s_RptFile = NULL;
static wxString  s_RptFilename;

static int       ErrorsDRC_Count;
static MARQUEUR* current_marqueur; /* Pour gestion des marqueurs sur pcb */

static bool      AbortDrc, DrcInProgress = FALSE;
static int       spot_cX, spot_cY;                      /* position d'elements a tester */
static int       finx, finy;                            // coord relatives de l'extremite du segm de reference
static int       segm_angle;                            // angle d'inclinaison du segment de reference en 0,1 degre
static int       segm_long;                             // longueur du segment de reference
static int       xcliplo, ycliplo, xcliphi, ycliphi;    /* coord de la surface de securite du segment a comparer */

/* Routines Locales */
static int  Pad_to_Pad_Isol( D_PAD* pad_ref, D_PAD* pad, const int dist_min );
static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
                                  wxDC* DC,
                                  D_PAD* pad_ref,
                                  LISTE_PAD* start_buffer,
                                  LISTE_PAD* end_buffer,
                                  int max_size,
                                  bool show_err );
static int  TestClearanceSegmToPad( const D_PAD* pad_to_test, int seg_width, int isol );
static int  TestMarginToCircle( int cx, int cy, int rayon, int longueur );
static int  Tst_Ligne( int x1, int y1, int x2, int y2 );
static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
                                TRACK* pt_ref, void* pt_item, int errnumber );
static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC,
                                BOARD* Pcb, D_PAD* pad1, D_PAD* pad2 );


/*******************************************/
/* Frame d'option et execution DRC general */
/*******************************************/
#include "dialog_drc.cpp"

/***************************************************************/
void WinEDA_DrcFrame::ListUnconnectedPads( wxCommandEvent& event )
/***************************************************************/
{
    if( (m_Parent->m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
    {
        m_Parent->Compile_Ratsnest( m_DC, TRUE );
    }
    if( m_Parent->m_Pcb->m_Ratsnest == NULL )
        return;

    CHEVELU*          Ratsnest  = m_Parent->m_Pcb->m_Ratsnest;
    int               draw_mode = GR_SURBRILL | GR_OR;
    WinEDA_DrawPanel* panel = m_Parent->DrawPanel;
    int               ii;
    wxString          msg;
    float             convert = 0.0001;

    msg = _( "Look for active routes\n" );
    m_logWindow->AppendText( msg );
    if( s_RptFile )
        fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );

    m_UnconnectedCount = 0;
    for( ii = m_Parent->m_Pcb->GetNumRatsnests(); ii > 0; Ratsnest++, ii-- )
    {
        if( (Ratsnest->status & CH_ACTIF) == 0 )
            continue;
        m_UnconnectedCount++;
        if( m_UnconnectedCount == 1 )
            m_logWindow->AppendText( _( "Unconnected found:\n" ) );
        D_PAD*   pad = Ratsnest->pad_start;
        pad->Draw( panel, m_DC, wxPoint( 0, 0 ), draw_mode );
        wxString pad_name    = pad->ReturnStringPadName();
        wxString module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
        msg.Printf( _( "%d > Pad %s (%s) @ %.4f,%.4f and " ), m_UnconnectedCount,
                    pad_name.GetData(), module_name.GetData(
                    ), pad->m_Pos.x * convert, pad->m_Pos.y * convert );
        m_logWindow->AppendText( msg );
        if( s_RptFile )
            fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );

        pad = Ratsnest->pad_end;
        pad->Draw( panel, m_DC, wxPoint( 0, 0 ), draw_mode );
        pad_name    = pad->ReturnStringPadName();
        module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
        msg.Printf( _( "Pad %s (%s) @ %.4f,%.4f\n" ),
                    pad_name.GetData(), module_name.GetData(
                    ), pad->m_Pos.x * convert, pad->m_Pos.y * convert );
        m_logWindow->AppendText( msg );
        if( s_RptFile )
            fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
    }

    if( m_UnconnectedCount )
        msg.Printf( _( "Active routes: %d\n" ), m_UnconnectedCount );
    else
        msg = _( "OK! (No active routes)\n" );
    m_logWindow->AppendText( msg );
    if( s_RptFile )
        fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
}


/****************************************************/
void WinEDA_DrcFrame::TestDrc( wxCommandEvent& event )
/****************************************************/
{
    int      errors;
    wxString msg;

    if( !DrcInProgress )
    {
        if( m_CreateRptCtrl->IsChecked() ) // Create a file rpt
        {
            s_RptFilename = m_RptFilenameCtrl->GetValue();
            if( s_RptFilename.IsEmpty() )
                OnButtonBrowseRptFileClick( event );
            if( !s_RptFilename.IsEmpty() )
                s_RptFile = wxFopen( s_RptFilename, wxT( "w" ) );
            else
                s_RptFile = NULL;
        }

        if( s_RptFile )
        {
            fprintf( s_RptFile, "Drc report for %s\n",
                    CONV_TO_UTF8( m_Parent->m_CurrentScreen->m_FileName ) );
            char line[256];
            fprintf( s_RptFile, "Created on %s\n", DateAndTime( line ) );
        }

        s_Pad2PadTestOpt     = m_Pad2PadTestCtrl->IsChecked();
        s_UnconnectedTestOpt = m_UnconnectedTestCtrl->IsChecked();
        s_ZonesTestOpt = m_ZonesTestCtrl->IsChecked();
        AbortDrc = FALSE;
        m_logWindow->Clear();
        g_DesignSettings.m_TrackClearence =
            ReturnValueFromTextCtrl( *m_SetClearance, m_Parent->m_InternalUnits );
        /* Test DRC errors (clearance errors, bad connections .. */
        errors = m_Parent->Test_DRC( m_DC, m_Pad2PadTestCtrl->IsChecked(
                                    ), m_ZonesTestCtrl->IsChecked() );
        /* Search for active routes (unconnected pads) */
        if( m_UnconnectedTestCtrl->IsChecked() )
            ListUnconnectedPads( event );
        else
            m_UnconnectedCount = 0;
        if( errors )
            msg.Printf( _( "** End Drc: %d errors **\n" ), errors );
        else if( m_UnconnectedCount == 0 )
            msg = _( "** End Drc: No Error **\n" );
        m_logWindow->AppendText( msg );

        if( s_RptFile )
            fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );

        if( s_RptFile )
        {
            msg.Printf( _( "Report file <%s> created\n" ), s_RptFilename.GetData() );
            m_logWindow->AppendText( msg );
            fclose( s_RptFile );
            s_RptFile = NULL;
        }
    }
    else
        wxBell();
}


/*********************************************************/
void WinEDA_DrcFrame::DelDRCMarkers( wxCommandEvent& event )
/*********************************************************/
{
    if( !DrcInProgress )
    {
        m_Parent->Erase_Marqueurs();
        m_Parent->DrawPanel->ReDraw( m_DC, TRUE );
    }
    else
        wxBell();
}


/******************************************************/
void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC )
/******************************************************/

/* Test des isolements : teste les isolements des pistes et place un
 *  marqueur sur les divers segments en defaut
 *  Principe:
 *      Appelle la routine drc() pour chaque segment de piste existant
 */
{
    AbortDrc = FALSE;
    DrcFrame = new WinEDA_DrcFrame( this, DC );
    DrcFrame->ShowModal(); DrcFrame->Destroy();
    DrcFrame = NULL;
}


/************************************************************************/
int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
/************************************************************************/

/* Test des isolements : teste les isolements des pistes et place un
 *  marqueur sur les divers segments en defaut
 *  Principe:
 *      Appelle la routine drc() pour chaque segment de piste existant
 */
{
    int             ii, jj, old_net;
    int             flag_err_Drc;
    TRACK*          pt_segm;
    D_PAD*          pad;
    MARQUEUR*       Marqueur;
    EDA_BaseStruct* PtStruct;
    wxString        Line;

#define PRINT_NB_PAD_POS      42
#define PRINT_PAD_ERR_POS     48
#define PRINT_TST_POS         20
#define PRINT_NB_SEGM_POS     26
#define PRINT_TRACK_ERR_POS   32
#define PRINT_NB_ZONESEGM_POS 60
#define PRINT_ZONE_ERR_POS    70

    DrcInProgress   = TRUE;
    ErrorsDRC_Count = 0;
    Compile_Ratsnest( DC, TRUE );

    MsgPanel->EraseMsgBox();

    m_CurrentScreen->SetRefreshReq();

    /* Effacement des anciens marqueurs */
    Erase_Marqueurs();

    if( TestPad2Pad )  /* Test DRC des pads entre eux */
    {
        Line.Printf( wxT( "%d" ), m_Pcb->m_NbPads );
        Affiche_1_Parametre( this, PRINT_NB_PAD_POS, wxT( "NbPad" ), Line, RED );
        Affiche_1_Parametre( this, PRINT_PAD_ERR_POS, wxT( "Pad Err" ), wxT( "0" ), LIGHTRED );
        
        if( DrcFrame )
            DrcFrame->m_logWindow->AppendText( _( "Tst Pad to Pad\n" ) );
        
        LISTE_PAD* pad_list_start = CreateSortedPadListByXCoord( m_Pcb );
        LISTE_PAD* pad_list_limit = &pad_list_start[m_Pcb->m_NbPads];
        int        max_size = 0;
        LISTE_PAD* pad_list;
        /* Compute the max size of the pads ( used to stop the test) */
        for( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++ )
        {
            pad = *pad_list;
            if( pad->m_Rayon > max_size )
                max_size = pad->m_Rayon;
        }

        /* Test the pads */
        for( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++ )
        {
            pad = *pad_list;
            if( Test_Pad_to_Pads_Drc( this, DC, pad, pad_list, pad_list_limit, max_size,
                                      TRUE ) == BAD_DRC )
            {
                Marqueur = current_marqueur;
                current_marqueur = NULL;
                if( Marqueur == NULL )
                {
                    DisplayError( this, wxT( "Test_Drc(): internal err" ) );
                    return ErrorsDRC_Count;
                }
                Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
                Affiche_1_Parametre( this, PRINT_PAD_ERR_POS, wxEmptyString, Line, LIGHTRED );
                Marqueur->Pnext = m_Pcb->m_Drawings;
                Marqueur->Pback = m_Pcb;

                PtStruct = m_Pcb->m_Drawings;
                if( PtStruct )
                    PtStruct->Pback = Marqueur;
                m_Pcb->m_Drawings = Marqueur;
            }
        }

        free( pad_list_start );
    }

    /* Test track segments */
    Line.Printf( wxT( "%d" ), m_Pcb->m_NbSegmTrack );
    Affiche_1_Parametre( this, PRINT_NB_SEGM_POS, _( "SegmNb" ), Line, RED );
    Affiche_1_Parametre( this, PRINT_TRACK_ERR_POS, _( "Track Err" ), wxT( "0" ), LIGHTRED );
    pt_segm = m_Pcb->m_Track;

    if( DrcFrame )
        DrcFrame->m_logWindow->AppendText( _( "Tst Tracks\n" ) );
    
    for( ii = 0, old_net = -1, jj = 0;
         pt_segm != NULL;
         pt_segm = (TRACK*) pt_segm->Pnext, ii++, jj-- )
    {
        if( pt_segm->Pnext == NULL )
            break;
        if( jj == 0 )
        {
            jj = 10;
            wxYield();
            if( AbortDrc )
            {
                AbortDrc = FALSE; break;
            }
            /* Print stats */
            Line.Printf( wxT( "%d" ), ii );
            Affiche_1_Parametre( this, PRINT_TST_POS, wxT( "Test" ), Line, CYAN );
        }

        if( old_net != pt_segm->m_NetCode )
        {
            wxString msg;
            jj = 1;
            EQUIPOT* equipot = m_Pcb->FindNet( pt_segm->m_NetCode );
            if( equipot )
                msg = equipot->m_Netname + wxT( "        " );
            else
                msg = wxT( "<noname>" );
            Affiche_1_Parametre( this, 0, _( "Netname" ), msg, YELLOW );
            old_net = pt_segm->m_NetCode;
        }

        g_HightLigth_NetCode = pt_segm->m_NetCode;
        flag_err_Drc = Drc( this, DC, pt_segm, (TRACK*) pt_segm->Pnext, 1 );
        if( flag_err_Drc == BAD_DRC )
        {
            Marqueur = current_marqueur;
            current_marqueur = NULL;
            if( Marqueur == NULL )
            {
                DisplayError( this, wxT( "Test_Drc(): internal err" ) );
                return ErrorsDRC_Count;
            }
            Marqueur->Pnext = m_Pcb->m_Drawings;
            Marqueur->Pback = m_Pcb;

            PtStruct = m_Pcb->m_Drawings;
            if( PtStruct )
                PtStruct->Pback = Marqueur;
            m_Pcb->m_Drawings = Marqueur;

            GRSetDrawMode( DC, GR_OR );
            pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
            Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
            Affiche_1_Parametre( this, PRINT_TRACK_ERR_POS, wxEmptyString, Line, LIGHTRED );
        }
    }

    /* Test zone segments segments */
    if( TestZone )
    {
        m_Pcb->m_NbSegmZone = 0;
        for( pt_segm = (TRACK*) m_Pcb->m_Zone;  pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
            m_Pcb->m_NbSegmZone++;

        Line.Printf( wxT( "%d" ), m_Pcb->m_NbSegmZone );
        Affiche_1_Parametre( this, PRINT_NB_ZONESEGM_POS, _( "SegmNb" ), Line, RED );
        Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, _( "Zone Err" ), wxT( "0" ), LIGHTRED );

        if( DrcFrame )
            DrcFrame->m_logWindow->AppendText( _( "Tst Zones\n" ) );

        pt_segm = (TRACK*) m_Pcb->m_Zone;
        for( ii = 0, old_net = -1, jj = 0;
             pt_segm != NULL;
             pt_segm = (TRACK*) pt_segm->Pnext, ii++, jj-- )
        {
            if( pt_segm->Pnext == NULL )
                break;
            if( jj == 0 )
            {
                jj = 100;
                wxYield();
                if( AbortDrc )
                {
                    AbortDrc = FALSE; break;
                }
                /* Print stats */
                Line.Printf( wxT( "%d" ), ii );
                Affiche_1_Parametre( this, PRINT_TST_POS, wxT( "Test" ), Line, CYAN );
            }

            if( old_net != pt_segm->m_NetCode )
            {
                jj = 1;
                wxString msg;
                EQUIPOT* equipot = m_Pcb->FindNet( pt_segm->m_NetCode );
                if( equipot )
                    msg = equipot->m_Netname + wxT( "        " );
                else
                    msg = wxT( "<noname>" );
                Affiche_1_Parametre( this, 0, _( "Netname" ), msg, YELLOW );
                old_net = pt_segm->m_NetCode;
            }
            g_HightLigth_NetCode = pt_segm->m_NetCode;
            /* Test drc with other zone segments, and pads */
            flag_err_Drc = Drc( this, DC, pt_segm, (TRACK*) pt_segm->Pnext, 1 );
            if( flag_err_Drc == BAD_DRC )
            {
                Marqueur = current_marqueur;
                current_marqueur = NULL;
                if( Marqueur == NULL )
                {
                    DisplayError( this, wxT( "Test_Drc(): internal err" ) );
                    return ErrorsDRC_Count;
                }
                Marqueur->Pnext = m_Pcb->m_Drawings;
                Marqueur->Pback = m_Pcb;

                PtStruct = m_Pcb->m_Drawings;
                if( PtStruct )
                    PtStruct->Pback = Marqueur;
                m_Pcb->m_Drawings = Marqueur;

                GRSetDrawMode( DC, GR_OR );
                pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
                Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
                Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED );
            }

            /* Test drc with track segments */
            int tmp = m_Pcb->m_NbPads; m_Pcb->m_NbPads = 0;    // Pads already tested: disable pad test
            flag_err_Drc    = Drc( this, DC, pt_segm, m_Pcb->m_Track, 1 );
            
            m_Pcb->m_NbPads = tmp;
            
            if( flag_err_Drc == BAD_DRC )
            {
                Marqueur = current_marqueur;
                current_marqueur = NULL;
                if( Marqueur == NULL )
                {
                    DisplayError( this, wxT( "Test_Drc(): internal err" ) );
                    return ErrorsDRC_Count;
                }
                Marqueur->Pnext = m_Pcb->m_Drawings;
                Marqueur->Pback = m_Pcb;

                PtStruct = m_Pcb->m_Drawings;
                if( PtStruct )
                    PtStruct->Pback = Marqueur;
                m_Pcb->m_Drawings = Marqueur;

                GRSetDrawMode( DC, GR_OR );
                pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
                Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
                Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED );
            }
        }
    }


    AbortDrc      = FALSE;
    DrcInProgress = FALSE;
    return ErrorsDRC_Count;
}


/***********************************************************************/
int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
         TRACK* pt_segment, TRACK* StartBuffer, int show_err )
/***********************************************************************/

/*
 *  Teste le segment en cours de trace:
 *  pt_segment = pointeur sur segment a controler
 *  StartBuffer = adresse de la zone des pistes a controler
 *  (typiquement m_Pcb->m_Track)
 *  show_err (flag) si 0 pas d'affichage d'erreur sur ecran
 *  retourne :
 *      BAD_DRC (1) si Violation DRC
 *      OK_DRC  (0) si OK
 */
{
    int     ii;
    TRACK*  pttrack;
    int     x0, y0, xf, yf; // coord des extremites du segment teste dans le repere modifie
    int     dx, dy;         // utilise pour calcul des dim x et dim y des segments
    int     w_dist;
    int     MaskLayer;
    int     net_code_ref;
    int     org_X, org_Y; // Origine sur le PCB des axes du repere centre sur
                         //	l'origine du segment de reference
    wxPoint shape_pos;

    org_X        = pt_segment->m_Start.x; org_Y = pt_segment->m_Start.y;
    finx         = dx = pt_segment->m_End.x - org_X;
    finy         = dy = pt_segment->m_End.y - org_Y;
    MaskLayer    = pt_segment->ReturnMaskLayer();
    net_code_ref = pt_segment->m_NetCode;

    segm_angle = 0;
    if( dx || dy )
    {
        /* calcul de l'angle d'inclinaison en 0,1 degre */
        segm_angle = ArcTangente( dy, dx );
        /* Calcul de la longueur du segment en segm_long : dx = longueur */
        RotatePoint( &dx, &dy, segm_angle ); /* segm_long = longueur, yf = 0 */
    }

    /* Ici le segment a ete tourne de segm_angle, et est horizontal, dx > 0 */
    segm_long = dx;

    /******************************************/
    /* Phase 1 : test DRC track to pads :*/
    /******************************************/

    /* calcul de la distance min aux pads : */
    w_dist = (unsigned) (pt_segment->m_Width >> 1 );
    for( ii = 0; ii < frame->m_Pcb->m_NbPads; ii++ )
    {
        D_PAD* pt_pad = frame->m_Pcb->m_Pads[ii];

        /* Pas de probleme si les pads sont en surface autre que la couche,
         *  sauf si le trou de percage gene	(cas des pastilles perc<EFBFBD>s simple
         *  face sur CI double face */
        if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 )
        {
            /* We must test the pad hole. In order to use the function "TestClearanceSegmToPad",
             *  a pseudo pad is used, with a shape and a size like the hole */
            if( pt_pad->m_Drill.x == 0 )
                continue;
            D_PAD pseudo_pad( (MODULE*) NULL );

            pseudo_pad.m_Size     = pt_pad->m_Drill;
            pseudo_pad.m_Pos      = pt_pad->m_Pos;
            pseudo_pad.m_PadShape = pt_pad->m_DrillShape;
            pseudo_pad.m_Orient   = pt_pad->m_Orient;
            pseudo_pad.ComputeRayon();
            spot_cX = pseudo_pad.m_Pos.x - org_X;
            spot_cY = pseudo_pad.m_Pos.y - org_Y;
            if( TestClearanceSegmToPad( &pseudo_pad, w_dist,
                                        g_DesignSettings.m_TrackClearence ) != OK_DRC )
            {
                ErrorsDRC_Count++;
                if( show_err )
                    Affiche_Erreur_DRC( frame->DrawPanel, DC,
                                        frame->m_Pcb, pt_segment, pt_pad, 0 );
                return BAD_DRC;
            }
            continue;
        }

        /* Le pad doit faire partie d'un net mais pas de probleme
         *  si le pad est du meme net */
        if( pt_pad->m_NetCode && (net_code_ref == pt_pad->m_NetCode) )
            continue;

        /* Test DRC pour les pads */
        shape_pos = pt_pad->ReturnShapePos();
        spot_cX   = shape_pos.x - org_X;
        spot_cY   = shape_pos.y - org_Y;
        if( TestClearanceSegmToPad( pt_pad, w_dist, g_DesignSettings.m_TrackClearence ) == OK_DRC )
            continue;

        /* extremite sur pad ou defaut d'isolation trouve */
        else
        {
            ErrorsDRC_Count++;
            if( show_err )
                Affiche_Erreur_DRC( frame->DrawPanel, DC,
                                    frame->m_Pcb, pt_segment, pt_pad, 1 );
            return BAD_DRC;
        }
    }

    /**********************************************/
    /* Phase 2 : test DRC avec les autres pistes :*/
    /**********************************************/

    /* Ici le segment de reference est sur l'axe X */

    /* Comparaison du segment de reference aux autres segments de piste */
    pttrack = StartBuffer;
    for( ; pttrack != NULL; pttrack = (TRACK*) pttrack->Pnext )
    {
        //pas de probleme si le segment a tester est du meme net:
        if( net_code_ref == pttrack->m_NetCode )
            continue;

        //pas de probleme si le segment a tester est sur une autre couche :
        if( ( MaskLayer & pttrack->ReturnMaskLayer() ) == 0 )
            continue;

        /* calcul de la Distance mini = Isol+ rayon ou demi largeur seg ref
         + rayon ou demi largeur seg a comparer */
        w_dist  = pt_segment->m_Width >> 1;
        w_dist += pttrack->m_Width >> 1;
        w_dist += g_DesignSettings.m_TrackClearence;

        /* si le segment de reference est une via, le traitement est ici */
        if( pt_segment->m_StructType == TYPEVIA )
        {
            int orgx, orgy; // origine du repere d'axe X = segment a comparer
            int angle = 0;  // angle du segment a tester;
            orgx = pttrack->m_Start.x; orgy = pttrack->m_Start.y;
            dx   = pttrack->m_End.x - orgx; dy = pttrack->m_End.y - orgy;
            x0   = pt_segment->m_Start.x - orgx; y0 = pt_segment->m_Start.y - orgy;

            if( pttrack->m_StructType == TYPEVIA )   /* Tst distance entre 2 vias */
            {
                if( (int) hypot( (float) x0, (float) y0 ) < w_dist )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            21 );
                    return BAD_DRC;
                }
            }
            else    /* Tst distance de via a segment */
            {
                /* calcul de l'angle */
                angle = ArcTangente( dy, dx );

                /* Calcul des coord dans le nouveau repere */
                RotatePoint( &dx, &dy, angle );
                RotatePoint( &x0, &y0, angle );

                if( TestMarginToCircle( x0, y0, w_dist, dx ) == BAD_DRC )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            20 );
                    return BAD_DRC;
                }
            }
            continue;
        }

        /* calcule x0,y0, xf,yf = coord de debut et fin du segment de piste
         *  a tester, dans le repere axe X = segment de reference */
        x0 = pttrack->m_Start.x - org_X; y0 = pttrack->m_Start.y - org_Y;
        xf = pttrack->m_End.x - org_X; yf = pttrack->m_End.y - org_Y;

        RotatePoint( &x0, &y0, segm_angle ); RotatePoint( &xf, &yf, segm_angle );

        if( pttrack->m_StructType == TYPEVIA )
        {
            if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == OK_DRC )
                continue;
            ErrorsDRC_Count++;
            if( show_err )
                Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 21 );
            return BAD_DRC;
        }


        /*
         *  le segment de reference est Horizontal, par suite des modifs  d'axe.
         *  3 cas : segment a comparer parallele, perp ou incline
         */
        if( y0 == yf ) // segments paralleles
        {
            if( abs( y0 ) >= w_dist )
                continue;
            if( x0 > xf )
                EXCHG( x0, xf );                                /* pour que x0 <= xf */

            if( x0 > (-w_dist) && x0 < (segm_long + w_dist) )   /* Risque de defaut */
            {
                /* test fin tenant compte des formes arrondies des extremites */
                if( x0 >= 0 && x0 <= segm_long )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            2 );
                    return BAD_DRC;
                }
                if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            2 );
                    return BAD_DRC;
                }
            }
            if( xf > (-w_dist) && xf < (segm_long + w_dist) )
            {
                /* test fin tenant compte des formes arrondies des extremites */
                if( xf >= 0 && xf <= segm_long )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            3 );
                    return BAD_DRC;
                }
                if( TestMarginToCircle( xf, yf, w_dist, segm_long ) == BAD_DRC )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            3 );
                    return BAD_DRC;
                }
            }

            if( x0 <=0 && xf >= 0 )
            {
                ErrorsDRC_Count++;
                if( show_err )
                    Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 4 );
                return BAD_DRC;
            }
        }
        else if( x0 == xf ) // segments perpendiculaires
        {
            if( ( x0 <= (-w_dist) ) || ( x0 >= (segm_long + w_dist) ) )
                continue;

            /* test si les segments se croisent */
            if( y0 > yf )
                EXCHG( y0, yf );
            if( (y0 < 0) && (yf > 0) )
            {
                ErrorsDRC_Count++;
                if( show_err )
                    Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 6 );
                return BAD_DRC;
            }

            /* ici l'erreur est due a une extremite pres d'une extremite du segm
             *  de reference */
            if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
            {
                ErrorsDRC_Count++;
                if( show_err )
                    Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 7 );
                return BAD_DRC;
            }
            if( TestMarginToCircle( xf, yf, w_dist, segm_long ) == BAD_DRC )
            {
                ErrorsDRC_Count++;
                if( show_err )
                    Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 8 );
                return BAD_DRC;
            }
        }
        else // segments quelconques entre eux */
        {
            int bflag = OK_DRC;
            /* calcul de la "surface de securite du segment de reference */
            /* premiere passe : la piste est assimilee a un rectangle */

            xcliplo = ycliplo = -w_dist;
            xcliphi = segm_long + w_dist; ycliphi = w_dist;

            bflag = Tst_Ligne( x0, y0, xf, yf );
            if( bflag == BAD_DRC )
            {
                /* 2eme passe : la piste a des extremites arrondies.
                 *  Si le defaut de drc est du a une extremite : le calcul
                 *  est affine pour tenir compte de cet arrondi */

                xcliplo = 0; xcliphi = segm_long;
                bflag   = Tst_Ligne( x0, y0, xf, yf );

                if( bflag == BAD_DRC )
                {
                    ErrorsDRC_Count++;
                    if( show_err )
                        Affiche_Erreur_DRC( frame->DrawPanel,
                                            DC,
                                            frame->m_Pcb,
                                            pt_segment,
                                            pttrack,
                                            9 );
                    return BAD_DRC;
                }
                else    // L'erreur est due a une extremite du segment de reference:
                {
                        // il faut tester les extremites de ce segment
                    int angle, rx0, ry0, rxf, ryf;
                    x0 = pttrack->m_Start.x; y0 = pttrack->m_Start.y;
                    xf = pttrack->m_End.x; yf = pttrack->m_End.y;
                    dx = xf - x0; dy = yf - y0;
                    /* calcul de l'angle d'inclinaison en 0,1 degre */
                    angle = ArcTangente( dy, dx );
                    /* Calcul de la longueur du segment: dx = longueur */
                    RotatePoint( &dx, &dy, angle );

                    /* calcul des coord du segment de reference ds le repere
                     *  d'axe X = segment courant en tst */
                    rx0 = pt_segment->m_Start.x - x0;
                    ry0 = pt_segment->m_Start.y - y0;
                    rxf = pt_segment->m_End.x - x0;
                    ryf = pt_segment->m_End.y - y0;

                    RotatePoint( &rx0, &ry0, angle );
                    RotatePoint( &rxf, &ryf, angle );
                    if( TestMarginToCircle( rx0, ry0, w_dist, dx ) == BAD_DRC )
                    {
                        ErrorsDRC_Count++;
                        if( show_err )
                            Affiche_Erreur_DRC( frame->DrawPanel,
                                                DC,
                                                frame->m_Pcb,
                                                pt_segment,
                                                pttrack,
                                                10 );
                        return BAD_DRC;
                    }
                    if( TestMarginToCircle( rxf, ryf, w_dist, dx ) == BAD_DRC )
                    {
                        ErrorsDRC_Count++;
                        if( show_err )
                            Affiche_Erreur_DRC( frame->DrawPanel,
                                                DC,
                                                frame->m_Pcb,
                                                pt_segment,
                                                pttrack,
                                                11 );
                        return BAD_DRC;
                    }
                }
            }
        }
    }

    return OK_DRC;
}


/*****************************************************************************/
static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
                                  wxDC* DC,
                                  D_PAD* pad_ref,
                                  LISTE_PAD* start_buffer,
                                  LISTE_PAD* end_buffer,
                                  int max_size,
                                  bool show_err )
/*****************************************************************************/

/* Teste l'isolation de pad_ref avec les autres pads.
 *  end_buffer = upper limit of the pad list.
 *  max_size = size of the biggest pad (used to stop the test when the X distance is > max_size)
 */
{
    int        MaskLayer;
    D_PAD*     pad;
    LISTE_PAD* pad_list = start_buffer;

    MaskLayer = pad_ref->m_Masque_Layer & ALL_CU_LAYERS;
    int        x_limite = max_size + g_DesignSettings.m_TrackClearence +
                          pad_ref->m_Rayon + pad_ref->m_Pos.x;
    for( ; pad_list < end_buffer; pad_list++ )
    {
        pad = *pad_list;
        if( pad == pad_ref )
            continue;

        /* We can stop the test when pad->m_Pos.x > x_limite
         *  because the list is sorted by X values */
        if( pad->m_Pos.x > x_limite )
            break;

        /* Pas de probleme si les pads ne sont pas sur les memes couches cuivre*/
        if( (pad->m_Masque_Layer & MaskLayer ) == 0 )
            continue;

        /* Le pad doit faire partie d'un net,
         *  mais pas de probleme si les pads sont du meme net */
        if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) )
            continue;

        /* pas de pb si les pads sont du meme module et
         *  de la meme reference ( pads multiples )  */
        if( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) )
            continue;

        if( Pad_to_Pad_Isol( pad_ref, pad, g_DesignSettings.m_TrackClearence ) == OK_DRC )
            continue;
        else    /* defaut d'isolation trouve */
        {
            ErrorsDRC_Count++;
            if( show_err )
                Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pad_ref, pad );
            return BAD_DRC;
        }
    }

    return OK_DRC;
}


/**************************************************************************************/
static int Pad_to_Pad_Isol( D_PAD* pad_ref, D_PAD* pad, const int dist_min )
/***************************************************************************************/

/* Return OK_DRC si clearance between pad_ref and pad is >= dist_min
 *  or BAD_DRC if not */
{
    wxPoint rel_pos;
    int     dist, diag;
    wxPoint shape_pos;
    int     pad_angle;

    rel_pos   = pad->ReturnShapePos();
    shape_pos = pad_ref->ReturnShapePos();

    // rel_pos is pad position relative to the pad_ref position
    rel_pos.x -= shape_pos.x;
    rel_pos.y -= shape_pos.y;
    dist = (int) hypot( (double) rel_pos.x, (double) rel_pos.y );

    diag = OK_DRC;

    /* tst rapide: si les cercles exinscrits sont distants de dist_min au moins,
     *  il n'y a pas de risque: */
    if( (dist - pad_ref->m_Rayon - pad->m_Rayon) >= dist_min )
        return OK_DRC;

    /* Ici les pads sont proches et les cercles exinxcrits sont trop proches
     *  Selon les formes relatives il peut y avoir ou non erreur */

    bool swap_pads = false;
    if( (pad_ref->m_PadShape != CIRCLE) && (pad->m_PadShape == CIRCLE) )
        swap_pads = true;
    else if( (pad_ref->m_PadShape != OVALE) && (pad->m_PadShape == OVALE) )
        swap_pads = true;

    if( swap_pads )
    {
        EXCHG( pad_ref, pad );
        rel_pos.x = -rel_pos.x;
        rel_pos.y = -rel_pos.y;
    }

    switch( pad_ref->m_PadShape )
    {
    case CIRCLE:        // pad_ref is like a track segment with a null lenght
        segm_long  = 0;
        segm_angle = 0;
        finx    = finy = 0;
        spot_cX = rel_pos.x;
        spot_cY = rel_pos.y;
        diag    = TestClearanceSegmToPad( pad, pad_ref->m_Rayon, dist_min );
        break;

    case RECT:
        RotatePoint( &rel_pos.x, &rel_pos.y, pad_ref->m_Orient );
        pad_angle = pad_ref->m_Orient + pad->m_Orient;      // pad_angle = pad orient relative to the pad_ref orient
        NORMALIZE_ANGLE_POS( pad_angle );
        if( pad->m_PadShape == RECT )
        {
            wxSize size = pad->m_Size;
            if( (pad_angle == 0) || (pad_angle == 900) || (pad_angle == 1800) ||
               (pad_angle == 2700) )
            {
                if( (pad_angle == 900) || (pad_angle == 2700) )
                {
                    EXCHG( size.x, size.y );
                }

                // Test DRC:
                diag      = BAD_DRC;
                rel_pos.x = ABS( rel_pos.x ); rel_pos.y = ABS( rel_pos.y );
                if( ( rel_pos.x - ( (size.x + pad_ref->m_Size.x) / 2 ) ) >= dist_min )
                    diag = OK_DRC;
                if( ( rel_pos.y - ( (size.y + pad_ref->m_Size.y) / 2 ) ) >= dist_min )
                    diag = OK_DRC;
            }
            else        // Any other orient
            {
                        /* TODO : any orient ... */
            }
        }
        break;

    case OVALE:     /* an oval pad is like a track segment */
    {
        /* Create and test a track segment with same dimensions */
        int segm_width;
        segm_angle = pad_ref->m_Orient;                     // Segment orient.
        if( pad_ref->m_Size.y < pad_ref->m_Size.x )         /* We suppose the pad is an horizontal oval */
        {
            segm_width = pad_ref->m_Size.y;
            segm_long  = pad_ref->m_Size.x - pad_ref->m_Size.y;
        }
        else        // it was a vertical oval, change to a rotated horizontal one
        {
            segm_width  = pad_ref->m_Size.x;
            segm_long   = pad_ref->m_Size.y - pad_ref->m_Size.x;
            segm_angle += 900;
        }
        /* the start point must be 0,0 and currently rel_pos is relative the center of pad coordinate */
        int sx = -segm_long / 2, sy = 0;        // Start point coordinate of the horizontal equivalent segment
        RotatePoint( &sx, &sy, segm_angle );    // True start point coordinate of the equivalent segment
        spot_cX = rel_pos.x + sx;
        spot_cY = rel_pos.y + sy;               // pad position / segment origin
        finx    = -sx;
        finy    = -sy;                          // end of segment coordinate
        diag    = TestClearanceSegmToPad( pad, segm_width / 2, dist_min );
        break;
    }

    default:
        /* TODO...*/
        break;
    }

    return diag;
}


/***************************************************************************/
static int TestClearanceSegmToPad( const D_PAD* pad_to_test, int w_segm, int dist_min )
/****************************************************************************/

/*
 *  Routine adaptee de la "distance()" (LOCATE.CPP)
 *  teste la distance du pad au segment de droite en cours
 * 
 *  retourne:
 *      0 si distance >= dist_min
 *      1 si distance < dist_min
 *  Parametres d'appel:
 *      pad_to_test	= pointeur sur le pad a tester
 *      w_segm = demi largeur du segment a tester
 *      dist_min = marge a respecter
 * 
 *  en variables globales
 *      segm_long = longueur du segment en test
 *      segm_angle = angle d'inclinaison du segment;
 *      finx, finy = coord fin du segment / origine
 *      spot_cX, spot_cY = position du pad / origine du segment
 */
{
    int p_dimx, p_dimy; /* demi - dimensions X et Y du pad a controler */
    int bflag;
    int orient;
    int x0, y0, xf, yf;
    int seuil;
    int deltay;

    seuil  = w_segm + dist_min;
    p_dimx = pad_to_test->m_Size.x >> 1;
    p_dimy = pad_to_test->m_Size.y >> 1;

    if( pad_to_test->m_PadShape == CIRCLE )
    {
        /* calcul des coord centre du pad dans le repere axe X confondu
         *  avec le segment en tst */
        RotatePoint( &spot_cX, &spot_cY, segm_angle );
        return TestMarginToCircle( spot_cX, spot_cY, seuil + p_dimx, segm_long );
    }
    else
    {
        /* calcul de la "surface de securite" du pad de reference */
        xcliplo = spot_cX - seuil - p_dimx;
        ycliplo = spot_cY - seuil - p_dimy;
        xcliphi = spot_cX + seuil + p_dimx;
        ycliphi = spot_cY + seuil + p_dimy;
        
        x0 = y0 = 0; 
        
        xf = finx; 
        yf = finy;
        
        orient = pad_to_test->m_Orient;
        
        RotatePoint( &x0, &y0, spot_cX, spot_cY, -orient );
        RotatePoint( &xf, &yf, spot_cX, spot_cY, -orient );

        bflag = Tst_Ligne( x0, y0, xf, yf );

        if( bflag == OK_DRC )
            return OK_DRC;
        /* Erreur DRC : analyse fine de la forme de la pastille */

        switch( pad_to_test->m_PadShape )
        {
        default:
            return BAD_DRC;

        case OVALE:
            /* test de la pastille ovale ramenee au type ovale vertical */
            if( p_dimx > p_dimy )
            {
                EXCHG( p_dimx, p_dimy ); orient += 900;
                if( orient >= 3600 )
                    orient -= 3600;
            }
            deltay = p_dimy - p_dimx;

            /* ici: p_dimx = rayon,
             *      delta = dist centre cercles a centre pad */

            /* Test du rectangle separant les 2 demi cercles */
            xcliplo = spot_cX - seuil - p_dimx;
            ycliplo = spot_cY - w_segm - deltay;
            xcliphi = spot_cX + seuil + p_dimx;
            ycliphi = spot_cY + w_segm + deltay;

            bflag = Tst_Ligne( x0, y0, xf, yf );
            if( bflag == BAD_DRC )
                return BAD_DRC;

            /* test des 2 cercles */
            x0 = spot_cX;     /* x0,y0 = centre du cercle superieur du pad ovale */
            y0 = spot_cY + deltay;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, p_dimx + seuil, segm_long );
            if( bflag == BAD_DRC )
                return BAD_DRC;

            x0 = spot_cX;     /* x0,y0 = centre du cercle inferieur du pad ovale */
            y0 = spot_cY - deltay;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, p_dimx + seuil, segm_long );
            if( bflag == BAD_DRC )
                return BAD_DRC;
            break;

        case RECT:      /* 2 rectangle + 4 1/4 cercles a tester */
            /* Test du rectangle dimx + seuil, dimy */
            xcliplo = spot_cX - p_dimx - seuil;
            ycliplo = spot_cY - p_dimy;
            xcliphi = spot_cX + p_dimx + seuil;
            ycliphi = spot_cY + p_dimy;

            bflag = Tst_Ligne( x0, y0, xf, yf );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            /* Test du rectangle dimx , dimy + seuil */
            xcliplo = spot_cX - p_dimx;
            ycliplo = spot_cY - p_dimy - seuil;
            xcliphi = spot_cX + p_dimx;
            ycliphi = spot_cY + p_dimy + seuil;

            bflag = Tst_Ligne( x0, y0, xf, yf );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            /* test des 4 cercles ( surface d'solation autour des sommets */
            /* test du coin sup. gauche du pad */
            x0 = spot_cX - p_dimx;
            y0 = spot_cY - p_dimy;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            /* test du coin sup. droit du pad */
            x0 = spot_cX + p_dimx;
            y0 = spot_cY - p_dimy;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            /* test du coin inf. gauche du pad */
            x0 = spot_cX - p_dimx;
            y0 = spot_cY + p_dimy;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            /* test du coin inf. droit du pad */
            x0 = spot_cX + p_dimx;
            y0 = spot_cY + p_dimy;
            RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
            RotatePoint( &x0, &y0, segm_angle );
            bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
            if( bflag == BAD_DRC )
            {
                return BAD_DRC;
            }

            break;
        }
    }
    return OK_DRC;
}


/*******************************************************************/
static int TestMarginToCircle( int cx, int cy, int rayon, int longueur )
/*******************************************************************/

/*
 *  Routine analogue a TestClearanceSegmToPad.
 *  Calcul de la distance d'un cercle (via ronde, extremite de piste)
 *   au segment de droite en cours de controle (segment de reference dans
 *   son repere )
 *  parametres:
 *      cx, cy: centre du cercle (surface ronde) a tester, dans le repere
 *                          segment de reference
 *      rayon = rayon du cercle
 *      longueur = longueur du segment dans son repere (i.e. coord de fin)
 *  retourne:
 *      OK_DRC si distance >= rayon
 *      BAD_DRC si distance < rayon
 */
{
    if( abs( cy ) > rayon )
        return OK_DRC;

    if( (cx >= -rayon ) && ( cx <= (longueur + rayon) ) )
    {
        if( (cx >= 0) && (cx <= longueur) )
            return BAD_DRC;
        if( cx > longueur )
            cx -= longueur;
        if( hypot( (double) cx, (double) cy ) < rayon )
            return BAD_DRC;
    }

    return OK_DRC;
}


/******************************************************************************/
static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
                                TRACK* pt_ref, void* pt_item, int errnumber )
/******************************************************************************/

/* affiche les erreurs de DRC :
 *  Message d'erreur
 +
 *  Marqueur
 *  number = numero d'identification
 */
{
    wxPoint  erc_pos;
    TRACK*   pt_segm;
    wxString msg;
    wxString tracktype, netname1, netname2;
    EQUIPOT* equipot = Pcb->FindNet( pt_ref->m_NetCode );

    if( equipot )
        netname1 = equipot->m_Netname;
    else
        netname1 = wxT( "<noname>" );
    netname2 = wxT( "<noname>" );

    tracktype = wxT( "Track" );
    if( pt_ref->m_StructType == TYPEVIA )
        tracktype = wxT( "Via" );
    if( pt_ref->m_StructType == TYPEZONE )
        tracktype = wxT( "Zone" );


    if( ( (EDA_BaseStruct*) pt_item )->m_StructType == TYPEPAD )
    {
        D_PAD* pad = (D_PAD*) pt_item;
        equipot = Pcb->FindNet( pad->m_NetCode );
        if( equipot )
            netname2 = equipot->m_Netname;
        erc_pos = pad->m_Pos;
        wxString pad_name    = pad->ReturnStringPadName();
        wxString module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
        msg.Printf( _( "%d Drc Err %d %s (net %s)and PAD %s (%s) net %s @ %d,%d\n" ),
                    ErrorsDRC_Count, errnumber, tracktype.GetData(),
                    netname1.GetData(),
                    pad_name.GetData(), module_name.GetData(),
                    netname2.GetData(),
                    erc_pos.x, erc_pos.y );
    }
    else    /* erreur sur segment de piste */
    {
        pt_segm = (TRACK*) pt_item;
        equipot = Pcb->FindNet( pt_segm->m_NetCode );
        if( equipot )
            netname2 = equipot->m_Netname;
        erc_pos = pt_segm->m_Start;
        if( pt_segm->m_StructType == TYPEVIA )
        {
            msg.Printf( _( "%d Err type %d: %s (net %s) and VIA (net %s) @ %d,%d\n" ),
                        ErrorsDRC_Count, errnumber, tracktype.GetData(),
                        netname1.GetData(), netname2.GetData(),
                        erc_pos.x, erc_pos.y );
        }
        else
        {
            wxPoint erc_pos_f = pt_segm->m_End;
            if( hypot( (double) (erc_pos_f.x - pt_ref->m_End.x),
                      (double) (erc_pos_f.y - pt_ref->m_End.y) )
               < hypot( (double) (erc_pos.x - pt_ref->m_End.x),
                       (double) (erc_pos.y - pt_ref->m_End.y) ) )
            {
                EXCHG( erc_pos_f.x, erc_pos.x ); EXCHG( erc_pos_f.y, erc_pos.y );
            }
            msg.Printf( _( "%d Err type %d: %s (net %s) and track (net %s) @ %d,%d\n" ),
                        ErrorsDRC_Count, errnumber, tracktype.GetData(),
                        netname1.GetData(), netname2.GetData(),
                        erc_pos.x, erc_pos.y );
        }
    }

    if( DrcFrame )
        DrcFrame->m_logWindow->AppendText( msg );
    else
        panel->m_Parent->Affiche_Message( msg );
    if( s_RptFile )
        fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );

    if( current_marqueur == NULL )
        current_marqueur = new MARQUEUR( Pcb );
    current_marqueur->m_Pos   = wxPoint( erc_pos.x, erc_pos.y );
    current_marqueur->m_Color = WHITE;
    current_marqueur->m_Diag  = msg;
    current_marqueur->Draw( panel, DC, GR_OR );
}


/******************************************************************************/
static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
                                D_PAD* pad1, D_PAD* pad2 )
/******************************************************************************/

/* affiche les erreurs de DRC :
 *  Message d'erreur
 +
 *  Marqueur
 *  number = numero d'identification
 */
{
    wxString msg;

    wxString pad_name1    = pad1->ReturnStringPadName();
    wxString module_name1 = ( (MODULE*) (pad1->m_Parent) )->m_Reference->m_Text;
    wxString pad_name2    = pad2->ReturnStringPadName();
    wxString module_name2 = ( (MODULE*) (pad2->m_Parent) )->m_Reference->m_Text;
    wxString netname1, netname2;
    EQUIPOT* equipot = Pcb->FindNet( pad1->m_NetCode );

    if( equipot )
        netname1 = equipot->m_Netname;
    else
        netname1 = wxT( "<noname>" );
    equipot = Pcb->FindNet( pad2->m_NetCode );
    if( equipot )
        netname2 = equipot->m_Netname;
    else
        netname2 = wxT( "<noname>" );

    msg.Printf( _( "%d Drc Err: PAD %s (%s) net %s @ %d,%d and PAD %s (%s) net %s @ %d,%d\n" ),
                ErrorsDRC_Count, pad_name1.GetData(), module_name1.GetData(),
                netname1.GetData(), pad1->m_Pos.x, pad1->m_Pos.y,
                pad_name2.GetData(), module_name2.GetData(),
                netname2.GetData(), pad2->m_Pos.x, pad2->m_Pos.y );
    if( DrcFrame )
        DrcFrame->m_logWindow->AppendText( msg );
    else
        panel->m_Parent->Affiche_Message( msg );
    if( s_RptFile )
        fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );

    if( current_marqueur == NULL )
        current_marqueur = new MARQUEUR( Pcb );
    current_marqueur->m_Pos   = pad1->m_Pos;
    current_marqueur->m_Color = WHITE;
    current_marqueur->m_Diag  = msg;
    current_marqueur->Draw( panel, DC, GR_OR );
}


/**********************************************/
/* int Tst_Ligne(int x1,int y1,int x2,int y2) */
/**********************************************/

/* Routine utilisee pour tester si une piste est en contact avec une autre piste.
 * 
 *  Cette routine controle si la ligne (x1,y1 x2,y2) a une partie s'inscrivant
 *  dans le cadre (xcliplo,ycliplo xcliphi,ycliphi) (variables globales,
 *  locales a ce fichier)
 * 
 *  Retourne OK_DRC si aucune partie commune
 *  Retourne BAD_DRC si partie commune
 */
#define us unsigned int
static inline int USCALE( us arg, us num, us den )
{
    int ii;

    ii = (int) ( ( (float) arg * num ) / den );
    return ii;
}


#define WHEN_OUTSIDE return (OK_DRC)
#define WHEN_INSIDE

static int Tst_Ligne( int x1, int y1, int x2, int y2 )
{
    int temp;

    do {
        if( x1 > x2 )
        {
            EXCHG( x1, x2 ); EXCHG( y1, y2 );
        }
        if( (x2 < xcliplo) || (x1 > xcliphi) )
        {
            WHEN_OUTSIDE;
        }
        if( y1 < y2 )
        {
            if( (y2 < ycliplo) || (y1 > ycliphi) )
            {
                WHEN_OUTSIDE;
            }
            if( y1 < ycliplo )
            {
                temp = USCALE( (x2 - x1), (ycliplo - y1), (y2 - y1) );
                if( (x1 += temp) > xcliphi )
                {
                    WHEN_OUTSIDE;
                }
                y1 = ycliplo;
                WHEN_INSIDE;
            }
            if( y2 > ycliphi )
            {
                temp = USCALE( (x2 - x1), (y2 - ycliphi), (y2 - y1) );
                if( (x2 -= temp) < xcliplo )
                {
                    WHEN_OUTSIDE;
                }
                y2 = ycliphi;
                WHEN_INSIDE;
            }
            if( x1 < xcliplo )
            {
                temp = USCALE( (y2 - y1), (xcliplo - x1), (x2 - x1) );
                y1  += temp; x1 = xcliplo;
                WHEN_INSIDE;
            }
            if( x2 > xcliphi )
            {
                temp = USCALE( (y2 - y1), (x2 - xcliphi), (x2 - x1) );
                y2  -= temp; x2 = xcliphi;
                WHEN_INSIDE;
            }
        }
        else
        {
            if( (y1 < ycliplo) || (y2 > ycliphi) )
            {
                WHEN_OUTSIDE;
            }
            if( y1 > ycliphi )
            {
                temp = USCALE( (x2 - x1), (y1 - ycliphi), (y1 - y2) );
                if( (x1 += temp) > xcliphi )
                {
                    WHEN_OUTSIDE;
                }
                y1 = ycliphi;
                WHEN_INSIDE;
            }
            if( y2 < ycliplo )
            {
                temp = USCALE( (x2 - x1), (ycliplo - y2), (y1 - y2) );
                if( (x2 -= temp) < xcliplo )
                {
                    WHEN_OUTSIDE;
                }
                y2 = ycliplo;
                WHEN_INSIDE;
            }
            if( x1 < xcliplo )
            {
                temp = USCALE( (y1 - y2), (xcliplo - x1), (x2 - x1) );
                y1  -= temp; x1 = xcliplo;
                WHEN_INSIDE;
            }
            if( x2 > xcliphi )
            {
                temp = USCALE( (y1 - y2), (x2 - xcliphi), (x2 - x1) );
                y2  += temp; x2 = xcliphi;
                WHEN_INSIDE;
            }
        }
    } while( 0 );

    if( ( (x2 + x1) / 2 <= xcliphi ) && ( (x2 + x1) / 2 >= xcliplo ) \
       && ( (y2 + y1) / 2 <= ycliphi ) && ( (y2 + y1) / 2 >= ycliplo ) )
    {
        return BAD_DRC;
    }
    else
        return OK_DRC;
}