diff --git a/pcbnew/board.cpp b/pcbnew/board.cpp
index 0a16df25a0..fae07f84e2 100644
--- a/pcbnew/board.cpp
+++ b/pcbnew/board.cpp
@@ -1,8 +1,8 @@
-	/************************************************/
-	/* EDITEUR de PCB: AUTOROUTAGE: routines d'init */
-	/************************************************/
+/************************************************/
+/* EDITEUR de PCB: AUTOROUTAGE: routines d'init */
+/************************************************/
 
-	/* Fichier BOARD.CC */
+/* Fichier BOARD.CC */
 
 #include "fctsys.h"
 #include "gr_basic.h"
@@ -17,383 +17,404 @@
 /* routines externes : */
 
 /* Routines definies ici: */
-int Build_Work(BOARD * Pcb, CHEVELU* pt_base_chevelu);
-void PlaceCells(BOARD * Pcb, int net_code, int flag);
-int InitBoard( void );
-BoardCell GetCell( int, int, int );
-void SetCell(int row,int col,int side,BoardCell x );
-void OrCell( int, int, int, BoardCell );
-void AndCell( int, int, int, BoardCell );
-void AddCell( int, int, int, BoardCell );
-void XorCell( int, int, int, BoardCell );
-void AddCell( int, int, int, BoardCell );
-DistCell GetDist( int, int, int );
-void SetDist( int, int, int, DistCell );
-int GetDir( int, int, int );
-void SetDir( int, int, int, int );
+int         Build_Work( BOARD* Pcb, CHEVELU* pt_base_chevelu );
+void        PlaceCells( BOARD* Pcb, int net_code, int flag );
+int         InitBoard( void );
+BoardCell   GetCell( int, int, int );
+void        SetCell( int row, int col, int side, BoardCell x );
+void        OrCell( int, int, int, BoardCell );
+void        AndCell( int, int, int, BoardCell );
+void        AddCell( int, int, int, BoardCell );
+void        XorCell( int, int, int, BoardCell );
+void        AddCell( int, int, int, BoardCell );
+DistCell    GetDist( int, int, int );
+void        SetDist( int, int, int, DistCell );
+int         GetDir( int, int, int );
+void        SetDir( int, int, int, int );
 
 /*****************************************************************/
-bool ComputeMatriceSize(WinEDA_BasePcbFrame * frame, int g_GridRoutingSize)
+bool ComputeMatriceSize( WinEDA_BasePcbFrame* frame, int g_GridRoutingSize )
 /*****************************************************************/
+
 /*
-Calcule Nrows et Ncols, dimensions de la matrice de representation du BOARD
-pour les routages automatiques et calculs de zone
-*/
+ *  Calcule Nrows et Ncols, dimensions de la matrice de representation du BOARD
+ *  pour les routages automatiques et calculs de zone
+ */
 {
-BOARD * pcb = frame->m_Pcb;
-	
-	pcb->ComputeBoundaryBox();
+    BOARD* pcb = frame->m_Pcb;
 
-	/* The boundary box must have its start point on routing grid: */
-	pcb->m_BoundaryBox.m_Pos.x -= pcb->m_BoundaryBox.m_Pos.x % g_GridRoutingSize;
-	pcb->m_BoundaryBox.m_Pos.y -= pcb->m_BoundaryBox.m_Pos.y % g_GridRoutingSize;
-	/* The boundary box must have its end point on routing grid: */
-	wxPoint end = pcb->m_BoundaryBox.GetEnd();
-	end.x -= end.x % g_GridRoutingSize; end.x += g_GridRoutingSize;
-	end.y -= end.y % g_GridRoutingSize; end.y += g_GridRoutingSize;
-	pcb->m_BoundaryBox.SetEnd(end);
+    pcb->ComputeBoundaryBox();
 
-	Nrows = pcb->m_BoundaryBox.m_Size.y / g_GridRoutingSize ;
-	Ncols = pcb->m_BoundaryBox.m_Size.x / g_GridRoutingSize ;
-	/* get a small margin for memory allocation: */
-	Ncols += 2; Nrows += 2;
+    /* The boundary box must have its start point on routing grid: */
+    pcb->m_BoundaryBox.m_Pos.x -= pcb->m_BoundaryBox.m_Pos.x % g_GridRoutingSize;
+    pcb->m_BoundaryBox.m_Pos.y -= pcb->m_BoundaryBox.m_Pos.y % g_GridRoutingSize;
+    /* The boundary box must have its end point on routing grid: */
+    wxPoint end = pcb->m_BoundaryBox.GetEnd();
+    end.x -= end.x % g_GridRoutingSize; end.x += g_GridRoutingSize;
+    end.y -= end.y % g_GridRoutingSize; end.y += g_GridRoutingSize;
+    pcb->m_BoundaryBox.SetEnd( end );
 
-	return TRUE;
+    Nrows = pcb->m_BoundaryBox.m_Size.y / g_GridRoutingSize;
+    Ncols = pcb->m_BoundaryBox.m_Size.x / g_GridRoutingSize;
+    /* get a small margin for memory allocation: */
+    Ncols += 2; Nrows += 2;
+
+    return TRUE;
 }
 
-	/*******************/
-	/* class BOARDHEAD */
-	/*******************/
 
-BOARDHEAD::BOARDHEAD(void)
+/*******************/
+/* class BOARDHEAD */
+/*******************/
+
+BOARDHEAD::BOARDHEAD( void )
 {
-	m_BoardSide[0] = m_BoardSide[1] = NULL;
-	m_DistSide[0] = m_DistSide[1] = NULL;
-	m_DirSide[0] = m_DirSide[1] = NULL;
-	m_InitBoardDone = FALSE;
-	m_Layers = 2;
-	m_Nrows = m_Ncols = 0;
-	m_MemSize = 0;
+    m_BoardSide[0]  = m_BoardSide[1] = NULL;
+    m_DistSide[0]   = m_DistSide[1] = NULL;
+    m_DirSide[0]    = m_DirSide[1] = NULL;
+    m_InitBoardDone = FALSE;
+    m_Layers  = 2;
+    m_Nrows   = m_Ncols = 0;
+    m_MemSize = 0;
 }
 
-BOARDHEAD::~BOARDHEAD(void)
+
+BOARDHEAD::~BOARDHEAD( void )
 {
 }
 
+
 /******************************/
-int BOARDHEAD::InitBoard (void)
+int BOARDHEAD::InitBoard( void )
 /*****************************/
- /* initialize the data structures
- 	retourne la taille RAM utilisee, ou -1 si defaut
-*/
+
+/* initialize the data structures
+ *  retourne la taille RAM utilisee, ou -1 si defaut
+ */
 {
-int ii, kk;
+    int ii, kk;
 
-	if (Nrows <= 0 || Ncols <= 0) return(0);
-	m_Nrows = Nrows;
-	m_Ncols = Ncols;
+    if( Nrows <= 0 || Ncols <= 0 )
+        return 0;
+    m_Nrows = Nrows;
+    m_Ncols = Ncols;
 
-	m_InitBoardDone = TRUE; /* we have been called */
+    m_InitBoardDone = TRUE; /* we have been called */
 
-	ii = (Nrows+1) * (Ncols+1);
+    ii = (Nrows + 1) * (Ncols + 1);
 
-	for ( kk = 0; kk < m_Layers; kk++ )
-		{
-		m_BoardSide[kk] = NULL;
-		m_DistSide[kk] = NULL;
-		m_DirSide[kk] = NULL;
+    for( kk = 0; kk < m_Layers; kk++ )
+    {
+        m_BoardSide[kk] = NULL;
+        m_DistSide[kk]  = NULL;
+        m_DirSide[kk]   = NULL;
 
-		/* allocate Board & initialize everything to empty */
-		m_BoardSide[kk] = (BoardCell*)MyZMalloc( ii * sizeof (BoardCell) );
-		if( m_BoardSide[kk] == NULL) return(-1);
+        /* allocate Board & initialize everything to empty */
+        m_BoardSide[kk] = (BoardCell*) MyZMalloc( ii * sizeof(BoardCell) );
+        if( m_BoardSide[kk] == NULL )
+            return -1;
 
-		/***** allocate Distances *****/
-		m_DistSide[kk] = (DistCell *)MyZMalloc( ii * sizeof(DistCell) );
-		if (m_DistSide[kk] == NULL) return(-1);
+        /***** allocate Distances *****/
+        m_DistSide[kk] = (DistCell*) MyZMalloc( ii * sizeof(DistCell) );
+        if( m_DistSide[kk] == NULL )
+            return -1;
 
-		/***** allocate Dir (chars) *****/
-		m_DirSide[kk] = (char *)MyZMalloc( ii );
-		if (m_DirSide[kk] == NULL) return( -1 );
-		}
+        /***** allocate Dir (chars) *****/
+        m_DirSide[kk] = (char*) MyZMalloc( ii );
+        if( m_DirSide[kk] == NULL )
+            return -1;
+    }
 
-	m_MemSize = m_Layers * ii * ( sizeof(BoardCell) + sizeof(DistCell) + sizeof(char) );
+    m_MemSize = m_Layers * ii * ( sizeof(BoardCell) + sizeof(DistCell) + sizeof(char) );
 
-	return(m_MemSize);
+    return m_MemSize;
 }
 
+
 /*********************************/
-void BOARDHEAD::UnInitBoard(void)
+void BOARDHEAD::UnInitBoard( void )
 /*********************************/
 /* deallocation de la memoire */
 {
-int ii;
+    int ii;
 
-	m_InitBoardDone = FALSE;
+    m_InitBoardDone = FALSE;
 
-	for ( ii = 0; ii < 2; ii++ )
-	{
-		/***** de-allocate Dir (chars) *****/
-		if( m_DirSide[ii] )
-		{
-			MyFree(m_DirSide[ii]); m_DirSide[ii] = NULL;
-		}
+    for( ii = 0; ii < 2; ii++ )
+    {
+        /***** de-allocate Dir (chars) *****/
+        if( m_DirSide[ii] )
+        {
+            MyFree( m_DirSide[ii] ); m_DirSide[ii] = NULL;
+        }
 
-		/***** de-allocate Distances *****/
-		if( m_DistSide[ii] )
-		{
-			MyFree(m_DistSide[ii]); m_DistSide[ii] = NULL;
-		}
+        /***** de-allocate Distances *****/
+        if( m_DistSide[ii] )
+        {
+            MyFree( m_DistSide[ii] ); m_DistSide[ii] = NULL;
+        }
 
-		/**** de-allocate Board *****/
-		if( m_BoardSide[ii] )
-		{
-			MyFree(m_BoardSide[ii]); m_BoardSide[ii] = NULL;
-		}
-	}
+        /**** de-allocate Board *****/
+        if( m_BoardSide[ii] )
+        {
+            MyFree( m_BoardSide[ii] ); m_BoardSide[ii] = NULL;
+        }
+    }
 
-	m_Nrows = m_Ncols = 0;
+    m_Nrows = m_Ncols = 0;
 }
 
 
+/*****************************************************/
+void PlaceCells( BOARD* Pcb, int net_code, int flag )
+/*****************************************************/
 
-/*****************************************************/
-void PlaceCells(BOARD * Pcb, int net_code, int flag)
-/*****************************************************/
 /* Initialise les cellules du board a la valeur HOLE et VIA_IMPOSSIBLE
-	selon les marges d'isolement
-	les elements de net_code = net_code ne seront pas places comme occupe
-	mais en VIA_IMPOSSIBLE uniquement
-	Pour Routage 1 seule face:
-		le plan BOTTOM est utilise
-		et Route_Layer_BOTTOM = Route_Layer_TOP
-
-	Selon les bits = 1 du parametre flag:
-		si FORCE_PADS : tous les pads seront places meme ceux de meme net_code
-*/
+ *  selon les marges d'isolement
+ *  les elements de net_code = net_code ne seront pas places comme occupe
+ *  mais en VIA_IMPOSSIBLE uniquement
+ *  Pour Routage 1 seule face:
+ *      le plan BOTTOM est utilise
+ *      et Route_Layer_BOTTOM = Route_Layer_TOP
+ * 
+ *  Selon les bits = 1 du parametre flag:
+ *      si FORCE_PADS : tous les pads seront places meme ceux de meme net_code
+ */
 {
-int ii;
-LISTE_PAD* ptr;
-TRACK * pt_segm;
-TEXTE_PCB * PtText;
-DRAWSEGMENT * DrawSegm;
-EDA_BaseStruct * PtStruct;
-int ux0 = 0 , uy0 = 0, ux1, uy1, dx, dy;
-int marge, via_marge;
-int masque_layer;
+    int             ii;
+    LISTE_PAD*      ptr;
+    TRACK*          pt_segm;
+    TEXTE_PCB*      PtText;
+    DRAWSEGMENT*    DrawSegm;
+    EDA_BaseStruct* PtStruct;
+    int             ux0 = 0, uy0 = 0, ux1, uy1, dx, dy;
+    int             marge, via_marge;
+    int             masque_layer;
 
-	marge = g_DesignSettings.m_TrackClearence + (g_DesignSettings.m_CurrentTrackWidth /2);
-	via_marge = g_DesignSettings.m_TrackClearence + (g_DesignSettings.m_CurrentViaSize /2);
+    marge     = g_DesignSettings.m_TrackClearence + (g_DesignSettings.m_CurrentTrackWidth / 2);
+    via_marge = g_DesignSettings.m_TrackClearence + (g_DesignSettings.m_CurrentViaSize / 2);
 
-	/////////////////////////////////////
-	// Placement des PADS sur le board //
-	/////////////////////////////////////
-	ptr = (LISTE_PAD*)Pcb->m_Pads; ii = Pcb->m_NbPads;
-	for( ; ii > 0 ; ii-- , ptr++)
-		{
-		if( (net_code != (*ptr)->m_NetCode ) || (flag & FORCE_PADS) )
-			{
-			Place_1_Pad_Board(Pcb, *ptr, HOLE, marge, WRITE_CELL);
-			}
-		Place_1_Pad_Board(Pcb, *ptr, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL);
-		}
+    /////////////////////////////////////
+    // Placement des PADS sur le board //
+    /////////////////////////////////////
+    ptr = (LISTE_PAD*) Pcb->m_Pads; ii = Pcb->m_NbPads;
+    for( ; ii > 0; ii--, ptr++ )
+    {
+        if( (net_code != (*ptr)->m_NetCode ) || (flag & FORCE_PADS) )
+        {
+            Place_1_Pad_Board( Pcb, *ptr, HOLE, marge, WRITE_CELL );
+        }
+        Place_1_Pad_Board( Pcb, *ptr, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
+    }
 
-	///////////////////////////////////////////////
-	// Placement des elements de modules sur PCB //
-	///////////////////////////////////////////////
-	PtStruct = Pcb->m_Modules;
-	for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
-		{
-		EDA_BaseStruct * PtModStruct = ((MODULE*)PtStruct)->m_Drawings;
-		for( ;PtModStruct != NULL; PtModStruct = PtModStruct->Pnext )
-			{
-			switch( PtModStruct->m_StructType )
-				{
-				case TYPEEDGEMODULE:
-					{
-					TRACK * TmpSegm = new TRACK(NULL);
-					TmpSegm->m_Layer = ((EDGE_MODULE *) PtModStruct)->m_Layer;
-					if(TmpSegm->m_Layer == EDGE_N) TmpSegm->m_Layer = -1;
+    ///////////////////////////////////////////////
+    // Placement des elements de modules sur PCB //
+    ///////////////////////////////////////////////
+    PtStruct = Pcb->m_Modules;
+    for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
+    {
+        EDA_BaseStruct* PtModStruct = ( (MODULE*) PtStruct )->m_Drawings;
+        for( ; PtModStruct != NULL; PtModStruct = PtModStruct->Pnext )
+        {
+            switch( PtModStruct->m_StructType )
+            {
+            case TYPEEDGEMODULE:
+            {
+                TRACK* TmpSegm = new TRACK( NULL );
+                TmpSegm->m_Layer = ( (EDGE_MODULE*) PtModStruct )->m_Layer;
+                if( TmpSegm->m_Layer == EDGE_N )
+                    TmpSegm->m_Layer = -1;
 
-					TmpSegm->m_Start = ((EDGE_MODULE *) PtModStruct)->m_Start;
-					TmpSegm->m_End = ((EDGE_MODULE *) PtModStruct)->m_End;
-					TmpSegm->m_Shape = ((EDGE_MODULE *) PtModStruct)->m_Shape;
-					TmpSegm->m_Width = ((EDGE_MODULE *) PtModStruct)->m_Width;
-					TmpSegm->m_Param = ((EDGE_MODULE *) PtModStruct)->m_Angle;
-					TmpSegm->m_NetCode = -1;
+                TmpSegm->m_Start   = ( (EDGE_MODULE*) PtModStruct )->m_Start;
+                TmpSegm->m_End     = ( (EDGE_MODULE*) PtModStruct )->m_End;
+                TmpSegm->m_Shape   = ( (EDGE_MODULE*) PtModStruct )->m_Shape;
+                TmpSegm->m_Width   = ( (EDGE_MODULE*) PtModStruct )->m_Width;
+                TmpSegm->m_Param   = ( (EDGE_MODULE*) PtModStruct )->m_Angle;
+                TmpSegm->m_NetCode = -1;
 
-					TraceSegmentPcb(Pcb, TmpSegm, HOLE, marge,WRITE_CELL );
-					TraceSegmentPcb(Pcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,
-									WRITE_OR_CELL );
-					delete TmpSegm;
-					break;
-					}
+                TraceSegmentPcb( Pcb, TmpSegm, HOLE, marge, WRITE_CELL );
+                TraceSegmentPcb( Pcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,
+                                 WRITE_OR_CELL );
+                delete TmpSegm;
+                break;
+            }
 
-				default: break;
-				}
-			}
-		}
+            default:
+                break;
+            }
+        }
+    }
 
-	////////////////////////////////////////////
-	// Placement des contours et segments PCB //
-	////////////////////////////////////////////
-	PtStruct = Pcb->m_Drawings;
-	for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
-		{
-		switch( PtStruct->m_StructType)
-			{
-			case TYPEDRAWSEGMENT:
-				{
-				int type_cell = HOLE;
-				TRACK * TmpSegm = new TRACK(NULL);
-				DrawSegm = (DRAWSEGMENT *) PtStruct;
-				TmpSegm->m_Layer = DrawSegm->m_Layer;
-				if(DrawSegm->m_Layer == EDGE_N)
-					{
-					TmpSegm->m_Layer = -1;
-					type_cell |= CELL_is_EDGE;
-					}
+    ////////////////////////////////////////////
+    // Placement des contours et segments PCB //
+    ////////////////////////////////////////////
+    PtStruct = Pcb->m_Drawings;
+    for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
+    {
+        switch( PtStruct->m_StructType )
+        {
+        case TYPEDRAWSEGMENT:
+        {
+            int    type_cell = HOLE;
+            TRACK* TmpSegm   = new TRACK( NULL );
+            DrawSegm = (DRAWSEGMENT*) PtStruct;
+            TmpSegm->m_Layer = DrawSegm->m_Layer;
+            if( DrawSegm->m_Layer == EDGE_N )
+            {
+                TmpSegm->m_Layer = -1;
+                type_cell |= CELL_is_EDGE;
+            }
 
-				TmpSegm->m_Start = DrawSegm->m_Start;
-				TmpSegm->m_End = DrawSegm->m_End;
-				TmpSegm->m_Shape = DrawSegm->m_Shape;
-				TmpSegm->m_Width = DrawSegm->m_Width;
-				TmpSegm->m_Param = DrawSegm->m_Angle;
-				TmpSegm->m_NetCode = -1;
+            TmpSegm->m_Start   = DrawSegm->m_Start;
+            TmpSegm->m_End     = DrawSegm->m_End;
+            TmpSegm->m_Shape   = DrawSegm->m_Shape;
+            TmpSegm->m_Width   = DrawSegm->m_Width;
+            TmpSegm->m_Param   = DrawSegm->m_Angle;
+            TmpSegm->m_NetCode = -1;
+
+            TraceSegmentPcb( Pcb, TmpSegm, type_cell, marge, WRITE_CELL );
 
-				TraceSegmentPcb(Pcb, TmpSegm, type_cell, marge,WRITE_CELL );
 //				TraceSegmentPcb(Pcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,WRITE_OR_CELL );
-				delete TmpSegm;
-				break;
-				}
+            delete TmpSegm;
+            break;
+        }
 
-			case TYPETEXTE:
-				PtText = (TEXTE_PCB*) PtStruct;
-				if(PtText->GetLength() == 0 ) break;
-				ux0 = PtText->m_Pos.x; uy0 = PtText->m_Pos.y;
+        case TYPETEXTE:
+            PtText = (TEXTE_PCB*) PtStruct;
+            if( PtText->GetLength() == 0 )
+                break;
+            ux0 = PtText->m_Pos.x; uy0 = PtText->m_Pos.y;
 
-				dx = PtText->Pitch()* PtText->GetLength();
-				dy = PtText->m_Size.y + PtText->m_Width;
+            dx = PtText->Pitch() * PtText->GetLength();
+            dy = PtText->m_Size.y + PtText->m_Width;
 
-				/* Calcul du rectangle d'encadrement */
-				dx /= 2; dy /= 2; /* dx et dy = demi dimensionx X et Y */
-				ux1 = ux0 + dx; uy1 = uy0 + dy;
-				ux0 -= dx; uy0 -= dy;
+            /* Calcul du rectangle d'encadrement */
+            dx  /= 2; dy /= 2;    /* dx et dy = demi dimensionx X et Y */
+            ux1  = ux0 + dx; uy1 = uy0 + dy;
+            ux0 -= dx; uy0 -= dy;
 
-				masque_layer = g_TabOneLayerMask[PtText->m_Layer];
+            masque_layer = g_TabOneLayerMask[PtText->m_Layer];
 
-				TraceFilledRectangle(Pcb, ux0-marge, uy0-marge, ux1+marge, uy1+marge,
-								(int)(PtText->m_Orient),
-								masque_layer, HOLE, WRITE_CELL);
-				TraceFilledRectangle(Pcb, ux0-via_marge, uy0-via_marge,
-								ux1+via_marge, uy1+via_marge,
-								(int)(PtText->m_Orient),
-								masque_layer, VIA_IMPOSSIBLE, WRITE_OR_CELL);
-				break;
+            TraceFilledRectangle( Pcb, ux0 - marge, uy0 - marge, ux1 + marge, uy1 + marge,
+                                  (int) (PtText->m_Orient),
+                                  masque_layer, HOLE, WRITE_CELL );
+            TraceFilledRectangle( Pcb, ux0 - via_marge, uy0 - via_marge,
+                                  ux1 + via_marge, uy1 + via_marge,
+                                  (int) (PtText->m_Orient),
+                                  masque_layer, VIA_IMPOSSIBLE, WRITE_OR_CELL );
+            break;
 
-			default: break;
-			}
-		}
+        default:
+            break;
+        }
+    }
 
-	/* Placement des PISTES */
-	pt_segm = Pcb->m_Track;
-	for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext)
-		{
-		if(net_code == pt_segm->m_NetCode) continue;
-		TraceSegmentPcb(Pcb, pt_segm, HOLE, marge, WRITE_CELL );
-		TraceSegmentPcb(Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
-		}
+    /* Placement des PISTES */
+    pt_segm = Pcb->m_Track;
+    for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
+    {
+        if( net_code == pt_segm->m_NetCode )
+            continue;
+        TraceSegmentPcb( Pcb, pt_segm, HOLE, marge, WRITE_CELL );
+        TraceSegmentPcb( Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
+    }
 
-	/* Placement des ZONES */
-	pt_segm = (TRACK*) Pcb->m_Zone;
-	for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext)
-		{
-		if(net_code == pt_segm->m_NetCode) continue;
-		TraceSegmentPcb(Pcb, pt_segm, HOLE, marge, WRITE_CELL );
-		TraceSegmentPcb(Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
-		}
+    /* Placement des ZONES */
+    pt_segm = (TRACK*) Pcb->m_Zone;
+    for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
+    {
+        if( net_code == pt_segm->m_NetCode )
+            continue;
+        TraceSegmentPcb( Pcb, pt_segm, HOLE, marge, WRITE_CELL );
+        TraceSegmentPcb( Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
+    }
 }
 
+
 /******************************************************/
-int Build_Work(BOARD * Pcb, CHEVELU* pt_base_chevelu)
+int Build_Work( BOARD* Pcb, CHEVELU* pt_base_chevelu )
 /*****************************************************/
- /* Build liste conn */
+/* Build liste conn */
 {
-int ii;
-CHEVELU* pt_rats = pt_base_chevelu;
-D_PAD * pt_pad;
-int r1,r2, c1,c2, current_net_code;
-CHEVELU * pt_ch;
-int demi_pas = g_GridRoutingSize /2;
-wxString msg;
-	
-	InitWork(); /* clear work list */
-	Ntotal = 0;
-	for ( ii = Pcb->GetNumRatsnests(); ii > 0 ; ii-- , pt_rats++)
-		{
-		/* On ne route que les chevelus actifs et routables */
-		if( (pt_rats->status & CH_ACTIF) == 0) continue;
-		if( pt_rats->status & CH_UNROUTABLE) continue;
-		if( (pt_rats->status & CH_ROUTE_REQ) == 0 ) continue;
-		pt_pad = pt_rats->pad_start;
+    int      ii;
+    CHEVELU* pt_rats = pt_base_chevelu;
+    D_PAD*   pt_pad;
+    int      r1, r2, c1, c2, current_net_code;
+    CHEVELU* pt_ch;
+    int      demi_pas = g_GridRoutingSize / 2;
+    wxString msg;
 
-		current_net_code = pt_pad->m_NetCode;
-		pt_ch = pt_rats;
+    InitWork(); /* clear work list */
+    Ntotal = 0;
+    for( ii = Pcb->GetNumRatsnests(); ii > 0; ii--, pt_rats++ )
+    {
+        /* On ne route que les chevelus actifs et routables */
+        if( (pt_rats->status & CH_ACTIF) == 0 )
+            continue;
+        if( pt_rats->status & CH_UNROUTABLE )
+            continue;
+        if( (pt_rats->status & CH_ROUTE_REQ) == 0 )
+            continue;
+        pt_pad = pt_rats->pad_start;
 
-		r1 = (pt_pad->m_Pos.y - Pcb->m_BoundaryBox.m_Pos.y + demi_pas ) / g_GridRoutingSize;
-		if( r1 < 0 || r1 >= Nrows)
-			{
-			msg.Printf( wxT("erreur : row = %d ( padY %d pcbY %d) "), r1,
-						pt_pad->m_Pos.y, Pcb->m_BoundaryBox.m_Pos.y);
-			DisplayError(NULL, msg);
-			return(0);
-			}
-		c1 = (pt_pad->m_Pos.x - Pcb->m_BoundaryBox.m_Pos.x + demi_pas ) / g_GridRoutingSize;
-		if( c1 < 0 || c1 >= Ncols)
-			{
-			msg.Printf( wxT("erreur : col = %d ( padX %d pcbX %d) "), c1,
-						pt_pad->m_Pos.x, Pcb->m_BoundaryBox.m_Pos.x);
-			DisplayError(NULL, msg);
-			return(0);
-			}
+        current_net_code = pt_pad->m_NetCode;
+        pt_ch = pt_rats;
 
-		pt_pad = pt_rats->pad_end;
+        r1 = (pt_pad->m_Pos.y - Pcb->m_BoundaryBox.m_Pos.y + demi_pas ) / g_GridRoutingSize;
+        if( r1 < 0 || r1 >= Nrows )
+        {
+            msg.Printf( wxT( "erreur : row = %d ( padY %d pcbY %d) " ), r1,
+                        pt_pad->m_Pos.y, Pcb->m_BoundaryBox.m_Pos.y );
+            DisplayError( NULL, msg );
+            return 0;
+        }
+        c1 = (pt_pad->m_Pos.x - Pcb->m_BoundaryBox.m_Pos.x + demi_pas ) / g_GridRoutingSize;
+        if( c1 < 0 || c1 >= Ncols )
+        {
+            msg.Printf( wxT( "erreur : col = %d ( padX %d pcbX %d) " ), c1,
+                        pt_pad->m_Pos.x, Pcb->m_BoundaryBox.m_Pos.x );
+            DisplayError( NULL, msg );
+            return 0;
+        }
 
-		r2 = (pt_pad->m_Pos.y - Pcb->m_BoundaryBox.m_Pos.y + demi_pas ) / g_GridRoutingSize;
-		if( r2 < 0 || r2 >= Nrows)
-			{
-			msg.Printf( wxT("erreur : row = %d ( padY %d pcbY %d) "), r2,
-						pt_pad->m_Pos.y, Pcb->m_BoundaryBox.m_Pos.y);
-			DisplayError(NULL, msg);
-			return(0);
-			}
-		c2 = (pt_pad->m_Pos.x - Pcb->m_BoundaryBox.m_Pos.x + demi_pas ) / g_GridRoutingSize;
-		if( c2 < 0 || c2 >= Ncols)
-			{
-			msg.Printf( wxT("erreur : col = %d ( padX %d pcbX %d) "), c2,
-						pt_pad->m_Pos.x, Pcb->m_BoundaryBox.m_Pos.x);
-			DisplayError(NULL, msg);
-			return(0);
-			}
+        pt_pad = pt_rats->pad_end;
 
-		SetWork( r1, c1, current_net_code, r2, c2, pt_ch, 0 ); Ntotal++;
-		}
+        r2 = (pt_pad->m_Pos.y - Pcb->m_BoundaryBox.m_Pos.y + demi_pas ) / g_GridRoutingSize;
+        if( r2 < 0 || r2 >= Nrows )
+        {
+            msg.Printf( wxT( "erreur : row = %d ( padY %d pcbY %d) " ), r2,
+                        pt_pad->m_Pos.y, Pcb->m_BoundaryBox.m_Pos.y );
+            DisplayError( NULL, msg );
+            return 0;
+        }
+        c2 = (pt_pad->m_Pos.x - Pcb->m_BoundaryBox.m_Pos.x + demi_pas ) / g_GridRoutingSize;
+        if( c2 < 0 || c2 >= Ncols )
+        {
+            msg.Printf( wxT( "erreur : col = %d ( padX %d pcbX %d) " ), c2,
+                        pt_pad->m_Pos.x, Pcb->m_BoundaryBox.m_Pos.x );
+            DisplayError( NULL, msg );
+            return 0;
+        }
 
-	SortWork();
-	return(Ntotal);
+        SetWork( r1, c1, current_net_code, r2, c2, pt_ch, 0 ); Ntotal++;
+    }
+
+    SortWork();
+    return Ntotal;
 }
 
 
+/*******************************************/
+BoardCell GetCell( int row, int col, int side )
+/*******************************************/
 
-/*******************************************/
-BoardCell GetCell(int row,int col,int side )
-/*******************************************/
- /* fetch board cell :
-*/
+/* fetch board cell :
+ */
 {
-BoardCell *p;
+    BoardCell* p;
 
-	p = Board.m_BoardSide[side];
-	return( p[row*Ncols +col] );
+    p = Board.m_BoardSide[side];
+    return p[row * Ncols + col];
 }
 
 
@@ -402,119 +423,118 @@ BoardCell *p;
 /************************************************/
 
 /* store board cell */
-void SetCell(int row,int col,int side,BoardCell x )
+void SetCell( int row, int col, int side, BoardCell x )
 {
-BoardCell *p;
+    BoardCell* p;
 
-	p = Board.m_BoardSide[side];
-	p[row*Ncols+col] = x;
+    p = Board.m_BoardSide[side];
+    p[row * Ncols + col] = x;
 }
 
 
-	/******************************************/
-	/* void OrCell(int r,int c,int s,BoardCell x ) */
-	/******************************************/
+/******************************************/
+/* void OrCell(int r,int c,int s,BoardCell x ) */
+/******************************************/
 
-void OrCell(int r,int c,int s,BoardCell x )
+void OrCell( int r, int c, int s, BoardCell x )
 {
-BoardCell *p;
+    BoardCell* p;
 
-	p = Board.m_BoardSide[s];
-	p[r*Ncols+c] |= x;
-}
-
-	/******************************************/
-	/* void XorCell(int r,int c,int s,BoardCell x ) */
-	/******************************************/
-
-void XorCell(int r,int c,int s,BoardCell x )
-{
-BoardCell *p;
-
-	p = Board.m_BoardSide[s];
-	p[r*Ncols+c] ^= x;
+    p = Board.m_BoardSide[s];
+    p[r * Ncols + c] |= x;
 }
 
 
-	/************************************************/
-	/* void AndCell(int r,int c,int s,BoardCell x ) */
-	/************************************************/
+/******************************************/
+/* void XorCell(int r,int c,int s,BoardCell x ) */
+/******************************************/
 
-void AndCell(int r,int c,int s,BoardCell x )
+void XorCell( int r, int c, int s, BoardCell x )
 {
-BoardCell *p;
+    BoardCell* p;
 
-	p = Board.m_BoardSide[s];
-	p[r*Ncols+c] &= x;
-}
-
-	/************************************************/
-	/* void AddCell(int r,int c,int s,BoardCell x ) */
-	/************************************************/
-
-void AddCell(int r,int c,int s,BoardCell x )
-{
-BoardCell *p;
-
-	p = Board.m_BoardSide[s];
-	p[r*Ncols+c] += x;
+    p = Board.m_BoardSide[s];
+    p[r * Ncols + c] ^= x;
 }
 
 
+/************************************************/
+/* void AndCell(int r,int c,int s,BoardCell x ) */
+/************************************************/
 
-	/****************************************/
-	/* DistCell GetDist(int r,int c,int s ) */
-	/****************************************/
+void AndCell( int r, int c, int s, BoardCell x )
+{
+    BoardCell* p;
+
+    p = Board.m_BoardSide[s];
+    p[r * Ncols + c] &= x;
+}
+
+
+/************************************************/
+/* void AddCell(int r,int c,int s,BoardCell x ) */
+/************************************************/
+
+void AddCell( int r, int c, int s, BoardCell x )
+{
+    BoardCell* p;
+
+    p = Board.m_BoardSide[s];
+    p[r * Ncols + c] += x;
+}
+
+
+/****************************************/
+/* DistCell GetDist(int r,int c,int s ) */
+/****************************************/
 
 /* fetch distance cell */
-DistCell GetDist(int r,int c,int s ) /* fetch distance cell */
+DistCell GetDist( int r, int c, int s ) /* fetch distance cell */
 {
-DistCell *p;
+    DistCell* p;
 
-	p = Board.m_DistSide[s];
-	return( p[r*Ncols+c] );
+    p = Board.m_DistSide[s];
+    return p[r * Ncols + c];
 }
 
 
-	/***********************************************/
-	/* void SetDist(int r,int c,int s,DistCell x ) */
-	/***********************************************/
+/***********************************************/
+/* void SetDist(int r,int c,int s,DistCell x ) */
+/***********************************************/
 
 /* store distance cell */
-void SetDist(int r,int c,int s,DistCell x )
+void SetDist( int r, int c, int s, DistCell x )
 {
-DistCell *p;
+    DistCell* p;
 
-	p = Board.m_DistSide[s];
-	p[r*Ncols+c] = x;
+    p = Board.m_DistSide[s];
+    p[r * Ncols + c] = x;
 }
 
 
-	/**********************************/
-	/* int GetDir(int r,int c,int s ) */
-	/**********************************/
+/**********************************/
+/* int GetDir(int r,int c,int s ) */
+/**********************************/
 
 /* fetch direction cell */
-int GetDir(int r,int c,int s )
+int GetDir( int r, int c, int s )
 {
-char *p;
+    char* p;
 
-	p = Board.m_DirSide[s];
-	return( (int)(p[r*Ncols+c]) );
+    p = Board.m_DirSide[s];
+    return (int) (p[r * Ncols + c]);
 }
 
 
-	/*****************************************/
-	/* void SetDir(int r,int c,int s,int x ) */
-	/*****************************************/
+/*****************************************/
+/* void SetDir(int r,int c,int s,int x ) */
+/*****************************************/
 
 /* store direction cell */
-
-void SetDir(int r,int c,int s,int x )
+void SetDir( int r, int c, int s, int x )
 {
-char *p;
+    char* p;
 
-	p = Board.m_DirSide[s];
-	p[r*Ncols+c] = (char)x;
+    p = Board.m_DirSide[s];
+    p[r * Ncols + c] = (char) x;
 }
-