[FIX] All modules now use their own namespace

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

1 files changed, 315 insertions, 319 deletions

diff --git a/pokemod/Pokemod.cpp b/pokemod/Pokemod.cpp
index 2d5b4d77..e670daf7 100644
--- a/pokemod/Pokemod.cpp
+++ b/pokemod/Pokemod.cpp
@@ -46,11 +46,7 @@
 #include <QBuffer>
 #include <QSet>
 
-const QStringList Pokemod::StatRBYStr = QStringList() << "HP" << "Attack" << "Defense" << "Speed" << "Special" << "Special" << "Accuracy" << "Evasion";
-const QStringList Pokemod::StatGSCStr = QStringList() << "HP" << "Attack" << "Defense" << "Speed" << "Special Attack" << "Special Defense" << "Accuracy" << "Evasion";
-const QStringList Pokemod::DirectionStr = QStringList() << "Up" << "Down" << "Left" << "Right" << "None";
-
-Pokemod::Pokemod() :
+Pokemod::Pokemod::Pokemod() :
         Object("Pokemod", NULL, 0),
         m_title(""),
         m_version(""),
@@ -68,27 +64,27 @@ Pokemod::Pokemod() :
 {
 }
 
-Pokemod::Pokemod(const Pokemod& pokemod) :
+Pokemod::Pokemod::Pokemod(const Pokemod& pokemod) :
         Object("Pokemod", NULL, 0),
         m_rules(new Rules(this))
 {
     *this = pokemod;
 }
 
-Pokemod::Pokemod(const QDomElement& xml) :
+Pokemod::Pokemod::Pokemod(const QDomElement& xml) :
         Object("Pokemod", NULL, 0),
         m_rules(new Rules(this))
 {
     load(xml);
 }
 
-Pokemod::~Pokemod()
+Pokemod::Pokemod::~Pokemod()
 {
     delete m_rules;
     clear();
 }
 
-void Pokemod::validate()
+void Pokemod::Pokemod::validate()
 {
     if (m_title.isEmpty())
         emit(error("Title is empty"));
@@ -395,7 +391,7 @@ void Pokemod::validate()
     }
 }
 
-void Pokemod::load(const QDomElement& xml, const int)
+void Pokemod::Pokemod::load(const QDomElement& xml, const int)
 {
     clear();
     LOAD(QString, title);
@@ -434,7 +430,7 @@ void Pokemod::load(const QDomElement& xml, const int)
     LOAD_Typechart(setTypechart, Fraction, typechart);
 }
 
-QDomElement Pokemod::save() const
+QDomElement Pokemod::Pokemod::save() const
 {
     QDomElement xml = QDomDocument().createElement(className());
     SAVE(QString, title);
@@ -474,27 +470,27 @@ QDomElement Pokemod::save() const
     return xml;
 }
 
-int Pokemod::maxCompatability(const Pokemod& pokemod) const
+int Pokemod::Pokemod::maxCompatability(const Pokemod& pokemod) const
 {
     // TODO: MaxCompatability between two versions
 }
 
-void Pokemod::setTitle(const QString& title)
+void Pokemod::Pokemod::setTitle(const QString& title)
 {
     CHECK(title);
 }
 
-void Pokemod::setVersion(const QString& version)
+void Pokemod::Pokemod::setVersion(const QString& version)
 {
     CHECK(version);
 }
 
-void Pokemod::setDescription(const QString& description)
+void Pokemod::Pokemod::setDescription(const QString& description)
 {
     CHECK(description);
 }
 
-void Pokemod::setStartMap(const int startMap)
+void Pokemod::Pokemod::setStartMap(const int startMap)
 {
     if (mapIndex(startMap) == INT_MAX)
     {
@@ -504,7 +500,7 @@ void Pokemod::setStartMap(const int startMap)
     CHECK(startMap);
 }
 
-void Pokemod::setStartWarp(const int startWarp)
+void Pokemod::Pokemod::setStartWarp(const int startWarp)
 {
     if (mapIndex(m_startMap) == INT_MAX)
     {
@@ -519,7 +515,7 @@ void Pokemod::setStartWarp(const int startWarp)
     CHECK(startWarp);
 }
 
-void Pokemod::setWalkSkin(const QPixmap& walkSkin)
+void Pokemod::Pokemod::setWalkSkin(const QPixmap& walkSkin)
 {
     if (walkSkin.size() != QSize(192, 128))
     {
@@ -530,7 +526,7 @@ void Pokemod::setWalkSkin(const QPixmap& walkSkin)
     emit(changed());
 }
 
-void Pokemod::setBikeSkin(const QPixmap& bikeSkin)
+void Pokemod::Pokemod::setBikeSkin(const QPixmap& bikeSkin)
 {
     if (bikeSkin.size() != QSize(192, 128))
     {
@@ -541,7 +537,7 @@ void Pokemod::setBikeSkin(const QPixmap& bikeSkin)
     emit(changed());
 }
 
-void Pokemod::setSurfSkin(const QPixmap& surfSkin)
+void Pokemod::Pokemod::setSurfSkin(const QPixmap& surfSkin)
 {
     if (surfSkin.size() != QSize(192, 128))
     {
@@ -552,7 +548,7 @@ void Pokemod::setSurfSkin(const QPixmap& surfSkin)
     emit(changed());
 }
 
-void Pokemod::setFlySkin(const QPixmap& flySkin)
+void Pokemod::Pokemod::setFlySkin(const QPixmap& flySkin)
 {
     if (flySkin.size() != QSize(192, 128))
     {
@@ -563,7 +559,7 @@ void Pokemod::setFlySkin(const QPixmap& flySkin)
     emit(changed());
 }
 
-void Pokemod::setFishSkin(const QPixmap& fishSkin)
+void Pokemod::Pokemod::setFishSkin(const QPixmap& fishSkin)
 {
     if (fishSkin.size() != QSize(192, 128))
     {
@@ -574,7 +570,7 @@ void Pokemod::setFishSkin(const QPixmap& fishSkin)
     emit(changed());
 }
 
-void Pokemod::setSurfFishSkin(const QPixmap& surfFishSkin)
+void Pokemod::Pokemod::setSurfFishSkin(const QPixmap& surfFishSkin)
 {
     if (surfFishSkin.size() != QSize(192, 128))
     {
@@ -585,124 +581,124 @@ void Pokemod::setSurfFishSkin(const QPixmap& surfFishSkin)
     emit(changed());
 }
 
-void Pokemod::setTypechart(const int attack, const int defense, const Fraction& multiplier)
+void Pokemod::Pokemod::setTypechart(const int attack, const int defense, const Fraction& multiplier)
 {
     CHECK_ARRAY(typechart(attack, defense), multiplier);
 }
 
-void Pokemod::setRules(const Rules& rules)
+void Pokemod::Pokemod::setRules(const Rules& rules)
 {
     *m_rules = rules;
 }
 
-void Pokemod::setRules(const QDomElement& xml)
+void Pokemod::Pokemod::setRules(const QDomElement& xml)
 {
     m_rules->load(xml);
 }
 
-QString Pokemod::title() const
+QString Pokemod::Pokemod::title() const
 {
     return m_title;
 }
 
-QString Pokemod::version() const
+QString Pokemod::Pokemod::version() const
 {
     return m_version;
 }
 
-QString Pokemod::description() const
+QString Pokemod::Pokemod::description() const
 {
     return m_description;
 }
 
-int Pokemod::startMap() const
+int Pokemod::Pokemod::startMap() const
 {
     return m_startMap;
 }
 
-int Pokemod::startWarp() const
+int Pokemod::Pokemod::startWarp() const
 {
     return m_startWarp;
 }
 
-QPixmap Pokemod::walkSkin() const
+QPixmap Pokemod::Pokemod::walkSkin() const
 {
     return m_walkSkin;
 }
 
-QPixmap Pokemod::bikeSkin() const
+QPixmap Pokemod::Pokemod::bikeSkin() const
 {
     return m_bikeSkin;
 }
 
-QPixmap Pokemod::surfSkin() const
+QPixmap Pokemod::Pokemod::surfSkin() const
 {
     return m_surfSkin;
 }
 
-QPixmap Pokemod::flySkin() const
+QPixmap Pokemod::Pokemod::flySkin() const
 {
     return m_flySkin;
 }
 
-QPixmap Pokemod::fishSkin() const
+QPixmap Pokemod::Pokemod::fishSkin() const
 {
     return m_fishSkin;
 }
 
-QPixmap Pokemod::surfFishSkin() const
+QPixmap Pokemod::Pokemod::surfFishSkin() const
 {
     return m_surfFishSkin;
 }
 
-const Matrix<Fraction>& Pokemod::typechart() const
+const Pokemod::Matrix<Pokemod::Fraction>* Pokemod::Pokemod::typechart() const
 {
-    return m_typechart;
+    return &m_typechart;
 }
 
-Matrix<Fraction>& Pokemod::typechart()
+Pokemod::Matrix<Pokemod::Fraction>* Pokemod::Pokemod::typechart()
 {
-    return m_typechart;
+    return &m_typechart;
 }
 
-Fraction Pokemod::typechart(const int attack, const int defense) const
+Pokemod::Fraction Pokemod::Pokemod::typechart(const int attack, const int defense) const
 {
     return m_typechart(attack, defense);
 }
 
-const Rules* Pokemod::rules() const
+const Pokemod::Rules* Pokemod::Pokemod::rules() const
 {
     return m_rules;
 }
 
-Rules* Pokemod::rules()
+Pokemod::Rules* Pokemod::Pokemod::rules()
 {
     return m_rules;
 }
 
-const Ability* Pokemod::ability(const int index) const
+const Pokemod::Ability* Pokemod::Pokemod::ability(const int index) const
 {
     Q_ASSERT(index < abilityCount());
     return m_abilities.at(index);
 }
 
-Ability* Pokemod::ability(const int index)
+Pokemod::Ability* Pokemod::Pokemod::ability(const int index)
 {
     Q_ASSERT(index < abilityCount());
     return m_abilities[index];
 }
 
-const Ability* Pokemod::abilityById(const int id) const
+const Pokemod::Ability* Pokemod::Pokemod::abilityById(const int id) const
 {
     return ability(abilityIndex(id));
 }
 
-Ability* Pokemod::abilityById(const int id)
+Pokemod::Ability* Pokemod::Pokemod::abilityById(const int id)
 {
     return ability(abilityIndex(id));
 }
 
-int Pokemod::abilityIndex(const int id) const
+int Pokemod::Pokemod::abilityIndex(const int id) const
 {
     for (int i = 0; i < abilityCount(); ++i)
     {
@@ -712,45 +708,45 @@ int Pokemod::abilityIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::abilityCount() const
+int Pokemod::Pokemod::abilityCount() const
 {
     return m_abilities.size();
 }
 
-Ability* Pokemod::newAbility()
+Pokemod::Ability* Pokemod::Pokemod::newAbility()
 {
     return newAbility(new Ability(this, newAbilityId()));
 }
 
-Ability* Pokemod::newAbility(const QDomElement& xml)
+Pokemod::Ability* Pokemod::Pokemod::newAbility(const QDomElement& xml)
 {
     return newAbility(new Ability(xml, this, newAbilityId()));
 }
 
-Ability* Pokemod::newAbility(const Ability& ability)
+Pokemod::Ability* Pokemod::Pokemod::newAbility(const Ability& ability)
 {
     return newAbility(new Ability(ability, this, newAbilityId()));
 }
 
-Ability* Pokemod::newAbility(Ability* ability)
+Pokemod::Ability* Pokemod::Pokemod::newAbility(Ability* ability)
 {
     m_abilities.append(ability);
     return ability;
 }
 
-void Pokemod::deleteAbility(const int index)
+void Pokemod::Pokemod::deleteAbility(const int index)
 {
     Q_ASSERT(index < abilityCount());
     delete m_abilities[index];
     m_abilities.removeAt(index);
 }
 
-void Pokemod::deleteAbilityById(const int id)
+void Pokemod::Pokemod::deleteAbilityById(const int id)
 {
     deleteAbility(abilityIndex(id));
 }
 
-int Pokemod::newAbilityId() const
+int Pokemod::Pokemod::newAbilityId() const
 {
     int i = 0;
     while ((i < abilityCount()) && (abilityIndex(i) != INT_MAX))
@@ -758,29 +754,29 @@ int Pokemod::newAbilityId() const
     return i;
 }
 
-const Author* Pokemod::author(const int index) const
+const Pokemod::Author* Pokemod::Pokemod::author(const int index) const
 {
     Q_ASSERT(index < authorCount());
     return m_authors.at(index);
 }
 
-Author* Pokemod::author(const int index)
+Pokemod::Author* Pokemod::Pokemod::author(const int index)
 {
     Q_ASSERT(index < authorCount());
     return m_authors[index];
 }
 
-const Author* Pokemod::authorById(const int id) const
+const Pokemod::Author* Pokemod::Pokemod::authorById(const int id) const
 {
     return author(authorIndex(id));
 }
 
-Author* Pokemod::authorById(const int id)
+Pokemod::Author* Pokemod::Pokemod::authorById(const int id)
 {
     return author(authorIndex(id));
 }
 
-int Pokemod::authorIndex(const int id) const
+int Pokemod::Pokemod::authorIndex(const int id) const
 {
     for (int i = 0; i < authorCount(); ++i)
     {
@@ -790,45 +786,45 @@ int Pokemod::authorIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::authorCount() const
+int Pokemod::Pokemod::authorCount() const
 {
     return m_authors.size();
 }
 
-Author* Pokemod::newAuthor()
+Pokemod::Author* Pokemod::Pokemod::newAuthor()
 {
     return newAuthor(new Author(this, newAuthorId()));
 }
 
-Author* Pokemod::newAuthor(const QDomElement& xml)
+Pokemod::Author* Pokemod::Pokemod::newAuthor(const QDomElement& xml)
 {
     return newAuthor(new Author(xml, this, newAuthorId()));
 }
 
-Author* Pokemod::newAuthor(const Author& author)
+Pokemod::Author* Pokemod::Pokemod::newAuthor(const Author& author)
 {
     return newAuthor(new Author(author, this, newAuthorId()));
 }
 
-Author* Pokemod::newAuthor(Author* author)
+Pokemod::Author* Pokemod::Pokemod::newAuthor(Author* author)
 {
     m_authors.append(author);
     return author;
 }
 
-void Pokemod::deleteAuthor(const int index)
+void Pokemod::Pokemod::deleteAuthor(const int index)
 {
     Q_ASSERT(index < authorCount());
     delete m_authors[index];
     m_authors.removeAt(index);
 }
 
-void Pokemod::deleteAuthorById(const int id)
+void Pokemod::Pokemod::deleteAuthorById(const int id)
 {
     deleteAuthor(authorIndex(id));
 }
 
-int Pokemod::newAuthorId() const
+int Pokemod::Pokemod::newAuthorId() const
 {
     int i = 0;
     while ((i < authorCount()) && (authorIndex(i) != INT_MAX))
@@ -836,29 +832,29 @@ int Pokemod::newAuthorId() const
     return i;
 }
 
-const Badge* Pokemod::badge(const int index) const
+const Pokemod::Badge* Pokemod::Pokemod::badge(const int index) const
 {
     Q_ASSERT(index < badgeCount());
     return m_badges.at(index);
 }
 
-Badge* Pokemod::badge(const int index)
+Pokemod::Badge* Pokemod::Pokemod::badge(const int index)
 {
     Q_ASSERT(index < badgeCount());
     return m_badges[index];
 }
 
-const Badge* Pokemod::badgeById(const int id) const
+const Pokemod::Badge* Pokemod::Pokemod::badgeById(const int id) const
 {
     return badge(badgeIndex(id));
 }
 
-Badge* Pokemod::badgeById(const int id)
+Pokemod::Badge* Pokemod::Pokemod::badgeById(const int id)
 {
     return badge(badgeIndex(id));
 }
 
-int Pokemod::badgeIndex(const int id) const
+int Pokemod::Pokemod::badgeIndex(const int id) const
 {
     for (int i = 0; i < badgeCount(); ++i)
     {
@@ -868,45 +864,45 @@ int Pokemod::badgeIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::badgeCount() const
+int Pokemod::Pokemod::badgeCount() const
 {
     return m_badges.size();
 }
 
-Badge* Pokemod::newBadge()
+Pokemod::Badge* Pokemod::Pokemod::newBadge()
 {
     return newBadge(new Badge(this, newBadgeId()));
 }
 
-Badge* Pokemod::newBadge(const QDomElement& xml)
+Pokemod::Badge* Pokemod::Pokemod::newBadge(const QDomElement& xml)
 {
     return newBadge(new Badge(xml, this, newBadgeId()));
 }
 
-Badge* Pokemod::newBadge(const Badge& badge)
+Pokemod::Badge* Pokemod::Pokemod::newBadge(const Badge& badge)
 {
     return newBadge(new Badge(badge, this, newBadgeId()));
 }
 
-Badge* Pokemod::newBadge(Badge* badge)
+Pokemod::Badge* Pokemod::Pokemod::newBadge(Badge* badge)
 {
     m_badges.append(badge);
     return badge;
 }
 
-void Pokemod::deleteBadge(const int index)
+void Pokemod::Pokemod::deleteBadge(const int index)
 {
     Q_ASSERT(index < badgeCount());
     delete m_badges[index];
     m_badges.removeAt(index);
 }
 
-void Pokemod::deleteBadgeById(const int id)
+void Pokemod::Pokemod::deleteBadgeById(const int id)
 {
     deleteBadge(badgeIndex(id));
 }
 
-int Pokemod::newBadgeId() const
+int Pokemod::Pokemod::newBadgeId() const
 {
     int i = 0;
     while ((i < badgeCount()) && (badgeIndex(i) != INT_MAX))
@@ -914,29 +910,29 @@ int Pokemod::newBadgeId() const
     return i;
 }
 
-const CoinList* Pokemod::coinList(const int index) const
+const Pokemod::CoinList* Pokemod::Pokemod::coinList(const int index) const
 {
     Q_ASSERT(index < coinListCount());
     return m_coinLists.at(index);
 }
 
-CoinList* Pokemod::coinList(const int index)
+Pokemod::CoinList* Pokemod::Pokemod::coinList(const int index)
 {
     Q_ASSERT(index < coinListCount());
     return m_coinLists[index];
 }
 
-const CoinList* Pokemod::coinListById(const int id) const
+const Pokemod::CoinList* Pokemod::Pokemod::coinListById(const int id) const
 {
     return coinList(coinListIndex(id));
 }
 
-CoinList* Pokemod::coinListById(const int id)
+Pokemod::CoinList* Pokemod::Pokemod::coinListById(const int id)
 {
     return coinList(coinListIndex(id));
 }
 
-int Pokemod::coinListIndex(const int id) const
+int Pokemod::Pokemod::coinListIndex(const int id) const
 {
     for (int i = 0; i < coinListCount(); ++i)
     {
@@ -946,45 +942,45 @@ int Pokemod::coinListIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::coinListCount() const
+int Pokemod::Pokemod::coinListCount() const
 {
     return m_coinLists.size();
 }
 
-CoinList* Pokemod::newCoinList()
+Pokemod::CoinList* Pokemod::Pokemod::newCoinList()
 {
     return newCoinList(new CoinList(this, newCoinListId()));
 }
 
-CoinList* Pokemod::newCoinList(const QDomElement& xml)
+Pokemod::CoinList* Pokemod::Pokemod::newCoinList(const QDomElement& xml)
 {
     return newCoinList(new CoinList(xml, this, newCoinListId()));
 }
 
-CoinList* Pokemod::newCoinList(const CoinList& coinList)
+Pokemod::CoinList* Pokemod::Pokemod::newCoinList(const CoinList& coinList)
 {
     return newCoinList(new CoinList(coinList, this, newCoinListId()));
 }
 
-CoinList* Pokemod::newCoinList(CoinList* coinList)
+Pokemod::CoinList* Pokemod::Pokemod::newCoinList(CoinList* coinList)
 {
     m_coinLists.append(coinList);
     return coinList;
 }
 
-void Pokemod::deleteCoinList(const int index)
+void Pokemod::Pokemod::deleteCoinList(const int index)
 {
     Q_ASSERT(index < coinListCount());
     delete m_coinLists[index];
     m_coinLists.removeAt(index);
 }
 
-void Pokemod::deleteCoinListById(const int id)
+void Pokemod::Pokemod::deleteCoinListById(const int id)
 {
     deleteCoinList(coinListIndex(id));
 }
 
-int Pokemod::newCoinListId() const
+int Pokemod::Pokemod::newCoinListId() const
 {
     int i = 0;
     while ((i < coinListCount()) && (coinListIndex(i) != INT_MAX))
@@ -992,29 +988,29 @@ int Pokemod::newCoinListId() const
     return i;
 }
 
-const EggGroup* Pokemod::eggGroup(const int index) const
+const Pokemod::EggGroup* Pokemod::Pokemod::eggGroup(const int index) const
 {
     Q_ASSERT(index < eggGroupCount());
     return m_eggGroups.at(index);
 }
 
-EggGroup* Pokemod::eggGroup(const int index)
+Pokemod::EggGroup* Pokemod::Pokemod::eggGroup(const int index)
 {
     Q_ASSERT(index < eggGroupCount());
     return m_eggGroups[index];
 }
 
-const EggGroup* Pokemod::eggGroupById(const int id) const
+const Pokemod::EggGroup* Pokemod::Pokemod::eggGroupById(const int id) const
 {
     return eggGroup(eggGroupIndex(id));
 }
 
-EggGroup* Pokemod::eggGroupById(const int id)
+Pokemod::EggGroup* Pokemod::Pokemod::eggGroupById(const int id)
 {
     return eggGroup(eggGroupIndex(id));
 }
 
-int Pokemod::eggGroupIndex(const int id) const
+int Pokemod::Pokemod::eggGroupIndex(const int id) const
 {
     for (int i = 0; i < eggGroupCount(); ++i)
     {
@@ -1024,45 +1020,45 @@ int Pokemod::eggGroupIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::eggGroupCount() const
+int Pokemod::Pokemod::eggGroupCount() const
 {
     return m_eggGroups.size();
 }
 
-EggGroup* Pokemod::newEggGroup()
+Pokemod::EggGroup* Pokemod::Pokemod::newEggGroup()
 {
     return newEggGroup(new EggGroup(this, newEggGroupId()));
 }
 
-EggGroup* Pokemod::newEggGroup(const QDomElement& xml)
+Pokemod::EggGroup* Pokemod::Pokemod::newEggGroup(const QDomElement& xml)
 {
     return newEggGroup(new EggGroup(xml, this, newEggGroupId()));
 }
 
-EggGroup* Pokemod::newEggGroup(const EggGroup& eggGroup)
+Pokemod::EggGroup* Pokemod::Pokemod::newEggGroup(const EggGroup& eggGroup)
 {
     return newEggGroup(new EggGroup(eggGroup, this, newEggGroupId()));
 }
 
-EggGroup* Pokemod::newEggGroup(EggGroup* eggGroup)
+Pokemod::EggGroup* Pokemod::Pokemod::newEggGroup(EggGroup* eggGroup)
 {
     m_eggGroups.append(eggGroup);
     return eggGroup;
 }
 
-void Pokemod::deleteEggGroup(const int index)
+void Pokemod::Pokemod::deleteEggGroup(const int index)
 {
     Q_ASSERT(index < eggGroupCount());
     delete m_eggGroups[index];
     m_eggGroups.removeAt(index);
 }
 
-void Pokemod::deleteEggGroupById(const int id)
+void Pokemod::Pokemod::deleteEggGroupById(const int id)
 {
     deleteEggGroup(eggGroupIndex(id));
 }
 
-int Pokemod::newEggGroupId() const
+int Pokemod::Pokemod::newEggGroupId() const
 {
     int i = 0;
     while ((i < eggGroupCount()) && (eggGroupIndex(i) != INT_MAX))
@@ -1070,29 +1066,29 @@ int Pokemod::newEggGroupId() const
     return i;
 }
 
-const GlobalScript* Pokemod::globalScript(const int index) const
+const Pokemod::GlobalScript* Pokemod::Pokemod::globalScript(const int index) const
 {
     Q_ASSERT(index < globalScriptCount());
     return m_globalScripts.at(index);
 }
 
-GlobalScript* Pokemod::globalScript(const int index)
+Pokemod::GlobalScript* Pokemod::Pokemod::globalScript(const int index)
 {
     Q_ASSERT(index < globalScriptCount());
     return m_globalScripts[index];
 }
 
-const GlobalScript* Pokemod::globalScriptById(const int id) const
+const Pokemod::GlobalScript* Pokemod::Pokemod::globalScriptById(const int id) const
 {
     return globalScript(globalScriptIndex(id));
 }
 
-GlobalScript* Pokemod::globalScriptById(const int id)
+Pokemod::GlobalScript* Pokemod::Pokemod::globalScriptById(const int id)
 {
     return globalScript(globalScriptIndex(id));
 }
 
-int Pokemod::globalScriptIndex(const int id) const
+int Pokemod::Pokemod::globalScriptIndex(const int id) const
 {
     for (int i = 0; i < globalScriptCount(); ++i)
     {
@@ -1102,45 +1098,45 @@ int Pokemod::globalScriptIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::globalScriptCount() const
+int Pokemod::Pokemod::globalScriptCount() const
 {
     return m_globalScripts.size();
 }
 
-GlobalScript* Pokemod::newGlobalScript()
+Pokemod::GlobalScript* Pokemod::Pokemod::newGlobalScript()
 {
     return newGlobalScript(new GlobalScript(this, newGlobalScriptId()));
 }
 
-GlobalScript* Pokemod::newGlobalScript(const QDomElement& xml)
+Pokemod::GlobalScript* Pokemod::Pokemod::newGlobalScript(const QDomElement& xml)
 {
     return newGlobalScript(new GlobalScript(xml, this, newGlobalScriptId()));
 }
 
-GlobalScript* Pokemod::newGlobalScript(const GlobalScript& globalScript)
+Pokemod::GlobalScript* Pokemod::Pokemod::newGlobalScript(const GlobalScript& globalScript)
 {
     return newGlobalScript(new GlobalScript(globalScript, this, newGlobalScriptId()));
 }
 
-GlobalScript* Pokemod::newGlobalScript(GlobalScript* globalScript)
+Pokemod::GlobalScript* Pokemod::Pokemod::newGlobalScript(GlobalScript* globalScript)
 {
     m_globalScripts.append(globalScript);
     return globalScript;
 }
 
-void Pokemod::deleteGlobalScript(const int index)
+void Pokemod::Pokemod::deleteGlobalScript(const int index)
 {
     Q_ASSERT(index < globalScriptCount());
     delete m_globalScripts[index];
     m_globalScripts.removeAt(index);
 }
 
-void Pokemod::deleteGlobalScriptById(const int id)
+void Pokemod::Pokemod::deleteGlobalScriptById(const int id)
 {
     deleteGlobalScript(globalScriptIndex(id));
 }
 
-int Pokemod::newGlobalScriptId() const
+int Pokemod::Pokemod::newGlobalScriptId() const
 {
     int i = 0;
     while ((i < globalScriptCount()) && (globalScriptIndex(i) != INT_MAX))
@@ -1148,29 +1144,29 @@ int Pokemod::newGlobalScriptId() const
     return i;
 }
 
-const Item* Pokemod::item(const int index) const
+const Pokemod::Item* Pokemod::Pokemod::item(const int index) const
 {
     Q_ASSERT(index < itemCount());
     return m_items.at(index);
 }
 
-Item* Pokemod::item(const int index)
+Pokemod::Item* Pokemod::Pokemod::item(const int index)
 {
     Q_ASSERT(index < itemCount());
     return m_items[index];
 }
 
-const Item* Pokemod::itemById(const int id) const
+const Pokemod::Item* Pokemod::Pokemod::itemById(const int id) const
 {
     return item(itemIndex(id));
 } 
 
-Item* Pokemod::itemById(const int id)
+Pokemod::Item* Pokemod::Pokemod::itemById(const int id)
 {
     return item(itemIndex(id));
 }
 
-int Pokemod::itemIndex(const int id) const
+int Pokemod::Pokemod::itemIndex(const int id) const
 {
     for (int i = 0; i < itemCount(); ++i)
     {
@@ -1180,45 +1176,45 @@ int Pokemod::itemIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::itemCount() const
+int Pokemod::Pokemod::itemCount() const
 {
     return m_items.size();
 }
 
-Item* Pokemod::newItem()
+Pokemod::Item* Pokemod::Pokemod::newItem()
 {
     return newItem(new Item(this, newItemId()));
 }
 
-Item* Pokemod::newItem(const QDomElement& xml)
+Pokemod::Item* Pokemod::Pokemod::newItem(const QDomElement& xml)
 {
     return newItem(new Item(xml, this, newItemId()));
 }
 
-Item* Pokemod::newItem(const Item& item)
+Pokemod::Item* Pokemod::Pokemod::newItem(const Item& item)
 {
     return newItem(new Item(item, this, newItemId()));
 }
 
-Item* Pokemod::newItem(Item* item)
+Pokemod::Item* Pokemod::Pokemod::newItem(Item* item)
 {
     m_items.append(item);
     return item;
 }
 
-void Pokemod::deleteItem(const int index)
+void Pokemod::Pokemod::deleteItem(const int index)
 {
     Q_ASSERT(index < itemCount());
     delete m_items[index];
     m_items.removeAt(index);
 }
 
-void Pokemod::deleteItemById(const int id)
+void Pokemod::Pokemod::deleteItemById(const int id)
 {
     deleteItem(itemIndex(id));
 }
 
-int Pokemod::newItemId() const
+int Pokemod::Pokemod::newItemId() const
 {
     int i = 0;
     for (; (i < itemCount()) && (itemIndex(i) != INT_MAX); ++i)
@@ -1226,29 +1222,29 @@ int Pokemod::newItemId() const
     return i;
 }
 
-const ItemType* Pokemod::itemType(const int index) const
+const Pokemod::ItemType* Pokemod::Pokemod::itemType(const int index) const
 {
     Q_ASSERT(index < itemTypeCount());
     return m_itemTypes.at(index);
 }
 
-ItemType* Pokemod::itemType(const int index)
+Pokemod::ItemType* Pokemod::Pokemod::itemType(const int index)
 {
     Q_ASSERT(index < itemTypeCount());
     return m_itemTypes[index];
 }
 
-const ItemType* Pokemod::itemTypeById(const int id) const
+const Pokemod::ItemType* Pokemod::Pokemod::itemTypeById(const int id) const
 {
     return itemType(itemTypeIndex(id));
 }
 
-ItemType* Pokemod::itemTypeById(const int id)
+Pokemod::ItemType* Pokemod::Pokemod::itemTypeById(const int id)
 {
     return itemType(itemTypeIndex(id));
 }
 
-int Pokemod::itemTypeIndex(const int id) const
+int Pokemod::Pokemod::itemTypeIndex(const int id) const
 {
     for (int i = 0; i < itemTypeCount(); ++i)
     {
@@ -1258,45 +1254,45 @@ int Pokemod::itemTypeIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::itemTypeCount() const
+int Pokemod::Pokemod::itemTypeCount() const
 {
     return m_itemTypes.size();
 }
 
-ItemType* Pokemod::newItemType()
+Pokemod::ItemType* Pokemod::Pokemod::newItemType()
 {
     return newItemType(new ItemType(this, newItemTypeId()));
 }
 
-ItemType* Pokemod::newItemType(const QDomElement& xml)
+Pokemod::ItemType* Pokemod::Pokemod::newItemType(const QDomElement& xml)
 {
     return newItemType(new ItemType(xml, this, newItemTypeId()));
 }
 
-ItemType* Pokemod::newItemType(const ItemType& itemType)
+Pokemod::ItemType* Pokemod::Pokemod::newItemType(const ItemType& itemType)
 {
     return newItemType(new ItemType(itemType, this, newItemTypeId()));
 }
 
-ItemType* Pokemod::newItemType(ItemType* itemType)
+Pokemod::ItemType* Pokemod::Pokemod::newItemType(ItemType* itemType)
 {
     m_itemTypes.append(itemType);
     return itemType;
 }
 
-void Pokemod::deleteItemType(const int index)
+void Pokemod::Pokemod::deleteItemType(const int index)
 {
     Q_ASSERT(index < itemTypeCount());
     delete m_itemTypes[index];
     m_itemTypes.removeAt(index);
 }
 
-void Pokemod::deleteItemTypeById(const int id)
+void Pokemod::Pokemod::deleteItemTypeById(const int id)
 {
     deleteItemType(itemTypeIndex(id));
 }
 
-int Pokemod::newItemTypeId() const
+int Pokemod::Pokemod::newItemTypeId() const
 {
     int i = 0;
     while ((i < itemTypeCount()) && (itemTypeIndex(i) != INT_MAX))
@@ -1304,29 +1300,29 @@ int Pokemod::newItemTypeId() const
     return i;
 }
 
-const Map* Pokemod::map(const int index) const
+const Pokemod::Map* Pokemod::Pokemod::map(const int index) const
 {
     Q_ASSERT(index < mapCount());
     return m_maps.at(index);
 }
 
-Map* Pokemod::map(const int index)
+Pokemod::Map* Pokemod::Pokemod::map(const int index)
 {
     Q_ASSERT(index < mapCount());
     return m_maps[index];
 }
 
-const Map* Pokemod::mapById(const int id) const
+const Pokemod::Map* Pokemod::Pokemod::mapById(const int id) const
 {
     return map(mapIndex(id));
 }
 
-Map* Pokemod::mapById(const int id)
+Pokemod::Map* Pokemod::Pokemod::mapById(const int id)
 {
     return map(mapIndex(id));
 }
 
-int Pokemod::mapIndex(const int id) const
+int Pokemod::Pokemod::mapIndex(const int id) const
 {
     for (int i = 0; i < mapCount(); ++i)
     {
@@ -1336,45 +1332,45 @@ int Pokemod::mapIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::mapCount() const
+int Pokemod::Pokemod::mapCount() const
 {
     return m_maps.size();
 }
 
-Map* Pokemod::newMap()
+Pokemod::Map* Pokemod::Pokemod::newMap()
 {
     return newMap(new Map(this, newMapId()));
 }
 
-Map* Pokemod::newMap(const QDomElement& xml)
+Pokemod::Map* Pokemod::Pokemod::newMap(const QDomElement& xml)
 {
     return newMap(new Map(xml, this, newMapId()));
 }
 
-Map* Pokemod::newMap(const Map& map)
+Pokemod::Map* Pokemod::Pokemod::newMap(const Map& map)
 {
     return newMap(new Map(map, this, newMapId()));
 }
 
-Map* Pokemod::newMap(Map* map)
+Pokemod::Map* Pokemod::Pokemod::newMap(Map* map)
 {
     m_maps.append(map);
     return map;
 }
 
-void Pokemod::deleteMap(const int index)
+void Pokemod::Pokemod::deleteMap(const int index)
 {
     Q_ASSERT(index < mapCount());
     delete m_maps[index];
     m_maps.removeAt(index);
 }
 
-void Pokemod::deleteMapById(const int id)
+void Pokemod::Pokemod::deleteMapById(const int id)
 {
     deleteMap(mapIndex(id));
 }
 
-int Pokemod::newMapId() const
+int Pokemod::Pokemod::newMapId() const
 {
     int i = 0;
     while ((i < mapCount()) && (mapIndex(i) != INT_MAX))
@@ -1382,29 +1378,29 @@ int Pokemod::newMapId() const
     return i;
 }
 
-const Move* Pokemod::move(const int index) const
+const Pokemod::Move* Pokemod::Pokemod::move(const int index) const
 {
     Q_ASSERT(index < moveCount());
     return m_moves.at(index);
 }
 
-Move* Pokemod::move(const int index)
+Pokemod::Move* Pokemod::Pokemod::move(const int index)
 {
     Q_ASSERT(index < moveCount());
     return m_moves[index];
 }
 
-const Move* Pokemod::moveById(const int id) const
+const Pokemod::Move* Pokemod::Pokemod::moveById(const int id) const
 {
     return move(moveIndex(id));
 }
 
-Move* Pokemod::moveById(const int id)
+Pokemod::Move* Pokemod::Pokemod::moveById(const int id)
 {
     return move(moveIndex(id));
 }
 
-int Pokemod::moveIndex(const int id) const
+int Pokemod::Pokemod::moveIndex(const int id) const
 {
     for (int i = 0; i < moveCount(); ++i)
     {
@@ -1414,45 +1410,45 @@ int Pokemod::moveIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::moveCount() const
+int Pokemod::Pokemod::moveCount() const
 {
     return m_moves.size();
 }
 
-Move* Pokemod::newMove()
+Pokemod::Move* Pokemod::Pokemod::newMove()
 {
     return newMove(new Move(this, newMoveId()));
 }
 
-Move* Pokemod::newMove(const QDomElement& xml)
+Pokemod::Move* Pokemod::Pokemod::newMove(const QDomElement& xml)
 {
     return newMove(new Move(xml, this, newMoveId()));
 }
 
-Move* Pokemod::newMove(const Move& move)
+Pokemod::Move* Pokemod::Pokemod::newMove(const Move& move)
 {
     return newMove(new Move(move, this, newMoveId()));
 }
 
-Move* Pokemod::newMove(Move* move)
+Pokemod::Move* Pokemod::Pokemod::newMove(Move* move)
 {
     m_moves.append(move);
     return move;
 }
 
-void Pokemod::deleteMove(const int index)
+void Pokemod::Pokemod::deleteMove(const int index)
 {
     Q_ASSERT(index < moveCount());
     delete m_moves[index];
     m_moves.removeAt(index);
 }
 
-void Pokemod::deleteMoveById(const int id)
+void Pokemod::Pokemod::deleteMoveById(const int id)
 {
     deleteMove(moveIndex(id));
 }
 
-int Pokemod::newMoveId() const
+int Pokemod::Pokemod::newMoveId() const
 {
     int i = 0;
     while ((i < moveCount()) && (moveIndex(i) != INT_MAX))
@@ -1460,29 +1456,29 @@ int Pokemod::newMoveId() const
     return i;
 }
 
-const Nature* Pokemod::nature(const int index) const
+const Pokemod::Nature* Pokemod::Pokemod::nature(const int index) const
 {
     Q_ASSERT(index < natureCount());
     return m_natures.at(index);
 }
 
-Nature* Pokemod::nature(const int index)
+Pokemod::Nature* Pokemod::Pokemod::nature(const int index)
 {
     Q_ASSERT(index < natureCount());
     return m_natures[index];
 }
 
-const Nature* Pokemod::natureById(const int id) const
+const Pokemod::Nature* Pokemod::Pokemod::natureById(const int id) const
 {
     return nature(natureIndex(id));
 }
 
-Nature* Pokemod::natureById(const int id)
+Pokemod::Nature* Pokemod::Pokemod::natureById(const int id)
 {
     return nature(natureIndex(id));
 }
 
-int Pokemod::natureIndex(const int id) const
+int Pokemod::Pokemod::natureIndex(const int id) const
 {
     for (int i = 0; i < natureCount(); ++i)
     {
@@ -1492,45 +1488,45 @@ int Pokemod::natureIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::natureCount() const
+int Pokemod::Pokemod::natureCount() const
 {
     return m_natures.size();
 }
 
-Nature* Pokemod::newNature()
+Pokemod::Nature* Pokemod::Pokemod::newNature()
 {
     return newNature(new Nature(this, newNatureId()));
 }
 
-Nature* Pokemod::newNature(const QDomElement& xml)
+Pokemod::Nature* Pokemod::Pokemod::newNature(const QDomElement& xml)
 {
     return newNature(new Nature(xml, this, newNatureId()));
 }
 
-Nature* Pokemod::newNature(const Nature& nature)
+Pokemod::Nature* Pokemod::Pokemod::newNature(const Nature& nature)
 {
     return newNature(new Nature(nature, this, newNatureId()));
 }
 
-Nature* Pokemod::newNature(Nature* nature)
+Pokemod::Nature* Pokemod::Pokemod::newNature(Nature* nature)
 {
     m_natures.append(nature);
     return nature;
 }
 
-void Pokemod::deleteNature(const int index)
+void Pokemod::Pokemod::deleteNature(const int index)
 {
     Q_ASSERT(index < natureCount());
     delete m_natures[index];
     m_natures.removeAt(index);
 }
 
-void Pokemod::deleteNatureById(const int id)
+void Pokemod::Pokemod::deleteNatureById(const int id)
 {
     deleteNature(natureIndex(id));
 }
 
-int Pokemod::newNatureId() const
+int Pokemod::Pokemod::newNatureId() const
 {
     int i = 0;
     while ((i < natureCount()) && (natureIndex(i) != INT_MAX))
@@ -1538,29 +1534,29 @@ int Pokemod::newNatureId() const
     return i;
 }
 
-const Sound* Pokemod::sound(const int index) const
+const Pokemod::Sound* Pokemod::Pokemod::sound(const int index) const
 {
     Q_ASSERT(index < soundCount());
     return m_sounds.at(index);
 }
 
-Sound* Pokemod::sound(const int index)
+Pokemod::Sound* Pokemod::Pokemod::sound(const int index)
 {
     Q_ASSERT(index < soundCount());
     return m_sounds[index];
 }
 
-const Sound* Pokemod::soundById(const int id) const
+const Pokemod::Sound* Pokemod::Pokemod::soundById(const int id) const
 {
     return sound(soundIndex(id));
 }
 
-Sound* Pokemod::soundById(const int id)
+Pokemod::Sound* Pokemod::Pokemod::soundById(const int id)
 {
     return sound(soundIndex(id));
 }
 
-int Pokemod::soundIndex(const int id) const
+int Pokemod::Pokemod::soundIndex(const int id) const
 {
     for (int i = 0; i < soundCount(); ++i)
     {
@@ -1570,45 +1566,45 @@ int Pokemod::soundIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::soundCount() const
+int Pokemod::Pokemod::soundCount() const
 {
     return m_sounds.size();
 }
 
-Sound* Pokemod::newSound()
+Pokemod::Sound* Pokemod::Pokemod::newSound()
 {
     return newSound(new Sound(this, newSoundId()));
 }
 
-Sound* Pokemod::newSound(const QDomElement& xml)
+Pokemod::Sound* Pokemod::Pokemod::newSound(const QDomElement& xml)
 {
     return newSound(new Sound(xml, this, newSoundId()));
 }
 
-Sound* Pokemod::newSound(const Sound& sound)
+Pokemod::Sound* Pokemod::Pokemod::newSound(const Sound& sound)
 {
     return newSound(new Sound(sound, this, newSoundId()));
 }
 
-Sound* Pokemod::newSound(Sound* sound)
+Pokemod::Sound* Pokemod::Pokemod::newSound(Sound* sound)
 {
     m_sounds.append(sound);
     return sound;
 }
 
-void Pokemod::deleteSound(const int index)
+void Pokemod::Pokemod::deleteSound(const int index)
 {
     Q_ASSERT(index < soundCount());
     delete m_sounds[index];
     m_sounds.removeAt(index);
 }
 
-void Pokemod::deleteSoundById(const int id)
+void Pokemod::Pokemod::deleteSoundById(const int id)
 {
     deleteSound(soundIndex(id));
 }
 
-int Pokemod::newSoundId() const
+int Pokemod::Pokemod::newSoundId() const
 {
     int i = 0;
     while ((i < soundCount()) && (soundIndex(i) != INT_MAX))
@@ -1616,29 +1612,29 @@ int Pokemod::newSoundId() const
     return i;
 }
 
-const Species* Pokemod::species(const int index) const
+const Pokemod::Species* Pokemod::Pokemod::species(const int index) const
 {
     Q_ASSERT(index < speciesCount());
     return m_species.at(index);
 }
 
-Species* Pokemod::species(const int index)
+Pokemod::Species* Pokemod::Pokemod::species(const int index)
 {
     Q_ASSERT(index < speciesCount());
     return m_species[index];
 }
 
-const Species* Pokemod::speciesById(const int id) const
+const Pokemod::Species* Pokemod::Pokemod::speciesById(const int id) const
 {
     return species(speciesIndex(id));
 }
 
-Species* Pokemod::speciesById(const int id)
+Pokemod::Species* Pokemod::Pokemod::speciesById(const int id)
 {
     return species(speciesIndex(id));
 }
 
-int Pokemod::speciesIndex(const int id) const
+int Pokemod::Pokemod::speciesIndex(const int id) const
 {
     for (int i = 0; i < speciesCount(); ++i)
     {
@@ -1648,45 +1644,45 @@ int Pokemod::speciesIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::speciesCount() const
+int Pokemod::Pokemod::speciesCount() const
 {
     return m_species.size();
 }
 
-Species* Pokemod::newSpecies()
+Pokemod::Species* Pokemod::Pokemod::newSpecies()
 {
     return newSpecies(new Species(this, newSpeciesId()));
 }
 
-Species* Pokemod::newSpecies(const QDomElement& xml)
+Pokemod::Species* Pokemod::Pokemod::newSpecies(const QDomElement& xml)
 {
     return newSpecies(new Species(xml, this, newSpeciesId()));
 }
 
-Species* Pokemod::newSpecies(const Species& species)
+Pokemod::Species* Pokemod::Pokemod::newSpecies(const Species& species)
 {
     return newSpecies(new Species(species, this, newSpeciesId()));
 }
 
-Species* Pokemod::newSpecies(Species* species)
+Pokemod::Species* Pokemod::Pokemod::newSpecies(Species* species)
 {
     m_species.append(species);
     return species;
 }
 
-void Pokemod::deleteSpecies(const int index)
+void Pokemod::Pokemod::deleteSpecies(const int index)
 {
     Q_ASSERT(index < speciesCount());
     delete m_species[index];
     m_species.removeAt(index);
 }
 
-void Pokemod::deleteSpeciesById(const int id)
+void Pokemod::Pokemod::deleteSpeciesById(const int id)
 {
     deleteSpecies(speciesIndex(id));
 }
 
-int Pokemod::newSpeciesId() const
+int Pokemod::Pokemod::newSpeciesId() const
 {
     int i = 0;
     while ((i < speciesCount()) && (speciesIndex(i) != INT_MAX))
@@ -1694,29 +1690,29 @@ int Pokemod::newSpeciesId() const
     return i;
 }
 
-const Sprite* Pokemod::sprite(const int index) const
+const Pokemod::Sprite* Pokemod::Pokemod::sprite(const int index) const
 {
     Q_ASSERT(index < spriteCount());
     return m_sprites.at(index);
 }
 
-Sprite* Pokemod::sprite(const int index)
+Pokemod::Sprite* Pokemod::Pokemod::sprite(const int index)
 {
     Q_ASSERT(index < spriteCount());
     return m_sprites[index];
 }
 
-const Sprite* Pokemod::spriteById(const int id) const
+const Pokemod::Sprite* Pokemod::Pokemod::spriteById(const int id) const
 {
     return sprite(spriteIndex(id));
 }
 
-Sprite* Pokemod::spriteById(const int id)
+Pokemod::Sprite* Pokemod::Pokemod::spriteById(const int id)
 {
     return sprite(spriteIndex(id));
 }
 
-int Pokemod::spriteIndex(const int id) const
+int Pokemod::Pokemod::spriteIndex(const int id) const
 {
     for (int i = 0; i < spriteCount(); ++i)
     {
@@ -1726,45 +1722,45 @@ int Pokemod::spriteIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::spriteCount() const
+int Pokemod::Pokemod::spriteCount() const
 {
     return m_sprites.size();
 }
 
-Sprite* Pokemod::newSprite()
+Pokemod::Sprite* Pokemod::Pokemod::newSprite()
 {
     return newSprite(new Sprite(this, newSpriteId()));
 }
 
-Sprite* Pokemod::newSprite(const QDomElement& xml)
+Pokemod::Sprite* Pokemod::Pokemod::newSprite(const QDomElement& xml)
 {
     return newSprite(new Sprite(xml, this, newSpriteId()));
 }
 
-Sprite* Pokemod::newSprite(const Sprite& sprite)
+Pokemod::Sprite* Pokemod::Pokemod::newSprite(const Sprite& sprite)
 {
     return newSprite(new Sprite(sprite, this, newSpriteId()));
 }
 
-Sprite* Pokemod::newSprite(Sprite* sprite)
+Pokemod::Sprite* Pokemod::Pokemod::newSprite(Sprite* sprite)
 {
     m_sprites.append(sprite);
     return sprite;
 }
 
-void Pokemod::deleteSprite(const int index)
+void Pokemod::Pokemod::deleteSprite(const int index)
 {
     Q_ASSERT(index < spriteCount());
     delete m_sprites[index];
     m_sprites.removeAt(index);
 }
 
-void Pokemod::deleteSpriteById(const int id)
+void Pokemod::Pokemod::deleteSpriteById(const int id)
 {
     deleteSprite(spriteIndex(id));
 }
 
-int Pokemod::newSpriteId() const
+int Pokemod::Pokemod::newSpriteId() const
 {
     int i = 0;
     while ((i < spriteCount()) && (spriteIndex(i) != INT_MAX))
@@ -1772,29 +1768,29 @@ int Pokemod::newSpriteId() const
     return i;
 }
 
-const Status* Pokemod::status(const int index) const
+const Pokemod::Status* Pokemod::Pokemod::status(const int index) const
 {
     Q_ASSERT(index < statusCount());
     return m_status.at(index);
 }
 
-Status* Pokemod::status(const int index)
+Pokemod::Status* Pokemod::Pokemod::status(const int index)
 {
     Q_ASSERT(index < statusCount());
     return m_status[index];
 }
 
-const Status* Pokemod::statusById(const int id) const
+const Pokemod::Status* Pokemod::Pokemod::statusById(const int id) const
 {
     return status(statusIndex(id));
 }
 
-Status* Pokemod::statusById(const int id)
+Pokemod::Status* Pokemod::Pokemod::statusById(const int id)
 {
     return status(statusIndex(id));
 }
 
-int Pokemod::statusIndex(const int id) const
+int Pokemod::Pokemod::statusIndex(const int id) const
 {
     for (int i = 0; i < statusCount(); ++i)
     {
@@ -1804,45 +1800,45 @@ int Pokemod::statusIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::statusCount() const
+int Pokemod::Pokemod::statusCount() const
 {
     return m_status.size();
 }
 
-Status* Pokemod::newStatus()
+Pokemod::Status* Pokemod::Pokemod::newStatus()
 {
     return newStatus(new Status(this, newStatusId()));
 }
 
-Status* Pokemod::newStatus(const QDomElement& xml)
+Pokemod::Status* Pokemod::Pokemod::newStatus(const QDomElement& xml)
 {
     return newStatus(new Status(xml, this, newStatusId()));
 }
 
-Status* Pokemod::newStatus(const Status& status)
+Pokemod::Status* Pokemod::Pokemod::newStatus(const Status& status)
 {
     return newStatus(new Status(status, this, newStatusId()));
 }
 
-Status* Pokemod::newStatus(Status* status)
+Pokemod::Status* Pokemod::Pokemod::newStatus(Status* status)
 {
     m_status.append(status);
     return status;
 }
 
-void Pokemod::deleteStatus(const int index)
+void Pokemod::Pokemod::deleteStatus(const int index)
 {
     Q_ASSERT(index < statusCount());
     delete m_status[index];
     m_status.removeAt(index);
 }
 
-void Pokemod::deleteStatusById(const int id)
+void Pokemod::Pokemod::deleteStatusById(const int id)
 {
     deleteStatus(statusIndex(id));
 }
 
-int Pokemod::newStatusId() const
+int Pokemod::Pokemod::newStatusId() const
 {
     int i = 0;
     while ((i < statusCount()) && (statusIndex(i) != INT_MAX))
@@ -1850,29 +1846,29 @@ int Pokemod::newStatusId() const
     return i;
 }
 
-const Store* Pokemod::store(const int index) const
+const Pokemod::Store* Pokemod::Pokemod::store(const int index) const
 {
     Q_ASSERT(index < storeCount());
     return m_stores.at(index);
 }
 
-Store* Pokemod::store(const int index)
+Pokemod::Store* Pokemod::Pokemod::store(const int index)
 {
     Q_ASSERT(index < storeCount());
     return m_stores[index];
 }
 
-const Store* Pokemod::storeById(const int id) const
+const Pokemod::Store* Pokemod::Pokemod::storeById(const int id) const
 {
     return store(storeIndex(id));
 }
 
-Store* Pokemod::storeById(const int id)
+Pokemod::Store* Pokemod::Pokemod::storeById(const int id)
 {
     return store(storeIndex(id));
 }
 
-int Pokemod::storeIndex(const int id) const
+int Pokemod::Pokemod::storeIndex(const int id) const
 {
     for (int i = 0; i < storeCount(); ++i)
     {
@@ -1882,45 +1878,45 @@ int Pokemod::storeIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::storeCount() const
+int Pokemod::Pokemod::storeCount() const
 {
     return m_stores.size();
 }
 
-Store* Pokemod::newStore()
+Pokemod::Store* Pokemod::Pokemod::newStore()
 {
     return newStore(new Store(this, newStoreId()));
 }
 
-Store* Pokemod::newStore(const QDomElement& xml)
+Pokemod::Store* Pokemod::Pokemod::newStore(const QDomElement& xml)
 {
     return newStore(new Store(xml, this, newStoreId()));
 }
 
-Store* Pokemod::newStore(const Store& store)
+Pokemod::Store* Pokemod::Pokemod::newStore(const Store& store)
 {
     return newStore(new Store(store, this, newStoreId()));
 }
 
-Store* Pokemod::newStore(Store* store)
+Pokemod::Store* Pokemod::Pokemod::newStore(Store* store)
 {
     m_stores.append(store);
     return store;
 }
 
-void Pokemod::deleteStore(const int index)
+void Pokemod::Pokemod::deleteStore(const int index)
 {
     Q_ASSERT(index < storeCount());
     delete m_stores[index];
     m_stores.removeAt(index);
 }
 
-void Pokemod::deleteStoreById(const int id)
+void Pokemod::Pokemod::deleteStoreById(const int id)
 {
     deleteStore(storeIndex(id));
 }
 
-int Pokemod::newStoreId() const
+int Pokemod::Pokemod::newStoreId() const
 {
     int i = 0;
     while ((i < storeCount()) && (storeIndex(i) != INT_MAX))
@@ -1928,29 +1924,29 @@ int Pokemod::newStoreId() const
     return i;
 }
 
-const Tile* Pokemod::tile(const int index) const
+const Pokemod::Tile* Pokemod::Pokemod::tile(const int index) const
 {
     Q_ASSERT(index < tileCount());
     return m_tiles.at(index);
 }
 
-Tile* Pokemod::tile(const int index)
+Pokemod::Tile* Pokemod::Pokemod::tile(const int index)
 {
     Q_ASSERT(index < tileCount());
     return m_tiles[index];
 }
 
-const Tile* Pokemod::tileById(const int id) const
+const Pokemod::Tile* Pokemod::Pokemod::tileById(const int id) const
 {
     return tile(tileIndex(id));
 }
 
-Tile* Pokemod::tileById(const int id)
+Pokemod::Tile* Pokemod::Pokemod::tileById(const int id)
 {
     return tile(tileIndex(id));
 }
 
-int Pokemod::tileIndex(const int id) const
+int Pokemod::Pokemod::tileIndex(const int id) const
 {
     for (int i = 0; i < tileCount(); ++i)
     {
@@ -1960,45 +1956,45 @@ int Pokemod::tileIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::tileCount() const
+int Pokemod::Pokemod::tileCount() const
 {
     return m_tiles.size();
 }
 
-Tile* Pokemod::newTile()
+Pokemod::Tile* Pokemod::Pokemod::newTile()
 {
     return newTile(new Tile(this, newTileId()));
 }
 
-Tile* Pokemod::newTile(const QDomElement& xml)
+Pokemod::Tile* Pokemod::Pokemod::newTile(const QDomElement& xml)
 {
     return newTile(new Tile(xml, this, newTileId()));
 }
 
-Tile* Pokemod::newTile(const Tile& tile)
+Pokemod::Tile* Pokemod::Pokemod::newTile(const Tile& tile)
 {
     return newTile(new Tile(tile, this, newTileId()));
 }
 
-Tile* Pokemod::newTile(Tile* tile)
+Pokemod::Tile* Pokemod::Pokemod::newTile(Tile* tile)
 {
     m_tiles.append(tile);
     return tile;
 }
 
-void Pokemod::deleteTile(const int index)
+void Pokemod::Pokemod::deleteTile(const int index)
 {
     Q_ASSERT(index < tileCount());
     delete m_tiles[index];
     m_tiles.removeAt(index);
 }
 
-void Pokemod::deleteTileById(const int id)
+void Pokemod::Pokemod::deleteTileById(const int id)
 {
     deleteTile(tileIndex(id));
 }
 
-int Pokemod::newTileId() const
+int Pokemod::Pokemod::newTileId() const
 {
     int i = 0;
     while ((i < tileCount()) && (tileIndex(i) != INT_MAX))
@@ -2006,29 +2002,29 @@ int Pokemod::newTileId() const
     return i;
 }
 
-const Time* Pokemod::time(const int index) const
+const Pokemod::Time* Pokemod::Pokemod::time(const int index) const
 {
     Q_ASSERT(index < timeCount());
     return m_times.at(index);
 }
 
-Time* Pokemod::time(const int index)
+Pokemod::Time* Pokemod::Pokemod::time(const int index)
 {
     Q_ASSERT(index < timeCount());
     return m_times[index];
 }
 
-const Time* Pokemod::timeById(const int id) const
+const Pokemod::Time* Pokemod::Pokemod::timeById(const int id) const
 {
     return time(timeIndex(id));
 }
 
-Time* Pokemod::timeById(const int id)
+Pokemod::Time* Pokemod::Pokemod::timeById(const int id)
 {
     return time(timeIndex(id));
 }
 
-int Pokemod::timeIndex(const int id) const
+int Pokemod::Pokemod::timeIndex(const int id) const
 {
     for (int i = 0; i < timeCount(); ++i)
     {
@@ -2038,45 +2034,45 @@ int Pokemod::timeIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::timeCount() const
+int Pokemod::Pokemod::timeCount() const
 {
     return m_times.size();
 }
 
-Time* Pokemod::newTime()
+Pokemod::Time* Pokemod::Pokemod::newTime()
 {
     return newTime(new Time(this, newTimeId()));
 }
 
-Time* Pokemod::newTime(const QDomElement& xml)
+Pokemod::Time* Pokemod::Pokemod::newTime(const QDomElement& xml)
 {
     return newTime(new Time(xml, this, newTimeId()));
 }
 
-Time* Pokemod::newTime(const Time& time)
+Pokemod::Time* Pokemod::Pokemod::newTime(const Time& time)
 {
     return newTime(new Time(time, this, newTimeId()));
 }
 
-Time* Pokemod::newTime(Time* time)
+Pokemod::Time* Pokemod::Pokemod::newTime(Time* time)
 {
     m_times.append(time);
     return time;
 }
 
-void Pokemod::deleteTime(const int index)
+void Pokemod::Pokemod::deleteTime(const int index)
 {
     Q_ASSERT(index < timeCount());
     delete m_times[index];
     m_times.removeAt(index);
 }
 
-void Pokemod::deleteTimeById(const int id)
+void Pokemod::Pokemod::deleteTimeById(const int id)
 {
     deleteTime(timeIndex(id));
 }
 
-int Pokemod::newTimeId() const
+int Pokemod::Pokemod::newTimeId() const
 {
     int i = 0;
     while ((i < timeCount()) && (timeIndex(i) != INT_MAX))
@@ -2084,29 +2080,29 @@ int Pokemod::newTimeId() const
     return i;
 }
 
-const Trainer* Pokemod::trainer(const int index) const
+const Pokemod::Trainer* Pokemod::Pokemod::trainer(const int index) const
 {
     Q_ASSERT(index < trainerCount());
     return m_trainers.at(index);
 }
 
-Trainer* Pokemod::trainer(const int index)
+Pokemod::Trainer* Pokemod::Pokemod::trainer(const int index)
 {
     Q_ASSERT(index < trainerCount());
     return m_trainers[index];
 }
 
-const Trainer* Pokemod::trainerById(const int id) const
+const Pokemod::Trainer* Pokemod::Pokemod::trainerById(const int id) const
 {
     return trainer(trainerIndex(id));
 }
 
-Trainer* Pokemod::trainerById(const int id)
+Pokemod::Trainer* Pokemod::Pokemod::trainerById(const int id)
 {
     return trainer(trainerIndex(id));
 }
 
-int Pokemod::trainerIndex(const int id) const
+int Pokemod::Pokemod::trainerIndex(const int id) const
 {
     for (int i = 0; i < trainerCount(); ++i)
     {
@@ -2116,45 +2112,45 @@ int Pokemod::trainerIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::trainerCount() const
+int Pokemod::Pokemod::trainerCount() const
 {
     return m_trainers.size();
 }
 
-Trainer* Pokemod::newTrainer()
+Pokemod::Trainer* Pokemod::Pokemod::newTrainer()
 {
     return newTrainer(new Trainer(this, newTrainerId()));
 }
 
-Trainer* Pokemod::newTrainer(const QDomElement& xml)
+Pokemod::Trainer* Pokemod::Pokemod::newTrainer(const QDomElement& xml)
 {
     return newTrainer(new Trainer(xml, this, newTrainerId()));
 }
 
-Trainer* Pokemod::newTrainer(const Trainer& trainer)
+Pokemod::Trainer* Pokemod::Pokemod::newTrainer(const Trainer& trainer)
 {
     return newTrainer(new Trainer(trainer, this, newTrainerId()));
 }
 
-Trainer* Pokemod::newTrainer(Trainer* trainer)
+Pokemod::Trainer* Pokemod::Pokemod::newTrainer(Trainer* trainer)
 {
     m_trainers.append(trainer);
     return trainer;
 }
 
-void Pokemod::deleteTrainer(const int index)
+void Pokemod::Pokemod::deleteTrainer(const int index)
 {
     Q_ASSERT(index < trainerCount());
     delete m_trainers[index];
     m_trainers.removeAt(index);
 }
 
-void Pokemod::deleteTrainerById(const int id)
+void Pokemod::Pokemod::deleteTrainerById(const int id)
 {
     deleteTrainer(trainerIndex(id));
 }
 
-int Pokemod::newTrainerId() const
+int Pokemod::Pokemod::newTrainerId() const
 {
     int i = 0;
     while ((i < trainerCount()) && (trainerIndex(i) != INT_MAX))
@@ -2162,29 +2158,29 @@ int Pokemod::newTrainerId() const
     return i;
 }
 
-const Type* Pokemod::type(const int index) const
+const Pokemod::Type* Pokemod::Pokemod::type(const int index) const
 {
     Q_ASSERT(index < typeCount());
     return m_types.at(index);
 }
 
-Type* Pokemod::type(const int index)
+Pokemod::Type* Pokemod::Pokemod::type(const int index)
 {
     Q_ASSERT(index < typeCount());
     return m_types[index];
 }
 
-const Type* Pokemod::typeById(const int id) const
+const Pokemod::Type* Pokemod::Pokemod::typeById(const int id) const
 {
     return type(typeIndex(id));
 }
 
-Type* Pokemod::typeById(const int id)
+Pokemod::Type* Pokemod::Pokemod::typeById(const int id)
 {
     return type(typeIndex(id));
 }
 
-int Pokemod::typeIndex(const int id) const
+int Pokemod::Pokemod::typeIndex(const int id) const
 {
     for (int i = 0; i < typeCount(); ++i)
     {
@@ -2194,34 +2190,34 @@ int Pokemod::typeIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::typeCount() const
+int Pokemod::Pokemod::typeCount() const
 {
     return m_types.size();
 }
 
-Type* Pokemod::newType()
+Pokemod::Type* Pokemod::Pokemod::newType()
 {
     return newType(new Type(this, newTypeId()));
 }
 
-Type* Pokemod::newType(const QDomElement& xml)
+Pokemod::Type* Pokemod::Pokemod::newType(const QDomElement& xml)
 {
     return newType(new Type(xml, this, newTypeId()));
 }
 
-Type* Pokemod::newType(const Type& type)
+Pokemod::Type* Pokemod::Pokemod::newType(const Type& type)
 {
     return newType(new Type(type, this, newTypeId()));
 }
 
-Type* Pokemod::newType(Type* type)
+Pokemod::Type* Pokemod::Pokemod::newType(Type* type)
 {
     m_types.append(type);
     m_typechart.resize(typeCount(), typeCount(), Fraction(1, 1));
     return type;
 }
 
-void Pokemod::deleteType(const int index)
+void Pokemod::Pokemod::deleteType(const int index)
 {
     Q_ASSERT(index < typeCount());
     delete m_types[index];
@@ -2229,12 +2225,12 @@ void Pokemod::deleteType(const int index)
     m_typechart.resize(typeCount(), typeCount(), Fraction(1, 1));
 }
 
-void Pokemod::deleteTypeById(const int id)
+void Pokemod::Pokemod::deleteTypeById(const int id)
 {
     deleteType(typeIndex(id));
 }
 
-int Pokemod::newTypeId() const
+int Pokemod::Pokemod::newTypeId() const
 {
     int i = 0;
     while ((i < typeCount()) && (typeIndex(i) != INT_MAX))
@@ -2242,29 +2238,29 @@ int Pokemod::newTypeId() const
     return i;
 }
 
-const Weather* Pokemod::weather(const int index) const
+const Pokemod::Weather* Pokemod::Pokemod::weather(const int index) const
 {
     Q_ASSERT(index < weatherCount());
     return m_weathers.at(index);
 }
 
-Weather* Pokemod::weather(const int index)
+Pokemod::Weather* Pokemod::Pokemod::weather(const int index)
 {
     Q_ASSERT(index < weatherCount());
     return m_weathers[index];
 }
 
-const Weather* Pokemod::weatherById(const int id) const
+const Pokemod::Weather* Pokemod::Pokemod::weatherById(const int id) const
 {
     return weather(weatherIndex(id));
 }
 
-Weather* Pokemod::weatherById(const int id)
+Pokemod::Weather* Pokemod::Pokemod::weatherById(const int id)
 {
     return weather(weatherIndex(id));
 }
 
-int Pokemod::weatherIndex(const int id) const
+int Pokemod::Pokemod::weatherIndex(const int id) const
 {
     for (int i = 0; i < weatherCount(); ++i)
     {
@@ -2274,45 +2270,45 @@ int Pokemod::weatherIndex(const int id) const
     return INT_MAX;
 }
 
-int Pokemod::weatherCount() const
+int Pokemod::Pokemod::weatherCount() const
 {
     return m_weathers.size();
 }
 
-Weather* Pokemod::newWeather()
+Pokemod::Weather* Pokemod::Pokemod::newWeather()
 {
     return newWeather(new Weather(this, newWeatherId()));
 }
 
-Weather* Pokemod::newWeather(const QDomElement& xml)
+Pokemod::Weather* Pokemod::Pokemod::newWeather(const QDomElement& xml)
 {
     return newWeather(new Weather(xml, this, newWeatherId()));
 }
 
-Weather* Pokemod::newWeather(const Weather& weather)
+Pokemod::Weather* Pokemod::Pokemod::newWeather(const Weather& weather)
 {
     return newWeather(new Weather(weather, this, newWeatherId()));
 }
 
-Weather* Pokemod::newWeather(Weather* weather)
+Pokemod::Weather* Pokemod::Pokemod::newWeather(Weather* weather)
 {
     m_weathers.append(weather);
     return weather;
 }
 
-void Pokemod::deleteWeather(const int index)
+void Pokemod::Pokemod::deleteWeather(const int index)
 {
     Q_ASSERT(index < weatherCount());
     delete m_weathers[index];
     m_weathers.removeAt(index);
 }
 
-void Pokemod::deleteWeatherById(const int id)
+void Pokemod::Pokemod::deleteWeatherById(const int id)
 {
     deleteWeather(weatherIndex(id));
 }
 
-int Pokemod::newWeatherId() const
+int Pokemod::Pokemod::newWeatherId() const
 {
     int i = 0;
     while ((i < weatherCount()) && (weatherIndex(i) != INT_MAX))
@@ -2320,7 +2316,7 @@ int Pokemod::newWeatherId() const
     return i;
 }
 
-Pokemod& Pokemod::operator=(const Pokemod& rhs)
+Pokemod::Pokemod& Pokemod::Pokemod::operator=(const Pokemod& rhs)
 {
     if (this == &rhs)
         return *this;
@@ -2357,7 +2353,7 @@ Pokemod& Pokemod::operator=(const Pokemod& rhs)
     return *this;
 }
 
-void Pokemod::clear()
+void Pokemod::Pokemod::clear()
 {
     while (abilityCount())
         deleteAbility(0);