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 (C) 2019-2021 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 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& 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;
 
    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;
};
 
 
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, bool aIsToggleEntry = false,
              bool aIsCancellable = false );
 
    void AddButton( const TOOL_ACTION& aAction );
 
    void AddScaledSeparator( wxWindow* aWindow );
 
    void AddToolContextMenu( const TOOL_ACTION& aAction, std::unique_ptr<ACTION_MENU> aMenu );
 
    void AddGroup( ACTION_GROUP* aGroup, bool aIsToggleEntry = false );
 
    void SelectAction( ACTION_GROUP* aGroup, const TOOL_ACTION& aAction );
 
    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 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::map<int, ACTION_GROUP*>       m_actionGroups;
 
    std::map<int, std::unique_ptr<ACTION_MENU>> m_toolMenus;
};
 
#endif