Merge remote-tracking branch 'sirherrbatka/DragDrop'

apps/opencs/CMakeLists.txt

@@ -24,7 +24,7 @@ opencs_units (model/world
 
 opencs_units_noqt (model/world
     universalid record commands columnbase scriptcontext cell refidcollection
-    refidadapter refiddata refidadapterimp ref collectionbase refcollection columns infocollection
+    refidadapter refiddata refidadapterimp ref collectionbase refcollection columns infocollection tablemimedata
     )
 
 opencs_hdrs_noqt (model/world

apps/opencs/model/world/columnbase.hpp

@@ -27,6 +27,47 @@ namespace CSMWorld
         enum Display
         {
             Display_String,
+
+            //CONCRETE TYPES STARTS HERE
+            Display_Skill,
+            Display_Class,
+            Display_Faction,
+            Display_Race,
+            Display_Sound,
+            Display_Region,
+            Display_Birthsign,
+            Display_Spell,
+            Display_Cell,
+            Display_Referenceable,
+            Display_Activator,
+            Display_Potion,
+            Display_Apparatus,
+            Display_Armor,
+            Display_Book,
+            Display_Clothing,
+            Display_Container,
+            Display_Creature,
+            Display_Door,
+            Display_Ingredient,
+            Display_CreatureLevelledList,
+            Display_ItemLevelledList,
+            Display_Light,
+            Display_Lockpick,
+            Display_Miscellaneous,
+            Display_Npc,
+            Display_Probe,
+            Display_Repair,
+            Display_Static,
+            Display_Weapon,
+            Display_Reference,
+            Display_Filter,
+            Display_Topic,
+            Display_Journal,
+            Display_TopicInfo,
+            Display_JournalInfo,
+            Display_Scene,
+            //CONCRETE TYPES ENDS HERE
+
             Display_Integer,
             Display_Float,
             Display_Var,

apps/opencs/model/world/columnimp.hpp

@@ -373,7 +373,7 @@ namespace CSMWorld
         SkillsColumn (int index, bool typePrefix = false, bool major = false)
         : Column<ESXRecordT> ((typePrefix ? (
             major ? Columns::ColumnId_MajorSkill1 : Columns::ColumnId_MinorSkill1) :
-            Columns::ColumnId_Skill1) + index, ColumnBase::Display_String),
+            Columns::ColumnId_Skill1) + index, ColumnBase::Display_Skill),
             mIndex (index), mMajor (major)
         {}
 
@@ -598,7 +598,7 @@ namespace CSMWorld
     struct SoundFileColumn : public Column<ESXRecordT>
     {
         SoundFileColumn()
-        : Column<ESXRecordT> (Columns::ColumnId_SoundFile, ColumnBase::Display_String)
+        : Column<ESXRecordT> (Columns::ColumnId_SoundFile, ColumnBase::Display_Sound)
         {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
@@ -811,7 +811,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct CellColumn : public Column<ESXRecordT>
     {
-        CellColumn() : Column<ESXRecordT> (Columns::ColumnId_Cell, ColumnBase::Display_String) {}
+        CellColumn() : Column<ESXRecordT> (Columns::ColumnId_Cell, ColumnBase::Display_Cell) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -890,7 +890,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct OwnerColumn : public Column<ESXRecordT>
     {
-        OwnerColumn() : Column<ESXRecordT> (Columns::ColumnId_Owner, ColumnBase::Display_String) {}
+        OwnerColumn() : Column<ESXRecordT> (Columns::ColumnId_Owner, ColumnBase::Display_Npc) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -915,7 +915,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct SoulColumn : public Column<ESXRecordT>
     {
-        SoulColumn() : Column<ESXRecordT> (Columns::ColumnId_Soul, ColumnBase::Display_String) {}
+        SoulColumn() : Column<ESXRecordT> (Columns::ColumnId_Soul, ColumnBase::Display_Creature) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -940,7 +940,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct FactionColumn : public Column<ESXRecordT>
     {
-        FactionColumn() : Column<ESXRecordT> (Columns::ColumnId_Faction, ColumnBase::Display_String) {}
+        FactionColumn() : Column<ESXRecordT> (Columns::ColumnId_Faction, ColumnBase::Display_Faction) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -1090,7 +1090,7 @@ namespace CSMWorld
     struct TeleportCellColumn : public Column<ESXRecordT>
     {
         TeleportCellColumn()
-        : Column<ESXRecordT> (Columns::ColumnId_TeleportCell, ColumnBase::Display_String)
+        : Column<ESXRecordT> (Columns::ColumnId_TeleportCell, ColumnBase::Display_Cell)
         {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
@@ -1146,7 +1146,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct KeyColumn : public Column<ESXRecordT>
     {
-        KeyColumn() : Column<ESXRecordT> (Columns::ColumnId_Key, ColumnBase::Display_String) {}
+        KeyColumn() : Column<ESXRecordT> (Columns::ColumnId_Key, ColumnBase::Display_Miscellaneous) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -1485,7 +1485,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct RaceColumn : public Column<ESXRecordT>
     {
-        RaceColumn() : Column<ESXRecordT> (Columns::ColumnId_Race, ColumnBase::Display_String) {}
+        RaceColumn() : Column<ESXRecordT> (Columns::ColumnId_Race, ColumnBase::Display_Race) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -1510,7 +1510,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct ClassColumn : public Column<ESXRecordT>
     {
-        ClassColumn() : Column<ESXRecordT> (Columns::ColumnId_Class, ColumnBase::Display_String) {}
+        ClassColumn() : Column<ESXRecordT> (Columns::ColumnId_Class, ColumnBase::Display_Class) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -1535,7 +1535,7 @@ namespace CSMWorld
     template<typename ESXRecordT>
     struct PcFactionColumn : public Column<ESXRecordT>
     {
-        PcFactionColumn() : Column<ESXRecordT> (Columns::ColumnId_PcFaction, ColumnBase::Display_String) {}
+        PcFactionColumn() : Column<ESXRecordT> (Columns::ColumnId_PcFaction, ColumnBase::Display_Faction) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {

apps/opencs/model/world/refidcollection.cpp

@@ -59,7 +59,7 @@ CSMWorld::RefIdCollection::RefIdCollection()
 
     mColumns.push_back (RefIdColumn (Columns::ColumnId_Name, ColumnBase::Display_String));
     nameColumns.mName = &mColumns.back();
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_Script, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_Script, ColumnBase::Display_Script));
     nameColumns.mScript = &mColumns.back();
 
     InventoryColumns inventoryColumns (nameColumns);
@@ -214,10 +214,10 @@ CSMWorld::RefIdCollection::RefIdCollection()
 
     creatureColumns.mFlags.insert (std::make_pair (respawn, ESM::Creature::Respawn));
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_OpenSound, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_OpenSound, ColumnBase::Display_Sound));
     const RefIdColumn *openSound = &mColumns.back();
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_CloseSound, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_CloseSound, ColumnBase::Display_Sound));
     const RefIdColumn *closeSound = &mColumns.back();
 
     LightColumns lightColumns (inventoryColumns);
@@ -231,7 +231,7 @@ CSMWorld::RefIdCollection::RefIdCollection()
     mColumns.push_back (RefIdColumn (Columns::ColumnId_Colour, ColumnBase::Display_Integer));
     lightColumns.mColor = &mColumns.back();
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_Sound, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_Sound, ColumnBase::Display_Sound));
     lightColumns.mSound = &mColumns.back();
 
     static const struct
@@ -263,13 +263,13 @@ CSMWorld::RefIdCollection::RefIdCollection()
 
     NpcColumns npcColumns (actorsColumns);
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_Race, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_Race, ColumnBase::Display_Race));
     npcColumns.mRace = &mColumns.back();
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_Class, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_Class, ColumnBase::Display_Class));
     npcColumns.mClass = &mColumns.back();
 
-    mColumns.push_back (RefIdColumn (Columns::ColumnId_Faction, ColumnBase::Display_String));
+    mColumns.push_back (RefIdColumn (Columns::ColumnId_Faction, ColumnBase::Display_Faction));
     npcColumns.mFaction = &mColumns.back();
 
     mColumns.push_back (RefIdColumn (Columns::Columnid_Hair, ColumnBase::Display_String));

apps/opencs/model/world/tablemimedata.cpp

@@ -0,0 +1,279 @@
+#include "tablemimedata.hpp"
+#include <string>
+
+#include "universalid.hpp"
+#include "columnbase.hpp"
+
+CSMWorld::TableMimeData::TableMimeData (UniversalId id)
+{
+    mUniversalId.push_back (id);
+    mObjectsFormats << QString::fromStdString ("tabledata/" + id.getTypeName());
+}
+
+CSMWorld::TableMimeData::TableMimeData (std::vector< CSMWorld::UniversalId >& id) :
+    mUniversalId (id)
+{
+    for (std::vector<UniversalId>::iterator it (mUniversalId.begin()); it != mUniversalId.end(); ++it)
+    {
+        mObjectsFormats << QString::fromStdString ("tabledata/" + it->getTypeName());
+    }
+}
+
+QStringList CSMWorld::TableMimeData::formats() const
+{
+    return mObjectsFormats;
+}
+
+CSMWorld::TableMimeData::~TableMimeData()
+{
+}
+
+std::string CSMWorld::TableMimeData::getIcon() const
+{
+    if (mUniversalId.empty())
+    {
+        throw ("TableMimeData holds no UniversalId");
+    }
+
+    std::string tmpIcon;
+    bool firstIteration = true;
+
+    for (unsigned i = 0; i < mUniversalId.size(); ++i)
+    {
+        if (firstIteration)
+        {
+            firstIteration = false;
+            tmpIcon = mUniversalId[i].getIcon();
+            continue;
+        }
+
+        if (tmpIcon != mUniversalId[i].getIcon())
+        {
+            return ":/multitype.png"; //icon stolen from gnome
+        }
+
+        tmpIcon = mUniversalId[i].getIcon();
+    }
+
+    return mUniversalId.begin()->getIcon(); //All objects are of the same type;
+}
+
+std::vector< CSMWorld::UniversalId > CSMWorld::TableMimeData::getData() const
+{
+    return mUniversalId;
+}
+
+bool CSMWorld::TableMimeData::holdsType (CSMWorld::UniversalId::Type type) const
+{
+    for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
+    {
+        if (it->getType() == type)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CSMWorld::TableMimeData::holdsType (CSMWorld::ColumnBase::Display type) const
+{
+    for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
+    {
+        if (it->getType() == convertEnums (type))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+CSMWorld::UniversalId CSMWorld::TableMimeData::returnMatching (CSMWorld::UniversalId::Type type) const
+{
+    for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
+    {
+        if (it->getType() == type)
+        {
+            return *it;
+        }
+    }
+
+    throw ("TableMimeData object does not hold object of the seeked type");
+}
+
+CSMWorld::UniversalId CSMWorld::TableMimeData::returnMatching (CSMWorld::ColumnBase::Display type) const
+{
+    for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
+    {
+        if (it->getType() == convertEnums (type))
+        {
+            return *it;
+        }
+    }
+
+    throw ("TableMimeData object does not hold object of the seeked type");
+}
+
+CSMWorld::UniversalId::Type CSMWorld::TableMimeData::convertEnums (CSMWorld::ColumnBase::Display type) const
+{
+    switch (type)
+    {
+        case CSMWorld::ColumnBase::Display_Race:
+            return CSMWorld::UniversalId::Type_Race;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Skill:
+            return CSMWorld::UniversalId::Type_Skill;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Class:
+            return CSMWorld::UniversalId::Type_Class;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Faction:
+            return CSMWorld::UniversalId::Type_Faction;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Sound:
+            return CSMWorld::UniversalId::Type_Sound;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Region:
+            return CSMWorld::UniversalId::Type_Region;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Birthsign:
+            return CSMWorld::UniversalId::Type_Birthsign;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Spell:
+            return CSMWorld::UniversalId::Type_Spell;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Cell:
+            return CSMWorld::UniversalId::Type_Cell;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Referenceable:
+            return CSMWorld::UniversalId::Type_Referenceable;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Activator:
+            return CSMWorld::UniversalId::Type_Activator;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Potion:
+            return CSMWorld::UniversalId::Type_Potion;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Apparatus:
+            return CSMWorld::UniversalId::Type_Apparatus;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Armor:
+            return CSMWorld::UniversalId::Type_Armor;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Book:
+            return CSMWorld::UniversalId::Type_Book;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Clothing:
+            return CSMWorld::UniversalId::Type_Clothing;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Container:
+            return CSMWorld::UniversalId::Type_Container;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Creature:
+            return CSMWorld::UniversalId::Type_Creature;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Door:
+            return CSMWorld::UniversalId::Type_Door;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Ingredient:
+            return CSMWorld::UniversalId::Type_Ingredient;
+            break;
+
+        case CSMWorld::ColumnBase::Display_CreatureLevelledList:
+            return CSMWorld::UniversalId::Type_CreatureLevelledList;
+            break;
+
+        case CSMWorld::ColumnBase::Display_ItemLevelledList:
+            return CSMWorld::UniversalId::Type_ItemLevelledList;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Light:
+            return CSMWorld::UniversalId::Type_Light;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Lockpick:
+            return CSMWorld::UniversalId::Type_Lockpick;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Miscellaneous:
+            return CSMWorld::UniversalId::Type_Miscellaneous;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Npc:
+            return CSMWorld::UniversalId::Type_Npc;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Probe:
+            return CSMWorld::UniversalId::Type_Probe;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Repair:
+            return CSMWorld::UniversalId::Type_Repair;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Static:
+            return CSMWorld::UniversalId::Type_Static;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Weapon:
+            return CSMWorld::UniversalId::Type_Weapon;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Reference:
+            return CSMWorld::UniversalId::Type_Reference;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Filter:
+            return CSMWorld::UniversalId::Type_Filter;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Topic:
+            return CSMWorld::UniversalId::Type_Topic;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Journal:
+            return CSMWorld::UniversalId::Type_Journal;
+            break;
+
+        case CSMWorld::ColumnBase::Display_TopicInfo:
+            return CSMWorld::UniversalId::Type_TopicInfo;
+            break;
+
+        case CSMWorld::ColumnBase::Display_JournalInfo:
+            return CSMWorld::UniversalId::Type_JournalInfo;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Scene:
+            return CSMWorld::UniversalId::Type_Scene;
+            break;
+
+        case CSMWorld::ColumnBase::Display_Script:
+            return CSMWorld::UniversalId::Type_Script;
+            break;
+
+        default:
+            return CSMWorld::UniversalId::Type_None;
+            break;
+    }
+}
+// kate: indent-mode cstyle; indent-width 4; replace-tabs on; 

apps/opencs/model/world/tablemimedata.hpp

@@ -0,0 +1,45 @@
+
+#ifndef TABLEMIMEDATA_H
+#define TABLEMIMEDATA_H
+
+#include <vector>
+
+#include <QtCore/QMimeData>
+#include <QStringList>
+
+#include "universalid.hpp"
+#include "columnbase.hpp"
+
+
+namespace CSMWorld
+{
+
+/// \brief Subclass of QmimeData, augmented to contain and transport UniversalIds.
+///
+/// This class provides way to construct mimedata object holding the universalid copy
+/// Universalid is used in the majority of the tables to store type, id, argument types.
+/// This way universalid grants a way to retrive record from the concrete table.
+/// Please note, that tablemimedata object can hold multiple universalIds in the vector.
+
+    class TableMimeData : public QMimeData
+    {
+        public:
+            TableMimeData(UniversalId id);
+            TableMimeData(std::vector<UniversalId>& id);
+            ~TableMimeData();
+            virtual QStringList formats() const;
+            std::string getIcon() const;
+            std::vector<UniversalId> getData() const;
+            bool holdsType(UniversalId::Type type) const;
+            bool holdsType(CSMWorld::ColumnBase::Display type) const;
+            UniversalId returnMatching(UniversalId::Type type) const;
+            UniversalId returnMatching(CSMWorld::ColumnBase::Display type) const;
+
+        private:
+            std::vector<UniversalId> mUniversalId;
+            QStringList mObjectsFormats;
+
+            CSMWorld::UniversalId::Type convertEnums(CSMWorld::ColumnBase::Display type) const;
+    };
+}
+#endif // TABLEMIMEDATA_H

apps/opencs/model/world/universalid.cpp

@@ -4,6 +4,7 @@
 #include <ostream>
 #include <stdexcept>
 #include <sstream>
+#include <iostream>
 
 namespace
 {
@@ -186,7 +187,6 @@ CSMWorld::UniversalId::UniversalId (Type type, const std::string& id)
             mClass = sIdArg[i].mClass;
             return;
         }
-
     throw std::logic_error ("invalid ID argument UniversalId type");
 }
 

apps/opencs/view/world/genericcreator.cpp

@@ -133,9 +133,9 @@ void CSVWorld::GenericCreator::create()
             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 {

apps/opencs/view/world/table.cpp

@@ -6,6 +6,8 @@
 #include <QAction>
 #include <QMenu>
 #include <QContextMenuEvent>
+#include <QString>
+#include <qt4/QtCore/qnamespace.h>
 
 #include "../../model/world/data.hpp"
 #include "../../model/world/commands.hpp"
@@ -13,6 +15,8 @@
 #include "../../model/world/idtable.hpp"
 #include "../../model/world/record.hpp"
 #include "../../model/world/columns.hpp"
+#include "../../model/world/tablemimedata.hpp"
+#include "../../model/world/tablemimedata.hpp"
 
 #include "recordstatusdelegate.hpp"
 #include "util.hpp"
@@ -88,7 +92,7 @@ std::vector<std::string> CSVWorld::Table::listRevertableSelectedIds() const
         QModelIndexList selectedRows = selectionModel()->selectedRows();
 
         for (QModelIndexList::const_iterator iter (selectedRows.begin()); iter!=selectedRows.end();
-             ++iter)
+            ++iter)
         {
             QModelIndex index = mProxyModel->mapToSource (mProxyModel->index (iter->row(), 0));
 
@@ -235,6 +239,8 @@ CSVWorld::Table::Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, Q
 
     connect (selectionModel(), SIGNAL (selectionChanged (const QItemSelection&, const QItemSelection&)),
         this, SLOT (selectionSizeUpdate ()));
+
+    setAcceptDrops(true);
 }
 
 void CSVWorld::Table::setEditLock (bool locked)
@@ -432,3 +438,71 @@ void CSVWorld::Table::recordFilterChanged (boost::shared_ptr<CSMFilter::Node> fi
 {
     mProxyModel->setFilter (filter);
 }
+
+void CSVWorld::Table::mouseMoveEvent (QMouseEvent* event)
+{
+    if (event->buttons() & Qt::LeftButton)
+    {
+        QModelIndexList selectedRows = selectionModel()->selectedRows();
+
+        if (selectedRows.size() == 0)
+        {
+            return;
+        }
+
+        QDrag* drag = new QDrag (this);
+        CSMWorld::TableMimeData* mime = NULL;
+
+        if (selectedRows.size() == 1)
+        {
+            mime = new CSMWorld::TableMimeData (getUniversalId (selectedRows.begin()->row()));
+        }
+        else
+        {
+            std::vector<CSMWorld::UniversalId> idToDrag;
+
+            foreach (QModelIndex it, selectedRows) //I had a dream. Dream where you could use C++11 in OpenMW.
+            {
+                idToDrag.push_back (getUniversalId (it.row()));
+            }
+
+            mime = new CSMWorld::TableMimeData (idToDrag);
+        }
+
+        drag->setMimeData (mime);
+        drag->setPixmap (QString::fromStdString (mime->getIcon()));
+        drag->exec();
+    }
+
+}
+
+void CSVWorld::Table::dragEnterEvent(QDragEnterEvent *event)
+{
+        event->acceptProposedAction();
+}
+
+void CSVWorld::Table::dropEvent(QDropEvent *event)
+{
+    QModelIndex index = indexAt (event->pos());
+
+    CSMWorld::ColumnBase::Display display = static_cast<CSMWorld::ColumnBase::Display>
+    (mModel->headerData(index.column(), Qt::Horizontal, CSMWorld::ColumnBase::Role_Display).toInt());
+
+    if (dynamic_cast<const CSMWorld::TableMimeData*>(event->mimeData())->holdsType(display))
+    {
+        const CSMWorld::TableMimeData* mime = dynamic_cast<const CSMWorld::TableMimeData*>
+                (event->mimeData());
+
+        CSMWorld::UniversalId record (mime->returnMatching (display));
+
+        std::auto_ptr<CSMWorld::ModifyCommand> command (new CSMWorld::ModifyCommand
+                (*mProxyModel, index, QVariant (QString::fromStdString (record.getId()))));
+
+        mUndoStack.push (command.release());
+    }
+}
+
+void CSVWorld::Table::dragMoveEvent(QDragMoveEvent *event)
+{
+        event->accept();
+}

apps/opencs/view/world/table.hpp

@@ -5,6 +5,7 @@
 #include <string>
 
 #include <QTableView>
+#include <QtGui/qevent.h>
 
 #include "../../model/filter/node.hpp"
 
@@ -50,6 +51,15 @@ namespace CSVWorld
 
             std::vector<std::string> listDeletableSelectedIds() const;
 
+            void mouseMoveEvent(QMouseEvent *event);
+
+            void dragEnterEvent(QDragEnterEvent *event);
+
+            void dropEvent(QDropEvent *event);
+
+            void dragMoveEvent(QDragMoveEvent *event);
+
+
         public:
 
             Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, QUndoStack& undoStack, bool createAndDelete, bool sorting);

files/opencs/resources.qrc

@@ -56,6 +56,7 @@
 	<file>spell.png</file>
 	<file>static.png</file>
 	<file>weapon.png</file>
+	<file>multitype.png</file>
         <file alias="startup/create-addon">raster/startup/big/create-addon.png</file>
         <file alias="startup/create-game">raster/startup/big/new-game.png</file>
         <file alias="startup/edit-content">raster/startup/big/edit-content.png</file>