Add priority level to zones.

pcbnew/board_items_to_polygon_shape_transform.cpp

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include <fctsys.h>
+#include <polygons_defs.h>
 #include <pcbnew.h>
 #include <wxPcbStruct.h>
 #include <trigo.h>
@@ -17,6 +18,7 @@
 #include <class_track.h>
 #include <class_drawsegment.h>
 #include <class_pcb_text.h>
+#include <class_zone.h>
 
 
 /* Exported functions */
@@ -130,6 +132,90 @@ void TEXTE_PCB::TransformShapeWithClearanceToPolygon( std::vector <CPolyPt>& aCo
     aCornerBuffer.back().end_contour = true;
 }
 
+ /* Function TransformShapeWithClearanceToPolygon
+  * Convert the track shape to a closed polygon
+  * Used in filling zones calculations
+  * Circles (vias) and arcs (ends of tracks) are approximated by segments
+  * param aCornerBuffer = a buffer to store the polygon
+  * param aClearanceValue = the clearance around the pad
+  * param aCircleToSegmentsCount = the number of segments to approximate a circle
+  * param aCorrectionFactor = the correction to apply to circles radius to keep
+  * param aAddClearance = true to add a clearance area to the polygon
+  *                      false to create the outline polygon.
+  * clearance when the circle is approximated by segment bigger or equal
+  * to the real clearance value (usually near from 1.0)
+  */
+void ZONE_CONTAINER::TransformShapeWithClearanceToPolygon( std::vector <CPolyPt>& aCornerBuffer,
+                                                      int                    aClearanceValue,
+                                                      int                    aCircleToSegmentsCount,
+                                                      double                 aCorrectionFactor,
+                                                      bool                   aAddClearance )
+{
+
+    /* Creates the main polygon (i.e. the filled area using only one outline)
+     * and reserve a clearance margin around the outlines and holes
+     */
+    std::vector <CPolyPt> zoneOutines;
+    BuildFilledPolysListData( NULL, &zoneOutines );
+    int clearance = 0;
+    if( aAddClearance )
+    {
+        GetClearance();
+        if( aClearanceValue > clearance )
+            clearance = aClearanceValue;
+    }
+
+    // Calculate the polygon with clearance and holes
+    // holes are linked to the main outline, so only one polygon should be created.
+    KPolygonSet polyset_zone_solid_areas;
+    std::vector<KPolyPoint> cornerslist;
+    unsigned ic = 0;
+    unsigned corners_count = zoneOutines.size();
+    while( ic < corners_count )
+    {
+        cornerslist.clear();
+        KPolygon poly;
+        {
+            for( ; ic < corners_count; ic++ )
+            {
+                CPolyPt* corner = &zoneOutines[ic];
+                cornerslist.push_back( KPolyPoint( corner->x, corner->y ) );
+                if( corner->end_contour )
+                {
+                    ic++;
+                    break;
+                }
+            }
+
+            bpl::set_points( poly, cornerslist.begin(), cornerslist.end() );
+            polyset_zone_solid_areas.push_back( poly );
+        }
+    }
+
+    polyset_zone_solid_areas += clearance;
+
+    // Put the resultng polygon in buffer
+    for( unsigned ii = 0; ii < polyset_zone_solid_areas.size(); ii++ )
+    {
+        KPolygon& poly = polyset_zone_solid_areas[ii];
+        CPolyPt   corner( 0, 0, false );
+
+        for( unsigned jj = 0; jj < poly.size(); jj++ )
+        {
+            KPolyPoint point = *(poly.begin() + jj);
+            corner.x = point.x();
+            corner.y = point.y();
+            corner.end_contour = false;
+            aCornerBuffer.push_back( corner );
+        }
+
+        corner.end_contour = true;
+        aCornerBuffer.pop_back();
+        aCornerBuffer.push_back( corner );
+    }
+}
+
+
 
 /**
  * Function TransformShapeWithClearanceToPolygon

pcbnew/class_zone.cpp

@@ -55,6 +55,7 @@ ZONE_CONTAINER::ZONE_CONTAINER( BOARD* parent ) :
     m_CornerSelection = -1;
     m_IsFilled = false;                         // fill status : true when the zone is filled
     m_FillMode = 0;                             // How to fill areas: 0 = use filled polygons, != 0 fill with segments
+    m_priority = 0;
     smoothedPoly = NULL;
     cornerSmoothingType = ZONE_SETTING::SMOOTHING_NONE;
     cornerRadius = 0;
@@ -77,6 +78,7 @@ ZONE_CONTAINER::ZONE_CONTAINER( const ZONE_CONTAINER& aZone ) :
     m_ZoneClearance = aZone.m_ZoneClearance;     // clearance value
     m_ZoneMinThickness = aZone.m_ZoneMinThickness;
     m_FillMode = aZone.m_FillMode;               // Filling mode (segments/polygons)
+    m_priority = aZone.m_priority;
     m_ArcToSegmentsCount = aZone.m_ArcToSegmentsCount;
     m_PadOption = aZone.m_PadOption;
     m_ThermalReliefGap = aZone.m_ThermalReliefGap;
@@ -677,16 +679,21 @@ void ZONE_CONTAINER::DisplayInfo( EDA_DRAW_FRAME* frame )
         }
 
         frame->AppendMsgPanel( _( "NetName" ), msg, RED );
+#if 1
+        // Display net code : (useful in test or debug)
+        msg.Printf( wxT( "%d" ), GetNet() );
+        frame->AppendMsgPanel( _( "NetCode" ), msg, RED );
+#endif
+
+        // Display priority level
+        msg.Printf( wxT( "%d" ), GetPriority() );
+        frame->AppendMsgPanel( _( "Priority" ), msg, BLUE );
     }
     else
     {
         frame->AppendMsgPanel( _( "Non Copper Zone" ), wxEmptyString, RED );
     }
 
-    /* Display net code : (useful in test or debug) */
-    msg.Printf( wxT( "%d" ), GetNet() );
-    frame->AppendMsgPanel( _( "NetCode" ), msg, RED );
-
     msg = board->GetLayerName( m_Layer );
     frame->AppendMsgPanel( _( "Layer" ), msg, BROWN );
 

pcbnew/class_zone.h

@@ -124,6 +124,10 @@ private:
     CPolyLine*            smoothedPoly;         // Corner-smoothed version of m_Poly
     int                   cornerSmoothingType;
     unsigned int          cornerRadius;
+    // Priority: when a zone outline is inside and other zone, if its priority is highter
+    // the other zone priority, it will be created inside.
+    // if priorities are equal, a DRC erroc is set
+    unsigned              m_priority;
 
 public:
     ZONE_CONTAINER( BOARD* parent );
@@ -149,6 +153,18 @@ public:
     const wxPoint GetPosition() const;          // overload
     void SetPosition( const wxPoint& aPos );    // overload
 
+    /**
+     * Function SetPriority
+     * @param aPriority = the priority level
+     */
+    void SetPriority( unsigned aPriority ) { m_priority = aPriority; }
+
+    /**
+     * Function GetPriority
+     * @return the priority level of this zone
+     */
+    unsigned GetPriority() const { return m_priority; }
+
     /**
      * Function copy
      * copy useful data from the source.
@@ -305,11 +321,13 @@ public:
      * in order to have drawable (and plottable) filled polygons
      * drawable filled polygons are polygons without hole
      * @param aPcb: the current board (can be NULL for non copper zones)
+     * @param aCornerBuffer: A reference to a buffer to put polygon corners, or NULL
+     * if NULL (default), uses m_FilledPolysList and fill current zone.
      * @return number of polygons
      * This function does not add holes for pads and tracks but calls
      * AddClearanceAreasPolygonsToPolysList() to do that for copper layers
      */
-    int BuildFilledPolysListData( BOARD* aPcb );
+    int BuildFilledPolysListData( BOARD* aPcb, std::vector <CPolyPt>* aCornerBuffer = NULL );
 
     /**
      * Function AddClearanceAreasPolygonsToPolysList
@@ -484,6 +502,25 @@ public:
         return m_Poly->GetHatchStyle();
     }
 
+     /**
+     * Function TransformShapeWithClearanceToPolygon
+     * Convert the track shape to a closed polygon
+     * Used in filling zones calculations
+     * Circles (vias) and arcs (ends of tracks) are approximated by segments
+     * @param aCornerBuffer = a buffer to store the polygon
+     * @param aClearanceValue = the clearance around the pad
+     * @param aCircleToSegmentsCount = the number of segments to approximate a circle
+     * @param aCorrectionFactor = the correction to apply to circles radius to keep
+     * @param aAddClearance = true to add a clearance area to the polygon
+     *                      false to create the outline polygon.
+     * clearance when the circle is approximated by segment bigger or equal
+     * to the real clearance value (usually near from 1.0)
+     */
+    void TransformShapeWithClearanceToPolygon( std::vector <CPolyPt>& aCornerBuffer,
+                                               int                    aClearanceValue,
+                                               int                    aCircleToSegmentsCount,
+                                               double                 aCorrectionFactor,
+                                               bool                   aAddClearance );
    /**
      * Function IsSame
      * tests if 2 zones are equivalent:

pcbnew/class_zone_setting.cpp

@@ -24,6 +24,7 @@
 
 ZONE_SETTING::ZONE_SETTING( void )
 {
+    m_ZonePriority = 0;
     m_FillMode = 0;                                                 // Mode for filling zone : 1 use segments, 0 use polygons
     m_ZoneClearance      = 200;                                     // Clearance value
     m_ZoneMinThickness   = 100;                                     // Min thickness value in filled areas
@@ -50,6 +51,7 @@ ZONE_SETTING::ZONE_SETTING( void )
  */
 void ZONE_SETTING::ImportSetting( const ZONE_CONTAINER& aSource )
 {
+    m_ZonePriority = aSource.GetPriority();
     m_FillMode     = aSource.m_FillMode;
     m_ZoneClearance      = aSource.m_ZoneClearance;
     m_ZoneMinThickness   = aSource.m_ZoneMinThickness;
@@ -88,6 +90,7 @@ void ZONE_SETTING::ExportSetting( ZONE_CONTAINER& aTarget, bool aFullExport )
     aTarget.SetCornerRadius( cornerRadius );
     if( aFullExport )
     {
+        aTarget.SetPriority( m_ZonePriority );
         aTarget.SetNet( m_NetcodeSelection );
         aTarget.SetLayer( m_CurrentZone_Layer );
     }

pcbnew/class_zone_setting.h

@@ -30,6 +30,8 @@ public:
     // Mode for filling zone : 1 use segments, 0 use polygons
     int  m_FillMode;
 
+    int  m_ZonePriority;                    // Priority (0 ... N) of the zone
+
     int  m_ZoneClearance;                   // Clearance value
     int  m_ZoneMinThickness;                // Min thickness value in filled areas
     int  m_NetcodeSelection;                // Net code selection for the current zone

pcbnew/dialogs/dialog_copper_zones.cpp

@@ -119,6 +119,8 @@ void DIALOG_COPPER_ZONE::initDialog()
         m_CopperWidthValue->Enable( true );
     }
 
+    m_PriorityLevelCtrl->SetValue( m_Zone_Setting->m_ZonePriority );
+
     AddUnitSymbol( *m_AntipadSizeText, g_UserUnit );
     AddUnitSymbol( *m_CopperBridgeWidthText, g_UserUnit );
     PutValueInLocalUnits( *m_AntipadSizeValue,
@@ -323,6 +325,8 @@ bool DIALOG_COPPER_ZONE::AcceptOptions( bool aPromptForErrors, bool aUseExportab
     txtvalue = m_cornerSmoothingCtrl->GetValue();
     m_Zone_Setting->SetCornerRadius( ReturnValueFromString( g_UserUnit, txtvalue, m_Parent->GetInternalUnits() ) );
 
+    m_Zone_Setting->m_ZonePriority = m_PriorityLevelCtrl->GetValue();
+
     if( m_OrientEdgesOpt->GetSelection() == 0 )
         g_Zone_45_Only = false;
     else

pcbnew/dialogs/dialog_copper_zones_base.cpp

 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Nov 18 2010)
+// C++ code generated with wxFormBuilder (version Jun 30 2011)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
@@ -105,11 +105,11 @@ DIALOG_COPPER_ZONE_BASE::DIALOG_COPPER_ZONE_BASE( wxWindow* parent, wxWindowID i
 	
 	m_MinThicknessValueTitle = new wxStaticText( this, wxID_ANY, _("Minimum width"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_MinThicknessValueTitle->Wrap( -1 );
+	m_MinThicknessValueTitle->SetToolTip( _("Minimun thickness of filled areas.") );
+	
 	bSizer9->Add( m_MinThicknessValueTitle, 0, wxTOP|wxRIGHT|wxLEFT, 5 );
 	
 	m_ZoneMinThicknessCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
-	m_ZoneMinThicknessCtrl->SetToolTip( _("Minimun thickness of filled areas.") );
-	
 	bSizer9->Add( m_ZoneMinThicknessCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );
 	
 	m_staticText151 = new wxStaticText( this, wxID_ANY, _("Corner smoothing:"), wxDefaultPosition, wxDefaultSize, 0 );
@@ -172,6 +172,15 @@ DIALOG_COPPER_ZONE_BASE::DIALOG_COPPER_ZONE_BASE( wxWindow* parent, wxWindowID i
 	wxBoxSizer* m_MiddleBox;
 	m_MiddleBox = new wxBoxSizer( wxVERTICAL );
 	
+	m_staticText171 = new wxStaticText( this, wxID_ANY, _("Priority level:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_staticText171->Wrap( -1 );
+	m_staticText171->SetToolTip( _("On each copper layer, zones are filled by priority order.\nSo when a zone is inside an other zone:\n* If its priority is highter: its outlines are removed from the other layer.\n* If its priority is equal: a DRC error is set.") );
+	
+	m_MiddleBox->Add( m_staticText171, 0, wxRIGHT|wxLEFT, 5 );
+	
+	m_PriorityLevelCtrl = new wxSpinCtrl( this, ID_M_PRIORITYLEVELCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 100, 0 );
+	m_MiddleBox->Add( m_PriorityLevelCtrl, 0, wxBOTTOM|wxRIGHT|wxLEFT, 5 );
+	
 	m_staticText11 = new wxStaticText( this, wxID_ANY, _("Fill mode:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_staticText11->Wrap( -1 );
 	m_MiddleBox->Add( m_staticText11, 0, wxLEFT|wxRIGHT|wxTOP, 5 );

pcbnew/dialogs/dialog_copper_zones_base.h

 ///////////////////////////////////////////////////////////////////////////
-// C++ code generated with wxFormBuilder (version Nov 18 2010)
+// C++ code generated with wxFormBuilder (version Jun 30 2011)
 // http://www.wxformbuilder.org/
 //
 // PLEASE DO "NOT" EDIT THIS FILE!
 ///////////////////////////////////////////////////////////////////////////
 
-#ifndef __dialog_copper_zones_base__
-#define __dialog_copper_zones_base__
+#ifndef __DIALOG_COPPER_ZONES_BASE_H__
+#define __DIALOG_COPPER_ZONES_BASE_H__
 
+#include <wx/artprov.h>
+#include <wx/xrc/xmlres.h>
 #include <wx/intl.h>
-
 #include <wx/string.h>
 #include <wx/stattext.h>
 #include <wx/gdicmn.h>
@@ -22,6 +23,7 @@
 #include <wx/textctrl.h>
 #include <wx/button.h>
 #include <wx/statbox.h>
+#include <wx/spinctrl.h>
 #include <wx/dialog.h>
 
 ///////////////////////////////////////////////////////////////////////////
@@ -59,6 +61,7 @@ class DIALOG_COPPER_ZONE_BASE : public wxDialog
 			ID_M_PADINZONEOPT,
 			wxID_ANTIPAD_SIZE,
 			wxID_COPPER_BRIDGE_VALUE,
+			ID_M_PRIORITYLEVELCTRL,
 			ID_M_FILLMODECTRL,
 			ID_M_ARCAPPROXIMATIONOPT,
 			ID_M_ORIENTEDGESOPT,
@@ -92,6 +95,8 @@ class DIALOG_COPPER_ZONE_BASE : public wxDialog
 		wxTextCtrl* m_AntipadSizeValue;
 		wxStaticText* m_CopperBridgeWidthText;
 		wxTextCtrl* m_CopperWidthValue;
+		wxStaticText* m_staticText171;
+		wxSpinCtrl* m_PriorityLevelCtrl;
 		wxStaticText* m_staticText11;
 		wxChoice* m_FillModeCtrl;
 		wxStaticText* m_staticText12;
@@ -123,4 +128,4 @@ class DIALOG_COPPER_ZONE_BASE : public wxDialog
 	
 };
 
-#endif //__dialog_copper_zones_base__
+#endif //__DIALOG_COPPER_ZONES_BASE_H__

pcbnew/item_io.cpp

@@ -258,6 +258,13 @@ bool ZONE_CONTAINER::Save( FILE* aFile ) const
     if( ret < 2 )
         return false;
 
+    if( GetPriority() > 0 )
+    {
+        ret = fprintf( aFile, "ZPriority %d\n", GetPriority() );
+        if( ret < 1 )
+            return false;
+    }
+
     // Save pad option and clearance
     switch( m_PadOption )
     {
@@ -1797,6 +1804,17 @@ int ZONE_CONTAINER::ReadDescr( LINE_READER* aReader )
             }
             /* Set hatch mode later, after reading outlines corners data */
         }
+
+        else if( strnicmp( Line, "ZPriority", 9 ) == 0 )
+        {
+            int tmp = 0;
+            text = Line + 9;
+            ret  = sscanf( text, "%d", &tmp );
+            if( ret < 1 )
+                return false;
+            SetPriority( tmp );
+        }
+
         else if( strnicmp( Line, "ZSmoothing", 10 ) == 0 )
         {
             int tempSmoothingType;

pcbnew/netlist_reader_kicad.cpp

@@ -62,6 +62,41 @@ public:
      */
     MODULE_INFO* ParseComp() throw( IO_ERROR, PARSE_ERROR );
 
+
+    /**
+     * Function ParseKicadFootprintFilterList
+     * Read the section "libparts" like:
+     * (libparts
+     *   (libpart (lib device) (part C)
+     *     (description "Condensateur non polarise")
+     *     (footprints
+     *       (fp SM*)
+     *       (fp C?)
+     *       (fp C1-1))
+     *     (fields
+     *       (field (name Reference) C)
+     *       (field (name Value) C))
+     *     (pins
+     *       (pin (num 1) (name ~) (type passive))
+     *       (pin (num 2) (name ~) (type passive))))
+     *
+     *  And add the strings giving the footprint filter (subsection footprints)
+     *  of the corresponding module info
+     *  <p>This section is used by CvPcb, and is not useful in Pcbnew,
+     *  therefore it it not always read </p>
+     */
+    bool ParseKicadFootprintFilterList() throw( IO_ERROR, PARSE_ERROR );
+
+    /**
+     * Function ParseNet
+     * Parses a section like
+     * (net (code 20) (name /PC-A0)
+     *  (node (ref BUS1) (pin 62))
+     *  (node (ref U3) (pin 3))
+     *  (node (ref U9) (pin M6)))
+     *
+     * and set the corresponfings pads netnames
+     */
     void ParseNet( BOARD * aBrd ) throw( IO_ERROR, PARSE_ERROR );
 
     /**
@@ -252,7 +287,7 @@ void NETLIST_READER_KICAD_PARSER::ParseNet( BOARD * aBrd )
         }
     }
 
-    // When there is onlu one item in net, clear pad netname
+    // When there is only one item in net, clear pad netname
     if( nodecount < 2 && pad )
         pad->SetNetname( wxEmptyString );
 }
@@ -333,3 +368,27 @@ MODULE_INFO* NETLIST_READER_KICAD_PARSER::ParseComp()
 
     return mod_info;
 }
+
+/* Read the section "libparts" like:
+ * (libparts
+ *   (libpart (lib device) (part C)
+ *     (description "Condensateur non polarise")
+ *     (footprints
+ *       (fp SM*)
+ *       (fp C?)
+ *       (fp C1-1))
+ *     (fields
+ *       (field (name Reference) C)
+ *       (field (name Value) C))
+ *     (pins
+ *       (pin (num 1) (name ~) (type passive))
+ *       (pin (num 2) (name ~) (type passive))))
+ *
+ *  And add the strings giving the footprint filter (subsection footprints)
+ *  of the corresponding module info
+ */
+bool NETLIST_READER_KICAD_PARSER::ParseKicadFootprintFilterList() throw( IO_ERROR, PARSE_ERROR )
+{
+    // TODO
+    return true;
+}

pcbnew/zone_filling_algorithm.cpp

@@ -27,12 +27,15 @@
  * in order to have drawable (and plottable) filled polygons
  * drawable filled polygons are polygons without hole
  * @param aPcb: the current board (can be NULL for non copper zones)
+ * @param aCornerBuffer: A reference to a buffer to put polygon corners, or NULL
+ * if NULL (default), uses m_FilledPolysList and fill current zone.
  * @return number of polygons
  * This function does not add holes for pads and tracks but calls
  * AddClearanceAreasPolygonsToPolysList() to do that for copper layers
  */
-int ZONE_CONTAINER::BuildFilledPolysListData( BOARD* aPcb )
+int ZONE_CONTAINER::BuildFilledPolysListData( BOARD* aPcb, std::vector <CPolyPt>* aCornerBuffer )
 {
+    if( aCornerBuffer == NULL )
         m_FilledPolysList.clear();
 
     /* convert outlines + holes to outlines without holes (adding extra segments if necessary)
@@ -74,13 +77,24 @@ int ZONE_CONTAINER::BuildFilledPolysListData( BOARD* aPcb )
             corner.x = (int) smoothedPoly->GetKboolEngine()->GetPolygonXPoint();
             corner.y = (int) smoothedPoly->GetKboolEngine()->GetPolygonYPoint();
             corner.end_contour = false;
+            if( aCornerBuffer )
+                aCornerBuffer->push_back( corner );
+            else
                 m_FilledPolysList.push_back( corner );
             count++;
         }
 
         corner.end_contour = true;
+        if( aCornerBuffer )
+        {
+            aCornerBuffer->pop_back();
+            aCornerBuffer->push_back( corner );
+        }
+        else
+        {
             m_FilledPolysList.pop_back();
             m_FilledPolysList.push_back( corner );
+        }
         smoothedPoly->GetKboolEngine()->EndPolygonGet();
     }
 
@@ -89,12 +103,14 @@ int ZONE_CONTAINER::BuildFilledPolysListData( BOARD* aPcb )
     /* For copper layers, we now must add holes in the Polygon list.
      * holes are pads and tracks with their clearance area
      */
-
+    if( ! aCornerBuffer )
+    {
         if( IsOnCopperLayer() )
             AddClearanceAreasPolygonsToPolysList( aPcb );
 
         if ( m_FillMode )   // if fill mode uses segments, create them:
             Fill_Zone_Areas_With_Segments( );
+    }
 
     return count;
 }

pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp

@@ -329,6 +329,33 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb )
         }
     }
 
+    // Add zones outlines having an higher priority
+    for( int ii = 0; ii < GetBoard()->GetAreaCount(); ii++ )
+    {
+        ZONE_CONTAINER* zone = GetBoard()->GetArea( ii );
+        if( zone->GetLayer() != GetLayer() )
+            continue;
+
+        if( zone->GetPriority() <= GetPriority() )
+            continue;
+
+        // A highter priority zone is found: remove its area
+        item_boundingbox = zone->GetBoundingBox();
+        if( !item_boundingbox.Intersects( zone_boundingbox ) )
+            continue;
+
+        // Add the zone outline area.
+        // However if the zone has the same net as the current zone,
+        // do not add clearance.
+        // the zone will be connected to the current zone, but filled areas
+        // will use different parameters (clearnce, thermal shapes )
+        bool addclearance = GetNet() != zone->GetNet();
+        zone->TransformShapeWithClearanceToPolygon(
+                    cornerBufferPolysToSubstract,
+                    zone_clearance, s_CircleToSegmentsCount,
+                    s_Correction, addclearance );
+    }
+
    // Remove thermal symbols
     if( m_PadOption == THERMAL_PAD )
     {

pcbnew/zones_functions_for_undo_redo.cpp

@@ -92,6 +92,9 @@ bool ZONE_CONTAINER::IsSame( const ZONE_CONTAINER& aZoneToCompare )
     if(  m_ThermalReliefCopperBridge != aZoneToCompare.m_ThermalReliefCopperBridge )
         return false;
 
+    if(  GetPriority() != aZoneToCompare.GetPriority() )
+        return false;
+
     // Compare outlines
     wxASSERT( m_Poly );                                      // m_Poly == NULL Should never happen
     wxASSERT( aZoneToCompare.m_Poly );

pcbnew/zones_test_and_combine_areas.cpp

@@ -454,6 +454,8 @@ int BOARD::CombineAllAreasInNet( PICKED_ITEMS_LIST* aDeletedList, int aNetCode,
 
             if( area2->GetNet() != aNetCode )
                 continue;
+            if( curr_area->GetPriority() != area2->GetPriority() )
+                continue;
 
             if( curr_area->GetLayer() == area2->GetLayer()
                 && curr_area->utility2 != -1 && area2->utility2 != -1 )
@@ -523,6 +525,9 @@ bool BOARD::TestAreaIntersections( ZONE_CONTAINER* area_to_test )
         if( area_to_test->GetLayer() != area2->GetLayer() )
             continue;
 
+        if( area_to_test->GetPriority() != area2->GetPriority() )
+            continue;
+
         CPolyLine* poly2 = area2->m_Poly;
 
         // test bounding rects
@@ -942,6 +947,10 @@ int BOARD::Test_Drc_Areas_Outlines_To_Areas_Outlines( ZONE_CONTAINER* aArea_To_E
             if( Area_Ref->GetNet() == Area_To_Test->GetNet() && Area_Ref->GetNet() >= 0 )
                 continue;
 
+            // test for different priorities
+            if( Area_Ref->GetPriority() != Area_To_Test->GetPriority() )
+                continue;
+
             // Examine a candidate zone: compare Area_To_Test to Area_Ref
 
             // Get clearance used in zone to zone test.  The policy used to
@@ -1139,6 +1148,10 @@ bool DRC::doEdgeZoneDrc( ZONE_CONTAINER* aArea, int aCornerIndex )
         if( ( aArea->GetNet() == Area_To_Test->GetNet() ) && (aArea->GetNet() >= 0) )
             continue;
 
+        // test for same priority
+        if( Area_To_Test->GetPriority() != aArea->GetPriority() )
+            continue;
+
         // test for ending line inside Area_To_Test
         int x = end.x;
         int y = end.y;