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, see <https://www.gnu.org/licenses/>.
 */
 
#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 <wx/filename.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>
#include <widgets/net_navigator_tree.h>
#include <map>
#include <connectivity/conn_subscription.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 SCH_DESIGN_BLOCK_PANE;
class PANEL_REMOTE_SYMBOL;
class DIALOG_BOOK_REPORTER;
class DIALOG_ERC;
class DIALOG_SYMBOL_FIELDS_TABLE;
class RESCUER;
class HIERARCHY_PANE;
class API_HANDLER_COMMON;
class API_HANDLER_LIBRARIES;
class API_HANDLER_SCH;
class DIALOG_SCHEMATIC_SETUP;
class PROGRESS_REPORTER;
class wxSearchCtrl;
class wxGenericTreeCtrl;
class BITMAP_BUTTON;
 
 
namespace SCH_CONNECTIVITY
{
class NAVIGATION_QUERY;
}

enum SCH_SEARCH_T
{
    HIGHLIGHT_PIN,
    HIGHLIGHT_SYMBOL
};
 
 
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 CreateDefaultScreens();
 
    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 HandleRemoteNetHighlight( const wxString& aNetName );
 
    void KiwayMailIn( KIWAY_MAIL_EVENT& aEvent ) override;

    void RefreshOperatingPointDisplay();

    void AutoRotateItem( SCH_SCREEN* aScreen, SCH_ITEM* aItem );

    void UpdateHierarchyNavigator( bool aRefreshNetNavigator = true, bool aClear = false );

    void UpdateLabelsHierarchyNavigator();

    void UpdateHierarchySelection();

    void UpdateDesignBlockOptions();
 
    void AddVariant();
 
    void RemoveVariant();
 
    void EditVariantDescription();
 
    void RenameVariant();
 
    void CopyVariant();

    void UpdateVariantSelectionCtrl( const wxArrayString& aVariantNames );
 
    void SetCurrentVariant( const wxString& aVariantName );

    bool ShowAddVariantDialog( wxWindow* aParent = nullptr );
 
    void onVariantSelected( wxCommandEvent& aEvent );

    void TestDanglingEnds();

    void SendSelectItemsToPcb( const std::vector<EDA_ITEM*>& aItems, bool aForce );

    void SendCrossProbeNetName( const wxString& aNetName );

    void SetCrossProbeConnection( const wxString& aName );

    void SendCrossProbeClearHighlight();
 
    const wxString& GetHighlightedConnection() const
    {
        return m_highlightedConn;
    }
 
    const wxString& GetHighlightedNetChain() const
    {
        return m_highlightedNetChain;
    }
 
    void SetHighlightedConnection( const wxString& aConnection, const NET_NAVIGATOR_ITEM_DATA* aSelection = nullptr,
                                   bool aForceNetNavigatorRefresh = false );
 
    void DirtyHighlightedConnection() { m_highlightedConnChanged = true; }
 
    void SetHighlightedNetChain( const wxString& aNetChain )
    {
        m_highlightedNetChain = aNetChain;
        if( m_schematic )
            m_schematic->SetHighlightedNetChain( aNetChain );
    }

    bool ReadyToNetlist( const wxString& aAnnotateMessage, bool* aUserCancelled = nullptr );

    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 aRegroupUnits, bool aRepairTimestamps, REPORTER& aReporter );

    int CheckAnnotate( ANNOTATION_ERROR_HANDLER aErrorHandler, ANNOTATE_SCOPE_T aAnnotateScope,
                       bool aRecursive );

    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();
    void ProjectChanged() override;

    bool SaveProject( bool aSaveAs = false );
 
    bool OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl = 0 ) override;

    bool ReloadFromDisk();
 
    void SetSchematic( SCHEMATIC* aSchematic );
 
    wxString GetCurrentFileName() const override;
 
    bool CanAcceptApiCommands() override;

    bool AskToSaveChanges();
 
    SCH_JUNCTION* AddJunction( SCH_COMMIT* aCommit, SCH_SCREEN* aScreen, const VECTOR2I& aPos );

    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 ChangeSheetFile( SCH_SHEET* aSheet, const wxString& aNewFilename,
                          bool* aClearAnnotationNewItems = nullptr,
                          bool* aIsUndoable = nullptr,
                          const wxString* aSourceSheetFilename = nullptr );

    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 UpdateHopOveredWires( SCH_ITEM* aItem );

    void SelectUnit( SCH_SYMBOL* aSymbol, int aUnit, SCH_COMMIT* aCommit = nullptr );

    void SelectBodyStyle( SCH_SYMBOL* aSymbol, int aBodyStyle, SCH_COMMIT* aCommit = nullptr );
 
    void SetAltPinFunction( SCH_PIN* aPin, const wxString& aFunction );
 
    /* Undo - redo */

    void SaveCopyInUndoList( SCH_SCREEN* aScreen, SCH_ITEM* aItemToCopy, UNDO_REDO aTypeCommand,
                             bool aAppend );

    void SaveCopyInUndoList( const PICKED_ITEMS_LIST& aItemsList, UNDO_REDO aTypeCommand,
                             bool aAppend );

    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* ResolveItem( const KIID& aId, bool aAllowNullptrReturn = false ) const override;

    void RollbackSchematicFromUndo();

    bool CreateArchiveLibrary( const wxString& aFileName );
 
    bool SaveSheetAsDesignBlock( const wxString& aLibraryName, SCH_SHEET_PATH& aSheetPath );
 
    bool SaveSelectionAsDesignBlock( const wxString& aLibraryName );
 
    bool UpdateDesignBlockFromSheet( const LIB_ID& aLibId, SCH_SHEET_PATH& aSheetPath );
 
    bool UpdateDesignBlockFromSelection( const LIB_ID& aLibId );
 
    SCH_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; }

    bool RecalculateConnections( SCH_COMMIT* aCommit, SCH_CLEANUP_FLAGS aCleanupFlags,
                                 PROGRESS_REPORTER* aProgressReporter = nullptr, bool aCleanupDone = false );
 
    // Commit source cleanup before the exporter's full connectivity rebuild.
    void PrepareForNetlist();
 
    // Refresh connectivity-dependent display state after a model rebuild.
    void RefreshConnectivity( bool aForce = false, const SCH_CONNECTIVITY::CHANGE_SET* aChanges = nullptr );

    void CommonSettingsChanged( int aFlags ) override;
 
    void UpdateNetHighlightStatus();
 
    void ShowChangedLanguage() override;
 
    void SetScreen( BASE_SCREEN* aScreen ) override;
 
    const BOX2I GetDocumentExtents( bool aIncludeAllVisible = true ) const override;
 
    void FocusOnItem( EDA_ITEM* aItem, bool aAllowScroll = true ) override;
 
    void SetSyncingSelection( bool aSet ) { m_syncingPcbToSchSelection = aSet; }
    bool IsSyncingSelection() { return m_syncingPcbToSchSelection; }

    bool SaveSymbolToSchematic( const LIB_SYMBOL& aSymbol, const KIID& aSchematicSymbolUUID );

    void RecomputeIntersheetRefs();

    void IntersheetRefUpdate( SCH_GLOBALLABEL* aItem ) override;
 
    void ShowAllIntersheetRefs( bool aShow );

    void ToggleSchematicHierarchy();

    void ToggleSearch();
 
    void ToggleProperties() override;
 
    void ToggleLibraryTree() override;
 
    void ToggleRemoteSymbolPanel();
 
 
    DIALOG_BOOK_REPORTER* GetSymbolDiffDialog();
 
    DIALOG_ERC* GetErcDialog();
    void ClearErcMarkers();
    void RefreshErcMarkers();
 
    DIALOG_SYMBOL_FIELDS_TABLE* GetSymbolFieldsTableDialog();
 
    wxGenericTreeCtrl* GetNetNavigator();
 
    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,
                              const std::vector<wxString>* aChangedNets = nullptr );
 
    void MakeNetNavigatorNode( const wxString& aNetName, wxTreeItemId aParentId,
                               const NET_NAVIGATOR_ITEM_DATA* aSelection,
                               const SCH_CONNECTIVITY::NAVIGATION_QUERY& aQuery );
 
    void SelectNetNavigatorItem( const NET_NAVIGATOR_ITEM_DATA* aSelection = nullptr );
 
    const SCH_ITEM* SelectNextPrevNetNavigatorItem( bool aNext );
 
    void ToggleNetNavigator();
    void FindNetInInspector( const wxString& aNetName );
 
    PLUGIN_ACTION_SCOPE PluginActionScope() const override
    {
        return PLUGIN_ACTION_SCOPE::SCHEMATIC;
    }
 
    void ClearToolbarControl( int aId ) override;
 
    void StartCrossProbeFlash( const std::vector<SCH_ITEM*>& aItems );

    bool ValidateNewVariantName( const wxString& aName, const wxString& aExcludeName );
 
    DECLARE_EVENT_TABLE()
 
protected:
    bool doAutoSave() override;
 
    bool canRunAutoSave() const override;

    bool interactiveOperationInProgress() const;
 
    void configureToolbars() override;
 
    void doReCreateMenuBar() override;

    void sendNetlistToCvpcb();
 
    void saveProjectSettings() override;
 
    void onCloseSymbolDiffDialog( wxCommandEvent& aEvent );
 
    void onCloseErcDialog( wxCommandEvent& aEvent );
 
    void onCloseSymbolFieldsTableDialog( wxCommandEvent& aEvent );
 
    void unitsChangeRefresh() override;
 
    void updateSelectionFilterVisbility() override;
 
    void onPluginAvailabilityChanged( wxCommandEvent& aEvt );
 
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();
 
    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, bool isSaveAs );

    void mapExistingAnnotation( std::map<wxString, wxString>& aMap );
 
    wxWindow* createHighlightedNetNavigator();
 
    void onNetNavigatorDPIChanged( wxDPIChangedEvent& aEvent );
    void onNetNavigatorFilterChanged( wxCommandEvent& aEvent );
    void onNetNavigatorKey( wxKeyEvent& aEvent );
    void onNetNavigatorItemMenu( wxTreeEvent& aEvent );
    void onNetNavigatorContextMenu( wxContextMenuEvent& aEvent );
    void onNetNavigatorMenuCommand( wxCommandEvent& aEvent );
    void showNetNavigatorMenu( const wxTreeItemId& aItem );
 
    void onNetNavigatorSelection( wxTreeEvent& aEvent );
 
    void onNetNavigatorSelChanging( wxTreeEvent& aEvent );
 
    void CaptureHierarchyPaneSize();
 
    void OnCrossProbeFlashTimer( wxTimerEvent& aEvent );
 
private:
    // The schematic editor control class should be able to access some internal
    // functions of the editor frame.
    friend class SCH_EDITOR_CONTROL;
 
    enum
    {
        ID_NET_NAVIGATOR_EXPAND_ALL = wxID_HIGHEST + 400,
        ID_NET_NAVIGATOR_COLLAPSE_ALL,
        ID_NET_NAVIGATOR_FIND_IN_INSPECTOR,
        ID_NET_NAVIGATOR_SEARCH_WILDCARD,
        ID_NET_NAVIGATOR_SEARCH_REGEX
    };
 
    void subscribeConnectivity();
    SCH_CONNECTIVITY::SUBSCRIPTION m_connectivitySubscription;
    SCHEMATIC*                  m_schematic;          
    wxString                    m_highlightedConn;    
    wxString                    m_highlightedNetChain;
 
    wxPageSetupDialogData       m_pageSetupData;
    std::vector<std::unique_ptr<SCH_ITEM>> m_items_to_repeat;  
 
    wxString                    m_netListerCommand;   
    int                         m_exec_flags;         
 
    DIALOG_ERC*                 m_ercDialog;
    DIALOG_BOOK_REPORTER*       m_diffSymbolDialog;
    HIERARCHY_PANE*             m_hierarchy;
    DIALOG_SYMBOL_FIELDS_TABLE* m_symbolFieldsTableDialog;
    DIALOG_SCHEMATIC_SETUP*     m_schematicSetupDialog;
 
 
    NET_NAVIGATOR_TREE*         m_netNavigator;
    wxSearchCtrl*               m_netNavigatorFilter;
    BITMAP_BUTTON*              m_netNavigatorMenuButton;
    wxString                    m_netNavigatorFilterValue;
    wxString                    m_netNavigatorMenuNetName;
    std::map<wxString, wxTreeItemId> m_netNavigatorNodes;
    wxString                    m_netNavigatorConnection;
    bool                        m_netNavigatorStale = true;
 
    bool                        m_syncingPcbToSchSelection; // Recursion guard when synchronizing selection from PCB
    // Cross-probe flashing support
    wxTimer                     m_crossProbeFlashTimer;   
    int                         m_crossProbeFlashPhase = 0;
    std::vector<KIID>           m_crossProbeFlashItems;   
    bool                        m_crossProbeFlashing = false;
    bool                        m_show_search;
    bool                        m_highlightedConnChanged;
 
    std::vector<wxEvtHandler*>  m_schematicChangeListeners;
 
    std::vector<LIB_ID>         m_designBlockHistoryList;
    SCH_DESIGN_BLOCK_PANE*      m_designBlocksPane;
    PANEL_REMOTE_SYMBOL*        m_remoteSymbolPane;
 
    wxChoice*                   m_currentVariantCtrl;
 
    std::unique_ptr<API_HANDLER_SCH> m_apiHandler;
    std::unique_ptr<API_HANDLER_COMMON> m_apiHandlerCommon;
    std::unique_ptr<API_HANDLER_LIBRARIES> m_apiLibrariesHandler;
};
 
 
#endif  // SCH_EDIT_FRAME_H