[FIX] SoundUI widget has a better layout

[FIX] Sound playback works in SoundUI
[FIX] SoundWrapper returns a Phonon object for playback in scripts now
[FIX] Wrapper classes now won't be duplicated (persistent storage is possible now)
[FIX] Linking to libraries is fixed for RPM
[FIX] Pokemod Macros.h is hidden if not compiling pokemod
[FIX] make-tarball script is simpler now (and works as upstream, not local copy)
[FIX] Cleaned up spec file per review request for Fedora

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

1 files changed, 81 insertions, 69 deletions

diff --git a/pokescripting/PokemodWrapper.h b/pokescripting/PokemodWrapper.h
index 08125a79..c8ea704c 100644
--- a/pokescripting/PokemodWrapper.h
+++ b/pokescripting/PokemodWrapper.h
@@ -32,6 +32,7 @@
 #include "NatureWrapper.h"
 #include "ObjectWrapper.h"
 #include "RulesWrapper.h"
+#include "SkinWrapper.h"
 #include "SoundWrapper.h"
 #include "SpeciesWrapper.h"
 #include "SpriteWrapper.h"
@@ -58,31 +59,32 @@ class POKESCRIPTING_EXPORT PokemodWrapper : public ObjectWrapper
         QString title() const;
         QString version() const;
         QString description() const;
-        const MapWarpWrapper* startWarp() const;
+        MapWarpWrapper* startWarp();
         Pokemod::Fraction effectiveness(const TypeWrapper* attacker, const TypeWrapper* defender) const;
-        const RulesWrapper* rules() const;
+        RulesWrapper* rules();
         
-        const AbilityWrapper* ability(const QString& name) const;
-        const AuthorWrapper* author(const QString& name) const;
-        const BadgeWrapper* badge(const QString& name) const;
-        const CoinListWrapper* coinList(const QString& name) const;
-        const EggGroupWrapper* eggGroup(const QString& name) const;
-        const GlobalScriptWrapper* globalScript(const QString& name) const;
-        const ItemWrapper* item(const QString& name) const;
-        const ItemTypeWrapper* itemType(const QString& name) const;
-        const MapWrapper* map(const QString& name) const;
-        const MoveWrapper* move(const QString& name) const;
-        const NatureWrapper* nature(const QString& name) const;
-        const SoundWrapper* sound(const QString& name) const;
-        const SpeciesWrapper* species(const QString& name) const;
-        const SpriteWrapper* sprite(const QString& name) const;
-        const StatusWrapper* status(const QString& name) const;
-        const StoreWrapper* store(const QString& name) const;
-        const TileWrapper* tile(const QString& name) const;
-        const TimeWrapper* time(const QString& name) const;
-        const TrainerWrapper* trainer(const QString& name) const;
-        const TypeWrapper* type(const QString& name) const;
-        const WeatherWrapper* weather(const QString& name) const;
+        AbilityWrapper* ability(const QString& name);
+        AuthorWrapper* author(const QString& name);
+        BadgeWrapper* badge(const QString& name);
+        CoinListWrapper* coinList(const QString& name);
+        EggGroupWrapper* eggGroup(const QString& name);
+        GlobalScriptWrapper* globalScript(const QString& name);
+        ItemWrapper* item(const QString& name);
+        ItemTypeWrapper* itemType(const QString& name);
+        MapWrapper* map(const QString& name);
+        MoveWrapper* move(const QString& name);
+        NatureWrapper* nature(const QString& name);
+        SkinWrapper* skin(const QString& name);
+        SoundWrapper* sound(const QString& name);
+        SpeciesWrapper* species(const QString& name);
+        SpriteWrapper* sprite(const QString& name);
+        StatusWrapper* status(const QString& name);
+        StoreWrapper* store(const QString& name);
+        TileWrapper* tile(const QString& name);
+        TimeWrapper* time(const QString& name);
+        TrainerWrapper* trainer(const QString& name);
+        TypeWrapper* type(const QString& name);
+        WeatherWrapper* weather(const QString& name);
     private:
         PokemodWrapper& operator=(const PokemodWrapper& rhs);
         
@@ -110,9 +112,9 @@ inline QString PokemodWrapper::description() const
     return m_pokemod->description();
 }
 
-inline const MapWarpWrapper* PokemodWrapper::startWarp() const
+inline MapWarpWrapper* PokemodWrapper::startWarp()
 {
-    return new MapWarpWrapper(m_pokemod->mapById(m_pokemod->startMap())->warpById(m_pokemod->startWarp()), const_cast<PokemodWrapper*>(this));
+    return MapWarpWrapper::create(m_pokemod->mapById(m_pokemod->startMap())->warpById(m_pokemod->startWarp()), this);
 }
 
 inline Pokemod::Fraction PokemodWrapper::effectiveness(const TypeWrapper* attacker, const TypeWrapper* defender) const
@@ -120,217 +122,227 @@ inline Pokemod::Fraction PokemodWrapper::effectiveness(const TypeWrapper* attack
     return m_pokemod->typechart(m_pokemod->typeIndex(attacker->id()), m_pokemod->typeIndex(defender->id()));
 }
 
-const RulesWrapper* PokemodWrapper::rules() const
+inline RulesWrapper* PokemodWrapper::rules()
 {
-    return new RulesWrapper(m_pokemod->rules(), const_cast<PokemodWrapper*>(this));
+    return RulesWrapper::create(m_pokemod->rules(), this);
 }
 
-inline const AbilityWrapper* PokemodWrapper::ability(const QString& name) const
+inline AbilityWrapper* PokemodWrapper::ability(const QString& name)
 {
     for (int i = 0; i < m_pokemod->abilityCount(); ++i)
     {
         if (m_pokemod->ability(i)->name() == name)
-            return new AbilityWrapper(m_pokemod->ability(i), const_cast<PokemodWrapper*>(this));
+            return AbilityWrapper::create(m_pokemod->ability(i), this);
     }
     return NULL;
 }
 
-inline const AuthorWrapper* PokemodWrapper::author(const QString& name) const
+inline AuthorWrapper* PokemodWrapper::author(const QString& name)
 {
     for (int i = 0; i < m_pokemod->authorCount(); ++i)
     {
         if (m_pokemod->author(i)->name() == name)
-            return new AuthorWrapper(m_pokemod->author(i), const_cast<PokemodWrapper*>(this));
+            return AuthorWrapper::create(m_pokemod->author(i), this);
     }
     return NULL;
 }
 
-inline const BadgeWrapper* PokemodWrapper::badge(const QString& name) const
+inline BadgeWrapper* PokemodWrapper::badge(const QString& name)
 {
     for (int i = 0; i < m_pokemod->badgeCount(); ++i)
     {
         if (m_pokemod->badge(i)->name() == name)
-            return new BadgeWrapper(m_pokemod->badge(i), const_cast<PokemodWrapper*>(this));
+            return BadgeWrapper::create(m_pokemod->badge(i), this);
     }
     return NULL;
 }
 
-inline const CoinListWrapper* PokemodWrapper::coinList(const QString& name) const
+inline CoinListWrapper* PokemodWrapper::coinList(const QString& name)
 {
     for (int i = 0; i < m_pokemod->coinListCount(); ++i)
     {
         if (m_pokemod->coinList(i)->name() == name)
-            return new CoinListWrapper(m_pokemod->coinList(i), const_cast<PokemodWrapper*>(this));
+            return CoinListWrapper::create(m_pokemod->coinList(i), this);
     }
     return NULL;
 }
 
-inline const EggGroupWrapper* PokemodWrapper::eggGroup(const QString& name) const
+inline EggGroupWrapper* PokemodWrapper::eggGroup(const QString& name)
 {
     for (int i = 0; i < m_pokemod->eggGroupCount(); ++i)
     {
         if (m_pokemod->eggGroup(i)->name() == name)
-            return new EggGroupWrapper(m_pokemod->eggGroup(i), const_cast<PokemodWrapper*>(this));
+            return EggGroupWrapper::create(m_pokemod->eggGroup(i), this);
     }
     return NULL;
 }
 
-inline const GlobalScriptWrapper* PokemodWrapper::globalScript(const QString& name) const
+inline GlobalScriptWrapper* PokemodWrapper::globalScript(const QString& name)
 {
     for (int i = 0; i < m_pokemod->globalScriptCount(); ++i)
     {
         if (m_pokemod->globalScript(i)->name() == name)
-            return new GlobalScriptWrapper(m_pokemod->globalScript(i), const_cast<PokemodWrapper*>(this));
+            return GlobalScriptWrapper::create(m_pokemod->globalScript(i), this);
     }
     return NULL;
 }
 
-inline const ItemWrapper* PokemodWrapper::item(const QString& name) const
+inline ItemWrapper* PokemodWrapper::item(const QString& name)
 {
     for (int i = 0; i < m_pokemod->itemCount(); ++i)
     {
         if (m_pokemod->item(i)->name() == name)
-            return new ItemWrapper(m_pokemod->item(i), const_cast<PokemodWrapper*>(this));
+            return ItemWrapper::create(m_pokemod->item(i), this);
     }
     return NULL;
 }
 
-inline const ItemTypeWrapper* PokemodWrapper::itemType(const QString& name) const
+inline ItemTypeWrapper* PokemodWrapper::itemType(const QString& name)
 {
     for (int i = 0; i < m_pokemod->itemTypeCount(); ++i)
     {
         if (m_pokemod->itemType(i)->name() == name)
-            return new ItemTypeWrapper(m_pokemod->itemType(i), const_cast<PokemodWrapper*>(this));
+            return ItemTypeWrapper::create(m_pokemod->itemType(i), this);
     }
     return NULL;
 }
 
-inline const MapWrapper* PokemodWrapper::map(const QString& name) const
+inline MapWrapper* PokemodWrapper::map(const QString& name)
 {
     for (int i = 0; i < m_pokemod->mapCount(); ++i)
     {
         if (m_pokemod->map(i)->name() == name)
-            return new MapWrapper(m_pokemod->map(i), const_cast<PokemodWrapper*>(this));
+            return MapWrapper::create(m_pokemod->map(i), this);
     }
     return NULL;
 }
 
-inline const MoveWrapper* PokemodWrapper::move(const QString& name) const
+inline MoveWrapper* PokemodWrapper::move(const QString& name)
 {
     for (int i = 0; i < m_pokemod->moveCount(); ++i)
     {
         if (m_pokemod->move(i)->name() == name)
-            return new MoveWrapper(m_pokemod->move(i), const_cast<PokemodWrapper*>(this));
+            return MoveWrapper::create(m_pokemod->move(i), this);
     }
     return NULL;
 }
 
-inline const NatureWrapper* PokemodWrapper::nature(const QString& name) const
+inline NatureWrapper* PokemodWrapper::nature(const QString& name)
 {
     for (int i = 0; i < m_pokemod->natureCount(); ++i)
     {
         if (m_pokemod->nature(i)->name() == name)
-            return new NatureWrapper(m_pokemod->nature(i), const_cast<PokemodWrapper*>(this));
+            return NatureWrapper::create(m_pokemod->nature(i), this);
     }
     return NULL;
 }
 
-inline const SoundWrapper* PokemodWrapper::sound(const QString& name) const
+inline SkinWrapper* PokemodWrapper::skin(const QString& name)
+{
+    for (int i = 0; i < m_pokemod->skinCount(); ++i)
+    {
+        if (m_pokemod->skin(i)->name() == name)
+            return SkinWrapper::create(m_pokemod->skin(i), this);
+    }
+    return NULL;
+}
+
+inline SoundWrapper* PokemodWrapper::sound(const QString& name)
 {
     for (int i = 0; i < m_pokemod->soundCount(); ++i)
     {
         if (m_pokemod->sound(i)->name() == name)
-            return new SoundWrapper(m_pokemod->sound(i), const_cast<PokemodWrapper*>(this));
+            return SoundWrapper::create(m_pokemod->sound(i), this);
     }
     return NULL;
 }
 
-inline const SpeciesWrapper* PokemodWrapper::species(const QString& name) const
+inline SpeciesWrapper* PokemodWrapper::species(const QString& name)
 {
     for (int i = 0; i < m_pokemod->speciesCount(); ++i)
     {
         if (m_pokemod->species(i)->name() == name)
-            return new SpeciesWrapper(m_pokemod->species(i), const_cast<PokemodWrapper*>(this));
+            return SpeciesWrapper::create(m_pokemod->species(i), this);
     }
     return NULL;
 }
 
-inline const SpriteWrapper* PokemodWrapper::sprite(const QString& name) const
+inline SpriteWrapper* PokemodWrapper::sprite(const QString& name)
 {
     for (int i = 0; i < m_pokemod->spriteCount(); ++i)
     {
         if (m_pokemod->sprite(i)->name() == name)
-            return new SpriteWrapper(m_pokemod->sprite(i), const_cast<PokemodWrapper*>(this));
+            return SpriteWrapper::create(m_pokemod->sprite(i), this);
     }
     return NULL;
 }
 
-inline const StatusWrapper* PokemodWrapper::status(const QString& name) const
+inline StatusWrapper* PokemodWrapper::status(const QString& name)
 {
     for (int i = 0; i < m_pokemod->statusCount(); ++i)
     {
         if (m_pokemod->status(i)->name() == name)
-            return new StatusWrapper(m_pokemod->status(i), const_cast<PokemodWrapper*>(this));
+            return StatusWrapper::create(m_pokemod->status(i), this);
     }
     return NULL;
 }
 
-inline const StoreWrapper* PokemodWrapper::store(const QString& name) const
+inline StoreWrapper* PokemodWrapper::store(const QString& name)
 {
     for (int i = 0; i < m_pokemod->storeCount(); ++i)
     {
         if (m_pokemod->store(i)->name() == name)
-            return new StoreWrapper(m_pokemod->store(i), const_cast<PokemodWrapper*>(this));
+            return StoreWrapper::create(m_pokemod->store(i), this);
     }
     return NULL;
 }
 
-inline const TileWrapper* PokemodWrapper::tile(const QString& name) const
+inline TileWrapper* PokemodWrapper::tile(const QString& name)
 {
     for (int i = 0; i < m_pokemod->tileCount(); ++i)
     {
         if (m_pokemod->tile(i)->name() == name)
-            return new TileWrapper(m_pokemod->tile(i), const_cast<PokemodWrapper*>(this));
+            return TileWrapper::create(m_pokemod->tile(i), this);
     }
     return NULL;
 }
 
-inline const TimeWrapper* PokemodWrapper::time(const QString& name) const
+inline TimeWrapper* PokemodWrapper::time(const QString& name)
 {
     for (int i = 0; i < m_pokemod->timeCount(); ++i)
     {
         if (m_pokemod->time(i)->name() == name)
-            return new TimeWrapper(m_pokemod->time(i), const_cast<PokemodWrapper*>(this));
+            return TimeWrapper::create(m_pokemod->time(i), this);
     }
     return NULL;
 }
 
-inline const TrainerWrapper* PokemodWrapper::trainer(const QString& name) const
+inline TrainerWrapper* PokemodWrapper::trainer(const QString& name)
 {
     for (int i = 0; i < m_pokemod->trainerCount(); ++i)
     {
         if (m_pokemod->trainer(i)->name() == name)
-            return new TrainerWrapper(m_pokemod->trainer(i), const_cast<PokemodWrapper*>(this));
+            return TrainerWrapper::create(m_pokemod->trainer(i), this);
     }
     return NULL;
 }
 
-inline const TypeWrapper* PokemodWrapper::type(const QString& name) const
+inline TypeWrapper* PokemodWrapper::type(const QString& name)
 {
     for (int i = 0; i < m_pokemod->typeCount(); ++i)
     {
         if (m_pokemod->type(i)->name() == name)
-            return new TypeWrapper(m_pokemod->type(i), const_cast<PokemodWrapper*>(this));
+            return TypeWrapper::create(m_pokemod->type(i), this);
     }
     return NULL;
 }
 
-inline const WeatherWrapper* PokemodWrapper::weather(const QString& name) const
+inline WeatherWrapper* PokemodWrapper::weather(const QString& name)
 {
     for (int i = 0; i < m_pokemod->weatherCount(); ++i)
     {
         if (m_pokemod->weather(i)->name() == name)
-            return new WeatherWrapper(m_pokemod->weather(i), const_cast<PokemodWrapper*>(this));
+            return WeatherWrapper::create(m_pokemod->weather(i), this);
     }
     return NULL;
 }