cvpcb_mainframe.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * 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 _CVPCB_MAINFRAME_H_
#define _CVPCB_MAINFRAME_H_
 
#include <kiway_player.h>
#include <netlist_reader/pcb_netlist.h>
 
#include <auto_associate.h>
#include <cvpcb_association.h>
#include <listboxes.h>
 
/*  Forward declarations */
class ACTION_TOOLBAR;
class ACTION_MENU;
class TOOL_DISPATCHER;
class wxAuiToolBar;
class wxStaticText;
class DISPLAY_FOOTPRINTS_FRAME;
 
namespace CV { struct IFACE; }
 
// The undo/redo list is composed of vectors of associations
typedef std::vector< CVPCB_ASSOCIATION >       CVPCB_UNDO_REDO_ENTRIES;
 
// The undo list is a vector of undo entries
typedef std::vector< CVPCB_UNDO_REDO_ENTRIES > CVPCB_UNDO_REDO_LIST;
 

class CVPCB_MAINFRAME : public KIWAY_PLAYER
{
public:
    ~CVPCB_MAINFRAME();
 
    bool OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl=0 ) override;
 
    void KiwayMailIn( KIWAY_EXPRESS& aEvent ) override;

    enum CVPCB_FILTER_ACTION
    {
        FILTER_DISABLE,     
        FILTER_ENABLE,      
        FILTER_TOGGLE       
    };

    enum CONTROL_TYPE
    {
        CONTROL_NONE,            
        CONTROL_LIBRARY,         
        CONTROL_COMPONENT,       
        CONTROL_FOOTPRINT        
    };

    enum FOCUS_DIR
    {
        CHANGE_FOCUS_RIGHT,
        CHANGE_FOCUS_LEFT
    };

    enum ITEM_DIR
    {
        ITEM_NEXT,  
        ITEM_PREV   
    };

    bool IsContentModified() const override
    {
        return m_modified;
    }

    DISPLAY_FOOTPRINTS_FRAME* GetFootprintViewerFrame() const;
 
    wxWindow* GetToolCanvas() const override;

    CVPCB_MAINFRAME::CONTROL_TYPE GetFocusedControl() const;

    void SetFocusedControl( CVPCB_MAINFRAME::CONTROL_TYPE aControl );

    void OnSelectComponent( wxListEvent& event );
 
    void ShowChangedLanguage() override;

    void AutomaticFootprintMatching();

    void SetFootprintFilter( FOOTPRINTS_LISTBOX::FP_FILTER_T aFilter,
                             CVPCB_MAINFRAME::CVPCB_FILTER_ACTION aAction );

    void UndoAssociation();

    void RedoAssociation();
 
    int GetUndoCommandCount() const override
    {
        return m_undoList.size();
    }
 
    int GetRedoCommandCount() const override
    {
        return m_redoList.size();
    }
 
    // Cvpcb does not handle a undo/redo description (it does not use a UNDO_REDO_CONTAINER,
    // but a CVPCB_UNDO_REDO_LIST to store the undo/redo commands)
    wxString GetUndoActionDescription() const override
    {
        return wxEmptyString;
    }
 
    wxString GetRedoActionDescription() const override
    {
        return wxEmptyString;
    }

    void AssociateFootprint( const CVPCB_ASSOCIATION& aAssociation, bool aNewEntry = true,
                             bool aAddUndoItem = true );
 
    /*
     * Functions to build the listbox contents
     */
    void BuildFootprintsList();
    void BuildLibrariesList();

    bool SaveFootprintAssociation( bool doSaveSchematic );
 
    void LoadSettings( APP_SETTINGS_BASE* aCfg ) override;
 
    void SaveSettings( APP_SETTINGS_BASE* aCfg ) override;

    void DisplayStatus();

    bool LoadFootprintFiles();

    void SendComponentSelectionToSch( bool aClearSelectionOnly = false );

    COMPONENT* GetSelectedComponent();

    void SetSelectedComponent( int aIndex, bool aSkipUpdate = false );

    enum CRITERIA
    {
        ALL_COMPONENTS,     
        SEL_COMPONENTS,     
        NA_COMPONENTS,      
        ASSOC_COMPONENTS    
    };

    std::vector<unsigned int> GetComponentIndices(
            CVPCB_MAINFRAME::CRITERIA aCriteria = CVPCB_MAINFRAME::ALL_COMPONENTS );

    wxString GetSelectedFootprint();
 
    void RefreshFootprintViewer();
 
    void SetStatusText( const wxString& aText, int aNumber = 0 ) override;
 
protected:
    CVPCB_MAINFRAME( KIWAY* aKiway, wxWindow* aParent );
 
    void configureToolbars() override;
 
    void doReCreateMenuBar() override;
 
    void setupUIConditions() override;
 
    bool canCloseWindow( wxCloseEvent& aCloseEvent ) override;
    void doCloseWindow() override;

    bool readNetListAndFpFiles( const std::string& aNetlist );

    int readSchematicNetlist( const std::string& aNetlist );
 
private:
    wxString formatSymbolDesc( int idx, const wxString& aReference, const wxString& aValue,
                               const wxString& aFootprint );

    void setupTools();

    void setupEventHandlers();
 
    void onTextFilterChanged( wxCommandEvent& event );
 
    void updateFootprintViewerOnIdle( wxIdleEvent& aEvent );
 
    void onTextFilterChangedTimer( wxTimerEvent& aEvent );

    int buildEquivalenceList( FOOTPRINT_EQUIVALENCE_LIST& aList,
                              wxString* aErrorMessages = nullptr );
 
    void refreshAfterSymbolSearch( COMPONENT* aSymbol );
 
public:
    FOOTPRINT_LIST* m_FootprintsList;
 
protected:
    bool            m_modified;
    bool            m_skipComponentSelect;  // skip component selection event during
                                            // automatic selection/deletion of associations
 
    bool            m_initialized;          // true after creating widgets.
    bool            m_cannotClose;          // true when the cvpcb frame cannot be closed
                                            // (mainly during reading a netlist sent by Eeschema)
 
private:
    friend struct CV::IFACE;
 
    NETLIST                   m_netlist;
    int                       m_filteringOptions;
    FOOTPRINTS_LISTBOX*       m_footprintListBox;
    LIBRARY_LISTBOX*          m_librariesListBox;
    SYMBOLS_LISTBOX*          m_symbolsListBox;
    wxTextCtrl*               m_tcFilterString;
    wxStaticText*             m_statusLine1;
    wxStaticText*             m_statusLine2;
    wxStaticText*             m_statusLine3;
    wxButton*                 m_saveAndContinue;
 
    TOOL_DISPATCHER*          m_toolDispatcher;
 
    // Context menus for the list boxes
    ACTION_MENU*              m_footprintContextMenu;
    ACTION_MENU*              m_symbolsContextMenu;
 
    CVPCB_UNDO_REDO_LIST      m_undoList;
    CVPCB_UNDO_REDO_LIST      m_redoList;
 
    wxTimer*                  m_filterTimer;
    bool                      m_viewerPendingUpdate;
 
};
 
#endif  //#ifndef _CVPCB_MAINFRAME_H_