Merge pull request #1 from saurabhb17/develop

Added main functions

1 files changed, 954 insertions, 0 deletions

diff --git a/pcbnew/moduleframe.cpp b/pcbnew/moduleframe.cpp
new file mode 100644
index 0000000..b1ff42d
--- /dev/null
+++ b/pcbnew/moduleframe.cpp
@@ -0,0 +1,954 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 2015 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 2015 Wayne Stambaugh <stambaughw@verizon.net>
+ * Copyright (C) 1992-2015 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 moduleframe.cpp
+ * @brief Footprint (module) editor main window.
+ */
+
+#include <fctsys.h>
+#include <pgm_base.h>
+#include <kiway.h>
+#include <project.h>
+#include <kicad_plugin.h>
+#include <class_drawpanel.h>
+#include <pcb_draw_panel_gal.h>
+#include <confirm.h>
+#include <wxPcbStruct.h>
+#include <dialog_helpers.h>
+#include <3d_viewer.h>
+#include <msgpanel.h>
+#include <fp_lib_table.h>
+
+#include <class_board.h>
+#include <class_module.h>
+
+#include <pcbnew.h>
+#include <pcbnew_id.h>
+#include <hotkeys.h>
+#include <dialog_hotkeys_editor.h>
+#include <module_editor_frame.h>
+#include <modview_frame.h>
+#include <wildcards_and_files_ext.h>
+#include <class_pcb_layer_widget.h>
+#include <invoke_pcb_dialog.h>
+
+#include <tool/tool_manager.h>
+#include <tool/tool_dispatcher.h>
+#include "tools/selection_tool.h"
+#include "tools/edit_tool.h"
+#include "tools/drawing_tool.h"
+#include "tools/point_editor.h"
+#include "tools/pcbnew_control.h"
+#include "tools/module_tools.h"
+#include "tools/placement_tool.h"
+#include "tools/picker_tool.h"
+#include "tools/common_actions.h"
+
+
+BEGIN_EVENT_TABLE( FOOTPRINT_EDIT_FRAME, PCB_BASE_FRAME )
+    EVT_MENU_RANGE( ID_POPUP_PCB_ITEM_SELECTION_START, ID_POPUP_PCB_ITEM_SELECTION_END,
+                    PCB_BASE_FRAME::ProcessItemSelection )
+    EVT_CLOSE( FOOTPRINT_EDIT_FRAME::OnCloseWindow )
+    EVT_MENU( wxID_EXIT, FOOTPRINT_EDIT_FRAME::CloseModuleEditor )
+
+    EVT_SIZE( FOOTPRINT_EDIT_FRAME::OnSize )
+
+    EVT_CHOICE( ID_ON_ZOOM_SELECT, FOOTPRINT_EDIT_FRAME::OnSelectZoom )
+    EVT_CHOICE( ID_ON_GRID_SELECT, FOOTPRINT_EDIT_FRAME::OnSelectGrid )
+
+    EVT_TOOL( ID_MODEDIT_SELECT_CURRENT_LIB, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    EVT_TOOL( ID_MODEDIT_SAVE_LIBRARY_AS, FOOTPRINT_EDIT_FRAME::OnSaveLibraryAs )
+
+    EVT_TOOL( ID_MODEDIT_SAVE_LIBMODULE, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_OPEN_MODULE_VIEWER, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    EVT_TOOL( ID_MODEDIT_DELETE_PART, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_NEW_MODULE, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_NEW_MODULE_FROM_WIZARD, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_IMPORT_PART, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_EXPORT_PART, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_CREATE_NEW_LIB_AND_SAVE_CURRENT_PART,
+              FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_SHEET_SET, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_GEN_IMPORT_DXF_FILE, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( wxID_PRINT, FOOTPRINT_EDIT_FRAME::ToPrinter )
+    EVT_TOOL( ID_MODEDIT_LOAD_MODULE, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_CHECK, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_PAD_SETTINGS, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_LOAD_MODULE_FROM_BOARD, FOOTPRINT_EDIT_FRAME::LoadModuleFromBoard )
+    EVT_TOOL( ID_MODEDIT_INSERT_MODULE_IN_BOARD, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_UPDATE_MODULE_IN_BOARD, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( ID_MODEDIT_EDIT_MODULE_PROPERTIES, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_TOOL( wxID_UNDO, FOOTPRINT_EDIT_FRAME::RestoreCopyFromUndoList )
+    EVT_TOOL( wxID_REDO, FOOTPRINT_EDIT_FRAME::RestoreCopyFromRedoList )
+
+    // Vertical tool bar button click event handler.
+    EVT_TOOL( ID_NO_TOOL_SELECTED, FOOTPRINT_EDIT_FRAME::OnVerticalToolbar )
+    EVT_TOOL_RANGE( ID_MODEDIT_PAD_TOOL, ID_MODEDIT_PLACE_GRID_COORD,
+                    FOOTPRINT_EDIT_FRAME::OnVerticalToolbar )
+
+    // Options Toolbar (ID_TB_OPTIONS_SHOW_PADS_SKETCH id is managed in PCB_BASE_FRAME)
+    EVT_TOOL( ID_TB_OPTIONS_SHOW_MODULE_TEXT_SKETCH, FOOTPRINT_EDIT_FRAME::OnSelectOptionToolbar )
+    EVT_TOOL( ID_TB_OPTIONS_SHOW_MODULE_EDGE_SKETCH, FOOTPRINT_EDIT_FRAME::OnSelectOptionToolbar )
+    EVT_TOOL( ID_TB_OPTIONS_SHOW_HIGH_CONTRAST_MODE, FOOTPRINT_EDIT_FRAME::OnSelectOptionToolbar )
+
+    // Preferences and option menus
+    EVT_MENU( ID_PREFERENCES_HOTKEY_EXPORT_CONFIG,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PREFERENCES_HOTKEY_IMPORT_CONFIG,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PREFERENCES_HOTKEY_SHOW_EDITOR,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PCB_LIB_WIZARD,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PCB_LIB_TABLE_EDIT,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( wxID_PREFERENCES,
+              FOOTPRINT_EDIT_FRAME::ProcessPreferences )
+    EVT_MENU( ID_PREFERENCES_CONFIGURE_PATHS, FOOTPRINT_EDIT_FRAME::OnConfigurePaths )
+
+    // popup commands
+    EVT_MENU_RANGE( ID_POPUP_PCB_START_RANGE, ID_POPUP_PCB_END_RANGE,
+                    FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    EVT_MENU_RANGE( ID_POPUP_GENERAL_START_RANGE, ID_POPUP_GENERAL_END_RANGE,
+                    FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    EVT_MENU( ID_POPUP_MODEDIT_EDIT_BODY_ITEM,
+              FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_POPUP_MODEDIT_EDIT_WIDTH_ALL_EDGE,
+              FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_POPUP_MODEDIT_EDIT_LAYER_ALL_EDGE,
+              FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_POPUP_MODEDIT_ENTER_EDGE_WIDTH, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    // Module transformations
+    EVT_MENU( ID_MODEDIT_MODULE_ROTATE, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_MODEDIT_MODULE_MIRROR, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_MODEDIT_MODULE_MOVE_EXACT, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    EVT_MENU( ID_PCB_DRAWINGS_WIDTHS_SETUP, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_PCB_PAD_SETUP, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+    EVT_MENU( ID_PCB_USER_GRID_SETUP, FOOTPRINT_EDIT_FRAME::Process_Special_Functions )
+
+    // Menu Help
+    EVT_MENU( wxID_HELP, EDA_DRAW_FRAME::GetKicadHelp )
+    EVT_MENU( wxID_INDEX, EDA_DRAW_FRAME::GetKicadHelp )
+    EVT_MENU( wxID_ABOUT, EDA_BASE_FRAME::GetKicadAbout )
+
+    // Menu 3D Frame
+    EVT_MENU( ID_MENU_PCB_SHOW_3D_FRAME, FOOTPRINT_EDIT_FRAME::Show3D_Frame )
+
+    // Switching canvases
+    EVT_MENU( ID_MENU_CANVAS_DEFAULT, PCB_BASE_FRAME::SwitchCanvas )
+    EVT_MENU( ID_MENU_CANVAS_CAIRO, PCB_BASE_FRAME::SwitchCanvas )
+    EVT_MENU( ID_MENU_CANVAS_OPENGL, PCB_BASE_FRAME::SwitchCanvas )
+
+    // UI update events.
+    EVT_UPDATE_UI( ID_MODEDIT_DELETE_PART, FOOTPRINT_EDIT_FRAME::OnUpdateLibSelected )
+    EVT_UPDATE_UI( ID_MODEDIT_SELECT_CURRENT_LIB, FOOTPRINT_EDIT_FRAME::OnUpdateSelectCurrentLib )
+    EVT_UPDATE_UI( ID_MODEDIT_EXPORT_PART, FOOTPRINT_EDIT_FRAME::OnUpdateModuleSelected )
+    EVT_UPDATE_UI( ID_MODEDIT_CREATE_NEW_LIB_AND_SAVE_CURRENT_PART,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateModuleSelected )
+    EVT_UPDATE_UI( ID_MODEDIT_SAVE_LIBMODULE, FOOTPRINT_EDIT_FRAME::OnUpdateLibAndModuleSelected )
+    EVT_UPDATE_UI( ID_MODEDIT_LOAD_MODULE_FROM_BOARD,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateLoadModuleFromBoard )
+    EVT_UPDATE_UI( ID_MODEDIT_INSERT_MODULE_IN_BOARD,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateInsertModuleInBoard )
+    EVT_UPDATE_UI( ID_MODEDIT_UPDATE_MODULE_IN_BOARD,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateReplaceModuleInBoard )
+    EVT_UPDATE_UI( ID_NO_TOOL_SELECTED, FOOTPRINT_EDIT_FRAME::OnUpdateVerticalToolbar )
+
+    EVT_UPDATE_UI_RANGE( ID_MODEDIT_PAD_TOOL, ID_MODEDIT_PLACE_GRID_COORD,
+                         FOOTPRINT_EDIT_FRAME::OnUpdateVerticalToolbar )
+
+    // Option toolbar:
+    EVT_UPDATE_UI( ID_TB_OPTIONS_SHOW_MODULE_TEXT_SKETCH,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateOptionsToolbar )
+    EVT_UPDATE_UI( ID_TB_OPTIONS_SHOW_MODULE_EDGE_SKETCH,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateOptionsToolbar )
+    EVT_UPDATE_UI( ID_TB_OPTIONS_SHOW_HIGH_CONTRAST_MODE,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateOptionsToolbar )
+
+    EVT_UPDATE_UI( ID_GEN_IMPORT_DXF_FILE,
+                   FOOTPRINT_EDIT_FRAME::OnUpdateModuleSelected )
+
+END_EVENT_TABLE()
+
+#define FOOTPRINT_EDIT_FRAME_NAME wxT( "ModEditFrame" )
+
+FOOTPRINT_EDIT_FRAME::FOOTPRINT_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
+    PCB_BASE_EDIT_FRAME( aKiway, aParent, FRAME_PCB_MODULE_EDITOR, wxEmptyString,
+                         wxDefaultPosition, wxDefaultSize,
+                         KICAD_DEFAULT_DRAWFRAME_STYLE, GetFootprintEditorFrameName() )
+{
+    m_showBorderAndTitleBlock = false;   // true to show the frame references
+    m_showAxis = true;                   // true to show X and Y axis on screen
+    m_showGridAxis = true;               // show the grid origin axis
+    m_hotkeysDescrList = g_Module_Editor_Hokeys_Descr;
+
+    // Give an icon
+    wxIcon icon;
+    icon.CopyFromBitmap( KiBitmap( icon_modedit_xpm ) );
+    SetIcon( icon );
+
+    // Show a title (frame title + footprint name):
+    updateTitle();
+
+    // Create GAL canvas
+    PCB_BASE_FRAME* parentFrame = static_cast<PCB_BASE_FRAME*>( Kiway().Player( FRAME_PCB, true ) );
+    PCB_DRAW_PANEL_GAL* drawPanel = new PCB_DRAW_PANEL_GAL( this, -1, wxPoint( 0, 0 ), m_FrameSize,
+                                                            parentFrame->GetGalCanvas()->GetBackend() );
+    SetGalCanvas( drawPanel );
+
+    SetBoard( new BOARD() );
+    // In modedit, the default net clearance is not known.
+    // (it depends on the actual board)
+    // So we do not show the default clearance, by setting it to 0
+    // The footprint or pad specific clearance will be shown
+    GetBoard()->GetDesignSettings().GetDefault()->SetClearance( 0 );
+
+    // Don't show the default board solder mask clearance in the footprint editor.  Only the
+    // footprint or pad clearance setting should be shown if it is not 0.
+    GetBoard()->GetDesignSettings().m_SolderMaskMargin = 0;
+
+    // restore the last footprint from the project, if any
+    restoreLastFootprint();
+
+    // Ensure all layers and items are visible:
+    // In footprint editor, some layers have no meaning or
+    // cannot be used, but we show all of them, at least to be able
+    // to edit a bad layer
+    GetBoard()->SetVisibleAlls();
+
+    wxFont font = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
+    m_Layers = new PCB_LAYER_WIDGET( this, GetCanvas(), font.GetPointSize(), true );
+
+    LoadSettings( config() );
+    SetScreen( new PCB_SCREEN( GetPageSettings().GetSizeIU() ) );
+    GetScreen()->SetMaxUndoItems( m_UndoRedoCountMax );
+    GetScreen()->SetCurItem( NULL );
+
+    GetScreen()->AddGrid( m_UserGridSize, m_UserGridUnit, ID_POPUP_GRID_USER );
+    GetScreen()->SetGrid( ID_POPUP_GRID_LEVEL_1000 + m_LastGridSizeId );
+
+    // In modedit, set the default paper size to A4:
+    // this should be OK for all footprint to plot/print
+    SetPageSettings( PAGE_INFO( PAGE_INFO::A4 ) );
+
+    SetSize( m_FramePos.x, m_FramePos.y, m_FrameSize.x, m_FrameSize.y );
+    ReCreateMenuBar();
+    ReCreateHToolbar();
+    ReCreateAuxiliaryToolbar();
+    ReCreateVToolbar();
+    ReCreateOptToolbar();
+
+    if( m_canvas )
+        m_canvas->SetEnableBlockCommands( true );
+
+    m_auimgr.SetManagedWindow( this );
+
+    EDA_PANEINFO horiz;
+    horiz.HorizontalToolbarPane();
+
+    EDA_PANEINFO vert;
+    vert.VerticalToolbarPane();
+
+    EDA_PANEINFO mesg_pane;
+    mesg_pane.MessageToolbarPane();
+
+    // Create a wxAuiPaneInfo for the Layers Manager, not derived from the template.
+    // LAYER_WIDGET is floatable, but initially docked at far right
+    EDA_PANEINFO   lyrs;
+    lyrs.LayersToolbarPane();
+    lyrs.MinSize( m_Layers->GetBestSize() );    // updated in ReFillLayerWidget
+    lyrs.BestSize( m_Layers->GetBestSize() );
+    lyrs.Caption( _( "Visibles" ) );
+
+    m_auimgr.AddPane( m_mainToolBar,
+                      wxAuiPaneInfo( horiz ).Name( wxT( "m_mainToolBar" ) ).Top(). Row( 0 ) );
+
+    m_auimgr.AddPane( m_auxiliaryToolBar,
+                      wxAuiPaneInfo( horiz ).Name( wxT( "m_auxiliaryToolBar" ) ).Top().Row( 1 ) );
+
+    // The main right vertical toolbar
+    m_auimgr.AddPane( m_drawToolBar,
+                      wxAuiPaneInfo( vert ).Name( wxT( "m_VToolBar" ) ).Right().Layer(1) );
+
+    // Add the layer manager ( most right side of pcbframe )
+    m_auimgr.AddPane( m_Layers, lyrs.Name( wxT( "m_LayersManagerToolBar" ) ).Right().Layer( 2 ) );
+    // Layers manager is visible
+    m_auimgr.GetPane( wxT( "m_LayersManagerToolBar" ) ).Show( true );
+
+    // The left vertical toolbar (fast acces to display options)
+    m_auimgr.AddPane( m_optionsToolBar,
+                      wxAuiPaneInfo( vert ).Name( wxT( "m_optionsToolBar" ) ). Left().Layer(1) );
+
+    m_auimgr.AddPane( m_canvas,
+                      wxAuiPaneInfo().Name( wxT( "DrawFrame" ) ).CentrePane() );
+    m_auimgr.AddPane( (wxWindow*) GetGalCanvas(),
+                      wxAuiPaneInfo().Name( wxT( "DrawFrameGal" ) ).CentrePane().Hide() );
+
+    m_auimgr.AddPane( m_messagePanel,
+                      wxAuiPaneInfo( mesg_pane ).Name( wxT( "MsgPanel" ) ).Bottom().Layer(10) );
+
+    // Create the manager and dispatcher & route draw panel events to the dispatcher
+    setupTools();
+    UseGalCanvas( parentFrame->IsGalCanvasActive() );
+
+    if( m_auimgr.GetPane( wxT( "m_LayersManagerToolBar" ) ).IsShown() )
+    {
+        m_Layers->ReFill();
+        m_Layers->ReFillRender();
+
+        GetScreen()->m_Active_Layer = F_SilkS;
+        m_Layers->SelectLayer( F_SilkS );
+        m_Layers->OnLayerSelected();
+    }
+
+    m_auimgr.Update();
+
+    Raise();            // On some window managers, this is needed
+    Show( true );
+
+    Zoom_Automatique( false );
+}
+
+
+FOOTPRINT_EDIT_FRAME::~FOOTPRINT_EDIT_FRAME()
+{
+    // save the footprint in the PROJECT
+    retainLastFootprint();
+
+    delete m_Layers;
+}
+
+
+const wxString FOOTPRINT_EDIT_FRAME::getLibPath()
+{
+    try
+    {
+        const wxString& nickname = GetCurrentLib();
+
+        const FP_LIB_TABLE::ROW* row = Prj().PcbFootprintLibs()->FindRow( nickname );
+
+        return row->GetFullURI( true );
+    }
+    catch( const IO_ERROR& ioe )
+    {
+        return wxEmptyString;
+    }
+}
+
+
+const wxString FOOTPRINT_EDIT_FRAME::GetCurrentLib() const
+{
+    return Prj().GetRString( PROJECT::PCB_LIB_NICKNAME );
+};
+
+
+void FOOTPRINT_EDIT_FRAME::retainLastFootprint()
+{
+    PCB_IO  pcb_io;
+    MODULE* module = GetBoard()->m_Modules;
+
+    if( module )
+    {
+        pcb_io.Format( module );
+
+        wxString pretty = FROM_UTF8( pcb_io.GetStringOutput( true ).c_str() );
+
+        // save the footprint in the RSTRING facility.
+        Prj().SetRString( PROJECT::PCB_FOOTPRINT, pretty );
+    }
+}
+
+
+void FOOTPRINT_EDIT_FRAME::restoreLastFootprint()
+{
+    wxString pretty = Prj().GetRString( PROJECT::PCB_FOOTPRINT );
+
+    if( !!pretty )
+    {
+        PCB_IO  pcb_io;
+        MODULE* module = NULL;
+
+        try
+        {
+            module = (MODULE*) pcb_io.Parse( pretty );
+        }
+        catch( const PARSE_ERROR& pe )
+        {
+            // unlikely to be a problem, since we produced the pretty string.
+            wxLogError( wxT( "PARSE_ERROR" ) );
+        }
+        catch( const IO_ERROR& ioe )
+        {
+            // unlikely to be a problem, since we produced the pretty string.
+            wxLogError( wxT( "IO_ERROR" ) );
+        }
+
+        if( module )
+        {
+            // assumes BOARD is empty.
+            wxASSERT( GetBoard()->m_Modules == NULL );
+
+            // no idea, its monkey see monkey do.  I would encapsulate this into
+            // a member function if its actually necessary.
+            module->SetParent( GetBoard() );
+            module->SetLink( 0 );
+
+            GetBoard()->Add( module );
+        }
+    }
+}
+
+
+const wxChar* FOOTPRINT_EDIT_FRAME::GetFootprintEditorFrameName()
+{
+    return FOOTPRINT_EDIT_FRAME_NAME;
+}
+
+
+BOARD_DESIGN_SETTINGS& FOOTPRINT_EDIT_FRAME::GetDesignSettings() const
+{
+    return GetBoard()->GetDesignSettings();
+}
+
+
+void FOOTPRINT_EDIT_FRAME::SetDesignSettings( const BOARD_DESIGN_SETTINGS& aSettings )
+{
+    GetBoard()->SetDesignSettings( aSettings );
+}
+
+
+const PCB_PLOT_PARAMS& FOOTPRINT_EDIT_FRAME::GetPlotSettings() const
+{
+    // get the settings from the parent editor, not our BOARD.
+
+    // @todo(DICK) change the routing to some default or the board directly, parent may not exist
+    PCB_BASE_FRAME* parentFrame = (PCB_BASE_FRAME*) Kiway().Player( FRAME_PCB, true );
+    wxASSERT( parentFrame );
+
+    return parentFrame->GetPlotSettings();
+}
+
+
+void FOOTPRINT_EDIT_FRAME::SetPlotSettings( const PCB_PLOT_PARAMS& aSettings )
+{
+    // set the settings into parent editor, not our BOARD.
+
+    // @todo(DICK) change the routing to some default or the board directly, parent may not exist
+    PCB_BASE_FRAME* parentFrame = (PCB_BASE_FRAME*) Kiway().Player( FRAME_PCB, true );
+    wxASSERT( parentFrame );
+
+    parentFrame->SetPlotSettings( aSettings );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::LoadSettings( wxConfigBase* aCfg )
+{
+    PCB_BASE_FRAME::LoadSettings( aCfg );
+    wxConfigLoadSetups( aCfg, GetConfigurationSettings() );
+
+    // Ensure some params are valid
+    BOARD_DESIGN_SETTINGS& settings = GetDesignSettings();
+
+    // Usually, graphic items are drawn on F_SilkS or F_Fab layer
+    // Force these layers if not default
+    if( ( settings.m_RefDefaultlayer != F_SilkS ) && ( settings.m_RefDefaultlayer != F_Fab ) )
+        settings.m_RefDefaultlayer = F_SilkS;
+
+    if( ( settings.m_ValueDefaultlayer != F_SilkS ) && ( settings.m_ValueDefaultlayer != F_Fab ) )
+        settings.m_ValueDefaultlayer = F_Fab;
+}
+
+
+void FOOTPRINT_EDIT_FRAME::SaveSettings( wxConfigBase* aCfg )
+{
+    PCB_BASE_FRAME::SaveSettings( aCfg );
+    wxConfigSaveSetups( aCfg, GetConfigurationSettings() );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnCloseWindow( wxCloseEvent& Event )
+{
+    if( GetScreen()->IsModify() )
+    {
+        int ii = DisplayExitDialog( this, _( "Save the changes to the footprint before closing?" ) );
+
+        switch( ii )
+        {
+        case wxID_NO:
+            break;
+
+        case wxID_YES:
+            // code from FOOTPRINT_EDIT_FRAME::Process_Special_Functions,
+            // at case ID_MODEDIT_SAVE_LIBMODULE
+            if( GetBoard()->m_Modules && GetCurrentLib().size() )
+            {
+                if( SaveFootprintInLibrary( GetCurrentLib(), GetBoard()->m_Modules, true, true ) )
+                {
+                    // save was correct
+                    GetScreen()->ClrModify();
+                    break;
+                }
+            }
+            else
+            {
+                DisplayError( this, _( "Library is not set, the footprint could not be saved." ) );
+            }
+            // fall through: cancel the close because of an error
+
+        case wxID_CANCEL:
+            Event.Veto();
+            return;
+        }
+    }
+
+    if( IsGalCanvasActive() )
+        GetGalCanvas()->StopDrawing();
+
+    //close the editor
+    Destroy();
+}
+
+
+void FOOTPRINT_EDIT_FRAME::CloseModuleEditor( wxCommandEvent& Event )
+{
+    Close();
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateVerticalToolbar( wxUpdateUIEvent& aEvent )
+{
+    aEvent.Enable( GetBoard()->m_Modules != NULL );
+
+    if( aEvent.GetEventObject() == m_drawToolBar )
+        aEvent.Check( GetToolId() == aEvent.GetId() );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateOptionsToolbar( wxUpdateUIEvent& aEvent )
+{
+    int        id = aEvent.GetId();
+    DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)GetDisplayOptions();
+
+    bool state = false;
+
+    switch( id )
+    {
+    case ID_TB_OPTIONS_SHOW_MODULE_TEXT_SKETCH:
+        state = displ_opts->m_DisplayModTextFill == SKETCH;
+        break;
+
+    case ID_TB_OPTIONS_SHOW_MODULE_EDGE_SKETCH:
+        state = displ_opts->m_DisplayModEdgeFill == SKETCH;
+        break;
+
+    case ID_TB_OPTIONS_SHOW_HIGH_CONTRAST_MODE:
+        state = displ_opts->m_ContrastModeDisplay;
+        break;
+
+    default:
+        wxMessageBox( wxT( "FOOTPRINT_EDIT_FRAME::OnUpdateOptionsToolbar error" ) );
+        break;
+    }
+
+    aEvent.Check( state );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateLibSelected( wxUpdateUIEvent& aEvent )
+{
+    bool enable = getLibPath() != wxEmptyString;
+    aEvent.Enable( enable );
+    GetMenuBar()->Enable( ID_MODEDIT_SAVE_LIBRARY_AS, enable );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateModuleSelected( wxUpdateUIEvent& aEvent )
+{
+    aEvent.Enable( GetBoard()->m_Modules != NULL );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateLibAndModuleSelected( wxUpdateUIEvent& aEvent )
+{
+    aEvent.Enable( getLibPath() != wxEmptyString  &&  GetBoard()->m_Modules != NULL );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateLoadModuleFromBoard( wxUpdateUIEvent& aEvent )
+{
+    PCB_EDIT_FRAME* frame = (PCB_EDIT_FRAME*) Kiway().Player( FRAME_PCB, false );
+
+    aEvent.Enable( frame && frame->GetBoard()->m_Modules != NULL );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateInsertModuleInBoard( wxUpdateUIEvent& aEvent )
+{
+    PCB_EDIT_FRAME* frame = (PCB_EDIT_FRAME*) Kiway().Player( FRAME_PCB, false );
+
+    MODULE* module_in_edit = GetBoard()->m_Modules;
+    bool canInsert = frame && module_in_edit && !module_in_edit->GetLink();
+
+    // If the source was deleted, the module can inserted but not updated in the board.
+    if( frame && module_in_edit && module_in_edit->GetLink() ) // this is not a new module
+    {
+        BOARD*  mainpcb = frame->GetBoard();
+        MODULE* source_module = mainpcb->m_Modules;
+
+        // search if the source module was not deleted:
+        for( ; source_module != NULL; source_module = source_module->Next() )
+        {
+            if( module_in_edit->GetLink() == source_module->GetTimeStamp() )
+                break;
+        }
+
+        canInsert = ( source_module == NULL );
+    }
+
+    aEvent.Enable( canInsert );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateReplaceModuleInBoard( wxUpdateUIEvent& aEvent )
+{
+    PCB_EDIT_FRAME* frame = (PCB_EDIT_FRAME*) Kiway().Player( FRAME_PCB, false );
+
+    MODULE* module_in_edit = GetBoard()->m_Modules;
+    bool canReplace = frame && module_in_edit && module_in_edit->GetLink();
+
+    if( canReplace ) // this is not a new module, but verify if the source is still on board
+    {
+        BOARD*  mainpcb = frame->GetBoard();
+        MODULE* source_module = mainpcb->m_Modules;
+
+        // search if the source module was not deleted:
+        for( ; source_module != NULL; source_module = source_module->Next() )
+        {
+            if( module_in_edit->GetLink() == source_module->GetTimeStamp() )
+                break;
+        }
+
+        canReplace = ( source_module != NULL );
+    }
+
+    aEvent.Enable( canReplace );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnUpdateSelectCurrentLib( wxUpdateUIEvent& aEvent )
+{
+    FP_LIB_TABLE* fptbl = Prj().PcbFootprintLibs();
+
+    aEvent.Enable( fptbl && !fptbl->IsEmpty() );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::Show3D_Frame( wxCommandEvent& event )
+{
+    if( m_Draw3DFrame )
+    {
+        // Raising the window does not show the window on Windows if iconized.
+        // This should work on any platform.
+        if( m_Draw3DFrame->IsIconized() )
+             m_Draw3DFrame->Iconize( false );
+
+        m_Draw3DFrame->Raise();
+
+        // Raising the window does not set the focus on Linux.  This should work on any platform.
+        if( wxWindow::FindFocus() != m_Draw3DFrame )
+            m_Draw3DFrame->SetFocus();
+
+        return;
+    }
+
+    m_Draw3DFrame = new EDA_3D_FRAME( &Kiway(), this, _( "3D Viewer" ) );
+    m_Draw3DFrame->Raise();     // Needed with some Window Managers
+    m_Draw3DFrame->Show( true );
+}
+
+
+bool FOOTPRINT_EDIT_FRAME::GeneralControl( wxDC* aDC, const wxPoint& aPosition, int aHotKey )
+{
+    bool eventHandled = true;
+
+    // Filter out the 'fake' mouse motion after a keyboard movement
+    if( !aHotKey && m_movingCursorWithKeyboard )
+    {
+        m_movingCursorWithKeyboard = false;
+        return false;
+    }
+
+    // when moving mouse, use the "magnetic" grid, unless the shift+ctrl keys is pressed
+    // for next cursor position
+    // ( shift or ctrl key down are PAN command with mouse wheel)
+    bool snapToGrid = true;
+
+    if( !aHotKey && wxGetKeyState( WXK_SHIFT ) && wxGetKeyState( WXK_CONTROL ) )
+        snapToGrid = false;
+
+    wxPoint oldpos = GetCrossHairPosition();
+    wxPoint pos = aPosition;
+    GeneralControlKeyMovement( aHotKey, &pos, snapToGrid );
+
+    SetCrossHairPosition( pos, snapToGrid );
+    RefreshCrossHair( oldpos, aPosition, aDC );
+
+    if( aHotKey )
+    {
+        eventHandled = OnHotKey( aDC, aHotKey, aPosition );
+    }
+
+    UpdateStatusBar();
+
+    return eventHandled;
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnModify()
+{
+    PCB_BASE_FRAME::OnModify();
+
+    if( m_Draw3DFrame )
+        m_Draw3DFrame->ReloadRequest();
+}
+
+
+void FOOTPRINT_EDIT_FRAME::updateTitle()
+{
+    wxString title   = _( "Footprint Editor " );
+
+    wxString nickname = GetCurrentLib();
+
+    if( !nickname )
+    {
+    L_none:
+        title += _( "(no active library)" );
+    }
+    else
+    {
+        try
+        {
+            bool writable = Prj().PcbFootprintLibs()->IsFootprintLibWritable( nickname );
+
+            // no exception was thrown, this means libPath is valid, but it may be read only.
+            title = _( "Footprint Editor (active library: " ) + nickname + wxT( ")" );
+
+            if( !writable )
+                title += _( " [Read Only]" );
+        }
+        catch( const IO_ERROR& ioe )
+        {
+            // user may be bewildered as to why after selecting a library it is not showing up
+            // in the title, we could show an error message, but that should have been done at time
+            // of libary selection UI.
+            goto L_none;
+        }
+    }
+
+    SetTitle( title );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::updateView()
+{
+    static_cast<PCB_DRAW_PANEL_GAL*>( GetGalCanvas() )->DisplayBoard( GetBoard() );
+    m_toolManager->ResetTools( TOOL_BASE::MODEL_RELOAD );
+    m_toolManager->RunAction( COMMON_ACTIONS::zoomFitScreen, true );
+}
+
+
+bool FOOTPRINT_EDIT_FRAME::IsGridVisible() const
+{
+    return IsElementVisible( GRID_VISIBLE );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::SetGridVisibility(bool aVisible)
+{
+    SetElementVisibility( GRID_VISIBLE, aVisible );
+}
+
+
+bool FOOTPRINT_EDIT_FRAME::IsElementVisible( int aElement ) const
+{
+    return GetBoard()->IsElementVisible( aElement );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::SetElementVisibility( int aElement, bool aNewState )
+{
+    GetGalCanvas()->GetView()->SetLayerVisible( ITEM_GAL_LAYER( aElement ), aNewState );
+    GetBoard()->SetElementVisibility( aElement, aNewState );
+    m_Layers->SetRenderState( aElement, aNewState );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::ProcessPreferences( wxCommandEvent& event )
+{
+    int id = event.GetId();
+
+    switch( id )
+    {
+    // Hotkey IDs
+    case ID_PREFERENCES_HOTKEY_EXPORT_CONFIG:
+        ExportHotkeyConfigToFile( g_Module_Editor_Hokeys_Descr, wxT( "pcbnew" ) );
+        break;
+
+    case ID_PREFERENCES_HOTKEY_IMPORT_CONFIG:
+        ImportHotkeyConfigFromFile( g_Module_Editor_Hokeys_Descr, wxT( "pcbnew" ) );
+        break;
+
+    case ID_PREFERENCES_HOTKEY_SHOW_EDITOR:
+        InstallHotkeyFrame( this, g_Module_Editor_Hokeys_Descr );
+        break;
+
+    case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST:
+        // Display current hotkey list for the footprint editor.
+        DisplayHotkeyList( this, g_Module_Editor_Hokeys_Descr );
+        break;
+
+    case ID_PCB_LIB_WIZARD:
+    case ID_PCB_LIB_TABLE_EDIT:
+        {
+            bool tableChanged = false;
+            int r = 0;
+
+            if( id == ID_PCB_LIB_TABLE_EDIT )
+                r = InvokePcbLibTableEditor( this, &GFootprintTable, Prj().PcbFootprintLibs() );
+            else
+                r = InvokeFootprintWizard( this, &GFootprintTable, Prj().PcbFootprintLibs() );
+
+            if( r & 1 )
+            {
+                try
+                {
+                    FILE_OUTPUTFORMATTER sf( FP_LIB_TABLE::GetGlobalTableFileName() );
+
+                    GFootprintTable.Format( &sf, 0 );
+                    tableChanged = true;
+                }
+                catch( const IO_ERROR& ioe )
+                {
+                    wxString msg = wxString::Format( _(
+                        "Error occurred saving the global footprint library "
+                        "table:\n\n%s" ),
+                        GetChars( ioe.errorText.GetData() )
+                        );
+                    wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
+                }
+            }
+
+            if( r & 2 )
+            {
+                wxString tblName = Prj().FootprintLibTblName();
+
+                try
+                {
+                    Prj().PcbFootprintLibs()->Save( tblName );
+                    tableChanged = true;
+                }
+                catch( const IO_ERROR& ioe )
+                {
+                    wxString msg = wxString::Format( _(
+                        "Error occurred saving project specific footprint library "
+                        "table:\n\n%s" ),
+                        GetChars( ioe.errorText )
+                        );
+                    wxMessageBox( msg, _( "File Save Error" ), wxOK | wxICON_ERROR );
+                }
+            }
+
+            FOOTPRINT_VIEWER_FRAME* viewer;
+            viewer = (FOOTPRINT_VIEWER_FRAME*)Kiway().Player( FRAME_PCB_MODULE_VIEWER, false );
+
+            if( tableChanged && viewer != NULL )
+                viewer->ReCreateLibraryList();
+        }
+        break;
+
+    case wxID_PREFERENCES:
+        InvokeFPEditorPrefsDlg( this );
+        break;
+
+    default:
+        DisplayError( this, wxT( "FOOTPRINT_EDIT_FRAME::ProcessPreferences error" ) );
+    }
+}
+
+
+void FOOTPRINT_EDIT_FRAME::OnConfigurePaths( wxCommandEvent& aEvent )
+{
+    Pgm().ConfigurePaths( this );
+}
+
+
+void FOOTPRINT_EDIT_FRAME::setupTools()
+{
+    PCB_DRAW_PANEL_GAL* drawPanel = static_cast<PCB_DRAW_PANEL_GAL*>( GetGalCanvas() );
+
+    // Create the manager and dispatcher & route draw panel events to the dispatcher
+    m_toolManager = new TOOL_MANAGER;
+    m_toolManager->SetEnvironment( GetBoard(), drawPanel->GetView(),
+                                   drawPanel->GetViewControls(), this );
+    m_toolDispatcher = new TOOL_DISPATCHER( m_toolManager );
+
+    drawPanel->SetEventDispatcher( m_toolDispatcher );
+
+    m_toolManager->RegisterTool( new SELECTION_TOOL );
+    m_toolManager->RegisterTool( new EDIT_TOOL );
+    m_toolManager->RegisterTool( new DRAWING_TOOL );
+    m_toolManager->RegisterTool( new POINT_EDITOR );
+    m_toolManager->RegisterTool( new PCBNEW_CONTROL );
+    m_toolManager->RegisterTool( new MODULE_TOOLS );
+    m_toolManager->RegisterTool( new PLACEMENT_TOOL );
+    m_toolManager->RegisterTool( new PICKER_TOOL );
+
+    m_toolManager->GetTool<SELECTION_TOOL>()->EditModules( true );
+    m_toolManager->GetTool<EDIT_TOOL>()->EditModules( true );
+    m_toolManager->GetTool<DRAWING_TOOL>()->EditModules( true );
+
+    m_toolManager->ResetTools( TOOL_BASE::RUN );
+    m_toolManager->InvokeTool( "pcbnew.InteractiveSelection" );
+
+}
+
+
+void FOOTPRINT_EDIT_FRAME::UseGalCanvas( bool aEnable )
+{
+    PCB_BASE_EDIT_FRAME::UseGalCanvas( aEnable );
+
+    if( aEnable )
+        updateView();
+}