[FIX] Organized some more model code

[ADD] Added AbilityGroupModel class

git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@116 6ecfd1a5-f3ed-3746-8530-beee90d26b22

1 files changed, 225 insertions, 175 deletions

diff --git a/pokemodr/models/PokemodModel.cpp b/pokemodr/models/PokemodModel.cpp
index febc4ae6..8fc799bc 100644
--- a/pokemodr/models/PokemodModel.cpp
+++ b/pokemodr/models/PokemodModel.cpp
@@ -20,6 +20,7 @@
 
 // Model includes
 #include "AbilityModel.h"
+// #include "AuthorModel.h"
 #include "BadgeModel.h"
 #include "CoinListModel.h"
 #include "DialogModel.h"
@@ -41,6 +42,7 @@
 
 // Pokemod includes
 #include "../../pokemod/Ability.h"
+#include "../../pokemod/Author.h"
 #include "../../pokemod/Badge.h"
 #include "../../pokemod/CoinList.h"
 #include "../../pokemod/Dialog.h"
@@ -59,23 +61,16 @@
 // Qt includes
 #include <QFile>
 
-AbilityGroupModel::AbilityGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Abilities")
+AbilityGroupModel::AbilityGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Abilities")
 {
-    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->abilityCount(); ++i)
-        m_objects.append(new AbilityModel(this, pokemod->ability(i)));
+    setupData();
 }
 
 AbilityGroupModel::~AbilityGroupModel()
 {
 }
 
-int AbilityGroupModel::rowCount() const
-{
-    return static_cast<Pokemod*>(m_object)->abilityCount();
-}
-
 int AbilityGroupModel::indexNumber() const
 {
     return 1;
@@ -99,28 +94,70 @@ bool AbilityGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-BadgeGroupModel::BadgeGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Badges")
+void AbilityGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->badgeCount(); ++i)
-        m_objects.append(new BadgeModel(this, pokemod->badge(i)));
+    for (int i = 0; i < pokemod->abilityCount(); ++i)
+        m_objects.append(new AbilityModel(this, pokemod->ability(i)));
 }
 
-BadgeGroupModel::~BadgeGroupModel()
+AuthorGroupModel::AuthorGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Abilities")
 {
+    setupData();
 }
 
-int BadgeGroupModel::rowCount() const
+AuthorGroupModel::~AuthorGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->badgeCount();
 }
 
-int BadgeGroupModel::indexNumber() const
+int AuthorGroupModel::indexNumber() const
 {
     return 2;
 }
 
+bool AuthorGroupModel::insertRows(const int rows)
+{
+    // TODO: AuthorModel
+//     for (int i = 0; i < rows; ++i)
+//         m_objects.append(new AuthorModel(this, static_cast<Pokemod*>(m_object)->newAuthor()));
+//     return true;
+}
+
+bool AuthorGroupModel::removeRows(const int position, const int rows)
+{
+    for (int i = 0; i < rows; ++i)
+    {
+        static_cast<Pokemod*>(m_object)->deleteAuthor(position);
+        delete m_objects[position];
+        m_objects.removeAt(position);
+    }
+    return true;
+}
+
+void AuthorGroupModel::setupData()
+{
+    // TODO: AuthorModel
+//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+//     for (int i = 0; i < pokemod->authorCount(); ++i)
+//         m_objects.append(new AuthorModel(this, pokemod->author(i)));
+}
+
+BadgeGroupModel::BadgeGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Badges")
+{
+    setupData();
+}
+
+BadgeGroupModel::~BadgeGroupModel()
+{
+}
+
+int BadgeGroupModel::indexNumber() const
+{
+    return 3;
+}
+
 bool BadgeGroupModel::insertRows(const int rows)
 {
     for (int i = 0; i < rows; ++i)
@@ -139,26 +176,26 @@ bool BadgeGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-CoinListGroupModel::CoinListGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Coin Lists")
+void BadgeGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->coinListCount(); ++i)
-        m_objects.append(new CoinListModel(this, pokemod->coinList(i)));
+    for (int i = 0; i < pokemod->badgeCount(); ++i)
+        m_objects.append(new BadgeModel(this, pokemod->badge(i)));
 }
 
-CoinListGroupModel::~CoinListGroupModel()
+CoinListGroupModel::CoinListGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Coin Lists")
 {
+    setupData();
 }
 
-int CoinListGroupModel::rowCount() const
+CoinListGroupModel::~CoinListGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->coinListCount();
 }
 
 int CoinListGroupModel::indexNumber() const
 {
-    return 3;
+    return 4;
 }
 
 bool CoinListGroupModel::insertRows(const int rows)
@@ -179,26 +216,26 @@ bool CoinListGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-DialogGroupModel::DialogGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Dialogs")
+void CoinListGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->dialogCount(); ++i)
-        m_objects.append(new DialogModel(this, pokemod->dialog(i)));
+    for (int i = 0; i < pokemod->coinListCount(); ++i)
+        m_objects.append(new CoinListModel(this, pokemod->coinList(i)));
 }
 
-DialogGroupModel::~DialogGroupModel()
+DialogGroupModel::DialogGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Dialogs")
 {
+    setupData();
 }
 
-int DialogGroupModel::rowCount() const
+DialogGroupModel::~DialogGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->dialogCount();
 }
 
 int DialogGroupModel::indexNumber() const
 {
-    return 4;
+    return 5;
 }
 
 bool DialogGroupModel::insertRows(const int rows)
@@ -219,26 +256,26 @@ bool DialogGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-EggGroupGroupModel::EggGroupGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Egg Groups")
+void DialogGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->eggGroupCount(); ++i)
-        m_objects.append(new EggGroupModel(this, pokemod->eggGroup(i)));
+    for (int i = 0; i < pokemod->dialogCount(); ++i)
+        m_objects.append(new DialogModel(this, pokemod->dialog(i)));
 }
 
-EggGroupGroupModel::~EggGroupGroupModel()
+EggGroupGroupModel::EggGroupGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Egg Groups")
 {
+    setupData();
 }
 
-int EggGroupGroupModel::rowCount() const
+EggGroupGroupModel::~EggGroupGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->eggGroupCount();
 }
 
 int EggGroupGroupModel::indexNumber() const
 {
-    return 5;
+    return 6;
 }
 
 bool EggGroupGroupModel::insertRows(const int rows)
@@ -259,27 +296,26 @@ bool EggGroupGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-ItemGroupModel::ItemGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Items")
+void EggGroupGroupModel::setupData()
 {
-    // TODO: ItemModel
-//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-//     for (int i = 0; i < pokemod->itemCount(); ++i)
-//         m_objects.append(new ItemModel(this, pokemod->item(i)));
+    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+    for (int i = 0; i < pokemod->eggGroupCount(); ++i)
+        m_objects.append(new EggGroupModel(this, pokemod->eggGroup(i)));
 }
 
-ItemGroupModel::~ItemGroupModel()
+ItemGroupModel::ItemGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Items")
 {
+    setupData();
 }
 
-int ItemGroupModel::rowCount() const
+ItemGroupModel::~ItemGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->itemCount();
 }
 
 int ItemGroupModel::indexNumber() const
 {
-    return 6;
+    return 7;
 }
 
 bool ItemGroupModel::insertRows(const int rows)
@@ -301,26 +337,27 @@ bool ItemGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-ItemTypeGroupModel::ItemTypeGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Item Types")
+void ItemGroupModel::setupData()
 {
-    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->itemTypeCount(); ++i)
-        m_objects.append(new ItemTypeModel(this, pokemod->itemType(i)));
+    // TODO: ItemModel
+//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+//     for (int i = 0; i < pokemod->itemCount(); ++i)
+//         m_objects.append(new ItemModel(this, pokemod->item(i)));
 }
 
-ItemTypeGroupModel::~ItemTypeGroupModel()
+ItemTypeGroupModel::ItemTypeGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Item Types")
 {
+    setupData();
 }
 
-int ItemTypeGroupModel::rowCount() const
+ItemTypeGroupModel::~ItemTypeGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->itemTypeCount();
 }
 
 int ItemTypeGroupModel::indexNumber() const
 {
-    return 7;
+    return 8;
 }
 
 bool ItemTypeGroupModel::insertRows(const int rows)
@@ -341,27 +378,26 @@ bool ItemTypeGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-MapGroupModel::MapGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Maps")
+void ItemTypeGroupModel::setupData()
 {
-    // TODO: MapModel
-//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-//     for (int i = 0; i < pokemod->mapCount(); ++i)
-//         m_objects.append(new MapModel(this, pokemod->map(i)));
+    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+    for (int i = 0; i < pokemod->itemTypeCount(); ++i)
+        m_objects.append(new ItemTypeModel(this, pokemod->itemType(i)));
 }
 
-MapGroupModel::~MapGroupModel()
+MapGroupModel::MapGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Maps")
 {
+    setupData();
 }
 
-int MapGroupModel::rowCount() const
+MapGroupModel::~MapGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->mapCount();
 }
 
 int MapGroupModel::indexNumber() const
 {
-    return 8;
+    return 9;
 }
 
 bool MapGroupModel::insertRows(const int rows)
@@ -383,27 +419,27 @@ bool MapGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-MoveGroupModel::MoveGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Moves")
+void MapGroupModel::setupData()
 {
-    // TODO: MoveModel
+    // TODO: MapModel
 //     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-//     for (int i = 0; i < pokemod->moveCount(); ++i)
-//         m_objects.append(new MoveModel(this, pokemod->move(i)));
+//     for (int i = 0; i < pokemod->mapCount(); ++i)
+//         m_objects.append(new MapModel(this, pokemod->map(i)));
 }
 
-MoveGroupModel::~MoveGroupModel()
+MoveGroupModel::MoveGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Moves")
 {
+    setupData();
 }
 
-int MoveGroupModel::rowCount() const
+MoveGroupModel::~MoveGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->moveCount();
 }
 
 int MoveGroupModel::indexNumber() const
 {
-    return 9;
+    return 10;
 }
 
 bool MoveGroupModel::insertRows(const int rows)
@@ -425,26 +461,27 @@ bool MoveGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-NatureGroupModel::NatureGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Natures")
+void MoveGroupModel::setupData()
 {
-    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->natureCount(); ++i)
-        m_objects.append(new NatureModel(this, pokemod->nature(i)));
+    // TODO: MoveModel
+//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+//     for (int i = 0; i < pokemod->moveCount(); ++i)
+//         m_objects.append(new MoveModel(this, pokemod->move(i)));
 }
 
-NatureGroupModel::~NatureGroupModel()
+NatureGroupModel::NatureGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Natures")
 {
+    setupData();
 }
 
-int NatureGroupModel::rowCount() const
+NatureGroupModel::~NatureGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->natureCount();
 }
 
 int NatureGroupModel::indexNumber() const
 {
-    return 10;
+    return 11;
 }
 
 bool NatureGroupModel::insertRows(const int rows)
@@ -465,27 +502,26 @@ bool NatureGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-SpeciesGroupModel::SpeciesGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Species")
+void NatureGroupModel::setupData()
 {
-    // TODO: SpeciesModel
-//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-//     for (int i = 0; i < pokemod->speciesCount(); ++i)
-//         m_objects.append(new SpeciesModel(this, pokemod->species(i)));
+    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+    for (int i = 0; i < pokemod->natureCount(); ++i)
+        m_objects.append(new NatureModel(this, pokemod->nature(i)));
 }
 
-SpeciesGroupModel::~SpeciesGroupModel()
+SpeciesGroupModel::SpeciesGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Species")
 {
+    setupData();
 }
 
-int SpeciesGroupModel::rowCount() const
+SpeciesGroupModel::~SpeciesGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->speciesCount();
 }
 
 int SpeciesGroupModel::indexNumber() const
 {
-    return 11;
+    return 12;
 }
 
 bool SpeciesGroupModel::insertRows(const int rows)
@@ -507,26 +543,27 @@ bool SpeciesGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-StoreGroupModel::StoreGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Stores")
+void SpeciesGroupModel::setupData()
 {
-    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->storeCount(); ++i)
-        m_objects.append(new StoreModel(this, pokemod->store(i)));
+    // TODO: SpeciesModel
+//     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+//     for (int i = 0; i < pokemod->speciesCount(); ++i)
+//         m_objects.append(new SpeciesModel(this, pokemod->species(i)));
 }
 
-StoreGroupModel::~StoreGroupModel()
+StoreGroupModel::StoreGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Stores")
 {
+    setupData();
 }
 
-int StoreGroupModel::rowCount() const
+StoreGroupModel::~StoreGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->storeCount();
 }
 
 int StoreGroupModel::indexNumber() const
 {
-    return 12;
+    return 13;
 }
 
 bool StoreGroupModel::insertRows(const int rows)
@@ -547,26 +584,26 @@ bool StoreGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-TileGroupModel::TileGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Tiles")
+void StoreGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->tileCount(); ++i)
-        m_objects.append(new TileModel(this, pokemod->tile(i)));
+    for (int i = 0; i < pokemod->storeCount(); ++i)
+        m_objects.append(new StoreModel(this, pokemod->store(i)));
 }
 
-TileGroupModel::~TileGroupModel()
+TileGroupModel::TileGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Tiles")
 {
+    setupData();
 }
 
-int TileGroupModel::rowCount() const
+TileGroupModel::~TileGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->tileCount();
 }
 
 int TileGroupModel::indexNumber() const
 {
-    return 13;
+    return 14;
 }
 
 bool TileGroupModel::insertRows(const int rows)
@@ -587,26 +624,26 @@ bool TileGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-TimeGroupModel::TimeGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Times")
+void TileGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->timeCount(); ++i)
-        m_objects.append(new TimeModel(this, pokemod->time(i)));
+    for (int i = 0; i < pokemod->tileCount(); ++i)
+        m_objects.append(new TileModel(this, pokemod->tile(i)));
 }
 
-TimeGroupModel::~TimeGroupModel()
+TimeGroupModel::TimeGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Times")
 {
+    setupData();
 }
 
-int TimeGroupModel::rowCount() const
+TimeGroupModel::~TimeGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->timeCount();
 }
 
 int TimeGroupModel::indexNumber() const
 {
-    return 14;
+    return 15;
 }
 
 bool TimeGroupModel::insertRows(const int rows)
@@ -627,26 +664,27 @@ bool TimeGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-TrainerGroupModel::TrainerGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Trainers")
+void TimeGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->trainerCount(); ++i)
-        m_objects.append(new TrainerModel(this, pokemod->trainer(i)));
+    for (int i = 0; i < pokemod->timeCount(); ++i)
+        m_objects.append(new TimeModel(this, pokemod->time(i)));
 }
 
-TrainerGroupModel::~TrainerGroupModel()
+TrainerGroupModel::TrainerGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Trainers")
 {
+    setupData();
 }
 
-int TrainerGroupModel::rowCount() const
+TrainerGroupModel::~TrainerGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->trainerCount();
+    setupData();
 }
 
 int TrainerGroupModel::indexNumber() const
 {
-    return 15;
+    return 16;
 }
 
 bool TrainerGroupModel::insertRows(const int rows)
@@ -667,26 +705,26 @@ bool TrainerGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-TypeGroupModel::TypeGroupModel(BaseModel* parent, Object* object) :
-        GroupModel(parent, object, "Types")
+void TrainerGroupModel::setupData()
 {
     Pokemod* pokemod = static_cast<Pokemod*>(m_object);
-    for (int i = 0; i < pokemod->typeCount(); ++i)
-        m_objects.append(new TypeModel(this, pokemod->type(i)));
+    for (int i = 0; i < pokemod->trainerCount(); ++i)
+        m_objects.append(new TrainerModel(this, pokemod->trainer(i)));
 }
 
-TypeGroupModel::~TypeGroupModel()
+TypeGroupModel::TypeGroupModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupModel(parent, pokemod, "Types")
 {
+    setupData();
 }
 
-int TypeGroupModel::rowCount() const
+TypeGroupModel::~TypeGroupModel()
 {
-    return static_cast<Pokemod*>(m_object)->typeCount();
 }
 
 int TypeGroupModel::indexNumber() const
 {
-    return 16;
+    return 17;
 }
 
 bool TypeGroupModel::insertRows(const int rows)
@@ -707,8 +745,15 @@ bool TypeGroupModel::removeRows(const int position, const int rows)
     return true;
 }
 
-PokemodModel::PokemodModel(BaseModel* parent, Object* object) :
-        GroupObjectModel(parent, object)
+void TypeGroupModel::setupData()
+{
+    Pokemod* pokemod = static_cast<Pokemod*>(m_object);
+    for (int i = 0; i < pokemod->typeCount(); ++i)
+        m_objects.append(new TypeModel(this, pokemod->type(i)));
+}
+
+PokemodModel::PokemodModel(BaseModel* parent, Pokemod* pokemod) :
+        GroupObjectModel(parent, pokemod)
 {
     setupData();
 }
@@ -738,7 +783,7 @@ QVariant PokemodModel::data(int role) const
 
 int PokemodModel::rowCount() const
 {
-    return 17;
+    return 18;
 }
 
 bool PokemodModel::setData(const QVariant& value, int role)
@@ -771,54 +816,57 @@ BaseModel* PokemodModel::childItem(const int row)
     switch (row)
     {
         case 0:
-            model = m_abilities;
+            model = m_rules;
             break;
         case 1:
-            model = m_badges;
+            model = m_abilities;
             break;
         case 2:
-            model = m_coinLists;
+            model = m_authors;
             break;
         case 3:
-            model = m_dialogs;
+            model = m_badges;
             break;
         case 4:
-            model = m_eggGroups;
+            model = m_coinLists;
             break;
         case 5:
-            model = m_items;
+            model = m_dialogs;
             break;
         case 6:
-            model = m_itemTypes;
+            model = m_eggGroups;
             break;
         case 7:
-            model = m_maps;
+            model = m_items;
             break;
         case 8:
-            model = m_moves;
+            model = m_itemTypes;
             break;
         case 9:
-            model = m_natures;
+            model = m_maps;
             break;
         case 10:
-            model = m_rules;
+            model = m_moves;
             break;
         case 11:
-            model = m_species;
+            model = m_natures;
             break;
         case 12:
-            model = m_stores;
+            model = m_species;
             break;
         case 13:
+            model = m_stores;
+            break;
+        case 15:
             model = m_tiles;
             break;
-        case 14:
+        case 16:
             model = m_times;
             break;
-        case 15:
+        case 17:
             model = m_trainers;
             break;
-        case 16:
+        case 18:
             model = m_types;
             break;
         default:
@@ -846,28 +894,30 @@ bool PokemodModel::removeRows(const int position, const int rows)
 void PokemodModel::setupData()
 {
     m_rules = new RulesModel(this, static_cast<Pokemod*>(m_object)->rules());
-    m_abilities = new AbilityGroupModel(this, m_object);
-    m_badges = new BadgeGroupModel(this, m_object);
-    m_coinLists = new CoinListGroupModel(this, m_object);
-    m_dialogs = new DialogGroupModel(this, m_object);
-    m_eggGroups = new EggGroupGroupModel(this, m_object);
-    m_items = new ItemGroupModel(this, m_object);
-    m_itemTypes = new ItemTypeGroupModel(this, m_object);
-    m_maps = new MapGroupModel(this, m_object);
-    m_moves = new MoveGroupModel(this, m_object);
-    m_natures = new NatureGroupModel(this, m_object);
-    m_species = new SpeciesGroupModel(this, m_object);
-    m_stores = new StoreGroupModel(this, m_object);
-    m_tiles = new TileGroupModel(this, m_object);
-    m_times = new TimeGroupModel(this, m_object);
-    m_trainers = new TrainerGroupModel(this, m_object);
-    m_types = new TypeGroupModel(this, m_object);
+    m_abilities = new AbilityGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_authors = new AuthorGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_badges = new BadgeGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_coinLists = new CoinListGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_dialogs = new DialogGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_eggGroups = new EggGroupGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_items = new ItemGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_itemTypes = new ItemTypeGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_maps = new MapGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_moves = new MoveGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_natures = new NatureGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_species = new SpeciesGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_stores = new StoreGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_tiles = new TileGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_times = new TimeGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_trainers = new TrainerGroupModel(this, static_cast<Pokemod*>(m_object));
+    m_types = new TypeGroupModel(this, static_cast<Pokemod*>(m_object));
 }
 
 void PokemodModel::clearData()
 {
     delete m_rules;
     delete m_abilities;
+    delete m_authors;
     delete m_badges;
     delete m_coinLists;
     delete m_dialogs;