symbol_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) 2014 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2008 Wayne Stambaugh <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2017 CERN
 * @author Maciej Suminski <[email protected]>
 *
 * 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 SYMBOL_EDIT_FRAME_H
#define SYMBOL_EDIT_FRAME_H
 
#include <sch_base_frame.h>
#include <sch_screen.h>
#include <symbol_tree_pane.h>
#include <widgets/editor_tab_context.h>
#include <memory>
#include <optional>
#include <vector>
 
class SCH_EDIT_FRAME;
class LIB_SYMBOL;
class LIB_TREE_NODE;
class LIB_ID;
class LIB_SYMBOL_LIBRARY_MANAGER;
class SYMBOL_EDITOR_SETTINGS;
class SYMBOL_EDITOR_TAB_CONTEXT;
class EDITOR_TABS_PANEL;
class EDITOR_TABS_MODEL;
class EDA_LIST_DIALOG;
class UNDO_REDO_CONTAINER;
class API_HANDLER_COMMON;
class API_HANDLER_LIBRARIES;
class API_HANDLER_SYMBOL;
 
 
#define UNITS_ALL _HKI( "ALL" )
#define DEMORGAN_ALL _HKI( "ALL" )
#define DEMORGAN_STD _HKI( "Standard" )
#define DEMORGAN_ALT _HKI( "Alternate" )
 

enum class SAVE_LIBRARY_AS
{
    ORIGINAL,              
    NEW,                   
    PACKED,                
    UNPACKED               
};
 

class SYMBOL_EDIT_FRAME : public SCH_BASE_FRAME
{
    // Lets the headless tab tests drive the static undo/redo helpers without a full GUI frame.
    friend struct SYMBOL_EDITOR_TABS_TEST_FIXTURE;
 
public:
    SYMBOL_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent );
 
    ~SYMBOL_EDIT_FRAME() override;
 
    std::unique_ptr<GRID_HELPER> MakeGridHelper() override;

    void SwitchCanvas( EDA_DRAW_PANEL_GAL::GAL_TYPE aCanvasType ) override;

    bool IsContentModified() const override;

    bool HasLibModifications() const;
 
    bool CanCloseSymbolFromSchematic( bool doClose );
 
    LIB_TREE* GetLibTree() const override { return m_treePane->GetLibTree(); }

    EDITOR_TABS_PANEL* GetTabsPanel() const { return m_tabsPanel; }

    void OnTabCharHook( wxKeyEvent& aEvent );

    void clearSymbolTabsModifiedForLibrary( const wxString& aLibrary );

    static void clearTabModifiedState( SYMBOL_EDITOR_TAB_CONTEXT& aContext, EDITOR_TABS_MODEL& aModel );

    static void clearSymbolTabUndoRedo( SYMBOL_EDITOR_TAB_CONTEXT& aContext );

    static void freeTransientUndoCommands( UNDO_REDO_CONTAINER& aList, const LIB_SYMBOL* aLiveSymbol );

    static bool libTreeAutoHiddenForSchematicEdit( bool aWasFromSchematic, bool aRestorePending,
                                                   bool aTreeShownNow );

    LIB_ID GetTreeLIBID( int* aUnit = nullptr ) const;
 
    int GetTreeSelectionCount() const;
 
    int GetTreeLIBIDs( std::vector<LIB_ID>& aSelection ) const;

    LIB_SYMBOL* GetCurSymbol() const { return m_symbol; }

    void SetCurSymbol( LIB_SYMBOL* aSymbol, bool aUpdateZoom );
 
    LIB_SYMBOL_LIBRARY_MANAGER& GetLibManager();
 
    SELECTION& GetCurrentSelection() override;
 
    // See comments for m_SyncPinEdit.
    bool SynchronizePins();

    wxString AddLibraryFile( bool aCreateNew );

    void DdAddLibrary( wxString aLibFile );

    void CreateNewSymbol( const wxString& newName = wxEmptyString );
 
    void ImportSymbol();
    void ExportSymbol();

    void Save();

    void SaveSymbolCopyAs( bool aOpenCopy );

    void SaveLibraryAs( SAVE_LIBRARY_AS aSaveType = SAVE_LIBRARY_AS::NEW );

    void SaveAll();

    bool SaveLibraryHeadless( const wxString& aLibrary );

    void Revert( LIB_ID& aTarget, bool aConfirm = true );
    void RevertAll();
 
    void DeleteSymbolFromLibrary();

    void RenameSymbolTab( const LIB_ID& aOldId, const LIB_ID& aNewId );
 
    void CopySymbolToClipboard();
 
    void LoadSymbol( const wxString& aLibrary, const wxString& aSymbol, int Unit );

    void DuplicateSymbol( bool aFromClipboard );
 
    void OnSelectUnit( wxCommandEvent& event );
    void OnSelectBodyStyle( wxCommandEvent& event );
 
    void ToggleProperties() override;
 
    void ToggleLibraryTree() override;
    bool IsLibraryTreeShown() const override;
    void FocusLibraryTreeInput() override;
    void FreezeLibraryTree();
    void ThawLibraryTree();
 
    bool IsSyncLibrariesInProgress() const { return m_syncLibrariesInProgress; }
 
    void OnUpdateUnitNumber( wxUpdateUIEvent& event );
    void OnUpdateBodyStyle( wxUpdateUIEvent& event );
 
    void UpdateAfterSymbolProperties( wxString* aOldName = nullptr );
    void RebuildSymbolUnitAndBodyStyleLists();
 
    bool canCloseWindow( wxCloseEvent& aCloseEvent ) override;
    void doCloseWindow() override;
    void OnExitKiCad( wxCommandEvent& event );
 
    void LoadSettings( APP_SETTINGS_BASE* aCfg ) override;
    void SaveSettings( APP_SETTINGS_BASE* aCfg ) override;
 
    SYMBOL_EDITOR_SETTINGS* GetSettings() const
    {
        return m_settings;
    }
 
    APP_SETTINGS_BASE* config() const override;
 
    COLOR_SETTINGS* GetColorSettings( bool aForceRefresh = false ) const override;

    void CloseWindow( wxCommandEvent& event )
    {
        // Generate a wxCloseEvent
        Close( false );
    }

    void OnModify() override;
 
    int GetUnit() const { return m_unit; }
    void SetUnit( int aUnit );
 
    int  GetBodyStyle() const { return m_bodyStyle; }
    void SetBodyStyle( int aBodyStyle );
 
    void SetDrawSpecificUnit( bool aSpecific ) { m_drawSpecificUnit = aSpecific; }
    bool GetDrawSpecificUnit() const { return m_drawSpecificUnit; }
 
    void SetDrawSpecificBodyStyle( bool aSpecific ) { m_drawSpecificBodyStyle = aSpecific; }
    bool GetDrawSpecificBodyStyle() const { return m_drawSpecificBodyStyle; }
 
    bool GetShowInvisibleFields();
    bool GetShowInvisiblePins();
 
    void ClearMsgPanel() override
    {
        UpdateSymbolMsgPanelInfo();
    }
 
    void UpdateMsgPanel() override
    {
        UpdateSymbolMsgPanelInfo();
    }

    void UpdateTitle();
 
    bool IsSymbolFromSchematic() const
    {
        // If we've already vetted closing this window, then we have no symbol anymore
        if( m_isClosing )
            return false;
 
        return m_isSymbolFromSchematic;
    }
 
    bool IsSymbolFromLegacyLibrary() const;

    void UpdateSymbolMsgPanelInfo();
 
    // General editing
    void SaveCopyInUndoList( const wxString& aDescription, LIB_SYMBOL* aSymbol,
                             UNDO_REDO aUndoType = UNDO_REDO::LIBEDIT );
 
    void PushSymbolToUndoList( const wxString& aDescription, LIB_SYMBOL* aSymbolCopy,
                               UNDO_REDO aUndoType = UNDO_REDO::LIBEDIT );
 
    void GetSymbolFromUndoList();
    void GetSymbolFromRedoList();

    void ClearUndoORRedoList( UNDO_REDO_LIST whichList, int aItemCount = -1 ) override;

    bool LoadSymbol( const LIB_ID& aLibId, int aUnit, int aBodyStyle );

    void SVGPlotSymbol( const wxString& aFullFileName );

    void SyncLibraries( bool aShowProgress, bool aPreloadCancelled = false,
                        const wxString& aForceRefresh = wxEmptyString );

    void RefreshLibraryTree();

    void UpdateLibraryTree( const wxDataViewItem& aTreeItem, LIB_SYMBOL* aSymbol );

    LIB_ID GetTargetLibId() const override;

    std::vector<LIB_ID> GetSelectedLibIds() const;
 
    void FocusOnLibId( const LIB_ID& aLibID );

    void CommonSettingsChanged( int aFlags ) override;
 
    void ShowChangedLanguage() override;
 
    void SetScreen( BASE_SCREEN* aScreen ) override;
 
    const BOX2I GetDocumentExtents( bool aIncludeAllVisible = true ) const override;
 
    void RebuildView();
 
    void UpdateItem( EDA_ITEM* aItem, bool isAddOrDelete = false,
                     bool aUpdateRtree = false ) override;

    void HardRedraw() override;
 
    void KiwayMailIn( KIWAY_MAIL_EVENT& mail ) override;
 
    void FocusOnItem( EDA_ITEM* aItem, bool aAllowScroll = true ) override;

    void LoadSymbolFromSchematic( SCH_SYMBOL* aSymbol );

    bool IsSymbolEditable() const;

    bool IsSymbolGraphicallyEditable() const;
 
    bool IsSymbolAlias() const;

    bool IsCurrentSymbol( const LIB_ID& aLibId ) const;

    void emptyScreen();
 
    void ClearToolbarControl( int aId ) override;
 
protected:
    void configureToolbars() override;
    void setupUIConditions() override;
 
    void doReCreateMenuBar() override;
 
    PLUGIN_ACTION_SCOPE PluginActionScope() const override
    {
        return PLUGIN_ACTION_SCOPE::SYMBOL;
    }
 
    void updateSelectionFilterVisbility() override;
 
    void onPluginAvailabilityChanged( wxCommandEvent& aEvt );
 
private:
    // Set up the tool framework
    void setupTools();
 
    void updateInfoBar();
 
    void saveSymbolCopyAs( bool aOpenCopy );

    bool saveLibrary( const wxString& aLibrary,  SAVE_LIBRARY_AS aSaveType = SAVE_LIBRARY_AS::ORIGINAL );

    bool LoadSymbolFromLib( const wxString& aLibName, const wxString& aSymbolName, int aUnit = 0,  int aBodyStyle = 0 );

    bool LoadOneLibrarySymbol( LIB_SYMBOL* aLibEntry, const wxString& aLibrary, int aUnit, int aBodyStyle );

    bool backupLibrary( const wxFileName& aOriginalFile, wxString& aErrorMsg );

    LIB_SYMBOL* getTargetSymbol() const;

    wxString getTargetLib() const;
 
    void centerItemIdleHandler( wxIdleEvent& aEvent );

    bool saveAllLibraries( bool aRequireConfirmation );

    bool saveCurrentSymbol();

    void ensureUniqueName( LIB_SYMBOL* aSymbol, const wxString& aLibrary );

    bool addLibTableEntry( const wxString& aLibFile,
                           LIBRARY_TABLE_SCOPE aScope = LIBRARY_TABLE_SCOPE::GLOBAL );

    bool replaceLibTableEntry( const wxString& aLibNickname, const wxString& aLibFile );

    void detachActiveSymbolTab();

    void activateSymbolTab( SYMBOL_EDITOR_TAB_CONTEXT* aContext );

    SYMBOL_EDITOR_TAB_CONTEXT* findOrCreateSymbolTab( const wxString& aLib, const wxString& aName,
                                                      int aUnit, int aBodyStyle, bool aAsPreview,
                                                      bool* aWasCreated = nullptr );

    SYMBOL_EDITOR_TAB_CONTEXT* findOrCreateSymbolInstanceTab( LIB_SYMBOL* aSymbol, SCH_SCREEN* aScreen,
                                                              const KIID&     aSchematicSymbolUUID,
                                                              const wxString& aReference, int aUnit,
                                                              int aBodyStyle );

    SYMBOL_EDITOR_TAB_CONTEXT* CreateUnsavedSymbolTab( LIB_SYMBOL* aSymbol, SCH_SCREEN* aScreen );

    SYMBOL_EDITOR_TAB_CONTEXT* symbolTabContextForIndex( int aIdx ) const;

    SYMBOL_EDITOR_TAB_CONTEXT* symbolTabContextForKey( const wxString& aKey ) const;

    void dropSymbolTabContext( const wxString& aKey );

    bool promptAndCloseSymbolTab( int aIdx );

    bool promptToSaveInactiveInstanceTabs();

    bool hasDirtyInactiveInstanceTabs() const;

    void closeAllSymbolTabsSilently();

    void closeSymbolTab( const LIB_ID& aLibId );

    EDITOR_TAB_CONTEXT::VIEW_SNAPSHOT captureSymbolViewSnapshot() const;

    void restoreSymbolViewSnapshot( const EDITOR_TAB_CONTEXT::VIEW_SNAPSHOT& aSnapshot );

    std::vector<KIID> captureSymbolSelectionKiids() const;

    void restoreSymbolSelectionKiids( const std::vector<KIID>& aKiids );

    void restoreSymbolTabsFromSettings();

    void storeSymbolTabsToSettings();
 
    DECLARE_EVENT_TABLE()
 
public:
private:
    SCH_SCREEN*         m_dummyScreen;
 
    LIB_SYMBOL*         m_symbol;                // a symbol I own, it is not in any library, but a copy could be.
    wxComboBox*         m_unitSelectBox;         // a ComboBox to select a unit to edit (if the
                                                 //   symbol has multiple units)
    wxComboBox*         m_bodyStyleSelectBox;    // a ComboBox to select a body style to edit (if the symbol has
                                                 //   multiple body styles)
    SYMBOL_TREE_PANE*           m_treePane;      // symbol search tree widget
    LIB_SYMBOL_LIBRARY_MANAGER* m_libMgr;        // manager taking care of temporary modifications
    SYMBOL_EDITOR_SETTINGS*     m_settings;      // Handle to the settings
 
    // Tabbed editing. One context per open symbol, owning a working symbol/screen copy plus its
    // per-tab undo/redo and view/selection snapshot. The active tab lends its objects to the frame
    // and reclaims them on detach. m_activeTab is the context currently bound to the frame.
    std::vector<std::unique_ptr<SYMBOL_EDITOR_TAB_CONTEXT>> m_tabContexts;
    SYMBOL_EDITOR_TAB_CONTEXT*                              m_activeTab = nullptr;
    EDITOR_TABS_PANEL*                                      m_tabsPanel = nullptr;
 
    // Guards against re-entering tab activation while a tab is being created or restored, since
    // AddTab() activates synchronously.
    bool m_loadingSymbolTab = false;

    bool m_silentSymbolTabClose = false;
 
    LIB_ID                      m_centerItemOnIdle;

    int         m_unit;

    int         m_bodyStyle;

    bool        m_drawSpecificUnit;

    bool        m_drawSpecificBodyStyle;

    bool        m_isSymbolFromSchematic;

    bool        m_libTreeAutoHiddenForSchematicEdit;
 
    KIID        m_schematicSymbolUUID;

    wxString    m_reference;
 
    // True to force DeMorgan/normal tools selection enabled.
    // They are enabled when the loaded symbol has graphic items for converted shape
    // But under some circumstances (New symbol created) these tools must left enabled
    static bool m_showDeMorgan;
 
    // Guard against re-entrant SyncLibraries calls.  The progress dialog used during sync
    // yields the event loop, which can dispatch queued UI events (e.g. menu clicks that
    // accumulated while the app was busy).  Without this guard, opening the symbol library
    // table dialog from within an active SyncLibraries call corrupts the library tree.
    bool        m_syncLibrariesInProgress;
 
    std::unique_ptr<API_HANDLER_SYMBOL>    m_apiHandler;
    std::unique_ptr<API_HANDLER_COMMON>    m_apiHandlerCommon;
    std::unique_ptr<API_HANDLER_LIBRARIES> m_apiLibrariesHandler;
};
 
#endif  // SYMBOL_EDIT_FRAME_H