board.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2007 Jean-Pierre Charras, jaen-pierre.charras@gipsa-lab.inpg.com
 * Copyright (C) 1992-2020 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
 */

#ifndef CLASS_BOARD_H_
#define CLASS_BOARD_H_

#include <board_design_settings.h>
#include <board_item_container.h>
#include <pcb_group.h>
#include <footprint.h>
#include <common.h> // Needed for stl hash extensions
#include <layers_id_colors_and_visibility.h>
#include <netinfo.h>
#include <pcb_plot_params.h>
#include <title_block.h>
#include <tools/pcb_selection.h>

class BOARD_COMMIT;
class PCB_BASE_FRAME;
class PCB_EDIT_FRAME;
class PICKED_ITEMS_LIST;
class BOARD;
class ZONE;
class TRACK;
class PAD;
class PCB_MARKER;
class MSG_PANEL_ITEM;
class NETLIST;
class REPORTER;
class SHAPE_POLY_SET;
class CONNECTIVITY_DATA;
class COMPONENT;
class PROJECT;

// Forward declare endpoint from class_track.h
enum ENDPOINT_T : int;

enum LAYER_T
{
    LT_UNDEFINED = -1,
    LT_SIGNAL,
    LT_POWER,
    LT_MIXED,
    LT_JUMPER
};


struct LAYER
{
    LAYER()
    {
        clear();
    }

    void clear()
    {
        m_type    = LT_SIGNAL;
        m_visible = true;
        m_number  = 0;
        m_name.clear();
        m_userName.clear();
    }

    /*
    LAYER( const wxString& aName = wxEmptyString,
            LAYER_T aType = LT_SIGNAL, bool aVisible = true, int aNumber = -1 ) :
        m_name( aName ),
        m_type( aType ),
        m_visible( aVisible ),
        m_number( aNumber )
    {
    }
    */

    wxString    m_name;      
    wxString    m_userName;  
    LAYER_T     m_type;      
    bool        m_visible;
    int         m_number;    

    static const char* ShowType( LAYER_T aType );

    static LAYER_T     ParseType( const char* aType );
};


// Helper class to handle high light nets
class HIGH_LIGHT_INFO
{
    friend class BOARD;

protected:
    std::set<int> m_netCodes;    // net(s) selected for highlight (-1 when no net selected )
    bool          m_highLightOn; // highlight active

    void Clear()
    {
        m_netCodes.clear();
        m_highLightOn = false;
    }

    HIGH_LIGHT_INFO()
    {
        Clear();
    }
};

class BOARD;

class BOARD_LISTENER
{
public:
    virtual ~BOARD_LISTENER() { }
    virtual void OnBoardItemAdded( BOARD& aBoard, BOARD_ITEM* aBoardItem ) { }
    virtual void OnBoardItemsAdded( BOARD& aBoard, std::vector<BOARD_ITEM*>& aBoardItem ) { }
    virtual void OnBoardItemRemoved( BOARD& aBoard, BOARD_ITEM* aBoardItem ) { }
    virtual void OnBoardItemsRemoved( BOARD& aBoard, std::vector<BOARD_ITEM*>& aBoardItem ) { }
    virtual void OnBoardNetSettingsChanged( BOARD& aBoard ) { }
    virtual void OnBoardItemChanged( BOARD& aBoard, BOARD_ITEM* aBoardItem ) { }
    virtual void OnBoardItemsChanged( BOARD& aBoard, std::vector<BOARD_ITEM*>& aBoardItem ) { }
    virtual void OnBoardHighlightNetChanged( BOARD& aBoard ) { }
};


DECL_VEC_FOR_SWIG( MARKERS, PCB_MARKER* )
DECL_VEC_FOR_SWIG( ZONES, ZONE* )
DECL_DEQ_FOR_SWIG( TRACKS, TRACK* )
// Dequeue rather than Vector just so we can use moveUnflaggedItems in pcbnew_control.cpp
DECL_DEQ_FOR_SWIG( GROUPS, PCB_GROUP* )


enum class BOARD_USE
{
    NORMAL,     // A normal board
    FPHOLDER    // A board that holds a single footprint
};


class BOARD : public BOARD_ITEM_CONTAINER
{
    friend class PCB_EDIT_FRAME;

private:
    BOARD_USE           m_boardUse;

    wxString            m_fileName;
    MARKERS             m_markers;
    DRAWINGS            m_drawings;
    FOOTPRINTS          m_footprints;
    TRACKS              m_tracks;
    GROUPS              m_groups;
    ZONES               m_zones;

    LAYER               m_layers[PCB_LAYER_ID_COUNT];

    HIGH_LIGHT_INFO     m_highLight;                // current high light data
    HIGH_LIGHT_INFO     m_highLightPrevious;        // a previously stored high light data

    int                 m_fileFormatVersionAtLoad;  // the version loaded from the file

    std::map<wxString, wxString>        m_properties;
    std::shared_ptr<CONNECTIVITY_DATA>  m_connectivity;

    PAGE_INFO           m_paper;
    TITLE_BLOCK         m_titles;               // text in lower right of screen and plots
    PCB_PLOT_PARAMS     m_plotOptions;
    PROJECT*            m_project;              // project this board is a part of

    std::unique_ptr<BOARD_DESIGN_SETTINGS> m_designSettings;

    NETINFO_LIST                 m_NetInfo;         // net info list (name, design constraints...

    std::vector<BOARD_LISTENER*> m_listeners;

    // The default copy constructor & operator= are inadequate,
    // either write one or do not use it at all
    BOARD( const BOARD& aOther ) = delete;

    BOARD& operator=( const BOARD& aOther ) = delete;

    template <typename Func, typename... Args>
    void InvokeListeners( Func&& aFunc, Args&&... args )
    {
        for( auto&& l : m_listeners )
            ( l->*aFunc )( std::forward<Args>( args )... );
    }

public:
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && PCB_T == aItem->Type();
    }

    void SetBoardUse( BOARD_USE aUse ) { m_boardUse = aUse; }

    BOARD_USE GetBoardUse() const { return m_boardUse; }

    bool IsFootprintHolder() const
    {
        return m_boardUse == BOARD_USE::FPHOLDER;
    }

    void SetFileName( const wxString& aFileName ) { m_fileName = aFileName; }

    const wxString &GetFileName() const { return m_fileName; }

    TRACKS& Tracks() { return m_tracks; }
    const TRACKS& Tracks() const { return m_tracks; }

    FOOTPRINTS& Footprints() { return m_footprints; }
    const FOOTPRINTS& Footprints() const { return m_footprints; }

    DRAWINGS& Drawings() { return m_drawings; }
    const DRAWINGS& Drawings() const { return m_drawings; }

    ZONES& Zones() { return m_zones; }
    const ZONES& Zones() const { return m_zones; }

    MARKERS& Markers() { return m_markers; }
    const MARKERS& Markers() const { return m_markers; }

    GROUPS& Groups() { return m_groups; }
    const GROUPS& Groups() const { return m_groups; }

    const std::vector<BOARD_CONNECTED_ITEM*> AllConnectedItems();

    const std::map<wxString, wxString>& GetProperties() const { return m_properties; }
    void SetProperties( const std::map<wxString, wxString>& aProps ) { m_properties = aProps; }

    bool ResolveTextVar( wxString* token, int aDepth ) const;

    LSET    m_LegacyVisibleLayers;
    GAL_SET m_LegacyVisibleItems;

    bool m_LegacyDesignSettingsLoaded;
    bool m_LegacyCopperEdgeClearanceLoaded;

    bool m_LegacyNetclassesLoaded;

    BOARD();
    ~BOARD();

    wxPoint GetPosition() const override;
    void SetPosition( const wxPoint& aPos ) override;
    const wxPoint GetFocusPosition() const override { return GetBoundingBox().GetCenter(); }

    bool IsEmpty() const
    {
        return m_drawings.empty() && m_footprints.empty() && m_tracks.empty() && m_zones.empty();
    }

    void Move( const wxPoint& aMoveVector ) override;

    void SetFileFormatVersionAtLoad( int aVersion ) { m_fileFormatVersionAtLoad = aVersion; }
    int GetFileFormatVersionAtLoad()  const { return m_fileFormatVersionAtLoad; }

    void Add( BOARD_ITEM* aItem, ADD_MODE aMode = ADD_MODE::INSERT ) override;

    void Remove( BOARD_ITEM* aBoardItem, REMOVE_MODE aMode = REMOVE_MODE::NORMAL ) override;

    void FinalizeBulkAdd( std::vector<BOARD_ITEM*>& aNewItems );

    void FinalizeBulkRemove( std::vector<BOARD_ITEM*>& aRemovedItems );

    FOOTPRINT* GetFirstFootprint() const
    {
        return m_footprints.empty() ? nullptr : m_footprints.front();
    }

    void DeleteAllFootprints()
    {
        for( FOOTPRINT* footprint : m_footprints )
            delete footprint;

        m_footprints.clear();
    }

    BOARD_ITEM* GetItem( const KIID& aID ) const;

    void FillItemMap( std::map<KIID, EDA_ITEM*>& aMap );

    wxString ConvertCrossReferencesToKIIDs( const wxString& aSource );
    wxString ConvertKIIDsToCrossReferences( const wxString& aSource );

    std::shared_ptr<CONNECTIVITY_DATA> GetConnectivity() const { return m_connectivity; }

    void BuildConnectivity();

    void DeleteMARKERs();

    void DeleteMARKERs( bool aWarningsAndErrors, bool aExclusions );

    PROJECT* GetProject() const { return m_project; }

    void SetProject( PROJECT* aProject );

    void ClearProject();

    std::vector<PCB_MARKER*> ResolveDRCExclusions();

    void ResetNetHighLight();

    const std::set<int>& GetHighLightNetCodes() const
    {
        return m_highLight.m_netCodes;
    }

    void SetHighLightNet( int aNetCode, bool aMulti = false );

    bool IsHighLightNetON() const { return m_highLight.m_highLightOn; }

    void HighLightON( bool aValue = true );

    void HighLightOFF()
    {
        HighLightON( false );
    }

    int  GetCopperLayerCount() const;
    void SetCopperLayerCount( int aCount );

    LSET GetEnabledLayers() const;

    void SetEnabledLayers( LSET aLayerMask );

    bool IsLayerEnabled( PCB_LAYER_ID aLayer ) const
    {
        return GetDesignSettings().IsLayerEnabled( aLayer );
    }

    bool IsLayerVisible( PCB_LAYER_ID aLayer ) const;

    LSET  GetVisibleLayers() const;

    void SetVisibleLayers( LSET aLayerMask );

    // these 2 functions are not tidy at this time, since there are PCB_LAYER_IDs that
    // are not stored in the bitmap.

    GAL_SET GetVisibleElements() const;

    void SetVisibleElements( const GAL_SET& aMask );

    void SetVisibleAlls();

    bool IsElementVisible( GAL_LAYER_ID aLayer ) const;

    void SetElementVisibility( GAL_LAYER_ID aLayer, bool aNewState );

    bool IsFootprintLayerVisible( PCB_LAYER_ID aLayer );

    BOARD_DESIGN_SETTINGS& GetDesignSettings() const
    {
        return *m_designSettings;
    }

    const ZONE_SETTINGS& GetZoneSettings() const override
    {
        return GetDesignSettings().GetDefaultZoneSettings();
    }

    void SetZoneSettings( const ZONE_SETTINGS& aSettings ) override
    {
        GetDesignSettings().SetDefaultZoneSettings( aSettings );
    }

    const PAGE_INFO& GetPageSettings() const                { return m_paper; }
    void SetPageSettings( const PAGE_INFO& aPageSettings )  { m_paper = aPageSettings; }

    const PCB_PLOT_PARAMS& GetPlotOptions() const           { return m_plotOptions; }
    void SetPlotOptions( const PCB_PLOT_PARAMS& aOptions )  { m_plotOptions = aOptions; }

    TITLE_BLOCK& GetTitleBlock()                            { return m_titles; }
    const TITLE_BLOCK& GetTitleBlock() const                { return m_titles; }
    void SetTitleBlock( const TITLE_BLOCK& aTitleBlock )    { m_titles = aTitleBlock; }

    wxString GetSelectMenuText( EDA_UNITS aUnits ) const override;

    bool GetBoardPolygonOutlines( SHAPE_POLY_SET& aOutlines,
                                  OUTLINE_ERROR_HANDLER* aErrorHandler = nullptr );

    void ConvertBrdLayerToPolygonalContours( PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aOutlines );

    const PCB_LAYER_ID GetLayerID( const wxString& aLayerName ) const;

    const wxString GetLayerName( PCB_LAYER_ID aLayer ) const;

    bool SetLayerName( PCB_LAYER_ID aLayer, const wxString& aLayerName );

    static wxString GetStandardLayerName( PCB_LAYER_ID aLayerId )
    {
        // a BOARD's standard layer name is the PCB_LAYER_ID fixed name
        return LayerName( aLayerId );
    }

    bool SetLayerDescr( PCB_LAYER_ID aIndex, const LAYER& aLayer );

    LAYER_T GetLayerType( PCB_LAYER_ID aLayer ) const;

    bool SetLayerType( PCB_LAYER_ID aLayer, LAYER_T aLayerType );

    unsigned GetNodesCount( int aNet = -1 ) const;

    unsigned GetUnconnectedNetCount() const;

    unsigned GetPadCount() const;

    const std::vector<PAD*> GetPads() const;

    void BuildListOfNets()
    {
        m_NetInfo.buildListOfNets();
    }

    NETINFO_ITEM* FindNet( int aNetcode ) const;

    NETINFO_ITEM* FindNet( const wxString& aNetname ) const;

    const NETINFO_LIST& GetNetInfo() const
    {
        return m_NetInfo;
    }

    NETINFO_LIST& GetNetInfo()
    {
        return m_NetInfo;
    }

#ifndef SWIG

    NETINFO_LIST::iterator BeginNets() const
    {
        return m_NetInfo.begin();
    }

    NETINFO_LIST::iterator EndNets() const
    {
        return m_NetInfo.end();
    }
#endif

    unsigned GetNetCount() const
    {
        return m_NetInfo.GetNetCount();
    }

    EDA_RECT ComputeBoundingBox( bool aBoardEdgesOnly = false ) const;

    const EDA_RECT GetBoundingBox() const override
    {
        return ComputeBoundingBox( false );
    }

    const EDA_RECT GetBoardEdgesBoundingBox() const
    {
        return ComputeBoundingBox( true );
    }

    void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;

    SEARCH_RESULT Visit( INSPECTOR inspector, void* testData, const KICAD_T scanTypes[] ) override;

    FOOTPRINT* FindFootprintByReference( const wxString& aReference ) const;

    FOOTPRINT* FindFootprintByPath( const KIID_PATH& aPath ) const;

    int SortedNetnamesList( wxArrayString& aNames, bool aSortbyPadsCount );

    std::vector<wxString> GetNetClassAssignmentCandidates();

    void SynchronizeNetsAndNetClasses();

    void SynchronizeProperties();

    wxString GetClass() const override
    {
        return wxT( "BOARD" );
    }

#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif


    /*************************/
    /* Copper Areas handling */
    /*************************/

    int SetAreasNetCodesFromNetNames();

    ZONE* GetArea( int index ) const
    {
        if( (unsigned) index < m_zones.size() )
            return m_zones[index];

        return NULL;
    }

    std::list<ZONE*> GetZoneList( bool aIncludeZonesInFootprints = false );

    int GetAreaCount() const
    {
        return static_cast<int>( m_zones.size() );
    }

    /* Functions used in test, merge and cut outlines */

    ZONE* AddArea( PICKED_ITEMS_LIST* aNewZonesList, int aNetcode, PCB_LAYER_ID aLayer,
                   wxPoint aStartPointPosition, ZONE_BORDER_DISPLAY_STYLE aHatch );

    bool NormalizeAreaPolygon( PICKED_ITEMS_LIST* aNewZonesList, ZONE* aCurrArea );

    bool OnAreaPolygonModified( PICKED_ITEMS_LIST* aModifiedZonesList, ZONE* modified_area );

    bool CombineAllZonesInNet( PICKED_ITEMS_LIST* aDeletedList, int aNetCode );

    bool TestZoneIntersections( ZONE* aZone );

    bool TestZoneIntersection( ZONE* aZone1, ZONE* aZone2 );

    bool CombineZones( PICKED_ITEMS_LIST* aDeletedList, ZONE* aRefZone, ZONE* aZoneToCombine );

    PAD* GetPad( const wxPoint& aPosition, LSET aLayerMask );
    PAD* GetPad( const wxPoint& aPosition )
    {
        return GetPad( aPosition, LSET().set() );
    }

    PAD* GetPad( TRACK* aTrace, ENDPOINT_T aEndPoint );

    PAD* GetPadFast( const wxPoint& aPosition, LSET aLayerMask );

    PAD* GetPad( std::vector<PAD*>& aPadList, const wxPoint& aPosition, LSET aLayerMask );

    void PadDelete( PAD* aPad );

    void GetSortedPadListByXthenYCoord( std::vector<PAD*>& aVector, int aNetCode = -1 );

    std::tuple<int, double, double> GetTrackLength( const TRACK& aTrack ) const;

    TRACKS TracksInNet( int aNetCode );

    FOOTPRINT* GetFootprint( const wxPoint& aPosition, PCB_LAYER_ID aActiveLayer,
                             bool aVisibleOnly, bool aIgnoreLocked = false );

    void ClearAllNetCodes();

    void MapNets( const BOARD* aDestBoard );

    void SanitizeNetcodes();

    void AddListener( BOARD_LISTENER* aListener );

    void RemoveListener( BOARD_LISTENER* aListener );

    void OnItemChanged( BOARD_ITEM* aItem );

    void OnItemsChanged( std::vector<BOARD_ITEM*>& aItems );

    /*
     * Consistency check of internal m_groups structure.
     * @param repair if true, modify groups structure until it passes the sanity check.
     * @return empty string on success.  Or error description if there's a problem.
     */
    wxString GroupsSanityCheck( bool repair = false );

    /*
     * @param repair if true, make one modification to groups structure that brings it
     *        closer to passing the sanity check.
     * @return empty string on success.  Or error description if there's a problem.
     */
    wxString GroupsSanityCheckInternal( bool repair );

    struct GroupLegalOpsField
    {
        bool create      : 1;
        bool ungroup     : 1;
        bool removeItems : 1;
        bool enter       : 1;
    };

    /*
     * Check which selection tool group operations are legal given the selection.
     * @return bit field of legal ops.
     */
    GroupLegalOpsField GroupLegalOps( const PCB_SELECTION& selection ) const;
};
#endif      // CLASS_BOARD_H_