[FIX] Validation works in Pokémodr

[FIX] Macros moved to their own file
[FIX] Macros for subclasses added
[FIX] Key shortcuts added to context menu items
[FIX] Rules had a redundant field

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

1 files changed, 91 insertions, 216 deletions

diff --git a/pokemod/Pokemod.cpp b/pokemod/Pokemod.cpp
index e670daf7..c5e2599c 100644
--- a/pokemod/Pokemod.cpp
+++ b/pokemod/Pokemod.cpp
@@ -27,6 +27,7 @@
 #include "GlobalScript.h"
 #include "Item.h"
 #include "ItemType.h"
+#include "Macros.h"
 #include "Map.h"
 #include "Move.h"
 #include "Nature.h"
@@ -86,6 +87,7 @@ Pokemod::Pokemod::~Pokemod()
 
 void Pokemod::Pokemod::validate()
 {
+    TEST_BEGIN();
     if (m_title.isEmpty())
         emit(error("Title is empty"));
     if (m_version.isEmpty())
@@ -94,301 +96,179 @@ void Pokemod::Pokemod::validate()
         emit(warning("Description is empty"));
     if (mapIndex(m_startMap) == INT_MAX)
         emit(error("Invalid starting map"));
-    else
-    {
-        if (mapById(m_startMap)->warpIndex(m_startWarp) == INT_MAX)
-            emit(error("Invalid starting warp"));
-    }
+    else if (mapById(m_startMap)->warpIndex(m_startWarp) == INT_MAX)
+        emit(error("Invalid starting warp"));
     if ((m_typechart.width() != typeCount()) || (m_typechart.height() != typeCount()))
         emit(error("Type chart is invalid"));
-    m_rules->validate();
+    TEST_CHILD(m_rules);
     QSet<int> idChecker;
     QSet<QString> nameChecker;
     QSet<int> timeChecker;
     if (abilityCount() < m_rules->maxAbilities())
         emit(error("There are too few abilities"));
-    foreach (Ability* ability, m_abilities)
-    {
-        ability->validate();
-        if (idChecker.contains(ability->id()))
-            emit(error(subclass("ability", ability->id())));
-        idChecker.insert(ability->id());
-        if (nameChecker.contains(ability->name()))
-            emit(error(subclass("ability", ability->name())));
-        nameChecker.insert(ability->name());
-    }
+    TEST_SUB_BEGIN(Ability, abilities);
+        TEST_SUB("ability", id);
+        TEST_SUB("ability", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!authorCount())
         emit(error("There are no authors"));
-    foreach (Author* author, m_authors)
-    {
-        author->validate();
-        if (idChecker.contains(author->id()))
-            emit(error(subclass("author", author->id())));
-        idChecker.insert(author->id());
-        if (nameChecker.contains(author->name()))
-            emit(error(subclass("author", author->name())));
-        nameChecker.insert(author->name());
-    }
+    TEST_SUB_BEGIN(Author, authors);
+        TEST_SUB("author", id);
+        TEST_SUB("author", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!badgeCount())
         emit(error("There are no badges"));
-    foreach (Badge* badge, m_badges)
-    {
-        badge->validate();
-        if (idChecker.contains(badge->id()))
-            emit(error(subclass("badge", badge->id())));
-        idChecker.insert(badge->id());
-        if (nameChecker.contains(badge->name()))
-            emit(error(subclass("badge", badge->name())));
-        nameChecker.insert(badge->name());
-    }
+    TEST_SUB_BEGIN(Badge, badges);
+        TEST_SUB("badge", id);
+        TEST_SUB("badge", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!coinListCount())
         emit(warning("There are no coin lists"));
-    foreach (CoinList* coinList, m_coinLists)
-    {
-        coinList->validate();
-        if (idChecker.contains(coinList->id()))
-            emit(error(subclass("coin list", coinList->id())));
-        idChecker.insert(coinList->id());
-        if (nameChecker.contains(coinList->name()))
-            emit(error(subclass("coin list", coinList->name())));
-        nameChecker.insert(coinList->name());
-    }
+    TEST_SUB_BEGIN(CoinList, coinLists);
+        TEST_SUB("coin list", id);
+        TEST_SUB("coin list", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (m_rules->breedingAllowed())
     {
         if (!eggGroupCount())
             emit(error("There are no egg groups"));
-        foreach (EggGroup* eggGroup, m_eggGroups)
-        {
-            eggGroup->validate();
-            if (idChecker.contains(eggGroup->id()))
-                emit(error(subclass("egg group", eggGroup->id())));
-            idChecker.insert(eggGroup->id());
-            if (nameChecker.contains(eggGroup->name()))
-                emit(error(subclass("egg group", eggGroup->name())));
-            nameChecker.insert(eggGroup->name());
-        }
+        TEST_SUB_BEGIN(EggGroup, eggGroups);
+            TEST_SUB("egg group", id);
+            TEST_SUB("egg group", name);
+        TEST_SUB_END();
         idChecker.clear();
         nameChecker.clear();
     }
     if (!globalScriptCount())
         emit(warning("There are no global scripts"));
-    foreach (GlobalScript* globalScript, m_globalScripts)
-    {
-        globalScript->validate();
-        if (idChecker.contains(globalScript->id()))
-            emit(error(subclass("global script", globalScript->id())));
-        idChecker.insert(globalScript->id());
-        if (nameChecker.contains(globalScript->name()))
-            emit(error(subclass("global script", globalScript->name())));
-        nameChecker.insert(globalScript->name());
-    }
+    TEST_SUB_BEGIN(GlobalScript, globalScripts);
+        TEST_SUB("global script", id);
+        TEST_SUB("global script", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!itemCount())
         emit(warning("There are no items"));
-    foreach (Item* item, m_items)
-    {
-        item->validate();
-        if (idChecker.contains(item->id()))
-            emit(error(subclass("item", item->id())));
-        idChecker.insert(item->id());
-        if (nameChecker.contains(item->name()))
-            emit(error(subclass("item", item->name())));
-        nameChecker.insert(item->name());
-    }
+    TEST_SUB_BEGIN(Item, items);
+        TEST_SUB("item", id);
+        TEST_SUB("item", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!itemTypeCount() && itemCount())
         emit(error("There are no item types"));
-    foreach (ItemType* itemType, m_itemTypes)
-    {
-        itemType->validate();
-        if (idChecker.contains(itemType->id()))
-            emit(error(subclass("item type", itemType->id())));
-        idChecker.insert(itemType->id());
-        if (nameChecker.contains(itemType->name()))
-            emit(error(subclass("item type", itemType->name())));
-        nameChecker.insert(itemType->name());
-    }
+    TEST_SUB_BEGIN(ItemType, itemTypes);
+        TEST_SUB("item type", id);
+        TEST_SUB("item type", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!mapCount())
         emit(error("There are no maps"));
-    foreach (Map* map, m_maps)
-    {
-        map->validate();
-        if (idChecker.contains(map->id()))
-            emit(error(subclass("map", map->id())));
-        idChecker.insert(map->id());
-        if (nameChecker.contains(map->name()))
-            emit(error(subclass("map", map->name())));
-        nameChecker.insert(map->name());
-    }
+    TEST_SUB_BEGIN(Map, maps);
+        TEST_SUB("map", id);
+        TEST_SUB("map", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!moveCount())
         emit(error("There are no moves"));
-    foreach (Move* move, m_moves)
-    {
-        move->validate();
-        if (idChecker.contains(move->id()))
-            emit(error(subclass("move", move->id())));
-        idChecker.insert(move->id());
-        if (nameChecker.contains(move->name()))
-            emit(error(subclass("move", move->name())));
-        nameChecker.insert(move->name());
-    }
+    TEST_SUB_BEGIN(Move, moves);
+        TEST_SUB("move", id);
+        TEST_SUB("move", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (natureCount() < m_rules->maxNatures())
         emit(error("There are too few natures"));
-    foreach (Nature* nature, m_natures)
-    {
-        nature->validate();
-        if (idChecker.contains(nature->id()))
-            emit(error(subclass("ability", nature->id())));
-        idChecker.insert(nature->id());
-        if (nameChecker.contains(nature->name()))
-            emit(error(subclass("nature", nature->name())));
-        nameChecker.insert(nature->name());
-    }
+    TEST_SUB_BEGIN(Nature, natures);
+        TEST_SUB("nature", id);
+        TEST_SUB("nature", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!soundCount())
-        emit(error("There are no sounds"));
-    foreach (Sound* sound, m_sounds)
-    {
-        sound->validate();
-        if (idChecker.contains(sound->id()))
-            emit(error(subclass("sound", sound->id())));
-        idChecker.insert(sound->id());
-        if (nameChecker.contains(sound->name()))
-            emit(error(subclass("sound", sound->name())));
-        nameChecker.insert(sound->name());
-    }
+        emit(warning("There are no sounds"));
+    TEST_SUB_BEGIN(Sound, sounds);
+        TEST_SUB("sound", id);
+        TEST_SUB("sound", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!speciesCount())
         emit(error("There are no species"));
-    foreach (Species* species, m_species)
-    {
-        species->validate();
-        if (idChecker.contains(species->id()))
-            emit(error(subclass("species", species->id())));
-        idChecker.insert(species->id());
-        if (nameChecker.contains(species->name()))
-            emit(error(subclass("species", species->name())));
-        nameChecker.insert(species->name());
-    }
+    TEST_SUB_BEGIN(Species, species);
+        TEST_SUB("species", id);
+        TEST_SUB("species", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!statusCount())
         emit(error("There are no status effects"));
-    foreach (Status* status, m_status)
-    {
-        status->validate();
-        if (idChecker.contains(status->id()))
-            emit(error(subclass("status effect", status->id())));
-        idChecker.insert(status->id());
-        if (nameChecker.contains(status->name()))
-            emit(error(subclass("status effect", status->name())));
-        nameChecker.insert(status->name());
-    }
+    TEST_SUB_BEGIN(Status, status);
+        TEST_SUB("status", id);
+        TEST_SUB("status", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!storeCount())
         emit(warning("There are no stores"));
-    foreach (Store* store, m_stores)
-    {
-        store->validate();
-        if (idChecker.contains(store->id()))
-            emit(error(subclass("store", store->id())));
-        idChecker.insert(store->id());
-        if (nameChecker.contains(store->name()))
-            emit(error(subclass("store", store->name())));
-        nameChecker.insert(store->name());
-    }
+    TEST_SUB_BEGIN(Store, stores);
+        TEST_SUB("store", id);
+        TEST_SUB("store", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!tileCount())
         emit(error("There are no tiles"));
-    foreach (Tile* tile, m_tiles)
-    {
-        tile->validate();
-        if (idChecker.contains(tile->id()))
-            emit(error(subclass("tile", tile->id())));
-        idChecker.insert(tile->id());
-        if (nameChecker.contains(tile->name()))
-            emit(error(subclass("tile", tile->name())));
-        nameChecker.insert(tile->name());
-    }
+    TEST_SUB_BEGIN(Tile, tiles);
+        TEST_SUB("tile", id);
+        TEST_SUB("tile", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!trainerCount())
         emit(warning("There are no trainers"));
-    foreach (Trainer* trainer, m_trainers)
-    {
-        trainer->validate();
-        if (idChecker.contains(trainer->id()))
-            emit(error(subclass("trainer", trainer->id())));
-        idChecker.insert(trainer->id());
-        if (nameChecker.contains(trainer->name()))
-            emit(error(subclass("trainer", trainer->name())));
-        nameChecker.insert(trainer->name());
-    }
+    TEST_SUB_BEGIN(Trainer, trainers);
+        TEST_SUB("trainer", id);
+        TEST_SUB("trainer", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!timeCount())
         emit(error("There are no times"));
-    foreach (Time* time, m_times)
-    {
-        time->validate();
-        if (idChecker.contains(time->id()))
-            emit(error(subclass("time", time->id())));
-        idChecker.insert(time->id());
-        if (nameChecker.contains(time->name()))
-            emit(error(subclass("time", time->name())));
-        nameChecker.insert(time->name());
-        if (timeChecker.contains((60 * time->hour()) + time->minute()))
-            emit(error(subclass("time", QString("%1:%2").arg(time->hour(), time->minute()))));
-        timeChecker.insert((60 * time->hour()) + time->minute());
-    }
+    TEST_SUB_BEGIN(Time, times);
+        TEST_SUB("time", id);
+        TEST_SUB("time", name);
+        if (timeChecker.contains((60 * object->hour()) + object->minute()))
+            emit(error(subclass("time", QString("%1:%2").arg(object->hour(), object->minute()))));
+        timeChecker.insert((60 * object->hour()) + object->minute());
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!typeCount())
         emit(error("There are no types"));
-    foreach (Type* type, m_types)
-    {
-        type->validate();
-        if (idChecker.contains(type->id()))
-            emit(error(subclass("type", type->id())));
-        idChecker.insert(type->id());
-        if (nameChecker.contains(type->name()))
-            emit(error(subclass("type", type->name())));
-        nameChecker.insert(type->name());
-    }
+    TEST_SUB_BEGIN(Type, types);
+        TEST_SUB("type", id);
+        TEST_SUB("type", name);
+    TEST_SUB_END();
     idChecker.clear();
     nameChecker.clear();
     if (!weatherCount())
-        emit(error("There are no weathers"));
-    foreach (Weather* weather, m_weathers)
-    {
-        weather->validate();
-        if (idChecker.contains(weather->id()))
-            emit(error(subclass("weather", weather->id())));
-        idChecker.insert(weather->id());
-        if (nameChecker.contains(weather->name()))
-            emit(error(subclass("weather", weather->name())));
-        nameChecker.insert(weather->name());
-    }
+        emit(warning("There are no weathers"));
+    TEST_SUB_BEGIN(Weather, weathers);
+        TEST_SUB("weather", id);
+        TEST_SUB("weather", name);
+    TEST_SUB_END();
+    TEST_END();
 }
 
 void Pokemod::Pokemod::load(const QDomElement& xml, const int)
@@ -470,11 +350,6 @@ QDomElement Pokemod::Pokemod::save() const
     return xml;
 }
 
-int Pokemod::Pokemod::maxCompatability(const Pokemod& pokemod) const
-{
-    // TODO: MaxCompatability between two versions
-}
-
 void Pokemod::Pokemod::setTitle(const QString& title)
 {
     CHECK(title);