Merge pull request #3 from saurabhb17/master

secondary files

1 files changed, 1740 insertions, 0 deletions

diff --git a/include/wxPcbStruct.h b/include/wxPcbStruct.h
new file mode 100644
index 0000000..f47625c
--- /dev/null
+++ b/include/wxPcbStruct.h
@@ -0,0 +1,1740 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2010 Jean-Pierre Charras, jp.charras@wanadoo.fr
+ * Copyright (C) 1992-2011 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
+ */
+
+/**
+ * @file wxPcbStruct.h
+ */
+
+#ifndef  WXPCB_STRUCT_H_
+#define  WXPCB_STRUCT_H_
+
+
+#include <pcb_base_edit_frame.h>
+#include <config_params.h>
+#include <class_macros_record.h>
+#include <class_undoredo_container.h>
+#include <zones.h>
+
+
+/*  Forward declarations of classes. */
+class PCB_SCREEN;
+class BOARD;
+class TEXTE_PCB;
+class MODULE;
+class TRACK;
+class SEGZONE;
+class VIA;
+class D_PAD;
+class TEXTE_MODULE;
+class PCB_TARGET;
+class DIMENSION;
+class EDGE_MODULE;
+class DRC;
+class ZONE_CONTAINER;
+class DRAWSEGMENT;
+class GENERAL_COLLECTOR;
+class GENERAL_COLLECTORS_GUIDE;
+class PCB_LAYER_WIDGET;
+class MARKER_PCB;
+class BOARD_ITEM;
+class PCB_LAYER_BOX_SELECTOR;
+class NETLIST;
+class REPORTER;
+struct PARSE_ERROR;
+struct IO_ERROR;
+class FP_LIB_TABLE;
+
+namespace PCB { struct IFACE; }     // KIFACE_I is in pcbnew.cpp
+
+/**
+ * Class PCB_EDIT_FRAME
+ * is the main frame for Pcbnew.
+ *
+ * See also class PCB_BASE_FRAME(): Basic class for Pcbnew and GerbView.
+ */
+#define PCB_EDIT_FRAME_NAME wxT( "PcbFrame" )
+
+
+class PCB_EDIT_FRAME : public PCB_BASE_EDIT_FRAME
+{
+    friend struct PCB::IFACE;
+    friend class PCB_LAYER_WIDGET;
+
+    void updateTraceWidthSelectBox();
+    void updateViaSizeSelectBox();
+
+    int             m_RecordingMacros;
+    MACROS_RECORDED m_Macros[10];
+
+    /// The auxiliary right vertical tool bar used to access the microwave tools.
+    wxAuiToolBar* m_microWaveToolBar;
+
+    /**
+     * Function loadFootprints
+     * loads the footprints for each #COMPONENT in \a aNetlist from the list of libraries.
+     *
+     * @param aNetlist is the netlist of components to load the footprints into.
+     * @param aReporter is the #REPORTER object to report to.
+     * @throw IO_ERROR if an I/O error occurs or a #PARSE_ERROR if a file parsing error
+     *           occurs while reading footprint library files.
+     */
+    void loadFootprints( NETLIST& aNetlist, REPORTER* aReporter )
+        throw( IO_ERROR, PARSE_ERROR );
+
+protected:
+    PCB_LAYER_WIDGET* m_Layers;
+
+    DRC* m_drc;                                 ///< the DRC controller, see drc.cpp
+
+    PARAM_CFG_ARRAY   m_configSettings;         ///< List of Pcbnew configuration settings.
+
+    wxString          m_lastNetListRead;        ///< Last net list read with relative path.
+
+    // The Tool Framework initalization
+    void setupTools();
+
+    // we'll use lower case function names for private member functions.
+    void createPopUpMenuForZones( ZONE_CONTAINER* edge_zone, wxMenu* aPopMenu );
+    void createPopUpMenuForFootprints( MODULE* aModule, wxMenu* aPopMenu );
+    void createPopUpMenuForFpTexts( TEXTE_MODULE* aText, wxMenu* aPopMenu );
+    void createPopUpMenuForFpPads( D_PAD* aPad, wxMenu* aPopMenu );
+    void createPopupMenuForTracks( TRACK* aTrack, wxMenu* aPopMenu );
+    void createPopUpMenuForTexts( TEXTE_PCB* Text, wxMenu* menu );
+    void createPopUpBlockMenu( wxMenu* menu );
+    void createPopUpMenuForMarkers( MARKER_PCB* aMarker, wxMenu* aPopMenu );
+
+    /**
+     * an helper function to enable some menus only active when the display
+     * is switched to GAL mode and which do nothing in legacy mode
+     */
+    void enableGALSpecificMenus();
+
+
+    // Has meaning only if DKICAD_SCRIPTING_WXPYTHON option is on
+    /**
+     * @return the frame name identifier for the python console frame
+     */
+    static const wxChar * pythonConsoleNameId()
+    {
+        return wxT( "PythonConsole" );
+    }
+
+    /**
+     * @return a pointer to the python console frame, or NULL if not exist
+     */
+    static wxWindow * findPythonConsole()
+    {
+       return FindWindowByName( pythonConsoleNameId() );
+    }
+
+    /**
+     * Function syncLayerWidgetLayer
+     * updates the currently layer "selection" within the PCB_LAYER_WIDGET.
+     * The currently selected layer is defined by the return value of GetActiveLayer().
+     * <p>
+     * This function cannot be inline without including layer_widget.h in
+     * here and we do not want to do that.
+     * </p>
+     */
+    void syncLayerWidgetLayer();
+
+    /**
+     * Function syncRenderStates
+     * updates the "Render" checkboxes in the layer widget according
+     * to current toggle values determined by IsElementVisible(), and is helpful
+     * immediately after loading a BOARD which may have state information in it.
+     */
+    void syncRenderStates();
+
+    /**
+     * Function syncLayerVisibilities
+     * updates each "Layer" checkbox in the layer widget according
+     * to each layer's current visibility determined by IsLayerVisible(), and is
+     * helpful immediately after loading a BOARD which may have state information in it.
+     */
+    void syncLayerVisibilities();
+
+    virtual void unitsChangeRefresh();
+
+    /**
+     * Function doAutoSave
+     * performs auto save when the board has been modified and not saved within the
+     * auto save interval.
+     *
+     * @return true if the auto save was successful.
+     */
+    virtual bool doAutoSave();
+
+    /**
+     * Function isautoSaveRequired
+     * returns true if the board has been modified.
+     */
+    virtual bool isAutoSaveRequired() const;
+
+    /**
+     * Function duplicateZone
+     * duplicates the given zone.
+     * @param aDC is the current Device Context.
+     * @param aZone is the zone to duplicate
+     */
+    void duplicateZone( wxDC* aDC, ZONE_CONTAINER* aZone );
+
+    /**
+     * Function moveExact
+     * Move the selected item exactly
+     */
+    void moveExact();
+
+    /**
+     * Function duplicateItems
+     * Duplicate selected item if possible and start a move
+     * @param aIncrement increment the item number if appropriate
+     */
+    void duplicateItems( bool aIncrement ); //override
+
+    // protected so that PCB::IFACE::CreateWindow() is the only factory.
+    PCB_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent );
+
+public:
+    PCB_LAYER_BOX_SELECTOR* m_SelLayerBox;  // a combo box to display and select active layer
+    wxChoice* m_SelTrackWidthBox;           // a choice box to display and select current track width
+    wxChoice* m_SelViaSizeBox;              // a choice box to display and select current via diameter
+
+    bool m_show_microwave_tools;
+    bool m_show_layer_manager_tools;
+
+    virtual ~PCB_EDIT_FRAME();
+
+    void OnQuit( wxCommandEvent& event );
+
+    /**
+     * Function GetAutoSaveFilePrefix
+     *
+     * @return the string to prepend to a file name for automatic save.
+     */
+    static wxString GetAutoSaveFilePrefix();
+
+    /**
+     * Execute a remote command send by Eeschema via a socket,
+     * port KICAD_PCB_PORT_SERVICE_NUMBER (currently 4242)
+     * this is a virtual function called by EDA_DRAW_FRAME::OnSockRequest().
+     * @param cmdline = received command from socket
+     */
+    virtual void ExecuteRemoteCommand( const char* cmdline );
+
+    void KiwayMailIn( KIWAY_EXPRESS& aEvent );      // virtual overload from KIWAY_PLAYER
+
+    /**
+     * Function ToPlotter
+     * Open a dialog frame to create plot and drill files
+     * relative to the current board
+     */
+    void ToPlotter( wxCommandEvent& event );
+
+    /**
+     * Function ToPrinter
+     * Install the print dialog
+     */
+    void ToPrinter( wxCommandEvent& event );
+
+    /**
+     * Function SVG_Print
+     * shows the print SVG file dialog.
+     */
+    void SVG_Print( wxCommandEvent& event );
+
+    // User interface update command event handlers.
+    void OnUpdateSave( wxUpdateUIEvent& aEvent );
+    void OnUpdateLayerPair( wxUpdateUIEvent& aEvent );
+    void OnUpdateLayerSelectBox( wxUpdateUIEvent& aEvent );
+    void OnUpdateDrcEnable( wxUpdateUIEvent& aEvent );
+    void OnUpdateShowBoardRatsnest( wxUpdateUIEvent& aEvent );
+    void OnUpdateShowModuleRatsnest( wxUpdateUIEvent& aEvent );
+    void OnUpdateAutoDeleteTrack( wxUpdateUIEvent& aEvent );
+    void OnUpdateViaDrawMode( wxUpdateUIEvent& aEvent );
+    void OnUpdateTraceDrawMode( wxUpdateUIEvent& aEvent );
+    void OnUpdateHighContrastDisplayMode( wxUpdateUIEvent& aEvent );
+    void OnUpdateShowLayerManager( wxUpdateUIEvent& aEvent );
+    void OnUpdateShowMicrowaveToolbar( wxUpdateUIEvent& aEvent );
+    void OnUpdateVerticalToolbar( wxUpdateUIEvent& aEvent );
+    void OnUpdateSelectViaSize( wxUpdateUIEvent& aEvent );
+    void OnUpdateZoneDisplayStyle( wxUpdateUIEvent& aEvent );
+    void OnUpdateSelectTrackWidth( wxUpdateUIEvent& aEvent );
+    void OnUpdateSelectAutoTrackWidth( wxUpdateUIEvent& aEvent );
+    void OnUpdateSelectCustomTrackWidth( wxUpdateUIEvent& aEvent );
+    void OnUpdateAutoPlaceModulesMode( wxUpdateUIEvent& aEvent );
+    void OnUpdateAutoPlaceTracksMode( wxUpdateUIEvent& aEvent );
+    void OnUpdateMuWaveToolbar( wxUpdateUIEvent& aEvent );
+    void OnLayerColorChange( wxCommandEvent& aEvent );
+    void OnConfigurePaths( wxCommandEvent& aEvent );
+
+    /**
+     * Function RecordMacros.
+     * records sequence of hotkeys and cursor positions to a macro.
+     * @param aDC = current device context
+     * @param aNumber The current number macros.
+     */
+    void RecordMacros( wxDC* aDC, int aNumber );
+
+    /**
+     * Function CallMacros
+     * play hotkeys and cursor position from a recorded macro.
+     * @param aDC = current device context
+     * @param aPosition The current cursor position in logical (drawing) units.
+     * @param aNumber The current number macros.
+     */
+    void CallMacros( wxDC* aDC, const wxPoint& aPosition, int aNumber );
+
+    void SaveMacros();
+
+    void ReadMacros();
+
+    /**
+     * Function PrintPage , virtual
+     * used to print a page
+     * Print the page pointed by the current screen, set by the calling print function
+     * @param aDC = wxDC given by the calling print function
+     * @param aPrintMaskLayer = a 32 bits mask: bit n = 1 -> layer n is printed
+     * @param aPrintMirrorMode = true to plot mirrored
+     * @param aData = a pointer on an auxiliary data (NULL if not used)
+     */
+    virtual void PrintPage( wxDC* aDC, LSET aPrintMaskLayer, bool aPrintMirrorMode,
+                            void* aData = NULL );
+
+    void GetKicadAbout( wxCommandEvent& event );
+
+    /**
+     * Function IsGridVisible() , virtual
+     * @return true if the grid must be shown
+     */
+    virtual bool IsGridVisible() const;
+
+    /**
+     * Function SetGridVisibility() , virtual
+     * It may be overloaded by derived classes
+     * if you want to store/retrieve the grid visibility in configuration.
+     * @param aVisible = true if the grid must be shown
+     */
+    virtual void SetGridVisibility( bool aVisible );
+
+    /**
+     * Function GetGridColor() , virtual
+     * @return the color of the grid
+     */
+    virtual EDA_COLOR_T GetGridColor() const;
+
+    /**
+     * Function SetGridColor() , virtual
+     * @param aColor = the new color of the grid
+     */
+    virtual void SetGridColor( EDA_COLOR_T aColor );
+
+    ///> @copydoc EDA_DRAW_FRAME::SetCursorShape()
+    virtual void SetCursorShape( int aCursorShape );
+
+    // Configurations:
+    void Process_Config( wxCommandEvent& event );
+
+    /**
+     * Function GetProjectFileParameters
+     * returns a project file parameter list for Pcbnew.
+     * <p>
+     * Populate a project file parameter array specific to Pcbnew.
+     * Creating the parameter list at run time has the advantage of being able
+     * to define local variables.  The old method of statically building the array
+     * at compile time requiring global variable definitions by design.
+     * </p>
+     * @return PARAM_CFG_ARRAY - it is only good until SetBoard() is called, so
+     *   don't keep it around past that event.
+     */
+    PARAM_CFG_ARRAY GetProjectFileParameters();
+
+    /**
+     * Function SaveProjectSettings
+     * saves changes to the project settings to the project (.pro) file.
+     * @param aAskForSave = true to open a dialog before saving the settings
+     */
+    void SaveProjectSettings( bool aAskForSave );
+
+    /**
+     * Load the current project's file configuration settings which are pertinent
+     * to this PCB_EDIT_FRAME instance.
+     *
+     * @return always returns true.
+     */
+    bool LoadProjectSettings();
+
+    /**
+     * Function GetConfigurationSettings
+     * returns the Pcbnew applications settings list.
+     *
+     * This replaces the old statically defined list that had the project
+     * file settings and the application settings mixed together.  This
+     * was confusing and caused some settings to get saved and loaded
+     * incorrectly.  Currently, only the settings that are needed at start
+     * up by the main window are defined here.  There are other locally used
+     * settings that are scattered throughout the Pcbnew source code.  If you need
+     * to define a configuration setting that needs to be loaded at run time,
+     * this is the place to define it.
+     *
+     * @return - Reference to the list of applications settings.
+     */
+    PARAM_CFG_ARRAY& GetConfigurationSettings();
+
+    void LoadSettings( wxConfigBase* aCfg );    // override virtual
+
+    void SaveSettings( wxConfigBase* aCfg );    // override virtual
+
+    wxConfigBase* GetSettings() { return config(); };
+
+    /**
+     * Get the last net list read with the net list dialog box.
+     *
+     * @return - Absolute path and file name of the last net list file successfully read.
+     */
+    wxString GetLastNetListRead();
+
+    /**
+     * Set the last net list successfully read by the net list dialog box.
+     *
+     * Note: the file path is converted to a path relative to the project file path.  If
+     *       the path cannot be made relative, than m_lastNetListRead is set to and empty
+     *       string.  This could happen when the net list file is on a different drive than
+     *       the project file.  The advantage of relative paths is that is more likely to
+     *       work when opening the same project from both Windows and Linux.
+     *
+     * @param aNetListFile - The last net list file with full path successfully read.
+     */
+    void SetLastNetListRead( const wxString& aNetListFile );
+
+    ///> @copydoc EDA_DRAW_FRAME::GetHotKeyDescription()
+    EDA_HOTKEY* GetHotKeyDescription( int aCommand ) const;
+
+    /**
+     * Function OnHotKey.
+     *  ** Commands are case insensitive **
+     *  Some commands are relatives to the item under the mouse cursor
+     * @param aDC = current device context
+     * @param aHotkeyCode = hotkey code (ascii or wxWidget code for special keys)
+     * @param aPosition The cursor position in logical (drawing) units.
+     * @param aItem = NULL or pointer on a EDA_ITEM under the mouse cursor
+     */
+    bool OnHotKey( wxDC* aDC, int aHotkeyCode, const wxPoint& aPosition, EDA_ITEM* aItem = NULL );
+
+    /**
+     * Function OnHotkeyDeleteItem
+     * Delete the item found under the mouse cursor
+     *  Depending on the current active tool::
+     *      Tool track
+     *          if a track is in progress: Delete the last segment
+     *          else delete the entire track
+     *      Tool module (footprint):
+     *          Delete the module.
+     * @param aDC = current device context
+     * @return true if an item was deleted
+     */
+    bool OnHotkeyDeleteItem( wxDC* aDC );
+
+    /**
+     * Function OnHotkeyPlaceItem
+     * Place the item (footprint, track, text .. ) found under the mouse cursor
+     * An item can be placed only if there is this item currently edited
+     * Only a footprint, a pad or a track can be placed
+     * @param aDC = current device context
+     * @return true if an item was placed
+     */
+    bool OnHotkeyPlaceItem( wxDC* aDC );
+
+    bool OnHotkeyEditItem( int aIdCommand );
+
+    /**
+     * Function OnHotkeyCopyItem
+     * returns the copy event id for copyable items.
+     * @return Event id of a suitable copy event, zero when no copyable item found.
+     */
+    int OnHotkeyCopyItem();
+
+    /**
+     * Function OnHotkeyDuplicateOrArrayItem
+     * Duplicate an item (optionally incrementing if necessary and possible)
+     * or invoke array dialog and create an array
+     * @param aIdCommand = the hotkey command id
+     * @return true if item duplicated or arrayed
+     */
+    bool OnHotkeyDuplicateOrArrayItem( int aIdCommand );
+
+    /**
+     * Function OnHotkeyMoveItem
+     * Moves or drag the item (footprint, track, text .. ) found under the mouse cursor
+     * Only a footprint or a track can be dragged
+     * @param aIdCommand = the hotkey command id
+     * @return true if an item was moved
+     */
+    bool OnHotkeyMoveItem( int aIdCommand );
+
+    /**
+     * Function OnHotkeyRotateItem
+     * Rotate the item (text or footprint) found under the mouse cursor
+     * @note This command can be used with an item currently in edit.
+     *       Only some items can be rotated (footprints and texts).
+     * @param aIdCommand = the hotkey command id
+     * @return true if an item was moved
+     */
+    bool OnHotkeyRotateItem( int aIdCommand );
+
+    /**
+     * Function OnHotkeyFlipItem
+     * Flip the item (text or footprint) found under the mouse cursor
+     * @note This command can be used with an item currently in edit.
+     *       Only some items can be rotated (footprints and texts).
+     * @param aIdCommand = the hotkey command id
+     * @return true if an item was moved
+     */
+    bool OnHotkeyFlipItem( int aIdCommand );
+
+    /**
+     * Function OnHotkeyBeginRoute
+     * If the current active layer is a copper layer,
+     * and if no item currently edited, start a new track segmenton
+     * the current copper layer.
+     * If a new track is in progress, terminate the current segment and
+     * start a new one.
+     * @param aDC = current device context
+     * @return a reference to the track if a track is created, or NULL
+     */
+    TRACK * OnHotkeyBeginRoute( wxDC* aDC );
+
+    void OnCloseWindow( wxCloseEvent& Event );
+    void Process_Special_Functions( wxCommandEvent& event );
+    void Tracks_and_Vias_Size_Event( wxCommandEvent& event );
+    void OnSelectTool( wxCommandEvent& aEvent );
+
+    /**
+     * Function OnResetModuleTextSizes
+     * resets text size and width of all module text fields of given field
+     * type to current settings in Preferences
+     */
+    void OnResetModuleTextSizes( wxCommandEvent& event );
+
+    void ProcessMuWaveFunctions( wxCommandEvent& event );
+    void MuWaveCommand( wxDC* DC, const wxPoint& MousePos );
+
+    void RedrawActiveWindow( wxDC* DC, bool EraseBg );
+    void ReCreateHToolbar();
+    void ReCreateAuxiliaryToolbar();
+    void ReCreateVToolbar();
+    void ReCreateMicrowaveVToolbar();
+    void ReCreateOptToolbar();
+    void ReCreateMenuBar();
+
+    /**
+     * Re create the layer Box by clearing the old list, and building
+     * le new one, from the new layers names and cole layers
+     * @param aForceResizeToolbar = true to resize the parent toolbar
+     * false if not needed (mainly in parent toolbar creation,
+     * or when the layers names are not modified)
+     */
+    void ReCreateLayerBox( bool aForceResizeToolbar = true );
+
+
+    /**
+     * Function SetCurrentNetClass
+     * Must be called after a netclass selection (or after a netclass parameter change
+     * calls BOARD_DESIGN_SETTINGS::SetCurrentNetClass() and update trace width and via size
+     * combo boxes on main toolbar
+     * Initialize vias and tracks values displayed in comb boxes of the auxiliary toolbar
+     * and some others parameters (netclass name ....)
+     * @param aNetClassName = the new netclass name
+     * @return true if lists of tracks and vias sizes are modified
+     */
+    bool SetCurrentNetClass( const wxString& aNetClassName );
+
+    /**
+     * Function OnModify
+     * must be called after a board change to set the modified flag.
+     * <p>
+     * Reloads the 3D view if required and calls the base PCB_BASE_FRAME::OnModify function
+     * to update auxiliary information.
+     * </p>
+     */
+    virtual void OnModify();
+
+    /**
+     * Function SetActiveLayer
+     * will change the currently active layer to \a aLayer and also
+     * update the PCB_LAYER_WIDGET.
+     */
+    virtual void SetActiveLayer( LAYER_ID aLayer );
+
+    /**
+     * Function IsElementVisible
+     * tests whether a given element category is visible. Keep this as an
+     * inline function.
+     * @param aElement is from the enum by the same name
+     * @return bool - true if the element is visible.
+     * @see enum PCB_VISIBLE
+     */
+    bool IsElementVisible( int aElement ) const;
+
+    /**
+     * Function SetElementVisibility
+     * changes the visibility of an element category
+     * @param aElement is from the enum by the same name
+     * @param aNewState = The new visibility state of the element category
+     * @see enum PCB_VISIBLE
+     */
+    void SetElementVisibility( int aElement, bool aNewState );
+
+    /**
+     * Function SetVisibleAlls
+     * Set the status of all visible element categories and layers to VISIBLE
+     */
+    void SetVisibleAlls();
+
+    /**
+     * Function ReFillLayerWidget
+     * changes out all the layers in m_Layers and may be called upon
+     * loading a new BOARD.
+     */
+    void ReFillLayerWidget();
+
+    /**
+     * Function Show3D_Frame
+     * displays the 3D view of current printed circuit board.
+     */
+    void Show3D_Frame( wxCommandEvent& event );
+
+    ///> @copydoc EDA_DRAW_FRAME::UseGalCanvas()
+    void UseGalCanvas( bool aEnable );
+
+    bool GeneralControl( wxDC* aDC, const wxPoint& aPosition, int aHotKey = 0 );
+
+    /**
+     * Function ShowDesignRulesEditor
+     * displays the Design Rules Editor.
+     */
+    void ShowDesignRulesEditor( wxCommandEvent& event );
+
+    /* toolbars update UI functions: */
+
+    void PrepareLayerIndicator();
+
+    /* mouse functions events: */
+    void OnLeftClick( wxDC* DC, const wxPoint& MousePos );
+    void OnLeftDClick( wxDC* DC, const wxPoint& MousePos );
+
+    /**
+     * Function OnRightClick
+     * populates a popup menu with the choices appropriate for the current context.
+     * The caller will add the ZOOM menu choices afterward.
+     * @param aMousePos The current mouse position
+     * @param aPopMenu The menu to add to.
+     */
+    bool OnRightClick( const wxPoint& aMousePos, wxMenu* aPopMenu );
+
+    void OnSelectOptionToolbar( wxCommandEvent& event );
+    void ToolOnRightClick( wxCommandEvent& event );
+
+    /**
+     * Function SaveCopyInUndoList.
+     * Creates a new entry in undo list of commands.
+     * add a picker to handle aItemToCopy
+     * @param aItemToCopy = the board item modified by the command to undo
+     * @param aTypeCommand = command type (see enum UNDO_REDO_T)
+     * @param aTransformPoint = the reference point of the transformation, for
+     *                          commands like move
+     */
+    virtual void SaveCopyInUndoList( BOARD_ITEM* aItemToCopy,
+                                     UNDO_REDO_T aTypeCommand,
+                                     const wxPoint& aTransformPoint = wxPoint( 0, 0 ) );
+
+    /**
+     * Function SaveCopyInUndoList (overloaded).
+     * Creates a new entry in undo list of commands.
+     * add a list of pickers to handle a list of items
+     * @param aItemsList = the list of items modified by the command to undo
+     * @param aTypeCommand = command type (see enum UNDO_REDO_T)
+     * @param aTransformPoint = the reference point of the transformation, for
+     *                          commands like move
+     */
+    virtual void SaveCopyInUndoList( const PICKED_ITEMS_LIST& aItemsList,
+                                     UNDO_REDO_T aTypeCommand,
+                                     const wxPoint& aTransformPoint = wxPoint( 0, 0 ) );
+
+    /**
+     * Function PutDataInPreviousState
+     * Used in undo or redo command.
+     * Put data pointed by List in the previous state, i.e. the state memorized by List
+     * @param aList = a PICKED_ITEMS_LIST pointer to the list of items to undo/redo
+     * @param aRedoCommand = a bool: true for redo, false for undo
+     * @param aRebuildRatsnet = a bool: true to rebuild ratsnest (normal use), false
+     * to just retrieve last state (used in abort commands that do not need to
+     * rebuild ratsnest)
+     */
+    void PutDataInPreviousState( PICKED_ITEMS_LIST* aList,
+                                 bool               aRedoCommand,
+                                 bool               aRebuildRatsnet = true );
+
+    /**
+     * Function RestoreCopyFromRedoList
+     *  Redo the last edition:
+     *  - Save the current board in Undo list
+     *  - Get an old version of the board from Redo list
+     *  @return none
+     */
+    void RestoreCopyFromRedoList( wxCommandEvent& aEvent );
+
+    /**
+     * Function RestoreCopyFromUndoList
+     *  Undo the last edition:
+     *  - Save the current board in Redo list
+     *  - Get an old version of the board from Undo list
+     *  @return none
+     */
+    void RestoreCopyFromUndoList( wxCommandEvent& aEvent );
+
+    /* Block operations: */
+
+    /**
+     * Function BlockCommand
+     * Returns the block command internat code (BLOCK_MOVE, BLOCK_COPY...)
+     * corresponding to the keys pressed (ALT, SHIFT, SHIFT ALT ..) when
+     * block command is started by dragging the mouse.
+     * @param aKey = the key modifiers (Alt, Shift ...)
+     * @return the block command id (BLOCK_MOVE, BLOCK_COPY...)
+     */
+    virtual int BlockCommand( int aKey );
+
+    /**
+     * Function HandleBlockPlace()
+     * Called after HandleBlockEnd, when a block command needs to be
+     * executed after the block is moved to its new place
+     * (bloc move, drag, copy .. )
+     * Parameters must be initialized in GetScreen()->m_BlockLocate
+     */
+    virtual void HandleBlockPlace( wxDC* DC );
+
+    /**
+     * Function HandleBlockEnd()
+     * Handle the "end"  of a block command,
+     * i.e. is called at the end of the definition of the area of a block.
+     * depending on the current block command, this command is executed
+     * or parameters are initialized to prepare a call to HandleBlockPlace
+     * in GetScreen()->m_BlockLocate
+     * @return false if no item selected, or command finished,
+     * true if some items found and HandleBlockPlace must be called later
+     */
+    virtual bool HandleBlockEnd( wxDC* DC );
+
+    /**
+     * Function Block_SelectItems
+     * Uses  GetScreen()->m_BlockLocate
+     * select items within the selected block.
+     * selected items are put in the pick list
+     */
+    void Block_SelectItems();
+
+    /**
+     * Function Block_Delete
+     * deletes all items within the selected block.
+     */
+    void Block_Delete();
+
+    /**
+     * Function Block_Rotate
+     * Rotate all items within the selected block.
+     * The rotation center is the center of the block
+     */
+    void Block_Rotate();
+
+    /**
+     * Function Block_Flip
+     * Flip items within the selected block.
+     * The flip center is the center of the block
+     */
+    void Block_Flip();
+
+    /**
+     * Function Block_Move
+     * move all items within the selected block.
+     * New location is determined by the current offset from the selected
+     * block's original location.
+     */
+    void Block_Move();
+
+    /**
+     * Function Block_Mirror_X
+     * mirrors all items within the currently selected block in the X axis.
+     */
+    void Block_Mirror_X();
+
+    /**
+     * Function Block_Duplicate
+     * Duplicate all items within the selected block.
+     * New location is determined by the current offset from the selected
+     * block's original location.
+     */
+    void Block_Duplicate( bool aIncrement );
+
+    void Process_Settings( wxCommandEvent& event );
+    void OnConfigurePcbOptions( wxCommandEvent& aEvent );
+    void InstallDisplayOptionsDialog( wxCommandEvent& aEvent );
+    void InstallPcbGlobalDeleteFrame( const wxPoint& pos );
+
+    /**
+     * Function GenFootprintsPositionFile
+     * Calls DoGenFootprintsPositionFile to create a footprint position file
+     * See DoGenFootprintsPositionFile for options and file format
+     */
+    void GenFootprintsPositionFile( wxCommandEvent& event );
+
+    /**
+     * Function DoGenFootprintsPositionFile
+     * Creates an ascii footprint position file
+     * @param aFullFileName = the full file name of the file to create
+     * @param aUnitsMM = false to use inches, true to use mm in coordinates
+     * @param aForceSmdItems = true to force all footprints with smd pads in list
+     *                       = false to put only footprints with option "INSERT" in list
+     * @param aSide = 0 to list footprints on BACK side,
+     *                1 to list footprints on FRONT side
+     *                2 to list footprints on both sides
+     * @return the number of footprints found on aSide side,
+     *    or -1 if the file could not be created
+     */
+    int DoGenFootprintsPositionFile( const wxString& aFullFileName, bool aUnitsMM,
+                                      bool aForceSmdItems, int aSide );
+
+    /**
+     * Function GenFootprintsReport
+     * Calls DoGenFootprintsReport to create a footprint reprot file
+     * See DoGenFootprintsReport for file format
+     */
+    void GenFootprintsReport( wxCommandEvent& event );
+
+    /**
+     * Function DoGenFootprintsReport
+     * Creates an ascii footprint report file giving some infos on footprints
+     * and board outlines
+     * @param aFullFilename = the full file name of the file to create
+     * @param aUnitsMM = false to use inches, true to use mm in coordinates
+     * @return true if OK, false if error
+     */
+    bool DoGenFootprintsReport( const wxString& aFullFilename, bool aUnitsMM );
+
+    void InstallDrillFrame( wxCommandEvent& event );
+    void GenD356File( wxCommandEvent& event );
+    void ToPostProcess( wxCommandEvent& event );
+
+    void OnFileHistory( wxCommandEvent& event );
+
+    /**
+     * Function Files_io
+     * @param event is the command event handler.
+     * do nothing else than call Files_io_from_id with the
+     * wxCommandEvent id
+     */
+    void Files_io( wxCommandEvent& event );
+
+    /**
+     * Function Files_io_from_id
+     * Read and write board files
+     * @param aId is an event ID ciming from file command events:
+     * ID_LOAD_FILE
+     * ID_MENU_READ_BOARD_BACKUP_FILE
+     * ID_MENU_RECOVER_BOARD_AUTOSAVE
+     * ID_APPEND_FILE
+     * ID_NEW_BOARD
+     * ID_SAVE_BOARD
+     * ID_COPY_BOARD_AS
+     * ID_SAVE_BOARD_AS
+     * Files_io_from_id prepare parameters and calls the specialized function
+     */
+    void Files_io_from_id( int aId );
+
+    /**
+     * Function OpenProjectFiles    (was LoadOnePcbFile)
+     * loads a KiCad board (.kicad_pcb) from \a aFileName.
+     *
+     * @param aFileSet - hold the BOARD file to load, a vector of one element.
+     *
+     * @param aCtl      - KICTL_ bits, one to indicate that an append of the board file
+     *                      aFileName to the currently loaded file is desired.
+     *                    @see #KIWAY_PLAYER for bit defines.
+     *
+     * @return bool - false if file load fails, otherwise true.
+    bool LoadOnePcbFile( const wxString& aFileName, bool aAppend = false,
+                         bool aForceFileDialog = false );
+     */
+    bool OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl = 0 );
+
+    /**
+     * Function AppendBoardFile
+     * appends a board file onto the current one, creating God knows what.
+     * the main purpose is only to allow panelizing boards.
+     */
+    bool AppendBoardFile( const wxString& aFullFileName, int aCtl );
+
+    /**
+     * Function SavePcbFile
+     * writes the board data structures to \a a aFileName
+     * Creates backup when requested and update flags (modified and saved flgs)
+     *
+     * @param aFileName The file name to write or wxEmptyString to prompt user for
+     *                  file name.
+     * @param aCreateBackupFile Creates a back of \a aFileName if true.  Helper
+     *                          definitions #CREATE_BACKUP_FILE and #NO_BACKUP_FILE
+     *                          are defined for improved code readability.
+     * @return True if file was saved successfully.
+     */
+    bool SavePcbFile( const wxString& aFileName, bool aCreateBackupFile = CREATE_BACKUP_FILE );
+
+    /**
+     * Function SavePcbCopy
+     * writes the board data structures to \a a aFileName
+     * but unlike SavePcbFile, does not make anything else
+     * (no backup, borad fliename change, no flag changes ...)
+     * Used under a project mgr to save under a new name the current board
+     *
+     * When not under a project mgr, the full SavePcbFile is used.
+     * @param aFileName The file name to write.
+     * @return True if file was saved successfully.
+     */
+    bool SavePcbCopy( const wxString& aFileName );
+
+    // BOARD handling
+
+    /**
+     * Function Clear_Pcb
+     * delete all and reinitialize the current board
+     * @param aQuery = true to prompt user for confirmation, false to initialize silently
+     */
+    bool Clear_Pcb( bool aQuery );
+
+    ///> @copydoc PCB_BASE_FRAME::SetBoard()
+    void SetBoard( BOARD* aBoard );
+
+    ///> @copydoc PCB_BASE_FRAME::SetPageSettings()
+    void SetPageSettings( const PAGE_INFO& aPageSettings ); // overload
+
+    // Drc control
+
+    /* function GetDrcController
+     * @return the DRC controller
+     */
+    DRC* GetDrcController() { return m_drc; }
+
+    /**
+     * Function RecreateBOMFileFromBoard
+     * Recreates a .cmp file from the current loaded board
+     * this is the same as created by CvPcb.
+     * can be used if this file is lost
+     */
+    void RecreateCmpFileFromBoard( wxCommandEvent& aEvent );
+
+    /**
+     * Function ArchiveModulesOnBoard
+     * Save modules in a library:
+     * @param aStoreInNewLib:
+     *              true : save modules in a existing lib. Existing footprints will be kept
+     *              or updated.
+     *              This lib should be in fp lib table, and is type is .pretty
+     *              false: save modules in a new lib. It it is an existing lib,
+     *              previous footprints will be removed
+     */
+    void ArchiveModulesOnBoard( bool aStoreInNewLib );
+
+    /**
+     * Function RecreateBOMFileFromBoard
+     * Creates a BOM file from the current loaded board
+     */
+    void RecreateBOMFileFromBoard( wxCommandEvent& aEvent );
+
+    /**
+     * Function ExportToGenCAD
+     * creates a file in  GenCAD 1.4 format from the current board.
+     */
+    void ExportToGenCAD( wxCommandEvent& event );
+
+    /**
+     * Function OnExportVRML
+     * will export the current BOARD to a VRML file.
+     */
+    void OnExportVRML( wxCommandEvent& event );
+
+    /**
+     * Function ExportVRML_File
+     * Creates the file(s) exporting current BOARD to a VRML file.
+     *
+     * @note When copying 3D shapes files, the new filename is build from the full path
+     *       name, changing the separators by underscore.  This is needed because files
+     *       with the same shortname can exist in different directories
+     * @note ExportVRML_File generates coordinates in board units (BIU) inside the file.
+     * @todo Use mm inside the file.  A general scale transform is applied to the whole
+     *       file (1.0 to have the actual WRML unit im mm, 0.001 to have the actual WRML
+     *       unit in meters.
+     * @note For 3D models built by a 3D modeler, the unit is 0,1 inches.  A specific scale
+     *       is applied to 3D models to convert them to internal units.
+     *
+     * @param aFullFileName = the full filename of the file to create
+     * @param aMMtoWRMLunit = the VRML scaling factor:
+     *      1.0 to export in mm. 0.001 for meters
+     * @param aExport3DFiles = true to copy 3D shapes in the subir a3D_Subdir
+     * @param aUseRelativePaths set to true to use relative paths instead of absolute paths
+     *                          in the board VRML file URLs.
+     * @param aUsePlainPCB set to true to export a board with no copper or silkskreen;
+     *                          this is useful for generating a VRML file which can be
+     *                          converted to a STEP model.
+     * @param a3D_Subdir = sub directory where 3D shapes files are copied.  This is only used
+     *                     when aExport3DFiles == true
+     * @param aXRef = X value of PCB (0,0) reference point
+     * @param aYRef = Y value of PCB (0,0) reference point
+     * @return true if Ok.
+     */
+    bool ExportVRML_File( const wxString & aFullFileName, double aMMtoWRMLunit,
+                          bool aExport3DFiles, bool aUseRelativePaths,
+                          bool aUsePlainPCB, const wxString & a3D_Subdir,
+                          double aXRef, double aYRef );
+
+    /**
+     * Function ExportToIDF3
+     * will export the current BOARD to a IDFv3 board and lib files.
+     */
+    void ExportToIDF3( wxCommandEvent& event );
+
+    /**
+     * Function ExporttoSPECCTRA
+     * Ask for a filename and call ExportSpecctraFile to export the current BOARD
+     * to a specctra dsn file.
+     */
+    void ExportToSpecctra( wxCommandEvent& event );
+
+    /**
+     * Function ExportSpecctraFile
+     * will export the current BOARD to a specctra dsn file.
+     * See http://www.autotraxeda.com/docs/SPECCTRA/SPECCTRA.pdf for the
+     * specification.
+     * @return true if OK
+     */
+    bool ExportSpecctraFile( const wxString& aFullFilename );
+
+    /**
+     * Function ImportSpecctraSession
+     * will import a specctra *.ses file and use it to relocate MODULEs and
+     * to replace all vias and tracks in an existing and loaded BOARD.
+     * See http://www.autotraxeda.com/docs/SPECCTRA/SPECCTRA.pdf for the
+     * specification.
+     */
+    void ImportSpecctraSession( wxCommandEvent& event );
+
+    /**
+     * Function ImportSpecctraDesign
+     * will import a specctra *.dsn file and use it to replace an entire BOARD.
+     * The new board will not have any graphics, only components, tracks and
+     * vias.
+     * See http://www.autotraxeda.com/docs/SPECCTRA/SPECCTRA.pdf for the
+     * specification.
+     */
+    void ImportSpecctraDesign( wxCommandEvent& event );
+
+    /**
+     * Function Access_to_External_Tool
+     * Run an external tool (like freeroute )
+     */
+    void Access_to_External_Tool( wxCommandEvent& event );
+
+    /**
+     * Function ListAndSelectModuleName
+     * builds and shows a list of existing modules on board that the user can select.
+     * @return a pointer to the selected module or NULL.
+     */
+    MODULE* ListAndSelectModuleName();
+
+    /**
+     * Function ListNetsAndSelect
+     * called by a command event
+     * displays the sorted list of nets in a dialog frame
+     * If a net is selected, it is highlighted
+     */
+    void ListNetsAndSelect( wxCommandEvent& event );
+
+    void Swap_Layers( wxCommandEvent& event );
+
+    // Handling texts on the board
+    void Rotate_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC );
+    void FlipTextePcb( TEXTE_PCB* aTextePcb, wxDC* aDC );
+    TEXTE_PCB* CreateTextePcb( wxDC* aDC, TEXTE_PCB* aText = NULL );
+    void Delete_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC );
+    void StartMoveTextePcb( TEXTE_PCB* aTextePcb, wxDC* aDC, bool aErase = true );
+    void Place_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC );
+    void InstallTextPCBOptionsFrame( TEXTE_PCB* TextPCB, wxDC* DC );
+
+    // Graphic Segments type DRAWSEGMENT
+    void Start_Move_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC );
+    void Place_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC );
+    void InstallGraphicItemPropertiesDialog( DRAWSEGMENT* aItem, wxDC* aDC );
+
+    // Footprint edition (see also PCB_BASE_FRAME)
+    void InstallModuleOptionsFrame( MODULE* Module, wxDC* DC );
+
+    /**
+     * Function StartMoveModule
+     * Initialize a drag or move pad command
+     * @param aModule = the module to move or drag
+     * @param aDC = the current device context
+     * @param aDragConnectedTracks = true to drag connected tracks,
+     *                               false to just move the module
+     */
+    void StartMoveModule( MODULE* aModule, wxDC* aDC, bool aDragConnectedTracks );
+
+    /**
+     * Function DlgGlobalChange_PadSettings
+     * Function to change pad caracteristics for the given footprint
+     * or all footprints which look like the given footprint
+     * Options are set by the opened dialog.
+     * @param aPad is the pattern. The given footprint is the parent of this pad
+     * @param aRedraw: if true: redraws the footprint
+     */
+    void DlgGlobalChange_PadSettings( D_PAD* aPad, bool aRedraw );
+
+    /**
+     * Function Delete Module
+     * Remove a footprint from m_Modules linked list and put it in undelete buffer
+     * The ratsnest and pad list are recalculated
+     * @param aModule = footprint to delete
+     * @param aDC = currentDevice Context. if NULL: do not redraw new ratsnest
+     */
+    bool Delete_Module( MODULE* aModule, wxDC* aDC );
+
+    /**
+     * Function Change_Side_Module
+     * Flip a footprint (switch layer from component or component to copper)
+     * The mirroring is made from X axis
+     * if a footprint is not on copper or component layer it is not flipped
+     * (it could be on an adhesive layer, not supported at this time)
+     * @param Module the footprint to flip
+     * @param  DC Current Device Context. if NULL, no redraw
+     */
+    void Change_Side_Module( MODULE* Module, wxDC* DC );
+
+    int InstallExchangeModuleFrame( MODULE* ExchangeModuleModule );
+
+    /**
+     * Function Exchange_Module
+     * Replaces OldModule by NewModule, using OldModule settings:
+     * position, orientation, pad netnames ...)
+     * OldModule is deleted or put in undo list.
+     * @param aOldModule = footprint to replace
+     * @param aNewModule = footprint to put
+     * @param aUndoPickList = the undo list used to save  OldModule. If null,
+     *                        OldModule is deleted
+     */
+    void Exchange_Module( MODULE* aOldModule, MODULE* aNewModule,
+                          PICKED_ITEMS_LIST* aUndoPickList );
+
+    // loading modules: see PCB_BASE_FRAME
+
+    // Board handling
+    void RemoveStruct( BOARD_ITEM* Item, wxDC* DC );
+
+    /**
+     * Function OnEditItemRequest
+     * Install the corresponding dialog editor for the given item
+     * @param aDC = the current device context
+     * @param aItem = a pointer to the BOARD_ITEM to edit
+     */
+    void OnEditItemRequest( wxDC* aDC, BOARD_ITEM* aItem );
+
+    /**
+     * Locate track or pad and highlight the corresponding net.
+     * @return The Netcode, or -1 if no net located.
+     */
+    int SelectHighLight( wxDC* DC );
+
+    /**
+     * Function HighLight.
+     * highlights the net at the current cursor position.
+     */
+    void HighLight( wxDC* DC );
+
+    // Track and via edition:
+    void Via_Edit_Control( wxCommandEvent& event );
+
+    /**
+     * Function IsMicroViaAcceptable
+     * return true if a microvia can be placed on the board.
+     * <p>
+     * A microvia is a small via restricted to 2 near neighbor layers
+     * because its is hole is made by laser which can penetrate only one layer
+     * It is mainly used to connect BGA to the first inner layer
+     * And it is allowed from an external layer to the first inner layer
+     * </p>
+     */
+    bool IsMicroViaAcceptable( void );
+
+    /**
+     * Function Other_Layer_Route
+     * operates in one of two ways.  If argument track is NULL, then swap the
+     * active layer between m_Route_Layer_TOP and m_Route_Layer_BOTTOM.  If a
+     * track is in progress (track is not NULL), and if DRC allows it, place
+     * a via on the end of the current track, and then swap the current active
+     * layer and start a new segment on the new layer.
+     * @param track A TRACK* to append the via to or NULL.
+     * @param DC A device context to draw on.
+     * @return bool - true if the operation was successful, else false such as
+     *                the case where DRC would not allow a via.
+     */
+    bool Other_Layer_Route( TRACK* track, wxDC* DC );
+    void HighlightUnconnectedPads( wxDC* DC );
+
+    /**
+     * Function Delete_Segment
+     * removes a track segment.
+     * If a new track is in progress: delete the current new segment.
+     * Otherwise, delete segment under the mouse cursor.
+     */
+    TRACK* Delete_Segment( wxDC* DC, TRACK* Track );
+
+    void Delete_Track( wxDC* DC, TRACK* Track );
+    void Delete_net( wxDC* DC, TRACK* Track );
+
+    /**
+     * Function Remove_One_Track
+     * removes 1 track/
+     * The leading segment is removed and all adjacent segments
+     * until a pad or a junction point of more than 2 segments is found
+     */
+    void Remove_One_Track( wxDC* DC, TRACK* pt_segm );
+
+    /**
+     * Function Reset_All_Tracks_And_Vias_To_Netclass_Values
+     * Reset all tracks width and/or vias diameters and drill
+     * to their default Netclass value
+     * @param aTrack : bool true to modify tracks
+     * @param aVia : bool true to modify vias
+     */
+    bool Reset_All_Tracks_And_Vias_To_Netclass_Values( bool aTrack, bool aVia );
+
+    /**
+     * Function Change_Net_Tracks_And_Vias_Sizes
+     * Reset all tracks width and vias diameters and drill
+     * to their default Netclass value or current values
+     * @param aNetcode : the netcode of the net to edit
+     * @param aUseNetclassValue : bool. True to use netclass values, false to
+     *                            use current values
+     */
+    bool Change_Net_Tracks_And_Vias_Sizes( int  aNetcode, bool aUseNetclassValue );
+
+    /**
+     * Function Edit_Track_Width
+     * Modify a full track width (using DRC control).
+     * a full track is the set of track segments between 2 ends: pads or a
+     * point that has more than 2 segments ends connected
+     * @param  aDC = the curred device context (can be NULL)
+     * @param aTrackSegment = a segment or via on the track to change
+     */
+    void Edit_Track_Width( wxDC* aDC, TRACK* aTrackSegment );
+
+    /**
+     * Function Edit_TrackSegm_Width
+     *  Modify one track segment width or one via diameter (using DRC control).
+     * @param  aDC = the current device context (can be NULL)
+     * @param aTrackItem = the track segment or via to modify
+     */
+    void Edit_TrackSegm_Width( wxDC* aDC, TRACK* aTrackItem );
+
+    /**
+     * Function Begin_Route
+     * Starts a new track and/or establish of a new track point.
+     *
+     * For a new track:
+     * - Search the netname of the new track from the starting point
+     * if it is on a pad or an existing track
+     * - Highlight all this net
+     * If a track is in progress:
+     * - Call DRC
+     * - If DRC is OK: finish the track segment and starts a new one.
+     * @param aTrack = the current track segment, or NULL to start a new track
+     * @param aDC = the current device context
+     * @return a pointer to the new track segment or null if not created (DRC error)
+     */
+    TRACK* Begin_Route( TRACK* aTrack, wxDC* aDC );
+
+    /**
+     * Function End_Route
+     * Terminates a track currently being created
+     * @param aTrack = the current track segment in progress
+     * @param aDC = the current device context
+     * @return true if the track was created, false if not (due to a DRC error)
+     */
+    bool End_Route( TRACK* aTrack, wxDC* aDC );
+
+    void Attribut_Segment( TRACK* track, wxDC* DC, bool Flag_On );
+    void Attribut_Track( TRACK* track, wxDC* DC, bool Flag_On );
+    void Attribut_net( wxDC* DC, int net_code, bool Flag_On );
+
+    /**
+     * Function StartMoveOneNodeOrSegment
+     * initializes the parameters to move one  via or/and a terminal point of a track segment
+     * The terminal point of other connected segments (if any) are moved too.
+     */
+    void StartMoveOneNodeOrSegment( TRACK* aTrack, wxDC* aDC, int aCommand );
+
+    bool PlaceDraggedOrMovedTrackSegment( TRACK* Track, wxDC* DC );
+
+    /**
+     * @todo This function is broken, because it merge segments having different
+     *       widths or without any connectivity test.
+     * 2 collinear segments can be merged only if no other segment or via is
+     * connected to the common point and if they have the same width. See
+     * cleanup.cpp for merge functions and consider MarkTrace() to locate segments
+     * that can be merged
+     */
+    bool MergeCollinearTracks( TRACK* track, wxDC* DC, int end );
+
+    void Start_DragTrackSegmentAndKeepSlope( TRACK* track, wxDC* DC );
+    void SwitchLayer( wxDC* DC, LAYER_ID layer );
+
+    /**
+     * Function Add45DegreeSegment
+     * adds a track segment between 2 tracks segments if these 2 segments
+     * make a 90 deg angle, in order to have 45 deg track segments
+     * Its only works on horizontal or vertical segments.
+     *
+     * @param aDC The wxDC device context to draw on.
+     * @return A bool value true if ok or false if not.
+     */
+    bool Add45DegreeSegment( wxDC* aDC );
+
+    /**
+     * Function EraseRedundantTrack
+     * Called after creating a track
+     * Remove (if exists) the old track that have the same starting and the
+     * same ending point as the new created track
+     * (this is the redunding track)
+     * @param aDC = the current device context (can be NULL)
+     * @param aNewTrack = the new created track (a pointer to a segment of the
+     *                    track list)
+     * @param aNewTrackSegmentsCount = number of segments in this new track
+     * @param aItemsListPicker = the list picker to use for an undo command
+     *                           (can be NULL)
+     */
+    int EraseRedundantTrack( wxDC*              aDC,
+                             TRACK*             aNewTrack,
+                             int                aNewTrackSegmentsCount,
+                             PICKED_ITEMS_LIST* aItemsListPicker );
+
+    /**
+     * Function SetTrackSegmentWidth
+     *  Modify one track segment width or one via diameter (using DRC control).
+     *  Basic routine used by other routines when editing tracks or vias
+     * @param aTrackItem = the track segment or via to modify
+     * @param aItemsListPicker = the list picker to use for an undo command
+     *                           (can be NULL)
+     * @param aUseNetclassValue = true to use NetClass value, false to use
+     *                            current designSettings value
+     * @return  true if done, false if no not change (because DRC error)
+     */
+    bool SetTrackSegmentWidth( TRACK*             aTrackItem,
+                               PICKED_ITEMS_LIST* aItemsListPicker,
+                               bool               aUseNetclassValue );
+
+
+    // zone handling
+
+    /**
+     * Function Delete_OldZone_Fill (obsolete)
+     * Used for compatibility with old boards
+     * Remove the zone filling which include the segment aZone, or the zone
+     * which have the given time stamp.
+     * For old boards, a zone is a group of SEGZONE segments which have the same TimeStamp
+     * @param aZone = zone segment within the zone to delete. Can be NULL
+     * @param aTimestamp = Timestamp for the zone to delete, used if aZone ==
+     *                     NULL
+     */
+    void Delete_OldZone_Fill( SEGZONE* aZone, time_t aTimestamp = 0 );
+
+    /**
+     * Function Delete_LastCreatedCorner
+     * Used only while creating a new zone outline
+     * Remove and delete the current outline segment in progress
+     * @return 0 if no corner in list, or corner number
+     */
+    int Delete_LastCreatedCorner( wxDC* DC );
+
+    /**
+     * Function Begin_Zone
+     * either initializes the first segment of a new zone, or adds an
+     * intermediate segment.
+     * A new zone can be:
+     * created from scratch: the user will be prompted to define parameters (layer, clearence ...)
+     * created from a similar zone (s_CurrentZone is used): parameters are copied from
+     * s_CurrentZone
+     * created as a cutout (an hole) inside s_CurrentZone
+     */
+    int Begin_Zone( wxDC* DC );
+
+    /**
+     * Function End_Zone
+     * terminates (if no DRC error ) the zone edge creation process
+     * @param DC = current Device Context
+     * @return true if Ok, false if DRC error
+     */
+    bool End_Zone( wxDC* DC );
+
+    /**
+     * Function Fill_Zone
+     *  Calculate the zone filling for the outline zone_container
+     *  The zone outline is a frontier, and can be complex (with holes)
+     *  The filling starts from starting points like pads, tracks.
+     * If exists the old filling is removed
+     * @param aZone = zone to fill
+     * @return error level (0 = no error)
+     */
+    int Fill_Zone( ZONE_CONTAINER* aZone );
+
+    /**
+     * Function Fill_All_Zones
+     *  Fill all zones on the board
+     * The old fillings are removed
+     * @param aActiveWindow = the current active window, if a progress bar is shown
+     *                      = NULL to do not display a progress bar
+     * @param aVerbose = true to show error messages
+     */
+    int Fill_All_Zones( wxWindow * aActiveWindow, bool aVerbose = true );
+
+
+    /**
+     * Function Add_Zone_Cutout
+     * Add a cutout zone to a given zone outline
+     * @param DC = current Device Context
+     * @param zone_container = parent zone outline
+     */
+    void Add_Zone_Cutout( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function Add_Similar_Zone
+     * Add a zone to a given zone outline.
+     * if the zones are overlapping they will be merged
+     * @param DC = current Device Context
+     * @param zone_container = parent zone outline
+     */
+    void Add_Similar_Zone( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function Edit_Zone_Params
+     * Edit params (layer, clearance, ...) for a zone outline
+     */
+    void Edit_Zone_Params( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function Start_Move_Zone_Corner
+     * Prepares a move corner in a zone outline,
+     * called from a move corner command (IsNewCorner = false),
+     * or a create new cornet command (IsNewCorner = true )
+     */
+    void Start_Move_Zone_Corner( wxDC*           DC,
+                                 ZONE_CONTAINER* zone_container,
+                                 int             corner_id,
+                                 bool            IsNewCorner );
+
+    /**
+     * Function Start_Move_Zone_Corner
+     * Prepares a drag edge in an existing zone outline,
+     */
+    void Start_Move_Zone_Drag_Outline_Edge( wxDC*            DC,
+                                            ZONE_CONTAINER* zone_container,
+                                            int             corner_id );
+
+    /**
+     * Function End_Move_Zone_Corner_Or_Outlines
+     * Terminates a move corner in a zone outline, or a move zone outlines
+     * @param DC = current Device Context (can be NULL)
+     * @param zone_container: the given zone
+     */
+    void End_Move_Zone_Corner_Or_Outlines( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function End_Move_Zone_Corner_Or_Outlines
+     * Remove the currently selected corner in a zone outline
+     * the .m_CornerSelection is used as corner selection
+     */
+    void Remove_Zone_Corner( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function Delete_Zone
+     * Remove the zone which include the segment aZone, or the zone which have
+     * the given time stamp.  A zone is a group of segments which have the
+     * same TimeStamp
+     * @param DC = current Device Context (can be NULL)
+     * @param zone_container = zone to modify
+     *  the member .m_CornerSelection is used to find the outline to remove.
+     * if the outline is the main outline, all the zone is removed
+     * otherwise, the hole is deleted
+     */
+    void Delete_Zone_Contour( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    /**
+     * Function Start_Move_Zone_Outlines
+     * Initialize parameters to move an existing zone outlines.
+     * @param DC = current Device Context (can be NULL)
+     * @param zone_container: the given zone to move
+     */
+    void Start_Move_Zone_Outlines( wxDC* DC, ZONE_CONTAINER* zone_container );
+
+    // Target handling
+    PCB_TARGET* CreateTarget( wxDC* DC );
+    void DeleteTarget( PCB_TARGET* aTarget, wxDC* DC );
+    void BeginMoveTarget( PCB_TARGET* aTarget, wxDC* DC );
+    void PlaceTarget( PCB_TARGET* aTarget, wxDC* DC );
+    void ShowTargetOptionsDialog( PCB_TARGET* aTarget, wxDC* DC );
+
+    // Graphic segments type DRAWSEGMENT handling:
+    DRAWSEGMENT* Begin_DrawSegment( DRAWSEGMENT* Segment, STROKE_T shape, wxDC* DC );
+    void End_Edge( DRAWSEGMENT* Segment, wxDC* DC );
+    void Delete_Segment_Edge( DRAWSEGMENT* Segment, wxDC* DC );
+    void Delete_Drawings_All_Layer( LAYER_ID aLayer );
+
+    // Dimension handling:
+    void ShowDimensionPropertyDialog( DIMENSION* aDimension, wxDC* aDC );
+    DIMENSION* EditDimension( DIMENSION* aDimension, wxDC* aDC );
+    void DeleteDimension( DIMENSION* aDimension, wxDC* aDC );
+    void BeginMoveDimensionText( DIMENSION* aItem, wxDC* DC );
+    void PlaceDimensionText( DIMENSION* aItem, wxDC* DC );
+
+
+    // netlist  handling:
+    void InstallNetlistFrame( wxDC* DC );
+
+    /**
+     * Function ReadPcbNetlist
+     * reads \a aNetlistFileName and updates the footprints (load missing footprints and
+     * delete on demand extra footprints) on the board.
+     * Update connectivity info, references, values and "TIME STAMP"
+     *
+     * @param aNetlistFileName = netlist file name (*.net)
+     * @param aCmpFileName = cmp/footprint link file name (*.cmp).
+     *                       if not found or empty, only the netlist will be used
+     * @param aReporter is a pointer to a #REPORTER object to write display messages.
+     *                  can be NULL.
+     * @param aChangeFootprint if true, footprints that have changed in netlist will be changed
+     * @param aDeleteBadTracks if true, erroneous tracks will be deleted
+     * @param aDeleteExtraFootprints if true, remove unlocked footprints that are not in netlist
+     * @param aSelectByTimestamp if true, use timestamp instead of reference to identify
+     *                           footprints from components (use after reannotation of the
+     *                           schematic)
+     * @param aDeleteSinglePadNets if true, remove nets counting only one pad
+     *                             and set net code to 0 for these pads
+     * @param aIsDryRun performs a dry run without making any changes if true.
+     */
+    void ReadPcbNetlist( const wxString&  aNetlistFileName,
+                         const wxString&  aCmpFileName,
+                         REPORTER*        aReporter,
+                         bool             aChangeFootprint,
+                         bool             aDeleteBadTracks,
+                         bool             aDeleteExtraFootprints,
+                         bool             aSelectByTimestamp,
+                         bool             aDeleteSinglePadNets,
+                         bool             aIsDryRun );
+
+    /**
+     * Function RemoveMisConnectedTracks
+     * finds all track segments which are mis-connected (to more than one net).
+     * When such a bad segment is found, it is flagged to be removed.
+     * All tracks having at least one flagged segment are removed.
+     * @return true if any change is made
+     */
+    bool RemoveMisConnectedTracks();
+
+
+    // Autoplacement:
+    void OnPlaceOrRouteFootprints( wxCommandEvent& event );
+
+    /**
+     * Function ScriptingConsoleEnableDisable
+     * enables or disabled the scripting console
+     */
+    void ScriptingConsoleEnableDisable( wxCommandEvent& aEvent );
+
+    void OnUpdateScriptingConsoleState( wxUpdateUIEvent& aEvent );
+
+    void OnSelectAutoPlaceMode( wxCommandEvent& aEvent );
+
+    /**
+     * Function OnOrientFootprints
+     * install the dialog box for the common Orient Footprints
+     */
+    void OnOrientFootprints( wxCommandEvent& event );
+
+    /**
+     * Function ReOrientModules
+     * Set the orientation of footprints
+     * @param ModuleMask = mask (wildcard allowed) selection
+     * @param Orient = new orientation
+     * @param include_fixe = true to orient locked footprints
+     * @return true if some footprints modified, false if no change
+     */
+    bool ReOrientModules( const wxString& ModuleMask, double Orient, bool include_fixe );
+    void LockModule( MODULE* aModule, bool aLocked );
+
+    /**
+     * Function SpreadFootprints
+     * Footprints (after loaded by reading a netlist for instance) are moved
+     * to be in a small free area (outside the current board) without overlapping.
+     * @param aFootprintsOutsideBoardOnly: true to move only
+     * footprints outside the board outlines
+     * (they are outside if the position of a footprint is outside
+     * the board outlines bounding box
+     */
+    void SpreadFootprints( bool aFootprintsOutsideBoardOnly );
+
+    /**
+     * Function AutoPlaceModule
+     * automatically places footprints within the confines of the PCB edges.
+     * The components with the FIXED status are not moved.  If the menu is
+     * calling the placement of 1 module, it will be replaced.
+     */
+    void AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC );
+
+    // Autorouting:
+    int Solve( wxDC* DC, int two_sides );
+    void Reset_Noroutable( wxDC* DC );
+    void Autoroute( wxDC* DC, int mode );
+    void ReadAutoroutedTracks( wxDC* DC );
+    void GlobalRoute( wxDC* DC );
+
+    /**
+     * Function Show_1_Ratsnest
+     * draw ratsnest.
+     *
+     * The net edge pad with mouse or module locates the mouse.
+     * Delete the ratsnest if no module or pad is selected.
+     */
+    void Show_1_Ratsnest( EDA_ITEM* item, wxDC* DC );
+
+    /**
+     * Function Clean_Pcb
+     * Clean up the board (remove redundant vias, not connected tracks
+     * and merges collinear track segments)
+     * Install the cleanup dialog frame to know what should be cleaned
+     * and run the cleanup function
+     */
+    void Clean_Pcb();
+
+    void InstallFindFrame();
+
+    /**
+     * Function SendMessageToEESCHEMA
+     * sends a message to the schematic editor so that it may move its cursor
+     * to a part with the same reference as the objectToSync
+     * @param objectToSync The object whose reference is used to synchronize Eeschema.
+     */
+    void SendMessageToEESCHEMA( BOARD_ITEM* objectToSync );
+
+    /**
+     * Function Edit_Gap
+     * edits the GAP module if it has changed the position and/or size of the pads that
+     * form the gap get a new value.
+     */
+    void Edit_Gap( wxDC* DC, MODULE* Module );
+
+    /**
+     * Function CreateMuWaveBaseFootprint
+     * create a basic footprint for micro wave applications.
+     * @param aValue = the text value
+     * @param aTextSize = the size of ref and value texts ( <= 0 to use board default values )
+     * @param aPadCount = number of pads
+     * Pads settings are:
+     *  PAD_ATTRIB_SMD, rectangular, H size = V size = current track width.
+     */
+    MODULE* CreateMuWaveBaseFootprint( const wxString& aValue, int aTextSize, int aPadCount );
+
+    /**
+     * Create_MuWaveComponent
+     * creates a module "GAP" or "STUB" used in micro wave designs.
+     *  This module has 2 pads:
+     *  PAD_ATTRIB_SMD, rectangular, H size = V size = current track width.
+     *  the "gap" is isolation created between this 2 pads
+     */
+    MODULE* Create_MuWaveComponent( int shape_type );
+
+    MODULE* Create_MuWavePolygonShape();
+
+    void Begin_Self( wxDC* DC );
+
+    /**
+     * Function Genre_Self
+     * creates a self-shaped coil for microwave applications.
+     * - Length Mself.lng
+     * - Extremities Mself.m_Start and Mself.m_End
+     *
+     * We must determine:
+     * Mself.nbrin = number of segments perpendicular to the direction
+     * (The coil nbrin will demicercles + 1 + 2 1 / 4 circle)
+     * Mself.lbrin = length of a strand
+     * Mself.radius = radius of rounded parts of the coil
+     * Mself.delta = segments extremities connection between him and the coil even
+     *
+     * The equations are
+     * Mself.m_Size.x = 2 * Mself.radius + Mself.lbrin
+     * Mself.m_Size.y * Mself.delta = 2 + 2 * Mself.nbrin * Mself.radius
+     * Mself.lng = 2 * Mself.delta / / connections to the coil
+     + (Mself.nbrin-2) * Mself.lbrin / / length of the strands except 1st and last
+     + (Mself.nbrin 1) * (PI * Mself.radius) / / length of rounded
+     * Mself.lbrin + / 2 - Melf.radius * 2) / / length of 1st and last bit
+     *
+     * The constraints are:
+     * Nbrin >= 2
+     * Mself.radius < Mself.m_Size.x
+     * Mself.m_Size.y = Mself.radius * 4 + 2 * Mself.raccord
+     * Mself.lbrin> Mself.radius * 2
+     *
+     * The calculation is conducted in the following way:
+     * Initially:
+     * Nbrin = 2
+     * Radius = 4 * m_Size.x (arbitrarily fixed value)
+     * Then:
+     * Increasing the number of segments to the desired length
+     * (Radius decreases if necessary)
+     *
+     */
+    MODULE* Genere_Self( wxDC* DC );
+
+    void ShowChangedLanguage();         // override EDA_BASE_FRAME virtual
+
+    /**
+     * Function UpdateTitle
+     * sets the main window title bar text.
+     * <p>
+     * If file name defined by PCB_SCREEN::m_FileName is not set, the title is set to the
+     * application name appended with no file.  Otherwise, the title is set to the full path
+     * and file name and read only is appended to the title if the user does not have write
+     * access to the file.
+     * </p>
+     */
+    void UpdateTitle();
+
+    DECLARE_EVENT_TABLE()
+};
+
+#endif  // WXPCB_STRUCT_H_