1 files changed, 128 insertions, 124 deletions

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);
 }