[DEL] Removed PokeGen namespace

[ADD] general/AudioCache.h completed
[DEL] VERSION removed from subdir .pro files
[DEL] audio/

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

1 files changed, 174 insertions, 174 deletions

diff --git a/pokemod/Pokemod.cpp b/pokemod/Pokemod.cpp
index 1917bd02..645ef33d 100644
--- a/pokemod/Pokemod.cpp
+++ b/pokemod/Pokemod.cpp
@@ -22,7 +22,7 @@
 
 #include "Pokemod.h"
 
-PokeGen::PokeMod::Pokemod::Pokemod(const QString& fname) :
+PokeMod::Pokemod::Pokemod(const QString& fname) :
         Object(*this, 0),
         valstream(NULL),
         title(""),
@@ -41,7 +41,7 @@ PokeGen::PokeMod::Pokemod::Pokemod(const QString& fname) :
     load(fname);
 }
 
-bool PokeGen::PokeMod::Pokemod::validate() const
+bool PokeMod::Pokemod::validate() const
 {
     bool valid = true;
     validationMsg(QString("Pokemod \"%1\"").arg(title), V_Msg);
@@ -610,12 +610,12 @@ bool PokeGen::PokeMod::Pokemod::validate() const
     return valid;
 }
 
-QString PokeGen::PokeMod::Pokemod::getPath() const
+QString PokeMod::Pokemod::getPath() const
 {
     return path;
 }
 
-void PokeGen::PokeMod::Pokemod::load(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::load(const QString& fname) throw(Exception)
 {
     Ini ini(fname);
     QStringList fpath = fname.split('\\', QString::SkipEmptyParts).join("/").split('\\', QString::SkipEmptyParts);
@@ -762,7 +762,7 @@ void PokeGen::PokeMod::Pokemod::load(const QString& fname) throw(Exception)
     }
 }
 
-void PokeGen::PokeMod::Pokemod::save() const throw(Exception)
+void PokeMod::Pokemod::save() const throw(Exception)
 {
     Ini ini;
     ini.addField("title", title);
@@ -820,39 +820,39 @@ void PokeGen::PokeMod::Pokemod::save() const throw(Exception)
         i.next().save();
 }
 
-unsigned PokeGen::PokeMod::Pokemod::maxCompatability(const Pokemod& p) const
+unsigned PokeMod::Pokemod::maxCompatability(const Pokemod& p) const
 {
     // TODO (Ben #1#): MaxCompatability between two versions
 }
 
-void PokeGen::PokeMod::Pokemod::setTitle(const QString& t)
+void PokeMod::Pokemod::setTitle(const QString& t)
 {
     title = t;
 }
 
-void PokeGen::PokeMod::Pokemod::setVersion(const QString& v)
+void PokeMod::Pokemod::setVersion(const QString& v)
 {
     version = v;
 }
 
-void PokeGen::PokeMod::Pokemod::setDescription(const QString& d)
+void PokeMod::Pokemod::setDescription(const QString& d)
 {
     description = d;
 }
 
-void PokeGen::PokeMod::Pokemod::setStartMap(const unsigned s) throw(BoundsException)
+void PokeMod::Pokemod::setStartMap(const unsigned s) throw(BoundsException)
 {
     if (getMapByID(s) == UINT_MAX)
         throw(BoundsException("Pokemod", "startMap"));
     startMap = s;
 }
 
-void PokeGen::PokeMod::Pokemod::setStartMoney(const unsigned s)
+void PokeMod::Pokemod::setStartMoney(const unsigned s)
 {
     startMoney = s;
 }
 
-void PokeGen::PokeMod::Pokemod::setStartCoordinate(const unsigned x, const unsigned y) throw(BoundsException)
+void PokeMod::Pokemod::setStartCoordinate(const unsigned x, const unsigned y) throw(BoundsException)
 {
     if (getMapByID(startMap) == UINT_MAX)
         throw(BoundsException("Pokemod", "startMap"));
@@ -863,7 +863,7 @@ void PokeGen::PokeMod::Pokemod::setStartCoordinate(const unsigned x, const unsig
     startCoordinate.set(x, y);
 }
 
-void PokeGen::PokeMod::Pokemod::setStartCoordinateX(const unsigned x) throw(BoundsException)
+void PokeMod::Pokemod::setStartCoordinateX(const unsigned x) throw(BoundsException)
 {
     if (getMapByID(startMap) == UINT_MAX)
         throw(BoundsException("Pokemod", "startMap"));
@@ -872,7 +872,7 @@ void PokeGen::PokeMod::Pokemod::setStartCoordinateX(const unsigned x) throw(Boun
     startCoordinate.setX(x);
 }
 
-void PokeGen::PokeMod::Pokemod::setStartCoordinateY(const unsigned y) throw(BoundsException)
+void PokeMod::Pokemod::setStartCoordinateY(const unsigned y) throw(BoundsException)
 {
     if (getMapByID(startMap) == UINT_MAX)
         throw(BoundsException("Pokemod", "startMap"));
@@ -881,21 +881,21 @@ void PokeGen::PokeMod::Pokemod::setStartCoordinateY(const unsigned y) throw(Boun
     startCoordinate.setY(y);
 }
 
-void PokeGen::PokeMod::Pokemod::setStartDirection(const unsigned s) throw(BoundsException)
+void PokeMod::Pokemod::setStartDirection(const unsigned s) throw(BoundsException)
 {
     if (D_End <= s)
         throw(BoundsException("Pokemod", "startDirection"));
     startDirection = s;
 }
 
-void PokeGen::PokeMod::Pokemod::setStartDialog(const unsigned s) throw(BoundsException)
+void PokeMod::Pokemod::setStartDialog(const unsigned s) throw(BoundsException)
 {
     if (getDialogByID(s) == UINT_MAX)
         throw(BoundsException("Pokemod", "startDialog"));
     startDialog = s;
 }
 
-void PokeGen::PokeMod::Pokemod::setWalkSkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setWalkSkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/walk.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -904,7 +904,7 @@ void PokeGen::PokeMod::Pokemod::setWalkSkin(const QString& fname) throw(Exceptio
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setBikeSkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setBikeSkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/bike.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -913,7 +913,7 @@ void PokeGen::PokeMod::Pokemod::setBikeSkin(const QString& fname) throw(Exceptio
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setSurfSkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setSurfSkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/surf.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -922,7 +922,7 @@ void PokeGen::PokeMod::Pokemod::setSurfSkin(const QString& fname) throw(Exceptio
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setFlySkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setFlySkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/fly.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -931,7 +931,7 @@ void PokeGen::PokeMod::Pokemod::setFlySkin(const QString& fname) throw(Exception
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setFishSkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setFishSkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/fish.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -940,7 +940,7 @@ void PokeGen::PokeMod::Pokemod::setFishSkin(const QString& fname) throw(Exceptio
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setSurfFishSkin(const QString& fname) throw(Exception)
+void PokeMod::Pokemod::setSurfFishSkin(const QString& fname) throw(Exception)
 {
     QFile file(QString("%1/image/skin/surfFish.png").arg(getPath()));
     if (file.exists() && !file.remove())
@@ -949,151 +949,151 @@ void PokeGen::PokeMod::Pokemod::setSurfFishSkin(const QString& fname) throw(Exce
         throw(SaveException("Pokemod", file.fileName()));
 }
 
-void PokeGen::PokeMod::Pokemod::setSuperPCUname(const QString& u)
+void PokeMod::Pokemod::setSuperPCUname(const QString& u)
 {
     superPCUname = u;
 }
 
-void PokeGen::PokeMod::Pokemod::setSuperPCPasswd(const QString& p)
+void PokeMod::Pokemod::setSuperPCPasswd(const QString& p)
 {
     superPCPasswd = p;
 }
 
-void PokeGen::PokeMod::Pokemod::setTypeChart(const unsigned att, const unsigned def, const unsigned n, const unsigned d) throw(Exception)
+void PokeMod::Pokemod::setTypeChart(const unsigned att, const unsigned def, const unsigned n, const unsigned d) throw(Exception)
 {
     typeChart(att, def).set(n, d);
 }
 
-void PokeGen::PokeMod::Pokemod::setTypeChartNum(const unsigned att, const unsigned def, const unsigned n) throw(Exception)
+void PokeMod::Pokemod::setTypeChartNum(const unsigned att, const unsigned def, const unsigned n) throw(Exception)
 {
     typeChart(att, def).setNum(n);
 }
 
-void PokeGen::PokeMod::Pokemod::setTypeChartDenom(const unsigned att, const unsigned def, const unsigned d) throw(Exception)
+void PokeMod::Pokemod::setTypeChartDenom(const unsigned att, const unsigned def, const unsigned d) throw(Exception)
 {
     typeChart(att, def).setDenom(d);
 }
 
-void PokeGen::PokeMod::Pokemod::setRules(const Rules& r)
+void PokeMod::Pokemod::setRules(const Rules& r)
 {
     rules = r;
 }
 
-void PokeGen::PokeMod::Pokemod::setRules(const QString& fname)
+void PokeMod::Pokemod::setRules(const QString& fname)
 {
     rules.load(fname);
 }
 
-QString PokeGen::PokeMod::Pokemod::getTitle() const
+QString PokeMod::Pokemod::getTitle() const
 {
     return title;
 }
 
-QString PokeGen::PokeMod::Pokemod::getVersion() const
+QString PokeMod::Pokemod::getVersion() const
 {
     return version;
 }
 
-QString PokeGen::PokeMod::Pokemod::getDescription() const
+QString PokeMod::Pokemod::getDescription() const
 {
     return description;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartMap() const
+unsigned PokeMod::Pokemod::getStartMap() const
 {
     return startMap;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartMoney() const
+unsigned PokeMod::Pokemod::getStartMoney() const
 {
     return startMoney;
 }
 
-PokeGen::Point PokeGen::PokeMod::Pokemod::getStartCoordinate() const
+Point PokeMod::Pokemod::getStartCoordinate() const
 {
     return startCoordinate;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartCoordinateX() const
+unsigned PokeMod::Pokemod::getStartCoordinateX() const
 {
     return startCoordinate.getX();
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartCoordinateY() const
+unsigned PokeMod::Pokemod::getStartCoordinateY() const
 {
     return startCoordinate.getY();
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartDirection() const
+unsigned PokeMod::Pokemod::getStartDirection() const
 {
     return startDirection;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStartDialog() const
+unsigned PokeMod::Pokemod::getStartDialog() const
 {
     return startDialog;
 }
 
-QString PokeGen::PokeMod::Pokemod::getSuperPCUname() const
+QString PokeMod::Pokemod::getSuperPCUname() const
 {
     return superPCUname;
 }
 
-QString PokeGen::PokeMod::Pokemod::getSuperPCPasswd() const
+QString PokeMod::Pokemod::getSuperPCPasswd() const
 {
     return superPCPasswd;
 }
 
-const PokeGen::FracMatrix& PokeGen::PokeMod::Pokemod::getTypeChart() const
+const FracMatrix& PokeMod::Pokemod::getTypeChart() const
 {
     return typeChart;
 }
 
-PokeGen::FracMatrix& PokeGen::PokeMod::Pokemod::getTypeChart()
+FracMatrix& PokeMod::Pokemod::getTypeChart()
 {
     return typeChart;
 }
 
-PokeGen::Frac PokeGen::PokeMod::Pokemod::getTypeChart(const unsigned att, const unsigned def) const
+Frac PokeMod::Pokemod::getTypeChart(const unsigned att, const unsigned def) const
 {
     return typeChart(att, def);
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTypeChartNum(const unsigned att, const unsigned def) const
+unsigned PokeMod::Pokemod::getTypeChartNum(const unsigned att, const unsigned def) const
 {
     return getTypeChart(att, def).getNum();
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTypeChartDenom(const unsigned att, const unsigned def) const
+unsigned PokeMod::Pokemod::getTypeChartDenom(const unsigned att, const unsigned def) const
 {
     return getTypeChart(att, def).getDenom();
 }
 
-const PokeGen::PokeMod::Rules& PokeGen::PokeMod::Pokemod::getRules() const
+const PokeMod::Rules& PokeMod::Pokemod::getRules() const
 {
     return rules;
 }
 
-PokeGen::PokeMod::Rules& PokeGen::PokeMod::Pokemod::getRules()
+PokeMod::Rules& PokeMod::Pokemod::getRules()
 {
     return rules;
 }
 
-const PokeGen::PokeMod::Ability& PokeGen::PokeMod::Pokemod::getAbility(const unsigned i) const throw(IndexException)
+const PokeMod::Ability& PokeMod::Pokemod::getAbility(const unsigned i) const throw(IndexException)
 {
     if (getAbilityCount() <= i)
         throw(IndexException("Pokemod"));
     return abilities.at(i);
 }
 
-PokeGen::PokeMod::Ability& PokeGen::PokeMod::Pokemod::getAbility(const unsigned i) throw(IndexException)
+PokeMod::Ability& PokeMod::Pokemod::getAbility(const unsigned i) throw(IndexException)
 {
     if (getAbilityCount() <= i)
         throw(IndexException("Pokemod"));
     return abilities[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getAbilityByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getAbilityByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getAbilityCount(); ++i)
     {
@@ -1103,51 +1103,51 @@ unsigned PokeGen::PokeMod::Pokemod::getAbilityByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getAbilityCount() const
+unsigned PokeMod::Pokemod::getAbilityCount() const
 {
     return abilities.size();
 }
 
-PokeGen::PokeMod::Ability& PokeGen::PokeMod::Pokemod::newAbility()
+PokeMod::Ability& PokeMod::Pokemod::newAbility()
 {
     abilities.append(Ability(*this, getNewAbilityId()));
     return abilities[getAbilityCount() - 1];
 }
 
-PokeGen::PokeMod::Ability& PokeGen::PokeMod::Pokemod::newAbility(const QString& fname)
+PokeMod::Ability& PokeMod::Pokemod::newAbility(const QString& fname)
 {
     abilities.append(Ability(*this, fname, getNewAbilityId()));
     return abilities[getAbilityCount() - 1];
 }
 
-PokeGen::PokeMod::Ability& PokeGen::PokeMod::Pokemod::newAbility(const Ability& a)
+PokeMod::Ability& PokeMod::Pokemod::newAbility(const Ability& a)
 {
     abilities.append(Ability(*this, a, getNewAbilityId()));
     return abilities[getAbilityCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteAbility(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteAbility(const unsigned i) throw(IndexException)
 {
     if (getAbilityCount() <= i)
         throw(IndexException("Pokemod"));
     abilities.removeAt(i);
 }
 
-const PokeGen::PokeMod::Author& PokeGen::PokeMod::Pokemod::getAuthor(const unsigned i) const throw(IndexException)
+const PokeMod::Author& PokeMod::Pokemod::getAuthor(const unsigned i) const throw(IndexException)
 {
     if (getAuthorCount() <= i)
         throw(IndexException("Pokemod"));
     return authors.at(i);
 }
 
-PokeGen::PokeMod::Author& PokeGen::PokeMod::Pokemod::getAuthor(const unsigned i) throw(IndexException)
+PokeMod::Author& PokeMod::Pokemod::getAuthor(const unsigned i) throw(IndexException)
 {
     if (getAuthorCount() <= i)
         throw(IndexException("Pokemod"));
     return authors[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getAuthorByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getAuthorByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getAuthorCount(); ++i)
     {
@@ -1157,39 +1157,39 @@ unsigned PokeGen::PokeMod::Pokemod::getAuthorByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getAuthorCount() const
+unsigned PokeMod::Pokemod::getAuthorCount() const
 {
     return authors.size();
 }
 
-PokeGen::PokeMod::Author& PokeGen::PokeMod::Pokemod::newAuthor()
+PokeMod::Author& PokeMod::Pokemod::newAuthor()
 {
     authors.append(Author(*this, getNewAuthorId()));
     return authors[getAuthorCount() + 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteAuthor(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteAuthor(const unsigned i) throw(IndexException)
 {
     if (getAuthorCount() <= i)
         throw(IndexException("Pokemod"));
     authors.removeAt(i);
 }
 
-const PokeGen::PokeMod::Badge& PokeGen::PokeMod::Pokemod::getBadge(const unsigned i) const throw(IndexException)
+const PokeMod::Badge& PokeMod::Pokemod::getBadge(const unsigned i) const throw(IndexException)
 {
     if (i < getBadgeCount())
         throw(IndexException("Pokemod"));
     return badges.at(i);
 }
 
-PokeGen::PokeMod::Badge& PokeGen::PokeMod::Pokemod::getBadge(const unsigned i) throw(IndexException)
+PokeMod::Badge& PokeMod::Pokemod::getBadge(const unsigned i) throw(IndexException)
 {
     if (i < getBadgeCount())
         throw(IndexException("Pokemod"));
     return badges[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getBadgeByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getBadgeByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getBadgeCount(); ++i)
     {
@@ -1199,51 +1199,51 @@ unsigned PokeGen::PokeMod::Pokemod::getBadgeByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getBadgeCount() const
+unsigned PokeMod::Pokemod::getBadgeCount() const
 {
     return badges.size();
 }
 
-PokeGen::PokeMod::Badge& PokeGen::PokeMod::Pokemod::newBadge()
+PokeMod::Badge& PokeMod::Pokemod::newBadge()
 {
     badges.append(Badge(*this, getNewBadgeId()));
     return badges[getBadgeCount() - 1];
 }
 
-PokeGen::PokeMod::Badge& PokeGen::PokeMod::Pokemod::newBadge(const QString& fname)
+PokeMod::Badge& PokeMod::Pokemod::newBadge(const QString& fname)
 {
     badges.append(Badge(*this, fname, getNewBadgeId()));
     return badges[getBadgeCount() - 1];
 }
 
-PokeGen::PokeMod::Badge& PokeGen::PokeMod::Pokemod::newBadge(const Badge& b)
+PokeMod::Badge& PokeMod::Pokemod::newBadge(const Badge& b)
 {
     badges.append(Badge(*this, b, getNewBadgeId()));
     return badges[getBadgeCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteBadge(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteBadge(const unsigned i) throw(IndexException)
 {
     if (getBadgeCount() <= i)
         throw(IndexException("Pokemod"));
     badges.removeAt(i);
 }
 
-const PokeGen::PokeMod::CoinList& PokeGen::PokeMod::Pokemod::getCoinList(const unsigned i) const throw(IndexException)
+const PokeMod::CoinList& PokeMod::Pokemod::getCoinList(const unsigned i) const throw(IndexException)
 {
     if (getCoinListCount() <= i)
         throw(IndexException("Pokemod"));
     return coinLists.at(i);
 }
 
-PokeGen::PokeMod::CoinList& PokeGen::PokeMod::Pokemod::getCoinList(const unsigned i) throw(IndexException)
+PokeMod::CoinList& PokeMod::Pokemod::getCoinList(const unsigned i) throw(IndexException)
 {
     if (getCoinListCount() <= i)
         throw(IndexException("Pokemod"));
     return coinLists[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getCoinListByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getCoinListByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getCoinListCount(); ++i)
     {
@@ -1253,51 +1253,51 @@ unsigned PokeGen::PokeMod::Pokemod::getCoinListByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getCoinListCount() const
+unsigned PokeMod::Pokemod::getCoinListCount() const
 {
     return coinLists.size();
 }
 
-PokeGen::PokeMod::CoinList& PokeGen::PokeMod::Pokemod::newCoinList()
+PokeMod::CoinList& PokeMod::Pokemod::newCoinList()
 {
     coinLists.append(CoinList(*this, getNewCoinListId()));
     return coinLists[getCoinListCount() - 1];
 }
 
-PokeGen::PokeMod::CoinList& PokeGen::PokeMod::Pokemod::newCoinList(const QString& fname)
+PokeMod::CoinList& PokeMod::Pokemod::newCoinList(const QString& fname)
 {
     coinLists.append(CoinList(*this, fname, getNewCoinListId()));
     return coinLists[getCoinListCount() - 1];
 }
 
-PokeGen::PokeMod::CoinList& PokeGen::PokeMod::Pokemod::newCoinList(const CoinList& c)
+PokeMod::CoinList& PokeMod::Pokemod::newCoinList(const CoinList& c)
 {
     coinLists.append(CoinList(*this, c, getNewCoinListId()));
     return coinLists[getCoinListCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteCoinList(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteCoinList(const unsigned i) throw(IndexException)
 {
     if (getCoinListCount() <= i)
         throw(IndexException("Pokemod"));
     coinLists.removeAt(i);
 }
 
-const PokeGen::PokeMod::Dialog& PokeGen::PokeMod::Pokemod::getDialog(const unsigned i) const throw(IndexException)
+const PokeMod::Dialog& PokeMod::Pokemod::getDialog(const unsigned i) const throw(IndexException)
 {
     if (getDialogCount() <= i)
         throw(IndexException("Pokemod"));
     return dialogs.at(i);
 }
 
-PokeGen::PokeMod::Dialog& PokeGen::PokeMod::Pokemod::getDialog(const unsigned i) throw(IndexException)
+PokeMod::Dialog& PokeMod::Pokemod::getDialog(const unsigned i) throw(IndexException)
 {
     if (getDialogCount() <= i)
         throw(IndexException("Pokemod"));
     return dialogs[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getDialogByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getDialogByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getDialogCount(); ++i)
     {
@@ -1307,51 +1307,51 @@ unsigned PokeGen::PokeMod::Pokemod::getDialogByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getDialogCount() const
+unsigned PokeMod::Pokemod::getDialogCount() const
 {
     return dialogs.size();
 }
 
-PokeGen::PokeMod::Dialog& PokeGen::PokeMod::Pokemod::newDialog()
+PokeMod::Dialog& PokeMod::Pokemod::newDialog()
 {
     dialogs.append(Dialog(*this, getNewDialogId()));
     return dialogs[getDialogCount() - 1];
 }
 
-PokeGen::PokeMod::Dialog& PokeGen::PokeMod::Pokemod::newDialog(const QString& fname)
+PokeMod::Dialog& PokeMod::Pokemod::newDialog(const QString& fname)
 {
     dialogs.append(Dialog(*this, fname, getNewDialogId()));
     return dialogs[getDialogCount() - 1];
 }
 
-PokeGen::PokeMod::Dialog& PokeGen::PokeMod::Pokemod::newDialog(const Dialog& d)
+PokeMod::Dialog& PokeMod::Pokemod::newDialog(const Dialog& d)
 {
     dialogs.append(Dialog(*this, d, getNewDialogId()));
     return dialogs[getDialogCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteDialog(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteDialog(const unsigned i) throw(IndexException)
 {
     if (getDialogCount() <= i)
         throw(IndexException("Pokemod"));
     dialogs.removeAt(i);
 }
 
-const PokeGen::PokeMod::EggGroup& PokeGen::PokeMod::Pokemod::getEggGroup(const unsigned i) const throw(IndexException)
+const PokeMod::EggGroup& PokeMod::Pokemod::getEggGroup(const unsigned i) const throw(IndexException)
 {
     if (getEggGroupCount() <= i)
         throw(IndexException("Pokemod"));
     return eggGroups.at(i);
 }
 
-PokeGen::PokeMod::EggGroup& PokeGen::PokeMod::Pokemod::getEggGroup(const unsigned i) throw(IndexException)
+PokeMod::EggGroup& PokeMod::Pokemod::getEggGroup(const unsigned i) throw(IndexException)
 {
     if (getEggGroupCount() <= i)
         throw(IndexException("Pokemod"));
     return eggGroups[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getEggGroupByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getEggGroupByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getEggGroupCount(); ++i)
     {
@@ -1361,51 +1361,51 @@ unsigned PokeGen::PokeMod::Pokemod::getEggGroupByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getEggGroupCount() const
+unsigned PokeMod::Pokemod::getEggGroupCount() const
 {
     return eggGroups.size();
 }
 
-PokeGen::PokeMod::EggGroup& PokeGen::PokeMod::Pokemod::newEggGroup()
+PokeMod::EggGroup& PokeMod::Pokemod::newEggGroup()
 {
     eggGroups.append(EggGroup(*this, getNewEggGroupId()));
     return eggGroups[getEggGroupCount() - 1];
 }
 
-PokeGen::PokeMod::EggGroup& PokeGen::PokeMod::Pokemod::newEggGroup(const QString& fname)
+PokeMod::EggGroup& PokeMod::Pokemod::newEggGroup(const QString& fname)
 {
     eggGroups.append(EggGroup(*this, fname, getNewEggGroupId()));
     return eggGroups[getEggGroupCount() - 1];
 }
 
-PokeGen::PokeMod::EggGroup& PokeGen::PokeMod::Pokemod::newEggGroup(const EggGroup& e)
+PokeMod::EggGroup& PokeMod::Pokemod::newEggGroup(const EggGroup& e)
 {
     eggGroups.append(EggGroup(*this, e, getNewEggGroupId()));
     return eggGroups[getEggGroupCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteEggGroup(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteEggGroup(const unsigned i) throw(IndexException)
 {
     if (getEggGroupCount() <= i)
         throw(IndexException("Pokemod"));
     eggGroups.removeAt(i);
 }
 
-const PokeGen::PokeMod::Item& PokeGen::PokeMod::Pokemod::getItem(const unsigned i) const throw(IndexException)
+const PokeMod::Item& PokeMod::Pokemod::getItem(const unsigned i) const throw(IndexException)
 {
     if (getItemCount() <= i)
         throw(IndexException("Pokemod"));
     return items.at(i);
 }
 
-PokeGen::PokeMod::Item& PokeGen::PokeMod::Pokemod::getItem(const unsigned i) throw(IndexException)
+PokeMod::Item& PokeMod::Pokemod::getItem(const unsigned i) throw(IndexException)
 {
     if (getItemCount() <= i)
         throw(IndexException("Pokemod"));
     return items[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getItemByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getItemByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getItemCount(); ++i)
     {
@@ -1415,51 +1415,51 @@ unsigned PokeGen::PokeMod::Pokemod::getItemByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getItemCount() const
+unsigned PokeMod::Pokemod::getItemCount() const
 {
     return items.size();
 }
 
-PokeGen::PokeMod::Item& PokeGen::PokeMod::Pokemod::newItem()
+PokeMod::Item& PokeMod::Pokemod::newItem()
 {
     items.append(Item(*this, getNewItemId()));
     return items[getItemCount() - 1];
 }
 
-PokeGen::PokeMod::Item& PokeGen::PokeMod::Pokemod::newItem(const QString& fname)
+PokeMod::Item& PokeMod::Pokemod::newItem(const QString& fname)
 {
     items.append(Item(*this, fname, getNewItemId()));
     return items[getItemCount() - 1];
 }
 
-PokeGen::PokeMod::Item& PokeGen::PokeMod::Pokemod::newItem(const Item& i)
+PokeMod::Item& PokeMod::Pokemod::newItem(const Item& i)
 {
     items.append(Item(*this, i, getNewItemId()));
     return items[getItemCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteItem(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteItem(const unsigned i) throw(IndexException)
 {
     if (getItemCount() <= i)
         throw(IndexException("Pokemod"));
     items.removeAt(i);
 }
 
-const PokeGen::PokeMod::ItemType& PokeGen::PokeMod::Pokemod::getItemType(const unsigned i) const throw(IndexException)
+const PokeMod::ItemType& PokeMod::Pokemod::getItemType(const unsigned i) const throw(IndexException)
 {
     if (getItemTypeCount() <= i)
         throw(IndexException("Pokemod"));
     return itemTypes.at(i);
 }
 
-PokeGen::PokeMod::ItemType& PokeGen::PokeMod::Pokemod::getItemType(const unsigned i) throw(IndexException)
+PokeMod::ItemType& PokeMod::Pokemod::getItemType(const unsigned i) throw(IndexException)
 {
     if (getItemTypeCount() <= i)
         throw(IndexException("Pokemod"));
     return itemTypes[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getItemTypeByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getItemTypeByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getItemTypeCount(); ++i)
     {
@@ -1469,51 +1469,51 @@ unsigned PokeGen::PokeMod::Pokemod::getItemTypeByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getItemTypeCount() const
+unsigned PokeMod::Pokemod::getItemTypeCount() const
 {
     return itemTypes.size();
 }
 
-PokeGen::PokeMod::ItemType& PokeGen::PokeMod::Pokemod::newItemType()
+PokeMod::ItemType& PokeMod::Pokemod::newItemType()
 {
     itemTypes.append(ItemType(*this, getNewItemTypeId()));
     return itemTypes[getItemTypeCount() - 1];
 }
 
-PokeGen::PokeMod::ItemType& PokeGen::PokeMod::Pokemod::newItemType(const QString& fname)
+PokeMod::ItemType& PokeMod::Pokemod::newItemType(const QString& fname)
 {
     itemTypes.append(ItemType(*this, fname, getNewItemTypeId()));
     return itemTypes[getItemTypeCount() - 1];
 }
 
-PokeGen::PokeMod::ItemType& PokeGen::PokeMod::Pokemod::newItemType(const ItemType& i)
+PokeMod::ItemType& PokeMod::Pokemod::newItemType(const ItemType& i)
 {
     itemTypes.append(ItemType(*this, i, getNewItemTypeId()));
     return itemTypes[getItemTypeCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteItemType(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteItemType(const unsigned i) throw(IndexException)
 {
     if (getItemTypeCount() <= i)
         throw(IndexException("Pokemod"));
     itemTypes.removeAt(i);
 }
 
-const PokeGen::PokeMod::Map& PokeGen::PokeMod::Pokemod::getMap(const unsigned i) const throw(IndexException)
+const PokeMod::Map& PokeMod::Pokemod::getMap(const unsigned i) const throw(IndexException)
 {
     if (getMapCount() <= i)
         throw(IndexException("Pokemod"));
     return maps.at(i);
 }
 
-PokeGen::PokeMod::Map& PokeGen::PokeMod::Pokemod::getMap(const unsigned i) throw(IndexException)
+PokeMod::Map& PokeMod::Pokemod::getMap(const unsigned i) throw(IndexException)
 {
     if (getMapCount() <= i)
         throw(IndexException("Pokemod"));
     return maps[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getMapByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getMapByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getMapCount(); ++i)
     {
@@ -1523,51 +1523,51 @@ unsigned PokeGen::PokeMod::Pokemod::getMapByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getMapCount() const
+unsigned PokeMod::Pokemod::getMapCount() const
 {
     return maps.size();
 }
 
-PokeGen::PokeMod::Map& PokeGen::PokeMod::Pokemod::newMap()
+PokeMod::Map& PokeMod::Pokemod::newMap()
 {
     maps.append(Map(*this, getNewMapId()));
     return maps[getMapCount() - 1];
 }
 
-PokeGen::PokeMod::Map& PokeGen::PokeMod::Pokemod::newMap(const QString& fname)
+PokeMod::Map& PokeMod::Pokemod::newMap(const QString& fname)
 {
     maps.append(Map(*this, fname, getNewMapId()));
     return maps[getMapCount() - 1];
 }
 
-PokeGen::PokeMod::Map& PokeGen::PokeMod::Pokemod::newMap(const Map& m)
+PokeMod::Map& PokeMod::Pokemod::newMap(const Map& m)
 {
     maps.append(Map(*this, m, getNewMapId()));
     return maps[getMapCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteMap(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteMap(const unsigned i) throw(IndexException)
 {
     if (getMapCount() <= i)
         throw(IndexException("Pokemod"));
     maps.removeAt(i);
 }
 
-const PokeGen::PokeMod::Move& PokeGen::PokeMod::Pokemod::getMove(const unsigned i) const throw(IndexException)
+const PokeMod::Move& PokeMod::Pokemod::getMove(const unsigned i) const throw(IndexException)
 {
     if (getMoveCount() <= i)
         throw(IndexException("Pokemod"));
     return moves.at(i);
 }
 
-PokeGen::PokeMod::Move& PokeGen::PokeMod::Pokemod::getMove(const unsigned i) throw(IndexException)
+PokeMod::Move& PokeMod::Pokemod::getMove(const unsigned i) throw(IndexException)
 {
     if (getMoveCount() <= i)
         throw(IndexException("Pokemod"));
     return moves[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getMoveByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getMoveByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getMoveCount(); ++i)
     {
@@ -1577,51 +1577,51 @@ unsigned PokeGen::PokeMod::Pokemod::getMoveByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getMoveCount() const
+unsigned PokeMod::Pokemod::getMoveCount() const
 {
     return moves.size();
 }
 
-PokeGen::PokeMod::Move& PokeGen::PokeMod::Pokemod::newMove()
+PokeMod::Move& PokeMod::Pokemod::newMove()
 {
     moves.append(Move(*this, getNewMoveId()));
     return moves[getMoveCount() - 1];
 }
 
-PokeGen::PokeMod::Move& PokeGen::PokeMod::Pokemod::newMove(const QString& fname)
+PokeMod::Move& PokeMod::Pokemod::newMove(const QString& fname)
 {
     moves.append(Move(*this, fname, getNewMoveId()));
     return moves[getMoveCount() - 1];
 }
 
-PokeGen::PokeMod::Move& PokeGen::PokeMod::Pokemod::newMove(const Move& m)
+PokeMod::Move& PokeMod::Pokemod::newMove(const Move& m)
 {
     moves.append(Move(*this, m, getNewMoveId()));
     return moves[getMoveCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteMove(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteMove(const unsigned i) throw(IndexException)
 {
     if (getMoveCount() <= i)
         throw(IndexException("Pokemod"));
     moves.removeAt(i);
 }
 
-const PokeGen::PokeMod::Nature& PokeGen::PokeMod::Pokemod::getNature(const unsigned i) const throw(IndexException)
+const PokeMod::Nature& PokeMod::Pokemod::getNature(const unsigned i) const throw(IndexException)
 {
     if (getNatureCount() <= i)
         throw(IndexException("Pokemod"));
     return natures.at(i);
 }
 
-PokeGen::PokeMod::Nature& PokeGen::PokeMod::Pokemod::getNature(const unsigned i) throw(IndexException)
+PokeMod::Nature& PokeMod::Pokemod::getNature(const unsigned i) throw(IndexException)
 {
     if (getNatureCount() <= i)
         throw(IndexException("Pokemod"));
     return natures[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getNatureByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getNatureByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getNatureCount(); ++i)
     {
@@ -1631,51 +1631,51 @@ unsigned PokeGen::PokeMod::Pokemod::getNatureByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getNatureCount() const
+unsigned PokeMod::Pokemod::getNatureCount() const
 {
     return natures.size();
 }
 
-PokeGen::PokeMod::Nature& PokeGen::PokeMod::Pokemod::newNature()
+PokeMod::Nature& PokeMod::Pokemod::newNature()
 {
     natures.append(Nature(*this, getNewNatureId()));
     return natures[getNatureCount() - 1];
 }
 
-PokeGen::PokeMod::Nature& PokeGen::PokeMod::Pokemod::newNature(const QString& fname)
+PokeMod::Nature& PokeMod::Pokemod::newNature(const QString& fname)
 {
     natures.append(Nature(*this, fname, getNewNatureId()));
     return natures[getNatureCount() - 1];
 }
 
-PokeGen::PokeMod::Nature& PokeGen::PokeMod::Pokemod::newNature(const Nature& n)
+PokeMod::Nature& PokeMod::Pokemod::newNature(const Nature& n)
 {
     natures.append(Nature(*this, n, getNewNatureId()));
     return natures[getNatureCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteNature(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteNature(const unsigned i) throw(IndexException)
 {
     if (getNatureCount() <= i)
         throw(IndexException("Pokemod"));
     natures.removeAt(i);
 }
 
-const PokeGen::PokeMod::Species& PokeGen::PokeMod::Pokemod::getSpecies(const unsigned i) const throw(IndexException)
+const PokeMod::Species& PokeMod::Pokemod::getSpecies(const unsigned i) const throw(IndexException)
 {
     if (getSpeciesCount() <= i)
         throw(IndexException("Pokemod"));
     return species.at(i);
 }
 
-PokeGen::PokeMod::Species& PokeGen::PokeMod::Pokemod::getSpecies(const unsigned i) throw(IndexException)
+PokeMod::Species& PokeMod::Pokemod::getSpecies(const unsigned i) throw(IndexException)
 {
     if (getSpeciesCount() <= i)
         throw(IndexException("Pokemod"));
     return species[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getSpeciesByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getSpeciesByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getSpeciesCount(); ++i)
     {
@@ -1685,51 +1685,51 @@ unsigned PokeGen::PokeMod::Pokemod::getSpeciesByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getSpeciesCount() const
+unsigned PokeMod::Pokemod::getSpeciesCount() const
 {
     return species.size();
 }
 
-PokeGen::PokeMod::Species& PokeGen::PokeMod::Pokemod::newSpecies()
+PokeMod::Species& PokeMod::Pokemod::newSpecies()
 {
     species.append(Species(*this, getNewSpeciesId()));
     return species[getSpeciesCount() - 1];
 }
 
-PokeGen::PokeMod::Species& PokeGen::PokeMod::Pokemod::newSpecies(const QString& fname)
+PokeMod::Species& PokeMod::Pokemod::newSpecies(const QString& fname)
 {
     species.append(Species(*this, fname, getNewSpeciesId()));
     return species[getSpeciesCount() - 1];
 }
 
-PokeGen::PokeMod::Species& PokeGen::PokeMod::Pokemod::newSpecies(const Species& s)
+PokeMod::Species& PokeMod::Pokemod::newSpecies(const Species& s)
 {
     species.append(Species(*this, s, getNewSpeciesId()));
     return species[getSpeciesCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteSpecies(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteSpecies(const unsigned i) throw(IndexException)
 {
     if (getSpeciesCount() <= i)
         throw(IndexException("Pokemod"));
     species.removeAt(i);
 }
 
-const PokeGen::PokeMod::Store& PokeGen::PokeMod::Pokemod::getStore(const unsigned i) const throw(IndexException)
+const PokeMod::Store& PokeMod::Pokemod::getStore(const unsigned i) const throw(IndexException)
 {
     if (getStoreCount() <= i)
         throw(IndexException("Pokemod"));
     return stores.at(i);
 }
 
-PokeGen::PokeMod::Store& PokeGen::PokeMod::Pokemod::getStore(const unsigned i) throw(IndexException)
+PokeMod::Store& PokeMod::Pokemod::getStore(const unsigned i) throw(IndexException)
 {
     if (getStoreCount() <= i)
         throw(IndexException("Pokemod"));
     return stores[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStoreByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getStoreByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getStoreCount(); ++i)
     {
@@ -1739,51 +1739,51 @@ unsigned PokeGen::PokeMod::Pokemod::getStoreByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getStoreCount() const
+unsigned PokeMod::Pokemod::getStoreCount() const
 {
     return stores.size();
 }
 
-PokeGen::PokeMod::Store& PokeGen::PokeMod::Pokemod::newStore()
+PokeMod::Store& PokeMod::Pokemod::newStore()
 {
     stores.append(Store(*this, getNewStoreId()));
     return stores[getStoreCount() - 1];
 }
 
-PokeGen::PokeMod::Store& PokeGen::PokeMod::Pokemod::newStore(const QString& fname)
+PokeMod::Store& PokeMod::Pokemod::newStore(const QString& fname)
 {
     stores.append(Store(*this, fname, getNewStoreId()));
     return stores[getStoreCount() - 1];
 }
 
-PokeGen::PokeMod::Store& PokeGen::PokeMod::Pokemod::newStore(const Store& s)
+PokeMod::Store& PokeMod::Pokemod::newStore(const Store& s)
 {
     stores.append(Store(*this, s, getNewStoreId()));
     return stores[getStoreCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteStore(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteStore(const unsigned i) throw(IndexException)
 {
     if (getStoreCount() <= i)
         throw(IndexException("Pokemod"));
     stores.removeAt(i);
 }
 
-const PokeGen::PokeMod::Tile& PokeGen::PokeMod::Pokemod::getTile(const unsigned i) const throw(IndexException)
+const PokeMod::Tile& PokeMod::Pokemod::getTile(const unsigned i) const throw(IndexException)
 {
     if (getTileCount() <= i)
         throw(IndexException("Pokemod"));
     return tiles.at(i);
 }
 
-PokeGen::PokeMod::Tile& PokeGen::PokeMod::Pokemod::getTile(const unsigned i) throw(IndexException)
+PokeMod::Tile& PokeMod::Pokemod::getTile(const unsigned i) throw(IndexException)
 {
     if (getTileCount() <= i)
         throw(IndexException("Pokemod"));
     return tiles[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTileByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getTileByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getTileCount(); ++i)
     {
@@ -1793,51 +1793,51 @@ unsigned PokeGen::PokeMod::Pokemod::getTileByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTileCount() const
+unsigned PokeMod::Pokemod::getTileCount() const
 {
     return tiles.size();
 }
 
-PokeGen::PokeMod::Tile& PokeGen::PokeMod::Pokemod::newTile()
+PokeMod::Tile& PokeMod::Pokemod::newTile()
 {
     tiles.append(Tile(*this, getNewTileId()));
     return tiles[getTileCount() - 1];
 }
 
-PokeGen::PokeMod::Tile& PokeGen::PokeMod::Pokemod::newTile(const QString& fname)
+PokeMod::Tile& PokeMod::Pokemod::newTile(const QString& fname)
 {
     tiles.append(Tile(*this, fname, getNewTileId()));
     return tiles[getTileCount() - 1];
 }
 
-PokeGen::PokeMod::Tile& PokeGen::PokeMod::Pokemod::newTile(const Tile& t)
+PokeMod::Tile& PokeMod::Pokemod::newTile(const Tile& t)
 {
     tiles.append(Tile(*this, t, getNewTileId()));
     return tiles[getTileCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteTile(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteTile(const unsigned i) throw(IndexException)
 {
     if (getTileCount() <= i)
         throw(IndexException("Pokemod"));
     tiles.removeAt(i);
 }
 
-const PokeGen::PokeMod::Time& PokeGen::PokeMod::Pokemod::getTime(const unsigned i) const throw(IndexException)
+const PokeMod::Time& PokeMod::Pokemod::getTime(const unsigned i) const throw(IndexException)
 {
     if (getTimeCount() <= i)
         throw(IndexException("Pokemod"));
     return times.at(i);
 }
 
-PokeGen::PokeMod::Time& PokeGen::PokeMod::Pokemod::getTime(const unsigned i) throw(IndexException)
+PokeMod::Time& PokeMod::Pokemod::getTime(const unsigned i) throw(IndexException)
 {
     if (getTimeCount() <= i)
         throw(IndexException("Pokemod"));
     return times[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTimeByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getTimeByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getTimeCount(); ++i)
     {
@@ -1847,51 +1847,51 @@ unsigned PokeGen::PokeMod::Pokemod::getTimeByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTimeCount() const
+unsigned PokeMod::Pokemod::getTimeCount() const
 {
     return times.size();
 }
 
-PokeGen::PokeMod::Time& PokeGen::PokeMod::Pokemod::newTime()
+PokeMod::Time& PokeMod::Pokemod::newTime()
 {
     times.append(Time(*this, getNewTimeId()));
     return times[getTimeCount() - 1];
 }
 
-PokeGen::PokeMod::Time& PokeGen::PokeMod::Pokemod::newTime(const QString& fname)
+PokeMod::Time& PokeMod::Pokemod::newTime(const QString& fname)
 {
     times.append(Time(*this, fname, getNewTimeId()));
     return times[getTimeCount() - 1];
 }
 
-PokeGen::PokeMod::Time& PokeGen::PokeMod::Pokemod::newTime(const Time& t)
+PokeMod::Time& PokeMod::Pokemod::newTime(const Time& t)
 {
     times.append(Time(*this, t, getNewTimeId()));
     return times[getTimeCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteTime(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteTime(const unsigned i) throw(IndexException)
 {
     if (getTimeCount() <= i)
         throw(IndexException("Pokemod"));
     times.removeAt(i);
 }
 
-const PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::getType(const unsigned i) const throw(IndexException)
+const PokeMod::Type& PokeMod::Pokemod::getType(const unsigned i) const throw(IndexException)
 {
     if (getTypeCount() <= i)
         throw(IndexException("Pokemod"));
     return types.at(i);
 }
 
-PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::getType(const unsigned i) throw(IndexException)
+PokeMod::Type& PokeMod::Pokemod::getType(const unsigned i) throw(IndexException)
 {
     if (getTypeCount() <= i)
         throw(IndexException("Pokemod"));
     return types[i];
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTypeByID(const unsigned _id) const
+unsigned PokeMod::Pokemod::getTypeByID(const unsigned _id) const
 {
     for (unsigned i = 0; i < getTypeCount(); ++i)
     {
@@ -1901,12 +1901,12 @@ unsigned PokeGen::PokeMod::Pokemod::getTypeByID(const unsigned _id) const
     return UINT_MAX;
 }
 
-unsigned PokeGen::PokeMod::Pokemod::getTypeCount() const
+unsigned PokeMod::Pokemod::getTypeCount() const
 {
     return types.size();
 }
 
-PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType()
+PokeMod::Type& PokeMod::Pokemod::newType()
 {
     unsigned i;
     types.append(Type(*this, i = getNewTypeId()));
@@ -1915,7 +1915,7 @@ PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType()
     return types[getTypeCount() - 1];
 }
 
-PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType(const QString& fname)
+PokeMod::Type& PokeMod::Pokemod::newType(const QString& fname)
 {
     unsigned i;
     types.append(Type(*this, fname, i = getNewTypeId()));
@@ -1924,7 +1924,7 @@ PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType(const QString& fname)
     return types[getTypeCount() - 1];
 }
 
-PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType(const Type& t)
+PokeMod::Type& PokeMod::Pokemod::newType(const Type& t)
 {
     unsigned i;
     types.append(Type(*this, t, i = getNewTypeId()));
@@ -1933,7 +1933,7 @@ PokeGen::PokeMod::Type& PokeGen::PokeMod::Pokemod::newType(const Type& t)
     return types[getTypeCount() - 1];
 }
 
-void PokeGen::PokeMod::Pokemod::deleteType(const unsigned i) throw(IndexException)
+void PokeMod::Pokemod::deleteType(const unsigned i) throw(IndexException)
 {
     if (getTypeCount() <= i)
         throw(IndexException("Pokemod"));