Merge remote-tracking branch 'origin/launcher-model' into launcher-model

Conflicts:
	apps/launcher/datafilespage.cpp

CMakeLists.txt

@@ -306,7 +306,7 @@ endif()
 
 # Compiler settings
 if (CMAKE_COMPILER_IS_GNUCC)
-    add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder)
+    add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder -std=c++0x -pedantic)
 
     # Silence warnings in OGRE headers. Remove once OGRE got fixed!
     add_definitions (-Wno-ignored-qualifiers)

apps/esmtool/CMakeLists.txt

@@ -1,5 +1,7 @@
 set(ESMTOOL
   esmtool.cpp
+  labels.hpp
+  labels.cpp
   record.hpp
   record.cpp
 )

apps/esmtool/labels.cpp

@@ -0,0 +1,881 @@
+#include "labels.hpp"
+
+#include <components/esm/loadbody.hpp>
+#include <components/esm/loadcell.hpp>
+#include <components/esm/loadcont.hpp>
+#include <components/esm/loadcrea.hpp>
+#include <components/esm/loadlevlist.hpp>
+#include <components/esm/loadligh.hpp>
+#include <components/esm/loadmgef.hpp>
+#include <components/esm/loadnpc.hpp>
+#include <components/esm/loadrace.hpp>
+#include <components/esm/loadspel.hpp>
+#include <components/esm/loadweap.hpp>
+#include <components/esm/aipackage.hpp>
+
+#include <iostream>
+#include <boost/format.hpp>
+
+std::string bodyPartLabel(char idx)
+{
+    const char *bodyPartLabels[] =  {
+        "Head",
+        "Hair",
+        "Neck",
+        "Cuirass",
+        "Groin",
+        "Skirt",
+        "Right Hand",
+        "Left Hand",
+        "Right Wrist",
+        "Left Wrist",
+        "Shield",
+        "Right Forearm",
+        "Left Forearm",
+        "Right Upperarm",
+        "Left Upperarm",
+        "Right Foot",
+        "Left Foot",
+        "Right Ankle",
+        "Left Ankle",
+        "Right Knee",
+        "Left Knee",
+        "Right Leg",
+        "Left Leg",
+        "Right Shoulder",
+        "Left Shoulder",
+        "Weapon",
+        "Tail"
+    };
+    
+    if ((int)idx >= 0 && (int)(idx) <= 26)
+        return bodyPartLabels[(int)(idx)];
+    else
+        return "Invalid";
+}
+
+std::string meshPartLabel(char idx)
+{
+    const char *meshPartLabels[] =  {
+        "Head",
+        "Hair",
+        "Neck",
+        "Chest",
+        "Groin",
+        "Hand",
+        "Wrist",
+        "Forearm",
+        "Upperarm",
+        "Foot",
+        "Ankle",
+        "Knee",
+        "Upper Leg",
+        "Clavicle",
+        "Tail"
+    };
+    
+    if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MP_Tail)
+        return meshPartLabels[(int)(idx)];
+    else
+        return "Invalid";
+}
+
+std::string meshTypeLabel(char idx)
+{
+    const char *meshTypeLabels[] =  {
+        "Skin",
+        "Clothing",
+        "Armor"
+    };
+    
+    if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MT_Armor)
+        return meshTypeLabels[(int)(idx)];
+    else
+        return "Invalid";   
+}
+
+std::string clothingTypeLabel(int idx)
+{
+    const char *clothingTypeLabels[] = {
+        "Pants",
+        "Shoes",
+        "Shirt",
+        "Belt",
+        "Robe",
+        "Right Glove",
+        "Left Glove",
+        "Skirt",
+        "Ring",
+        "Amulet"
+    };
+    
+    if (idx >= 0 && idx <= 9)
+        return clothingTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string armorTypeLabel(int idx)
+{
+    const char *armorTypeLabels[] = {
+        "Helmet",
+        "Cuirass",
+        "Left Pauldron",
+        "Right Pauldron",
+        "Greaves",
+        "Boots",
+        "Left Gauntlet",
+        "Right Gauntlet",
+        "Shield",
+        "Left Bracer",
+        "Right Bracer"
+    };
+    
+    if (idx >= 0 && idx <= 10)
+        return armorTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string dialogTypeLabel(int idx)
+{
+    const char *dialogTypeLabels[] = {
+        "Topic",
+        "Voice",
+        "Greeting",
+        "Persuasion",
+        "Journal"
+    };
+    
+    if (idx >= 0 && idx <= 4)
+        return dialogTypeLabels[idx];
+    else if (idx == -1)
+        return "Deleted";
+    else
+        return "Invalid";
+}
+
+std::string questStatusLabel(int idx)
+{
+    const char *questStatusLabels[] = {
+        "None",
+        "Name",
+        "Finished",
+        "Restart",
+        "Deleted"
+    };
+    
+    if (idx >= 0 && idx <= 4)
+        return questStatusLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string creatureTypeLabel(int idx)
+{
+    const char *creatureTypeLabels[] = {
+        "Creature",
+        "Daedra",
+        "Undead",
+        "Humanoid",
+    };
+    
+    if (idx >= 0 && idx <= 3)
+        return creatureTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string soundTypeLabel(int idx)
+{
+    const char *soundTypeLabels[] = {
+        "Left Foot",
+        "Right Foot",
+        "Swim Left",
+        "Swim Right",
+        "Moan",
+        "Roar",
+        "Scream",
+        "Land"
+    };
+    
+    if (idx >= 0 && idx <= 7)
+        return soundTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string weaponTypeLabel(int idx)
+{
+    const char *weaponTypeLabels[] = {
+        "Short Blade One Hand",
+        "Long Blade One Hand",
+        "Long Blade Two Hand",
+        "Blunt One Hand",
+        "Blunt Two Close",
+        "Blunt Two Wide",
+        "Spear Two Wide",
+        "Axe One Hand",
+        "Axe Two Hand",
+        "Marksman Bow",
+        "Marksman Crossbow",
+        "Marksman Thrown",
+        "Arrow",
+        "Bolt"
+    };
+    
+    if (idx >= 0 && idx <= 13)
+        return weaponTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string aiTypeLabel(int type)
+{
+    if (type == ESM::AI_Wander) return "Wander";
+    else if (type == ESM::AI_Travel) return "Travel";
+    else if (type == ESM::AI_Follow) return "Follow";
+    else if (type == ESM::AI_Escort) return "Escort";
+    else if (type == ESM::AI_Activate) return "Activate";
+    else return "Invalid";
+}
+
+std::string magicEffectLabel(int idx)
+{
+    const char* magicEffectLabels [] = {
+        "Water Breathing",
+        "Swift Swim",
+        "Water Walking",
+        "Shield",
+        "Fire Shield",
+        "Lightning Shield",
+        "Frost Shield",
+        "Burden",
+        "Feather",
+        "Jump",
+        "Levitate",
+        "SlowFall",
+        "Lock",
+        "Open",
+        "Fire Damage",
+        "Shock Damage",
+        "Frost Damage",
+        "Drain Attribute",
+        "Drain Health",
+        "Drain Magicka",
+        "Drain Fatigue",
+        "Drain Skill",
+        "Damage Attribute",
+        "Damage Health",
+        "Damage Magicka",
+        "Damage Fatigue",
+        "Damage Skill",
+        "Poison",
+        "Weakness to Fire",
+        "Weakness to Frost",
+        "Weakness to Shock",
+        "Weakness to Magicka",
+        "Weakness to Common Disease",
+        "Weakness to Blight Disease",
+        "Weakness to Corprus Disease",
+        "Weakness to Poison",
+        "Weakness to Normal Weapons",
+        "Disintegrate Weapon",
+        "Disintegrate Armor",
+        "Invisibility",
+        "Chameleon",
+        "Light",
+        "Sanctuary",
+        "Night Eye",
+        "Charm",
+        "Paralyze",
+        "Silence",
+        "Blind",
+        "Sound",
+        "Calm Humanoid",
+        "Calm Creature",
+        "Frenzy Humanoid",
+        "Frenzy Creature",
+        "Demoralize Humanoid",
+        "Demoralize Creature",
+        "Rally Humanoid",
+        "Rally Creature",
+        "Dispel",
+        "Soultrap",
+        "Telekinesis",
+        "Mark",
+        "Recall",
+        "Divine Intervention",
+        "Almsivi Intervention",
+        "Detect Animal",
+        "Detect Enchantment",
+        "Detect Key",
+        "Spell Absorption",
+        "Reflect",
+        "Cure Common Disease",
+        "Cure Blight Disease",
+        "Cure Corprus Disease",
+        "Cure Poison",
+        "Cure Paralyzation",
+        "Restore Attribute",
+        "Restore Health",
+        "Restore Magicka",
+        "Restore Fatigue",
+        "Restore Skill",
+        "Fortify Attribute",
+        "Fortify Health",
+        "Fortify Magicka",
+        "Fortify Fatigue",
+        "Fortify Skill",
+        "Fortify Maximum Magicka",
+        "Absorb Attribute",
+        "Absorb Health",
+        "Absorb Magicka",
+        "Absorb Fatigue",
+        "Absorb Skill",
+        "Resist Fire",
+        "Resist Frost",
+        "Resist Shock",
+        "Resist Magicka",
+        "Resist Common Disease",
+        "Resist Blight Disease",
+        "Resist Corprus Disease",
+        "Resist Poison",
+        "Resist Normal Weapons",
+        "Resist Paralysis",
+        "Remove Curse",
+        "Turn Undead",
+        "Summon Scamp",
+        "Summon Clannfear",
+        "Summon Daedroth",
+        "Summon Dremora",
+        "Summon Ancestral Ghost",
+        "Summon Skeletal Minion",
+        "Summon Bonewalker",
+        "Summon Greater Bonewalker",
+        "Summon Bonelord",
+        "Summon Winged Twilight",
+        "Summon Hunger",
+        "Summon Golden Saint",
+        "Summon Flame Atronach",
+        "Summon Frost Atronach",
+        "Summon Storm Atronach",
+        "Fortify Attack",
+        "Command Creature",
+        "Command Humanoid",
+        "Bound Dagger",
+        "Bound Longsword",
+        "Bound Mace",
+        "Bound Battle Axe",
+        "Bound Spear",
+        "Bound Longbow",
+        "EXTRA SPELL",
+        "Bound Cuirass",
+        "Bound Helm",
+        "Bound Boots",
+        "Bound Shield",
+        "Bound Gloves",
+        "Corprus",
+        "Vampirism",
+        "Summon Centurion Sphere",
+        "Sun Damage",
+        "Stunted Magicka",
+        "Summon Fabricant",
+        "sEffectSummonCreature01",
+        "sEffectSummonCreature02",
+        "sEffectSummonCreature03",
+        "sEffectSummonCreature04",
+        "sEffectSummonCreature05"
+    };
+    if (idx >= 0 && idx <= 143)
+        return magicEffectLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string attributeLabel(int idx)
+{
+    const char* attributeLabels [] = {
+        "Strength",
+        "Intelligence",
+        "Willpower",
+        "Agility",
+        "Speed",
+        "Endurance",
+        "Personality",
+        "Luck"
+    };
+    if (idx >= 0 && idx <= 7)
+        return attributeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string spellTypeLabel(int idx)
+{
+    const char* spellTypeLabels [] = {
+        "Spells",
+        "Abilities",
+        "Blight Disease",
+        "Disease",
+        "Curse",
+        "Powers"
+    };
+    if (idx >= 0 && idx <= 5)
+        return spellTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string specializationLabel(int idx)
+{
+    const char* specializationLabels [] = {
+        "Combat",
+        "Magic",
+        "Stealth"
+    };
+    if (idx >= 0 && idx <= 2)
+        return specializationLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string skillLabel(int idx)
+{
+    const char* skillLabels [] = {
+        "Block",
+        "Armorer",
+        "Medium Armor",
+        "Heavy Armor",
+        "Blunt Weapon",
+        "Long Blade",
+        "Axe",
+        "Spear",
+        "Athletics",
+        "Enchant",
+        "Destruction",
+        "Alteration",
+        "Illusion",
+        "Conjuration",
+        "Mysticism",
+        "Restoration",
+        "Alchemy",
+        "Unarmored",
+        "Security",
+        "Sneak",
+        "Acrobatics",
+        "Light Armor",
+        "Short Blade",
+        "Marksman",
+        "Mercantile",
+        "Speechcraft",
+        "Hand-to-hand"
+    };
+    if (idx >= 0 && idx <= 27)
+        return skillLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string apparatusTypeLabel(int idx)
+{
+    const char* apparatusTypeLabels [] = {
+        "Mortar",
+        "Alembic",
+        "Calcinator",
+        "Retort",
+    };
+    if (idx >= 0 && idx <= 3)
+        return apparatusTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string rangeTypeLabel(int idx)
+{
+    const char* rangeTypeLabels [] = {
+        "Self",
+        "Touch",
+        "Target"
+    };
+    if (idx >= 0 && idx <= 3)
+        return rangeTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string schoolLabel(int idx)
+{
+    const char* schoolLabels [] = {
+        "Alteration",
+        "Conjuration",
+        "Destruction",
+        "Illusion",
+        "Mysticism",
+        "Restoration"
+    };
+    if (idx >= 0 && idx <= 5)
+        return schoolLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string enchantTypeLabel(int idx)
+{
+    const char* enchantTypeLabels [] = {
+        "Cast Once",
+        "Cast When Strikes",
+        "Cast When Used",
+        "Constant Effect"
+    };
+    if (idx >= 0 && idx <= 3)
+        return enchantTypeLabels[idx];
+    else
+        return "Invalid";
+}
+
+std::string ruleFunction(int idx)
+{
+    std::string ruleFunctions[] = {
+        "Reaction Low",
+        "Reaction High",
+        "Rank Requirement",
+        "NPC? Reputation",
+        "Health Percent",
+        "Player Reputation",
+        "NPC Level",
+        "Player Health Percent",
+        "Player Magicka",
+        "Player Fatigue",
+        "Player Attribute Strength",
+        "Player Skill Block",
+        "Player Skill Armorer",
+        "Player Skill Medium Armor",
+        "Player Skill Heavy Armor",
+        "Player Skill Blunt Weapon",
+        "Player Skill Long Blade",
+        "Player Skill Axe",
+        "Player Skill Spear",
+        "Player Skill Athletics",
+        "Player Skill Enchant",
+        "Player Skill Destruction",
+        "Player Skill Alteration",
+        "Player Skill Illusion",
+        "Player Skill Conjuration",
+        "Player Skill Mysticism",
+        "Player SKill Restoration",
+        "Player Skill Alchemy",
+        "Player Skill Unarmored",
+        "Player Skill Security",
+        "Player Skill Sneak",
+        "Player Skill Acrobatics",
+        "Player Skill Light Armor",
+        "Player Skill Short Blade",
+        "Player Skill Marksman",
+        "Player Skill Mercantile",
+        "Player Skill Speechcraft",
+        "Player Skill Hand to Hand",
+        "Player Gender",
+        "Player Expelled from Faction",
+        "Player Diseased (Common)",
+        "Player Diseased (Blight)",
+        "Player Clothing Modifier",
+        "Player Crime Level",
+        "Player Same Sex",
+        "Player Same Race",
+        "Player Same Faction",
+        "Faction Rank Difference",
+        "Player Detected",
+        "Alarmed",
+        "Choice Selected",
+        "Player Attribute Intelligence",
+        "Player Attribute Willpower",
+        "Player Attribute Agility",
+        "Player Attribute Speed",
+        "Player Attribute Endurance",
+        "Player Attribute Personality",
+        "Player Attribute Luck",
+        "Player Diseased (Corprus)",
+        "Weather",
+        "Player is a Vampire",
+        "Player Level",
+        "Attacked",
+        "NPC Talked to Player",
+        "Player Health",
+        "Creature Target",
+        "Friend Hit",
+        "Fight",
+        "Hello",
+        "Alarm",
+        "Flee",
+        "Should Attack",
+        //Unkown but causes NPCs to growl and roar.
+        "UNKNOWN 72"
+    };
+    if (idx >= 0 && idx <= 72)
+        return ruleFunctions[idx];
+    else
+        return "Invalid";
+}
+   
+// The "unused flag bits" should probably be defined alongside the
+// defined bits in the ESM component.  The names of the flag bits are
+// very inconsistent.
+
+std::string bodyPartFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";    
+    if (flags & ESM::BodyPart::BPF_Female) properties += "Female ";
+    if (flags & ESM::BodyPart::BPF_Playable) properties += "Playable ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::BodyPart::BPF_Female|
+                   ESM::BodyPart::BPF_Playable));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string cellFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";    
+    if (flags & ESM::Cell::HasWater) properties += "HasWater ";
+    if (flags & ESM::Cell::Interior) properties += "Interior ";
+    if (flags & ESM::Cell::NoSleep) properties += "NoSleep ";
+    if (flags & ESM::Cell::QuasiEx) properties += "QuasiEx ";
+    // This used value is not in the ESM component.
+    if (flags & 0x00000040) properties += "Unknown ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Cell::HasWater|
+                   ESM::Cell::Interior|
+                   ESM::Cell::NoSleep|
+                   ESM::Cell::QuasiEx|
+                   0x00000040));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string containerFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    if (flags & ESM::Container::Unknown) properties += "Unknown ";
+    if (flags & ESM::Container::Organic) properties += "Organic ";
+    if (flags & ESM::Container::Respawn) properties += "Respawn ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Container::Unknown|
+                   ESM::Container::Organic|
+                   ESM::Container::Respawn));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string creatureFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    if (flags & ESM::Creature::None) properties += "All ";
+    if (flags & ESM::Creature::Walks) properties += "Walks ";
+    if (flags & ESM::Creature::Swims) properties += "Swims ";
+    if (flags & ESM::Creature::Flies) properties += "Flies ";
+    if (flags & ESM::Creature::Biped) properties += "Biped ";   
+    if (flags & ESM::Creature::Respawn) properties += "Respawn ";
+    if (flags & ESM::Creature::Weapon) properties += "Weapon ";
+    if (flags & ESM::Creature::Skeleton) properties += "Skeleton ";
+    if (flags & ESM::Creature::Metal) properties += "Metal ";
+    if (flags & ESM::Creature::Essential) properties += "Essential ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Creature::None|
+                   ESM::Creature::Walks|
+                   ESM::Creature::Swims|
+                   ESM::Creature::Flies|
+                   ESM::Creature::Biped|
+                   ESM::Creature::Respawn|
+                   ESM::Creature::Weapon|
+                   ESM::Creature::Skeleton|
+                   ESM::Creature::Metal|
+                   ESM::Creature::Essential));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string landFlags(int flags)
+{
+    std::string properties = "";
+    // The ESM component says that this first four bits are used, but
+    // only the first three bits are used as far as I can tell.
+    // There's also no enumeration of the bit in the ESM component.
+    if (flags == 0) properties += "[None] ";
+    if (flags & 0x00000001) properties += "Unknown1 ";
+    if (flags & 0x00000004) properties += "Unknown3 ";
+    if (flags & 0x00000002) properties += "Unknown2 ";
+    if (flags & 0xFFFFFFF8) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string leveledListFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    if (flags & ESM::LeveledListBase::AllLevels) properties += "AllLevels ";
+    // This flag apparently not present on creature lists...
+    if (flags & ESM::LeveledListBase::Each) properties += "Each ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::LeveledListBase::AllLevels|
+                   ESM::LeveledListBase::Each));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string lightFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    if (flags & ESM::Light::Dynamic) properties += "Dynamic ";
+    if (flags & ESM::Light::Fire) properties += "Fire ";
+    if (flags & ESM::Light::Carry) properties += "Carry ";
+    if (flags & ESM::Light::Flicker) properties += "Flicker ";
+    if (flags & ESM::Light::FlickerSlow) properties += "FlickerSlow ";
+    if (flags & ESM::Light::Pulse) properties += "Pulse ";
+    if (flags & ESM::Light::PulseSlow) properties += "PulseSlow ";
+    if (flags & ESM::Light::Negative) properties += "Negative ";
+    if (flags & ESM::Light::OffDefault) properties += "OffDefault ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Light::Dynamic|
+                   ESM::Light::Fire|
+                   ESM::Light::Carry|
+                   ESM::Light::Flicker|
+                   ESM::Light::FlickerSlow|
+                   ESM::Light::Pulse|
+                   ESM::Light::PulseSlow|
+                   ESM::Light::Negative|
+                   ESM::Light::OffDefault));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string magicEffectFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    // Enchanting & SpellMaking occur on the same list of effects.
+    // "EXTRA SPELL" appears in the construction set under both the
+    // spell making and enchanting tabs as an allowed effect.  Since
+    // most of the effects without this flags are defective in various
+    // ways, it's still very unclear what these flag bits are.
+    if (flags & ESM::MagicEffect::SpellMaking) properties += "SpellMaking ";
+    if (flags & ESM::MagicEffect::Enchanting) properties += "Enchanting ";
+    if (flags & 0x00000040) properties += "RangeNoSelf ";
+    if (flags & 0x00000080) properties += "RangeTouch ";
+    if (flags & 0x00000100) properties += "RangeTarget ";
+    if (flags & 0x00001000) properties += "Unknown2 ";
+    if (flags & 0x00000001) properties += "AffectSkill ";
+    if (flags & 0x00000002) properties += "AffectAttribute ";
+    if (flags & ESM::MagicEffect::NoDuration) properties += "NoDuration ";
+    if (flags & 0x00000008) properties += "NoMagnitude ";
+    if (flags & 0x00000010) properties += "Negative ";
+    if (flags & 0x00000020) properties += "Unknown1 ";
+    // ESM componet says 0x800 is negative, but none of the magic
+    // effects have this flags set.
+    if (flags & ESM::MagicEffect::Negative) properties += "Unused ";
+    // Since only Chameleon has this flag it could be anything
+    // that uniquely distinguishes Chameleon.
+    if (flags & 0x00002000) properties += "Chameleon ";
+    if (flags & 0x00004000) properties += "Bound ";
+    if (flags & 0x00008000) properties += "Summon ";
+    // Calm, Demoralize, Frenzy, Lock, Open, Rally, Soultrap, Turn Unded
+    if (flags & 0x00010000) properties += "Unknown3 ";
+    if (flags & 0x00020000) properties += "Absorb ";
+    if (flags & 0xFFFC0000) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string npcFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    // Mythicmods and the ESM component differ.  Mythicmods says
+    // 0x8=None and 0x10=AutoCalc, while our code defines 0x8 as
+    // AutoCalc.  The former seems to be correct.  All Bethesda
+    // records have bit 0x8 set.  A suspiciously large portion of
+    // females have autocalc turned off.
+    if (flags & ESM::NPC::Autocalc) properties += "Unknown ";
+    if (flags & 0x00000010) properties += "Autocalc ";
+    if (flags & ESM::NPC::Female) properties += "Female ";
+    if (flags & ESM::NPC::Respawn) properties += "Respawn ";
+    if (flags & ESM::NPC::Essential) properties += "Essential ";
+    // These two flags do not appear on any NPCs and may have been
+    // confused with the flags for creatures.
+    if (flags & ESM::NPC::Skeleton) properties += "Skeleton ";
+    if (flags & ESM::NPC::Metal) properties += "Metal ";
+    // Whether corpses persist is a bit that is unaccounted for,
+    // however the only unknown bit occurs on ALL records, and
+    // relatively few NPCs have this bit set.
+    int unused = (0xFFFFFFFF ^
+                  (ESM::NPC::Autocalc|
+                   0x00000010|
+                   ESM::NPC::Female|
+                   ESM::NPC::Respawn|
+                   ESM::NPC::Essential|
+                   ESM::NPC::Skeleton|
+                   ESM::NPC::Metal));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string raceFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    // All races have the playable flag set in Bethesda files.
+    if (flags & ESM::Race::Playable) properties += "Playable ";
+    if (flags & ESM::Race::Beast) properties += "Beast ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Race::Playable|
+                   ESM::Race::Beast));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string spellFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    if (flags & ESM::Spell::F_Autocalc) properties += "Autocalc ";
+    if (flags & ESM::Spell::F_PCStart) properties += "PCStart ";
+    if (flags & ESM::Spell::F_Always) properties += "Always ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Spell::F_Autocalc|
+                   ESM::Spell::F_PCStart|
+                   ESM::Spell::F_Always));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}
+
+std::string weaponFlags(int flags)
+{
+    std::string properties = "";
+    if (flags == 0) properties += "[None] ";
+    // The interpretation of the flags are still unclear to me.
+    // Apparently you can't be Silver without being Magical?  Many of
+    // the "Magical" weapons don't have enchantments of any sort.
+    if (flags & ESM::Weapon::Magical) properties += "Magical ";
+    if (flags & ESM::Weapon::Silver) properties += "Silver ";
+    int unused = (0xFFFFFFFF ^
+                  (ESM::Weapon::Magical|
+                   ESM::Weapon::Silver));
+    if (flags & unused) properties += "Invalid ";
+    properties += str(boost::format("(0x%08X)") % flags);
+    return properties;
+}

apps/esmtool/labels.hpp

@@ -0,0 +1,64 @@
+#ifndef OPENMW_ESMTOOL_LABELS_H
+#define OPENMW_ESMTOOL_LABELS_H
+
+#include <string>
+
+std::string bodyPartLabel(char idx);
+std::string meshPartLabel(char idx);
+std::string meshTypeLabel(char idx);
+std::string clothingTypeLabel(int idx);
+std::string armorTypeLabel(int idx);
+std::string dialogTypeLabel(int idx);
+std::string questStatusLabel(int idx);
+std::string creatureTypeLabel(int idx);
+std::string soundTypeLabel(int idx);
+std::string weaponTypeLabel(int idx);
+
+// This function's a bit different because the types are record types,
+// not consecutive values.
+std::string aiTypeLabel(int type);
+
+// This one's also a bit different, because it enumerates dialog
+// select rule functions, not types.  Structurally, it still converts
+// indexes to strings for display.
+std::string ruleFunction(int idx);
+
+// The labels below here can all be loaded from GMSTs, but are not
+// currently because among other things, that requires loading the
+// GMSTs before dumping any of the records.
+
+// If the data format supported ordered lists of GMSTs (post 1.0), the
+// lists could define the valid values, their localization strings,
+// and the indexes for referencing the types in other records in the
+// database.  Then a single label function could work for all types.
+
+std::string magicEffectLabel(int idx);
+std::string attributeLabel(int idx);
+std::string spellTypeLabel(int idx);
+std::string specializationLabel(int idx);
+std::string skillLabel(int idx);
+std::string apparatusTypeLabel(int idx);
+std::string rangeTypeLabel(int idx);
+std::string schoolLabel(int idx);
+std::string enchantTypeLabel(int idx);
+
+// The are the flag functions that convert a bitmask into a list of
+// human readble strings representing the set bits.
+
+std::string bodyPartFlags(int flags);
+std::string cellFlags(int flags);
+std::string containerFlags(int flags);
+std::string creatureFlags(int flags);
+std::string landFlags(int flags);
+std::string leveledListFlags(int flags);
+std::string lightFlags(int flags);
+std::string magicEffectFlags(int flags);
+std::string npcFlags(int flags);
+std::string raceFlags(int flags);
+std::string spellFlags(int flags);
+std::string weaponFlags(int flags);
+
+// Missing flags functions:
+// aiServicesFlags, possibly more
+
+#endif

apps/esmtool/record.cpp

@@ -1,54 +1,126 @@
 #include "record.hpp"
+#include "labels.hpp"
 
 #include <iostream>
 #include <boost/format.hpp>
 
 void printAIPackage(ESM::AIPackage p)
 {
-  if (p.mType == ESM::AI_Wander)
-  {
-      std::cout << "  AIType Wander:" << std::endl;
-      std::cout << "    Distance: " << p.mWander.mDistance << std::endl;
-      std::cout << "    Duration: " << p.mWander.mDuration << std::endl;
-      std::cout << "    Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl;
-      if (p.mWander.mUnk != 1)
-          std::cout <<  "    Unknown: " << (int)p.mWander.mUnk << std::endl;
-
-      std::cout << "    Idle: ";
-      for (int i = 0; i != 8; i++)
-          std::cout << (int)p.mWander.mIdle[i] << " ";
-      std::cout << std::endl;
-  }
-  else if (p.mType == ESM::AI_Travel)
-  {
-      std::cout << "  AIType Travel:" << std::endl;
-      std::cout << "    Travel Coordinates: (" << p.mTravel.mX << ","
-           << p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl;
-      std::cout << "    Travel Unknown: " << (int)p.mTravel.mUnk << std::endl;
-  }
-  else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort)
-  {
-      if (p.mType == ESM::AI_Follow) std::cout << "  AIType Follow:" << std::endl;
-      else std::cout << "  AIType Escort:" << std::endl;
-
-      std::cout << "    Follow Coordinates: (" << p.mTarget.mX << ","
-           << p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl;
-      std::cout << "    Duration: " << p.mTarget.mDuration << std::endl;
-      std::cout << "    Target ID: " << p.mTarget.mId.toString() << std::endl;
-      std::cout << "    Unknown: " << (int)p.mTarget.mUnk << std::endl;
-  }
-  else if (p.mType == ESM::AI_Activate)
-  {
-      std::cout << "  AIType Activate:" << std::endl;
-      std::cout << "    Name: " << p.mActivate.mName.toString() << std::endl;
-      std::cout << "    Activate Unknown: " << (int)p.mActivate.mUnk << std::endl;
-  }
-  else {
-      std::cout << "    BadPackage: " << boost::format("0x%08x") % p.mType << std::endl;
-  }
-
-  if (p.mCellName != "")
-      std::cout << "    Cell Name: " << p.mCellName << std::endl;
+    std::cout << "  AI Type: " << aiTypeLabel(p.mType)
+              << " (" << boost::format("0x%08X") % p.mType << ")" << std::endl;
+    if (p.mType == ESM::AI_Wander)
+    {
+        std::cout << "    Distance: " << p.mWander.mDistance << std::endl;
+        std::cout << "    Duration: " << p.mWander.mDuration << std::endl;
+        std::cout << "    Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl;
+        if (p.mWander.mUnk != 1)
+            std::cout <<  "    Unknown: " << (int)p.mWander.mUnk << std::endl;
+        
+        std::cout << "    Idle: ";
+        for (int i = 0; i != 8; i++)
+            std::cout << (int)p.mWander.mIdle[i] << " ";
+        std::cout << std::endl;
+    }
+    else if (p.mType == ESM::AI_Travel)
+    {
+        std::cout << "    Travel Coordinates: (" << p.mTravel.mX << ","
+                  << p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl;
+        std::cout << "    Travel Unknown: " << (int)p.mTravel.mUnk << std::endl;
+    }
+    else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort)
+    {       
+        std::cout << "    Follow Coordinates: (" << p.mTarget.mX << ","
+                  << p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl;
+        std::cout << "    Duration: " << p.mTarget.mDuration << std::endl;
+        std::cout << "    Target ID: " << p.mTarget.mId.toString() << std::endl;
+        std::cout << "    Unknown: " << (int)p.mTarget.mUnk << std::endl;
+    }
+    else if (p.mType == ESM::AI_Activate)
+    {
+        std::cout << "    Name: " << p.mActivate.mName.toString() << std::endl;
+        std::cout << "    Activate Unknown: " << (int)p.mActivate.mUnk << std::endl;
+    }
+    else {
+        std::cout << "    BadPackage: " << boost::format("0x%08x") % p.mType << std::endl;
+    }
+    
+    if (p.mCellName != "")
+        std::cout << "    Cell Name: " << p.mCellName << std::endl;
+}
+
+std::string ruleString(ESM::DialInfo::SelectStruct ss)
+{
+    std::string rule = ss.mSelectRule;
+    
+    if (rule.length() < 5)
+        return "INVALID";
+    
+    char type = rule[1];
+    char indicator = rule[2];
+    
+    std::string type_str = "INVALID";
+    std::string func_str = str(boost::format("INVALID=%s") % rule.substr(1,3));
+    int func;
+    std::istringstream iss(rule.substr(2,2));
+    iss >> func;
+
+    switch(type)
+    {
+    case '1':
+        type_str = "Function";
+        func_str = ruleFunction(func);
+        break;
+    case '2':
+        if (indicator == 's') type_str = "Global short"; 
+        else if (indicator == 'l') type_str = "Global long"; 
+        else if (indicator == 'f') type_str = "Global float"; 
+        break;
+    case '3':
+        if (indicator == 's') type_str = "Local short"; 
+        else if (indicator == 'l') type_str = "Local long"; 
+        else if (indicator == 'f') type_str = "Local float"; 
+        break;
+    case '4': if (indicator == 'J') type_str = "Journal"; break;
+    case '5': if (indicator == 'I') type_str = "Item type"; break;
+    case '6': if (indicator == 'D') type_str = "NPC Dead"; break;
+    case '7': if (indicator == 'X') type_str = "Not ID"; break;
+    case '8': if (indicator == 'F') type_str = "Not Faction"; break;
+    case '9': if (indicator == 'C') type_str = "Not Class"; break;
+    case 'A': if (indicator == 'R') type_str = "Not Race"; break;
+    case 'B': if (indicator == 'L') type_str = "Not Cell"; break;
+    case 'C': if (indicator == 's') type_str = "Not Local"; break;
+    }
+    
+    // Append the variable name to the function string if any.
+    if (type != '1') func_str = rule.substr(5);
+    
+    // In the previous switch, we assumed that the second char was X
+    // for all types not qual to one.  If this wasn't true, go back to
+    // the error message.
+    if (type != '1' && rule[3] != 'X')
+        func_str = str(boost::format("INVALID=%s") % rule.substr(1,3));    
+
+    char oper = rule[4];
+    std::string oper_str = "??";
+    switch (oper)
+    {
+    case '0': oper_str = "=="; break;
+    case '1': oper_str = "!="; break;
+    case '2': oper_str = "< "; break;
+    case '3': oper_str = "<="; break;
+    case '4': oper_str = "> "; break;
+    case '5': oper_str = ">="; break;
+    }
+
+    std::string value_str = "??";
+    if (ss.mType == ESM::VT_Int)
+        value_str = str(boost::format("%d") % ss.mI);
+    else if (ss.mType == ESM::VT_Float)
+        value_str = str(boost::format("%f") % ss.mF);
+    
+    std::string result = str(boost::format("%-12s %-32s %2s %s") 
+                             % type_str % func_str % oper_str % value_str);
+    return result;
 }
 
 void printEffectList(ESM::EffectList effects)
@@ -57,12 +129,16 @@ void printEffectList(ESM::EffectList effects)
     std::vector<ESM::ENAMstruct>::iterator eit;
     for (eit = effects.mList.begin(); eit != effects.mList.end(); eit++)
     {
-        std::cout << "  Effect[" << i << "]: " << eit->mEffectID << std::endl;
+        std::cout << "  Effect[" << i << "]: " << magicEffectLabel(eit->mEffectID)
+                  << " (" << eit->mEffectID << ")" << std::endl;
         if (eit->mSkill != -1)
-            std::cout << "    Skill: " << (int)eit->mSkill << std::endl;
+            std::cout << "    Skill: " << skillLabel(eit->mSkill)
+                      << " (" << (int)eit->mSkill << ")" << std::endl;
         if (eit->mAttribute != -1)
-            std::cout << "    Attribute: " << (int)eit->mAttribute << std::endl; 
-        std::cout << "    Range: " << eit->mRange << std::endl;
+            std::cout << "    Attribute: " << attributeLabel(eit->mAttribute)
+                      << " (" << (int)eit->mAttribute << ")" << std::endl; 
+        std::cout << "    Range: " << rangeTypeLabel(eit->mRange)
+                  << " (" << eit->mRange << ")" << std::endl;
         // Area is always zero if range type is "Self"
         if (eit->mRange != ESM::RT_Self)
             std::cout << "    Area: " << eit->mArea << std::endl;
@@ -331,7 +407,8 @@ void Record<ESM::Armor>::print()
         std::cout << "  Script: " << mData.mScript << std::endl;
     if (mData.mEnchant != "")
         std::cout << "  Enchantment: " << mData.mEnchant << std::endl;
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
+    std::cout << "  Type: " << armorTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
     std::cout << "  Health: " << mData.mData.mHealth << std::endl;
@@ -340,7 +417,8 @@ void Record<ESM::Armor>::print()
     std::vector<ESM::PartReference>::iterator pit;
     for (pit = mData.mParts.mParts.begin(); pit != mData.mParts.mParts.end(); pit++)
     {
-        std::cout << "  Body Part: " << (int)(pit->mPart) << std::endl;
+        std::cout << "  Body Part: " << bodyPartLabel(pit->mPart)
+                  << " (" << (int)(pit->mPart) << ")" << std::endl;
         std::cout << "    Male Name: " << pit->mMale << std::endl;
         if (pit->mFemale != "")
             std::cout << "    Female Name: " << pit->mFemale << std::endl;
@@ -354,7 +432,8 @@ void Record<ESM::Apparatus>::print()
     std::cout << "  Model: " << mData.mModel << std::endl;
     std::cout << "  Icon: " << mData.mIcon << std::endl;
     std::cout << "  Script: " << mData.mScript << std::endl;
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
+    std::cout << "  Type: " << apparatusTypeLabel(mData.mData.mType)
+              << " (" << (int)mData.mData.mType << ")" << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
     std::cout << "  Quality: " << mData.mData.mQuality << std::endl;
@@ -365,9 +444,11 @@ void Record<ESM::BodyPart>::print()
 {
     std::cout << "  Name: " << mData.mName << std::endl;
     std::cout << "  Model: " << mData.mModel << std::endl;
-    std::cout << "  Type: " << (int)mData.mData.mType << std::endl;
-    std::cout << "  Flags: " << (int)mData.mData.mFlags << std::endl;
-    std::cout << "  Part: " << (int)mData.mData.mPart << std::endl;
+    std::cout << "  Type: " << meshTypeLabel(mData.mData.mType)
+              << " (" << (int)mData.mData.mType << ")" << std::endl;
+    std::cout << "  Flags: " << bodyPartFlags(mData.mData.mFlags) << std::endl;
+    std::cout << "  Part: " << meshPartLabel(mData.mData.mPart)
+              << " (" << (int)mData.mData.mPart << ")" << std::endl;
     std::cout << "  Vampire: " << (int)mData.mData.mVampire << std::endl;
 }
 
@@ -413,7 +494,7 @@ void Record<ESM::Cell>::print()
         std::cout << "  Name: " << mData.mName << std::endl;
     if (mData.mRegion != "")
         std::cout << "  Region: " << mData.mRegion << std::endl;
-    std::cout << "  Flags: " << (int)mData.mData.mFlags << std::endl;
+    std::cout << "  Flags: " << cellFlags(mData.mData.mFlags) << std::endl;
     
     std::cout << "  Coordinates: " << " (" << mData.getGridX() << ","
               << mData.getGridY() << ")" << std::endl;
@@ -441,13 +522,18 @@ void Record<ESM::Class>::print()
     std::cout << "  Description: " << mData.mDescription << std::endl;
     std::cout << "  Playable: " << mData.mData.mIsPlayable << std::endl;
     std::cout << "  AutoCalc: " << mData.mData.mCalc << std::endl;
-    std::cout << "  Attribute1: " << mData.mData.mAttribute[0] << std::endl;
-    std::cout << "  Attribute2: " << mData.mData.mAttribute[1] << std::endl;
-    std::cout << "  Specialization: " << mData.mData.mSpecialization << std::endl;
+    std::cout << "  Attribute1: " << attributeLabel(mData.mData.mAttribute[0])
+              << " (" << mData.mData.mAttribute[0] << ")" << std::endl;
+    std::cout << "  Attribute2: " << attributeLabel(mData.mData.mAttribute[1])
+              << " (" << mData.mData.mAttribute[1] << ")" << std::endl;
+    std::cout << "  Specialization: " << specializationLabel(mData.mData.mSpecialization)
+              << " (" << mData.mData.mSpecialization << ")" << std::endl;
     for (int i = 0; i != 5; i++)
-        std::cout << "  Major Skill: " << mData.mData.mSkills[i][0] << std::endl;
+        std::cout << "  Major Skill: " << skillLabel(mData.mData.mSkills[i][0])
+                  << " (" << mData.mData.mSkills[i][0] << ")" << std::endl; 
     for (int i = 0; i != 5; i++)
-        std::cout << "  Minor Skill: " << mData.mData.mSkills[i][1] << std::endl;
+        std::cout << "  Minor Skill: " << skillLabel(mData.mData.mSkills[i][1])
+                  << " (" << mData.mData.mSkills[i][1] << ")" << std::endl;
 }
 
 template<>
@@ -460,10 +546,20 @@ void Record<ESM::Clothing>::print()
         std::cout << "  Script: " << mData.mScript << std::endl;
     if (mData.mEnchant != "")
         std::cout << "  Enchantment: " << mData.mEnchant << std::endl;
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
+    std::cout << "  Type: " << clothingTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
-    // mEnchant also in CTDTstruct?
+    std::cout << "  Enchantment Points: " << mData.mData.mEnchant << std::endl;
+    std::vector<ESM::PartReference>::iterator pit;
+    for (pit = mData.mParts.mParts.begin(); pit != mData.mParts.mParts.end(); pit++)
+    {
+        std::cout << "  Body Part: " << bodyPartLabel(pit->mPart)
+                  << " (" << (int)(pit->mPart) << ")" << std::endl;
+        std::cout << "    Male Name: " << pit->mMale << std::endl;
+        if (pit->mFemale != "")
+            std::cout << "    Female Name: " << pit->mFemale << std::endl;
+    }
 }
 
 template<>
@@ -473,7 +569,7 @@ void Record<ESM::Container>::print()
     std::cout << "  Model: " << mData.mModel << std::endl;
     if (mData.mScript != "")
         std::cout << "  Script: " << mData.mScript << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << containerFlags(mData.mFlags) << std::endl;
     std::cout << "  Weight: " << mData.mWeight << std::endl;
     std::vector<ESM::ContItem>::iterator cit;
     for (cit = mData.mInventory.mList.begin(); cit != mData.mInventory.mList.end(); cit++)
@@ -487,11 +583,12 @@ void Record<ESM::Creature>::print()
     std::cout << "  Name: " << mData.mName << std::endl;
     std::cout << "  Model: " << mData.mModel << std::endl;
     std::cout << "  Script: " << mData.mScript << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << creatureFlags(mData.mFlags) << std::endl;
     std::cout << "  Original: " << mData.mOriginal << std::endl;
     std::cout << "  Scale: " << mData.mScale << std::endl;
 
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
+    std::cout << "  Type: " << creatureTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
     std::cout << "  Level: " << mData.mData.mLevel << std::endl;
 
     std::cout << "  Attributes:" << std::endl;
@@ -547,7 +644,8 @@ void Record<ESM::Creature>::print()
 template<>
 void Record<ESM::Dialogue>::print()
 {
-    std::cout << "  Type: " << (int)mData.mType << std::endl;
+    std::cout << "  Type: " << dialogTypeLabel(mData.mType)
+              << " (" << (int)mData.mType << ")" << std::endl;
     // Sadly, there are no DialInfos, because the loader dumps as it
     // loads, rather than loading and then dumping. :-( Anyone mind if
     // I change this?
@@ -569,7 +667,8 @@ void Record<ESM::Door>::print()
 template<>
 void Record<ESM::Enchantment>::print()
 {
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
+    std::cout << "  Type: " << enchantTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
     std::cout << "  Cost: " << mData.mData.mCost << std::endl;
     std::cout << "  Charge: " << mData.mData.mCharge << std::endl;
     std::cout << "  AutoCalc: " << mData.mData.mAutocalc << std::endl;
@@ -583,11 +682,14 @@ void Record<ESM::Faction>::print()
     std::cout << "  Hidden: " << mData.mData.mIsHidden << std::endl;
     if (mData.mData.mUnknown != -1)
         std::cout << "  Unknown: " << mData.mData.mUnknown << std::endl;
-    std::cout << "  Attribute1: " << mData.mData.mAttribute1 << std::endl;
-    std::cout << "  Attribute2: " << mData.mData.mAttribute2 << std::endl;
+    std::cout << "  Attribute1: " << attributeLabel(mData.mData.mAttribute1)
+              << " (" << mData.mData.mAttribute1 << ")" << std::endl;
+    std::cout << "  Attribute2: " << attributeLabel(mData.mData.mAttribute2)
+              << " (" << mData.mData.mAttribute2 << ")" << std::endl;
     for (int i = 0; i != 6; i++)
         if (mData.mData.mSkillID[i] != -1)
-            std::cout << "  Skill: " << mData.mData.mSkillID[i] << std::endl;
+            std::cout << "  Skill: " << skillLabel(mData.mData.mSkillID[i])
+                      << " (" << mData.mData.mSkillID[i] << ")" << std::endl;
     for (int i = 0; i != 10; i++)
         if (mData.mRanks[i] != "")
         {
@@ -683,13 +785,14 @@ void Record<ESM::DialInfo>::print()
         // std::cout << "-------------------------------------------" << std::endl;
     }
 
-    std::cout << "  Quest Status: " << mData.mQuestStatus << std::endl;
+    std::cout << "  Quest Status: " << questStatusLabel(mData.mQuestStatus)
+              << " (" << mData.mQuestStatus << ")" << std::endl;
     std::cout << "  Unknown1: " << mData.mData.mUnknown1 << std::endl;
     std::cout << "  Unknown2: " << (int)mData.mData.mUnknown2 << std::endl;
 
     std::vector<ESM::DialInfo::SelectStruct>::iterator sit;
     for (sit = mData.mSelects.begin(); sit != mData.mSelects.end(); sit++)
-        std::cout << "  Select Rule: " << sit->mType << " " << sit->mSelectRule << std::endl;
+        std::cout << "  Select Rule: " << ruleString(*sit) << std::endl;
 }
 
 template<>
@@ -706,9 +809,12 @@ void Record<ESM::Ingredient>::print()
     {
         // A value of -1 means no effect
         if (mData.mData.mEffectID[i] == -1) continue;
-        std::cout << "  Effect: " << mData.mData.mEffectID[i] << std::endl;
-        std::cout << "  Skill: " << mData.mData.mSkills[i] << std::endl;
-        std::cout << "  Attribute: " << mData.mData.mAttributes[i] << std::endl;
+        std::cout << "  Effect: " << magicEffectLabel(mData.mData.mEffectID[i])
+                  << " (" << mData.mData.mEffectID[i] << ")" << std::endl;
+        std::cout << "  Skill: " << skillLabel(mData.mData.mSkills[i])
+                  << " (" << mData.mData.mSkills[i] << ")" << std::endl;
+        std::cout << "  Attribute: " << attributeLabel(mData.mData.mAttributes[i])
+                  << " (" << mData.mData.mAttributes[i] << ")" << std::endl;
     }
 }
 
@@ -716,7 +822,7 @@ template<>
 void Record<ESM::Land>::print()
 {
     std::cout << "  Coordinates: (" << mData.mX << "," << mData.mY << ")" << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << landFlags(mData.mFlags) << std::endl;
     std::cout << "  HasData: " << mData.mHasData << std::endl;
     std::cout << "  DataTypes: " << mData.mDataTypes << std::endl;
 
@@ -739,7 +845,7 @@ template<>
 void Record<ESM::CreatureLevList>::print()
 {
     std::cout << "  Chance for None: " << (int)mData.mChanceNone << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << leveledListFlags(mData.mFlags) << std::endl;
     std::cout << "  Number of items: " << mData.mList.size() << std::endl;
     std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
     for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++)
@@ -751,7 +857,7 @@ template<>
 void Record<ESM::ItemLevList>::print()
 {
     std::cout << "  Chance for None: " << (int)mData.mChanceNone << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << leveledListFlags(mData.mFlags) << std::endl;
     std::cout << "  Number of items: " << mData.mList.size() << std::endl;
     std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
     for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++)
@@ -770,7 +876,7 @@ void Record<ESM::Light>::print()
         std::cout << "  Icon: " << mData.mIcon << std::endl;
     if (mData.mScript != "")
         std::cout << "  Script: " << mData.mScript << std::endl;
-    std::cout << "  Flags: " << mData.mData.mFlags << std::endl;
+    std::cout << "  Flags: " << lightFlags(mData.mData.mFlags) << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
     std::cout << "  Sound: " << mData.mSound << std::endl;
@@ -802,6 +908,7 @@ void Record<ESM::Probe>::print()
     std::cout << "  Icon: " << mData.mIcon << std::endl;
     if (mData.mScript != "")
         std::cout << "  Script: " << mData.mScript << std::endl;
+    // BUG? No Type Label?
     std::cout << "  Type: " << mData.mType << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
@@ -835,10 +942,11 @@ void Record<ESM::LandTexture>::print()
 template<>
 void Record<ESM::MagicEffect>::print()
 {
-    std::cout << "  Index: " << mData.mIndex << std::endl;
+    std::cout << "  Index: " << magicEffectLabel(mData.mIndex)
+              << " (" << mData.mIndex << ")" << std::endl;
     std::cout << "  Description: " << mData.mDescription << std::endl;
     std::cout << "  Icon: " << mData.mIcon << std::endl;
-    std::cout << "  Flags: " << mData.mData.mFlags << std::endl;
+    std::cout << "  Flags: " << magicEffectFlags(mData.mData.mFlags) << std::endl;
     std::cout << "  Particle Texture: " << mData.mParticle << std::endl;
     if (mData.mCasting != "")
         std::cout << "  Casting Static: " << mData.mCasting << std::endl;
@@ -856,7 +964,8 @@ void Record<ESM::MagicEffect>::print()
         std::cout << "  Area Static: " << mData.mArea << std::endl;
     if (mData.mAreaSound != "")
         std::cout << "  Area Sound: " << mData.mAreaSound << std::endl;
-    std::cout << "  School: " << mData.mData.mSchool << std::endl;
+    std::cout << "  School: " << schoolLabel(mData.mData.mSchool)
+              << " (" << mData.mData.mSchool << ")" << std::endl;
     std::cout << "  Base Cost: " << mData.mData.mBaseCost << std::endl;
     std::cout << "  Speed: " << mData.mData.mSpeed << std::endl;
     std::cout << "  Size: " << mData.mData.mSize << std::endl;
@@ -893,7 +1002,7 @@ void Record<ESM::NPC>::print()
         std::cout << "  Script: " << mData.mScript << std::endl;
     if (mData.mFaction != "")
         std::cout << "  Faction: " << mData.mFaction << std::endl;
-    std::cout << "  Flags: " << mData.mFlags << std::endl;
+    std::cout << "  Flags: " << npcFlags(mData.mFlags) << std::endl;
 
     // Seriously?
     if (mData.mNpdt52.mGold == -10)
@@ -929,7 +1038,7 @@ void Record<ESM::NPC>::print()
 
         std::cout << "  Skills:" << std::endl;
         for (int i = 0; i != 27; i++)
-            std::cout << "    " << i << " = " 
+            std::cout << "    " << skillLabel(i) << ": " 
                       << (int)((unsigned char)mData.mNpdt52.mSkills[i]) << std::endl;   
         
         std::cout << "  Health: " << mData.mNpdt52.mHealth << std::endl;
@@ -1018,7 +1127,7 @@ void Record<ESM::Race>::print()
 {
     std::cout << "  Name: " << mData.mName << std::endl;
     std::cout << "  Description: " << mData.mDescription << std::endl;
-    std::cout << "  Flags: " << mData.mData.mFlags << std::endl;
+    std::cout << "  Flags: " << raceFlags(mData.mData.mFlags) << std::endl;
 
     std::cout << "  Male:" << std::endl;
     std::cout << "    Strength: "
@@ -1067,8 +1176,10 @@ void Record<ESM::Race>::print()
     for (int i = 0; i != 7; i++)
         // Not all races have 7 skills.
         if (mData.mData.mBonus[i].mSkill != -1)
-            std::cout << "  Skill: " << mData.mData.mBonus[i].mSkill
-                      << " = " << mData.mData.mBonus[i].mBonus << std::endl;
+            std::cout << "  Skill: "
+                      << skillLabel(mData.mData.mBonus[i].mSkill)
+                      << " (" << mData.mData.mBonus[i].mSkill << ") = "
+                      << mData.mData.mBonus[i].mBonus << std::endl;
 
     std::vector<std::string>::iterator sit;
     for (sit = mData.mPowers.mList.begin(); sit != mData.mPowers.mList.end(); sit++)
@@ -1130,18 +1241,15 @@ void Record<ESM::Script>::print()
 template<>
 void Record<ESM::Skill>::print()
 {
-    std::cout << "  ID: " << mData.mIndex << std::endl;
-
-    const char *spec = 0;
-    int specId = mData.mData.mSpecialization;
-    if (specId == 0) {
-        spec = "Combat";
-    } else if (specId == 1) {
-        spec = "Magic";
-    } else {
-        spec = "Stealth";
-    }
-    std::cout << "  Type: " << spec << std::endl;
+    std::cout << "  ID: " << skillLabel(mData.mIndex)
+              << " (" << mData.mIndex << ")" << std::endl;
+    std::cout << "  Description: " << mData.mDescription << std::endl;
+    std::cout << "  Governing Attribute: " << attributeLabel(mData.mData.mAttribute)
+              << " (" << mData.mData.mAttribute << ")" << std::endl;
+    std::cout << "  Specialization: " << specializationLabel(mData.mData.mSpecialization)
+              << " (" << mData.mData.mSpecialization << ")" << std::endl;
+    for (int i = 0; i != 4; i++)
+        std::cout << "  UseValue[" << i << "]:" << mData.mData.mUseValue[i] << std::endl;
 }
 
 template<>
@@ -1149,7 +1257,8 @@ void Record<ESM::SoundGenerator>::print()
 {
     std::cout << "  Creature: " << mData.mCreature << std::endl;
     std::cout << "  Sound: " << mData.mSound << std::endl;
-    std::cout << "  Type: " << mData.mType << std::endl;
+    std::cout << "  Type: " << soundTypeLabel(mData.mType)
+              << " (" << mData.mType << ")" << std::endl;
 }
 
 template<>
@@ -1166,8 +1275,9 @@ template<>
 void Record<ESM::Spell>::print()
 {
     std::cout << "  Name: " << mData.mName << std::endl;
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
-    std::cout << "  Flags: " << mData.mData.mFlags << std::endl;
+    std::cout << "  Type: " << spellTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
+    std::cout << "  Flags: " << spellFlags(mData.mData.mFlags) << std::endl;
     std::cout << "  Cost: " << mData.mData.mCost << std::endl;
     printEffectList(mData.mEffects);
 }
@@ -1199,8 +1309,9 @@ void Record<ESM::Weapon>::print()
         std::cout << "  Script: " << mData.mScript << std::endl;
     if (mData.mEnchant != "")
         std::cout << "  Enchantment: " << mData.mEnchant << std::endl;    
-    std::cout << "  Type: " << mData.mData.mType << std::endl;
-    std::cout << "  Flags: " << mData.mData.mFlags << std::endl;
+    std::cout << "  Type: " << weaponTypeLabel(mData.mData.mType)
+              << " (" << mData.mData.mType << ")" << std::endl;
+    std::cout << "  Flags: " << weaponFlags(mData.mData.mFlags) << std::endl;
     std::cout << "  Weight: " << mData.mData.mWeight << std::endl;
     std::cout << "  Value: " << mData.mData.mValue << std::endl;
     std::cout << "  Health: " << mData.mData.mHealth << std::endl;

apps/launcher/CMakeLists.txt

@@ -1,54 +1,51 @@
 set(LAUNCHER
     datafilespage.cpp
-    filedialog.cpp
     graphicspage.cpp
-    lineedit.cpp
     main.cpp
     maindialog.cpp
-    naturalsort.cpp
     playpage.cpp
-    pluginsmodel.cpp
-    pluginsview.cpp
-
-    launcher.rc
 
     model/datafilesmodel.cpp
     model/modelitem.cpp
     model/esm/esmfile.cpp
+
+    utils/filedialog.cpp
+    utils/naturalsort.cpp
+    utils/lineedit.cpp
+
+    launcher.rc
 )
 
 set(LAUNCHER_HEADER
-    combobox.hpp
     datafilespage.hpp
-    filedialog.hpp
     graphicspage.hpp
-    lineedit.hpp
     maindialog.hpp
-    naturalsort.hpp
     playpage.hpp
-    pluginsmodel.hpp
-    pluginsview.hpp
 
     model/datafilesmodel.hpp
     model/modelitem.hpp
     model/esm/esmfile.hpp
+
+    utils/combobox.hpp
+    utils/lineedit.hpp
+    utils/filedialog.hpp
+    utils/naturalsort.hpp
 )
 
 # Headers that must be pre-processed
 set(LAUNCHER_HEADER_MOC
-    combobox.hpp
     datafilespage.hpp
-    filedialog.hpp
     graphicspage.hpp
-    lineedit.hpp
     maindialog.hpp
     playpage.hpp
-    pluginsmodel.hpp
-    pluginsview.hpp
 
     model/datafilesmodel.hpp
     model/modelitem.hpp
     model/esm/esmfile.hpp
+
+    utils/combobox.hpp
+    utils/lineedit.hpp
+    utils/filedialog.hpp
 )
 
 source_group(launcher FILES ${LAUNCHER} ${LAUNCHER_HEADER} ${LAUNCHER_HEADER_MOC})
@@ -87,7 +84,7 @@ add_executable(omwlauncher
 target_link_libraries(omwlauncher
     ${Boost_LIBRARIES}
     ${OGRE_LIBRARIES}
-	${OGRE_STATIC_PLUGINS}
+    ${OGRE_STATIC_PLUGINS}
     ${QT_LIBRARIES}
     components
 )

apps/launcher/datafilespage.cpp

@@ -6,11 +6,12 @@
 #include "model/datafilesmodel.hpp"
 #include "model/esm/esmfile.hpp"
 
-#include "combobox.hpp"
+#include "utils/combobox.hpp"
+#include "utils/filedialog.hpp"
+#include "utils/lineedit.hpp"
+#include "utils/naturalsort.hpp"
+
 #include "datafilespage.hpp"
-#include "filedialog.hpp"
-#include "lineedit.hpp"
-#include "naturalsort.hpp"
 
 #include <boost/version.hpp>
 /**
@@ -112,6 +113,7 @@ DataFilesPage::DataFilesPage(Files::ConfigurationManager &cfg, QWidget *parent)
     mPluginsTable->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
     mPluginsTable->horizontalHeader()->setStretchLastSection(true);
     mPluginsTable->horizontalHeader()->hide();
+
     mPluginsTable->verticalHeader()->setDefaultSectionSize(height);
     mPluginsTable->verticalHeader()->setResizeMode(QHeaderView::Fixed);
     mPluginsTable->setColumnHidden(1, true);

apps/launcher/datafilespage.hpp

@@ -6,7 +6,6 @@
 
 #include <components/files/collections.hpp>
 
-#include "combobox.hpp"
 
 class QTableView;
 class QSortFilterProxyModel;

apps/launcher/graphicspage.cpp

@@ -9,8 +9,9 @@
 #include <components/files/ogreplugin.hpp>
 #include <components/settings/settings.hpp>
 
+#include "utils/naturalsort.hpp"
+
 #include "graphicspage.hpp"
-#include "naturalsort.hpp"
 
 QString getAspect(int x, int y)
 {

apps/launcher/maindialog.cpp

@@ -1,5 +1,7 @@
 #include <QtGui>
 
+#include "utils/combobox.hpp"
+
 #include "maindialog.hpp"
 #include "playpage.hpp"
 #include "graphicspage.hpp"

apps/launcher/model/datafilesmodel.cpp

@@ -6,8 +6,9 @@
 
 #include "esm/esmfile.hpp"
 
+#include "../utils/naturalsort.hpp"
+
 #include "datafilesmodel.hpp"
-#include "../naturalsort.hpp"
 
 DataFilesModel::DataFilesModel(QObject *parent) :
     QAbstractTableModel(parent)

apps/launcher/pluginsmodel.cpp

@@ -1,149 +0,0 @@
-#include <QMimeData>
-#include <QBitArray>
-
-#include <limits>
-
-#include "pluginsmodel.hpp"
-
-PluginsModel::PluginsModel(QObject *parent) : QStandardItemModel(parent)
-{
-
-}
-
-void decodeDataRecursive(QDataStream &stream, QStandardItem *item)
-{
-    int colCount, childCount;
-    stream >> *item;
-    stream >> colCount >> childCount;
-    item->setColumnCount(colCount);
-
-    int childPos = childCount;
-
-    while(childPos > 0) {
-        childPos--;
-        QStandardItem *child = new QStandardItem();
-        decodeDataRecursive(stream, child);
-        item->setChild( childPos / colCount, childPos % colCount, child);
-    }
-}
-
-bool PluginsModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
-                                      int row, int column, const QModelIndex &parent)
-{
-    // Code largely based on QStandardItemModel::dropMimeData
-
-    // check if the action is supported
-    if (!data || !(action == Qt::CopyAction || action == Qt::MoveAction))
-        return false;
-
-    // check if the format is supported
-    QString format = QLatin1String("application/x-qstandarditemmodeldatalist");
-    if (!data->hasFormat(format))
-        return QAbstractItemModel::dropMimeData(data, action, row, column, parent);
-
-    if (row > rowCount(parent))
-        row = rowCount(parent);
-    if (row == -1)
-        row = rowCount(parent);
-    if (column == -1)
-        column = 0;
-
-    // decode and insert
-    QByteArray encoded = data->data(format);
-    QDataStream stream(&encoded, QIODevice::ReadOnly);
-
-
-    //code based on QAbstractItemModel::decodeData
-    // adapted to work with QStandardItem
-    int top = std::numeric_limits<int>::max();
-    int left = std::numeric_limits<int>::max();
-    int bottom = 0;
-    int right = 0;
-    QVector<int> rows, columns;
-    QVector<QStandardItem *> items;
-
-    while (!stream.atEnd()) {
-        int r, c;
-        QStandardItem *item = new QStandardItem();
-        stream >> r >> c;
-        decodeDataRecursive(stream, item);
-
-        rows.append(r);
-        columns.append(c);
-        items.append(item);
-        top = qMin(r, top);
-        left = qMin(c, left);
-        bottom = qMax(r, bottom);
-        right = qMax(c, right);
-    }
-
-    // insert the dragged items into the table, use a bit array to avoid overwriting items,
-    // since items from different tables can have the same row and column
-    int dragRowCount = 0;
-    int dragColumnCount = right - left + 1;
-
-    // Compute the number of continuous rows upon insertion and modify the rows to match
-    QVector<int> rowsToInsert(bottom + 1);
-    for (int i = 0; i < rows.count(); ++i)
-        rowsToInsert[rows.at(i)] = 1;
-    for (int i = 0; i < rowsToInsert.count(); ++i) {
-        if (rowsToInsert[i] == 1){
-            rowsToInsert[i] = dragRowCount;
-            ++dragRowCount;
-        }
-    }
-    for (int i = 0; i < rows.count(); ++i)
-        rows[i] = top + rowsToInsert[rows[i]];
-
-    QBitArray isWrittenTo(dragRowCount * dragColumnCount);
-
-    // make space in the table for the dropped data
-    int colCount = columnCount(parent);
-    if (colCount < dragColumnCount + column) {
-        insertColumns(colCount, dragColumnCount + column - colCount, parent);
-        colCount = columnCount(parent);
-    }
-    insertRows(row, dragRowCount, parent);
-
-    row = qMax(0, row);
-    column = qMax(0, column);
-
-    QStandardItem *parentItem = itemFromIndex (parent);
-    if (!parentItem)
-        parentItem = invisibleRootItem();
-
-    QVector<QPersistentModelIndex> newIndexes(items.size());
-    // set the data in the table
-    for (int j = 0; j < items.size(); ++j) {
-        int relativeRow = rows.at(j) - top;
-        int relativeColumn = columns.at(j) - left;
-        int destinationRow = relativeRow + row;
-        int destinationColumn = relativeColumn + column;
-        int flat = (relativeRow * dragColumnCount) + relativeColumn;
-        // if the item was already written to, or we just can't fit it in the table, create a new row
-        if (destinationColumn >= colCount || isWrittenTo.testBit(flat)) {
-            destinationColumn = qBound(column, destinationColumn, colCount - 1);
-            destinationRow = row + dragRowCount;
-            insertRows(row + dragRowCount, 1, parent);
-            flat = (dragRowCount * dragColumnCount) + relativeColumn;
-            isWrittenTo.resize(++dragRowCount * dragColumnCount);
-        }
-        if (!isWrittenTo.testBit(flat)) {
-            newIndexes[j] = index(destinationRow, destinationColumn, parentItem->index());
-            isWrittenTo.setBit(flat);
-        }
-    }
-
-    for(int k = 0; k < newIndexes.size(); k++) {
-        if (newIndexes.at(k).isValid()) {
-            parentItem->setChild(newIndexes.at(k).row(), newIndexes.at(k).column(), items.at(k));
-        } else {
-            delete items.at(k);
-        }
-    }
-
-    // The important part, tell the view what is dropped
-    emit indexesDropped(newIndexes);
-
-    return true;
-}

apps/launcher/pluginsmodel.hpp

@@ -1,21 +0,0 @@
-#ifndef PLUGINSMODEL_H
-#define PLUGINSMODEL_H
-
-#include <QStandardItemModel>
-
-class PluginsModel : public QStandardItemModel
-{
-    Q_OBJECT
-
-public:
-    PluginsModel(QObject *parent = 0);
-    ~PluginsModel() {};
-
-    bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
-
-signals:
-    void indexesDropped(QVector<QPersistentModelIndex> indexes);
-
-};
-
-#endif

apps/launcher/pluginsview.cpp

@@ -1,41 +0,0 @@
-#include <QSortFilterProxyModel>
-
-#include "pluginsview.hpp"
-
-PluginsView::PluginsView(QWidget *parent) : QTableView(parent)
-{
-    setSelectionBehavior(QAbstractItemView::SelectRows);
-    setSelectionMode(QAbstractItemView::ExtendedSelection);
-    setEditTriggers(QAbstractItemView::NoEditTriggers);
-    setAlternatingRowColors(true);
-    setDragEnabled(true);
-    setDragDropMode(QAbstractItemView::InternalMove);
-    setDropIndicatorShown(true);
-    setDragDropOverwriteMode(false);
-    setContextMenuPolicy(Qt::CustomContextMenu);
-
-}
-
-void PluginsView::startDrag(Qt::DropActions supportedActions)
-{
-    selectionModel()->select( selectionModel()->selection(),
-                              QItemSelectionModel::Select | QItemSelectionModel::Rows );
-    QAbstractItemView::startDrag( supportedActions );
-}
-
-void PluginsView::setModel(QSortFilterProxyModel *model)
-{
-    QTableView::setModel(model);
-
-    qRegisterMetaType< QVector<QPersistentModelIndex> >();
-
-    connect(model->sourceModel(), SIGNAL(indexesDropped(QVector<QPersistentModelIndex>)),
-            this, SLOT(selectIndexes(QVector<QPersistentModelIndex>)), Qt::QueuedConnection);
-}
-
-void PluginsView::selectIndexes( QVector<QPersistentModelIndex> aIndexes )
-{
-    selectionModel()->clearSelection();
-    foreach( QPersistentModelIndex pIndex, aIndexes )
-        selectionModel()->select( pIndex, QItemSelectionModel::Select | QItemSelectionModel::Rows );
-}

apps/launcher/pluginsview.hpp

@@ -1,29 +0,0 @@
-#ifndef PLUGINSVIEW_H
-#define PLUGINSVIEW_H
-
-#include <QTableView>
-
-#include "pluginsmodel.hpp"
-
-class QSortFilterProxyModel;
-
-class PluginsView : public QTableView
-{
-    Q_OBJECT
-public:
-    PluginsView(QWidget *parent = 0);
-
-    PluginsModel* model() const
-        { return qobject_cast<PluginsModel*>(QAbstractItemView::model()); }
-
-    void startDrag(Qt::DropActions supportedActions);
-    void setModel(QSortFilterProxyModel *model);
-
-public slots:
-    void selectIndexes(QVector<QPersistentModelIndex> aIndexes);
-
-};
-
-Q_DECLARE_METATYPE(QVector<QPersistentModelIndex>);
-
-#endif

apps/mwiniimporter/importer.cpp

@@ -78,7 +78,7 @@ MwIniImporter::multistrmap MwIniImporter::loadIniFile(std::string filename) {
 
         multistrmap::iterator it;
         if((it = map.find(key)) == map.end()) {
-            map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) );
+            map.insert( std::make_pair (key, std::vector<std::string>() ) );
         }
         map[key].push_back(value);
     }
@@ -115,7 +115,7 @@ MwIniImporter::multistrmap MwIniImporter::loadCfgFile(std::string filename) {
 
         multistrmap::iterator it;
         if((it = map.find(key)) == map.end()) {
-            map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) );
+            map.insert( std::make_pair (key, std::vector<std::string>() ) );
         }
         map[key].push_back(value);
     }
@@ -152,12 +152,12 @@ void MwIniImporter::mergeFallback(multistrmap &cfg, multistrmap &ini) {
             }
         }
     }
-};
+}
 
 void MwIniImporter::insertMultistrmap(multistrmap &cfg, std::string key, std::string value) {
     multistrmap::iterator it = cfg.find(key);
     if(it == cfg.end()) {
-        cfg.insert(std::make_pair<std::string, std::vector<std::string> >(key, std::vector<std::string>() ));
+        cfg.insert(std::make_pair (key, std::vector<std::string>() ));
     }
     cfg[key].push_back(value);
 }

apps/openmw/main.cpp

@@ -68,7 +68,7 @@ void validate(boost::any &v, std::vector<std::string> const &tokens, FallbackMap
 
         if((mapIt = map->mMap.find(key)) == map->mMap.end())
         {
-            map->mMap.insert(std::make_pair<std::string,std::string>(key,value));
+            map->mMap.insert(std::make_pair (key,value));
         }
     }
 }

apps/openmw/mwbase/soundmanager.hpp

@@ -37,7 +37,7 @@ namespace MWBase
                 Play_Normal  = 0, /* tracked, non-looping, multi-instance, environment */
                 Play_Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
                 Play_NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
-                Play_NoTrack = 1<<2, /* (3D only) Play the sound at the given object's position
+                Play_NoTrack = 1<<2  /* (3D only) Play the sound at the given object's position
                                       * but do not keep it updated (the sound will not move with
                                       * the object and will not stop when the object is deleted. */
             };

apps/openmw/mwmechanics/drawstate.hpp

@@ -8,7 +8,7 @@ namespace MWMechanics
     {
         DrawState_Weapon = 0,
         DrawState_Spell = 1,
-        DrawState_Nothing = 2,
+        DrawState_Nothing = 2
     };
 }
 

apps/openmw/mwrender/globalmap.cpp

@@ -53,7 +53,7 @@ namespace MWRender
         {
             Ogre::Image image;
 
-            Ogre::uchar data[mWidth * mHeight * 3];
+            std::vector<Ogre::uchar> data (mWidth * mHeight * 3);
 
             for (int x = mMinX; x <= mMaxX; ++x)
             {
@@ -150,7 +150,7 @@ namespace MWRender
                 }
             }
 
-            image.loadDynamicImage (data, mWidth, mHeight, Ogre::PF_B8G8R8);
+            image.loadDynamicImage (&data[0], mWidth, mHeight, Ogre::PF_B8G8R8);
 
             //image.save (mCacheDir + "/GlobalMap.png");
 

apps/openmw/mwrender/water.hpp

@@ -23,7 +23,7 @@ namespace Ogre
     class Entity;
     class Vector3;
     struct RenderTargetEvent;
-};
+}
 
 namespace MWRender {
 

apps/openmw/mwscript/scriptmanagerimp.hpp

@@ -74,6 +74,6 @@ namespace MWScript
             ///< Return index of the variable of the given name and type in the given script. Will
             /// throw an exception, if there is no such script or variable or the type does not match.
     };
-};
+}
 
 #endif

apps/openmw/mwsound/mpgsnd_decoder.hpp

@@ -52,6 +52,6 @@ namespace MWSound
 #ifndef DEFAULT_DECODER
 #define DEFAULT_DECODER (::MWSound::MpgSnd_Decoder)
 #endif
-};
+}
 
 #endif

apps/openmw/mwsound/openal_output.hpp

@@ -66,6 +66,6 @@ namespace MWSound
 #ifndef DEFAULT_OUTPUT
 #define DEFAULT_OUTPUT (::MWSound::OpenAL_Output)
 #endif
-};
+}
 
 #endif

apps/openmw/mwsound/soundmanagerimp.hpp

@@ -26,7 +26,7 @@ namespace MWSound
 
     enum Environment {
         Env_Normal,
-        Env_Underwater,
+        Env_Underwater
     };
 
     class SoundManager : public MWBase::SoundManager

components/esm/aipackage.hpp

@@ -60,7 +60,7 @@ namespace ESM
         AI_Travel = 0x545f4941,
         AI_Follow = 0x465f4941,
         AI_Escort = 0x455f4941,
-        AI_Activate = 0x415f4941,
+        AI_Activate = 0x415f4941
     };
 
     /// \note Used for storaging packages in a single container

components/esm/esmwriter.cpp

@@ -138,11 +138,11 @@ void ESMWriter::writeHNString(const std::string& name, const std::string& data)
 
 void ESMWriter::writeHNString(const std::string& name, const std::string& data, int size)
 {
-    assert(data.size() <= size);
+    assert(static_cast<int> (data.size()) <= size);
     startSubRecord(name);
     writeHString(data);
 
-    if (data.size() < size)
+    if (static_cast<int> (data.size()) < size)
     {
         for (int i = data.size(); i < size; ++i)
             write("\0",1);

components/esm_store/reclists.hpp

@@ -331,7 +331,7 @@ namespace ESMS
     // Find land for the given coordinates. Return null if no mData.
     Land *search(int x, int y) const
     {
-      LandMap::const_iterator itr = lands.find(std::make_pair<int, int>(x, y));
+      LandMap::const_iterator itr = lands.find(std::make_pair (x, y));
       if ( itr == lands.end() )
       {
         return NULL;
@@ -350,7 +350,7 @@ namespace ESMS
       land->load(esm);
 
       // Store the structure
-      lands[std::make_pair<int, int>(land->mX, land->mY)] = land;
+      lands[std::make_pair (land->mX, land->mY)] = land;
     }
   };
 

credits.txt

@@ -16,6 +16,7 @@ Alexander Olofsson (Ace)
 Artem Kotsynyak (greye)
 athile
 BrotherBrick
+Cory F. Cohen (cfcohen)
 Cris Mihalache (Mirceam)
 Douglas Diniz (Dgdiniz)
 Eli2

extern/shiny

@@ -1 +1 @@
-Subproject commit b9ed0f2f3f10915aafd083248a1d6a37293c0db0
+Subproject commit f17c4ebab0e7a1f3bbb25fd9b3dbef2bd742536a

libs/openengine/bullet/CMotionState.cpp

@@ -16,7 +16,7 @@ namespace Physic
         pEng = eng;
         tr.setIdentity();
         pName = name;
-    };
+    }
 
     void CMotionState::getWorldTransform(btTransform &worldTrans) const
     {

libs/openengine/bullet/physic.cpp

@@ -626,4 +626,4 @@ namespace Physic
 
         shape->Shape->getAabb(trans, min, max);
     }
-}};
+}}