schematic.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The 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 3 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, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef KICAD_SCHEMATIC_H
#define KICAD_SCHEMATIC_H
 
#include <eda_item.h>
#include <embedded_files.h>
#include <schematic_holder.h>
#include <sch_sheet_path.h>
#include <schematic_settings.h>
#include <project.h>
 
 
class BUS_ALIAS;
class CONNECTION_GRAPH;
class EDA_BASE_FRAME;
class ERC_SETTINGS;
class PROJECT;
class SCH_COMMIT;
class SCH_LINE;
class SCH_SCREEN;
class SCH_SHEET;
class SCH_SHEET_LIST;
class SCH_GLOBALLABEL;
class SCH_REFERENCE;
class PROGRESS_REPORTER;
class TOOL_MANAGER;
class PICKED_ITEMS_LIST;
 
namespace KIFONT
{
class OUTLINE_FONT;
}
 
namespace KIGFX
{
class SCH_VIEW;
}
 
 
class SCHEMATIC;
 
class SCHEMATIC_LISTENER
{
public:
    virtual ~SCHEMATIC_LISTENER() {}
    virtual void OnSchItemsAdded( SCHEMATIC& aSch, std::vector<SCH_ITEM*>& aSchItem ) {}
    virtual void OnSchItemsRemoved( SCHEMATIC& aSch, std::vector<SCH_ITEM*>& aSchItem ) {}
    virtual void OnSchItemsChanged( SCHEMATIC& aSch, std::vector<SCH_ITEM*>& aSchItem ) {}
 
    // This is called when the user changes to a new sheet, not when a sheet is altered.
    // Sheet alteration events will call OnSchItems*
    virtual void OnSchSheetChanged( SCHEMATIC& aSch ) {}
};
 
enum SCH_CLEANUP_FLAGS
{
    NO_CLEANUP,
    LOCAL_CLEANUP,
    GLOBAL_CLEANUP
};
 
class SCHEMATIC : public EDA_ITEM, public EMBEDDED_FILES, public PROJECT::_ELEM
{
public:
    SCHEMATIC( PROJECT* aPrj );
 
    virtual ~SCHEMATIC();
 
    virtual wxString GetClass() const override
    {
        return wxT( "SCHEMATIC" );
    }
 
    void Reset();
 
    PROJECT& Project() const { return *m_project; }
    void SetProject( PROJECT* aPrj );
 
    const std::map<wxString, wxString>* GetProperties() { return &m_properties; }
 
    SCH_SHEET_LIST BuildSheetListSortedByPageNumbers() const
    {
        SCH_SHEET_LIST hierarchy( m_rootSheet );
 
        hierarchy.SortByPageNumbers();
 
        return hierarchy;
    }
 
    SCH_SHEET_LIST BuildUnorderedSheetList() const
    {
        SCH_SHEET_LIST sheets;
 
        if( m_rootSheet )
            sheets.BuildSheetList( m_rootSheet, false );
 
        return sheets;
    }
 
    SCH_SHEET_LIST Hierarchy() const;
 
    void RefreshHierarchy();
 
    SCH_ITEM* ResolveItem( const KIID& aID, SCH_SHEET_PATH* aPathOut = nullptr,
                           bool aAllowNullptrReturn = false ) const
    {
        return BuildUnorderedSheetList().ResolveItem( aID, aPathOut, aAllowNullptrReturn );
    }
 
    SCH_SHEET& Root() const
    {
        return *m_rootSheet;
    }
 
    void SetRoot( SCH_SHEET* aRootSheet );
 
    bool IsValid() const
    {
        return m_rootSheet != nullptr;
    }
 
    SCH_SCREEN* RootScreen() const;
 
    void GetContextualTextVars( wxArrayString* aVars ) const;
 
    bool ResolveTextVar( const SCH_SHEET_PATH* aSheetPath, wxString* token, int aDepth ) const;
 
    wxString GetFileName() const;
 
    SCH_SHEET_PATH& CurrentSheet() const
    {
        return *m_currentSheet;
    }
 
    void SetCurrentSheet( const SCH_SHEET_PATH& aPath )
    {
        *m_currentSheet = aPath;
    }
 
    SCH_SCREEN* GetCurrentScreen() const { return CurrentSheet().LastScreen(); }
 
    CONNECTION_GRAPH* ConnectionGraph() const
    {
        return m_connectionGraph;
    }
 
    SCHEMATIC_SETTINGS& Settings() const;
 
    ERC_SETTINGS& ErcSettings() const;
 
    std::vector<SCH_MARKER*> ResolveERCExclusions();
 
    EMBEDDED_FILES* GetEmbeddedFiles() override;
    const EMBEDDED_FILES* GetEmbeddedFiles() const;
 
    std::shared_ptr<BUS_ALIAS> GetBusAlias( const wxString& aLabel ) const;
 
    std::set<wxString> GetNetClassAssignmentCandidates();
 
    bool ResolveCrossReference( wxString* token, int aDepth ) const;
 
    std::map<wxString, std::set<int>>& GetPageRefsMap() { return m_labelToPageRefsMap; }
 
    std::map<int, wxString> GetVirtualPageToSheetNamesMap() const;
    std::map<int, wxString> GetVirtualPageToSheetPagesMap() const;
 
    wxString ConvertRefsToKIIDs( const wxString& aSource ) const;
    wxString ConvertKIIDsToRefs( const wxString& aSource ) const;
 
    void SetLegacySymbolInstanceData();
 
    wxString GetUniqueFilenameForCurrentSheet();
 
    void SetSheetNumberAndCount();
 
    void RecomputeIntersheetRefs();
 
    void ClearOperatingPoints()
    {
        m_operatingPoints.clear();
    }
 
    void SetOperatingPoint( const wxString& aSignal, double aValue )
    {
        m_operatingPoints[ aSignal ] = aValue;
    }
 
    wxString GetOperatingPoint( const wxString& aNetName, int aPrecision, const wxString& aRange );
 
    void FixupJunctionsAfterImport();
 
    void BreakSegment( SCH_COMMIT* aCommit, SCH_LINE* aSegment, const VECTOR2I& aPoint, SCH_LINE** aNewSegment,
                       SCH_SCREEN* aScreen );
 
    bool BreakSegments( SCH_COMMIT* aCommit, const VECTOR2I& aPoint, SCH_SCREEN* aScreen );
 
    bool BreakSegmentsOnJunctions( SCH_COMMIT* aCommit, SCH_SCREEN* aScreen );
 
    void RecordERCExclusions();
 
    void ResolveERCExclusionsPostUpdate();
 
    void OnItemsAdded( std::vector<SCH_ITEM*>& aNewItems );
 
    void OnItemsRemoved( std::vector<SCH_ITEM*>& aRemovedItems );
 
    void OnItemsChanged( std::vector<SCH_ITEM*>& aItems );
 
    void OnSchSheetChanged();
 
    void AddListener( SCHEMATIC_LISTENER* aListener );
 
    void RemoveListener( SCHEMATIC_LISTENER* aListener );
 
    void RemoveAllListeners();
 
    void RunOnNestedEmbeddedFiles( const std::function<void( EMBEDDED_FILES* )>& aFunction ) override;
 
    void EmbedFonts() override;
 
    std::set<KIFONT::OUTLINE_FONT*> GetFonts() const override;
 
    std::set<const SCH_SCREEN*> GetSchematicsSharedByMultipleProjects() const;
 
    bool IsComplexHierarchy() const;
 
    void SetSchematicHolder( SCHEMATIC_HOLDER* aHolder ) { m_schematicHolder = aHolder; }
 
    void CleanUp( SCH_COMMIT* aCommit, SCH_SCREEN* aScreen = nullptr );
 
    void RecalculateConnections( SCH_COMMIT* aCommit, SCH_CLEANUP_FLAGS aCleanupFlags,
                                 TOOL_MANAGER* aToolManager,
                                 PROGRESS_REPORTER* aProgressReporter = nullptr,
                                 KIGFX::SCH_VIEW* aSchView = nullptr,
                                 std::function<void( SCH_ITEM* )>* aChangedItemHandler = nullptr,
                                 PICKED_ITEMS_LIST*                aLastChangeList = nullptr );
 
    void CacheExistingAnnotation();
 
    bool Contains( const SCH_REFERENCE& aRef ) const;
 
    static bool m_IsSchematicExists;
 
#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const override {}
#endif
 
    PROJECT::ELEM ProjectElementType() override { return PROJECT::ELEM::SCHEMATIC; }
 
private:
    friend class SCH_EDIT_FRAME;
 
    template <typename Func, typename... Args>
    void InvokeListeners( Func&& aFunc, Args&&... args )
    {
        for( auto&& l : m_listeners )
            ( l->*aFunc )( std::forward<Args>( args )... );
    }
 
    PROJECT* m_project;
 
    SCH_SHEET* m_rootSheet;
 
    SCH_SHEET_PATH* m_currentSheet;
 
    CONNECTION_GRAPH* m_connectionGraph;
 
    std::map<wxString, std::set<int>> m_labelToPageRefsMap;
 
    std::map<wxString, wxString>      m_properties;
 
    std::map<wxString, double>        m_operatingPoints;
 
    SCH_SHEET_LIST m_hierarchy;
 
    std::vector<SCHEMATIC_LISTENER*> m_listeners;
 
    SCHEMATIC_HOLDER* m_schematicHolder;
};
 
#endif