[FIX] Modified Rules a bit

[FIX] Updated Rules widget to match up with Rules
[FIX] Reorganized the Rules widget
[FIX] Using KStandardDirs rather than hardcoded ones
[FIX] Cleaned up some minor things with KListWidgets

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

1 files changed, 78 insertions, 60 deletions

diff --git a/pokemodr/RulesUI.cpp b/pokemodr/RulesUI.cpp
index 80ed5c49..c41ec4fb 100644
--- a/pokemodr/RulesUI.cpp
+++ b/pokemodr/RulesUI.cpp
@@ -41,20 +41,9 @@ void RulesUI::setGui()
 {
     boxGenders->setChecked(static_cast<Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
     varBreeding->setCheckState(static_cast<Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
-    varHeldItems->setValue(static_cast<Rules*>(modified())->holdItems());
-    boxCriticalDomains->setChecked(static_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
-    boxAllowAbilities->setChecked(static_cast<Rules*>(modified())->abilityAllowed() ? Qt::Checked : Qt::Unchecked);
-    boxAllowNatures->setChecked(static_cast<Rules*>(modified())->natureAllowed() ? Qt::Checked : Qt::Unchecked);
-    varBoxes->setValue(static_cast<Rules*>(modified())->numBoxes());
-    varBoxSize->setEnabled(0 < static_cast<Rules*>(modified())->numBoxes());
-    varBoxSize->setValue(static_cast<Rules*>(modified())->boxSize());
-    varMaxParty->setValue(static_cast<Rules*>(modified())->maxParty());
-    varMaxFight->setMaximum(static_cast<Rules*>(modified())->maxParty());
-    varMaxFight->setValue(static_cast<Rules*>(modified())->maxFight());
-    varMaxMoves->setValue(static_cast<Rules*>(modified())->maxMoves());
-    varMaxLevel->setValue(static_cast<Rules*>(modified())->maxLevel());
-    varMaxMoney->setValue(static_cast<Rules*>(modified())->maxMoney());
-    boxHardCash->setChecked(static_cast<Rules*>(modified())->hardCash() ? Qt::Checked : Qt::Unchecked);
+    varCriticalDomains->setChecked(static_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
+    varHardCash->setChecked(static_cast<Rules*>(modified())->hardCash() ? Qt::Checked : Qt::Unchecked);
+    varSwitchStyle->setChecked(static_cast<Rules*>(modified())->allowSwitchStyle() ? Qt::Checked : Qt::Unchecked);
     boxSplitSpecial->setChecked(static_cast<Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
     varSplitSpecialDV->setCheckState(static_cast<Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
     varMaxDV->setCurrentIndex(static_cast<Rules*>(modified())->maxDVValue());
@@ -68,6 +57,20 @@ void RulesUI::setGui()
     varMaxEVPerStat->setMaximum(static_cast<Rules*>(modified())->maxTotalEV());
     varMaxEVPerStat->setValue(static_cast<Rules*>(modified())->maxEVPerStat());
     varPokerus->setValue(static_cast<Rules*>(modified())->pokerusChance());
+    varBoxes->setValue(static_cast<Rules*>(modified())->numBoxes());
+    varBoxSize->setEnabled(0 < static_cast<Rules*>(modified())->numBoxes());
+    varBoxSize->setValue(static_cast<Rules*>(modified())->boxSize());
+    varMaxParty->setValue(static_cast<Rules*>(modified())->maxParty());
+    varMaxFight->setMaximum(static_cast<Rules*>(modified())->maxParty());
+    varMaxFight->setValue(static_cast<Rules*>(modified())->maxFight());
+    varMaxPlayers->setValue(static_cast<Rules*>(modified())->maxPlayers());
+    varMaxMoves->setValue(static_cast<Rules*>(modified())->maxMoves());
+    varMaxLevel->setValue(static_cast<Rules*>(modified())->maxLevel());
+    varMaxHeldItems->setValue(static_cast<Rules*>(modified())->maxHeldItems());
+    varMaxNatures->setValue(static_cast<Rules*>(modified())->maxNatures());
+    varMaxAbilities->setValue(static_cast<Rules*>(modified())->maxAbilities());
+    varMaxStages->setValue(static_cast<Rules*>(modified())->maxStages());
+    varMaxMoney->setValue(static_cast<Rules*>(modified())->maxMoney());
 }
 
 void RulesUI::apply()
@@ -93,117 +96,132 @@ void RulesUI::on_varBreeding_toggled(const bool breeding)
     static_cast<Rules*>(modified())->setBreedingAllowed(breeding);
 }
 
-void RulesUI::on_varHeldItems_valueChanged(const int heldItems)
+void RulesUI::on_varCriticalDomains_toggled(const bool criticalDomains)
 {
-    static_cast<Rules*>(modified())->setHoldItems(heldItems);
+    static_cast<Rules*>(modified())->setCriticalDomains(criticalDomains);
 }
 
-void RulesUI::on_boxCriticalDomains_toggled(const bool criticalDomains)
+void RulesUI::on_varHardCash_toggled(const bool hardCash)
 {
-    static_cast<Rules*>(modified())->setCriticalDomains(criticalDomains);
+    static_cast<Rules*>(modified())->setHardCash(hardCash);
 }
 
-void RulesUI::on_boxAllowAbilities_toggled(const bool allowAbilities)
+void RulesUI::on_varSwitchStyle_toggled(const bool switchStyle)
 {
-    static_cast<Rules*>(modified())->setAbilityAllowed(allowAbilities);
+    static_cast<Rules*>(modified())->setAllowSwitchStyle(switchStyle);
 }
 
-void RulesUI::on_boxAllowNatures_toggled(const bool allowNatures)
+void RulesUI::on_boxSplitSpecial_toggled(const bool splitSpecial)
 {
-    static_cast<Rules*>(modified())->setNatureAllowed(allowNatures);
+    static_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
 }
 
-void RulesUI::on_varBoxes_valueChanged(const int boxes)
+void RulesUI::on_varSplitSpecialDV_toggled(const bool splitSpecialDV)
 {
-    static_cast<Rules*>(modified())->setNumBoxes(boxes);
+    static_cast<Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
 }
 
-void RulesUI::on_varBoxSize_valueChanged(const int boxSize)
+void RulesUI::on_varMaxDV_activated(const int maxDV)
 {
-    static_cast<Rules*>(modified())->setBoxSize(boxSize);
+    static_cast<Rules*>(modified())->setMaxDVValue(maxDV);
 }
 
-void RulesUI::on_varMaxParty_valueChanged(const int maxParty)
+void RulesUI::on_boxHappiness_toggled(const bool happiness)
 {
-    static_cast<Rules*>(modified())->setMaxParty(maxParty);
+    static_cast<Rules*>(modified())->setHappiness(happiness);
 }
 
-void RulesUI::on_varMaxFight_valueChanged(const int maxFight)
+void RulesUI::on_varFaintLoss_valueChanged(const int faintLoss)
 {
-    static_cast<Rules*>(modified())->setMaxFight(maxFight);
+    static_cast<Rules*>(modified())->setHappyFaintLoss(faintLoss);
 }
 
-void RulesUI::on_varMaxMoves_valueChanged(const int maxMoves)
+void RulesUI::on_varLevelGain_valueChanged(const int levelGain)
 {
-    static_cast<Rules*>(modified())->setMaxMoves(maxMoves);
+    static_cast<Rules*>(modified())->setHappyLevelGain(levelGain);
 }
 
-void RulesUI::on_varMaxLevel_valueChanged(const int maxLevel)
+void RulesUI::on_varNumSteps_valueChanged(const int numSteps)
 {
-    static_cast<Rules*>(modified())->setMaxLevel(maxLevel);
+    static_cast<Rules*>(modified())->setHappySteps(numSteps);
 }
 
-void RulesUI::on_varMaxMoney_valueChanged(const int maxMoney)
+void RulesUI::on_boxEffortValues_toggled(const bool effortValues)
 {
-    static_cast<Rules*>(modified())->setMaxMoney(maxMoney);
+    static_cast<Rules*>(modified())->setEffortValuesAllowed(effortValues);
 }
 
-void RulesUI::on_boxHardCash_toggled(const bool hardCash)
+void RulesUI::on_varMaxEV_valueChanged(const int maxEV)
 {
-    static_cast<Rules*>(modified())->setHardCash(hardCash);
+    static_cast<Rules*>(modified())->setMaxTotalEV(maxEV);
 }
 
-void RulesUI::on_boxSplitSpecial_toggled(const bool splitSpecial)
+void RulesUI::on_varMaxEVPerStat_valueChanged(const int maxEVPerStat)
 {
-    static_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
+    static_cast<Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
 }
 
-void RulesUI::on_varSplitSpecialDV_toggled(const bool splitSpecialDV)
+void RulesUI::on_varPokerus_valueChanged(const Fraction& pokerusChance)
 {
-    static_cast<Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
+    static_cast<Rules*>(modified())->setPokerusChance(pokerusChance);
 }
 
-void RulesUI::on_varMaxDV_activated(const int maxDV)
+void RulesUI::on_varBoxes_valueChanged(const int boxes)
 {
-    static_cast<Rules*>(modified())->setMaxDVValue(maxDV);
+    static_cast<Rules*>(modified())->setNumBoxes(boxes);
 }
 
-void RulesUI::on_boxHappiness_toggled(const bool happiness)
+void RulesUI::on_varBoxSize_valueChanged(const int boxSize)
 {
-    static_cast<Rules*>(modified())->setHappiness(happiness);
+    static_cast<Rules*>(modified())->setBoxSize(boxSize);
 }
 
-void RulesUI::on_varFaintLoss_valueChanged(const int faintLoss)
+void RulesUI::on_varMaxParty_valueChanged(const int maxParty)
 {
-    static_cast<Rules*>(modified())->setHappyFaintLoss(faintLoss);
+    static_cast<Rules*>(modified())->setMaxParty(maxParty);
 }
 
-void RulesUI::on_varLevelGain_valueChanged(const int levelGain)
+void RulesUI::on_varMaxFight_valueChanged(const int maxFight)
 {
-    static_cast<Rules*>(modified())->setHappyLevelGain(levelGain);
+    static_cast<Rules*>(modified())->setMaxFight(maxFight);
 }
 
-void RulesUI::on_varNumSteps_valueChanged(const int numSteps)
+void RulesUI::on_varMaxPlayers_valueChanged(const int maxPlayers)
 {
-    static_cast<Rules*>(modified())->setHappySteps(numSteps);
+    static_cast<Rules*>(modified())->setMaxPlayers(maxPlayers);
 }
 
-void RulesUI::on_boxEffortValues_toggled(const bool effortValues)
+void RulesUI::on_varMaxMoves_valueChanged(const int maxMoves)
 {
-    static_cast<Rules*>(modified())->setEffortValuesAllowed(effortValues);
+    static_cast<Rules*>(modified())->setMaxMoves(maxMoves);
 }
 
-void RulesUI::on_varMaxEV_valueChanged(const int maxEV)
+void RulesUI::on_varMaxLevel_valueChanged(const int maxLevel)
 {
-    static_cast<Rules*>(modified())->setMaxTotalEV(maxEV);
+    static_cast<Rules*>(modified())->setMaxLevel(maxLevel);
 }
 
-void RulesUI::on_varMaxEVPerStat_valueChanged(const int maxEVPerStat)
+void RulesUI::on_varMaxHeldItems_valueChanged(const int maxHeldItems)
 {
-    static_cast<Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
+    static_cast<Rules*>(modified())->setMaxHeldItems(maxHeldItems);
 }
 
-void RulesUI::on_varPokerus_valueChanged(const Fraction& pokerusChance)
+void RulesUI::on_varMaxNatures_valueChanged(const int maxNatures)
 {
-    static_cast<Rules*>(modified())->setPokerusChance(pokerusChance);
+    static_cast<Rules*>(modified())->setMaxNatures(maxNatures);
+}
+
+void RulesUI::on_varMaxAbilities_valueChanged(const int maxAbilities)
+{
+    static_cast<Rules*>(modified())->setMaxAbilities(maxAbilities);
+}
+
+void RulesUI::on_varMaxStages_valueChanged(const int maxStages)
+{
+    static_cast<Rules*>(modified())->setMaxStages(maxStages);
+}
+
+void RulesUI::on_varMaxMoney_valueChanged(const int maxMoney)
+{
+    static_cast<Rules*>(modified())->setMaxMoney(maxMoney);
 }