2013-04-25 16:29:35 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2014-04-24 18:54:49 +00:00
|
|
|
* Copyright (C) 2009 Jean-Pierre Charras, jp.charras at wanadoo.fr
|
2013-04-25 16:29:35 +00:00
|
|
|
* Copyright (C) 1992-2012 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
|
|
|
|
*/
|
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
/**
|
|
|
|
* @file class_netinfo.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Classes to handle info on nets
|
|
|
|
*/
|
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
#ifndef CLASS_NETINFO_
|
|
|
|
#define CLASS_NETINFO_
|
2011-09-24 18:33:28 +00:00
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
#include <macros.h>
|
2012-09-01 13:38:27 +00:00
|
|
|
#include <gr_basic.h>
|
2012-01-23 04:33:36 +00:00
|
|
|
#include <class_netclass.h>
|
2016-01-29 10:21:13 +00:00
|
|
|
#include <class_board_item.h>
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
|
2011-09-24 18:33:28 +00:00
|
|
|
class wxDC;
|
|
|
|
class wxPoint;
|
2011-09-23 20:00:30 +00:00
|
|
|
class LINE_READER;
|
|
|
|
class EDA_DRAW_PANEL;
|
|
|
|
class EDA_DRAW_FRAME;
|
|
|
|
class D_PAD;
|
|
|
|
class BOARD;
|
|
|
|
class BOARD_ITEM;
|
2013-01-12 17:32:24 +00:00
|
|
|
class MSG_PANEL_ITEM;
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*****************************/
|
|
|
|
/* flags for a RATSNEST_ITEM */
|
|
|
|
/*****************************/
|
|
|
|
#define CH_VISIBLE 1 /* Visible */
|
|
|
|
#define CH_UNROUTABLE 2 /* Don't use autorouter. */
|
|
|
|
#define CH_ROUTE_REQ 4 /* Must be routed by the autorouter. */
|
|
|
|
#define CH_ACTIF 8 /* Not routed. */
|
|
|
|
#define LOCAL_RATSNEST_ITEM 0x8000 /* Line between two pads of a single module. */
|
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
DECL_VEC_FOR_SWIG( D_PADS, D_PAD* )
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Class NETINFO_ITEM
|
|
|
|
* handles the data for a net
|
|
|
|
*/
|
|
|
|
class NETINFO_ITEM : public BOARD_ITEM
|
|
|
|
{
|
|
|
|
friend class NETINFO_LIST;
|
|
|
|
|
|
|
|
private:
|
|
|
|
int m_NetCode; ///< A number equivalent to the net name.
|
|
|
|
///< Used for fast comparisons in ratsnest and DRC computations.
|
|
|
|
|
|
|
|
wxString m_Netname; ///< Full net name like /mysheet/mysubsheet/vout used by Eeschema
|
|
|
|
|
|
|
|
wxString m_ShortNetname; ///< short net name, like vout from /mysheet/mysubsheet/vout
|
|
|
|
|
|
|
|
NETCLASSPTR m_NetClass;
|
|
|
|
|
|
|
|
BOARD* m_parent; ///< The parent board the net belongs to.
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
NETINFO_ITEM( BOARD* aParent, const wxString& aNetName = wxEmptyString, int aNetCode = -1 );
|
|
|
|
~NETINFO_ITEM();
|
|
|
|
|
|
|
|
static inline bool ClassOf( const EDA_ITEM* aItem )
|
|
|
|
{
|
|
|
|
return aItem && PCB_T == aItem->Type();
|
|
|
|
}
|
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
wxString GetClass() const override
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
{
|
|
|
|
return wxT( "NETINFO_ITEM" );
|
|
|
|
}
|
|
|
|
|
2016-09-24 20:00:09 +00:00
|
|
|
#if defined(DEBUG)
|
2016-09-24 18:53:15 +00:00
|
|
|
void Show( int nestLevel, std::ostream& os ) const override
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
{
|
|
|
|
}
|
2016-09-24 20:00:09 +00:00
|
|
|
#endif
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
2017-12-18 17:24:25 +00:00
|
|
|
const wxPoint GetPosition() const override
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
{
|
|
|
|
static wxPoint dummy(0, 0);
|
|
|
|
return dummy;
|
|
|
|
}
|
|
|
|
|
2016-09-24 18:53:15 +00:00
|
|
|
void SetPosition( const wxPoint& aPos ) override
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function SetClass
|
|
|
|
* sets \a aNetclass into this NET
|
|
|
|
*/
|
2017-09-23 09:20:10 +00:00
|
|
|
void SetClass( const NETCLASSPTR& aNetClass );
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
|
|
|
NETCLASSPTR GetNetClass()
|
|
|
|
{
|
|
|
|
return m_NetClass;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetClassName
|
|
|
|
* returns the class name
|
|
|
|
*/
|
2017-07-28 14:03:15 +00:00
|
|
|
wxString GetClassName() const
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
{
|
2017-07-28 14:03:15 +00:00
|
|
|
return m_NetClass ? m_NetClass->GetName() : NETCLASS::Default;
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 1
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetTrackWidth
|
|
|
|
* returns the width of tracks used to route this net.
|
|
|
|
*/
|
|
|
|
int GetTrackWidth()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetTrackWidth();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetViaSize
|
|
|
|
* returns the size of vias used to route this net
|
|
|
|
*/
|
|
|
|
int GetViaSize()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetViaDiameter();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetMicroViaSize
|
|
|
|
* returns the size of vias used to route this net
|
|
|
|
*/
|
|
|
|
int GetMicroViaSize()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetuViaDiameter();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetViaDrillSize
|
|
|
|
* returns the size of via drills used to route this net
|
|
|
|
*/
|
|
|
|
int GetViaDrillSize()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetViaDrill();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetViaDrillSize
|
|
|
|
* returns the size of via drills used to route this net
|
|
|
|
*/
|
|
|
|
int GetMicroViaDrillSize()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetuViaDrill();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetViaMinSize
|
|
|
|
* returns the Minimum value for via sizes (used in DRC)
|
|
|
|
*/
|
|
|
|
int GetViaMinSize()
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetViaMinSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetClearance
|
|
|
|
* returns the clearance when routing near aBoardItem
|
|
|
|
*/
|
|
|
|
int GetClearance( BOARD_ITEM* aBoardItem )
|
|
|
|
{
|
|
|
|
wxASSERT( m_NetClass );
|
|
|
|
return m_NetClass->GetClearance();
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function Draw
|
|
|
|
* @todo we actually could show a NET, simply show all the tracks and
|
|
|
|
* a pads or net name on pad and vias
|
|
|
|
*/
|
|
|
|
void Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE aDrawMode,
|
2016-09-24 18:53:15 +00:00
|
|
|
const wxPoint& offset ) override;
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetNet
|
|
|
|
* @return int - the netcode
|
|
|
|
*/
|
|
|
|
int GetNet() const { return m_NetCode; }
|
|
|
|
|
|
|
|
void SetNetCode( int aNetCode ) { m_NetCode = aNetCode; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetNetname
|
|
|
|
* @return const wxString&, a reference to the full netname
|
|
|
|
*/
|
|
|
|
const wxString& GetNetname() const { return m_Netname; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetShortNetname
|
|
|
|
* @return const wxString &, a reference to the short netname
|
|
|
|
*/
|
|
|
|
const wxString& GetShortNetname() const { return m_ShortNetname; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetMsgPanelInfo
|
|
|
|
* returns the information about the #NETINFO_ITEM in \a aList to display in the
|
|
|
|
* message panel.
|
|
|
|
*
|
|
|
|
* @param aList is the list in which to place the status information.
|
|
|
|
*/
|
2016-09-24 18:53:15 +00:00
|
|
|
void GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList ) override;
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Function Clear
|
|
|
|
* sets all fields to their defaults values.
|
|
|
|
*/
|
|
|
|
void Clear()
|
|
|
|
{
|
|
|
|
SetClass( NETCLASSPTR() );
|
|
|
|
}
|
|
|
|
|
|
|
|
BOARD* GetParent() const
|
|
|
|
{
|
|
|
|
return m_parent;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
Added NETINFO_MAPPING, to ease saving nets with consecutive net codes (without modifying the net codes during the run time).
Now, nets are saved with consecutive net codes (both modern & legacy plugins).
Zones are saved together with their nets, without depending on the fact if there are any pads with such net. Therefore validation of zone net names was removed (pcbnew/class_board.cpp).
Performed tests:
- Changed a pad's net name from empty to existent - ok, name was changed.
- Changed a pad's net name from empty to nonexistent - ok, error message is displayed, net name stays empty.
- Changed a pad's net name from existent to empty - ok, net name became empty
- Changed a pad's net name from existent to nonexistent - ok, error message is displayed, net name is not changed.
- Drawn a zone that belongs to a net, then modified schematics so the net does not exist anymore. After reloading the net list, all pads/tracks are updated. Zones still belongs to the net that does not exist in the schematic (but still exists in .kicad_pcb file). After running DRC, the zone becomes not filled.
- Undo & redo affects assignment of a polygon to a specific net (you may change net of a polygon, refill it and undo/redo the changes).
- KiCad s-expr & legacy, Eagle, P-CAD boards seem to load without any problem (they also contain correct net names assigned to the appropriate pads). All types of board file formats were loaded, then saved in sexpr format and reopened with a KiCad built from the master branch (without my modifications).
- A few boards were also saved using the legacy format and were opened with the master KiCad without any issues.
- Change a net name for a pad, restore with undo/redo - ok
- Remove everything, restore with undo - ok
- Remove everything, reload netlist - ok
Differences observed between files saved by the master branch KiCad and this one:
- list of nets are not saved in any particular order, so net codes may differ
- the default net class does not contain the unconnected net
2014-01-28 09:19:51 +00:00
|
|
|
class NETINFO_MAPPING
|
|
|
|
{
|
|
|
|
public:
|
2015-04-12 17:44:46 +00:00
|
|
|
NETINFO_MAPPING()
|
|
|
|
{
|
|
|
|
m_board = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Added NETINFO_MAPPING, to ease saving nets with consecutive net codes (without modifying the net codes during the run time).
Now, nets are saved with consecutive net codes (both modern & legacy plugins).
Zones are saved together with their nets, without depending on the fact if there are any pads with such net. Therefore validation of zone net names was removed (pcbnew/class_board.cpp).
Performed tests:
- Changed a pad's net name from empty to existent - ok, name was changed.
- Changed a pad's net name from empty to nonexistent - ok, error message is displayed, net name stays empty.
- Changed a pad's net name from existent to empty - ok, net name became empty
- Changed a pad's net name from existent to nonexistent - ok, error message is displayed, net name is not changed.
- Drawn a zone that belongs to a net, then modified schematics so the net does not exist anymore. After reloading the net list, all pads/tracks are updated. Zones still belongs to the net that does not exist in the schematic (but still exists in .kicad_pcb file). After running DRC, the zone becomes not filled.
- Undo & redo affects assignment of a polygon to a specific net (you may change net of a polygon, refill it and undo/redo the changes).
- KiCad s-expr & legacy, Eagle, P-CAD boards seem to load without any problem (they also contain correct net names assigned to the appropriate pads). All types of board file formats were loaded, then saved in sexpr format and reopened with a KiCad built from the master branch (without my modifications).
- A few boards were also saved using the legacy format and were opened with the master KiCad without any issues.
- Change a net name for a pad, restore with undo/redo - ok
- Remove everything, restore with undo - ok
- Remove everything, reload netlist - ok
Differences observed between files saved by the master branch KiCad and this one:
- list of nets are not saved in any particular order, so net codes may differ
- the default net class does not contain the unconnected net
2014-01-28 09:19:51 +00:00
|
|
|
/**
|
|
|
|
* Function SetBoard
|
|
|
|
* Sets a BOARD object that is used to prepare the net code map.
|
|
|
|
*/
|
|
|
|
void SetBoard( const BOARD* aBoard )
|
|
|
|
{
|
|
|
|
m_board = aBoard;
|
|
|
|
Update();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function Update
|
|
|
|
* Prepares a mapping for net codes so they can be saved as consecutive numbers.
|
|
|
|
* To retrieve a mapped net code, use translateNet() function after calling this.
|
|
|
|
*/
|
|
|
|
void Update();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function Translate
|
|
|
|
* Translates net number according to the map prepared by Update() function. It
|
|
|
|
* allows to have items stored with consecutive net codes.
|
|
|
|
* @param aNetCode is an old net code.
|
|
|
|
* @return Net code that follows the mapping.
|
|
|
|
*/
|
|
|
|
int Translate( int aNetCode ) const;
|
|
|
|
|
|
|
|
///> Wrapper class, so you can iterate through NETINFO_ITEM*s, not
|
|
|
|
///> std::pair<int/wxString, NETINFO_ITEM*>
|
|
|
|
class iterator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
iterator( std::map<int, int>::const_iterator aIter, const NETINFO_MAPPING* aMapping ) :
|
|
|
|
m_iterator( aIter ), m_mapping( aMapping )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-increment operator
|
|
|
|
const iterator& operator++()
|
|
|
|
{
|
|
|
|
++m_iterator;
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-increment operator
|
|
|
|
iterator operator++( int )
|
|
|
|
{
|
|
|
|
iterator ret = *this;
|
|
|
|
++m_iterator;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
NETINFO_ITEM* operator*() const;
|
|
|
|
|
|
|
|
NETINFO_ITEM* operator->() const;
|
|
|
|
|
|
|
|
bool operator!=( const iterator& aOther ) const
|
|
|
|
{
|
|
|
|
return m_iterator != aOther.m_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator==( const iterator& aOther ) const
|
|
|
|
{
|
|
|
|
return m_iterator == aOther.m_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::map<int, int>::const_iterator m_iterator;
|
|
|
|
const NETINFO_MAPPING* m_mapping;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function begin()
|
|
|
|
* Returns iterator to the first entry in the mapping.
|
|
|
|
* NOTE: The entry is a pointer to the original NETINFO_ITEM object, this it contains
|
|
|
|
* not mapped net code.
|
|
|
|
*/
|
|
|
|
iterator begin() const
|
|
|
|
{
|
|
|
|
return iterator( m_netMapping.begin(), this );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function end()
|
|
|
|
* Returns iterator to the last entry in the mapping.
|
|
|
|
* NOTE: The entry is a pointer to the original NETINFO_ITEM object, this it contains
|
|
|
|
* not mapped net code.
|
|
|
|
*/
|
|
|
|
iterator end() const
|
|
|
|
{
|
|
|
|
return iterator( m_netMapping.end(), this );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetSize
|
|
|
|
* @return Number of mapped nets (i.e. not empty nets for a given BOARD object).
|
|
|
|
*/
|
|
|
|
int GetSize() const
|
|
|
|
{
|
|
|
|
return m_netMapping.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
///> Board for which mapping is prepared
|
|
|
|
const BOARD* m_board;
|
|
|
|
|
|
|
|
///> Map that allows saving net codes with consecutive numbers (for compatibility reasons)
|
|
|
|
std::map<int, int> m_netMapping;
|
|
|
|
};
|
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
// waiting for swig to support std::unordered_map, see
|
|
|
|
// http://www.swig.org/Doc3.0/CPlusPlus11.html
|
|
|
|
// section 7.3.3
|
|
|
|
#include <hashtables.h>
|
|
|
|
DECL_HASH_FOR_SWIG( NETNAMES_MAP, wxString, NETINFO_ITEM* )
|
|
|
|
DECL_HASH_FOR_SWIG( NETCODES_MAP, int, NETINFO_ITEM* )
|
|
|
|
#else
|
|
|
|
// use std::map for now
|
|
|
|
DECL_MAP_FOR_SWIG( NETNAMES_MAP, wxString, NETINFO_ITEM* )
|
|
|
|
DECL_MAP_FOR_SWIG( NETCODES_MAP, int, NETINFO_ITEM* )
|
|
|
|
#endif
|
Added NETINFO_MAPPING, to ease saving nets with consecutive net codes (without modifying the net codes during the run time).
Now, nets are saved with consecutive net codes (both modern & legacy plugins).
Zones are saved together with their nets, without depending on the fact if there are any pads with such net. Therefore validation of zone net names was removed (pcbnew/class_board.cpp).
Performed tests:
- Changed a pad's net name from empty to existent - ok, name was changed.
- Changed a pad's net name from empty to nonexistent - ok, error message is displayed, net name stays empty.
- Changed a pad's net name from existent to empty - ok, net name became empty
- Changed a pad's net name from existent to nonexistent - ok, error message is displayed, net name is not changed.
- Drawn a zone that belongs to a net, then modified schematics so the net does not exist anymore. After reloading the net list, all pads/tracks are updated. Zones still belongs to the net that does not exist in the schematic (but still exists in .kicad_pcb file). After running DRC, the zone becomes not filled.
- Undo & redo affects assignment of a polygon to a specific net (you may change net of a polygon, refill it and undo/redo the changes).
- KiCad s-expr & legacy, Eagle, P-CAD boards seem to load without any problem (they also contain correct net names assigned to the appropriate pads). All types of board file formats were loaded, then saved in sexpr format and reopened with a KiCad built from the master branch (without my modifications).
- A few boards were also saved using the legacy format and were opened with the master KiCad without any issues.
- Change a net name for a pad, restore with undo/redo - ok
- Remove everything, restore with undo - ok
- Remove everything, reload netlist - ok
Differences observed between files saved by the master branch KiCad and this one:
- list of nets are not saved in any particular order, so net codes may differ
- the default net class does not contain the unconnected net
2014-01-28 09:19:51 +00:00
|
|
|
|
2011-12-10 05:33:24 +00:00
|
|
|
/**
|
2014-04-24 18:54:49 +00:00
|
|
|
* Class NETINFO_LIST
|
2011-12-10 05:33:24 +00:00
|
|
|
* is a container class for NETINFO_ITEM elements, which are the nets. That makes
|
|
|
|
* this class a container for the nets.
|
|
|
|
*/
|
2011-09-23 20:00:30 +00:00
|
|
|
class NETINFO_LIST
|
|
|
|
{
|
2011-12-10 05:33:24 +00:00
|
|
|
friend class BOARD;
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
public:
|
2011-12-10 05:33:24 +00:00
|
|
|
NETINFO_LIST( BOARD* aParent );
|
2011-09-23 20:00:30 +00:00
|
|
|
~NETINFO_LIST();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function GetItem
|
2014-01-16 13:20:51 +00:00
|
|
|
* @param aNetCode = netcode to identify a given NETINFO_ITEM
|
|
|
|
* @return NETINFO_ITEM* - by \a aNetCode, or NULL if not found
|
2011-09-23 20:00:30 +00:00
|
|
|
*/
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
NETINFO_ITEM* GetNetItem( int aNetCode ) const;
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2014-01-10 17:04:07 +00:00
|
|
|
/**
|
|
|
|
* Function GetItem
|
|
|
|
* @param aNetName = net name to identify a given NETINFO_ITEM
|
|
|
|
* @return NETINFO_ITEM* - by \a aNetName, or NULL if not found
|
|
|
|
*/
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
NETINFO_ITEM* GetNetItem( const wxString& aNetName ) const;
|
2014-01-10 17:04:07 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
/**
|
2011-12-10 05:33:24 +00:00
|
|
|
* Function GetNetCount
|
2011-09-23 20:00:30 +00:00
|
|
|
* @return the number of nets ( always >= 1 )
|
2011-12-10 05:33:24 +00:00
|
|
|
* because the first net is the "not connected" net and always exists
|
2011-09-23 20:00:30 +00:00
|
|
|
*/
|
2014-01-16 13:20:51 +00:00
|
|
|
unsigned GetNetCount() const { return m_netNames.size(); }
|
2011-09-23 20:00:30 +00:00
|
|
|
|
|
|
|
/**
|
2016-01-29 10:29:56 +00:00
|
|
|
* Function AppendNet
|
|
|
|
* adds \a aNewElement to the end of the net list. Negative net code means it is going to be
|
2014-06-02 09:41:54 +00:00
|
|
|
* auto-assigned.
|
2011-09-23 20:00:30 +00:00
|
|
|
*/
|
|
|
|
void AppendNet( NETINFO_ITEM* aNewElement );
|
|
|
|
|
2016-01-29 10:29:56 +00:00
|
|
|
/**
|
|
|
|
* Function RemoveNet
|
|
|
|
* Removes a new from the net list.
|
|
|
|
*/
|
|
|
|
void RemoveNet( NETINFO_ITEM* aNet );
|
2011-09-23 20:00:30 +00:00
|
|
|
/**
|
2011-12-10 05:33:24 +00:00
|
|
|
* Function GetPadCount
|
|
|
|
* @return the number of pads in board
|
2011-09-23 20:00:30 +00:00
|
|
|
*/
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
|
|
|
|
/// Return the name map, at least for python.
|
2016-07-19 20:34:09 +00:00
|
|
|
const NETNAMES_MAP& NetsByName() const { return m_netNames; }
|
|
|
|
|
|
|
|
/// Return the netcode map, at least for python.
|
|
|
|
const NETCODES_MAP& NetsByNetcode() const { return m_netCodes; }
|
2011-09-23 20:00:30 +00:00
|
|
|
|
2015-02-17 16:32:47 +00:00
|
|
|
///> Constant that holds the "unconnected net" number (typically 0)
|
|
|
|
///> all items "connected" to this net are actually not connected items
|
2014-01-15 08:34:16 +00:00
|
|
|
static const int UNCONNECTED;
|
|
|
|
|
2015-02-17 16:32:47 +00:00
|
|
|
///> Constant that forces initialization of a netinfo item to the NETINFO_ITEM ORPHANED
|
|
|
|
///> (typically -1) when calling SetNetCode od board connected items
|
2016-01-29 10:29:56 +00:00
|
|
|
static const int ORPHANED;
|
2015-02-17 16:32:47 +00:00
|
|
|
|
BOARD_CONNECTED_ITEMs do not store net code anymore (m_NetCode field), instead net info is stored using a pointer to NETINFO_ITEM.
GetNet() refers to the net code stored in the NETINFO_ITEM. SetNet() finds an appropriate NETINFO_ITEM and uses it.
Removing GetNet() & SetNet() (and the whole net code idea) requires too many changes in the code (~250 references to the mentioned functions).
BOARD_CONNECTED_ITEMs by default get a pointer to NETINFO_ITEM that stores unconnected items. This requires for all BOARD_CONNECTED_ITEMs to have a parent (so BOARD* is accessible). The only orphaned item is BOARD_DESIGN_SETTINGS::m_Pad_Master, but it does not cause any issues so far.
Items that do not have access to a BOARD (do not have set parents) and therefore cannot get net assigned, by default get const static NETINFO_LIST::ORPHANED.
Performed tests:
- loaded .kicad_pcb, KiCad legacy board, Eagle 6.0 board, P-CAD board - all ok
- load a simple project, reload netlist after changing connections in eeschema - ok
- save & reload a board - ok, but still contain empty nets
- remove everything, restore with undo - ok
- remove everything, reload netlist - ok
- changing net names (all possibilites: empty->existing, empty->not existing, existing->empty, existing->not existing) - all ok
- zones: when net is changed to a net that does not have any nodes besides the zone itself, it does not get filled
2014-01-15 17:03:06 +00:00
|
|
|
///> NETINFO_ITEM meaning that there was no net assigned for an item, as there was no
|
|
|
|
///> board storing net list available.
|
2016-01-29 10:29:56 +00:00
|
|
|
static NETINFO_ITEM ORPHANED_ITEM;
|
BOARD_CONNECTED_ITEMs do not store net code anymore (m_NetCode field), instead net info is stored using a pointer to NETINFO_ITEM.
GetNet() refers to the net code stored in the NETINFO_ITEM. SetNet() finds an appropriate NETINFO_ITEM and uses it.
Removing GetNet() & SetNet() (and the whole net code idea) requires too many changes in the code (~250 references to the mentioned functions).
BOARD_CONNECTED_ITEMs by default get a pointer to NETINFO_ITEM that stores unconnected items. This requires for all BOARD_CONNECTED_ITEMs to have a parent (so BOARD* is accessible). The only orphaned item is BOARD_DESIGN_SETTINGS::m_Pad_Master, but it does not cause any issues so far.
Items that do not have access to a BOARD (do not have set parents) and therefore cannot get net assigned, by default get const static NETINFO_LIST::ORPHANED.
Performed tests:
- loaded .kicad_pcb, KiCad legacy board, Eagle 6.0 board, P-CAD board - all ok
- load a simple project, reload netlist after changing connections in eeschema - ok
- save & reload a board - ok, but still contain empty nets
- remove everything, restore with undo - ok
- remove everything, reload netlist - ok
- changing net names (all possibilites: empty->existing, empty->not existing, existing->empty, existing->not existing) - all ok
- zones: when net is changed to a net that does not have any nodes besides the zone itself, it does not get filled
2014-01-15 17:03:06 +00:00
|
|
|
|
2013-03-14 22:54:47 +00:00
|
|
|
#if defined(DEBUG)
|
|
|
|
void Show() const;
|
|
|
|
#endif
|
|
|
|
|
2014-03-12 13:58:49 +00:00
|
|
|
#ifndef SWIG
|
2014-01-16 15:47:31 +00:00
|
|
|
///> Wrapper class, so you can iterate through NETINFO_ITEM*s, not
|
|
|
|
///> std::pair<int/wxString, NETINFO_ITEM*>
|
|
|
|
class iterator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
iterator( NETNAMES_MAP::const_iterator aIter ) : m_iterator( aIter )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/// pre-increment operator
|
|
|
|
const iterator& operator++()
|
|
|
|
{
|
|
|
|
++m_iterator;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// post-increment operator
|
|
|
|
iterator operator++( int )
|
|
|
|
{
|
|
|
|
iterator ret = *this;
|
|
|
|
++m_iterator;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
NETINFO_ITEM* operator*() const
|
|
|
|
{
|
|
|
|
return m_iterator->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
NETINFO_ITEM* operator->() const
|
|
|
|
{
|
|
|
|
return m_iterator->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator!=( const iterator& aOther ) const
|
|
|
|
{
|
|
|
|
return m_iterator != aOther.m_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator==( const iterator& aOther ) const
|
|
|
|
{
|
|
|
|
return m_iterator == aOther.m_iterator;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
NETNAMES_MAP::const_iterator m_iterator;
|
|
|
|
};
|
|
|
|
|
|
|
|
iterator begin() const
|
|
|
|
{
|
|
|
|
return iterator( m_netNames.begin() );
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator end() const
|
|
|
|
{
|
|
|
|
return iterator( m_netNames.end() );
|
|
|
|
}
|
2014-03-12 13:58:49 +00:00
|
|
|
#endif
|
2014-01-16 15:47:31 +00:00
|
|
|
|
2016-01-29 10:21:13 +00:00
|
|
|
BOARD* GetParent() const
|
|
|
|
{
|
|
|
|
return m_Parent;
|
|
|
|
}
|
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
private:
|
|
|
|
/**
|
2015-09-23 23:02:40 +00:00
|
|
|
* Function clear
|
2011-12-10 05:33:24 +00:00
|
|
|
* deletes the list of nets (and free memory)
|
|
|
|
*/
|
|
|
|
void clear();
|
|
|
|
|
|
|
|
/**
|
2013-08-24 08:08:55 +00:00
|
|
|
* Function buildListOfNets
|
2011-12-10 05:33:24 +00:00
|
|
|
* builds or rebuilds the list of NETINFO_ITEMs
|
|
|
|
* The list is sorted by names.
|
|
|
|
*/
|
|
|
|
void buildListOfNets();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function buildPadsFullList
|
|
|
|
* creates the pad list, and initializes:
|
2011-09-23 20:00:30 +00:00
|
|
|
* m_Pads (list of pads)
|
|
|
|
* set m_Status_Pcb = LISTE_PAD_OK;
|
|
|
|
* and clear for all pads in list the m_SubRatsnest member;
|
|
|
|
* clear m_Pcb->m_FullRatsnest
|
|
|
|
*/
|
2011-12-10 05:33:24 +00:00
|
|
|
void buildPadsFullList();
|
|
|
|
|
2014-01-16 13:20:51 +00:00
|
|
|
/**
|
|
|
|
* Function getFreeNetCode
|
|
|
|
* returns the first available net code that is not used by any other net.
|
|
|
|
*/
|
2014-06-02 09:41:54 +00:00
|
|
|
int getFreeNetCode();
|
2014-01-16 13:20:51 +00:00
|
|
|
|
Added NETINFO_MAPPING, to ease saving nets with consecutive net codes (without modifying the net codes during the run time).
Now, nets are saved with consecutive net codes (both modern & legacy plugins).
Zones are saved together with their nets, without depending on the fact if there are any pads with such net. Therefore validation of zone net names was removed (pcbnew/class_board.cpp).
Performed tests:
- Changed a pad's net name from empty to existent - ok, name was changed.
- Changed a pad's net name from empty to nonexistent - ok, error message is displayed, net name stays empty.
- Changed a pad's net name from existent to empty - ok, net name became empty
- Changed a pad's net name from existent to nonexistent - ok, error message is displayed, net name is not changed.
- Drawn a zone that belongs to a net, then modified schematics so the net does not exist anymore. After reloading the net list, all pads/tracks are updated. Zones still belongs to the net that does not exist in the schematic (but still exists in .kicad_pcb file). After running DRC, the zone becomes not filled.
- Undo & redo affects assignment of a polygon to a specific net (you may change net of a polygon, refill it and undo/redo the changes).
- KiCad s-expr & legacy, Eagle, P-CAD boards seem to load without any problem (they also contain correct net names assigned to the appropriate pads). All types of board file formats were loaded, then saved in sexpr format and reopened with a KiCad built from the master branch (without my modifications).
- A few boards were also saved using the legacy format and were opened with the master KiCad without any issues.
- Change a net name for a pad, restore with undo/redo - ok
- Remove everything, restore with undo - ok
- Remove everything, reload netlist - ok
Differences observed between files saved by the master branch KiCad and this one:
- list of nets are not saved in any particular order, so net codes may differ
- the default net class does not contain the unconnected net
2014-01-28 09:19:51 +00:00
|
|
|
BOARD* m_Parent;
|
2014-01-16 13:20:51 +00:00
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
NETNAMES_MAP m_netNames; ///< map of <wxString, NETINFO_ITEM*>, is NETINFO_ITEM owner
|
|
|
|
NETCODES_MAP m_netCodes; ///< map of <int, NETINFO_ITEM*> is NOT owner
|
2014-01-09 14:51:47 +00:00
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
int m_newNetCode; ///< possible value for new net code assignment
|
2011-09-23 20:00:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************/
|
|
|
|
/* Description of a trace point for monitoring connections */
|
|
|
|
/***********************************************************/
|
|
|
|
#define START_ON_PAD 0x10
|
|
|
|
#define END_ON_PAD 0x20
|
|
|
|
#define START_ON_TRACK 0x40
|
|
|
|
#define END_ON_TRACK 0x80
|
|
|
|
|
|
|
|
/* Status bit (OR'ed bits) for class BOARD member .m_Status_Pcb */
|
|
|
|
enum StatusPcbFlags {
|
2017-03-22 13:51:07 +00:00
|
|
|
|
2011-09-23 20:00:30 +00:00
|
|
|
RATSNEST_ITEM_LOCAL_OK = 4, /* current MODULE ratsnest is Ok */
|
|
|
|
DO_NOT_SHOW_GENERAL_RASTNEST = 0x20 /* Do not display the general
|
|
|
|
* ratsnest (used in module moves) */
|
|
|
|
};
|
|
|
|
|
2017-03-22 13:51:07 +00:00
|
|
|
|
Pcbnew: major swig fix.
* Switched hashtables.h over to std::undordered_map from boost version.
* Added new macros DECL_VEC_FOR_SWIG() and DECL_MAP_FOR_SWIG() in macros.h.
These along with future DECL_HASH_FOR_SWIG() unify the declaration to swig
and C++ so that the resultant type name is common in both languages, and
the types AGREE.
* Fixed swigging of NETINFO_ITEM and NETINFO_LIST via magic.
* Newly exposed (python wrapped) are: D_PADS, TRACKS (was TRACK_PTRS),
NETNAME_MAP, NETCODE_MAP, wxString (without constructor purposely, read
comment in wx.i), MARKERS, ZONE_CONTAINERS, NETCLASSPTR, KICAD_T types.
* std::vector<SOMETHING*> tends to end up named SOMETHINGS in C++ and python.
Having the name consistent between like types is helpful, and between
languages. std::map<> ends up as SOMETHING_MAP.
* NETINFO_LIST::m_netNames and NETINFO_LIST::m_netCodes are now std::map
instead of hashtables, because swig does not yet support std::unordered_map.
* You can now get to any netclass or net info. NETNAMES_MAP and NETCODES_MAP
are traversable basically the same as a python dictionary using a python
string (not wsString) as the key! The wxString typemap converts python
string to wxString before the lookup happens. Iteration also works.
2016-07-18 17:23:09 +00:00
|
|
|
#endif // CLASS_NETINFO_
|