Made the rest of the widgets use pimpl

32 files changed, 1384 insertions, 1335 deletions

diff --git a/sigmodr/widgets/BadgeUI.cpp b/sigmodr/widgets/BadgeUI.cpp
index bb6cb1b0..3f4f98c9 100644
--- a/sigmodr/widgets/BadgeUI.cpp
+++ b/sigmodr/widgets/BadgeUI.cpp
@@ -134,6 +134,7 @@ void BadgeUI::Private::refreshGui()
     }
     else
         ui_stat->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
+    ui_statMultiplier->setEnabled(false);
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     ui_stat->setItem(ST_Attack - ST_Attack, 0, item);
@@ -177,7 +178,6 @@ void BadgeUI::Private::resetGui()
     }
     else
         ui_stat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_Special), 'g', 7));
-    ui_statMultiplier->setValue(m_badge->stat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>()));
 }
 
 void BadgeUI::Private::nameChanged(const QString& name)
@@ -206,10 +206,12 @@ void BadgeUI::Private::badgeChanged(const int badge)
 
 void BadgeUI::Private::statChanged(const int row)
 {
+    ui_statMultiplier->setEnabled(true);
     ui_statMultiplier->setValue(m_badge->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
 void BadgeUI::Private::statMultiplierChanged(const Fraction& multiplier)
 {
     m_badge->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
+    emit(changed());
 }
diff --git a/sigmodr/widgets/CoinListItemUI_p.h b/sigmodr/widgets/CoinListItemUI_p.h
index 4f3e3f38..e61684b4 100644
--- a/sigmodr/widgets/CoinListItemUI_p.h
+++ b/sigmodr/widgets/CoinListItemUI_p.h
@@ -45,7 +45,6 @@ class CoinListItemUI::Private : public ObjectUIPrivate
         
         Sigmod::CoinListItem* m_item;
     public slots:
-        void refreshGui();
         void resetGui();
     protected slots:
         void typeChanged(const int type);
diff --git a/sigmodr/widgets/EggGroupUI_p.h b/sigmodr/widgets/EggGroupUI_p.h
index e16869d0..7b855bba 100644
--- a/sigmodr/widgets/EggGroupUI_p.h
+++ b/sigmodr/widgets/EggGroupUI_p.h
@@ -43,7 +43,6 @@ class EggGroupUI::Private : public ObjectUIPrivate
         
         Sigmod::EggGroup* m_eggGroup;
     public slots:
-        void refreshGui();
         void resetGui();
     protected slots:
         void nameChanged(const QString& name);
diff --git a/sigmodr/widgets/GameUI.cpp b/sigmodr/widgets/GameUI.cpp
index ab6153ee..75a6a500 100644
--- a/sigmodr/widgets/GameUI.cpp
+++ b/sigmodr/widgets/GameUI.cpp
@@ -150,7 +150,6 @@ void GameUI::Private::startScriptChanged(const Script& startScript)
 
 void GameUI::Private::typechartChanged(const QModelIndex& index)
 {
-    m_changing = true;
     ui_effectiveness->setEnabled(true);
     ui_labelTypes->setText(QString("%1 vs. %2").arg(m_game->type(index.row())->name()).arg(m_game->type(index.column())->name()));
     ui_effectiveness->setValue(ui_typechart->model()->data(index, Qt::EditRole).value<Fraction>());
@@ -158,11 +157,6 @@ void GameUI::Private::typechartChanged(const QModelIndex& index)
 
 void GameUI::Private::effectivenessChanged(const Fraction& multiplier)
 {
-    if (m_changing)
-    {
-        m_changing = false;
-        return;
-    }
     ui_typechart->model()->setData(ui_typechart->currentIndex(), QVariant::fromValue(multiplier), Qt::EditRole);
     emit(changed());
 }
diff --git a/sigmodr/widgets/GameUI_p.h b/sigmodr/widgets/GameUI_p.h
index 189a8a1d..14ffe1c4 100644
--- a/sigmodr/widgets/GameUI_p.h
+++ b/sigmodr/widgets/GameUI_p.h
@@ -79,8 +79,6 @@ class GameUI::Private : public ObjectUIPrivate
         QTableView* ui_typechart;
         QLabel* ui_labelTypes;
         CoreWidgets::FractionWidget* ui_effectiveness;
-        
-        bool m_changing;
 };
 }
 }
diff --git a/sigmodr/widgets/ItemUI.cpp b/sigmodr/widgets/ItemUI.cpp
index 26234204..23284975 100644
--- a/sigmodr/widgets/ItemUI.cpp
+++ b/sigmodr/widgets/ItemUI.cpp
@@ -133,7 +133,7 @@ void ItemUI::Private::typeChanged(const int type)
 {
     if (0 <= type)
     {
-        const ItemType* itemType = m_item->game()->itemTypeById(m_item->type());
+        const ItemType* itemType = m_item->game()->itemType(type);
         m_item->setType(itemType->id());
         ui_weight->setMaximum(itemType->maxWeight());
     }
diff --git a/sigmodr/widgets/MapEffectUI.cpp b/sigmodr/widgets/MapEffectUI.cpp
index 075bc96f..f2565a7e 100644
--- a/sigmodr/widgets/MapEffectUI.cpp
+++ b/sigmodr/widgets/MapEffectUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapEffectUI.h"
+#include "MapEffectUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -32,10 +33,7 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -43,76 +41,86 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 MapEffectUI::MapEffectUI(MapEffect* effect, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(effect, parent),
+        d(new Private(new MapEffect(*effect)))
 {
-    setObjects(effect, new MapEffect(*effect));
+    setWidget(d->makeWidgets(this));
 }
 
-void Sigmodr::Widgets::MapEffectUI::initGui()
+void MapEffectUI::apply()
 {
-    QFile file(":/gui/mapeffect.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_skin = formWidget->findChild<KComboBox*>("varSkin");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    ui_isGhost = formWidget->findChild<QCheckBox*>("varIsGhost");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_skin, SIGNAL(currentIndexChanged(int)), this, SLOT(skinChanged(int)));
-    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    connect(ui_isGhost, SIGNAL(toggled(bool)), this, SLOT(isGhostChanged(bool)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<MapEffect*>(m_object) = *d->m_effect;
+    ObjectUI::apply();
 }
 
-void MapEffectUI::refreshGui()
+void MapEffectUI::discard()
 {
-    for (int i = 0; i < game()->skinCount(); ++i)
-        ui_skin->addItem(game()->skin(i)->name());
+    *d->m_effect = *qobject_cast<MapEffect*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void MapEffectUI::setGui()
+MapEffectUI::Private::Private(MapEffect* effect) :
+        ObjectUIPrivate(effect),
+        m_effect(effect)
 {
-    ui_name->setText(qobject_cast<MapEffect*>(modified())->name());
-    ui_skin->setCurrentIndex(game()->skinIndex(qobject_cast<MapEffect*>(modified())->skin()));
-    ui_script->setValue(qobject_cast<MapEffect*>(modified())->script());
-    ui_isGhost->setCheckState(qobject_cast<MapEffect*>(modified())->isGhost() ? Qt::Checked : Qt::Unchecked);
 }
 
-void MapEffectUI::apply()
+MapEffectUI::Private::~Private()
 {
-    *qobject_cast<MapEffect*>(original()) = *qobject_cast<MapEffect*>(modified());
-    emit(changed(false));
+    delete m_effect;
 }
 
-void MapEffectUI::discard()
+QWidget* MapEffectUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/mapeffect.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_skin = form->findChild<KComboBox*>("varSkin");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    ui_isGhost = form->findChild<QCheckBox*>("varIsGhost");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_skin, SIGNAL(currentIndexChanged(int)), this, SLOT(skinChanged(int)));
+    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
+    connect(ui_isGhost, SIGNAL(toggled(bool)), this, SLOT(isGhostChanged(bool)));
+    return form;
+}
+
+void MapEffectUI::Private::refreshGui()
+{
+    const bool blocked = ui_skin->blockSignals(true);
+    ui_skin->clear();
+    for (int i = 0; i < m_effect->game()->skinCount(); ++i)
+        ui_skin->addItem(m_effect->game()->skin(i)->name());
+    ui_skin->blockSignals(blocked);
+}
+
+void MapEffectUI::Private::resetGui()
 {
-    *qobject_cast<MapEffect*>(modified()) = *qobject_cast<MapEffect*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_effect->name());
+    ui_skin->setCurrentIndex(m_effect->game()->skinIndex(m_effect->skin()));
+    ui_script->setValue(m_effect->script());
+    ui_isGhost->setCheckState(m_effect->isGhost() ? Qt::Checked : Qt::Unchecked);
 }
 
-void MapEffectUI::nameChanged(const QString& name)
+void MapEffectUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<MapEffect*>(modified())->setName(name);
+    m_effect->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void MapEffectUI::skinChanged(const int skin)
+void MapEffectUI::Private::skinChanged(const int skin)
 {
     if (0 <= skin)
-        qobject_cast<MapEffect*>(modified())->setSkin(game()->skin(skin)->id());
+        m_effect->setSkin(m_effect->game()->skin(skin)->id());
 }
 
-void MapEffectUI::scriptChanged(const Script& script)
+void MapEffectUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<MapEffect*>(modified())->setScript(script);
+    m_effect->setScript(script);
 }
 
-void MapEffectUI::isGhostChanged(const bool isGhost)
+void MapEffectUI::Private::isGhostChanged(const bool isGhost)
 {
-    qobject_cast<MapEffect*>(modified())->setIsGhost(isGhost);
+    m_effect->setIsGhost(isGhost);
 }
diff --git a/sigmodr/widgets/MapEffectUI_p.h b/sigmodr/widgets/MapEffectUI_p.h
index b285e12c..2f68da16 100644
--- a/sigmodr/widgets/MapEffectUI_p.h
+++ b/sigmodr/widgets/MapEffectUI_p.h
@@ -56,9 +56,6 @@ class MapEffectUI::Private : public ObjectUIPrivate
     public slots:
         void refreshGui();
         void resetGui();
-    public slots:
-        void apply();
-        void discard();
     protected slots:
         void nameChanged(const QString& name);
         void skinChanged(const int skin);
diff --git a/sigmodr/widgets/MapTrainerTeamMemberUI.cpp b/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
index 3148bc61..9b15bd78 100644
--- a/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
+++ b/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapTrainerTeamMemberUI.h"
+#include "MapTrainerTeamMemberUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Ability.h>
@@ -35,39 +36,58 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QGroupBox>
 #include <QtGui/QListWidgetItem>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 MapTrainerTeamMemberUI::MapTrainerTeamMemberUI(MapTrainerTeamMember* teamMember, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(teamMember, parent),
+        d(new Private(new MapTrainerTeamMember(*teamMember)))
 {
-    setObjects(teamMember, new MapTrainerTeamMember(*teamMember));
+    setWidget(d->makeWidgets(this));
 }
 
-void MapTrainerTeamMemberUI::initGui()
+void MapTrainerTeamMemberUI::apply()
+{
+    *qobject_cast<MapTrainerTeamMember*>(m_object) = *d->m_teamMember;
+    ObjectUI::apply();
+}
+
+void MapTrainerTeamMemberUI::discard()
+{
+    *d->m_teamMember = *qobject_cast<MapTrainerTeamMember*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+MapTrainerTeamMemberUI::Private::Private(MapTrainerTeamMember* teamMember) :
+        ObjectUIPrivate(teamMember),
+        m_teamMember(teamMember)
+{
+}
+
+MapTrainerTeamMemberUI::Private::~Private()
 {
-    QFile file(":/gui/maptrainerteammember.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_species = formWidget->findChild<KComboBox*>("varSpecies");
-    ui_level = formWidget->findChild<KIntNumInput*>("varLevel");
-    ui_abilities = formWidget->findChild<KActionSelector*>("varAbilities");
-    ui_boxItems = formWidget->findChild<QGroupBox*>("boxItems");
-    ui_items = formWidget->findChild<KActionSelector*>("varItems");
-    ui_itemCount = formWidget->findChild<KIntNumInput*>("varItemCount");
-    ui_moves = formWidget->findChild<KActionSelector*>("varMoves");
-    ui_natures = formWidget->findChild<KActionSelector*>("varNatures");
+    delete m_teamMember;
+}
+
+QWidget* MapTrainerTeamMemberUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/maptrainerteammember.ui", widget);
+    ui_species = form->findChild<KComboBox*>("varSpecies");
+    ui_level = form->findChild<KIntNumInput*>("varLevel");
+    ui_abilities = form->findChild<KActionSelector*>("varAbilities");
+    ui_boxItems = form->findChild<QGroupBox*>("boxItems");
+    ui_items = form->findChild<KActionSelector*>("varItems");
+    ui_itemCount = form->findChild<KIntNumInput*>("varItemCount");
+    ui_moves = form->findChild<KActionSelector*>("varMoves");
+    ui_natures = form->findChild<KActionSelector*>("varNatures");
     connect(ui_species, SIGNAL(currentIndexChanged(int)), this, SLOT(speciesChanged(int)));
     connect(ui_level, SIGNAL(valueChanged(int)), this, SLOT(levelChanged(int)));
-    connect(ui_abilities, SIGNAL(added(QListWidgetItem*)), this, SLOT(abilityAdded(QListWidgetItem*)));
-    connect(ui_abilities, SIGNAL(removed(QListWidgetItem*)), this, SLOT(abilityRemoved(QListWidgetItem*)));
+    connect(ui_abilities, SIGNAL(added(QListWidgetItem*)), this, SLOT(teamMemberAdded(QListWidgetItem*)));
+    connect(ui_abilities, SIGNAL(removed(QListWidgetItem*)), this, SLOT(teamMemberRemoved(QListWidgetItem*)));
     connect(ui_items, SIGNAL(added(QListWidgetItem*)), this, SLOT(itemAdded(QListWidgetItem*)));
     connect(ui_items, SIGNAL(removed(QListWidgetItem*)), this, SLOT(itemRemoved(QListWidgetItem*)));
     connect(ui_itemCount, SIGNAL(valueChanged(int)), this, SLOT(itemCountChanged(int)));
@@ -76,49 +96,48 @@ void MapTrainerTeamMemberUI::initGui()
     connect(ui_natures, SIGNAL(added(QListWidgetItem*)), this, SLOT(natureAdded(QListWidgetItem*)));
     connect(ui_natures, SIGNAL(removed(QListWidgetItem*)), this, SLOT(natureRemoved(QListWidgetItem*)));
     connect(ui_items->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(selectedItemChanged(QListWidgetItem*)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void MapTrainerTeamMemberUI::refreshGui()
+void MapTrainerTeamMemberUI::Private::refreshGui()
 {
     const bool blockedSpecies = ui_species->blockSignals(true);
     ui_species->clear();
-    for (int i = 0; i < game()->speciesCount(); ++i)
-        ui_species->addItem(game()->species(i)->name());
+    for (int i = 0; i < m_teamMember->game()->speciesCount(); ++i)
+        ui_species->addItem(m_teamMember->game()->species(i)->name());
     ui_species->blockSignals(blockedSpecies);
-    ui_level->setMaximum(game()->rules()->maxLevel());
+    ui_level->setMaximum(m_teamMember->game()->rules()->maxLevel());
     const bool blockedAbilities = ui_abilities->blockSignals(true);
     ui_abilities->availableListWidget()->clear();
     ui_abilities->selectedListWidget()->clear();
-    for (int i = 0; i < game()->abilityCount(); ++i)
+    for (int i = 0; i < m_teamMember->game()->abilityCount(); ++i)
     {
-        const Ability* ability = game()->ability(i);
+        const Ability* ability = m_teamMember->game()->ability(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(ability->name(), ui_abilities->availableListWidget());
         widgetItem->setData(Qt::UserRole, ability->id());
     }
     ui_abilities->blockSignals(blockedAbilities);
     ui_abilities->setButtonsEnabled();
-    ui_abilities->setEnabled(game()->rules()->maxAbilities());
+    ui_abilities->setEnabled(m_teamMember->game()->rules()->maxAbilities());
     const bool blockedItems = ui_items->blockSignals(true);
     ui_items->availableListWidget()->clear();
     ui_items->selectedListWidget()->clear();
-    for (int i = 0; i < game()->itemCount(); ++i)
+    for (int i = 0; i < m_teamMember->game()->itemCount(); ++i)
     {
-        const Item* item = game()->item(i);
+        const Item* item = m_teamMember->game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), ui_items->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
     ui_items->blockSignals(blockedItems);
     ui_items->setButtonsEnabled();
-    ui_boxItems->setEnabled(game()->rules()->maxHeldItems());
+    ui_itemCount->setEnabled(false);
+    ui_boxItems->setEnabled(m_teamMember->game()->rules()->maxHeldItems());
     const bool blockedMoves = ui_moves->blockSignals(true);
     ui_moves->availableListWidget()->clear();
     ui_moves->selectedListWidget()->clear();
-    for (int i = 0; i < game()->moveCount(); ++i)
+    for (int i = 0; i < m_teamMember->game()->moveCount(); ++i)
     {
-        const Move* move = game()->move(i);
+        const Move* move = m_teamMember->game()->move(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(move->name(), ui_moves->availableListWidget());
         widgetItem->setData(Qt::UserRole, move->id());
     }
@@ -127,161 +146,136 @@ void MapTrainerTeamMemberUI::refreshGui()
     const bool blockedNatures = ui_natures->blockSignals(true);
     ui_natures->availableListWidget()->clear();
     ui_natures->selectedListWidget()->clear();
-    for (int i = 0; i < game()->natureCount(); ++i)
+    for (int i = 0; i < m_teamMember->game()->natureCount(); ++i)
     {
-        const Nature* nature = game()->nature(i);
+        const Nature* nature = m_teamMember->game()->nature(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(nature->name(), ui_natures->availableListWidget());
         widgetItem->setData(Qt::UserRole, nature->id());
     }
     ui_natures->blockSignals(blockedNatures);
     ui_natures->setButtonsEnabled();
-    ui_natures->setEnabled(game()->rules()->maxNatures());
+    ui_natures->setEnabled(m_teamMember->game()->rules()->maxNatures());
 }
 
-void MapTrainerTeamMemberUI::setGui()
+void MapTrainerTeamMemberUI::Private::resetGui()
 {
-    ui_species->setCurrentIndex(game()->speciesIndex(qobject_cast<MapTrainerTeamMember*>(modified())->species()));
-    ui_level->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->level());
+    ui_species->setCurrentIndex(m_teamMember->game()->speciesIndex(m_teamMember->species()));
+    ui_level->setValue(m_teamMember->level());
     for (int i = 0; i < ui_abilities->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_abilities->availableListWidget()->item(i);
-        if (qobject_cast<MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_teamMember->ability(widgetItem->data(Qt::UserRole).toInt()))
             ui_abilities->selectedListWidget()->addItem(ui_abilities->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_abilities->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_abilities->selectedListWidget()->item(i);
-        if (!qobject_cast<MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_teamMember->ability(widgetItem->data(Qt::UserRole).toInt()))
             ui_abilities->availableListWidget()->addItem(ui_abilities->selectedListWidget()->takeItem(i--));
     }
     ui_abilities->setButtonsEnabled();
     for (int i = 0; i < ui_items->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->availableListWidget()->item(i);
-        if (qobject_cast<MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_teamMember->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->selectedListWidget()->addItem(ui_items->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_items->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->selectedListWidget()->item(i);
-        if (!qobject_cast<MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_teamMember->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->availableListWidget()->addItem(ui_items->selectedListWidget()->takeItem(i--));
     }
     ui_items->setButtonsEnabled();
-    QListWidgetItem* selectedItem = ui_items->selectedListWidget()->currentItem();
-    if (selectedItem)
-        ui_itemCount->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->item(selectedItem->data(Qt::UserRole).toInt()));
     for (int i = 0; i < ui_moves->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_moves->availableListWidget()->item(i);
-        if (qobject_cast<MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_teamMember->move(widgetItem->data(Qt::UserRole).toInt()))
             ui_moves->selectedListWidget()->addItem(ui_moves->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_moves->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_moves->selectedListWidget()->item(i);
-        if (!qobject_cast<MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_teamMember->move(widgetItem->data(Qt::UserRole).toInt()))
             ui_moves->availableListWidget()->addItem(ui_moves->selectedListWidget()->takeItem(i--));
     }
     ui_moves->setButtonsEnabled();
     for (int i = 0; i < ui_natures->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_natures->availableListWidget()->item(i);
-        if (qobject_cast<MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_teamMember->nature(widgetItem->data(Qt::UserRole).toInt()))
             ui_natures->selectedListWidget()->addItem(ui_natures->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_natures->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_natures->selectedListWidget()->item(i);
-        if (!qobject_cast<MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_teamMember->nature(widgetItem->data(Qt::UserRole).toInt()))
             ui_natures->availableListWidget()->addItem(ui_natures->selectedListWidget()->takeItem(i--));
     }
     ui_natures->setButtonsEnabled();
 }
 
-void MapTrainerTeamMemberUI::apply()
-{
-    *qobject_cast<MapTrainerTeamMember*>(original()) = *qobject_cast<MapTrainerTeamMember*>(modified());
-    emit(changed(false));
-}
-
-void MapTrainerTeamMemberUI::discard()
-{
-    *qobject_cast<MapTrainerTeamMember*>(modified()) = *qobject_cast<MapTrainerTeamMember*>(original());
-    setGui();
-    emit(changed(false));
-}
-
-void MapTrainerTeamMemberUI::speciesChanged(const int species)
+void MapTrainerTeamMemberUI::Private::speciesChanged(const int species)
 {
     if (0 <= species)
-        qobject_cast<MapTrainerTeamMember*>(modified())->setSpecies(game()->species(species)->id());
+        m_teamMember->setSpecies(m_teamMember->game()->species(species)->id());
 }
 
-void MapTrainerTeamMemberUI::levelChanged(const int level)
+void MapTrainerTeamMemberUI::Private::levelChanged(const int level)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setLevel(level);
+    m_teamMember->setLevel(level);
 }
 
-void MapTrainerTeamMemberUI::abilityAdded(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::abilityAdded(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_teamMember->setAbility(item->data(Qt::UserRole).toInt(), true);
 }
 
-void MapTrainerTeamMemberUI::abilityRemoved(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::abilityRemoved(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_teamMember->setAbility(item->data(Qt::UserRole).toInt(), false);
 }
 
-void MapTrainerTeamMemberUI::itemAdded(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::itemAdded(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
-    setGui();
+    m_teamMember->setItem(item->data(Qt::UserRole).toInt(), 1);
 }
 
-void MapTrainerTeamMemberUI::itemRemoved(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::itemRemoved(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
-    setGui();
+    m_teamMember->setItem(item->data(Qt::UserRole).toInt(), 0);
 }
 
-void MapTrainerTeamMemberUI::itemChanged(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::itemChanged(QListWidgetItem* item)
 {
     if (item)
-        ui_itemCount->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->item(item->data(Qt::UserRole).toInt()));
-    else
-        ui_itemCount->setEnabled(false);
+        ui_itemCount->setValue(m_teamMember->item(item->data(Qt::UserRole).toInt()));
+    ui_itemCount->setEnabled(!!item);
 }
 
-void MapTrainerTeamMemberUI::itemCountChanged(const int itemCount)
+void MapTrainerTeamMemberUI::Private::itemCountChanged(const int itemCount)
 {
     QListWidgetItem* item = ui_items->selectedListWidget()->currentItem();
-    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemCount);
-    setGui();
+    m_teamMember->setItem(item->data(Qt::UserRole).toInt(), itemCount);
+    emit(changed());
 }
 
-void MapTrainerTeamMemberUI::moveAdded(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::moveAdded(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_teamMember->setMove(item->data(Qt::UserRole).toInt(), true);
 }
 
-void MapTrainerTeamMemberUI::moveRemoved(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::moveRemoved(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_teamMember->setMove(item->data(Qt::UserRole).toInt(), false);
 }
 
-void MapTrainerTeamMemberUI::natureAdded(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::natureAdded(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_teamMember->setNature(item->data(Qt::UserRole).toInt(), true);
 }
 
-void MapTrainerTeamMemberUI::natureRemoved(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::Private::natureRemoved(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_teamMember->setNature(item->data(Qt::UserRole).toInt(), false);
 }
diff --git a/sigmodr/widgets/MapTrainerUI.cpp b/sigmodr/widgets/MapTrainerUI.cpp
index fcb46cb1..d5d11b26 100644
--- a/sigmodr/widgets/MapTrainerUI.cpp
+++ b/sigmodr/widgets/MapTrainerUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapTrainerUI.h"
+#include "MapTrainerUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -36,11 +37,8 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QListWidget>
 #include <QtGui/QListWidgetItem>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -48,49 +46,69 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 MapTrainerUI::MapTrainerUI(MapTrainer* trainer, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(trainer, parent),
+        d(new Private(new MapTrainer(*trainer)))
 {
-    setObjects(trainer, new MapTrainer(*trainer));
+    setWidget(d->makeWidgets(this));
 }
 
-void MapTrainerUI::initGui()
+void MapTrainerUI::apply()
+{
+    *qobject_cast<MapTrainer*>(m_object) = *d->m_trainer;
+    ObjectUI::apply();
+}
+
+void MapTrainerUI::discard()
+{
+    *d->m_trainer = *qobject_cast<MapTrainer*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+MapTrainerUI::Private::Private(MapTrainer* trainer) :
+        ObjectUIPrivate(trainer),
+        m_trainer(trainer)
+{
+}
+
+MapTrainerUI::Private::~Private()
 {
-    QFile file(":/gui/maptrainer.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_trainerClass = formWidget->findChild<KComboBox*>("varTrainerClass");
-    ui_numberFight = formWidget->findChild<KIntNumInput*>("varNumberFight");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    ui_leadTeamMembers = formWidget->findChild<KActionSelector*>("varLeadTeamMembers");
+    delete m_trainer;
+}
+
+QWidget* MapTrainerUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/maptrainer.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_trainerClass = form->findChild<KComboBox*>("varTrainerClass");
+    ui_numberFight = form->findChild<KIntNumInput*>("varNumberFight");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    ui_leadTeamMembers = form->findChild<KActionSelector*>("varLeadTeamMembers");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_trainerClass, SIGNAL(currentIndexChanged(int)), this, SLOT(trainerClassChanged(int)));
     connect(ui_numberFight, SIGNAL(valueChanged(int)), this, SLOT(numberFightChanged(int)));
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
     connect(ui_leadTeamMembers, SIGNAL(added(QListWidgetItem*)), this, SLOT(leadTeamMemberAdded(QListWidgetItem*)));
     connect(ui_leadTeamMembers, SIGNAL(removed(QListWidgetItem*)), this, SLOT(leadTeamMemberRemoved(QListWidgetItem*)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void MapTrainerUI::refreshGui()
+void MapTrainerUI::Private::refreshGui()
 {
     const bool blockedTrainerClass = ui_trainerClass->blockSignals(true);
     ui_trainerClass->clear();
-    for (int i = 0; i < game()->trainerCount(); ++i)
-        ui_trainerClass->addItem(game()->trainer(i)->name());
+    for (int i = 0; i < m_trainer->game()->trainerCount(); ++i)
+        ui_trainerClass->addItem(m_trainer->game()->trainer(i)->name());
     ui_trainerClass->blockSignals(blockedTrainerClass);
-    ui_numberFight->setMaximum(game()->rules()->maxFight());
+    ui_numberFight->setMaximum(m_trainer->game()->rules()->maxFight());
     const bool blockedLeadTeamMember = ui_leadTeamMembers->blockSignals(true);
     ui_leadTeamMembers->availableListWidget()->clear();
     ui_leadTeamMembers->selectedListWidget()->clear();
-    for (int i = 0; i < qobject_cast<MapTrainer*>(original())->teamMemberCount(); ++i)
+    for (int i = 0; i < m_trainer->teamMemberCount(); ++i)
     {
         QString speciesName;
-        const MapTrainerTeamMember* teamMember = qobject_cast<MapTrainer*>(original())->teamMember(i);
-        const Species* species = game()->species(teamMember->species());
+        const MapTrainerTeamMember* teamMember = m_trainer->teamMember(i);
+        const Species* species = m_trainer->game()->species(teamMember->species());
         speciesName = species ? species->name() : "(Invalid)";
         QListWidgetItem* widgetItem = new QListWidgetItem(QString("%1 level %2 (%3)").arg(speciesName, teamMember->level(), i), ui_leadTeamMembers->availableListWidget());
         widgetItem->setData(Qt::UserRole, teamMember->id());
@@ -99,71 +117,56 @@ void MapTrainerUI::refreshGui()
     ui_leadTeamMembers->setButtonsEnabled();
 }
 
-void MapTrainerUI::setGui()
+void MapTrainerUI::Private::resetGui()
 {
-    ui_name->setText(qobject_cast<MapTrainer*>(modified())->name());
-    ui_trainerClass->setCurrentIndex(game()->trainerIndex(qobject_cast<MapTrainer*>(modified())->trainerClass()));
-    ui_numberFight->setValue(qobject_cast<MapTrainer*>(modified())->numberFight());
-    ui_script->setValue(qobject_cast<MapTrainer*>(modified())->script());
+    ui_name->setText(m_trainer->name());
+    ui_trainerClass->setCurrentIndex(m_trainer->game()->trainerIndex(m_trainer->trainerClass()));
+    ui_numberFight->setValue(m_trainer->numberFight());
+    ui_script->setValue(m_trainer->script());
     for (int i = 0; i < ui_leadTeamMembers->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_leadTeamMembers->availableListWidget()->item(i);
-        if (qobject_cast<MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_trainer->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
             ui_leadTeamMembers->selectedListWidget()->addItem(ui_leadTeamMembers->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_leadTeamMembers->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_leadTeamMembers->selectedListWidget()->item(i);
-        if (!qobject_cast<MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_trainer->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
             ui_leadTeamMembers->availableListWidget()->addItem(ui_leadTeamMembers->selectedListWidget()->takeItem(i--));
     }
     ui_leadTeamMembers->setButtonsEnabled();
 }
 
-void MapTrainerUI::apply()
-{
-    *qobject_cast<MapTrainer*>(original()) = *qobject_cast<MapTrainer*>(modified());
-    emit(changed(false));
-}
-
-void MapTrainerUI::discard()
-{
-    *qobject_cast<MapTrainer*>(modified()) = *qobject_cast<MapTrainer*>(original());
-    setGui();
-    emit(changed(false));
-}
-
-void MapTrainerUI::nameChanged(const QString& name)
+void MapTrainerUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<MapTrainer*>(modified())->setName(name);
+    m_trainer->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void MapTrainerUI::trainerClassChanged(const int trainerClass)
+void MapTrainerUI::Private::trainerClassChanged(const int trainerClass)
 {
     if (0 <= trainerClass)
-        qobject_cast<MapTrainer*>(modified())->setTrainerClass(game()->trainer(trainerClass)->id());
+        m_trainer->setTrainerClass(m_trainer->game()->trainer(trainerClass)->id());
 }
 
-void MapTrainerUI::numberFightChanged(const int numberFight)
+void MapTrainerUI::Private::numberFightChanged(const int numberFight)
 {
-    qobject_cast<MapTrainer*>(modified())->setNumberFight(numberFight);
+    m_trainer->setNumberFight(numberFight);
 }
 
-void MapTrainerUI::scriptChanged(const Script& script)
+void MapTrainerUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<MapTrainer*>(modified())->setScript(script);
+    m_trainer->setScript(script);
 }
 
-void MapTrainerUI::leadTeamMemberAdded(QListWidgetItem* item)
+void MapTrainerUI::Private::leadTeamMemberAdded(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_trainer->setLeadTeamMember(item->data(Qt::UserRole).toInt(), true);
 }
 
-void MapTrainerUI::leadTeamMemberRemoved(QListWidgetItem* item)
+void MapTrainerUI::Private::leadTeamMemberRemoved(QListWidgetItem* item)
 {
-    qobject_cast<MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_trainer->setLeadTeamMember(item->data(Qt::UserRole).toInt(), false);
 }
diff --git a/sigmodr/widgets/MapTrainerUI_p.h b/sigmodr/widgets/MapTrainerUI_p.h
index 42b2b3fc..a96d351a 100644
--- a/sigmodr/widgets/MapTrainerUI_p.h
+++ b/sigmodr/widgets/MapTrainerUI_p.h
@@ -49,12 +49,12 @@ class MapTrainerUI::Private : public ObjectUIPrivate
     Q_OBJECT
     
     public:
-        Private(Sigmod::Trainer* trainer);
+        Private(Sigmod::MapTrainer* trainer);
         ~Private();
         
         QWidget* makeWidgets(ObjectUI* widget);
         
-        Sigmod::Trainer* m_trainer;
+        Sigmod::MapTrainer* m_trainer;
     public slots:
         void refreshGui();
         void resetGui();
diff --git a/sigmodr/widgets/MapWarpUI.cpp b/sigmodr/widgets/MapWarpUI.cpp
index 4dc9bb43..4da4b034 100644
--- a/sigmodr/widgets/MapWarpUI.cpp
+++ b/sigmodr/widgets/MapWarpUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapWarpUI.h"
+#include "MapWarpUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -30,122 +31,122 @@
 #include <KComboBox>
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 MapWarpUI::MapWarpUI(MapWarp* warp, QWidget* parent) :
-        ObjectUI(parent),
-        m_lastMap(-1)
+        ObjectUI(warp, parent),
+        d(new Private(new MapWarp(*warp)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void MapWarpUI::apply()
+{
+    *qobject_cast<MapWarp*>(m_object) = *d->m_warp;
+    ObjectUI::apply();
+}
+
+void MapWarpUI::discard()
+{
+    *d->m_warp = *qobject_cast<MapWarp*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+MapWarpUI::Private::Private(MapWarp* warp) :
+        ObjectUIPrivate(warp),
+        m_warp(warp)
 {
-    setObjects(warp, new MapWarp(*warp));
 }
 
-void MapWarpUI::initGui()
+MapWarpUI::Private::~Private()
 {
-    QFile file(":/gui/mapwarp.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_type = formWidget->findChild<KComboBox*>("varType");
-    ui_toMap = formWidget->findChild<KComboBox*>("varToMap");
-    ui_toWarp = formWidget->findChild<KComboBox*>("varToWarp");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
+    delete m_warp;
+}
+
+QWidget* MapWarpUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/mapwarp.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_type = form->findChild<KComboBox*>("varType");
+    ui_toMap = form->findChild<KComboBox*>("varToMap");
+    ui_toWarp = form->findChild<KComboBox*>("varToWarp");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_type, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
     connect(ui_toMap, SIGNAL(currentIndexChanged(int)), this, SLOT(toMapChanged(int)));
     connect(ui_toWarp, SIGNAL(currentIndexChanged(int)), this, SLOT(toWarpChanged(int)));
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
     ui_type->addItems(MapWarp::TypeStr);
+    return form;
 }
 
-void MapWarpUI::refreshGui()
+void MapWarpUI::Private::refreshGui()
 {
     const bool blocked = ui_toMap->blockSignals(true);
     ui_toMap->clear();
-    for (int i = 0; i < game()->mapCount(); ++i)
-        ui_toMap->addItem(game()->map(i)->name());
+    for (int i = 0; i < m_warp->game()->mapCount(); ++i)
+        ui_toMap->addItem(m_warp->game()->map(i)->name());
     ui_toMap->blockSignals(blocked);
+    ui_toWarp->setEnabled(false);
 }
 
-void MapWarpUI::setGui()
+void MapWarpUI::Private::resetGui()
 {
-    const bool resetWarps = (qobject_cast<MapWarp*>(modified())->toMap() != m_lastMap);
-    ui_name->setText(qobject_cast<MapWarp*>(modified())->name());
-    ui_type->setCurrentIndex(qobject_cast<MapWarp*>(modified())->type());
-    ui_toMap->setCurrentIndex(game()->mapIndex(qobject_cast<MapWarp*>(modified())->toMap()));
-    m_lastMap = qobject_cast<MapWarp*>(modified())->toMap();
-    const Map* map = game()->mapById(qobject_cast<MapWarp*>(modified())->toMap());
-    if (resetWarps)
-    {
-        const bool blocked = ui_toWarp->blockSignals(true);
-        ui_toWarp->clear();
-        if (map)
-        {
-            for (int i = 0; i < map->warpCount(); ++i)
-                ui_toWarp->addItem(map->warp(i)->name());
-        }
-        ui_toWarp->blockSignals(blocked);
-    }
-    if (map)
-        ui_toWarp->setCurrentIndex(map->warpIndex(qobject_cast<MapWarp*>(modified())->toWarp()));
-    else
-        ui_toWarp->setCurrentIndex(-1);
-    ui_script->setValue(qobject_cast<MapWarp*>(modified())->script());
-}
-
-void MapWarpUI::apply()
-{
-    *qobject_cast<MapWarp*>(original()) = *qobject_cast<MapWarp*>(modified());
-    emit(changed(false));
-}
-
-void MapWarpUI::discard()
-{
-    *qobject_cast<MapWarp*>(modified()) = *qobject_cast<MapWarp*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_warp->name());
+    ui_type->setCurrentIndex(m_warp->type());
+    ui_toMap->setCurrentIndex(m_warp->game()->mapIndex(m_warp->toMap()));
+    const Map* map = m_warp->game()->mapById(m_warp->toMap());
+    ui_toWarp->setCurrentIndex(map ? map->warpIndex(m_warp->toWarp()) : -1);
+    ui_script->setValue(m_warp->script());
 }
 
-void MapWarpUI::nameChanged(const QString& name)
+void MapWarpUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<MapWarp*>(modified())->setName(name);
+    m_warp->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void MapWarpUI::typeChanged(const int type)
+void MapWarpUI::Private::typeChanged(const int type)
 {
-    qobject_cast<MapWarp*>(modified())->setType(static_cast<MapWarp::Type>(type));
+    m_warp->setType(static_cast<MapWarp::Type>(type));
 }
 
-void MapWarpUI::toMapChanged(const int toMap)
+void MapWarpUI::Private::toMapChanged(const int toMap)
 {
     if (0 <= toMap)
-        qobject_cast<MapWarp*>(modified())->setToMap(game()->map(toMap)->id());
+    {
+        const Map* map = m_warp->game()->map(toMap);
+        m_warp->setToMap(map->id());
+        ui_toWarp->setEnabled(true);
+        const bool blocked = ui_toWarp->blockSignals(true);
+        ui_toWarp->clear();
+        if (map)
+        {
+            for (int i = 0; i < map->warpCount(); ++i)
+                ui_toWarp->addItem(map->warp(i)->name());
+        }
+        ui_toWarp->blockSignals(blocked);
+    }
+    else
+        ui_toWarp->setEnabled(false);
 }
 
-void MapWarpUI::toWarpChanged(const int toWarp)
+void MapWarpUI::Private::toWarpChanged(const int toWarp)
 {
     if (0 <= toWarp)
     {
-        const Map* map = game()->map(qobject_cast<MapWarp*>(modified())->toMap());
+        const Map* map = m_warp->game()->map(m_warp->toMap());
         if (map)
-            qobject_cast<MapWarp*>(modified())->setToWarp(map->warp(toWarp)->id());
+            m_warp->setToWarp(map->warp(toWarp)->id());
     }
 }
 
-void MapWarpUI::scriptChanged(const Script& script)
+void MapWarpUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<MapWarp*>(modified())->setScript(script);
+    m_warp->setScript(script);
 }
diff --git a/sigmodr/widgets/MapWildListEncounterUI.cpp b/sigmodr/widgets/MapWildListEncounterUI.cpp
index 7ef68a39..3a5d1e66 100644
--- a/sigmodr/widgets/MapWildListEncounterUI.cpp
+++ b/sigmodr/widgets/MapWildListEncounterUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapWildListEncounterUI.h"
+#include "MapWildListEncounterUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -28,79 +29,81 @@
 #include <KComboBox>
 #include <KIntNumInput>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 MapWildListEncounterUI::MapWildListEncounterUI(MapWildListEncounter* encounter, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(encounter, parent),
+        d(new Private(new MapWildListEncounter(*encounter)))
 {
-    setObjects(encounter, new MapWildListEncounter(*encounter));
+    setWidget(d->makeWidgets(this));
 }
 
-void MapWildListEncounterUI::initGui()
+void MapWildListEncounterUI::apply()
 {
-    QFile file(":/gui/mapwildlistencounter.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_species = formWidget->findChild<KComboBox*>("varSpecies");
-    ui_level = formWidget->findChild<KIntNumInput*>("varLevel");
-    ui_weight = formWidget->findChild<KIntNumInput*>("varWeight");
-    connect(ui_species, SIGNAL(currentIndexChanged(int)), this, SLOT(speciesChanged(int)));
-    connect(ui_level, SIGNAL(valueChanged(int)), this, SLOT(levelChanged(int)));
-    connect(ui_weight, SIGNAL(valueChanged(int)), this, SLOT(weightChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<MapWildListEncounter*>(m_object) = *d->m_encounter;
+    ObjectUI::apply();
 }
 
-void MapWildListEncounterUI::refreshGui()
+void MapWildListEncounterUI::discard()
 {
-    const bool blocked = ui_species->blockSignals(true);
-    ui_species->clear();
-    for (int i = 0; i < game()->speciesCount(); ++i)
-        ui_species->addItem(game()->species(i)->name());
-    ui_species->blockSignals(blocked);
-    ui_level->setMaximum(game()->rules()->maxLevel());
+    *d->m_encounter = *qobject_cast<MapWildListEncounter*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void MapWildListEncounterUI::setGui()
+MapWildListEncounterUI::Private::Private(MapWildListEncounter* encounter) :
+        ObjectUIPrivate(encounter),
+        m_encounter(encounter)
 {
-    ui_species->setCurrentIndex(game()->speciesIndex(qobject_cast<MapWildListEncounter*>(modified())->species()));
-    ui_level->setValue(qobject_cast<MapWildListEncounter*>(modified())->level());
-    ui_weight->setValue(qobject_cast<MapWildListEncounter*>(modified())->weight());
 }
 
-void MapWildListEncounterUI::apply()
+MapWildListEncounterUI::Private::~Private()
 {
-    *qobject_cast<MapWildListEncounter*>(original()) = *qobject_cast<MapWildListEncounter*>(modified());
-    emit(changed(false));
+    delete m_encounter;
 }
 
-void MapWildListEncounterUI::discard()
+QWidget* MapWildListEncounterUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/mapwildlistencounter.ui", widget);
+    ui_species = form->findChild<KComboBox*>("varSpecies");
+    ui_level = form->findChild<KIntNumInput*>("varLevel");
+    ui_weight = form->findChild<KIntNumInput*>("varWeight");
+    connect(ui_species, SIGNAL(currentIndexChanged(int)), this, SLOT(speciesChanged(int)));
+    connect(ui_level, SIGNAL(valueChanged(int)), this, SLOT(levelChanged(int)));
+    connect(ui_weight, SIGNAL(valueChanged(int)), this, SLOT(weightChanged(int)));
+    return form;
+}
+
+void MapWildListEncounterUI::Private::refreshGui()
+{
+    const bool blocked = ui_species->blockSignals(true);
+    ui_species->clear();
+    for (int i = 0; i < m_encounter->game()->speciesCount(); ++i)
+        ui_species->addItem(m_encounter->game()->species(i)->name());
+    ui_species->blockSignals(blocked);
+    ui_level->setMaximum(m_encounter->game()->rules()->maxLevel());
+}
+
+void MapWildListEncounterUI::Private::resetGui()
 {
-    *qobject_cast<MapWildListEncounter*>(modified()) = *qobject_cast<MapWildListEncounter*>(original());
-    setGui();
-    emit(changed(false));
+    ui_species->setCurrentIndex(m_encounter->game()->speciesIndex(m_encounter->species()));
+    ui_level->setValue(m_encounter->level());
+    ui_weight->setValue(m_encounter->weight());
 }
 
-void MapWildListEncounterUI::speciesChanged(const int species)
+void MapWildListEncounterUI::Private::speciesChanged(const int species)
 {
     if (0 <= species)
-        qobject_cast<MapWildListEncounter*>(modified())->setSpecies(game()->species(species)->id());
+        m_encounter->setSpecies(m_encounter->game()->species(species)->id());
 }
 
-void MapWildListEncounterUI::levelChanged(const int level)
+void MapWildListEncounterUI::Private::levelChanged(const int level)
 {
-    qobject_cast<MapWildListEncounter*>(modified())->setLevel(level);
+    m_encounter->setLevel(level);
 }
 
-void MapWildListEncounterUI::weightChanged(const int weight)
+void MapWildListEncounterUI::Private::weightChanged(const int weight)
 {
-    qobject_cast<MapWildListEncounter*>(modified())->setWeight(weight);
+    m_encounter->setWeight(weight);
 }
diff --git a/sigmodr/widgets/MapWildListUI.cpp b/sigmodr/widgets/MapWildListUI.cpp
index cd211819..1cfef19f 100644
--- a/sigmodr/widgets/MapWildListUI.cpp
+++ b/sigmodr/widgets/MapWildListUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapWildListUI.h"
+#include "MapWildListUI_p.h"
 
 // Sigmod includes
 #include <sigmod/MapWildList.h>
@@ -24,54 +25,56 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 MapWildListUI::MapWildListUI(MapWildList* wildList, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(wildList, parent),
+        d(new Private(new MapWildList(*wildList)))
 {
-    setObjects(wildList, new MapWildList(*wildList));
+    setWidget(d->makeWidgets(this));
 }
 
-void MapWildListUI::initGui()
+void MapWildListUI::apply()
 {
-    QFile file(":/gui/mapwildlist.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<MapWildList*>(m_object) = *d->m_wildList;
+    ObjectUI::apply();
 }
 
-void MapWildListUI::setGui()
+void MapWildListUI::discard()
 {
-    ui_name->setText(qobject_cast<MapWildList*>(modified())->name());
+    *d->m_wildList = *qobject_cast<MapWildList*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void MapWildListUI::apply()
+MapWildListUI::Private::Private(MapWildList* wildList) :
+        ObjectUIPrivate(wildList),
+        m_wildList(wildList)
 {
-    *qobject_cast<MapWildList*>(original()) = *qobject_cast<MapWildList*>(modified());
-    emit(changed(false));
 }
 
-void MapWildListUI::discard()
+MapWildListUI::Private::~Private()
+{
+    delete m_wildList;
+}
+
+QWidget* MapWildListUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/mapwildlist.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    return form;
+}
+
+void MapWildListUI::Private::resetGui()
 {
-    *qobject_cast<MapWildList*>(modified()) = *qobject_cast<MapWildList*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_wildList->name());
 }
 
-void MapWildListUI::nameChanged(const QString& name)
+void MapWildListUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<MapWildList*>(modified())->setName(name);
+    m_wildList->setName(name);
     ui_name->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/MoveUI.cpp b/sigmodr/widgets/MoveUI.cpp
index 9a9c09dd..5c0e5c89 100644
--- a/sigmodr/widgets/MoveUI.cpp
+++ b/sigmodr/widgets/MoveUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MoveUI.h"
+#include "MoveUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/FractionWidget.h>
@@ -33,10 +34,7 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -44,28 +42,50 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 MoveUI::MoveUI(Move* move, QWidget* parent) :
-        ObjectUI(parent)
-{
-    setObjects(move, new Move(*move));
-}
-
-void MoveUI::initGui()
-{
-    QFile file(":/gui/move.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_priority = formWidget->findChild<KIntNumInput*>("varPriority");
-    ui_accuracy = formWidget->findChild<FractionWidget*>("varAccuracy");
-    ui_power = formWidget->findChild<KIntNumInput*>("varPower");
-    ui_type = formWidget->findChild<KComboBox*>("varType");
-    ui_powerPoints = formWidget->findChild<KIntNumInput*>("varPowerPoints");
-    ui_special = formWidget->findChild<QCheckBox*>("varSpecial");
-    ui_description = formWidget->findChild<KLineEdit*>("varDescription");
-    ui_battleScript = formWidget->findChild<ScriptWidget*>("varBattleScript");
-    ui_worldScript = formWidget->findChild<ScriptWidget*>("varWorldScript");
-    ui_priorityScript = formWidget->findChild<ScriptWidget*>("varPriorityScript");
+        ObjectUI(move, parent),
+        d(new Private(new Move(*move)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void MoveUI::apply()
+{
+    *qobject_cast<Move*>(m_object) = *d->m_move;
+    ObjectUI::apply();
+}
+
+void MoveUI::discard()
+{
+    *d->m_move = *qobject_cast<Move*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+MoveUI::Private::Private(Move* move) :
+        ObjectUIPrivate(move),
+        m_move(move)
+{
+}
+
+MoveUI::Private::~Private()
+{
+    delete m_move;
+}
+
+QWidget* MoveUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/move.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_priority = form->findChild<KIntNumInput*>("varPriority");
+    ui_accuracy = form->findChild<FractionWidget*>("varAccuracy");
+    ui_power = form->findChild<KIntNumInput*>("varPower");
+    ui_type = form->findChild<KComboBox*>("varType");
+    ui_powerPoints = form->findChild<KIntNumInput*>("varPowerPoints");
+    ui_special = form->findChild<QCheckBox*>("varSpecial");
+    ui_description = form->findChild<KLineEdit*>("varDescription");
+    ui_battleScript = form->findChild<ScriptWidget*>("varBattleScript");
+    ui_worldScript = form->findChild<ScriptWidget*>("varWorldScript");
+    ui_priorityScript = form->findChild<ScriptWidget*>("varPriorityScript");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_priority, SIGNAL(valueChanged(int)), this, SLOT(priorityChanged(int)));
     connect(ui_accuracy, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(accuracyChanged(Sigcore::Fraction)));
@@ -77,104 +97,89 @@ void MoveUI::initGui()
     connect(ui_battleScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(battleScriptChanged(Sigcore::Script)));
     connect(ui_worldScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(worldScriptChanged(Sigcore::Script)));
     connect(ui_priorityScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(priorityScriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void MoveUI::refreshGui()
+void MoveUI::Private::refreshGui()
 {
     const bool blocked = ui_type->blockSignals(true);
     ui_type->clear();
-    for (int i = 0; i < game()->typeCount(); ++i)
-        ui_type->addItem(game()->type(i)->name());
+    for (int i = 0; i < m_move->game()->typeCount(); ++i)
+        ui_type->addItem(m_move->game()->type(i)->name());
     ui_type->blockSignals(blocked);
 }
 
-void MoveUI::setGui()
-{
-    ui_name->setText(qobject_cast<Move*>(modified())->name());
-    ui_priority->setValue(qobject_cast<Move*>(modified())->priority());
-    ui_accuracy->setValue(qobject_cast<Move*>(modified())->accuracy());
-    ui_power->setValue(qobject_cast<Move*>(modified())->power());
-    ui_type->setCurrentIndex(game()->typeIndex(qobject_cast<Move*>(modified())->type()));
-    ui_powerPoints->setValue(qobject_cast<Move*>(modified())->powerPoints());
-    ui_special->setChecked(qobject_cast<Move*>(modified())->special() ? Qt::Checked : Qt::Unchecked);
-    ui_description->setText(qobject_cast<Move*>(modified())->description());
-    ui_battleScript->setValue(qobject_cast<Move*>(modified())->battleScript());
-    ui_worldScript->setValue(qobject_cast<Move*>(modified())->worldScript());
-    ui_priorityScript->setValue(qobject_cast<Move*>(modified())->priorityScript());
-}
-
-void MoveUI::apply()
-{
-    *qobject_cast<Move*>(original()) = *qobject_cast<Move*>(modified());
-    emit(changed(false));
-}
-
-void MoveUI::discard()
+void MoveUI::Private::resetGui()
 {
-    *qobject_cast<Move*>(modified()) = *qobject_cast<Move*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_move->name());
+    ui_priority->setValue(m_move->priority());
+    ui_accuracy->setValue(m_move->accuracy());
+    ui_power->setValue(m_move->power());
+    ui_type->setCurrentIndex(m_move->game()->typeIndex(m_move->type()));
+    ui_powerPoints->setValue(m_move->powerPoints());
+    ui_special->setChecked(m_move->special() ? Qt::Checked : Qt::Unchecked);
+    ui_description->setText(m_move->description());
+    ui_battleScript->setValue(m_move->battleScript());
+    ui_worldScript->setValue(m_move->worldScript());
+    ui_priorityScript->setValue(m_move->priorityScript());
 }
 
-void MoveUI::nameChanged(const QString& name)
+void MoveUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Move*>(modified())->setName(name);
+    m_move->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void MoveUI::priorityChanged(const int priority)
+void MoveUI::Private::priorityChanged(const int priority)
 {
-    qobject_cast<Move*>(modified())->setPriority(priority);
+    m_move->setPriority(priority);
 }
 
-void MoveUI::accuracyChanged(const Fraction& accuracy)
+void MoveUI::Private::accuracyChanged(const Fraction& accuracy)
 {
-    qobject_cast<Move*>(modified())->setAccuracy(accuracy);
+    m_move->setAccuracy(accuracy);
 }
 
-void MoveUI::powerChanged(const int power)
+void MoveUI::Private::powerChanged(const int power)
 {
-    qobject_cast<Move*>(modified())->setPower(power);
+    m_move->setPower(power);
 }
 
-void MoveUI::typeChanged(const int type)
+void MoveUI::Private::typeChanged(const int type)
 {
     if (0 <= type)
-        qobject_cast<Move*>(modified())->setType(game()->type(type)->id());
+        m_move->setType(m_move->game()->type(type)->id());
 }
 
-void MoveUI::powerPointsChanged(const int powerPoints)
+void MoveUI::Private::powerPointsChanged(const int powerPoints)
 {
-    qobject_cast<Move*>(modified())->setPowerPoints(powerPoints);
+    m_move->setPowerPoints(powerPoints);
 }
 
-void MoveUI::specialChanged(const bool special)
+void MoveUI::Private::specialChanged(const bool special)
 {
-    qobject_cast<Move*>(modified())->setSpecial(special);
+    m_move->setSpecial(special);
 }
 
-void MoveUI::descriptionChanged(const QString& description)
+void MoveUI::Private::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Move*>(modified())->setDescription(description);
+    m_move->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void MoveUI::battleScriptChanged(const Script& battleScript)
+void MoveUI::Private::battleScriptChanged(const Script& battleScript)
 {
-    qobject_cast<Move*>(modified())->setBattleScript(battleScript);
+    m_move->setBattleScript(battleScript);
 }
 
-void MoveUI::worldScriptChanged(const Script& worldScript)
+void MoveUI::Private::worldScriptChanged(const Script& worldScript)
 {
-    qobject_cast<Move*>(modified())->setWorldScript(worldScript);
+    m_move->setWorldScript(worldScript);
 }
 
-void MoveUI::priorityScriptChanged(const Script& priorityScript)
+void MoveUI::Private::priorityScriptChanged(const Script& priorityScript)
 {
-    qobject_cast<Move*>(modified())->setPriorityScript(priorityScript);
+    m_move->setPriorityScript(priorityScript);
 }
diff --git a/sigmodr/widgets/NatureUI.cpp b/sigmodr/widgets/NatureUI.cpp
index fd6753f4..f6d53be1 100644
--- a/sigmodr/widgets/NatureUI.cpp
+++ b/sigmodr/widgets/NatureUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "NatureUI.h"
+#include "NatureUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/FractionWidget.h>
@@ -31,11 +32,8 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QHeaderView>
 #include <QtGui/QTableWidget>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -43,34 +41,54 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 NatureUI::NatureUI(Nature* nature, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(nature, parent),
+        d(new Private(new Nature(*nature)))
 {
-    setObjects(nature, new Nature(*nature));
+    setWidget(d->makeWidgets(this));
 }
 
-void NatureUI::initGui()
+void NatureUI::apply()
+{
+    *qobject_cast<Nature*>(m_object) = *d->m_nature;
+    ObjectUI::apply();
+}
+
+void NatureUI::discard()
+{
+    *d->m_nature = *qobject_cast<Nature*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+NatureUI::Private::Private(Nature* nature) :
+        ObjectUIPrivate(nature),
+        m_nature(nature)
+{
+}
+
+NatureUI::Private::~Private()
 {
-    QFile file(":/gui/nature.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_stat = formWidget->findChild<QTableWidget*>("varStat");
-    ui_statMultiplier = formWidget->findChild<FractionWidget*>("varStatMultiplier");
-    ui_weight = formWidget->findChild<KIntNumInput*>("varWeight");
+    delete m_nature;
+}
+
+QWidget* NatureUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/nature.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_stat = form->findChild<QTableWidget*>("varStat");
+    ui_statMultiplier = form->findChild<FractionWidget*>("varStatMultiplier");
+    ui_weight = form->findChild<KIntNumInput*>("varWeight");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_stat, SIGNAL(currentCellChanged(int,int,int,int)), this, SLOT(statChanged(int)));
     connect(ui_statMultiplier, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(statMultiplierChanged(Sigcore::Fraction)));
     connect(ui_weight, SIGNAL(valueChanged(int)), this, SLOT(weightChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
     ui_stat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+    return form;
 }
 
-void NatureUI::refreshGui()
+void NatureUI::Private::refreshGui()
 {
-    const bool isSplit = game()->rules()->specialSplit();
+    const bool isSplit = m_nature->game()->rules()->specialSplit();
     ui_stat->clear();
     ui_stat->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
     ui_stat->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
@@ -96,6 +114,7 @@ void NatureUI::refreshGui()
     }
     else
         ui_stat->setItem(ST_Special - ST_Attack, 0, new QTableWidgetItem);
+    ui_statMultiplier->setEnabled(false);
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     ui_stat->setItem(ST_Attack - ST_Attack, 0, item);
@@ -123,54 +142,42 @@ void NatureUI::refreshGui()
     }
 }
 
-void NatureUI::setGui()
+void NatureUI::Private::resetGui()
 {
-    ui_name->setText(qobject_cast<Nature*>(modified())->name());
-    ui_stat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Attack), 'g', 7));
-    ui_stat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Defense), 'g', 7));
-    ui_stat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Speed), 'g', 7));
-    if (game()->rules()->specialSplit())
+    ui_name->setText(m_nature->name());
+    ui_stat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_Attack), 'g', 7));
+    ui_stat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_Defense), 'g', 7));
+    ui_stat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_Speed), 'g', 7));
+    if (m_nature->game()->rules()->specialSplit())
     {
-        ui_stat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_SpecialAttack), 'g', 7));
-        ui_stat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_SpecialDefense), 'g', 7));
+        ui_stat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_SpecialAttack), 'g', 7));
+        ui_stat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_SpecialDefense), 'g', 7));
     }
     else
-        ui_stat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Special), 'g', 7));
-    ui_statMultiplier->setValue(qobject_cast<Nature*>(modified())->stat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>()));
-    ui_weight->setValue(qobject_cast<Nature*>(modified())->weight());
-}
-
-void NatureUI::apply()
-{
-    *qobject_cast<Nature*>(original()) = *qobject_cast<Nature*>(modified());
-    emit(changed(false));
-}
-
-void NatureUI::discard()
-{
-    *qobject_cast<Nature*>(modified()) = *qobject_cast<Nature*>(original());
-    setGui();
-    emit(changed(false));
+        ui_stat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_nature->stat(ST_Special), 'g', 7));
+    ui_weight->setValue(m_nature->weight());
 }
 
-void NatureUI::nameChanged(const QString& name)
+void NatureUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Nature*>(modified())->setName(name);
+    m_nature->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void NatureUI::statChanged(const int row)
+void NatureUI::Private::statChanged(const int row)
 {
-    ui_statMultiplier->setValue(qobject_cast<Nature*>(modified())->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
+    ui_statMultiplier->setEnabled(true);
+    ui_statMultiplier->setValue(m_nature->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void NatureUI::statMultiplierChanged(const Fraction& multiplier)
+void NatureUI::Private::statMultiplierChanged(const Fraction& multiplier)
 {
-    qobject_cast<Nature*>(modified())->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
+    m_nature->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
+    emit(changed());
 }
 
-void NatureUI::weightChanged(const int weight)
+void NatureUI::Private::weightChanged(const int weight)
 {
-    qobject_cast<Nature*>(modified())->setWeight(weight);
+    m_nature->setWeight(weight);
 }
diff --git a/sigmodr/widgets/RulesUI.cpp b/sigmodr/widgets/RulesUI.cpp
index 69ef7ad6..7f78831e 100644
--- a/sigmodr/widgets/RulesUI.cpp
+++ b/sigmodr/widgets/RulesUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "RulesUI.h"
+#include "RulesUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Rules.h>
@@ -25,47 +26,66 @@
 #include <KIntNumInput>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 RulesUI::RulesUI(Rules* rules, QWidget* parent) :
-        ObjectUI(parent)
-{
-    setObjects(rules, new Rules(*rules));
-}
-
-void RulesUI::initGui()
-{
-    QFile file(":/gui/rules.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_genders = formWidget->findChild<QCheckBox*>("varGenders");
-    ui_breeding = formWidget->findChild<QCheckBox*>("varBreeding");
-    ui_criticalDomains = formWidget->findChild<QCheckBox*>("varCriticalDomains");
-    ui_splitSpecial = formWidget->findChild<QCheckBox*>("varSplitSpecial");
-    ui_splitSpecialDV = formWidget->findChild<QCheckBox*>("varSplitSpecialDV");
-    ui_effortValues = formWidget->findChild<QCheckBox*>("varEffortValues");
-    ui_maxEV = formWidget->findChild<KIntNumInput*>("varMaxEV");
-    ui_maxEVPerStat = formWidget->findChild<KIntNumInput*>("varMaxEVPerStat");
-    ui_boxes = formWidget->findChild<KIntNumInput*>("varBoxes");
-    ui_boxSize = formWidget->findChild<KIntNumInput*>("varBoxSize");
-    ui_maxParty = formWidget->findChild<KIntNumInput*>("varMaxParty");
-    ui_maxFight = formWidget->findChild<KIntNumInput*>("varMaxFight");
-    ui_maxPlayers = formWidget->findChild<KIntNumInput*>("varMaxPlayers");
-    ui_maxMoves = formWidget->findChild<KIntNumInput*>("varMaxMoves");
-    ui_maxLevel = formWidget->findChild<KIntNumInput*>("varMaxLevel");
-    ui_maxHeldItems = formWidget->findChild<KIntNumInput*>("varMaxHeldItems");
-    ui_maxNatures = formWidget->findChild<KIntNumInput*>("varMaxNatures");
-    ui_maxAbilities = formWidget->findChild<KIntNumInput*>("varMaxAbilities");
-    ui_maxStages = formWidget->findChild<KIntNumInput*>("varMaxStages");
-    ui_maxMoney = formWidget->findChild<KIntNumInput*>("varMaxMoney");
-    ui_maxTotalWeight = formWidget->findChild<KIntNumInput*>("varMaxTotalWeight");
+        ObjectUI(rules, parent),
+        d(new Private(new Rules(*rules)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void RulesUI::apply()
+{
+    *qobject_cast<Rules*>(m_object) = *d->m_rules;
+    ObjectUI::apply();
+}
+
+void RulesUI::discard()
+{
+    *d->m_rules = *qobject_cast<Rules*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+RulesUI::Private::Private(Rules* rules) :
+        ObjectUIPrivate(rules),
+        m_rules(rules)
+{
+}
+
+RulesUI::Private::~Private()
+{
+    delete m_rules;
+}
+
+QWidget* RulesUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/rules.ui", widget);
+    ui_genders = form->findChild<QCheckBox*>("varGenders");
+    ui_breeding = form->findChild<QCheckBox*>("varBreeding");
+    ui_criticalDomains = form->findChild<QCheckBox*>("varCriticalDomains");
+    ui_splitSpecial = form->findChild<QCheckBox*>("varSplitSpecial");
+    ui_splitSpecialDV = form->findChild<QCheckBox*>("varSplitSpecialDV");
+    ui_effortValues = form->findChild<QCheckBox*>("varEffortValues");
+    ui_maxEV = form->findChild<KIntNumInput*>("varMaxEV");
+    ui_maxEVPerStat = form->findChild<KIntNumInput*>("varMaxEVPerStat");
+    ui_boxes = form->findChild<KIntNumInput*>("varBoxes");
+    ui_boxSize = form->findChild<KIntNumInput*>("varBoxSize");
+    ui_maxParty = form->findChild<KIntNumInput*>("varMaxParty");
+    ui_maxFight = form->findChild<KIntNumInput*>("varMaxFight");
+    ui_maxPlayers = form->findChild<KIntNumInput*>("varMaxPlayers");
+    ui_maxMoves = form->findChild<KIntNumInput*>("varMaxMoves");
+    ui_maxLevel = form->findChild<KIntNumInput*>("varMaxLevel");
+    ui_maxHeldItems = form->findChild<KIntNumInput*>("varMaxHeldItems");
+    ui_maxNatures = form->findChild<KIntNumInput*>("varMaxNatures");
+    ui_maxAbilities = form->findChild<KIntNumInput*>("varMaxAbilities");
+    ui_maxStages = form->findChild<KIntNumInput*>("varMaxStages");
+    ui_maxMoney = form->findChild<KIntNumInput*>("varMaxMoney");
+    ui_maxTotalWeight = form->findChild<KIntNumInput*>("varMaxTotalWeight");
     connect(ui_genders, SIGNAL(toggled(bool)), this, SLOT(gendersChanged(bool)));
     connect(ui_breeding, SIGNAL(toggled(bool)), this, SLOT(breedingChanged(bool)));
     connect(ui_criticalDomains, SIGNAL(toggled(bool)), this, SLOT(criticalDomainsChanged(bool)));
@@ -87,159 +107,143 @@ void RulesUI::initGui()
     connect(ui_maxStages, SIGNAL(valueChanged(int)), this, SLOT(maxStagesChanged(int)));
     connect(ui_maxMoney, SIGNAL(valueChanged(int)), this, SLOT(maxMoneyChanged(int)));
     connect(ui_maxTotalWeight, SIGNAL(valueChanged(int)), this, SLOT(maxTotalWeightChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
-}
-
-void RulesUI::setGui()
-{
-    ui_genders->setCheckState(qobject_cast<Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
-    ui_breeding->setCheckState(qobject_cast<Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
-    ui_breeding->setEnabled(qobject_cast<Rules*>(modified())->genderAllowed());
-    ui_criticalDomains->setCheckState(qobject_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
-    ui_splitSpecial->setCheckState(qobject_cast<Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
-    ui_splitSpecialDV->setEnabled(qobject_cast<Rules*>(modified())->specialSplit());
-    ui_splitSpecialDV->setCheckState(qobject_cast<Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
-    ui_effortValues->setCheckState(qobject_cast<Rules*>(modified())->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
-    ui_maxEV->setEnabled(qobject_cast<Rules*>(modified())->effortValuesAllowed());
-    ui_maxEV->setValue(qobject_cast<Rules*>(modified())->maxTotalEV());
-    ui_maxEVPerStat->setEnabled((0 < qobject_cast<Rules*>(modified())->maxTotalEV()) && qobject_cast<Rules*>(modified())->effortValuesAllowed());
-    ui_maxEVPerStat->setMaximum(qobject_cast<Rules*>(modified())->maxTotalEV());
-    ui_maxEVPerStat->setValue(qobject_cast<Rules*>(modified())->maxEVPerStat());
-    ui_boxes->setValue(qobject_cast<Rules*>(modified())->numBoxes());
-    ui_boxSize->setEnabled(0 < qobject_cast<Rules*>(modified())->numBoxes());
-    ui_boxSize->setValue(qobject_cast<Rules*>(modified())->boxSize());
-    ui_maxParty->setValue(qobject_cast<Rules*>(modified())->maxParty());
-    ui_maxFight->setMaximum(qobject_cast<Rules*>(modified())->maxParty());
-    ui_maxFight->setValue(qobject_cast<Rules*>(modified())->maxFight());
-    ui_maxPlayers->setValue(qobject_cast<Rules*>(modified())->maxPlayers());
-    ui_maxMoves->setValue(qobject_cast<Rules*>(modified())->maxMoves());
-    ui_maxLevel->setValue(qobject_cast<Rules*>(modified())->maxLevel());
-    ui_maxHeldItems->setValue(qobject_cast<Rules*>(modified())->maxHeldItems());
-    ui_maxNatures->setValue(qobject_cast<Rules*>(modified())->maxNatures());
-    ui_maxAbilities->setValue(qobject_cast<Rules*>(modified())->maxAbilities());
-    ui_maxStages->setValue(qobject_cast<Rules*>(modified())->maxStages());
-    ui_maxMoney->setValue(qobject_cast<Rules*>(modified())->maxMoney());
-    ui_maxTotalWeight->setValue(qobject_cast<Rules*>(modified())->maxTotalWeight());
+    return form;
 }
 
-void RulesUI::apply()
-{
-    *qobject_cast<Rules*>(original()) = *qobject_cast<Rules*>(modified());
-    emit(changed(false));
-}
-
-void RulesUI::discard()
+void RulesUI::Private::resetGui()
 {
-    *qobject_cast<Rules*>(modified()) = *qobject_cast<Rules*>(original());
-    setGui();
-    emit(changed(false));
+    ui_genders->setCheckState(m_rules->genderAllowed() ? Qt::Checked : Qt::Unchecked);
+    ui_breeding->setCheckState(m_rules->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
+    ui_criticalDomains->setCheckState(m_rules->criticalDomains() ? Qt::Checked : Qt::Unchecked);
+    ui_splitSpecial->setCheckState(m_rules->specialSplit() ? Qt::Checked : Qt::Unchecked);
+    ui_splitSpecialDV->setCheckState(m_rules->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
+    ui_effortValues->setCheckState(m_rules->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
+    ui_maxEV->setValue(m_rules->maxTotalEV());
+    ui_maxEVPerStat->setValue(m_rules->maxEVPerStat());
+    ui_boxes->setValue(m_rules->numBoxes());
+    ui_boxSize->setValue(m_rules->boxSize());
+    ui_maxParty->setValue(m_rules->maxParty());
+    ui_maxFight->setValue(m_rules->maxFight());
+    ui_maxPlayers->setValue(m_rules->maxPlayers());
+    ui_maxMoves->setValue(m_rules->maxMoves());
+    ui_maxLevel->setValue(m_rules->maxLevel());
+    ui_maxHeldItems->setValue(m_rules->maxHeldItems());
+    ui_maxNatures->setValue(m_rules->maxNatures());
+    ui_maxAbilities->setValue(m_rules->maxAbilities());
+    ui_maxStages->setValue(m_rules->maxStages());
+    ui_maxMoney->setValue(m_rules->maxMoney());
+    ui_maxTotalWeight->setValue(m_rules->maxTotalWeight());
 }
 
-void RulesUI::gendersChanged(const bool genders)
+void RulesUI::Private::gendersChanged(const bool genders)
 {
-    qobject_cast<Rules*>(modified())->setGenderAllowed(genders);
+    m_rules->setGenderAllowed(genders);
+    ui_breeding->setEnabled(genders);
 }
 
-void RulesUI::breedingChanged(const bool breeding)
+void RulesUI::Private::breedingChanged(const bool breeding)
 {
-    qobject_cast<Rules*>(modified())->setBreedingAllowed(breeding);
+    m_rules->setBreedingAllowed(breeding);
 }
 
-void RulesUI::criticalDomainsChanged(const bool criticalDomains)
+void RulesUI::Private::criticalDomainsChanged(const bool criticalDomains)
 {
-    qobject_cast<Rules*>(modified())->setCriticalDomains(criticalDomains);
+    m_rules->setCriticalDomains(criticalDomains);
 }
 
-void RulesUI::splitSpecialChanged(const bool splitSpecial)
+void RulesUI::Private::splitSpecialChanged(const bool splitSpecial)
 {
-    qobject_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
-    if (!splitSpecial)
-        qobject_cast<Rules*>(modified())->setSpecialDVSplit(false);
+    m_rules->setSpecialSplit(splitSpecial);
+    ui_splitSpecialDV->setEnabled(splitSpecial);
 }
 
-void RulesUI::splitSpecialDVChanged(const bool splitSpecialDV)
+void RulesUI::Private::splitSpecialDVChanged(const bool splitSpecialDV)
 {
-    qobject_cast<Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
+    m_rules->setSpecialDVSplit(splitSpecialDV);
 }
 
-void RulesUI::effortValuesChanged(const bool effortValues)
+void RulesUI::Private::effortValuesChanged(const bool effortValues)
 {
-    qobject_cast<Rules*>(modified())->setEffortValuesAllowed(effortValues);
+    m_rules->setEffortValuesAllowed(effortValues);
+    ui_maxEV->setEnabled(effortValues);
+    ui_maxEVPerStat->setEnabled(effortValues);
 }
 
-void RulesUI::maxEVChanged(const int maxEV)
+void RulesUI::Private::maxEVChanged(const int maxEV)
 {
-    qobject_cast<Rules*>(modified())->setMaxTotalEV(maxEV);
+    m_rules->setMaxTotalEV(maxEV);
+    ui_maxEVPerStat->setMaximum(maxEV);
+    ui_maxEVPerStat->setEnabled(0 < maxEV);
 }
 
-void RulesUI::maxEVPerStatChanged(const int maxEVPerStat)
+void RulesUI::Private::maxEVPerStatChanged(const int maxEVPerStat)
 {
-    qobject_cast<Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
+    m_rules->setMaxEVPerStat(maxEVPerStat);
 }
 
-void RulesUI::boxesChanged(const int boxes)
+void RulesUI::Private::boxesChanged(const int boxes)
 {
-    qobject_cast<Rules*>(modified())->setNumBoxes(boxes);
+    m_rules->setNumBoxes(boxes);
+    ui_boxSize->setEnabled(0 < boxes);
 }
 
-void RulesUI::boxSizeChanged(const int boxSize)
+void RulesUI::Private::boxSizeChanged(const int boxSize)
 {
-    qobject_cast<Rules*>(modified())->setBoxSize(boxSize);
+    m_rules->setBoxSize(boxSize);
 }
 
-void RulesUI::maxPartyChanged(const int maxParty)
+void RulesUI::Private::maxPartyChanged(const int maxParty)
 {
-    qobject_cast<Rules*>(modified())->setMaxParty(maxParty);
+    m_rules->setMaxParty(maxParty);
+    ui_maxFight->setMaximum(maxParty);
 }
 
-void RulesUI::maxFightChanged(const int maxFight)
+void RulesUI::Private::maxFightChanged(const int maxFight)
 {
-    qobject_cast<Rules*>(modified())->setMaxFight(maxFight);
+    m_rules->setMaxFight(maxFight);
 }
 
-void RulesUI::maxPlayersChanged(const int maxPlayers)
+void RulesUI::Private::maxPlayersChanged(const int maxPlayers)
 {
-    qobject_cast<Rules*>(modified())->setMaxPlayers(maxPlayers);
+    m_rules->setMaxPlayers(maxPlayers);
 }
 
-void RulesUI::maxMovesChanged(const int maxMoves)
+void RulesUI::Private::maxMovesChanged(const int maxMoves)
 {
-    qobject_cast<Rules*>(modified())->setMaxMoves(maxMoves);
+    m_rules->setMaxMoves(maxMoves);
 }
 
-void RulesUI::maxLevelChanged(const int maxLevel)
+void RulesUI::Private::maxLevelChanged(const int maxLevel)
 {
-    qobject_cast<Rules*>(modified())->setMaxLevel(maxLevel);
+    m_rules->setMaxLevel(maxLevel);
 }
 
-void RulesUI::maxHeldItemsChanged(const int maxHeldItems)
+void RulesUI::Private::maxHeldItemsChanged(const int maxHeldItems)
 {
-    qobject_cast<Rules*>(modified())->setMaxHeldItems(maxHeldItems);
+    m_rules->setMaxHeldItems(maxHeldItems);
 }
 
-void RulesUI::maxNaturesChanged(const int maxNatures)
+void RulesUI::Private::maxNaturesChanged(const int maxNatures)
 {
-    qobject_cast<Rules*>(modified())->setMaxNatures(maxNatures);
+    m_rules->setMaxNatures(maxNatures);
 }
 
-void RulesUI::maxAbilitiesChanged(const int maxAbilities)
+void RulesUI::Private::maxAbilitiesChanged(const int maxAbilities)
 {
-    qobject_cast<Rules*>(modified())->setMaxAbilities(maxAbilities);
+    m_rules->setMaxAbilities(maxAbilities);
 }
 
-void RulesUI::maxStagesChanged(const int maxStages)
+void RulesUI::Private::maxStagesChanged(const int maxStages)
 {
-    qobject_cast<Rules*>(modified())->setMaxStages(maxStages);
+    m_rules->setMaxStages(maxStages);
 }
 
-void RulesUI::maxMoneyChanged(const int maxMoney)
+void RulesUI::Private::maxMoneyChanged(const int maxMoney)
 {
-    qobject_cast<Rules*>(modified())->setMaxMoney(maxMoney);
+    m_rules->setMaxMoney(maxMoney);
 }
 
-void RulesUI::maxTotalWeightChanged(const int maxTotalWeight)
+void RulesUI::Private::maxTotalWeightChanged(const int maxTotalWeight)
 {
-    qobject_cast<Rules*>(modified())->setMaxTotalWeight(maxTotalWeight);
+    m_rules->setMaxTotalWeight(maxTotalWeight);
 }
diff --git a/sigmodr/widgets/SkinUI.cpp b/sigmodr/widgets/SkinUI.cpp
index 2b443e37..eb99a3a0 100644
--- a/sigmodr/widgets/SkinUI.cpp
+++ b/sigmodr/widgets/SkinUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "SkinUI.h"
+#include "SkinUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -27,64 +28,66 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 SkinUI::SkinUI(Skin* skin, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(skin, parent),
+        d(new Private(new Skin(*skin)))
 {
-    setObjects(skin, new Skin(*skin));
+    setWidget(d->makeWidgets(this));
 }
 
-void SkinUI::initGui()
+void SkinUI::apply()
 {
-    QFile file(":/gui/skin.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Skin*>(m_object) = *d->m_skin;
+    ObjectUI::apply();
 }
 
-void SkinUI::setGui()
+void SkinUI::discard()
 {
-    ui_name->setText(qobject_cast<Skin*>(modified())->name());
-    ui_script->setValue(qobject_cast<Skin*>(modified())->script());
+    *d->m_skin = *qobject_cast<Skin*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void SkinUI::apply()
+SkinUI::Private::Private(Skin* skin) :
+        ObjectUIPrivate(skin),
+        m_skin(skin)
 {
-    *qobject_cast<Skin*>(original()) = *qobject_cast<Skin*>(modified());
-    emit(changed(false));
 }
 
-void SkinUI::discard()
+SkinUI::Private::~Private()
+{
+    delete m_skin;
+}
+
+QWidget* SkinUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/skin.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
+    return form;
+}
+
+void SkinUI::Private::resetGui()
 {
-    *qobject_cast<Skin*>(modified()) = *qobject_cast<Skin*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_skin->name());
+    ui_script->setValue(m_skin->script());
 }
 
-void SkinUI::nameChanged(const QString& name)
+void SkinUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Skin*>(modified())->setName(name);
+    m_skin->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void SkinUI::scriptChanged(const Script& script)
+void SkinUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<Skin*>(modified())->setScript(script);
+    m_skin->setScript(script);
 }
diff --git a/sigmodr/widgets/SoundUI.cpp b/sigmodr/widgets/SoundUI.cpp
index 14d20a8a..891b0d07 100644
--- a/sigmodr/widgets/SoundUI.cpp
+++ b/sigmodr/widgets/SoundUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "SoundUI.h"
+#include "SoundUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -37,109 +38,109 @@
 
 // Qt includes
 #include <QtCore/QBuffer>
-#include <QtCore/QFile>
 #include <QtCore/QTime>
 #include <QtGui/QLabel>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 SoundUI::SoundUI(Sound* sound, QWidget* parent) :
-        ObjectUI(parent),
+        ObjectUI(sound, parent),
+        d(new Private(new Sound(*sound)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void SoundUI::apply()
+{
+    *qobject_cast<Sound*>(m_object) = *d->m_sound;
+    ObjectUI::apply();
+}
+
+void SoundUI::discard()
+{
+    *d->m_sound = *qobject_cast<Sound*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+SoundUI::Private::Private(Sound* sound) :
+        ObjectUIPrivate(sound),
+        m_sound(sound),
         m_output(new Phonon::AudioOutput(Phonon::MusicCategory, this)),
         m_media(new Phonon::MediaObject(this)),
         m_buffer(new QBuffer)
 {
-    setObjects(sound, new Sound(*sound));
 }
 
-SoundUI::~SoundUI()
+SoundUI::Private::~Private()
 {
+    delete m_sound;
     delete m_media;
     delete m_buffer;
 }
 
-void SoundUI::initGui()
+QWidget* SoundUI::Private::makeWidgets(ObjectUI* widget)
 {
-    QFile file(":/gui/sound.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    Phonon::SeekSlider* seeker = formWidget->findChild<Phonon::SeekSlider*>("seeker");
-    ui_time = formWidget->findChild<QLabel*>("label");
-    ui_play = formWidget->findChild<KPushButton*>("buttonPlay");
-    ui_stop = formWidget->findChild<KPushButton*>("buttonStop");
-    Phonon::VolumeSlider* sliderVolume = formWidget->findChild<Phonon::VolumeSlider*>("sliderVolume");
-    KPushButton* buttonBrowse = formWidget->findChild<KPushButton*>("buttonBrowse");
-    Phonon::createPath(m_media, m_output);
-    m_media->setTickInterval(100);
-    seeker->setMediaObject(m_media);
-    sliderVolume->setAudioOutput(m_output);
+    QWidget *form = openUiFile(":/gui/sound.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    Phonon::SeekSlider* seeker = form->findChild<Phonon::SeekSlider*>("seeker");
+    ui_time = form->findChild<QLabel*>("label");
+    ui_play = form->findChild<KPushButton*>("buttonPlay");
+    ui_stop = form->findChild<KPushButton*>("buttonStop");
+    Phonon::VolumeSlider* sliderVolume = form->findChild<Phonon::VolumeSlider*>("sliderVolume");
+    KPushButton* buttonBrowse = form->findChild<KPushButton*>("buttonBrowse");
     connect(m_media, SIGNAL(tick(qint64)), this, SLOT(tick(qint64)));
     connect(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), this, SLOT(stateChanged(Phonon::State)));
     connect(ui_play, SIGNAL(clicked()), m_media, SLOT(play()));
     connect(ui_stop, SIGNAL(clicked()), m_media, SLOT(stop()));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    Phonon::createPath(m_media, m_output);
+    m_media->setTickInterval(100);
+    seeker->setMediaObject(m_media);
+    sliderVolume->setAudioOutput(m_output);
     ui_play->setIcon(KIcon("media-playback-start"));
     ui_stop->setIcon(KIcon("media-playback-stop"));
     buttonBrowse->setIcon(KIcon("document-open"));
+    return form;
 }
 
-void SoundUI::refreshGui()
+void SoundUI::Private::refreshGui()
 {
     resetAudioData();
 }
 
-void SoundUI::setGui()
-{
-    ui_name->setText(qobject_cast<Sound*>(modified())->name());
-}
-
-void SoundUI::apply()
-{
-    *qobject_cast<Sound*>(original()) = *qobject_cast<Sound*>(modified());
-    emit(changed(false));
-}
-
-void SoundUI::discard()
+void SoundUI::Private::resetGui()
 {
-    *qobject_cast<Sound*>(modified()) = *qobject_cast<Sound*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_sound->name());
 }
 
-void SoundUI::nameChanged(const QString& name)
+void SoundUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sound*>(modified())->setName(name);
+    m_sound->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void SoundUI::browse()
+void SoundUI::Private::browse()
 {
-    QFile file(KFileDialog::getOpenFileName(KUrl("kfiledialog:///audio"), "audio/*|Audio files", this));
+    QFile file(KFileDialog::getOpenFileName(KUrl("kfiledialog:///audio"), "audio/*|Audio files", NULL));
     if (file.open(QIODevice::ReadOnly))
     {
-        qobject_cast<Sound*>(modified())->setData(file.readAll());
+        m_sound->setData(file.readAll());
         file.close();
         resetAudioData();
     }
 }
 
-void SoundUI::stateChanged(Phonon::State newState)
+void SoundUI::Private::stateChanged(Phonon::State newState)
 {
     switch (newState)
     {
         case Phonon::ErrorState:
             if (m_media->errorType() == Phonon::FatalError)
-                KMessageBox::warningContinueCancel(this, "Fatal Error", m_media->errorString());
+                KMessageBox::warningContinueCancel(NULL, "Fatal Error", m_media->errorString());
             else
-                KMessageBox::warningContinueCancel(this, "Error", m_media->errorString());
+                KMessageBox::warningContinueCancel(NULL, "Error", m_media->errorString());
             break;
         case Phonon::PlayingState:
             disconnect(ui_play, SIGNAL(clicked()), m_media, SLOT(play()));
@@ -167,15 +168,15 @@ void SoundUI::stateChanged(Phonon::State newState)
     }
 }
 
-void SoundUI::resetAudioData()
+void SoundUI::Private::resetAudioData()
 {
     m_media->stop();
-    m_buffer->setData(qobject_cast<Sound*>(modified())->data());
+    m_buffer->setData(m_sound->data());
     m_media->setCurrentSource(m_buffer);
     tick(0);
 }
 
-void SoundUI::tick(qint64 time)
+void SoundUI::Private::tick(qint64 time)
 {
     QTime currentTime(0, (time / 60000) % 60, (time / 1000) % 60, time % 1000);
     qint64 total = ((m_media->state() == Phonon::BufferingState) ? 0 : m_media->totalTime());
diff --git a/sigmodr/widgets/SoundUI.h b/sigmodr/widgets/SoundUI.h
index 91a88fd4..2a31d462 100644
--- a/sigmodr/widgets/SoundUI.h
+++ b/sigmodr/widgets/SoundUI.h
@@ -37,7 +37,6 @@ class SIGMODRWIDGETS_EXPORT SoundUI : public ObjectUI
     
     public:
         SoundUI(Sigmod::Sound* sound, QWidget* parent);
-        ~SoundUI();
     public slots:
         void apply();
         void discard();
diff --git a/sigmodr/widgets/SpeciesMoveUI.cpp b/sigmodr/widgets/SpeciesMoveUI.cpp
index cfe7d42b..adfd1414 100644
--- a/sigmodr/widgets/SpeciesMoveUI.cpp
+++ b/sigmodr/widgets/SpeciesMoveUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "SpeciesMoveUI.h"
+#include "SpeciesMoveUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -28,80 +29,82 @@
 #include <KComboBox>
 #include <KIntNumInput>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 SpeciesMoveUI::SpeciesMoveUI(SpeciesMove* move, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(move, parent),
+        d(new Private(new SpeciesMove(*move)))
 {
-    setObjects(move, new SpeciesMove(*move));
+    setWidget(d->makeWidgets(this));
 }
 
-void SpeciesMoveUI::initGui()
+void SpeciesMoveUI::apply()
 {
-    QFile file(":/gui/speciesmove.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_move = formWidget->findChild<KComboBox*>("varMove");
-    ui_level = formWidget->findChild<KIntNumInput*>("varLevel");
-    ui_wildLevel = formWidget->findChild<KIntNumInput*>("varWildLevel");
-    connect(ui_move, SIGNAL(currentIndexChanged(int)), this, SLOT(moveChanged(int)));
-    connect(ui_level, SIGNAL(valueChanged(int)), this, SLOT(levelChanged(int)));
-    connect(ui_wildLevel, SIGNAL(valueChanged(int)), this, SLOT(wildLevelChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<SpeciesMove*>(m_object) = *d->m_move;
+    ObjectUI::apply();
 }
 
-void SpeciesMoveUI::refreshGui()
+void SpeciesMoveUI::discard()
 {
-    const bool blocked = ui_move->blockSignals(true);
-    ui_move->clear();
-    for (int i = 0; i < game()->moveCount(); ++i)
-        ui_move->addItem(game()->move(i)->name());
-    ui_move->blockSignals(blocked);
-    ui_level->setMaximum(game()->rules()->maxLevel());
-    ui_wildLevel->setMaximum(game()->rules()->maxLevel());
+    *d->m_move = *qobject_cast<SpeciesMove*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void SpeciesMoveUI::setGui()
+SpeciesMoveUI::Private::Private(SpeciesMove* move) :
+        ObjectUIPrivate(move),
+        m_move(move)
 {
-    ui_move->setCurrentIndex(game()->moveIndex(qobject_cast<SpeciesMove*>(modified())->move()));
-    ui_level->setValue(qobject_cast<SpeciesMove*>(modified())->level());
-    ui_wildLevel->setValue(qobject_cast<SpeciesMove*>(modified())->wild());
 }
 
-void SpeciesMoveUI::apply()
+SpeciesMoveUI::Private::~Private()
 {
-    *qobject_cast<SpeciesMove*>(original()) = *qobject_cast<SpeciesMove*>(modified());
-    emit(changed(false));
+    delete m_move;
 }
 
-void SpeciesMoveUI::discard()
+QWidget* SpeciesMoveUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/speciesmove.ui", widget);
+    ui_move = form->findChild<KComboBox*>("varMove");
+    ui_level = form->findChild<KIntNumInput*>("varLevel");
+    ui_wildLevel = form->findChild<KIntNumInput*>("varWildLevel");
+    connect(ui_move, SIGNAL(currentIndexChanged(int)), this, SLOT(moveChanged(int)));
+    connect(ui_level, SIGNAL(valueChanged(int)), this, SLOT(levelChanged(int)));
+    connect(ui_wildLevel, SIGNAL(valueChanged(int)), this, SLOT(wildLevelChanged(int)));
+    return form;
+}
+
+void SpeciesMoveUI::Private::refreshGui()
+{
+    const bool blocked = ui_move->blockSignals(true);
+    ui_move->clear();
+    for (int i = 0; i < m_move->game()->moveCount(); ++i)
+        ui_move->addItem(m_move->game()->move(i)->name());
+    ui_move->blockSignals(blocked);
+    ui_level->setMaximum(m_move->game()->rules()->maxLevel());
+    ui_wildLevel->setMaximum(m_move->game()->rules()->maxLevel());
+}
+
+void SpeciesMoveUI::Private::resetGui()
 {
-    *qobject_cast<SpeciesMove*>(modified()) = *qobject_cast<SpeciesMove*>(original());
-    setGui();
-    emit(changed(false));
+    ui_move->setCurrentIndex(m_move->game()->moveIndex(m_move->move()));
+    ui_level->setValue(m_move->level());
+    ui_wildLevel->setValue(m_move->wild());
 }
 
-void SpeciesMoveUI::moveChanged(const int move)
+void SpeciesMoveUI::Private::moveChanged(const int move)
 {
     if (0 <= move)
-        qobject_cast<SpeciesMove*>(modified())->setMove(game()->move(move)->id());
+        m_move->setMove(m_move->game()->move(move)->id());
 }
 
-void SpeciesMoveUI::levelChanged(const int level)
+void SpeciesMoveUI::Private::levelChanged(const int level)
 {
-    qobject_cast<SpeciesMove*>(modified())->setLevel(level);
+    m_move->setLevel(level);
 }
 
-void SpeciesMoveUI::wildLevelChanged(const int wildLevel)
+void SpeciesMoveUI::Private::wildLevelChanged(const int wildLevel)
 {
-    qobject_cast<SpeciesMove*>(modified())->setWild(wildLevel);
+    m_move->setWild(wildLevel);
 }
diff --git a/sigmodr/widgets/SpeciesUI.cpp b/sigmodr/widgets/SpeciesUI.cpp
index 9268d8be..7b64c5ae 100644
--- a/sigmodr/widgets/SpeciesUI.cpp
+++ b/sigmodr/widgets/SpeciesUI.cpp
@@ -17,13 +17,14 @@
 
 // Header include
 #include "SpeciesUI.h"
+#include "SpeciesUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/FractionWidget.h>
 #include <sigmodr/corewidgets/ScriptWidget.h>
 
 // Sigmod includes
-#include <sigmod/Ability.h>
+#include <sigmod/Species.h>
 #include <sigmod/EggGroup.h>
 #include <sigmod/Game.h>
 #include <sigmod/Item.h>
@@ -40,15 +41,12 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
 #include <QtGui/QGroupBox>
 #include <QtGui/QHeaderView>
 #include <QtGui/QListWidget>
 #include <QtGui/QTableWidget>
 #include <QtGui/QTableWidgetItem>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -56,55 +54,76 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 SpeciesUI::SpeciesUI(Species* species, QWidget* parent) :
-        ObjectUI(parent)
-{
-    setObjects(species, new Species(*species));
-}
-
-void SpeciesUI::initGui()
-{
-    QFile file(":/gui/species.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_baseStat = formWidget->findChild<QTableWidget*>("varBaseStat");
-    ui_baseStatValue = formWidget->findChild<KIntNumInput*>("varBaseStatValue");
-    ui_boxEffortValues = formWidget->findChild<QGroupBox*>("boxEffortValues");
-    ui_effortValue = formWidget->findChild<QTableWidget*>("varEffortValue");
-    ui_effortValueValue = formWidget->findChild<KIntNumInput*>("varEffortValueValue");
-    ui_growth = formWidget->findChild<KComboBox*>("varGrowth");
-    ui_experienceValue = formWidget->findChild<KIntNumInput*>("varExperienceValue");
-    ui_catchValue = formWidget->findChild<KIntNumInput*>("varCatchValue");
-    ui_maxHoldWeight = formWidget->findChild<KIntNumInput*>("varMaxHoldWeight");
-    ui_runChance = formWidget->findChild<FractionWidget*>("varRunChance");
-    ui_fleeChance = formWidget->findChild<FractionWidget*>("varFleeChance");
-    ui_itemChance = formWidget->findChild<FractionWidget*>("varItemChance");
-    ui_encyclopediaNumber = formWidget->findChild<KIntNumInput*>("varEncyclopediaNumber");
-    ui_weight = formWidget->findChild<KIntNumInput*>("varWeight");
-    ui_height = formWidget->findChild<KIntNumInput*>("varHeight");
-    ui_encyclopediaEntry = formWidget->findChild<KLineEdit*>("varEncyclopediaEntry");
-    ui_maleFront = formWidget->findChild<KComboBox*>("varMaleFront");
-    ui_maleBack = formWidget->findChild<KComboBox*>("varMaleBack");
-    ui_femaleFront = formWidget->findChild<KComboBox*>("varFemaleFront");
-    ui_femaleBack = formWidget->findChild<KComboBox*>("varFemaleBack");
-    ui_skin = formWidget->findChild<KComboBox*>("varSkin");
-    ui_genetics = formWidget->findChild<QWidget*>("tabGenetics");
-    ui_hasGender = formWidget->findChild<QCheckBox*>("varHasGender");
-    ui_genderChance = formWidget->findChild<FractionWidget*>("varGenderChance");
-    ui_boxEggGroups = formWidget->findChild<QGroupBox*>("boxEggGroups");
-    ui_eggSpecies = formWidget->findChild<KComboBox*>("varEggSpecies");
-    ui_eggSteps = formWidget->findChild<KIntNumInput*>("varEggSteps");
-    ui_evolution = formWidget->findChild<ScriptWidget*>("varEvolution");
-    ui_types = formWidget->findChild<KActionSelector*>("varTypes");
-    ui_eggGroups = formWidget->findChild<KActionSelector*>("varEggGroups");
-    ui_boxAbilities = formWidget->findChild<QGroupBox*>("boxAbilities");
-    ui_abilities = formWidget->findChild<KActionSelector*>("varAbilities");
-    ui_abilityWeight = formWidget->findChild<KIntNumInput*>("varAbilityWeight");
-    ui_boxItems = formWidget->findChild<QGroupBox*>("boxItems");
-    ui_items = formWidget->findChild<KActionSelector*>("varItems");
-    ui_itemWeight = formWidget->findChild<KIntNumInput*>("varItemWeight");
-    ui_growth->addItems(Species::StyleStr);
+        ObjectUI(species, parent),
+        d(new Private(new Species(*species)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void SpeciesUI::apply()
+{
+    *qobject_cast<Species*>(m_object) = *d->m_species;
+    ObjectUI::apply();
+}
+
+void SpeciesUI::discard()
+{
+    *d->m_species = *qobject_cast<Species*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+SpeciesUI::Private::Private(Species* species) :
+        ObjectUIPrivate(species),
+        m_species(species)
+{
+}
+
+SpeciesUI::Private::~Private()
+{
+    delete m_species;
+}
+
+QWidget* SpeciesUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/species.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_baseStat = form->findChild<QTableWidget*>("varBaseStat");
+    ui_baseStatValue = form->findChild<KIntNumInput*>("varBaseStatValue");
+    ui_boxEffortValues = form->findChild<QGroupBox*>("boxEffortValues");
+    ui_effortValue = form->findChild<QTableWidget*>("varEffortValue");
+    ui_effortValueValue = form->findChild<KIntNumInput*>("varEffortValueValue");
+    ui_growth = form->findChild<KComboBox*>("varGrowth");
+    ui_experienceValue = form->findChild<KIntNumInput*>("varExperienceValue");
+    ui_catchValue = form->findChild<KIntNumInput*>("varCatchValue");
+    ui_maxHoldWeight = form->findChild<KIntNumInput*>("varMaxHoldWeight");
+    ui_runChance = form->findChild<FractionWidget*>("varRunChance");
+    ui_fleeChance = form->findChild<FractionWidget*>("varFleeChance");
+    ui_itemChance = form->findChild<FractionWidget*>("varItemChance");
+    ui_encyclopediaNumber = form->findChild<KIntNumInput*>("varEncyclopediaNumber");
+    ui_weight = form->findChild<KIntNumInput*>("varWeight");
+    ui_height = form->findChild<KIntNumInput*>("varHeight");
+    ui_encyclopediaEntry = form->findChild<KLineEdit*>("varEncyclopediaEntry");
+    ui_maleFront = form->findChild<KComboBox*>("varMaleFront");
+    ui_maleBack = form->findChild<KComboBox*>("varMaleBack");
+    ui_femaleFront = form->findChild<KComboBox*>("varFemaleFront");
+    ui_femaleBack = form->findChild<KComboBox*>("varFemaleBack");
+    ui_skin = form->findChild<KComboBox*>("varSkin");
+    ui_genetics = form->findChild<QWidget*>("tabGenetics");
+    ui_hasGender = form->findChild<QCheckBox*>("varHasGender");
+    ui_genderChance = form->findChild<FractionWidget*>("varGenderChance");
+    ui_boxEggGroups = form->findChild<QGroupBox*>("boxEggGroups");
+    ui_eggSpecies = form->findChild<KComboBox*>("varEggSpecies");
+    ui_eggSteps = form->findChild<KIntNumInput*>("varEggSteps");
+    ui_evolution = form->findChild<ScriptWidget*>("varEvolution");
+    ui_types = form->findChild<KActionSelector*>("varTypes");
+    ui_eggGroups = form->findChild<KActionSelector*>("varEggGroups");
+    ui_boxAbilities = form->findChild<QGroupBox*>("boxAbilities");
+    ui_abilities = form->findChild<KActionSelector*>("varAbilities");
+    ui_abilityWeight = form->findChild<KIntNumInput*>("varAbilityWeight");
+    ui_boxItems = form->findChild<QGroupBox*>("boxItems");
+    ui_items = form->findChild<KActionSelector*>("varItems");
+    ui_itemWeight = form->findChild<KIntNumInput*>("varItemWeight");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_baseStat, SIGNAL(currentCellChanged(int,int,int,int)), this, SLOT(baseStatChanged(int)));
     connect(ui_baseStatValue, SIGNAL(valueChanged(int)), this, SLOT(baseStatValueChanged(int)));
@@ -141,18 +160,17 @@ void SpeciesUI::initGui()
     connect(ui_items, SIGNAL(added(QListWidgetItem*)), this, SLOT(itemAdded(QListWidgetItem*)));
     connect(ui_items, SIGNAL(removed(QListWidgetItem*)), this, SLOT(itemRemoved(QListWidgetItem*)));
     connect(ui_itemWeight, SIGNAL(valueChanged(int)), this, SLOT(itemWeightChanged(int)));
-    connect(ui_abilities->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(abilityChanged(QListWidgetItem*)));
+    connect(ui_abilities->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(speciesChanged(QListWidgetItem*)));
     connect(ui_items->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(itemChanged(QListWidgetItem*)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    ui_growth->addItems(Species::StyleStr);
     ui_baseStat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
     ui_effortValue->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+    return form;
 }
 
-void SpeciesUI::refreshGui()
+void SpeciesUI::Private::refreshGui()
 {
-    const bool isSplit = game()->rules()->specialSplit();
+    const bool isSplit = m_species->game()->rules()->specialSplit();
     ui_baseStat->clear();
     ui_baseStat->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
     ui_baseStat->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
@@ -168,6 +186,7 @@ void SpeciesUI::refreshGui()
     }
     else
         ui_baseStat->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
+    ui_baseStatValue->setEnabled(false);
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     ui_baseStat->setItem(ST_Attack - ST_Attack, 0, item);
@@ -193,7 +212,7 @@ void SpeciesUI::refreshGui()
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
         ui_baseStat->setItem(ST_Special - ST_Attack, 0, item);
     }
-    if (game()->rules()->effortValuesAllowed())
+    if (m_species->game()->rules()->effortValuesAllowed())
     {
         ui_effortValue->clear();
         ui_effortValue->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
@@ -210,6 +229,7 @@ void SpeciesUI::refreshGui()
         }
         else
             ui_effortValue->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
+        ui_effortValue->setEnabled(false);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
         ui_effortValue->setItem(ST_Attack - ST_Attack, 0, item);
@@ -238,7 +258,7 @@ void SpeciesUI::refreshGui()
     }
     else
         ui_boxEffortValues->setEnabled(false);
-    if (!game()->rules()->maxHeldItems())
+    if (!m_species->game()->rules()->maxHeldItems())
         ui_itemChance->setEnabled(false);
     int maxHeight = 0;
     int maxWidth = 0;
@@ -250,9 +270,9 @@ void SpeciesUI::refreshGui()
     ui_femaleFront->clear();
     const bool blockedFemaleBack = ui_femaleBack->blockSignals(true);
     ui_femaleBack->clear();
-    for (int i = 0; i < game()->spriteCount(); ++i)
+    for (int i = 0; i < m_species->game()->spriteCount(); ++i)
     {
-        const Sprite* sprite = game()->sprite(i);
+        const Sprite* sprite = m_species->game()->sprite(i);
         QPixmap icon;
         icon.loadFromData(sprite->sprite());
         maxHeight = qMax(maxHeight, icon.height());
@@ -271,38 +291,38 @@ void SpeciesUI::refreshGui()
     ui_maleBack->setIconSize(maxSize);
     ui_femaleFront->setIconSize(maxSize);
     ui_femaleBack->setIconSize(maxSize);
-    ui_femaleFront->setEnabled(game()->rules()->genderAllowed());
-    ui_femaleBack->setEnabled(game()->rules()->genderAllowed());
+    ui_femaleFront->setEnabled(m_species->game()->rules()->genderAllowed());
+    ui_femaleBack->setEnabled(m_species->game()->rules()->genderAllowed());
     const bool blockedSkin = ui_skin->blockSignals(true);
     ui_skin->clear();
-    for (int i = 0; i < game()->skinCount(); ++i)
-        ui_skin->addItem(game()->skin(i)->name());
+    for (int i = 0; i < m_species->game()->skinCount(); ++i)
+        ui_skin->addItem(m_species->game()->skin(i)->name());
     ui_skin->blockSignals(blockedSkin);
     const bool blockedEggSpecies = ui_eggSpecies->blockSignals(true);
     ui_eggSpecies->clear();
-    for (int i = 0; i < game()->speciesCount(); ++i)
-        ui_eggSpecies->addItem(game()->species(i)->name());
-    ui_eggSpecies->setEnabled(game()->rules()->breedingAllowed());
+    for (int i = 0; i < m_species->game()->speciesCount(); ++i)
+        ui_eggSpecies->addItem(m_species->game()->species(i)->name());
+    ui_eggSpecies->setEnabled(m_species->game()->rules()->breedingAllowed());
     ui_eggSpecies->blockSignals(blockedEggSpecies);
-    ui_eggSteps->setEnabled(game()->rules()->breedingAllowed());
+    ui_eggSteps->setEnabled(m_species->game()->rules()->breedingAllowed());
     const bool blockedEggGroups = ui_eggGroups->blockSignals(true);
     ui_eggGroups->availableListWidget()->clear();
     ui_eggGroups->selectedListWidget()->clear();
-    for (int i = 0; i < game()->eggGroupCount(); ++i)
+    for (int i = 0; i < m_species->game()->eggGroupCount(); ++i)
     {
-        const EggGroup* eggGroup = game()->eggGroup(i);
+        const EggGroup* eggGroup = m_species->game()->eggGroup(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(eggGroup->name(), ui_eggGroups->availableListWidget());
         widgetItem->setData(Qt::UserRole, eggGroup->id());
     }
     ui_eggGroups->blockSignals(blockedEggGroups);
     ui_eggGroups->setButtonsEnabled();
-    ui_genetics->setEnabled(game()->rules()->genderAllowed());
+    ui_genetics->setEnabled(m_species->game()->rules()->genderAllowed());
     const bool blockedTypes = ui_types->blockSignals(true);
     ui_types->availableListWidget()->clear();
     ui_types->selectedListWidget()->clear();
-    for (int i = 0; i < game()->typeCount(); ++i)
+    for (int i = 0; i < m_species->game()->typeCount(); ++i)
     {
-        const Type* type = game()->type(i);
+        const Type* type = m_species->game()->type(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(type->name(), ui_types->selectedListWidget());
         widgetItem->setData(Qt::UserRole, type->id());
     }
@@ -311,372 +331,345 @@ void SpeciesUI::refreshGui()
     const bool blockedAbilities = ui_abilities->blockSignals(true);
     ui_abilities->availableListWidget()->clear();
     ui_abilities->selectedListWidget()->clear();
-    for (int i = 0; i < game()->abilityCount(); ++i)
+    for (int i = 0; i < m_species->game()->speciesCount(); ++i)
     {
-        const Ability* ability = game()->ability(i);
-        QListWidgetItem* widgetItem = new QListWidgetItem(ability->name(), ui_abilities->availableListWidget());
-        widgetItem->setData(Qt::UserRole, ability->id());
+        const Species* species = m_species->game()->species(i);
+        QListWidgetItem* widgetItem = new QListWidgetItem(species->name(), ui_abilities->availableListWidget());
+        widgetItem->setData(Qt::UserRole, species->id());
     }
     ui_abilities->blockSignals(blockedAbilities);
     ui_abilities->setButtonsEnabled();
-    ui_boxAbilities->setEnabled(game()->rules()->maxAbilities());
+    ui_abilityWeight->setEnabled(false);
+    ui_boxAbilities->setEnabled(m_species->game()->rules()->maxAbilities());
     const bool blockedItems = ui_items->blockSignals(true);
     ui_items->availableListWidget()->clear();
     ui_items->selectedListWidget()->clear();
-    for (int i = 0; i < game()->itemCount(); ++i)
+    for (int i = 0; i < m_species->game()->itemCount(); ++i)
     {
-        const Item* item = game()->item(i);
+        const Item* item = m_species->game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), ui_items->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
     ui_items->blockSignals(blockedItems);
     ui_items->setButtonsEnabled();
-    ui_boxItems->setEnabled(game()->rules()->maxHeldItems());
+    ui_itemWeight->setEnabled(false);
+    ui_boxItems->setEnabled(m_species->game()->rules()->maxHeldItems());
 }
 
-void SpeciesUI::setGui()
+void SpeciesUI::Private::resetGui()
 {
-    ui_name->setText(qobject_cast<Species*>(modified())->name());
-    ui_baseStat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Attack)));
-    ui_baseStat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Defense)));
-    ui_baseStat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Speed)));
-    if (game()->rules()->specialSplit())
+    ui_name->setText(m_species->name());
+    ui_baseStat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_Attack)));
+    ui_baseStat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_Defense)));
+    ui_baseStat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_Speed)));
+    if (m_species->game()->rules()->specialSplit())
     {
-        ui_baseStat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_SpecialAttack)));
-        ui_baseStat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_SpecialDefense)));
+        ui_baseStat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_SpecialAttack)));
+        ui_baseStat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_SpecialDefense)));
     }
     else
-        ui_baseStat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Special)));
-    ui_baseStatValue->setValue(qobject_cast<Species*>(modified())->baseStat(ui_baseStat->verticalHeaderItem(ui_baseStat->currentRow())->data(Qt::UserRole).value<Stat>()));
-    if (game()->rules()->effortValuesAllowed())
+        ui_baseStat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->baseStat(ST_Special)));
+    if (m_species->game()->rules()->effortValuesAllowed())
     {
-        ui_effortValue->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Attack)));
-        ui_effortValue->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Defense)));
-        ui_effortValue->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Speed)));
-        if (game()->rules()->specialSplit())
+        ui_effortValue->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_Attack)));
+        ui_effortValue->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_Defense)));
+        ui_effortValue->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_Speed)));
+        if (m_species->game()->rules()->specialSplit())
         {
-            ui_effortValue->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_SpecialAttack)));
-            ui_effortValue->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_SpecialDefense)));
+            ui_effortValue->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_SpecialAttack)));
+            ui_effortValue->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_SpecialDefense)));
         }
         else
-            ui_effortValue->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Special)));
-        ui_effortValueValue->setValue(qobject_cast<Species*>(modified())->effortValue(ui_effortValue->verticalHeaderItem(ui_effortValue->currentRow())->data(Qt::UserRole).value<Stat>()));
+            ui_effortValue->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_species->effortValue(ST_Special)));
     }
-    ui_growth->setCurrentIndex(qobject_cast<Species*>(modified())->growth());
-    ui_experienceValue->setValue(qobject_cast<Species*>(modified())->experienceValue());
-    ui_catchValue->setValue(qobject_cast<Species*>(modified())->catchValue());
-    ui_maxHoldWeight->setValue(qobject_cast<Species*>(modified())->maxHoldWeight());
-    ui_runChance->setValue(qobject_cast<Species*>(modified())->runChance());
-    ui_fleeChance->setValue(qobject_cast<Species*>(modified())->fleeChance());
-    ui_itemChance->setValue(qobject_cast<Species*>(modified())->itemChance());
-    ui_encyclopediaNumber->setValue(qobject_cast<Species*>(modified())->encyclopediaNumber());
-    ui_weight->setValue(qobject_cast<Species*>(modified())->weight());
-    ui_height->setValue(qobject_cast<Species*>(modified())->height());
-    ui_encyclopediaEntry->setText(qobject_cast<Species*>(modified())->encyclopediaEntry());
-    ui_maleFront->setCurrentIndex(game()->spriteIndex(qobject_cast<Species*>(modified())->frontMaleSprite()));
-    ui_maleBack->setCurrentIndex(game()->spriteIndex(qobject_cast<Species*>(modified())->backMaleSprite()));
-    ui_maleFront->setEnabled(qobject_cast<Species*>(modified())->genderFactor() < 1);
-    ui_maleBack->setEnabled(qobject_cast<Species*>(modified())->genderFactor() < 1);
-    if (game()->rules()->genderAllowed())
-    {
-        ui_femaleFront->setCurrentIndex(game()->spriteIndex(qobject_cast<Species*>(modified())->frontFemaleSprite()));
-        ui_femaleBack->setCurrentIndex(game()->spriteIndex(qobject_cast<Species*>(modified())->backFemaleSprite()));
-        ui_femaleFront->setEnabled(0 < qobject_cast<Species*>(modified())->genderFactor());
-        ui_femaleBack->setEnabled(0 < qobject_cast<Species*>(modified())->genderFactor());
-    }
-    ui_skin->setCurrentIndex(ui_skin->findData(qobject_cast<Species*>(modified())->skin()));
-    ui_hasGender->setCheckState((qobject_cast<Species*>(modified())->genderFactor() < 0) ? Qt::Checked : Qt::Unchecked);
-    ui_genderChance->setValue(qobject_cast<Species*>(modified())->genderFactor());
-    ui_boxEggGroups->setEnabled(game()->rules()->breedingAllowed() && qobject_cast<Species*>(modified())->eggGroup().size());
-    ui_eggSpecies->setCurrentIndex(game()->speciesIndex(qobject_cast<Species*>(modified())->eggSpecies()));
-    ui_eggSteps->setValue(qobject_cast<Species*>(modified())->eggSteps());
-    ui_evolution->setValue(qobject_cast<Species*>(modified())->evolution());
+    ui_growth->setCurrentIndex(m_species->growth());
+    ui_experienceValue->setValue(m_species->experienceValue());
+    ui_catchValue->setValue(m_species->catchValue());
+    ui_maxHoldWeight->setValue(m_species->maxHoldWeight());
+    ui_runChance->setValue(m_species->runChance());
+    ui_fleeChance->setValue(m_species->fleeChance());
+    ui_itemChance->setValue(m_species->itemChance());
+    ui_encyclopediaNumber->setValue(m_species->encyclopediaNumber());
+    ui_weight->setValue(m_species->weight());
+    ui_height->setValue(m_species->height());
+    ui_encyclopediaEntry->setText(m_species->encyclopediaEntry());
+    ui_maleFront->setCurrentIndex(m_species->game()->spriteIndex(m_species->frontMaleSprite()));
+    ui_maleBack->setCurrentIndex(m_species->game()->spriteIndex(m_species->backMaleSprite()));
+    ui_femaleFront->setCurrentIndex(m_species->game()->spriteIndex(m_species->frontFemaleSprite()));
+    ui_femaleBack->setCurrentIndex(m_species->game()->spriteIndex(m_species->backFemaleSprite()));
+    ui_skin->setCurrentIndex(ui_skin->findData(m_species->skin()));
+    ui_hasGender->setCheckState((m_species->genderFactor() < 0) ? Qt::Checked : Qt::Unchecked);
+    ui_genderChance->setValue(m_species->genderFactor());
+    ui_eggSpecies->setCurrentIndex(m_species->game()->speciesIndex(m_species->eggSpecies()));
+    ui_eggSteps->setValue(m_species->eggSteps());
+    ui_evolution->setValue(m_species->evolution());
     for (int i = 0; i < ui_types->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_types->availableListWidget()->item(i);
-        if (qobject_cast<Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_species->type(widgetItem->data(Qt::UserRole).toInt()))
             ui_types->selectedListWidget()->addItem(ui_types->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_types->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_types->selectedListWidget()->item(i);
-        if (!qobject_cast<Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_species->type(widgetItem->data(Qt::UserRole).toInt()))
             ui_types->availableListWidget()->addItem(ui_types->selectedListWidget()->takeItem(i--));
     }
     ui_types->setButtonsEnabled();
     for (int i = 0; i < ui_eggGroups->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_eggGroups->availableListWidget()->item(i);
-        if (qobject_cast<Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_species->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
             ui_eggGroups->selectedListWidget()->addItem(ui_eggGroups->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_eggGroups->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_eggGroups->selectedListWidget()->item(i);
-        if (!qobject_cast<Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_species->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
             ui_eggGroups->availableListWidget()->addItem(ui_eggGroups->selectedListWidget()->takeItem(i--));
     }
     ui_eggGroups->setButtonsEnabled();
     for (int i = 0; i < ui_abilities->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_abilities->availableListWidget()->item(i);
-        if (qobject_cast<Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_species->ability(widgetItem->data(Qt::UserRole).toInt()))
             ui_abilities->selectedListWidget()->addItem(ui_abilities->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_abilities->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_abilities->selectedListWidget()->item(i);
-        if (!qobject_cast<Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_species->ability(widgetItem->data(Qt::UserRole).toInt()))
             ui_abilities->availableListWidget()->addItem(ui_abilities->selectedListWidget()->takeItem(i--));
     }
     ui_abilities->setButtonsEnabled();
-    QListWidgetItem* selectedAbility= ui_abilities->selectedListWidget()->currentItem();
-    if (selectedAbility)
-        ui_abilityWeight->setValue(qobject_cast<Species*>(modified())->ability(selectedAbility->data(Qt::UserRole).toInt()));
     for (int i = 0; i < ui_items->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->availableListWidget()->item(i);
-        if (qobject_cast<Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_species->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->selectedListWidget()->addItem(ui_items->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_items->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->selectedListWidget()->item(i);
-        if (!qobject_cast<Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_species->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->availableListWidget()->addItem(ui_items->selectedListWidget()->takeItem(i--));
     }
     ui_items->setButtonsEnabled();
-    QListWidgetItem* selectedItem = ui_items->selectedListWidget()->currentItem();
-    if (selectedItem)
-        ui_itemWeight->setValue(qobject_cast<Species*>(modified())->ability(selectedItem->data(Qt::UserRole).toInt()));
-}
-
-void SpeciesUI::apply()
-{
-    *qobject_cast<Species*>(original()) = *qobject_cast<Species*>(modified());
-    emit(changed(false));
 }
 
-void SpeciesUI::discard()
-{
-    *qobject_cast<Species*>(modified()) = *qobject_cast<Species*>(original());
-    setGui();
-    emit(changed(false));
-}
-
-void SpeciesUI::nameChanged(const QString& name)
+void SpeciesUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Species*>(modified())->setName(name);
+    m_species->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void SpeciesUI::baseStatChanged(const int row)
+void SpeciesUI::Private::baseStatChanged(const int row)
 {
-    ui_baseStatValue->setValue(qobject_cast<Species*>(modified())->baseStat(ui_baseStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
+    ui_baseStatValue->setEnabled(true);
+    ui_baseStatValue->setValue(m_species->baseStat(ui_baseStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void SpeciesUI::baseStatValueChanged(const int baseStat)
+void SpeciesUI::Private::baseStatValueChanged(const int baseStat)
 {
-    qobject_cast<Species*>(modified())->setBaseStat(ui_baseStat->verticalHeaderItem(ui_baseStat->currentRow())->data(Qt::UserRole).value<Stat>(), baseStat);
+    m_species->setBaseStat(ui_baseStat->verticalHeaderItem(ui_baseStat->currentRow())->data(Qt::UserRole).value<Stat>(), baseStat);
 }
 
-void SpeciesUI::effortValueChanged(const int row)
+void SpeciesUI::Private::effortValueChanged(const int row)
 {
-    ui_effortValueValue->setValue(qobject_cast<Species*>(modified())->effortValue(ui_effortValue->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
+    ui_effortValueValue->setEnabled(true);
+    ui_effortValueValue->setValue(m_species->effortValue(ui_effortValue->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void SpeciesUI::effortValueValueChanged(const int effortValue)
+void SpeciesUI::Private::effortValueValueChanged(const int effortValue)
 {
-    qobject_cast<Species*>(modified())->setEffortValue(ui_effortValue->verticalHeaderItem(ui_effortValue->currentRow())->data(Qt::UserRole).value<Stat>(), effortValue);
+    m_species->setEffortValue(ui_effortValue->verticalHeaderItem(ui_effortValue->currentRow())->data(Qt::UserRole).value<Stat>(), effortValue);
 }
 
-void SpeciesUI::growthChanged(const int growth)
+void SpeciesUI::Private::growthChanged(const int growth)
 {
-    qobject_cast<Species*>(modified())->setGrowth(static_cast<Species::Style>(growth));
+    m_species->setGrowth(static_cast<Species::Style>(growth));
 }
 
-void SpeciesUI::experienceValueChanged(const int experienceValue)
+void SpeciesUI::Private::experienceValueChanged(const int experienceValue)
 {
-    qobject_cast<Species*>(modified())->setExperienceValue(experienceValue);
+    m_species->setExperienceValue(experienceValue);
 }
 
-void SpeciesUI::catchValueChanged(const int catchValue)
+void SpeciesUI::Private::catchValueChanged(const int catchValue)
 {
-    qobject_cast<Species*>(modified())->setCatchValue(catchValue);
+    m_species->setCatchValue(catchValue);
 }
 
-void SpeciesUI::maxHoldWeightChanged(const int maxHoldWeight)
+void SpeciesUI::Private::maxHoldWeightChanged(const int maxHoldWeight)
 {
-    qobject_cast<Species*>(modified())->setMaxHoldWeight(maxHoldWeight);
+    m_species->setMaxHoldWeight(maxHoldWeight);
 }
 
-void SpeciesUI::runChanceChanged(const Fraction& runChance)
+void SpeciesUI::Private::runChanceChanged(const Fraction& runChance)
 {
-    qobject_cast<Species*>(modified())->setRunChance(runChance);
+    m_species->setRunChance(runChance);
 }
 
-void SpeciesUI::fleeChanceChanged(const Fraction& fleeChance)
+void SpeciesUI::Private::fleeChanceChanged(const Fraction& fleeChance)
 {
-    qobject_cast<Species*>(modified())->setFleeChance(fleeChance);
+    m_species->setFleeChance(fleeChance);
 }
 
-void SpeciesUI::itemChanceChanged(const Fraction& itemChance)
+void SpeciesUI::Private::itemChanceChanged(const Fraction& itemChance)
 {
-    qobject_cast<Species*>(modified())->setItemChance(itemChance);
+    m_species->setItemChance(itemChance);
 }
 
-void SpeciesUI::encyclopediaNumberChanged(const int encyclopediaNumber)
+void SpeciesUI::Private::encyclopediaNumberChanged(const int encyclopediaNumber)
 {
-    qobject_cast<Species*>(modified())->setEncyclopediaNumber(encyclopediaNumber);
+    m_species->setEncyclopediaNumber(encyclopediaNumber);
 }
 
-void SpeciesUI::weightChanged(const int weight)
+void SpeciesUI::Private::weightChanged(const int weight)
 {
-    qobject_cast<Species*>(modified())->setWeight(weight);
+    m_species->setWeight(weight);
 }
 
-void SpeciesUI::heightChanged(const int height)
+void SpeciesUI::Private::heightChanged(const int height)
 {
-    qobject_cast<Species*>(modified())->setHeight(height);
+    m_species->setHeight(height);
 }
 
-void SpeciesUI::encyclopediaEntryChanged(const QString& encyclopediaEntry)
+void SpeciesUI::Private::encyclopediaEntryChanged(const QString& encyclopediaEntry)
 {
     const int cursor = ui_encyclopediaEntry->cursorPosition();
-    qobject_cast<Species*>(modified())->setEncyclopediaEntry(encyclopediaEntry);
+    m_species->setEncyclopediaEntry(encyclopediaEntry);
     ui_encyclopediaEntry->setCursorPosition(cursor);
 }
 
-void SpeciesUI::maleFrontChanged(const int maleFront)
+void SpeciesUI::Private::maleFrontChanged(const int maleFront)
 {
     if (0 <= maleFront)
-        qobject_cast<Species*>(modified())->setFrontMaleSprite(game()->sprite(maleFront)->id());
+        m_species->setFrontMaleSprite(m_species->game()->sprite(maleFront)->id());
 }
 
-void SpeciesUI::maleBackChanged(const int maleBack)
+void SpeciesUI::Private::maleBackChanged(const int maleBack)
 {
     if (0 <= maleBack)
-        qobject_cast<Species*>(modified())->setBackMaleSprite(game()->sprite(maleBack)->id());
+        m_species->setBackMaleSprite(m_species->game()->sprite(maleBack)->id());
 }
 
-void SpeciesUI::femaleFrontChanged(const int femaleFront)
+void SpeciesUI::Private::femaleFrontChanged(const int femaleFront)
 {
     if (0 <= femaleFront)
-        qobject_cast<Species*>(modified())->setFrontFemaleSprite(game()->sprite(femaleFront)->id());
+        m_species->setFrontFemaleSprite(m_species->game()->sprite(femaleFront)->id());
 }
 
-void SpeciesUI::femaleBackChanged(const int femaleBack)
+void SpeciesUI::Private::femaleBackChanged(const int femaleBack)
 {
     if (0 <= femaleBack)
-        qobject_cast<Species*>(modified())->setBackFemaleSprite(game()->sprite(femaleBack)->id());
+        m_species->setBackFemaleSprite(m_species->game()->sprite(femaleBack)->id());
 }
 
-void SpeciesUI::skinChanged(const int skin)
+void SpeciesUI::Private::skinChanged(const int skin)
 {
     if (0 <= skin)
-        qobject_cast<Species*>(modified())->setSkin(game()->skin(skin)->id());
+        m_species->setSkin(m_species->game()->skin(skin)->id());
 }
 
-void SpeciesUI::hasGenderChanged(const bool hasGender)
+void SpeciesUI::Private::hasGenderChanged(const bool hasGender)
 {
-    qobject_cast<Species*>(modified())->setGenderFactor(Fraction((hasGender ? 1 : -1), 1));
+    m_species->setGenderFactor(Fraction((hasGender ? 1 : -1), 1));
+    ui_femaleFront->setEnabled(0 < m_species->genderFactor());
+    ui_femaleBack->setEnabled(0 < m_species->genderFactor());
 }
 
-void SpeciesUI::genderChanceChanged(const Fraction& genderChance)
+void SpeciesUI::Private::genderChanceChanged(const Fraction& genderChance)
 {
-    qobject_cast<Species*>(modified())->setGenderFactor(genderChance);
+    m_species->setGenderFactor(genderChance);
+    ui_maleFront->setEnabled(genderChance < 1);
+    ui_maleBack->setEnabled(genderChance < 1);
+    ui_femaleFront->setEnabled(0 < genderChance);
+    ui_femaleBack->setEnabled(0 < genderChance);
 }
 
-void SpeciesUI::eggSpeciesChanged(const int eggSpecies)
+void SpeciesUI::Private::eggSpeciesChanged(const int eggSpecies)
 {
-    qobject_cast<Species*>(modified())->setEggSpecies(game()->species(eggSpecies)->id());
+    m_species->setEggSpecies(m_species->game()->species(eggSpecies)->id());
 }
 
-void SpeciesUI::eggStepsChanged(const int eggSteps)
+void SpeciesUI::Private::eggStepsChanged(const int eggSteps)
 {
-    qobject_cast<Species*>(modified())->setEggSteps(eggSteps);
+    m_species->setEggSteps(eggSteps);
 }
 
-void SpeciesUI::evolutionChanged(const Script& evolution)
+void SpeciesUI::Private::evolutionChanged(const Script& evolution)
 {
-    qobject_cast<Species*>(modified())->setEvolution(evolution);
+    m_species->setEvolution(evolution);
 }
 
-void SpeciesUI::typeAdded(QListWidgetItem* item)
+void SpeciesUI::Private::typeAdded(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_species->setType(item->data(Qt::UserRole).toInt(), true);
 }
 
-void SpeciesUI::typeRemoved(QListWidgetItem* item)
+void SpeciesUI::Private::typeRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_species->setType(item->data(Qt::UserRole).toInt(), false);
 }
 
-void SpeciesUI::eggGroupAdded(QListWidgetItem* item)
+void SpeciesUI::Private::eggGroupAdded(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_species->setEggGroup(item->data(Qt::UserRole).toInt(), true);
+    ui_boxEggGroups->setEnabled(m_species->game()->rules()->breedingAllowed() && m_species->eggGroup().size());
 }
 
-void SpeciesUI::eggGroupRemoved(QListWidgetItem* item)
+void SpeciesUI::Private::eggGroupRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_species->setEggGroup(item->data(Qt::UserRole).toInt(), false);
+    ui_boxEggGroups->setEnabled(m_species->game()->rules()->breedingAllowed() && m_species->eggGroup().size());
 }
 
-void SpeciesUI::abilityAdded(QListWidgetItem* item)
+void SpeciesUI::Private::abilityAdded(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 1);
-    setGui();
+    m_species->setAbility(item->data(Qt::UserRole).toInt(), true);
 }
 
-void SpeciesUI::abilityRemoved(QListWidgetItem* item)
+void SpeciesUI::Private::abilityRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 0);
-    setGui();
+    m_species->setAbility(item->data(Qt::UserRole).toInt(), false);
 }
 
-void SpeciesUI::abilityChanged(QListWidgetItem* item)
+void SpeciesUI::Private::abilityChanged(QListWidgetItem* item)
 {
     if (item)
-        ui_abilityWeight->setValue(qobject_cast<Species*>(modified())->ability(item->data(Qt::UserRole).toInt()));
-    else
-        ui_abilityWeight->setEnabled(false);
+        ui_abilityWeight->setValue(m_species->ability(item->data(Qt::UserRole).toInt()));
+    ui_abilityWeight->setEnabled(!!item);
 }
 
-void SpeciesUI::abilityWeightChanged(const int abilityWeight)
+void SpeciesUI::Private::abilityWeightChanged(const int abilityWeight)
 {
     QListWidgetItem* item = ui_abilities->selectedListWidget()->currentItem();
-    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), abilityWeight);
-    setGui();
+    m_species->setAbility(item->data(Qt::UserRole).toInt(), abilityWeight);
+    emit(changed());
 }
 
-void SpeciesUI::itemAdded(QListWidgetItem* item)
+void SpeciesUI::Private::itemAdded(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
-    setGui();
+    m_species->setItem(item->data(Qt::UserRole).toInt(), 1);
 }
 
-void SpeciesUI::itemRemoved(QListWidgetItem* item)
+void SpeciesUI::Private::itemRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
-    setGui();
+    m_species->setItem(item->data(Qt::UserRole).toInt(), 0);
 }
 
-void SpeciesUI::itemChanged(QListWidgetItem* item)
+void SpeciesUI::Private::itemChanged(QListWidgetItem* item)
 {
     if (item)
-        ui_itemWeight->setValue(qobject_cast<Species*>(modified())->item(item->data(Qt::UserRole).toInt()));
-    else
-        ui_itemWeight->setEnabled(false);
+        ui_itemWeight->setValue(m_species->item(item->data(Qt::UserRole).toInt()));
+    ui_itemWeight->setEnabled(!!item);
 }
 
-void SpeciesUI::itemWeightChanged(const int itemWeight)
+void SpeciesUI::Private::itemWeightChanged(const int itemWeight)
 {
     QListWidgetItem* item = ui_items->selectedListWidget()->currentItem();
-    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemWeight);
-    setGui();
+    m_species->setItem(item->data(Qt::UserRole).toInt(), itemWeight);
+    emit(changed());
 }
diff --git a/sigmodr/widgets/SpriteUI.cpp b/sigmodr/widgets/SpriteUI.cpp
index d17dd98a..7def532f 100644
--- a/sigmodr/widgets/SpriteUI.cpp
+++ b/sigmodr/widgets/SpriteUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "SpriteUI.h"
+#include "SpriteUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -31,68 +32,72 @@
 #include <KIO/NetAccess>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QLabel>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 SpriteUI::SpriteUI(Sprite* sprite, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(sprite, parent),
+        d(new Private(new Sprite(*sprite)))
 {
-    setObjects(sprite, new Sprite(*sprite));
+    setWidget(d->makeWidgets(this));
 }
 
-void SpriteUI::initGui()
+void SpriteUI::apply()
 {
-    QFile file(":/gui/sprite.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_sprite = formWidget->findChild<QLabel*>("varSprite");
-    KPushButton* buttonBrowse = formWidget->findChild<KPushButton*>("buttonBrowse");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(buttonBrowse, SIGNAL(toggled(bool)), this, SLOT(browse()));
-    buttonBrowse->setIcon(KIcon("document-open"));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Sprite*>(m_object) = *d->m_sprite;
+    ObjectUI::apply();
 }
 
-void SpriteUI::setGui()
+void SpriteUI::discard()
 {
-    ui_name->setText(qobject_cast<Sprite*>(modified())->name());
-    QPixmap icon;
-    icon.loadFromData(qobject_cast<Sprite*>(modified())->sprite());
-    ui_sprite->setPixmap(icon);
+    *d->m_sprite = *qobject_cast<Sprite*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void SpriteUI::apply()
+SpriteUI::Private::Private(Sprite* sprite) :
+        ObjectUIPrivate(sprite),
+        m_sprite(sprite)
 {
-    *qobject_cast<Sprite*>(original()) = *qobject_cast<Sprite*>(modified());
-    emit(changed(false));
 }
 
-void SpriteUI::discard()
+SpriteUI::Private::~Private()
+{
+    delete m_sprite;
+}
+
+QWidget* SpriteUI::Private::makeWidgets(ObjectUI* widget)
 {
-    *qobject_cast<Sprite*>(modified()) = *qobject_cast<Sprite*>(original());
-    setGui();
-    emit(changed(false));
+    QWidget *form = openUiFile(":/gui/sprite.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_sprite = form->findChild<QLabel*>("varSprite");
+    KPushButton* buttonBrowse = form->findChild<KPushButton*>("buttonBrowse");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(buttonBrowse, SIGNAL(clicked(bool)), this, SLOT(browse()));
+    buttonBrowse->setIcon(KIcon("document-open"));
+    return form;
+}
+
+void SpriteUI::Private::resetGui()
+{
+    ui_name->setText(m_sprite->name());
+    QPixmap icon;
+    icon.loadFromData(m_sprite->sprite());
+    ui_sprite->setPixmap(icon);
 }
 
-void SpriteUI::nameChanged(const QString& name)
+void SpriteUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sprite*>(modified())->setName(name);
+    m_sprite->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void SpriteUI::browse()
+void SpriteUI::Private::browse()
 {
-    KFileDialog* dialog = new KFileDialog(KUrl("kfiledialog:///image"), "image/png image/jpeg image/tiff image/bmp image/gif", this);
+    KFileDialog* dialog = new KFileDialog(KUrl("kfiledialog:///image"), "image/png image/jpeg image/tiff image/bmp image/gif", NULL);
     dialog->setCaption("Use Image File");
     dialog->setOperationMode(KFileDialog::Opening);
     dialog->setPreviewWidget(new KImageFilePreview);
@@ -108,29 +113,29 @@ void SpriteUI::browse()
                 path = url.path();
             else
             {
-                if (KIO::NetAccess::download(url, path, this))
+                if (KIO::NetAccess::download(url, path, NULL))
                     removeTempFile = true;
                 else
                 {
-                    KMessageBox::error(this, KIO::NetAccess::lastErrorString(), "KIO Error");
+                    KMessageBox::error(NULL, KIO::NetAccess::lastErrorString(), "KIO Error");
                     load = false;
                 }
             }
             if (load)
             {
-                QImage image(url.path());
+                QPixmap image(url.path());
                 QByteArray bytes;
                 QBuffer buffer(&bytes);
                 buffer.open(QIODevice::WriteOnly);
                 image.save(&buffer);
-                qobject_cast<Sprite*>(modified())->setSprite(bytes);
-                setGui();
+                ui_sprite->setPixmap(image);
+                m_sprite->setSprite(bytes);
             }
             if (removeTempFile)
                 KIO::NetAccess::removeTempFile(path);
         }
         else
-            KMessageBox::error(this, "The URL is not valid", "Malformed URL");
+            KMessageBox::error(NULL, "The URL is not valid", "Malformed URL");
     }
     delete dialog;
 }
diff --git a/sigmodr/widgets/SpriteUI_p.h b/sigmodr/widgets/SpriteUI_p.h
index ac3696a2..32af1f7c 100644
--- a/sigmodr/widgets/SpriteUI_p.h
+++ b/sigmodr/widgets/SpriteUI_p.h
@@ -42,7 +42,7 @@ class SpriteUI::Private : public ObjectUIPrivate
         
         QWidget* makeWidgets(ObjectUI* widget);
         
-        Sigmod::Sprite* m_Sprite;
+        Sigmod::Sprite* m_sprite;
     public slots:
         void resetGui();
     protected slots:
diff --git a/sigmodr/widgets/StatusUI.cpp b/sigmodr/widgets/StatusUI.cpp
index f7ea25de..2d3a70b5 100644
--- a/sigmodr/widgets/StatusUI.cpp
+++ b/sigmodr/widgets/StatusUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "StatusUI.h"
+#include "StatusUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -27,72 +28,74 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 StatusUI::StatusUI(Status* status, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(status, parent),
+        d(new Private(new Status(*status)))
 {
-    setObjects(status, new Status(*status));
+    setWidget(d->makeWidgets(this));
 }
 
-void StatusUI::initGui()
+void StatusUI::apply()
 {
-    QFile file(":/gui/status.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_battleScript = formWidget->findChild<ScriptWidget*>("varBattleScript");
-    ui_worldScript = formWidget->findChild<ScriptWidget*>("varWorldScript");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_battleScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(battleScriptChanged(Sigcore::Script)));
-    connect(ui_worldScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(worldScriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Status*>(m_object) = *d->m_status;
+    ObjectUI::apply();
 }
 
-void StatusUI::setGui()
+void StatusUI::discard()
 {
-    ui_name->setText(qobject_cast<Status*>(modified())->name());
-    ui_battleScript->setValue(qobject_cast<Status*>(modified())->battleScript());
-    ui_worldScript->setValue(qobject_cast<Status*>(modified())->worldScript());
+    *d->m_status = *qobject_cast<Status*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void StatusUI::apply()
+StatusUI::Private::Private(Status* status) :
+        ObjectUIPrivate(status),
+        m_status(status)
 {
-    *qobject_cast<Status*>(original()) = *qobject_cast<Status*>(modified());
-    emit(changed(false));
 }
 
-void StatusUI::discard()
+StatusUI::Private::~Private()
+{
+    delete m_status;
+}
+
+QWidget* StatusUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/status.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_battleScript = form->findChild<ScriptWidget*>("varBattleScript");
+    ui_worldScript = form->findChild<ScriptWidget*>("varWorldScript");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_battleScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(battleScriptChanged(Sigcore::Script)));
+    connect(ui_worldScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(worldScriptChanged(Sigcore::Script)));
+    return form;
+}
+
+void StatusUI::Private::resetGui()
 {
-    *qobject_cast<Status*>(modified()) = *qobject_cast<Status*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_status->name());
+    ui_battleScript->setValue(m_status->battleScript());
+    ui_worldScript->setValue(m_status->worldScript());
 }
 
-void StatusUI::nameChanged(const QString& name)
+void StatusUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Status*>(modified())->setName(name);
+    m_status->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void StatusUI::battleScriptChanged(const Script& battleScript)
+void StatusUI::Private::battleScriptChanged(const Script& battleScript)
 {
-    qobject_cast<Status*>(modified())->setBattleScript(battleScript);
+    m_status->setBattleScript(battleScript);
 }
 
-void StatusUI::worldScriptChanged(const Script& worldScript)
+void StatusUI::Private::worldScriptChanged(const Script& worldScript)
 {
-    qobject_cast<Status*>(modified())->setWorldScript(worldScript);
+    m_status->setWorldScript(worldScript);
 }
diff --git a/sigmodr/widgets/StoreUI.cpp b/sigmodr/widgets/StoreUI.cpp
index a4be89db..097e0134 100644
--- a/sigmodr/widgets/StoreUI.cpp
+++ b/sigmodr/widgets/StoreUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "StoreUI.h"
+#include "StoreUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -28,44 +29,61 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QListWidgetItem>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 StoreUI::StoreUI(Store* store, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(store, parent),
+        d(new Private(new Store(*store)))
 {
-    setObjects(store, new Store(*store));
+    setWidget(d->makeWidgets(this));
 }
 
-void StoreUI::initGui()
+void StoreUI::apply()
+{
+    *qobject_cast<Store*>(m_object) = *d->m_store;
+    ObjectUI::apply();
+}
+
+void StoreUI::discard()
+{
+    *d->m_store = *qobject_cast<Store*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+StoreUI::Private::Private(Store* store) :
+        ObjectUIPrivate(store),
+        m_store(store)
+{
+}
+
+StoreUI::Private::~Private()
 {
-    QFile file(":/gui/store.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_items = formWidget->findChild<KActionSelector*>("varItems");
+    delete m_store;
+}
+
+QWidget* StoreUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/store.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_items = form->findChild<KActionSelector*>("varItems");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_items, SIGNAL(added(QListWidgetItem*)), this, SLOT(itemAdded(QListWidgetItem*)));
     connect(ui_items, SIGNAL(removed(QListWidgetItem*)), this, SLOT(itemRemoved(QListWidgetItem*)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void StoreUI::refreshGui()
+void StoreUI::Private::refreshGui()
 {
     const bool blockedItems = ui_items->blockSignals(true);
     ui_items->availableListWidget()->clear();
     ui_items->selectedListWidget()->clear();
-    for (int i = 0; i < game()->itemCount(); ++i)
+    for (int i = 0; i < m_store->game()->itemCount(); ++i)
     {
-        const Item* item = game()->item(i);
+        const Item* item = m_store->game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), ui_items->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
@@ -73,53 +91,37 @@ void StoreUI::refreshGui()
     ui_items->setButtonsEnabled();
 }
 
-void StoreUI::setGui()
+void StoreUI::Private::resetGui()
 {
-    ui_name->setText(qobject_cast<Store*>(modified())->name());
+    ui_name->setText(m_store->name());
     for (int i = 0; i < ui_items->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->availableListWidget()->item(i);
-        if (qobject_cast<Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (m_store->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->selectedListWidget()->addItem(ui_items->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_items->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->selectedListWidget()->item(i);
-        if (!qobject_cast<Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!m_store->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->availableListWidget()->addItem(ui_items->selectedListWidget()->takeItem(i--));
     }
     ui_items->setButtonsEnabled();
 }
 
-void StoreUI::apply()
-{
-    *qobject_cast<Store*>(original()) = *qobject_cast<Store*>(modified());
-    emit(changed(false));
-}
-
-void StoreUI::discard()
-{
-    *qobject_cast<Store*>(modified()) = *qobject_cast<Store*>(original());
-    setGui();
-    emit(changed(false));
-}
-
-void StoreUI::nameChanged(const QString& name)
+void StoreUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Store*>(modified())->setName(name);
+    m_store->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void StoreUI::itemAdded(QListWidgetItem* item)
+void StoreUI::Private::itemAdded(QListWidgetItem* item)
 {
-    qobject_cast<Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), true);
-    setGui();
+    m_store->setItem(item->data(Qt::UserRole).toInt(), true);
 }
 
-void StoreUI::itemRemoved(QListWidgetItem* item)
+void StoreUI::Private::itemRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), false);
-    setGui();
+    m_store->setItem(item->data(Qt::UserRole).toInt(), false);
 }
-
diff --git a/sigmodr/widgets/StoreUI_p.h b/sigmodr/widgets/StoreUI_p.h
index 318004c3..ce0bc136 100644
--- a/sigmodr/widgets/StoreUI_p.h
+++ b/sigmodr/widgets/StoreUI_p.h
@@ -43,7 +43,7 @@ class StoreUI::Private : public ObjectUIPrivate
         
         QWidget* makeWidgets(ObjectUI* widget);
         
-        Sigmod::Store* m_Store;
+        Sigmod::Store* m_store;
     public slots:
         void refreshGui();
         void resetGui();
diff --git a/sigmodr/widgets/TileUI.cpp b/sigmodr/widgets/TileUI.cpp
index ce393e14..476ee52c 100644
--- a/sigmodr/widgets/TileUI.cpp
+++ b/sigmodr/widgets/TileUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "TileUI.h"
+#include "TileUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -30,10 +31,7 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -41,61 +39,68 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 TileUI::TileUI(Tile* tile, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(tile, parent),
+        d(new Private(new Tile(*tile)))
 {
-    setObjects(tile, new Tile(*tile));
+    setWidget(d->makeWidgets(this));
 }
 
-void TileUI::initGui()
+void TileUI::apply()
 {
-    QFile file(":/gui/tile.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_walkable = formWidget->findChild<QCheckBox*>("varWalkable");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_walkable, SIGNAL(toggled(bool)), this, SLOT(walkableChanged(bool)));
-    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Tile*>(m_object) = *d->m_tile;
+    ObjectUI::apply();
 }
 
-void TileUI::setGui()
+void TileUI::discard()
 {
-    ui_name->setText(qobject_cast<Tile*>(modified())->name());
-    ui_walkable->setChecked(qobject_cast<Tile*>(modified())->walkable());
-    ui_script->setValue(qobject_cast<Tile*>(modified())->script());
+    *d->m_tile = *qobject_cast<Tile*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void TileUI::apply()
+TileUI::Private::Private(Tile* tile) :
+        ObjectUIPrivate(tile),
+        m_tile(tile)
 {
-    *qobject_cast<Tile*>(original()) = *qobject_cast<Tile*>(modified());
-    emit(changed(false));
 }
 
-void TileUI::discard()
+TileUI::Private::~Private()
+{
+    delete m_tile;
+}
+
+QWidget* TileUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/tile.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_walkable = form->findChild<QCheckBox*>("varWalkable");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_walkable, SIGNAL(toggled(bool)), this, SLOT(walkableChanged(bool)));
+    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
+    return form;
+}
+
+void TileUI::Private::resetGui()
 {
-    *qobject_cast<Tile*>(modified()) = *qobject_cast<Tile*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_tile->name());
+    ui_walkable->setChecked(m_tile->walkable());
+    ui_script->setValue(m_tile->script());
 }
 
-void TileUI::nameChanged(const QString& name)
+void TileUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Tile*>(modified())->setName(name);
+    m_tile->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void TileUI::walkableChanged(const bool walkable)
+void TileUI::Private::walkableChanged(const bool walkable)
 {
-    qobject_cast<Tile*>(modified())->setWalkable(walkable);
+    m_tile->setWalkable(walkable);
 }
 
-void TileUI::scriptChanged(const Script& script)
+void TileUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<Tile*>(modified())->setScript(script);
+    m_tile->setScript(script);
 }
diff --git a/sigmodr/widgets/TimeUI.cpp b/sigmodr/widgets/TimeUI.cpp
index 2a108ef7..de27504f 100644
--- a/sigmodr/widgets/TimeUI.cpp
+++ b/sigmodr/widgets/TimeUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "TimeUI.h"
+#include "TimeUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -28,10 +29,7 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QTimeEdit>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -39,62 +37,69 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 TimeUI::TimeUI(Time* time, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(time, parent),
+        d(new Private(new Time(*time)))
 {
-    setObjects(time, new Time(*time));
+    setWidget(d->makeWidgets(this));
 }
 
-void TimeUI::initGui()
+void TimeUI::apply()
 {
-    QFile file(":/gui/time.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_time = formWidget->findChild<QTimeEdit*>("varTime");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_time, SIGNAL(timeChanged(QTime)), this, SLOT(timeChanged(QTime)));
-    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Time*>(m_object) = *d->m_time;
+    ObjectUI::apply();
 }
 
-void TimeUI::setGui()
+void TimeUI::discard()
 {
-    ui_name->setText(qobject_cast<Time*>(modified())->name());
-    ui_time->setTime(QTime(qobject_cast<Time*>(modified())->hour(), qobject_cast<Time*>(modified())->minute()));
-    ui_script->setValue(qobject_cast<Time*>(modified())->script());
+    *d->m_time = *qobject_cast<Time*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void TimeUI::apply()
+TimeUI::Private::Private(Time* time) :
+        ObjectUIPrivate(time),
+        m_time(time)
 {
-    *qobject_cast<Time*>(original()) = *qobject_cast<Time*>(modified());
-    emit(changed(false));
 }
 
-void TimeUI::discard()
+TimeUI::Private::~Private()
+{
+    delete m_time;
+}
+
+QWidget* TimeUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/time.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_time = form->findChild<QTimeEdit*>("varTime");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_time, SIGNAL(timeChanged(QTime)), this, SLOT(timeChanged(QTime)));
+    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
+    return form;
+}
+
+void TimeUI::Private::resetGui()
 {
-    *qobject_cast<Time*>(modified()) = *qobject_cast<Time*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_time->name());
+    ui_time->setTime(QTime(m_time->hour(), m_time->minute()));
+    ui_script->setValue(m_time->script());
 }
 
-void TimeUI::nameChanged(const QString& name)
+void TimeUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Time*>(modified())->setName(name);
+    m_time->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void TimeUI::timeChanged(const QTime& time)
+void TimeUI::Private::timeChanged(const QTime& time)
 {
-    qobject_cast<Time*>(modified())->setHour(time.hour());
-    qobject_cast<Time*>(modified())->setMinute(time.minute());
+    m_time->setHour(time.hour());
+    m_time->setMinute(time.minute());
 }
 
-void TimeUI::scriptChanged(const Script& script)
+void TimeUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<Time*>(modified())->setScript(script);
+    m_time->setScript(script);
 }
diff --git a/sigmodr/widgets/TrainerUI.cpp b/sigmodr/widgets/TrainerUI.cpp
index be7822bf..e8bf49ef 100644
--- a/sigmodr/widgets/TrainerUI.cpp
+++ b/sigmodr/widgets/TrainerUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "TrainerUI.h"
+#include "TrainerUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -29,35 +30,52 @@
 #include <KIntNumInput>
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 TrainerUI::TrainerUI(Trainer* trainer, QWidget* parent) :
-        ObjectUI(parent)
-{
-    setObjects(trainer, new Trainer(*trainer));
-}
-
-void TrainerUI::initGui()
-{
-    QFile file(":/gui/trainer.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_moneyFactor = formWidget->findChild<KIntNumInput*>("varMoneyFactor");
-    ui_skin = formWidget->findChild<KComboBox*>("varSkin");
-    ui_depth = formWidget->findChild<KIntNumInput*>("varDepth");
-    ui_teamIntel = formWidget->findChild<KComboBox*>("varTeamIntel");
-    ui_moveIntel = formWidget->findChild<KComboBox*>("varMoveIntel");
-    ui_itemIntel = formWidget->findChild<KComboBox*>("varItemIntel");
-    ui_abilityIntel = formWidget->findChild<KComboBox*>("varAbilityIntel");
-    ui_statIntel = formWidget->findChild<KComboBox*>("varStatIntel");
+        ObjectUI(trainer, parent),
+        d(new Private(new Trainer(*trainer)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void TrainerUI::apply()
+{
+    *qobject_cast<Trainer*>(m_object) = *d->m_trainer;
+    ObjectUI::apply();
+}
+
+void TrainerUI::discard()
+{
+    *d->m_trainer = *qobject_cast<Trainer*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+TrainerUI::Private::Private(Trainer* trainer) :
+        ObjectUIPrivate(trainer),
+        m_trainer(trainer)
+{
+}
+
+TrainerUI::Private::~Private()
+{
+    delete m_trainer;
+}
+
+QWidget* TrainerUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/trainer.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_moneyFactor = form->findChild<KIntNumInput*>("varMoneyFactor");
+    ui_skin = form->findChild<KComboBox*>("varSkin");
+    ui_depth = form->findChild<KIntNumInput*>("varDepth");
+    ui_teamIntel = form->findChild<KComboBox*>("varTeamIntel");
+    ui_moveIntel = form->findChild<KComboBox*>("varMoveIntel");
+    ui_itemIntel = form->findChild<KComboBox*>("varItemIntel");
+    ui_abilityIntel = form->findChild<KComboBox*>("varAbilityIntel");
+    ui_statIntel = form->findChild<KComboBox*>("varStatIntel");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_moneyFactor, SIGNAL(valueChanged(int)), this, SLOT(moneyFactorChanged(int)));
     connect(ui_skin, SIGNAL(currentIndexChanged(int)), this, SLOT(skinChanged(int)));
@@ -72,88 +90,77 @@ void TrainerUI::initGui()
     ui_itemIntel->addItems(Trainer::IntelligenceStr);
     ui_abilityIntel->addItems(Trainer::IntelligenceStr);
     ui_statIntel->addItems(Trainer::IntelligenceStr);
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void TrainerUI::refreshGui()
+void TrainerUI::Private::refreshGui()
 {
-    for (int i = 0; i < game()->skinCount(); ++i)
-        ui_skin->addItem(game()->skin(i)->name());
-    ui_itemIntel->setEnabled(game()->rules()->maxHeldItems());
-    ui_abilityIntel->setEnabled(game()->rules()->maxAbilities());
+    const bool blocked = ui_skin->blockSignals(true);
+    ui_skin->clear();
+    for (int i = 0; i < m_trainer->game()->skinCount(); ++i)
+        ui_skin->addItem(m_trainer->game()->skin(i)->name());
+    ui_skin->blockSignals(blocked);
+    ui_itemIntel->setEnabled(m_trainer->game()->rules()->maxHeldItems());
+    ui_abilityIntel->setEnabled(m_trainer->game()->rules()->maxAbilities());
 }
 
-void TrainerUI::setGui()
-{
-    ui_name->setText(qobject_cast<Trainer*>(modified())->name());
-    ui_moneyFactor->setValue(qobject_cast<Trainer*>(modified())->moneyFactor());
-    ui_skin->setCurrentIndex(game()->skinIndex(qobject_cast<Trainer*>(modified())->skin()));
-    ui_depth->setValue(qobject_cast<Trainer*>(modified())->depth());
-    ui_teamIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->teamIntel());
-    ui_moveIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->moveIntel());
-    ui_itemIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->itemIntel());
-    ui_abilityIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->abilityIntel());
-    ui_statIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->statIntel());
-}
-
-void TrainerUI::apply()
-{
-    *qobject_cast<Trainer*>(original()) = *qobject_cast<Trainer*>(modified());
-    emit(changed(false));
-}
-
-void TrainerUI::discard()
+void TrainerUI::Private::resetGui()
 {
-    *qobject_cast<Trainer*>(modified()) = *qobject_cast<Trainer*>(original());
-    emit(changed(false));
+    ui_name->setText(m_trainer->name());
+    ui_moneyFactor->setValue(m_trainer->moneyFactor());
+    ui_skin->setCurrentIndex(m_trainer->game()->skinIndex(m_trainer->skin()));
+    ui_depth->setValue(m_trainer->depth());
+    ui_teamIntel->setCurrentIndex(m_trainer->teamIntel());
+    ui_moveIntel->setCurrentIndex(m_trainer->moveIntel());
+    ui_itemIntel->setCurrentIndex(m_trainer->itemIntel());
+    ui_abilityIntel->setCurrentIndex(m_trainer->abilityIntel());
+    ui_statIntel->setCurrentIndex(m_trainer->statIntel());
 }
 
-void TrainerUI::nameChanged(const QString& name)
+void TrainerUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Trainer*>(modified())->setName(name);
+    m_trainer->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void TrainerUI::moneyFactorChanged(const int moneyFactor)
+void TrainerUI::Private::moneyFactorChanged(const int moneyFactor)
 {
-    qobject_cast<Trainer*>(modified())->setMoneyFactor(moneyFactor);
+    m_trainer->setMoneyFactor(moneyFactor);
 }
 
-void TrainerUI::skinChanged(const int skin)
+void TrainerUI::Private::skinChanged(const int skin)
 {
     if (0 <= skin)
-        qobject_cast<Trainer*>(modified())->setSkin(game()->skin(skin)->id());
+        m_trainer->setSkin(m_trainer->game()->skin(skin)->id());
 }
 
-void TrainerUI::depthChanged(const int depth)
+void TrainerUI::Private::depthChanged(const int depth)
 {
-    qobject_cast<Trainer*>(modified())->setDepth(depth);
+    m_trainer->setDepth(depth);
 }
 
-void TrainerUI::teamIntelChanged(const int teamIntel)
+void TrainerUI::Private::teamIntelChanged(const int teamIntel)
 {
-    qobject_cast<Trainer*>(modified())->setTeamIntel(static_cast<Trainer::Intelligence>(teamIntel));
+    m_trainer->setTeamIntel(static_cast<Trainer::Intelligence>(teamIntel));
 }
 
-void TrainerUI::moveIntelChanged(const int moveIntel)
+void TrainerUI::Private::moveIntelChanged(const int moveIntel)
 {
-    qobject_cast<Trainer*>(modified())->setMoveIntel(static_cast<Trainer::Intelligence>(moveIntel));
+    m_trainer->setMoveIntel(static_cast<Trainer::Intelligence>(moveIntel));
 }
 
-void TrainerUI::itemIntelChanged(const int itemIntel)
+void TrainerUI::Private::itemIntelChanged(const int itemIntel)
 {
-    qobject_cast<Trainer*>(modified())->setItemIntel(static_cast<Trainer::Intelligence>(itemIntel));
+    m_trainer->setItemIntel(static_cast<Trainer::Intelligence>(itemIntel));
 }
 
-void TrainerUI::abilityIntelChanged(const int abilityIntel)
+void TrainerUI::Private::abilityIntelChanged(const int abilityIntel)
 {
-    qobject_cast<Trainer*>(modified())->setAbilityIntel(static_cast<Trainer::Intelligence>(abilityIntel));
+    m_trainer->setAbilityIntel(static_cast<Trainer::Intelligence>(abilityIntel));
 }
 
-void TrainerUI::statIntelChanged(const int statIntel)
+void TrainerUI::Private::statIntelChanged(const int statIntel)
 {
-    qobject_cast<Trainer*>(modified())->setStatIntel(static_cast<Trainer::Intelligence>(statIntel));
+    m_trainer->setStatIntel(static_cast<Trainer::Intelligence>(statIntel));
 }
diff --git a/sigmodr/widgets/TypeUI.cpp b/sigmodr/widgets/TypeUI.cpp
index d931ccc5..04a7045a 100644
--- a/sigmodr/widgets/TypeUI.cpp
+++ b/sigmodr/widgets/TypeUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "TypeUI.h"
+#include "TypeUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/FractionWidget.h>
@@ -27,64 +28,66 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 TypeUI::TypeUI(Type* type, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(type, parent),
+        d(new Private(new Type(*type)))
 {
-    setObjects(type, new Type(*type));
+    setWidget(d->makeWidgets(this));
 }
 
-void TypeUI::initGui()
+void TypeUI::apply()
 {
-    QFile file(":/gui/type.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_stab = formWidget->findChild<FractionWidget*>("varSTAB");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_stab, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(stabChanged(Sigcore::Fraction)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Type*>(m_object) = *d->m_type;
+    ObjectUI::apply();
 }
 
-void TypeUI::setGui()
+void TypeUI::discard()
 {
-    ui_name->setText(qobject_cast<Type*>(modified())->name());
-    ui_stab->setValue(qobject_cast<Type*>(modified())->stab());
+    *d->m_type = *qobject_cast<Type*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void TypeUI::apply()
+TypeUI::Private::Private(Type* type) :
+        ObjectUIPrivate(type),
+        m_type(type)
 {
-    *qobject_cast<Type*>(original()) = *qobject_cast<Type*>(modified());
-    emit(changed(false));
 }
 
-void TypeUI::discard()
+TypeUI::Private::~Private()
+{
+    delete m_type;
+}
+
+QWidget* TypeUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/type.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_stab = form->findChild<FractionWidget*>("varSTAB");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_stab, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(stabChanged(Sigcore::Fraction)));
+    return form;
+}
+
+void TypeUI::Private::resetGui()
 {
-    *qobject_cast<Type*>(modified()) = *qobject_cast<Type*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_type->name());
+    ui_stab->setValue(m_type->stab());
 }
 
-void TypeUI::nameChanged(const QString& name)
+void TypeUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Type*>(modified())->setName(name);
+    m_type->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void TypeUI::stabChanged(const Fraction& stab)
+void TypeUI::Private::stabChanged(const Fraction& stab)
 {
-    qobject_cast<Type*>(modified())->setStab(stab);
+    m_type->setStab(stab);
 }
diff --git a/sigmodr/widgets/WeatherUI.cpp b/sigmodr/widgets/WeatherUI.cpp
index 8255432d..74d01eb4 100644
--- a/sigmodr/widgets/WeatherUI.cpp
+++ b/sigmodr/widgets/WeatherUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "WeatherUI.h"
+#include "WeatherUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -27,64 +28,66 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 WeatherUI::WeatherUI(Weather* weather, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(weather, parent),
+        d(new Private(new Weather(*weather)))
 {
-    setObjects(weather, new Weather(*weather));
+    setWidget(d->makeWidgets(this));
 }
 
-void WeatherUI::initGui()
+void WeatherUI::apply()
 {
-    QFile file(":/gui/weather.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Weather*>(m_object) = *d->m_weather;
+    ObjectUI::apply();
 }
 
-void WeatherUI::setGui()
+void WeatherUI::discard()
 {
-    ui_name->setText(qobject_cast<Weather*>(modified())->name());
-    ui_script->setValue(qobject_cast<Weather*>(modified())->script());
+    *d->m_weather = *qobject_cast<Weather*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void WeatherUI::apply()
+WeatherUI::Private::Private(Weather* weather) :
+        ObjectUIPrivate(weather),
+        m_weather(weather)
 {
-    *qobject_cast<Weather*>(original()) = *qobject_cast<Weather*>(modified());
-    emit(changed(false));
 }
 
-void WeatherUI::discard()
+WeatherUI::Private::~Private()
+{
+    delete m_weather;
+}
+
+QWidget* WeatherUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/weather.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
+    return form;
+}
+
+void WeatherUI::Private::resetGui()
 {
-    *qobject_cast<Weather*>(modified()) = *qobject_cast<Weather*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_weather->name());
+    ui_script->setValue(m_weather->script());
 }
 
-void WeatherUI::nameChanged(const QString& name)
+void WeatherUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Weather*>(modified())->setName(name);
+    m_weather->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void WeatherUI::scriptChanged(const Script& script)
+void WeatherUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<Weather*>(modified())->setScript(script);
+    m_weather->setScript(script);
 }