Merge branch 'class'

apps/opencs/model/doc/document.cpp

@@ -207,7 +207,7 @@ void CSMDoc::Document::createBase()
     {
         ESM::Skill record;
         record.mIndex = i;
-        record.mId = ESM::Skill::getIndexToId (record.mIndex);
+        record.mId = ESM::Skill::indexToId (record.mIndex);
         record.blank();
 
         getData().getSkills().add (record);

apps/opencs/model/world/columnbase.hpp

@@ -33,7 +33,8 @@ namespace CSMWorld
             Display_GmstVarType,
             Display_GlobalVarType,
             Display_Specialisation,
-            Display_Attribute
+            Display_Attribute,
+            Display_Boolean
         };
 
         std::string mTitle;

apps/opencs/model/world/columns.hpp

@@ -1,6 +1,8 @@
 #ifndef CSM_WOLRD_COLUMNS_H
 #define CSM_WOLRD_COLUMNS_H
 
+#include <sstream>
+
 #include <boost/lexical_cast.hpp>
 
 #include "columnbase.hpp"
@@ -285,6 +287,128 @@ namespace CSMWorld
         }
     };
 
+    template<typename ESXRecordT>
+    struct NameColumn : public Column<ESXRecordT>
+    {
+        NameColumn() : Column<ESXRecordT> ("Name", ColumnBase::Display_String) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return QString::fromUtf8 (record.get().mName.c_str());
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mName = data.toString().toUtf8().constData();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct AttributesColumn : public Column<ESXRecordT>
+    {
+        int mIndex;
+
+        AttributesColumn (int index)
+        : Column<ESXRecordT> ("Attribute #" + boost::lexical_cast<std::string> (index),
+            ColumnBase::Display_Attribute), mIndex (index) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return record.get().mData.mAttribute[mIndex];
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mData.mAttribute[mIndex] = data.toInt();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct SkillsColumn : public Column<ESXRecordT>
+    {
+        int mIndex;
+        bool mMajor;
+
+        SkillsColumn (int index, bool major)
+        : Column<ESXRecordT> ((major ? "Major Skill #" : "Minor Skill #")+
+            boost::lexical_cast<std::string> (index), ColumnBase::Display_String),
+            mIndex (index), mMajor (major)
+        {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            int skill = record.get().mData.mSkills[mIndex][mMajor ? 1 : 0];
+
+            return QString::fromUtf8 (ESM::Skill::indexToId (skill).c_str());
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            std::istringstream stream (data.toString().toUtf8().constData());
+
+            int index = -1;
+            char c;
+
+            stream >> c >> index;
+
+            if (index!=-1)
+            {
+                ESXRecordT record2 = record.get();
+
+                record2.mData.mSkills[mIndex][mMajor ? 1 : 0] = index;
+
+                record.setModified (record2);
+            }
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct PlayableColumn : public Column<ESXRecordT>
+    {
+        PlayableColumn() : Column<ESXRecordT> ("Playable", ColumnBase::Display_Boolean) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return record.get().mData.mIsPlayable!=0;
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mData.mIsPlayable = data.toInt();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
 }
 
 #endif

apps/opencs/model/world/data.cpp

@@ -44,9 +44,23 @@ CSMWorld::Data::Data()
         mSkills.addColumn (new UseValueColumn<ESM::Skill> (i));
     mSkills.addColumn (new DescriptionColumn<ESM::Skill>);
 
+    mClasses.addColumn (new StringIdColumn<ESM::Class>);
+    mClasses.addColumn (new RecordStateColumn<ESM::Class>);
+    mClasses.addColumn (new NameColumn<ESM::Class>);
+    mClasses.addColumn (new AttributesColumn<ESM::Class> (0));
+    mClasses.addColumn (new AttributesColumn<ESM::Class> (1));
+    mClasses.addColumn (new SpecialisationColumn<ESM::Class>);
+    for (int i=0; i<5; ++i)
+        mClasses.addColumn (new SkillsColumn<ESM::Class> (i, true));
+    for (int i=0; i<5; ++i)
+        mClasses.addColumn (new SkillsColumn<ESM::Class> (i, false));
+    mClasses.addColumn (new PlayableColumn<ESM::Class>);
+    mClasses.addColumn (new DescriptionColumn<ESM::Class>);
+
     addModel (new IdTable (&mGlobals), UniversalId::Type_Globals, UniversalId::Type_Global);
     addModel (new IdTable (&mGmsts), UniversalId::Type_Gmsts, UniversalId::Type_Gmst);
     addModel (new IdTable (&mSkills), UniversalId::Type_Skills, UniversalId::Type_Skill);
+    addModel (new IdTable (&mClasses), UniversalId::Type_Classes, UniversalId::Type_Class);
 }
 
 CSMWorld::Data::~Data()
@@ -122,6 +136,7 @@ void CSMWorld::Data::loadFile (const boost::filesystem::path& path, bool base)
             case ESM::REC_GLOB: mGlobals.load (reader, base); break;
             case ESM::REC_GMST: mGmsts.load (reader, base); break;
             case ESM::REC_SKIL: mSkills.load (reader, base); break;
+            case ESM::REC_CLAS: mClasses.load (reader, base); break;
 
             default:
 

apps/opencs/model/world/data.hpp

@@ -9,6 +9,7 @@
 #include <components/esm/loadglob.hpp>
 #include <components/esm/loadgmst.hpp>
 #include <components/esm/loadskil.hpp>
+#include <components/esm/loadclas.hpp>
 
 #include "idcollection.hpp"
 #include "universalid.hpp"
@@ -22,6 +23,7 @@ namespace CSMWorld
             IdCollection<ESM::Global> mGlobals;
             IdCollection<ESM::GameSetting> mGmsts;
             IdCollection<ESM::Skill> mSkills;
+            IdCollection<ESM::Class> mClasses;
             std::vector<QAbstractItemModel *> mModels;
             std::map<UniversalId::Type, QAbstractItemModel *> mModelIndex;
 

apps/opencs/model/world/universalid.cpp

@@ -20,6 +20,7 @@ namespace
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Globals, "Global Variables" },
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Gmsts, "Game Settings" },
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Skills, "Skills" },
+        { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Classes, "Classes" },
 
         { CSMWorld::UniversalId::Class_None, CSMWorld::UniversalId::Type_None, 0 } // end marker
     };
@@ -29,6 +30,7 @@ namespace
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Global, "Global Variable" },
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Gmst, "Game Setting" },
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Skill, "Skill" },
+        { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Class, "Class" },
 
         { CSMWorld::UniversalId::Class_None, CSMWorld::UniversalId::Type_None, 0 } // end marker
     };

apps/opencs/model/world/universalid.hpp

@@ -39,7 +39,9 @@ namespace CSMWorld
                 Type_Gmsts,
                 Type_Gmst,
                 Type_Skills,
-                Type_Skill
+                Type_Skill,
+                Type_Classes,
+                Type_Class
             };
 
         private:

apps/opencs/view/doc/view.cpp

@@ -90,6 +90,10 @@ void CSVDoc::View::setupWorldMenu()
     connect (skills, SIGNAL (triggered()), this, SLOT (addSkillsSubView()));
     world->addAction (skills);
 
+    QAction *classes = new QAction (tr ("Classes"), this);
+    connect (classes, SIGNAL (triggered()), this, SLOT (addClassesSubView()));
+    world->addAction (classes);
+
     mVerify = new QAction (tr ("&Verify"), this);
     connect (mVerify, SIGNAL (triggered()), this, SLOT (verify()));
     world->addAction (mVerify);
@@ -253,6 +257,11 @@ void CSVDoc::View::addSkillsSubView()
     addSubView (CSMWorld::UniversalId::Type_Skills);
 }
 
+void CSVDoc::View::addClassesSubView()
+{
+    addSubView (CSMWorld::UniversalId::Type_Classes);
+}
+
 void CSVDoc::View::abortOperation (int type)
 {
     mDocument->abortOperation (type);

apps/opencs/view/doc/view.hpp

@@ -117,6 +117,8 @@ namespace CSVDoc
             void addGmstsSubView();
 
             void addSkillsSubView();
+
+            void addClassesSubView();
     };
 }
 

apps/opencs/view/world/subviews.cpp

@@ -17,6 +17,9 @@ void CSVWorld::addSubViewFactories (CSVDoc::SubViewFactoryManager& manager)
     manager.add (CSMWorld::UniversalId::Type_Skills,
         new CSVDoc::SubViewFactoryWithCreateFlag<TableSubView> (false));
 
-    manager.add (CSMWorld::UniversalId::Type_Global,
+    manager.add (CSMWorld::UniversalId::Type_Classes,
-        new CSVDoc::SubViewFactoryWithCreateFlag<DialogueSubView> (true));
+        new CSVDoc::SubViewFactoryWithCreateFlag<TableSubView> (true));
+
+//    manager.add (CSMWorld::UniversalId::Type_Global,
+//        new CSVDoc::SubViewFactoryWithCreateFlag<DialogueSubView> (true));
 }

components/esm/loadclas.cpp

@@ -35,4 +35,18 @@ void Class::save(ESMWriter &esm)
     esm.writeHNOString("DESC", mDescription);
 }
 
+    void Class::blank()
+    {
+        mName.clear();
+        mDescription.clear();
+
+        mData.mAttribute[0] = mData.mAttribute[1] = 0;
+        mData.mSpecialization = 0;
+        mData.mIsPlayable = 0;
+        mData.mCalc = 0;
+
+        for (int i=0; i<5; ++i)
+            for (int i2=0; i2<2; ++i2)
+                mData.mSkills[i][i2] = 0;
+    }
 }

components/esm/loadclas.hpp

@@ -65,6 +65,10 @@ struct Class
 
     void load(ESMReader &esm);
     void save(ESMWriter &esm);
+
+    void blank();
+     ///< Set record to default state (does not touch the ID/index).
+
 };
 }
 #endif

components/esm/loadskil.cpp

@@ -2,6 +2,8 @@
 
 #include <sstream>
 
+#include <components/misc/stringops.hpp>
+
 #include "esmreader.hpp"
 #include "esmwriter.hpp"
 
@@ -103,8 +105,9 @@ void Skill::load(ESMReader &esm)
 
     // create an ID from the index and the name (only used in the editor and likely to change in the
     // future)
-    mId = getIndexToId (mIndex);
+    mId = indexToId (mIndex);
 }
+
 void Skill::save(ESMWriter &esm)
 {
     esm.writeHNT("INDX", mIndex);
@@ -120,7 +123,7 @@ void Skill::save(ESMWriter &esm)
         mDescription.clear();
     }
 
-    std::string Skill::getIndexToId (int index)
+    std::string Skill::indexToId (int index)
     {
         std::ostringstream stream;
 

components/esm/loadskil.hpp

@@ -79,7 +79,7 @@ struct Skill
     void blank();
      ///< Set record to default state (does not touch the ID/index).
 
-    static std::string getIndexToId (int index);
+    static std::string indexToId (int index);
 };
 }
 #endif