Fixed more widgets to use pimpl

14 files changed, 518 insertions, 500 deletions

diff --git a/sigmodr/widgets/AbilityUI.cpp b/sigmodr/widgets/AbilityUI.cpp
index ea010e41..97665599 100644
--- a/sigmodr/widgets/AbilityUI.cpp
+++ b/sigmodr/widgets/AbilityUI.cpp
@@ -29,9 +29,6 @@
 #include <KIntNumInput>
 #include <KLineEdit>
 
-// Qt includes
-#include <QtGui/QVBoxLayout>
-
 using namespace Sigcore;
 using namespace Sigmod;
 using namespace Sigmodr::CoreWidgets;
diff --git a/sigmodr/widgets/AuthorUI.cpp b/sigmodr/widgets/AuthorUI.cpp
index 749cf4ee..f3378c01 100644
--- a/sigmodr/widgets/AuthorUI.cpp
+++ b/sigmodr/widgets/AuthorUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "AuthorUI.h"
+#include "AuthorUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Author.h>
@@ -24,74 +25,76 @@
 // KDE includes
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 AuthorUI::AuthorUI(Author* author, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(author, parent),
+        d(new Private(new Author(*author)))
 {
-    setObjects(author, new Author(*author));
+    setWidget(d->makeWidgets(this));
 }
 
-void AuthorUI::initGui()
+void AuthorUI::apply()
 {
-    QFile file(":/gui/author.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_email= formWidget->findChild<KLineEdit*>("varEmail");
-    ui_role = formWidget->findChild<KLineEdit*>("varRole");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_email, SIGNAL(textChanged(QString)), this, SLOT(emailChanged(QString)));
-    connect(ui_role, SIGNAL(textChanged(QString)), this, SLOT(roleChanged(QString)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<Author*>(m_object) = *d->m_author;
+    ObjectUI::apply();
 }
 
-void AuthorUI::setGui()
+void AuthorUI::discard()
 {
-    ui_name->setText(qobject_cast<Author*>(modified())->name());
-    ui_email->setText(qobject_cast<Author*>(modified())->email());
-    ui_role->setText(qobject_cast<Author*>(modified())->role());
+    *d->m_author = *qobject_cast<Author*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void AuthorUI::apply()
+AuthorUI::Private::Private(Author* author) :
+        ObjectUIPrivate(author),
+        m_author(author)
 {
-    *qobject_cast<Author*>(original()) = *qobject_cast<Author*>(modified());
-    emit(changed(false));
 }
 
-void AuthorUI::discard()
+AuthorUI::Private::~Private()
+{
+    delete m_author;
+}
+
+QWidget* AuthorUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/author.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_email= form->findChild<KLineEdit*>("varEmail");
+    ui_role = form->findChild<KLineEdit*>("varRole");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_email, SIGNAL(textChanged(QString)), this, SLOT(emailChanged(QString)));
+    connect(ui_role, SIGNAL(textChanged(QString)), this, SLOT(roleChanged(QString)));
+    return form;
+}
+
+void AuthorUI::Private::resetGui()
 {
-    *qobject_cast<Author*>(modified()) = *qobject_cast<Author*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_author->name());
+    ui_email->setText(m_author->email());
+    ui_role->setText(m_author->role());
 }
 
-void AuthorUI::nameChanged(const QString& name)
+void AuthorUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Author*>(modified())->setName(name);
+    m_author->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void AuthorUI::emailChanged(const QString& email)
+void AuthorUI::Private::emailChanged(const QString& email)
 {
     const int cursor = ui_email->cursorPosition();
-    qobject_cast<Author*>(modified())->setEmail(email);
+    m_author->setEmail(email);
     ui_email->setCursorPosition(cursor);
 }
 
-void AuthorUI::roleChanged(const QString& role)
+void AuthorUI::Private::roleChanged(const QString& role)
 {
     const int cursor = ui_role->cursorPosition();
-    qobject_cast<Author*>(modified())->setRole(role);
+    m_author->setRole(role);
     ui_role->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/BadgeUI.cpp b/sigmodr/widgets/BadgeUI.cpp
index d1dea1d0..bb6cb1b0 100644
--- a/sigmodr/widgets/BadgeUI.cpp
+++ b/sigmodr/widgets/BadgeUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "BadgeUI.h"
+#include "BadgeUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/FractionWidget.h>
@@ -34,12 +35,9 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QHeaderView>
 #include <QtGui/QTableWidget>
 #include <QtGui/QTableWidgetItem>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -47,47 +45,67 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 BadgeUI::BadgeUI(Badge* badge, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(badge, parent),
+        d(new Private(new Badge(*badge)))
 {
-    setObjects(badge, new Badge(*badge));
+    setWidget(d->makeWidgets(this));
 }
 
-void BadgeUI::initGui()
+void BadgeUI::apply()
+{
+    *qobject_cast<Badge*>(m_object) = *d->m_badge;
+    ObjectUI::apply();
+}
+
+void BadgeUI::discard()
+{
+    *d->m_badge = *qobject_cast<Badge*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+BadgeUI::Private::Private(Badge* badge) :
+        ObjectUIPrivate(badge),
+        m_badge(badge)
+{
+}
+
+BadgeUI::Private::~Private()
 {
-    QFile file(":/gui/badge.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_obey= formWidget->findChild<KIntNumInput*>("varObey");
-    ui_face = formWidget->findChild<KComboBox*>("varFace");
-    ui_badge = formWidget->findChild<KComboBox*>("varBadge");
-    ui_stat = formWidget->findChild<QTableWidget*>("varStat");
-    ui_statMultiplier = formWidget->findChild<FractionWidget*>("varStatMultiplier");
+    delete m_badge;
+}
+
+QWidget* BadgeUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/badge.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_obey= form->findChild<KIntNumInput*>("varObey");
+    ui_face = form->findChild<KComboBox*>("varFace");
+    ui_badge = form->findChild<KComboBox*>("varBadge");
+    ui_stat = form->findChild<QTableWidget*>("varStat");
+    ui_statMultiplier = form->findChild<FractionWidget*>("varStatMultiplier");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_obey, SIGNAL(valueChanged(int)), this, SLOT(obeyChanged(int)));
     connect(ui_face, SIGNAL(currentIndexChanged(int)), this, SLOT(faceChanged(int)));
     connect(ui_badge, SIGNAL(currentIndexChanged(int)), this, SLOT(badgeChanged(int)));
     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)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
     ui_stat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+    return form;
 }
 
-void BadgeUI::refreshGui()
+void BadgeUI::Private::refreshGui()
 {
     int maxHeight = 0;
     int maxWidth = 0;
-    ui_obey->setMaximum(game()->rules()->maxLevel());
+    ui_obey->setMaximum(m_badge->game()->rules()->maxLevel());
     const bool blockedFace = ui_face->blockSignals(true);
     const bool blockedBadge = ui_badge->blockSignals(true);
     ui_face->clear();
     ui_badge->clear();
-    for (int i = 0; i < game()->spriteCount(); ++i)
+    for (int i = 0; i < m_badge->game()->spriteCount(); ++i)
     {
-        const Sprite* sprite = game()->sprite(i);
+        const Sprite* sprite = m_badge->game()->sprite(i);
         QPixmap icon;
         icon.loadFromData(sprite->sprite());
         maxHeight = qMax(maxHeight, icon.height());
@@ -100,7 +118,7 @@ void BadgeUI::refreshGui()
     const QSize maxSize(maxWidth, maxHeight);
     ui_face->setIconSize(maxSize);
     ui_badge->setIconSize(maxSize);
-    const bool isSplit = game()->rules()->specialSplit();
+    const bool isSplit = m_badge->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));
@@ -143,68 +161,55 @@ void BadgeUI::refreshGui()
     }
 }
 
-void BadgeUI::setGui()
+void BadgeUI::Private::resetGui()
 {
-    ui_name->setText(qobject_cast<Badge*>(modified())->name());
-    ui_obey->setValue(qobject_cast<Badge*>(modified())->obey());
-    ui_face->setCurrentIndex(game()->spriteIndex(qobject_cast<Badge*>(modified())->face()));
-    ui_badge->setCurrentIndex(game()->spriteIndex(qobject_cast<Badge*>(modified())->badge()));
-    ui_stat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Attack), 'g', 7));
-    ui_stat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Defense), 'g', 7));
-    ui_stat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Speed), 'g', 7));
-    if (game()->rules()->specialSplit())
+    ui_name->setText(m_badge->name());
+    ui_obey->setValue(m_badge->obey());
+    ui_face->setCurrentIndex(m_badge->game()->spriteIndex(m_badge->face()));
+    ui_badge->setCurrentIndex(m_badge->game()->spriteIndex(m_badge->badge()));
+    ui_stat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_Attack), 'g', 7));
+    ui_stat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_Defense), 'g', 7));
+    ui_stat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_Speed), 'g', 7));
+    if (m_badge->game()->rules()->specialSplit())
     {
-        ui_stat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_SpecialAttack), 'g', 7));
-        ui_stat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_SpecialDefense), 'g', 7));
+        ui_stat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_SpecialAttack), 'g', 7));
+        ui_stat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(m_badge->stat(ST_SpecialDefense), 'g', 7));
     }
     else
-        ui_stat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Special), 'g', 7));
-    ui_statMultiplier->setValue(qobject_cast<Badge*>(modified())->stat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>()));
-}
-
-void BadgeUI::apply()
-{
-    *qobject_cast<Badge*>(original()) = *qobject_cast<Badge*>(modified());
-    emit(changed(false));
-}
-
-void BadgeUI::discard()
-{
-    *qobject_cast<Badge*>(modified()) = *qobject_cast<Badge*>(original());
-    setGui();
-    emit(changed(false));
+        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::nameChanged(const QString& name)
+void BadgeUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Badge*>(modified())->setName(name);
+    m_badge->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void BadgeUI::obeyChanged(const int obey)
+void BadgeUI::Private::obeyChanged(const int obey)
 {
-    qobject_cast<Badge*>(modified())->setObey(obey);
+    m_badge->setObey(obey);
 }
 
-void BadgeUI::faceChanged(const int face)
+void BadgeUI::Private::faceChanged(const int face)
 {
     if (0 <= face)
-        qobject_cast<Badge*>(modified())->setFace(game()->sprite(face)->id());
+        m_badge->setFace(m_badge->game()->sprite(face)->id());
 }
 
-void BadgeUI::badgeChanged(const int badge)
+void BadgeUI::Private::badgeChanged(const int badge)
 {
     if (0 <= badge)
-        qobject_cast<Badge*>(modified())->setBadge(game()->sprite(badge)->id());
+        m_badge->setBadge(m_badge->game()->sprite(badge)->id());
 }
 
-void BadgeUI::statChanged(const int row)
+void BadgeUI::Private::statChanged(const int row)
 {
-    ui_statMultiplier->setValue(qobject_cast<Badge*>(modified())->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
+    ui_statMultiplier->setValue(m_badge->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void BadgeUI::statMultiplierChanged(const Fraction& multiplier)
+void BadgeUI::Private::statMultiplierChanged(const Fraction& multiplier)
 {
-    qobject_cast<Badge*>(modified())->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
+    m_badge->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
 }
diff --git a/sigmodr/widgets/CoinListItemUI.cpp b/sigmodr/widgets/CoinListItemUI.cpp
index b3efe4de..c141a40b 100644
--- a/sigmodr/widgets/CoinListItemUI.cpp
+++ b/sigmodr/widgets/CoinListItemUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "CoinListItemUI.h"
+#include "CoinListItemUI_p.h"
 
 // Sigmod includes
 #include <sigmod/CoinListItem.h>
@@ -29,101 +30,99 @@
 #include <KIntNumInput>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QButtonGroup>
 #include <QtGui/QRadioButton>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 CoinListItemUI::CoinListItemUI(CoinListItem* item, QWidget* parent) :
-        ObjectUI(parent),
-        ui_type(new QButtonGroup(this)),
-        m_lastType(-1)
+        ObjectUI(item, parent),
+        d(new Private(new CoinListItem(*item)))
 {
-    setObjects(item, new CoinListItem(*item));
+    setWidget(d->makeWidgets(this));
 }
 
-void CoinListItemUI::initGui()
+void CoinListItemUI::apply()
 {
-    QFile file(":/gui/coinlistitem.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    QRadioButton* item = formWidget->findChild<QRadioButton*>("varItem");
-    QRadioButton* species = formWidget->findChild<QRadioButton*>("varSpecies");
-    ui_object = formWidget->findChild<KComboBox*>("varObject");
-    ui_cost = formWidget->findChild<KIntNumInput*>("varCost");
-    ui_type->addButton(item, CoinListItem::Item);
-    ui_type->addButton(species, CoinListItem::Species);
-    connect(ui_type, SIGNAL(buttonClicked(int)), this, SLOT(typeChanged(int)));
-    connect(ui_object, SIGNAL(currentIndexChanged(int)), this, SLOT(objectChanged(int)));
-    connect(ui_cost, SIGNAL(valueChanged(int)), this, SLOT(costChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    *qobject_cast<CoinListItem*>(m_object) = *d->m_item;
+    ObjectUI::apply();
 }
 
-void CoinListItemUI::setGui()
+void CoinListItemUI::discard()
 {
-    bool resetObjects = (qobject_cast<CoinListItem*>(modified())->type() != m_lastType);
-    ui_type->button(qobject_cast<CoinListItem*>(modified())->type())->setChecked(true);
-    m_lastType = qobject_cast<CoinListItem*>(modified())->type();
-    if (resetObjects)
-    {
-        const bool blocked = ui_object->blockSignals(true);
-        ui_object->clear();
-        if (qobject_cast<CoinListItem*>(modified())->type() == CoinListItem::Item)
-        {
-            for (int i = 0; i < game()->itemCount(); ++i)
-                ui_object->addItem(game()->item(i)->name());
-        }
-        else
-        {
-            for (int i = 0; i < game()->speciesCount(); ++i)
-                ui_object->addItem(game()->species(i)->name());
-        }
-        ui_object->blockSignals(blocked);
-    }
-    if (m_lastType == CoinListItem::Item)
-        ui_object->setCurrentIndex(game()->itemIndex(qobject_cast<CoinListItem*>(modified())->object()));
-    else
-        ui_object->setCurrentIndex(game()->speciesIndex(qobject_cast<CoinListItem*>(modified())->object()));
-    ui_cost->setValue(qobject_cast<CoinListItem*>(modified())->cost());
+    *d->m_item = *qobject_cast<CoinListItem*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void CoinListItemUI::apply()
+CoinListItemUI::Private::Private(CoinListItem* item) :
+        ObjectUIPrivate(item),
+        m_item(item)
 {
-    *qobject_cast<CoinListItem*>(original()) = *qobject_cast<CoinListItem*>(modified());
-    emit(changed(false));
 }
 
-void CoinListItemUI::discard()
+CoinListItemUI::Private::~Private()
+{
+    delete m_item;
+}
+
+QWidget* CoinListItemUI::Private::makeWidgets(ObjectUI* widget)
 {
-    *qobject_cast<CoinListItem*>(modified()) = *qobject_cast<CoinListItem*>(original());
-    setGui();
-    emit(changed(false));
+    QWidget *form = openUiFile(":/gui/coinlistitem.ui", widget);
+    QRadioButton* item = form->findChild<QRadioButton*>("varItem");
+    QRadioButton* species = form->findChild<QRadioButton*>("varSpecies");
+    ui_object = form->findChild<KComboBox*>("varObject");
+    ui_cost = form->findChild<KIntNumInput*>("varCost");
+    ui_type = new QButtonGroup(widget);
+    ui_type->addButton(item, CoinListItem::Item);
+    ui_type->addButton(species, CoinListItem::Species);
+    connect(ui_type, SIGNAL(buttonClicked(int)), this, SLOT(typeChanged(int)));
+    connect(ui_object, SIGNAL(currentIndexChanged(int)), this, SLOT(objectChanged(int)));
+    connect(ui_cost, SIGNAL(valueChanged(int)), this, SLOT(costChanged(int)));
+    return form;
 }
 
-void CoinListItemUI::typeChanged(const int type)
+void CoinListItemUI::Private::resetGui()
 {
-    qobject_cast<CoinListItem*>(modified())->setType(static_cast<CoinListItem::Type>(type));
+    ui_type->button(m_item->type())->setChecked(true);
+    if (m_item->type() == CoinListItem::Item)
+        ui_object->setCurrentIndex(m_item->game()->itemIndex(m_item->object()));
+    else
+        ui_object->setCurrentIndex(m_item->game()->speciesIndex(m_item->object()));
+    ui_cost->setValue(m_item->cost());
+}
+
+void CoinListItemUI::Private::typeChanged(const int type)
+{
+    m_item->setType(static_cast<CoinListItem::Type>(type));
+    const bool blocked = ui_object->blockSignals(true);
+    ui_object->clear();
+    if (m_item->type() == CoinListItem::Item)
+    {
+        for (int i = 0; i < m_item->game()->itemCount(); ++i)
+            ui_object->addItem(m_item->game()->item(i)->name());
+    }
+    else
+    {
+        for (int i = 0; i < m_item->game()->speciesCount(); ++i)
+            ui_object->addItem(m_item->game()->species(i)->name());
+    }
+    ui_object->blockSignals(blocked);
 }
 
-void CoinListItemUI::objectChanged(const int object)
+void CoinListItemUI::Private::objectChanged(const int object)
 {
     if (0 <= object)
     {
-        if (qobject_cast<CoinListItem*>(modified())->type() == CoinListItem::Item)
-            qobject_cast<CoinListItem*>(modified())->setObject(game()->item(object)->id());
+        if (m_item->type() == CoinListItem::Item)
+            m_item->setObject(m_item->game()->item(object)->id());
         else
-            qobject_cast<CoinListItem*>(modified())->setObject(game()->species(object)->id());
+            m_item->setObject(m_item->game()->species(object)->id());
     }
 }
 
-void CoinListItemUI::costChanged(const int cost)
+void CoinListItemUI::Private::costChanged(const int cost)
 {
-    qobject_cast<CoinListItem*>(modified())->setCost(cost);
+    m_item->setCost(cost);
 }
diff --git a/sigmodr/widgets/CoinListItemUI_p.h b/sigmodr/widgets/CoinListItemUI_p.h
index 9e6fecfc..4f3e3f38 100644
--- a/sigmodr/widgets/CoinListItemUI_p.h
+++ b/sigmodr/widgets/CoinListItemUI_p.h
@@ -55,8 +55,6 @@ class CoinListItemUI::Private : public ObjectUIPrivate
         QButtonGroup* ui_type;
         KComboBox* ui_object;
         KIntNumInput* ui_cost;
-        
-        bool m_lastType;
 };
 }
 }
diff --git a/sigmodr/widgets/CoinListUI.cpp b/sigmodr/widgets/CoinListUI.cpp
index c4ee59a4..a2905d83 100644
--- a/sigmodr/widgets/CoinListUI.cpp
+++ b/sigmodr/widgets/CoinListUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "CoinListUI.h"
+#include "CoinListUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.h>
@@ -28,64 +29,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;
 
 CoinListUI::CoinListUI(CoinList* coinList, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(coinList, parent),
+        d(new Private(new CoinList(*coinList)))
 {
-    setObjects(coinList, new CoinList(*coinList));
+    setWidget(d->makeWidgets(this));
 }
 
-void CoinListUI::initGui()
+void CoinListUI::apply()
 {
-    QFile file(":/gui/coinlist.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<CoinList*>(m_object) = *d->m_coinList;
+    ObjectUI::apply();
 }
 
-void CoinListUI::setGui()
+void CoinListUI::discard()
 {
-    ui_name->setText(qobject_cast<CoinList*>(modified())->name());
-    ui_script->setValue(qobject_cast<CoinList*>(modified())->script());
+    *d->m_coinList = *qobject_cast<CoinList*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void CoinListUI::apply()
+CoinListUI::Private::Private(CoinList* coinList) :
+        ObjectUIPrivate(coinList),
+        m_coinList(coinList)
 {
-    *qobject_cast<CoinList*>(original()) = *qobject_cast<CoinList*>(modified());
-    emit(changed(false));
 }
 
-void CoinListUI::discard()
+CoinListUI::Private::~Private()
+{
+    delete m_coinList;
+}
+
+QWidget* CoinListUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/coinlist.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 CoinListUI::Private::resetGui()
 {
-    *qobject_cast<CoinList*>(modified()) = *qobject_cast<CoinList*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_coinList->name());
+    ui_script->setValue(m_coinList->script());
 }
 
-void CoinListUI::nameChanged(const QString& name)
+void CoinListUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<CoinList*>(modified())->setName(name);
+    m_coinList->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void CoinListUI::scriptChanged(const Script& script)
+void CoinListUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<CoinList*>(modified())->setScript(script);
+    m_coinList->setScript(script);
 }
diff --git a/sigmodr/widgets/EggGroupUI.cpp b/sigmodr/widgets/EggGroupUI.cpp
index f416ec6d..3f07b703 100644
--- a/sigmodr/widgets/EggGroupUI.cpp
+++ b/sigmodr/widgets/EggGroupUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "EggGroupUI.h"
+#include "EggGroupUI_p.h"
 
 // Sigmod includes
 #include <sigmod/EggGroup.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;
 
 EggGroupUI::EggGroupUI(EggGroup* eggGroup, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(eggGroup, parent),
+        d(new Private(new EggGroup(*eggGroup)))
 {
-    setObjects(eggGroup, new EggGroup(*eggGroup));
+    setWidget(d->makeWidgets(this));
 }
 
-void EggGroupUI::initGui()
+void EggGroupUI::apply()
 {
-    QFile file(":/gui/egggroup.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<EggGroup*>(m_object) = *d->m_eggGroup;
+    ObjectUI::apply();
 }
 
-void EggGroupUI::setGui()
+void EggGroupUI::discard()
 {
-    ui_name->setText(qobject_cast<EggGroup*>(modified())->name());
+    *d->m_eggGroup = *qobject_cast<EggGroup*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void EggGroupUI::apply()
+EggGroupUI::Private::Private(EggGroup* eggGroup) :
+        ObjectUIPrivate(eggGroup),
+        m_eggGroup(eggGroup)
 {
-    *qobject_cast<EggGroup*>(original()) = *qobject_cast<EggGroup*>(modified());
-    emit(changed(false));
 }
 
-void EggGroupUI::discard()
+EggGroupUI::Private::~Private()
+{
+    delete m_eggGroup;
+}
+
+QWidget* EggGroupUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/egggroup.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    return form;
+}
+
+void EggGroupUI::Private::resetGui()
 {
-    *qobject_cast<EggGroup*>(modified()) = *qobject_cast<EggGroup*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_eggGroup->name());
 }
 
-void EggGroupUI::nameChanged(const QString& name)
+void EggGroupUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<EggGroup*>(modified())->setName(name);
+    m_eggGroup->setName(name);
     ui_name->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/GameUI.cpp b/sigmodr/widgets/GameUI.cpp
index 0cf5ce03..ab6153ee 100644
--- a/sigmodr/widgets/GameUI.cpp
+++ b/sigmodr/widgets/GameUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "GameUI.h"
+#include "GameUI_p.h"
 
 // Sigmodr widget includes
 #include "TypechartModel.h"
@@ -35,12 +36,9 @@
 #include <KLineEdit>
 
 // Qt includes
-#include <QtCore/QFile>
 #include <QtGui/QCheckBox>
 #include <QtGui/QLabel>
 #include <QtGui/QTableView>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
 
 using namespace Sigcore;
 using namespace Sigmod;
@@ -48,116 +46,123 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 GameUI::GameUI(Game* game, QWidget* parent) :
-        ObjectUI(parent),
-        m_changingMult(true)
+        ObjectUI(game, parent),
+        d(new Private(new Game(*game)))
 {
-    setObjects(game, new Game(*game));
+    setWidget(d->makeWidgets(this));
 }
 
-void GameUI::initGui()
+void GameUI::apply()
+{
+    *qobject_cast<Game*>(m_object) = *d->m_game;
+    ObjectUI::apply();
+}
+
+void GameUI::discard()
+{
+    *d->m_game = *qobject_cast<Game*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+GameUI::Private::Private(Game* game) :
+        ObjectUIPrivate(game),
+        m_game(game)
+{
+}
+
+GameUI::Private::~Private()
 {
-    QFile file(":/gui/game.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_title = formWidget->findChild<KLineEdit*>("varTitle");
-    ui_version = formWidget->findChild<KLineEdit*>("varVersion");
-    ui_description = formWidget->findChild<KLineEdit*>("varDescription");
-    ui_singlePlayer = formWidget->findChild<QCheckBox*>("varSinglePlayer");
-    ui_startScript = formWidget->findChild<ScriptWidget*>("varStartScript");
-    ui_typechart = formWidget->findChild<QTableView*>("varTypechart");
-    ui_labelTypes = formWidget->findChild<QLabel*>("labelTypes");
-    ui_effectiveness = formWidget->findChild<FractionWidget*>("varEffectiveness");
+    delete m_game;
+}
+
+QWidget* GameUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/game.ui", widget);
+    ui_title = form->findChild<KLineEdit*>("varTitle");
+    ui_version = form->findChild<KLineEdit*>("varVersion");
+    ui_description = form->findChild<KLineEdit*>("varDescription");
+    ui_singlePlayer = form->findChild<QCheckBox*>("varSinglePlayer");
+    ui_startScript = form->findChild<ScriptWidget*>("varStartScript");
+    ui_typechart = form->findChild<QTableView*>("varTypechart");
+    ui_labelTypes = form->findChild<QLabel*>("labelTypes");
+    ui_effectiveness = form->findChild<FractionWidget*>("varEffectiveness");
     connect(ui_title, SIGNAL(textChanged(QString)), this, SLOT(titleChanged(QString)));
     connect(ui_version, SIGNAL(textChanged(QString)), this, SLOT(versionChanged(QString)));
     connect(ui_description, SIGNAL(textChanged(QString)), this, SLOT(descriptionChanged(QString)));
     connect(ui_singlePlayer, SIGNAL(toggled(bool)), this, SLOT(singlePlayerChanged(bool)));
     connect(ui_startScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(startScriptChanged(Sigcore::Script)));
-    connect(ui_typechart, SIGNAL(clicked(QModelIndex)), this, SLOT(typechartChanged(QModelIndex)));
+    connect(ui_typechart, SIGNAL(currentChanged(QModelIndex, QModelIndew)), this, SLOT(typechartChanged(QModelIndex)));
     connect(ui_effectiveness, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(effectivenessChanged(Sigcore::Fraction)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void GameUI::refreshGui()
+void GameUI::Private::refreshGui()
 {
     delete ui_typechart->model();
     QStringList types;
-    for (int i = 0; i < qobject_cast<Game*>(original())->typeCount(); ++i)
-        types << qobject_cast<Game*>(original())->type(i)->name();
-    ui_typechart->setModel(new TypechartModel(qobject_cast<Game*>(modified())->typechart(), types));
+    for (int i = 0; i < m_game->typeCount(); ++i)
+        types << m_game->type(i)->name();
+    delete ui_typechart->model();
+    ui_typechart->setModel(new TypechartModel(m_game->typechart(), types));
     ui_effectiveness->setEnabled(false);
 }
 
-void GameUI::setGui()
-{
-    ui_title->setText(qobject_cast<Game*>(modified())->title());
-    ui_version->setText(qobject_cast<Game*>(modified())->version());
-    ui_description->setText(qobject_cast<Game*>(modified())->description());
-    ui_singlePlayer->setCheckState(qobject_cast<Game*>(modified())->singlePlayer() ? Qt::Checked : Qt::Unchecked);
-    ui_startScript->setValue(qobject_cast<Game*>(modified())->startScript());
-}
-
-void GameUI::apply()
-{
-    *qobject_cast<Game*>(original()) = *qobject_cast<Game*>(modified());
-    emit(changed(false));
-}
-
-void GameUI::discard()
+void GameUI::Private::resetGui()
 {
-    *qobject_cast<Game*>(modified()) = *qobject_cast<Game*>(original());
-    setGui();
-    qobject_cast<TypechartModel*>(ui_typechart->model())->discarded();
-    emit(changed(false));
+    ui_title->setText(m_game->title());
+    ui_version->setText(m_game->version());
+    ui_description->setText(m_game->description());
+    ui_singlePlayer->setCheckState(m_game->singlePlayer() ? Qt::Checked : Qt::Unchecked);
+    ui_startScript->setValue(m_game->startScript());
 }
 
-void GameUI::titleChanged(const QString& title)
+void GameUI::Private::titleChanged(const QString& title)
 {
     const int cursor = ui_title->cursorPosition();
-    qobject_cast<Game*>(modified())->setTitle(title);
+    m_game->setTitle(title);
     ui_title->setCursorPosition(cursor);
 }
 
-void GameUI::versionChanged(const QString& version)
+void GameUI::Private::versionChanged(const QString& version)
 {
     const int cursor = ui_version->cursorPosition();
-    qobject_cast<Game*>(modified())->setVersion(version);
+    m_game->setVersion(version);
     ui_version->setCursorPosition(cursor);
 }
 
-void GameUI::descriptionChanged(const QString& description)
+void GameUI::Private::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Game*>(modified())->setDescription(description);
+    m_game->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void GameUI::singlePlayerChanged(const bool singlePlayer)
+void GameUI::Private::singlePlayerChanged(const bool singlePlayer)
 {
-    qobject_cast<Game*>(modified())->setSinglePlayer(singlePlayer);
+    m_game->setSinglePlayer(singlePlayer);
 }
 
-void GameUI::startScriptChanged(const Script& startScript)
+void GameUI::Private::startScriptChanged(const Script& startScript)
 {
-    qobject_cast<Game*>(modified())->setStartScript(startScript);
+    m_game->setStartScript(startScript);
 }
 
-void GameUI::typechartChanged(const QModelIndex& index)
+void GameUI::Private::typechartChanged(const QModelIndex& index)
 {
-    m_index = index;
-    m_changingMult = true;
+    m_changing = true;
     ui_effectiveness->setEnabled(true);
-    ui_labelTypes->setText(QString("%1 vs. %2").arg(game()->type(index.row())->name()).arg(game()->type(index.column())->name()));
-    ui_effectiveness->setValue(ui_typechart->model()->data(m_index, Qt::EditRole).value<Fraction>());
+    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>());
 }
 
-void GameUI::effectivenessChanged(const Fraction& multiplier)
+void GameUI::Private::effectivenessChanged(const Fraction& multiplier)
 {
-    ui_typechart->model()->setData(m_index, QVariant::fromValue(multiplier), Qt::EditRole);
-    if (!m_changingMult)
-        emit(changed());
-    m_changingMult = false;
-    setGui();
+    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 4124a09f..189a8a1d 100644
--- a/sigmodr/widgets/GameUI_p.h
+++ b/sigmodr/widgets/GameUI_p.h
@@ -80,8 +80,7 @@ class GameUI::Private : public ObjectUIPrivate
         QLabel* ui_labelTypes;
         CoreWidgets::FractionWidget* ui_effectiveness;
         
-        bool m_changingMult;
-        QModelIndex m_index;
+        bool m_changing;
 };
 }
 }
diff --git a/sigmodr/widgets/GlobalScriptUI.cpp b/sigmodr/widgets/GlobalScriptUI.cpp
index 6827b39e..4aba3552 100644
--- a/sigmodr/widgets/GlobalScriptUI.cpp
+++ b/sigmodr/widgets/GlobalScriptUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "GlobalScriptUI.h"
+#include "GlobalScriptUI_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;
 
 GlobalScriptUI::GlobalScriptUI(GlobalScript* globalScript, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(globalScript, parent),
+        d(new Private(new GlobalScript(*globalScript)))
 {
-    setObjects(globalScript, new GlobalScript(*globalScript));
+    setWidget(d->makeWidgets(this));
 }
 
-void GlobalScriptUI::initGui()
+void GlobalScriptUI::apply()
 {
-    QFile file(":/gui/globalscript.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<GlobalScript*>(m_object) = *d->m_globalScript;
+    ObjectUI::apply();
 }
 
-void GlobalScriptUI::setGui()
+void GlobalScriptUI::discard()
 {
-    ui_name->setText(qobject_cast<GlobalScript*>(modified())->name());
-    ui_script->setValue(qobject_cast<GlobalScript*>(modified())->script());
+    *d->m_globalScript = *qobject_cast<GlobalScript*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void GlobalScriptUI::apply()
+GlobalScriptUI::Private::Private(GlobalScript* globalScript) :
+        ObjectUIPrivate(globalScript),
+        m_globalScript(globalScript)
 {
-    *qobject_cast<GlobalScript*>(original()) = *qobject_cast<GlobalScript*>(modified());
-    emit(changed(false));
 }
 
-void GlobalScriptUI::discard()
+GlobalScriptUI::Private::~Private()
+{
+    delete m_globalScript;
+}
+
+QWidget* GlobalScriptUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/globalscript.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 GlobalScriptUI::Private::resetGui()
 {
-    *qobject_cast<GlobalScript*>(modified()) = *qobject_cast<GlobalScript*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_globalScript->name());
+    ui_script->setValue(m_globalScript->script());
 }
 
-void GlobalScriptUI::nameChanged(const QString& name)
+void GlobalScriptUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<GlobalScript*>(modified())->setName(name);
+    m_globalScript->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void GlobalScriptUI::scriptChanged(const Script& script)
+void GlobalScriptUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<GlobalScript*>(modified())->setScript(script);
+    m_globalScript->setScript(script);
 }
diff --git a/sigmodr/widgets/ItemTypeUI.cpp b/sigmodr/widgets/ItemTypeUI.cpp
index c1427631..e816c933 100644
--- a/sigmodr/widgets/ItemTypeUI.cpp
+++ b/sigmodr/widgets/ItemTypeUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "ItemTypeUI.h"
+#include "ItemTypeUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -28,92 +29,94 @@
 #include <KIntNumInput>
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 ItemTypeUI::ItemTypeUI(ItemType* itemType, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(itemType, parent),
+        d(new Private(new ItemType(*itemType)))
 {
-    setObjects(itemType, new ItemType(*itemType));
+    setWidget(d->makeWidgets(this));
 }
 
-void ItemTypeUI::initGui()
+void ItemTypeUI::apply()
 {
-    QFile file(":/gui/itemtype.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_computer = formWidget->findChild<KIntNumInput*>("varComputer");
-    ui_player = formWidget->findChild<KIntNumInput*>("varPlayer");
-    ui_maxWeight = formWidget->findChild<KIntNumInput*>("varMaxWeight");
-    ui_count = formWidget->findChild<KComboBox*>("varCount");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_computer, SIGNAL(valueChanged(int)), this, SLOT(computerChanged(int)));
-    connect(ui_player, SIGNAL(valueChanged(int)), this, SLOT(playerChanged(int)));
-    connect(ui_maxWeight, SIGNAL(valueChanged(int)), this, SLOT(maxWeightChanged(int)));
-    connect(ui_count, SIGNAL(currentIndexChanged(int)), this, SLOT(countChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
-    ui_count->addItems(ItemType::CountStr);
+    *qobject_cast<ItemType*>(m_object) = *d->m_itemType;
+    ObjectUI::apply();
 }
 
-void ItemTypeUI::refreshGui()
+void ItemTypeUI::discard()
 {
-    ui_maxWeight->setMaximum(game()->rules()->maxTotalWeight());
+    *d->m_itemType = *qobject_cast<ItemType*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void ItemTypeUI::setGui()
+ItemTypeUI::Private::Private(ItemType* itemType) :
+        ObjectUIPrivate(itemType),
+        m_itemType(itemType)
 {
-    ui_name->setText(qobject_cast<ItemType*>(modified())->name());
-    ui_computer->setValue(qobject_cast<ItemType*>(modified())->computer());
-    ui_player->setValue(qobject_cast<ItemType*>(modified())->player());
-    ui_maxWeight->setValue(qobject_cast<ItemType*>(modified())->maxWeight());
-    ui_count->setCurrentIndex(qobject_cast<ItemType*>(modified())->count());
 }
 
-void ItemTypeUI::apply()
+ItemTypeUI::Private::~Private()
 {
-    *qobject_cast<ItemType*>(original()) = *qobject_cast<ItemType*>(modified());
-    emit(changed(false));
+    delete m_itemType;
 }
 
-void ItemTypeUI::discard()
+QWidget* ItemTypeUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/itemtype.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_computer = form->findChild<KIntNumInput*>("varComputer");
+    ui_player = form->findChild<KIntNumInput*>("varPlayer");
+    ui_maxWeight = form->findChild<KIntNumInput*>("varMaxWeight");
+    ui_count = form->findChild<KComboBox*>("varCount");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_computer, SIGNAL(valueChanged(int)), this, SLOT(computerChanged(int)));
+    connect(ui_player, SIGNAL(valueChanged(int)), this, SLOT(playerChanged(int)));
+    connect(ui_maxWeight, SIGNAL(valueChanged(int)), this, SLOT(maxWeightChanged(int)));
+    connect(ui_count, SIGNAL(currentIndexChanged(int)), this, SLOT(countChanged(int)));
+    ui_count->addItems(ItemType::CountStr);
+    return form;
+}
+
+void ItemTypeUI::Private::refreshGui()
+{
+    ui_maxWeight->setMaximum(m_itemType->game()->rules()->maxTotalWeight());
+}
+
+void ItemTypeUI::Private::resetGui()
 {
-    *qobject_cast<ItemType*>(modified()) = *qobject_cast<ItemType*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_itemType->name());
+    ui_computer->setValue(m_itemType->computer());
+    ui_player->setValue(m_itemType->player());
+    ui_maxWeight->setValue(m_itemType->maxWeight());
+    ui_count->setCurrentIndex(m_itemType->count());
 }
 
-void ItemTypeUI::nameChanged(const QString& name)
+void ItemTypeUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<ItemType*>(modified())->setName(name);
+    m_itemType->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void ItemTypeUI::computerChanged(const int computer)
+void ItemTypeUI::Private::computerChanged(const int computer)
 {
-    qobject_cast<ItemType*>(modified())->setComputer(computer);
+    m_itemType->setComputer(computer);
 }
 
-void ItemTypeUI::playerChanged(const int player)
+void ItemTypeUI::Private::playerChanged(const int player)
 {
-    qobject_cast<ItemType*>(modified())->setPlayer(player);
+    m_itemType->setPlayer(player);
 }
 
-void ItemTypeUI::maxWeightChanged(const int maxWeight)
+void ItemTypeUI::Private::maxWeightChanged(const int maxWeight)
 {
-    qobject_cast<ItemType*>(modified())->setMaxWeight(maxWeight);
+    m_itemType->setMaxWeight(maxWeight);
 }
 
-void ItemTypeUI::countChanged(const int count)
+void ItemTypeUI::Private::countChanged(const int count)
 {
-    qobject_cast<ItemType*>(modified())->setCount(static_cast<ItemType::Count>(count));
+    m_itemType->setCount(static_cast<ItemType::Count>(count));
 }
diff --git a/sigmodr/widgets/ItemUI.cpp b/sigmodr/widgets/ItemUI.cpp
index 4dda8c51..26234204 100644
--- a/sigmodr/widgets/ItemUI.cpp
+++ b/sigmodr/widgets/ItemUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "ItemUI.h"
+#include "ItemUI_p.h"
 
 // Sigmodr core widget includes
 #include <sigmodr/corewidgets/ScriptWidget.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,26 +42,47 @@ using namespace Sigmodr::CoreWidgets;
 using namespace Sigmodr::Widgets;
 
 ItemUI::ItemUI(Item* item, QWidget* parent) :
-        ObjectUI(parent),
-        m_lastType(-1)
-{
-    setObjects(item, new Item(*item));
-}
-
-void ItemUI::initGui()
-{
-    QFile file(":/gui/item.ui");
-    file.open(QFile::ReadOnly);
-    QWidget *formWidget = QUiLoader().load(&file, this);
-    file.close();
-    ui_name = formWidget->findChild<KLineEdit*>("varName");
-    ui_sellable = formWidget->findChild<QCheckBox*>("varSellable");
-    ui_type = formWidget->findChild<KComboBox*>("varType");
-    ui_price = formWidget->findChild<KIntNumInput*>("varPrice");
-    ui_sellPrice = formWidget->findChild<KIntNumInput*>("varSellPrice");
-    ui_weight = formWidget->findChild<KIntNumInput*>("varWeight");
-    ui_description = formWidget->findChild<KLineEdit*>("varDescription");
-    ui_script = formWidget->findChild<ScriptWidget*>("varScript");
+        ObjectUI(item, parent),
+        d(new Private(new Item(*item)))
+{
+    setWidget(d->makeWidgets(this));
+}
+
+void ItemUI::apply()
+{
+    *qobject_cast<Item*>(m_object) = *d->m_item;
+    ObjectUI::apply();
+}
+
+void ItemUI::discard()
+{
+    *d->m_item = *qobject_cast<Item*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
+}
+
+ItemUI::Private::Private(Item* item) :
+        ObjectUIPrivate(item),
+        m_item(item)
+{
+}
+
+ItemUI::Private::~Private()
+{
+    delete m_item;
+}
+
+QWidget* ItemUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/item.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_sellable = form->findChild<QCheckBox*>("varSellable");
+    ui_type = form->findChild<KComboBox*>("varType");
+    ui_price = form->findChild<KIntNumInput*>("varPrice");
+    ui_sellPrice = form->findChild<KIntNumInput*>("varSellPrice");
+    ui_weight = form->findChild<KIntNumInput*>("varWeight");
+    ui_description = form->findChild<KLineEdit*>("varDescription");
+    ui_script = form->findChild<ScriptWidget*>("varScript");
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
     connect(ui_sellable, SIGNAL(toggled(bool)), this, SLOT(sellableChanged(bool)));
     connect(ui_type, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
@@ -72,96 +91,79 @@ void ItemUI::initGui()
     connect(ui_weight, SIGNAL(valueChanged(int)), this, SLOT(weightChanged(int)));
     connect(ui_description, SIGNAL(textChanged(QString)), this, SLOT(descriptionChanged(QString)));
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
+    return form;
 }
 
-void ItemUI::refreshGui()
+void ItemUI::Private::refreshGui()
 {
     const bool blocked = ui_type->blockSignals(true);
     ui_type->clear();
-    for (int i = 0; i < game()->itemTypeCount(); ++i)
-        ui_type->addItem(game()->itemType(i)->name());
+    for (int i = 0; i < m_item->game()->itemTypeCount(); ++i)
+        ui_type->addItem(m_item->game()->itemType(i)->name());
     ui_type->blockSignals(blocked);
-    ui_price->setMaximum(game()->rules()->maxMoney());
+    ui_price->setMaximum(m_item->game()->rules()->maxMoney());
 }
 
-void ItemUI::setGui()
+void ItemUI::Private::resetGui()
 {
-    const bool resetWeight = (qobject_cast<Item*>(modified())->type() != m_lastType);
-    ui_name->setText(qobject_cast<Item*>(modified())->name());
-    ui_sellable->setCheckState(qobject_cast<Item*>(modified())->sellable() ? Qt::Checked : Qt::Unchecked);
-    ui_type->setCurrentIndex(game()->itemTypeIndex(qobject_cast<Item*>(modified())->type()));
-    m_lastType = qobject_cast<Item*>(modified())->type();
-    ui_price->setValue(qobject_cast<Item*>(modified())->price());
-    ui_sellPrice->setValue(qobject_cast<Item*>(modified())->sellPrice());
-    ui_sellPrice->setEnabled(qobject_cast<Item*>(modified())->sellable());
-    if (resetWeight)
-    {
-        const ItemType* itemType = game()->itemTypeById(qobject_cast<Item*>(modified())->type());
-        if (itemType)
-            ui_weight->setMaximum(itemType->maxWeight());
-    }
-    ui_weight->setValue(qobject_cast<Item*>(modified())->weight());
-    ui_description->setText(qobject_cast<Item*>(modified())->description());
-    ui_script->setValue(qobject_cast<Item*>(modified())->script());
+    ui_name->setText(m_item->name());
+    ui_sellable->setCheckState(m_item->sellable() ? Qt::Checked : Qt::Unchecked);
+    ui_type->setCurrentIndex(m_item->game()->itemTypeIndex(m_item->type()));
+    ui_price->setValue(m_item->price());
+    ui_sellPrice->setValue(m_item->sellPrice());
+    ui_sellPrice->setEnabled(m_item->sellable());
+    ui_weight->setValue(m_item->weight());
+    ui_description->setText(m_item->description());
+    ui_script->setValue(m_item->script());
 }
 
-void ItemUI::apply()
-{
-    *qobject_cast<Item*>(original()) = *qobject_cast<Item*>(modified());
-    emit(changed(false));
-}
-
-void ItemUI::discard()
-{
-    *qobject_cast<Item*>(modified()) = *qobject_cast<Item*>(original());
-    setGui();
-    emit(changed(false));
-}
-
-void ItemUI::nameChanged(const QString& name)
+void ItemUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Item*>(modified())->setName(name);
+    m_item->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void ItemUI::sellableChanged(const bool sellable)
+void ItemUI::Private::sellableChanged(const bool sellable)
 {
-    qobject_cast<Item*>(modified())->setSellable(sellable);
+    m_item->setSellable(sellable);
 }
 
-void ItemUI::typeChanged(const int type)
+void ItemUI::Private::typeChanged(const int type)
 {
     if (0 <= type)
-        qobject_cast<Item*>(modified())->setType(game()->itemType(type)->id());
+    {
+        const ItemType* itemType = m_item->game()->itemTypeById(m_item->type());
+        m_item->setType(itemType->id());
+        ui_weight->setMaximum(itemType->maxWeight());
+    }
+    else
+        ui_weight->setMaximum(INT_MAX);
 }
 
-void ItemUI::priceChanged(const int price)
+void ItemUI::Private::priceChanged(const int price)
 {
-    qobject_cast<Item*>(modified())->setPrice(price);
+    m_item->setPrice(price);
 }
 
-void ItemUI::sellPriceChanged(const int sellPrice)
+void ItemUI::Private::sellPriceChanged(const int sellPrice)
 {
-    qobject_cast<Item*>(modified())->setSellPrice(sellPrice);
+    m_item->setSellPrice(sellPrice);
 }
 
-void ItemUI::weightChanged(const int weight)
+void ItemUI::Private::weightChanged(const int weight)
 {
-    qobject_cast<Item*>(modified())->setWeight(weight);
+    m_item->setWeight(weight);
 }
 
-void ItemUI::descriptionChanged(const QString& description)
+void ItemUI::Private::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Item*>(modified())->setDescription(description);
+    m_item->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void ItemUI::scriptChanged(const Script& script)
+void ItemUI::Private::scriptChanged(const Script& script)
 {
-    qobject_cast<Item*>(modified())->setScript(script);
+    m_item->setScript(script);
 }
diff --git a/sigmodr/widgets/ItemUI_p.h b/sigmodr/widgets/ItemUI_p.h
index 0570b1ae..514ce89d 100644
--- a/sigmodr/widgets/ItemUI_p.h
+++ b/sigmodr/widgets/ItemUI_p.h
@@ -75,8 +75,6 @@ class ItemUI::Private : public ObjectUIPrivate
         KIntNumInput* ui_weight;
         KLineEdit* ui_description;
         CoreWidgets::ScriptWidget* ui_script;
-        
-        int m_lastType;
 };
 }
 }
diff --git a/sigmodr/widgets/MapUI.cpp b/sigmodr/widgets/MapUI.cpp
index 17426e98..8dd0356c 100644
--- a/sigmodr/widgets/MapUI.cpp
+++ b/sigmodr/widgets/MapUI.cpp
@@ -17,6 +17,7 @@
 
 // Header include
 #include "MapUI.h"
+#include "MapUI_p.h"
 
 // Sigmod includes
 #include <sigmod/Game.h>
@@ -29,68 +30,67 @@
 #include <KComboBox>
 #include <KLineEdit>
 
-// Qt includes
-#include <QtCore/QFile>
-#include <QtGui/QVBoxLayout>
-#include <QtUiTools/QUiLoader>
-
 // FIXME: Update map editing to new collage map
 
 using namespace Sigmod;
 using namespace Sigmodr::Widgets;
 
 MapUI::MapUI(Map* map, QWidget* parent) :
-        ObjectUI(parent)
+        ObjectUI(map, parent),
+        d(new Private(new Map(*map)))
 {
-    setObjects(map, new Map(*map));
-//     varMap->setMap(map);
-//     connect(varMap, SIGNAL(changed()), this, SIGNAL(changed()));
+    setWidget(d->makeWidgets(this));
 }
 
-void MapUI::initGui()
+void MapUI::apply()
 {
-    QFile file(":/gui/map.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");
-    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
-    connect(ui_type, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
-    QVBoxLayout* layout = new QVBoxLayout;
-    layout->addWidget(formWidget);
-    setLayout(layout);
-    ui_type->addItems(Map::TypeStr);
+    *qobject_cast<Map*>(m_object) = *d->m_map;
+    ObjectUI::apply();
 }
 
-void MapUI::setGui()
+void MapUI::discard()
 {
-    ui_name->setText(qobject_cast<Map*>(modified())->name());
-    ui_type->setCurrentIndex(qobject_cast<Map*>(modified())->type());
-//     varMap->reset();
+    *d->m_map = *qobject_cast<Map*>(m_object);
+    d->resetGui();
+    ObjectUI::discard();
 }
 
-void MapUI::apply()
+MapUI::Private::Private(Map* map) :
+        ObjectUIPrivate(map),
+        m_map(map)
 {
-    *qobject_cast<Map*>(original()) = *qobject_cast<Map*>(modified());
-    emit(changed(false));
 }
 
-void MapUI::discard()
+MapUI::Private::~Private()
+{
+    delete m_map;
+}
+
+QWidget* MapUI::Private::makeWidgets(ObjectUI* widget)
+{
+    QWidget *form = openUiFile(":/gui/map.ui", widget);
+    ui_name = form->findChild<KLineEdit*>("varName");
+    ui_type = form->findChild<KComboBox*>("varType");
+    connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
+    connect(ui_type, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
+    ui_type->addItems(Map::TypeStr);
+    return form;
+}
+
+void MapUI::Private::resetGui()
 {
-    *qobject_cast<Map*>(modified()) = *qobject_cast<Map*>(original());
-    setGui();
-    emit(changed(false));
+    ui_name->setText(m_map->name());
+    ui_type->setCurrentIndex(m_map->type());
 }
 
-void MapUI::nameChanged(const QString& name)
+void MapUI::Private::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Map*>(modified())->setName(name);
+    m_map->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void MapUI::typeChanged(const int type)
+void MapUI::Private::typeChanged(const int type)
 {
-    qobject_cast<Map*>(modified())->setType(static_cast<Map::Type>(type));
+    m_map->setType(static_cast<Map::Type>(type));
 }