diff --git a/apps/opencs/model/world/collection.hpp b/apps/opencs/model/world/collection.hpp
index df144ba7bf..d342e88a47 100644
--- a/apps/opencs/model/world/collection.hpp
+++ b/apps/opencs/model/world/collection.hpp
@@ -98,6 +98,10 @@ namespace CSMWorld
                 UniversalId::Type type = UniversalId::Type_None);
             ///< \param type Will be ignored, unless the collection supports multiple record types
 
+            virtual void cloneRecord(const std::string& origin, 
+                                     const std::string& destination,
+                                     const UniversalId::Type type);
+
             virtual int searchId (const std::string& id) const;
             ////< Search record with \a id.
             /// \return index of record (if found) or -1 (not found)
@@ -193,6 +197,19 @@ namespace CSMWorld
         return true;
     }
 
+    template<typename ESXRecordT, typename IdAccessorT>
+    void Collection<ESXRecordT, IdAccessorT>::cloneRecord(const std::string& origin, 
+                                                          const std::string& destination,
+                                                          const UniversalId::Type type)
+    {
+       Record<ESXRecordT> copy;
+       copy.mModified = getRecord(origin).get();
+       copy.mState = RecordBase::State_ModifiedOnly;
+       copy.get().mId = destination;
+
+       insertRecord(copy, getAppendIndex(destination, type));
+    }
+
     template<typename ESXRecordT, typename IdAccessorT>
     Collection<ESXRecordT, IdAccessorT>::Collection()
     {}
diff --git a/apps/opencs/model/world/collectionbase.hpp b/apps/opencs/model/world/collectionbase.hpp
index ab7a9ebecb..408a89d923 100644
--- a/apps/opencs/model/world/collectionbase.hpp
+++ b/apps/opencs/model/world/collectionbase.hpp
@@ -74,6 +74,10 @@ namespace CSMWorld
                 UniversalId::Type type = UniversalId::Type_None) = 0;
             ///< If the record type does not match, an exception is thrown.
 
+            virtual void cloneRecord(const std::string& origin, 
+                                     const std::string& destination,
+                                     const UniversalId::Type type) = 0;
+
             virtual const RecordBase& getRecord (const std::string& id) const = 0;
 
             virtual const RecordBase& getRecord (int index) const = 0;
diff --git a/apps/opencs/model/world/commands.cpp b/apps/opencs/model/world/commands.cpp
index 21feb14be6..b60ffeb29c 100644
--- a/apps/opencs/model/world/commands.cpp
+++ b/apps/opencs/model/world/commands.cpp
@@ -4,10 +4,10 @@
 #include <QAbstractItemModel>
 
 #include "idtable.hpp"
-#include "idtable.hpp"
+#include <components/misc/stringops.hpp>
 
 CSMWorld::ModifyCommand::ModifyCommand (QAbstractItemModel& model, const QModelIndex& index,
-    const QVariant& new_, QUndoCommand *parent)
+                                        const QVariant& new_, QUndoCommand* parent)
 : QUndoCommand (parent), mModel (model), mIndex (index), mNew (new_)
 {
     mOld = mModel.data (mIndex, Qt::EditRole);
@@ -25,7 +25,7 @@ void CSMWorld::ModifyCommand::undo()
     mModel.setData (mIndex, mOld);
 }
 
-CSMWorld::CreateCommand::CreateCommand (IdTable& model, const std::string& id, QUndoCommand *parent)
+CSMWorld::CreateCommand::CreateCommand (IdTable& model, const std::string& id, QUndoCommand* parent)
 : QUndoCommand (parent), mModel (model), mId (id), mType (UniversalId::Type_None)
 {
     setText (("Create record " + id).c_str());
@@ -54,7 +54,7 @@ void CSMWorld::CreateCommand::undo()
     mModel.removeRow (mModel.getModelIndex (mId, 0).row());
 }
 
-CSMWorld::RevertCommand::RevertCommand (IdTable& model, const std::string& id, QUndoCommand *parent)
+CSMWorld::RevertCommand::RevertCommand (IdTable& model, const std::string& id, QUndoCommand* parent)
 : QUndoCommand (parent), mModel (model), mId (id), mOld (0)
 {
     setText (("Revert record " + id).c_str());
@@ -89,7 +89,7 @@ void CSMWorld::RevertCommand::undo()
     mModel.setRecord (mId, *mOld);
 }
 
-CSMWorld::DeleteCommand::DeleteCommand (IdTable& model, const std::string& id, QUndoCommand *parent)
+CSMWorld::DeleteCommand::DeleteCommand (IdTable& model, const std::string& id, QUndoCommand* parent)
 : QUndoCommand (parent), mModel (model), mId (id), mOld (0)
 {
     setText (("Delete record " + id).c_str());
@@ -126,7 +126,7 @@ void CSMWorld::DeleteCommand::undo()
 
 
 CSMWorld::ReorderRowsCommand::ReorderRowsCommand (IdTable& model, int baseIndex,
-    const std::vector<int>& newOrder)
+        const std::vector<int>& newOrder)
 : mModel (model), mBaseIndex (baseIndex), mNewOrder (newOrder)
 {}
 
@@ -140,8 +140,35 @@ void CSMWorld::ReorderRowsCommand::undo()
     int size = static_cast<int> (mNewOrder.size());
     std::vector<int> reverse (size);
 
-    for (int i=0; i<size; ++i)
+    for (int i=0; i< size; ++i)
         reverse.at (mNewOrder[i]) = i;
 
     mModel.reorderRows (mBaseIndex, reverse);
+}
+
+CSMWorld::CloneCommand::CloneCommand (CSMWorld::IdTable& model,
+                                      const std::string& idOrigin,
+                                      const std::string& IdDestination,
+                                      const CSMWorld::UniversalId::Type type,
+                                      QUndoCommand* parent) :
+    QUndoCommand (parent),
+    mModel (model),
+    mIdOrigin (idOrigin),
+    mIdDestination (Misc::StringUtils::lowerCase (IdDestination)),
+    mType (type)
+{
+    setText ( ("Clone record " + idOrigin + " to the " + IdDestination).c_str());
+}
+
+void CSMWorld::CloneCommand::redo()
+{
+    mModel.cloneRecord (mIdOrigin, mIdDestination, mType);
+
+    for (std::map<int, QVariant>::const_iterator iter (mValues.begin()); iter != mValues.end(); ++iter)
+        mModel.setData (mModel.getModelIndex (mIdDestination, iter->first), iter->second);
+}
+
+void CSMWorld::CloneCommand::undo()
+{
+    mModel.removeRow (mModel.getModelIndex (mIdDestination, 0).row());
 }
\ No newline at end of file
diff --git a/apps/opencs/model/world/commands.hpp b/apps/opencs/model/world/commands.hpp
index f0480a369d..ec6350658f 100644
--- a/apps/opencs/model/world/commands.hpp
+++ b/apps/opencs/model/world/commands.hpp
@@ -39,6 +39,26 @@ namespace CSMWorld
             virtual void undo();
     };
 
+    class CloneCommand : public QUndoCommand
+    {
+            IdTable& mModel;
+            std::string mIdOrigin;
+            std::string mIdDestination;
+            UniversalId::Type mType;
+            std::map<int, QVariant> mValues;
+
+        public:
+
+            CloneCommand (IdTable& model, const std::string& idOrigin, 
+                          const std::string& IdDestination,
+                          const UniversalId::Type type,
+                          QUndoCommand* parent = 0);
+
+            virtual void redo();
+
+            virtual void undo();
+    };
+
     class CreateCommand : public QUndoCommand
     {
             IdTable& mModel;
diff --git a/apps/opencs/model/world/data.cpp b/apps/opencs/model/world/data.cpp
index 04e35cdaaf..8d53c4e53a 100644
--- a/apps/opencs/model/world/data.cpp
+++ b/apps/opencs/model/world/data.cpp
@@ -154,14 +154,17 @@ CSMWorld::Data::Data() : mRefs (mCells)
 
     mTopics.addColumn (new StringIdColumn<ESM::Dialogue>);
     mTopics.addColumn (new RecordStateColumn<ESM::Dialogue>);
+    mTopics.addColumn (new FixedRecordTypeColumn<ESM::Dialogue> (UniversalId::Type_Topic));
     mTopics.addColumn (new DialogueTypeColumn<ESM::Dialogue>);
 
     mJournals.addColumn (new StringIdColumn<ESM::Dialogue>);
     mJournals.addColumn (new RecordStateColumn<ESM::Dialogue>);
+    mJournals.addColumn (new FixedRecordTypeColumn<ESM::Dialogue> (UniversalId::Type_Journal));
     mJournals.addColumn (new DialogueTypeColumn<ESM::Dialogue> (true));
 
     mTopicInfos.addColumn (new StringIdColumn<Info> (true));
     mTopicInfos.addColumn (new RecordStateColumn<Info>);
+    mTopicInfos.addColumn (new FixedRecordTypeColumn<Info> (UniversalId::Type_TopicInfo));
     mTopicInfos.addColumn (new TopicColumn<Info> (false));
     mTopicInfos.addColumn (new ActorColumn<Info>);
     mTopicInfos.addColumn (new RaceColumn<Info>);
@@ -178,6 +181,7 @@ CSMWorld::Data::Data() : mRefs (mCells)
 
     mJournalInfos.addColumn (new StringIdColumn<Info> (true));
     mJournalInfos.addColumn (new RecordStateColumn<Info>);
+    mJournalInfos.addColumn (new FixedRecordTypeColumn<Info> (UniversalId::Type_Journal));
     mJournalInfos.addColumn (new TopicColumn<Info> (true));
     mJournalInfos.addColumn (new QuestStatusTypeColumn<Info>);
     mJournalInfos.addColumn (new QuestIndexColumn<Info>);
@@ -194,6 +198,7 @@ CSMWorld::Data::Data() : mRefs (mCells)
 
     mRefs.addColumn (new StringIdColumn<CellRef> (true));
     mRefs.addColumn (new RecordStateColumn<CellRef>);
+    mRefs.addColumn (new FixedRecordTypeColumn<CellRef> (UniversalId::Type_Reference));
     mRefs.addColumn (new CellColumn<CellRef>);
     mRefs.addColumn (new IdColumn<CellRef>);
     mRefs.addColumn (new PosColumn<CellRef> (&CellRef::mPos, 0, false));
@@ -224,6 +229,7 @@ CSMWorld::Data::Data() : mRefs (mCells)
 
     mFilters.addColumn (new StringIdColumn<CSMFilter::Filter>);
     mFilters.addColumn (new RecordStateColumn<CSMFilter::Filter>);
+    mFilters.addColumn (new FixedRecordTypeColumn<CSMFilter::Filter> (UniversalId::Type_Filter));
     mFilters.addColumn (new FilterColumn<CSMFilter::Filter>);
     mFilters.addColumn (new DescriptionColumn<CSMFilter::Filter>);
     mFilters.addColumn (new ScopeColumn<CSMFilter::Filter>);
diff --git a/apps/opencs/model/world/idtable.cpp b/apps/opencs/model/world/idtable.cpp
index 809d64339c..bea307aa21 100644
--- a/apps/opencs/model/world/idtable.cpp
+++ b/apps/opencs/model/world/idtable.cpp
@@ -124,6 +124,17 @@ void CSMWorld::IdTable::addRecord (const std::string& id, UniversalId::Type type
     endInsertRows();
 }
 
+void CSMWorld::IdTable::cloneRecord(const std::string& origin,
+                                    const std::string& destination,
+                                    CSMWorld::UniversalId::Type type)
+{
+    int index = mIdCollection->getAppendIndex (destination);
+    beginInsertRows (QModelIndex(), index, index);
+    mIdCollection->cloneRecord(origin, destination, type);
+    endInsertRows();
+}
+
+
 QModelIndex CSMWorld::IdTable::getModelIndex (const std::string& id, int column) const
 {
     return index (mIdCollection->getIndex (id), column);
diff --git a/apps/opencs/model/world/idtable.hpp b/apps/opencs/model/world/idtable.hpp
index e4ae58fd04..74923867d6 100644
--- a/apps/opencs/model/world/idtable.hpp
+++ b/apps/opencs/model/world/idtable.hpp
@@ -63,6 +63,10 @@ namespace CSMWorld
             void addRecord (const std::string& id, UniversalId::Type type = UniversalId::Type_None);
             ///< \param type Will be ignored, unless the collection supports multiple record types
 
+            void cloneRecord(const std::string& origin, 
+                             const std::string& destination, 
+                             UniversalId::Type type = UniversalId::Type_None);
+
             QModelIndex getModelIndex (const std::string& id, int column) const;
 
             void setRecord (const std::string& id, const RecordBase& record);
diff --git a/apps/opencs/model/world/refcollection.cpp b/apps/opencs/model/world/refcollection.cpp
index 696aeefaa2..6b00812583 100644
--- a/apps/opencs/model/world/refcollection.cpp
+++ b/apps/opencs/model/world/refcollection.cpp
@@ -5,6 +5,8 @@
 
 #include "ref.hpp"
 #include "cell.hpp"
+#include "universalid.hpp"
+#include "record.hpp"
 
 void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool base)
 {
@@ -34,4 +36,15 @@ std::string CSMWorld::RefCollection::getNewId()
     std::ostringstream stream;
     stream << "ref#" << mNextId++;
     return stream.str();
+}
+
+void CSMWorld::RefCollection::cloneRecord(const std::string& origin, 
+                         const std::string& destination,
+                         const CSMWorld::UniversalId::Type type,
+                         const CSMWorld::UniversalId::ArgumentType argumentType)
+{
+       Record<CSMWorld::CellRef> clone(getRecord(origin));
+       clone.mState = CSMWorld::RecordBase::State_ModifiedOnly;
+       clone.get().mId = destination;
+       insertRecord(clone, getAppendIndex(destination, type), type);
 }
\ No newline at end of file
diff --git a/apps/opencs/model/world/refcollection.hpp b/apps/opencs/model/world/refcollection.hpp
index b5f8c8064a..dcfd2036cd 100644
--- a/apps/opencs/model/world/refcollection.hpp
+++ b/apps/opencs/model/world/refcollection.hpp
@@ -8,6 +8,7 @@
 namespace CSMWorld
 {
     struct Cell;
+    struct UniversalId;
 
     /// \brief References in cells
     class RefCollection : public Collection<CellRef>
@@ -25,6 +26,11 @@ namespace CSMWorld
             ///< Load a sequence of references.
 
             std::string getNewId();
+            
+            void cloneRecord(const std::string& origin, 
+                             const std::string& destination,
+                             const CSMWorld::UniversalId::Type type,
+                             const CSMWorld::UniversalId::ArgumentType argumentType);
     };
 }
 
diff --git a/apps/opencs/model/world/refidadapter.hpp b/apps/opencs/model/world/refidadapter.hpp
index df0ceae706..0870a2d3e6 100644
--- a/apps/opencs/model/world/refidadapter.hpp
+++ b/apps/opencs/model/world/refidadapter.hpp
@@ -31,6 +31,7 @@ namespace CSMWorld
             ///< If the data type does not match an exception is thrown.
 
             virtual std::string getId (const RecordBase& record) const = 0;
+            virtual void setId(RecordBase& record, const std::string& id) = 0;
     };
 }
 
diff --git a/apps/opencs/model/world/refidadapterimp.hpp b/apps/opencs/model/world/refidadapterimp.hpp
index d5d84a8f7e..bd509a86b6 100644
--- a/apps/opencs/model/world/refidadapterimp.hpp
+++ b/apps/opencs/model/world/refidadapterimp.hpp
@@ -34,6 +34,8 @@ namespace CSMWorld
             BaseRefIdAdapter (UniversalId::Type type, const BaseColumns& base);
 
             virtual std::string getId (const RecordBase& record) const;
+            
+            virtual void setId (RecordBase& record, const std::string& id);
 
             virtual QVariant getData (const RefIdColumn *column, const RefIdData& data, int index)
                 const;
@@ -50,6 +52,12 @@ namespace CSMWorld
     : mType (type), mBase (base)
     {}
 
+    template<typename RecordT>
+    void BaseRefIdAdapter<RecordT>::setId (RecordBase& record, const std::string& id)
+    {
+        (dynamic_cast<Record<RecordT>&> (record).get().mId) = id;
+    }
+    
     template<typename RecordT>
     std::string BaseRefIdAdapter<RecordT>::getId (const RecordBase& record) const
     {
diff --git a/apps/opencs/model/world/refidcollection.cpp b/apps/opencs/model/world/refidcollection.cpp
index 176a19f2f0..8a1af35092 100644
--- a/apps/opencs/model/world/refidcollection.cpp
+++ b/apps/opencs/model/world/refidcollection.cpp
@@ -2,6 +2,7 @@
 #include "refidcollection.hpp"
 
 #include <stdexcept>
+#include <memory>
 
 #include <components/esm/esmreader.hpp>
 
@@ -449,6 +450,16 @@ void CSMWorld::RefIdCollection::replace (int index, const RecordBase& record)
     mData.getRecord (mData.globalToLocalIndex (index)).assign (record);
 }
 
+void CSMWorld::RefIdCollection::cloneRecord(const std::string& origin, 
+                                     const std::string& destination,
+                                     const CSMWorld::UniversalId::Type type)
+{
+        std::auto_ptr<RecordBase> newRecord(mData.getRecord(mData.searchId(origin)).clone());
+        newRecord->mState = RecordBase::State_ModifiedOnly;
+        mAdapters.find(type)->second->setId(*newRecord, destination);
+        mData.insertRecord(*newRecord, type, destination);
+}
+
 void CSMWorld::RefIdCollection::appendRecord (const RecordBase& record,
     UniversalId::Type type)
 {
diff --git a/apps/opencs/model/world/refidcollection.hpp b/apps/opencs/model/world/refidcollection.hpp
index 328680d85a..dd6213677e 100644
--- a/apps/opencs/model/world/refidcollection.hpp
+++ b/apps/opencs/model/world/refidcollection.hpp
@@ -69,6 +69,10 @@ namespace CSMWorld
 
             virtual void removeRows (int index, int count);
 
+            virtual void cloneRecord(const std::string& origin, 
+                                     const std::string& destination,
+                                     const UniversalId::Type type);
+
             virtual void appendBlankRecord (const std::string& id, UniversalId::Type type);
             ///< \param type Will be ignored, unless the collection supports multiple record types
 
diff --git a/apps/opencs/model/world/refiddata.cpp b/apps/opencs/model/world/refiddata.cpp
index 65990c1d45..9d980a99cd 100644
--- a/apps/opencs/model/world/refiddata.cpp
+++ b/apps/opencs/model/world/refiddata.cpp
@@ -330,4 +330,18 @@ const CSMWorld::RefIdDataContainer< ESM::Repair >& CSMWorld::RefIdData::getRepai
 const CSMWorld::RefIdDataContainer< ESM::Static >& CSMWorld::RefIdData::getStatics() const
 {
     return mStatics;
-}
\ No newline at end of file
+}
+
+void CSMWorld::RefIdData::insertRecord(CSMWorld::RecordBase& record, CSMWorld::UniversalId::Type type, const std::string& id)
+{
+  std::map<UniversalId::Type, RefIdDataContainerBase *>::iterator iter =
+        mRecordContainers.find (type);
+
+    if (iter==mRecordContainers.end())
+        throw std::logic_error ("invalid local index type");
+
+    iter->second->insertRecord(record);
+
+    mIndex.insert (std::make_pair (Misc::StringUtils::lowerCase (id),
+        LocalIndex (iter->second->getSize()-1, type)));
+}
diff --git a/apps/opencs/model/world/refiddata.hpp b/apps/opencs/model/world/refiddata.hpp
index a204334b37..9fb143e813 100644
--- a/apps/opencs/model/world/refiddata.hpp
+++ b/apps/opencs/model/world/refiddata.hpp
@@ -46,6 +46,8 @@ namespace CSMWorld
         virtual RecordBase& getRecord (int index)= 0;
 
         virtual void appendRecord (const std::string& id) = 0;
+        
+        virtual void insertRecord (RecordBase& record) = 0;
 
         virtual void load (int index,  ESM::ESMReader& reader, bool base) = 0;
 
@@ -68,6 +70,8 @@ namespace CSMWorld
         virtual RecordBase& getRecord (int index);
 
         virtual void appendRecord (const std::string& id);
+        
+        virtual void insertRecord (RecordBase& record);
 
         virtual void load (int index,  ESM::ESMReader& reader, bool base);
 
@@ -78,6 +82,13 @@ namespace CSMWorld
         virtual void save (int index, ESM::ESMWriter& writer) const;
     };
 
+    template<typename RecordT>
+    void RefIdDataContainer<RecordT>::insertRecord(RecordBase& record)
+    {
+        Record<RecordT>& newRecord = dynamic_cast<Record<RecordT>& >(record);
+        mContainer.push_back(newRecord);
+    }
+    
     template<typename RecordT>
     int RefIdDataContainer<RecordT>::getSize() const
     {
@@ -200,6 +211,8 @@ namespace CSMWorld
             LocalIndex searchId (const std::string& id) const;
 
             void erase (int index, int count);
+            
+            void insertRecord(CSMWorld::RecordBase& record, CSMWorld::UniversalId::Type type, const std::string& id);
 
             const RecordBase& getRecord (const LocalIndex& index) const;
 
diff --git a/apps/opencs/view/world/cellcreator.cpp b/apps/opencs/view/world/cellcreator.cpp
index 74fb068700..cdeee56559 100644
--- a/apps/opencs/view/world/cellcreator.cpp
+++ b/apps/opencs/view/world/cellcreator.cpp
@@ -61,6 +61,7 @@ void CSVWorld::CellCreator::reset()
     mX->setValue (0);
     mY->setValue (0);
     mType->setCurrentIndex (0);
+    setType(0);
     GenericCreator::reset();
 }
 
@@ -78,4 +79,25 @@ void CSVWorld::CellCreator::setType (int index)
 void CSVWorld::CellCreator::valueChanged (int index)
 {
     update();
-}
\ No newline at end of file
+}
+
+void CSVWorld::CellCreator::cloneMode(const std::string& originId, 
+                                      const CSMWorld::UniversalId::Type type)
+{
+    CSVWorld::GenericCreator::cloneMode(originId, type);
+    if (*(originId.begin()) == '#') //if originid points to the exterior cell
+    {
+        setType(1); //enable x and y controls
+        mType->setCurrentIndex(1);
+    } else {
+        setType(0);
+        mType->setCurrentIndex(0);
+    }
+}
+
+
+void CSVWorld::CellCreator::toggleWidgets(bool active)
+{
+    CSVWorld::GenericCreator::toggleWidgets(active);
+    mType->setEnabled(active);
+}
diff --git a/apps/opencs/view/world/cellcreator.hpp b/apps/opencs/view/world/cellcreator.hpp
index a5473e2c97..db9fbf8a34 100644
--- a/apps/opencs/view/world/cellcreator.hpp
+++ b/apps/opencs/view/world/cellcreator.hpp
@@ -29,6 +29,11 @@ namespace CSVWorld
 
             virtual void reset();
 
+            virtual void toggleWidgets(bool active = true);
+
+            virtual void cloneMode(const std::string& originId, 
+                                   const CSMWorld::UniversalId::Type type);
+
         private slots:
 
             void setType (int index);
diff --git a/apps/opencs/view/world/creator.hpp b/apps/opencs/view/world/creator.hpp
index df9b116eed..88da70330d 100644
--- a/apps/opencs/view/world/creator.hpp
+++ b/apps/opencs/view/world/creator.hpp
@@ -2,6 +2,7 @@
 #define CSV_WORLD_CREATOR_H
 
 #include <QWidget>
+#include "../../model/world/universalid.hpp"
 
 class QUndoStack;
 
@@ -24,8 +25,13 @@ namespace CSVWorld
 
             virtual void reset() = 0;
 
+            virtual void cloneMode(const std::string& originId,
+                                   const CSMWorld::UniversalId::Type type) = 0;
+
             virtual void setEditLock (bool locked) = 0;
 
+            virtual void toggleWidgets(bool active = true) = 0;
+
         signals:
 
             void done();
diff --git a/apps/opencs/view/world/genericcreator.cpp b/apps/opencs/view/world/genericcreator.cpp
index ba2b3665a9..cd7a5fa189 100644
--- a/apps/opencs/view/world/genericcreator.cpp
+++ b/apps/opencs/view/world/genericcreator.cpp
@@ -57,8 +57,15 @@ const CSMWorld::UniversalId& CSVWorld::GenericCreator::getCollectionId() const
 }
 
 CSVWorld::GenericCreator::GenericCreator (CSMWorld::Data& data, QUndoStack& undoStack,
-    const CSMWorld::UniversalId& id, bool relaxedIdRules)
-: mData (data), mUndoStack (undoStack), mListId (id), mLocked (false)
+    const CSMWorld::UniversalId& id, bool relaxedIdRules):
+
+    mData (data),
+    mUndoStack (undoStack),
+    mListId (id),
+    mLocked (false),
+    mCloneMode(false),
+    mClonedType(CSMWorld::UniversalId::Type_None)
+
 {
     mLayout = new QHBoxLayout;
     mLayout->setContentsMargins (0, 0, 0, 0);
@@ -89,6 +96,7 @@ void CSVWorld::GenericCreator::setEditLock (bool locked)
 
 void CSVWorld::GenericCreator::reset()
 {
+    mCloneMode = false;
     mId->setText ("");
     update();
 }
@@ -120,16 +128,40 @@ void CSVWorld::GenericCreator::create()
 {
     if (!mLocked)
     {
-        std::string id = getId();
+        if (mCloneMode)
+        {
+            std::string id = getId();
+            std::auto_ptr<CSMWorld::CloneCommand> command (new CSMWorld::CloneCommand (
+                dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel(mListId)), mClonedId, id, mClonedType));
+            
+            mUndoStack.push(command.release());
+            
+            emit done();
+            emit requestFocus(id);
+        } else {
+            std::string id = getId();
 
-        std::auto_ptr<CSMWorld::CreateCommand> command (new CSMWorld::CreateCommand (
+            std::auto_ptr<CSMWorld::CreateCommand> command (new CSMWorld::CreateCommand (
             dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel (mListId)), id));
 
-        configureCreateCommand (*command);
+            configureCreateCommand (*command);
 
-        mUndoStack.push (command.release());
+            mUndoStack.push (command.release());
 
-        emit done();
-        emit requestFocus (id);
+            emit done();
+            emit requestFocus (id);
+        }
     }
-}
\ No newline at end of file
+}
+
+void CSVWorld::GenericCreator::cloneMode(const std::string& originId,
+                                         const CSMWorld::UniversalId::Type type)
+{
+    mCloneMode = true;
+    mClonedId = originId;
+    mClonedType = type;
+}
+
+void CSVWorld::GenericCreator::toggleWidgets(bool active)
+{
+}
diff --git a/apps/opencs/view/world/genericcreator.hpp b/apps/opencs/view/world/genericcreator.hpp
index 8dd2ca911c..714853f986 100644
--- a/apps/opencs/view/world/genericcreator.hpp
+++ b/apps/opencs/view/world/genericcreator.hpp
@@ -1,6 +1,7 @@
 #ifndef CSV_WORLD_GENERICCREATOR_H
 #define CSV_WORLD_GENERICCREATOR_H
 
+class QString;
 class QPushButton;
 class QLineEdit;
 class QHBoxLayout;
@@ -28,6 +29,11 @@ namespace CSVWorld
             std::string mErrors;
             QHBoxLayout *mLayout;
             bool mLocked;
+            std::string mClonedId;
+            CSMWorld::UniversalId::Type mClonedType;
+
+        protected:
+            bool mCloneMode;
 
         protected:
 
@@ -57,11 +63,15 @@ namespace CSVWorld
 
             virtual void reset();
 
+            virtual void toggleWidgets (bool active = true);
+
+            virtual void cloneMode(const std::string& originId, 
+                                   const CSMWorld::UniversalId::Type type);
+
             virtual std::string getErrors() const;
             ///< Return formatted error descriptions for the current state of the creator. if an empty
             /// string is returned, there is no error.
 
-
         private slots:
 
             void textChanged (const QString& text);
diff --git a/apps/opencs/view/world/referenceablecreator.cpp b/apps/opencs/view/world/referenceablecreator.cpp
index 718fe9ca7c..7a5fca8538 100644
--- a/apps/opencs/view/world/referenceablecreator.cpp
+++ b/apps/opencs/view/world/referenceablecreator.cpp
@@ -40,4 +40,10 @@ void CSVWorld::ReferenceableCreator::reset()
 {
     mType->setCurrentIndex (0);
     GenericCreator::reset();
-}
\ No newline at end of file
+}
+
+void CSVWorld::ReferenceableCreator::toggleWidgets(bool active)
+{
+    CSVWorld::GenericCreator::toggleWidgets(active);
+    mType->setEnabled(active);
+}
diff --git a/apps/opencs/view/world/referenceablecreator.hpp b/apps/opencs/view/world/referenceablecreator.hpp
index 06e0e582be..88545575e3 100644
--- a/apps/opencs/view/world/referenceablecreator.hpp
+++ b/apps/opencs/view/world/referenceablecreator.hpp
@@ -23,6 +23,7 @@ namespace CSVWorld
                 const CSMWorld::UniversalId& id);
 
             virtual void reset();
+            virtual void toggleWidgets(bool active = true);
 
     };
 }
diff --git a/apps/opencs/view/world/referencecreator.cpp b/apps/opencs/view/world/referencecreator.cpp
index aef25a81d0..6b8e02da0d 100644
--- a/apps/opencs/view/world/referencecreator.cpp
+++ b/apps/opencs/view/world/referencecreator.cpp
@@ -40,15 +40,20 @@ CSVWorld::ReferenceCreator::ReferenceCreator (CSMWorld::Data& data, QUndoStack&
 
 void CSVWorld::ReferenceCreator::reset()
 {
+    GenericCreator::reset();
     mCell->setText ("");
     mId = getData().getReferences().getNewId();
-    GenericCreator::reset();
 }
 
 std::string CSVWorld::ReferenceCreator::getErrors() const
 {
     std::string errors = GenericCreator::getErrors();
 
+    if (mCloneMode)
+    {
+        return errors;
+    }
+
     std::string cell = mCell->text().toUtf8().constData();
 
     if (cell.empty())
@@ -72,4 +77,17 @@ std::string CSVWorld::ReferenceCreator::getErrors() const
 void CSVWorld::ReferenceCreator::cellChanged()
 {
     update();
-}
\ No newline at end of file
+}
+
+void CSVWorld::ReferenceCreator::toggleWidgets(bool active)
+{
+    CSVWorld::GenericCreator::toggleWidgets(active);
+    mCell->setEnabled(active);
+}
+
+void CSVWorld::ReferenceCreator::cloneMode(const std::string& originId,
+                                           const CSMWorld::UniversalId::Type type)
+{
+    CSVWorld::GenericCreator::cloneMode(originId, type);
+    cellChanged(); //otherwise ok button will remain disabled
+}
diff --git a/apps/opencs/view/world/referencecreator.hpp b/apps/opencs/view/world/referencecreator.hpp
index 27f81564fd..12fb12dd90 100644
--- a/apps/opencs/view/world/referencecreator.hpp
+++ b/apps/opencs/view/world/referencecreator.hpp
@@ -25,7 +25,11 @@ namespace CSVWorld
             ReferenceCreator (CSMWorld::Data& data, QUndoStack& undoStack,
                 const CSMWorld::UniversalId& id);
 
+            virtual void cloneMode(const std::string& originId, 
+                                   const CSMWorld::UniversalId::Type type);
+
             virtual void reset();
+            virtual void toggleWidgets(bool active = true);
 
             virtual std::string getErrors() const;
             ///< Return formatted error descriptions for the current state of the creator. if an empty
diff --git a/apps/opencs/view/world/table.cpp b/apps/opencs/view/world/table.cpp
index 71bdb9000e..8f6fc46a88 100644
--- a/apps/opencs/view/world/table.cpp
+++ b/apps/opencs/view/world/table.cpp
@@ -28,7 +28,11 @@ void CSVWorld::Table::contextMenuEvent (QContextMenuEvent *event)
     if (!mEditLock)
     {
         if (selectedRows.size()==1)
+        {
             menu.addAction (mEditAction);
+            if (mCreateAction)
+                menu.addAction(mCloneAction);
+        }
 
         if (mCreateAction)
             menu.addAction (mCreateAction);
@@ -155,7 +159,7 @@ std::vector<std::string> CSVWorld::Table::listDeletableSelectedIds() const
 
 CSVWorld::Table::Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, QUndoStack& undoStack,
     bool createAndDelete, bool sorting)
-    : mUndoStack (undoStack), mCreateAction (0), mEditLock (false), mRecordStatusDisplay (0)
+    : mUndoStack (undoStack), mCreateAction (0), mCloneAction(0), mEditLock (false), mRecordStatusDisplay (0)
 {
     mModel = &dynamic_cast<CSMWorld::IdTable&> (*data.getTableModel (id));
 
@@ -199,6 +203,10 @@ CSVWorld::Table::Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, Q
         mCreateAction = new QAction (tr ("Add Record"), this);
         connect (mCreateAction, SIGNAL (triggered()), this, SIGNAL (createRequest()));
         addAction (mCreateAction);
+
+        mCloneAction = new QAction (tr ("Clone Record"), this);
+        connect(mCloneAction, SIGNAL (triggered()), this, SLOT (cloneRecord()));
+        addAction(mCloneAction);
     }
 
     mRevertAction = new QAction (tr ("Revert Record"), this);
@@ -295,6 +303,19 @@ void CSVWorld::Table::editRecord()
     }
 }
 
+void CSVWorld::Table::cloneRecord()
+{
+    if (!mEditLock)
+    {
+        QModelIndexList selectedRows = selectionModel()->selectedRows();
+        const CSMWorld::UniversalId& toClone = getUniversalId(selectedRows.begin()->row());
+        if (selectedRows.size()==1 && !mModel->getRecord(toClone.getId()).isDeleted())
+        {
+            emit cloneRequest (toClone);
+        }
+    }
+}
+
 void CSVWorld::Table::moveUpRecord()
 {
     QModelIndexList selectedRows = selectionModel()->selectedRows();
diff --git a/apps/opencs/view/world/table.hpp b/apps/opencs/view/world/table.hpp
index 889e2847ac..d30083333f 100644
--- a/apps/opencs/view/world/table.hpp
+++ b/apps/opencs/view/world/table.hpp
@@ -32,6 +32,7 @@ namespace CSVWorld
             QUndoStack& mUndoStack;
             QAction *mEditAction;
             QAction *mCreateAction;
+            QAction *mCloneAction;
             QAction *mRevertAction;
             QAction *mDeleteAction;
             QAction *mMoveUpAction;
@@ -73,6 +74,7 @@ namespace CSVWorld
             /// \param modified Number of added and modified records
 
             void createRequest();
+            void cloneRequest(const CSMWorld::UniversalId&);
 
         private slots:
 
@@ -82,6 +84,8 @@ namespace CSVWorld
 
             void editRecord();
 
+            void cloneRecord();
+
             void moveUpRecord();
 
             void moveDownRecord();
diff --git a/apps/opencs/view/world/tablebottombox.cpp b/apps/opencs/view/world/tablebottombox.cpp
index 3edf9af317..239c7410fb 100644
--- a/apps/opencs/view/world/tablebottombox.cpp
+++ b/apps/opencs/view/world/tablebottombox.cpp
@@ -153,7 +153,19 @@ void CSVWorld::TableBottomBox::tableSizeChanged (int size, int deleted, int modi
 void CSVWorld::TableBottomBox::createRequest()
 {
     mCreator->reset();
+    mCreator->toggleWidgets(true);
     mLayout->setCurrentWidget (mCreator);
     setVisible (true);
     mCreating = true;
-}
\ No newline at end of file
+}
+
+void CSVWorld::TableBottomBox::cloneRequest(const std::string& id, 
+                                            const CSMWorld::UniversalId::Type type) 
+{
+    mCreator->reset();
+    mCreator->cloneMode(id, type);
+    mLayout->setCurrentWidget(mCreator);
+    mCreator->toggleWidgets(false);
+    setVisible (true);
+    mCreating = true;
+}
diff --git a/apps/opencs/view/world/tablebottombox.hpp b/apps/opencs/view/world/tablebottombox.hpp
index a5ae5e0bd9..8f0d851632 100644
--- a/apps/opencs/view/world/tablebottombox.hpp
+++ b/apps/opencs/view/world/tablebottombox.hpp
@@ -2,6 +2,7 @@
 #define CSV_WORLD_BOTTOMBOX_H
 
 #include <QWidget>
+#include <apps/opencs/model/world/universalid.hpp>
 
 class QLabel;
 class QStackedLayout;
@@ -76,6 +77,8 @@ namespace CSVWorld
             /// \param modified Number of added and modified records
 
             void createRequest();
+            void cloneRequest(const std::string& id,
+                              const CSMWorld::UniversalId::Type type);
     };
 }
 
diff --git a/apps/opencs/view/world/tablesubview.cpp b/apps/opencs/view/world/tablesubview.cpp
index 55ded09de2..981faaf591 100644
--- a/apps/opencs/view/world/tablesubview.cpp
+++ b/apps/opencs/view/world/tablesubview.cpp
@@ -6,7 +6,6 @@
 #include "../../model/doc/document.hpp"
 
 #include "../filter/filterbox.hpp"
-
 #include "table.hpp"
 #include "tablebottombox.hpp"
 #include "creator.hpp"
@@ -46,8 +45,15 @@ CSVWorld::TableSubView::TableSubView (const CSMWorld::UniversalId& id, CSMDoc::D
     mTable->selectionSizeUpdate();
 
     if (mBottom->canCreateAndDelete())
+    {
         connect (mTable, SIGNAL (createRequest()), mBottom, SLOT (createRequest()));
 
+        connect (mTable, SIGNAL (cloneRequest(const CSMWorld::UniversalId&)), this,
+                 SLOT(cloneRequest(const CSMWorld::UniversalId&)));
+
+        connect (this, SIGNAL(cloneRequest(const std::string&, const CSMWorld::UniversalId::Type)),
+                mBottom, SLOT(cloneRequest(const std::string&, const CSMWorld::UniversalId::Type)));
+    }
     connect (mBottom, SIGNAL (requestFocus (const std::string&)),
         mTable, SLOT (requestFocus (const std::string&)));
 
@@ -75,4 +81,9 @@ void CSVWorld::TableSubView::updateEditorSetting(const QString &settingName, con
 void CSVWorld::TableSubView::setStatusBar (bool show)
 {
     mBottom->setStatusBar (show);
-}
\ No newline at end of file
+}
+
+void CSVWorld::TableSubView::cloneRequest(const CSMWorld::UniversalId& toClone)
+{
+    emit cloneRequest(toClone.getId(), toClone.getType());
+}
diff --git a/apps/opencs/view/world/tablesubview.hpp b/apps/opencs/view/world/tablesubview.hpp
index 56a441a4d5..d728dc2f38 100644
--- a/apps/opencs/view/world/tablesubview.hpp
+++ b/apps/opencs/view/world/tablesubview.hpp
@@ -5,6 +5,11 @@
 
 class QModelIndex;
 
+namespace CSMWorld
+{
+    class IdTable;
+}
+
 namespace CSMDoc
 {
     class Document;
@@ -34,9 +39,14 @@ namespace CSVWorld
 
             virtual void setStatusBar (bool show);
 
+        signals:
+            void cloneRequest(const std::string&,
+                              const CSMWorld::UniversalId::Type);
+
         private slots:
 
             void editRequest (int row);
+            void cloneRequest (const CSMWorld::UniversalId& toClone);
     };
 }