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, 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 ACTION_TOOLBAR_H
#define ACTION_TOOLBAR_H
 
#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>
 
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; }
 
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 ApplyConfiguration( const TOOLBAR_CONFIGURATION& aConfig );
 
    void UpdateControlWidths();
 
    void UpdateControlWidth( int aID );
 
    void ClearToolbar();
 
    void SetToolBitmap( const TOOL_ACTION& aAction, const wxBitmap& 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*>& GetCustomControlList()
    {
        static std::list<ACTION_TOOLBAR_CONTROL*> m_controls;
        return m_controls;
    }
 
    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 onToolRightClick( wxAuiToolBarEvent& aEvent );
 
    void onPaletteEvent( wxCommandEvent& aEvent );
 
    void onTimerDone( wxTimerEvent& aEvent );
 
    void onThemeChanged( wxSysColourChangedEvent &aEvent );
 
    void OnCustomRender( wxDC& aDc, const wxAuiToolBarItem& aItem, const wxRect& aRect ) override;
 
protected:
    // Timer used to determine when the palette should be opened after a group item is pressed
    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;
};
 
typedef std::function<void ( ACTION_TOOLBAR* )> ACTION_TOOLBAR_CONTROL_FACTORY;
 
 
class ACTION_TOOLBAR_CONTROL
{
public:
    ACTION_TOOLBAR_CONTROL( std::string aName, wxString aUiName, wxString aDescription ) :
        m_name( aName ),
        m_uiname( aUiName ),
        m_description( aDescription )
    {
        wxASSERT_MSG( aName.starts_with( "control" ),
                      wxString::Format( "Control name \"%s\" must start with \"control\"", aName ) );
 
        ACTION_TOOLBAR::GetCustomControlList().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; }
 
protected:
    std::string m_name;
 
    wxString m_uiname;
 
    wxString m_description;
};
 
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 layerSelector;
};
 
#endif