eda_base_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) 2009-2015 Jean-Pierre Charras, jp.charras wanadoo.fr
 * Copyright (C) 2011 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  EDA_BASE_FRAME_H_
#define  EDA_BASE_FRAME_H_
 
 
#include <functional>
#include <map>
#include <optional>
#include <string>
#include <vector>
 
#include <memory>
#include <nlohmann/json_fwd.hpp>
 
#include <wx/aui/aui.h>
#include <wx/datetime.h>
#include <layer_ids.h>
#include <frame_type.h>
#include <hotkeys_basic.h>
#include <kiway_holder.h>
#include <tool/tools_holder.h>
#include <widgets/ui_common.h>
#include <widgets/wx_infobar_message_type.h>
#include <undo_redo_container.h>
#include <units_provider.h>
#include <origin_transforms.h>
#include <ui_events.h>
 
// Option for main frames
#define KICAD_DEFAULT_DRAWFRAME_STYLE wxDEFAULT_FRAME_STYLE | wxWANTS_CHARS
 
 
#define VIEWER3D_FRAMENAME wxT( "Viewer3DFrameName" )
#define QUALIFIED_VIEWER3D_FRAMENAME( parent ) \
                    ( wxString( VIEWER3D_FRAMENAME ) + wxT( ":" ) + parent->GetName() )
 
#define KICAD_MANAGER_FRAME_NAME   wxT( "KicadFrame" )
 
 
class wxChoice;
class wxEvent;
class wxFileName;
class EDA_ITEM;
class EDA_DRAW_PANEL_GAL;
class EDA_MSG_PANEL;
class BASE_SCREEN;
class PAGE_INFO;
class PLOTTER;
class TITLE_BLOCK;
class MSG_PANEL_ITEM;
class TOOL_MANAGER;
class TOOL_DISPATCHER;
class ACTIONS;
class PAGED_DIALOG;
class DIALOG_EDIT_LIBRARY_TABLES;
class PANEL_HOTKEYS_EDITOR;
class FILE_HISTORY;
class SETTINGS_MANAGER;
class SEARCH_STACK;
class APP_SETTINGS_BASE;
class APPEARANCE_CONTROLS_3D;
struct WINDOW_SETTINGS;
struct WINDOW_STATE;
class ACTION_MENU;
class ACTION_TOOLBAR;
class ACTION_TOOLBAR_CONTROL;
class TOOL_INTERACTIVE;
class TOOLBAR_SETTINGS;
class WX_INFOBAR;
 
using ACTION_TOOLBAR_CONTROL_FACTORY = std::function<void( ACTION_TOOLBAR* )>;
 
#define DEFAULT_MAX_UNDO_ITEMS 0
#define ABS_MAX_UNDO_ITEMS (INT_MAX / 2)

typedef std::function< void( wxUpdateUIEvent& ) > UIUpdateHandler;
 

class EDA_BASE_FRAME : public wxFrame, public TOOLS_HOLDER, public KIWAY_HOLDER,
                       public UNITS_PROVIDER
{
public:
    enum UNDO_REDO_LIST
    {
        UNDO_LIST,
        REDO_LIST
    };
 
    EDA_BASE_FRAME( wxWindow* aParent, FRAME_T aFrameType, const wxString& aTitle,
                    const wxPoint& aPos, const wxSize& aSize, long aStyle,
                    const wxString& aFrameName, KIWAY* aKiway, const EDA_IU_SCALE& aIuScale );
 
    ~EDA_BASE_FRAME();
 
    void ChangeUserUnits( EDA_UNITS aUnits );
 
    virtual void ToggleUserUnits() { }

    ORIGIN_TRANSFORMS& GetOriginTransforms() override
    {
        return m_originTransforms;
    }
 
 
    SETTINGS_MANAGER* GetSettingsManager() const { return m_settingsManager; }
 
    virtual SEVERITY GetSeverity( int aErrorCode ) const { return RPT_SEVERITY_UNDEFINED; }

    bool ProcessEvent( wxEvent& aEvent ) override;

    virtual void OnCharHook( wxKeyEvent& aKeyEvent );

    void OnMenuEvent( wxMenuEvent& event );

    virtual void RegisterUIUpdateHandler( int aID, const ACTION_CONDITIONS& aConditions ) override;

    virtual void UnregisterUIUpdateHandler( int aID ) override;

    static void HandleUpdateUIEvent( wxUpdateUIEvent& aEvent, EDA_BASE_FRAME* aFrame,
                                     ACTION_CONDITIONS& aCond );
 
    virtual void OnMove( wxMoveEvent& aEvent )
    {
        aEvent.Skip();
    }
 
    virtual void OnSize( wxSizeEvent& aEvent );

    void SelectToolbarAction( const TOOL_ACTION& aAction );
 
    void OnMaximize( wxMaximizeEvent& aEvent );
 
    int GetAutoSaveInterval() const;
 
    bool IsType( FRAME_T aType ) const { return m_ident == aType; }
    FRAME_T GetFrameType() const { return m_ident; }

    virtual const SEARCH_STACK& sys_search();
 
    virtual wxString help_name();
 
    // Event handlers for menu events generated by the macOS application menu
    void OnKicadAbout( wxCommandEvent& event );
    void OnPreferences( wxCommandEvent& event );

    void ShowPreferences( wxString aStartPage, wxString aStartParentPage );
 
    void PrintMsg( const wxString& text );
 
    void CreateInfoBar();
 
    void RestoreAuiLayout();
 
    void FinishAUIInitialization();

    WX_INFOBAR* GetInfoBar() { return m_infoBar; }

    void ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton = false,
                           INFOBAR_MESSAGE_TYPE aType = INFOBAR_MESSAGE_TYPE::GENERIC );

    void ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton,
                           std::function<void(void)> aCallback );

    void ShowInfoBarWarning( const wxString& aWarningMsg, bool aShowCloseButton = false );

    void ShowInfoBarMsg( const wxString& aMsg, bool aShowCloseButton = false );

    virtual APP_SETTINGS_BASE* config() const;
 
    void LoadWindowState( const wxString& aFileName );

    void LoadWindowSettings( const WINDOW_SETTINGS* aCfg );

    void SaveWindowSettings( WINDOW_SETTINGS* aCfg );

    virtual void LoadSettings( APP_SETTINGS_BASE* aCfg );

    virtual void SaveSettings( APP_SETTINGS_BASE* aCfg );

    virtual WINDOW_SETTINGS* GetWindowSettings( APP_SETTINGS_BASE* aCfg );

    virtual void LoadWindowState( const WINDOW_STATE& aState );

    wxString ConfigBaseName() override
    {
        wxString baseCfgName = m_configName.IsEmpty() ? GetName() : m_configName;
        return baseCfgName;
    }

    virtual void SaveProjectLocalSettings() {};

    void ImportHotkeyConfigFromFile( std::map<std::string, TOOL_ACTION*> aActionMap,
                                     const wxString& aDefaultShortname );

    wxString GetFileFromHistory( int cmdId, const wxString& type,
                                 FILE_HISTORY* aFileHistory = nullptr );

    virtual void ClearFileHistory();

    void UpdateFileHistory( const wxString& FullFileName, FILE_HISTORY* aFileHistory = nullptr );

    FILE_HISTORY& GetFileHistory()
    {
        return *m_fileHistory;
    }
 
    void SetMruPath( const wxString& aPath ) { m_mruPath = aPath; }
 
    wxString GetMruPath() const { return m_mruPath; }

    virtual wxString GetCurrentFileName() const { return wxEmptyString; }
 
    virtual void RecreateToolbars();

    void OnToolbarSizeChanged();

    virtual void UpdateToolbarControlSizes();

    void RegisterCustomToolbarControlFactory( const ACTION_TOOLBAR_CONTROL& aControlDesc,
                                              const ACTION_TOOLBAR_CONTROL_FACTORY& aControlFactory );

    ACTION_TOOLBAR_CONTROL_FACTORY* GetCustomToolbarControlFactory( const std::string& aName );

    void ReCreateMenuBar();

    void AddStandardHelpMenu( wxMenuBar* aMenuBar );
 
    wxString GetRunMenuCommandDescription( const TOOL_ACTION& aAction );

    bool IsWritable( const wxFileName& aFileName, bool aVerbose = true );

    virtual void UpdateStatusBar() { }

    void ShowChangedLanguage() override;

    void CommonSettingsChanged( int aFlags ) override;

    virtual void ThemeChanged();

    virtual void ProjectChanged() {}
 
    wxString GetAboutTitle() const { return wxGetTranslation( m_aboutTitle ); }
 
    const wxString& GetUntranslatedAboutTitle() const { return m_aboutTitle; }

    virtual bool IsContentModified() const;

    wxSize GetWindowSize();

    virtual void ClearUndoORRedoList( UNDO_REDO_LIST aList, int aItemCount = -1 )
    { }

    virtual void ClearUndoRedoList();

    virtual void PushCommandToUndoList( PICKED_ITEMS_LIST* aItem );

    virtual void PushCommandToRedoList( PICKED_ITEMS_LIST* aItem );

    virtual PICKED_ITEMS_LIST* PopCommandFromUndoList();

    virtual PICKED_ITEMS_LIST* PopCommandFromRedoList();
 
    virtual int GetUndoCommandCount() const { return m_undoList.m_CommandsList.size(); }
    virtual int GetRedoCommandCount() const { return m_redoList.m_CommandsList.size(); }
 
    virtual wxString GetUndoActionDescription() const;
    virtual wxString GetRedoActionDescription() const;
 
    int GetMaxUndoItems() const { return m_undoRedoCountMax; }

    virtual void OnModify();
 
    bool IsClosing() const { return m_isClosing; }
 
    bool NonUserClose( bool aForce )
    {
        m_isNonUserClose = true;
        return Close( aForce );
    }
 
    virtual void ClearToolbarControl( int aId ) { }

    virtual void HandleSystemColorChange();

    virtual bool CanAcceptApiCommands() { return IsEnabled(); }
 
protected:
    static constexpr int KICAD_AUI_TB_STYLE = wxAUI_TB_DEFAULT_STYLE | wxAUI_TB_PLAIN_BACKGROUND;
 
    virtual void doReCreateMenuBar() {}
 
    virtual void configureToolbars();

    void onAutoSaveTimer( wxTimerEvent& aEvent );
 

    virtual void handleIconizeEvent( wxIconizeEvent& aEvent ) {}
    void         onIconize( wxIconizeEvent& aEvent );

    virtual bool isAutoSaveRequired() const { return m_autoSaveRequired; }

    virtual bool doAutoSave();

    virtual bool canRunAutoSave() const { return true; }

    void CheckForAutosaveFiles( const wxString& aProjectPath, const std::vector<wxString>& aExtensions );
 
    virtual bool canCloseWindow( wxCloseEvent& aCloseEvent ) { return true; }
    virtual void doCloseWindow() { }
 
    void onSystemColorChange( wxSysColourChangedEvent& aEvent );

    virtual void unitsChangeRefresh() { }

    virtual void setupUIConditions();

    void initExitKey();
 
    void ensureWindowIsOnScreen();

    virtual void saveProjectSettings() {}

    virtual void OnDropFiles( wxDropFilesEvent& aEvent );

    void AddMenuLanguageList( ACTION_MENU* aMasterMenu, TOOL_INTERACTIVE* aControlTool );

    void OnLanguageSelectionEvent( wxCommandEvent& aEvent );

    virtual void            DoWithAcceptedFiles();
    std::vector<wxFileName> m_AcceptedFiles;
 
    DECLARE_EVENT_TABLE()
 
private:
    void onUpdateUI( wxUpdateUIEvent& aEvent );

    void windowClosing( wxCloseEvent& event );

    void commonInit( FRAME_T aFrameType );
 
    wxWindow* findQuasiModalDialog();

    virtual bool IsModal() const { return false; }
 
#ifdef __WXMSW__
    WXLRESULT MSWWindowProc( WXUINT message, WXWPARAM wParam, WXLPARAM lParam ) override;
#endif
 
 protected:
    FRAME_T         m_ident;                // Id Type (pcb, schematic, library..)
    wxPoint         m_framePos;
    wxSize          m_frameSize;
    bool            m_maximizeByDefault;
    int             m_displayIndex;
 
    // These contain the frame size and position for when it is not maximized
    wxPoint         m_normalFramePos;
    wxSize          m_normalFrameSize;
 
    wxString                m_aboutTitle;        // Name of program displayed in About.
 
    wxAuiManager            m_auimgr;
    wxString                m_perspective;       // wxAuiManager perspective.
    std::unique_ptr<nlohmann::json> m_auiLayoutState;
    WX_INFOBAR*             m_infoBar;           // Infobar for the frame
    APPEARANCE_CONTROLS_3D* m_appearancePanel;
    wxString                m_configName;        // Prefix used to identify some params (frame
                                                 // size) and to name some config files (legacy
                                                 // hotkey files)
    SETTINGS_MANAGER*       m_settingsManager;
 
    FILE_HISTORY*           m_fileHistory;       // The frame's recently opened file list
    bool                    m_supportsAutoSave;
    bool                    m_autoSavePending;
    bool                    m_autoSaveRequired;
    wxTimer*                m_autoSaveTimer;
    bool                    m_autoSavePermissionError;
 
    // Wall-clock of the first autosave deferred by canRunAutoSave(), or an invalid time when no
    // deferral is outstanding.  Used to bound how long an interactive operation may starve the
    // snapshot so a long routing session can't leave the document unsnapshotted forever.
    wxDateTime              m_autoSaveDeferredSince;
 
    int                     m_undoRedoCountMax;  // undo/Redo command Max depth
 
    UNDO_REDO_CONTAINER     m_undoList;          // Objects list for the undo command (old data)
    UNDO_REDO_CONTAINER     m_redoList;          // Objects list for the redo command (old data)
 
    wxString                m_mruPath;           // Most recently used path.
 
    ORIGIN_TRANSFORMS       m_originTransforms;  // Default display origin transforms object.

    std::map<int, UIUpdateHandler> m_uiUpdateMap;

    bool m_uiUpdateHandlerBound;

    bool            m_isClosing;

    bool            m_isNonUserClose;

    std::map<const wxString, TOOL_ACTION*> m_acceptedExts;
 
    // Toolbar Settings - this is not owned by the frame
    TOOLBAR_SETTINGS*    m_toolbarSettings;
 
    // Toolbar UI elements
    ACTION_TOOLBAR*      m_tbTopMain;
    ACTION_TOOLBAR*      m_tbTopAux;  // Additional tools under main toolbar
    ACTION_TOOLBAR*      m_tbRight;       // Drawing tools (typically on right edge of window)
    ACTION_TOOLBAR*      m_tbLeft;    // Options (typically on left edge of window)
 
    std::map<std::string, ACTION_TOOLBAR_CONTROL_FACTORY> m_toolbarControlFactories;
};
 

class EDA_PANE : public wxAuiPaneInfo
{
public:
    EDA_PANE()
    {
        Gripper( false );
        CloseButton( false );
        PaneBorder( false );
    }

    EDA_PANE& HToolbar()
    {
        SetFlag( optionToolbar, true );
        CaptionVisible( false );
        TopDockable().BottomDockable();
        DockFixed( true );
        Movable( false );
        Resizable( true );      // expand to fit available space
        return *this;
    }

    EDA_PANE& VToolbar()
    {
        SetFlag( optionToolbar, true );
        CaptionVisible( false );
        LeftDockable().RightDockable();
        DockFixed( true );
        Movable( false );
        Resizable( true );      // expand to fit available space
        return *this;
    }

    EDA_PANE& Palette()
    {
        CaptionVisible( true );
        PaneBorder( true );
        return *this;
    }

    EDA_PANE& Canvas()
    {
        CaptionVisible( false );
        Layer( 0 );
        PaneBorder( true );
        Resizable( true );      // expand to fit available space
        return *this;
    }

    EDA_PANE& Messages()
    {
        CaptionVisible( false );
        BottomDockable( true );
        DockFixed( true );
        Movable( false );
        Resizable( true );      // expand to fit available space
        return *this;
    }

    EDA_PANE& InfoBar()
    {
        CaptionVisible( false );
        Movable( false );
        Resizable( true );
        PaneBorder( false );
        DockFixed( true );
        return *this;
    }
};
 
#endif  // EDA_BASE_FRAME_H_