action_toolbar.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 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/>.
 */
 
#pragma once
 
#include <map>
#include <memory>
#include <vector>
#include <wx/bitmap.h>          // Needed for the auibar include
#include <wx/aui/auibar.h>
#include <wx/aui/framemanager.h>
#include <wx/popupwin.h>
#include <wx/panel.h>
#include <tool/action_manager.h>
#include <frame_type.h>
 
class ACTION_MENU;
class BITMAP_BUTTON;
class EDA_BASE_FRAME;
class TOOL_ACTION;
class TOOL_MANAGER;
class TOOLBAR_CONFIGURATION;

class ACTION_GROUP
{
public:
    // Make the toolbar a friend so it can easily access everything inside here
    friend class ACTION_TOOLBAR;
 
    ACTION_GROUP( const std::string_view& aName );
 
    ACTION_GROUP( const std::string_view& aName, const std::vector<const TOOL_ACTION*>& aActions );

    void SetDefaultAction( const TOOL_ACTION& aDefault );

    const TOOL_ACTION* GetDefaultAction() const { return m_defaultAction; }

    std::string GetName() const { return m_name; }

    int GetUIId() const;

    void SetActions( const std::vector<const TOOL_ACTION*>& aActions );

    const std::vector<const TOOL_ACTION*>& GetActions() const { return m_actions; }
 
protected:
    int m_id;

    std::string m_name;

    const TOOL_ACTION* m_defaultAction;

    std::vector<const TOOL_ACTION*> m_actions;
};
 

class ACTION_TOOLBAR_PALETTE : public wxPopupTransientWindow
{
public:
    ACTION_TOOLBAR_PALETTE( wxWindow* aParent, bool aVertical );

    void AddAction( const TOOL_ACTION& aAction );

    void EnableAction( const TOOL_ACTION& aAction, bool aEnable = true );

    void CheckAction( const TOOL_ACTION& aAction, bool aCheck = true );

    void SetButtonSize( wxRect& aSize ) { m_buttonSize = aSize; }

    void Popup( wxWindow* aFocus = nullptr ) override;

    void SetGroup( ACTION_GROUP* aGroup ) { m_group = aGroup; }
    ACTION_GROUP* GetGroup() { return m_group; }
 
#ifdef __WXMSW__
    bool MSWHandleMessage( WXLRESULT* aResult, WXUINT aMessage, WXWPARAM aWParam,
                           WXLPARAM aLParam ) override;
#endif
 
protected:
    void onCharHook( wxKeyEvent& aEvent );
 
    // The group that the buttons in the palette are part of
     ACTION_GROUP* m_group;

    wxRect         m_buttonSize;

    bool           m_isVertical;
 
    wxPanel*       m_panel;
    wxBoxSizer*    m_mainSizer;
    wxBoxSizer*    m_buttonSizer;

    std::map<int, BITMAP_BUTTON*> m_buttons;
};
 
// Forward declare this because the toolbar wants it
class ACTION_TOOLBAR_CONTROL;

class ACTION_TOOLBAR : public wxAuiToolBar
{
public:
    ACTION_TOOLBAR( EDA_BASE_FRAME* parent, wxWindowID id = wxID_ANY,
                    const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
                    long style = wxAUI_TB_DEFAULT_STYLE );
 
    virtual ~ACTION_TOOLBAR();

    void SetAuiManager( wxAuiManager* aManager ) { m_auiManager = aManager; }
 
    void SetToolManager( TOOL_MANAGER* aManager ) { m_toolManager = aManager; }

    void Add( const TOOL_ACTION& aAction );

    void Add( const TOOL_ACTION& aAction, bool aIsToggleEntry,
              bool aIsCancellable = false );

    void AddButton( const TOOL_ACTION& aAction );

    void AddScaledSeparator( wxWindow* aWindow );

    void Add( wxControl* aControl, const wxString& aLabel = wxEmptyString );

    void AddToolContextMenu( const TOOL_ACTION& aAction, std::unique_ptr<ACTION_MENU> aMenu );

    void AddGroup( std::unique_ptr<ACTION_GROUP> aGroup );

    void SelectAction( ACTION_GROUP* aGroup, const TOOL_ACTION& aAction );

    void SelectAction( const TOOL_ACTION& aAction );

    void ApplyConfiguration( const TOOLBAR_CONFIGURATION& aConfig );

    void UpdateControlWidths();

    void UpdateControlWidth( int aID );

    void ClearToolbar();

    void SetToolBitmap( const TOOL_ACTION& aAction, const wxBitmapBundle& aBitmap );

    void Toggle( const TOOL_ACTION& aAction, bool aState );
 
    void Toggle( const TOOL_ACTION& aAction, bool aEnabled, bool aChecked );

    bool KiRealize();

    void RefreshBitmaps();

    static std::list<ACTION_TOOLBAR_CONTROL*>& GetAllCustomControls()
    {
        static std::list<ACTION_TOOLBAR_CONTROL*> m_controls;
        return m_controls;
    }

    static std::list<ACTION_TOOLBAR_CONTROL*> GetCustomControlList( FRAME_T aContext );
 
    static constexpr bool TOGGLE = true;
    static constexpr bool CANCEL = true;
 
protected:
    void doSelectAction( ACTION_GROUP* aGroup, const TOOL_ACTION& aAction );

    void popupPalette( wxAuiToolBarItem* aItem );

    void onMouseClick( wxMouseEvent& aEvent );

    void onItemDrag( wxAuiToolBarEvent& aEvent );

    void onToolEvent( wxAuiToolBarEvent& aEvent );

    void onRightClick( wxAuiToolBarEvent& aEvent );

    void onRightUp( wxMouseEvent& aEvent );

    void showContextMenu( int aToolId );

    void onPaletteEvent( wxCommandEvent& aEvent );

    void onTimerDone( wxTimerEvent& aEvent );
 
    void onThemeChanged( wxSysColourChangedEvent &aEvent );

    void OnCustomRender( wxDC& aDc, const wxAuiToolBarItem& aItem, const wxRect& aRect ) override;
 
    void DoSetToolTipText( const wxString& aTip ) override;
 
protected:
    // Timer used to determine when the palette should be opened after a group item is pressed
    EDA_BASE_FRAME*         m_parent;
    wxTimer*                m_paletteTimer;
 
    wxAuiManager*           m_auiManager;
    TOOL_MANAGER*           m_toolManager;
    ACTION_TOOLBAR_PALETTE* m_palette;
 
    std::map<int, bool>                m_toolKinds;
    std::map<int, bool>                m_toolCancellable;
    std::map<int, const TOOL_ACTION*>  m_toolActions;

    std::vector<int> m_controlIDs;
 
    std::map<int, std::unique_ptr<ACTION_GROUP>> m_actionGroups;
    std::map<int, std::unique_ptr<ACTION_MENU>>  m_toolMenus;

    std::map<std::string, std::string> m_groupSelections;
};

typedef std::function<void ( ACTION_TOOLBAR* )> ACTION_TOOLBAR_CONTROL_FACTORY;
 

class ACTION_TOOLBAR_CONTROL
{
public:
    ACTION_TOOLBAR_CONTROL( const std::string& aName, const wxString& aUiName,
                            const wxString& aDescription, std::vector<FRAME_T> aSupportedContexts ) :
        m_name( aName ),
        m_uiname( aUiName ),
        m_description( aDescription ),
        m_supportedContexts( aSupportedContexts )
    {
        wxASSERT_MSG( aName.starts_with( "control" ),
                      wxString::Format( "Control name \"%s\" must start with \"control\"", aName ) );
 
        ACTION_TOOLBAR::GetAllCustomControls().push_back( this );
    }
 
    const std::string& GetName() const { return m_name; }
    const wxString& GetUiName() const { return m_uiname; }
    const wxString& GetDescription() const { return m_description; }
 
    bool SupportedFor( FRAME_T aFrame ) const
    {
        for( FRAME_T candidate : m_supportedContexts )
        {
            if( aFrame == candidate )
                return true;
        }
 
        return false;
    }
 
protected:
    std::string m_name;

    wxString m_uiname;

    wxString m_description;

    std::vector<FRAME_T> m_supportedContexts;
};
 
class ACTION_TOOLBAR_CONTROLS
{
public:
    static ACTION_TOOLBAR_CONTROL gridSelect;
    static ACTION_TOOLBAR_CONTROL zoomSelect;
    static ACTION_TOOLBAR_CONTROL ipcScripting;
    static ACTION_TOOLBAR_CONTROL unitSelector;
    static ACTION_TOOLBAR_CONTROL bodyStyleSelector;
    static ACTION_TOOLBAR_CONTROL layerSelector;
    static ACTION_TOOLBAR_CONTROL overrideLocks;
};