sch_edit_frame.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015 Jean-Pierre Charras, jp.charras wanadoo.fr
 * Copyright (C) 2008 Wayne Stambaugh <[email protected]>
 * Copyright (C) 2023 CERN (www.cern.ch)
 * 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 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  SCH_EDIT_FRAME_H
#define  SCH_EDIT_FRAME_H
 
#include <stddef.h>
#include <vector>
#include <wx/cmndata.h>
#include <wx/event.h>
#include <wx/gdicmn.h>
#include <wx/string.h>
#include <wx/treectrl.h>
#include <wx/utils.h>
 
#include <core/typeinfo.h>
#include <eda_base_frame.h>
#include <eeschema_settings.h>
#include <math/box2.h>
#include <sch_base_frame.h>
#include <template_fieldnames.h>
 
class SCH_ITEM;
class EDA_ITEM;
class SCH_LINE;
class SCH_TEXT;
class SCH_BITMAP;
class SCH_SHEET;
class SCH_SHEET_PATH;
class SCH_SHEET_PIN;
class SCH_SYMBOL;
class SCH_FIELD;
class SCH_JUNCTION;
class SCHEMATIC;
class SCH_COMMIT;
class DESIGN_BLOCK;
class DESIGN_BLOCK_PANE;
class DIALOG_BOOK_REPORTER;
class DIALOG_ERC;
class DIALOG_SYMBOL_FIELDS_TABLE;
class DIALOG_SCH_FIND;
class RESCUER;
class HIERARCHY_PANE;
class API_HANDLER_SCH;
class DIALOG_SCHEMATIC_SETUP;
 
 
enum SCH_SEARCH_T
{
    HIGHLIGHT_PIN,
    HIGHLIGHT_SYMBOL
};
 
 
enum SCH_CLEANUP_FLAGS
{
    NO_CLEANUP,
    LOCAL_CLEANUP,
    GLOBAL_CLEANUP
};
 
 
wxDECLARE_EVENT( EDA_EVT_SCHEMATIC_CHANGING, wxCommandEvent );
wxDECLARE_EVENT( EDA_EVT_SCHEMATIC_CHANGED, wxCommandEvent );
 
 
class NET_NAVIGATOR_ITEM_DATA : public wxTreeItemData
{
public:
    NET_NAVIGATOR_ITEM_DATA( const SCH_SHEET_PATH& aSheetPath, const SCH_ITEM* aItem ) :
        m_sheetPath( aSheetPath ),
        m_item( aItem )
    {
    }
 
    NET_NAVIGATOR_ITEM_DATA() :
        m_item( nullptr )
    {
    }
 
    SCH_SHEET_PATH& GetSheetPath() { return m_sheetPath; }
    const SCH_ITEM* GetItem() const { return m_item; }
 
    bool operator==( const NET_NAVIGATOR_ITEM_DATA& aRhs ) const
    {
        return ( m_sheetPath == aRhs.m_sheetPath ) && ( m_item == aRhs.m_item );
    }
 
    NET_NAVIGATOR_ITEM_DATA& operator=( const NET_NAVIGATOR_ITEM_DATA& aItemData )
    {
        if( this == &aItemData )
            return *this;
 
        m_sheetPath = aItemData.m_sheetPath;
        m_item = aItemData.m_item;
 
        return *this;
    }
 
private:
    SCH_SHEET_PATH m_sheetPath;
    const SCH_ITEM* m_item;
};
 
 
class SCH_EDIT_FRAME : public SCH_BASE_FRAME
{
public:
    SCH_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent );
    ~SCH_EDIT_FRAME() override;
 
    SCH_SCREEN* GetScreen() const override;
 
    SELECTION& GetCurrentSelection() override;
 
    SCHEMATIC& Schematic() const;
 
    std::unique_ptr<GRID_HELPER> MakeGridHelper() override;
 
    bool GetShowAllPins() const override;
 
    void SaveProjectLocalSettings() override;
 
    bool LoadProjectSettings();
 
    void LoadDrawingSheet();
 
    void ShowSchematicSetupDialog( const wxString& aInitialPage = wxEmptyString );
 
    void LoadSettings( APP_SETTINGS_BASE* aCfg ) override;
    void SaveSettings( APP_SETTINGS_BASE* aCfg ) override;
 
    void CreateScreens();
 
    void setupUIConditions() override;
 
    bool IsContentModified() const override;
 
    void OnModify() override;
 
    SEVERITY GetSeverity( int aErrorCode ) const override;
 
    wxString GetScreenDesc() const override;
    wxString GetFullScreenDesc() const override;
 
    void ExecuteRemoteCommand( const char* cmdline ) override;
 
    void KiwayMailIn( KIWAY_EXPRESS& aEvent ) override;
 
    void RefreshOperatingPointDisplay();
 
    void AutoRotateItem( SCH_SCREEN* aScreen, SCH_ITEM* aItem );
 
    void ShowFindReplaceDialog( bool aReplace );
 
    void UpdateHierarchyNavigator( bool aRefreshNetNavigator = true, bool aClear = false );
 
    void UpdateLabelsHierarchyNavigator();
 
    void UpdateHierarchySelection();
 
    void ShowFindReplaceStatus( const wxString& aMsg, int aStatusTime );
    void ClearFindReplaceStatus();
 
    void OnFindDialogClose();
 
    void UpdateDesignBlockOptions();
 
    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 TestDanglingEnds();
 
    void SendSelectItemsToPcb( const std::vector<EDA_ITEM*>& aItems, bool aForce );
 
    void SendCrossProbeNetName( const wxString& aNetName );
 
    void SetCrossProbeConnection( const SCH_CONNECTION* aConnection );
 
    void SendCrossProbeClearHighlight();
 
    const wxString& GetHighlightedConnection() const
    {
        return m_highlightedConn;
    }
 
    void SetHighlightedConnection( const wxString& aConnection,
                                   const NET_NAVIGATOR_ITEM_DATA* aSelection = nullptr );
 
    bool ReadyToNetlist( const wxString& aAnnotateMessage );
 
    bool WriteNetListFile( int aFormat, const wxString& aFullFileName, unsigned aNetlistOptions,
                           REPORTER* aReporter = nullptr );
 
    void DeleteAnnotation( ANNOTATE_SCOPE_T aAnnotateScope, bool aRecursive, REPORTER& aReporter );
 
    void AnnotateSymbols( SCH_COMMIT* aCommit, ANNOTATE_SCOPE_T aAnnotateScope,
                          ANNOTATE_ORDER_T aSortOption, ANNOTATE_ALGO_T aAlgoOption,
                          bool aRecursive, int aStartNumber, bool aResetAnnotation,
                          bool aRepairTimestamps, REPORTER& aReporter );
 
    int CheckAnnotate( ANNOTATION_ERROR_HANDLER aErrorHandler,
                       ANNOTATE_SCOPE_T         aAnnotateScope = ANNOTATE_ALL,
                       bool                     aRecursive = true );
 
    int ModalAnnotate( const wxString& aMessage );
 
    // Functions used for hierarchy handling
    SCH_SHEET_PATH& GetCurrentSheet() const;
 
    void SetCurrentSheet( const SCH_SHEET_PATH& aSheet );
 
    void UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete = false,
                     bool aUpdateRtree = false ) override;
 
    void HardRedraw() override;
 
    void DisplayCurrentSheet();
 
    void DrawCurrentSheetToClipboard();
 
    void OnPageSettingsChange() override;
 
    void SetSheetNumberAndCount();
 
    wxPageSetupDialogData& GetPageSetupData() { return m_pageSetupData; }
 
    void NewProject();
    void LoadProject();
 
    bool SaveProject( bool aSaveAs = false );
 
    bool OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl = 0 ) override;
 
    wxString GetCurrentFileName() const override;
 
    bool AskToSaveChanges();
 
    SCH_JUNCTION* AddJunction( SCH_COMMIT* aCommit, SCH_SCREEN* aScreen, const VECTOR2I& aPos );
 
    void SchematicCleanUp( SCH_COMMIT* aCommit, SCH_SCREEN* aScreen = nullptr );
 
    bool TrimWire( SCH_COMMIT* aCommit, const VECTOR2I& aStart, const VECTOR2I& aEnd );
 
    void OnOpenPcbnew();
    void OnOpenCvpcb();
    void OnUpdatePCB();
    void OnAnnotate();
 
    bool CheckSheetForRecursion( SCH_SHEET* aSheet, SCH_SHEET_PATH* aCurrentSheet );
 
    bool AllowCaseSensitiveFileNameClashes( const wxString& aOldName,
                                            const wxString& aSchematicFileName );
 
    bool EditSheetProperties( SCH_SHEET* aSheet, SCH_SHEET_PATH* aHierarchy,
                              bool* aIsUndoable = nullptr, bool* aClearAnnotationNewItems = nullptr,
                              bool* aUpdateHierarchyNavigator = nullptr,
                              wxString* aSourceSheetFilename = nullptr );
 
    void InitSheet( SCH_SHEET* aSheet, const wxString& aNewFilename );
 
    bool LoadSheetFromFile( SCH_SHEET* aSheet, SCH_SHEET_PATH* aCurrentSheet,
                            const wxString& aFileName, bool aSkipRecursionCheck = false,
                            bool aSkipLibCheck = false );
 
    void DeleteJunction( SCH_COMMIT* aCommit, SCH_ITEM* aItem );
 
    void FlipBodyStyle( SCH_SYMBOL* aSymbol );
 
    void SelectUnit( SCH_SYMBOL* aSymbol, int aUnit );
 
    void SetAltPinFunction( SCH_PIN* aPin, const wxString& aFunction );
 
    /* Undo - redo */
 
    void SaveCopyInUndoList( SCH_SCREEN* aScreen, SCH_ITEM* aItemToCopy, UNDO_REDO aTypeCommand,
                             bool aAppend, bool aDirtyConnectivity = true );
 
    void SaveCopyInUndoList( const PICKED_ITEMS_LIST& aItemsList, UNDO_REDO aTypeCommand,
                             bool aAppend, bool aDirtyConnectivity = true );
 
    void PutDataInPreviousState( PICKED_ITEMS_LIST* aList );
 
    void ClearUndoORRedoList( UNDO_REDO_LIST whichList, int aItemCount = -1 ) override;
 
    void SaveCopyForRepeatItem( const SCH_ITEM* aItem );
    void AddCopyForRepeatItem( const SCH_ITEM* aItem );
 
    const std::vector<std::unique_ptr<SCH_ITEM>>& GetRepeatItems() const
    {
        return m_items_to_repeat;
    }
 
    void ClearRepeatItemsList()
    {
        m_items_to_repeat.clear();
    }
 
    EDA_ITEM* GetItem( const KIID& aId ) const override;
 
    void RollbackSchematicFromUndo();
 
    bool CreateArchiveLibrary( const wxString& aFileName );
 
    wxString CreateNewDesignBlockLibrary( const wxString& aLibName = wxEmptyString,
                                          const wxString& aProposedName = wxEmptyString );
 
    bool AddDesignBlockLibrary( const wxString& aFilename, DESIGN_BLOCK_LIB_TABLE* aTable );
 
    void SaveSheetAsDesignBlock( const wxString& aLibraryName, SCH_SHEET_PATH& aSheetPath );
 
    void SaveSelectionAsDesignBlock( const wxString& aLibraryName );
 
    bool DeleteDesignBlockLibrary( const wxString& aLibName, bool aConfirm );
 
    bool DeleteDesignBlockFromLibrary( const LIB_ID& aLibId, bool aConfirm );
 
    bool EditDesignBlockProperties( const LIB_ID& aLibId );
 
 
    DESIGN_BLOCK* GetDesignBlock( const LIB_ID& aLibId, bool aUseCacheLib = false,
                                  bool aShowErrorMsg = false );
 
    DESIGN_BLOCK_PANE* GetDesignBlockPane() const { return m_designBlocksPane; }
 
    void SetNetListerCommand( const wxString& aCommand ) { m_netListerCommand = aCommand; }
 
    void DefaultExecFlags() { m_exec_flags = wxEXEC_SYNC; }
 
    void SetExecFlags( const int aFlags ) { m_exec_flags |= aFlags; }
 
    void ClearExecFlags( const int aFlags ) { m_exec_flags &= ~( aFlags ); }
 
    wxString GetNetListerCommand() const { return m_netListerCommand; }
 
    void RecalculateConnections( SCH_COMMIT* aCommit, SCH_CLEANUP_FLAGS aCleanupFlags );
 
    void CommonSettingsChanged( int aFlags ) override;
 
    void UpdateNetHighlightStatus();
 
    void ShowChangedLanguage() override;
 
    void SetScreen( BASE_SCREEN* aScreen ) override;
 
    const BOX2I GetDocumentExtents( bool aIncludeAllVisible = true ) const override;
 
    int GetSchematicJunctionSize();
 
    void FocusOnItem( SCH_ITEM* aItem );
 
    bool IsSyncingSelection() { return m_syncingPcbToSchSelection; }
 
    void SaveSymbolToSchematic( const LIB_SYMBOL& aSymbol, const KIID& aSchematicSymbolUUID );
 
    void RecomputeIntersheetRefs();
 
    void ShowAllIntersheetRefs( bool aShow );
 
    virtual void CheckForAutoSaveFile( const wxFileName& aFileName ) override;
 
    virtual void DeleteAutoSaveFile( const wxFileName& aFileName ) override;
 
    void ToggleSchematicHierarchy();
 
    void ToggleSearch();
 
    void ToggleProperties() override;
 
    void ToggleLibraryTree() override;
 
    DIALOG_BOOK_REPORTER* GetSymbolDiffDialog();
 
    DIALOG_ERC* GetErcDialog();
 
    DIALOG_SYMBOL_FIELDS_TABLE* GetSymbolFieldsTableDialog();
 
    wxTreeCtrl* GetNetNavigator() { return m_netNavigator; }
 
    const SCH_ITEM* GetSelectedNetNavigatorItem() const;
 
    static const wxString SchematicHierarchyPaneName()
    {
        return wxT( "SchematicHierarchy" );
    }
 
    static const wxString SearchPaneName() { return wxT( "Search" ); }
 
    bool IsSearchPaneShown() { return m_auimgr.GetPane( SearchPaneName() ).IsShown(); }
 
    void FocusSearch();
 
    void AddSchematicChangeListener( wxEvtHandler* aListener );
 
    void RemoveSchematicChangeListener( wxEvtHandler* aListener );
 
    static const wxString NetNavigatorPaneName()
    {
        return wxS( "NetNavigator" );
    }
 
    void RefreshNetNavigator( const NET_NAVIGATOR_ITEM_DATA* aSelection = nullptr );
 
    void MakeNetNavigatorNode( const wxString& aNetName, wxTreeItemId aParentId,
                               const NET_NAVIGATOR_ITEM_DATA* aSelection,
                               bool aSingleSheetSchematic );
 
    void SelectNetNavigatorItem( const NET_NAVIGATOR_ITEM_DATA* aSelection = nullptr );
 
    const SCH_ITEM* SelectNextPrevNetNavigatorItem( bool aNext );
 
    void ToggleNetNavigator();
 
    PLUGIN_ACTION_SCOPE PluginActionScope() const override
    {
        return PLUGIN_ACTION_SCOPE::SCHEMATIC;
    }
 
    DECLARE_EVENT_TABLE()
 
protected:
    bool doAutoSave() override;
 
    void configureToolbars() override;
 
    void doReCreateMenuBar() override;
 
    void sendNetlistToCvpcb();
 
    void onSize( wxSizeEvent& aEvent );
 
    void saveProjectSettings() override;
 
    void onCloseSymbolDiffDialog( wxCommandEvent& aEvent );
 
    void onCloseErcDialog( wxCommandEvent& aEvent );
 
    void onCloseSymbolFieldsTableDialog( wxCommandEvent& aEvent );
 
    void unitsChangeRefresh() override;
 
    void updateSelectionFilterVisbility() override;
 
#ifdef KICAD_IPC_API
    void onPluginAvailabilityChanged( wxCommandEvent& aEvt );
#endif
 
    DESIGN_BLOCK_LIB_TABLE* selectDesignBlockLibTable( bool aOptional = false );
 
    wxString createNewDesignBlockLibrary( const wxString& aLibName, const wxString& aProposedName,
                                          DESIGN_BLOCK_LIB_TABLE* aTable );
 
private:
    // Called when resizing the Hierarchy Navigator panel
    void OnResizeHierarchyNavigator( wxSizeEvent& aEvent );
 
    void onResizeNetNavigator( wxSizeEvent& aEvent );
 
    // Sets up the tool framework
    void setupTools();
 
    void OnExit( wxCommandEvent& event );
 
    void OnLoadFile( wxCommandEvent& event );
    void OnImportProject( wxCommandEvent& event );
 
    void OnClearFileHistory( wxCommandEvent& aEvent );
 
    bool canCloseWindow( wxCloseEvent& aCloseEvent ) override;
    void doCloseWindow() override;
 
    void updateTitle();
 
    void initScreenZoom();
 
    bool checkForNoFullyDefinedLibIds( SCH_SHEET* aSheet );
 
    bool importFile( const wxString& aFileName, int aFileType,
                     const std::map<std::string, UTF8>* aProperties = nullptr );
 
    bool saveSchematicFile( SCH_SHEET* aSheet, const wxString& aSavePath );
 
    void mapExistingAnnotation( std::map<wxString, wxString>& aMap );
 
    bool updateAutoSaveFile();
 
    const wxString& getAutoSaveFileName() const;
 
    wxTreeCtrl* createHighlightedNetNavigator();
 
    void onNetNavigatorSelection( wxTreeEvent& aEvent );
 
    void onNetNavigatorSelChanging( wxTreeEvent& aEvent );
 
    void CaptureHierarchyPaneSize();
 
private:
    // The schematic editor control class should be able to access some internal
    // functions of the editor frame.
    friend class SCH_EDITOR_CONTROL;
    friend class SCH_FIND_REPLACE_TOOL;
 
    SCHEMATIC*              m_schematic;          
    wxString                m_highlightedConn;    
 
    wxPageSetupDialogData   m_pageSetupData;
    std::vector<std::unique_ptr<SCH_ITEM>> m_items_to_repeat;  
 
    wxString                m_netListerCommand;   
    int                     m_exec_flags;         
 
    DIALOG_SCH_FIND*        m_findReplaceDialog;
    DIALOG_ERC*             m_ercDialog;
    DIALOG_BOOK_REPORTER*   m_diffSymbolDialog;
    HIERARCHY_PANE*         m_hierarchy;
    DIALOG_SYMBOL_FIELDS_TABLE* m_symbolFieldsTableDialog;
    DIALOG_SCHEMATIC_SETUP*     m_schematicSetupDialog;
 
 
    wxTreeCtrl*             m_netNavigator;
 
    bool m_syncingPcbToSchSelection; // Recursion guard when synchronizing selection from PCB
 
    bool m_show_search;
 
    bool m_highlightedConnChanged;
 
    std::vector<wxEvtHandler*> m_schematicChangeListeners;
 
    std::vector<LIB_ID> m_designBlockHistoryList;
 
    DESIGN_BLOCK_PANE* m_designBlocksPane;
 
#ifdef KICAD_IPC_API
    std::unique_ptr<API_HANDLER_SCH> m_apiHandler;
#endif
};
 
 
#endif  // SCH_EDIT_FRAME_H