Added main execs

1 files changed, 263 insertions, 0 deletions

diff --git a/pcbnew/connect.h b/pcbnew/connect.h
new file mode 100644
index 0000000..46868c8
--- /dev/null
+++ b/pcbnew/connect.h
@@ -0,0 +1,263 @@
+/**
+ * @file connect.h
+ * @brief helper classes to find track to track and track to pad connections.
+ */
+#ifndef CONNECT_H
+#define CONNECT_H
+
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2012 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <class_track.h>
+#include <class_board.h>
+
+
+// Helper classes to handle connection points (i.e. candidates) for tracks
+
+/* class CONNECTED_POINT describes a coordinate having a track or pad parent.
+ * when a pad is the parent, the coordinate is (obviously) the connection point
+ * when a track is the parent, the coordinate is the staring point
+ * or the ending point.
+ * therefore when building a list of CONNECTED_POINT, a pad or via generates one item,
+ * and a track generates 2 items.
+ */
+class CONNECTED_POINT
+{
+private:
+    BOARD_CONNECTED_ITEM * m_item;  // a link to the parent item (track, via or pad)
+    wxPoint m_point;                // coordinates of this connected point
+
+public:
+    // ctor to build a CONNECTED_POINT instance, when the parent is a track or via
+    CONNECTED_POINT( TRACK * aTrack, const wxPoint & aPoint)
+    {
+        m_item = aTrack;
+        m_point = aPoint;
+    }
+
+    // ctor to build a CONNECTED_POINT instance, when the parent is a pad
+    CONNECTED_POINT( D_PAD * aPad, const wxPoint & aPoint)
+    {
+        m_item = aPad;
+        m_point = aPoint;
+    }
+
+    /**
+     * Function GetTrack
+     * @return the parent track or via of this connected point,
+     * or null if the parent is a pad
+     */
+    TRACK * GetTrack() const
+    {
+        return m_item->Type() != PCB_PAD_T ? (TRACK*) m_item : NULL ;
+    }
+
+    /**
+     * Function GetPad
+     * @return the parent pad of this connected point,
+     * or null if the parent is a track or via
+     */
+    D_PAD * GetPad() const
+    {
+        return m_item->Type() == PCB_PAD_T ? (D_PAD*) m_item : NULL;
+    }
+
+    const wxPoint & GetPoint() const { return m_point; }
+};
+
+// A helper class to handle connections calculations:
+class CONNECTIONS
+{
+private:
+    std::vector <TRACK*> m_connected;           // List of connected tracks/vias
+                                                // to a given track or via
+    std::vector <CONNECTED_POINT> m_candidates; // List of points to test
+                                                // (end points of tracks or vias location )
+    BOARD * m_brd;                              // the master board.
+    const TRACK * m_firstTrack;                 // The first track used to build m_Candidates
+    const TRACK * m_lastTrack;                  // The last track used to build m_Candidates
+    std::vector<D_PAD*> m_sortedPads;           // list of sorted pads by X (then Y) coordinate
+
+public:
+    CONNECTIONS( BOARD * aBrd );
+    ~CONNECTIONS() {};
+
+    /**
+     * Function BuildPadsList
+     * Fills m_sortedPads with all pads that be connected to tracks
+     * pads are sorted by X then Y coordinates to allow fast binary search in list
+     * @param aNetcode = net code to use to filter pads
+     * if  aNetcode < 0, all pads will be put in list (default)
+     */
+    void BuildPadsList( int aNetcode = -1 );
+
+    /**
+     * Function GetPadsList
+     * @return the pads list used in connections calculations
+     */
+    std::vector<D_PAD*>& GetPadsList() { return m_sortedPads; }
+
+    /**
+     * Function Build_CurrNet_SubNets_Connections
+     * should be called after a track change (delete or add a track):
+     * Connections to pads and to tracks are recalculated
+     *   If a track is deleted, the other pointers to pads do not change.
+     *   When a new track is added in track list, its pointers to pads are already initialized
+     * Builds the subnets inside a net (tracks from aFirstTrack to aFirstTrack).
+     * subnets are clusters of pads and tracks that are connected together.
+     * When all tracks are created relative to the net, there is only a cluster
+     * when not tracks there are a cluster per pad
+     * @param aFirstTrack = first track of the given net
+     * @param aLastTrack = last track of the given net
+     * @param aNetcode = the netcode of the given net
+     */
+    void Build_CurrNet_SubNets_Connections( TRACK* aFirstTrack, TRACK* aLastTrack, int aNetcode );
+
+    /**
+     * Function BuildTracksCandidatesList
+     * Fills m_Candidates with all connecting points (track ends or via location)
+     * with tracks from aBegin to aEnd.
+     * @param aBegin = first track to store in list (should not be NULL)
+     * @param aEnd = last track to store in list
+     * if aEnd == NULL, uses all tracks from aBegin
+     */
+    void BuildTracksCandidatesList( TRACK * aBegin, TRACK * aEnd = NULL);
+
+    /**
+     * Function BuildPadsCandidatesList
+     * Populates m_candidates with all pads connecting points (pads position)
+     * m_sortedPads is expected to be populated by the pad candidates list
+     */
+    void BuildPadsCandidatesList();
+
+    /**
+     * function SearchConnectedTracks
+     * Populates .m_connected with tracks/vias connected to aTrack
+     * m_candidates is expected to be populated by the track candidates ends list
+     * @param aTrack = track or via to use as reference
+     */
+    int SearchConnectedTracks( const TRACK * aTrack );
+
+    /**
+     * Function GetConnectedTracks
+     * Copy m_Connected that contains the list of tracks connected
+     * calculated by SearchConnectedTracks
+     * in aTrack->m_TracksConnected
+     * @param aTrack = track or via to fill with connected tracks
+     */
+    void GetConnectedTracks(TRACK * aTrack)
+    {
+        aTrack->m_TracksConnected = m_connected;
+    }
+
+    /**
+     * function SearchConnectionsPadsToIntersectingPads
+     * Explores the list of pads and adds to m_PadsConnected member
+     * of each pad pads connected to
+     * Here, connections are due to intersecting pads, not tracks
+     * m_sortedPads must be initialized
+     */
+    void SearchConnectionsPadsToIntersectingPads();
+
+    /**
+     * function SearchTracksConnectedToPads
+     * Explores the list of pads.
+     * if( add_to_padlist )
+     *  adds to m_PadsConnected member of each track the pad(s) connected to
+     * if add_to_tracklist
+     *  adds to m_TracksConnected member of each pad the track(s) connected to
+     * D_PAD::m_TracksConnected is cleared before adding items
+     * TRACK::m_PadsConnected is not cleared
+     * @param add_to_padlist = true to fill m_PadsConnected member of each track
+     * @param add_to_tracklist = true to fill m_TracksConnected member of each pad
+     */
+    void SearchTracksConnectedToPads( bool add_to_padlist = true, bool add_to_tracklist = true);
+
+    /**
+     * function CollectItemsNearTo
+     * Used by SearchTracksConnectedToPads
+     * Fills aList with pads near to aPosition
+     * near means aPosition to pad position <= aDistMax
+     * @param aList = list to fill
+     * @param aPosition = aPosition to use as reference
+     * @param aDistMax = dist max from aPosition to a candidate to select it
+     */
+    void CollectItemsNearTo( std::vector<CONNECTED_POINT*>& aList,
+                            const wxPoint& aPosition, int aDistMax );
+
+    /**
+     * Function Propagate_SubNets
+     * Test a list of tracks, to create or propagate a sub netcode to pads and
+     * segments connected together.
+     * The track list must be sorted by nets, and all segments
+     * from m_firstTrack to m_lastTrack have the same net.
+     * When 2 items are connected (a track to a pad, or a track to an other track),
+     * they are grouped in a cluster.
+     * For pads, this is the .m_physical_connexion member which is a cluster identifier
+     * For tracks, this is the .m_Subnet member which is a cluster identifier
+     * For a given net, if all tracks are created, there is only one cluster.
+     * but if not all tracks are created, there are more than one cluster,
+     * and some ratsnests will be left active.
+     */
+    void Propagate_SubNets();
+
+private:
+    /**
+     * function searchEntryPointInCandidatesList
+     * Search an item in m_Connected connected to aPoint
+     * note m_Connected containts usually more than one candidate
+     * and searchEntryPointInCandidatesList returns an index to one of these candidates
+     * Others are neightbor of the indexed item.
+     * @param aPoint is the reference coordinates
+     * @return the index of item found or -1 if no candidate
+     */
+    int searchEntryPointInCandidatesList( const wxPoint & aPoint);
+
+    /**
+     * Function Merge_SubNets
+     * Change a subnet old value to a new value, for tracks and pads which are connected to
+     * tracks from m_firstTrack to m_lastTrack and their connected pads.
+     * and modify the subnet parameter (change the old value to the new value).
+     * After that, 2 cluster (or subnets) are merged into only one.
+     * Note: the resulting sub net value is the smallest between aOldSubNet and aNewSubNet
+     * @return modification count
+     * @param aOldSubNet = subnet value to modify
+     * @param aNewSubNet = new subnet value for each item which have old_val as subnet value
+     */
+    int Merge_SubNets( int aOldSubNet, int aNewSubNet );
+
+    /**
+     * Function Merge_PadsSubNets
+     * Change a subnet value to a new value, in m_sortedPads pad list
+     * After that, 2 cluster (or subnets) are merged into only one.
+     * Note: the resulting subnet value is the smallest between aOldSubNet et aNewSubNet
+     * @return modification count
+     * @param aOldSubNet = subnet value to modify
+     * @param aNewSubNet = new subnet value for each item which have old_val as subnet value
+     */
+    int Merge_PadsSubNets( int aOldSubNet, int aNewSubNet );
+};
+
+#endif      //  ifndef CONNECT_H