Merge ~kristoffer-odmark/kicad:tom-copypasta into ~kicad-product-committers/kicad:master

[Kristoffer]

Added copy-paste functionality to pcbnew. Coworked with Tomasz. I think it is fully acceptable in the current state and ready for mainstream testing.

[Wayne Stambaugh (stambaughw)]

Kristoffer,

Please do not put license text inside Doxygen comments. I also saw
quite a few coding policy violations:

Trailing white space.

Missing spaces around function argument braces.

100 character line length exceeded.

Only one empty space (should be 2) between method definitions in .cpp
source files.

Curly bracket not on next line.

Incorrect indentation level.

Please clean these up before we merge your patch.

Thanks,

Wayne

On 9/26/2017 1:58 PM, Kristoffer wrote:
> Kristoffer has proposed merging ~kristoffer-odmark/kicad:tom-copypasta into kicad:master.
>
> Requested reviews:
> Tomasz Wlostowski (twlostow)
>
> For more details, see:
> https://code.launchpad.net/~kristoffer-odmark/kicad/+git/kicad/+merge/331369
>
> Added copy-paste functionality to pcbnew. Coworked with Tomasz. I think it is fully acceptable in the current state and ready for mainstream testing.
>
>

1faee98... by Kristoffer on 2017-09-26

some coding violations fixed

[Kristoffer (kristoffer-odmark)]

Does it look better now?

[Tomasz Wlostowski (twlostow)]

On 27.09.2017 20:46, Kristoffer wrote:
> Does it look better now?
>
Hi Kristoffer,

I've had a quick look (not at the code style yet):
- there's a bug that makes the selection go in crazy direciton when
moving cursor with arrow keys. I'm working now to fix it.
- the code for merging NETINFO_ITEMs from the board being pasted is OK,
but the net propagation is not what I meant (in some cases, pasted
tracks/vias don't inherit the nets of the pads they're pasted over).

Tom

[Kristoffer (kristoffer-odmark)]

Any progress?

[Franck78 (fbourdonnec)]

Why is this thing still in 'pending' state ????????????????

It ages around 4.0.7 release (2017)
We are 2 years latter 5.1.x (2019)
Some Copy/paste in v5 v6 is implemented

Except for discouraging a new developer (too late for Kristoffer) to join, a patch is accepted or rejected in a reasonable delay.

[Tomasz Wlostowski (twlostow)]

The branch was merged in 2017, with the exception of two last commits (https://git.launchpad.net/~kristoffer-odmark/kicad/commit/?id=7a58afc154868efbe4f4a62961e1c11aa81d01e2 - this one does introduce new functionality without undo, which doesn't fit in our plans).

And since you mentioned discouraging developers - stop bitching, Franck. You are not contributing anything valuable to the project, just complaining. I sometimes feel quite discouraged from contributing just because of your negativity.

Tom

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index a325d23..93d4692 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -403,6 +403,7 @@ set( PCB_COMMON_SRCS
     ../pcbnew/eagle_plugin.cpp
     ../pcbnew/legacy_plugin.cpp
     ../pcbnew/kicad_plugin.cpp
+    ../pcbnew/kicad_clipboard.cpp
     ../pcbnew/gpcb_plugin.cpp
     ../pcbnew/pcb_netlist.cpp
     widgets/widget_net_selector.cpp
diff --git a/include/tool/selection.h b/include/tool/selection.h
index 7e4f488..fb0c735 100644
--- a/include/tool/selection.h
+++ b/include/tool/selection.h
@@ -170,7 +170,30 @@ public:
 
     virtual const VIEW_GROUP::ITEMS updateDrawList() const override;
 
+    bool HasReferencePoint() const
+    {
+        return m_referencePoint != boost::none;
+    }
+
+    VECTOR2I GetReferencePoint() const
+    {
+        return *m_referencePoint;
+    }
+
+    void SetReferencePoint( const VECTOR2I& aP )
+    {
+        m_referencePoint = aP;
+    }
+
+    void ClearReferencePoint()
+    {
+        m_referencePoint = boost::none;
+    }
+
 private:
+
+    boost::optional<VECTOR2I> m_referencePoint;
+
     /// Set of selected items
     std::set<EDA_ITEM*> m_items;
 
diff --git a/pcbnew/board_commit.cpp b/pcbnew/board_commit.cpp
index 8ddfbcb..a967096 100644
--- a/pcbnew/board_commit.cpp
+++ b/pcbnew/board_commit.cpp
@@ -132,6 +132,7 @@ void BOARD_COMMIT::Push( const wxString& aMessage, bool aCreateUndoEntry )
                     // modules inside modules are not supported yet
                     assert( boardItem->Type() != PCB_MODULE_T );
 
+                    boardItem->SetParent( board->m_Modules.GetFirst() );
                     if( !( changeFlags & CHT_DONE ) )
                         board->m_Modules->Add( boardItem );
                 }
diff --git a/pcbnew/kicad_clipboard.cpp b/pcbnew/kicad_clipboard.cpp
new file mode 100644
index 0000000..38b59cf
--- /dev/null
+++ b/pcbnew/kicad_clipboard.cpp
@@ -0,0 +1,311 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2017 KiCad Developers, see CHANGELOG.TXT for contributors.
+ * @author Kristoffer Ödmark
+ *
+ * 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
+ */
+
+#include <wx/clipbrd.h>
+#include <common.h>
+#include <pcb_parser.h>
+#include <class_netinfo.h>
+#include <class_board.h>
+#include <build_version.h>
+
+#include <kicad_plugin.h>
+#include <kicad_clipboard.h>
+
+CLIPBOARD_IO::CLIPBOARD_IO():
+    PCB_IO( CTL_STD_LAYER_NAMES ),
+    m_formatter(),
+    m_parser( new CLIPBOARD_PARSER() )
+{
+    m_out = &m_formatter;
+}
+
+
+CLIPBOARD_IO::~CLIPBOARD_IO(){}
+
+
+STRING_FORMATTER* CLIPBOARD_IO::GetFormatter()
+{
+    return &m_formatter;
+}
+
+
+void CLIPBOARD_IO::SetBoard( BOARD* aBoard )
+{
+    m_board = aBoard;
+}
+
+
+void CLIPBOARD_IO::SaveSelection( const SELECTION& aSelected )
+{
+    LOCALE_IO   toggle;     // toggles on, then off, the C locale.
+    VECTOR2I refPoint( 0, 0 );
+
+    // dont even start if the selection is empty
+    if( aSelected.Empty() )
+        return;
+
+    if( aSelected.HasReferencePoint() )
+        refPoint = aSelected.GetReferencePoint();
+
+    // Prepare net mapping that assures that net codes saved in a file are consecutive integers
+    m_mapping->SetBoard( m_board );
+
+    // Differentiate how it is formatted depending on what selection contains
+    bool onlyModuleParts = true;
+    for( const auto i : aSelected )
+    {
+        // check if it not one of the module primitives
+        if( ( i->Type() != PCB_MODULE_EDGE_T ) &&
+                ( i->Type() != PCB_MODULE_TEXT_T ) &&
+                ( i->Type() != PCB_PAD_T ) )
+        {
+            onlyModuleParts = false;
+            continue;
+        }
+    }
+
+    // if there is only parts of a module selected, format it as a new module else
+    // format it as an entire board
+    MODULE partialModule( m_board );
+
+    // only a module selected.
+    if( aSelected.Size() == 1 && aSelected.Front()->Type() == PCB_MODULE_T )
+    {
+        // make the module safe to transfer to other pcbs
+        const MODULE* mod = static_cast<MODULE*>( aSelected.Front() );
+        // Do not modify existing board
+        MODULE newModule(*mod);
+
+        for( D_PAD* pad = newModule.PadsList().begin(); pad; pad = pad->Next() )
+        {
+            pad->SetNetCode( 0, 0 );
+        }
+
+        // locate the reference point at (0, 0) in the copied items
+        newModule.Move( wxPoint( -refPoint.x, -refPoint.y ) );
+
+        Format( static_cast<BOARD_ITEM*>( &newModule ) );
+    }
+    // partial module selected.
+    else if( onlyModuleParts )
+    {
+        for( const auto item : aSelected )
+        {
+            auto clone = static_cast<BOARD_ITEM*>( item->Clone() );
+
+            // Do not add reference/value - convert them to the common type
+            if( TEXTE_MODULE* text = dyn_cast<TEXTE_MODULE*>( clone ) )
+                text->SetType( TEXTE_MODULE::TEXT_is_DIVERS );
+
+            // If it is only a module, clear the nets from the pads
+            if( clone->Type() == PCB_PAD_T )
+            {
+               D_PAD* pad = static_cast<D_PAD*>( clone );
+               pad->SetNetCode( 0, 0 );
+            }
+
+            // locate the reference point at (0, 0) in the copied items
+            clone->Move( wxPoint(-refPoint.x, -refPoint.y ) );
+
+            partialModule.Add( clone );
+        }
+
+        // Set the new relative internal local coordinates of copied items
+        MODULE* editedModule = m_board->m_Modules;
+        wxPoint moveVector = partialModule.GetPosition() + editedModule->GetPosition();
+
+        partialModule.MoveAnchorPosition( moveVector );
+
+        Format( &partialModule, 0 );
+
+    }
+    // lots of stuff selected
+    else
+    {
+        // we will fake being a .kicad_pcb to get the full parser kicking
+        // This means we also need layers and nets
+        m_formatter.Print( 0, "(kicad_pcb (version %d) (host pcbnew %s)\n",
+                SEXPR_BOARD_FILE_VERSION, m_formatter.Quotew( GetBuildVersion() ).c_str() );
+
+
+        m_formatter.Print( 0, "\n" );
+
+        formatBoardLayers( m_board );
+        formatNetInformation( m_board );
+
+        m_formatter.Print( 0, "\n" );
+
+
+        for( const auto i : aSelected )
+        {
+            // Dont format stuff that cannot exist standalone!
+            if( ( i->Type() != PCB_MODULE_EDGE_T ) &&
+                ( i->Type() != PCB_MODULE_TEXT_T ) &&
+                ( i->Type() != PCB_PAD_T ) )
+            {
+                auto item = static_cast<BOARD_ITEM*>( i );
+                std::unique_ptr<BOARD_ITEM> clone( static_cast<BOARD_ITEM*> ( item->Clone() ) );
+
+                // locate the reference point at (0, 0) in the copied items
+                clone->Move( wxPoint(-refPoint.x, -refPoint.y ) );
+
+                Format( clone.get(), 1 );
+            }
+
+        }
+        m_formatter.Print( 0, "\n)" );
+    }
+    if( wxTheClipboard->Open() )
+    {
+        wxTheClipboard->SetData( new wxTextDataObject(
+                    wxString( m_formatter.GetString().c_str(), wxConvUTF8 ) ) );
+        wxTheClipboard->Close();
+    }
+}
+
+
+BOARD_ITEM* CLIPBOARD_IO::Parse()
+{
+    std::string result;
+
+    if( wxTheClipboard->Open() )
+    {
+        if( wxTheClipboard->IsSupported( wxDF_TEXT ) )
+        {
+            wxTextDataObject data;
+            wxTheClipboard->GetData( data );
+
+            result = data.GetText().mb_str();
+        }
+
+        wxTheClipboard->Close();
+    }
+
+    BOARD_ITEM *item;
+    try
+    {
+        item = PCB_IO::Parse( result );
+    } catch (...) {
+        item = nullptr;
+    }
+
+    return item;
+}
+
+
+void CLIPBOARD_IO::Save( const wxString& aFileName, BOARD* aBoard,
+                const PROPERTIES* aProperties )
+{
+    LOCALE_IO   toggle;     // toggles on, then off, the C locale.
+
+    init( aProperties );
+
+    m_board = aBoard;       // after init()
+
+    // Prepare net mapping that assures that net codes saved in a file are consecutive integers
+    m_mapping->SetBoard( aBoard );
+
+    STRING_FORMATTER    formatter;
+
+    m_out = &formatter;
+
+    m_out->Print( 0, "(kicad_pcb (version %d) (host pcbnew %s)\n", SEXPR_BOARD_FILE_VERSION,
+                  formatter.Quotew( GetBuildVersion() ).c_str() );
+
+    Format( aBoard, 1 );
+
+    m_out->Print( 0, ")\n" );
+
+    if( wxTheClipboard->Open() )
+    {
+        wxTheClipboard->SetData( new wxTextDataObject(
+                    wxString( m_formatter.GetString().c_str(), wxConvUTF8 ) ) );
+        wxTheClipboard->Close();
+    }
+
+}
+
+
+BOARD* CLIPBOARD_IO::Load( const wxString& aFileName,
+        BOARD* aAppendToMe, const PROPERTIES* aProperties )
+{
+    std::string result;
+
+    if( wxTheClipboard->Open() )
+    {
+        if( wxTheClipboard->IsSupported( wxDF_TEXT ) )
+        {
+            wxTextDataObject data;
+            wxTheClipboard->GetData( data );
+
+            result = data.GetText().mb_str();
+        }
+
+        wxTheClipboard->Close();
+    }
+
+    STRING_LINE_READER    reader(result, wxT( "clipboard" ) );
+
+    init( aProperties );
+
+    m_parser->SetLineReader( &reader );
+    m_parser->SetBoard( aAppendToMe );
+
+    BOARD_ITEM* item;
+    BOARD* board;
+
+    try
+    {
+        item =  m_parser->Parse();
+    }
+    catch( const FUTURE_FORMAT_ERROR& )
+    {
+        // Don't wrap a FUTURE_FORMAT_ERROR in another
+        throw;
+    }
+    catch( const PARSE_ERROR& parse_error )
+    {
+        if( m_parser->IsTooRecent() )
+            throw FUTURE_FORMAT_ERROR( parse_error, m_parser->GetRequiredVersion() );
+        else
+            throw;
+    }
+
+    if( item->Type() != PCB_T )
+    {
+        // The parser loaded something that was valid, but wasn't a board.
+        THROW_PARSE_ERROR( _( "Clipboard content is not Kicad compatible" ),
+                m_parser->CurSource(), m_parser->CurLine(),
+                m_parser->CurLineNumber(), m_parser->CurOffset() );
+    }
+    else
+    {
+        board = dynamic_cast<BOARD*>( item );
+    }
+    // Give the filename to the board if it's new
+    if( !aAppendToMe )
+        board->SetFileName( aFileName );
+
+    return board;
+}
diff --git a/pcbnew/kicad_clipboard.h b/pcbnew/kicad_clipboard.h
new file mode 100644
index 0000000..ccc2877
--- /dev/null
+++ b/pcbnew/kicad_clipboard.h
@@ -0,0 +1,81 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2017 KiCad Developers, see CHANGELOG.TXT for contributors.
+ * @author Kristoffer Ödmark
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#ifndef KICAD_CLIPBOARD_H
+#define KICAD_CLIPBOARD_H
+
+#include <kicad_plugin.h>
+#include <class_board_item.h>
+#include <class_module.h>
+#include <pcb_parser.h>
+#include <memory.h>
+
+#include <tool/selection.h>
+
+class CLIPBOARD_PARSER : public PCB_PARSER
+{
+public:
+    CLIPBOARD_PARSER( LINE_READER* aReader = NULL ): PCB_PARSER( aReader ) {};
+
+    MODULE* parseMODULE( wxArrayString* aInitialComments )
+    {
+       MODULE* mod = PCB_PARSER::parseMODULE( aInitialComments );
+
+       //TODO: figure out better way of handling paths
+       mod->SetPath( wxT( "" ) );
+       return mod;
+    }
+};
+
+
+class CLIPBOARD_IO : public PCB_IO
+{
+
+public:
+    /* Saves the entire board to the clipboard formatted using the PCB_IO formatting */
+    void Save( const wxString& aFileName, BOARD* aBoard,
+                const PROPERTIES* aProperties = NULL ) override;
+    /* Writes all the settings of the BOARD* set by setBoard() and then adds all
+     * the BOARD_ITEM* found in selection formatted by PCB_IO to clipboard as a text
+     */
+    void SaveSelection( const SELECTION& selected );
+
+    BOARD_ITEM* Parse();
+
+    BOARD* Load( const wxString& aFileName, BOARD* aAppendToMe, const PROPERTIES* aProperties = NULL ) override;
+    CLIPBOARD_IO();
+    ~CLIPBOARD_IO();
+
+    void SetBoard( BOARD* aBoard );
+    STRING_FORMATTER* GetFormatter();
+
+private:
+    void writeHeader( BOARD* aBoard );
+
+    STRING_FORMATTER m_formatter;
+    CLIPBOARD_PARSER* m_parser;
+};
+
+
+#endif /* KICAD_CLIPBOARD_H */
diff --git a/pcbnew/kicad_plugin.cpp b/pcbnew/kicad_plugin.cpp
index bdc632d..fbf7ee4 100644
--- a/pcbnew/kicad_plugin.cpp
+++ b/pcbnew/kicad_plugin.cpp
@@ -527,9 +527,9 @@ void PCB_IO::formatLayer( const BOARD_ITEM* aItem ) const
         m_out->Print( 0, " (layer %s)", m_out->Quotew( aItem->GetLayerName() ).c_str() );
 }
 
-
-void PCB_IO::format( BOARD* aBoard, int aNestLevel ) const
+void PCB_IO::formatSetup( BOARD* aBoard, int aNestLevel ) const
 {
+
     const BOARD_DESIGN_SETTINGS& dsnSettings = aBoard->GetDesignSettings();
 
     m_out->Print( 0, "\n" );
@@ -572,7 +572,8 @@ void PCB_IO::format( BOARD* aBoard, int aNestLevel ) const
 
     // Save used non-copper layers in the order they are defined.
     // desired sequence for non Cu BOARD layers.
-    static const PCB_LAYER_ID non_cu[] = {
+    static const PCB_LAYER_ID non_cu[] =
+    {
         B_Adhes,        // 32
         F_Adhes,
         B_Paste,
@@ -719,8 +720,96 @@ void PCB_IO::format( BOARD* aBoard, int aNestLevel ) const
     aBoard->GetPlotOptions().Format( m_out, aNestLevel+1 );
 
     m_out->Print( aNestLevel, ")\n\n" );
+}
 
-    // Save net codes and names
+
+void PCB_IO::formatGeneral( BOARD* aBoard, int aNestLevel ) const
+{
+    const BOARD_DESIGN_SETTINGS& dsnSettings = aBoard->GetDesignSettings();
+
+    m_out->Print( 0, "\n" );
+    m_out->Print( aNestLevel, "(general\n" );
+    // Write Bounding box info
+    m_out->Print( aNestLevel+1, "(thickness %s)\n",
+                  FMTIU( dsnSettings.GetBoardThickness() ).c_str() );
+
+    m_out->Print( aNestLevel+1, "(drawings %d)\n", aBoard->Drawings().Size() );
+    m_out->Print( aNestLevel+1, "(tracks %d)\n", aBoard->GetNumSegmTrack() );
+    m_out->Print( aNestLevel+1, "(zones %d)\n", aBoard->GetNumSegmZone() );
+    m_out->Print( aNestLevel+1, "(modules %d)\n", aBoard->m_Modules.GetCount() );
+    m_out->Print( aNestLevel+1, "(nets %d)\n", m_mapping->GetSize() );
+    m_out->Print( aNestLevel, ")\n\n" );
+
+    aBoard->GetPageSettings().Format( m_out, aNestLevel, m_ctl );
+    aBoard->GetTitleBlock().Format( m_out, aNestLevel, m_ctl );
+}
+
+
+void PCB_IO::formatBoardLayers( BOARD* aBoard, int aNestLevel ) const
+{
+    m_out->Print( aNestLevel, "(layers\n" );
+
+    // Save only the used copper layers from front to back.
+    LSET visible_layers = aBoard->GetVisibleLayers();
+
+    for( LSEQ cu = aBoard->GetEnabledLayers().CuStack();  cu;  ++cu )
+    {
+        PCB_LAYER_ID layer = *cu;
+
+        m_out->Print( aNestLevel+1, "(%d %s %s", layer,
+                      m_out->Quotew( aBoard->GetLayerName( layer ) ).c_str(),
+                      LAYER::ShowType( aBoard->GetLayerType( layer ) ) );
+
+        if( !visible_layers[layer] )
+            m_out->Print( 0, " hide" );
+
+        m_out->Print( 0, ")\n" );
+    }
+
+    // Save used non-copper layers in the order they are defined.
+    // desired sequence for non Cu BOARD layers.
+    static const PCB_LAYER_ID non_cu[] =
+    {
+        B_Adhes,        // 32
+        F_Adhes,
+        B_Paste,
+        F_Paste,
+        B_SilkS,
+        F_SilkS,
+        B_Mask,
+        F_Mask,
+        Dwgs_User,
+        Cmts_User,
+        Eco1_User,
+        Eco2_User,
+        Edge_Cuts,
+        Margin,
+        B_CrtYd,
+        F_CrtYd,
+        B_Fab,
+        F_Fab
+    };
+
+    for( LSEQ seq = aBoard->GetEnabledLayers().Seq( non_cu, DIM( non_cu ) );  seq;  ++seq )
+    {
+        PCB_LAYER_ID layer = *seq;
+
+        m_out->Print( aNestLevel+1, "(%d %s user", layer,
+                      m_out->Quotew( aBoard->GetLayerName( layer ) ).c_str() );
+
+        if( !visible_layers[layer] )
+            m_out->Print( 0, " hide" );
+
+        m_out->Print( 0, ")\n" );
+    }
+
+    m_out->Print( aNestLevel, ")\n\n" );
+}
+
+
+void PCB_IO::formatNetInformation( BOARD* aBoard, int aNestLevel ) const
+{
+    const BOARD_DESIGN_SETTINGS& dsnSettings = aBoard->GetDesignSettings();
     for( NETINFO_MAPPING::iterator net = m_mapping->begin(), netEnd = m_mapping->end();
             net != netEnd; ++net )
     {
@@ -745,6 +834,23 @@ void PCB_IO::format( BOARD* aBoard, int aNestLevel ) const
         filterNetClass( *aBoard, netclass );    // Remove empty nets (from a copy of a netclass)
         netclass.Format( m_out, aNestLevel, m_ctl );
     }
+}
+
+
+void PCB_IO::formatHeader( BOARD* aBoard, int aNestLevel ) const
+{
+    formatGeneral( aBoard );
+    // Layers.
+    formatBoardLayers( aBoard );
+    // Setup
+    formatSetup( aBoard, aNestLevel );
+    // Save net codes and names
+    formatNetInformation( aBoard, aNestLevel );
+}
+
+void PCB_IO::format( BOARD* aBoard, int aNestLevel ) const
+{
+    formatHeader( aBoard );
 
     // Save the modules.
     for( MODULE* module = aBoard->m_Modules;  module;  module = module->Next() )
@@ -1541,7 +1647,7 @@ void PCB_IO::format( TRACK* aTrack, int aNestLevel ) const
     {
         PCB_LAYER_ID  layer1, layer2;
 
-        const VIA*  via = static_cast<const VIA*>(aTrack);
+        const VIA*  via = static_cast<const VIA*>( aTrack );
         BOARD*      board = (BOARD*) via->GetParent();
 
         wxCHECK_RET( board != 0, wxT( "Via " ) + via->GetSelectMenuText() +
diff --git a/pcbnew/kicad_plugin.h b/pcbnew/kicad_plugin.h
index 6ec6c7c..eff7590 100644
--- a/pcbnew/kicad_plugin.h
+++ b/pcbnew/kicad_plugin.h
@@ -109,7 +109,7 @@ public:
         return wxT( "kicad_pcb" );
     }
 
-    void Save( const wxString& aFileName, BOARD* aBoard,
+    virtual void Save( const wxString& aFileName, BOARD* aBoard,
                const PROPERTIES* aProperties = NULL ) override;
 
     BOARD* Load( const wxString& aFileName, BOARD* aAppendToMe,
@@ -188,6 +188,21 @@ protected:
 
     void init( const PROPERTIES* aProperties );
 
+    /// formats the board setup information
+    void formatSetup( BOARD* aBoard, int aNestLevel = 0 ) const;
+
+    /// formats the General section of the file
+    void formatGeneral( BOARD* aBoard, int aNestLevel = 0 ) const;
+
+    /// formats the board layer information
+    void formatBoardLayers( BOARD* aBoard, int aNestLevel = 0 ) const;
+
+    /// formats the Nets and Netclasses
+    void formatNetInformation( BOARD* aBoard, int aNestLevel = 0 ) const;
+
+    /// writes everything that comes before the board_items, like settings and layers etc
+    void formatHeader( BOARD* aBoard, int aNestLevel = 0 ) const;
+
 private:
     void format( BOARD* aBoard, int aNestLevel = 0 ) const;
 
diff --git a/pcbnew/pcb_parser.h b/pcbnew/pcb_parser.h
index c03303c..b2ed26a 100644
--- a/pcbnew/pcb_parser.h
+++ b/pcbnew/pcb_parser.h
@@ -119,14 +119,6 @@ class PCB_PARSER : public PCB_LEXER
     DIMENSION*      parseDIMENSION();
 
     /**
-     * Function parseMODULE
-     * @param aInitialComments may be a pointer to a heap allocated initial comment block
-     *   or NULL.  If not NULL, then caller has given ownership of a wxArrayString to
-     *   this function and care must be taken to delete it even on exception.
-     */
-    MODULE*         parseMODULE( wxArrayString* aInitialComments = 0 );
-
-    /**
      * Function parseMODULE_unchecked
      * Parse a module, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
      */
@@ -309,6 +301,13 @@ public:
     }
 
     BOARD_ITEM* Parse();
+    /**
+     * Function parseMODULE
+     * @param aInitialComments may be a pointer to a heap allocated initial comment block
+     *   or NULL.  If not NULL, then caller has given ownership of a wxArrayString to
+     *   this function and care must be taken to delete it even on exception.
+     */
+    MODULE*         parseMODULE( wxArrayString* aInitialComments = 0 );
 
     /**
      * Return whether a version number, if any was parsed, was too recent
@@ -327,4 +326,5 @@ public:
 };
 
 
+
 #endif    // _PCBNEW_PARSER_H_
diff --git a/pcbnew/tools/edit_tool.cpp b/pcbnew/tools/edit_tool.cpp
index ef6cc2b..ea734a5 100644
--- a/pcbnew/tools/edit_tool.cpp
+++ b/pcbnew/tools/edit_tool.cpp
@@ -54,7 +54,10 @@ using namespace std::placeholders;
 #include "pcb_actions.h"
 #include "selection_tool.h"
 #include "edit_tool.h"
+#include "picker_tool.h"
 #include "grid_helper.h"
+#include "kicad_clipboard.h"
+#include "pcbnew_control.h"
 
 #include <router/router_tool.h>
 
@@ -161,6 +164,16 @@ TOOL_ACTION PCB_ACTIONS::measureTool( "pcbnew.InteractiveEdit.measureTool",
         _( "Measuring tool" ), _( "Interactively measure distance between points" ),
         nullptr, AF_ACTIVATE );
 
+TOOL_ACTION PCB_ACTIONS::copyToClipboard( "pcbnew.InteractiveEdit.CopyToClipboard",
+        AS_GLOBAL, MD_CTRL + int( 'C' ),
+        _( "Copy" ), _( "Copy selected content to clipboard" ),
+        copy_xpm );
+
+TOOL_ACTION PCB_ACTIONS::cutToClipboard( "pcbnew.InteractiveEdit.CutToClipboard",
+        AS_GLOBAL, MD_CTRL + int( 'X' ),
+        _( "Cut" ), _( "Cut selected content to clipboard" ),
+        cut_xpm );
+
 static wxPoint getAnchorPoint( const SELECTION &selection, const MOVE_PARAMETERS &params )
 {
     wxPoint anchorPoint;
@@ -235,8 +248,6 @@ static wxPoint getAnchorPoint( const SELECTION &selection, const MOVE_PARAMETERS
 }
 
 
-
-
 EDIT_TOOL::EDIT_TOOL() :
     PCB_TOOL( "pcbnew.InteractiveEdit" ), m_selectionTool( NULL ),
     m_dragging( false )
@@ -289,6 +300,12 @@ bool EDIT_TOOL::Init()
     menu.AddItem( PCB_ACTIONS::duplicate, SELECTION_CONDITIONS::NotEmpty );
     menu.AddItem( PCB_ACTIONS::createArray, SELECTION_CONDITIONS::NotEmpty );
 
+    menu.AddSeparator();
+    menu.AddItem( PCB_ACTIONS::copyToClipboard, SELECTION_CONDITIONS::NotEmpty );
+    menu.AddItem( PCB_ACTIONS::cutToClipboard, SELECTION_CONDITIONS::NotEmpty );
+    menu.AddItem( PCB_ACTIONS::pasteFromClipboard );
+    menu.AddSeparator();
+
     // Mirror only available in modedit
     menu.AddItem( PCB_ACTIONS::mirror, editingModuleCondition && SELECTION_CONDITIONS::NotEmpty );
 
@@ -376,10 +393,10 @@ int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
     controls->SetAutoPan( true );
 
     // cumulative translation
-    wxPoint totalMovement( 0, 0 );
-
+    VECTOR2I totalMovement;
     GRID_HELPER grid( editFrame );
     OPT_TOOL_EVENT evt = aEvent;
+    VECTOR2I prevPos;
 
     // Main loop: keep receiving events
     do
@@ -398,14 +415,20 @@ int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
             if( m_dragging && evt->Category() == TC_MOUSE )
             {
                 m_cursor = grid.BestSnapAnchor( evt->Position(), curr_item );
+
                 controls->ForceCursorPosition( true, m_cursor );
 
-                wxPoint movement = wxPoint( m_cursor.x, m_cursor.y ) - curr_item->GetPosition();
+                VECTOR2I movement( m_cursor - prevPos );// - curr_item->GetPosition();
+
                 totalMovement += movement;
+                prevPos = m_cursor;
+                auto delta = movement + m_offset;
 
                 // Drag items to the current cursor position
                 for( auto item : selection )
-                    static_cast<BOARD_ITEM*>( item )->Move( movement + m_offset );
+                    static_cast<BOARD_ITEM*>( item )->Move( wxPoint( delta.x, delta.y ) );
+
+                m_offset = VECTOR2I(0, 0);
             }
             else if( !m_dragging )    // Prepare to start dragging
             {
@@ -429,8 +452,25 @@ int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
                         m_commit->Modify( item );
 
                     m_cursor = controls->GetCursorPosition();
+                    m_offset = VECTOR2I(0, 0);
 
-                    if( selection.Size() == 1 )
+                    auto refPoint = VECTOR2I( curr_item->GetPosition() );
+
+                    if ( selection.HasReferencePoint() )
+                    {
+                        // start moving with the reference point attached to the cursor
+                        refPoint = selection.GetReferencePoint();
+                        grid.SetAuxAxes( false );
+
+                        auto delta = m_cursor - selection.GetReferencePoint();
+
+                        // Drag items to the current cursor position
+                        for( auto item : selection )
+                            static_cast<BOARD_ITEM*>( item )->Move( wxPoint( delta.x, delta.y ) );
+
+                        selection.ClearReferencePoint();
+                    }
+                    else if( selection.Size() == 1 )
                     {
                         // Set the current cursor position to the first dragged item origin, so the
                         // movement vector could be computed later
@@ -444,10 +484,7 @@ int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
 
                     controls->SetCursorPosition( m_cursor, false );
 
-                    VECTOR2I o = VECTOR2I( curr_item->GetPosition() );
-                    m_offset.x = o.x - m_cursor.x;
-                    m_offset.y = o.y - m_cursor.y;
-
+                    prevPos = m_cursor;
                     controls->SetAutoPan( true );
                     m_dragging = true;
                 }
@@ -495,7 +532,8 @@ int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
                 for( auto item : selection )
                 {
                     BOARD_ITEM* i = static_cast<BOARD_ITEM*>( item );
-                    i->SetPosition( i->GetPosition() - totalMovement );
+                    auto delta = VECTOR2I( i->GetPosition() ) - totalMovement;
+                    i->SetPosition( wxPoint( delta.x, delta.y ) );
 
                     // And what about flipping and rotation?
                     // for now, they won't be undone, but maybe that is how
@@ -1211,6 +1249,10 @@ void EDIT_TOOL::setTransitions()
     Go( &EDIT_TOOL::editFootprintInFpEditor, PCB_ACTIONS::editFootprintInFpEditor.MakeEvent() );
     Go( &EDIT_TOOL::ExchangeFootprints,      PCB_ACTIONS::exchangeFootprints.MakeEvent() );
     Go( &EDIT_TOOL::MeasureTool,             PCB_ACTIONS::measureTool.MakeEvent() );
+
+    Go( &EDIT_TOOL::copyToClipboard, PCB_ACTIONS::copyToClipboard.MakeEvent() );
+    Go( &EDIT_TOOL::cutToClipboard, PCB_ACTIONS::cutToClipboard.MakeEvent() );
+
 }
 
 
@@ -1218,7 +1260,9 @@ wxPoint EDIT_TOOL::getModificationPoint( const SELECTION& aSelection )
 {
     if( aSelection.Size() == 1 )
     {
-        return static_cast<BOARD_ITEM*>( aSelection.Front() )->GetPosition() - m_offset;
+        auto item =  static_cast<BOARD_ITEM*>( aSelection.Front() );
+        auto pos = item->GetPosition();
+        return wxPoint( pos.x - m_offset.x, pos.y - m_offset.y );
     }
     else
     {
@@ -1268,6 +1312,50 @@ int EDIT_TOOL::editFootprintInFpEditor( const TOOL_EVENT& aEvent )
     return 0;
 }
 
+bool EDIT_TOOL::pickCopyReferencePoint( VECTOR2I& aP )
+{
+    PICKER_TOOL* picker = m_toolMgr->GetTool<PICKER_TOOL>();
+    assert( picker );
+
+    picker->Activate();
+
+    while ( picker->IsPicking() )
+        Wait();
+
+    if( !picker->GetPoint() )
+        return false;
+
+    aP = *picker->GetPoint();
+    return true;
+}
+
+int EDIT_TOOL::copyToClipboard( const TOOL_EVENT& aEvent )
+{
+    CLIPBOARD_IO io;
+    BOARD*  board = getModel<BOARD>();
+    VECTOR2I refPoint;
+
+    Activate();
+
+    SELECTION selection = m_selectionTool->RequestSelection();
+
+    if( !pickCopyReferencePoint( refPoint ) )
+        return 0;
+
+    selection.SetReferencePoint( refPoint );
+    io.SetBoard( board );
+    io.SaveSelection( selection );
+
+    return 0;
+}
+
+int EDIT_TOOL::cutToClipboard( const TOOL_EVENT& aEvent )
+{
+    copyToClipboard( aEvent );
+    Remove( aEvent );
+    return 0;
+}
+
 
 template<class T>
 T* EDIT_TOOL::uniqueSelected()
diff --git a/pcbnew/tools/edit_tool.h b/pcbnew/tools/edit_tool.h
index 0868c68..0e19c44 100644
--- a/pcbnew/tools/edit_tool.h
+++ b/pcbnew/tools/edit_tool.h
@@ -139,6 +139,28 @@ public:
     ///> Sets up handlers for various events.
     void setTransitions() override;
 
+    /**
+     * Function copyToClipboard()
+     * Sends the current selection to the clipboard by formatting it as a fake pcb
+     * see AppendBoardFromClipboard for importing
+     * @return True if it was sent succesfully
+     */
+    int copyToClipboard( const TOOL_EVENT& aEvent );
+
+    /**
+     * Function cutToClipboard()
+     * Sends the current selection to the clipboard by formatting it as a fake pcb
+     * see AppendBoardFromClipboard for importing
+     * @return True if it was sent succesfully
+     */
+    int cutToClipboard( const TOOL_EVENT& aEvent );
+
+
+    BOARD_COMMIT* GetCurrentCommit() const
+    {
+        return m_commit.get();
+    }
+
 private:
     ///> Selection tool used for obtaining selected items
     SELECTION_TOOL* m_selectionTool;
@@ -147,7 +169,7 @@ private:
     bool m_dragging;
 
     ///> Offset from the dragged item's center (anchor)
-    wxPoint m_offset;
+    VECTOR2I m_offset;
 
     ///> Last cursor position (needed for getModificationPoint() to avoid changes
     ///> of edit reference point).
@@ -163,6 +185,7 @@ private:
     bool isInteractiveDragEnabled() const;
 
     bool changeTrackWidthOnClick( const SELECTION& selection );
+    bool pickCopyReferencePoint( VECTOR2I& aP );
 
 
     /**
diff --git a/pcbnew/tools/grid_helper.cpp b/pcbnew/tools/grid_helper.cpp
index 7dce3b0..f01f2f8 100644
--- a/pcbnew/tools/grid_helper.cpp
+++ b/pcbnew/tools/grid_helper.cpp
@@ -251,7 +251,13 @@ VECTOR2I GRID_HELPER::BestSnapAnchor( const VECTOR2I& aOrigin, BOARD_ITEM* aDrag
         computeAnchors( item, aOrigin );
     }
 
-    LSET layers( aDraggedItem->GetLayer() );
+    LSET layers;
+
+    if( aDraggedItem )
+        layers = aDraggedItem->GetLayer();
+    else
+        layers = LSET::AllLayersMask();
+
     ANCHOR* nearest = nearestAnchor( aOrigin, CORNER | SNAPPABLE, layers );
 
     VECTOR2I nearestGrid = Align( aOrigin );
diff --git a/pcbnew/tools/module_editor_tools.cpp b/pcbnew/tools/module_editor_tools.cpp
index 7c02ad5..7357b76 100644
--- a/pcbnew/tools/module_editor_tools.cpp
+++ b/pcbnew/tools/module_editor_tools.cpp
@@ -23,6 +23,7 @@
  */
 
 #include "module_editor_tools.h"
+#include "kicad_clipboard.h"
 #include "selection_tool.h"
 #include "pcb_actions.h"
 #include <tool/tool_manager.h>
@@ -63,11 +64,11 @@ TOOL_ACTION PCB_ACTIONS::enumeratePads( "pcbnew.ModuleEditor.enumeratePads",
         _( "Enumerate Pads" ), _( "Enumerate pads" ), pad_enumerate_xpm, AF_ACTIVATE );
 
 TOOL_ACTION PCB_ACTIONS::copyItems( "pcbnew.ModuleEditor.copyItems",
-        AS_GLOBAL, TOOL_ACTION::LegacyHotKey( HK_COPY_ITEM ),
+        AS_ACTIVE, 0,
         _( "Copy" ), _( "Copy items" ), NULL, AF_ACTIVATE );
 
 TOOL_ACTION PCB_ACTIONS::pasteItems( "pcbnew.ModuleEditor.pasteItems",
-        AS_GLOBAL, MD_CTRL + int( 'V' ),
+        AS_GLOBAL, 0,
         _( "Paste" ), _( "Paste items" ), NULL, AF_ACTIVATE );
 
 TOOL_ACTION PCB_ACTIONS::moduleEdgeOutlines( "pcbnew.ModuleEditor.graphicOutlines",
@@ -333,21 +334,8 @@ int MODULE_EDITOR_TOOLS::CopyItems( const TOOL_EVENT& aEvent )
 
 int MODULE_EDITOR_TOOLS::PasteItems( const TOOL_EVENT& aEvent )
 {
-    // Parse clipboard
-    PCB_IO io( CTL_FOR_CLIPBOARD );
-    MODULE* pastedModule = NULL;
 
-    try
-    {
-        BOARD_ITEM* item = io.Parse( wxString( m_toolMgr->GetClipboard().c_str(), wxConvUTF8 ) );
-        assert( item->Type() == PCB_MODULE_T );
-        pastedModule = dyn_cast<MODULE*>( item );
-    }
-    catch( ... )
-    {
-        frame()->DisplayToolMsg( _( "Invalid clipboard contents" ) );
-        return 0;
-    }
+    MODULE* pastedModule = aEvent.Parameter<MODULE*>();
 
     // Placement tool part
     VECTOR2I cursorPos = getViewControls()->GetCursorPosition();
@@ -427,7 +415,6 @@ int MODULE_EDITOR_TOOLS::PasteItems( const TOOL_EVENT& aEvent )
                     // Whyyyyyyyyyyyyyyyyyyyyyy?! All other items conform to rotation performed
                     // on its parent module, but texts are so independent..
                     text->Rotate( text->GetPosition(), pastedModule->GetOrientation() );
-                    commit.Add( text );
                 }
 
                 commit.Add( clone );
diff --git a/pcbnew/tools/pcb_actions.h b/pcbnew/tools/pcb_actions.h
index b82f142..008213e 100644
--- a/pcbnew/tools/pcb_actions.h
+++ b/pcbnew/tools/pcb_actions.h
@@ -82,6 +82,7 @@ public:
     /// Filters the items in the current selection (invokes dialog)
     static TOOL_ACTION filterSelection;
 
+
     // Edit Tool
     /// Activation of the edit tool
     static TOOL_ACTION editActivate;
@@ -300,6 +301,15 @@ public:
     /// Pasting module items from clipboard
     static TOOL_ACTION pasteItems;
 
+    /// Copy selected items to clipboard
+    static TOOL_ACTION copyToClipboard;
+
+    /// Paste from clipboard
+    static TOOL_ACTION pasteFromClipboard;
+
+    /// Paste from clipboard
+    static TOOL_ACTION cutToClipboard;
+
     /// Display module edges as outlines
     static TOOL_ACTION moduleEdgeOutlines;
 
diff --git a/pcbnew/tools/pcb_editor_control.cpp b/pcbnew/tools/pcb_editor_control.cpp
index 438d521..0815944 100644
--- a/pcbnew/tools/pcb_editor_control.cpp
+++ b/pcbnew/tools/pcb_editor_control.cpp
@@ -390,7 +390,7 @@ int PCB_EDITOR_CONTROL::ViaSizeDec( const TOOL_EVENT& aEvent )
 
 int PCB_EDITOR_CONTROL::PlaceModule( const TOOL_EVENT& aEvent )
 {
-    MODULE* module = NULL;
+    MODULE* module = aEvent.Parameter<MODULE*>();
     KIGFX::VIEW* view = getView();
     KIGFX::VIEW_CONTROLS* controls = getViewControls();
     BOARD* board = getModel<BOARD>();
@@ -406,10 +406,20 @@ int PCB_EDITOR_CONTROL::PlaceModule( const TOOL_EVENT& aEvent )
     Activate();
     m_frame->SetToolID( ID_PCB_MODULE_BUTT, wxCURSOR_PENCIL, _( "Add footprint" ) );
 
+    // Add all the drawable parts to preview
+    VECTOR2I cursorPos = controls->GetCursorPosition();
+    if( module )
+    {
+        module->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
+        preview.Add( module );
+        module->RunOnChildren( std::bind( &KIGFX::VIEW_GROUP::Add, &preview, _1 ) );
+        view->Update( &preview );
+    }
+
     // Main loop: keep receiving events
     while( OPT_TOOL_EVENT evt = Wait() )
     {
-        VECTOR2I cursorPos = controls->GetCursorPosition();
+        cursorPos = controls->GetCursorPosition();
 
         if( evt->IsCancel() || evt->IsActivate() )
         {
diff --git a/pcbnew/tools/pcb_tool.h b/pcbnew/tools/pcb_tool.h
index 2c83ff9..0d98f92 100644
--- a/pcbnew/tools/pcb_tool.h
+++ b/pcbnew/tools/pcb_tool.h
@@ -124,6 +124,8 @@ protected:
     KIGFX::VIEW_CONTROLS* controls() const { return getViewControls(); }
     PCB_EDIT_FRAME* frame() const { return getEditFrame<PCB_EDIT_FRAME>(); }
     BOARD* board() const { return getModel<BOARD>(); }
+    MODULE* module() const { return board()->m_Modules; }
+
 
     bool m_editModules;
 };
diff --git a/pcbnew/tools/pcbnew_control.cpp b/pcbnew/tools/pcbnew_control.cpp
index 3ef2490..24bb034 100644
--- a/pcbnew/tools/pcbnew_control.cpp
+++ b/pcbnew/tools/pcbnew_control.cpp
@@ -27,7 +27,9 @@
 #include "pcbnew_control.h"
 #include "pcb_actions.h"
 #include "selection_tool.h"
+#include "edit_tool.h"
 #include "picker_tool.h"
+#include "pcb_editor_control.h"
 #include "grid_helper.h"
 
 #include <class_board.h>
@@ -40,6 +42,8 @@
 #include <hotkeys.h>
 #include <properties.h>
 #include <io_mgr.h>
+#include <kicad_plugin.h>
+#include <kicad_clipboard.h>
 
 #include <pcbnew_id.h>
 #include <wxPcbStruct.h>
@@ -51,6 +55,7 @@
 #include <pcb_painter.h>
 #include <origin_viewitem.h>
 #include <board_commit.h>
+#include <bitmaps.h>
 
 #include <functional>
 using namespace std::placeholders;
@@ -221,9 +226,14 @@ TOOL_ACTION PCB_ACTIONS::toBeDone( "pcbnew.Control.toBeDone",
         AS_GLOBAL, 0,           // dialog saying it is not implemented yet
         "", "" );               // so users are aware of that
 
+TOOL_ACTION PCB_ACTIONS::pasteFromClipboard( "pcbnew.InteractiveEdit.pasteFromClipboard",
+        AS_GLOBAL, MD_CTRL + int( 'V' ),
+        _( "Paste" ), _( "Paste content from clipboard" ),
+        paste_xpm );
+
 
 PCBNEW_CONTROL::PCBNEW_CONTROL() :
-    TOOL_INTERACTIVE( "pcbnew.Control" ), m_frame( NULL )
+    PCB_TOOL( "pcbnew.Control" ), m_frame( NULL )
 {
     m_gridOrigin.reset( new KIGFX::ORIGIN_VIEWITEM() );
 }
@@ -240,7 +250,7 @@ void PCBNEW_CONTROL::Reset( RESET_REASON aReason )
 
     if( aReason == MODEL_RELOAD || aReason == GAL_SWITCH )
     {
-        m_gridOrigin->SetPosition( getModel<BOARD>()->GetGridOrigin() );
+        m_gridOrigin->SetPosition( board()->GetGridOrigin() );
         getView()->Remove( m_gridOrigin.get() );
         getView()->Add( m_gridOrigin.get() );
     }
@@ -257,10 +267,10 @@ int PCBNEW_CONTROL::TrackDisplayMode( const TOOL_EVENT& aEvent )
     displ_opts->m_DisplayPcbTrackFill = !displ_opts->m_DisplayPcbTrackFill;
     settings->LoadDisplayOptions( displ_opts );
 
-    for( TRACK* track = getModel<BOARD>()->m_Track; track; track = track->Next() )
+    for( auto track : board()->Tracks() )
     {
         if( track->Type() == PCB_TRACE_T )
-            getView()->Update( track, KIGFX::GEOMETRY );
+            view()->Update( track, KIGFX::GEOMETRY );
     }
 
     m_frame->GetGalCanvas()->Refresh();
@@ -280,7 +290,7 @@ int PCBNEW_CONTROL::PadDisplayMode( const TOOL_EVENT& aEvent )
     displ_opts->m_DisplayPadFill = !displ_opts->m_DisplayPadFill;
     settings->LoadDisplayOptions( displ_opts );
 
-    for( MODULE* module = getModel<BOARD>()->m_Modules; module; module = module->Next() )
+    for( auto module : board()->Modules() )
     {
         for( auto pad : module->Pads() )
             getView()->Update( pad, KIGFX::GEOMETRY );
@@ -302,7 +312,7 @@ int PCBNEW_CONTROL::ViaDisplayMode( const TOOL_EVENT& aEvent )
     displ_opts->m_DisplayViaFill = !displ_opts->m_DisplayViaFill;
     settings->LoadDisplayOptions( displ_opts );
 
-    for( TRACK* track = getModel<BOARD>()->m_Track; track; track = track->Next() )
+    for( auto track : board()->Tracks() )
     {
         if( track->Type() == PCB_TRACE_T || track->Type() == PCB_VIA_T )
             getView()->Update( track, KIGFX::GEOMETRY );
@@ -332,9 +342,8 @@ int PCBNEW_CONTROL::ZoneDisplayMode( const TOOL_EVENT& aEvent )
 
     settings->LoadDisplayOptions( displ_opts );
 
-    BOARD* board = getModel<BOARD>();
-    for( int i = 0; i < board->GetAreaCount(); ++i )
-        getView()->Update( board->GetArea( i ), KIGFX::GEOMETRY );
+    for( int i = 0; i < board()->GetAreaCount(); ++i )
+        view()->Update( board()->GetArea( i ), KIGFX::GEOMETRY );
 
     m_frame->GetGalCanvas()->Refresh();
 
@@ -385,7 +394,7 @@ int PCBNEW_CONTROL::LayerNext( const TOOL_EVENT& aEvent )
     if( layer < F_Cu || layer > B_Cu )
         return 0;
 
-    int layerCount = getModel<BOARD>()->GetCopperLayerCount();
+    int layerCount = board()->GetCopperLayerCount();
 
     if( layer == layerCount - 2 || layerCount < 2 )
         layer = B_Cu;
@@ -409,7 +418,7 @@ int PCBNEW_CONTROL::LayerPrev( const TOOL_EVENT& aEvent )
     if( layer < F_Cu || layer > B_Cu )
         return 0;
 
-    int layerCount = getModel<BOARD>()->GetCopperLayerCount();
+    int layerCount = board()->GetCopperLayerCount();
 
     if( layer == F_Cu || layerCount < 2 )
         layer = B_Cu;
@@ -640,7 +649,7 @@ int PCBNEW_CONTROL::GridSetOrigin( const TOOL_EVENT& aEvent )
 
 int PCBNEW_CONTROL::GridResetOrigin( const TOOL_EVENT& aEvent )
 {
-    getModel<BOARD>()->SetGridOrigin( wxPoint( 0, 0 ) );
+    board()->SetGridOrigin( wxPoint( 0, 0 ) );
     m_gridOrigin->SetPosition( VECTOR2D( 0, 0 ) );
 
     return 0;
@@ -729,7 +738,83 @@ int PCBNEW_CONTROL::DeleteItemCursor( const TOOL_EVENT& aEvent )
 }
 
 
-int PCBNEW_CONTROL::AppendBoard( const TOOL_EVENT& aEvent )
+int PCBNEW_CONTROL::PasteItemsFromClipboard( const TOOL_EVENT& aEvent )
+{
+    CLIPBOARD_IO pi;
+
+    pi.SetBoard( board() );
+    BOARD_ITEM* clipItem = pi.Parse();
+
+    if(!clipItem )
+    {
+        return 0;
+    }
+
+    bool editModules = m_editModules || frame()->IsType( FRAME_PCB_MODULE_EDITOR );
+
+    // The clipboard can contain two different things, an entire kicad_pcb
+    // or a single module
+
+    if ( editModules && ( !board() || !module() ) )
+    {
+        wxLogDebug( wxT( "Attempting to paste to empty module editor window\n") );
+        return 0;
+    }
+
+
+    switch( clipItem->Type() )
+    {
+        case PCB_T:
+        {
+            if( editModules )
+            {
+                wxLogDebug( wxT( "attempting to paste a pcb in the footprint editor\n") );
+                return 0;
+            }
+
+		    placeBoardItems( static_cast<BOARD*>( clipItem ) );
+            break;
+        }
+
+        case PCB_MODULE_T:
+        {
+            std::vector<BOARD_ITEM *> items;
+
+            clipItem->SetParent( board() );
+
+            if( editModules )
+            {
+                auto mod = static_cast<MODULE *>( clipItem );
+
+                for ( auto pad : mod->Pads() )
+                {
+                    pad->SetParent ( board()->m_Modules.GetFirst() );
+                    items.push_back( pad );
+                }
+                for ( auto item : mod->GraphicalItems() )
+                {
+                    item->SetParent ( board()->m_Modules.GetFirst() );
+                    items.push_back( item );
+                }
+            }
+            else
+            {
+                items.push_back( clipItem );
+            }
+
+            placeBoardItems( items );
+            break;
+        }
+        default:
+            m_frame->DisplayToolMsg( _( "Invalid clipboard contents" ) );
+            // FAILED
+            break;
+    }
+    return 1;
+}
+
+
+int PCBNEW_CONTROL::AppendBoardFromFile( const TOOL_EVENT& aEvent )
 {
     int open_ctl;
     wxString fileName;
@@ -737,31 +822,151 @@ int PCBNEW_CONTROL::AppendBoard( const TOOL_EVENT& aEvent )
     PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
 
     if( !editFrame )
-        return 0;
+        return 1;
 
     // Pick a file to append
     if( !AskLoadBoardFileName( editFrame, &open_ctl, &fileName, true ) )
-        return 0;
+        return 1;
 
     IO_MGR::PCB_FILE_T pluginType = plugin_type( fileName, open_ctl );
     PLUGIN::RELEASER pi( IO_MGR::PluginFind( pluginType ) );
 
+    return AppendBoard( *pi, fileName );
+}
+
+
+int PCBNEW_CONTROL::placeBoardItems( BOARD* aBoard )
+{
+    std::vector<BOARD_ITEM*> items;
+    auto currentBoard = board();
+
+    PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
+
+    if( currentBoard->GetCopperLayerCount() < aBoard->GetCopperLayerCount() )
+    {
+
+        if( !IsOK( editFrame, _( "Pasting will add extra layers to the PCB, continue? ") ) )
+            return 0;
+
+        currentBoard->SetCopperLayerCount( aBoard->GetCopperLayerCount() );
+        currentBoard->SetEnabledLayers( aBoard->GetEnabledLayers() );
+
+        editFrame->ReCreateLayerBox();
+        editFrame->ReFillLayerWidget();
+    }
+
+    for( auto track : aBoard->Tracks() )
+    {
+        if( !currentBoard->FindNet( track->GetNetname() ) )
+        {
+            NETINFO_ITEM* newNet = new NETINFO_ITEM( currentBoard,
+                        track->GetNet()->GetNetname(), -1 );
+            currentBoard->Add( newNet );
+            currentBoard->BuildListOfNets();
+        }
+        track->SetParent( currentBoard );
+        track->SetNet( currentBoard->FindNet( track->GetNetname()) );
+        items.push_back( track );
+    }
+
+    for( auto module : aBoard->Modules() )
+    {
+        module->SetParent( currentBoard );
+        for( auto pad : module->Pads() )
+        {
+        // Check if the net is there by name, otherwise, add a new net and
+        // reassign the item to the new net
+            if( !currentBoard->FindNet( pad->GetNet()->GetNetname() ) )
+            {
+                // A net with -1 in netcode will be autoassigned a net
+                NETINFO_ITEM* newNet = new NETINFO_ITEM( currentBoard,
+                        pad->GetNet()->GetNetname(), -1 );
+                currentBoard->Add( newNet );
+                currentBoard->BuildListOfNets();
+            }
+            pad->SetParent( module );
+            pad->SetNet( currentBoard->FindNet( pad->GetNetname() ) );
+        }
+
+        items.push_back( module );
+    }
+
+    for( auto drawing : aBoard->Drawings() )
+    {
+        items.push_back( drawing );
+    }
+
+    for( auto zone : aBoard->Zones() )
+    {
+        // Check if the net is there by name, otherwise, add a new net and
+        // reassign the item to the new net
+        if( !currentBoard->FindNet( zone->GetNet()->GetNetname() ) )
+        {
+            NETINFO_ITEM* newNet = new NETINFO_ITEM( currentBoard,
+                    zone->GetNet()->GetNetname(), -1 );
+            currentBoard->Add( newNet );
+            currentBoard->BuildListOfNets();
+        }
+        zone->SetParent( currentBoard );
+        zone->SetNet( currentBoard->FindNet( zone->GetNetname() ) );
+        items.push_back( zone );
+    }
+
+    // A lot of changes to the nets may have happen, be on the safe side
+    // and rebuild these things
+    currentBoard->BuildListOfNets();
+    currentBoard->SynchronizeNetsAndNetClasses();
+    currentBoard->GetConnectivity()->RecalculateRatsnest();
+
+    // the list of items should now be sanitized to fit on the current board
+    return placeBoardItems( items );
+}
+
+
+int PCBNEW_CONTROL::placeBoardItems( std::vector<BOARD_ITEM*>& aItems )
+{
+    m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
+
+    auto selectionTool = m_toolMgr->GetTool<SELECTION_TOOL>();
+    auto editTool = m_toolMgr->GetTool<EDIT_TOOL>();
+
+    SELECTION& selection = selectionTool->GetSelection();
+
+    for ( auto item : aItems )
+    {
+        item->SetSelected();
+        selection.Add( item );
+        editTool->GetCurrentCommit()->Add( item );
+    }
+
+    selection.SetReferencePoint( VECTOR2I( 0, 0 ) );
+
+    m_toolMgr->ProcessEvent( SELECTION_TOOL::SelectedEvent );
+    m_toolMgr->RunAction( PCB_ACTIONS::move, true );
+
+    return 0;
+}
+
+int PCBNEW_CONTROL::AppendBoard( PLUGIN& pi, wxString& fileName )
+{
+
+    PCB_EDIT_FRAME* editFrame = dynamic_cast<PCB_EDIT_FRAME*>( m_frame );
+    if( !editFrame )
+        return 1;
+
     // Mark existing tracks, in order to know what are the new tracks
     // Tracks are inserted, not appended, so mark existing tracks to be
     // able to select the new tracks only later
-    BOARD* board = getModel<BOARD>();
+    BOARD* brd = board();
+    if( !brd )
+        return 1;
 
-    for( TRACK* track = board->m_Track; track; track = track->Next() )
+    for( auto track : brd->Tracks() )
         track->SetFlags( FLAG0 );
 
-    // Other items are appended to the item list, so keep trace to the last existing item is enough
-    MODULE* module = board->m_Modules.GetLast();
-    BOARD_ITEM* drawing = board->DrawingsList().GetLast();
-    int zonescount = board->GetAreaCount();
-
     // Keep also the count of copper layers, to adjust if necessary
-    int initialCopperLayerCount = board->GetCopperLayerCount();
-    LSET initialEnabledLayers = board->GetEnabledLayers();
+    int initialCopperLayerCount = brd->GetCopperLayerCount();
+    LSET initialEnabledLayers = brd->GetEnabledLayers();
 
     // Load the data
     try
@@ -778,7 +983,7 @@ int PCBNEW_CONTROL::AppendBoard( const TOOL_EVENT& aEvent )
         props["page_height"] = ybuf;
 
         editFrame->GetDesignSettings().m_NetClasses.Clear();
-        pi->Load( fileName, board, &props );
+        pi.Load( fileName, brd, &props );
     }
     catch( const IO_ERROR& ioe )
     {
@@ -789,86 +994,25 @@ int PCBNEW_CONTROL::AppendBoard( const TOOL_EVENT& aEvent )
     }
 
     // rebuild nets and ratsnest before any use of nets
-    board->BuildListOfNets();
-    board->SynchronizeNetsAndNetClasses();
-    board->GetConnectivity()->Build( board );
-
-    m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
-
-    SELECTION_TOOL* selectionTool = m_toolMgr->GetTool<SELECTION_TOOL>();
-    SELECTION& selection = selectionTool->GetSelection();
-    BOARD_COMMIT commit( editFrame );
-
-    // Process the new items
-    for( TRACK* track = board->m_Track; track; track = track->Next() )
-    {
-        if( track->GetFlags() & FLAG0 )
-        {
-            track->ClearFlags( FLAG0 );
-            continue;
-        }
-
-        commit.Added( track );
-        selection.Add( track );
-    }
-
-    module = module ? module->Next() : board->m_Modules;
-
-    for( ; module; module = module->Next() )
-    {
-        commit.Added( module );
-        selection.Add( module );
-    }
-
-    drawing = drawing ? drawing->Next() : board->DrawingsList();
-
-    for( ; drawing; drawing = drawing->Next() )
-    {
-        commit.Added( drawing );
-        selection.Add( drawing );
-    }
+    brd->BuildListOfNets();
+    brd->SynchronizeNetsAndNetClasses();
 
-    for( ZONE_CONTAINER* zone = board->GetArea( zonescount ); zone;
-         zone = board->GetArea( zonescount ) )
-    {
-        ++zonescount;
-        commit.Added( zone );
-        selection.Add( zone );
-    }
-
-    if( commit.Empty() )
-        return 0;
-
-    commit.Push( _( "Append a board" ) );
 
     // Synchronize layers
     // we should not ask PLUGINs to do these items:
-    int copperLayerCount = board->GetCopperLayerCount();
+    int copperLayerCount = brd->GetCopperLayerCount();
 
     if( copperLayerCount > initialCopperLayerCount )
-        board->SetCopperLayerCount( copperLayerCount );
+        brd->SetCopperLayerCount( copperLayerCount );
 
     // Enable all used layers, and make them visible:
-    LSET enabledLayers = board->GetEnabledLayers();
+    LSET enabledLayers = brd->GetEnabledLayers();
     enabledLayers |= initialEnabledLayers;
-    board->SetEnabledLayers( enabledLayers );
-    board->SetVisibleLayers( enabledLayers );
-    editFrame->ReCreateLayerBox();
-    editFrame->ReFillLayerWidget();
-    static_cast<PCB_DRAW_PANEL_GAL*>( editFrame->GetGalCanvas() )->SyncLayersVisibility( board );
-
-    // Start dragging the appended board
-    if( selection.Size() )     // be sure at least one item is loaded
-    {
-        // Inform other potentially interested tools
-        m_toolMgr->ProcessEvent( SELECTION_TOOL::SelectedEvent );
+    brd->SetEnabledLayers( enabledLayers );
+    brd->SetVisibleLayers( enabledLayers );
 
-        VECTOR2D v( static_cast<BOARD_ITEM*>( selection.Front() )->GetPosition() );
-        getViewControls()->WarpCursor( v, true, true );
-        m_toolMgr->InvokeTool( "pcbnew.InteractiveEdit" );
-    }
 
-    return 0;
+    return placeBoardItems( brd );
 }
 
 
@@ -945,9 +1089,15 @@ void PCBNEW_CONTROL::setTransitions()
     Go( &PCBNEW_CONTROL::SwitchCursor,       PCB_ACTIONS::switchCursor.MakeEvent() );
     Go( &PCBNEW_CONTROL::SwitchUnits,        PCB_ACTIONS::switchUnits.MakeEvent() );
     Go( &PCBNEW_CONTROL::DeleteItemCursor,   PCB_ACTIONS::deleteItemCursor.MakeEvent() );
-    Go( &PCBNEW_CONTROL::AppendBoard,        PCB_ACTIONS::appendBoard.MakeEvent() );
     Go( &PCBNEW_CONTROL::ShowHelp,           PCB_ACTIONS::showHelp.MakeEvent() );
     Go( &PCBNEW_CONTROL::ToBeDone,           PCB_ACTIONS::toBeDone.MakeEvent() );
+
+    // Append control
+    Go( &PCBNEW_CONTROL::AppendBoardFromFile,
+            PCB_ACTIONS::appendBoard.MakeEvent() );
+
+    Go( &PCBNEW_CONTROL::PasteItemsFromClipboard,
+            PCB_ACTIONS::pasteFromClipboard.MakeEvent() );
 }
 
 
diff --git a/pcbnew/tools/pcbnew_control.h b/pcbnew/tools/pcbnew_control.h
index 11131a2..a63bff6 100644
--- a/pcbnew/tools/pcbnew_control.h
+++ b/pcbnew/tools/pcbnew_control.h
@@ -25,21 +25,23 @@
 #ifndef PCBNEW_CONTROL_H
 #define PCBNEW_CONTROL_H
 
-#include <tool/tool_interactive.h>
+#include <io_mgr.h>
 #include <memory>
+#include <tools/pcb_tool.h>
 
 namespace KIGFX {
     class ORIGIN_VIEWITEM;
 }
-class PCB_BASE_FRAME;
 
+class PCB_BASE_FRAME;
+class BOARD_ITEM;
 /**
  * Class PCBNEW_CONTROL
  *
  * Handles actions that are shared between different frames in pcbnew.
  */
 
-class PCBNEW_CONTROL : public TOOL_INTERACTIVE
+class PCBNEW_CONTROL : public PCB_TOOL
 {
 public:
     PCBNEW_CONTROL();
@@ -79,7 +81,9 @@ public:
     int SwitchCursor( const TOOL_EVENT& aEvent );
     int SwitchUnits( const TOOL_EVENT& aEvent );
     int DeleteItemCursor( const TOOL_EVENT& aEvent );
-    int AppendBoard( const TOOL_EVENT& aEvent );
+    int PasteItemsFromClipboard( const TOOL_EVENT& aEvent );
+    int AppendBoardFromFile( const TOOL_EVENT& aEvent );
+    int AppendBoard( PLUGIN& pi, wxString& fileName );
     int ShowHelp( const TOOL_EVENT& aEvent );
     int ToBeDone( const TOOL_EVENT& aEvent );
 
@@ -87,6 +91,10 @@ public:
     void setTransitions() override;
 
 private:
+
+    int placeBoardItems( BOARD* aBoard );
+    int placeBoardItems( std::vector<BOARD_ITEM*>& aItems );
+
     ///> Pointer to the currently used edit frame.
     PCB_BASE_FRAME* m_frame;
 
diff --git a/pcbnew/tools/picker_tool.cpp b/pcbnew/tools/picker_tool.cpp
index 332aacf..a8e63d6 100644
--- a/pcbnew/tools/picker_tool.cpp
+++ b/pcbnew/tools/picker_tool.cpp
@@ -24,6 +24,7 @@
 
 #include "picker_tool.h"
 #include "pcb_actions.h"
+#include "grid_helper.h"
 
 #include <wxPcbStruct.h>
 #include <view/view_controls.h>
@@ -33,7 +34,7 @@ TOOL_ACTION PCB_ACTIONS::pickerTool( "pcbnew.Picker", AS_GLOBAL, 0, "", "", NULL
 
 
 PICKER_TOOL::PICKER_TOOL()
-    : TOOL_INTERACTIVE( "pcbnew.Picker" )
+    : PCB_TOOL( "pcbnew.Picker" )
 {
     reset();
 }
@@ -42,6 +43,7 @@ PICKER_TOOL::PICKER_TOOL()
 int PICKER_TOOL::Main( const TOOL_EVENT& aEvent )
 {
     KIGFX::VIEW_CONTROLS* controls = getViewControls();
+    GRID_HELPER grid( frame() );
 
     assert( !m_picking );
     m_picking = true;
@@ -49,13 +51,19 @@ int PICKER_TOOL::Main( const TOOL_EVENT& aEvent )
 
     setControls();
 
+
     while( OPT_TOOL_EVENT evt = Wait() )
     {
+        auto mousePos = controls->GetMousePosition();
+        auto p = grid.BestSnapAnchor( mousePos, nullptr );
+        controls->ForceCursorPosition( true, p );
+
         if( evt->IsClick( BUT_LEFT ) )
         {
             bool getNext = false;
-            m_picked = controls->GetCursorPosition();
 
+            m_picked = p;
+            
             if( m_clickHandler )
             {
                 try
@@ -83,6 +91,7 @@ int PICKER_TOOL::Main( const TOOL_EVENT& aEvent )
     }
 
     reset();
+    controls->ForceCursorPosition( false );
     getEditFrame<PCB_BASE_FRAME>()->SetNoToolSelected();
 
     return 0;
diff --git a/pcbnew/tools/picker_tool.h b/pcbnew/tools/picker_tool.h
index 75f5571..60b5b6f 100644
--- a/pcbnew/tools/picker_tool.h
+++ b/pcbnew/tools/picker_tool.h
@@ -25,21 +25,20 @@
 #ifndef PICKER_TOOL_H
 #define PICKER_TOOL_H
 
-#include <tool/tool_interactive.h>
 #include <boost/optional/optional.hpp>
-#include <boost/function.hpp>
 
+#include "pcb_tool.h"
 /**
  * @brief Generic tool for picking a point.
  */
-class PICKER_TOOL : public TOOL_INTERACTIVE
+class PICKER_TOOL : public PCB_TOOL
 {
 public:
     PICKER_TOOL();
     ~PICKER_TOOL() {}
 
     ///> Mouse event click handler type.
-    typedef boost::function<bool(const VECTOR2D&)> CLICK_HANDLER;
+    typedef std::function<bool(const VECTOR2D&)> CLICK_HANDLER;
 
     ///> @copydoc TOOL_INTERACTIVE::Reset()
     void Reset( RESET_REASON aReason ) override {}
diff --git a/pcbnew/tools/selection_tool.cpp b/pcbnew/tools/selection_tool.cpp
index 4042925..1d4c636 100644
--- a/pcbnew/tools/selection_tool.cpp
+++ b/pcbnew/tools/selection_tool.cpp
@@ -58,6 +58,8 @@ using namespace std::placeholders;
 #include "pcb_bright_box.h"
 #include "pcb_actions.h"
 
+#include "kicad_plugin.h"
+
 // Selection tool actions
 TOOL_ACTION PCB_ACTIONS::selectionActivate( "pcbnew.InteractiveSelection",
         AS_GLOBAL, 0,
@@ -120,8 +122,6 @@ TOOL_ACTION PCB_ACTIONS::filterSelection( "pcbnew.InteractiveSelection.FilterSel
         _( "Filter Selection" ), _( "Filter the types of items in the selection" ),
         nullptr );
 
-
-
 class SELECT_MENU: public CONTEXT_MENU
 {
 public:
@@ -609,11 +609,13 @@ void SELECTION_TOOL::setTransitions()
     Go( &SELECTION_TOOL::selectCopper, PCB_ACTIONS::selectCopper.MakeEvent() );
     Go( &SELECTION_TOOL::selectNet, PCB_ACTIONS::selectNet.MakeEvent() );
     Go( &SELECTION_TOOL::selectSameSheet, PCB_ACTIONS::selectSameSheet.MakeEvent() );
+
     Go( &SELECTION_TOOL::selectOnSheetFromEeschema, PCB_ACTIONS::selectOnSheetFromEeschema.MakeEvent() );
     Go( &SELECTION_TOOL::updateSelection, PCB_ACTIONS::selectionModified.MakeEvent() );
 }
 
 
+
 SELECTION_LOCK_FLAGS SELECTION_TOOL::CheckLock()
 {
     if( !m_locked || m_editModules )