id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
34,912
|
infoselectwrapper.cpp
|
OpenMW_openmw/apps/opencs/model/world/infoselectwrapper.cpp
|
#include "infoselectwrapper.hpp"
#include <limits>
#include <sstream>
#include <stdexcept>
#include <components/esm3/variant.hpp>
const char* CSMWorld::ConstInfoSelectWrapper::FunctionEnumStrings[] = {
"Faction Reaction Low",
"Faction Reaction High",
"Rank Requirement",
"Reputation",
"Health Percent",
"PC Reputation",
"PC Level",
"PC Health Percent",
"PC Magicka",
"PC Fatigue",
"PC Strength",
"PC Block",
"PC Armorer",
"PC Medium Armor",
"PC Heavy Armor",
"PC Blunt Weapon",
"PC Long Blade",
"PC Axe",
"PC Spear",
"PC Athletics",
"PC Enchant",
"PC Detruction",
"PC Alteration",
"PC Illusion",
"PC Conjuration",
"PC Mysticism",
"PC Restoration",
"PC Alchemy",
"PC Unarmored",
"PC Security",
"PC Sneak",
"PC Acrobatics",
"PC Light Armor",
"PC Short Blade",
"PC Marksman",
"PC Merchantile",
"PC Speechcraft",
"PC Hand to Hand",
"PC Sex",
"PC Expelled",
"PC Common Disease",
"PC Blight Disease",
"PC Clothing Modifier",
"PC Crime Level",
"Same Sex",
"Same Race",
"Same Faction",
"Faction Rank Difference",
"Detected",
"Alarmed",
"Choice",
"PC Intelligence",
"PC Willpower",
"PC Agility",
"PC Speed",
"PC Endurance",
"PC Personality",
"PC Luck",
"PC Corprus",
"Weather",
"PC Vampire",
"Level",
"Attacked",
"Talked to PC",
"PC Health",
"Creature Target",
"Friend Hit",
"Fight",
"Hello",
"Alarm",
"Flee",
"Should Attack",
"Werewolf",
"PC Werewolf Kills",
"Global",
"Local",
"Journal",
"Item",
"Dead",
"Not Id",
"Not Faction",
"Not Class",
"Not Race",
"Not Cell",
"Not Local",
nullptr,
};
const char* CSMWorld::ConstInfoSelectWrapper::RelationEnumStrings[] = {
"=",
"!=",
">",
">=",
"<",
"<=",
nullptr,
};
namespace
{
std::string_view convertToString(ESM::DialogueCondition::Function name)
{
if (name < ESM::DialogueCondition::Function_None)
return CSMWorld::ConstInfoSelectWrapper::FunctionEnumStrings[name];
return "(Invalid Data: Function)";
}
std::string_view convertToString(ESM::DialogueCondition::Comparison type)
{
if (type != ESM::DialogueCondition::Comp_None)
return CSMWorld::ConstInfoSelectWrapper::RelationEnumStrings[type - ESM::DialogueCondition::Comp_Eq];
return "(Invalid Data: Relation)";
}
}
// ConstInfoSelectWrapper
CSMWorld::ConstInfoSelectWrapper::ConstInfoSelectWrapper(const ESM::DialogueCondition& select)
: mConstSelect(select)
{
updateHasVariable();
updateComparisonType();
}
ESM::DialogueCondition::Function CSMWorld::ConstInfoSelectWrapper::getFunctionName() const
{
return mConstSelect.mFunction;
}
ESM::DialogueCondition::Comparison CSMWorld::ConstInfoSelectWrapper::getRelationType() const
{
return mConstSelect.mComparison;
}
CSMWorld::ConstInfoSelectWrapper::ComparisonType CSMWorld::ConstInfoSelectWrapper::getComparisonType() const
{
return mComparisonType;
}
bool CSMWorld::ConstInfoSelectWrapper::hasVariable() const
{
return mHasVariable;
}
const std::string& CSMWorld::ConstInfoSelectWrapper::getVariableName() const
{
return mConstSelect.mVariable;
}
bool CSMWorld::ConstInfoSelectWrapper::conditionIsAlwaysTrue() const
{
if (mComparisonType == Comparison_Boolean || mComparisonType == Comparison_Integer)
{
if (std::holds_alternative<float>(mConstSelect.mValue))
return conditionIsAlwaysTrue(getConditionFloatRange(), getValidIntRange());
else
return conditionIsAlwaysTrue(getConditionIntRange(), getValidIntRange());
}
else if (mComparisonType == Comparison_Numeric)
{
if (std::holds_alternative<float>(mConstSelect.mValue))
return conditionIsAlwaysTrue(getConditionFloatRange(), getValidFloatRange());
else
return conditionIsAlwaysTrue(getConditionIntRange(), getValidFloatRange());
}
return false;
}
bool CSMWorld::ConstInfoSelectWrapper::conditionIsNeverTrue() const
{
if (mComparisonType == Comparison_Boolean || mComparisonType == Comparison_Integer)
{
if (std::holds_alternative<float>(mConstSelect.mValue))
return conditionIsNeverTrue(getConditionFloatRange(), getValidIntRange());
else
return conditionIsNeverTrue(getConditionIntRange(), getValidIntRange());
}
else if (mComparisonType == Comparison_Numeric)
{
if (std::holds_alternative<float>(mConstSelect.mValue))
return conditionIsNeverTrue(getConditionFloatRange(), getValidFloatRange());
else
return conditionIsNeverTrue(getConditionIntRange(), getValidFloatRange());
}
return false;
}
std::string CSMWorld::ConstInfoSelectWrapper::toString() const
{
std::ostringstream stream;
stream << convertToString(getFunctionName()) << " ";
if (mHasVariable)
stream << getVariableName() << " ";
stream << convertToString(getRelationType()) << " ";
std::visit([&](auto value) { stream << value; }, mConstSelect.mValue);
return stream.str();
}
void CSMWorld::ConstInfoSelectWrapper::updateHasVariable()
{
switch (getFunctionName())
{
case ESM::DialogueCondition::Function_Global:
case ESM::DialogueCondition::Function_Local:
case ESM::DialogueCondition::Function_Journal:
case ESM::DialogueCondition::Function_Item:
case ESM::DialogueCondition::Function_Dead:
case ESM::DialogueCondition::Function_NotId:
case ESM::DialogueCondition::Function_NotFaction:
case ESM::DialogueCondition::Function_NotClass:
case ESM::DialogueCondition::Function_NotRace:
case ESM::DialogueCondition::Function_NotCell:
case ESM::DialogueCondition::Function_NotLocal:
mHasVariable = true;
break;
default:
mHasVariable = false;
break;
}
}
void CSMWorld::ConstInfoSelectWrapper::updateComparisonType()
{
switch (getFunctionName())
{
// Boolean
case ESM::DialogueCondition::Function_NotId:
case ESM::DialogueCondition::Function_NotFaction:
case ESM::DialogueCondition::Function_NotClass:
case ESM::DialogueCondition::Function_NotRace:
case ESM::DialogueCondition::Function_NotCell:
case ESM::DialogueCondition::Function_PcExpelled:
case ESM::DialogueCondition::Function_PcCommonDisease:
case ESM::DialogueCondition::Function_PcBlightDisease:
case ESM::DialogueCondition::Function_SameSex:
case ESM::DialogueCondition::Function_SameRace:
case ESM::DialogueCondition::Function_SameFaction:
case ESM::DialogueCondition::Function_Detected:
case ESM::DialogueCondition::Function_Alarmed:
case ESM::DialogueCondition::Function_PcCorprus:
case ESM::DialogueCondition::Function_PcVampire:
case ESM::DialogueCondition::Function_Attacked:
case ESM::DialogueCondition::Function_TalkedToPc:
case ESM::DialogueCondition::Function_ShouldAttack:
case ESM::DialogueCondition::Function_Werewolf:
mComparisonType = Comparison_Boolean;
break;
// Integer
case ESM::DialogueCondition::Function_Journal:
case ESM::DialogueCondition::Function_Item:
case ESM::DialogueCondition::Function_Dead:
case ESM::DialogueCondition::Function_FacReactionLowest:
case ESM::DialogueCondition::Function_FacReactionHighest:
case ESM::DialogueCondition::Function_RankRequirement:
case ESM::DialogueCondition::Function_Reputation:
case ESM::DialogueCondition::Function_PcReputation:
case ESM::DialogueCondition::Function_PcLevel:
case ESM::DialogueCondition::Function_PcStrength:
case ESM::DialogueCondition::Function_PcBlock:
case ESM::DialogueCondition::Function_PcArmorer:
case ESM::DialogueCondition::Function_PcMediumArmor:
case ESM::DialogueCondition::Function_PcHeavyArmor:
case ESM::DialogueCondition::Function_PcBluntWeapon:
case ESM::DialogueCondition::Function_PcLongBlade:
case ESM::DialogueCondition::Function_PcAxe:
case ESM::DialogueCondition::Function_PcSpear:
case ESM::DialogueCondition::Function_PcAthletics:
case ESM::DialogueCondition::Function_PcEnchant:
case ESM::DialogueCondition::Function_PcDestruction:
case ESM::DialogueCondition::Function_PcAlteration:
case ESM::DialogueCondition::Function_PcIllusion:
case ESM::DialogueCondition::Function_PcConjuration:
case ESM::DialogueCondition::Function_PcMysticism:
case ESM::DialogueCondition::Function_PcRestoration:
case ESM::DialogueCondition::Function_PcAlchemy:
case ESM::DialogueCondition::Function_PcUnarmored:
case ESM::DialogueCondition::Function_PcSecurity:
case ESM::DialogueCondition::Function_PcSneak:
case ESM::DialogueCondition::Function_PcAcrobatics:
case ESM::DialogueCondition::Function_PcLightArmor:
case ESM::DialogueCondition::Function_PcShortBlade:
case ESM::DialogueCondition::Function_PcMarksman:
case ESM::DialogueCondition::Function_PcMerchantile:
case ESM::DialogueCondition::Function_PcSpeechcraft:
case ESM::DialogueCondition::Function_PcHandToHand:
case ESM::DialogueCondition::Function_PcGender:
case ESM::DialogueCondition::Function_PcClothingModifier:
case ESM::DialogueCondition::Function_PcCrimeLevel:
case ESM::DialogueCondition::Function_FactionRankDifference:
case ESM::DialogueCondition::Function_Choice:
case ESM::DialogueCondition::Function_PcIntelligence:
case ESM::DialogueCondition::Function_PcWillpower:
case ESM::DialogueCondition::Function_PcAgility:
case ESM::DialogueCondition::Function_PcSpeed:
case ESM::DialogueCondition::Function_PcEndurance:
case ESM::DialogueCondition::Function_PcPersonality:
case ESM::DialogueCondition::Function_PcLuck:
case ESM::DialogueCondition::Function_Weather:
case ESM::DialogueCondition::Function_Level:
case ESM::DialogueCondition::Function_CreatureTarget:
case ESM::DialogueCondition::Function_FriendHit:
case ESM::DialogueCondition::Function_Fight:
case ESM::DialogueCondition::Function_Hello:
case ESM::DialogueCondition::Function_Alarm:
case ESM::DialogueCondition::Function_Flee:
case ESM::DialogueCondition::Function_PcWerewolfKills:
mComparisonType = Comparison_Integer;
break;
// Numeric
case ESM::DialogueCondition::Function_Global:
case ESM::DialogueCondition::Function_Local:
case ESM::DialogueCondition::Function_NotLocal:
case ESM::DialogueCondition::Function_Health_Percent:
case ESM::DialogueCondition::Function_PcHealthPercent:
case ESM::DialogueCondition::Function_PcMagicka:
case ESM::DialogueCondition::Function_PcFatigue:
case ESM::DialogueCondition::Function_PcHealth:
mComparisonType = Comparison_Numeric;
break;
default:
mComparisonType = Comparison_None;
break;
}
}
std::pair<int, int> CSMWorld::ConstInfoSelectWrapper::getConditionIntRange() const
{
const int IntMax = std::numeric_limits<int>::max();
const int IntMin = std::numeric_limits<int>::min();
const std::pair<int, int> InvalidRange(IntMax, IntMin);
int value = std::get<int>(mConstSelect.mValue);
switch (getRelationType())
{
case ESM::DialogueCondition::Comp_Eq:
case ESM::DialogueCondition::Comp_Ne:
return std::pair<int, int>(value, value);
case ESM::DialogueCondition::Comp_Gt:
if (value == IntMax)
{
return InvalidRange;
}
else
{
return std::pair<int, int>(value + 1, IntMax);
}
break;
case ESM::DialogueCondition::Comp_Ge:
return std::pair<int, int>(value, IntMax);
case ESM::DialogueCondition::Comp_Ls:
if (value == IntMin)
{
return InvalidRange;
}
else
{
return std::pair<int, int>(IntMin, value - 1);
}
case ESM::DialogueCondition::Comp_Le:
return std::pair<int, int>(IntMin, value);
default:
throw std::logic_error("InfoSelectWrapper: relation does not have a range");
}
}
std::pair<float, float> CSMWorld::ConstInfoSelectWrapper::getConditionFloatRange() const
{
const float FloatMax = std::numeric_limits<float>::infinity();
const float FloatMin = -std::numeric_limits<float>::infinity();
const float Epsilon = std::numeric_limits<float>::epsilon();
float value = std::get<float>(mConstSelect.mValue);
switch (getRelationType())
{
case ESM::DialogueCondition::Comp_Eq:
case ESM::DialogueCondition::Comp_Ne:
return std::pair<float, float>(value, value);
case ESM::DialogueCondition::Comp_Gt:
return std::pair<float, float>(value + Epsilon, FloatMax);
case ESM::DialogueCondition::Comp_Ge:
return std::pair<float, float>(value, FloatMax);
case ESM::DialogueCondition::Comp_Ls:
return std::pair<float, float>(FloatMin, value - Epsilon);
case ESM::DialogueCondition::Comp_Le:
return std::pair<float, float>(FloatMin, value);
default:
throw std::logic_error("InfoSelectWrapper: given relation does not have a range");
}
}
std::pair<int, int> CSMWorld::ConstInfoSelectWrapper::getValidIntRange() const
{
const int IntMax = std::numeric_limits<int>::max();
const int IntMin = std::numeric_limits<int>::min();
switch (getFunctionName())
{
// Boolean
case ESM::DialogueCondition::Function_NotId:
case ESM::DialogueCondition::Function_NotFaction:
case ESM::DialogueCondition::Function_NotClass:
case ESM::DialogueCondition::Function_NotRace:
case ESM::DialogueCondition::Function_NotCell:
case ESM::DialogueCondition::Function_PcExpelled:
case ESM::DialogueCondition::Function_PcCommonDisease:
case ESM::DialogueCondition::Function_PcBlightDisease:
case ESM::DialogueCondition::Function_SameSex:
case ESM::DialogueCondition::Function_SameRace:
case ESM::DialogueCondition::Function_SameFaction:
case ESM::DialogueCondition::Function_Detected:
case ESM::DialogueCondition::Function_Alarmed:
case ESM::DialogueCondition::Function_PcCorprus:
case ESM::DialogueCondition::Function_PcVampire:
case ESM::DialogueCondition::Function_Attacked:
case ESM::DialogueCondition::Function_TalkedToPc:
case ESM::DialogueCondition::Function_ShouldAttack:
case ESM::DialogueCondition::Function_Werewolf:
return std::pair<int, int>(0, 1);
// Integer
case ESM::DialogueCondition::Function_FacReactionLowest:
case ESM::DialogueCondition::Function_FacReactionHighest:
case ESM::DialogueCondition::Function_Reputation:
case ESM::DialogueCondition::Function_PcReputation:
case ESM::DialogueCondition::Function_Journal:
return std::pair<int, int>(IntMin, IntMax);
case ESM::DialogueCondition::Function_Item:
case ESM::DialogueCondition::Function_Dead:
case ESM::DialogueCondition::Function_PcLevel:
case ESM::DialogueCondition::Function_PcStrength:
case ESM::DialogueCondition::Function_PcBlock:
case ESM::DialogueCondition::Function_PcArmorer:
case ESM::DialogueCondition::Function_PcMediumArmor:
case ESM::DialogueCondition::Function_PcHeavyArmor:
case ESM::DialogueCondition::Function_PcBluntWeapon:
case ESM::DialogueCondition::Function_PcLongBlade:
case ESM::DialogueCondition::Function_PcAxe:
case ESM::DialogueCondition::Function_PcSpear:
case ESM::DialogueCondition::Function_PcAthletics:
case ESM::DialogueCondition::Function_PcEnchant:
case ESM::DialogueCondition::Function_PcDestruction:
case ESM::DialogueCondition::Function_PcAlteration:
case ESM::DialogueCondition::Function_PcIllusion:
case ESM::DialogueCondition::Function_PcConjuration:
case ESM::DialogueCondition::Function_PcMysticism:
case ESM::DialogueCondition::Function_PcRestoration:
case ESM::DialogueCondition::Function_PcAlchemy:
case ESM::DialogueCondition::Function_PcUnarmored:
case ESM::DialogueCondition::Function_PcSecurity:
case ESM::DialogueCondition::Function_PcSneak:
case ESM::DialogueCondition::Function_PcAcrobatics:
case ESM::DialogueCondition::Function_PcLightArmor:
case ESM::DialogueCondition::Function_PcShortBlade:
case ESM::DialogueCondition::Function_PcMarksman:
case ESM::DialogueCondition::Function_PcMerchantile:
case ESM::DialogueCondition::Function_PcSpeechcraft:
case ESM::DialogueCondition::Function_PcHandToHand:
case ESM::DialogueCondition::Function_PcClothingModifier:
case ESM::DialogueCondition::Function_PcCrimeLevel:
case ESM::DialogueCondition::Function_Choice:
case ESM::DialogueCondition::Function_PcIntelligence:
case ESM::DialogueCondition::Function_PcWillpower:
case ESM::DialogueCondition::Function_PcAgility:
case ESM::DialogueCondition::Function_PcSpeed:
case ESM::DialogueCondition::Function_PcEndurance:
case ESM::DialogueCondition::Function_PcPersonality:
case ESM::DialogueCondition::Function_PcLuck:
case ESM::DialogueCondition::Function_Level:
case ESM::DialogueCondition::Function_PcWerewolfKills:
return std::pair<int, int>(0, IntMax);
case ESM::DialogueCondition::Function_Fight:
case ESM::DialogueCondition::Function_Hello:
case ESM::DialogueCondition::Function_Alarm:
case ESM::DialogueCondition::Function_Flee:
return std::pair<int, int>(0, 100);
case ESM::DialogueCondition::Function_Weather:
return std::pair<int, int>(0, 9);
case ESM::DialogueCondition::Function_FriendHit:
return std::pair<int, int>(0, 4);
case ESM::DialogueCondition::Function_RankRequirement:
return std::pair<int, int>(0, 3);
case ESM::DialogueCondition::Function_CreatureTarget:
return std::pair<int, int>(0, 2);
case ESM::DialogueCondition::Function_PcGender:
return std::pair<int, int>(0, 1);
case ESM::DialogueCondition::Function_FactionRankDifference:
return std::pair<int, int>(-9, 9);
// Numeric
case ESM::DialogueCondition::Function_Global:
case ESM::DialogueCondition::Function_Local:
case ESM::DialogueCondition::Function_NotLocal:
return std::pair<int, int>(IntMin, IntMax);
case ESM::DialogueCondition::Function_PcMagicka:
case ESM::DialogueCondition::Function_PcFatigue:
case ESM::DialogueCondition::Function_PcHealth:
return std::pair<int, int>(0, IntMax);
case ESM::DialogueCondition::Function_Health_Percent:
case ESM::DialogueCondition::Function_PcHealthPercent:
return std::pair<int, int>(0, 100);
default:
throw std::runtime_error("InfoSelectWrapper: function does not exist");
}
}
std::pair<float, float> CSMWorld::ConstInfoSelectWrapper::getValidFloatRange() const
{
const float FloatMax = std::numeric_limits<float>::infinity();
const float FloatMin = -std::numeric_limits<float>::infinity();
switch (getFunctionName())
{
// Numeric
case ESM::DialogueCondition::Function_Global:
case ESM::DialogueCondition::Function_Local:
case ESM::DialogueCondition::Function_NotLocal:
return std::pair<float, float>(FloatMin, FloatMax);
case ESM::DialogueCondition::Function_PcMagicka:
case ESM::DialogueCondition::Function_PcFatigue:
case ESM::DialogueCondition::Function_PcHealth:
return std::pair<float, float>(0, FloatMax);
case ESM::DialogueCondition::Function_Health_Percent:
case ESM::DialogueCondition::Function_PcHealthPercent:
return std::pair<float, float>(0, 100);
default:
throw std::runtime_error("InfoSelectWrapper: function does not exist or is not numeric");
}
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::rangeContains(T1 value, std::pair<T2, T2> range) const
{
return (value >= range.first && value <= range.second);
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::rangeFullyContains(
std::pair<T1, T1> containingRange, std::pair<T2, T2> testRange) const
{
return (containingRange.first <= testRange.first) && (testRange.second <= containingRange.second);
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::rangesOverlap(std::pair<T1, T1> range1, std::pair<T2, T2> range2) const
{
// One of the bounds of either range should fall within the other range
return (range1.first <= range2.first && range2.first <= range1.second)
|| (range1.first <= range2.second && range2.second <= range1.second)
|| (range2.first <= range1.first && range1.first <= range2.second)
|| (range2.first <= range1.second && range1.second <= range2.second);
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::rangesMatch(std::pair<T1, T1> range1, std::pair<T2, T2> range2) const
{
return (range1.first == range2.first && range1.second == range2.second);
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::conditionIsAlwaysTrue(
std::pair<T1, T1> conditionRange, std::pair<T2, T2> validRange) const
{
switch (getRelationType())
{
case ESM::DialogueCondition::Comp_Eq:
return false;
case ESM::DialogueCondition::Comp_Ne:
// If value is not within range, it will always be true
return !rangeContains(conditionRange.first, validRange);
case ESM::DialogueCondition::Comp_Gt:
case ESM::DialogueCondition::Comp_Ge:
case ESM::DialogueCondition::Comp_Ls:
case ESM::DialogueCondition::Comp_Le:
// If the valid range is completely within the condition range, it will always be true
return rangeFullyContains(conditionRange, validRange);
default:
throw std::logic_error("InfoCondition: operator can not be used to compare");
}
return false;
}
template <typename T1, typename T2>
bool CSMWorld::ConstInfoSelectWrapper::conditionIsNeverTrue(
std::pair<T1, T1> conditionRange, std::pair<T2, T2> validRange) const
{
switch (getRelationType())
{
case ESM::DialogueCondition::Comp_Eq:
return !rangeContains(conditionRange.first, validRange);
case ESM::DialogueCondition::Comp_Ne:
return false;
case ESM::DialogueCondition::Comp_Gt:
case ESM::DialogueCondition::Comp_Ge:
case ESM::DialogueCondition::Comp_Ls:
case ESM::DialogueCondition::Comp_Le:
// If ranges do not overlap, it will never be true
return !rangesOverlap(conditionRange, validRange);
default:
throw std::logic_error("InfoCondition: operator can not be used to compare");
}
return false;
}
QVariant CSMWorld::ConstInfoSelectWrapper::getValue() const
{
return std::visit([](auto value) { return QVariant(value); }, mConstSelect.mValue);
}
// InfoSelectWrapper
CSMWorld::InfoSelectWrapper::InfoSelectWrapper(ESM::DialogueCondition& select)
: CSMWorld::ConstInfoSelectWrapper(select)
, mSelect(select)
{
}
void CSMWorld::InfoSelectWrapper::setFunctionName(ESM::DialogueCondition::Function name)
{
mSelect.mFunction = name;
updateHasVariable();
updateComparisonType();
if (getComparisonType() != ConstInfoSelectWrapper::Comparison_Numeric
&& std::holds_alternative<float>(mSelect.mValue))
{
mSelect.mValue = std::visit([](auto value) { return static_cast<int>(value); }, mSelect.mValue);
}
}
void CSMWorld::InfoSelectWrapper::setRelationType(ESM::DialogueCondition::Comparison type)
{
mSelect.mComparison = type;
}
void CSMWorld::InfoSelectWrapper::setVariableName(const std::string& name)
{
mSelect.mVariable = name;
}
void CSMWorld::InfoSelectWrapper::setValue(int value)
{
mSelect.mValue = value;
}
void CSMWorld::InfoSelectWrapper::setValue(float value)
{
mSelect.mValue = value;
}
| 25,166
|
C++
|
.cpp
| 614
| 33.87785
| 113
| 0.6916
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,913
|
record.cpp
|
OpenMW_openmw/apps/opencs/model/world/record.cpp
|
#include "record.hpp"
bool CSMWorld::RecordBase::isDeleted() const
{
return mState == State_Deleted || mState == State_Erased;
}
bool CSMWorld::RecordBase::isErased() const
{
return mState == State_Erased;
}
bool CSMWorld::RecordBase::isModified() const
{
return mState == State_Modified || mState == State_ModifiedOnly;
}
| 337
|
C++
|
.cpp
| 13
| 23.846154
| 68
| 0.732919
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,914
|
pathgrid.cpp
|
OpenMW_openmw/apps/opencs/model/world/pathgrid.cpp
|
#include "pathgrid.hpp"
#include "cell.hpp"
#include "idcollection.hpp"
#include <sstream>
void CSMWorld::Pathgrid::load(ESM::ESMReader& esm, bool& isDeleted, const IdCollection<Cell>& cells)
{
load(esm, isDeleted);
// correct ID
if (!mId.empty() && !mId.startsWith("#") && cells.searchId(mId) == -1)
{
std::ostringstream stream;
stream << "#" << mData.mX << " " << mData.mY;
mId = ESM::RefId::stringRefId(stream.str());
}
}
void CSMWorld::Pathgrid::load(ESM::ESMReader& esm, bool& isDeleted)
{
ESM::Pathgrid::load(esm, isDeleted);
mId = mCell;
if (mCell.empty())
{
std::ostringstream stream;
stream << "#" << mData.mX << " " << mData.mY;
mId = ESM::RefId::stringRefId(stream.str());
}
}
| 781
|
C++
|
.cpp
| 26
| 25.461538
| 100
| 0.608
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,915
|
refcollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/refcollection.cpp
|
#include "refcollection.hpp"
#include <algorithm>
#include <stdexcept>
#include <string_view>
#include <utility>
#include <apps/opencs/model/world/collection.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/misc/strings/conversion.hpp>
#include "cell.hpp"
#include "record.hpp"
#include "ref.hpp"
#include "universalid.hpp"
#include "../doc/messages.hpp"
namespace CSMWorld
{
template <>
void Collection<CellRef>::removeRows(int index, int count)
{
mRecords.erase(mRecords.begin() + index, mRecords.begin() + index + count);
// index map is updated in RefCollection::removeRows()
}
template <>
void Collection<CellRef>::insertRecord(std::unique_ptr<RecordBase> record, int index, UniversalId::Type type)
{
int size = static_cast<int>(mRecords.size());
if (index < 0 || index > size)
throw std::runtime_error("index out of range");
std::unique_ptr<Record<CellRef>> record2(static_cast<Record<CellRef>*>(record.release()));
if (index == size)
mRecords.push_back(std::move(record2));
else
mRecords.insert(mRecords.begin() + index, std::move(record2));
// index map is updated in RefCollection::insertRecord()
}
}
void CSMWorld::RefCollection::load(ESM::ESMReader& reader, int cellIndex, bool base,
std::map<ESM::RefNum, unsigned int>& cache, CSMDoc::Messages& messages)
{
Record<Cell> cell = mCells.getRecord(cellIndex);
Cell& cell2 = base ? cell.mBase : cell.mModified;
ESM::MovedCellRef mref;
bool isDeleted = false;
bool isMoved = false;
while (true)
{
CellRef ref;
ref.mNew = false;
if (!ESM::Cell::getNextRef(reader, ref, isDeleted, mref, isMoved))
break;
if (!base && reader.getIndex() == ref.mRefNum.mContentFile)
ref.mRefNum.mContentFile = -1;
// Keep mOriginalCell empty when in modified (as an indicator that the
// original cell will always be equal the current cell).
ref.mOriginalCell = base ? cell2.mId : ESM::RefId();
if (cell.get().isExterior())
{
// Autocalculate the cell index from coordinates first
std::pair<int, int> index = ref.getCellIndex();
ref.mCell = ESM::RefId::stringRefId(ESM::RefId::esm3ExteriorCell(index.first, index.second).toString());
// Handle non-base moved references
if (!base && isMoved)
{
// Moved references must have a link back to their original cell
// See discussion: https://forum.openmw.org/viewtopic.php?f=6&t=577&start=30
ref.mOriginalCell = cell2.mId;
// Some mods may move references outside of the bounds, which often happens they are deleted.
// This results in nonsensical autocalculated cell IDs, so we must use the record target cell.
// Log a warning if the record target cell is different
if (index.first != mref.mTarget[0] || index.second != mref.mTarget[1])
{
ESM::RefId indexCell = ref.mCell;
ref.mCell = ESM::RefId::stringRefId(
ESM::RefId::esm3ExteriorCell(mref.mTarget[0], mref.mTarget[1]).toString());
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Cell, mCells.getId(cellIndex));
messages.add(id, "The position of the moved reference " + ref.mRefID.toDebugString() + " (cell " + indexCell.toDebugString() + ")"
" does not match the target cell (" + ref.mCell.toDebugString() + ")",
std::string(), CSMDoc::Message::Severity_Warning);
}
}
}
else
ref.mCell = cell2.mId;
auto iter = cache.find(ref.mRefNum);
if (isMoved)
{
if (iter == cache.end())
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Cell, mCells.getId(cellIndex));
messages.add(id,
"Attempt to move a non-existent reference - RefNum index " + std::to_string(ref.mRefNum.mIndex)
+ ", refID " + ref.mRefID.toDebugString() + ", content file index "
+ std::to_string(ref.mRefNum.mContentFile),
/*hint*/ "", CSMDoc::Message::Severity_Warning);
continue;
}
int index = getIntIndex(iter->second);
// ensure we have the same record id for setRecord()
ref.mId = getRecord(index).get().mId;
ref.mIdNum = extractIdNum(ref.mId.getRefIdString());
auto record = std::make_unique<Record<CellRef>>();
// TODO: check whether a base record be moved
record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
(base ? record->mBase : record->mModified) = std::move(ref);
// overwrite original record
setRecord(index, std::move(record));
continue; // NOTE: assumed moved references are not deleted at the same time
}
if (isDeleted)
{
if (iter == cache.end())
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Cell, mCells.getId(cellIndex));
messages.add(id,
"Attempt to delete a non-existent reference - RefNum index " + std::to_string(ref.mRefNum.mIndex)
+ ", refID " + ref.mRefID.getRefIdString() + ", content file index "
+ std::to_string(ref.mRefNum.mContentFile),
/*hint*/ "", CSMDoc::Message::Severity_Warning);
continue;
}
int index = getIntIndex(iter->second);
if (base)
{
removeRows(index, 1);
cache.erase(iter);
}
else
{
auto record = std::make_unique<Record<CellRef>>(getRecord(index));
record->mState = RecordBase::State_Deleted;
setRecord(index, std::move(record));
}
continue;
}
if (iter == cache.end())
{
// new reference
ref.mIdNum = mNextId; // FIXME: fragile
ref.mId = ESM::RefId::stringRefId(getNewId());
cache.emplace(ref.mRefNum, ref.mIdNum);
auto record = std::make_unique<Record<CellRef>>();
record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
(base ? record->mBase : record->mModified) = std::move(ref);
appendRecord(std::move(record));
}
else
{
// old reference -> merge
int index = getIntIndex(iter->second);
#if 0
// ref.mRefNum.mIndex : the key
// iter->second : previously cached idNum for the key
// index : position of the record for that idNum
// getRecord(index).get() : record in the index position
assert(iter->second != getRecord(index).get().mIdNum); // sanity check
// check if the plugin used the same RefNum index for a different record
if (ref.mRefID != getRecord(index).get().mRefID)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Cell, mCells.getId(cellIndex));
messages.add(id,
"RefNum renamed from RefID \"" + getRecord(index).get().mRefID + "\" to \""
+ ref.mRefID + "\" (RefNum index " + std::to_string(ref.mRefNum.mIndex) + ")",
/*hint*/"",
CSMDoc::Message::Severity_Info);
}
#endif
ref.mId = getRecord(index).get().mId;
ref.mIdNum = extractIdNum(ref.mId.getRefIdString());
auto record = std::make_unique<Record<CellRef>>(getRecord(index));
record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_Modified;
(base ? record->mBase : record->mModified) = std::move(ref);
setRecord(index, std::move(record));
}
}
}
std::string CSMWorld::RefCollection::getNewId()
{
return "ref#" + std::to_string(mNextId++);
}
unsigned int CSMWorld::RefCollection::extractIdNum(std::string_view id) const
{
std::string::size_type separator = id.find_last_of('#');
if (separator == std::string::npos)
throw std::runtime_error("invalid ref ID: " + std::string(id));
return Misc::StringUtils::toNumeric<unsigned int>(id.substr(separator + 1), 0);
}
int CSMWorld::RefCollection::getIntIndex(unsigned int id) const
{
int index = searchId(id);
if (index == -1)
throw std::runtime_error("invalid RefNum: " + std::to_string(id));
return index;
}
int CSMWorld::RefCollection::searchId(unsigned int id) const
{
std::map<unsigned int, int>::const_iterator iter = mRefIndex.find(id);
if (iter == mRefIndex.end())
return -1;
return iter->second;
}
void CSMWorld::RefCollection::removeRows(int index, int count)
{
Collection<CellRef>::removeRows(index, count); // erase records only
std::map<unsigned int, int>::iterator iter = mRefIndex.begin();
while (iter != mRefIndex.end())
{
if (iter->second >= index)
{
if (iter->second >= index + count)
{
iter->second -= count;
++iter;
}
else
mRefIndex.erase(iter++);
}
else
++iter;
}
}
void CSMWorld::RefCollection::appendBlankRecord(const ESM::RefId& id, UniversalId::Type type)
{
auto record = std::make_unique<Record<CellRef>>();
record->mState = Record<CellRef>::State_ModifiedOnly;
record->mModified.blank();
record->get().mId = id;
record->get().mIdNum = extractIdNum(id.getRefIdString());
Collection<CellRef>::appendRecord(std::move(record));
}
void CSMWorld::RefCollection::cloneRecord(
const ESM::RefId& origin, const ESM::RefId& destination, const UniversalId::Type type)
{
auto copy = std::make_unique<Record<CellRef>>();
int index = getAppendIndex(ESM::RefId(), type);
copy->mModified = getRecord(origin).get();
copy->mState = RecordBase::State_ModifiedOnly;
copy->get().mId = destination;
copy->get().mIdNum = extractIdNum(destination.getRefIdString());
if (copy->get().mRefNum.hasContentFile())
{
mRefIndex.insert(std::make_pair(static_cast<Record<CellRef>*>(copy.get())->get().mIdNum, index));
copy->get().mRefNum.mContentFile = -1;
copy->get().mRefNum.mIndex = index;
}
else
copy->get().mRefNum.mIndex = copy->get().mIdNum;
insertRecord(std::move(copy), getAppendIndex(destination, type)); // call RefCollection::insertRecord()
}
int CSMWorld::RefCollection::searchId(const ESM::RefId& id) const
{
return searchId(extractIdNum(id.getRefIdString()));
}
void CSMWorld::RefCollection::appendRecord(std::unique_ptr<RecordBase> record, UniversalId::Type type)
{
int index = getAppendIndex(/*id*/ ESM::RefId(), type); // for CellRef records id is ignored
mRefIndex.insert(std::make_pair(static_cast<Record<CellRef>*>(record.get())->get().mIdNum, index));
Collection<CellRef>::insertRecord(std::move(record), index, type); // add records only
}
void CSMWorld::RefCollection::insertRecord(std::unique_ptr<RecordBase> record, int index, UniversalId::Type type)
{
int size = getAppendIndex(/*id*/ ESM::RefId(), type); // for CellRef records id is ignored
unsigned int idNum = static_cast<Record<CellRef>*>(record.get())->get().mIdNum;
Collection<CellRef>::insertRecord(std::move(record), index, type); // add records only
if (index < size - 1)
{
for (std::map<unsigned int, int>::iterator iter(mRefIndex.begin()); iter != mRefIndex.end(); ++iter)
{
if (iter->second >= index)
++(iter->second);
}
}
mRefIndex.insert(std::make_pair(idNum, index));
}
| 12,303
|
C++
|
.cpp
| 274
| 35.284672
| 150
| 0.599682
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,917
|
nestedcollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/nestedcollection.cpp
|
#include "nestedcollection.hpp"
#include <apps/opencs/model/world/columns.hpp>
#include <stdexcept>
#include "columnbase.hpp"
int CSMWorld::NestedCollection::getNestedRowsCount(int row, int column) const
{
return 0;
}
int CSMWorld::NestedCollection::getNestedColumnsCount(int row, int column) const
{
return 0;
}
int CSMWorld::NestedCollection::searchNestedColumnIndex(int parentColumn, Columns::ColumnId id)
{
// Assumed that the parentColumn is always a valid index
const NestableColumn* parent = getNestableColumn(parentColumn);
int nestedColumnCount = getNestedColumnsCount(0, parentColumn);
for (int i = 0; i < nestedColumnCount; ++i)
{
if (parent->nestedColumn(i).mColumnId == id)
{
return i;
}
}
return -1;
}
int CSMWorld::NestedCollection::findNestedColumnIndex(int parentColumn, Columns::ColumnId id)
{
int index = searchNestedColumnIndex(parentColumn, id);
if (index == -1)
{
throw std::logic_error("CSMWorld::NestedCollection: No such nested column");
}
return index;
}
| 1,088
|
C++
|
.cpp
| 35
| 27.028571
| 95
| 0.724665
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,918
|
universalid.cpp
|
OpenMW_openmw/apps/opencs/model/world/universalid.cpp
|
#include "universalid.hpp"
#include <algorithm>
#include <compare>
#include <iostream>
#include <span>
#include <sstream>
#include <stdexcept>
#include <string_view>
#include <tuple>
#include <vector>
namespace
{
struct TypeData
{
CSMWorld::UniversalId::Class mClass;
CSMWorld::UniversalId::Type mType;
std::string_view mName;
std::string_view mIcon;
};
constexpr TypeData sNoArg[] = {
{ CSMWorld::UniversalId::Class_None, CSMWorld::UniversalId::Type_None, "-", ":placeholder" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Globals, "Global Variables",
":global-variable" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Gmsts, "Game Settings", ":gmst" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Skills, "Skills", ":skill" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Classes, "Classes", ":class" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Factions, "Factions", ":faction" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Races, "Races", ":race" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Sounds, "Sounds", ":sound" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Scripts, "Scripts", ":script" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Regions, "Regions", ":region" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Birthsigns, "Birthsigns", ":birthsign" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Spells, "Spells", ":spell" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Topics, "Topics", ":dialogue-topics" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Journals, "Journals",
":journal-topics" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_TopicInfos, "Topic Infos",
":dialogue-info" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_JournalInfos, "Journal Infos",
":journal-topic-infos" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Cells, "Cells", ":cell" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Enchantments, "Enchantments",
":enchantment" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_BodyParts, "Body Parts", ":body-part" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Referenceables, "Objects", ":object" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_References, "Instances", ":instance" },
{ CSMWorld::UniversalId::Class_NonRecord, CSMWorld::UniversalId::Type_RegionMap, "Region Map", ":region-map" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Filters, "Filters", ":filter" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_Meshes, "Meshes", ":resources-mesh" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_Icons, "Icons", ":resources-icon" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_Musics, "Music Files",
":resources-music" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_SoundsRes, "Sound Files",
":resources-sound" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_Textures, "Textures",
":resources-texture" },
{ CSMWorld::UniversalId::Class_ResourceList, CSMWorld::UniversalId::Type_Videos, "Videos", ":resources-video" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_DebugProfiles, "Debug Profiles",
":debug-profile" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_SelectionGroup, "Selection Groups", "" },
{ CSMWorld::UniversalId::Class_Transient, CSMWorld::UniversalId::Type_RunLog, "Run Log", ":run-log" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_SoundGens, "Sound Generators",
":sound-generator" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_MagicEffects, "Magic Effects",
":magic-effect" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Lands, "Lands", ":land-heightmap" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_LandTextures, "Land Textures",
":land-texture" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Pathgrids, "Pathgrids", ":pathgrid" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_StartScripts, "Start Scripts",
":start-script" },
{ CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_MetaDatas, "Metadata", ":metadata" },
};
constexpr TypeData sIdArg[] = {
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Global, "Global Variable",
":global-variable" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Gmst, "Game Setting", ":gmst" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Skill, "Skill", ":skill" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Class, "Class", ":class" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Faction, "Faction", ":faction" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Race, "Race", ":race" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Sound, "Sound", ":sound" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Script, "Script", ":script" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Region, "Region", ":region" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Birthsign, "Birthsign", ":birthsign" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Spell, "Spell", ":spell" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Topic, "Topic", ":dialogue-topics" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Journal, "Journal", ":journal-topics" },
{ CSMWorld::UniversalId::Class_SubRecord, CSMWorld::UniversalId::Type_TopicInfo, "TopicInfo",
":dialogue-info" },
{ CSMWorld::UniversalId::Class_SubRecord, CSMWorld::UniversalId::Type_JournalInfo, "JournalInfo",
":journal-topic-infos" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Cell, "Cell", ":cell" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Cell_Missing, "Cell", ":cell" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Referenceable, "Object", ":object" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Activator, "Activator", ":activator" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Potion, "Potion", ":potion" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Apparatus, "Apparatus", ":apparatus" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Armor, "Armor", ":armor" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Book, "Book", ":book" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Clothing, "Clothing", ":clothing" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Container, "Container", ":container" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Creature, "Creature", ":creature" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Door, "Door", ":door" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Ingredient, "Ingredient", ":ingredient" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_CreatureLevelledList,
"Creature Levelled List", ":levelled-creature" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_ItemLevelledList, "Item Levelled List",
":levelled-item" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Light, "Light", ":light" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Lockpick, "Lockpick", ":lockpick" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Miscellaneous, "Miscellaneous",
":miscellaneous" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Npc, "NPC", ":npc" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Probe, "Probe", ":probe" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Repair, "Repair", ":repair" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Static, "Static", ":static" },
{ CSMWorld::UniversalId::Class_RefRecord, CSMWorld::UniversalId::Type_Weapon, "Weapon", ":weapon" },
{ CSMWorld::UniversalId::Class_SubRecord, CSMWorld::UniversalId::Type_Reference, "Instance", ":instance" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Filter, "Filter", ":filter" },
{ CSMWorld::UniversalId::Class_Collection, CSMWorld::UniversalId::Type_Scene, "Scene", ":scene" },
{ CSMWorld::UniversalId::Class_Collection, CSMWorld::UniversalId::Type_Preview, "Preview", ":edit-preview" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Enchantment, "Enchantment", ":enchantment" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_BodyPart, "Body Part", ":body-part" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_Mesh, "Mesh", ":resources-mesh" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_Icon, "Icon", ":resources-icon" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_Music, "Music", ":resources-music" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_SoundRes, "Sound File",
":resources-sound" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_Texture, "Texture", ":resources-texture" },
{ CSMWorld::UniversalId::Class_Resource, CSMWorld::UniversalId::Type_Video, "Video", ":resources-video" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_DebugProfile, "Debug Profile",
":debug-profile" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_SoundGen, "Sound Generator",
":sound-generator" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_MagicEffect, "Magic Effect",
":magic-effect" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Land, "Land", ":land-heightmap" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_LandTexture, "Land Texture",
":land-texture" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Pathgrid, "Pathgrid", ":pathgrid" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_StartScript, "Start Script",
":start-script" },
{ CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_MetaData, "Metadata", ":metadata" },
};
constexpr TypeData sIndexArg[] = {
{ CSMWorld::UniversalId::Class_Transient, CSMWorld::UniversalId::Type_VerificationResults,
"Verification Results", ":menu-verify" },
{ CSMWorld::UniversalId::Class_Transient, CSMWorld::UniversalId::Type_LoadErrorLog, "Load Error Log",
":error-log" },
{ CSMWorld::UniversalId::Class_Transient, CSMWorld::UniversalId::Type_Search, "Global Search", ":menu-search" },
};
struct WriteToStream
{
std::ostream& mStream;
void operator()(std::monostate /*value*/) const {}
template <class T>
void operator()(const T& value) const
{
mStream << ": " << value;
}
void operator()(const ESM::RefId& value) const { mStream << ": " << value.toString(); }
};
struct GetTypeData
{
std::span<const TypeData> operator()(std::monostate /*value*/) const { return sNoArg; }
std::span<const TypeData> operator()(int /*value*/) const { return sIndexArg; }
template <class T>
std::span<const TypeData> operator()(const T& /*value*/) const
{
return sIdArg;
}
};
std::string toString(CSMWorld::UniversalId::ArgumentType value)
{
switch (value)
{
case CSMWorld::UniversalId::ArgumentType_None:
return "None";
case CSMWorld::UniversalId::ArgumentType_Id:
return "Id";
case CSMWorld::UniversalId::ArgumentType_Index:
return "Index";
case CSMWorld::UniversalId::ArgumentType_RefId:
return "RefId";
}
return std::to_string(value);
}
CSMWorld::UniversalId::Class getClassByType(CSMWorld::UniversalId::Type type)
{
if (const auto it
= std::find_if(std::begin(sIdArg), std::end(sIdArg), [&](const TypeData& v) { return v.mType == type; });
it != std::end(sIdArg))
return it->mClass;
if (const auto it = std::find_if(
std::begin(sIndexArg), std::end(sIndexArg), [&](const TypeData& v) { return v.mType == type; });
it != std::end(sIndexArg))
return it->mClass;
if (const auto it
= std::find_if(std::begin(sNoArg), std::end(sNoArg), [&](const TypeData& v) { return v.mType == type; });
it != std::end(sNoArg))
return it->mClass;
throw std::logic_error("invalid UniversalId type: " + std::to_string(type));
}
}
CSMWorld::UniversalId::UniversalId(const std::string& universalId)
: mValue(std::monostate{})
{
std::string::size_type index = universalId.find(':');
if (index != std::string::npos)
{
std::string type = universalId.substr(0, index);
for (const TypeData& value : sIdArg)
if (type == value.mName)
{
mType = value.mType;
mClass = value.mClass;
mValue = universalId.substr(index + 2);
return;
}
for (const TypeData& value : sIndexArg)
if (type == value.mName)
{
mType = value.mType;
mClass = value.mClass;
std::istringstream stream(universalId.substr(index + 2));
int index = 0;
if (stream >> index)
{
mValue = index;
return;
}
break;
}
}
else
{
for (const TypeData& value : sIndexArg)
if (universalId == value.mName)
{
mType = value.mType;
mClass = value.mClass;
return;
}
}
throw std::runtime_error("invalid UniversalId: " + universalId);
}
CSMWorld::UniversalId::UniversalId(Type type)
: mType(type)
, mValue(std::monostate{})
{
for (const TypeData& value : sNoArg)
if (type == value.mType)
{
mClass = value.mClass;
return;
}
for (const TypeData& value : sIdArg)
if (type == value.mType)
{
mValue = std::string();
mClass = value.mClass;
return;
}
for (const TypeData& value : sIndexArg)
if (type == value.mType)
{
mValue = int{};
mClass = value.mClass;
return;
}
throw std::logic_error("invalid argument-less UniversalId type");
}
CSMWorld::UniversalId::UniversalId(Type type, const std::string& id)
: mType(type)
, mValue(id)
{
for (const TypeData& value : sIdArg)
if (type == value.mType)
{
mClass = value.mClass;
return;
}
throw std::logic_error("invalid ID argument UniversalId type: " + std::to_string(type));
}
CSMWorld::UniversalId::UniversalId(Type type, ESM::RefId id)
: mType(type)
, mValue(id)
{
for (const TypeData& value : sIdArg)
if (type == value.mType)
{
mClass = value.mClass;
return;
}
throw std::logic_error("invalid RefId argument UniversalId type: " + std::to_string(type));
}
CSMWorld::UniversalId::UniversalId(Type type, const UniversalId& id)
: mClass(getClassByType(type))
, mType(type)
, mValue(id.mValue)
{
}
CSMWorld::UniversalId::UniversalId(Type type, int index)
: mType(type)
, mValue(index)
{
for (const TypeData& value : sIndexArg)
if (type == value.mType)
{
mClass = value.mClass;
return;
}
throw std::logic_error("invalid index argument UniversalId type: " + std::to_string(type));
}
CSMWorld::UniversalId::Class CSMWorld::UniversalId::getClass() const
{
return mClass;
}
CSMWorld::UniversalId::ArgumentType CSMWorld::UniversalId::getArgumentType() const
{
return static_cast<CSMWorld::UniversalId::ArgumentType>(mValue.index());
}
CSMWorld::UniversalId::Type CSMWorld::UniversalId::getType() const
{
return mType;
}
const std::string& CSMWorld::UniversalId::getId() const
{
if (const std::string* result = std::get_if<std::string>(&mValue))
return *result;
if (const ESM::RefId* refId = std::get_if<ESM::RefId>(&mValue))
if (const ESM::StringRefId* result = refId->getIf<ESM::StringRefId>())
return result->getValue();
throw std::logic_error("invalid access to ID of " + ::toString(getArgumentType()) + " UniversalId");
}
int CSMWorld::UniversalId::getIndex() const
{
if (const int* result = std::get_if<int>(&mValue))
return *result;
throw std::logic_error("invalid access to index of " + ::toString(getArgumentType()) + " UniversalId");
}
ESM::RefId CSMWorld::UniversalId::getRefId() const
{
if (const ESM::RefId* result = std::get_if<ESM::RefId>(&mValue))
return *result;
throw std::logic_error("invalid access to RefId of " + ::toString(getArgumentType()) + " UniversalId");
}
std::string CSMWorld::UniversalId::getTypeName() const
{
const std::span<const TypeData> typeData = std::visit(GetTypeData{}, mValue);
for (const TypeData& value : typeData)
if (value.mType == mType)
return std::string(value.mName);
throw std::logic_error("failed to retrieve UniversalId type name");
}
std::string CSMWorld::UniversalId::toString() const
{
std::ostringstream stream;
stream << getTypeName();
std::visit(WriteToStream{ stream }, mValue);
return stream.str();
}
std::string CSMWorld::UniversalId::getIcon() const
{
const std::span<const TypeData> typeData = std::visit(GetTypeData{}, mValue);
for (const TypeData& value : typeData)
if (value.mType == mType)
return std::string(value.mIcon);
throw std::logic_error("failed to retrieve UniversalId type icon");
}
std::vector<CSMWorld::UniversalId::Type> CSMWorld::UniversalId::listReferenceableTypes()
{
std::vector<CSMWorld::UniversalId::Type> list;
for (const TypeData& value : sIdArg)
if (value.mClass == Class_RefRecord)
list.push_back(value.mType);
return list;
}
std::vector<CSMWorld::UniversalId::Type> CSMWorld::UniversalId::listTypes(int classes)
{
std::vector<CSMWorld::UniversalId::Type> list;
for (const TypeData& value : sNoArg)
if (value.mClass & classes)
list.push_back(value.mType);
for (const TypeData& value : sIdArg)
if (value.mClass & classes)
list.push_back(value.mType);
for (const TypeData& value : sIndexArg)
if (value.mClass & classes)
list.push_back(value.mType);
return list;
}
CSMWorld::UniversalId::Type CSMWorld::UniversalId::getParentType(Type type)
{
for (const TypeData& value : sIdArg)
if (type == value.mType)
{
if (value.mClass == Class_RefRecord)
return Type_Referenceables;
if (value.mClass == Class_SubRecord || value.mClass == Class_Record || value.mClass == Class_Resource)
{
if (type == Type_Cell_Missing)
return Type_Cells;
return static_cast<Type>(type - 1);
}
break;
}
return Type_None;
}
bool CSMWorld::operator==(const CSMWorld::UniversalId& left, const CSMWorld::UniversalId& right)
{
return std::tie(left.mClass, left.mType, left.mValue) == std::tie(right.mClass, right.mType, right.mValue);
}
bool CSMWorld::operator<(const UniversalId& left, const UniversalId& right)
{
return std::tie(left.mClass, left.mType, left.mValue) < std::tie(right.mClass, right.mType, right.mValue);
}
| 21,751
|
C++
|
.cpp
| 418
| 43.813397
| 120
| 0.645867
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,919
|
land.cpp
|
OpenMW_openmw/apps/opencs/model/world/land.cpp
|
#include "land.hpp"
#include <sstream>
#include <stdexcept>
#include <components/misc/strings/conversion.hpp>
namespace ESM
{
class ESMReader;
}
namespace CSMWorld
{
void Land::load(ESM::ESMReader& esm, bool& isDeleted)
{
ESM::Land::load(esm, isDeleted);
}
std::string Land::createUniqueRecordId(int x, int y)
{
std::ostringstream stream;
stream << "#" << x << " " << y;
return stream.str();
}
void Land::parseUniqueRecordId(const std::string& id, int& x, int& y)
{
size_t mid = id.find(' ');
if (mid == std::string::npos || id[0] != '#')
throw std::runtime_error("Invalid Land ID");
x = Misc::StringUtils::toNumeric<int>(id.substr(1, mid - 1), 0);
y = Misc::StringUtils::toNumeric<int>(id.substr(mid + 1), 0);
}
}
| 839
|
C++
|
.cpp
| 29
| 23.655172
| 73
| 0.597257
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,921
|
commanddispatcher.cpp
|
OpenMW_openmw/apps/opencs/model/world/commanddispatcher.cpp
|
#include "commanddispatcher.hpp"
#include <algorithm>
#include <cmath>
#include <memory>
#include <string>
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QObject>
#include <QVariant>
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/data.hpp>
#include <apps/opencs/model/world/idtablebase.hpp>
#include <apps/opencs/model/world/ref.hpp>
#include <apps/opencs/model/world/refcollection.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/misc/constants.hpp>
#include <components/misc/strings/lower.hpp>
#include "../doc/document.hpp"
#include "commandmacro.hpp"
#include "commands.hpp"
#include "idtable.hpp"
#include "idtableproxymodel.hpp"
#include "record.hpp"
std::vector<std::string> CSMWorld::CommandDispatcher::getDeletableRecords() const
{
std::vector<std::string> result;
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(mId));
int stateColumnIndex = model.findColumnIndex(Columns::ColumnId_Modification);
for (std::vector<std::string>::const_iterator iter(mSelection.begin()); iter != mSelection.end(); ++iter)
{
int row = model.getModelIndex(*iter, 0).row();
// check record state
RecordBase::State state
= static_cast<RecordBase::State>(model.data(model.index(row, stateColumnIndex)).toInt());
if (state == RecordBase::State_Deleted)
continue;
// check other columns (only relevant for a subset of the tables)
int dialogueTypeIndex = model.searchColumnIndex(Columns::ColumnId_DialogueType);
if (dialogueTypeIndex != -1)
{
int type = model.data(model.index(row, dialogueTypeIndex)).toInt();
if (type != ESM::Dialogue::Topic && type != ESM::Dialogue::Journal)
continue;
}
result.push_back(*iter);
}
return result;
}
std::vector<std::string> CSMWorld::CommandDispatcher::getRevertableRecords() const
{
std::vector<std::string> result;
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(mId));
/// \todo Reverting temporarily disabled on tables that support reordering, because
/// revert logic currently can not handle reordering.
if (model.getFeatures() & IdTable::Feature_ReorderWithinTopic)
return result;
int stateColumnIndex = model.findColumnIndex(Columns::ColumnId_Modification);
for (std::vector<std::string>::const_iterator iter(mSelection.begin()); iter != mSelection.end(); ++iter)
{
int row = model.getModelIndex(*iter, 0).row();
// check record state
RecordBase::State state
= static_cast<RecordBase::State>(model.data(model.index(row, stateColumnIndex)).toInt());
if (state == RecordBase::State_BaseOnly)
continue;
result.push_back(*iter);
}
return result;
}
CSMWorld::CommandDispatcher::CommandDispatcher(
CSMDoc::Document& document, const CSMWorld::UniversalId& id, QObject* parent)
: QObject(parent)
, mLocked(false)
, mDocument(document)
, mId(id)
{
}
void CSMWorld::CommandDispatcher::setEditLock(bool locked)
{
mLocked = locked;
}
void CSMWorld::CommandDispatcher::setSelection(const std::vector<std::string>& selection)
{
mSelection = selection;
std::sort(mSelection.begin(), mSelection.end(), Misc::StringUtils::CiComp{});
}
void CSMWorld::CommandDispatcher::setExtendedTypes(const std::vector<UniversalId>& types)
{
mExtendedTypes = types;
}
bool CSMWorld::CommandDispatcher::canDelete() const
{
if (mLocked)
return false;
return getDeletableRecords().size() != 0;
}
bool CSMWorld::CommandDispatcher::canRevert() const
{
if (mLocked)
return false;
return getRevertableRecords().size() != 0;
}
std::vector<CSMWorld::UniversalId> CSMWorld::CommandDispatcher::getExtendedTypes() const
{
std::vector<CSMWorld::UniversalId> tables;
if (mId == UniversalId::Type_Cells)
{
tables.push_back(mId);
tables.emplace_back(UniversalId::Type_References);
/// \todo add other cell-specific types
}
return tables;
}
void CSMWorld::CommandDispatcher::executeModify(
QAbstractItemModel* model, const QModelIndex& index, const QVariant& new_)
{
if (mLocked)
return;
std::unique_ptr<CSMWorld::UpdateCellCommand> modifyCell;
int columnId = model->data(index, ColumnBase::Role_ColumnId).toInt();
if (columnId == Columns::ColumnId_PositionXPos || columnId == Columns::ColumnId_PositionYPos)
{
const float oldPosition = model->data(index).toFloat();
// Modulate by cell size, update cell id if reference has been moved to a new cell
if (std::abs(std::fmod(oldPosition, Constants::CellSizeInUnits))
- std::abs(std::fmod(new_.toFloat(), Constants::CellSizeInUnits))
>= 0.5f)
{
IdTableProxyModel* proxy = dynamic_cast<IdTableProxyModel*>(model);
int row = proxy ? proxy->mapToSource(index).row() : index.row();
// This is not guaranteed to be the same as \a model, since a proxy could be used.
IdTable& model2 = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(mId));
int cellColumn = model2.searchColumnIndex(Columns::ColumnId_Cell);
if (cellColumn != -1)
{
QModelIndex cellIndex = model2.index(row, cellColumn);
std::string cellId = model2.data(cellIndex).toString().toUtf8().data();
if (cellId.find('#') != std::string::npos)
{
// Need to recalculate the cell
modifyCell = std::make_unique<UpdateCellCommand>(model2, row);
}
}
}
}
auto modifyData = std::make_unique<CSMWorld::ModifyCommand>(*model, index, new_);
if (modifyCell.get())
{
CommandMacro macro(mDocument.getUndoStack());
macro.push(modifyData.release());
macro.push(modifyCell.release());
}
else
mDocument.getUndoStack().push(modifyData.release());
}
void CSMWorld::CommandDispatcher::executeDelete()
{
if (mLocked)
return;
std::vector<std::string> rows = getDeletableRecords();
if (rows.empty())
return;
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(mId));
int columnIndex = model.findColumnIndex(Columns::ColumnId_Id);
CommandMacro macro(mDocument.getUndoStack(), rows.size() > 1 ? "Delete multiple records" : "");
for (std::vector<std::string>::const_iterator iter(rows.begin()); iter != rows.end(); ++iter)
{
std::string id = model.data(model.getModelIndex(*iter, columnIndex)).toString().toUtf8().constData();
if (mId.getType() == UniversalId::Type_Referenceables)
{
macro.push(new CSMWorld::DeleteCommand(model, id,
static_cast<CSMWorld::UniversalId::Type>(
model
.data(model.index(model.getModelIndex(id, columnIndex).row(),
model.findColumnIndex(CSMWorld::Columns::ColumnId_RecordType)))
.toInt())));
}
else
mDocument.getUndoStack().push(new CSMWorld::DeleteCommand(model, id));
}
}
void CSMWorld::CommandDispatcher::executeRevert()
{
if (mLocked)
return;
std::vector<std::string> rows = getRevertableRecords();
if (rows.empty())
return;
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(mId));
int columnIndex = model.findColumnIndex(Columns::ColumnId_Id);
CommandMacro macro(mDocument.getUndoStack(), rows.size() > 1 ? "Revert multiple records" : "");
for (std::vector<std::string>::const_iterator iter(rows.begin()); iter != rows.end(); ++iter)
{
std::string id = model.data(model.getModelIndex(*iter, columnIndex)).toString().toUtf8().constData();
macro.push(new CSMWorld::RevertCommand(model, id));
}
}
void CSMWorld::CommandDispatcher::executeExtendedDelete()
{
CommandMacro macro(
mDocument.getUndoStack(), mExtendedTypes.size() > 1 ? tr("Extended delete of multiple records") : "");
for (std::vector<UniversalId>::const_iterator iter(mExtendedTypes.begin()); iter != mExtendedTypes.end(); ++iter)
{
if (*iter == mId)
executeDelete();
else if (*iter == UniversalId::Type_References)
{
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(*iter));
const RefCollection& collection = mDocument.getData().getReferences();
int size = collection.getSize();
for (int i = size - 1; i >= 0; --i)
{
const Record<CellRef>& record = collection.getRecord(i);
if (record.mState == RecordBase::State_Deleted)
continue;
if (!std::binary_search(mSelection.begin(), mSelection.end(), record.get().mCell))
continue;
macro.push(new CSMWorld::DeleteCommand(model, record.get().mId.getRefIdString()));
}
}
}
}
void CSMWorld::CommandDispatcher::executeExtendedRevert()
{
CommandMacro macro(
mDocument.getUndoStack(), mExtendedTypes.size() > 1 ? tr("Extended revert of multiple records") : "");
for (std::vector<UniversalId>::const_iterator iter(mExtendedTypes.begin()); iter != mExtendedTypes.end(); ++iter)
{
if (*iter == mId)
executeRevert();
else if (*iter == UniversalId::Type_References)
{
IdTable& model = dynamic_cast<IdTable&>(*mDocument.getData().getTableModel(*iter));
const RefCollection& collection = mDocument.getData().getReferences();
int size = collection.getSize();
for (int i = size - 1; i >= 0; --i)
{
const Record<CellRef>& record = collection.getRecord(i);
if (!std::binary_search(mSelection.begin(), mSelection.end(), record.get().mCell))
continue;
macro.push(new CSMWorld::RevertCommand(model, record.get().mId.getRefIdString()));
}
}
}
}
| 10,413
|
C++
|
.cpp
| 247
| 34.700405
| 117
| 0.652622
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,922
|
cellselection.cpp
|
OpenMW_openmw/apps/opencs/model/world/cellselection.cpp
|
#include "cellselection.hpp"
#include "cellcoordinates.hpp"
#include <cmath>
#include <limits>
#include <stdexcept>
#include <utility>
CSMWorld::CellSelection::Iterator CSMWorld::CellSelection::begin() const
{
return mCells.begin();
}
CSMWorld::CellSelection::Iterator CSMWorld::CellSelection::end() const
{
return mCells.end();
}
bool CSMWorld::CellSelection::add(const CellCoordinates& coordinates)
{
return mCells.insert(coordinates).second;
}
void CSMWorld::CellSelection::remove(const CellCoordinates& coordinates)
{
mCells.erase(coordinates);
}
bool CSMWorld::CellSelection::has(const CellCoordinates& coordinates) const
{
return mCells.find(coordinates) != end();
}
int CSMWorld::CellSelection::getSize() const
{
return mCells.size();
}
CSMWorld::CellCoordinates CSMWorld::CellSelection::getCentre() const
{
if (mCells.empty())
throw std::logic_error("call of getCentre on empty cell selection");
double x = 0;
double y = 0;
for (Iterator iter = begin(); iter != end(); ++iter)
{
x += iter->getX();
y += iter->getY();
}
x /= mCells.size();
y /= mCells.size();
Iterator closest = begin();
double distance = std::numeric_limits<double>::max();
for (Iterator iter(begin()); iter != end(); ++iter)
{
double deltaX = x - iter->getX();
double deltaY = y - iter->getY();
double delta = std::sqrt(deltaX * deltaX + deltaY * deltaY);
if (delta < distance)
{
distance = delta;
closest = iter;
}
}
return *closest;
}
void CSMWorld::CellSelection::move(int x, int y)
{
Container moved;
for (Iterator iter = begin(); iter != end(); ++iter)
moved.insert(iter->move(x, y));
mCells.swap(moved);
}
| 1,804
|
C++
|
.cpp
| 65
| 23.430769
| 76
| 0.658522
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,923
|
resources.cpp
|
OpenMW_openmw/apps/opencs/model/world/resources.cpp
|
#include "resources.hpp"
#include <algorithm>
#include <sstream>
#include <stddef.h>
#include <stdexcept>
#include <string_view>
#include <utility>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/misc/strings/lower.hpp>
#include <components/vfs/manager.hpp>
#include <components/vfs/recursivedirectoryiterator.hpp>
CSMWorld::Resources::Resources(
const VFS::Manager* vfs, const std::string& baseDirectory, UniversalId::Type type, const char* const* extensions)
: mBaseDirectory(baseDirectory)
, mType(type)
{
recreate(vfs, extensions);
}
void CSMWorld::Resources::recreate(const VFS::Manager* vfs, const char* const* extensions)
{
mFiles.clear();
mIndex.clear();
size_t baseSize = mBaseDirectory.size();
for (const auto& filepath : vfs->getRecursiveDirectoryIterator())
{
const std::string_view view = filepath.view();
if (view.size() < baseSize + 1 || !view.starts_with(mBaseDirectory) || view[baseSize] != '/')
continue;
if (extensions)
{
const auto extensionIndex = view.find_last_of('.');
if (extensionIndex == std::string_view::npos)
continue;
std::string_view extension = view.substr(extensionIndex + 1);
int i = 0;
for (; extensions[i]; ++i)
if (extensions[i] == extension)
break;
if (!extensions[i])
continue;
}
std::string file(view.substr(baseSize + 1));
mFiles.push_back(file);
mIndex.emplace(std::move(file), static_cast<int>(mFiles.size()) - 1);
}
}
int CSMWorld::Resources::getSize() const
{
return static_cast<int>(mFiles.size());
}
std::string CSMWorld::Resources::getId(int index) const
{
return mFiles.at(index);
}
int CSMWorld::Resources::getIndex(const std::string& id) const
{
int index = searchId(id);
if (index == -1)
{
std::ostringstream stream;
stream << "Invalid resource: " << mBaseDirectory << '/' << id;
throw std::runtime_error(stream.str());
}
return index;
}
int CSMWorld::Resources::searchId(std::string_view id) const
{
std::string id2 = Misc::StringUtils::lowerCase(id);
std::replace(id2.begin(), id2.end(), '\\', '/');
std::map<std::string, int>::const_iterator iter = mIndex.find(id2);
if (iter == mIndex.end())
return -1;
return iter->second;
}
CSMWorld::UniversalId::Type CSMWorld::Resources::getType() const
{
return mType;
}
| 2,556
|
C++
|
.cpp
| 78
| 27.076923
| 117
| 0.641925
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,924
|
nestedtableproxymodel.cpp
|
OpenMW_openmw/apps/opencs/model/world/nestedtableproxymodel.cpp
|
#include "nestedtableproxymodel.hpp"
#include "idtree.hpp"
#include <cassert>
#include <apps/opencs/model/world/columnbase.hpp>
CSMWorld::NestedTableProxyModel::NestedTableProxyModel(
const QModelIndex& parent, ColumnBase::Display columnId, CSMWorld::IdTree* parentModel)
: mParentColumn(parent.column())
, mMainModel(parentModel)
{
const int parentRow = parent.row();
mId = std::string(parentModel->index(parentRow, 0).data().toString().toUtf8());
QAbstractProxyModel::setSourceModel(parentModel);
connect(mMainModel, &IdTree::rowsAboutToBeInserted, this, &NestedTableProxyModel::forwardRowsAboutToInserted);
connect(mMainModel, &IdTree::rowsInserted, this, &NestedTableProxyModel::forwardRowsInserted);
connect(mMainModel, &IdTree::rowsAboutToBeRemoved, this, &NestedTableProxyModel::forwardRowsAboutToRemoved);
connect(mMainModel, &IdTree::rowsRemoved, this, &NestedTableProxyModel::forwardRowsRemoved);
connect(mMainModel, &IdTree::resetStart, this, &NestedTableProxyModel::forwardResetStart);
connect(mMainModel, &IdTree::resetEnd, this, &NestedTableProxyModel::forwardResetEnd);
connect(mMainModel, &IdTree::dataChanged, this, &NestedTableProxyModel::forwardDataChanged);
}
QModelIndex CSMWorld::NestedTableProxyModel::mapFromSource(const QModelIndex& sourceIndex) const
{
const QModelIndex& testedParent = mMainModel->parent(sourceIndex);
const QModelIndex& parent = mMainModel->getNestedModelIndex(mId, mParentColumn);
if (testedParent == parent)
{
return createIndex(sourceIndex.row(), sourceIndex.column());
}
else
{
return QModelIndex();
}
}
QModelIndex CSMWorld::NestedTableProxyModel::mapToSource(const QModelIndex& proxyIndex) const
{
const QModelIndex& parent = mMainModel->getNestedModelIndex(mId, mParentColumn);
return mMainModel->index(proxyIndex.row(), proxyIndex.column(), parent);
}
int CSMWorld::NestedTableProxyModel::rowCount(const QModelIndex& index) const
{
assert(!index.isValid());
return mMainModel->rowCount(mMainModel->getModelIndex(mId, mParentColumn));
}
int CSMWorld::NestedTableProxyModel::columnCount(const QModelIndex& parent) const
{
assert(!parent.isValid());
return mMainModel->columnCount(mMainModel->getModelIndex(mId, mParentColumn));
}
QModelIndex CSMWorld::NestedTableProxyModel::index(int row, int column, const QModelIndex& parent) const
{
assert(!parent.isValid());
int numRows = rowCount(parent);
int numColumns = columnCount(parent);
if (row < 0 || row >= numRows || column < 0 || column >= numColumns)
return QModelIndex();
return createIndex(row, column);
}
QModelIndex CSMWorld::NestedTableProxyModel::parent(const QModelIndex& index) const
{
return QModelIndex();
}
QVariant CSMWorld::NestedTableProxyModel::headerData(int section, Qt::Orientation orientation, int role) const
{
return mMainModel->nestedHeaderData(mParentColumn, section, orientation, role);
}
QVariant CSMWorld::NestedTableProxyModel::data(const QModelIndex& index, int role) const
{
return mMainModel->data(mapToSource(index), role);
}
// NOTE: Due to mapToSouce(index) the dataChanged() signal resulting from setData() will have the
// source model's index values. The indicies need to be converted to the proxy space values.
// See forwardDataChanged()
bool CSMWorld::NestedTableProxyModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
return mMainModel->setData(mapToSource(index), value, role);
}
Qt::ItemFlags CSMWorld::NestedTableProxyModel::flags(const QModelIndex& index) const
{
return mMainModel->flags(mapToSource(index));
}
std::string CSMWorld::NestedTableProxyModel::getParentId() const
{
return mId;
}
int CSMWorld::NestedTableProxyModel::getParentColumn() const
{
return mParentColumn;
}
CSMWorld::IdTree* CSMWorld::NestedTableProxyModel::model() const
{
return mMainModel;
}
void CSMWorld::NestedTableProxyModel::forwardRowsAboutToInserted(const QModelIndex& parent, int first, int last)
{
if (indexIsParent(parent))
{
beginInsertRows(QModelIndex(), first, last);
}
}
void CSMWorld::NestedTableProxyModel::forwardRowsInserted(const QModelIndex& parent, int first, int last)
{
if (indexIsParent(parent))
{
endInsertRows();
}
}
bool CSMWorld::NestedTableProxyModel::indexIsParent(const QModelIndex& index)
{
return (index.isValid() && index.column() == mParentColumn
&& mMainModel->data(mMainModel->index(index.row(), 0)).toString().toUtf8().constData() == mId);
}
void CSMWorld::NestedTableProxyModel::forwardRowsAboutToRemoved(const QModelIndex& parent, int first, int last)
{
if (indexIsParent(parent))
{
beginRemoveRows(QModelIndex(), first, last);
}
}
void CSMWorld::NestedTableProxyModel::forwardRowsRemoved(const QModelIndex& parent, int first, int last)
{
if (indexIsParent(parent))
{
endRemoveRows();
}
}
void CSMWorld::NestedTableProxyModel::forwardResetStart(const QString& id)
{
if (id.toUtf8() == mId.c_str())
beginResetModel();
}
void CSMWorld::NestedTableProxyModel::forwardResetEnd(const QString& id)
{
if (id.toUtf8() == mId.c_str())
endResetModel();
}
void CSMWorld::NestedTableProxyModel::forwardDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
const QModelIndex& parent = mMainModel->getNestedModelIndex(mId, mParentColumn);
if (topLeft.column() <= parent.column() && bottomRight.column() >= parent.column())
{
emit dataChanged(index(0, 0), index(mMainModel->rowCount(parent) - 1, mMainModel->columnCount(parent) - 1));
}
else if (topLeft.parent() == parent && bottomRight.parent() == parent)
{
emit dataChanged(index(topLeft.row(), topLeft.column()), index(bottomRight.row(), bottomRight.column()));
}
}
| 5,898
|
C++
|
.cpp
| 147
| 36.510204
| 116
| 0.75696
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,925
|
regionmap.cpp
|
OpenMW_openmw/apps/opencs/model/world/regionmap.cpp
|
#include "regionmap.hpp"
#include <QApplication>
#include <QBrush>
#include <QModelIndex>
#include <QPalette>
#include <QSize>
#include <QVariant>
#include <algorithm>
#include <sstream>
#include <stdexcept>
#include <type_traits>
#include <apps/opencs/model/world/cell.hpp>
#include <apps/opencs/model/world/cellcoordinates.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/misc/strings/lower.hpp>
#include "data.hpp"
#include "universalid.hpp"
namespace CSMWorld
{
float getLandHeight(const CSMWorld::Cell& cell, CSMWorld::Data& data)
{
const IdCollection<Land>& lands = data.getLand();
int landIndex = lands.searchId(cell.mId);
if (landIndex == -1)
return 0.0f;
// If any part of land is above water, returns > 0 - otherwise returns < 0
const Land& land = lands.getRecord(landIndex).get();
if (land.getLandData())
return land.getLandData()->mMaxHeight - cell.mWater;
return 0.0f;
}
}
CSMWorld::RegionMap::CellDescription::CellDescription(const Record<Cell>& cell, float landHeight)
{
const Cell& cell2 = cell.get();
if (!cell2.isExterior())
throw std::logic_error("Interior cell in region map");
mMaxLandHeight = landHeight;
mDeleted = cell.isDeleted();
mRegion = cell2.mRegion;
mName = cell2.mName;
}
CSMWorld::CellCoordinates CSMWorld::RegionMap::getIndex(const QModelIndex& index) const
{
return mMin.move(index.column(), mMax.getY() - mMin.getY() - index.row() - 1);
}
QModelIndex CSMWorld::RegionMap::getIndex(const CellCoordinates& index) const
{
// I hate you, Qt API naming scheme!
return QAbstractTableModel::index(
mMax.getY() - mMin.getY() - (index.getY() - mMin.getY()) - 1, index.getX() - mMin.getX());
}
CSMWorld::CellCoordinates CSMWorld::RegionMap::getIndex(const Cell& cell) const
{
std::istringstream stream(cell.mId.getRefIdString());
char ignore;
int x = 0;
int y = 0;
stream >> ignore >> x >> y;
return CellCoordinates(x, y);
}
void CSMWorld::RegionMap::buildRegions()
{
const IdCollection<ESM::Region>& regions = mData.getRegions();
int size = regions.getSize();
for (int i = 0; i < size; ++i)
{
const Record<ESM::Region>& region = regions.getRecord(i);
if (!region.isDeleted())
mColours.insert(std::make_pair(region.get().mId, region.get().mMapColor));
}
}
void CSMWorld::RegionMap::buildMap()
{
const IdCollection<Cell>& cells = mData.getCells();
int size = cells.getSize();
for (int i = 0; i < size; ++i)
{
const Record<Cell>& cell = cells.getRecord(i);
const Cell& cell2 = cell.get();
if (cell2.isExterior())
{
CellDescription description(cell, getLandHeight(cell2, mData));
CellCoordinates index = getIndex(cell2);
mMap.insert(std::make_pair(index, description));
}
}
std::pair<CellCoordinates, CellCoordinates> mapSize = getSize();
mMin = mapSize.first;
mMax = mapSize.second;
}
void CSMWorld::RegionMap::addCell(const CellCoordinates& index, const CellDescription& description)
{
std::map<CellCoordinates, CellDescription>::iterator cell = mMap.find(index);
if (cell != mMap.end())
{
cell->second = description;
}
else
{
updateSize();
mMap.insert(std::make_pair(index, description));
}
QModelIndex index2 = getIndex(index);
dataChanged(index2, index2);
}
void CSMWorld::RegionMap::addCells(int start, int end)
{
const IdCollection<Cell>& cells = mData.getCells();
for (int i = start; i <= end; ++i)
{
const Record<Cell>& cell = cells.getRecord(i);
const Cell& cell2 = cell.get();
if (cell2.isExterior())
{
CellCoordinates index = getIndex(cell2);
CellDescription description(cell, getLandHeight(cell.get(), mData));
addCell(index, description);
}
}
}
void CSMWorld::RegionMap::removeCell(const CellCoordinates& index)
{
std::map<CellCoordinates, CellDescription>::iterator cell = mMap.find(index);
if (cell != mMap.end())
{
mMap.erase(cell);
QModelIndex index2 = getIndex(index);
dataChanged(index2, index2);
updateSize();
}
}
void CSMWorld::RegionMap::addRegion(const ESM::RefId& region, unsigned int colour)
{
mColours[region] = colour;
}
void CSMWorld::RegionMap::removeRegion(const ESM::RefId& region)
{
auto iter(mColours.find(region));
if (iter != mColours.end())
mColours.erase(iter);
}
void CSMWorld::RegionMap::updateRegions(const std::vector<ESM::RefId>& regions)
{
std::vector<ESM::RefId> regions2(regions);
std::sort(regions2.begin(), regions2.end());
for (std::map<CellCoordinates, CellDescription>::const_iterator iter(mMap.begin()); iter != mMap.end(); ++iter)
{
if (!iter->second.mRegion.empty()
&& std::find(regions2.begin(), regions2.end(), iter->second.mRegion) != regions2.end())
{
QModelIndex index = getIndex(iter->first);
dataChanged(index, index);
}
}
}
void CSMWorld::RegionMap::updateSize()
{
std::pair<CellCoordinates, CellCoordinates> size = getSize();
if (int diff = size.first.getX() - mMin.getX())
{
beginInsertColumns(QModelIndex(), 0, std::abs(diff) - 1);
mMin = CellCoordinates(size.first.getX(), mMin.getY());
endInsertColumns();
}
if (int diff = size.first.getY() - mMin.getY())
{
beginInsertRows(QModelIndex(), 0, std::abs(diff) - 1);
mMin = CellCoordinates(mMin.getX(), size.first.getY());
endInsertRows();
}
if (int diff = size.second.getX() - mMax.getX())
{
int columns = columnCount();
if (diff > 0)
beginInsertColumns(QModelIndex(), columns, columns + diff - 1);
else
beginRemoveColumns(QModelIndex(), columns + diff, columns - 1);
mMax = CellCoordinates(size.second.getX(), mMax.getY());
endInsertColumns();
}
if (int diff = size.second.getY() - mMax.getY())
{
int rows = rowCount();
if (diff > 0)
beginInsertRows(QModelIndex(), rows, rows + diff - 1);
else
beginRemoveRows(QModelIndex(), rows + diff, rows - 1);
mMax = CellCoordinates(mMax.getX(), size.second.getY());
endInsertRows();
}
}
std::pair<CSMWorld::CellCoordinates, CSMWorld::CellCoordinates> CSMWorld::RegionMap::getSize() const
{
const IdCollection<Cell>& cells = mData.getCells();
int size = cells.getSize();
CellCoordinates min(0, 0);
CellCoordinates max(0, 0);
for (int i = 0; i < size; ++i)
{
const Record<Cell>& cell = cells.getRecord(i);
const Cell& cell2 = cell.get();
if (cell2.isExterior())
{
CellCoordinates index = getIndex(cell2);
if (min == max)
{
min = index;
max = min.move(1, 1);
}
else
{
if (index.getX() < min.getX())
min = CellCoordinates(index.getX(), min.getY());
else if (index.getX() >= max.getX())
max = CellCoordinates(index.getX() + 1, max.getY());
if (index.getY() < min.getY())
min = CellCoordinates(min.getX(), index.getY());
else if (index.getY() >= max.getY())
max = CellCoordinates(max.getX(), index.getY() + 1);
}
}
}
return std::make_pair(min, max);
}
CSMWorld::RegionMap::RegionMap(Data& data)
: mData(data)
{
buildRegions();
buildMap();
QAbstractItemModel* regions = data.getTableModel(UniversalId(UniversalId::Type_Regions));
connect(regions, &QAbstractItemModel::rowsAboutToBeRemoved, this, &RegionMap::regionsAboutToBeRemoved);
connect(regions, &QAbstractItemModel::rowsInserted, this, &RegionMap::regionsInserted);
connect(regions, &QAbstractItemModel::dataChanged, this, &RegionMap::regionsChanged);
QAbstractItemModel* cells = data.getTableModel(UniversalId(UniversalId::Type_Cells));
connect(cells, &QAbstractItemModel::rowsAboutToBeRemoved, this, &RegionMap::cellsAboutToBeRemoved);
connect(cells, &QAbstractItemModel::rowsInserted, this, &RegionMap::cellsInserted);
connect(cells, &QAbstractItemModel::dataChanged, this, &RegionMap::cellsChanged);
}
int CSMWorld::RegionMap::rowCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return mMax.getY() - mMin.getY();
}
int CSMWorld::RegionMap::columnCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return mMax.getX() - mMin.getX();
}
QVariant CSMWorld::RegionMap::data(const QModelIndex& index, int role) const
{
if (role == Qt::SizeHintRole)
return QSize(16, 16);
if (role == Qt::BackgroundRole)
{
/// \todo GUI class in non-GUI code. Needs to be addressed eventually.
std::map<CellCoordinates, CellDescription>::const_iterator cell = mMap.find(getIndex(index));
if (cell != mMap.end())
{
if (cell->second.mDeleted)
return QBrush(Qt::red, Qt::DiagCrossPattern);
auto iter = mColours.find(cell->second.mRegion);
if (iter != mColours.end())
return QBrush(QColor(iter->second & 0xff, (iter->second >> 8) & 0xff, (iter->second >> 16) & 0xff),
cell->second.mMaxLandHeight > 0 ? Qt::SolidPattern : Qt::CrossPattern);
if (cell->second.mRegion.empty()) // no region
return QBrush(cell->second.mMaxLandHeight > 0 ? Qt::Dense3Pattern : Qt::Dense6Pattern);
return QBrush(Qt::red, Qt::Dense6Pattern); // invalid region
}
return QBrush(Qt::DiagCrossPattern);
}
if (role == Qt::ToolTipRole)
{
CellCoordinates cellIndex = getIndex(index);
std::ostringstream stream;
stream << cellIndex;
std::map<CellCoordinates, CellDescription>::const_iterator cell = mMap.find(cellIndex);
if (cell != mMap.end())
{
if (!cell->second.mName.empty())
stream << " " << cell->second.mName;
if (cell->second.mDeleted)
stream << " (deleted)";
if (!cell->second.mRegion.empty())
{
stream << "<br>";
auto iter = mColours.find(cell->second.mRegion);
if (iter != mColours.end())
stream << cell->second.mRegion;
else
stream << "<font color=red>" << cell->second.mRegion << "</font>";
}
}
else
stream << " (no cell)";
return QString::fromUtf8(stream.str().c_str());
}
if (role == Role_Region)
{
CellCoordinates cellIndex = getIndex(index);
std::map<CellCoordinates, CellDescription>::const_iterator cell = mMap.find(cellIndex);
if (cell != mMap.end() && !cell->second.mRegion.empty())
return QString::fromUtf8(cell->second.mRegion.getRefIdString().c_str());
}
if (role == Role_CellId)
{
CellCoordinates cellIndex = getIndex(index);
std::ostringstream stream;
stream << "#" << cellIndex.getX() << " " << cellIndex.getY();
return QString::fromUtf8(stream.str().c_str());
}
return QVariant();
}
Qt::ItemFlags CSMWorld::RegionMap::flags(const QModelIndex& index) const
{
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
void CSMWorld::RegionMap::regionsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
{
std::vector<ESM::RefId> update;
const IdCollection<ESM::Region>& regions = mData.getRegions();
for (int i = start; i <= end; ++i)
{
const Record<ESM::Region>& region = regions.getRecord(i);
update.push_back(region.get().mId);
removeRegion(region.get().mId);
}
updateRegions(update);
}
void CSMWorld::RegionMap::regionsInserted(const QModelIndex& parent, int start, int end)
{
std::vector<ESM::RefId> update;
const IdCollection<ESM::Region>& regions = mData.getRegions();
for (int i = start; i <= end; ++i)
{
const Record<ESM::Region>& region = regions.getRecord(i);
if (!region.isDeleted())
{
update.push_back(region.get().mId);
addRegion(region.get().mId, region.get().mMapColor);
}
}
updateRegions(update);
}
void CSMWorld::RegionMap::regionsChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
// Note: At this point an additional check could be inserted to see if there is any change to the
// columns we are interested in. If not we can exit the function here and avoid all updating.
std::vector<ESM::RefId> update;
const IdCollection<ESM::Region>& regions = mData.getRegions();
for (int i = topLeft.row(); i <= bottomRight.column(); ++i)
{
const Record<ESM::Region>& region = regions.getRecord(i);
update.push_back(region.get().mId);
if (!region.isDeleted())
addRegion(region.get().mId, region.get().mMapColor);
else
removeRegion(region.get().mId);
}
updateRegions(update);
}
void CSMWorld::RegionMap::cellsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
{
const IdCollection<Cell>& cells = mData.getCells();
for (int i = start; i <= end; ++i)
{
const Record<Cell>& cell = cells.getRecord(i);
const Cell& cell2 = cell.get();
if (cell2.isExterior())
removeCell(getIndex(cell2));
}
}
void CSMWorld::RegionMap::cellsInserted(const QModelIndex& parent, int start, int end)
{
addCells(start, end);
}
void CSMWorld::RegionMap::cellsChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
// Note: At this point an additional check could be inserted to see if there is any change to the
// columns we are interested in. If not we can exit the function here and avoid all updating.
addCells(topLeft.row(), bottomRight.row());
}
| 14,408
|
C++
|
.cpp
| 386
| 30.450777
| 115
| 0.632829
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,926
|
idtree.cpp
|
OpenMW_openmw/apps/opencs/model/world/idtree.cpp
|
#include "idtree.hpp"
#include "nestedtablewrapper.hpp"
#include "collectionbase.hpp"
#include "columnbase.hpp"
#include "nestedcollection.hpp"
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/idtable.hpp>
#include <stdexcept>
// NOTE: parent class still needs idCollection
CSMWorld::IdTree::IdTree(NestedCollection* nestedCollection, CollectionBase* idCollection, unsigned int features)
: IdTable(idCollection, features)
, mNestedCollection(nestedCollection)
{
}
int CSMWorld::IdTree::rowCount(const QModelIndex& parent) const
{
if (hasChildren(parent))
return mNestedCollection->getNestedRowsCount(parent.row(), parent.column());
return IdTable::rowCount(parent);
}
int CSMWorld::IdTree::columnCount(const QModelIndex& parent) const
{
if (hasChildren(parent))
return mNestedCollection->getNestedColumnsCount(parent.row(), parent.column());
return IdTable::columnCount(parent);
}
QVariant CSMWorld::IdTree::data(const QModelIndex& index, int role) const
{
if (!index.isValid())
return QVariant();
if (index.internalId() != 0)
{
std::pair<int, int> parentAddress(unfoldIndexAddress(index.internalId()));
const NestableColumn* parentColumn = mNestedCollection->getNestableColumn(parentAddress.second);
if (role == ColumnBase::Role_Display)
return parentColumn->nestedColumn(index.column()).mDisplayType;
if (role == ColumnBase::Role_ColumnId)
return parentColumn->nestedColumn(index.column()).mColumnId;
if (role == Qt::EditRole && !parentColumn->nestedColumn(index.column()).isEditable())
return QVariant();
if (role != Qt::DisplayRole && role != Qt::EditRole)
return QVariant();
return mNestedCollection->getNestedData(parentAddress.first, parentAddress.second, index.row(), index.column());
}
else
{
return IdTable::data(index, role);
}
}
QVariant CSMWorld::IdTree::nestedHeaderData(int section, int subSection, Qt::Orientation orientation, int role) const
{
if (section < 0 || section >= idCollection()->getColumns())
return QVariant();
const NestableColumn* parentColumn = mNestedCollection->getNestableColumn(section);
if (orientation == Qt::Vertical)
return QVariant();
if (role == Qt::DisplayRole)
return tr(parentColumn->nestedColumn(subSection).getTitle().c_str());
if (role == ColumnBase::Role_Flags)
return parentColumn->nestedColumn(subSection).mFlags;
if (role == ColumnBase::Role_Display)
return parentColumn->nestedColumn(subSection).mDisplayType;
if (role == ColumnBase::Role_ColumnId)
return parentColumn->nestedColumn(subSection).mColumnId;
return QVariant();
}
bool CSMWorld::IdTree::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (index.internalId() != 0)
{
if (idCollection()->getColumn(parent(index).column()).isEditable() && role == Qt::EditRole)
{
const std::pair<int, int>& parentAddress(unfoldIndexAddress(index.internalId()));
mNestedCollection->setNestedData(
parentAddress.first, parentAddress.second, value, index.row(), index.column());
emit dataChanged(index, index);
// Modifying a value can also change the Modified status of a record.
int stateColumn = searchColumnIndex(Columns::ColumnId_Modification);
if (stateColumn != -1)
{
QModelIndex stateIndex = this->index(index.parent().row(), stateColumn);
emit dataChanged(stateIndex, stateIndex);
}
return true;
}
else
return false;
}
return IdTable::setData(index, value, role);
}
Qt::ItemFlags CSMWorld::IdTree::flags(const QModelIndex& index) const
{
if (!index.isValid())
return Qt::ItemFlags();
if (index.internalId() != 0)
{
std::pair<int, int> parentAddress(unfoldIndexAddress(index.internalId()));
Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
if (mNestedCollection->getNestableColumn(parentAddress.second)->nestedColumn(index.column()).isEditable())
flags |= Qt::ItemIsEditable;
return flags;
}
else
return IdTable::flags(index);
}
bool CSMWorld::IdTree::removeRows(int row, int count, const QModelIndex& parent)
{
if (parent.isValid())
{
beginRemoveRows(parent, row, row + count - 1);
for (int i = 0; i < count; ++i)
{
mNestedCollection->removeNestedRows(parent.row(), parent.column(), row + i);
}
endRemoveRows();
emit dataChanged(CSMWorld::IdTree::index(parent.row(), 0),
CSMWorld::IdTree::index(parent.row(), idCollection()->getColumns() - 1));
return true;
}
else
return IdTable::removeRows(row, count, parent);
}
void CSMWorld::IdTree::addNestedRow(const QModelIndex& parent, int position)
{
if (!hasChildren(parent))
throw std::logic_error("Tried to set nested table, but index has no children");
int row = parent.row();
beginInsertRows(parent, position, position);
mNestedCollection->addNestedRow(row, parent.column(), position);
endInsertRows();
emit dataChanged(CSMWorld::IdTree::index(row, 0), CSMWorld::IdTree::index(row, idCollection()->getColumns() - 1));
}
QModelIndex CSMWorld::IdTree::index(int row, int column, const QModelIndex& parent) const
{
unsigned int encodedId = 0;
if (parent.isValid())
{
encodedId = this->foldIndexAddress(parent);
}
if (row < 0 || row >= rowCount(parent))
return QModelIndex();
if (column < 0 || column >= columnCount(parent))
return QModelIndex();
return createIndex(row, column, encodedId); // store internal id
}
QModelIndex CSMWorld::IdTree::getNestedModelIndex(const std::string& id, int column) const
{
return CSMWorld::IdTable::index(idCollection()->getIndex(ESM::RefId::stringRefId(id)), column);
}
QModelIndex CSMWorld::IdTree::parent(const QModelIndex& index) const
{
if (index.internalId() == 0) // 0 is used for indexs with invalid parent (top level data)
return QModelIndex();
unsigned int id = index.internalId();
const std::pair<int, int>& address(unfoldIndexAddress(id));
if (address.first >= this->rowCount() || address.second >= this->columnCount())
throw std::logic_error("Parent index is not present in the model");
return createIndex(address.first, address.second);
}
unsigned int CSMWorld::IdTree::foldIndexAddress(const QModelIndex& index) const
{
unsigned int out = index.row() * this->columnCount();
out += index.column();
return ++out;
}
std::pair<int, int> CSMWorld::IdTree::unfoldIndexAddress(unsigned int id) const
{
if (id == 0)
throw std::runtime_error("Attempt to unfold index id of the top level data cell");
--id;
int row = id / this->columnCount();
int column = id - row * this->columnCount();
return std::make_pair(row, column);
}
// FIXME: Not sure why this check is also needed?
//
// index.data().isValid() requires RefIdAdapter::getData() to return a valid QVariant for
// nested columns (refidadapterimp.hpp)
//
// Also see comments in refidadapter.hpp and refidadapterimp.hpp.
bool CSMWorld::IdTree::hasChildren(const QModelIndex& index) const
{
return (index.isValid() && index.internalId() == 0
&& mNestedCollection->getNestableColumn(index.column())->hasChildren() && index.data().isValid());
}
void CSMWorld::IdTree::setNestedTable(const QModelIndex& index, const CSMWorld::NestedTableWrapperBase& nestedTable)
{
if (!hasChildren(index))
throw std::logic_error("Tried to set nested table, but index has no children");
bool removeRowsMode = false;
if (nestedTable.size() != this->nestedTable(index)->size())
{
emit resetStart(this->index(index.row(), 0).data().toString());
removeRowsMode = true;
}
mNestedCollection->setNestedTable(index.row(), index.column(), nestedTable);
emit dataChanged(CSMWorld::IdTree::index(index.row(), 0),
CSMWorld::IdTree::index(index.row(), idCollection()->getColumns() - 1));
if (removeRowsMode)
{
emit resetEnd(this->index(index.row(), 0).data().toString());
}
}
CSMWorld::NestedTableWrapperBase* CSMWorld::IdTree::nestedTable(const QModelIndex& index) const
{
if (!hasChildren(index))
throw std::logic_error("Tried to retrieve nested table, but index has no children");
return mNestedCollection->nestedTable(index.row(), index.column());
}
int CSMWorld::IdTree::searchNestedColumnIndex(int parentColumn, Columns::ColumnId id)
{
return mNestedCollection->searchNestedColumnIndex(parentColumn, id);
}
int CSMWorld::IdTree::findNestedColumnIndex(int parentColumn, Columns::ColumnId id)
{
return mNestedCollection->findNestedColumnIndex(parentColumn, id);
}
| 9,056
|
C++
|
.cpp
| 217
| 36.069124
| 120
| 0.691624
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,927
|
nestedcoladapterimp.cpp
|
OpenMW_openmw/apps/opencs/model/world/nestedcoladapterimp.cpp
|
#include "nestedcoladapterimp.hpp"
#include <map>
#include <stdint.h>
#include <type_traits>
#include <utility>
#include <variant>
#include <apps/opencs/model/world/cell.hpp>
#include <apps/opencs/model/world/disabletag.hpp>
#include <apps/opencs/model/world/nestedtablewrapper.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm/attr.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadinfo.hpp>
#include <components/esm3/loadpgrd.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/variant.hpp>
#include "info.hpp"
#include "infoselectwrapper.hpp"
#include "pathgrid.hpp"
namespace CSMWorld
{
void PathgridPointListAdapter::addRow(Record<Pathgrid>& record, int position) const
{
Pathgrid pathgrid = record.get();
ESM::Pathgrid::PointList& points = pathgrid.mPoints;
// blank row
ESM::Pathgrid::Point point;
point.mX = 0;
point.mY = 0;
point.mZ = 0;
point.mAutogenerated = 0;
point.mConnectionNum = 0;
points.insert(points.begin() + position, point);
pathgrid.mData.mPoints = pathgrid.mPoints.size();
record.setModified(pathgrid);
}
void PathgridPointListAdapter::removeRow(Record<Pathgrid>& record, int rowToRemove) const
{
Pathgrid pathgrid = record.get();
ESM::Pathgrid::PointList& points = pathgrid.mPoints;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(points.size()))
throw std::runtime_error("index out of range");
// Do not remove dangling edges, does not work with current undo mechanism
// Do not automatically adjust indices, what would be done with dangling edges?
points.erase(points.begin() + rowToRemove);
pathgrid.mData.mPoints = pathgrid.mPoints.size();
record.setModified(pathgrid);
}
void PathgridPointListAdapter::setTable(Record<Pathgrid>& record, const NestedTableWrapperBase& nestedTable) const
{
Pathgrid pathgrid = record.get();
pathgrid.mPoints = static_cast<const NestedTableWrapper<ESM::Pathgrid::PointList>&>(nestedTable).mNestedTable;
pathgrid.mData.mPoints = pathgrid.mPoints.size();
record.setModified(pathgrid);
}
NestedTableWrapperBase* PathgridPointListAdapter::table(const Record<Pathgrid>& record) const
{
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<ESM::Pathgrid::PointList>(record.get().mPoints);
}
QVariant PathgridPointListAdapter::getData(const Record<Pathgrid>& record, int subRowIndex, int subColIndex) const
{
ESM::Pathgrid::Point point = record.get().mPoints[subRowIndex];
switch (subColIndex)
{
case 0:
return subRowIndex;
case 1:
return point.mX;
case 2:
return point.mY;
case 3:
return point.mZ;
default:
throw std::runtime_error("Pathgrid point subcolumn index out of range");
}
}
void PathgridPointListAdapter::setData(
Record<Pathgrid>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
Pathgrid pathgrid = record.get();
ESM::Pathgrid::Point point = pathgrid.mPoints[subRowIndex];
switch (subColIndex)
{
case 0:
return; // return without saving
case 1:
point.mX = value.toInt();
break;
case 2:
point.mY = value.toInt();
break;
case 3:
point.mZ = value.toInt();
break;
default:
throw std::runtime_error("Pathgrid point subcolumn index out of range");
}
pathgrid.mPoints[subRowIndex] = point;
record.setModified(pathgrid);
}
int PathgridPointListAdapter::getColumnsCount(const Record<Pathgrid>& record) const
{
return 4;
}
int PathgridPointListAdapter::getRowsCount(const Record<Pathgrid>& record) const
{
return static_cast<int>(record.get().mPoints.size());
}
void PathgridEdgeListAdapter::addRow(Record<Pathgrid>& record, int position) const
{
Pathgrid pathgrid = record.get();
ESM::Pathgrid::EdgeList& edges = pathgrid.mEdges;
// blank row
ESM::Pathgrid::Edge edge;
edge.mV0 = 0;
edge.mV1 = 0;
// NOTE: inserting a blank edge does not really make sense, perhaps this should be a
// logic_error exception
//
// Currently the code assumes that the end user to know what he/she is doing.
// e.g. Edges come in pairs, from points a->b and b->a
edges.insert(edges.begin() + position, edge);
record.setModified(pathgrid);
}
void PathgridEdgeListAdapter::removeRow(Record<Pathgrid>& record, int rowToRemove) const
{
Pathgrid pathgrid = record.get();
ESM::Pathgrid::EdgeList& edges = pathgrid.mEdges;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(edges.size()))
throw std::runtime_error("index out of range");
edges.erase(edges.begin() + rowToRemove);
record.setModified(pathgrid);
}
void PathgridEdgeListAdapter::setTable(Record<Pathgrid>& record, const NestedTableWrapperBase& nestedTable) const
{
Pathgrid pathgrid = record.get();
pathgrid.mEdges = static_cast<const NestedTableWrapper<ESM::Pathgrid::EdgeList>&>(nestedTable).mNestedTable;
record.setModified(pathgrid);
}
NestedTableWrapperBase* PathgridEdgeListAdapter::table(const Record<Pathgrid>& record) const
{
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<ESM::Pathgrid::EdgeList>(record.get().mEdges);
}
QVariant PathgridEdgeListAdapter::getData(const Record<Pathgrid>& record, int subRowIndex, int subColIndex) const
{
Pathgrid pathgrid = record.get();
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(pathgrid.mEdges.size()))
throw std::runtime_error("index out of range");
ESM::Pathgrid::Edge edge = pathgrid.mEdges[subRowIndex];
switch (subColIndex)
{
case 0:
return subRowIndex;
case 1:
return static_cast<uint>(edge.mV0);
case 2:
return static_cast<uint>(edge.mV1);
default:
throw std::runtime_error("Pathgrid edge subcolumn index out of range");
}
}
void PathgridEdgeListAdapter::setData(
Record<Pathgrid>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
Pathgrid pathgrid = record.get();
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(pathgrid.mEdges.size()))
throw std::runtime_error("index out of range");
ESM::Pathgrid::Edge edge = pathgrid.mEdges[subRowIndex];
switch (subColIndex)
{
case 0:
return; // return without saving
case 1:
edge.mV0 = value.toInt();
break;
case 2:
edge.mV1 = value.toInt();
break;
default:
throw std::runtime_error("Pathgrid edge subcolumn index out of range");
}
pathgrid.mEdges[subRowIndex] = edge;
record.setModified(pathgrid);
}
int PathgridEdgeListAdapter::getColumnsCount(const Record<Pathgrid>& record) const
{
return 3;
}
int PathgridEdgeListAdapter::getRowsCount(const Record<Pathgrid>& record) const
{
return static_cast<int>(record.get().mEdges.size());
}
void FactionReactionsAdapter::addRow(Record<ESM::Faction>& record, int position) const
{
ESM::Faction faction = record.get();
std::map<ESM::RefId, int>& reactions = faction.mReactions;
// blank row
reactions.insert(std::make_pair(ESM::RefId(), 0));
record.setModified(faction);
}
void FactionReactionsAdapter::removeRow(Record<ESM::Faction>& record, int rowToRemove) const
{
ESM::Faction faction = record.get();
std::map<ESM::RefId, int>& reactions = faction.mReactions;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(reactions.size()))
throw std::runtime_error("index out of range");
// FIXME: how to ensure that the map entries correspond to table indicies?
// WARNING: Assumed that the table view has the same order as std::map
auto iter = reactions.begin();
for (int i = 0; i < rowToRemove; ++i)
++iter;
reactions.erase(iter);
record.setModified(faction);
}
void FactionReactionsAdapter::setTable(
Record<ESM::Faction>& record, const NestedTableWrapperBase& nestedTable) const
{
ESM::Faction faction = record.get();
faction.mReactions
= static_cast<const NestedTableWrapper<std::map<ESM::RefId, int>>&>(nestedTable).mNestedTable;
record.setModified(faction);
}
NestedTableWrapperBase* FactionReactionsAdapter::table(const Record<ESM::Faction>& record) const
{
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::map<ESM::RefId, int>>(record.get().mReactions);
}
QVariant FactionReactionsAdapter::getData(
const Record<ESM::Faction>& record, int subRowIndex, int subColIndex) const
{
ESM::Faction faction = record.get();
std::map<ESM::RefId, int>& reactions = faction.mReactions;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(reactions.size()))
throw std::runtime_error("index out of range");
// FIXME: how to ensure that the map entries correspond to table indicies?
// WARNING: Assumed that the table view has the same order as std::map
auto iter = reactions.begin();
for (int i = 0; i < subRowIndex; ++i)
++iter;
switch (subColIndex)
{
case 0:
return QString((*iter).first.getRefIdString().c_str());
case 1:
return (*iter).second;
default:
throw std::runtime_error("Faction reactions subcolumn index out of range");
}
}
void FactionReactionsAdapter::setData(
Record<ESM::Faction>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Faction faction = record.get();
std::map<ESM::RefId, int>& reactions = faction.mReactions;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(reactions.size()))
throw std::runtime_error("index out of range");
// FIXME: how to ensure that the map entries correspond to table indicies?
// WARNING: Assumed that the table view has the same order as std::map
auto iter = reactions.begin();
for (int i = 0; i < subRowIndex; ++i)
++iter;
ESM::RefId factionId = (*iter).first;
int reaction = (*iter).second;
switch (subColIndex)
{
case 0:
{
reactions.erase(iter);
reactions.insert(
std::make_pair(ESM::RefId::stringRefId(value.toString().toUtf8().constData()), reaction));
break;
}
case 1:
{
reactions[factionId] = value.toInt();
break;
}
default:
throw std::runtime_error("Faction reactions subcolumn index out of range");
}
record.setModified(faction);
}
int FactionReactionsAdapter::getColumnsCount(const Record<ESM::Faction>& record) const
{
return 2;
}
int FactionReactionsAdapter::getRowsCount(const Record<ESM::Faction>& record) const
{
return static_cast<int>(record.get().mReactions.size());
}
void RegionSoundListAdapter::addRow(Record<ESM::Region>& record, int position) const
{
ESM::Region region = record.get();
std::vector<ESM::Region::SoundRef>& soundList = region.mSoundList;
// blank row
ESM::Region::SoundRef soundRef;
soundRef.mSound = ESM::RefId();
soundRef.mChance = 0;
soundList.insert(soundList.begin() + position, soundRef);
record.setModified(region);
}
void RegionSoundListAdapter::removeRow(Record<ESM::Region>& record, int rowToRemove) const
{
ESM::Region region = record.get();
std::vector<ESM::Region::SoundRef>& soundList = region.mSoundList;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(soundList.size()))
throw std::runtime_error("index out of range");
soundList.erase(soundList.begin() + rowToRemove);
record.setModified(region);
}
void RegionSoundListAdapter::setTable(Record<ESM::Region>& record, const NestedTableWrapperBase& nestedTable) const
{
ESM::Region region = record.get();
region.mSoundList
= static_cast<const NestedTableWrapper<std::vector<ESM::Region::SoundRef>>&>(nestedTable).mNestedTable;
record.setModified(region);
}
NestedTableWrapperBase* RegionSoundListAdapter::table(const Record<ESM::Region>& record) const
{
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Region::SoundRef>>(record.get().mSoundList);
}
QVariant RegionSoundListAdapter::getData(const Record<ESM::Region>& record, int subRowIndex, int subColIndex) const
{
const ESM::Region& region = record.get();
const std::vector<ESM::Region::SoundRef>& soundList = region.mSoundList;
const size_t index = static_cast<size_t>(subRowIndex);
if (subRowIndex < 0 || index >= soundList.size())
throw std::runtime_error("index out of range");
const ESM::Region::SoundRef& soundRef = soundList[subRowIndex];
switch (subColIndex)
{
case 0:
return QString(soundRef.mSound.getRefIdString().c_str());
case 1:
return soundRef.mChance;
case 2:
{
float probability = 1.f;
for (size_t i = 0; i < index; ++i)
{
const float p = std::min(soundList[i].mChance / 100.f, 1.f);
probability *= 1.f - p;
}
probability *= std::min(soundRef.mChance / 100.f, 1.f) * 100.f;
return QString("%1%").arg(probability, 0, 'f', 2);
}
default:
throw std::runtime_error("Region sounds subcolumn index out of range");
}
}
void RegionSoundListAdapter::setData(
Record<ESM::Region>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Region region = record.get();
std::vector<ESM::Region::SoundRef>& soundList = region.mSoundList;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(soundList.size()))
throw std::runtime_error("index out of range");
ESM::Region::SoundRef soundRef = soundList[subRowIndex];
switch (subColIndex)
{
case 0:
soundRef.mSound = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
break;
case 1:
soundRef.mChance = static_cast<unsigned char>(value.toInt());
break;
default:
throw std::runtime_error("Region sounds subcolumn index out of range");
}
region.mSoundList[subRowIndex] = soundRef;
record.setModified(region);
}
int RegionSoundListAdapter::getColumnsCount(const Record<ESM::Region>& record) const
{
return 3;
}
int RegionSoundListAdapter::getRowsCount(const Record<ESM::Region>& record) const
{
return static_cast<int>(record.get().mSoundList.size());
}
void InfoListAdapter::addRow(Record<Info>& record, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void InfoListAdapter::removeRow(Record<Info>& record, int rowToRemove) const
{
throw std::logic_error("cannot remove a row to a fixed table");
}
void InfoListAdapter::setTable(Record<Info>& record, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
NestedTableWrapperBase* InfoListAdapter::table(const Record<Info>& record) const
{
throw std::logic_error("table operation not supported");
}
QVariant InfoListAdapter::getData(const Record<Info>& record, int subRowIndex, int subColIndex) const
{
Info info = record.get();
if (subColIndex == 0)
return QString(info.mResultScript.c_str());
else
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
void InfoListAdapter::setData(Record<Info>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
Info info = record.get();
if (subColIndex == 0)
info.mResultScript = value.toString().toStdString();
else
throw std::runtime_error("Trying to access non-existing column in the nested table!");
record.setModified(info);
}
int InfoListAdapter::getColumnsCount(const Record<Info>& record) const
{
return 1;
}
int InfoListAdapter::getRowsCount(const Record<Info>& record) const
{
return 1; // fixed at size 1
}
void InfoConditionAdapter::addRow(Record<Info>& record, int position) const
{
Info info = record.get();
auto& conditions = info.mSelects;
// default row
ESM::DialogueCondition condStruct;
condStruct.mIndex = conditions.size();
conditions.insert(conditions.begin() + position, condStruct);
record.setModified(info);
}
void InfoConditionAdapter::removeRow(Record<Info>& record, int rowToRemove) const
{
Info info = record.get();
auto& conditions = info.mSelects;
if (rowToRemove < 0 || rowToRemove >= static_cast<int>(conditions.size()))
throw std::runtime_error("index out of range");
conditions.erase(conditions.begin() + rowToRemove);
record.setModified(info);
}
void InfoConditionAdapter::setTable(Record<Info>& record, const NestedTableWrapperBase& nestedTable) const
{
Info info = record.get();
info.mSelects
= static_cast<const NestedTableWrapper<std::vector<ESM::DialogueCondition>>&>(nestedTable).mNestedTable;
record.setModified(info);
}
NestedTableWrapperBase* InfoConditionAdapter::table(const Record<Info>& record) const
{
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::DialogueCondition>>(record.get().mSelects);
}
QVariant InfoConditionAdapter::getData(const Record<Info>& record, int subRowIndex, int subColIndex) const
{
Info info = record.get();
auto& conditions = info.mSelects;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(conditions.size()))
throw std::runtime_error("index out of range");
ConstInfoSelectWrapper infoSelectWrapper(conditions[subRowIndex]);
switch (subColIndex)
{
case 0:
{
return infoSelectWrapper.getFunctionName();
}
case 1:
{
if (infoSelectWrapper.hasVariable())
return QString(infoSelectWrapper.getVariableName().c_str());
else
return "";
}
case 2:
{
return infoSelectWrapper.getRelationType() - ESM::DialogueCondition::Comp_Eq;
}
case 3:
{
return infoSelectWrapper.getValue();
}
default:
throw std::runtime_error("Info condition subcolumn index out of range");
}
}
void InfoConditionAdapter::setData(
Record<Info>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
Info info = record.get();
auto& conditions = info.mSelects;
if (subRowIndex < 0 || subRowIndex >= static_cast<int>(conditions.size()))
throw std::runtime_error("index out of range");
InfoSelectWrapper infoSelectWrapper(conditions[subRowIndex]);
bool conversionResult = false;
switch (subColIndex)
{
case 0: // Function
{
infoSelectWrapper.setFunctionName(static_cast<ESM::DialogueCondition::Function>(value.toInt()));
break;
}
case 1: // Variable
{
infoSelectWrapper.setVariableName(value.toString().toUtf8().constData());
break;
}
case 2: // Relation
{
infoSelectWrapper.setRelationType(
static_cast<ESM::DialogueCondition::Comparison>(value.toInt() + ESM::DialogueCondition::Comp_Eq));
break;
}
case 3: // Value
{
switch (infoSelectWrapper.getComparisonType())
{
case ConstInfoSelectWrapper::Comparison_Numeric:
{
// QVariant seems to have issues converting 0
if ((value.toInt(&conversionResult) && conversionResult) || value.toString().compare("0") == 0)
{
infoSelectWrapper.setValue(value.toInt());
}
else if (value.toFloat(&conversionResult) && conversionResult)
{
infoSelectWrapper.setValue(value.toFloat());
}
break;
}
case ConstInfoSelectWrapper::Comparison_Boolean:
case ConstInfoSelectWrapper::Comparison_Integer:
{
if ((value.toInt(&conversionResult) && conversionResult) || value.toString().compare("0") == 0)
{
infoSelectWrapper.setValue(value.toInt());
}
break;
}
default:
break;
}
break;
}
default:
throw std::runtime_error("Info condition subcolumn index out of range");
}
record.setModified(info);
}
int InfoConditionAdapter::getColumnsCount(const Record<Info>& record) const
{
return 4;
}
int InfoConditionAdapter::getRowsCount(const Record<Info>& record) const
{
return static_cast<int>(record.get().mSelects.size());
}
void RaceAttributeAdapter::addRow(Record<ESM::Race>& record, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void RaceAttributeAdapter::removeRow(Record<ESM::Race>& record, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void RaceAttributeAdapter::setTable(Record<ESM::Race>& record, const NestedTableWrapperBase& nestedTable) const
{
ESM::Race race = record.get();
race.mData = static_cast<const NestedTableWrapper<std::vector<ESM::Race::RADTstruct>>&>(nestedTable)
.mNestedTable.at(0);
record.setModified(race);
}
NestedTableWrapperBase* RaceAttributeAdapter::table(const Record<ESM::Race>& record) const
{
std::vector<ESM::Race::RADTstruct> wrap;
wrap.push_back(record.get().mData);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Race::RADTstruct>>(wrap);
}
QVariant RaceAttributeAdapter::getData(const Record<ESM::Race>& record, int subRowIndex, int subColIndex) const
{
ESM::Race race = record.get();
ESM::RefId attribute = ESM::Attribute::indexToRefId(subRowIndex);
if (attribute.empty())
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
return subRowIndex;
case 1:
return race.mData.getAttribute(attribute, true);
case 2:
return race.mData.getAttribute(attribute, false);
default:
throw std::runtime_error("Race Attribute subcolumn index out of range");
}
}
void RaceAttributeAdapter::setData(
Record<ESM::Race>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Race race = record.get();
ESM::RefId attribute = ESM::Attribute::indexToRefId(subRowIndex);
if (attribute.empty())
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
return; // throw an exception here?
case 1:
race.mData.setAttribute(attribute, true, value.toInt());
break;
case 2:
race.mData.setAttribute(attribute, false, value.toInt());
break;
default:
throw std::runtime_error("Race Attribute subcolumn index out of range");
}
record.setModified(race);
}
int RaceAttributeAdapter::getColumnsCount(const Record<ESM::Race>& record) const
{
return 3; // attrib, male, female
}
int RaceAttributeAdapter::getRowsCount(const Record<ESM::Race>& record) const
{
return ESM::Attribute::Length; // there are 8 attributes
}
void RaceSkillsBonusAdapter::addRow(Record<ESM::Race>& record, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void RaceSkillsBonusAdapter::removeRow(Record<ESM::Race>& record, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void RaceSkillsBonusAdapter::setTable(Record<ESM::Race>& record, const NestedTableWrapperBase& nestedTable) const
{
ESM::Race race = record.get();
race.mData = static_cast<const NestedTableWrapper<std::vector<ESM::Race::RADTstruct>>&>(nestedTable)
.mNestedTable.at(0);
record.setModified(race);
}
NestedTableWrapperBase* RaceSkillsBonusAdapter::table(const Record<ESM::Race>& record) const
{
std::vector<ESM::Race::RADTstruct> wrap;
wrap.push_back(record.get().mData);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Race::RADTstruct>>(wrap);
}
QVariant RaceSkillsBonusAdapter::getData(const Record<ESM::Race>& record, int subRowIndex, int subColIndex) const
{
ESM::Race race = record.get();
if (subRowIndex < 0 || static_cast<size_t>(subRowIndex) >= race.mData.mBonus.size())
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
return race.mData.mBonus[subRowIndex].mSkill; // can be -1
case 1:
return race.mData.mBonus[subRowIndex].mBonus;
default:
throw std::runtime_error("Race skill bonus subcolumn index out of range");
}
}
void RaceSkillsBonusAdapter::setData(
Record<ESM::Race>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Race race = record.get();
if (subRowIndex < 0 || static_cast<size_t>(subRowIndex) >= race.mData.mBonus.size())
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
race.mData.mBonus[subRowIndex].mSkill = value.toInt();
break; // can be -1
case 1:
race.mData.mBonus[subRowIndex].mBonus = value.toInt();
break;
default:
throw std::runtime_error("Race skill bonus subcolumn index out of range");
}
record.setModified(race);
}
int RaceSkillsBonusAdapter::getColumnsCount(const Record<ESM::Race>& record) const
{
return 2; // skill, bonus
}
int RaceSkillsBonusAdapter::getRowsCount(const Record<ESM::Race>& record) const
{
return record.get().mData.mBonus.size();
}
void CellListAdapter::addRow(Record<CSMWorld::Cell>& record, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void CellListAdapter::removeRow(Record<CSMWorld::Cell>& record, int rowToRemove) const
{
throw std::logic_error("cannot remove a row to a fixed table");
}
void CellListAdapter::setTable(Record<CSMWorld::Cell>& record, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
NestedTableWrapperBase* CellListAdapter::table(const Record<CSMWorld::Cell>& record) const
{
throw std::logic_error("table operation not supported");
}
QVariant CellListAdapter::getData(const Record<CSMWorld::Cell>& record, int subRowIndex, int subColIndex) const
{
CSMWorld::Cell cell = record.get();
bool isInterior = (cell.mData.mFlags & ESM::Cell::Interior) != 0;
bool behaveLikeExterior = (cell.mData.mFlags & ESM::Cell::QuasiEx) != 0;
bool interiorWater = (cell.mData.mFlags & ESM::Cell::HasWater) != 0;
switch (subColIndex)
{
case 0:
return isInterior;
// While the ambient information is not necessarily valid if the subrecord wasn't loaded,
// the user should still be allowed to edit it
case 1:
return (isInterior && !behaveLikeExterior) ? cell.mAmbi.mAmbient : DisableTag::getVariant();
case 2:
return (isInterior && !behaveLikeExterior) ? cell.mAmbi.mSunlight : DisableTag::getVariant();
case 3:
return (isInterior && !behaveLikeExterior) ? cell.mAmbi.mFog : DisableTag::getVariant();
case 4:
return (isInterior && !behaveLikeExterior) ? cell.mAmbi.mFogDensity : DisableTag::getVariant();
case 5:
{
if (isInterior && interiorWater)
return cell.mWater;
else
return DisableTag::getVariant();
}
case 6:
return isInterior ? DisableTag::getVariant() : cell.mMapColor; // TODO: how to select?
// case 7: return isInterior ?
// behaveLikeExterior : DisableTag::getVariant();
default:
throw std::runtime_error("Cell subcolumn index out of range");
}
}
void CellListAdapter::setData(
Record<CSMWorld::Cell>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
CSMWorld::Cell cell = record.get();
bool isInterior = (cell.mData.mFlags & ESM::Cell::Interior) != 0;
bool behaveLikeExterior = (cell.mData.mFlags & ESM::Cell::QuasiEx) != 0;
bool interiorWater = (cell.mData.mFlags & ESM::Cell::HasWater) != 0;
switch (subColIndex)
{
case 0:
{
if (value.toBool())
cell.mData.mFlags |= ESM::Cell::Interior;
else
cell.mData.mFlags &= ~ESM::Cell::Interior;
break;
}
case 1:
{
if (isInterior && !behaveLikeExterior)
{
cell.mAmbi.mAmbient = static_cast<int32_t>(value.toInt());
cell.setHasAmbient(true);
}
else
return; // return without saving
break;
}
case 2:
{
if (isInterior && !behaveLikeExterior)
{
cell.mAmbi.mSunlight = static_cast<int32_t>(value.toInt());
cell.setHasAmbient(true);
}
else
return; // return without saving
break;
}
case 3:
{
if (isInterior && !behaveLikeExterior)
{
cell.mAmbi.mFog = static_cast<int32_t>(value.toInt());
cell.setHasAmbient(true);
}
else
return; // return without saving
break;
}
case 4:
{
if (isInterior && !behaveLikeExterior)
{
cell.mAmbi.mFogDensity = value.toFloat();
cell.setHasAmbient(true);
}
else
return; // return without saving
break;
}
case 5:
{
if (isInterior && interiorWater)
{
cell.mWater = value.toFloat();
cell.setHasWaterHeightSub(true);
}
else
return; // return without saving
break;
}
case 6:
{
if (!isInterior)
cell.mMapColor = value.toInt();
else
return; // return without saving
break;
}
#if 0
// redundant since this flag is shown in the main table as "Interior Sky"
// keep here for documenting the logic based on vanilla
case 7:
{
if (isInterior)
{
if (value.toBool())
cell.mData.mFlags |= ESM::Cell::QuasiEx;
else
cell.mData.mFlags &= ~ESM::Cell::QuasiEx;
}
else
return; // return without saving
break;
}
#endif
default:
throw std::runtime_error("Cell subcolumn index out of range");
}
record.setModified(cell);
}
int CellListAdapter::getColumnsCount(const Record<CSMWorld::Cell>& record) const
{
return 7;
}
int CellListAdapter::getRowsCount(const Record<CSMWorld::Cell>& record) const
{
return 1; // fixed at size 1
}
void RegionWeatherAdapter::addRow(Record<ESM::Region>& record, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void RegionWeatherAdapter::removeRow(Record<ESM::Region>& record, int rowToRemove) const
{
throw std::logic_error("cannot remove a row from a fixed table");
}
void RegionWeatherAdapter::setTable(Record<ESM::Region>& record, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
NestedTableWrapperBase* RegionWeatherAdapter::table(const Record<ESM::Region>& record) const
{
throw std::logic_error("table operation not supported");
}
QVariant RegionWeatherAdapter::getData(const Record<ESM::Region>& record, int subRowIndex, int subColIndex) const
{
const char* WeatherNames[]
= { "Clear", "Cloudy", "Fog", "Overcast", "Rain", "Thunder", "Ash", "Blight", "Snow", "Blizzard" };
const ESM::Region& region = record.get();
if (subColIndex == 0 && subRowIndex >= 0 && subRowIndex < 10)
{
return WeatherNames[subRowIndex];
}
else if (subColIndex == 1)
{
if (subRowIndex >= 0 && static_cast<size_t>(subRowIndex) < region.mData.mProbabilities.size())
return region.mData.mProbabilities[subRowIndex];
}
throw std::runtime_error("index out of range");
}
void RegionWeatherAdapter::setData(
Record<ESM::Region>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Region region = record.get();
uint8_t chance = static_cast<uint8_t>(value.toInt());
if (subColIndex == 1)
{
region.mData.mProbabilities.at(subRowIndex) = chance;
record.setModified(region);
}
}
int RegionWeatherAdapter::getColumnsCount(const Record<ESM::Region>& record) const
{
return 2;
}
int RegionWeatherAdapter::getRowsCount(const Record<ESM::Region>& record) const
{
return 10;
}
void FactionRanksAdapter::addRow(Record<ESM::Faction>& record, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void FactionRanksAdapter::removeRow(Record<ESM::Faction>& record, int rowToRemove) const
{
throw std::logic_error("cannot remove a row from a fixed table");
}
void FactionRanksAdapter::setTable(Record<ESM::Faction>& record, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
NestedTableWrapperBase* FactionRanksAdapter::table(const Record<ESM::Faction>& record) const
{
throw std::logic_error("table operation not supported");
}
QVariant FactionRanksAdapter::getData(const Record<ESM::Faction>& record, int subRowIndex, int subColIndex) const
{
const ESM::Faction& faction = record.get();
const auto& rankData = faction.mData.mRankData.at(subRowIndex);
switch (subColIndex)
{
case 0:
return QString(faction.mRanks[subRowIndex].c_str());
case 1:
return rankData.mAttribute1;
case 2:
return rankData.mAttribute2;
case 3:
return rankData.mPrimarySkill;
case 4:
return rankData.mFavouredSkill;
case 5:
return rankData.mFactReaction;
default:
throw std::runtime_error("Rank subcolumn index out of range");
}
}
void FactionRanksAdapter::setData(
Record<ESM::Faction>& record, const QVariant& value, int subRowIndex, int subColIndex) const
{
ESM::Faction faction = record.get();
auto& rankData = faction.mData.mRankData.at(subRowIndex);
switch (subColIndex)
{
case 0:
faction.mRanks[subRowIndex] = value.toString().toUtf8().constData();
break;
case 1:
rankData.mAttribute1 = value.toInt();
break;
case 2:
rankData.mAttribute2 = value.toInt();
break;
case 3:
rankData.mPrimarySkill = value.toInt();
break;
case 4:
rankData.mFavouredSkill = value.toInt();
break;
case 5:
rankData.mFactReaction = value.toInt();
break;
default:
throw std::runtime_error("Rank index out of range");
}
record.setModified(faction);
}
int FactionRanksAdapter::getColumnsCount(const Record<ESM::Faction>& record) const
{
return 6;
}
int FactionRanksAdapter::getRowsCount(const Record<ESM::Faction>& record) const
{
return 10;
}
}
| 40,139
|
C++
|
.cpp
| 983
| 30.236012
| 119
| 0.596657
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,928
|
columnimp.cpp
|
OpenMW_openmw/apps/opencs/model/world/columnimp.cpp
|
#include "columnimp.hpp"
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/disabletag.hpp>
#include <apps/opencs/model/world/land.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadland.hpp>
#include <components/esm3/loadltex.hpp>
#include <components/esm3/loadmgef.hpp>
#include <algorithm>
#include <stdexcept>
namespace CSMWorld
{
namespace
{
struct GetStringId
{
std::string operator()(ESM::EmptyRefId /*value*/) const { return std::string(); }
std::string operator()(ESM::StringRefId value) const { return value.getValue(); }
std::string operator()(ESM::FormId value) const { return value.toString("FormId:"); }
std::string operator()(ESM::IndexRefId value) const
{
switch (value.getRecordType())
{
case ESM::REC_MGEF:
return std::string(ESM::MagicEffect::sIndexNames[value.getValue()]);
default:
break;
}
return value.toDebugString();
}
template <class T>
std::string operator()(const T& value) const
{
return value.toDebugString();
}
};
}
/* LandTextureIndexColumn */
LandTextureIndexColumn::LandTextureIndexColumn()
: Column<ESM::LandTexture>(Columns::ColumnId_TextureIndex, ColumnBase::Display_Integer)
{
}
QVariant LandTextureIndexColumn::get(const Record<ESM::LandTexture>& record) const
{
return record.get().mIndex;
}
bool LandTextureIndexColumn::isEditable() const
{
return false;
}
/* LandPluginIndexColumn */
LandPluginIndexColumn::LandPluginIndexColumn()
: Column<Land>(Columns::ColumnId_PluginIndex, ColumnBase::Display_Integer, 0)
{
}
QVariant LandPluginIndexColumn::get(const Record<Land>& record) const
{
return record.get().getPlugin();
}
bool LandPluginIndexColumn::isEditable() const
{
return false;
}
/* LandNormalsColumn */
LandNormalsColumn::LandNormalsColumn()
: Column<Land>(Columns::ColumnId_LandNormalsIndex, ColumnBase::Display_String, 0)
{
}
QVariant LandNormalsColumn::get(const Record<Land>& record) const
{
const int Size = Land::LAND_NUM_VERTS * 3;
const Land& land = record.get();
DataType values(Size, 0);
if (land.isDataLoaded(Land::DATA_VNML))
{
for (int i = 0; i < Size; ++i)
values[i] = land.getLandData()->mNormals[i];
}
QVariant variant;
variant.setValue(values);
return variant;
}
void LandNormalsColumn::set(Record<Land>& record, const QVariant& data)
{
DataType values = data.value<DataType>();
if (values.size() != Land::LAND_NUM_VERTS * 3)
throw std::runtime_error("invalid land normals data");
Land copy = record.get();
copy.add(Land::DATA_VNML);
for (int i = 0; i < values.size(); ++i)
{
copy.getLandData()->mNormals[i] = values[i];
}
record.setModified(copy);
}
bool LandNormalsColumn::isEditable() const
{
return true;
}
/* LandHeightsColumn */
LandHeightsColumn::LandHeightsColumn()
: Column<Land>(Columns::ColumnId_LandHeightsIndex, ColumnBase::Display_String, 0)
{
}
QVariant LandHeightsColumn::get(const Record<Land>& record) const
{
const int Size = Land::LAND_NUM_VERTS;
const Land& land = record.get();
DataType values(Size, 0);
if (land.isDataLoaded(Land::DATA_VHGT))
{
for (int i = 0; i < Size; ++i)
values[i] = land.getLandData()->mHeights[i];
}
QVariant variant;
variant.setValue(values);
return variant;
}
void LandHeightsColumn::set(Record<Land>& record, const QVariant& data)
{
DataType values = data.value<DataType>();
if (values.size() != Land::LAND_NUM_VERTS)
throw std::runtime_error("invalid land heights data");
Land copy = record.get();
copy.add(Land::DATA_VHGT);
for (int i = 0; i < values.size(); ++i)
{
copy.getLandData()->mHeights[i] = values[i];
}
copy.mFlags |= Land::Flag_HeightsNormals;
record.setModified(copy);
}
bool LandHeightsColumn::isEditable() const
{
return true;
}
/* LandColoursColumn */
LandColoursColumn::LandColoursColumn()
: Column<Land>(Columns::ColumnId_LandColoursIndex, ColumnBase::Display_String, 0)
{
}
QVariant LandColoursColumn::get(const Record<Land>& record) const
{
const int Size = Land::LAND_NUM_VERTS * 3;
const Land& land = record.get();
DataType values(Size, 0);
if (land.isDataLoaded(Land::DATA_VCLR))
{
for (int i = 0; i < Size; ++i)
values[i] = land.getLandData()->mColours[i];
}
QVariant variant;
variant.setValue(values);
return variant;
}
void LandColoursColumn::set(Record<Land>& record, const QVariant& data)
{
DataType values = data.value<DataType>();
if (values.size() != Land::LAND_NUM_VERTS * 3)
throw std::runtime_error("invalid land colours data");
Land copy = record.get();
copy.add(Land::DATA_VCLR);
for (int i = 0; i < values.size(); ++i)
{
copy.getLandData()->mColours[i] = values[i];
}
copy.mFlags |= Land::Flag_Colors;
record.setModified(copy);
}
bool LandColoursColumn::isEditable() const
{
return true;
}
/* LandTexturesColumn */
LandTexturesColumn::LandTexturesColumn()
: Column<Land>(Columns::ColumnId_LandTexturesIndex, ColumnBase::Display_String, 0)
{
}
QVariant LandTexturesColumn::get(const Record<Land>& record) const
{
const int Size = Land::LAND_NUM_TEXTURES;
const Land& land = record.get();
DataType values(Size, 0);
if (land.isDataLoaded(Land::DATA_VTEX))
{
for (int i = 0; i < Size; ++i)
values[i] = land.getLandData()->mTextures[i];
}
QVariant variant;
variant.setValue(values);
return variant;
}
void LandTexturesColumn::set(Record<Land>& record, const QVariant& data)
{
DataType values = data.value<DataType>();
if (values.size() != Land::LAND_NUM_TEXTURES)
throw std::runtime_error("invalid land textures data");
Land copy = record.get();
copy.add(Land::DATA_VTEX);
for (int i = 0; i < values.size(); ++i)
{
copy.getLandData()->mTextures[i] = values[i];
}
copy.mFlags |= Land::Flag_Textures;
record.setModified(copy);
}
bool LandTexturesColumn::isEditable() const
{
return true;
}
/* BodyPartRaceColumn */
BodyPartRaceColumn::BodyPartRaceColumn(const MeshTypeColumn<ESM::BodyPart>* meshType)
: mMeshType(meshType)
{
}
QVariant BodyPartRaceColumn::get(const Record<ESM::BodyPart>& record) const
{
if (mMeshType != nullptr && mMeshType->get(record) == ESM::BodyPart::MT_Skin)
{
return QString::fromUtf8(record.get().mRace.getRefIdString().c_str());
}
return DisableTag::getVariant();
}
void BodyPartRaceColumn::set(Record<ESM::BodyPart>& record, const QVariant& data)
{
ESM::BodyPart record2 = record.get();
record2.mRace = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
record.setModified(record2);
}
bool BodyPartRaceColumn::isEditable() const
{
return true;
}
SelectionGroupColumn::SelectionGroupColumn()
: Column<ESM::SelectionGroup>(Columns::ColumnId_SelectionGroupObjects, ColumnBase::Display_None)
{
}
QVariant SelectionGroupColumn::get(const Record<ESM::SelectionGroup>& record) const
{
QVariant data;
QStringList selectionInfo;
const std::vector<std::string>& instances = record.get().selectedInstances;
for (const std::string& instance : instances)
selectionInfo << QString::fromStdString(instance);
data.setValue(selectionInfo);
return data;
}
void SelectionGroupColumn::set(Record<ESM::SelectionGroup>& record, const QVariant& data)
{
ESM::SelectionGroup record2 = record.get();
for (const auto& item : data.toStringList())
record2.selectedInstances.push_back(item.toStdString());
record.setModified(record2);
}
bool SelectionGroupColumn::isEditable() const
{
return false;
}
std::optional<std::uint32_t> getSkillIndex(std::string_view value)
{
int index = ESM::Skill::refIdToIndex(ESM::RefId::stringRefId(value));
if (index < 0)
return std::nullopt;
return static_cast<std::uint32_t>(index);
}
std::string getStringId(ESM::RefId value)
{
return visit(GetStringId{}, value);
}
}
| 9,410
|
C++
|
.cpp
| 271
| 26.560886
| 104
| 0.609689
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,929
|
refidadapterimp.cpp
|
OpenMW_openmw/apps/opencs/model/world/refidadapterimp.cpp
|
#include "refidadapterimp.hpp"
#include <stdexcept>
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/disabletag.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm/attr.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadskil.hpp>
#include "nestedtablewrapper.hpp"
CSMWorld::PotionColumns::PotionColumns(const InventoryColumns& columns)
: InventoryColumns(columns)
, mEffects(nullptr)
{
}
CSMWorld::PotionRefIdAdapter::PotionRefIdAdapter(const PotionColumns& columns, const RefIdColumn* autoCalc)
: InventoryRefIdAdapter<ESM::Potion>(UniversalId::Type_Potion, columns)
, mColumns(columns)
, mAutoCalc(autoCalc)
{
}
QVariant CSMWorld::PotionRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Potion>& record = static_cast<const Record<ESM::Potion>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Potion)));
if (column == mAutoCalc)
return record.get().mData.mFlags & ESM::Potion::Autocalc;
// to show nested tables in dialogue subview, see IdTree::hasChildren()
if (column == mColumns.mEffects)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
return InventoryRefIdAdapter<ESM::Potion>::getData(column, data, index);
}
void CSMWorld::PotionRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Potion>& record
= static_cast<Record<ESM::Potion>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Potion)));
ESM::Potion potion = record.get();
if (column == mAutoCalc)
potion.mData.mFlags = value.toBool();
else
{
InventoryRefIdAdapter<ESM::Potion>::setData(column, data, index, value);
return;
}
record.setModified(potion);
}
CSMWorld::IngredientColumns::IngredientColumns(const InventoryColumns& columns)
: InventoryColumns(columns)
, mEffects(nullptr)
{
}
CSMWorld::IngredientRefIdAdapter::IngredientRefIdAdapter(const IngredientColumns& columns)
: InventoryRefIdAdapter<ESM::Ingredient>(UniversalId::Type_Ingredient, columns)
, mColumns(columns)
{
}
QVariant CSMWorld::IngredientRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
if (column == mColumns.mEffects)
return QVariant::fromValue(ColumnBase::TableEdit_FixedRows);
return InventoryRefIdAdapter<ESM::Ingredient>::getData(column, data, index);
}
void CSMWorld::IngredientRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
InventoryRefIdAdapter<ESM::Ingredient>::setData(column, data, index, value);
return;
}
CSMWorld::IngredEffectRefIdAdapter::IngredEffectRefIdAdapter()
: mType(UniversalId::Type_Ingredient)
{
}
void CSMWorld::IngredEffectRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::IngredEffectRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::IngredEffectRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
Record<ESM::Ingredient>& record
= static_cast<Record<ESM::Ingredient>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
ESM::Ingredient ingredient = record.get();
ingredient.mData = static_cast<const NestedTableWrapper<std::vector<ESM::Ingredient::IRDTstruct>>&>(nestedTable)
.mNestedTable.at(0);
record.setModified(ingredient);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::IngredEffectRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Ingredient>& record
= static_cast<const Record<ESM::Ingredient>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
// return the whole struct
std::vector<ESM::Ingredient::IRDTstruct> wrap;
wrap.push_back(record.get().mData);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Ingredient::IRDTstruct>>(wrap);
}
QVariant CSMWorld::IngredEffectRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::Ingredient>& record
= static_cast<const Record<ESM::Ingredient>&>(data.getRecord(RefIdData::LocalIndex(index, mType)));
if (subRowIndex < 0 || subRowIndex >= 4)
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
return record.get().mData.mEffectID[subRowIndex];
case 1:
{
switch (record.get().mData.mEffectID[subRowIndex])
{
case ESM::MagicEffect::DrainSkill:
case ESM::MagicEffect::DamageSkill:
case ESM::MagicEffect::RestoreSkill:
case ESM::MagicEffect::FortifySkill:
case ESM::MagicEffect::AbsorbSkill:
return record.get().mData.mSkills[subRowIndex];
default:
return QVariant();
}
}
case 2:
{
switch (record.get().mData.mEffectID[subRowIndex])
{
case ESM::MagicEffect::DrainAttribute:
case ESM::MagicEffect::DamageAttribute:
case ESM::MagicEffect::RestoreAttribute:
case ESM::MagicEffect::FortifyAttribute:
case ESM::MagicEffect::AbsorbAttribute:
return record.get().mData.mAttributes[subRowIndex];
default:
return QVariant();
}
}
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
}
void CSMWorld::IngredEffectRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::Ingredient>& record
= static_cast<Record<ESM::Ingredient>&>(data.getRecord(RefIdData::LocalIndex(row, mType)));
ESM::Ingredient ingredient = record.get();
if (subRowIndex < 0 || subRowIndex >= 4)
throw std::runtime_error("index out of range");
switch (subColIndex)
{
case 0:
ingredient.mData.mEffectID[subRowIndex] = value.toInt();
switch (ingredient.mData.mEffectID[subRowIndex])
{
case ESM::MagicEffect::DrainSkill:
case ESM::MagicEffect::DamageSkill:
case ESM::MagicEffect::RestoreSkill:
case ESM::MagicEffect::FortifySkill:
case ESM::MagicEffect::AbsorbSkill:
ingredient.mData.mAttributes[subRowIndex] = -1;
break;
case ESM::MagicEffect::DrainAttribute:
case ESM::MagicEffect::DamageAttribute:
case ESM::MagicEffect::RestoreAttribute:
case ESM::MagicEffect::FortifyAttribute:
case ESM::MagicEffect::AbsorbAttribute:
ingredient.mData.mSkills[subRowIndex] = -1;
break;
default:
ingredient.mData.mSkills[subRowIndex] = -1;
ingredient.mData.mAttributes[subRowIndex] = -1;
}
break;
case 1:
ingredient.mData.mSkills[subRowIndex] = value.toInt();
break;
case 2:
ingredient.mData.mAttributes[subRowIndex] = value.toInt();
break;
default:
throw std::runtime_error("Trying to access non-existing column in the nested table!");
}
record.setModified(ingredient);
}
int CSMWorld::IngredEffectRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 3; // effect, skill, attribute
}
int CSMWorld::IngredEffectRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
return 4; // up to 4 effects
}
CSMWorld::ApparatusRefIdAdapter::ApparatusRefIdAdapter(
const InventoryColumns& columns, const RefIdColumn* type, const RefIdColumn* quality)
: InventoryRefIdAdapter<ESM::Apparatus>(UniversalId::Type_Apparatus, columns)
, mType(type)
, mQuality(quality)
{
}
QVariant CSMWorld::ApparatusRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Apparatus>& record = static_cast<const Record<ESM::Apparatus>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Apparatus)));
if (column == mType)
return record.get().mData.mType;
if (column == mQuality)
return record.get().mData.mQuality;
return InventoryRefIdAdapter<ESM::Apparatus>::getData(column, data, index);
}
void CSMWorld::ApparatusRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Apparatus>& record = static_cast<Record<ESM::Apparatus>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Apparatus)));
ESM::Apparatus apparatus = record.get();
if (column == mType)
apparatus.mData.mType = value.toInt();
else if (column == mQuality)
apparatus.mData.mQuality = value.toFloat();
else
{
InventoryRefIdAdapter<ESM::Apparatus>::setData(column, data, index, value);
return;
}
record.setModified(apparatus);
}
CSMWorld::ArmorRefIdAdapter::ArmorRefIdAdapter(const EnchantableColumns& columns, const RefIdColumn* type,
const RefIdColumn* health, const RefIdColumn* armor, const RefIdColumn* partRef)
: EnchantableRefIdAdapter<ESM::Armor>(UniversalId::Type_Armor, columns)
, mType(type)
, mHealth(health)
, mArmor(armor)
, mPartRef(partRef)
{
}
QVariant CSMWorld::ArmorRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Armor>& record
= static_cast<const Record<ESM::Armor>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Armor)));
if (column == mType)
return record.get().mData.mType;
if (column == mHealth)
return record.get().mData.mHealth;
if (column == mArmor)
return record.get().mData.mArmor;
if (column == mPartRef)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
return EnchantableRefIdAdapter<ESM::Armor>::getData(column, data, index);
}
void CSMWorld::ArmorRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Armor>& record
= static_cast<Record<ESM::Armor>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Armor)));
ESM::Armor armor = record.get();
if (column == mType)
armor.mData.mType = value.toInt();
else if (column == mHealth)
armor.mData.mHealth = value.toInt();
else if (column == mArmor)
armor.mData.mArmor = value.toInt();
else
{
EnchantableRefIdAdapter<ESM::Armor>::setData(column, data, index, value);
return;
}
record.setModified(armor);
}
CSMWorld::BookRefIdAdapter::BookRefIdAdapter(
const EnchantableColumns& columns, const RefIdColumn* bookType, const RefIdColumn* skill, const RefIdColumn* text)
: EnchantableRefIdAdapter<ESM::Book>(UniversalId::Type_Book, columns)
, mBookType(bookType)
, mSkill(skill)
, mText(text)
{
}
QVariant CSMWorld::BookRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Book>& record
= static_cast<const Record<ESM::Book>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Book)));
if (column == mBookType)
return record.get().mData.mIsScroll;
if (column == mSkill)
return record.get().mData.mSkillId;
if (column == mText)
return QString::fromUtf8(record.get().mText.c_str());
return EnchantableRefIdAdapter<ESM::Book>::getData(column, data, index);
}
void CSMWorld::BookRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Book>& record
= static_cast<Record<ESM::Book>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Book)));
ESM::Book book = record.get();
if (column == mBookType)
book.mData.mIsScroll = value.toInt();
else if (column == mSkill)
book.mData.mSkillId = value.toInt();
else if (column == mText)
book.mText = value.toString().toUtf8().data();
else
{
EnchantableRefIdAdapter<ESM::Book>::setData(column, data, index, value);
return;
}
record.setModified(book);
}
CSMWorld::ClothingRefIdAdapter::ClothingRefIdAdapter(
const EnchantableColumns& columns, const RefIdColumn* type, const RefIdColumn* partRef)
: EnchantableRefIdAdapter<ESM::Clothing>(UniversalId::Type_Clothing, columns)
, mType(type)
, mPartRef(partRef)
{
}
QVariant CSMWorld::ClothingRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Clothing>& record = static_cast<const Record<ESM::Clothing>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Clothing)));
if (column == mType)
return record.get().mData.mType;
if (column == mPartRef)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
return EnchantableRefIdAdapter<ESM::Clothing>::getData(column, data, index);
}
void CSMWorld::ClothingRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Clothing>& record
= static_cast<Record<ESM::Clothing>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Clothing)));
ESM::Clothing clothing = record.get();
if (column == mType)
clothing.mData.mType = value.toInt();
else
{
EnchantableRefIdAdapter<ESM::Clothing>::setData(column, data, index, value);
return;
}
record.setModified(clothing);
}
CSMWorld::ContainerRefIdAdapter::ContainerRefIdAdapter(const NameColumns& columns, const RefIdColumn* weight,
const RefIdColumn* organic, const RefIdColumn* respawn, const RefIdColumn* content)
: NameRefIdAdapter<ESM::Container>(UniversalId::Type_Container, columns)
, mWeight(weight)
, mOrganic(organic)
, mRespawn(respawn)
, mContent(content)
{
}
QVariant CSMWorld::ContainerRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Container>& record = static_cast<const Record<ESM::Container>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Container)));
if (column == mWeight)
return record.get().mWeight;
if (column == mOrganic)
return (record.get().mFlags & ESM::Container::Organic) != 0;
if (column == mRespawn)
return (record.get().mFlags & ESM::Container::Respawn) != 0;
if (column == mContent)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
return NameRefIdAdapter<ESM::Container>::getData(column, data, index);
}
void CSMWorld::ContainerRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Container>& record = static_cast<Record<ESM::Container>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Container)));
ESM::Container container = record.get();
if (column == mWeight)
container.mWeight = value.toFloat();
else if (column == mOrganic)
{
if (value.toInt())
container.mFlags |= ESM::Container::Organic;
else
container.mFlags &= ~ESM::Container::Organic;
}
else if (column == mRespawn)
{
if (value.toInt())
container.mFlags |= ESM::Container::Respawn;
else
container.mFlags &= ~ESM::Container::Respawn;
}
else
{
NameRefIdAdapter<ESM::Container>::setData(column, data, index, value);
return;
}
record.setModified(container);
}
CSMWorld::CreatureColumns::CreatureColumns(const ActorColumns& actorColumns)
: ActorColumns(actorColumns)
, mType(nullptr)
, mScale(nullptr)
, mOriginal(nullptr)
, mAttributes(nullptr)
, mAttacks(nullptr)
, mMisc(nullptr)
, mBloodType(nullptr)
{
}
CSMWorld::CreatureRefIdAdapter::CreatureRefIdAdapter(const CreatureColumns& columns)
: ActorRefIdAdapter<ESM::Creature>(UniversalId::Type_Creature, columns)
, mColumns(columns)
{
}
QVariant CSMWorld::CreatureRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
if (column == mColumns.mType)
return record.get().mData.mType;
if (column == mColumns.mScale)
return record.get().mScale;
if (column == mColumns.mOriginal)
return QString::fromUtf8(record.get().mOriginal.getRefIdString().c_str());
if (column == mColumns.mAttributes)
return QVariant::fromValue(ColumnBase::TableEdit_FixedRows);
if (column == mColumns.mAttacks)
return QVariant::fromValue(ColumnBase::TableEdit_FixedRows);
if (column == mColumns.mMisc)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
if (column == mColumns.mBloodType)
return record.get().mBloodType;
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
return (record.get().mFlags & iter->second) != 0;
}
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mServices.find(column);
if (iter != mColumns.mServices.end() && iter->second == ESM::NPC::Training)
return QVariant();
}
return ActorRefIdAdapter<ESM::Creature>::getData(column, data, index);
}
void CSMWorld::CreatureRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
ESM::Creature creature = record.get();
if (column == mColumns.mType)
creature.mData.mType = value.toInt();
else if (column == mColumns.mScale)
creature.mScale = value.toFloat();
else if (column == mColumns.mOriginal)
creature.mOriginal = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mBloodType)
creature.mBloodType = value.toInt();
else
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
{
if (value.toInt() != 0)
creature.mFlags |= iter->second;
else
creature.mFlags &= ~iter->second;
}
else
{
ActorRefIdAdapter<ESM::Creature>::setData(column, data, index, value);
return;
}
}
record.setModified(creature);
}
CSMWorld::DoorRefIdAdapter::DoorRefIdAdapter(
const NameColumns& columns, const RefIdColumn* openSound, const RefIdColumn* closeSound)
: NameRefIdAdapter<ESM::Door>(UniversalId::Type_Door, columns)
, mOpenSound(openSound)
, mCloseSound(closeSound)
{
}
QVariant CSMWorld::DoorRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Door>& record
= static_cast<const Record<ESM::Door>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Door)));
if (column == mOpenSound)
return QString::fromUtf8(record.get().mOpenSound.getRefIdString().c_str());
if (column == mCloseSound)
return QString::fromUtf8(record.get().mCloseSound.getRefIdString().c_str());
return NameRefIdAdapter<ESM::Door>::getData(column, data, index);
}
void CSMWorld::DoorRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Door>& record
= static_cast<Record<ESM::Door>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Door)));
ESM::Door door = record.get();
if (column == mOpenSound)
door.mOpenSound = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mCloseSound)
door.mCloseSound = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else
{
NameRefIdAdapter<ESM::Door>::setData(column, data, index, value);
return;
}
record.setModified(door);
}
CSMWorld::LightColumns::LightColumns(const InventoryColumns& columns)
: InventoryColumns(columns)
, mTime(nullptr)
, mRadius(nullptr)
, mColor(nullptr)
, mSound(nullptr)
, mEmitterType(nullptr)
{
}
CSMWorld::LightRefIdAdapter::LightRefIdAdapter(const LightColumns& columns)
: InventoryRefIdAdapter<ESM::Light>(UniversalId::Type_Light, columns)
, mColumns(columns)
{
}
QVariant CSMWorld::LightRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Light>& record
= static_cast<const Record<ESM::Light>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Light)));
if (column == mColumns.mTime)
return record.get().mData.mTime;
if (column == mColumns.mRadius)
return record.get().mData.mRadius;
if (column == mColumns.mColor)
return record.get().mData.mColor;
if (column == mColumns.mSound)
return QString::fromUtf8(record.get().mSound.getRefIdString().c_str());
if (column == mColumns.mEmitterType)
{
int mask = ESM::Light::Flicker | ESM::Light::FlickerSlow | ESM::Light::Pulse | ESM::Light::PulseSlow;
if ((record.get().mData.mFlags & mask) == ESM::Light::Flicker)
return 1;
if ((record.get().mData.mFlags & mask) == ESM::Light::FlickerSlow)
return 2;
if ((record.get().mData.mFlags & mask) == ESM::Light::Pulse)
return 3;
if ((record.get().mData.mFlags & mask) == ESM::Light::PulseSlow)
return 4;
return 0;
}
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
return (record.get().mData.mFlags & iter->second) != 0;
return InventoryRefIdAdapter<ESM::Light>::getData(column, data, index);
}
void CSMWorld::LightRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Light>& record
= static_cast<Record<ESM::Light>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Light)));
ESM::Light light = record.get();
if (column == mColumns.mTime)
light.mData.mTime = value.toInt();
else if (column == mColumns.mRadius)
light.mData.mRadius = value.toInt();
else if (column == mColumns.mColor)
light.mData.mColor = value.toInt();
else if (column == mColumns.mSound)
light.mSound = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mEmitterType)
{
int mask = ~(ESM::Light::Flicker | ESM::Light::FlickerSlow | ESM::Light::Pulse | ESM::Light::PulseSlow);
if (value.toInt() == 0)
light.mData.mFlags = light.mData.mFlags & mask;
else if (value.toInt() == 1)
light.mData.mFlags = (light.mData.mFlags & mask) | ESM::Light::Flicker;
else if (value.toInt() == 2)
light.mData.mFlags = (light.mData.mFlags & mask) | ESM::Light::FlickerSlow;
else if (value.toInt() == 3)
light.mData.mFlags = (light.mData.mFlags & mask) | ESM::Light::Pulse;
else
light.mData.mFlags = (light.mData.mFlags & mask) | ESM::Light::PulseSlow;
}
else
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
{
if (value.toInt() != 0)
light.mData.mFlags |= iter->second;
else
light.mData.mFlags &= ~iter->second;
}
else
{
InventoryRefIdAdapter<ESM::Light>::setData(column, data, index, value);
return;
}
}
record.setModified(light);
}
CSMWorld::MiscRefIdAdapter::MiscRefIdAdapter(const InventoryColumns& columns, const RefIdColumn* key)
: InventoryRefIdAdapter<ESM::Miscellaneous>(UniversalId::Type_Miscellaneous, columns)
, mKey(key)
{
}
QVariant CSMWorld::MiscRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Miscellaneous>& record = static_cast<const Record<ESM::Miscellaneous>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Miscellaneous)));
if (column == mKey)
return bool(record.get().mData.mFlags & ESM::Miscellaneous::Key);
return InventoryRefIdAdapter<ESM::Miscellaneous>::getData(column, data, index);
}
void CSMWorld::MiscRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Miscellaneous>& record = static_cast<Record<ESM::Miscellaneous>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Miscellaneous)));
ESM::Miscellaneous misc = record.get();
if (column == mKey)
misc.mData.mFlags = value.toInt();
else
{
InventoryRefIdAdapter<ESM::Miscellaneous>::setData(column, data, index, value);
return;
}
record.setModified(misc);
}
CSMWorld::NpcColumns::NpcColumns(const ActorColumns& actorColumns)
: ActorColumns(actorColumns)
, mRace(nullptr)
, mClass(nullptr)
, mFaction(nullptr)
, mHair(nullptr)
, mHead(nullptr)
, mAttributes(nullptr)
, mSkills(nullptr)
, mMisc(nullptr)
, mBloodType(nullptr)
, mGender(nullptr)
{
}
CSMWorld::NpcRefIdAdapter::NpcRefIdAdapter(const NpcColumns& columns)
: ActorRefIdAdapter<ESM::NPC>(UniversalId::Type_Npc, columns)
, mColumns(columns)
{
}
QVariant CSMWorld::NpcRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
if (column == mColumns.mRace)
return QString::fromUtf8(record.get().mRace.getRefIdString().c_str());
if (column == mColumns.mClass)
return QString::fromUtf8(record.get().mClass.getRefIdString().c_str());
if (column == mColumns.mFaction)
return QString::fromUtf8(record.get().mFaction.getRefIdString().c_str());
if (column == mColumns.mHair)
return QString::fromUtf8(record.get().mHair.getRefIdString().c_str());
if (column == mColumns.mHead)
return QString::fromUtf8(record.get().mHead.getRefIdString().c_str());
if (column == mColumns.mAttributes || column == mColumns.mSkills)
{
if ((record.get().mFlags & ESM::NPC::Autocalc) != 0)
return QVariant::fromValue(ColumnBase::TableEdit_None);
else
return QVariant::fromValue(ColumnBase::TableEdit_FixedRows);
}
if (column == mColumns.mMisc)
return QVariant::fromValue(ColumnBase::TableEdit_Full);
if (column == mColumns.mBloodType)
return record.get().mBloodType;
if (column == mColumns.mGender)
{
// Implemented this way to allow additional gender types in the future.
if ((record.get().mFlags & ESM::NPC::Female) == ESM::NPC::Female)
return 1;
return 0;
}
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
return (record.get().mFlags & iter->second) != 0;
return ActorRefIdAdapter<ESM::NPC>::getData(column, data, index);
}
void CSMWorld::NpcRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
if (column == mColumns.mRace)
npc.mRace = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mClass)
npc.mClass = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mFaction)
npc.mFaction = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mHair)
npc.mHair = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mHead)
npc.mHead = ESM::RefId::stringRefId(value.toString().toUtf8().constData());
else if (column == mColumns.mBloodType)
npc.mBloodType = value.toInt();
else if (column == mColumns.mGender)
{
// Implemented this way to allow additional gender types in the future.
if (value.toInt() == 1)
npc.mFlags = (npc.mFlags & ~ESM::NPC::Female) | ESM::NPC::Female;
else
npc.mFlags = npc.mFlags & ~ESM::NPC::Female;
}
else
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
{
if (value.toInt() != 0)
npc.mFlags |= iter->second;
else
npc.mFlags &= ~iter->second;
if (iter->second == ESM::NPC::Autocalc)
npc.mNpdtType = (value.toInt() != 0) ? ESM::NPC::NPC_WITH_AUTOCALCULATED_STATS : ESM::NPC::NPC_DEFAULT;
}
else
{
ActorRefIdAdapter<ESM::NPC>::setData(column, data, index, value);
return;
}
}
record.setModified(npc);
}
void CSMWorld::NpcAttributesRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::NpcAttributesRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::NpcAttributesRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
// store the whole struct
npc.mNpdt
= static_cast<const NestedTableWrapper<std::vector<ESM::NPC::NPDTstruct52>>&>(nestedTable).mNestedTable.at(0);
record.setModified(npc);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::NpcAttributesRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
// return the whole struct
std::vector<ESM::NPC::NPDTstruct52> wrap;
wrap.push_back(record.get().mNpdt);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::NPC::NPDTstruct52>>(wrap);
}
QVariant CSMWorld::NpcAttributesRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
const ESM::NPC::NPDTstruct52& npcStruct = record.get().mNpdt;
if (subColIndex == 0)
return subRowIndex;
else if (subColIndex == 1 && subRowIndex >= 0 && subRowIndex < ESM::Attribute::Length)
return static_cast<int>(npcStruct.mAttributes[subRowIndex]);
return QVariant(); // throw an exception here?
}
void CSMWorld::NpcAttributesRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
ESM::NPC::NPDTstruct52& npcStruct = npc.mNpdt;
if (subColIndex == 1 && subRowIndex >= 0 && subRowIndex < ESM::Attribute::Length)
npcStruct.mAttributes[subRowIndex] = static_cast<unsigned char>(value.toInt());
else
return; // throw an exception here?
record.setModified(npc);
}
int CSMWorld::NpcAttributesRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 2;
}
int CSMWorld::NpcAttributesRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
return ESM::Attribute::Length;
}
void CSMWorld::NpcSkillsRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::NpcSkillsRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::NpcSkillsRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
// store the whole struct
npc.mNpdt
= static_cast<const NestedTableWrapper<std::vector<ESM::NPC::NPDTstruct52>>&>(nestedTable).mNestedTable.at(0);
record.setModified(npc);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::NpcSkillsRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
// return the whole struct
std::vector<ESM::NPC::NPDTstruct52> wrap;
wrap.push_back(record.get().mNpdt);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::NPC::NPDTstruct52>>(wrap);
}
QVariant CSMWorld::NpcSkillsRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
const ESM::NPC::NPDTstruct52& npcStruct = record.get().mNpdt;
if (subRowIndex < 0 || subRowIndex >= ESM::Skill::Length)
throw std::runtime_error("index out of range");
if (subColIndex == 0)
return subRowIndex;
else if (subColIndex == 1)
return static_cast<int>(npcStruct.mSkills[subRowIndex]);
else
return QVariant(); // throw an exception here?
}
void CSMWorld::NpcSkillsRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
ESM::NPC::NPDTstruct52& npcStruct = npc.mNpdt;
if (subRowIndex < 0 || subRowIndex >= ESM::Skill::Length)
throw std::runtime_error("index out of range");
if (subColIndex == 1)
npcStruct.mSkills[subRowIndex] = static_cast<unsigned char>(value.toInt());
else
return; // throw an exception here?
record.setModified(npc);
}
int CSMWorld::NpcSkillsRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 2;
}
int CSMWorld::NpcSkillsRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
// There are 27 skills
return ESM::Skill::Length;
}
void CSMWorld::NpcMiscRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void CSMWorld::NpcMiscRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
throw std::logic_error("cannot remove a row to a fixed table");
}
void CSMWorld::NpcMiscRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
CSMWorld::NestedTableWrapperBase* CSMWorld::NpcMiscRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
throw std::logic_error("table operation not supported");
}
QVariant CSMWorld::NpcMiscRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::NPC>& record
= static_cast<const Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Npc)));
bool autoCalc = (record.get().mFlags & ESM::NPC::Autocalc) != 0;
if (autoCalc)
switch (subColIndex)
{
case 0:
return static_cast<int>(record.get().mNpdt.mLevel);
case 1:
return CSMWorld::DisableTag::getVariant();
case 2:
return CSMWorld::DisableTag::getVariant();
case 3:
return CSMWorld::DisableTag::getVariant();
case 4:
return static_cast<int>(record.get().mNpdt.mDisposition);
case 5:
return static_cast<int>(record.get().mNpdt.mReputation);
case 6:
return static_cast<int>(record.get().mNpdt.mRank);
case 7:
return record.get().mNpdt.mGold;
default:
return QVariant(); // throw an exception here?
}
else
switch (subColIndex)
{
case 0:
return static_cast<int>(record.get().mNpdt.mLevel);
case 1:
return static_cast<int>(record.get().mNpdt.mHealth);
case 2:
return static_cast<int>(record.get().mNpdt.mMana);
case 3:
return static_cast<int>(record.get().mNpdt.mFatigue);
case 4:
return static_cast<int>(record.get().mNpdt.mDisposition);
case 5:
return static_cast<int>(record.get().mNpdt.mReputation);
case 6:
return static_cast<int>(record.get().mNpdt.mRank);
case 7:
return record.get().mNpdt.mGold;
default:
return QVariant(); // throw an exception here?
}
}
void CSMWorld::NpcMiscRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::NPC>& record
= static_cast<Record<ESM::NPC>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Npc)));
ESM::NPC npc = record.get();
bool autoCalc = (record.get().mFlags & ESM::NPC::Autocalc) != 0;
if (autoCalc)
switch (subColIndex)
{
case 0:
npc.mNpdt.mLevel = static_cast<short>(value.toInt());
break;
case 1:
return;
case 2:
return;
case 3:
return;
case 4:
npc.mNpdt.mDisposition = static_cast<signed char>(value.toInt());
break;
case 5:
npc.mNpdt.mReputation = static_cast<signed char>(value.toInt());
break;
case 6:
npc.mNpdt.mRank = static_cast<signed char>(value.toInt());
break;
case 7:
npc.mNpdt.mGold = value.toInt();
break;
default:
return; // throw an exception here?
}
else
switch (subColIndex)
{
case 0:
npc.mNpdt.mLevel = static_cast<short>(value.toInt());
break;
case 1:
npc.mNpdt.mHealth = static_cast<unsigned short>(value.toInt());
break;
case 2:
npc.mNpdt.mMana = static_cast<unsigned short>(value.toInt());
break;
case 3:
npc.mNpdt.mFatigue = static_cast<unsigned short>(value.toInt());
break;
case 4:
npc.mNpdt.mDisposition = static_cast<signed char>(value.toInt());
break;
case 5:
npc.mNpdt.mReputation = static_cast<signed char>(value.toInt());
break;
case 6:
npc.mNpdt.mRank = static_cast<signed char>(value.toInt());
break;
case 7:
npc.mNpdt.mGold = value.toInt();
break;
default:
return; // throw an exception here?
}
record.setModified(npc);
}
int CSMWorld::NpcMiscRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 8; // Level, Health, Mana, Fatigue, Disposition, Reputation, Rank, Gold
}
int CSMWorld::NpcMiscRefIdAdapter::getNestedRowsCount(const RefIdColumn* column, const RefIdData& data, int index) const
{
return 1; // fixed at size 1
}
void CSMWorld::CreatureAttributesRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::CreatureAttributesRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::CreatureAttributesRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
ESM::Creature creature = record.get();
// store the whole struct
creature.mData = static_cast<const NestedTableWrapper<std::vector<ESM::Creature::NPDTstruct>>&>(nestedTable)
.mNestedTable.at(0);
record.setModified(creature);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::CreatureAttributesRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
// return the whole struct
std::vector<ESM::Creature::NPDTstruct> wrap;
wrap.push_back(record.get().mData);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Creature::NPDTstruct>>(wrap);
}
QVariant CSMWorld::CreatureAttributesRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
const ESM::Creature& creature = record.get();
if (subColIndex == 0)
return subRowIndex;
else if (subColIndex == 1 && subRowIndex >= 0 && subRowIndex < ESM::Attribute::Length)
return creature.mData.mAttributes[subRowIndex];
return QVariant(); // throw an exception here?
}
void CSMWorld::CreatureAttributesRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Creature)));
if (subColIndex == 1 && subRowIndex >= 0 && subRowIndex < ESM::Attribute::Length)
{
ESM::Creature creature = record.get();
creature.mData.mAttributes[subRowIndex] = value.toInt();
record.setModified(creature);
}
// throw an exception here?
}
int CSMWorld::CreatureAttributesRefIdAdapter::getNestedColumnsCount(
const RefIdColumn* column, const RefIdData& data) const
{
return 2;
}
int CSMWorld::CreatureAttributesRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
return ESM::Attribute::Length;
}
void CSMWorld::CreatureAttackRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::CreatureAttackRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
// Do nothing, this table cannot be changed by the user
}
void CSMWorld::CreatureAttackRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
ESM::Creature creature = record.get();
// store the whole struct
creature.mData = static_cast<const NestedTableWrapper<std::vector<ESM::Creature::NPDTstruct>>&>(nestedTable)
.mNestedTable.at(0);
record.setModified(creature);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::CreatureAttackRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
// return the whole struct
std::vector<ESM::Creature::NPDTstruct> wrap;
wrap.push_back(record.get().mData);
// deleted by dtor of NestedTableStoring
return new NestedTableWrapper<std::vector<ESM::Creature::NPDTstruct>>(wrap);
}
QVariant CSMWorld::CreatureAttackRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
const ESM::Creature& creature = record.get();
if (subRowIndex < 0 || subRowIndex > 2)
throw std::runtime_error("index out of range");
if (subColIndex == 0)
return subRowIndex + 1;
else if (subColIndex == 1 || subColIndex == 2)
return creature.mData.mAttack[(subRowIndex * 2) + (subColIndex - 1)];
else
throw std::runtime_error("index out of range");
}
void CSMWorld::CreatureAttackRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Creature)));
ESM::Creature creature = record.get();
if (subRowIndex < 0 || subRowIndex > 2)
throw std::runtime_error("index out of range");
if (subColIndex == 1 || subColIndex == 2)
creature.mData.mAttack[(subRowIndex * 2) + (subColIndex - 1)] = value.toInt();
else
return; // throw an exception here?
record.setModified(creature);
}
int CSMWorld::CreatureAttackRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 3;
}
int CSMWorld::CreatureAttackRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
// There are 3 attacks
return 3;
}
void CSMWorld::CreatureMiscRefIdAdapter::addNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int position) const
{
throw std::logic_error("cannot add a row to a fixed table");
}
void CSMWorld::CreatureMiscRefIdAdapter::removeNestedRow(
const RefIdColumn* column, RefIdData& data, int index, int rowToRemove) const
{
throw std::logic_error("cannot remove a row to a fixed table");
}
void CSMWorld::CreatureMiscRefIdAdapter::setNestedTable(
const RefIdColumn* column, RefIdData& data, int index, const NestedTableWrapperBase& nestedTable) const
{
throw std::logic_error("table operation not supported");
}
CSMWorld::NestedTableWrapperBase* CSMWorld::CreatureMiscRefIdAdapter::nestedTable(
const RefIdColumn* column, const RefIdData& data, int index) const
{
throw std::logic_error("table operation not supported");
}
QVariant CSMWorld::CreatureMiscRefIdAdapter::getNestedData(
const RefIdColumn* column, const RefIdData& data, int index, int subRowIndex, int subColIndex) const
{
const Record<ESM::Creature>& record = static_cast<const Record<ESM::Creature>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Creature)));
const ESM::Creature& creature = record.get();
switch (subColIndex)
{
case 0:
return creature.mData.mLevel;
case 1:
return creature.mData.mHealth;
case 2:
return creature.mData.mMana;
case 3:
return creature.mData.mFatigue;
case 4:
return creature.mData.mSoul;
case 5:
return creature.mData.mCombat;
case 6:
return creature.mData.mMagic;
case 7:
return creature.mData.mStealth;
case 8:
return creature.mData.mGold;
default:
return QVariant(); // throw an exception here?
}
}
void CSMWorld::CreatureMiscRefIdAdapter::setNestedData(
const RefIdColumn* column, RefIdData& data, int row, const QVariant& value, int subRowIndex, int subColIndex) const
{
Record<ESM::Creature>& record
= static_cast<Record<ESM::Creature>&>(data.getRecord(RefIdData::LocalIndex(row, UniversalId::Type_Creature)));
ESM::Creature creature = record.get();
switch (subColIndex)
{
case 0:
creature.mData.mLevel = value.toInt();
break;
case 1:
creature.mData.mHealth = value.toInt();
break;
case 2:
creature.mData.mMana = value.toInt();
break;
case 3:
creature.mData.mFatigue = value.toInt();
break;
case 4:
creature.mData.mSoul = value.toInt();
break;
case 5:
creature.mData.mCombat = value.toInt();
break;
case 6:
creature.mData.mMagic = value.toInt();
break;
case 7:
creature.mData.mStealth = value.toInt();
break;
case 8:
creature.mData.mGold = value.toInt();
break;
default:
return; // throw an exception here?
}
record.setModified(creature);
}
int CSMWorld::CreatureMiscRefIdAdapter::getNestedColumnsCount(const RefIdColumn* column, const RefIdData& data) const
{
return 9; // Level, Health, Mana, Fatigue, Soul, Combat, Magic, Steath, Gold
}
int CSMWorld::CreatureMiscRefIdAdapter::getNestedRowsCount(
const RefIdColumn* column, const RefIdData& data, int index) const
{
return 1; // fixed at size 1
}
CSMWorld::WeaponColumns::WeaponColumns(const EnchantableColumns& columns)
: EnchantableColumns(columns)
, mType(nullptr)
, mHealth(nullptr)
, mSpeed(nullptr)
, mReach(nullptr)
, mChop{ nullptr }
, mSlash{ nullptr }
, mThrust{ nullptr }
{
}
CSMWorld::WeaponRefIdAdapter::WeaponRefIdAdapter(const WeaponColumns& columns)
: EnchantableRefIdAdapter<ESM::Weapon>(UniversalId::Type_Weapon, columns)
, mColumns(columns)
{
}
QVariant CSMWorld::WeaponRefIdAdapter::getData(const RefIdColumn* column, const RefIdData& data, int index) const
{
const Record<ESM::Weapon>& record = static_cast<const Record<ESM::Weapon>&>(
data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Weapon)));
if (column == mColumns.mType)
return record.get().mData.mType;
if (column == mColumns.mHealth)
return record.get().mData.mHealth;
if (column == mColumns.mSpeed)
return record.get().mData.mSpeed;
if (column == mColumns.mReach)
return record.get().mData.mReach;
for (int i = 0; i < 2; ++i)
{
if (column == mColumns.mChop[i])
return record.get().mData.mChop[i];
if (column == mColumns.mSlash[i])
return record.get().mData.mSlash[i];
if (column == mColumns.mThrust[i])
return record.get().mData.mThrust[i];
}
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
return (record.get().mData.mFlags & iter->second) != 0;
return EnchantableRefIdAdapter<ESM::Weapon>::getData(column, data, index);
}
void CSMWorld::WeaponRefIdAdapter::setData(
const RefIdColumn* column, RefIdData& data, int index, const QVariant& value) const
{
Record<ESM::Weapon>& record
= static_cast<Record<ESM::Weapon>&>(data.getRecord(RefIdData::LocalIndex(index, UniversalId::Type_Weapon)));
ESM::Weapon weapon = record.get();
if (column == mColumns.mType)
weapon.mData.mType = value.toInt();
else if (column == mColumns.mHealth)
weapon.mData.mHealth = value.toInt();
else if (column == mColumns.mSpeed)
weapon.mData.mSpeed = value.toFloat();
else if (column == mColumns.mReach)
weapon.mData.mReach = value.toFloat();
else if (column == mColumns.mChop[0])
weapon.mData.mChop[0] = value.toInt();
else if (column == mColumns.mChop[1])
weapon.mData.mChop[1] = value.toInt();
else if (column == mColumns.mSlash[0])
weapon.mData.mSlash[0] = value.toInt();
else if (column == mColumns.mSlash[1])
weapon.mData.mSlash[1] = value.toInt();
else if (column == mColumns.mThrust[0])
weapon.mData.mThrust[0] = value.toInt();
else if (column == mColumns.mThrust[1])
weapon.mData.mThrust[1] = value.toInt();
else
{
std::map<const RefIdColumn*, unsigned int>::const_iterator iter = mColumns.mFlags.find(column);
if (iter != mColumns.mFlags.end())
{
if (value.toInt() != 0)
weapon.mData.mFlags |= iter->second;
else
weapon.mData.mFlags &= ~iter->second;
}
else
{
EnchantableRefIdAdapter<ESM::Weapon>::setData(column, data, index, value);
return; // Don't overwrite changes made by base class
}
}
record.setModified(weapon);
}
| 56,431
|
C++
|
.cpp
| 1,339
| 35.422704
| 120
| 0.677529
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,930
|
infotableproxymodel.cpp
|
OpenMW_openmw/apps/opencs/model/world/infotableproxymodel.cpp
|
#include "infotableproxymodel.hpp"
#include <QModelIndex>
#include <QObject>
#include <QString>
#include <apps/opencs/model/world/idtableproxymodel.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/misc/strings/lower.hpp>
#include <string>
#include "columns.hpp"
#include "idtablebase.hpp"
namespace
{
QString toLower(const QString& str)
{
return QString::fromUtf8(Misc::StringUtils::lowerCase(str.toUtf8().constData()).c_str());
}
}
CSMWorld::InfoTableProxyModel::InfoTableProxyModel(CSMWorld::UniversalId::Type type, QObject* parent)
: IdTableProxyModel(parent)
, mType(type)
, mInfoColumnId(type == UniversalId::Type_TopicInfos ? Columns::ColumnId_Topic : Columns::ColumnId_Journal)
, mInfoColumnIndex(-1)
, mLastAddedSourceRow(-1)
{
Q_ASSERT(type == UniversalId::Type_TopicInfos || type == UniversalId::Type_JournalInfos);
}
void CSMWorld::InfoTableProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
{
IdTableProxyModel::setSourceModel(sourceModel);
if (mSourceModel != nullptr)
{
mInfoColumnIndex = mSourceModel->findColumnIndex(mInfoColumnId);
mFirstRowCache.clear();
}
}
bool CSMWorld::InfoTableProxyModel::lessThan(const QModelIndex& left, const QModelIndex& right) const
{
Q_ASSERT(mSourceModel != nullptr);
QModelIndex first = mSourceModel->index(getFirstInfoRow(left.row()), left.column());
QModelIndex second = mSourceModel->index(getFirstInfoRow(right.row()), right.column());
// If both indexes are belonged to the same Topic/Journal, compare their original rows only
if (first.row() == second.row())
{
return sortOrder() == Qt::AscendingOrder ? left.row() < right.row() : right.row() < left.row();
}
return IdTableProxyModel::lessThan(first, second);
}
int CSMWorld::InfoTableProxyModel::getFirstInfoRow(int currentRow) const
{
Q_ASSERT(mSourceModel != nullptr);
int row = currentRow;
int column = mInfoColumnIndex;
QString info = toLower(mSourceModel->data(mSourceModel->index(row, column)).toString());
if (mFirstRowCache.contains(info))
{
return mFirstRowCache[info];
}
while (--row >= 0 && toLower(mSourceModel->data(mSourceModel->index(row, column)).toString()) == info)
;
++row;
mFirstRowCache[info] = row;
return row;
}
void CSMWorld::InfoTableProxyModel::sourceRowsRemoved(const QModelIndex& /*parent*/, int /*start*/, int /*end*/)
{
refreshFilter();
mFirstRowCache.clear();
}
void CSMWorld::InfoTableProxyModel::sourceRowsInserted(const QModelIndex& parent, int /*start*/, int end)
{
refreshFilter();
if (!parent.isValid())
{
mFirstRowCache.clear();
// We can't re-sort the model here, because the topic of the added row isn't set yet.
// Store the row index for using in the first dataChanged() after this row insertion.
mLastAddedSourceRow = end;
}
}
void CSMWorld::InfoTableProxyModel::sourceDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
{
refreshFilter();
if (mLastAddedSourceRow != -1 && topLeft.row() <= mLastAddedSourceRow && bottomRight.row() >= mLastAddedSourceRow)
{
// Now the topic of the last added row is set,
// so we can re-sort the model to ensure the corrent position of this row
int column = sortColumn();
Qt::SortOrder order = sortOrder();
sort(mInfoColumnIndex); // Restore the correct position of an added row
sort(column, order); // Restore the original sort order
emit rowAdded(getRecordId(mLastAddedSourceRow).toUtf8().constData());
// Make sure that we perform a re-sorting only in the first dataChanged() after a row insertion
mLastAddedSourceRow = -1;
}
}
| 3,813
|
C++
|
.cpp
| 95
| 35.526316
| 118
| 0.71475
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,931
|
landtexturetableproxymodel.cpp
|
OpenMW_openmw/apps/opencs/model/world/landtexturetableproxymodel.cpp
|
#include "landtexturetableproxymodel.hpp"
#include <apps/opencs/model/world/idtableproxymodel.hpp>
namespace CSMWorld
{
LandTextureTableProxyModel::LandTextureTableProxyModel(QObject* parent)
: IdTableProxyModel(parent)
{
}
bool LandTextureTableProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
{
return IdTableProxyModel::filterAcceptsRow(sourceRow, sourceParent);
}
}
| 446
|
C++
|
.cpp
| 13
| 30
| 107
| 0.788372
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,932
|
resourcetable.cpp
|
OpenMW_openmw/apps/opencs/model/world/resourcetable.cpp
|
#include "resourcetable.hpp"
#include <stdexcept>
#include <type_traits>
#include <apps/opencs/model/world/idtablebase.hpp>
#include "columnbase.hpp"
#include "resources.hpp"
#include "universalid.hpp"
CSMWorld::ResourceTable::ResourceTable(const Resources* resources, unsigned int features)
: IdTableBase(features | Feature_Constant)
, mResources(resources)
{
}
int CSMWorld::ResourceTable::rowCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return mResources->getSize();
}
int CSMWorld::ResourceTable::columnCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return 2; // ID, type
}
QVariant CSMWorld::ResourceTable::data(const QModelIndex& index, int role) const
{
if (role != Qt::DisplayRole)
return QVariant();
if (index.column() == 0)
return QString::fromUtf8(mResources->getId(index.row()).c_str());
if (index.column() == 1)
return static_cast<int>(mResources->getType());
throw std::logic_error("Invalid column in resource table");
}
QVariant CSMWorld::ResourceTable::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Vertical)
return QVariant();
if (role == ColumnBase::Role_Flags)
return section == 0 ? ColumnBase::Flag_Table : 0;
switch (section)
{
case 0:
if (role == Qt::DisplayRole)
return Columns::getName(Columns::ColumnId_Id).c_str();
if (role == ColumnBase::Role_Display)
return ColumnBase::Display_Id;
break;
case 1:
if (role == Qt::DisplayRole)
return Columns::getName(Columns::ColumnId_RecordType).c_str();
if (role == ColumnBase::Role_Display)
return ColumnBase::Display_Integer;
break;
}
return QVariant();
}
bool CSMWorld::ResourceTable::setData(const QModelIndex& index, const QVariant& value, int role)
{
return false;
}
Qt::ItemFlags CSMWorld::ResourceTable::flags(const QModelIndex& index) const
{
return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
}
QModelIndex CSMWorld::ResourceTable::index(int row, int column, const QModelIndex& parent) const
{
if (parent.isValid())
return QModelIndex();
if (row < 0 || row >= mResources->getSize())
return QModelIndex();
if (column < 0 || column > 1)
return QModelIndex();
return createIndex(row, column);
}
QModelIndex CSMWorld::ResourceTable::parent(const QModelIndex& index) const
{
return QModelIndex();
}
QModelIndex CSMWorld::ResourceTable::getModelIndex(const std::string& id, int column) const
{
int row = mResources->searchId(id);
if (row != -1)
return index(row, column);
return QModelIndex();
}
int CSMWorld::ResourceTable::searchColumnIndex(Columns::ColumnId id) const
{
if (id == Columns::ColumnId_Id)
return 0;
if (id == Columns::ColumnId_RecordType)
return 1;
return -1;
}
int CSMWorld::ResourceTable::findColumnIndex(Columns::ColumnId id) const
{
int index = searchColumnIndex(id);
if (index == -1)
throw std::logic_error("invalid column index");
return index;
}
std::pair<CSMWorld::UniversalId, std::string> CSMWorld::ResourceTable::view(int row) const
{
return std::make_pair(UniversalId::Type_None, "");
}
bool CSMWorld::ResourceTable::isDeleted(const std::string& id) const
{
return false;
}
int CSMWorld::ResourceTable::getColumnId(int column) const
{
switch (column)
{
case 0:
return Columns::ColumnId_Id;
case 1:
return Columns::ColumnId_RecordType;
}
return -1;
}
void CSMWorld::ResourceTable::beginReset()
{
beginResetModel();
}
void CSMWorld::ResourceTable::endReset()
{
endResetModel();
}
| 3,881
|
C++
|
.cpp
| 128
| 25.351563
| 102
| 0.67835
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,933
|
cell.cpp
|
OpenMW_openmw/apps/opencs/model/world/cell.cpp
|
#include "cell.hpp"
#include <sstream>
void CSMWorld::Cell::load(ESM::ESMReader& esm, bool& isDeleted)
{
ESM::Cell::load(esm, isDeleted, false);
mId = ESM::RefId::stringRefId(ESM::Cell::mId.toString());
}
| 216
|
C++
|
.cpp
| 7
| 28.285714
| 63
| 0.699029
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,934
|
idcollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/idcollection.cpp
|
#include "idcollection.hpp"
#include <memory>
#include <string>
#include <utility>
#include <apps/opencs/model/world/collection.hpp>
#include <apps/opencs/model/world/pathgrid.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/loadpgrd.hpp>
namespace ESM
{
class ESMReader;
}
namespace CSMWorld
{
template <>
int BaseIdCollection<Pathgrid>::load(ESM::ESMReader& reader, bool base)
{
Pathgrid record;
bool isDeleted = false;
loadRecord(record, reader, isDeleted, base);
const ESM::RefId id = getRecordId(record);
int index = this->searchId(id);
if (record.mPoints.empty() || record.mEdges.empty())
isDeleted = true;
if (isDeleted)
{
if (index == -1)
{
// deleting a record that does not exist
// ignore it for now
/// \todo report the problem to the user
return -1;
}
if (base)
{
this->removeRows(index, 1);
return -1;
}
auto baseRecord = std::make_unique<Record<Pathgrid>>(this->getRecord(index));
baseRecord->mState = RecordBase::State_Deleted;
this->setRecord(index, std::move(baseRecord));
return index;
}
return load(record, base, index);
}
const Record<ESM::LandTexture>* IdCollection<ESM::LandTexture>::searchRecord(std::uint16_t index, int plugin) const
{
auto found = mIndices.find({ plugin, index });
if (found != mIndices.end())
{
int index = searchId(found->second);
if (index != -1)
return &getRecord(index);
}
return nullptr;
}
const std::string* IdCollection<ESM::LandTexture>::getLandTexture(std::uint16_t index, int plugin) const
{
const Record<ESM::LandTexture>* record = searchRecord(index, plugin);
if (record && !record->isDeleted())
return &record->get().mTexture;
return nullptr;
}
void IdCollection<ESM::LandTexture>::loadRecord(
ESM::LandTexture& record, ESM::ESMReader& reader, bool& isDeleted, bool base)
{
record.load(reader, isDeleted);
int plugin = base ? reader.getIndex() : -1;
mIndices.emplace(std::make_pair(plugin, record.mIndex), record.mId);
}
std::uint16_t IdCollection<ESM::LandTexture>::assignNewIndex(ESM::RefId id)
{
std::uint16_t index = 0;
if (!mIndices.empty())
{
auto end = mIndices.lower_bound({ -1, std::numeric_limits<std::uint16_t>::max() });
if (end != mIndices.begin())
end = std::prev(end);
if (end->first.first == -1)
{
constexpr std::uint16_t maxIndex = std::numeric_limits<std::uint16_t>::max() - 1;
if (end->first.second < maxIndex)
index = end->first.second + 1;
else
{
std::uint16_t prevIndex = 0;
for (auto it = mIndices.lower_bound({ -1, 0 }); it != end; ++it)
{
if (prevIndex != it->first.second)
{
index = prevIndex;
break;
}
++prevIndex;
}
}
}
}
mIndices.emplace(std::make_pair(-1, index), id);
return index;
}
bool IdCollection<ESM::LandTexture>::touchRecord(const ESM::RefId& id)
{
int row = BaseIdCollection<ESM::LandTexture>::touchRecordImp(id);
if (row != -1)
{
const_cast<ESM::LandTexture&>(getRecord(row).get()).mIndex = assignNewIndex(id);
return true;
}
return false;
}
void IdCollection<ESM::LandTexture>::cloneRecord(
const ESM::RefId& origin, const ESM::RefId& destination, const UniversalId::Type type)
{
int row = cloneRecordImp(origin, destination, type);
const_cast<ESM::LandTexture&>(getRecord(row).get()).mIndex = assignNewIndex(destination);
}
void IdCollection<ESM::LandTexture>::appendBlankRecord(const ESM::RefId& id, UniversalId::Type type)
{
ESM::LandTexture record;
record.blank();
record.mId = id;
record.mIndex = assignNewIndex(id);
auto record2 = std::make_unique<Record<ESM::LandTexture>>();
record2->mState = Record<ESM::LandTexture>::State_ModifiedOnly;
record2->mModified = std::move(record);
insertRecord(std::move(record2), getAppendIndex(id, type), type);
}
void IdCollection<ESM::LandTexture>::removeRows(int index, int count)
{
for (int row = index; row < index + count; ++row)
{
const auto& record = getRecord(row);
if (record.isModified())
mIndices.erase({ -1, record.get().mIndex });
}
BaseIdCollection<ESM::LandTexture>::removeRows(index, count);
}
void IdCollection<ESM::LandTexture>::replace(int index, std::unique_ptr<RecordBase> record)
{
const auto& current = getRecord(index);
if (current.isModified() && !record->isModified())
mIndices.erase({ -1, current.get().mIndex });
BaseIdCollection<ESM::LandTexture>::replace(index, std::move(record));
}
}
| 5,549
|
C++
|
.cpp
| 147
| 27.748299
| 119
| 0.567578
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,935
|
scriptcontext.cpp
|
OpenMW_openmw/apps/opencs/model/world/scriptcontext.cpp
|
#include "scriptcontext.hpp"
#include <algorithm>
#include <sstream>
#include <type_traits>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <components/compiler/nullerrorhandler.hpp>
#include <components/compiler/quickfileparser.hpp>
#include <components/compiler/scanner.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadscpt.hpp>
#include <components/esm3/variant.hpp>
#include <components/misc/strings/lower.hpp>
#include "data.hpp"
CSMWorld::ScriptContext::ScriptContext(const Data& data)
: mData(data)
, mIdsUpdated(false)
{
}
bool CSMWorld::ScriptContext::canDeclareLocals() const
{
return true;
}
char CSMWorld::ScriptContext::getGlobalType(const std::string& name) const
{
const int index = mData.getGlobals().searchId(ESM::RefId::stringRefId(name));
if (index != -1)
{
switch (mData.getGlobals().getRecord(index).get().mValue.getType())
{
case ESM::VT_Short:
return 's';
case ESM::VT_Long:
return 'l';
case ESM::VT_Float:
return 'f';
default:
return ' ';
}
}
return ' ';
}
std::pair<char, bool> CSMWorld::ScriptContext::getMemberType(const std::string& name, const ESM::RefId& id) const
{
ESM::RefId id2 = id;
int index = mData.getScripts().searchId(id2);
bool reference = false;
if (index == -1)
{
// ID is not a script ID. Search for a matching referenceable instead.
index = mData.getReferenceables().searchId(id2);
if (index != -1)
{
// Referenceable found.
int columnIndex = mData.getReferenceables().findColumnIndex(Columns::ColumnId_Script);
id2 = ESM::RefId::stringRefId(
mData.getReferenceables().getData(index, columnIndex).toString().toUtf8().constData());
if (!id2.empty())
{
// Referenceable has a script -> use it.
index = mData.getScripts().searchId(id2);
reference = true;
}
}
}
if (index == -1)
return std::make_pair(' ', false);
auto iter = mLocals.find(id2);
if (iter == mLocals.end())
{
Compiler::Locals locals;
Compiler::NullErrorHandler errorHandler;
std::istringstream stream(mData.getScripts().getRecord(index).get().mScriptText);
Compiler::QuickFileParser parser(errorHandler, *this, locals);
Compiler::Scanner scanner(errorHandler, stream, getExtensions());
scanner.scan(parser);
iter = mLocals.emplace(id2, std::move(locals)).first;
}
return std::make_pair(iter->second.getType(Misc::StringUtils::lowerCase(name)), reference);
}
bool CSMWorld::ScriptContext::isId(const ESM::RefId& name) const
{
if (!mIdsUpdated)
{
mIds = mData.getIds();
std::sort(mIds.begin(), mIds.end());
mIdsUpdated = true;
}
return std::binary_search(mIds.begin(), mIds.end(), name);
}
void CSMWorld::ScriptContext::invalidateIds()
{
mIdsUpdated = false;
}
void CSMWorld::ScriptContext::clear()
{
mIds.clear();
mIdsUpdated = false;
mLocals.clear();
}
bool CSMWorld::ScriptContext::clearLocals(const std::string& script)
{
const auto iter = mLocals.find(script);
if (iter != mLocals.end())
{
mLocals.erase(iter);
mIdsUpdated = false;
return true;
}
return false;
}
| 3,646
|
C++
|
.cpp
| 113
| 26.070796
| 113
| 0.645631
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,936
|
refiddata.cpp
|
OpenMW_openmw/apps/opencs/model/world/refiddata.cpp
|
#include "refiddata.hpp"
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/misc/strings/lower.hpp>
#include <memory>
#include <string_view>
#include <type_traits>
namespace ESM
{
class ESMWriter;
}
ESM::RefId CSMWorld::RefIdData::getRecordId(const CSMWorld::RefIdData::LocalIndex& index) const
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator found = mRecordContainers.find(index.second);
if (found == mRecordContainers.end())
throw std::logic_error("invalid local index type");
return found->second->getId(index.first);
}
CSMWorld::RefIdData::RefIdData()
{
mRecordContainers.insert(std::make_pair(UniversalId::Type_Activator, &mActivators));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Potion, &mPotions));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Apparatus, &mApparati));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Armor, &mArmors));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Book, &mBooks));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Clothing, &mClothing));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Container, &mContainers));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Creature, &mCreatures));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Door, &mDoors));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Ingredient, &mIngredients));
mRecordContainers.insert(std::make_pair(UniversalId::Type_CreatureLevelledList, &mCreatureLevelledLists));
mRecordContainers.insert(std::make_pair(UniversalId::Type_ItemLevelledList, &mItemLevelledLists));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Light, &mLights));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Lockpick, &mLockpicks));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Miscellaneous, &mMiscellaneous));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Npc, &mNpcs));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Probe, &mProbes));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Repair, &mRepairs));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Static, &mStatics));
mRecordContainers.insert(std::make_pair(UniversalId::Type_Weapon, &mWeapons));
}
CSMWorld::RefIdData::LocalIndex CSMWorld::RefIdData::globalToLocalIndex(int index) const
{
for (std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter(mRecordContainers.begin());
iter != mRecordContainers.end(); ++iter)
{
if (index < iter->second->getSize())
return LocalIndex(index, iter->first);
index -= iter->second->getSize();
}
throw std::runtime_error("RefIdData index out of range");
}
int CSMWorld::RefIdData::localToGlobalIndex(const LocalIndex& index) const
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator end = mRecordContainers.find(index.second);
if (end == mRecordContainers.end())
throw std::logic_error("invalid local index type");
int globalIndex = index.first;
for (std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter(mRecordContainers.begin());
iter != end; ++iter)
globalIndex += iter->second->getSize();
return globalIndex;
}
CSMWorld::RefIdData::LocalIndex CSMWorld::RefIdData::searchId(const ESM::RefId& id) const
{
auto iter = mIndex.find(id);
if (iter == mIndex.end())
return std::make_pair(-1, CSMWorld::UniversalId::Type_None);
return iter->second;
}
unsigned int CSMWorld::RefIdData::getRecordFlags(const ESM::RefId& id) const
{
LocalIndex localIndex = searchId(id);
switch (localIndex.second)
{
case UniversalId::Type_Activator:
return mActivators.getRecordFlags(localIndex.first);
case UniversalId::Type_Potion:
return mPotions.getRecordFlags(localIndex.first);
case UniversalId::Type_Apparatus:
return mApparati.getRecordFlags(localIndex.first);
case UniversalId::Type_Armor:
return mArmors.getRecordFlags(localIndex.first);
case UniversalId::Type_Book:
return mBooks.getRecordFlags(localIndex.first);
case UniversalId::Type_Clothing:
return mClothing.getRecordFlags(localIndex.first);
case UniversalId::Type_Container:
return mContainers.getRecordFlags(localIndex.first);
case UniversalId::Type_Creature:
return mCreatures.getRecordFlags(localIndex.first);
case UniversalId::Type_Door:
return mDoors.getRecordFlags(localIndex.first);
case UniversalId::Type_Ingredient:
return mIngredients.getRecordFlags(localIndex.first);
case UniversalId::Type_CreatureLevelledList:
return mCreatureLevelledLists.getRecordFlags(localIndex.first);
case UniversalId::Type_ItemLevelledList:
return mItemLevelledLists.getRecordFlags(localIndex.first);
case UniversalId::Type_Light:
return mLights.getRecordFlags(localIndex.first);
case UniversalId::Type_Lockpick:
return mLockpicks.getRecordFlags(localIndex.first);
case UniversalId::Type_Miscellaneous:
return mMiscellaneous.getRecordFlags(localIndex.first);
case UniversalId::Type_Npc:
return mNpcs.getRecordFlags(localIndex.first);
case UniversalId::Type_Probe:
return mProbes.getRecordFlags(localIndex.first);
case UniversalId::Type_Repair:
return mRepairs.getRecordFlags(localIndex.first);
case UniversalId::Type_Static:
return mStatics.getRecordFlags(localIndex.first);
case UniversalId::Type_Weapon:
return mWeapons.getRecordFlags(localIndex.first);
default:
break;
}
return 0;
}
void CSMWorld::RefIdData::erase(int index, int count)
{
LocalIndex localIndex = globalToLocalIndex(index);
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter
= mRecordContainers.find(localIndex.second);
while (count > 0 && iter != mRecordContainers.end())
{
int size = iter->second->getSize();
if (localIndex.first + count > size)
{
erase(localIndex, size - localIndex.first);
count -= size - localIndex.first;
++iter;
if (iter == mRecordContainers.end())
throw std::runtime_error("invalid count value for erase operation");
localIndex.first = 0;
localIndex.second = iter->first;
}
else
{
erase(localIndex, count);
count = 0;
}
}
}
const CSMWorld::RecordBase& CSMWorld::RefIdData::getRecord(const LocalIndex& index) const
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter = mRecordContainers.find(index.second);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
return iter->second->getRecord(index.first);
}
CSMWorld::RecordBase& CSMWorld::RefIdData::getRecord(const LocalIndex& index)
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::iterator iter = mRecordContainers.find(index.second);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
return iter->second->getRecord(index.first);
}
void CSMWorld::RefIdData::appendRecord(UniversalId::Type type, const ESM::RefId& id, bool base)
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::iterator iter = mRecordContainers.find(type);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
iter->second->appendRecord(id, base);
mIndex.insert(std::make_pair(id, LocalIndex(iter->second->getSize() - 1, type)));
}
int CSMWorld::RefIdData::getAppendIndex(UniversalId::Type type) const
{
int index = 0;
for (std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter(mRecordContainers.begin());
iter != mRecordContainers.end(); ++iter)
{
index += iter->second->getSize();
if (type == iter->first)
break;
}
return index;
}
void CSMWorld::RefIdData::load(ESM::ESMReader& reader, bool base, CSMWorld::UniversalId::Type type)
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::iterator found = mRecordContainers.find(type);
if (found == mRecordContainers.end())
throw std::logic_error("Invalid Referenceable ID type");
int index = found->second->load(reader, base);
if (index != -1)
{
LocalIndex localIndex = LocalIndex(index, type);
if (base && getRecord(localIndex).mState == RecordBase::State_Deleted)
{
erase(localIndex, 1);
}
else
{
mIndex[getRecordId(localIndex)] = localIndex;
}
}
}
void CSMWorld::RefIdData::erase(const LocalIndex& index, int count)
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::iterator iter = mRecordContainers.find(index.second);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
for (int i = index.first; i < index.first + count; ++i)
{
auto result = mIndex.find(iter->second->getId(i));
if (result != mIndex.end())
mIndex.erase(result);
}
// Adjust the local indexes to avoid gaps between them after removal of records
int recordIndex = index.first + count;
int recordCount = iter->second->getSize();
while (recordIndex < recordCount)
{
auto recordIndexFound = mIndex.find(iter->second->getId(recordIndex));
if (recordIndexFound != mIndex.end())
{
recordIndexFound->second.first -= count;
}
++recordIndex;
}
iter->second->erase(index.first, count);
}
int CSMWorld::RefIdData::getSize() const
{
return mIndex.size();
}
std::vector<ESM::RefId> CSMWorld::RefIdData::getIds(bool listDeleted) const
{
std::vector<ESM::RefId> ids;
for (auto iter(mIndex.begin()); iter != mIndex.end(); ++iter)
{
if (listDeleted || !getRecord(iter->second).isDeleted())
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator container
= mRecordContainers.find(iter->second.second);
if (container == mRecordContainers.end())
throw std::logic_error("Invalid referenceable ID type");
ids.push_back(container->second->getId(iter->second.first));
}
}
return ids;
}
void CSMWorld::RefIdData::save(int index, ESM::ESMWriter& writer) const
{
LocalIndex localIndex = globalToLocalIndex(index);
std::map<UniversalId::Type, RefIdDataContainerBase*>::const_iterator iter
= mRecordContainers.find(localIndex.second);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
iter->second->save(localIndex.first, writer);
}
const CSMWorld::RefIdDataContainer<ESM::Book>& CSMWorld::RefIdData::getBooks() const
{
return mBooks;
}
const CSMWorld::RefIdDataContainer<ESM::Activator>& CSMWorld::RefIdData::getActivators() const
{
return mActivators;
}
const CSMWorld::RefIdDataContainer<ESM::Potion>& CSMWorld::RefIdData::getPotions() const
{
return mPotions;
}
const CSMWorld::RefIdDataContainer<ESM::Apparatus>& CSMWorld::RefIdData::getApparati() const
{
return mApparati;
}
const CSMWorld::RefIdDataContainer<ESM::Armor>& CSMWorld::RefIdData::getArmors() const
{
return mArmors;
}
const CSMWorld::RefIdDataContainer<ESM::Clothing>& CSMWorld::RefIdData::getClothing() const
{
return mClothing;
}
const CSMWorld::RefIdDataContainer<ESM::Container>& CSMWorld::RefIdData::getContainers() const
{
return mContainers;
}
const CSMWorld::RefIdDataContainer<ESM::Creature>& CSMWorld::RefIdData::getCreatures() const
{
return mCreatures;
}
const CSMWorld::RefIdDataContainer<ESM::Door>& CSMWorld::RefIdData::getDoors() const
{
return mDoors;
}
const CSMWorld::RefIdDataContainer<ESM::Ingredient>& CSMWorld::RefIdData::getIngredients() const
{
return mIngredients;
}
const CSMWorld::RefIdDataContainer<ESM::CreatureLevList>& CSMWorld::RefIdData::getCreatureLevelledLists() const
{
return mCreatureLevelledLists;
}
const CSMWorld::RefIdDataContainer<ESM::ItemLevList>& CSMWorld::RefIdData::getItemLevelledList() const
{
return mItemLevelledLists;
}
const CSMWorld::RefIdDataContainer<ESM::Light>& CSMWorld::RefIdData::getLights() const
{
return mLights;
}
const CSMWorld::RefIdDataContainer<ESM::Lockpick>& CSMWorld::RefIdData::getLocpicks() const
{
return mLockpicks;
}
const CSMWorld::RefIdDataContainer<ESM::Miscellaneous>& CSMWorld::RefIdData::getMiscellaneous() const
{
return mMiscellaneous;
}
const CSMWorld::RefIdDataContainer<ESM::NPC>& CSMWorld::RefIdData::getNPCs() const
{
return mNpcs;
}
const CSMWorld::RefIdDataContainer<ESM::Weapon>& CSMWorld::RefIdData::getWeapons() const
{
return mWeapons;
}
const CSMWorld::RefIdDataContainer<ESM::Probe>& CSMWorld::RefIdData::getProbes() const
{
return mProbes;
}
const CSMWorld::RefIdDataContainer<ESM::Repair>& CSMWorld::RefIdData::getRepairs() const
{
return mRepairs;
}
const CSMWorld::RefIdDataContainer<ESM::Static>& CSMWorld::RefIdData::getStatics() const
{
return mStatics;
}
void CSMWorld::RefIdData::insertRecord(
std::unique_ptr<CSMWorld::RecordBase> record, CSMWorld::UniversalId::Type type, const ESM::RefId& id)
{
std::map<UniversalId::Type, RefIdDataContainerBase*>::iterator iter = mRecordContainers.find(type);
if (iter == mRecordContainers.end())
throw std::logic_error("invalid local index type");
iter->second->insertRecord(std::move(record));
mIndex.insert(std::make_pair(id, LocalIndex(iter->second->getSize() - 1, type)));
}
void CSMWorld::RefIdData::copyTo(int index, RefIdData& target) const
{
LocalIndex localIndex = globalToLocalIndex(index);
auto foundIndex = mRecordContainers.find(localIndex.second);
assert(foundIndex != mRecordContainers.end());
RefIdDataContainerBase* source = foundIndex->second;
target.insertRecord(
source->getRecord(localIndex.first).modifiedCopy(), localIndex.second, source->getId(localIndex.first));
}
| 14,537
|
C++
|
.cpp
| 350
| 35.965714
| 118
| 0.714306
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,937
|
commands.cpp
|
OpenMW_openmw/apps/opencs/model/world/commands.cpp
|
#include "commands.hpp"
#include <algorithm>
#include <cmath>
#include <sstream>
#include <unordered_set>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/land.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadland.hpp>
#include <components/esm3/loadpgrd.hpp>
#include <components/misc/constants.hpp>
#include <QAbstractItemModel>
#include <QAbstractProxyModel>
#include "cellcoordinates.hpp"
#include "idtable.hpp"
#include "idtree.hpp"
#include "nestedtablewrapper.hpp"
#include "pathgrid.hpp"
CSMWorld::TouchCommand::TouchCommand(IdTable& table, const std::string& id, QUndoCommand* parent)
: QUndoCommand(parent)
, mTable(table)
, mId(id)
, mOld(nullptr)
, mChanged(false)
{
setText(("Touch " + mId).c_str());
}
void CSMWorld::TouchCommand::redo()
{
mOld = mTable.getRecord(mId).clone();
mChanged = mTable.touchRecord(mId);
}
void CSMWorld::TouchCommand::undo()
{
if (mChanged)
{
mTable.setRecord(mId, std::move(mOld));
mChanged = false;
}
}
CSMWorld::ImportLandTexturesCommand::ImportLandTexturesCommand(
IdTable& landTable, IdTable& ltexTable, QUndoCommand* parent)
: QUndoCommand(parent)
, mLands(landTable)
, mLtexs(ltexTable)
, mOldState(0)
{
setText("Copy land textures to current plugin");
}
void CSMWorld::ImportLandTexturesCommand::redo()
{
const int pluginColumn = mLands.findColumnIndex(Columns::ColumnId_PluginIndex);
const int oldPlugin = mLands.data(mLands.getModelIndex(getOriginId(), pluginColumn)).toInt();
// Original data
const int textureColumn = mLands.findColumnIndex(Columns::ColumnId_LandTexturesIndex);
mOld = mLands.data(mLands.getModelIndex(getOriginId(), textureColumn)).value<DataType>();
// Need to make a copy so the old values can be looked up
DataType copy(mOld);
// Perform touch/copy/etc...
onRedo();
std::unordered_map<uint16_t, uint16_t> indexMapping;
for (uint16_t index : mOld)
{
// All indices are offset by 1 for a default texture
if (index == 0)
continue;
if (indexMapping.contains(index))
continue;
const CSMWorld::Record<ESM::LandTexture>* record
= static_cast<LandTextureIdTable&>(mLtexs).searchRecord(index - 1, oldPlugin);
if (!record || record->isDeleted())
{
indexMapping.emplace(index, 0);
continue;
}
if (!record->isModified())
{
mTouchedTextures.emplace_back(record->clone());
mLtexs.touchRecord(record->get().mId.getRefIdString());
}
indexMapping.emplace(index, record->get().mIndex + 1);
}
for (int i = 0; i < Land::LAND_NUM_TEXTURES; ++i)
{
uint16_t oldIndex = mOld[i];
uint16_t newIndex = indexMapping[oldIndex];
copy[i] = newIndex;
}
// Apply modification
const int stateColumn = mLands.findColumnIndex(Columns::ColumnId_Modification);
mOldState = mLands.data(mLands.getModelIndex(getDestinationId(), stateColumn)).toInt();
QVariant variant;
variant.setValue(copy);
mLands.setData(mLands.getModelIndex(getDestinationId(), textureColumn), variant);
}
void CSMWorld::ImportLandTexturesCommand::undo()
{
// Restore to previous
int textureColumn = mLands.findColumnIndex(Columns::ColumnId_LandTexturesIndex);
QVariant variant;
variant.setValue(mOld);
mLands.setData(mLands.getModelIndex(getDestinationId(), textureColumn), variant);
int stateColumn = mLands.findColumnIndex(Columns::ColumnId_Modification);
mLands.setData(mLands.getModelIndex(getDestinationId(), stateColumn), mOldState);
// Undo copy/touch/etc...
onUndo();
for (auto& ltex : mTouchedTextures)
{
ESM::RefId id = static_cast<Record<ESM::LandTexture>*>(ltex.get())->get().mId;
mLtexs.setRecord(id.getRefIdString(), std::move(ltex));
}
mTouchedTextures.clear();
}
CSMWorld::CopyLandTexturesCommand::CopyLandTexturesCommand(
IdTable& landTable, IdTable& ltexTable, const std::string& origin, const std::string& dest, QUndoCommand* parent)
: ImportLandTexturesCommand(landTable, ltexTable, parent)
, mOriginId(origin)
, mDestId(dest)
{
}
const std::string& CSMWorld::CopyLandTexturesCommand::getOriginId() const
{
return mOriginId;
}
const std::string& CSMWorld::CopyLandTexturesCommand::getDestinationId() const
{
return mDestId;
}
CSMWorld::TouchLandCommand::TouchLandCommand(
IdTable& landTable, IdTable& ltexTable, const std::string& id, QUndoCommand* parent)
: ImportLandTexturesCommand(landTable, ltexTable, parent)
, mId(id)
, mOld(nullptr)
, mChanged(false)
{
setText(("Touch " + mId).c_str());
}
const std::string& CSMWorld::TouchLandCommand::getOriginId() const
{
return mId;
}
const std::string& CSMWorld::TouchLandCommand::getDestinationId() const
{
return mId;
}
void CSMWorld::TouchLandCommand::onRedo()
{
mOld = mLands.getRecord(mId).clone();
mChanged = mLands.touchRecord(mId);
}
void CSMWorld::TouchLandCommand::onUndo()
{
if (mChanged)
{
mLands.setRecord(mId, std::move(mOld));
mChanged = false;
}
}
CSMWorld::ModifyCommand::ModifyCommand(
QAbstractItemModel& model, const QModelIndex& index, const QVariant& new_, QUndoCommand* parent)
: QUndoCommand(parent)
, mModel(&model)
, mIndex(index)
, mNew(new_)
, mHasRecordState(false)
, mOldRecordState(CSMWorld::RecordBase::State_BaseOnly)
{
if (QAbstractProxyModel* proxy = dynamic_cast<QAbstractProxyModel*>(mModel))
{
// Replace proxy with actual model
mIndex = proxy->mapToSource(mIndex);
mModel = proxy->sourceModel();
}
}
void CSMWorld::ModifyCommand::redo()
{
if (mIndex.parent().isValid())
{
CSMWorld::IdTree* tree = &dynamic_cast<CSMWorld::IdTree&>(*mModel);
setText("Modify "
+ tree->nestedHeaderData(mIndex.parent().column(), mIndex.column(), Qt::Horizontal, Qt::DisplayRole)
.toString());
}
else
{
setText("Modify " + mModel->headerData(mIndex.column(), Qt::Horizontal, Qt::DisplayRole).toString());
}
// Remember record state before the modification
if (CSMWorld::IdTable* table = dynamic_cast<IdTable*>(mModel))
{
mHasRecordState = true;
int stateColumnIndex = table->findColumnIndex(Columns::ColumnId_Modification);
int rowIndex = mIndex.row();
if (mIndex.parent().isValid())
{
rowIndex = mIndex.parent().row();
}
mRecordStateIndex = table->index(rowIndex, stateColumnIndex);
mOldRecordState = static_cast<CSMWorld::RecordBase::State>(table->data(mRecordStateIndex).toInt());
}
mOld = mModel->data(mIndex, Qt::EditRole);
mModel->setData(mIndex, mNew);
}
void CSMWorld::ModifyCommand::undo()
{
mModel->setData(mIndex, mOld);
if (mHasRecordState)
{
mModel->setData(mRecordStateIndex, mOldRecordState);
}
}
void CSMWorld::CreateCommand::applyModifications()
{
if (!mNestedValues.empty())
{
CSMWorld::IdTree* tree = &dynamic_cast<CSMWorld::IdTree&>(mModel);
std::map<int, std::pair<int, QVariant>>::const_iterator current = mNestedValues.begin();
std::map<int, std::pair<int, QVariant>>::const_iterator end = mNestedValues.end();
for (; current != end; ++current)
{
QModelIndex index = tree->index(0, current->second.first, tree->getNestedModelIndex(mId, current->first));
tree->setData(index, current->second.second);
}
}
}
CSMWorld::CreateCommand::CreateCommand(IdTable& model, const std::string& id, QUndoCommand* parent)
: QUndoCommand(parent)
, mModel(model)
, mId(id)
, mType(UniversalId::Type_None)
{
setText(("Create record " + id).c_str());
}
void CSMWorld::CreateCommand::addValue(int column, const QVariant& value)
{
mValues[column] = value;
}
void CSMWorld::CreateCommand::addNestedValue(int parentColumn, int nestedColumn, const QVariant& value)
{
mNestedValues[parentColumn] = std::make_pair(nestedColumn, value);
}
void CSMWorld::CreateCommand::setType(UniversalId::Type type)
{
mType = type;
}
void CSMWorld::CreateCommand::redo()
{
mModel.addRecordWithData(mId, mValues, mType);
applyModifications();
}
void CSMWorld::CreateCommand::undo()
{
mModel.removeRow(mModel.getModelIndex(mId, 0).row());
}
CSMWorld::RevertCommand::RevertCommand(IdTable& model, const std::string& id, QUndoCommand* parent)
: QUndoCommand(parent)
, mModel(model)
, mId(id)
, mOld(nullptr)
{
setText(("Revert record " + id).c_str());
}
void CSMWorld::RevertCommand::redo()
{
mOld = mModel.getRecord(mId).clone();
int column = mModel.findColumnIndex(Columns::ColumnId_Modification);
QModelIndex index = mModel.getModelIndex(mId, column);
RecordBase::State state = static_cast<RecordBase::State>(mModel.data(index).toInt());
if (state == RecordBase::State_ModifiedOnly)
{
mModel.removeRows(index.row(), 1);
}
else
{
mModel.setData(index, static_cast<int>(RecordBase::State_BaseOnly));
}
}
void CSMWorld::RevertCommand::undo()
{
mModel.setRecord(mId, std::move(mOld));
}
CSMWorld::DeleteCommand::DeleteCommand(
IdTable& model, const std::string& id, CSMWorld::UniversalId::Type type, QUndoCommand* parent)
: QUndoCommand(parent)
, mModel(model)
, mId(id)
, mOld(nullptr)
, mType(type)
{
setText(("Delete record " + id).c_str());
}
void CSMWorld::DeleteCommand::redo()
{
mOld = mModel.getRecord(mId).clone();
int column = mModel.findColumnIndex(Columns::ColumnId_Modification);
QModelIndex index = mModel.getModelIndex(mId, column);
RecordBase::State state = static_cast<RecordBase::State>(mModel.data(index).toInt());
if (state == RecordBase::State_ModifiedOnly)
{
mModel.removeRows(index.row(), 1);
}
else
{
mModel.setData(index, static_cast<int>(RecordBase::State_Deleted));
}
}
void CSMWorld::DeleteCommand::undo()
{
mModel.setRecord(mId, std::move(mOld), mType);
}
CSMWorld::ReorderRowsCommand::ReorderRowsCommand(IdTable& model, int baseIndex, const std::vector<int>& newOrder)
: mModel(model)
, mBaseIndex(baseIndex)
, mNewOrder(newOrder)
{
}
void CSMWorld::ReorderRowsCommand::redo()
{
mModel.reorderRows(mBaseIndex, mNewOrder);
}
void CSMWorld::ReorderRowsCommand::undo()
{
int size = static_cast<int>(mNewOrder.size());
std::vector<int> reverse(size);
for (int i = 0; i < size; ++i)
reverse.at(mNewOrder[i]) = i;
mModel.reorderRows(mBaseIndex, reverse);
}
CSMWorld::CloneCommand::CloneCommand(CSMWorld::IdTable& model, const std::string& idOrigin,
const std::string& idDestination, const CSMWorld::UniversalId::Type type, QUndoCommand* parent)
: CreateCommand(model, idDestination, parent)
, mIdOrigin(idOrigin)
{
setType(type);
setText(("Clone record " + idOrigin + " to the " + idDestination).c_str());
}
void CSMWorld::CloneCommand::redo()
{
mModel.cloneRecord(ESM::RefId::stringRefId(mIdOrigin), ESM::RefId::stringRefId(mId), mType);
applyModifications();
for (auto& value : mOverrideValues)
{
mModel.setData(mModel.getModelIndex(mId, value.first), value.second);
}
}
void CSMWorld::CloneCommand::undo()
{
mModel.removeRow(mModel.getModelIndex(mId, 0).row());
}
void CSMWorld::CloneCommand::setOverrideValue(int column, QVariant value)
{
mOverrideValues.emplace_back(std::make_pair(column, value));
}
CSMWorld::CreatePathgridCommand::CreatePathgridCommand(IdTable& model, const std::string& id, QUndoCommand* parent)
: CreateCommand(model, id, parent)
{
setType(UniversalId::Type_Pathgrid);
}
void CSMWorld::CreatePathgridCommand::redo()
{
CreateCommand::redo();
std::unique_ptr<Record<Pathgrid>> record
= std::make_unique<Record<Pathgrid>>(static_cast<const Record<Pathgrid>&>(mModel.getRecord(mId)));
record->get().blank();
record->get().mCell = ESM::RefId::stringRefId(mId);
std::pair<CellCoordinates, bool> coords = CellCoordinates::fromId(mId);
if (coords.second)
{
record->get().mData.mX = coords.first.getX();
record->get().mData.mY = coords.first.getY();
}
mModel.setRecord(mId, std::move(record), mType);
}
CSMWorld::UpdateCellCommand::UpdateCellCommand(IdTable& model, int row, QUndoCommand* parent)
: QUndoCommand(parent)
, mModel(model)
, mRow(row)
{
setText("Update cell ID");
}
void CSMWorld::UpdateCellCommand::redo()
{
if (!mNew.isValid())
{
int cellColumn = mModel.searchColumnIndex(Columns::ColumnId_Cell);
mIndex = mModel.index(mRow, cellColumn);
QModelIndex xIndex = mModel.index(mRow, mModel.findColumnIndex(Columns::ColumnId_PositionXPos));
QModelIndex yIndex = mModel.index(mRow, mModel.findColumnIndex(Columns::ColumnId_PositionYPos));
int x = std::floor(mModel.data(xIndex).toFloat() / Constants::CellSizeInUnits);
int y = std::floor(mModel.data(yIndex).toFloat() / Constants::CellSizeInUnits);
std::ostringstream stream;
stream << "#" << x << " " << y;
mNew = QString::fromUtf8(stream.str().c_str());
}
mModel.setData(mIndex, mNew);
}
void CSMWorld::UpdateCellCommand::undo()
{
mModel.setData(mIndex, mOld);
}
CSMWorld::DeleteNestedCommand::DeleteNestedCommand(
IdTree& model, const std::string& id, int nestedRow, int parentColumn, QUndoCommand* parent)
: QUndoCommand(parent)
, NestedTableStoring(model, id, parentColumn)
, mModel(model)
, mId(id)
, mParentColumn(parentColumn)
, mNestedRow(nestedRow)
{
std::string title = model.headerData(parentColumn, Qt::Horizontal, Qt::DisplayRole).toString().toUtf8().constData();
setText(("Delete row in " + title + " sub-table of " + mId).c_str());
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModifyParentCommand = new ModifyCommand(mModel, parentIndex, parentIndex.data(Qt::EditRole), this);
}
void CSMWorld::DeleteNestedCommand::redo()
{
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModifyParentCommand->redo();
mModel.removeRows(mNestedRow, 1, parentIndex);
}
void CSMWorld::DeleteNestedCommand::undo()
{
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModel.setNestedTable(parentIndex, getOld());
mModifyParentCommand->undo();
}
CSMWorld::AddNestedCommand::AddNestedCommand(
IdTree& model, const std::string& id, int nestedRow, int parentColumn, QUndoCommand* parent)
: QUndoCommand(parent)
, NestedTableStoring(model, id, parentColumn)
, mModel(model)
, mId(id)
, mNewRow(nestedRow)
, mParentColumn(parentColumn)
{
std::string title = model.headerData(parentColumn, Qt::Horizontal, Qt::DisplayRole).toString().toUtf8().constData();
setText(("Add row in " + title + " sub-table of " + mId).c_str());
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModifyParentCommand = new ModifyCommand(mModel, parentIndex, parentIndex.data(Qt::EditRole), this);
}
void CSMWorld::AddNestedCommand::redo()
{
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModifyParentCommand->redo();
mModel.addNestedRow(parentIndex, mNewRow);
}
void CSMWorld::AddNestedCommand::undo()
{
QModelIndex parentIndex = mModel.getModelIndex(mId, mParentColumn);
mModel.setNestedTable(parentIndex, getOld());
mModifyParentCommand->undo();
}
CSMWorld::NestedTableStoring::NestedTableStoring(const IdTree& model, const std::string& id, int parentColumn)
: mOld(model.nestedTable(model.getModelIndex(id, parentColumn)))
{
}
CSMWorld::NestedTableStoring::~NestedTableStoring()
{
delete mOld;
}
const CSMWorld::NestedTableWrapperBase& CSMWorld::NestedTableStoring::getOld() const
{
return *mOld;
}
| 16,148
|
C++
|
.cpp
| 465
| 30.288172
| 120
| 0.705335
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,938
|
idcompletionmanager.cpp
|
OpenMW_openmw/apps/opencs/model/world/idcompletionmanager.cpp
|
#include "idcompletionmanager.hpp"
#include <QAbstractItemModel>
#include <QCompleter>
#include <algorithm>
#include <stdexcept>
#include <utility>
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include "../../view/widget/completerpopup.hpp"
#include "data.hpp"
#include "idtablebase.hpp"
class QAbstractItemView;
namespace
{
std::map<CSMWorld::ColumnBase::Display, CSMWorld::UniversalId::Type> generateModelTypes()
{
std::map<CSMWorld::ColumnBase::Display, CSMWorld::UniversalId::Type> types;
types[CSMWorld::ColumnBase::Display_BodyPart] = CSMWorld::UniversalId::Type_BodyPart;
types[CSMWorld::ColumnBase::Display_Cell] = CSMWorld::UniversalId::Type_Cell;
types[CSMWorld::ColumnBase::Display_Class] = CSMWorld::UniversalId::Type_Class;
types[CSMWorld::ColumnBase::Display_CreatureLevelledList] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Creature] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Enchantment] = CSMWorld::UniversalId::Type_Enchantment;
types[CSMWorld::ColumnBase::Display_Faction] = CSMWorld::UniversalId::Type_Faction;
types[CSMWorld::ColumnBase::Display_GlobalVariable] = CSMWorld::UniversalId::Type_Global;
types[CSMWorld::ColumnBase::Display_Icon] = CSMWorld::UniversalId::Type_Icon;
types[CSMWorld::ColumnBase::Display_Journal] = CSMWorld::UniversalId::Type_Journal;
types[CSMWorld::ColumnBase::Display_Mesh] = CSMWorld::UniversalId::Type_Mesh;
types[CSMWorld::ColumnBase::Display_Miscellaneous] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Npc] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Race] = CSMWorld::UniversalId::Type_Race;
types[CSMWorld::ColumnBase::Display_Region] = CSMWorld::UniversalId::Type_Region;
types[CSMWorld::ColumnBase::Display_Referenceable] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Script] = CSMWorld::UniversalId::Type_Script;
types[CSMWorld::ColumnBase::Display_Skill] = CSMWorld::UniversalId::Type_Skill;
types[CSMWorld::ColumnBase::Display_Sound] = CSMWorld::UniversalId::Type_Sound;
types[CSMWorld::ColumnBase::Display_SoundRes] = CSMWorld::UniversalId::Type_SoundRes;
types[CSMWorld::ColumnBase::Display_Spell] = CSMWorld::UniversalId::Type_Spell;
types[CSMWorld::ColumnBase::Display_Static] = CSMWorld::UniversalId::Type_Referenceable;
types[CSMWorld::ColumnBase::Display_Texture] = CSMWorld::UniversalId::Type_Texture;
types[CSMWorld::ColumnBase::Display_Topic] = CSMWorld::UniversalId::Type_Topic;
types[CSMWorld::ColumnBase::Display_Weapon] = CSMWorld::UniversalId::Type_Referenceable;
return types;
}
typedef std::map<CSMWorld::ColumnBase::Display, CSMWorld::UniversalId::Type>::const_iterator ModelTypeConstIterator;
}
const std::map<CSMWorld::ColumnBase::Display, CSMWorld::UniversalId::Type>
CSMWorld::IdCompletionManager::sCompleterModelTypes = generateModelTypes();
std::vector<CSMWorld::ColumnBase::Display> CSMWorld::IdCompletionManager::getDisplayTypes()
{
std::vector<CSMWorld::ColumnBase::Display> types;
ModelTypeConstIterator current = sCompleterModelTypes.begin();
ModelTypeConstIterator end = sCompleterModelTypes.end();
for (; current != end; ++current)
{
types.push_back(current->first);
}
// Hack for Display_InfoCondVar
types.push_back(CSMWorld::ColumnBase::Display_InfoCondVar);
return types;
}
CSMWorld::IdCompletionManager::IdCompletionManager(CSMWorld::Data& data)
{
generateCompleters(data);
}
bool CSMWorld::IdCompletionManager::hasCompleterFor(CSMWorld::ColumnBase::Display display) const
{
return mCompleters.find(display) != mCompleters.end();
}
std::shared_ptr<QCompleter> CSMWorld::IdCompletionManager::getCompleter(CSMWorld::ColumnBase::Display display)
{
if (!hasCompleterFor(display))
{
throw std::logic_error("This column doesn't have an ID completer");
}
return mCompleters[display];
}
void CSMWorld::IdCompletionManager::generateCompleters(CSMWorld::Data& data)
{
ModelTypeConstIterator current = sCompleterModelTypes.begin();
ModelTypeConstIterator end = sCompleterModelTypes.end();
for (; current != end; ++current)
{
QAbstractItemModel* model = data.getTableModel(current->second);
CSMWorld::IdTableBase* table = dynamic_cast<CSMWorld::IdTableBase*>(model);
if (table != nullptr)
{
int idColumn = table->searchColumnIndex(CSMWorld::Columns::ColumnId_Id);
if (idColumn != -1)
{
std::shared_ptr<QCompleter> completer = std::make_shared<QCompleter>(table);
completer->setCompletionColumn(idColumn);
// The completion role must be Qt::DisplayRole to get the ID values from the model
completer->setCompletionRole(Qt::DisplayRole);
completer->setCaseSensitivity(Qt::CaseInsensitive);
QAbstractItemView* popup = new CSVWidget::CompleterPopup();
completer->setPopup(popup); // The completer takes ownership of the popup
completer->setMaxVisibleItems(10);
mCompleters[current->first] = std::move(completer);
}
}
}
}
| 5,572
|
C++
|
.cpp
| 104
| 46.961538
| 120
| 0.725037
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,939
|
ref.cpp
|
OpenMW_openmw/apps/opencs/model/world/ref.cpp
|
#include "ref.hpp"
#include <components/esm/defs.hpp>
#include "cellcoordinates.hpp"
CSMWorld::CellRef::CellRef()
: mNew(true)
, mIdNum(0)
{
}
std::pair<int, int> CSMWorld::CellRef::getCellIndex() const
{
return CellCoordinates::coordinatesToCellIndex(mPos.pos[0], mPos.pos[1]);
}
| 297
|
C++
|
.cpp
| 12
| 22.416667
| 77
| 0.733096
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,941
|
idtableproxymodel.cpp
|
OpenMW_openmw/apps/opencs/model/world/idtableproxymodel.cpp
|
#include "idtableproxymodel.hpp"
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QSortFilterProxyModel>
#include <QString>
#include <compare>
#include <type_traits>
#include <vector>
#include <apps/opencs/model/filter/node.hpp>
#include <apps/opencs/model/world/columns.hpp>
#include "columnbase.hpp"
#include "idtablebase.hpp"
class QObject;
namespace
{
std::string getEnumValue(const std::vector<std::pair<int, std::string>>& values, int index)
{
if (index < 0 || index >= static_cast<int>(values.size()))
{
return "";
}
return values[index].second;
}
}
void CSMWorld::IdTableProxyModel::updateColumnMap()
{
Q_ASSERT(mSourceModel != nullptr);
mColumnMap.clear();
if (mFilter)
{
std::vector<int> columns = mFilter->getReferencedColumns();
for (std::vector<int>::const_iterator iter(columns.begin()); iter != columns.end(); ++iter)
mColumnMap.insert(std::make_pair(
*iter, mSourceModel->searchColumnIndex(static_cast<CSMWorld::Columns::ColumnId>(*iter))));
}
}
bool CSMWorld::IdTableProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
{
Q_ASSERT(mSourceModel != nullptr);
// It is not possible to use filterAcceptsColumn() and check for
// sourceModel()->headerData (sourceColumn, Qt::Horizontal, CSMWorld::ColumnBase::Role_Flags)
// because the sourceColumn parameter excludes the hidden columns, i.e. wrong columns can
// be rejected. Workaround by disallowing tree branches (nested columns), which are not meant
// to be visible, from the filter.
if (sourceParent.isValid())
return false;
if (!mFilter)
return true;
return mFilter->test(*mSourceModel, sourceRow, mColumnMap);
}
CSMWorld::IdTableProxyModel::IdTableProxyModel(QObject* parent)
: QSortFilterProxyModel(parent)
, mFilterTimer{ new QTimer(this) }
, mSourceModel(nullptr)
{
setSortCaseSensitivity(Qt::CaseInsensitive);
mFilterTimer->setSingleShot(true);
int intervalSetting = CSMPrefs::State::get()["ID Tables"]["filter-delay"].toInt();
mFilterTimer->setInterval(intervalSetting);
connect(&CSMPrefs::State::get(), &CSMPrefs::State::settingChanged, this,
[this](const CSMPrefs::Setting* setting) { this->settingChanged(setting); });
connect(mFilterTimer.get(), &QTimer::timeout, this, [this]() { this->timerTimeout(); });
}
QModelIndex CSMWorld::IdTableProxyModel::getModelIndex(const std::string& id, int column) const
{
Q_ASSERT(mSourceModel != nullptr);
return mapFromSource(mSourceModel->getModelIndex(id, column));
}
void CSMWorld::IdTableProxyModel::setSourceModel(QAbstractItemModel* model)
{
QSortFilterProxyModel::setSourceModel(model);
mSourceModel = dynamic_cast<IdTableBase*>(sourceModel());
connect(mSourceModel, &IdTableBase::rowsInserted, this, &IdTableProxyModel::sourceRowsInserted);
connect(mSourceModel, &IdTableBase::rowsRemoved, this, &IdTableProxyModel::sourceRowsRemoved);
connect(mSourceModel, &IdTableBase::dataChanged, this, &IdTableProxyModel::sourceDataChanged);
}
void CSMWorld::IdTableProxyModel::setFilter(const std::shared_ptr<CSMFilter::Node>& filter)
{
mAwaitingFilter = filter;
mFilterTimer->start();
}
bool CSMWorld::IdTableProxyModel::lessThan(const QModelIndex& left, const QModelIndex& right) const
{
Columns::ColumnId id = static_cast<Columns::ColumnId>(left.data(ColumnBase::Role_ColumnId).toInt());
EnumColumnCache::const_iterator valuesIt = mEnumColumnCache.find(id);
if (valuesIt == mEnumColumnCache.end())
{
if (Columns::hasEnums(id))
{
valuesIt = mEnumColumnCache.insert(std::make_pair(id, Columns::getEnums(id))).first;
}
}
if (valuesIt != mEnumColumnCache.end())
{
std::string first = getEnumValue(valuesIt->second, left.data().toInt());
std::string second = getEnumValue(valuesIt->second, right.data().toInt());
return first < second;
}
return QSortFilterProxyModel::lessThan(left, right);
}
QString CSMWorld::IdTableProxyModel::getRecordId(int sourceRow) const
{
Q_ASSERT(mSourceModel != nullptr);
int idColumn = mSourceModel->findColumnIndex(Columns::ColumnId_Id);
return mSourceModel->data(mSourceModel->index(sourceRow, idColumn)).toString();
}
void CSMWorld::IdTableProxyModel::refreshFilter()
{
if (mFilter)
{
updateColumnMap();
invalidateFilter();
}
}
void CSMWorld::IdTableProxyModel::timerTimeout()
{
if (mAwaitingFilter)
{
beginResetModel();
mFilter = mAwaitingFilter;
updateColumnMap();
endResetModel();
mAwaitingFilter.reset();
}
}
void CSMWorld::IdTableProxyModel::settingChanged(const CSMPrefs::Setting* setting)
{
if (*setting == "ID Tables/filter-delay")
{
mFilterTimer->setInterval(setting->toInt());
}
}
void CSMWorld::IdTableProxyModel::sourceRowsInserted(const QModelIndex& parent, int /*start*/, int end)
{
refreshFilter();
if (!parent.isValid())
{
emit rowAdded(getRecordId(end).toUtf8().constData());
}
}
void CSMWorld::IdTableProxyModel::sourceRowsRemoved(const QModelIndex& /*parent*/, int /*start*/, int /*end*/)
{
refreshFilter();
}
void CSMWorld::IdTableProxyModel::sourceDataChanged(const QModelIndex& /*topLeft*/, const QModelIndex& /*bottomRight*/)
{
refreshFilter();
}
| 5,482
|
C++
|
.cpp
| 148
| 32.513514
| 119
| 0.715498
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,942
|
columns.cpp
|
OpenMW_openmw/apps/opencs/model/world/columns.cpp
|
#include "columns.hpp"
#include <algorithm>
#include <string_view>
#include <components/fallback/fallback.hpp>
#include <components/misc/strings/algorithm.hpp>
#include "infoselectwrapper.hpp"
#include "universalid.hpp"
namespace CSMWorld
{
namespace Columns
{
struct ColumnDesc
{
int mId;
const char* mName;
};
const ColumnDesc sNames[] = {
{ ColumnId_Value, "Value" },
{ ColumnId_Id, "ID" },
{ ColumnId_Modification, "Modified" },
{ ColumnId_RecordType, "Record Type" },
{ ColumnId_ValueType, "Value Type" },
{ ColumnId_Description, "Description" },
{ ColumnId_Specialisation, "Specialisation" },
{ ColumnId_Attribute, "Attribute" },
{ ColumnId_Name, "Name" },
{ ColumnId_Playable, "Playable" },
{ ColumnId_Hidden, "Hidden" },
{ ColumnId_MaleWeight, "Male Weight" },
{ ColumnId_FemaleWeight, "Female Weight" },
{ ColumnId_MaleHeight, "Male Height" },
{ ColumnId_FemaleHeight, "Female Height" },
{ ColumnId_Volume, "Volume" },
{ ColumnId_MinRange, "Min Range" },
{ ColumnId_MaxRange, "Max Range" },
{ ColumnId_MinMagnitude, "Min Magnitude" },
{ ColumnId_MaxMagnitude, "Max Magnitude" },
{ ColumnId_SoundFile, "Sound File" },
{ ColumnId_MapColour, "Map Colour" },
{ ColumnId_SleepEncounter, "Sleep Encounter" },
{ ColumnId_Texture, "Texture" },
{ ColumnId_SpellType, "Spell Type" },
{ ColumnId_Cost, "Cost" },
{ ColumnId_ScriptText, "Script Text" },
{ ColumnId_Region, "Region" },
{ ColumnId_Cell, "Cell" },
{ ColumnId_Scale, "Scale" },
{ ColumnId_Owner, "Owner" },
{ ColumnId_Soul, "Soul" },
{ ColumnId_Faction, "Faction" },
{ ColumnId_FactionIndex, "Faction Index" },
{ ColumnId_Charges, "Charges" },
{ ColumnId_Enchantment, "Enchantment" },
{ ColumnId_StackCount, "Count" },
{ ColumnId_GoldValue, "Value" },
{ ColumnId_Teleport, "Teleport" },
{ ColumnId_TeleportCell, "Teleport Cell" },
{ ColumnId_IsLocked, "Locked" },
{ ColumnId_LockLevel, "Lock Level" },
{ ColumnId_Key, "Key" },
{ ColumnId_Trap, "Trap" },
{ ColumnId_BeastRace, "Beast Race" },
{ ColumnId_AutoCalc, "Auto Calc" },
{ ColumnId_StarterSpell, "Starter Spell" },
{ ColumnId_AlwaysSucceeds, "Always Succeeds" },
{ ColumnId_SleepForbidden, "Sleep Forbidden" },
{ ColumnId_InteriorWater, "Interior Water" },
{ ColumnId_InteriorSky, "Interior Sky" },
{ ColumnId_Model, "Model/Animation" },
{ ColumnId_Script, "Script" },
{ ColumnId_Icon, "Icon" },
{ ColumnId_Weight, "Weight" },
{ ColumnId_EnchantmentPoints, "Enchantment Points" },
{ ColumnId_Quality, "Quality" },
{ ColumnId_AiHello, "AI Hello" },
{ ColumnId_AiFlee, "AI Flee" },
{ ColumnId_AiFight, "AI Fight" },
{ ColumnId_AiAlarm, "AI Alarm" },
{ ColumnId_BuysWeapons, "Buys Weapons" },
{ ColumnId_BuysArmor, "Buys Armor" },
{ ColumnId_BuysClothing, "Buys Clothing" },
{ ColumnId_BuysBooks, "Buys Books" },
{ ColumnId_BuysIngredients, "Buys Ingredients" },
{ ColumnId_BuysLockpicks, "Buys Lockpicks" },
{ ColumnId_BuysProbes, "Buys Probes" },
{ ColumnId_BuysLights, "Buys Lights" },
{ ColumnId_BuysApparati, "Buys Apparati" },
{ ColumnId_BuysRepairItems, "Buys Repair Items" },
{ ColumnId_BuysMiscItems, "Buys Misc Items" },
{ ColumnId_BuysPotions, "Buys Potions" },
{ ColumnId_BuysMagicItems, "Buys Magic Items" },
{ ColumnId_SellsSpells, "Sells Spells" },
{ ColumnId_Trainer, "Trainer" },
{ ColumnId_Spellmaking, "Spellmaking" },
{ ColumnId_EnchantingService, "Enchanting Service" },
{ ColumnId_RepairService, "Repair Service" },
{ ColumnId_ApparatusType, "Apparatus Type" },
{ ColumnId_ArmorType, "Armor Type" },
{ ColumnId_Health, "Health" },
{ ColumnId_ArmorValue, "Armor Value" },
{ ColumnId_BookType, "Book Type" },
{ ColumnId_ClothingType, "Clothing Type" },
{ ColumnId_WeightCapacity, "Weight Capacity" },
{ ColumnId_OrganicContainer, "Organic Container" },
{ ColumnId_Respawn, "Respawn" },
{ ColumnId_CreatureType, "Creature Type" },
{ ColumnId_SoulPoints, "Soul Points" },
{ ColumnId_ParentCreature, "Parent Creature" },
{ ColumnId_Biped, "Biped" },
{ ColumnId_HasWeapon, "Has Weapon" },
{ ColumnId_Swims, "Swims" },
{ ColumnId_Flies, "Flies" },
{ ColumnId_Walks, "Walks" },
{ ColumnId_Essential, "Essential" },
{ ColumnId_BloodType, "Blood Type" },
{ ColumnId_OpenSound, "Open Sound" },
{ ColumnId_CloseSound, "Close Sound" },
{ ColumnId_Duration, "Duration" },
{ ColumnId_Radius, "Radius" },
{ ColumnId_Colour, "Colour" },
{ ColumnId_Sound, "Sound" },
{ ColumnId_Dynamic, "Dynamic" },
{ ColumnId_Portable, "Portable" },
{ ColumnId_NegativeLight, "Negative Light" },
{ ColumnId_EmitterType, "Emitter Type" },
{ ColumnId_Fire, "Fire" },
{ ColumnId_OffByDefault, "Off by default" },
{ ColumnId_IsKey, "Is Key" },
{ ColumnId_Race, "Race" },
{ ColumnId_Class, "Class" },
{ Columnid_Hair, "Hair" },
{ ColumnId_Head, "Head" },
{ ColumnId_Female, "Female" },
{ ColumnId_WeaponType, "Weapon Type" },
{ ColumnId_WeaponSpeed, "Weapon Speed" },
{ ColumnId_WeaponReach, "Weapon Reach" },
{ ColumnId_MinChop, "Min Chop" },
{ ColumnId_MaxChip, "Max Chop" },
{ Columnid_MinSlash, "Min Slash" },
{ ColumnId_MaxSlash, "Max Slash" },
{ ColumnId_MinThrust, "Min Thrust" },
{ ColumnId_MaxThrust, "Max Thrust" },
{ ColumnId_Magical, "Magical" },
{ ColumnId_Silver, "Silver" },
{ ColumnId_Filter, "Filter" },
{ ColumnId_PositionXPos, "Pos X" },
{ ColumnId_PositionYPos, "Pos Y" },
{ ColumnId_PositionZPos, "Pos Z" },
{ ColumnId_PositionXRot, "Rot X" },
{ ColumnId_PositionYRot, "Rot Y" },
{ ColumnId_PositionZRot, "Rot Z" },
{ ColumnId_DoorPositionXPos, "Teleport Pos X" },
{ ColumnId_DoorPositionYPos, "Teleport Pos Y" },
{ ColumnId_DoorPositionZPos, "Teleport Pos Z" },
{ ColumnId_DoorPositionXRot, "Teleport Rot X" },
{ ColumnId_DoorPositionYRot, "Teleport Rot Y" },
{ ColumnId_DoorPositionZRot, "Teleport Rot Z" },
{ ColumnId_DialogueType, "Dialogue Type" },
{ ColumnId_QuestIndex, "Quest Index" },
{ ColumnId_QuestStatusType, "Quest Status" },
{ ColumnId_QuestDescription, "Quest Description" },
{ ColumnId_Topic, "Topic" },
{ ColumnId_Journal, "Journal" },
{ ColumnId_Actor, "Actor" },
{ ColumnId_PcFaction, "PC Faction" },
{ ColumnId_Response, "Response" },
{ ColumnId_Disposition, "Disposition" },
{ ColumnId_Rank, "Rank" },
{ ColumnId_Gender, "Gender" },
{ ColumnId_PcRank, "PC Rank" },
{ ColumnId_ReferenceableId, "Object ID" },
{ ColumnId_ContainerContent, "Content" },
{ ColumnId_ItemCount, "Count" },
{ ColumnId_InventoryItemId, "Item ID" },
{ ColumnId_CombatState, "Combat" },
{ ColumnId_MagicState, "Magic" },
{ ColumnId_StealthState, "Stealth" },
{ ColumnId_EnchantmentType, "Enchantment Type" },
{ ColumnId_Vampire, "Vampire" },
{ ColumnId_BodyPartType, "Bodypart Type" },
{ ColumnId_MeshType, "Mesh Type" },
{ ColumnId_ActorInventory, "Inventory" },
{ ColumnId_SpellList, "Spells" },
{ ColumnId_SpellId, "Spell ID" },
{ ColumnId_NpcDestinations, "Destinations" },
{ ColumnId_DestinationCell, "Dest Cell" },
{ ColumnId_PosX, "Dest X" },
{ ColumnId_PosY, "Dest Y" },
{ ColumnId_PosZ, "Dest Z" },
{ ColumnId_RotX, "Rotation X" },
{ ColumnId_RotY, "Rotation Y" },
{ ColumnId_RotZ, "Rotation Z" },
{ ColumnId_OwnerGlobal, "Owner Global" },
{ ColumnId_DefaultProfile, "Default Profile" },
{ ColumnId_BypassNewGame, "Bypass New Game" },
{ ColumnId_GlobalProfile, "Global Profile" },
{ ColumnId_RefNumCounter, "RefNum Counter" },
{ ColumnId_RefNum, "RefNum" },
{ ColumnId_Creature, "Creature" },
{ ColumnId_SoundGeneratorType, "Sound Generator Type" },
{ ColumnId_AllowSpellmaking, "Allow Spellmaking" },
{ ColumnId_AllowEnchanting, "Allow Enchanting" },
{ ColumnId_BaseCost, "Base Cost" },
{ ColumnId_School, "School" },
{ ColumnId_Particle, "Particle" },
{ ColumnId_CastingObject, "Casting Object" },
{ ColumnId_HitObject, "Hit Object" },
{ ColumnId_AreaObject, "Area Object" },
{ ColumnId_BoltObject, "Bolt Object" },
{ ColumnId_CastingSound, "Casting Sound" },
{ ColumnId_HitSound, "Hit Sound" },
{ ColumnId_AreaSound, "Area Sound" },
{ ColumnId_BoltSound, "Bolt Sound" },
{ ColumnId_PathgridPoints, "Points" },
{ ColumnId_PathgridIndex, "pIndex" },
{ ColumnId_PathgridPosX, "X" },
{ ColumnId_PathgridPosY, "Y" },
{ ColumnId_PathgridPosZ, "Z" },
{ ColumnId_PathgridEdges, "Edges" },
{ ColumnId_PathgridEdgeIndex, "eIndex" },
{ ColumnId_PathgridEdge0, "Point 0" },
{ ColumnId_PathgridEdge1, "Point 1" },
{ ColumnId_RegionSounds, "Sounds" },
{ ColumnId_SoundName, "Sound Name" },
{ ColumnId_SoundChance, "Chance" },
{ ColumnId_SoundProbability, "Probability" },
{ ColumnId_FactionReactions, "Reactions" },
{ ColumnId_FactionRanks, "Ranks" },
{ ColumnId_FactionReaction, "Reaction" },
{ ColumnId_FactionAttrib1, "Attrib 1" },
{ ColumnId_FactionAttrib2, "Attrib 2" },
{ ColumnId_FactionPrimSkill, "Prim Skill" },
{ ColumnId_FactionFavSkill, "Fav Skill" },
{ ColumnId_FactionRep, "Fact Rep" },
{ ColumnId_RankName, "Rank Name" },
{ ColumnId_EffectList, "Effects" },
{ ColumnId_EffectId, "Effect" },
{ ColumnId_EffectRange, "Range" },
{ ColumnId_EffectArea, "Area" },
{ ColumnId_AiPackageList, "Ai Packages" },
{ ColumnId_AiPackageType, "Package" },
{ ColumnId_AiWanderDist, "Wander Dist" },
{ ColumnId_AiDuration, "Ai Duration" },
{ ColumnId_AiWanderToD, "Wander ToD" },
{ ColumnId_AiWanderRepeat, "Ai Repeat" },
{ ColumnId_AiActivateName, "Activate" },
{ ColumnId_AiTargetId, "Target ID" },
{ ColumnId_AiTargetCell, "Target Cell" },
{ ColumnId_PartRefList, "Part Reference" },
{ ColumnId_PartRefType, "Type" },
{ ColumnId_PartRefMale, "Male Part" },
{ ColumnId_PartRefFemale, "Female Part" },
{ ColumnId_LevelledList, "Levelled List" },
{ ColumnId_LevelledItemId, "Levelled Item" },
{ ColumnId_LevelledItemLevel, "PC Level" },
{ ColumnId_LevelledItemType, "Calculate all levels <= player" },
{ ColumnId_LevelledItemTypeEach, "Select a new item for each instance" },
{ ColumnId_LevelledItemChanceNone, "Chance None" },
{ ColumnId_PowerList, "Powers" },
{ ColumnId_Skill, "Skill" },
{ ColumnId_InfoList, "Info List" },
{ ColumnId_InfoCondition, "Info Conditions" },
{ ColumnId_InfoCondFunc, "Function" },
{ ColumnId_InfoCondVar, "Variable/Object" },
{ ColumnId_InfoCondComp, "Relation" },
{ ColumnId_InfoCondValue, "Values" },
{ ColumnId_OriginalCell, "Original Cell" },
{ ColumnId_NpcAttributes, "NPC Attributes" },
{ ColumnId_NpcSkills, "NPC Skill" },
{ ColumnId_UChar, "Value [0..255]" },
{ ColumnId_NpcMisc, "NPC Misc" },
{ ColumnId_Level, "Level" },
{ ColumnId_Mana, "Mana" },
{ ColumnId_Fatigue, "Fatigue" },
{ ColumnId_NpcDisposition, "NPC Disposition" },
{ ColumnId_NpcReputation, "Reputation" },
{ ColumnId_NpcRank, "NPC Rank" },
{ ColumnId_Gold, "Gold" },
{ ColumnId_RaceAttributes, "Race Attributes" },
{ ColumnId_Male, "Male" },
{ ColumnId_RaceSkillBonus, "Skill Bonus" },
{ ColumnId_RaceBonus, "Bonus" },
{ ColumnId_Interior, "Interior" },
{ ColumnId_Ambient, "Ambient" },
{ ColumnId_Sunlight, "Sunlight" },
{ ColumnId_Fog, "Fog" },
{ ColumnId_FogDensity, "Fog Density" },
{ ColumnId_WaterLevel, "Water Level" },
{ ColumnId_MapColor, "Map Color" },
{ ColumnId_FileFormat, "File Format" },
{ ColumnId_FileDescription, "File Description" },
{ ColumnId_Author, "Author" },
{ ColumnId_CreatureAttributes, "Creature Attributes" },
{ ColumnId_AttributeValue, "Attrib Value" },
{ ColumnId_CreatureAttack, "Creature Attack" },
{ ColumnId_MinAttack, "Min Attack" },
{ ColumnId_MaxAttack, "Max Attack" },
{ ColumnId_CreatureMisc, "Creature Misc" },
{ ColumnId_Idle2, "Idle 2" },
{ ColumnId_Idle3, "Idle 3" },
{ ColumnId_Idle4, "Idle 4" },
{ ColumnId_Idle5, "Idle 5" },
{ ColumnId_Idle6, "Idle 6" },
{ ColumnId_Idle7, "Idle 7" },
{ ColumnId_Idle8, "Idle 8" },
{ ColumnId_Idle9, "Idle 9" },
{ ColumnId_RegionWeather, "Weather" },
{ ColumnId_WeatherName, "Type" },
{ ColumnId_WeatherChance, "Percent Chance" },
{ ColumnId_Text, "Text" },
{ ColumnId_TextureNickname, "Texture Nickname" },
{ ColumnId_PluginIndex, "Plugin Index" },
{ ColumnId_TextureIndex, "Texture Index" },
{ ColumnId_LandMapLodIndex, "Land map height LOD" },
{ ColumnId_LandNormalsIndex, "Land normals" },
{ ColumnId_LandHeightsIndex, "Land heights" },
{ ColumnId_LandColoursIndex, "Land colors" },
{ ColumnId_LandTexturesIndex, "Land textures" },
{ ColumnId_UseValue1, "Use value 1" },
{ ColumnId_UseValue2, "Use value 2" },
{ ColumnId_UseValue3, "Use value 3" },
{ ColumnId_UseValue4, "Use value 4" },
{ ColumnId_Attribute1, "Attribute 1" },
{ ColumnId_Attribute2, "Attribute 2" },
{ ColumnId_MajorSkill1, "Major Skill 1" },
{ ColumnId_MajorSkill2, "Major Skill 2" },
{ ColumnId_MajorSkill3, "Major Skill 3" },
{ ColumnId_MajorSkill4, "Major Skill 4" },
{ ColumnId_MajorSkill5, "Major Skill 5" },
{ ColumnId_MinorSkill1, "Minor Skill 1" },
{ ColumnId_MinorSkill2, "Minor Skill 2" },
{ ColumnId_MinorSkill3, "Minor Skill 3" },
{ ColumnId_MinorSkill4, "Minor Skill 4" },
{ ColumnId_MinorSkill5, "Minor Skill 5" },
{ ColumnId_Skill1, "Skill 1" },
{ ColumnId_Skill2, "Skill 2" },
{ ColumnId_Skill3, "Skill 3" },
{ ColumnId_Skill4, "Skill 4" },
{ ColumnId_Skill5, "Skill 5" },
{ ColumnId_Skill6, "Skill 6" },
{ ColumnId_Skill7, "Skill 7" },
{ ColumnId_Persistent, "Persistent" },
{ ColumnId_Blocked, "Blocked" },
{ ColumnId_LevelledCreatureId, "Levelled Creature" },
{ ColumnId_ProjectileSpeed, "Projectile Speed" },
// end marker
{ -1, 0 },
};
}
}
std::string CSMWorld::Columns::getName(ColumnId column)
{
for (int i = 0; sNames[i].mName; ++i)
if (column == sNames[i].mId)
return sNames[i].mName;
return "";
}
int CSMWorld::Columns::getId(const std::string& name)
{
for (int i = 0; sNames[i].mName; ++i)
if (Misc::StringUtils::ciEqual(std::string_view(sNames[i].mName), name))
return sNames[i].mId;
return -1;
}
namespace
{
static const char* sSpecialisations[] = { "Combat", "Magic", "Stealth", 0 };
// see ESM::Attribute::AttributeID in <component/esm3/attr.hpp>
static const char* sAttributes[]
= { "Strength", "Intelligence", "Willpower", "Agility", "Speed", "Endurance", "Personality", "Luck", 0 };
static const char* sSpellTypes[] = { "Spell", "Ability", "Blight", "Disease", "Curse", "Power", 0 };
static const char* sApparatusTypes[] = { "Mortar & Pestle", "Alembic", "Calcinator", "Retort", 0 };
static const char* sArmorTypes[] = { "Helmet", "Cuirass", "Left Pauldron", "Right Pauldron", "Greaves", "Boots",
"Left Gauntlet", "Right Gauntlet", "Shield", "Left Bracer", "Right Bracer", 0 };
static const char* sClothingTypes[]
= { "Pants", "Shoes", "Shirt", "Belt", "Robe", "Right Glove", "Left Glove", "Skirt", "Ring", "Amulet", 0 };
static const char* sCreatureTypes[] = { "Creature", "Daedra", "Undead", "Humanoid", 0 };
static const char* sWeaponTypes[]
= { "Short Blade 1H", "Long Blade 1H", "Long Blade 2H", "Blunt 1H", "Blunt 2H Close", "Blunt 2H Wide",
"Spear 2H", "Axe 1H", "Axe 2H", "Bow", "Crossbow", "Thrown", "Arrow", "Bolt", 0 };
static const char* sModificationEnums[] = { "Base", "Modified", "Added", "Deleted", "Deleted", 0 };
static const char* sVarTypeEnums[] = { "unknown", "none", "short", "integer", "long", "float", "string", 0 };
static const char* sDialogueTypeEnums[] = { "Topic", "Voice", "Greeting", "Persuasion", 0 };
static const char* sQuestStatusTypes[] = { "None", "Name", "Finished", "Restart", 0 };
static const char* sGenderEnums[] = { "Male", "Female", 0 };
static const char* sEnchantmentTypes[] = { "Cast Once", "When Strikes", "When Used", "Constant Effect", 0 };
static const char* sBodyPartTypes[] = { "Head", "Hair", "Neck", "Chest", "Groin", "Hand", "Wrist", "Forearm",
"Upper Arm", "Foot", "Ankle", "Knee", "Upper Leg", "Clavicle", "Tail", 0 };
static const char* sMeshTypes[] = { "Skin", "Clothing", "Armour", 0 };
static const char* sSoundGeneratorType[]
= { "Left Foot", "Right Foot", "Swim Left", "Swim Right", "Moan", "Roar", "Scream", "Land", 0 };
static const char* sSchools[]
= { "Alteration", "Conjuration", "Destruction", "Illusion", "Mysticism", "Restoration", 0 };
// impact from magic effects, see ESM::Skill::SkillEnum in <component/esm3/loadskil.hpp>
static const char* sSkills[] = { "Block", "Armorer", "MediumArmor", "HeavyArmor", "BluntWeapon", "LongBlade", "Axe",
"Spear", "Athletics", "Enchant", "Destruction", "Alteration", "Illusion", "Conjuration", "Mysticism",
"Restoration", "Alchemy", "Unarmored", "Security", "Sneak", "Acrobatics", "LightArmor", "ShortBlade",
"Marksman", "Mercantile", "Speechcraft", "HandToHand", 0 };
// range of magic effects, see ESM::RangeType in <component/esm3/defs.hpp>
static const char* sEffectRange[] = { "Self", "Touch", "Target", 0 };
// magic effect names, see ESM::MagicEffect::Effects in <component/esm3/loadmgef.hpp>
static const char* sEffectId[] = { "WaterBreathing", "SwiftSwim", "WaterWalking", "Shield", "FireShield",
"LightningShield", "FrostShield", "Burden", "Feather", "Jump", "Levitate", "SlowFall", "Lock", "Open",
"FireDamage", "ShockDamage", "FrostDamage", "DrainAttribute", "DrainHealth", "DrainMagicka", "DrainFatigue",
"DrainSkill", "DamageAttribute", "DamageHealth", "DamageMagicka", "DamageFatigue", "DamageSkill", "Poison",
"WeaknessToFire", "WeaknessToFrost", "WeaknessToShock", "WeaknessToMagicka", "WeaknessToCommonDisease",
"WeaknessToBlightDisease", "WeaknessToCorprusDisease", "WeaknessToPoison", "WeaknessToNormalWeapons",
"DisintegrateWeapon", "DisintegrateArmor", "Invisibility", "Chameleon", "Light", "Sanctuary", "NightEye",
"Charm", "Paralyze", "Silence", "Blind", "Sound", "CalmHumanoid", "CalmCreature", "FrenzyHumanoid",
"FrenzyCreature", "DemoralizeHumanoid", "DemoralizeCreature", "RallyHumanoid", "RallyCreature", "Dispel",
"Soultrap", "Telekinesis", "Mark", "Recall", "DivineIntervention", "AlmsiviIntervention", "DetectAnimal",
"DetectEnchantment", "DetectKey", "SpellAbsorption", "Reflect", "CureCommonDisease", "CureBlightDisease",
"CureCorprusDisease", "CurePoison", "CureParalyzation", "RestoreAttribute", "RestoreHealth", "RestoreMagicka",
"RestoreFatigue", "RestoreSkill", "FortifyAttribute", "FortifyHealth", "FortifyMagicka", "FortifyFatigue",
"FortifySkill", "FortifyMaximumMagicka", "AbsorbAttribute", "AbsorbHealth", "AbsorbMagicka", "AbsorbFatigue",
"AbsorbSkill", "ResistFire", "ResistFrost", "ResistShock", "ResistMagicka", "ResistCommonDisease",
"ResistBlightDisease", "ResistCorprusDisease", "ResistPoison", "ResistNormalWeapons", "ResistParalysis",
"RemoveCurse", "TurnUndead", "SummonScamp", "SummonClannfear", "SummonDaedroth", "SummonDremora",
"SummonAncestralGhost", "SummonSkeletalMinion", "SummonBonewalker", "SummonGreaterBonewalker", "SummonBonelord",
"SummonWingedTwilight", "SummonHunger", "SummonGoldenSaint", "SummonFlameAtronach", "SummonFrostAtronach",
"SummonStormAtronach", "FortifyAttack", "CommandCreature", "CommandHumanoid", "BoundDagger", "BoundLongsword",
"BoundMace", "BoundBattleAxe", "BoundSpear", "BoundLongbow", "ExtraSpell", "BoundCuirass", "BoundHelm",
"BoundBoots", "BoundShield", "BoundGloves", "Corprus", "Vampirism", "SummonCenturionSphere", "SunDamage",
"StuntedMagicka", "SummonFabricant", "SummonWolf", "SummonBear", "SummonBonewolf", "SummonCreature04",
"SummonCreature05", 0 };
// see ESM::PartReferenceType in <component/esm3/loadarmo.hpp>
static const char* sPartRefType[] = { "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 Pauldron", "Left Pauldron", "Weapon", "Tail", 0 };
// see the enums in <component/esm3/aipackage.hpp>
static const char* sAiPackageType[] = { "AI Wander", "AI Travel", "AI Follow", "AI Escort", "AI Activate", 0 };
static const char* sBookType[] = { "Book", "Scroll", 0 };
static const char* sEmitterType[] = { "<None>", "Flickering", "Flickering (Slow)", "Pulsing", "Pulsing (Slow)", 0 };
const char** getEnumNames(CSMWorld::Columns::ColumnId column)
{
switch (column)
{
case CSMWorld::Columns::ColumnId_Specialisation:
return sSpecialisations;
case CSMWorld::Columns::ColumnId_Attribute:
return sAttributes;
case CSMWorld::Columns::ColumnId_SpellType:
return sSpellTypes;
case CSMWorld::Columns::ColumnId_ApparatusType:
return sApparatusTypes;
case CSMWorld::Columns::ColumnId_ArmorType:
return sArmorTypes;
case CSMWorld::Columns::ColumnId_ClothingType:
return sClothingTypes;
case CSMWorld::Columns::ColumnId_CreatureType:
return sCreatureTypes;
case CSMWorld::Columns::ColumnId_WeaponType:
return sWeaponTypes;
case CSMWorld::Columns::ColumnId_Modification:
return sModificationEnums;
case CSMWorld::Columns::ColumnId_ValueType:
return sVarTypeEnums;
case CSMWorld::Columns::ColumnId_DialogueType:
return sDialogueTypeEnums;
case CSMWorld::Columns::ColumnId_QuestStatusType:
return sQuestStatusTypes;
case CSMWorld::Columns::ColumnId_Gender:
return sGenderEnums;
case CSMWorld::Columns::ColumnId_EnchantmentType:
return sEnchantmentTypes;
case CSMWorld::Columns::ColumnId_BodyPartType:
return sBodyPartTypes;
case CSMWorld::Columns::ColumnId_MeshType:
return sMeshTypes;
case CSMWorld::Columns::ColumnId_SoundGeneratorType:
return sSoundGeneratorType;
case CSMWorld::Columns::ColumnId_School:
return sSchools;
case CSMWorld::Columns::ColumnId_Skill:
return sSkills;
case CSMWorld::Columns::ColumnId_EffectRange:
return sEffectRange;
case CSMWorld::Columns::ColumnId_EffectId:
return sEffectId;
case CSMWorld::Columns::ColumnId_PartRefType:
return sPartRefType;
case CSMWorld::Columns::ColumnId_AiPackageType:
return sAiPackageType;
case CSMWorld::Columns::ColumnId_InfoCondFunc:
return CSMWorld::ConstInfoSelectWrapper::FunctionEnumStrings;
case CSMWorld::Columns::ColumnId_InfoCondComp:
return CSMWorld::ConstInfoSelectWrapper::RelationEnumStrings;
case CSMWorld::Columns::ColumnId_BookType:
return sBookType;
case CSMWorld::Columns::ColumnId_EmitterType:
return sEmitterType;
default:
return 0;
}
}
}
bool CSMWorld::Columns::hasEnums(ColumnId column)
{
return getEnumNames(column) != 0 || column == ColumnId_RecordType;
}
std::vector<std::pair<int, std::string>> CSMWorld::Columns::getEnums(ColumnId column)
{
std::vector<std::pair<int, std::string>> enums;
if (const char** table = getEnumNames(column))
for (int i = 0; table[i]; ++i)
enums.emplace_back(i, table[i]);
else if (column == ColumnId_BloodType)
{
for (int i = 0; i < 8; i++)
{
std::string_view bloodName = Fallback::Map::getString("Blood_Texture_Name_" + std::to_string(i));
if (!bloodName.empty())
enums.emplace_back(i, bloodName);
}
}
else if (column == ColumnId_RecordType)
{
enums.emplace_back(UniversalId::Type_None, ""); // none
for (int i = UniversalId::Type_None + 1; i < UniversalId::NumberOfTypes; ++i)
enums.emplace_back(i, UniversalId(static_cast<UniversalId::Type>(i)).getTypeName());
}
return enums;
}
| 28,021
|
C++
|
.cpp
| 524
| 41.85687
| 120
| 0.580061
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,943
|
columnbase.cpp
|
OpenMW_openmw/apps/opencs/model/world/columnbase.cpp
|
#include "columnbase.hpp"
#include <algorithm>
#include "columns.hpp"
CSMWorld::ColumnBase::ColumnBase(int columnId, Display displayType, int flags)
: mColumnId(columnId)
, mFlags(flags)
, mDisplayType(displayType)
{
}
bool CSMWorld::ColumnBase::isUserEditable() const
{
return isEditable();
}
std::string CSMWorld::ColumnBase::getTitle() const
{
return Columns::getName(static_cast<Columns::ColumnId>(mColumnId));
}
int CSMWorld::ColumnBase::getId() const
{
return mColumnId;
}
bool CSMWorld::ColumnBase::isId(Display display)
{
static const Display ids[] = {
Display_Skill,
Display_Class,
Display_Faction,
Display_Rank,
Display_Race,
Display_Sound,
Display_Region,
Display_Birthsign,
Display_Spell,
Display_Cell,
Display_Referenceable,
Display_Activator,
Display_Potion,
Display_Apparatus,
Display_Armor,
Display_Book,
Display_Clothing,
Display_Container,
Display_Creature,
Display_Door,
Display_Ingredient,
Display_CreatureLevelledList,
Display_ItemLevelledList,
Display_Light,
Display_Lockpick,
Display_Miscellaneous,
Display_Npc,
Display_Probe,
Display_Repair,
Display_Static,
Display_Weapon,
Display_Reference,
Display_Filter,
Display_Topic,
Display_Journal,
Display_TopicInfo,
Display_JournalInfo,
Display_Scene,
Display_GlobalVariable,
Display_BodyPart,
Display_Enchantment,
Display_Script,
Display_Mesh,
Display_Icon,
Display_Music,
Display_SoundRes,
Display_Texture,
Display_Video,
Display_Id,
Display_SkillId,
Display_EffectRange,
Display_EffectId,
Display_PartRefType,
Display_AiPackageType,
Display_InfoCondFunc,
Display_InfoCondVar,
Display_InfoCondComp,
Display_EffectSkill,
Display_EffectAttribute,
Display_IngredEffectId,
Display_None,
};
for (int i = 0; ids[i] != Display_None; ++i)
if (ids[i] == display)
return true;
return false;
}
bool CSMWorld::ColumnBase::isText(Display display)
{
return display == Display_String || display == Display_LongString || display == Display_String32
|| display == Display_String64 || display == Display_LongString256;
}
bool CSMWorld::ColumnBase::isScript(Display display)
{
return display == Display_ScriptFile || display == Display_ScriptLines;
}
void CSMWorld::NestableColumn::addColumn(CSMWorld::NestableColumn* column)
{
mNestedColumns.push_back(column);
}
const CSMWorld::ColumnBase& CSMWorld::NestableColumn::nestedColumn(int subColumn) const
{
if (mNestedColumns.empty())
throw std::logic_error("Tried to access nested column of the non-nest column");
return *mNestedColumns.at(subColumn);
}
CSMWorld::NestableColumn::NestableColumn(int columnId, CSMWorld::ColumnBase::Display displayType, int flag)
: CSMWorld::ColumnBase(columnId, displayType, flag)
{
}
CSMWorld::NestableColumn::~NestableColumn()
{
for (auto* col : mNestedColumns)
{
delete col;
}
}
bool CSMWorld::NestableColumn::hasChildren() const
{
return !mNestedColumns.empty();
}
CSMWorld::NestedChildColumn::NestedChildColumn(
int id, CSMWorld::ColumnBase::Display display, int flags, bool isEditable)
: NestableColumn(id, display, flags)
, mIsEditable(isEditable)
{
}
bool CSMWorld::NestedChildColumn::isEditable() const
{
return mIsEditable;
}
| 3,719
|
C++
|
.cpp
| 135
| 21.725926
| 107
| 0.677338
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,945
|
idtablebase.cpp
|
OpenMW_openmw/apps/opencs/model/world/idtablebase.cpp
|
#include "idtablebase.hpp"
CSMWorld::IdTableBase::IdTableBase(unsigned int features)
: mFeatures(features)
{
}
unsigned int CSMWorld::IdTableBase::getFeatures() const
{
return mFeatures;
}
| 199
|
C++
|
.cpp
| 9
| 20
| 57
| 0.787234
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| true
| true
| true
| false
|
34,946
|
tablemimedata.cpp
|
OpenMW_openmw/apps/opencs/model/world/tablemimedata.cpp
|
#include "tablemimedata.hpp"
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <string>
#include <QDebug>
#include <QString>
#include "columnbase.hpp"
#include "universalid.hpp"
CSMWorld::TableMimeData::TableMimeData(UniversalId id, const CSMDoc::Document& document)
: mDocument(document)
, mTableOfDragStart(nullptr)
{
mUniversalId.push_back(id);
mObjectsFormats << QString::fromUtf8(("tabledata/" + id.getTypeName()).c_str());
}
CSMWorld::TableMimeData::TableMimeData(const std::vector<CSMWorld::UniversalId>& id, const CSMDoc::Document& document)
: mUniversalId(id)
, mDocument(document)
, mTableOfDragStart(nullptr)
{
for (std::vector<UniversalId>::iterator it(mUniversalId.begin()); it != mUniversalId.end(); ++it)
{
mObjectsFormats << QString::fromUtf8(("tabledata/" + it->getTypeName()).c_str());
}
}
QStringList CSMWorld::TableMimeData::formats() const
{
return mObjectsFormats;
}
std::string CSMWorld::TableMimeData::getIcon() const
{
if (mUniversalId.empty())
{
qDebug() << "TableMimeData object does not hold any records!"; // because throwing in the event loop tends to be
// problematic
throw std::runtime_error("TableMimeData object does not hold any records!");
}
std::string tmpIcon;
bool firstIteration = true;
for (const auto& id : mUniversalId)
{
if (firstIteration)
{
firstIteration = false;
tmpIcon = id.getIcon();
continue;
}
if (tmpIcon != id.getIcon())
{
return ":multitype";
}
tmpIcon = id.getIcon();
}
return mUniversalId.begin()->getIcon(); // All objects are of the same type;
}
std::vector<CSMWorld::UniversalId> CSMWorld::TableMimeData::getData() const
{
return mUniversalId;
}
bool CSMWorld::TableMimeData::isReferencable(CSMWorld::ColumnBase::Display type) const
{
return (type == CSMWorld::ColumnBase::Display_Activator || type == CSMWorld::ColumnBase::Display_Potion
|| type == CSMWorld::ColumnBase::Display_Apparatus || type == CSMWorld::ColumnBase::Display_Armor
|| type == CSMWorld::ColumnBase::Display_Book || type == CSMWorld::ColumnBase::Display_Clothing
|| type == CSMWorld::ColumnBase::Display_Container || type == CSMWorld::ColumnBase::Display_Creature
|| type == CSMWorld::ColumnBase::Display_Door || type == CSMWorld::ColumnBase::Display_Ingredient
|| type == CSMWorld::ColumnBase::Display_CreatureLevelledList
|| type == CSMWorld::ColumnBase::Display_ItemLevelledList || type == CSMWorld::ColumnBase::Display_Light
|| type == CSMWorld::ColumnBase::Display_Lockpick || type == CSMWorld::ColumnBase::Display_Miscellaneous
|| type == CSMWorld::ColumnBase::Display_Npc || type == CSMWorld::ColumnBase::Display_Probe
|| type == CSMWorld::ColumnBase::Display_Repair || type == CSMWorld::ColumnBase::Display_Static
|| type == CSMWorld::ColumnBase::Display_Weapon);
}
bool CSMWorld::TableMimeData::isReferencable(CSMWorld::UniversalId::Type type)
{
return (type == CSMWorld::UniversalId::Type_Activator || type == CSMWorld::UniversalId::Type_Potion
|| type == CSMWorld::UniversalId::Type_Apparatus || type == CSMWorld::UniversalId::Type_Armor
|| type == CSMWorld::UniversalId::Type_Book || type == CSMWorld::UniversalId::Type_Clothing
|| type == CSMWorld::UniversalId::Type_Container || type == CSMWorld::UniversalId::Type_Creature
|| type == CSMWorld::UniversalId::Type_Door || type == CSMWorld::UniversalId::Type_Ingredient
|| type == CSMWorld::UniversalId::Type_CreatureLevelledList
|| type == CSMWorld::UniversalId::Type_ItemLevelledList || type == CSMWorld::UniversalId::Type_Light
|| type == CSMWorld::UniversalId::Type_Lockpick || type == CSMWorld::UniversalId::Type_Miscellaneous
|| type == CSMWorld::UniversalId::Type_Npc || type == CSMWorld::UniversalId::Type_Probe
|| type == CSMWorld::UniversalId::Type_Repair || type == CSMWorld::UniversalId::Type_Static
|| type == CSMWorld::UniversalId::Type_Weapon);
}
bool CSMWorld::TableMimeData::holdsType(CSMWorld::UniversalId::Type type) const
{
bool referencable = (type == CSMWorld::UniversalId::Type_Referenceable);
for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
{
if (referencable)
{
if (isReferencable(it->getType()))
{
return true;
}
}
else
{
if (it->getType() == type)
{
return true;
}
}
}
return false;
}
bool CSMWorld::TableMimeData::holdsType(CSMWorld::ColumnBase::Display type) const
{
bool referencable = (type == CSMWorld::ColumnBase::Display_Referenceable);
for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
{
if (referencable)
{
if (isReferencable(it->getType()))
{
return true;
}
}
else
{
if (it->getType() == convertEnums(type))
{
return true;
}
}
}
return false;
}
CSMWorld::UniversalId CSMWorld::TableMimeData::returnMatching(CSMWorld::UniversalId::Type type) const
{
bool referencable = (type == CSMWorld::UniversalId::Type_Referenceable);
for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
{
if (referencable)
{
if (isReferencable(it->getType()))
{
return *it;
}
}
else
{
if (it->getType() == type)
{
return *it;
}
}
}
throw std::runtime_error("TableMimeData object does not hold object of the sought type");
}
CSMWorld::UniversalId CSMWorld::TableMimeData::returnMatching(CSMWorld::ColumnBase::Display type) const
{
bool referencable = (type == CSMWorld::ColumnBase::Display_Referenceable);
for (std::vector<UniversalId>::const_iterator it = mUniversalId.begin(); it != mUniversalId.end(); ++it)
{
if (referencable)
{
if (isReferencable(it->getType()))
{
return *it;
}
}
else
{
if (it->getType() == convertEnums(type))
{
return *it;
}
}
}
throw std::runtime_error("TableMimeData object does not hold object of the sought type");
}
bool CSMWorld::TableMimeData::fromDocument(const CSMDoc::Document& document) const
{
return &document == &mDocument;
}
namespace
{
struct Mapping
{
CSMWorld::UniversalId::Type mUniversalIdType;
CSMWorld::ColumnBase::Display mDisplayType;
};
const Mapping mapping[] = {
{ CSMWorld::UniversalId::Type_Race, CSMWorld::ColumnBase::Display_Race },
{ CSMWorld::UniversalId::Type_Skill, CSMWorld::ColumnBase::Display_Skill },
{ CSMWorld::UniversalId::Type_Class, CSMWorld::ColumnBase::Display_Class },
{ CSMWorld::UniversalId::Type_Faction, CSMWorld::ColumnBase::Display_Faction },
{ CSMWorld::UniversalId::Type_Sound, CSMWorld::ColumnBase::Display_Sound },
{ CSMWorld::UniversalId::Type_Region, CSMWorld::ColumnBase::Display_Region },
{ CSMWorld::UniversalId::Type_Birthsign, CSMWorld::ColumnBase::Display_Birthsign },
{ CSMWorld::UniversalId::Type_Spell, CSMWorld::ColumnBase::Display_Spell },
{ CSMWorld::UniversalId::Type_Cell, CSMWorld::ColumnBase::Display_Cell },
{ CSMWorld::UniversalId::Type_Referenceable, CSMWorld::ColumnBase::Display_Referenceable },
{ CSMWorld::UniversalId::Type_Activator, CSMWorld::ColumnBase::Display_Activator },
{ CSMWorld::UniversalId::Type_Potion, CSMWorld::ColumnBase::Display_Potion },
{ CSMWorld::UniversalId::Type_Apparatus, CSMWorld::ColumnBase::Display_Apparatus },
{ CSMWorld::UniversalId::Type_Armor, CSMWorld::ColumnBase::Display_Armor },
{ CSMWorld::UniversalId::Type_Book, CSMWorld::ColumnBase::Display_Book },
{ CSMWorld::UniversalId::Type_Clothing, CSMWorld::ColumnBase::Display_Clothing },
{ CSMWorld::UniversalId::Type_Container, CSMWorld::ColumnBase::Display_Container },
{ CSMWorld::UniversalId::Type_Creature, CSMWorld::ColumnBase::Display_Creature },
{ CSMWorld::UniversalId::Type_Door, CSMWorld::ColumnBase::Display_Door },
{ CSMWorld::UniversalId::Type_Ingredient, CSMWorld::ColumnBase::Display_Ingredient },
{ CSMWorld::UniversalId::Type_CreatureLevelledList, CSMWorld::ColumnBase::Display_CreatureLevelledList },
{ CSMWorld::UniversalId::Type_ItemLevelledList, CSMWorld::ColumnBase::Display_ItemLevelledList },
{ CSMWorld::UniversalId::Type_Light, CSMWorld::ColumnBase::Display_Light },
{ CSMWorld::UniversalId::Type_Lockpick, CSMWorld::ColumnBase::Display_Lockpick },
{ CSMWorld::UniversalId::Type_Miscellaneous, CSMWorld::ColumnBase::Display_Miscellaneous },
{ CSMWorld::UniversalId::Type_Npc, CSMWorld::ColumnBase::Display_Npc },
{ CSMWorld::UniversalId::Type_Probe, CSMWorld::ColumnBase::Display_Probe },
{ CSMWorld::UniversalId::Type_Repair, CSMWorld::ColumnBase::Display_Repair },
{ CSMWorld::UniversalId::Type_Static, CSMWorld::ColumnBase::Display_Static },
{ CSMWorld::UniversalId::Type_Weapon, CSMWorld::ColumnBase::Display_Weapon },
{ CSMWorld::UniversalId::Type_Reference, CSMWorld::ColumnBase::Display_Reference },
{ CSMWorld::UniversalId::Type_Filter, CSMWorld::ColumnBase::Display_Filter },
{ CSMWorld::UniversalId::Type_Topic, CSMWorld::ColumnBase::Display_Topic },
{ CSMWorld::UniversalId::Type_Journal, CSMWorld::ColumnBase::Display_Journal },
{ CSMWorld::UniversalId::Type_TopicInfo, CSMWorld::ColumnBase::Display_TopicInfo },
{ CSMWorld::UniversalId::Type_JournalInfo, CSMWorld::ColumnBase::Display_JournalInfo },
{ CSMWorld::UniversalId::Type_Scene, CSMWorld::ColumnBase::Display_Scene },
{ CSMWorld::UniversalId::Type_Script, CSMWorld::ColumnBase::Display_Script },
{ CSMWorld::UniversalId::Type_Mesh, CSMWorld::ColumnBase::Display_Mesh },
{ CSMWorld::UniversalId::Type_Icon, CSMWorld::ColumnBase::Display_Icon },
{ CSMWorld::UniversalId::Type_Music, CSMWorld::ColumnBase::Display_Music },
{ CSMWorld::UniversalId::Type_SoundRes, CSMWorld::ColumnBase::Display_SoundRes },
{ CSMWorld::UniversalId::Type_Texture, CSMWorld::ColumnBase::Display_Texture },
{ CSMWorld::UniversalId::Type_Video, CSMWorld::ColumnBase::Display_Video },
{ CSMWorld::UniversalId::Type_Global, CSMWorld::ColumnBase::Display_GlobalVariable },
{ CSMWorld::UniversalId::Type_BodyPart, CSMWorld::ColumnBase::Display_BodyPart },
{ CSMWorld::UniversalId::Type_Enchantment, CSMWorld::ColumnBase::Display_Enchantment },
{ CSMWorld::UniversalId::Type_None, CSMWorld::ColumnBase::Display_None } // end marker
};
}
CSMWorld::UniversalId::Type CSMWorld::TableMimeData::convertEnums(ColumnBase::Display type)
{
for (int i = 0; mapping[i].mUniversalIdType != CSMWorld::UniversalId::Type_None; ++i)
if (mapping[i].mDisplayType == type)
return mapping[i].mUniversalIdType;
return CSMWorld::UniversalId::Type_None;
}
CSMWorld::ColumnBase::Display CSMWorld::TableMimeData::convertEnums(UniversalId::Type type)
{
for (int i = 0; mapping[i].mUniversalIdType != CSMWorld::UniversalId::Type_None; ++i)
if (mapping[i].mUniversalIdType == type)
return mapping[i].mDisplayType;
return CSMWorld::ColumnBase::Display_None;
}
const CSMDoc::Document* CSMWorld::TableMimeData::getDocumentPtr() const
{
return &mDocument;
}
| 12,123
|
C++
|
.cpp
| 256
| 39.894531
| 120
| 0.664498
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,947
|
metadata.cpp
|
OpenMW_openmw/apps/opencs/model/world/metadata.cpp
|
#include "metadata.hpp"
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadtes3.hpp>
void CSMWorld::MetaData::blank()
{
// ESM::Header::CurrentFormat is `1` but since new records are not yet used in opencs
// we use the format `0` for compatibility with old versions.
mFormatVersion = ESM::DefaultFormatVersion;
mAuthor.clear();
mDescription.clear();
}
void CSMWorld::MetaData::load(ESM::ESMReader& esm)
{
mFormatVersion = esm.getHeader().mFormatVersion;
mAuthor = esm.getHeader().mData.author;
mDescription = esm.getHeader().mData.desc;
}
void CSMWorld::MetaData::save(ESM::ESMWriter& esm) const
{
esm.setFormatVersion(mFormatVersion);
esm.setAuthor(mAuthor);
esm.setDescription(mDescription);
}
| 806
|
C++
|
.cpp
| 24
| 30.583333
| 89
| 0.750643
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,948
|
resourcesmanager.cpp
|
OpenMW_openmw/apps/opencs/model/world/resourcesmanager.cpp
|
#include "resourcesmanager.hpp"
#include "resources.hpp"
#include <apps/opencs/model/world/universalid.hpp>
#include <stdexcept>
#include <type_traits>
#include <utility>
CSMWorld::ResourcesManager::ResourcesManager()
: mVFS(nullptr)
{
}
CSMWorld::ResourcesManager::~ResourcesManager() = default;
void CSMWorld::ResourcesManager::addResources(const Resources& resources)
{
mResources.insert(std::make_pair(resources.getType(), resources));
mResources.insert(std::make_pair(UniversalId::getParentType(resources.getType()), resources));
}
const char* const* CSMWorld::ResourcesManager::getMeshExtensions()
{
// maybe we could go over the osgDB::Registry to list all supported node formats
static const char* const sMeshTypes[] = { "nif", "osg", "osgt", "osgb", "osgx", "osg2", "dae", 0 };
return sMeshTypes;
}
void CSMWorld::ResourcesManager::setVFS(const VFS::Manager* vfs)
{
mVFS = vfs;
mResources.clear();
addResources(Resources(vfs, "meshes", UniversalId::Type_Mesh, getMeshExtensions()));
addResources(Resources(vfs, "icons", UniversalId::Type_Icon));
addResources(Resources(vfs, "music", UniversalId::Type_Music));
addResources(Resources(vfs, "sound", UniversalId::Type_SoundRes));
addResources(Resources(vfs, "textures", UniversalId::Type_Texture));
addResources(Resources(vfs, "video", UniversalId::Type_Video));
}
const VFS::Manager* CSMWorld::ResourcesManager::getVFS() const
{
return mVFS;
}
void CSMWorld::ResourcesManager::recreateResources()
{
std::map<UniversalId::Type, Resources>::iterator it = mResources.begin();
for (; it != mResources.end(); ++it)
{
if (it->first == UniversalId::Type_Mesh)
it->second.recreate(mVFS, getMeshExtensions());
else
it->second.recreate(mVFS);
}
}
const CSMWorld::Resources& CSMWorld::ResourcesManager::get(UniversalId::Type type) const
{
std::map<UniversalId::Type, Resources>::const_iterator iter = mResources.find(type);
if (iter == mResources.end())
throw std::logic_error("Unknown resource type");
return iter->second;
}
| 2,122
|
C++
|
.cpp
| 55
| 34.854545
| 103
| 0.722358
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,949
|
collectionbase.cpp
|
OpenMW_openmw/apps/opencs/model/world/collectionbase.cpp
|
#include "collectionbase.hpp"
#include <stdexcept>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include "columnbase.hpp"
int CSMWorld::CollectionBase::getInsertIndex(const ESM::RefId& id, UniversalId::Type type, RecordBase* record) const
{
return getAppendIndex(id, type);
}
int CSMWorld::CollectionBase::searchColumnIndex(Columns::ColumnId id) const
{
int columns = getColumns();
for (int i = 0; i < columns; ++i)
if (getColumn(i).mColumnId == id)
return i;
return -1;
}
int CSMWorld::CollectionBase::findColumnIndex(Columns::ColumnId id) const
{
int index = searchColumnIndex(id);
if (index == -1)
throw std::logic_error("invalid column index");
return index;
}
| 784
|
C++
|
.cpp
| 24
| 28.916667
| 116
| 0.72
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,950
|
scope.cpp
|
OpenMW_openmw/apps/opencs/model/world/scope.cpp
|
#include "scope.hpp"
#include <string_view>
#include <components/esm/refid.hpp>
#include <components/misc/strings/algorithm.hpp>
namespace CSMWorld
{
namespace
{
struct GetScope
{
Scope operator()(ESM::StringRefId v) const
{
std::string_view namespace_;
const std::string::size_type i = v.getValue().find("::");
if (i != std::string::npos)
namespace_ = std::string_view(v.getValue()).substr(0, i);
if (Misc::StringUtils::ciEqual(namespace_, "project"))
return Scope_Project;
if (Misc::StringUtils::ciEqual(namespace_, "session"))
return Scope_Session;
return Scope_Content;
}
template <class T>
Scope operator()(const T& /*v*/) const
{
return Scope_Content;
}
};
}
}
CSMWorld::Scope CSMWorld::getScopeFromId(ESM::RefId id)
{
return visit(GetScope{}, id);
}
| 1,063
|
C++
|
.cpp
| 34
| 21.264706
| 77
| 0.532875
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,951
|
infocollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/infocollection.cpp
|
#include "infocollection.hpp"
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include "components/debug/debuglog.hpp"
#include "components/esm3/infoorder.hpp"
#include "components/esm3/loaddial.hpp"
#include "components/esm3/loadinfo.hpp"
#include "collection.hpp"
#include "info.hpp"
namespace CSMWorld
{
namespace
{
std::string_view getInfoTopicId(const ESM::RefId& infoId)
{
return parseInfoRefId(infoId).first;
}
}
ESM::RefId makeCompositeInfoRefId(const ESM::RefId& topicId, const ESM::RefId& infoId)
{
return ESM::RefId::stringRefId(topicId.getRefIdString() + '#' + infoId.getRefIdString());
}
}
void CSMWorld::InfoCollection::load(const Info& value, bool base)
{
const int index = searchId(value.mId);
if (index == -1)
{
// new record
auto record = std::make_unique<Record<Info>>();
record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
(base ? record->mBase : record->mModified) = value;
insertRecord(std::move(record), getSize());
}
else
{
// old record
auto record = std::make_unique<Record<Info>>(getRecord(index));
if (base)
record->mBase = value;
else
record->setModified(value);
setRecord(index, std::move(record));
}
}
void CSMWorld::InfoCollection::load(
ESM::ESMReader& reader, bool base, const ESM::Dialogue& dialogue, InfoOrderByTopic& infoOrders)
{
Info info;
bool isDeleted = false;
info.load(reader, isDeleted);
const ESM::RefId id = makeCompositeInfoRefId(dialogue.mId, info.mId);
if (isDeleted)
{
const int index = searchId(id);
if (index == -1)
{
Log(Debug::Warning) << "Trying to delete absent info \"" << info.mId << "\" from topic \"" << dialogue.mId
<< "\"";
return;
}
if (base)
{
infoOrders.at(dialogue.mId).removeInfo(info.mId);
removeRows(index, 1);
return;
}
auto record = std::make_unique<Record<Info>>(getRecord(index));
record->mState = RecordBase::State_Deleted;
setRecord(index, std::move(record));
return;
}
info.mTopicId = dialogue.mId;
info.mOriginalId = info.mId;
info.mId = id;
load(info, base);
infoOrders[dialogue.mId].insertInfo(OrderedInfo(info), isDeleted);
}
void CSMWorld::InfoCollection::sort(const InfoOrderByTopic& infoOrders)
{
std::vector<int> order;
order.reserve(getSize());
for (const auto& [topicId, infoOrder] : infoOrders)
for (const OrderedInfo& info : infoOrder.getOrderedInfo())
order.push_back(getIndex(makeCompositeInfoRefId(topicId, info.mId)));
reorderRowsImp(order);
}
CSMWorld::InfosRecordPtrByTopic CSMWorld::InfoCollection::getInfosByTopic() const
{
InfosRecordPtrByTopic result;
for (const std::unique_ptr<Record<Info>>& record : getRecords())
result[record->get().mTopicId].push_back(record.get());
return result;
}
int CSMWorld::InfoCollection::getAppendIndex(const ESM::RefId& id, UniversalId::Type /*type*/) const
{
const auto lessByTopicId
= [](std::string_view lhs, const std::unique_ptr<Record<Info>>& rhs) { return lhs < rhs->get().mTopicId; };
const auto it = std::upper_bound(getRecords().begin(), getRecords().end(), getInfoTopicId(id), lessByTopicId);
return static_cast<int>(it - getRecords().begin());
}
bool CSMWorld::InfoCollection::reorderRows(int baseIndex, const std::vector<int>& newOrder)
{
const int lastIndex = baseIndex + static_cast<int>(newOrder.size()) - 1;
if (lastIndex >= getSize())
return false;
if (getRecord(baseIndex).get().mTopicId != getRecord(lastIndex).get().mTopicId)
return false;
return reorderRowsImp(baseIndex, newOrder);
}
| 3,989
|
C++
|
.cpp
| 113
| 29.274336
| 118
| 0.656445
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,952
|
nestedinfocollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/nestedinfocollection.cpp
|
#include "nestedinfocollection.hpp"
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>
#include <apps/opencs/model/world/collection.hpp>
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/info.hpp>
#include <apps/opencs/model/world/infocollection.hpp>
#include <apps/opencs/model/world/nestedcolumnadapter.hpp>
#include <apps/opencs/model/world/nestedtablewrapper.hpp>
#include <apps/opencs/model/world/record.hpp>
namespace CSMWorld
{
NestedInfoCollection::~NestedInfoCollection()
{
for (std::map<const ColumnBase*, NestedColumnAdapter<Info>*>::iterator iter(mAdapters.begin());
iter != mAdapters.end(); ++iter)
{
delete (*iter).second;
}
}
void NestedInfoCollection::addAdapter(std::pair<const ColumnBase*, NestedColumnAdapter<Info>*> adapter)
{
mAdapters.insert(adapter);
}
const NestedColumnAdapter<Info>& NestedInfoCollection::getAdapter(const ColumnBase& column) const
{
std::map<const ColumnBase*, NestedColumnAdapter<Info>*>::const_iterator iter = mAdapters.find(&column);
if (iter == mAdapters.end())
throw std::logic_error("No such column in the nestedidadapter");
return *iter->second;
}
void NestedInfoCollection::addNestedRow(int row, int column, int position)
{
auto record = std::make_unique<Record<Info>>();
record->assign(Collection<Info>::getRecord(row));
getAdapter(Collection<Info>::getColumn(column)).addRow(*record, position);
Collection<Info>::setRecord(row, std::move(record));
}
void NestedInfoCollection::removeNestedRows(int row, int column, int subRow)
{
auto record = std::make_unique<Record<Info>>();
record->assign(Collection<Info>::getRecord(row));
getAdapter(Collection<Info>::getColumn(column)).removeRow(*record, subRow);
Collection<Info>::setRecord(row, std::move(record));
}
QVariant NestedInfoCollection::getNestedData(int row, int column, int subRow, int subColumn) const
{
return getAdapter(Collection<Info>::getColumn(column))
.getData(Collection<Info>::getRecord(row), subRow, subColumn);
}
void NestedInfoCollection::setNestedData(int row, int column, const QVariant& data, int subRow, int subColumn)
{
auto record = std::make_unique<Record<Info>>();
record->assign(Collection<Info>::getRecord(row));
getAdapter(Collection<Info>::getColumn(column)).setData(*record, data, subRow, subColumn);
Collection<Info>::setRecord(row, std::move(record));
}
CSMWorld::NestedTableWrapperBase* NestedInfoCollection::nestedTable(int row, int column) const
{
return getAdapter(Collection<Info>::getColumn(column)).table(Collection<Info>::getRecord(row));
}
void NestedInfoCollection::setNestedTable(int row, int column, const CSMWorld::NestedTableWrapperBase& nestedTable)
{
auto record = std::make_unique<Record<Info>>();
record->assign(Collection<Info>::getRecord(row));
getAdapter(Collection<Info>::getColumn(column)).setTable(*record, nestedTable);
Collection<Info>::setRecord(row, std::move(record));
}
int NestedInfoCollection::getNestedRowsCount(int row, int column) const
{
return getAdapter(Collection<Info>::getColumn(column)).getRowsCount(Collection<Info>::getRecord(row));
}
int NestedInfoCollection::getNestedColumnsCount(int row, int column) const
{
return getAdapter(Collection<Info>::getColumn(column)).getColumnsCount(Collection<Info>::getRecord(row));
}
CSMWorld::NestableColumn* NestedInfoCollection::getNestableColumn(int column)
{
return Collection<Info>::getNestableColumn(column);
}
}
| 3,874
|
C++
|
.cpp
| 85
| 39.388235
| 119
| 0.710226
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,953
|
referencecheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/referencecheck.cpp
|
#include "referencecheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include "../../model/world/cell.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/ref.hpp>
#include <apps/opencs/model/world/refcollection.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/loadbody.hpp>
#include <components/esm3/loadfact.hpp>
CSMTools::ReferenceCheckStage::ReferenceCheckStage(const CSMWorld::RefCollection& references,
const CSMWorld::RefIdCollection& referencables, const CSMWorld::IdCollection<CSMWorld::Cell>& cells,
const CSMWorld::IdCollection<ESM::Faction>& factions, const CSMWorld::IdCollection<ESM::BodyPart>& bodyparts)
: mReferences(references)
, mObjects(referencables)
, mDataSet(referencables.getDataSet())
, mCells(cells)
, mFactions(factions)
, mBodyParts(bodyparts)
{
mIgnoreBaseRecords = false;
}
void CSMTools::ReferenceCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<CSMWorld::CellRef>& record = mReferences.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const CSMWorld::CellRef& cellRef = record.get();
const CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Reference, cellRef.mId);
// Check RefNum is unique per content file, otherwise can cause load issues
const auto refNum = cellRef.mRefNum;
const auto insertResult = mUsedReferenceIDs.emplace(refNum, cellRef.mId);
if (!insertResult.second)
messages.add(id,
"Duplicate RefNum: " + std::to_string(refNum.mContentFile) + std::string("-")
+ std::to_string(refNum.mIndex) + " shared with cell reference "
+ insertResult.first->second.toString(),
"", CSMDoc::Message::Severity_Error);
// Check reference id
if (cellRef.mRefID.empty())
messages.add(id, "Instance is not based on an object", "", CSMDoc::Message::Severity_Error);
else
{
// Check for non existing referenced object
if (mObjects.searchId(cellRef.mRefID) == -1 && mBodyParts.searchId(cellRef.mRefID) == -1)
{
messages.add(id, "Instance of a non-existent object '" + cellRef.mRefID.getRefIdString() + "'", "",
CSMDoc::Message::Severity_Error);
}
else
{
// Check if reference charge is valid for it's proper referenced type
CSMWorld::RefIdData::LocalIndex localIndex = mDataSet.searchId(cellRef.mRefID);
bool isLight = localIndex.second == CSMWorld::UniversalId::Type_Light;
if ((isLight && cellRef.mChargeFloat < -1) || (!isLight && cellRef.mChargeInt < -1))
messages.add(id, "Invalid charge", "", CSMDoc::Message::Severity_Error);
}
}
// If object have owner, check if that owner reference is valid
if (!cellRef.mOwner.empty() && mObjects.searchId(cellRef.mOwner) == -1)
messages.add(id, "Owner object '" + cellRef.mOwner.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
// If object have creature soul trapped, check if that creature reference is valid
if (!cellRef.mSoul.empty())
if (mObjects.searchId(cellRef.mSoul) == -1)
messages.add(id, "Trapped soul object '" + cellRef.mSoul.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
if (cellRef.mFaction.empty())
{
if (cellRef.mFactionRank != -2)
messages.add(id, "Reference without a faction has a faction rank", "", CSMDoc::Message::Severity_Error);
}
else
{
if (mFactions.searchId(cellRef.mFaction) == -1)
messages.add(id, "Faction '" + cellRef.mFaction.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
else if (cellRef.mFactionRank < -1)
messages.add(id, "Invalid faction rank", "", CSMDoc::Message::Severity_Error);
}
if (!cellRef.mDestCell.empty() && mCells.searchId(ESM::RefId::stringRefId(cellRef.mDestCell)) == -1)
messages.add(
id, "Destination cell '" + cellRef.mDestCell + "' does not exist", "", CSMDoc::Message::Severity_Error);
if (cellRef.mScale < 0)
messages.add(id, "Negative scale", "", CSMDoc::Message::Severity_Error);
// Check if enchantement points aren't negative or are at full (-1)
if (cellRef.mEnchantmentCharge < -1)
messages.add(id, "Negative number of enchantment points", "", CSMDoc::Message::Severity_Error);
if (cellRef.mCount < 1)
messages.add(id, "Reference without count", {}, CSMDoc::Message::Severity_Error);
}
int CSMTools::ReferenceCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
mUsedReferenceIDs.clear();
return mReferences.getSize();
}
| 5,368
|
C++
|
.cpp
| 105
| 44.52381
| 116
| 0.679954
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,954
|
journalcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/journalcheck.cpp
|
#include "journalcheck.hpp"
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <variant>
#include <vector>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/info.hpp>
#include <apps/opencs/model/world/infocollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loadinfo.hpp>
#include "../prefs/state.hpp"
CSMTools::JournalCheckStage::JournalCheckStage(
const CSMWorld::IdCollection<ESM::Dialogue>& journals, const CSMWorld::InfoCollection& journalInfos)
: mJournals(journals)
, mJournalInfos(journalInfos)
{
mIgnoreBaseRecords = false;
}
int CSMTools::JournalCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
mInfosByTopic = mJournalInfos.getInfosByTopic();
return mJournals.getSize();
}
void CSMTools::JournalCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Dialogue>& journalRecord = mJournals.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && journalRecord.mState == CSMWorld::RecordBase::State_BaseOnly)
|| journalRecord.isDeleted())
return;
const ESM::Dialogue& journal = journalRecord.get();
int statusNamedCount = 0;
int totalInfoCount = 0;
std::set<int> questIndices;
if (const auto infos = mInfosByTopic.find(journal.mId); infos != mInfosByTopic.end())
{
for (const CSMWorld::Record<CSMWorld::Info>* record : infos->second)
{
if (record->isDeleted())
continue;
const CSMWorld::Info& journalInfo = record->get();
totalInfoCount += 1;
if (journalInfo.mQuestStatus == ESM::DialInfo::QS_Name)
{
statusNamedCount += 1;
}
// Skip "Base" records (setting!)
if (mIgnoreBaseRecords && record->mState == CSMWorld::RecordBase::State_BaseOnly)
continue;
if (journalInfo.mResponse.empty())
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_JournalInfo, journalInfo.mId);
messages.add(id, "Missing journal entry text", "", CSMDoc::Message::Severity_Warning);
}
// Duplicate index
if (!questIndices.insert(journalInfo.mData.mJournalIndex).second)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_JournalInfo, journalInfo.mId);
messages.add(id, "Duplicated quest index " + std::to_string(journalInfo.mData.mJournalIndex), "",
CSMDoc::Message::Severity_Error);
}
}
}
if (totalInfoCount == 0)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Journal, journal.mId);
messages.add(id, "No related journal entry", "", CSMDoc::Message::Severity_Warning);
}
else if (statusNamedCount > 1)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Journal, journal.mId);
messages.add(id, "Multiple entries with quest status 'Named'", "", CSMDoc::Message::Severity_Error);
}
}
| 3,439
|
C++
|
.cpp
| 82
| 34.926829
| 113
| 0.671257
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,955
|
spellcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/spellcheck.cpp
|
#include "spellcheck.hpp"
#include <string>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadspel.hpp>
#include "../prefs/state.hpp"
#include "effectlistcheck.hpp"
CSMTools::SpellCheckStage::SpellCheckStage(const CSMWorld::IdCollection<ESM::Spell>& spells)
: mSpells(spells)
{
mIgnoreBaseRecords = false;
}
int CSMTools::SpellCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mSpells.getSize();
}
void CSMTools::SpellCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Spell>& record = mSpells.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Spell& spell = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Spell, spell.mId);
// test for empty name
if (spell.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
// test for invalid cost values
if (spell.mData.mCost < 0)
messages.add(id, "Spell cost is negative", "", CSMDoc::Message::Severity_Error);
effectListCheck(spell.mEffects.mList, messages, id);
}
| 1,573
|
C++
|
.cpp
| 37
| 38.945946
| 108
| 0.733728
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,956
|
startscriptcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/startscriptcheck.cpp
|
#include "startscriptcheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadsscr.hpp>
#include <components/misc/strings/lower.hpp>
namespace ESM
{
class Script;
}
CSMTools::StartScriptCheckStage::StartScriptCheckStage(
const CSMWorld::IdCollection<ESM::StartScript>& startScripts, const CSMWorld::IdCollection<ESM::Script>& scripts)
: mStartScripts(startScripts)
, mScripts(scripts)
{
mIgnoreBaseRecords = false;
}
void CSMTools::StartScriptCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::StartScript>& record = mStartScripts.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const auto& scriptId = record.get().mId;
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_StartScript, scriptId);
if (mScripts.searchId(scriptId) == -1)
messages.add(
id, "Start script " + scriptId.getRefIdString() + " does not exist", "", CSMDoc::Message::Severity_Error);
}
int CSMTools::StartScriptCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mStartScripts.getSize();
}
| 1,613
|
C++
|
.cpp
| 39
| 37.974359
| 118
| 0.748879
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,957
|
birthsigncheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/birthsigncheck.cpp
|
#include "birthsigncheck.hpp"
#include <string>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <components/esm3/loadbsgn.hpp>
#include <components/misc/resourcehelpers.hpp>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
CSMTools::BirthsignCheckStage::BirthsignCheckStage(
const CSMWorld::IdCollection<ESM::BirthSign>& birthsigns, const CSMWorld::Resources& textures)
: mBirthsigns(birthsigns)
, mTextures(textures)
{
mIgnoreBaseRecords = false;
}
int CSMTools::BirthsignCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mBirthsigns.getSize();
}
void CSMTools::BirthsignCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::BirthSign>& record = mBirthsigns.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::BirthSign& birthsign = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Birthsign, birthsign.mId);
if (birthsign.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
if (birthsign.mDescription.empty())
messages.add(id, "Description is missing", "", CSMDoc::Message::Severity_Warning);
if (birthsign.mTexture.empty())
messages.add(id, "Image is missing", "", CSMDoc::Message::Severity_Error);
else if (mTextures.searchId(birthsign.mTexture) == -1)
{
std::string ddsTexture = birthsign.mTexture;
if (!(Misc::ResourceHelpers::changeExtensionToDds(ddsTexture) && mTextures.searchId(ddsTexture) != -1))
messages.add(id, "Image '" + birthsign.mTexture + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
/// \todo check data members that can't be edited in the table view
}
| 2,198
|
C++
|
.cpp
| 46
| 43.565217
| 119
| 0.727996
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,958
|
searchoperation.cpp
|
OpenMW_openmw/apps/opencs/model/tools/searchoperation.cpp
|
#include "searchoperation.hpp"
#include "../doc/document.hpp"
#include "../doc/state.hpp"
#include "../world/data.hpp"
#include "../world/idtablebase.hpp"
#include <vector>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/doc/operation.hpp>
#include <apps/opencs/model/tools/search.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include "searchstage.hpp"
CSMTools::SearchOperation::SearchOperation(CSMDoc::Document& document)
: CSMDoc::Operation(CSMDoc::State_Searching, false)
{
std::vector<CSMWorld::UniversalId::Type> types = CSMWorld::UniversalId::listTypes(
CSMWorld::UniversalId::Class_RecordList | CSMWorld::UniversalId::Class_ResourceList);
for (std::vector<CSMWorld::UniversalId::Type>::const_iterator iter(types.begin()); iter != types.end(); ++iter)
appendStage(new SearchStage(&dynamic_cast<CSMWorld::IdTableBase&>(*document.getData().getTableModel(*iter))));
setDefaultSeverity(CSMDoc::Message::Severity_Info);
}
void CSMTools::SearchOperation::configure(const Search& search)
{
mSearch = search;
}
void CSMTools::SearchOperation::appendStage(SearchStage* stage)
{
CSMDoc::Operation::appendStage(stage);
stage->setOperation(this);
}
const CSMTools::Search& CSMTools::SearchOperation::getSearch() const
{
return mSearch;
}
| 1,329
|
C++
|
.cpp
| 33
| 37.484848
| 118
| 0.760311
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,959
|
reportmodel.cpp
|
OpenMW_openmw/apps/opencs/model/tools/reportmodel.cpp
|
#include "reportmodel.hpp"
#include <algorithm>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include "../world/columns.hpp"
CSMTools::ReportModel::ReportModel(bool fieldColumn, bool severityColumn)
: mColumnField(-1)
, mColumnSeverity(-1)
{
int index = 3;
if (severityColumn)
mColumnSeverity = index++;
if (fieldColumn)
mColumnField = index++;
mColumnDescription = index;
}
int CSMTools::ReportModel::rowCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return static_cast<int>(mRows.size());
}
int CSMTools::ReportModel::columnCount(const QModelIndex& parent) const
{
if (parent.isValid())
return 0;
return mColumnDescription + 1;
}
QVariant CSMTools::ReportModel::data(const QModelIndex& index, int role) const
{
if (role != Qt::DisplayRole && role != Qt::UserRole)
return QVariant();
switch (index.column())
{
case Column_Type:
if (role == Qt::UserRole)
return QString::fromUtf8(mRows.at(index.row()).mId.getTypeName().c_str());
else
return static_cast<int>(mRows.at(index.row()).mId.getType());
case Column_Id:
{
CSMWorld::UniversalId id = mRows.at(index.row()).mId;
switch (id.getArgumentType())
{
case CSMWorld::UniversalId::ArgumentType_None:
return QString("-");
case CSMWorld::UniversalId::ArgumentType_Index:
return QString::number(id.getIndex());
case CSMWorld::UniversalId::ArgumentType_Id:
return QString::fromStdString(id.getId());
case CSMWorld::UniversalId::ArgumentType_RefId:
return QString::fromStdString(id.getRefId().toString());
}
return QString("unsupported");
}
case Column_Hint:
return QString::fromUtf8(mRows.at(index.row()).mHint.c_str());
}
if (index.column() == mColumnDescription)
return QString::fromUtf8(mRows.at(index.row()).mMessage.c_str());
if (index.column() == mColumnField)
{
std::string field;
std::istringstream stream(mRows.at(index.row()).mHint);
char type, ignore;
int fieldIndex;
if ((stream >> type >> ignore >> fieldIndex) && (type == 'r' || type == 'R'))
{
field = CSMWorld::Columns::getName(static_cast<CSMWorld::Columns::ColumnId>(fieldIndex));
}
return QString::fromUtf8(field.c_str());
}
if (index.column() == mColumnSeverity)
{
return QString::fromUtf8(CSMDoc::Message::toString(mRows.at(index.row()).mSeverity).c_str());
}
return QVariant();
}
QVariant CSMTools::ReportModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (role != Qt::DisplayRole)
return QVariant();
if (orientation == Qt::Vertical)
return QVariant();
switch (section)
{
case Column_Type:
return "Type";
case Column_Id:
return "ID";
}
if (section == mColumnDescription)
return "Description";
if (section == mColumnField)
return "Field";
if (section == mColumnSeverity)
return "Severity";
return "-";
}
bool CSMTools::ReportModel::removeRows(int row, int count, const QModelIndex& parent)
{
if (parent.isValid())
return false;
if (count > 0)
{
beginRemoveRows(parent, row, row + count - 1);
mRows.erase(mRows.begin() + row, mRows.begin() + row + count);
endRemoveRows();
}
return true;
}
void CSMTools::ReportModel::add(const CSMDoc::Message& message)
{
beginInsertRows(QModelIndex(), static_cast<int>(mRows.size()), static_cast<int>(mRows.size()));
mRows.push_back(message);
endInsertRows();
}
void CSMTools::ReportModel::flagAsReplaced(int index)
{
CSMDoc::Message& line = mRows.at(index);
std::string hint = line.mHint;
if (hint.empty() || hint[0] != 'R')
throw std::logic_error("trying to flag message as replaced that is not replaceable");
hint[0] = 'r';
line.mHint = std::move(hint);
emit dataChanged(this->index(index, 0), this->index(index, columnCount()));
}
const CSMWorld::UniversalId& CSMTools::ReportModel::getUniversalId(int row) const
{
return mRows.at(row).mId;
}
std::string CSMTools::ReportModel::getHint(int row) const
{
return mRows.at(row).mHint;
}
void CSMTools::ReportModel::clear()
{
if (!mRows.empty())
{
beginRemoveRows(QModelIndex(), 0, static_cast<int>(mRows.size()) - 1);
mRows.clear();
endRemoveRows();
}
}
int CSMTools::ReportModel::countErrors() const
{
int count = 0;
for (std::vector<CSMDoc::Message>::const_iterator iter(mRows.begin()); iter != mRows.end(); ++iter)
if (iter->mSeverity == CSMDoc::Message::Severity_Error
|| iter->mSeverity == CSMDoc::Message::Severity_SeriousError)
++count;
return count;
}
| 5,210
|
C++
|
.cpp
| 156
| 26.724359
| 103
| 0.628274
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,960
|
racecheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/racecheck.cpp
|
#include "racecheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadrace.hpp>
void CSMTools::RaceCheckStage::performPerRecord(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Race>& record = mRaces.getRecord(stage);
if (record.isDeleted())
return;
const ESM::Race& race = record.get();
// Consider mPlayable flag even when "Base" records are ignored
if (race.mData.mFlags & 0x1)
mPlayable = true;
// Skip "Base" records (setting!)
if (mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly)
return;
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Race, race.mId);
// test for empty name and description
if (race.mName.empty())
messages.add(id, "Name is missing", "",
(race.mData.mFlags & 0x1) ? CSMDoc::Message::Severity_Error : CSMDoc::Message::Severity_Warning);
if (race.mDescription.empty())
messages.add(id, "Description is missing", "", CSMDoc::Message::Severity_Warning);
// test for positive height
if (race.mData.mMaleHeight <= 0)
messages.add(id, "Male height is non-positive", "", CSMDoc::Message::Severity_Error);
if (race.mData.mFemaleHeight <= 0)
messages.add(id, "Female height is non-positive", "", CSMDoc::Message::Severity_Error);
// test for non-negative weight
if (race.mData.mMaleWeight < 0)
messages.add(id, "Male weight is negative", "", CSMDoc::Message::Severity_Error);
if (race.mData.mFemaleWeight < 0)
messages.add(id, "Female weight is negative", "", CSMDoc::Message::Severity_Error);
/// \todo check data members that can't be edited in the table view
}
void CSMTools::RaceCheckStage::performFinal(CSMDoc::Messages& messages)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Races);
if (!mPlayable)
messages.add(id, "No playable race", "", CSMDoc::Message::Severity_SeriousError);
}
CSMTools::RaceCheckStage::RaceCheckStage(const CSMWorld::IdCollection<ESM::Race>& races)
: mRaces(races)
, mPlayable(false)
{
mIgnoreBaseRecords = false;
}
int CSMTools::RaceCheckStage::setup()
{
mPlayable = false;
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mRaces.getSize() + 1;
}
void CSMTools::RaceCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
if (stage == mRaces.getSize())
performFinal(messages);
else
performPerRecord(stage, messages);
}
| 2,821
|
C++
|
.cpp
| 66
| 38.060606
| 109
| 0.704612
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,961
|
skillcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/skillcheck.cpp
|
#include "skillcheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadskil.hpp>
CSMTools::SkillCheckStage::SkillCheckStage(const CSMWorld::IdCollection<ESM::Skill>& skills)
: mSkills(skills)
{
mIgnoreBaseRecords = false;
}
int CSMTools::SkillCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mSkills.getSize();
}
void CSMTools::SkillCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Skill>& record = mSkills.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Skill& skill = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Skill, skill.mId);
if (skill.mDescription.empty())
messages.add(id, "Description is missing", "", CSMDoc::Message::Severity_Warning);
for (int i = 0; i < 4; ++i)
if (skill.mData.mUseValue[i] < 0)
{
messages.add(id, "Use value #" + std::to_string(i) + " is negative", "", CSMDoc::Message::Severity_Error);
}
}
| 1,514
|
C++
|
.cpp
| 36
| 38.027778
| 118
| 0.707167
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,962
|
bodypartcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/bodypartcheck.cpp
|
#include "bodypartcheck.hpp"
#include <string>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadbody.hpp>
#include "../prefs/state.hpp"
CSMTools::BodyPartCheckStage::BodyPartCheckStage(const CSMWorld::IdCollection<ESM::BodyPart>& bodyParts,
const CSMWorld::Resources& meshes, const CSMWorld::IdCollection<ESM::Race>& races)
: mBodyParts(bodyParts)
, mMeshes(meshes)
, mRaces(races)
{
mIgnoreBaseRecords = false;
}
int CSMTools::BodyPartCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mBodyParts.getSize();
}
void CSMTools::BodyPartCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::BodyPart>& record = mBodyParts.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::BodyPart& bodyPart = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_BodyPart, bodyPart.mId);
// Check BYDT
if (bodyPart.mData.mPart >= ESM::BodyPart::MP_Count)
messages.add(id, "Invalid part", "", CSMDoc::Message::Severity_Error);
if (bodyPart.mData.mType > ESM::BodyPart::MT_Armor)
messages.add(id, "Invalid type", "", CSMDoc::Message::Severity_Error);
// Check MODL
if (bodyPart.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mMeshes.searchId(bodyPart.mModel) == -1)
messages.add(id, "Model '" + bodyPart.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// Check FNAM for skin body parts (for non-skin body parts it's meaningless)
if (bodyPart.mData.mType == ESM::BodyPart::MT_Skin)
{
if (bodyPart.mRace.empty())
messages.add(id, "Race is missing", "", CSMDoc::Message::Severity_Error);
else if (mRaces.searchId(bodyPart.mRace) == -1)
messages.add(id, "Race '" + bodyPart.mRace.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
}
}
| 2,482
|
C++
|
.cpp
| 52
| 42.903846
| 112
| 0.702277
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,963
|
gmstcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/gmstcheck.cpp
|
#include "gmstcheck.hpp"
#include <sstream>
#include <stddef.h>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadgmst.hpp>
#include "../prefs/state.hpp"
#include "../world/defaultgmsts.hpp"
CSMTools::GmstCheckStage::GmstCheckStage(const CSMWorld::IdCollection<ESM::GameSetting>& gameSettings)
: mGameSettings(gameSettings)
{
mIgnoreBaseRecords = false;
}
int CSMTools::GmstCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mGameSettings.getSize();
}
void CSMTools::GmstCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::GameSetting>& record = mGameSettings.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::GameSetting& gmst = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Gmst, gmst.mId);
const std::string& gmstIdString = gmst.mId.getRefIdString();
// Test for empty string
if (gmst.mValue.getType() == ESM::VT_String && gmst.mValue.getString().empty())
messages.add(id, gmstIdString + " is an empty string", "", CSMDoc::Message::Severity_Warning);
// Checking type and limits
// optimization - compare it to lists based on naming convention (f-float,i-int,s-string)
if (gmst.mId.startsWith("f"))
{
for (size_t i = 0; i < CSMWorld::DefaultGmsts::FloatCount; ++i)
{
if (gmst.mId == ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Floats[i]))
{
if (gmst.mValue.getType() != ESM::VT_Float)
{
std::ostringstream stream;
stream << "Expected float type for " << gmst.mId << " but found "
<< varTypeToString(gmst.mValue.getType()) << " type";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
}
if (gmst.mValue.getFloat() < CSMWorld::DefaultGmsts::FloatLimits[i * 2])
messages.add(
id, gmstIdString + " is less than the suggested range", "", CSMDoc::Message::Severity_Warning);
if (gmst.mValue.getFloat() > CSMWorld::DefaultGmsts::FloatLimits[i * 2 + 1])
messages.add(
id, gmstIdString + " is more than the suggested range", "", CSMDoc::Message::Severity_Warning);
break; // for loop
}
}
}
else if (gmst.mId.startsWith("i"))
{
for (size_t i = 0; i < CSMWorld::DefaultGmsts::IntCount; ++i)
{
if (gmst.mId == ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Ints[i]))
{
if (gmst.mValue.getType() != ESM::VT_Int)
{
std::ostringstream stream;
stream << "Expected int type for " << gmst.mId << " but found "
<< varTypeToString(gmst.mValue.getType()) << " type";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
}
if (gmst.mValue.getInteger() < CSMWorld::DefaultGmsts::IntLimits[i * 2])
messages.add(
id, gmstIdString + " is less than the suggested range", "", CSMDoc::Message::Severity_Warning);
if (gmst.mValue.getInteger() > CSMWorld::DefaultGmsts::IntLimits[i * 2 + 1])
messages.add(
id, gmstIdString + " is more than the suggested range", "", CSMDoc::Message::Severity_Warning);
break; // for loop
}
}
}
else if (gmst.mId.startsWith("s"))
{
for (size_t i = 0; i < CSMWorld::DefaultGmsts::StringCount; ++i)
{
if (gmst.mId == ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Strings[i]))
{
ESM::VarType type = gmst.mValue.getType();
if (type != ESM::VT_String && type != ESM::VT_None)
{
std::ostringstream stream;
stream << "Expected string or none type for " << gmstIdString << " but found "
<< varTypeToString(gmst.mValue.getType()) << " type";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
}
break; // for loop
}
}
}
}
std::string CSMTools::GmstCheckStage::varTypeToString(ESM::VarType type)
{
switch (type)
{
case ESM::VT_Unknown:
return "unknown";
case ESM::VT_None:
return "none";
case ESM::VT_Short:
return "short";
case ESM::VT_Int:
return "int";
case ESM::VT_Long:
return "long";
case ESM::VT_Float:
return "float";
case ESM::VT_String:
return "string";
default:
return "unhandled";
}
}
| 5,380
|
C++
|
.cpp
| 123
| 33.03252
| 119
| 0.569763
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,964
|
mergestages.cpp
|
OpenMW_openmw/apps/opencs/model/tools/mergestages.cpp
|
#include "mergestages.hpp"
#include <cstdint>
#include <filesystem>
#include <utility>
#include <vector>
#include <apps/opencs/model/world/land.hpp>
#include <apps/opencs/model/world/metadata.hpp>
#include <apps/opencs/model/world/ref.hpp>
#include <apps/opencs/model/world/refcollection.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/esmreader.hpp>
#include "mergestate.hpp"
#include "../doc/document.hpp"
#include "../world/commands.hpp"
#include "../world/data.hpp"
#include "../world/idtable.hpp"
namespace CSMDoc
{
class Messages;
}
CSMTools::StartMergeStage::StartMergeStage(MergeState& state)
: mState(state)
{
}
int CSMTools::StartMergeStage::setup()
{
return 1;
}
void CSMTools::StartMergeStage::perform(int stage, CSMDoc::Messages& messages)
{
mState.mCompleted = false;
mState.mTextureIndices.clear();
}
CSMTools::FinishMergedDocumentStage::FinishMergedDocumentStage(MergeState& state, ToUTF8::FromType encoding)
: mState(state)
, mEncoder(encoding)
{
}
int CSMTools::FinishMergedDocumentStage::setup()
{
return 1;
}
void CSMTools::FinishMergedDocumentStage::perform(int stage, CSMDoc::Messages& messages)
{
// We know that the content file list contains at least two entries and that the first one
// does exist on disc (otherwise it would have been impossible to initiate a merge on that
// document).
std::filesystem::path path = mState.mSource.getContentFiles()[0];
ESM::ESMReader reader;
reader.setEncoder(&mEncoder);
reader.open(path);
CSMWorld::MetaData source;
source.mId = ESM::RefId::stringRefId("sys::meta");
source.load(reader);
CSMWorld::MetaData target = mState.mTarget->getData().getMetaData();
target.mAuthor = source.mAuthor;
target.mDescription = source.mDescription;
mState.mTarget->getData().setMetaData(target);
mState.mCompleted = true;
}
CSMTools::MergeRefIdsStage::MergeRefIdsStage(MergeState& state)
: mState(state)
{
}
int CSMTools::MergeRefIdsStage::setup()
{
return mState.mSource.getData().getReferenceables().getSize();
}
void CSMTools::MergeRefIdsStage::perform(int stage, CSMDoc::Messages& messages)
{
mState.mSource.getData().getReferenceables().copyTo(stage, mState.mTarget->getData().getReferenceables());
}
CSMTools::MergeReferencesStage::MergeReferencesStage(MergeState& state)
: mState(state)
{
}
int CSMTools::MergeReferencesStage::setup()
{
mIndex.clear();
return mState.mSource.getData().getReferences().getSize();
}
void CSMTools::MergeReferencesStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<CSMWorld::CellRef>& record = mState.mSource.getData().getReferences().getRecord(stage);
if (!record.isDeleted())
{
CSMWorld::CellRef ref = record.get();
ref.mOriginalCell = ref.mCell;
ref.mRefNum.mIndex = mIndex[ref.mCell]++;
ref.mRefNum.mContentFile = -1;
ref.mNew = false;
mState.mTarget->getData().getReferences().appendRecord(std::make_unique<CSMWorld::Record<CSMWorld::CellRef>>(
CSMWorld::Record<CSMWorld::CellRef>(CSMWorld::RecordBase::State_ModifiedOnly, nullptr, &ref)));
}
}
CSMTools::PopulateLandTexturesMergeStage::PopulateLandTexturesMergeStage(MergeState& state)
: mState(state)
{
}
int CSMTools::PopulateLandTexturesMergeStage::setup()
{
return mState.mSource.getData().getLandTextures().getSize();
}
void CSMTools::PopulateLandTexturesMergeStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::LandTexture>& record = mState.mSource.getData().getLandTextures().getRecord(stage);
if (!record.isDeleted())
{
mState.mTarget->getData().getLandTextures().appendRecord(std::make_unique<CSMWorld::Record<ESM::LandTexture>>(
CSMWorld::Record<ESM::LandTexture>(CSMWorld::RecordBase::State_ModifiedOnly, nullptr, &record.get())));
}
}
CSMTools::MergeLandStage::MergeLandStage(MergeState& state)
: mState(state)
{
}
int CSMTools::MergeLandStage::setup()
{
return mState.mSource.getData().getLand().getSize();
}
void CSMTools::MergeLandStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<CSMWorld::Land>& record = mState.mSource.getData().getLand().getRecord(stage);
if (!record.isDeleted())
{
mState.mTarget->getData().getLand().appendRecord(std::make_unique<CSMWorld::Record<CSMWorld::Land>>(
CSMWorld::Record<CSMWorld::Land>(CSMWorld::RecordBase::State_ModifiedOnly, nullptr, &record.get())));
}
}
CSMTools::FixLandsAndLandTexturesMergeStage::FixLandsAndLandTexturesMergeStage(MergeState& state)
: mState(state)
{
}
int CSMTools::FixLandsAndLandTexturesMergeStage::setup()
{
// We will have no more than the source
return mState.mSource.getData().getLand().getSize();
}
void CSMTools::FixLandsAndLandTexturesMergeStage::perform(int stage, CSMDoc::Messages& messages)
{
if (stage < mState.mTarget->getData().getLand().getSize())
{
CSMWorld::IdTable& landTable = dynamic_cast<CSMWorld::IdTable&>(
*mState.mTarget->getData().getTableModel(CSMWorld::UniversalId::Type_Lands));
CSMWorld::IdTable& ltexTable = dynamic_cast<CSMWorld::IdTable&>(
*mState.mTarget->getData().getTableModel(CSMWorld::UniversalId::Type_LandTextures));
const auto& id = mState.mTarget->getData().getLand().getId(stage);
CSMWorld::TouchLandCommand cmd(landTable, ltexTable, id.getRefIdString());
cmd.redo();
// Get rid of base data
const CSMWorld::Record<CSMWorld::Land>& oldRecord = mState.mTarget->getData().getLand().getRecord(stage);
mState.mTarget->getData().getLand().setRecord(stage,
std::make_unique<CSMWorld::Record<CSMWorld::Land>>(
CSMWorld::Record<CSMWorld::Land>(CSMWorld::RecordBase::State_ModifiedOnly, nullptr, &oldRecord.get())));
}
}
CSMTools::CleanupLandTexturesMergeStage::CleanupLandTexturesMergeStage(MergeState& state)
: mState(state)
{
}
int CSMTools::CleanupLandTexturesMergeStage::setup()
{
return 1;
}
void CSMTools::CleanupLandTexturesMergeStage::perform(int stage, CSMDoc::Messages& messages)
{
auto& landTextures = mState.mTarget->getData().getLandTextures();
for (int i = 0; i < landTextures.getSize();)
{
if (!landTextures.getRecord(i).isModified())
landTextures.removeRows(i, 1);
else
++i;
}
}
| 6,597
|
C++
|
.cpp
| 177
| 33.271186
| 120
| 0.733407
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,965
|
pathgridcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/pathgridcheck.cpp
|
#include "pathgridcheck.hpp"
#include <algorithm>
#include <memory>
#include <sstream>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadpgrd.hpp>
#include "../prefs/state.hpp"
#include "../world/idcollection.hpp"
#include "../world/pathgrid.hpp"
#include "../world/subcellcollection.hpp"
#include "../world/universalid.hpp"
CSMTools::PathgridCheckStage::PathgridCheckStage(const CSMWorld::SubCellCollection<CSMWorld::Pathgrid>& pathgrids)
: mPathgrids(pathgrids)
{
mIgnoreBaseRecords = false;
}
int CSMTools::PathgridCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mPathgrids.getSize();
}
void CSMTools::PathgridCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<CSMWorld::Pathgrid>& record = mPathgrids.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const CSMWorld::Pathgrid& pathgrid = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Pathgrid, pathgrid.mId);
// check the number of pathgrid points
if (pathgrid.mData.mPoints < pathgrid.mPoints.size())
messages.add(id, "Less points than expected", "", CSMDoc::Message::Severity_Error);
else if (pathgrid.mData.mPoints > pathgrid.mPoints.size())
messages.add(id, "More points than expected", "", CSMDoc::Message::Severity_Error);
std::vector<CSMTools::Point> pointList(pathgrid.mPoints.size());
std::vector<size_t> duplList;
for (const auto& edge : pathgrid.mEdges)
{
if (edge.mV0 < pathgrid.mPoints.size())
{
auto& point = pointList[edge.mV0];
point.mConnectionNum++;
// first check for duplicate edges
size_t j = 0;
for (; j < point.mOtherIndex.size(); ++j)
{
if (point.mOtherIndex[j] == edge.mV1)
{
std::ostringstream ss;
ss << "Duplicate edge between points #" << edge.mV0 << " and #" << edge.mV1;
messages.add(id, ss.str(), {}, CSMDoc::Message::Severity_Error);
break;
}
}
// only add if not a duplicate
if (j == point.mOtherIndex.size())
point.mOtherIndex.push_back(edge.mV1);
}
else
{
std::ostringstream ss;
ss << "An edge is connected to a non-existent point #" << edge.mV0;
messages.add(id, ss.str(), {}, CSMDoc::Message::Severity_Error);
}
}
for (size_t i = 0; i < pathgrid.mPoints.size(); ++i)
{
// check that edges are bidirectional
bool foundReverse = false;
for (const auto& otherIndex : pointList[i].mOtherIndex)
{
for (const auto& other : pointList[otherIndex].mOtherIndex)
{
if (other == i)
{
foundReverse = true;
break;
}
}
if (!foundReverse)
{
std::ostringstream ss;
ss << "Missing edge between points #" << i << " and #" << otherIndex;
messages.add(id, ss.str(), {}, CSMDoc::Message::Severity_Error);
}
}
// check duplicate points
// FIXME: how to do this efficiently?
for (size_t j = 0; j != i; ++j)
{
if (pathgrid.mPoints[i].mX == pathgrid.mPoints[j].mX && pathgrid.mPoints[i].mY == pathgrid.mPoints[j].mY
&& pathgrid.mPoints[i].mZ == pathgrid.mPoints[j].mZ)
{
auto it = std::find(duplList.begin(), duplList.end(), i);
if (it == duplList.end())
{
std::ostringstream ss;
ss << "Point #" << i << " duplicates point #" << j << " (" << pathgrid.mPoints[i].mX << ", "
<< pathgrid.mPoints[i].mY << ", " << pathgrid.mPoints[i].mZ << ")";
messages.add(id, ss.str(), {}, CSMDoc::Message::Severity_Warning);
duplList.push_back(i);
break;
}
}
}
}
// check pathgrid points that are not connected to anything
for (size_t i = 0; i < pointList.size(); ++i)
{
if (pointList[i].mConnectionNum == 0)
{
std::ostringstream ss;
ss << "Point #" << i << " (" << pathgrid.mPoints[i].mX << ", " << pathgrid.mPoints[i].mY << ", "
<< pathgrid.mPoints[i].mZ << ") is disconnected from other points";
messages.add(id, ss.str(), {}, CSMDoc::Message::Severity_Warning);
}
}
// TODO: check whether there are disconnected graphs
}
| 5,077
|
C++
|
.cpp
| 122
| 31.729508
| 116
| 0.56416
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,966
|
scriptcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/scriptcheck.cpp
|
#include "scriptcheck.hpp"
#include <exception>
#include <sstream>
#include <string>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/scriptcontext.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/compiler/exception.hpp>
#include <components/compiler/extensions0.hpp>
#include <components/compiler/fileparser.hpp>
#include <components/compiler/scanner.hpp>
#include <components/compiler/tokenloc.hpp>
#include <components/esm3/loadscpt.hpp>
#include "../doc/document.hpp"
#include "../world/data.hpp"
#include "../prefs/state.hpp"
CSMDoc::Message::Severity CSMTools::ScriptCheckStage::getSeverity(Type type)
{
switch (type)
{
case WarningMessage:
return CSMDoc::Message::Severity_Warning;
case ErrorMessage:
return CSMDoc::Message::Severity_Error;
}
return CSMDoc::Message::Severity_SeriousError;
}
void CSMTools::ScriptCheckStage::report(const std::string& message, const Compiler::TokenLoc& loc, Type type)
{
std::ostringstream stream;
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Script, mId);
stream << message << " (" << loc.mLiteral << ")"
<< " @ line " << loc.mLine + 1 << ", column " << loc.mColumn;
std::ostringstream hintStream;
hintStream << "l:" << loc.mLine + 1 << " " << loc.mColumn;
mMessages->add(id, stream.str(), hintStream.str(), getSeverity(type));
}
void CSMTools::ScriptCheckStage::report(const std::string& message, Type type)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Script, mId);
std::ostringstream stream;
stream << message;
mMessages->add(id, stream.str(), "", getSeverity(type));
}
CSMTools::ScriptCheckStage::ScriptCheckStage(const CSMDoc::Document& document)
: mDocument(document)
, mContext(document.getData())
, mMessages(nullptr)
, mWarningMode(Mode_Ignore)
{
/// \todo add an option to configure warning mode
setWarningsMode(0);
Compiler::registerExtensions(mExtensions);
mContext.setExtensions(&mExtensions);
mIgnoreBaseRecords = false;
}
int CSMTools::ScriptCheckStage::setup()
{
std::string warnings = CSMPrefs::get()["Scripts"]["warnings"].toString();
if (warnings == "Ignore")
mWarningMode = Mode_Ignore;
else if (warnings == "Normal")
mWarningMode = Mode_Normal;
else if (warnings == "Strict")
mWarningMode = Mode_Strict;
mContext.clear();
mMessages = nullptr;
mId = ESM::RefId();
Compiler::ErrorHandler::reset();
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mDocument.getData().getScripts().getSize();
}
void CSMTools::ScriptCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Script>& record = mDocument.getData().getScripts().getRecord(stage);
mId = mDocument.getData().getScripts().getId(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
mMessages = &messages;
switch (mWarningMode)
{
case Mode_Ignore:
setWarningsMode(0);
break;
case Mode_Normal:
setWarningsMode(1);
break;
case Mode_Strict:
setWarningsMode(2);
break;
}
try
{
mFile = record.get().mId.getRefIdString();
std::istringstream input(record.get().mScriptText);
Compiler::Scanner scanner(*this, input, mContext.getExtensions());
Compiler::FileParser parser(*this, mContext);
scanner.scan(parser);
}
catch (const Compiler::SourceException&)
{
// error has already been reported via error handler
}
catch (const std::exception& error)
{
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Script, mId);
std::ostringstream stream;
stream << error.what();
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_SeriousError);
}
mMessages = nullptr;
}
| 4,340
|
C++
|
.cpp
| 117
| 31.820513
| 109
| 0.688008
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,967
|
mergeoperation.cpp
|
OpenMW_openmw/apps/opencs/model/tools/mergeoperation.cpp
|
#include "mergeoperation.hpp"
#include <utility>
#include <variant>
#include <apps/opencs/model/doc/operation.hpp>
#include <apps/opencs/model/tools/mergestate.hpp>
#include <apps/opencs/model/world/cell.hpp>
#include <apps/opencs/model/world/data.hpp>
#include <apps/opencs/model/world/info.hpp>
#include <apps/opencs/model/world/infocollection.hpp>
#include <apps/opencs/model/world/pathgrid.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/subcellcollection.hpp>
#include <components/esm3/debugprofile.hpp>
#include <components/esm3/filter.hpp>
#include <components/esm3/loadbody.hpp>
#include <components/esm3/loadbsgn.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/loadscpt.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/loadsndg.hpp>
#include <components/esm3/loadsoun.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadsscr.hpp>
#include "../doc/document.hpp"
#include "../doc/state.hpp"
#include "mergestages.hpp"
CSMTools::MergeOperation::MergeOperation(CSMDoc::Document& document, ToUTF8::FromType encoding)
: CSMDoc::Operation(CSMDoc::State_Merging, true)
, mState(document)
{
appendStage(new StartMergeStage(mState));
appendStage(new MergeIdCollectionStage<ESM::Global>(mState, &CSMWorld::Data::getGlobals));
appendStage(new MergeIdCollectionStage<ESM::GameSetting>(mState, &CSMWorld::Data::getGmsts));
appendStage(new MergeIdCollectionStage<ESM::Skill>(mState, &CSMWorld::Data::getSkills));
appendStage(new MergeIdCollectionStage<ESM::Class>(mState, &CSMWorld::Data::getClasses));
appendStage(new MergeIdCollectionStage<ESM::Faction>(mState, &CSMWorld::Data::getFactions));
appendStage(new MergeIdCollectionStage<ESM::Race>(mState, &CSMWorld::Data::getRaces));
appendStage(new MergeIdCollectionStage<ESM::Sound>(mState, &CSMWorld::Data::getSounds));
appendStage(new MergeIdCollectionStage<ESM::Script>(mState, &CSMWorld::Data::getScripts));
appendStage(new MergeIdCollectionStage<ESM::Region>(mState, &CSMWorld::Data::getRegions));
appendStage(new MergeIdCollectionStage<ESM::BirthSign>(mState, &CSMWorld::Data::getBirthsigns));
appendStage(new MergeIdCollectionStage<ESM::Spell>(mState, &CSMWorld::Data::getSpells));
appendStage(new MergeIdCollectionStage<ESM::Dialogue>(mState, &CSMWorld::Data::getTopics));
appendStage(new MergeIdCollectionStage<ESM::Dialogue>(mState, &CSMWorld::Data::getJournals));
appendStage(new MergeIdCollectionStage<CSMWorld::Cell>(mState, &CSMWorld::Data::getCells));
appendStage(new MergeIdCollectionStage<ESM::Filter>(mState, &CSMWorld::Data::getFilters));
appendStage(new MergeIdCollectionStage<ESM::Enchantment>(mState, &CSMWorld::Data::getEnchantments));
appendStage(new MergeIdCollectionStage<ESM::BodyPart>(mState, &CSMWorld::Data::getBodyParts));
appendStage(new MergeIdCollectionStage<ESM::DebugProfile>(mState, &CSMWorld::Data::getDebugProfiles));
appendStage(new MergeIdCollectionStage<ESM::SoundGenerator>(mState, &CSMWorld::Data::getSoundGens));
appendStage(new MergeIdCollectionStage<ESM::MagicEffect>(mState, &CSMWorld::Data::getMagicEffects));
appendStage(new MergeIdCollectionStage<ESM::StartScript>(mState, &CSMWorld::Data::getStartScripts));
appendStage(new MergeIdCollectionStage<CSMWorld::Pathgrid, CSMWorld::SubCellCollection<CSMWorld::Pathgrid>>(
mState, &CSMWorld::Data::getPathgrids));
appendStage(
new MergeIdCollectionStage<CSMWorld::Info, CSMWorld::InfoCollection>(mState, &CSMWorld::Data::getTopicInfos));
appendStage(
new MergeIdCollectionStage<CSMWorld::Info, CSMWorld::InfoCollection>(mState, &CSMWorld::Data::getJournalInfos));
appendStage(new MergeRefIdsStage(mState));
appendStage(new MergeReferencesStage(mState));
appendStage(new MergeReferencesStage(mState));
appendStage(new PopulateLandTexturesMergeStage(mState));
appendStage(new MergeLandStage(mState));
appendStage(new FixLandsAndLandTexturesMergeStage(mState));
appendStage(new CleanupLandTexturesMergeStage(mState));
appendStage(new FinishMergedDocumentStage(mState, encoding));
}
void CSMTools::MergeOperation::setTarget(std::unique_ptr<CSMDoc::Document> document)
{
mState.mTarget = std::move(document);
}
void CSMTools::MergeOperation::operationDone()
{
CSMDoc::Operation::operationDone();
if (mState.mCompleted)
emit mergeDone(mState.mTarget.release());
}
| 4,819
|
C++
|
.cpp
| 85
| 53.4
| 120
| 0.78827
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,968
|
magiceffectcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/magiceffectcheck.cpp
|
#include "magiceffectcheck.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/misc/resourcehelpers.hpp>
#include "../prefs/state.hpp"
namespace ESM
{
struct Sound;
}
std::string CSMTools::MagicEffectCheckStage::checkObject(
const ESM::RefId& id, const CSMWorld::UniversalId& type, const std::string& column) const
{
CSMWorld::RefIdData::LocalIndex index = mObjects.getDataSet().searchId(id);
if (index.first == -1)
return (column + " '" + id.getRefIdString() + "' does not exist");
else if (index.second != type.getType())
return (column + " '" + id.getRefIdString() + "' does not have " + type.getTypeName() + " type");
return std::string();
}
CSMTools::MagicEffectCheckStage::MagicEffectCheckStage(const CSMWorld::IdCollection<ESM::MagicEffect>& effects,
const CSMWorld::IdCollection<ESM::Sound>& sounds, const CSMWorld::RefIdCollection& objects,
const CSMWorld::Resources& icons, const CSMWorld::Resources& textures)
: mMagicEffects(effects)
, mSounds(sounds)
, mObjects(objects)
, mIcons(icons)
, mTextures(textures)
{
mIgnoreBaseRecords = false;
}
int CSMTools::MagicEffectCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mMagicEffects.getSize();
}
void CSMTools::MagicEffectCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::MagicEffect>& record = mMagicEffects.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
ESM::MagicEffect effect = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_MagicEffect, CSMWorld::getRecordId(effect));
if (effect.mData.mSpeed <= 0.0f)
{
messages.add(id, "Speed is less than or equal to zero", "", CSMDoc::Message::Severity_Error);
}
if (effect.mDescription.empty())
{
messages.add(id, "Description is missing", "", CSMDoc::Message::Severity_Warning);
}
if (effect.mData.mBaseCost < 0.0f)
{
messages.add(id, "Base cost is negative", "", CSMDoc::Message::Severity_Error);
}
if (effect.mIcon.empty())
{
messages.add(id, "Icon is missing", "", CSMDoc::Message::Severity_Error);
}
else
{
if (mIcons.searchId(effect.mIcon) == -1)
{
std::string ddsIcon = effect.mIcon;
if (!(Misc::ResourceHelpers::changeExtensionToDds(ddsIcon) && mIcons.searchId(ddsIcon) != -1))
messages.add(id, "Icon '" + effect.mIcon + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
}
if (!effect.mParticle.empty())
{
if (mTextures.searchId(effect.mParticle) == -1)
{
std::string ddsParticle = effect.mParticle;
if (!(Misc::ResourceHelpers::changeExtensionToDds(ddsParticle) && mTextures.searchId(ddsParticle) != -1))
messages.add(id, "Particle texture '" + effect.mParticle + "' does not exist", "",
CSMDoc::Message::Severity_Error);
}
}
if (!effect.mCasting.empty())
{
const std::string error = checkObject(effect.mCasting, CSMWorld::UniversalId::Type_Static, "Casting object");
if (!error.empty())
messages.add(id, error, "", CSMDoc::Message::Severity_Error);
}
if (!effect.mHit.empty())
{
const std::string error = checkObject(effect.mHit, CSMWorld::UniversalId::Type_Static, "Hit object");
if (!error.empty())
messages.add(id, error, "", CSMDoc::Message::Severity_Error);
}
if (!effect.mArea.empty())
{
const std::string error = checkObject(effect.mArea, CSMWorld::UniversalId::Type_Static, "Area object");
if (!error.empty())
messages.add(id, error, "", CSMDoc::Message::Severity_Error);
}
if (!effect.mBolt.empty())
{
const std::string error = checkObject(effect.mBolt, CSMWorld::UniversalId::Type_Weapon, "Bolt object");
if (!error.empty())
messages.add(id, error, "", CSMDoc::Message::Severity_Error);
}
if (!effect.mCastSound.empty() && mSounds.searchId(effect.mCastSound) == -1)
messages.add(id, "Casting sound '" + effect.mCastSound.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
if (!effect.mHitSound.empty() && mSounds.searchId(effect.mHitSound) == -1)
messages.add(id, "Hit sound '" + effect.mHitSound.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
if (!effect.mAreaSound.empty() && mSounds.searchId(effect.mAreaSound) == -1)
messages.add(id, "Area sound '" + effect.mAreaSound.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
if (!effect.mBoltSound.empty() && mSounds.searchId(effect.mBoltSound) == -1)
messages.add(id, "Bolt sound '" + effect.mBoltSound.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
}
| 5,549
|
C++
|
.cpp
| 122
| 39.262295
| 117
| 0.661487
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,969
|
regioncheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/regioncheck.cpp
|
#include "regioncheck.hpp"
#include <string>
#include <vector>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadregn.hpp>
CSMTools::RegionCheckStage::RegionCheckStage(const CSMWorld::IdCollection<ESM::Region>& regions)
: mRegions(regions)
{
mIgnoreBaseRecords = false;
}
int CSMTools::RegionCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mRegions.getSize();
}
void CSMTools::RegionCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Region>& record = mRegions.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Region& region = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Region, region.mId);
// test for empty name
if (region.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
/// \todo test that the ID in mSleeplist exists
// test that chances add up to 100
auto chances = std::accumulate(region.mData.mProbabilities.begin(), region.mData.mProbabilities.end(), 0u);
if (chances != 100)
messages.add(id, "Weather chances do not add up to 100", "", CSMDoc::Message::Severity_Error);
for (const ESM::Region::SoundRef& sound : region.mSoundList)
{
if (sound.mChance > 100)
messages.add(id, "Chance of '" + sound.mSound.getRefIdString() + "' sound to play is over 100 percent", "",
CSMDoc::Message::Severity_Warning);
}
/// \todo check data members that can't be edited in the table view
}
| 2,035
|
C++
|
.cpp
| 45
| 40.822222
| 119
| 0.710086
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,970
|
soundgencheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/soundgencheck.cpp
|
#include "soundgencheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include "../world/refiddata.hpp"
#include "../world/universalid.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <components/esm3/loadsndg.hpp>
#include <components/esm3/loadsoun.hpp>
CSMTools::SoundGenCheckStage::SoundGenCheckStage(const CSMWorld::IdCollection<ESM::SoundGenerator>& soundGens,
const CSMWorld::IdCollection<ESM::Sound>& sounds, const CSMWorld::RefIdCollection& objects)
: mSoundGens(soundGens)
, mSounds(sounds)
, mObjects(objects)
{
mIgnoreBaseRecords = false;
}
int CSMTools::SoundGenCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mSoundGens.getSize();
}
void CSMTools::SoundGenCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::SoundGenerator>& record = mSoundGens.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::SoundGenerator& soundGen = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_SoundGen, soundGen.mId);
if (!soundGen.mCreature.empty())
{
CSMWorld::RefIdData::LocalIndex creatureIndex = mObjects.getDataSet().searchId(soundGen.mCreature);
if (creatureIndex.first == -1)
{
messages.add(id, "Creature '" + soundGen.mCreature.getRefIdString() + "' doesn't exist", "",
CSMDoc::Message::Severity_Error);
}
else if (creatureIndex.second != CSMWorld::UniversalId::Type_Creature)
{
messages.add(id, "'" + soundGen.mCreature.getRefIdString() + "' is not a creature", "",
CSMDoc::Message::Severity_Error);
}
}
if (soundGen.mSound.empty())
{
messages.add(id, "Sound is missing", "", CSMDoc::Message::Severity_Error);
}
else if (mSounds.searchId(soundGen.mSound) == -1)
{
messages.add(
id, "Sound '" + soundGen.mSound.getRefIdString() + "' doesn't exist", "", CSMDoc::Message::Severity_Error);
}
}
| 2,467
|
C++
|
.cpp
| 58
| 37.310345
| 119
| 0.695743
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,971
|
search.cpp
|
OpenMW_openmw/apps/opencs/model/tools/search.cpp
|
#include "search.hpp"
#include <QModelIndex>
#include <QRegularExpression>
#include <QString>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <apps/opencs/model/world/columns.hpp>
#include "../doc/document.hpp"
#include "../doc/messages.hpp"
#include "../world/columnbase.hpp"
#include "../world/commands.hpp"
#include "../world/idtablebase.hpp"
#include "../world/universalid.hpp"
void CSMTools::Search::searchTextCell(const CSMWorld::IdTableBase* model, const QModelIndex& index,
const CSMWorld::UniversalId& id, bool writable, CSMDoc::Messages& messages) const
{
// using QString here for easier handling of case folding.
QString search = QString::fromUtf8(mText.c_str());
QString text = model->data(index).toString();
int pos = 0;
Qt::CaseSensitivity caseSensitivity = mCase ? Qt::CaseSensitive : Qt::CaseInsensitive;
while ((pos = text.indexOf(search, pos, caseSensitivity)) != -1)
{
std::ostringstream hint;
hint << (writable ? 'R' : 'r') << ": " << model->getColumnId(index.column()) << " " << pos << " "
<< search.length();
messages.add(id, formatDescription(text, pos, search.length()).toUtf8().data(), hint.str());
pos += search.length();
}
}
void CSMTools::Search::searchRegExCell(const CSMWorld::IdTableBase* model, const QModelIndex& index,
const CSMWorld::UniversalId& id, bool writable, CSMDoc::Messages& messages) const
{
// TODO: verify regular expression before starting a search
if (!mRegExp.isValid())
return;
QString text = model->data(index).toString();
QRegularExpressionMatchIterator i = mRegExp.globalMatch(text);
while (i.hasNext())
{
QRegularExpressionMatch match = i.next();
int pos = match.capturedStart();
int length = match.capturedLength();
std::ostringstream hint;
hint << (writable ? 'R' : 'r') << ": " << model->getColumnId(index.column()) << " " << pos << " " << length;
messages.add(id, formatDescription(text, pos, length).toUtf8().data(), hint.str());
}
}
void CSMTools::Search::searchRecordStateCell(const CSMWorld::IdTableBase* model, const QModelIndex& index,
const CSMWorld::UniversalId& id, bool writable, CSMDoc::Messages& messages) const
{
if (writable)
throw std::logic_error("Record state can not be modified by search and replace");
int data = model->data(index).toInt();
if (data == mValue)
{
std::vector<std::pair<int, std::string>> states
= CSMWorld::Columns::getEnums(CSMWorld::Columns::ColumnId_Modification);
const std::string hint = "r: " + std::to_string(model->getColumnId(index.column()));
messages.add(id, states.at(data).second, hint);
}
}
QString CSMTools::Search::formatDescription(const QString& description, int pos, int length) const
{
QString text(description);
// split
QString highlight = flatten(text.mid(pos, length));
QString before = flatten(mPaddingBefore >= pos ? text.mid(0, pos) : text.mid(pos - mPaddingBefore, mPaddingBefore));
QString after = flatten(text.mid(pos + length, mPaddingAfter));
// compensate for Windows nonsense
text.remove('\r');
// join
text = before + "<b>" + highlight + "</b>" + after;
// improve layout for single line display
text.replace("\n", "<CR>");
text.replace('\t', ' ');
return text;
}
QString CSMTools::Search::flatten(const QString& text) const
{
QString flat(text);
flat.replace("&", "&");
flat.replace("<", "<");
return flat;
}
CSMTools::Search::Search()
: mType(Type_None)
, mValue(0)
, mCase(false)
, mIdColumn(0)
, mTypeColumn(0)
, mPaddingBefore(10)
, mPaddingAfter(10)
{
}
CSMTools::Search::Search(Type type, bool caseSensitive, const std::string& value)
: mType(type)
, mText(value)
, mValue(0)
, mCase(caseSensitive)
, mIdColumn(0)
, mTypeColumn(0)
, mPaddingBefore(10)
, mPaddingAfter(10)
{
if (type != Type_Text && type != Type_Id)
throw std::logic_error("Invalid search parameter (string)");
}
CSMTools::Search::Search(Type type, bool caseSensitive, const QRegularExpression& value)
: mType(type)
, mRegExp(value)
, mValue(0)
, mCase(caseSensitive)
, mIdColumn(0)
, mTypeColumn(0)
, mPaddingBefore(10)
, mPaddingAfter(10)
{
mRegExp.setPatternOptions(mCase ? QRegularExpression::NoPatternOption : QRegularExpression::CaseInsensitiveOption);
if (type != Type_TextRegEx && type != Type_IdRegEx)
throw std::logic_error("Invalid search parameter (RegExp)");
}
CSMTools::Search::Search(Type type, bool caseSensitive, int value)
: mType(type)
, mValue(value)
, mCase(caseSensitive)
, mIdColumn(0)
, mTypeColumn(0)
, mPaddingBefore(10)
, mPaddingAfter(10)
{
if (type != Type_RecordState)
throw std::logic_error("invalid search parameter (int)");
}
void CSMTools::Search::configure(const CSMWorld::IdTableBase* model)
{
mColumns.clear();
int columns = model->columnCount();
for (int i = 0; i < columns; ++i)
{
CSMWorld::ColumnBase::Display display = static_cast<CSMWorld::ColumnBase::Display>(
model->headerData(i, Qt::Horizontal, static_cast<int>(CSMWorld::ColumnBase::Role_Display)).toInt());
bool consider = false;
switch (mType)
{
case Type_Text:
case Type_TextRegEx:
if (CSMWorld::ColumnBase::isText(display) || CSMWorld::ColumnBase::isScript(display))
{
consider = true;
}
break;
case Type_Id:
case Type_IdRegEx:
if (CSMWorld::ColumnBase::isId(display) || CSMWorld::ColumnBase::isScript(display))
{
consider = true;
}
break;
case Type_RecordState:
if (display == CSMWorld::ColumnBase::Display_RecordState)
consider = true;
break;
case Type_None:
break;
}
if (consider)
mColumns.insert(i);
}
mIdColumn = model->findColumnIndex(CSMWorld::Columns::ColumnId_Id);
mTypeColumn = model->findColumnIndex(CSMWorld::Columns::ColumnId_RecordType);
}
void CSMTools::Search::searchRow(const CSMWorld::IdTableBase* model, int row, CSMDoc::Messages& messages) const
{
for (std::set<int>::const_iterator iter(mColumns.begin()); iter != mColumns.end(); ++iter)
{
QModelIndex index = model->index(row, *iter);
CSMWorld::UniversalId::Type type
= static_cast<CSMWorld::UniversalId::Type>(model->data(model->index(row, mTypeColumn)).toInt());
CSMWorld::UniversalId id(type, model->data(model->index(row, mIdColumn)).toString().toUtf8().data());
bool writable = model->flags(index) & Qt::ItemIsEditable;
switch (mType)
{
case Type_Text:
case Type_Id:
searchTextCell(model, index, id, writable, messages);
break;
case Type_TextRegEx:
case Type_IdRegEx:
searchRegExCell(model, index, id, writable, messages);
break;
case Type_RecordState:
searchRecordStateCell(model, index, id, writable, messages);
break;
case Type_None:
break;
}
}
}
void CSMTools::Search::setPadding(int before, int after)
{
mPaddingBefore = before;
mPaddingAfter = after;
}
void CSMTools::Search::replace(CSMDoc::Document& document, CSMWorld::IdTableBase* model,
const CSMWorld::UniversalId& id, const std::string& messageHint, const std::string& replaceText) const
{
std::istringstream stream(messageHint.c_str());
char hint, ignore;
int columnId, pos, length;
if (stream >> hint >> ignore >> columnId >> pos >> length)
{
int column = model->findColumnIndex(static_cast<CSMWorld::Columns::ColumnId>(columnId));
QModelIndex index = model->getModelIndex(id.getId(), column);
std::string text = model->data(index).toString().toUtf8().constData();
std::string before = text.substr(0, pos);
std::string after = text.substr(pos + length);
std::string newText = before + replaceText + after;
document.getUndoStack().push(new CSMWorld::ModifyCommand(*model, index, QString::fromUtf8(newText.c_str())));
}
}
bool CSMTools::Search::verify(CSMDoc::Document& document, CSMWorld::IdTableBase* model, const CSMWorld::UniversalId& id,
const std::string& messageHint) const
{
CSMDoc::Messages messages(CSMDoc::Message::Severity_Info);
int row = model->getModelIndex(id.getId(), model->findColumnIndex(CSMWorld::Columns::ColumnId_Id)).row();
searchRow(model, row, messages);
for (CSMDoc::Messages::Iterator iter(messages.begin()); iter != messages.end(); ++iter)
if (iter->mHint == messageHint)
return true;
return false;
}
| 9,191
|
C++
|
.cpp
| 235
| 32.365957
| 120
| 0.644555
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,972
|
enchantmentcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/enchantmentcheck.cpp
|
#include "enchantmentcheck.hpp"
#include <stddef.h>
#include <string>
#include <vector>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/loadench.hpp>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
#include "effectlistcheck.hpp"
CSMTools::EnchantmentCheckStage::EnchantmentCheckStage(const CSMWorld::IdCollection<ESM::Enchantment>& enchantments)
: mEnchantments(enchantments)
{
mIgnoreBaseRecords = false;
}
int CSMTools::EnchantmentCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mEnchantments.getSize();
}
void CSMTools::EnchantmentCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Enchantment>& record = mEnchantments.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Enchantment& enchantment = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Enchantment, enchantment.mId);
if (enchantment.mData.mType < 0 || enchantment.mData.mType > 3)
messages.add(id, "Invalid type", "", CSMDoc::Message::Severity_Error);
if (enchantment.mData.mCost < 0)
messages.add(id, "Cost is negative", "", CSMDoc::Message::Severity_Error);
if (enchantment.mData.mCharge < 0)
messages.add(id, "Charge is negative", "", CSMDoc::Message::Severity_Error);
if (enchantment.mData.mCost > enchantment.mData.mCharge)
messages.add(id, "Cost is higher than charge", "", CSMDoc::Message::Severity_Error);
effectListCheck(enchantment.mEffects.mList, messages, id);
}
| 1,952
|
C++
|
.cpp
| 41
| 43.829268
| 116
| 0.742736
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,973
|
searchstage.cpp
|
OpenMW_openmw/apps/opencs/model/tools/searchstage.cpp
|
#include "searchstage.hpp"
#include "../world/idtablebase.hpp"
#include <apps/opencs/model/tools/search.hpp>
#include "searchoperation.hpp"
namespace CSMDoc
{
class Messages;
}
CSMTools::SearchStage::SearchStage(const CSMWorld::IdTableBase* model)
: mModel(model)
, mOperation(nullptr)
{
}
int CSMTools::SearchStage::setup()
{
if (mOperation)
mSearch = mOperation->getSearch();
mSearch.configure(mModel);
return mModel->rowCount();
}
void CSMTools::SearchStage::perform(int stage, CSMDoc::Messages& messages)
{
mSearch.searchRow(mModel, stage, messages);
}
void CSMTools::SearchStage::setOperation(const SearchOperation* operation)
{
mOperation = operation;
}
| 710
|
C++
|
.cpp
| 28
| 22.571429
| 74
| 0.755952
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,974
|
factioncheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/factioncheck.cpp
|
#include "factioncheck.hpp"
#include <map>
#include <string>
#include <utility>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadskil.hpp>
#include "../prefs/state.hpp"
CSMTools::FactionCheckStage::FactionCheckStage(const CSMWorld::IdCollection<ESM::Faction>& factions)
: mFactions(factions)
{
mIgnoreBaseRecords = false;
}
int CSMTools::FactionCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mFactions.getSize();
}
void CSMTools::FactionCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Faction>& record = mFactions.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Faction& faction = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Faction, faction.mId);
// test for empty name
if (faction.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
// test for invalid attributes
std::map<int, int> attributeCount;
for (size_t i = 0; i < faction.mData.mAttribute.size(); ++i)
{
int attribute = faction.mData.mAttribute[i];
if (attribute != -1)
{
auto it = attributeCount.find(attribute);
if (it == attributeCount.end())
attributeCount.emplace(attribute, 1);
else
{
if (it->second == 1)
messages.add(id, "Same attribute is listed twice", {}, CSMDoc::Message::Severity_Error);
++it->second;
}
}
}
// test for non-unique skill
std::map<int, int> skills; // ID, number of occurrences
for (int skill : faction.mData.mSkills)
if (skill != -1)
++skills[skill];
for (auto& skill : skills)
if (skill.second > 1)
{
messages.add(id, "Skill " + ESM::Skill::indexToRefId(skill.first).toString() + " is listed more than once",
"", CSMDoc::Message::Severity_Error);
}
/// \todo check data members that can't be edited in the table view
}
| 2,583
|
C++
|
.cpp
| 65
| 33.369231
| 119
| 0.655338
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
34,975
|
tools.cpp
|
OpenMW_openmw/apps/opencs/model/tools/tools.cpp
|
#include "tools.hpp"
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "../doc/document.hpp"
#include "birthsigncheck.hpp"
#include "bodypartcheck.hpp"
#include "classcheck.hpp"
#include "enchantmentcheck.hpp"
#include "factioncheck.hpp"
#include "gmstcheck.hpp"
#include "journalcheck.hpp"
#include "magiceffectcheck.hpp"
#include "mandatoryid.hpp"
#include "mergeoperation.hpp"
#include "pathgridcheck.hpp"
#include "racecheck.hpp"
#include "referenceablecheck.hpp"
#include "referencecheck.hpp"
#include "regioncheck.hpp"
#include "reportmodel.hpp"
#include "scriptcheck.hpp"
#include "searchoperation.hpp"
#include "skillcheck.hpp"
#include "soundcheck.hpp"
#include "soundgencheck.hpp"
#include "spellcheck.hpp"
#include "startscriptcheck.hpp"
#include "topicinfocheck.hpp"
#include <apps/opencs/model/doc/operationholder.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
namespace CSMDoc
{
struct Message;
}
CSMDoc::OperationHolder* CSMTools::Tools::get(int type)
{
switch (type)
{
case CSMDoc::State_Verifying:
return &mVerifier;
case CSMDoc::State_Searching:
return &mSearch;
case CSMDoc::State_Merging:
return &mMerge;
}
return nullptr;
}
const CSMDoc::OperationHolder* CSMTools::Tools::get(int type) const
{
return const_cast<Tools*>(this)->get(type);
}
CSMDoc::OperationHolder* CSMTools::Tools::getVerifier()
{
if (!mVerifierOperation)
{
mVerifierOperation = new CSMDoc::Operation(CSMDoc::State_Verifying, false);
connect(&mVerifier, &CSMDoc::OperationHolder::progress, this, &Tools::progress);
connect(&mVerifier, &CSMDoc::OperationHolder::done, this, &Tools::done);
connect(&mVerifier, &CSMDoc::OperationHolder::reportMessage, this, &Tools::verifierMessage);
std::vector<ESM::RefId> mandatoryRefIds;
{
auto mandatoryIds = { "Day", "DaysPassed", "GameHour", "Month", "PCRace" };
for (auto& id : mandatoryIds)
mandatoryRefIds.push_back(ESM::RefId::stringRefId(id));
}
mVerifierOperation->appendStage(new MandatoryIdStage(
mData.getGlobals(), CSMWorld::UniversalId(CSMWorld::UniversalId::Type_Globals), mandatoryRefIds));
mVerifierOperation->appendStage(new SkillCheckStage(mData.getSkills()));
mVerifierOperation->appendStage(new ClassCheckStage(mData.getClasses()));
mVerifierOperation->appendStage(new FactionCheckStage(mData.getFactions()));
mVerifierOperation->appendStage(new RaceCheckStage(mData.getRaces()));
mVerifierOperation->appendStage(
new SoundCheckStage(mData.getSounds(), mData.getResources(CSMWorld::UniversalId::Type_SoundsRes)));
mVerifierOperation->appendStage(new RegionCheckStage(mData.getRegions()));
mVerifierOperation->appendStage(
new BirthsignCheckStage(mData.getBirthsigns(), mData.getResources(CSMWorld::UniversalId::Type_Textures)));
mVerifierOperation->appendStage(new SpellCheckStage(mData.getSpells()));
mVerifierOperation->appendStage(
new ReferenceableCheckStage(mData.getReferenceables().getDataSet(), mData.getRaces(), mData.getClasses(),
mData.getFactions(), mData.getScripts(), mData.getResources(CSMWorld::UniversalId::Type_Meshes),
mData.getResources(CSMWorld::UniversalId::Type_Icons), mData.getBodyParts()));
mVerifierOperation->appendStage(new ReferenceCheckStage(mData.getReferences(), mData.getReferenceables(),
mData.getCells(), mData.getFactions(), mData.getBodyParts()));
mVerifierOperation->appendStage(new ScriptCheckStage(mDocument));
mVerifierOperation->appendStage(new StartScriptCheckStage(mData.getStartScripts(), mData.getScripts()));
mVerifierOperation->appendStage(new BodyPartCheckStage(mData.getBodyParts(),
mData.getResources(CSMWorld::UniversalId(CSMWorld::UniversalId::Type_Meshes)), mData.getRaces()));
mVerifierOperation->appendStage(new PathgridCheckStage(mData.getPathgrids()));
mVerifierOperation->appendStage(
new SoundGenCheckStage(mData.getSoundGens(), mData.getSounds(), mData.getReferenceables()));
mVerifierOperation->appendStage(new MagicEffectCheckStage(mData.getMagicEffects(), mData.getSounds(),
mData.getReferenceables(), mData.getResources(CSMWorld::UniversalId::Type_Icons),
mData.getResources(CSMWorld::UniversalId::Type_Textures)));
mVerifierOperation->appendStage(new GmstCheckStage(mData.getGmsts()));
mVerifierOperation->appendStage(new TopicInfoCheckStage(mData.getTopicInfos(), mData.getCells(),
mData.getClasses(), mData.getFactions(), mData.getGmsts(), mData.getGlobals(), mData.getJournals(),
mData.getRaces(), mData.getRegions(), mData.getTopics(), mData.getReferenceables().getDataSet(),
mData.getResources(CSMWorld::UniversalId::Type_SoundsRes)));
mVerifierOperation->appendStage(new JournalCheckStage(mData.getJournals(), mData.getJournalInfos()));
mVerifierOperation->appendStage(new EnchantmentCheckStage(mData.getEnchantments()));
mVerifier.setOperation(mVerifierOperation);
}
return &mVerifier;
}
CSMTools::Tools::Tools(CSMDoc::Document& document, ToUTF8::FromType encoding)
: mDocument(document)
, mData(document.getData())
, mVerifierOperation(nullptr)
, mSearchOperation(nullptr)
, mMergeOperation(nullptr)
, mNextReportNumber(0)
, mEncoding(encoding)
{
// index 0: load error log
mReports.insert(std::make_pair(mNextReportNumber++, new ReportModel));
mActiveReports.insert(std::make_pair(CSMDoc::State_Loading, 0));
connect(&mSearch, &CSMDoc::OperationHolder::progress, this, &Tools::progress);
connect(&mSearch, &CSMDoc::OperationHolder::done, this, &Tools::done);
connect(&mSearch, &CSMDoc::OperationHolder::reportMessage, this, &Tools::verifierMessage);
connect(&mMerge, &CSMDoc::OperationHolder::progress, this, &Tools::progress);
connect(&mMerge, &CSMDoc::OperationHolder::done, this, &Tools::done);
// don't need to connect report message, since there are no messages for merge
}
CSMTools::Tools::~Tools()
{
if (mVerifierOperation)
{
mVerifier.abortAndWait();
delete mVerifierOperation;
}
if (mSearchOperation)
{
mSearch.abortAndWait();
delete mSearchOperation;
}
if (mMergeOperation)
{
mMerge.abortAndWait();
delete mMergeOperation;
}
for (std::map<int, ReportModel*>::iterator iter(mReports.begin()); iter != mReports.end(); ++iter)
delete iter->second;
}
CSMWorld::UniversalId CSMTools::Tools::runVerifier(const CSMWorld::UniversalId& reportId)
{
int reportNumber = reportId.getType() == CSMWorld::UniversalId::Type_VerificationResults ? reportId.getIndex()
: mNextReportNumber++;
if (mReports.find(reportNumber) == mReports.end())
mReports.insert(std::make_pair(reportNumber, new ReportModel));
mActiveReports[CSMDoc::State_Verifying] = reportNumber;
getVerifier()->start();
return CSMWorld::UniversalId(CSMWorld::UniversalId::Type_VerificationResults, reportNumber);
}
CSMWorld::UniversalId CSMTools::Tools::newSearch()
{
mReports.insert(std::make_pair(mNextReportNumber++, new ReportModel(true, false)));
return CSMWorld::UniversalId(CSMWorld::UniversalId::Type_Search, mNextReportNumber - 1);
}
void CSMTools::Tools::runSearch(const CSMWorld::UniversalId& searchId, const Search& search)
{
mActiveReports[CSMDoc::State_Searching] = searchId.getIndex();
if (!mSearchOperation)
{
mSearchOperation = new SearchOperation(mDocument);
mSearch.setOperation(mSearchOperation);
}
mSearchOperation->configure(search);
mSearch.start();
}
void CSMTools::Tools::runMerge(std::unique_ptr<CSMDoc::Document> target)
{
// not setting an active report, because merge does not produce messages
if (!mMergeOperation)
{
mMergeOperation = new MergeOperation(mDocument, mEncoding);
mMerge.setOperation(mMergeOperation);
connect(mMergeOperation, &MergeOperation::mergeDone, this, &Tools::mergeDone);
}
target->flagAsDirty();
mMergeOperation->setTarget(std::move(target));
mMerge.start();
}
void CSMTools::Tools::abortOperation(int type)
{
if (CSMDoc::OperationHolder* operation = get(type))
operation->abort();
}
int CSMTools::Tools::getRunningOperations() const
{
static const int sOperations[] = {
CSMDoc::State_Verifying,
CSMDoc::State_Searching,
CSMDoc::State_Merging,
-1,
};
int result = 0;
for (int i = 0; sOperations[i] != -1; ++i)
if (const CSMDoc::OperationHolder* operation = get(sOperations[i]))
if (operation->isRunning())
result |= sOperations[i];
return result;
}
CSMTools::ReportModel* CSMTools::Tools::getReport(const CSMWorld::UniversalId& id)
{
if (id.getType() != CSMWorld::UniversalId::Type_VerificationResults
&& id.getType() != CSMWorld::UniversalId::Type_LoadErrorLog
&& id.getType() != CSMWorld::UniversalId::Type_Search)
throw std::logic_error("invalid request for report model: " + id.toString());
return mReports.at(id.getIndex());
}
void CSMTools::Tools::verifierMessage(const CSMDoc::Message& message, int type)
{
std::map<int, int>::iterator iter = mActiveReports.find(type);
if (iter != mActiveReports.end())
mReports[iter->second]->add(message);
}
| 9,847
|
C++
|
.cpp
| 220
| 38.563636
| 118
| 0.712687
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,976
|
classcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/classcheck.cpp
|
#include "classcheck.hpp"
#include <map>
#include <string>
#include <utility>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadskil.hpp>
#include "../prefs/state.hpp"
CSMTools::ClassCheckStage::ClassCheckStage(const CSMWorld::IdCollection<ESM::Class>& classes)
: mClasses(classes)
{
mIgnoreBaseRecords = false;
}
int CSMTools::ClassCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mClasses.getSize();
}
void CSMTools::ClassCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Class>& record = mClasses.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Class& class_ = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Class, class_.mId);
// A class should have a name
if (class_.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
// A playable class should have a description
if (class_.mData.mIsPlayable != 0 && class_.mDescription.empty())
messages.add(id, "Description of a playable class is missing", "", CSMDoc::Message::Severity_Warning);
// test for invalid attributes
std::map<int, int> attributeCount;
for (size_t i = 0; i < class_.mData.mAttribute.size(); ++i)
{
int attribute = class_.mData.mAttribute[i];
if (attribute == -1)
messages.add(id, "Attribute #" + std::to_string(i) + " is not set", {}, CSMDoc::Message::Severity_Error);
else
{
auto it = attributeCount.find(attribute);
if (it == attributeCount.end())
attributeCount.emplace(attribute, 1);
else
{
if (it->second == 1)
messages.add(id, "Same attribute is listed twice", {}, CSMDoc::Message::Severity_Error);
++it->second;
}
}
}
// test for non-unique skill
std::map<int, int> skills; // ID, number of occurrences
for (const auto& s : class_.mData.mSkills)
for (int skill : s)
++skills[skill];
for (auto& skill : skills)
if (skill.second > 1)
{
messages.add(id, "Skill " + ESM::Skill::indexToRefId(skill.first).toString() + " is listed more than once",
"", CSMDoc::Message::Severity_Error);
}
}
| 2,858
|
C++
|
.cpp
| 69
| 34.898551
| 119
| 0.647908
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,977
|
soundcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/soundcheck.cpp
|
#include "soundcheck.hpp"
#include <string>
#include "../prefs/state.hpp"
#include "../world/universalid.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <components/esm3/loadsoun.hpp>
CSMTools::SoundCheckStage::SoundCheckStage(
const CSMWorld::IdCollection<ESM::Sound>& sounds, const CSMWorld::Resources& soundfiles)
: mSounds(sounds)
, mSoundFiles(soundfiles)
{
mIgnoreBaseRecords = false;
}
int CSMTools::SoundCheckStage::setup()
{
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mSounds.getSize();
}
void CSMTools::SoundCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<ESM::Sound>& record = mSounds.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && record.mState == CSMWorld::RecordBase::State_BaseOnly) || record.isDeleted())
return;
const ESM::Sound& sound = record.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Sound, sound.mId);
if (sound.mData.mMinRange > sound.mData.mMaxRange)
{
messages.add(id, "Minimum range is larger than maximum range", "", CSMDoc::Message::Severity_Warning);
}
if (sound.mSound.empty())
{
messages.add(id, "Sound file is missing", "", CSMDoc::Message::Severity_Error);
}
else if (mSoundFiles.searchId(sound.mSound) == -1)
{
messages.add(id, "Sound file '" + sound.mSound + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
}
| 1,788
|
C++
|
.cpp
| 44
| 36.772727
| 114
| 0.716763
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,978
|
topicinfocheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/topicinfocheck.cpp
|
#include "topicinfocheck.hpp"
#include <sstream>
#include <string>
#include <vector>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/cell.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/info.hpp>
#include <apps/opencs/model/world/infocollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadinfo.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/variant.hpp>
#include "../prefs/state.hpp"
#include "../world/infoselectwrapper.hpp"
CSMTools::TopicInfoCheckStage::TopicInfoCheckStage(const CSMWorld::InfoCollection& topicInfos,
const CSMWorld::IdCollection<CSMWorld::Cell>& cells, const CSMWorld::IdCollection<ESM::Class>& classes,
const CSMWorld::IdCollection<ESM::Faction>& factions, const CSMWorld::IdCollection<ESM::GameSetting>& gmsts,
const CSMWorld::IdCollection<ESM::Global>& globals, const CSMWorld::IdCollection<ESM::Dialogue>& journals,
const CSMWorld::IdCollection<ESM::Race>& races, const CSMWorld::IdCollection<ESM::Region>& regions,
const CSMWorld::IdCollection<ESM::Dialogue>& topics, const CSMWorld::RefIdData& referencables,
const CSMWorld::Resources& soundFiles)
: mTopicInfos(topicInfos)
, mCells(cells)
, mClasses(classes)
, mFactions(factions)
, mGameSettings(gmsts)
, mGlobals(globals)
, mJournals(journals)
, mRaces(races)
, mRegions(regions)
, mTopics(topics)
, mReferencables(referencables)
, mSoundFiles(soundFiles)
{
mIgnoreBaseRecords = false;
}
int CSMTools::TopicInfoCheckStage::setup()
{
// Generate list of cell names for reference checking
mCellNames.clear();
for (int i = 0; i < mCells.getSize(); ++i)
{
const CSMWorld::Record<CSMWorld::Cell>& cellRecord = mCells.getRecord(i);
if (cellRecord.isDeleted())
continue;
mCellNames.insert(cellRecord.get().mName);
}
// Cell names can also include region names
for (int i = 0; i < mRegions.getSize(); ++i)
{
const CSMWorld::Record<ESM::Region>& regionRecord = mRegions.getRecord(i);
if (regionRecord.isDeleted())
continue;
mCellNames.insert(regionRecord.get().mName);
}
// Default cell name
const int index = mGameSettings.searchId(ESM::RefId::stringRefId("sDefaultCellname"));
if (index != -1)
{
const CSMWorld::Record<ESM::GameSetting>& gmstRecord = mGameSettings.getRecord(index);
if (!gmstRecord.isDeleted() && gmstRecord.get().mValue.getType() == ESM::VT_String)
{
mCellNames.insert(gmstRecord.get().mValue.getString());
}
}
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mTopicInfos.getSize();
}
void CSMTools::TopicInfoCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
const CSMWorld::Record<CSMWorld::Info>& infoRecord = mTopicInfos.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && infoRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || infoRecord.isDeleted())
return;
const CSMWorld::Info& topicInfo = infoRecord.get();
// There should always be a topic that matches
int topicIndex = mTopics.searchId(topicInfo.mTopicId);
const CSMWorld::Record<ESM::Dialogue>& topicRecord = mTopics.getRecord(topicIndex);
if (topicRecord.isDeleted())
return;
const ESM::Dialogue& topic = topicRecord.get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_TopicInfo, topicInfo.mId);
// Check fields
if (!topicInfo.mActor.empty())
{
verifyActor(topicInfo.mActor, id, messages);
}
if (!topicInfo.mClass.empty())
{
verifyId(topicInfo.mClass, mClasses, id, messages);
}
if (!topicInfo.mCell.empty())
{
verifyCell(topicInfo.mCell.getRefIdString(), id, messages);
}
if (!topicInfo.mFaction.empty() && !topicInfo.mFactionLess)
{
if (verifyId(topicInfo.mFaction, mFactions, id, messages))
{
verifyFactionRank(topicInfo.mFaction, topicInfo.mData.mRank, id, messages);
}
}
if (!topicInfo.mPcFaction.empty())
{
if (verifyId(topicInfo.mPcFaction, mFactions, id, messages))
{
verifyFactionRank(topicInfo.mPcFaction, topicInfo.mData.mPCrank, id, messages);
}
}
if (topicInfo.mData.mGender < -1 || topicInfo.mData.mGender > 1)
{
messages.add(id, "Gender is invalid", "", CSMDoc::Message::Severity_Error);
}
if (!topicInfo.mRace.empty())
{
verifyId(topicInfo.mRace, mRaces, id, messages);
}
if (!topicInfo.mSound.empty())
{
verifySound(topicInfo.mSound, id, messages);
}
if (topicInfo.mResponse.empty() && topic.mType != ESM::Dialogue::Voice)
{
messages.add(id, "Response is empty", "", CSMDoc::Message::Severity_Warning);
}
// Check info conditions
for (const auto& select : topicInfo.mSelects)
{
verifySelectStruct(select, id, messages);
}
}
// Verification functions
bool CSMTools::TopicInfoCheckStage::verifyActor(
const ESM::RefId& actor, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
const std::string& actorString = actor.getRefIdString();
CSMWorld::RefIdData::LocalIndex index = mReferencables.searchId(actor);
if (index.first == -1)
{
messages.add(id, "Actor '" + actorString + "' does not exist", "", CSMDoc::Message::Severity_Error);
return false;
}
else if (mReferencables.getRecord(index).isDeleted())
{
messages.add(
id, "Deleted actor '" + actorString + "' is being referenced", "", CSMDoc::Message::Severity_Error);
return false;
}
else if (index.second != CSMWorld::UniversalId::Type_Npc && index.second != CSMWorld::UniversalId::Type_Creature)
{
CSMWorld::UniversalId tempId(index.second, actor);
std::ostringstream stream;
stream << "Object '" << actor << "' has invalid type " << tempId.getTypeName()
<< " (an actor must be an NPC or a creature)";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
return false;
}
return true;
}
bool CSMTools::TopicInfoCheckStage::verifyCell(
const std::string& cell, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
if (mCellNames.find(cell) == mCellNames.end())
{
messages.add(id, "Cell '" + cell + "' does not exist", "", CSMDoc::Message::Severity_Error);
return false;
}
return true;
}
bool CSMTools::TopicInfoCheckStage::verifyFactionRank(
const ESM::RefId& factionName, int rank, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
if (rank < -1)
{
std::ostringstream stream;
stream << "Faction rank is set to " << rank << ", but it should be set to -1 if there are no rank requirements";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Warning);
return false;
}
int index = mFactions.searchId(factionName);
const ESM::Faction& faction = mFactions.getRecord(index).get();
int limit = 0;
for (; limit < 10; ++limit)
{
if (faction.mRanks[limit].empty())
break;
}
if (rank >= limit)
{
std::ostringstream stream;
stream << "Faction rank is set to " << rank << " which is more than the maximum of " << limit - 1
<< " for the '" << factionName << "' faction";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
return false;
}
return true;
}
bool CSMTools::TopicInfoCheckStage::verifyItem(
const ESM::RefId& item, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
const std::string& idString = item.getRefIdString();
CSMWorld::RefIdData::LocalIndex index = mReferencables.searchId(item);
if (index.first == -1)
{
messages.add(id, ("Item '" + idString + "' does not exist"), "", CSMDoc::Message::Severity_Error);
return false;
}
else if (mReferencables.getRecord(index).isDeleted())
{
messages.add(id, ("Deleted item '" + idString + "' is being referenced"), "", CSMDoc::Message::Severity_Error);
return false;
}
else
{
switch (index.second)
{
case CSMWorld::UniversalId::Type_Potion:
case CSMWorld::UniversalId::Type_Apparatus:
case CSMWorld::UniversalId::Type_Armor:
case CSMWorld::UniversalId::Type_Book:
case CSMWorld::UniversalId::Type_Clothing:
case CSMWorld::UniversalId::Type_Ingredient:
case CSMWorld::UniversalId::Type_Light:
case CSMWorld::UniversalId::Type_Lockpick:
case CSMWorld::UniversalId::Type_Miscellaneous:
case CSMWorld::UniversalId::Type_Probe:
case CSMWorld::UniversalId::Type_Repair:
case CSMWorld::UniversalId::Type_Weapon:
case CSMWorld::UniversalId::Type_ItemLevelledList:
break;
default:
{
CSMWorld::UniversalId tempId(index.second, item);
std::ostringstream stream;
stream << "Object '" << item << "' has invalid type " << tempId.getTypeName()
<< " (an item can be a potion, an armor piece, a book and so on)";
messages.add(id, stream.str(), "", CSMDoc::Message::Severity_Error);
return false;
}
}
}
return true;
}
bool CSMTools::TopicInfoCheckStage::verifySelectStruct(
const ESM::DialogueCondition& select, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
CSMWorld::ConstInfoSelectWrapper infoCondition(select);
if (select.mFunction == ESM::DialogueCondition::Function_None)
{
messages.add(id, "Invalid condition '" + infoCondition.toString() + "'", "", CSMDoc::Message::Severity_Error);
return false;
}
else if (infoCondition.conditionIsAlwaysTrue())
{
messages.add(
id, "Condition '" + infoCondition.toString() + "' is always true", "", CSMDoc::Message::Severity_Warning);
return false;
}
else if (infoCondition.conditionIsNeverTrue())
{
messages.add(
id, "Condition '" + infoCondition.toString() + "' is never true", "", CSMDoc::Message::Severity_Warning);
return false;
}
// Id checks
if (select.mFunction == ESM::DialogueCondition::Function_Global
&& !verifyId(ESM::RefId::stringRefId(select.mVariable), mGlobals, id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_Journal
&& !verifyId(ESM::RefId::stringRefId(select.mVariable), mJournals, id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_Item
&& !verifyItem(ESM::RefId::stringRefId(select.mVariable), id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_Dead
&& !verifyActor(ESM::RefId::stringRefId(select.mVariable), id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_NotId
&& !verifyActor(ESM::RefId::stringRefId(select.mVariable), id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_NotFaction
&& !verifyId(ESM::RefId::stringRefId(select.mVariable), mFactions, id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_NotClass
&& !verifyId(ESM::RefId::stringRefId(select.mVariable), mClasses, id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_NotRace
&& !verifyId(ESM::RefId::stringRefId(select.mVariable), mRaces, id, messages))
{
return false;
}
else if (select.mFunction == ESM::DialogueCondition::Function_NotCell
&& !verifyCell(select.mVariable, id, messages))
{
return false;
}
return true;
}
bool CSMTools::TopicInfoCheckStage::verifySound(
const std::string& sound, const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
if (mSoundFiles.searchId(sound) == -1)
{
messages.add(id, "Sound file '" + sound + "' does not exist", "", CSMDoc::Message::Severity_Error);
return false;
}
return true;
}
template <typename T>
bool CSMTools::TopicInfoCheckStage::verifyId(const ESM::RefId& name, const CSMWorld::IdCollection<T>& collection,
const CSMWorld::UniversalId& id, CSMDoc::Messages& messages)
{
int index = collection.searchId(name);
if (index == -1)
{
messages.add(id, std::string(T::getRecordType()) + " '" + name.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
return false;
}
else if (collection.getRecord(index).isDeleted())
{
messages.add(id,
"Deleted " + std::string(T::getRecordType()) + " record '" + name.getRefIdString()
+ "' is being referenced",
"", CSMDoc::Message::Severity_Error);
return false;
}
return true;
}
| 13,948
|
C++
|
.cpp
| 355
| 32.853521
| 120
| 0.65903
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,979
|
effectlistcheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/effectlistcheck.cpp
|
#include "effectlistcheck.hpp"
#include <components/esm/attr.hpp>
#include <components/esm3/effectlist.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadskil.hpp>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/world/universalid.hpp>
namespace CSMTools
{
void effectListCheck(
const std::vector<ESM::IndexedENAMstruct>& list, CSMDoc::Messages& messages, const CSMWorld::UniversalId& id)
{
if (list.empty())
{
messages.add(id, "No magic effects", "", CSMDoc::Message::Severity_Warning);
return;
}
size_t i = 1;
for (const ESM::IndexedENAMstruct& effect : list)
{
const std::string number = std::to_string(i);
// At the time of writing this effects, attributes and skills are mostly hardcoded
if (effect.mData.mEffectID < 0 || effect.mData.mEffectID >= ESM::MagicEffect::Length)
messages.add(id, "Effect #" + number + ": invalid effect ID", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mSkill < -1 || effect.mData.mSkill >= ESM::Skill::Length)
messages.add(id, "Effect #" + number + ": invalid skill", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mAttribute < -1 || effect.mData.mAttribute >= ESM::Attribute::Length)
messages.add(id, "Effect #" + number + ": invalid attribute", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mRange < ESM::RT_Self || effect.mData.mRange > ESM::RT_Target)
messages.add(id, "Effect #" + number + ": invalid range", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mArea < 0)
messages.add(id, "Effect #" + number + ": negative area", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mDuration < 0)
messages.add(id, "Effect #" + number + ": negative duration", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mMagnMin < 0)
messages.add(
id, "Effect #" + number + ": negative minimum magnitude", "", CSMDoc::Message::Severity_Error);
if (effect.mData.mMagnMax < 0)
messages.add(
id, "Effect #" + number + ": negative maximum magnitude", "", CSMDoc::Message::Severity_Error);
else if (effect.mData.mMagnMax == 0)
messages.add(
id, "Effect #" + number + ": zero maximum magnitude", "", CSMDoc::Message::Severity_Warning);
if (effect.mData.mMagnMin > effect.mData.mMagnMax)
messages.add(id, "Effect #" + number + ": minimum magnitude is higher than maximum magnitude", "",
CSMDoc::Message::Severity_Error);
++i;
}
}
void ingredientEffectListCheck(
const ESM::Ingredient& ingredient, CSMDoc::Messages& messages, const CSMWorld::UniversalId& id)
{
bool hasEffects = false;
for (size_t i = 0; i < 4; i++)
{
if (ingredient.mData.mEffectID[i] == -1)
continue;
hasEffects = true;
const std::string number = std::to_string(i + 1);
if (ingredient.mData.mEffectID[i] < -1 || ingredient.mData.mEffectID[i] >= ESM::MagicEffect::Length)
messages.add(id, "Effect #" + number + ": invalid effect ID", "", CSMDoc::Message::Severity_Error);
if (ingredient.mData.mSkills[i] < -1 || ingredient.mData.mSkills[i] >= ESM::Skill::Length)
messages.add(id, "Effect #" + number + ": invalid skill", "", CSMDoc::Message::Severity_Error);
if (ingredient.mData.mAttributes[i] < -1 || ingredient.mData.mAttributes[i] >= ESM::Attribute::Length)
messages.add(id, "Effect #" + number + ": invalid attribute", "", CSMDoc::Message::Severity_Error);
}
if (!hasEffects)
messages.add(id, "No magic effects", "", CSMDoc::Message::Severity_Warning);
}
}
| 4,098
|
C++
|
.cpp
| 71
| 46.56338
| 117
| 0.594264
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,980
|
referenceablecheck.cpp
|
OpenMW_openmw/apps/opencs/model/tools/referenceablecheck.cpp
|
#include "referenceablecheck.hpp"
#include <memory>
#include <stddef.h>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/resources.hpp>
#include <components/esm3/aipackage.hpp>
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/strings/algorithm.hpp>
#include "../prefs/state.hpp"
#include "../world/record.hpp"
#include "../world/universalid.hpp"
#include "effectlistcheck.hpp"
namespace ESM
{
class Script;
struct BodyPart;
struct Class;
struct Faction;
struct Race;
}
CSMTools::ReferenceableCheckStage::ReferenceableCheckStage(const CSMWorld::RefIdData& referenceable,
const CSMWorld::IdCollection<ESM::Race>& races, const CSMWorld::IdCollection<ESM::Class>& classes,
const CSMWorld::IdCollection<ESM::Faction>& faction, const CSMWorld::IdCollection<ESM::Script>& scripts,
const CSMWorld::Resources& models, const CSMWorld::Resources& icons,
const CSMWorld::IdCollection<ESM::BodyPart>& bodyparts)
: mReferencables(referenceable)
, mRaces(races)
, mClasses(classes)
, mFactions(faction)
, mScripts(scripts)
, mModels(models)
, mIcons(icons)
, mBodyParts(bodyparts)
, mPlayerPresent(false)
{
mIgnoreBaseRecords = false;
}
void CSMTools::ReferenceableCheckStage::perform(int stage, CSMDoc::Messages& messages)
{
// Checks for books, than, when stage is above mBooksSize goes to other checks, with (stage - PrevSum) as stage.
const int bookSize(mReferencables.getBooks().getSize());
if (stage < bookSize)
{
bookCheck(stage, mReferencables.getBooks(), messages);
return;
}
stage -= bookSize;
const int activatorSize(mReferencables.getActivators().getSize());
if (stage < activatorSize)
{
activatorCheck(stage, mReferencables.getActivators(), messages);
return;
}
stage -= activatorSize;
const int potionSize(mReferencables.getPotions().getSize());
if (stage < potionSize)
{
potionCheck(stage, mReferencables.getPotions(), messages);
return;
}
stage -= potionSize;
const int apparatusSize(mReferencables.getApparati().getSize());
if (stage < apparatusSize)
{
apparatusCheck(stage, mReferencables.getApparati(), messages);
return;
}
stage -= apparatusSize;
const int armorSize(mReferencables.getArmors().getSize());
if (stage < armorSize)
{
armorCheck(stage, mReferencables.getArmors(), messages);
return;
}
stage -= armorSize;
const int clothingSize(mReferencables.getClothing().getSize());
if (stage < clothingSize)
{
clothingCheck(stage, mReferencables.getClothing(), messages);
return;
}
stage -= clothingSize;
const int containerSize(mReferencables.getContainers().getSize());
if (stage < containerSize)
{
containerCheck(stage, mReferencables.getContainers(), messages);
return;
}
stage -= containerSize;
const int doorSize(mReferencables.getDoors().getSize());
if (stage < doorSize)
{
doorCheck(stage, mReferencables.getDoors(), messages);
return;
}
stage -= doorSize;
const int ingredientSize(mReferencables.getIngredients().getSize());
if (stage < ingredientSize)
{
ingredientCheck(stage, mReferencables.getIngredients(), messages);
return;
}
stage -= ingredientSize;
const int creatureLevListSize(mReferencables.getCreatureLevelledLists().getSize());
if (stage < creatureLevListSize)
{
creaturesLevListCheck(stage, mReferencables.getCreatureLevelledLists(), messages);
return;
}
stage -= creatureLevListSize;
const int itemLevelledListSize(mReferencables.getItemLevelledList().getSize());
if (stage < itemLevelledListSize)
{
itemLevelledListCheck(stage, mReferencables.getItemLevelledList(), messages);
return;
}
stage -= itemLevelledListSize;
const int lightSize(mReferencables.getLights().getSize());
if (stage < lightSize)
{
lightCheck(stage, mReferencables.getLights(), messages);
return;
}
stage -= lightSize;
const int lockpickSize(mReferencables.getLocpicks().getSize());
if (stage < lockpickSize)
{
lockpickCheck(stage, mReferencables.getLocpicks(), messages);
return;
}
stage -= lockpickSize;
const int miscSize(mReferencables.getMiscellaneous().getSize());
if (stage < miscSize)
{
miscCheck(stage, mReferencables.getMiscellaneous(), messages);
return;
}
stage -= miscSize;
const int npcSize(mReferencables.getNPCs().getSize());
if (stage < npcSize)
{
npcCheck(stage, mReferencables.getNPCs(), messages);
return;
}
stage -= npcSize;
const int weaponSize(mReferencables.getWeapons().getSize());
if (stage < weaponSize)
{
weaponCheck(stage, mReferencables.getWeapons(), messages);
return;
}
stage -= weaponSize;
const int probeSize(mReferencables.getProbes().getSize());
if (stage < probeSize)
{
probeCheck(stage, mReferencables.getProbes(), messages);
return;
}
stage -= probeSize;
const int repairSize(mReferencables.getRepairs().getSize());
if (stage < repairSize)
{
repairCheck(stage, mReferencables.getRepairs(), messages);
return;
}
stage -= repairSize;
const int staticSize(mReferencables.getStatics().getSize());
if (stage < staticSize)
{
staticCheck(stage, mReferencables.getStatics(), messages);
return;
}
stage -= staticSize;
const int creatureSize(mReferencables.getCreatures().getSize());
if (stage < creatureSize)
{
creatureCheck(stage, mReferencables.getCreatures(), messages);
return;
}
// if we come that far, we are about to perform our last, final check.
finalCheck(messages);
return;
}
int CSMTools::ReferenceableCheckStage::setup()
{
mPlayerPresent = false;
mIgnoreBaseRecords = CSMPrefs::get()["Reports"]["ignore-base-records"].isTrue();
return mReferencables.getSize() + 1;
}
void CSMTools::ReferenceableCheckStage::bookCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Book>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Book& book = (dynamic_cast<const CSMWorld::Record<ESM::Book>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Book, book.mId);
inventoryItemCheck<ESM::Book>(book, messages, id.toString(), true);
// Check that mentioned scripts exist
scriptCheck<ESM::Book>(book, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::activatorCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Activator>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Activator& activator = (dynamic_cast<const CSMWorld::Record<ESM::Activator>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Activator, activator.mId);
if (activator.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(activator.mModel) == -1)
messages.add(id, "Model '" + activator.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// Check that mentioned scripts exist
scriptCheck<ESM::Activator>(activator, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::potionCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Potion>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Potion& potion = (dynamic_cast<const CSMWorld::Record<ESM::Potion>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Potion, potion.mId);
inventoryItemCheck<ESM::Potion>(potion, messages, id.toString());
effectListCheck(potion.mEffects.mList, messages, id);
// Check that mentioned scripts exist
scriptCheck<ESM::Potion>(potion, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::apparatusCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Apparatus>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Apparatus& apparatus = (dynamic_cast<const CSMWorld::Record<ESM::Apparatus>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Apparatus, apparatus.mId);
inventoryItemCheck<ESM::Apparatus>(apparatus, messages, id.toString());
toolCheck<ESM::Apparatus>(apparatus, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Apparatus>(apparatus, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::armorCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Armor>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Armor& armor = (dynamic_cast<const CSMWorld::Record<ESM::Armor>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Armor, armor.mId);
inventoryItemCheck<ESM::Armor>(armor, messages, id.toString(), true);
// Armor should have positive armor class, but 0 class is not an error
if (armor.mData.mArmor < 0)
messages.add(id, "Armor class is negative", "", CSMDoc::Message::Severity_Error);
// Armor durability must be a positive number
if (armor.mData.mHealth <= 0)
messages.add(id, "Durability is non-positive", "", CSMDoc::Message::Severity_Error);
// Check that mentioned scripts exist
scriptCheck<ESM::Armor>(armor, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::clothingCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Clothing>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Clothing& clothing = (dynamic_cast<const CSMWorld::Record<ESM::Clothing>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Clothing, clothing.mId);
inventoryItemCheck<ESM::Clothing>(clothing, messages, id.toString(), true);
// Check that mentioned scripts exist
scriptCheck<ESM::Clothing>(clothing, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::containerCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Container>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Container& container = (dynamic_cast<const CSMWorld::Record<ESM::Container>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Container, container.mId);
// checking for name
if (container.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
// Checking for model
if (container.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(container.mModel) == -1)
messages.add(id, "Model '" + container.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// Checking for capacity (weight)
if (container.mWeight < 0) // 0 is allowed
messages.add(id, "Capacity is negative", "", CSMDoc::Message::Severity_Error);
// checking contained items
inventoryListCheck(container.mInventory.mList, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Container>(container, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::creatureCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Creature>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Creature& creature = (dynamic_cast<const CSMWorld::Record<ESM::Creature>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Creature, creature.mId);
if (creature.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
if (creature.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(creature.mModel) == -1)
messages.add(id, "Model '" + creature.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// stats checks
if (creature.mData.mLevel <= 0)
messages.add(id, "Level is non-positive", "", CSMDoc::Message::Severity_Warning);
for (size_t i = 0; i < creature.mData.mAttributes.size(); ++i)
{
if (creature.mData.mAttributes[i] < 0)
messages.add(id, ESM::Attribute::indexToRefId(i).toDebugString() + " is negative", {},
CSMDoc::Message::Severity_Warning);
}
if (creature.mData.mCombat < 0)
messages.add(id, "Combat is negative", "", CSMDoc::Message::Severity_Warning);
if (creature.mData.mMagic < 0)
messages.add(id, "Magic is negative", "", CSMDoc::Message::Severity_Warning);
if (creature.mData.mStealth < 0)
messages.add(id, "Stealth is negative", "", CSMDoc::Message::Severity_Warning);
if (creature.mData.mHealth < 0)
messages.add(id, "Health is negative", "", CSMDoc::Message::Severity_Error);
if (creature.mData.mMana < 0)
messages.add(id, "Magicka is negative", "", CSMDoc::Message::Severity_Error);
if (creature.mData.mFatigue < 0)
messages.add(id, "Fatigue is negative", "", CSMDoc::Message::Severity_Error);
if (creature.mData.mSoul < 0)
messages.add(id, "Soul value is negative", "", CSMDoc::Message::Severity_Error);
if (creature.mAiData.mAlarm > 100)
messages.add(id, "Alarm rating is over 100", "", CSMDoc::Message::Severity_Warning);
if (creature.mAiData.mFight > 100)
messages.add(id, "Fight rating is over 100", "", CSMDoc::Message::Severity_Warning);
if (creature.mAiData.mFlee > 100)
messages.add(id, "Flee rating is over 100", "", CSMDoc::Message::Severity_Warning);
for (int i = 0; i < 6; ++i)
{
if (creature.mData.mAttack[i] < 0)
messages.add(id,
"Attack " + std::to_string(i / 2 + 1) + " has negative" + (i % 2 == 0 ? " minimum " : " maximum ")
+ "damage",
"", CSMDoc::Message::Severity_Error);
if (i % 2 == 0 && creature.mData.mAttack[i] > creature.mData.mAttack[i + 1])
messages.add(id, "Attack " + std::to_string(i / 2 + 1) + " has minimum damage higher than maximum damage",
"", CSMDoc::Message::Severity_Error);
}
if (creature.mData.mGold < 0)
messages.add(id, "Gold count is negative", "", CSMDoc::Message::Severity_Error);
if (creature.mScale == 0)
messages.add(id, "Scale is equal to zero", "", CSMDoc::Message::Severity_Error);
if (!creature.mOriginal.empty())
{
CSMWorld::RefIdData::LocalIndex index = mReferencables.searchId(creature.mOriginal);
if (index.first == -1)
messages.add(id, "Parent creature '" + creature.mOriginal.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
else if (index.second != CSMWorld::UniversalId::Type_Creature)
messages.add(id, "'" + creature.mOriginal.getRefIdString() + "' is not a creature", "",
CSMDoc::Message::Severity_Error);
}
// Check inventory
inventoryListCheck(creature.mInventory.mList, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Creature>(creature, messages, id.toString());
/// \todo Check spells, teleport table, AI data and AI packages for validity
}
void CSMTools::ReferenceableCheckStage::doorCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Door>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Door& door = (dynamic_cast<const CSMWorld::Record<ESM::Door>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Door, door.mId);
// usual, name or model
if (door.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
if (door.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(door.mModel) == -1)
messages.add(id, "Model '" + door.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// Check that mentioned scripts exist
scriptCheck<ESM::Door>(door, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::ingredientCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Ingredient>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Ingredient& ingredient = (dynamic_cast<const CSMWorld::Record<ESM::Ingredient>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Ingredient, ingredient.mId);
inventoryItemCheck<ESM::Ingredient>(ingredient, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Ingredient>(ingredient, messages, id.toString());
ingredientEffectListCheck(ingredient, messages, id);
}
void CSMTools::ReferenceableCheckStage::creaturesLevListCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::CreatureLevList>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::CreatureLevList& CreatureLevList
= (dynamic_cast<const CSMWorld::Record<ESM::CreatureLevList>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_CreatureLevelledList,
CreatureLevList.mId); // CreatureLevList but Type_CreatureLevelledList :/
listCheck<ESM::CreatureLevList>(CreatureLevList, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::itemLevelledListCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::ItemLevList>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::ItemLevList& ItemLevList = (dynamic_cast<const CSMWorld::Record<ESM::ItemLevList>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_ItemLevelledList, ItemLevList.mId);
listCheck<ESM::ItemLevList>(ItemLevList, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::lightCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Light>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Light& light = (dynamic_cast<const CSMWorld::Record<ESM::Light>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Light, light.mId);
if (light.mData.mRadius < 0)
messages.add(id, "Light radius is negative", "", CSMDoc::Message::Severity_Error);
if (light.mData.mFlags & ESM::Light::Carry)
inventoryItemCheck<ESM::Light>(light, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Light>(light, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::lockpickCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Lockpick>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Lockpick& lockpick = (dynamic_cast<const CSMWorld::Record<ESM::Lockpick>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Lockpick, lockpick.mId);
inventoryItemCheck<ESM::Lockpick>(lockpick, messages, id.toString());
toolCheck<ESM::Lockpick>(lockpick, messages, id.toString(), true);
// Check that mentioned scripts exist
scriptCheck<ESM::Lockpick>(lockpick, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::miscCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Miscellaneous>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Miscellaneous& miscellaneous
= (dynamic_cast<const CSMWorld::Record<ESM::Miscellaneous>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Miscellaneous, miscellaneous.mId);
inventoryItemCheck<ESM::Miscellaneous>(miscellaneous, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::Miscellaneous>(miscellaneous, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::npcCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::NPC>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
if (baseRecord.isDeleted())
return;
const ESM::NPC& npc = (dynamic_cast<const CSMWorld::Record<ESM::NPC>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Npc, npc.mId);
// Detect if player is present
if (npc.mId == "Player") // Happy now, scrawl?
mPlayerPresent = true;
// Skip "Base" records (setting!)
if (mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly)
return;
short level(npc.mNpdt.mLevel);
int gold(npc.mNpdt.mGold);
if (npc.mNpdtType == ESM::NPC::NPC_WITH_AUTOCALCULATED_STATS) // 12 = autocalculated
{
if ((npc.mFlags & ESM::NPC::Autocalc) == 0) // 0x0010 = autocalculated flag
{
messages.add(id, "NPC with autocalculated stats doesn't have autocalc flag turned on", "",
CSMDoc::Message::Severity_Error); // should not happen?
return;
}
}
if (level <= 0)
messages.add(id, "Level is non-positive", "", CSMDoc::Message::Severity_Warning);
if (npc.mAiData.mAlarm > 100)
messages.add(id, "Alarm rating is over 100", "", CSMDoc::Message::Severity_Warning);
if (npc.mAiData.mFight > 100)
messages.add(id, "Fight rating is over 100", "", CSMDoc::Message::Severity_Warning);
if (npc.mAiData.mFlee > 100)
messages.add(id, "Flee rating is over 100", "", CSMDoc::Message::Severity_Warning);
if (gold < 0)
messages.add(id, "Gold count is negative", "", CSMDoc::Message::Severity_Error);
if (npc.mName.empty())
messages.add(id, "Name is missing", "", CSMDoc::Message::Severity_Error);
if (npc.mClass.empty())
messages.add(id, "Class is missing", "", CSMDoc::Message::Severity_Error);
else if (mClasses.searchId(npc.mClass) == -1)
messages.add(
id, "Class '" + npc.mClass.getRefIdString() + "' does not exist", "", CSMDoc::Message::Severity_Error);
if (npc.mRace.empty())
messages.add(id, "Race is missing", "", CSMDoc::Message::Severity_Error);
else if (mRaces.searchId(npc.mRace) == -1)
messages.add(
id, "Race '" + npc.mRace.getRefIdString() + "' does not exist", "", CSMDoc::Message::Severity_Error);
if (!npc.mFaction.empty() && mFactions.searchId(npc.mFaction) == -1)
messages.add(
id, "Faction '" + npc.mFaction.getRefIdString() + "' does not exist", "", CSMDoc::Message::Severity_Error);
if (npc.mHead.empty())
messages.add(id, "Head is missing", "", CSMDoc::Message::Severity_Error);
else
{
if (mBodyParts.searchId(npc.mHead) == -1)
messages.add(id, "Head body part '" + npc.mHead.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
/// \todo Check gender, race and other body parts stuff validity for the specific NPC
}
if (npc.mHair.empty())
messages.add(id, "Hair is missing", "", CSMDoc::Message::Severity_Error);
else
{
if (mBodyParts.searchId(npc.mHair) == -1)
messages.add(id, "Hair body part '" + npc.mHair.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
/// \todo Check gender, race and other body part stuff validity for the specific NPC
}
// Check inventory
inventoryListCheck(npc.mInventory.mList, messages, id.toString());
// Check that mentioned scripts exist
scriptCheck<ESM::NPC>(npc, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::weaponCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Weapon>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Weapon& weapon = (dynamic_cast<const CSMWorld::Record<ESM::Weapon>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Weapon, weapon.mId);
// TODO, It seems that this stuff for spellcasting is obligatory and In fact We should check if records are present
if ( // THOSE ARE HARDCODED!
!(weapon.mId == "VFX_Hands" || weapon.mId == "VFX_Absorb" || weapon.mId == "VFX_Reflect"
|| weapon.mId == "VFX_DefaultBolt" ||
// TODO I don't know how to get full list of effects :/
// DANGER!, ACHTUNG! FIXME! The following is the list of the magical bolts, valid for Morrowind.esm. However
// those are not hardcoded.
weapon.mId == "magic_bolt" || weapon.mId == "shock_bolt" || weapon.mId == "shield_bolt"
|| weapon.mId == "VFX_DestructBolt" || weapon.mId == "VFX_PoisonBolt" || weapon.mId == "VFX_RestoreBolt"
|| weapon.mId == "VFX_AlterationBolt" || weapon.mId == "VFX_ConjureBolt" || weapon.mId == "VFX_FrostBolt"
|| weapon.mId == "VFX_MysticismBolt" || weapon.mId == "VFX_IllusionBolt" || weapon.mId == "VFX_Multiple2"
|| weapon.mId == "VFX_Multiple3" || weapon.mId == "VFX_Multiple4" || weapon.mId == "VFX_Multiple5"
|| weapon.mId == "VFX_Multiple6" || weapon.mId == "VFX_Multiple7" || weapon.mId == "VFX_Multiple8"
|| weapon.mId == "VFX_Multiple9"))
{
inventoryItemCheck<ESM::Weapon>(weapon, messages, id.toString(), true);
if (!(weapon.mData.mType == ESM::Weapon::MarksmanBow || weapon.mData.mType == ESM::Weapon::MarksmanCrossbow
|| weapon.mData.mType == ESM::Weapon::MarksmanThrown || weapon.mData.mType == ESM::Weapon::Arrow
|| weapon.mData.mType == ESM::Weapon::Bolt))
{
if (weapon.mData.mSlash[0] > weapon.mData.mSlash[1])
messages.add(id, "Minimum slash damage higher than maximum", "", CSMDoc::Message::Severity_Warning);
if (weapon.mData.mThrust[0] > weapon.mData.mThrust[1])
messages.add(id, "Minimum thrust damage higher than maximum", "", CSMDoc::Message::Severity_Warning);
}
if (weapon.mData.mChop[0] > weapon.mData.mChop[1])
messages.add(id, "Minimum chop damage higher than maximum", "", CSMDoc::Message::Severity_Warning);
if (!(weapon.mData.mType == ESM::Weapon::Arrow || weapon.mData.mType == ESM::Weapon::Bolt
|| weapon.mData.mType == ESM::Weapon::MarksmanThrown))
{
// checking of health
if (weapon.mData.mHealth == 0)
messages.add(id, "Durability is equal to zero", "", CSMDoc::Message::Severity_Warning);
if (weapon.mData.mReach < 0)
messages.add(id, "Reach is negative", "", CSMDoc::Message::Severity_Error);
}
}
// Check that mentioned scripts exist
scriptCheck<ESM::Weapon>(weapon, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::probeCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Probe>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Probe& probe = (dynamic_cast<const CSMWorld::Record<ESM::Probe>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Probe, probe.mId);
inventoryItemCheck<ESM::Probe>(probe, messages, id.toString());
toolCheck<ESM::Probe>(probe, messages, id.toString(), true);
// Check that mentioned scripts exist
scriptCheck<ESM::Probe>(probe, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::repairCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Repair>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Repair& repair = (dynamic_cast<const CSMWorld::Record<ESM::Repair>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Repair, repair.mId);
inventoryItemCheck<ESM::Repair>(repair, messages, id.toString());
toolCheck<ESM::Repair>(repair, messages, id.toString(), true);
// Check that mentioned scripts exist
scriptCheck<ESM::Repair>(repair, messages, id.toString());
}
void CSMTools::ReferenceableCheckStage::staticCheck(
int stage, const CSMWorld::RefIdDataContainer<ESM::Static>& records, CSMDoc::Messages& messages)
{
const CSMWorld::RecordBase& baseRecord = records.getRecord(stage);
// Skip "Base" records (setting!) and "Deleted" records
if ((mIgnoreBaseRecords && baseRecord.mState == CSMWorld::RecordBase::State_BaseOnly) || baseRecord.isDeleted())
return;
const ESM::Static& staticElement = (dynamic_cast<const CSMWorld::Record<ESM::Static>&>(baseRecord)).get();
CSMWorld::UniversalId id(CSMWorld::UniversalId::Type_Static, staticElement.mId);
if (staticElement.mModel.empty())
messages.add(id, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(staticElement.mModel) == -1)
messages.add(id, "Model '" + staticElement.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
// final check
void CSMTools::ReferenceableCheckStage::finalCheck(CSMDoc::Messages& messages)
{
if (!mPlayerPresent)
messages.add(CSMWorld::UniversalId::Type_Referenceables, "Player record is missing", "",
CSMDoc::Message::Severity_SeriousError);
}
void CSMTools::ReferenceableCheckStage::inventoryListCheck(
const std::vector<ESM::ContItem>& itemList, CSMDoc::Messages& messages, const std::string& id)
{
for (size_t i = 0; i < itemList.size(); ++i)
{
const ESM::RefId& item = itemList[i].mItem;
const auto& itemName = item.getRefIdString();
CSMWorld::RefIdData::LocalIndex localIndex = mReferencables.searchId(item);
if (localIndex.first == -1)
messages.add(id, "Item '" + itemName + "' does not exist", "", CSMDoc::Message::Severity_Error);
else
{
// Needs to accommodate containers, creatures, and NPCs
switch (localIndex.second)
{
case CSMWorld::UniversalId::Type_Potion:
case CSMWorld::UniversalId::Type_Apparatus:
case CSMWorld::UniversalId::Type_Armor:
case CSMWorld::UniversalId::Type_Book:
case CSMWorld::UniversalId::Type_Clothing:
case CSMWorld::UniversalId::Type_Ingredient:
case CSMWorld::UniversalId::Type_Light:
case CSMWorld::UniversalId::Type_Lockpick:
case CSMWorld::UniversalId::Type_Miscellaneous:
case CSMWorld::UniversalId::Type_Probe:
case CSMWorld::UniversalId::Type_Repair:
case CSMWorld::UniversalId::Type_Weapon:
case CSMWorld::UniversalId::Type_ItemLevelledList:
break;
default:
messages.add(id, "'" + itemName + "' is not an item", "", CSMDoc::Message::Severity_Error);
}
}
}
}
// Templates begins here
template <typename Item>
void CSMTools::ReferenceableCheckStage::inventoryItemCheck(
const Item& someItem, CSMDoc::Messages& messages, const std::string& someID, bool enchantable)
{
if (someItem.mName.empty())
messages.add(someID, "Name is missing", "", CSMDoc::Message::Severity_Error);
// Checking for weight
if (someItem.mData.mWeight < 0)
messages.add(someID, "Weight is negative", "", CSMDoc::Message::Severity_Error);
// Checking for value
if (someItem.mData.mValue < 0)
messages.add(someID, "Value is negative", "", CSMDoc::Message::Severity_Error);
// checking for model
if (someItem.mModel.empty())
messages.add(someID, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(someItem.mModel) == -1)
messages.add(someID, "Model '" + someItem.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// checking for icon
if (someItem.mIcon.empty())
messages.add(someID, "Icon is missing", "", CSMDoc::Message::Severity_Error);
else if (mIcons.searchId(someItem.mIcon) == -1)
{
std::string ddsIcon = someItem.mIcon;
if (!(Misc::ResourceHelpers::changeExtensionToDds(ddsIcon) && mIcons.searchId(ddsIcon) != -1))
messages.add(someID, "Icon '" + someItem.mIcon + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
if (enchantable && someItem.mData.mEnchant < 0)
messages.add(someID, "Enchantment points number is negative", "", CSMDoc::Message::Severity_Error);
}
template <typename Item>
void CSMTools::ReferenceableCheckStage::inventoryItemCheck(
const Item& someItem, CSMDoc::Messages& messages, const std::string& someID)
{
if (someItem.mName.empty())
messages.add(someID, "Name is missing", "", CSMDoc::Message::Severity_Error);
// Checking for weight
if (someItem.mData.mWeight < 0)
messages.add(someID, "Weight is negative", "", CSMDoc::Message::Severity_Error);
// Checking for value
if (someItem.mData.mValue < 0)
messages.add(someID, "Value is negative", "", CSMDoc::Message::Severity_Error);
// checking for model
if (someItem.mModel.empty())
messages.add(someID, "Model is missing", "", CSMDoc::Message::Severity_Error);
else if (mModels.searchId(someItem.mModel) == -1)
messages.add(someID, "Model '" + someItem.mModel + "' does not exist", "", CSMDoc::Message::Severity_Error);
// checking for icon
if (someItem.mIcon.empty())
messages.add(someID, "Icon is missing", "", CSMDoc::Message::Severity_Error);
else if (mIcons.searchId(someItem.mIcon) == -1)
{
std::string ddsIcon = someItem.mIcon;
if (!(Misc::ResourceHelpers::changeExtensionToDds(ddsIcon) && mIcons.searchId(ddsIcon) != -1))
messages.add(someID, "Icon '" + someItem.mIcon + "' does not exist", "", CSMDoc::Message::Severity_Error);
}
}
template <typename Tool>
void CSMTools::ReferenceableCheckStage::toolCheck(
const Tool& someTool, CSMDoc::Messages& messages, const std::string& someID, bool canBeBroken)
{
if (someTool.mData.mQuality <= 0)
messages.add(someID, "Quality is non-positive", "", CSMDoc::Message::Severity_Error);
if (canBeBroken && someTool.mData.mUses <= 0)
messages.add(someID, "Number of uses is non-positive", "", CSMDoc::Message::Severity_Error);
}
template <typename Tool>
void CSMTools::ReferenceableCheckStage::toolCheck(
const Tool& someTool, CSMDoc::Messages& messages, const std::string& someID)
{
if (someTool.mData.mQuality <= 0)
messages.add(someID, "Quality is non-positive", "", CSMDoc::Message::Severity_Error);
}
template <typename List>
void CSMTools::ReferenceableCheckStage::listCheck(
const List& someList, CSMDoc::Messages& messages, const std::string& someID)
{
if (someList.mChanceNone > 100)
{
messages.add(
someID, "Chance that no object is used is over 100 percent", "", CSMDoc::Message::Severity_Warning);
}
for (const auto& element : someList.mList)
{
if (mReferencables.searchId(element.mId).first == -1)
messages.add(someID, "Object '" + element.mId.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
if (element.mLevel < 1)
messages.add(someID, "Level of item '" + element.mId.getRefIdString() + "' is non-positive", "",
CSMDoc::Message::Severity_Error);
}
}
template <typename Tool>
void CSMTools::ReferenceableCheckStage::scriptCheck(
const Tool& someTool, CSMDoc::Messages& messages, const std::string& someID)
{
if (!someTool.mScript.empty())
{
if (mScripts.searchId(someTool.mScript) == -1)
messages.add(someID, "Script '" + someTool.mScript.getRefIdString() + "' does not exist", "",
CSMDoc::Message::Severity_Error);
}
}
| 41,434
|
C++
|
.cpp
| 811
| 44.737361
| 120
| 0.686859
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,981
|
mandatoryid.cpp
|
OpenMW_openmw/apps/opencs/model/tools/mandatoryid.cpp
|
#include "mandatoryid.hpp"
#include <memory>
#include "../world/collectionbase.hpp"
#include "../world/record.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/world/universalid.hpp>
CSMTools::MandatoryIdStage::MandatoryIdStage(const CSMWorld::CollectionBase& idCollection,
const CSMWorld::UniversalId& collectionId, const std::vector<ESM::RefId>& ids)
: mIdCollection(idCollection)
, mCollectionId(collectionId)
, mIds(ids)
{
}
int CSMTools::MandatoryIdStage::setup()
{
return static_cast<int>(mIds.size());
}
void CSMTools::MandatoryIdStage::perform(int stage, CSMDoc::Messages& messages)
{
if (mIdCollection.searchId(mIds.at(stage)) == -1 || mIdCollection.getRecord(mIds.at(stage)).isDeleted())
messages.add(mCollectionId, "Missing mandatory record: " + mIds.at(stage).toDebugString());
}
| 860
|
C++
|
.cpp
| 22
| 36.318182
| 108
| 0.756919
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,982
|
shortcuteventhandler.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/shortcuteventhandler.cpp
|
#include "shortcuteventhandler.hpp"
#include <algorithm>
#include <cassert>
#include <QEvent>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QWidget>
#include "shortcut.hpp"
namespace CSMPrefs
{
ShortcutEventHandler::ShortcutEventHandler(QObject* parent)
: QObject(parent)
{
}
void ShortcutEventHandler::addShortcut(Shortcut* shortcut)
{
// Enforced by shortcut class
QWidget* widget = static_cast<QWidget*>(shortcut->parent());
// Check if widget setup is needed
ShortcutMap::iterator shortcutListIt = mWidgetShortcuts.find(widget);
if (shortcutListIt == mWidgetShortcuts.end())
{
// Create list
shortcutListIt = mWidgetShortcuts.insert(std::make_pair(widget, ShortcutList())).first;
// Check if widget has a parent with shortcuts, unfortunately it is not typically set yet
updateParent(widget);
// Intercept widget events
widget->installEventFilter(this);
connect(widget, &QWidget::destroyed, this, &ShortcutEventHandler::widgetDestroyed);
}
// Add to list
shortcutListIt->second.push_back(shortcut);
}
void ShortcutEventHandler::removeShortcut(Shortcut* shortcut)
{
// Enforced by shortcut class
QWidget* widget = static_cast<QWidget*>(shortcut->parent());
ShortcutMap::iterator shortcutListIt = mWidgetShortcuts.find(widget);
if (shortcutListIt != mWidgetShortcuts.end())
{
shortcutListIt->second.erase(
std::remove(shortcutListIt->second.begin(), shortcutListIt->second.end(), shortcut),
shortcutListIt->second.end());
}
}
bool ShortcutEventHandler::eventFilter(QObject* watched, QEvent* event)
{
// Process event
if (event->type() == QEvent::KeyPress)
{
QWidget* widget = static_cast<QWidget*>(watched);
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
unsigned int mod = (unsigned int)keyEvent->modifiers();
unsigned int key = (unsigned int)keyEvent->key();
if (!keyEvent->isAutoRepeat())
return activate(widget, mod, key);
}
else if (event->type() == QEvent::KeyRelease)
{
QWidget* widget = static_cast<QWidget*>(watched);
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
unsigned int mod = (unsigned int)keyEvent->modifiers();
unsigned int key = (unsigned int)keyEvent->key();
if (!keyEvent->isAutoRepeat())
return deactivate(widget, mod, key);
}
else if (event->type() == QEvent::MouseButtonPress)
{
QWidget* widget = static_cast<QWidget*>(watched);
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
unsigned int mod = (unsigned int)mouseEvent->modifiers();
unsigned int button = (unsigned int)mouseEvent->button();
return activate(widget, mod, button);
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QWidget* widget = static_cast<QWidget*>(watched);
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
unsigned int mod = (unsigned int)mouseEvent->modifiers();
unsigned int button = (unsigned int)mouseEvent->button();
return deactivate(widget, mod, button);
}
else if (event->type() == QEvent::FocusOut)
{
QWidget* widget = static_cast<QWidget*>(watched);
ShortcutMap::iterator shortcutListIt = mWidgetShortcuts.find(widget);
assert(shortcutListIt != mWidgetShortcuts.end());
// Deactivate in case events are missed
for (ShortcutList::iterator it = shortcutListIt->second.begin(); it != shortcutListIt->second.end(); ++it)
{
Shortcut* shortcut = *it;
shortcut->setPosition(0);
shortcut->setModifierStatus(false);
if (shortcut->getActivationStatus() == Shortcut::AS_Regular)
{
shortcut->setActivationStatus(Shortcut::AS_Inactive);
shortcut->signalActivated(false);
}
else if (shortcut->getActivationStatus() == Shortcut::AS_Secondary)
{
shortcut->setActivationStatus(Shortcut::AS_Inactive);
shortcut->signalSecondary(false);
}
}
}
else if (event->type() == QEvent::FocusIn)
{
QWidget* widget = static_cast<QWidget*>(watched);
updateParent(widget);
}
return false;
}
void ShortcutEventHandler::updateParent(QWidget* widget)
{
QWidget* parent = widget->parentWidget();
while (parent)
{
ShortcutMap::iterator parentIt = mWidgetShortcuts.find(parent);
if (parentIt != mWidgetShortcuts.end())
{
mChildParentRelations.insert(std::make_pair(widget, parent));
updateParent(parent);
break;
}
// Check next
parent = parent->parentWidget();
}
}
bool ShortcutEventHandler::activate(QWidget* widget, unsigned int mod, unsigned int button)
{
std::vector<std::pair<MatchResult, Shortcut*>> potentials;
bool used = false;
while (widget)
{
ShortcutMap::iterator shortcutListIt = mWidgetShortcuts.find(widget);
assert(shortcutListIt != mWidgetShortcuts.end());
// Find potential activations
for (ShortcutList::iterator it = shortcutListIt->second.begin(); it != shortcutListIt->second.end(); ++it)
{
Shortcut* shortcut = *it;
if (!shortcut->isEnabled())
continue;
if (checkModifier(mod, button, shortcut, true))
used = true;
if (shortcut->getActivationStatus() != Shortcut::AS_Inactive)
continue;
int pos = shortcut->getPosition();
int lastPos = shortcut->getLastPosition();
MatchResult result = match(mod, button, shortcut->getSequence()[pos]);
if (result == Matches_WithMod || result == Matches_NoMod)
{
if (pos < lastPos && (result == Matches_WithMod || pos > 0))
{
shortcut->setPosition(pos + 1);
}
else if (pos == lastPos)
{
potentials.emplace_back(result, shortcut);
}
}
}
// Move on to parent
WidgetMap::iterator widgetIt = mChildParentRelations.find(widget);
widget = (widgetIt != mChildParentRelations.end()) ? widgetIt->second : 0;
}
// Only activate the best match; in exact conflicts, this will favor the first shortcut added.
if (!potentials.empty())
{
std::stable_sort(potentials.begin(), potentials.end(), ShortcutEventHandler::sort);
Shortcut* shortcut = potentials.front().second;
if (shortcut->getModifierStatus() && shortcut->getSecondaryMode() == Shortcut::SM_Replace)
{
shortcut->setActivationStatus(Shortcut::AS_Secondary);
shortcut->signalSecondary(true);
shortcut->signalSecondary();
}
else
{
shortcut->setActivationStatus(Shortcut::AS_Regular);
shortcut->signalActivated(true);
shortcut->signalActivated();
}
used = true;
}
return used;
}
bool ShortcutEventHandler::deactivate(QWidget* widget, unsigned int mod, unsigned int button)
{
const int KeyMask = 0x01FFFFFF;
bool used = false;
while (widget)
{
ShortcutMap::iterator shortcutListIt = mWidgetShortcuts.find(widget);
assert(shortcutListIt != mWidgetShortcuts.end());
for (ShortcutList::iterator it = shortcutListIt->second.begin(); it != shortcutListIt->second.end(); ++it)
{
Shortcut* shortcut = *it;
if (checkModifier(mod, button, shortcut, false))
used = true;
int pos = shortcut->getPosition();
MatchResult result = match(0, button, shortcut->getSequence()[pos] & KeyMask);
if (result != Matches_Not)
{
shortcut->setPosition(0);
if (shortcut->getActivationStatus() == Shortcut::AS_Regular)
{
shortcut->setActivationStatus(Shortcut::AS_Inactive);
shortcut->signalActivated(false);
used = true;
}
else if (shortcut->getActivationStatus() == Shortcut::AS_Secondary)
{
shortcut->setActivationStatus(Shortcut::AS_Inactive);
shortcut->signalSecondary(false);
used = true;
}
}
}
// Move on to parent
WidgetMap::iterator widgetIt = mChildParentRelations.find(widget);
widget = (widgetIt != mChildParentRelations.end()) ? widgetIt->second : 0;
}
return used;
}
bool ShortcutEventHandler::checkModifier(unsigned int mod, unsigned int button, Shortcut* shortcut, bool activate)
{
if (!shortcut->isEnabled() || !shortcut->getModifier() || shortcut->getSecondaryMode() == Shortcut::SM_Ignore
|| shortcut->getModifierStatus() == activate)
return false;
MatchResult result = match(mod, button, shortcut->getModifier());
bool used = false;
if (result != Matches_Not)
{
shortcut->setModifierStatus(activate);
if (shortcut->getSecondaryMode() == Shortcut::SM_Detach)
{
if (activate)
{
shortcut->signalSecondary(true);
shortcut->signalSecondary();
}
else
{
shortcut->signalSecondary(false);
}
}
else if (!activate && shortcut->getActivationStatus() == Shortcut::AS_Secondary)
{
shortcut->setActivationStatus(Shortcut::AS_Inactive);
shortcut->setPosition(0);
shortcut->signalSecondary(false);
used = true;
}
}
return used;
}
ShortcutEventHandler::MatchResult ShortcutEventHandler::match(
unsigned int mod, unsigned int button, unsigned int value)
{
if ((mod | button) == value)
{
return Matches_WithMod;
}
else if (button == value)
{
return Matches_NoMod;
}
else
{
return Matches_Not;
}
}
bool ShortcutEventHandler::sort(
const std::pair<MatchResult, Shortcut*>& left, const std::pair<MatchResult, Shortcut*>& right)
{
if (left.first == Matches_WithMod && right.first == Matches_NoMod)
return true;
else
return left.second->getPosition() > right.second->getPosition();
}
void ShortcutEventHandler::widgetDestroyed()
{
QWidget* widget = static_cast<QWidget*>(sender());
mWidgetShortcuts.erase(widget);
mChildParentRelations.erase(widget);
}
}
| 11,915
|
C++
|
.cpp
| 287
| 29.121951
| 118
| 0.560912
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,983
|
stringsetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/stringsetting.cpp
|
#include "stringsetting.hpp"
#include <QLabel>
#include <QLineEdit>
#include <QMutexLocker>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "category.hpp"
#include "state.hpp"
CSMPrefs::StringSetting::StringSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mWidget(nullptr)
{
}
CSMPrefs::StringSetting& CSMPrefs::StringSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::StringSetting::makeWidgets(QWidget* parent)
{
QLabel* label = new QLabel(getLabel(), parent);
mWidget = new QLineEdit(QString::fromStdString(getValue()), parent);
mWidget->setMinimumWidth(300);
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
label->setToolTip(tooltip);
mWidget->setToolTip(tooltip);
}
connect(mWidget, &QLineEdit::textChanged, this, &StringSetting::textChanged);
return SettingWidgets{ .mLabel = label, .mInput = mWidget };
}
void CSMPrefs::StringSetting::updateWidget()
{
if (mWidget)
mWidget->setText(QString::fromStdString(getValue()));
}
void CSMPrefs::StringSetting::textChanged(const QString& text)
{
setValue(text.toStdString());
getParent()->getState()->update(*this);
}
| 1,441
|
C++
|
.cpp
| 43
| 29.953488
| 104
| 0.731214
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,984
|
shortcutmanager.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/shortcutmanager.cpp
|
#include "shortcutmanager.hpp"
#include <algorithm>
#include <string>
#include <utility>
#include <QStringList>
#include "shortcut.hpp"
#include "shortcuteventhandler.hpp"
namespace CSMPrefs
{
ShortcutManager::ShortcutManager()
{
createLookupTables();
mEventHandler = new ShortcutEventHandler(this);
}
void ShortcutManager::addShortcut(Shortcut* shortcut)
{
mShortcuts.insert(std::make_pair(shortcut->getName(), shortcut));
mShortcuts.insert(std::make_pair(shortcut->getModifierName(), shortcut));
mEventHandler->addShortcut(shortcut);
}
void ShortcutManager::removeShortcut(Shortcut* shortcut)
{
std::pair<ShortcutMap::iterator, ShortcutMap::iterator> range = mShortcuts.equal_range(shortcut->getName());
for (ShortcutMap::iterator it = range.first; it != range.second;)
{
if (it->second == shortcut)
{
mShortcuts.erase(it++);
}
else
{
++it;
}
}
mEventHandler->removeShortcut(shortcut);
}
bool ShortcutManager::getSequence(std::string_view name, QKeySequence& sequence) const
{
SequenceMap::const_iterator item = mSequences.find(name);
if (item != mSequences.end())
{
sequence = item->second;
return true;
}
else
return false;
}
void ShortcutManager::setSequence(std::string_view name, const QKeySequence& sequence)
{
// Add to map/modify
SequenceMap::iterator item = mSequences.find(name);
if (item != mSequences.end())
{
item->second = sequence;
}
else
{
mSequences.insert(std::make_pair(name, sequence));
}
// Change active shortcuts
std::pair<ShortcutMap::iterator, ShortcutMap::iterator> rangeS = mShortcuts.equal_range(name);
for (ShortcutMap::iterator it = rangeS.first; it != rangeS.second; ++it)
{
it->second->setSequence(sequence);
}
}
bool ShortcutManager::getModifier(const std::string& name, int& modifier) const
{
ModifierMap::const_iterator item = mModifiers.find(name);
if (item != mModifiers.end())
{
modifier = item->second;
return true;
}
else
return false;
}
void ShortcutManager::setModifier(std::string_view name, int modifier)
{
// Add to map/modify
ModifierMap::iterator item = mModifiers.find(name);
if (item != mModifiers.end())
{
item->second = modifier;
}
else
{
mModifiers.insert(std::make_pair(name, modifier));
}
// Change active shortcuts
std::pair<ShortcutMap::iterator, ShortcutMap::iterator> rangeS = mShortcuts.equal_range(name);
for (ShortcutMap::iterator it = rangeS.first; it != rangeS.second; ++it)
{
it->second->setModifier(modifier);
}
}
std::string ShortcutManager::convertToString(const QKeySequence& sequence) const
{
const int MouseKeyMask = 0x01FFFFFF;
const int ModMask = 0x7E000000;
std::string result;
for (int i = 0; i < (int)sequence.count(); ++i)
{
int mods = sequence[i] & ModMask;
int key = sequence[i] & MouseKeyMask;
if (key)
{
NameMap::const_iterator searchResult = mNames.find(key);
if (searchResult != mNames.end())
{
if (mods && i == 0)
{
if (mods & Qt::ControlModifier)
result.append("Ctrl+");
if (mods & Qt::ShiftModifier)
result.append("Shift+");
if (mods & Qt::AltModifier)
result.append("Alt+");
if (mods & Qt::MetaModifier)
result.append("Meta+");
if (mods & Qt::KeypadModifier)
result.append("Keypad+");
if (mods & Qt::GroupSwitchModifier)
result.append("GroupSwitch+");
}
else if (i > 0)
{
result.append("+");
}
result.append(searchResult->second);
}
}
}
return result;
}
std::string ShortcutManager::convertToString(int modifier) const
{
NameMap::const_iterator searchResult = mNames.find(modifier);
if (searchResult != mNames.end())
{
return searchResult->second;
}
else
return "";
}
std::string ShortcutManager::convertToString(const QKeySequence& sequence, int modifier) const
{
std::string concat = convertToString(sequence) + ";" + convertToString(modifier);
return concat;
}
void ShortcutManager::convertFromString(const std::string& data, QKeySequence& sequence) const
{
const int MaxKeys = 4; // A limitation of QKeySequence
size_t end = data.find(';');
size_t size = std::min(end, data.size());
std::string value = data.substr(0, size);
size_t start = 0;
int keyPos = 0;
int mods = 0;
int keys[MaxKeys] = {};
while (start < value.size())
{
end = data.find('+', start);
end = std::min(end, value.size());
std::string name = value.substr(start, end - start);
if (name == "Ctrl")
{
mods |= Qt::ControlModifier;
}
else if (name == "Shift")
{
mods |= Qt::ShiftModifier;
}
else if (name == "Alt")
{
mods |= Qt::AltModifier;
}
else if (name == "Meta")
{
mods |= Qt::MetaModifier;
}
else if (name == "Keypad")
{
mods |= Qt::KeypadModifier;
}
else if (name == "GroupSwitch")
{
mods |= Qt::GroupSwitchModifier;
}
else
{
KeyMap::const_iterator searchResult = mKeys.find(name);
if (searchResult != mKeys.end())
{
keys[keyPos] = mods | searchResult->second;
mods = 0;
keyPos += 1;
if (keyPos >= MaxKeys)
break;
}
}
start = end + 1;
}
sequence = QKeySequence(keys[0], keys[1], keys[2], keys[3]);
}
void ShortcutManager::convertFromString(const std::string& data, int& modifier) const
{
size_t start = data.find(';') + 1;
start = std::min(start, data.size());
std::string name = data.substr(start);
KeyMap::const_iterator searchResult = mKeys.find(name);
if (searchResult != mKeys.end())
{
modifier = searchResult->second;
}
else
{
modifier = 0;
}
}
void ShortcutManager::convertFromString(const std::string& data, QKeySequence& sequence, int& modifier) const
{
convertFromString(data, sequence);
convertFromString(data, modifier);
}
void ShortcutManager::createLookupTables()
{
// Mouse buttons
mNames.insert(std::make_pair(Qt::LeftButton, "LMB"));
mNames.insert(std::make_pair(Qt::RightButton, "RMB"));
mNames.insert(std::make_pair(Qt::MiddleButton, "MMB"));
mNames.insert(std::make_pair(Qt::XButton1, "Mouse4"));
mNames.insert(std::make_pair(Qt::XButton2, "Mouse5"));
// Keyboard buttons
for (size_t i = 0; QtKeys[i].first != 0; ++i)
{
mNames.insert(QtKeys[i]);
}
// Generate inverse map
for (NameMap::const_iterator it = mNames.begin(); it != mNames.end(); ++it)
{
mKeys.insert(std::make_pair(it->second, it->first));
}
}
QString ShortcutManager::processToolTip(const QString& toolTip) const
{
const QChar SequenceStart = '{';
const QChar SequenceEnd = '}';
QStringList substrings;
int prevIndex = 0;
int startIndex = toolTip.indexOf(SequenceStart);
int endIndex = (startIndex != -1) ? toolTip.indexOf(SequenceEnd, startIndex) : -1;
// Process every valid shortcut escape sequence
while (startIndex != -1 && endIndex != -1)
{
int count = startIndex - prevIndex;
if (count > 0)
{
substrings.push_back(toolTip.mid(prevIndex, count));
}
// Find sequence name
startIndex += 1; // '{' character
count = endIndex - startIndex;
if (count > 0)
{
QString settingName = toolTip.mid(startIndex, count);
QKeySequence sequence;
int modifier;
if (getSequence(settingName.toUtf8().data(), sequence))
{
QString value = QString::fromUtf8(convertToString(sequence).c_str());
substrings.push_back(value);
}
else if (getModifier(settingName.toUtf8().data(), modifier))
{
QString value = QString::fromUtf8(convertToString(modifier).c_str());
substrings.push_back(value);
}
prevIndex = endIndex + 1; // '}' character
}
startIndex = toolTip.indexOf(SequenceStart, endIndex);
endIndex = (startIndex != -1) ? toolTip.indexOf(SequenceEnd, startIndex) : -1;
}
if (prevIndex < toolTip.size())
{
substrings.push_back(toolTip.mid(prevIndex));
}
return substrings.join("");
}
const std::pair<int, const char*> ShortcutManager::QtKeys[] = {
std::make_pair((int)Qt::Key_Space, "Space"),
std::make_pair((int)Qt::Key_Exclam, "Exclam"),
std::make_pair((int)Qt::Key_QuoteDbl, "QuoteDbl"),
std::make_pair((int)Qt::Key_NumberSign, "NumberSign"),
std::make_pair((int)Qt::Key_Dollar, "Dollar"),
std::make_pair((int)Qt::Key_Percent, "Percent"),
std::make_pair((int)Qt::Key_Ampersand, "Ampersand"),
std::make_pair((int)Qt::Key_Apostrophe, "Apostrophe"),
std::make_pair((int)Qt::Key_ParenLeft, "ParenLeft"),
std::make_pair((int)Qt::Key_ParenRight, "ParenRight"),
std::make_pair((int)Qt::Key_Asterisk, "Asterisk"),
std::make_pair((int)Qt::Key_Plus, "Plus"),
std::make_pair((int)Qt::Key_Comma, "Comma"),
std::make_pair((int)Qt::Key_Minus, "Minus"),
std::make_pair((int)Qt::Key_Period, "Period"),
std::make_pair((int)Qt::Key_Slash, "Slash"),
std::make_pair((int)Qt::Key_0, "0"),
std::make_pair((int)Qt::Key_1, "1"),
std::make_pair((int)Qt::Key_2, "2"),
std::make_pair((int)Qt::Key_3, "3"),
std::make_pair((int)Qt::Key_4, "4"),
std::make_pair((int)Qt::Key_5, "5"),
std::make_pair((int)Qt::Key_6, "6"),
std::make_pair((int)Qt::Key_7, "7"),
std::make_pair((int)Qt::Key_8, "8"),
std::make_pair((int)Qt::Key_9, "9"),
std::make_pair((int)Qt::Key_Colon, "Colon"),
std::make_pair((int)Qt::Key_Semicolon, "Semicolon"),
std::make_pair((int)Qt::Key_Less, "Less"),
std::make_pair((int)Qt::Key_Equal, "Equal"),
std::make_pair((int)Qt::Key_Greater, "Greater"),
std::make_pair((int)Qt::Key_Question, "Question"),
std::make_pair((int)Qt::Key_At, "At"),
std::make_pair((int)Qt::Key_A, "A"),
std::make_pair((int)Qt::Key_B, "B"),
std::make_pair((int)Qt::Key_C, "C"),
std::make_pair((int)Qt::Key_D, "D"),
std::make_pair((int)Qt::Key_E, "E"),
std::make_pair((int)Qt::Key_F, "F"),
std::make_pair((int)Qt::Key_G, "G"),
std::make_pair((int)Qt::Key_H, "H"),
std::make_pair((int)Qt::Key_I, "I"),
std::make_pair((int)Qt::Key_J, "J"),
std::make_pair((int)Qt::Key_K, "K"),
std::make_pair((int)Qt::Key_L, "L"),
std::make_pair((int)Qt::Key_M, "M"),
std::make_pair((int)Qt::Key_N, "N"),
std::make_pair((int)Qt::Key_O, "O"),
std::make_pair((int)Qt::Key_P, "P"),
std::make_pair((int)Qt::Key_Q, "Q"),
std::make_pair((int)Qt::Key_R, "R"),
std::make_pair((int)Qt::Key_S, "S"),
std::make_pair((int)Qt::Key_T, "T"),
std::make_pair((int)Qt::Key_U, "U"),
std::make_pair((int)Qt::Key_V, "V"),
std::make_pair((int)Qt::Key_W, "W"),
std::make_pair((int)Qt::Key_X, "X"),
std::make_pair((int)Qt::Key_Y, "Y"),
std::make_pair((int)Qt::Key_Z, "Z"),
std::make_pair((int)Qt::Key_BracketLeft, "BracketLeft"),
std::make_pair((int)Qt::Key_Backslash, "Backslash"),
std::make_pair((int)Qt::Key_BracketRight, "BracketRight"),
std::make_pair((int)Qt::Key_AsciiCircum, "AsciiCircum"),
std::make_pair((int)Qt::Key_Underscore, "Underscore"),
std::make_pair((int)Qt::Key_QuoteLeft, "QuoteLeft"),
std::make_pair((int)Qt::Key_BraceLeft, "BraceLeft"),
std::make_pair((int)Qt::Key_Bar, "Bar"),
std::make_pair((int)Qt::Key_BraceRight, "BraceRight"),
std::make_pair((int)Qt::Key_AsciiTilde, "AsciiTilde"),
std::make_pair((int)Qt::Key_nobreakspace, "nobreakspace"),
std::make_pair((int)Qt::Key_exclamdown, "exclamdown"),
std::make_pair((int)Qt::Key_cent, "cent"),
std::make_pair((int)Qt::Key_sterling, "sterling"),
std::make_pair((int)Qt::Key_currency, "currency"),
std::make_pair((int)Qt::Key_yen, "yen"),
std::make_pair((int)Qt::Key_brokenbar, "brokenbar"),
std::make_pair((int)Qt::Key_section, "section"),
std::make_pair((int)Qt::Key_diaeresis, "diaeresis"),
std::make_pair((int)Qt::Key_copyright, "copyright"),
std::make_pair((int)Qt::Key_ordfeminine, "ordfeminine"),
std::make_pair((int)Qt::Key_guillemotleft, "guillemotleft"),
std::make_pair((int)Qt::Key_notsign, "notsign"),
std::make_pair((int)Qt::Key_hyphen, "hyphen"),
std::make_pair((int)Qt::Key_registered, "registered"),
std::make_pair((int)Qt::Key_macron, "macron"),
std::make_pair((int)Qt::Key_degree, "degree"),
std::make_pair((int)Qt::Key_plusminus, "plusminus"),
std::make_pair((int)Qt::Key_twosuperior, "twosuperior"),
std::make_pair((int)Qt::Key_threesuperior, "threesuperior"),
std::make_pair((int)Qt::Key_acute, "acute"),
std::make_pair((int)Qt::Key_mu, "mu"),
std::make_pair((int)Qt::Key_paragraph, "paragraph"),
std::make_pair((int)Qt::Key_periodcentered, "periodcentered"),
std::make_pair((int)Qt::Key_cedilla, "cedilla"),
std::make_pair((int)Qt::Key_onesuperior, "onesuperior"),
std::make_pair((int)Qt::Key_masculine, "masculine"),
std::make_pair((int)Qt::Key_guillemotright, "guillemotright"),
std::make_pair((int)Qt::Key_onequarter, "onequarter"),
std::make_pair((int)Qt::Key_onehalf, "onehalf"),
std::make_pair((int)Qt::Key_threequarters, "threequarters"),
std::make_pair((int)Qt::Key_questiondown, "questiondown"),
std::make_pair((int)Qt::Key_Agrave, "Agrave"),
std::make_pair((int)Qt::Key_Aacute, "Aacute"),
std::make_pair((int)Qt::Key_Acircumflex, "Acircumflex"),
std::make_pair((int)Qt::Key_Atilde, "Atilde"),
std::make_pair((int)Qt::Key_Adiaeresis, "Adiaeresis"),
std::make_pair((int)Qt::Key_Aring, "Aring"),
std::make_pair((int)Qt::Key_AE, "AE"),
std::make_pair((int)Qt::Key_Ccedilla, "Ccedilla"),
std::make_pair((int)Qt::Key_Egrave, "Egrave"),
std::make_pair((int)Qt::Key_Eacute, "Eacute"),
std::make_pair((int)Qt::Key_Ecircumflex, "Ecircumflex"),
std::make_pair((int)Qt::Key_Ediaeresis, "Ediaeresis"),
std::make_pair((int)Qt::Key_Igrave, "Igrave"),
std::make_pair((int)Qt::Key_Iacute, "Iacute"),
std::make_pair((int)Qt::Key_Icircumflex, "Icircumflex"),
std::make_pair((int)Qt::Key_Idiaeresis, "Idiaeresis"),
std::make_pair((int)Qt::Key_ETH, "ETH"),
std::make_pair((int)Qt::Key_Ntilde, "Ntilde"),
std::make_pair((int)Qt::Key_Ograve, "Ograve"),
std::make_pair((int)Qt::Key_Oacute, "Oacute"),
std::make_pair((int)Qt::Key_Ocircumflex, "Ocircumflex"),
std::make_pair((int)Qt::Key_Otilde, "Otilde"),
std::make_pair((int)Qt::Key_Odiaeresis, "Odiaeresis"),
std::make_pair((int)Qt::Key_multiply, "multiply"),
std::make_pair((int)Qt::Key_Ooblique, "Ooblique"),
std::make_pair((int)Qt::Key_Ugrave, "Ugrave"),
std::make_pair((int)Qt::Key_Uacute, "Uacute"),
std::make_pair((int)Qt::Key_Ucircumflex, "Ucircumflex"),
std::make_pair((int)Qt::Key_Udiaeresis, "Udiaeresis"),
std::make_pair((int)Qt::Key_Yacute, "Yacute"),
std::make_pair((int)Qt::Key_THORN, "THORN"),
std::make_pair((int)Qt::Key_ssharp, "ssharp"),
std::make_pair((int)Qt::Key_division, "division"),
std::make_pair((int)Qt::Key_ydiaeresis, "ydiaeresis"),
std::make_pair((int)Qt::Key_Escape, "Escape"),
std::make_pair((int)Qt::Key_Tab, "Tab"),
std::make_pair((int)Qt::Key_Backtab, "Backtab"),
std::make_pair((int)Qt::Key_Backspace, "Backspace"),
std::make_pair((int)Qt::Key_Return, "Return"),
std::make_pair((int)Qt::Key_Enter, "Enter"),
std::make_pair((int)Qt::Key_Insert, "Insert"),
std::make_pair((int)Qt::Key_Delete, "Delete"),
std::make_pair((int)Qt::Key_Pause, "Pause"),
std::make_pair((int)Qt::Key_Print, "Print"),
std::make_pair((int)Qt::Key_SysReq, "SysReq"),
std::make_pair((int)Qt::Key_Clear, "Clear"),
std::make_pair((int)Qt::Key_Home, "Home"),
std::make_pair((int)Qt::Key_End, "End"),
std::make_pair((int)Qt::Key_Left, "Left"),
std::make_pair((int)Qt::Key_Up, "Up"),
std::make_pair((int)Qt::Key_Right, "Right"),
std::make_pair((int)Qt::Key_Down, "Down"),
std::make_pair((int)Qt::Key_PageUp, "PageUp"),
std::make_pair((int)Qt::Key_PageDown, "PageDown"),
std::make_pair((int)Qt::Key_Shift, "Shift"),
std::make_pair((int)Qt::Key_Control, "Control"),
std::make_pair((int)Qt::Key_Meta, "Meta"),
std::make_pair((int)Qt::Key_Alt, "Alt"),
std::make_pair((int)Qt::Key_CapsLock, "CapsLock"),
std::make_pair((int)Qt::Key_NumLock, "NumLock"),
std::make_pair((int)Qt::Key_ScrollLock, "ScrollLock"),
std::make_pair((int)Qt::Key_F1, "F1"),
std::make_pair((int)Qt::Key_F2, "F2"),
std::make_pair((int)Qt::Key_F3, "F3"),
std::make_pair((int)Qt::Key_F4, "F4"),
std::make_pair((int)Qt::Key_F5, "F5"),
std::make_pair((int)Qt::Key_F6, "F6"),
std::make_pair((int)Qt::Key_F7, "F7"),
std::make_pair((int)Qt::Key_F8, "F8"),
std::make_pair((int)Qt::Key_F9, "F9"),
std::make_pair((int)Qt::Key_F10, "F10"),
std::make_pair((int)Qt::Key_F11, "F11"),
std::make_pair((int)Qt::Key_F12, "F12"),
std::make_pair((int)Qt::Key_F13, "F13"),
std::make_pair((int)Qt::Key_F14, "F14"),
std::make_pair((int)Qt::Key_F15, "F15"),
std::make_pair((int)Qt::Key_F16, "F16"),
std::make_pair((int)Qt::Key_F17, "F17"),
std::make_pair((int)Qt::Key_F18, "F18"),
std::make_pair((int)Qt::Key_F19, "F19"),
std::make_pair((int)Qt::Key_F20, "F20"),
std::make_pair((int)Qt::Key_F21, "F21"),
std::make_pair((int)Qt::Key_F22, "F22"),
std::make_pair((int)Qt::Key_F23, "F23"),
std::make_pair((int)Qt::Key_F24, "F24"),
std::make_pair((int)Qt::Key_F25, "F25"),
std::make_pair((int)Qt::Key_F26, "F26"),
std::make_pair((int)Qt::Key_F27, "F27"),
std::make_pair((int)Qt::Key_F28, "F28"),
std::make_pair((int)Qt::Key_F29, "F29"),
std::make_pair((int)Qt::Key_F30, "F30"),
std::make_pair((int)Qt::Key_F31, "F31"),
std::make_pair((int)Qt::Key_F32, "F32"),
std::make_pair((int)Qt::Key_F33, "F33"),
std::make_pair((int)Qt::Key_F34, "F34"),
std::make_pair((int)Qt::Key_F35, "F35"),
std::make_pair((int)Qt::Key_Super_L, "Super_L"),
std::make_pair((int)Qt::Key_Super_R, "Super_R"),
std::make_pair((int)Qt::Key_Menu, "Menu"),
std::make_pair((int)Qt::Key_Hyper_L, "Hyper_L"),
std::make_pair((int)Qt::Key_Hyper_R, "Hyper_R"),
std::make_pair((int)Qt::Key_Help, "Help"),
std::make_pair((int)Qt::Key_Direction_L, "Direction_L"),
std::make_pair((int)Qt::Key_Direction_R, "Direction_R"),
std::make_pair((int)Qt::Key_Back, "Back"),
std::make_pair((int)Qt::Key_Forward, "Forward"),
std::make_pair((int)Qt::Key_Stop, "Stop"),
std::make_pair((int)Qt::Key_Refresh, "Refresh"),
std::make_pair((int)Qt::Key_VolumeDown, "VolumeDown"),
std::make_pair((int)Qt::Key_VolumeMute, "VolumeMute"),
std::make_pair((int)Qt::Key_VolumeUp, "VolumeUp"),
std::make_pair((int)Qt::Key_BassBoost, "BassBoost"),
std::make_pair((int)Qt::Key_BassUp, "BassUp"),
std::make_pair((int)Qt::Key_BassDown, "BassDown"),
std::make_pair((int)Qt::Key_TrebleUp, "TrebleUp"),
std::make_pair((int)Qt::Key_TrebleDown, "TrebleDown"),
std::make_pair((int)Qt::Key_MediaPlay, "MediaPlay"),
std::make_pair((int)Qt::Key_MediaStop, "MediaStop"),
std::make_pair((int)Qt::Key_MediaPrevious, "MediaPrevious"),
std::make_pair((int)Qt::Key_MediaNext, "MediaNext"),
std::make_pair((int)Qt::Key_MediaRecord, "MediaRecord"),
std::make_pair((int)Qt::Key_MediaPause, "MediaPause"),
std::make_pair((int)Qt::Key_MediaTogglePlayPause, "MediaTogglePlayPause"),
std::make_pair((int)Qt::Key_HomePage, "HomePage"),
std::make_pair((int)Qt::Key_Favorites, "Favorites"),
std::make_pair((int)Qt::Key_Search, "Search"),
std::make_pair((int)Qt::Key_Standby, "Standby"),
std::make_pair((int)Qt::Key_OpenUrl, "OpenUrl"),
std::make_pair((int)Qt::Key_LaunchMail, "LaunchMail"),
std::make_pair((int)Qt::Key_LaunchMedia, "LaunchMedia"),
std::make_pair((int)Qt::Key_Launch0, "Launch0"),
std::make_pair((int)Qt::Key_Launch1, "Launch1"),
std::make_pair((int)Qt::Key_Launch2, "Launch2"),
std::make_pair((int)Qt::Key_Launch3, "Launch3"),
std::make_pair((int)Qt::Key_Launch4, "Launch4"),
std::make_pair((int)Qt::Key_Launch5, "Launch5"),
std::make_pair((int)Qt::Key_Launch6, "Launch6"),
std::make_pair((int)Qt::Key_Launch7, "Launch7"),
std::make_pair((int)Qt::Key_Launch8, "Launch8"),
std::make_pair((int)Qt::Key_Launch9, "Launch9"),
std::make_pair((int)Qt::Key_LaunchA, "LaunchA"),
std::make_pair((int)Qt::Key_LaunchB, "LaunchB"),
std::make_pair((int)Qt::Key_LaunchC, "LaunchC"),
std::make_pair((int)Qt::Key_LaunchD, "LaunchD"),
std::make_pair((int)Qt::Key_LaunchE, "LaunchE"),
std::make_pair((int)Qt::Key_LaunchF, "LaunchF"),
std::make_pair((int)Qt::Key_MonBrightnessUp, "MonBrightnessUp"),
std::make_pair((int)Qt::Key_MonBrightnessDown, "MonBrightnessDown"),
std::make_pair((int)Qt::Key_KeyboardLightOnOff, "KeyboardLightOnOff"),
std::make_pair((int)Qt::Key_KeyboardBrightnessUp, "KeyboardBrightnessUp"),
std::make_pair((int)Qt::Key_KeyboardBrightnessDown, "KeyboardBrightnessDown"),
std::make_pair((int)Qt::Key_PowerOff, "PowerOff"),
std::make_pair((int)Qt::Key_WakeUp, "WakeUp"),
std::make_pair((int)Qt::Key_Eject, "Eject"),
std::make_pair((int)Qt::Key_ScreenSaver, "ScreenSaver"),
std::make_pair((int)Qt::Key_WWW, "WWW"),
std::make_pair((int)Qt::Key_Memo, "Memo"),
std::make_pair((int)Qt::Key_LightBulb, "LightBulb"),
std::make_pair((int)Qt::Key_Shop, "Shop"),
std::make_pair((int)Qt::Key_History, "History"),
std::make_pair((int)Qt::Key_AddFavorite, "AddFavorite"),
std::make_pair((int)Qt::Key_HotLinks, "HotLinks"),
std::make_pair((int)Qt::Key_BrightnessAdjust, "BrightnessAdjust"),
std::make_pair((int)Qt::Key_Finance, "Finance"),
std::make_pair((int)Qt::Key_Community, "Community"),
std::make_pair((int)Qt::Key_AudioRewind, "AudioRewind"),
std::make_pair((int)Qt::Key_BackForward, "BackForward"),
std::make_pair((int)Qt::Key_ApplicationLeft, "ApplicationLeft"),
std::make_pair((int)Qt::Key_ApplicationRight, "ApplicationRight"),
std::make_pair((int)Qt::Key_Book, "Book"),
std::make_pair((int)Qt::Key_CD, "CD"),
std::make_pair((int)Qt::Key_Calculator, "Calculator"),
std::make_pair((int)Qt::Key_ToDoList, "ToDoList"),
std::make_pair((int)Qt::Key_ClearGrab, "ClearGrab"),
std::make_pair((int)Qt::Key_Close, "Close"),
std::make_pair((int)Qt::Key_Copy, "Copy"),
std::make_pair((int)Qt::Key_Cut, "Cut"),
std::make_pair((int)Qt::Key_Display, "Display"),
std::make_pair((int)Qt::Key_DOS, "DOS"),
std::make_pair((int)Qt::Key_Documents, "Documents"),
std::make_pair((int)Qt::Key_Excel, "Excel"),
std::make_pair((int)Qt::Key_Explorer, "Explorer"),
std::make_pair((int)Qt::Key_Game, "Game"),
std::make_pair((int)Qt::Key_Go, "Go"),
std::make_pair((int)Qt::Key_iTouch, "iTouch"),
std::make_pair((int)Qt::Key_LogOff, "LogOff"),
std::make_pair((int)Qt::Key_Market, "Market"),
std::make_pair((int)Qt::Key_Meeting, "Meeting"),
std::make_pair((int)Qt::Key_MenuKB, "MenuKB"),
std::make_pair((int)Qt::Key_MenuPB, "MenuPB"),
std::make_pair((int)Qt::Key_MySites, "MySites"),
std::make_pair((int)Qt::Key_News, "News"),
std::make_pair((int)Qt::Key_OfficeHome, "OfficeHome"),
std::make_pair((int)Qt::Key_Option, "Option"),
std::make_pair((int)Qt::Key_Paste, "Paste"),
std::make_pair((int)Qt::Key_Phone, "Phone"),
std::make_pair((int)Qt::Key_Calendar, "Calendar"),
std::make_pair((int)Qt::Key_Reply, "Reply"),
std::make_pair((int)Qt::Key_Reload, "Reload"),
std::make_pair((int)Qt::Key_RotateWindows, "RotateWindows"),
std::make_pair((int)Qt::Key_RotationPB, "RotationPB"),
std::make_pair((int)Qt::Key_RotationKB, "RotationKB"),
std::make_pair((int)Qt::Key_Save, "Save"),
std::make_pair((int)Qt::Key_Send, "Send"),
std::make_pair((int)Qt::Key_Spell, "Spell"),
std::make_pair((int)Qt::Key_SplitScreen, "SplitScreen"),
std::make_pair((int)Qt::Key_Support, "Support"),
std::make_pair((int)Qt::Key_TaskPane, "TaskPane"),
std::make_pair((int)Qt::Key_Terminal, "Terminal"),
std::make_pair((int)Qt::Key_Tools, "Tools"),
std::make_pair((int)Qt::Key_Travel, "Travel"),
std::make_pair((int)Qt::Key_Video, "Video"),
std::make_pair((int)Qt::Key_Word, "Word"),
std::make_pair((int)Qt::Key_Xfer, "Xfer"),
std::make_pair((int)Qt::Key_ZoomIn, "ZoomIn"),
std::make_pair((int)Qt::Key_ZoomOut, "ZoomOut"),
std::make_pair((int)Qt::Key_Away, "Away"),
std::make_pair((int)Qt::Key_Messenger, "Messenger"),
std::make_pair((int)Qt::Key_WebCam, "WebCam"),
std::make_pair((int)Qt::Key_MailForward, "MailForward"),
std::make_pair((int)Qt::Key_Pictures, "Pictures"),
std::make_pair((int)Qt::Key_Music, "Music"),
std::make_pair((int)Qt::Key_Battery, "Battery"),
std::make_pair((int)Qt::Key_Bluetooth, "Bluetooth"),
std::make_pair((int)Qt::Key_WLAN, "WLAN"),
std::make_pair((int)Qt::Key_UWB, "UWB"),
std::make_pair((int)Qt::Key_AudioForward, "AudioForward"),
std::make_pair((int)Qt::Key_AudioRepeat, "AudioRepeat"),
std::make_pair((int)Qt::Key_AudioRandomPlay, "AudioRandomPlay"),
std::make_pair((int)Qt::Key_Subtitle, "Subtitle"),
std::make_pair((int)Qt::Key_AudioCycleTrack, "AudioCycleTrack"),
std::make_pair((int)Qt::Key_Time, "Time"),
std::make_pair((int)Qt::Key_Hibernate, "Hibernate"),
std::make_pair((int)Qt::Key_View, "View"),
std::make_pair((int)Qt::Key_TopMenu, "TopMenu"),
std::make_pair((int)Qt::Key_PowerDown, "PowerDown"),
std::make_pair((int)Qt::Key_Suspend, "Suspend"),
std::make_pair((int)Qt::Key_ContrastAdjust, "ContrastAdjust"),
std::make_pair((int)Qt::Key_LaunchG, "LaunchG"),
std::make_pair((int)Qt::Key_LaunchH, "LaunchH"),
std::make_pair((int)Qt::Key_TouchpadToggle, "TouchpadToggle"),
std::make_pair((int)Qt::Key_TouchpadOn, "TouchpadOn"),
std::make_pair((int)Qt::Key_TouchpadOff, "TouchpadOff"),
std::make_pair((int)Qt::Key_MicMute, "MicMute"),
std::make_pair((int)Qt::Key_Red, "Red"),
std::make_pair((int)Qt::Key_Green, "Green"),
std::make_pair((int)Qt::Key_Yellow, "Yellow"),
std::make_pair((int)Qt::Key_Blue, "Blue"),
std::make_pair((int)Qt::Key_ChannelUp, "ChannelUp"),
std::make_pair((int)Qt::Key_ChannelDown, "ChannelDown"),
std::make_pair((int)Qt::Key_Guide, "Guide"),
std::make_pair((int)Qt::Key_Info, "Info"),
std::make_pair((int)Qt::Key_Settings, "Settings"),
std::make_pair((int)Qt::Key_MicVolumeUp, "MicVolumeUp"),
std::make_pair((int)Qt::Key_MicVolumeDown, "MicVolumeDown"),
std::make_pair((int)Qt::Key_New, "New"),
std::make_pair((int)Qt::Key_Open, "Open"),
std::make_pair((int)Qt::Key_Find, "Find"),
std::make_pair((int)Qt::Key_Undo, "Undo"),
std::make_pair((int)Qt::Key_Redo, "Redo"),
std::make_pair((int)Qt::Key_AltGr, "AltGr"),
std::make_pair((int)Qt::Key_Multi_key, "Multi_key"),
std::make_pair((int)Qt::Key_Kanji, "Kanji"),
std::make_pair((int)Qt::Key_Muhenkan, "Muhenkan"),
std::make_pair((int)Qt::Key_Henkan, "Henkan"),
std::make_pair((int)Qt::Key_Romaji, "Romaji"),
std::make_pair((int)Qt::Key_Hiragana, "Hiragana"),
std::make_pair((int)Qt::Key_Katakana, "Katakana"),
std::make_pair((int)Qt::Key_Hiragana_Katakana, "Hiragana_Katakana"),
std::make_pair((int)Qt::Key_Zenkaku, "Zenkaku"),
std::make_pair((int)Qt::Key_Hankaku, "Hankaku"),
std::make_pair((int)Qt::Key_Zenkaku_Hankaku, "Zenkaku_Hankaku"),
std::make_pair((int)Qt::Key_Touroku, "Touroku"),
std::make_pair((int)Qt::Key_Massyo, "Massyo"),
std::make_pair((int)Qt::Key_Kana_Lock, "Kana_Lock"),
std::make_pair((int)Qt::Key_Kana_Shift, "Kana_Shift"),
std::make_pair((int)Qt::Key_Eisu_Shift, "Eisu_Shift"),
std::make_pair((int)Qt::Key_Eisu_toggle, "Eisu_toggle"),
std::make_pair((int)Qt::Key_Hangul, "Hangul"),
std::make_pair((int)Qt::Key_Hangul_Start, "Hangul_Start"),
std::make_pair((int)Qt::Key_Hangul_End, "Hangul_End"),
std::make_pair((int)Qt::Key_Hangul_Hanja, "Hangul_Hanja"),
std::make_pair((int)Qt::Key_Hangul_Jamo, "Hangul_Jamo"),
std::make_pair((int)Qt::Key_Hangul_Romaja, "Hangul_Romaja"),
std::make_pair((int)Qt::Key_Codeinput, "Codeinput"),
std::make_pair((int)Qt::Key_Hangul_Jeonja, "Hangul_Jeonja"),
std::make_pair((int)Qt::Key_Hangul_Banja, "Hangul_Banja"),
std::make_pair((int)Qt::Key_Hangul_PreHanja, "Hangul_PreHanja"),
std::make_pair((int)Qt::Key_Hangul_PostHanja, "Hangul_PostHanja"),
std::make_pair((int)Qt::Key_SingleCandidate, "SingleCandidate"),
std::make_pair((int)Qt::Key_MultipleCandidate, "MultipleCandidate"),
std::make_pair((int)Qt::Key_PreviousCandidate, "PreviousCandidate"),
std::make_pair((int)Qt::Key_Hangul_Special, "Hangul_Special"),
std::make_pair((int)Qt::Key_Mode_switch, "Mode_switch"),
std::make_pair((int)Qt::Key_Dead_Grave, "Dead_Grave"),
std::make_pair((int)Qt::Key_Dead_Acute, "Dead_Acute"),
std::make_pair((int)Qt::Key_Dead_Circumflex, "Dead_Circumflex"),
std::make_pair((int)Qt::Key_Dead_Tilde, "Dead_Tilde"),
std::make_pair((int)Qt::Key_Dead_Macron, "Dead_Macron"),
std::make_pair((int)Qt::Key_Dead_Breve, "Dead_Breve"),
std::make_pair((int)Qt::Key_Dead_Abovedot, "Dead_Abovedot"),
std::make_pair((int)Qt::Key_Dead_Diaeresis, "Dead_Diaeresis"),
std::make_pair((int)Qt::Key_Dead_Abovering, "Dead_Abovering"),
std::make_pair((int)Qt::Key_Dead_Doubleacute, "Dead_Doubleacute"),
std::make_pair((int)Qt::Key_Dead_Caron, "Dead_Caron"),
std::make_pair((int)Qt::Key_Dead_Cedilla, "Dead_Cedilla"),
std::make_pair((int)Qt::Key_Dead_Ogonek, "Dead_Ogonek"),
std::make_pair((int)Qt::Key_Dead_Iota, "Dead_Iota"),
std::make_pair((int)Qt::Key_Dead_Voiced_Sound, "Dead_Voiced_Sound"),
std::make_pair((int)Qt::Key_Dead_Semivoiced_Sound, "Dead_Semivoiced_Sound"),
std::make_pair((int)Qt::Key_Dead_Belowdot, "Dead_Belowdot"),
std::make_pair((int)Qt::Key_Dead_Hook, "Dead_Hook"),
std::make_pair((int)Qt::Key_Dead_Horn, "Dead_Horn"),
std::make_pair((int)Qt::Key_MediaLast, "MediaLast"),
std::make_pair((int)Qt::Key_Select, "Select"),
std::make_pair((int)Qt::Key_Yes, "Yes"),
std::make_pair((int)Qt::Key_No, "No"),
std::make_pair((int)Qt::Key_Cancel, "Cancel"),
std::make_pair((int)Qt::Key_Printer, "Printer"),
std::make_pair((int)Qt::Key_Execute, "Execute"),
std::make_pair((int)Qt::Key_Sleep, "Sleep"),
std::make_pair((int)Qt::Key_Play, "Play"),
std::make_pair((int)Qt::Key_Zoom, "Zoom"),
std::make_pair((int)Qt::Key_Exit, "Exit"),
std::make_pair((int)Qt::Key_Context1, "Context1"),
std::make_pair((int)Qt::Key_Context2, "Context2"),
std::make_pair((int)Qt::Key_Context3, "Context3"),
std::make_pair((int)Qt::Key_Context4, "Context4"),
std::make_pair((int)Qt::Key_Call, "Call"),
std::make_pair((int)Qt::Key_Hangup, "Hangup"),
std::make_pair((int)Qt::Key_Flip, "Flip"),
std::make_pair((int)Qt::Key_ToggleCallHangup, "ToggleCallHangup"),
std::make_pair((int)Qt::Key_VoiceDial, "VoiceDial"),
std::make_pair((int)Qt::Key_LastNumberRedial, "LastNumberRedial"),
std::make_pair((int)Qt::Key_Camera, "Camera"),
std::make_pair((int)Qt::Key_CameraFocus, "CameraFocus"),
std::make_pair(0, static_cast<const char*>(nullptr)),
};
}
| 35,367
|
C++
|
.cpp
| 730
| 38.487671
| 116
| 0.568739
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,985
|
intsetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/intsetting.cpp
|
#include "intsetting.hpp"
#include <limits>
#include <QLabel>
#include <QMutexLocker>
#include <QSpinBox>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "category.hpp"
#include "state.hpp"
CSMPrefs::IntSetting::IntSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mMin(0)
, mMax(std::numeric_limits<int>::max())
, mWidget(nullptr)
{
}
CSMPrefs::IntSetting& CSMPrefs::IntSetting::setRange(int min, int max)
{
mMin = min;
mMax = max;
return *this;
}
CSMPrefs::IntSetting& CSMPrefs::IntSetting::setMin(int min)
{
mMin = min;
return *this;
}
CSMPrefs::IntSetting& CSMPrefs::IntSetting::setMax(int max)
{
mMax = max;
return *this;
}
CSMPrefs::IntSetting& CSMPrefs::IntSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::IntSetting::makeWidgets(QWidget* parent)
{
QLabel* label = new QLabel(getLabel(), parent);
mWidget = new QSpinBox(parent);
mWidget->setRange(mMin, mMax);
mWidget->setValue(getValue());
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
label->setToolTip(tooltip);
mWidget->setToolTip(tooltip);
}
connect(mWidget, qOverload<int>(&QSpinBox::valueChanged), this, &IntSetting::valueChanged);
return SettingWidgets{ .mLabel = label, .mInput = mWidget };
}
void CSMPrefs::IntSetting::updateWidget()
{
if (mWidget)
mWidget->setValue(getValue());
}
void CSMPrefs::IntSetting::valueChanged(int value)
{
setValue(value);
getParent()->getState()->update(*this);
}
| 1,784
|
C++
|
.cpp
| 63
| 24.873016
| 104
| 0.708749
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,986
|
enumsetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/enumsetting.cpp
|
#include "enumsetting.hpp"
#include <QComboBox>
#include <QLabel>
#include <QMutexLocker>
#include <QString>
#include <algorithm>
#include <memory>
#include <apps/opencs/model/prefs/setting.hpp>
#include <components/settings/settings.hpp>
#include "category.hpp"
#include "state.hpp"
CSMPrefs::EnumSetting::EnumSetting(Category* parent, QMutex* mutex, std::string_view key, const QString& label,
std::span<const EnumValueView> values, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mValues(values)
, mWidget(nullptr)
{
}
CSMPrefs::EnumSetting& CSMPrefs::EnumSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::EnumSetting::makeWidgets(QWidget* parent)
{
QLabel* label = new QLabel(getLabel(), parent);
mWidget = new QComboBox(parent);
for (std::size_t i = 0; i < mValues.size(); ++i)
{
const EnumValueView& v = mValues[i];
mWidget->addItem(QString::fromUtf8(v.mValue.data(), static_cast<int>(v.mValue.size())));
if (!v.mTooltip.empty())
mWidget->setItemData(static_cast<int>(i),
QString::fromUtf8(v.mTooltip.data(), static_cast<int>(v.mTooltip.size())), Qt::ToolTipRole);
}
const std::string value = getValue();
const std::size_t index = std::find_if(mValues.begin(), mValues.end(), [&](const EnumValueView& v) {
return v.mValue == value;
}) - mValues.begin();
mWidget->setCurrentIndex(static_cast<int>(index));
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
label->setToolTip(tooltip);
}
connect(mWidget, qOverload<int>(&QComboBox::currentIndexChanged), this, &EnumSetting::valueChanged);
return SettingWidgets{ .mLabel = label, .mInput = mWidget };
}
void CSMPrefs::EnumSetting::updateWidget()
{
if (mWidget)
mWidget->setCurrentIndex(mWidget->findText(QString::fromStdString(getValue())));
}
void CSMPrefs::EnumSetting::valueChanged(int value)
{
if (value < 0 || static_cast<std::size_t>(value) >= mValues.size())
throw std::logic_error("Invalid enum setting \"" + getKey() + "\" value index: " + std::to_string(value));
setValue(std::string(mValues[value].mValue));
getParent()->getState()->update(*this);
}
| 2,349
|
C++
|
.cpp
| 60
| 34.683333
| 114
| 0.687528
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,987
|
coloursetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/coloursetting.cpp
|
#include "coloursetting.hpp"
#include <QLabel>
#include <QMutexLocker>
#include <QString>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "../../view/widget/coloreditor.hpp"
#include "category.hpp"
#include "state.hpp"
CSMPrefs::ColourSetting::ColourSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mWidget(nullptr)
{
}
CSMPrefs::ColourSetting& CSMPrefs::ColourSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::ColourSetting::makeWidgets(QWidget* parent)
{
QLabel* label = new QLabel(getLabel(), parent);
mWidget = new CSVWidget::ColorEditor(toColor(), parent);
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
label->setToolTip(tooltip);
mWidget->setToolTip(tooltip);
}
connect(mWidget, &CSVWidget::ColorEditor::pickingFinished, this, &ColourSetting::valueChanged);
return SettingWidgets{ .mLabel = label, .mInput = mWidget };
}
void CSMPrefs::ColourSetting::updateWidget()
{
if (mWidget)
mWidget->setColor(toColor());
}
void CSMPrefs::ColourSetting::valueChanged()
{
CSVWidget::ColorEditor& widget = dynamic_cast<CSVWidget::ColorEditor&>(*sender());
setValue(widget.color().name().toStdString());
getParent()->getState()->update(*this);
}
| 1,517
|
C++
|
.cpp
| 44
| 30.977273
| 104
| 0.72721
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,988
|
setting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/setting.cpp
|
#include "setting.hpp"
#include <QColor>
#include <QMutexLocker>
#include <components/settings/settings.hpp>
#include <components/settings/settingvalue.hpp>
#include "category.hpp"
#include "state.hpp"
QMutex* CSMPrefs::Setting::getMutex()
{
return mMutex;
}
CSMPrefs::Setting::Setting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: QObject(parent->getState())
, mParent(parent)
, mMutex(mutex)
, mKey(key)
, mLabel(label)
, mIndex(index)
{
}
const CSMPrefs::Category* CSMPrefs::Setting::getParent() const
{
return mParent;
}
const std::string& CSMPrefs::Setting::getKey() const
{
return mKey;
}
QColor CSMPrefs::Setting::toColor() const
{
// toString() handles lock
return QColor(QString::fromUtf8(toString().c_str()));
}
bool CSMPrefs::operator==(const Setting& setting, const std::string& key)
{
std::string fullKey = setting.getParent()->getKey() + "/" + setting.getKey();
return fullKey == key;
}
bool CSMPrefs::operator==(const std::string& key, const Setting& setting)
{
return setting == key;
}
bool CSMPrefs::operator!=(const Setting& setting, const std::string& key)
{
return !(setting == key);
}
bool CSMPrefs::operator!=(const std::string& key, const Setting& setting)
{
return !(key == setting);
}
| 1,349
|
C++
|
.cpp
| 51
| 23.862745
| 104
| 0.711284
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,989
|
subcategory.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/subcategory.cpp
|
#include "subcategory.hpp"
#include <QGridLayout>
namespace CSMPrefs
{
class Category;
Subcategory::Subcategory(Category* parent, QMutex* mutex, const QString& label, Settings::Index& index)
: Setting(parent, mutex, "", label, index)
{
}
SettingWidgets Subcategory::makeWidgets(QWidget* /*parent*/)
{
return SettingWidgets{ .mLabel = nullptr, .mInput = nullptr };
}
}
| 416
|
C++
|
.cpp
| 14
| 25.285714
| 107
| 0.688442
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,990
|
shortcutsetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/shortcutsetting.cpp
|
#include "shortcutsetting.hpp"
#include <QEvent>
#include <QKeyEvent>
#include <QLabel>
#include <QMouseEvent>
#include <QPushButton>
#include <QString>
#include <QWidget>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "shortcutmanager.hpp"
#include "state.hpp"
namespace CSMPrefs
{
ShortcutSetting::ShortcutSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mButton(nullptr)
, mEditorActive(false)
, mEditorPos(0)
{
for (int i = 0; i < MaxKeys; ++i)
{
mEditorKeys[i] = 0;
}
}
SettingWidgets ShortcutSetting::makeWidgets(QWidget* parent)
{
QKeySequence sequence;
State::get().getShortcutManager().getSequence(getKey(), sequence);
QString text = QString::fromUtf8(State::get().getShortcutManager().convertToString(sequence).c_str());
QLabel* label = new QLabel(getLabel(), parent);
QPushButton* widget = new QPushButton(text, parent);
widget->setCheckable(true);
widget->installEventFilter(this);
// right clicking on button sets shortcut to RMB, so context menu should not appear
widget->setContextMenuPolicy(Qt::PreventContextMenu);
mButton = widget;
connect(widget, &QPushButton::toggled, this, &ShortcutSetting::buttonToggled);
return SettingWidgets{ .mLabel = label, .mInput = widget };
}
void ShortcutSetting::updateWidget()
{
if (mButton)
{
const std::string shortcut = getValue();
QKeySequence sequence;
State::get().getShortcutManager().convertFromString(shortcut, sequence);
State::get().getShortcutManager().setSequence(getKey(), sequence);
resetState();
}
}
bool ShortcutSetting::eventFilter(QObject* target, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->isAutoRepeat())
return true;
int mod = keyEvent->modifiers();
int key = keyEvent->key();
return handleEvent(target, mod, key, true);
}
else if (event->type() == QEvent::KeyRelease)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->isAutoRepeat())
return true;
int mod = keyEvent->modifiers();
int key = keyEvent->key();
return handleEvent(target, mod, key, false);
}
else if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
int mod = mouseEvent->modifiers();
int key = mouseEvent->button();
return handleEvent(target, mod, key, true);
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
int mod = mouseEvent->modifiers();
int key = mouseEvent->button();
return handleEvent(target, mod, key, false);
}
else if (event->type() == QEvent::FocusOut)
{
resetState();
}
return false;
}
bool ShortcutSetting::handleEvent(QObject* target, int mod, int value, bool active)
{
// Modifiers are handled differently
const int Blacklist[] = { Qt::Key_Shift, Qt::Key_Control, Qt::Key_Meta, Qt::Key_Alt, Qt::Key_AltGr };
const size_t BlacklistSize = sizeof(Blacklist) / sizeof(int);
if (!mEditorActive)
{
if (value == Qt::RightButton && !active)
{
// Clear sequence
QKeySequence sequence = QKeySequence(0, 0, 0, 0);
storeValue(sequence);
resetState();
}
return false;
}
// Handle blacklist
for (size_t i = 0; i < BlacklistSize; ++i)
{
if (value == Blacklist[i])
return true;
}
if (!active || mEditorPos >= MaxKeys)
{
// Update key
QKeySequence sequence = QKeySequence(mEditorKeys[0], mEditorKeys[1], mEditorKeys[2], mEditorKeys[3]);
storeValue(sequence);
resetState();
}
else
{
if (mEditorPos == 0)
{
mEditorKeys[0] = mod | value;
}
else
{
mEditorKeys[mEditorPos] = value;
}
mEditorPos += 1;
}
return true;
}
void ShortcutSetting::storeValue(const QKeySequence& sequence)
{
State::get().getShortcutManager().setSequence(getKey(), sequence);
setValue(State::get().getShortcutManager().convertToString(sequence));
getParent()->getState()->update(*this);
}
void ShortcutSetting::resetState()
{
mButton->setChecked(false);
mEditorActive = false;
mEditorPos = 0;
for (int i = 0; i < MaxKeys; ++i)
{
mEditorKeys[i] = 0;
}
// Button text
QKeySequence sequence;
State::get().getShortcutManager().getSequence(getKey(), sequence);
QString text = QString::fromUtf8(State::get().getShortcutManager().convertToString(sequence).c_str());
mButton->setText(text);
}
void ShortcutSetting::buttonToggled(bool checked)
{
if (checked)
mButton->setText("Press keys or click here...");
mEditorActive = checked;
}
}
| 5,847
|
C++
|
.cpp
| 164
| 26.292683
| 113
| 0.582211
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,991
|
modifiersetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/modifiersetting.cpp
|
#include "modifiersetting.hpp"
#include <QEvent>
#include <QKeyEvent>
#include <QLabel>
#include <QMouseEvent>
#include <QPushButton>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "shortcutmanager.hpp"
#include "state.hpp"
class QObject;
class QWidget;
namespace CSMPrefs
{
ModifierSetting::ModifierSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mButton(nullptr)
, mEditorActive(false)
{
}
SettingWidgets ModifierSetting::makeWidgets(QWidget* parent)
{
int modifier = 0;
State::get().getShortcutManager().getModifier(getKey(), modifier);
QString text = QString::fromUtf8(State::get().getShortcutManager().convertToString(modifier).c_str());
QLabel* label = new QLabel(getLabel(), parent);
QPushButton* widget = new QPushButton(text, parent);
widget->setCheckable(true);
widget->installEventFilter(this);
// right clicking on button sets shortcut to RMB, so context menu should not appear
widget->setContextMenuPolicy(Qt::PreventContextMenu);
mButton = widget;
connect(widget, &QPushButton::toggled, this, &ModifierSetting::buttonToggled);
return SettingWidgets{ .mLabel = label, .mInput = widget };
}
void ModifierSetting::updateWidget()
{
if (mButton)
{
const std::string& shortcut = getValue();
int modifier;
State::get().getShortcutManager().convertFromString(shortcut, modifier);
State::get().getShortcutManager().setModifier(getKey(), modifier);
resetState();
}
}
bool ModifierSetting::eventFilter(QObject* target, QEvent* event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->isAutoRepeat())
return true;
int mod = keyEvent->modifiers();
int key = keyEvent->key();
return handleEvent(target, mod, key);
}
else if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
int mod = mouseEvent->modifiers();
int button = mouseEvent->button();
return handleEvent(target, mod, button);
}
else if (event->type() == QEvent::FocusOut)
{
resetState();
}
return false;
}
bool ModifierSetting::handleEvent(QObject* target, int mod, int value)
{
// For potential future exceptions
const int Blacklist[] = { 0 };
const size_t BlacklistSize = sizeof(Blacklist) / sizeof(int);
if (!mEditorActive)
{
if (value == Qt::RightButton)
{
// Clear modifier
int modifier = 0;
storeValue(modifier);
resetState();
}
return false;
}
// Handle blacklist
for (size_t i = 0; i < BlacklistSize; ++i)
{
if (value == Blacklist[i])
return true;
}
// Update modifier
int modifier = value;
storeValue(modifier);
resetState();
return true;
}
void ModifierSetting::storeValue(int modifier)
{
State::get().getShortcutManager().setModifier(getKey(), modifier);
setValue(State::get().getShortcutManager().convertToString(modifier));
getParent()->getState()->update(*this);
}
void ModifierSetting::resetState()
{
mButton->setChecked(false);
mEditorActive = false;
// Button text
int modifier = 0;
State::get().getShortcutManager().getModifier(getKey(), modifier);
QString text = QString::fromUtf8(State::get().getShortcutManager().convertToString(modifier).c_str());
mButton->setText(text);
}
void ModifierSetting::buttonToggled(bool checked)
{
if (checked)
mButton->setText("Press keys or click here...");
mEditorActive = checked;
}
}
| 4,357
|
C++
|
.cpp
| 123
| 26.878049
| 110
| 0.610291
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,992
|
shortcut.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/shortcut.cpp
|
#include "shortcut.hpp"
#include <cassert>
#include <exception>
#include <QAction>
#include <QWidget>
#include <components/debug/debuglog.hpp>
#include "shortcutmanager.hpp"
#include "state.hpp"
namespace CSMPrefs
{
Shortcut::Shortcut(const std::string& name, QWidget* parent)
: QObject(parent)
, mEnabled(true)
, mName(name)
, mModName("")
, mSecondaryMode(SM_Ignore)
, mModifier(0)
, mCurrentPos(0)
, mLastPos(0)
, mActivationStatus(AS_Inactive)
, mModifierStatus(false)
, mAction(nullptr)
{
assert(parent);
State::get().getShortcutManager().addShortcut(this);
State::get().getShortcutManager().getSequence(name, mSequence);
}
Shortcut::Shortcut(const std::string& name, const std::string& modName, QWidget* parent)
: QObject(parent)
, mEnabled(true)
, mName(name)
, mModName(modName)
, mSecondaryMode(SM_Ignore)
, mModifier(0)
, mCurrentPos(0)
, mLastPos(0)
, mActivationStatus(AS_Inactive)
, mModifierStatus(false)
, mAction(nullptr)
{
assert(parent);
State::get().getShortcutManager().addShortcut(this);
State::get().getShortcutManager().getSequence(name, mSequence);
State::get().getShortcutManager().getModifier(modName, mModifier);
}
Shortcut::Shortcut(const std::string& name, const std::string& modName, SecondaryMode secMode, QWidget* parent)
: QObject(parent)
, mEnabled(true)
, mName(name)
, mModName(modName)
, mSecondaryMode(secMode)
, mModifier(0)
, mCurrentPos(0)
, mLastPos(0)
, mActivationStatus(AS_Inactive)
, mModifierStatus(false)
, mAction(nullptr)
{
assert(parent);
State::get().getShortcutManager().addShortcut(this);
State::get().getShortcutManager().getSequence(name, mSequence);
State::get().getShortcutManager().getModifier(modName, mModifier);
}
Shortcut::~Shortcut()
{
try
{
State::get().getShortcutManager().removeShortcut(this);
}
catch (const std::exception& e)
{
Log(Debug::Error) << "Error in the destructor: " << e.what();
}
}
bool Shortcut::isEnabled() const
{
return mEnabled;
}
const std::string& Shortcut::getName() const
{
return mName;
}
const std::string& Shortcut::getModifierName() const
{
return mModName;
}
Shortcut::SecondaryMode Shortcut::getSecondaryMode() const
{
return mSecondaryMode;
}
const QKeySequence& Shortcut::getSequence() const
{
return mSequence;
}
int Shortcut::getModifier() const
{
return mModifier;
}
int Shortcut::getPosition() const
{
return mCurrentPos;
}
int Shortcut::getLastPosition() const
{
return mLastPos;
}
Shortcut::ActivationStatus Shortcut::getActivationStatus() const
{
return mActivationStatus;
}
bool Shortcut::getModifierStatus() const
{
return mModifierStatus;
}
void Shortcut::enable(bool state)
{
mEnabled = state;
}
void Shortcut::setSequence(const QKeySequence& sequence)
{
mSequence = sequence;
mCurrentPos = 0;
mLastPos = sequence.count() - 1;
if (mAction)
{
mAction->setText(mActionText + "\t" + State::get().getShortcutManager().convertToString(mSequence).data());
}
}
void Shortcut::setModifier(int modifier)
{
mModifier = modifier;
}
void Shortcut::setPosition(int pos)
{
mCurrentPos = pos;
}
void Shortcut::setActivationStatus(ActivationStatus status)
{
mActivationStatus = status;
}
void Shortcut::setModifierStatus(bool status)
{
mModifierStatus = status;
}
void Shortcut::associateAction(QAction* action)
{
if (mAction)
{
mAction->setText(mActionText);
disconnect(this, qOverload<>(&Shortcut::activated), mAction, &QAction::trigger);
disconnect(mAction, &QAction::destroyed, this, &Shortcut::actionDeleted);
}
mAction = action;
if (mAction)
{
mActionText = mAction->text();
mAction->setText(mActionText + "\t" + State::get().getShortcutManager().convertToString(mSequence).data());
connect(this, qOverload<>(&Shortcut::activated), mAction, &QAction::trigger);
connect(mAction, &QAction::destroyed, this, &Shortcut::actionDeleted);
}
}
void Shortcut::signalActivated(bool state)
{
emit activated(state);
}
void Shortcut::signalActivated()
{
emit activated();
}
void Shortcut::signalSecondary(bool state)
{
emit secondary(state);
}
void Shortcut::signalSecondary()
{
emit secondary();
}
QString Shortcut::toString() const
{
return QString(State::get().getShortcutManager().convertToString(mSequence, mModifier).data());
}
void Shortcut::actionDeleted()
{
mAction = nullptr;
}
}
| 5,331
|
C++
|
.cpp
| 186
| 21.456989
| 119
| 0.614842
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,993
|
doublesetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/doublesetting.cpp
|
#include "doublesetting.hpp"
#include <limits>
#include <QDoubleSpinBox>
#include <QLabel>
#include <QMutexLocker>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "category.hpp"
#include "state.hpp"
CSMPrefs::DoubleSetting::DoubleSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mPrecision(2)
, mMin(0)
, mMax(std::numeric_limits<double>::max())
, mWidget(nullptr)
{
}
CSMPrefs::DoubleSetting& CSMPrefs::DoubleSetting::setPrecision(int precision)
{
mPrecision = precision;
return *this;
}
CSMPrefs::DoubleSetting& CSMPrefs::DoubleSetting::setRange(double min, double max)
{
mMin = min;
mMax = max;
return *this;
}
CSMPrefs::DoubleSetting& CSMPrefs::DoubleSetting::setMin(double min)
{
mMin = min;
return *this;
}
CSMPrefs::DoubleSetting& CSMPrefs::DoubleSetting::setMax(double max)
{
mMax = max;
return *this;
}
CSMPrefs::DoubleSetting& CSMPrefs::DoubleSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::DoubleSetting::makeWidgets(QWidget* parent)
{
QLabel* label = new QLabel(getLabel(), parent);
mWidget = new QDoubleSpinBox(parent);
mWidget->setDecimals(mPrecision);
mWidget->setRange(mMin, mMax);
mWidget->setValue(getValue());
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
label->setToolTip(tooltip);
mWidget->setToolTip(tooltip);
}
connect(mWidget, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &DoubleSetting::valueChanged);
return SettingWidgets{ .mLabel = label, .mInput = mWidget };
}
void CSMPrefs::DoubleSetting::updateWidget()
{
if (mWidget)
mWidget->setValue(getValue());
}
void CSMPrefs::DoubleSetting::valueChanged(double value)
{
setValue(value);
getParent()->getState()->update(*this);
}
| 2,055
|
C++
|
.cpp
| 70
| 25.914286
| 107
| 0.724822
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,994
|
state.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/state.cpp
|
#include "state.hpp"
#include <QColor>
#include <QKeySequence>
#include <filesystem>
#include <sstream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <apps/opencs/model/prefs/category.hpp>
#include <apps/opencs/model/prefs/enumsetting.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include <apps/opencs/model/prefs/shortcutmanager.hpp>
#include <apps/opencs/model/prefs/subcategory.hpp>
#include <components/settings/categories.hpp>
#include <components/settings/settings.hpp>
#include "boolsetting.hpp"
#include "coloursetting.hpp"
#include "doublesetting.hpp"
#include "intsetting.hpp"
#include "modifiersetting.hpp"
#include "shortcutsetting.hpp"
#include "stringsetting.hpp"
#include "values.hpp"
CSMPrefs::State* CSMPrefs::State::sThis = nullptr;
void CSMPrefs::State::declare()
{
declareCategory("Windows");
declareInt(mValues->mWindows.mDefaultWidth, "Default Window Width")
.setTooltip("Newly opened top-level windows will open with this width.")
.setMin(80);
declareInt(mValues->mWindows.mDefaultHeight, "Default Window Height")
.setTooltip("Newly opened top-level windows will open with this height.")
.setMin(80);
declareBool(mValues->mWindows.mShowStatusbar, "Show Status Bar")
.setTooltip(
"Whether a newly open top level window will show status bars. "
" Note that this does not affect existing windows.");
declareBool(mValues->mWindows.mReuse, "Reuse Subviews")
.setTooltip(
"When a new subview is requested and a matching subview already exists, reuse the existing subview.");
declareInt(mValues->mWindows.mMaxSubviews, "Maximum Number of Subviews per Top-Level Window")
.setTooltip(
"If the maximum number is reached and a new subview is opened "
"it will be placed into a new top-level window.")
.setRange(1, 256);
declareBool(mValues->mWindows.mHideSubview, "Hide Single Subview")
.setTooltip(
"When a view contains only a single subview, hide the subview title "
"bar and if this subview is closed also close the view (unless it is the last "
"view for this document)");
declareInt(mValues->mWindows.mMinimumWidth, "Minimum Subview Width")
.setTooltip("Minimum width of subviews.")
.setRange(50, 10000);
declareEnum(mValues->mWindows.mMainwindowScrollbar, "Main Window Horizontal Scrollbar Mode");
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
declareBool(mValues->mWindows.mGrowLimit, "Grow Limit Screen")
.setTooltip(
"When \"Grow then Scroll\" option is selected, the window size grows to"
" the width of the virtual desktop. \nIf this option is selected the the window growth"
"is limited to the current screen.");
#endif
declareCategory("Records");
declareEnum(mValues->mRecords.mStatusFormat, "Modification Status Display Format");
declareEnum(mValues->mRecords.mTypeFormat, "ID Type Display Format");
declareCategory("ID Tables");
declareEnum(mValues->mIdTables.mDouble, "Double Click");
declareEnum(mValues->mIdTables.mDoubleS, "Shift Double Click");
declareEnum(mValues->mIdTables.mDoubleC, "Control Double Click");
declareEnum(mValues->mIdTables.mDoubleSc, "Shift Control Double Click");
declareEnum(mValues->mIdTables.mJumpToAdded, "Action on Adding or Cloning a Record");
declareBool(
mValues->mIdTables.mExtendedConfig, "Manually Specify Affected Record Types for an Extended Delete/Revert")
.setTooltip(
"Delete and revert commands have an extended form that also affects "
"associated records.\n\n"
"If this option is enabled, types of affected records are selected "
"manually before a command execution.\nOtherwise, all associated "
"records are deleted/reverted immediately.");
declareBool(mValues->mIdTables.mSubviewNewWindow, "Open Record in a New Window")
.setTooltip(
"When editing a record, open the view in a new window,"
" rather than docked in the main view.");
declareInt(mValues->mIdTables.mFilterDelay, "Filter Apply Delay (ms)");
declareCategory("ID Dialogues");
declareBool(mValues->mIdDialogues.mToolbar, "Show Toolbar");
declareCategory("Reports");
declareEnum(mValues->mReports.mDouble, "Double Click");
declareEnum(mValues->mReports.mDoubleS, "Shift Double Click");
declareEnum(mValues->mReports.mDoubleC, "Control Double Click");
declareEnum(mValues->mReports.mDoubleSc, "Shift Control Double Click");
declareBool(mValues->mReports.mIgnoreBaseRecords, "Ignore Base Records in Verifier");
declareCategory("Search & Replace");
declareInt(mValues->mSearchAndReplace.mCharBefore, "Max Characters Before the Search String")
.setTooltip("Maximum number of characters to display in the search result before the searched text");
declareInt(mValues->mSearchAndReplace.mCharAfter, "Max Characters After the Search String")
.setTooltip("Maximum number of characters to display in the search result after the searched text");
declareBool(mValues->mSearchAndReplace.mAutoDelete, "Delete Row from the Result Table After Replace");
declareCategory("Scripts");
declareBool(mValues->mScripts.mShowLinenum, "Show Line Numbers")
.setTooltip(
"Show line numbers to the left of the script editor window."
"The current row and column numbers of the text cursor are shown at the bottom.");
declareBool(mValues->mScripts.mWrapLines, "Wrap Lines")
.setTooltip("Wrap lines that are longer than the width of the script editor.");
declareBool(mValues->mScripts.mMonoFont, "Use Monospace Font");
declareInt(mValues->mScripts.mTabWidth, "Tab Width")
.setTooltip("Number of characters for tab width")
.setRange(1, 10);
declareEnum(mValues->mScripts.mWarnings, "Warning Mode");
declareBool(mValues->mScripts.mToolbar, "Show Toolbar");
declareInt(mValues->mScripts.mCompileDelay, "Source Error Update Delay (ms)").setRange(0, 10000);
declareInt(mValues->mScripts.mErrorHeight, "Initial Error Panel Height").setRange(100, 10000);
declareBool(mValues->mScripts.mHighlightOccurrences, "Highlight Selected Name Occurrences");
declareColour(mValues->mScripts.mColourHighlight, "Highlight Colour: Selected Name Occurrences");
declareColour(mValues->mScripts.mColourInt, "Highlight Colour: Integer Literals");
declareColour(mValues->mScripts.mColourFloat, "Highlight Colour: Float Literals");
declareColour(mValues->mScripts.mColourName, "Highlight Colour: Names");
declareColour(mValues->mScripts.mColourKeyword, "Highlight Colour: Keywords");
declareColour(mValues->mScripts.mColourSpecial, "Highlight Colour: Special Characters");
declareColour(mValues->mScripts.mColourComment, "Highlight Colour: Comments");
declareColour(mValues->mScripts.mColourId, "Highlight Colour: IDs");
declareCategory("General Input");
declareBool(mValues->mGeneralInput.mCycle, "Cyclic Next/Previous")
.setTooltip(
"When using next/previous functions at the last/first item of a "
"list go to the first/last item");
declareCategory("3D Scene Input");
declareDouble(mValues->mSceneInput.mNaviWheelFactor, "Camera Zoom Sensitivity").setRange(-100.0, 100.0);
declareDouble(mValues->mSceneInput.mSNaviSensitivity, "Secondary Camera Movement Sensitivity")
.setRange(-1000.0, 1000.0);
declareDouble(mValues->mSceneInput.mPNaviFreeSensitivity, "Free Camera Sensitivity")
.setPrecision(5)
.setRange(0.0, 1.0);
declareBool(mValues->mSceneInput.mPNaviFreeInvert, "Invert Free Camera Mouse Input");
declareDouble(mValues->mSceneInput.mNaviFreeLinSpeed, "Free Camera Linear Speed").setRange(1.0, 10000.0);
declareDouble(mValues->mSceneInput.mNaviFreeRotSpeed, "Free Camera Rotational Speed").setRange(0.001, 6.28);
declareDouble(mValues->mSceneInput.mNaviFreeSpeedMult, "Free Camera Speed Multiplier (from Modifier)")
.setRange(0.001, 1000.0);
declareDouble(mValues->mSceneInput.mPNaviOrbitSensitivity, "Orbit Camera Sensitivity")
.setPrecision(5)
.setRange(0.0, 1.0);
declareBool(mValues->mSceneInput.mPNaviOrbitInvert, "Invert Orbit Camera Mouse Input");
declareDouble(mValues->mSceneInput.mNaviOrbitRotSpeed, "Orbital Camera Rotational Speed").setRange(0.001, 6.28);
declareDouble(mValues->mSceneInput.mNaviOrbitSpeedMult, "Orbital Camera Speed Multiplier (from Modifier)")
.setRange(0.001, 1000.0);
declareBool(mValues->mSceneInput.mNaviOrbitConstRoll, "Keep Camera Roll Constant for Orbital Camera");
declareBool(mValues->mSceneInput.mContextSelect, "Context Sensitive Selection");
declareDouble(mValues->mSceneInput.mDragFactor, "Dragging Mouse Sensitivity").setRange(0.001, 100.0);
declareDouble(mValues->mSceneInput.mDragWheelFactor, "Dragging Mouse Wheel Sensitivity").setRange(0.001, 100.0);
declareDouble(mValues->mSceneInput.mDragShiftFactor, "Dragging Shift-Acceleration Factor")
.setTooltip("Acceleration factor during drag operations while holding down shift")
.setRange(0.001, 100.0);
declareDouble(mValues->mSceneInput.mRotateFactor, "Free rotation factor").setPrecision(4).setRange(0.0001, 0.1);
declareCategory("Rendering");
declareInt(mValues->mRendering.mFramerateLimit, "FPS Limit")
.setTooltip("Framerate limit in 3D preview windows. Zero value means \"unlimited\".")
.setRange(0, 10000);
declareInt(mValues->mRendering.mCameraFov, "Camera FOV").setRange(10, 170);
declareBool(mValues->mRendering.mCameraOrtho, "Orthographic Projection for Camera");
declareInt(mValues->mRendering.mCameraOrthoSize, "Orthographic Projection Size Parameter")
.setTooltip("Size of the orthographic frustum, greater value will allow the camera to see more of the world.")
.setRange(10, 10000);
declareDouble(mValues->mRendering.mObjectMarkerAlpha, "Object Marker Transparency").setPrecision(2).setRange(0, 1);
declareBool(mValues->mRendering.mSceneUseGradient, "Use Gradient Background");
declareColour(mValues->mRendering.mSceneDayBackgroundColour, "Day Background Colour");
declareColour(mValues->mRendering.mSceneDayGradientColour, "Day Gradient Colour")
.setTooltip(
"Sets the gradient color to use in conjunction with the day background color. Ignored if "
"the gradient option is disabled.");
declareColour(mValues->mRendering.mSceneBrightBackgroundColour, "Scene Bright Background Colour");
declareColour(mValues->mRendering.mSceneBrightGradientColour, "Scene Bright Gradient Colour")
.setTooltip(
"Sets the gradient color to use in conjunction with the bright background color. Ignored if "
"the gradient option is disabled.");
declareColour(mValues->mRendering.mSceneNightBackgroundColour, "Scene Night Background Colour");
declareColour(mValues->mRendering.mSceneNightGradientColour, "Scene Night Gradient Colour")
.setTooltip(
"Sets the gradient color to use in conjunction with the night background color. Ignored if "
"the gradient option is disabled.");
declareBool(mValues->mRendering.mSceneDayNightSwitchNodes, "Use Day/Night Switch Nodes");
declareCategory("Tooltips");
declareBool(mValues->mTooltips.mScene, "Show Tooltips in 3D Scenes");
declareBool(mValues->mTooltips.mSceneHideBasic, "Hide Basic 3D Scene Tooltips");
declareInt(mValues->mTooltips.mSceneDelay, "Tooltip Delay (ms)").setMin(1);
declareCategory("3D Scene Editing");
declareDouble(mValues->mSceneEditing.mGridsnapMovement, "Grid Snap Size");
declareDouble(mValues->mSceneEditing.mGridsnapRotation, "Angle Snap Size");
declareDouble(mValues->mSceneEditing.mGridsnapScale, "Scale Snap Size");
declareInt(mValues->mSceneEditing.mDistance, "Drop Distance")
.setTooltip(
"If the dropped instance cannot be placed against another object at the "
"insertion point, it will be placed at this distance from the insertion point.");
declareEnum(mValues->mSceneEditing.mOutsideDrop, "Instance Dropping Outside of Cells");
declareEnum(mValues->mSceneEditing.mOutsideVisibleDrop, "Instance Dropping Outside of Visible Cells");
declareEnum(mValues->mSceneEditing.mOutsideLandedit, "Terrain Editing Outside of Cells")
.setTooltip("Behaviour of terrain editing if land editing brush reaches an area without a cell record.");
declareEnum(mValues->mSceneEditing.mOutsideVisibleLandedit, "Terrain Editing Outside of Visible Cells")
.setTooltip(
"Behaviour of terrain editing if land editing brush reaches an area that is not currently visible.");
declareInt(mValues->mSceneEditing.mTexturebrushMaximumsize, "Maximum Texture Brush Size").setMin(1);
declareInt(mValues->mSceneEditing.mShapebrushMaximumsize, "Maximum Height Edit Brush Size")
.setTooltip("Setting for the slider range of brush size in terrain height editing.")
.setMin(1);
declareBool(mValues->mSceneEditing.mLandeditPostSmoothpainting, "Smooth Land after Height Painting")
.setTooltip("Smooth the normally bumpy results of raise and lower tools.");
declareDouble(mValues->mSceneEditing.mLandeditPostSmoothstrength, "Post-Edit Smoothing Strength")
.setTooltip(
"Smoothing strength for Smooth Land after Height Painting setting. "
"Negative values may be used to invert the effect and make the terrain rougher.")
.setMin(-1)
.setMax(1);
declareBool(mValues->mSceneEditing.mOpenListView, "Open Action Shows Instances Table")
.setTooltip(
"Opening an instance from the scene view will open the instances table instead of the record view for that "
"instance.");
declareEnum(mValues->mSceneEditing.mPrimarySelectAction, "Primary Select Action")
.setTooltip(
"Selection can be chosen between select only, add to selection, remove from selection and invert "
"selection.");
declareEnum(mValues->mSceneEditing.mSecondarySelectAction, "Secondary Select Action")
.setTooltip(
"Selection can be chosen between select only, add to selection, remove from selection and invert "
"selection.");
declareCategory("Key Bindings");
declareSubcategory("Document");
declareShortcut(mValues->mKeyBindings.mDocumentFileNewgame, "New Game");
declareShortcut(mValues->mKeyBindings.mDocumentFileNewaddon, "New Addon");
declareShortcut(mValues->mKeyBindings.mDocumentFileOpen, "Open");
declareShortcut(mValues->mKeyBindings.mDocumentFileSave, "Save");
declareShortcut(mValues->mKeyBindings.mDocumentHelpHelp, "Help");
declareShortcut(mValues->mKeyBindings.mDocumentHelpTutorial, "Tutorial");
declareShortcut(mValues->mKeyBindings.mDocumentFileVerify, "Verify");
declareShortcut(mValues->mKeyBindings.mDocumentFileMerge, "Merge");
declareShortcut(mValues->mKeyBindings.mDocumentFileErrorlog, "Open Load Error Log");
declareShortcut(mValues->mKeyBindings.mDocumentFileMetadata, "Meta Data");
declareShortcut(mValues->mKeyBindings.mDocumentFileClose, "Close Document");
declareShortcut(mValues->mKeyBindings.mDocumentFileExit, "Exit Application");
declareShortcut(mValues->mKeyBindings.mDocumentEditUndo, "Undo");
declareShortcut(mValues->mKeyBindings.mDocumentEditRedo, "Redo");
declareShortcut(mValues->mKeyBindings.mDocumentEditPreferences, "Open Preferences");
declareShortcut(mValues->mKeyBindings.mDocumentEditSearch, "Search");
declareShortcut(mValues->mKeyBindings.mDocumentViewNewview, "New View");
declareShortcut(mValues->mKeyBindings.mDocumentViewStatusbar, "Toggle Status Bar");
declareShortcut(mValues->mKeyBindings.mDocumentViewFilters, "Open Filter List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldRegions, "Open Region List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldCells, "Open Cell List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldReferencables, "Open Object List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldReferences, "Open Instance List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldLands, "Open Lands List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldLandtextures, "Open Land Textures List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldPathgrid, "Open Pathgrid List");
declareShortcut(mValues->mKeyBindings.mDocumentWorldRegionmap, "Open Region Map");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsGlobals, "Open Global List");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsGamesettings, "Open Game Settings");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsScripts, "Open Script List");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsSpells, "Open Spell List");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsEnchantments, "Open Enchantment List");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsMagiceffects, "Open Magic Effect List");
declareShortcut(mValues->mKeyBindings.mDocumentMechanicsStartscripts, "Open Start Script List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterSkills, "Open Skill List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterClasses, "Open Class List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterFactions, "Open Faction List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterRaces, "Open Race List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterBirthsigns, "Open Birthsign List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterTopics, "Open Topic List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterJournals, "Open Journal List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterTopicinfos, "Open Topic Info List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterJournalinfos, "Open Journal Info List");
declareShortcut(mValues->mKeyBindings.mDocumentCharacterBodyparts, "Open Body Part List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsReload, "Reload Assets");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsSounds, "Open Sound Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsSoundgens, "Open Sound Generator List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsMeshes, "Open Mesh Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsIcons, "Open Icon Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsMusic, "Open Music Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsSoundres, "Open Sound File List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsTextures, "Open Texture Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentAssetsVideos, "Open Video Asset List");
declareShortcut(mValues->mKeyBindings.mDocumentDebugRun, "Run Debug");
declareShortcut(mValues->mKeyBindings.mDocumentDebugShutdown, "Stop Debug");
declareShortcut(mValues->mKeyBindings.mDocumentDebugProfiles, "Debug Profiles");
declareShortcut(mValues->mKeyBindings.mDocumentDebugRunlog, "Open Run Log");
declareSubcategory("Table");
declareShortcut(mValues->mKeyBindings.mTableEdit, "Edit Record");
declareShortcut(mValues->mKeyBindings.mTableAdd, "Add Row/Record");
declareShortcut(mValues->mKeyBindings.mTableClone, "Clone Record");
declareShortcut(mValues->mKeyBindings.mTouchRecord, "Touch Record");
declareShortcut(mValues->mKeyBindings.mTableRevert, "Revert Record");
declareShortcut(mValues->mKeyBindings.mTableRemove, "Remove Row/Record");
declareShortcut(mValues->mKeyBindings.mTableMoveup, "Move Record Up");
declareShortcut(mValues->mKeyBindings.mTableMovedown, "Move Record Down");
declareShortcut(mValues->mKeyBindings.mTableView, "View Record");
declareShortcut(mValues->mKeyBindings.mTablePreview, "Preview Record");
declareShortcut(mValues->mKeyBindings.mTableExtendeddelete, "Extended Record Deletion");
declareShortcut(mValues->mKeyBindings.mTableExtendedrevert, "Extended Record Revertion");
declareSubcategory("Report Table");
declareShortcut(mValues->mKeyBindings.mReporttableShow, "Show Report");
declareShortcut(mValues->mKeyBindings.mReporttableRemove, "Remove Report");
declareShortcut(mValues->mKeyBindings.mReporttableReplace, "Replace Report");
declareShortcut(mValues->mKeyBindings.mReporttableRefresh, "Refresh Report");
declareSubcategory("Scene");
declareShortcut(mValues->mKeyBindings.mSceneNaviPrimary, "Camera Rotation From Mouse Movement");
declareShortcut(mValues->mKeyBindings.mSceneNaviSecondary, "Camera Translation From Mouse Movement");
declareShortcut(mValues->mKeyBindings.mSceneOpenPrimary, "Primary Open");
declareShortcut(mValues->mKeyBindings.mSceneEditPrimary, "Primary Edit");
declareShortcut(mValues->mKeyBindings.mSceneEditSecondary, "Secondary Edit");
declareShortcut(mValues->mKeyBindings.mSceneSelectPrimary, "Primary Select");
declareShortcut(mValues->mKeyBindings.mSceneSelectSecondary, "Secondary Select");
declareShortcut(mValues->mKeyBindings.mSceneSelectTertiary, "Tertiary Select");
declareModifier(mValues->mKeyBindings.mSceneSpeedModifier, "Speed Modifier");
declareShortcut(mValues->mKeyBindings.mSceneDelete, "Delete Instance");
declareShortcut(mValues->mKeyBindings.mSceneInstanceDropTerrain, "Drop to Terrain Level");
declareShortcut(mValues->mKeyBindings.mSceneInstanceDropCollision, "Drop to Collision");
declareShortcut(mValues->mKeyBindings.mSceneInstanceDropTerrainSeparately, "Drop to Terrain Level Separately");
declareShortcut(mValues->mKeyBindings.mSceneInstanceDropCollisionSeparately, "Drop to Collision Separately");
declareShortcut(mValues->mKeyBindings.mSceneLoadCamCell, "Load Camera Cell");
declareShortcut(mValues->mKeyBindings.mSceneLoadCamEastcell, "Load East Cell");
declareShortcut(mValues->mKeyBindings.mSceneLoadCamNorthcell, "Load North Cell");
declareShortcut(mValues->mKeyBindings.mSceneLoadCamWestcell, "Load West Cell");
declareShortcut(mValues->mKeyBindings.mSceneLoadCamSouthcell, "Load South Cell");
declareShortcut(mValues->mKeyBindings.mSceneEditAbort, "Abort");
declareShortcut(mValues->mKeyBindings.mSceneFocusToolbar, "Toggle Toolbar Focus");
declareShortcut(mValues->mKeyBindings.mSceneRenderStats, "Debug Rendering Stats");
declareShortcut(mValues->mKeyBindings.mSceneDuplicate, "Duplicate Instance");
declareShortcut(mValues->mKeyBindings.mSceneClearSelection, "Clear Selection");
declareShortcut(mValues->mKeyBindings.mSceneUnhideAll, "Unhide All Objects");
declareShortcut(mValues->mKeyBindings.mSceneToggleVisibility, "Toggle Selection Visibility");
declareShortcut(mValues->mKeyBindings.mSceneGroup0, "Selection Group 0");
declareShortcut(mValues->mKeyBindings.mSceneSave0, "Save Group 0");
declareShortcut(mValues->mKeyBindings.mSceneGroup1, "Select Group 1");
declareShortcut(mValues->mKeyBindings.mSceneSave1, "Save Group 1");
declareShortcut(mValues->mKeyBindings.mSceneGroup2, "Select Group 2");
declareShortcut(mValues->mKeyBindings.mSceneSave2, "Save Group 2");
declareShortcut(mValues->mKeyBindings.mSceneGroup3, "Select Group 3");
declareShortcut(mValues->mKeyBindings.mSceneSave3, "Save Group 3");
declareShortcut(mValues->mKeyBindings.mSceneGroup4, "Select Group 4");
declareShortcut(mValues->mKeyBindings.mSceneSave4, "Save Group 4");
declareShortcut(mValues->mKeyBindings.mSceneGroup5, "Selection Group 5");
declareShortcut(mValues->mKeyBindings.mSceneSave5, "Save Group 5");
declareShortcut(mValues->mKeyBindings.mSceneGroup6, "Selection Group 6");
declareShortcut(mValues->mKeyBindings.mSceneSave6, "Save Group 6");
declareShortcut(mValues->mKeyBindings.mSceneGroup7, "Selection Group 7");
declareShortcut(mValues->mKeyBindings.mSceneSave7, "Save Group 7");
declareShortcut(mValues->mKeyBindings.mSceneGroup8, "Selection Group 8");
declareShortcut(mValues->mKeyBindings.mSceneSave8, "Save Group 8");
declareShortcut(mValues->mKeyBindings.mSceneGroup9, "Selection Group 9");
declareShortcut(mValues->mKeyBindings.mSceneSave9, "Save Group 9");
declareShortcut(mValues->mKeyBindings.mSceneAxisX, "X Axis Movement Lock");
declareShortcut(mValues->mKeyBindings.mSceneAxisY, "Y Axis Movement Lock");
declareShortcut(mValues->mKeyBindings.mSceneAxisZ, "Z Axis Movement Lock");
declareShortcut(mValues->mKeyBindings.mSceneMoveSubmode, "Move Object Submode");
declareShortcut(mValues->mKeyBindings.mSceneScaleSubmode, "Scale Object Submode");
declareShortcut(mValues->mKeyBindings.mSceneRotateSubmode, "Rotate Object Submode");
declareShortcut(mValues->mKeyBindings.mSceneCameraCycle, "Cycle Camera Mode");
declareSubcategory("1st/Free Camera");
declareShortcut(mValues->mKeyBindings.mFreeForward, "Forward");
declareShortcut(mValues->mKeyBindings.mFreeBackward, "Backward");
declareShortcut(mValues->mKeyBindings.mFreeLeft, "Left");
declareShortcut(mValues->mKeyBindings.mFreeRight, "Right");
declareShortcut(mValues->mKeyBindings.mFreeRollLeft, "Roll Left");
declareShortcut(mValues->mKeyBindings.mFreeRollRight, "Roll Right");
declareShortcut(mValues->mKeyBindings.mFreeSpeedMode, "Toggle Speed Mode");
declareSubcategory("Orbit Camera");
declareShortcut(mValues->mKeyBindings.mOrbitUp, "Up");
declareShortcut(mValues->mKeyBindings.mOrbitDown, "Down");
declareShortcut(mValues->mKeyBindings.mOrbitLeft, "Left");
declareShortcut(mValues->mKeyBindings.mOrbitRight, "Right");
declareShortcut(mValues->mKeyBindings.mOrbitRollLeft, "Roll Left");
declareShortcut(mValues->mKeyBindings.mOrbitRollRight, "Roll Right");
declareShortcut(mValues->mKeyBindings.mOrbitSpeedMode, "Toggle Speed Mode");
declareShortcut(mValues->mKeyBindings.mOrbitCenterSelection, "Center On Selected");
declareSubcategory("Script Editor");
declareShortcut(mValues->mKeyBindings.mScriptEditorComment, "Comment Selection");
declareShortcut(mValues->mKeyBindings.mScriptEditorUncomment, "Uncomment Selection");
declareCategory("Models");
declareString(mValues->mModels.mBaseanim, "Base Animations").setTooltip("Third person base model and animations");
declareString(mValues->mModels.mBaseanimkna, "Base Animations, Beast")
.setTooltip("Third person beast race base model and animations");
declareString(mValues->mModels.mBaseanimfemale, "Base Animations, Female")
.setTooltip("Third person female base model and animations");
declareString(mValues->mModels.mWolfskin, "Base Animations, Werewolf").setTooltip("Third person werewolf skin");
}
void CSMPrefs::State::declareCategory(const std::string& key)
{
std::map<std::string, Category>::iterator iter = mCategories.find(key);
if (iter != mCategories.end())
{
mCurrentCategory = iter;
}
else
{
mCurrentCategory = mCategories.insert(std::make_pair(key, Category(this, key))).first;
}
}
CSMPrefs::IntSetting& CSMPrefs::State::declareInt(Settings::SettingValue<int>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::IntSetting* setting
= new CSMPrefs::IntSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::DoubleSetting& CSMPrefs::State::declareDouble(Settings::SettingValue<double>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::DoubleSetting* setting
= new CSMPrefs::DoubleSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::BoolSetting& CSMPrefs::State::declareBool(Settings::SettingValue<bool>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::BoolSetting* setting
= new CSMPrefs::BoolSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::EnumSetting& CSMPrefs::State::declareEnum(EnumSettingValue& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::EnumSetting* setting = new CSMPrefs::EnumSetting(
&mCurrentCategory->second, &mMutex, value.getValue().mName, label, value.getEnumValues(), *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::ColourSetting& CSMPrefs::State::declareColour(
Settings::SettingValue<std::string>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::ColourSetting* setting
= new CSMPrefs::ColourSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::ShortcutSetting& CSMPrefs::State::declareShortcut(
Settings::SettingValue<std::string>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
// Setup with actual data
QKeySequence sequence;
getShortcutManager().convertFromString(value, sequence);
getShortcutManager().setSequence(value.mName, sequence);
CSMPrefs::ShortcutSetting* setting
= new CSMPrefs::ShortcutSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::StringSetting& CSMPrefs::State::declareString(
Settings::SettingValue<std::string>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
CSMPrefs::StringSetting* setting
= new CSMPrefs::StringSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
CSMPrefs::ModifierSetting& CSMPrefs::State::declareModifier(
Settings::SettingValue<std::string>& value, const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
// Setup with actual data
int modifier;
getShortcutManager().convertFromString(value.get(), modifier);
getShortcutManager().setModifier(value.mName, modifier);
CSMPrefs::ModifierSetting* setting
= new CSMPrefs::ModifierSetting(&mCurrentCategory->second, &mMutex, value.mName, label, *mIndex);
mCurrentCategory->second.addSetting(setting);
return *setting;
}
void CSMPrefs::State::declareSubcategory(const QString& label)
{
if (mCurrentCategory == mCategories.end())
throw std::logic_error("no category for setting");
mCurrentCategory->second.addSubcategory(
new CSMPrefs::Subcategory(&mCurrentCategory->second, &mMutex, label, *mIndex));
}
CSMPrefs::State::State(const Files::ConfigurationManager& configurationManager)
: mConfigFile("openmw-cs.cfg")
, mDefaultConfigFile("defaults-cs.bin")
, mConfigurationManager(configurationManager)
, mCurrentCategory(mCategories.end())
, mIndex(std::make_unique<Settings::Index>())
, mValues(std::make_unique<Values>(*mIndex))
{
if (sThis)
throw std::logic_error("An instance of CSMPRefs::State already exists");
sThis = this;
declare();
}
CSMPrefs::State::~State()
{
sThis = nullptr;
}
void CSMPrefs::State::save()
{
Settings::Manager::saveUser(mConfigurationManager.getUserConfigPath() / mConfigFile);
}
CSMPrefs::State::Iterator CSMPrefs::State::begin()
{
return mCategories.begin();
}
CSMPrefs::State::Iterator CSMPrefs::State::end()
{
return mCategories.end();
}
CSMPrefs::ShortcutManager& CSMPrefs::State::getShortcutManager()
{
return mShortcutManager;
}
CSMPrefs::Category& CSMPrefs::State::operator[](const std::string& key)
{
Iterator iter = mCategories.find(key);
if (iter == mCategories.end())
throw std::logic_error("Invalid user settings category: " + key);
return iter->second;
}
void CSMPrefs::State::update(const Setting& setting)
{
emit settingChanged(&setting);
}
CSMPrefs::State& CSMPrefs::State::get()
{
if (!sThis)
throw std::logic_error("No instance of CSMPrefs::State");
return *sThis;
}
void CSMPrefs::State::resetCategory(const std::string& category)
{
Collection::iterator container = mCategories.find(category);
if (container != mCategories.end())
{
for (Setting* setting : container->second)
{
setting->reset();
update(*setting);
}
}
}
void CSMPrefs::State::resetAll()
{
for (Collection::iterator iter = mCategories.begin(); iter != mCategories.end(); ++iter)
{
resetCategory(iter->first);
}
}
CSMPrefs::State& CSMPrefs::get()
{
return State::get();
}
| 33,742
|
C++
|
.cpp
| 558
| 54.842294
| 120
| 0.759925
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,995
|
category.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/category.cpp
|
#include "category.hpp"
#include <stdexcept>
#include "setting.hpp"
#include "state.hpp"
#include "subcategory.hpp"
CSMPrefs::Category::Category(State* parent, const std::string& key)
: mParent(parent)
, mKey(key)
{
}
const std::string& CSMPrefs::Category::getKey() const
{
return mKey;
}
CSMPrefs::State* CSMPrefs::Category::getState() const
{
return mParent;
}
void CSMPrefs::Category::addSetting(Setting* setting)
{
if (!mIndex.emplace(setting->getKey(), setting).second)
throw std::logic_error("Category " + mKey + " already has setting: " + setting->getKey());
mSettings.push_back(setting);
}
void CSMPrefs::Category::addSubcategory(Subcategory* setting)
{
mSettings.push_back(setting);
}
CSMPrefs::Category::Iterator CSMPrefs::Category::begin()
{
return mSettings.begin();
}
CSMPrefs::Category::Iterator CSMPrefs::Category::end()
{
return mSettings.end();
}
CSMPrefs::Setting& CSMPrefs::Category::operator[](const std::string& key)
{
const auto it = mIndex.find(key);
if (it != mIndex.end())
return *it->second;
throw std::logic_error("Invalid user setting in " + mKey + " category: " + key);
}
void CSMPrefs::Category::update()
{
for (Iterator iter = mSettings.begin(); iter != mSettings.end(); ++iter)
mParent->update(**iter);
}
| 1,328
|
C++
|
.cpp
| 48
| 24.770833
| 98
| 0.701976
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,996
|
boolsetting.cpp
|
OpenMW_openmw/apps/opencs/model/prefs/boolsetting.cpp
|
#include "boolsetting.hpp"
#include <QCheckBox>
#include <QMutexLocker>
#include <components/settings/settings.hpp>
#include <apps/opencs/model/prefs/setting.hpp>
#include "category.hpp"
#include "state.hpp"
CSMPrefs::BoolSetting::BoolSetting(
Category* parent, QMutex* mutex, std::string_view key, const QString& label, Settings::Index& index)
: TypedSetting(parent, mutex, key, label, index)
, mWidget(nullptr)
{
}
CSMPrefs::BoolSetting& CSMPrefs::BoolSetting::setTooltip(const std::string& tooltip)
{
mTooltip = tooltip;
return *this;
}
CSMPrefs::SettingWidgets CSMPrefs::BoolSetting::makeWidgets(QWidget* parent)
{
mWidget = new QCheckBox(getLabel(), parent);
mWidget->setCheckState(getValue() ? Qt::Checked : Qt::Unchecked);
if (!mTooltip.empty())
{
QString tooltip = QString::fromUtf8(mTooltip.c_str());
mWidget->setToolTip(tooltip);
}
connect(mWidget, &QCheckBox::stateChanged, this, &BoolSetting::valueChanged);
return SettingWidgets{ .mLabel = nullptr, .mInput = mWidget };
}
void CSMPrefs::BoolSetting::updateWidget()
{
if (mWidget)
{
mWidget->setCheckState(getValue() ? Qt::Checked : Qt::Unchecked);
}
}
void CSMPrefs::BoolSetting::valueChanged(int value)
{
setValue(value != Qt::Unchecked);
getParent()->getState()->update(*this);
}
| 1,349
|
C++
|
.cpp
| 42
| 28.642857
| 104
| 0.719691
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,997
|
messages.cpp
|
OpenMW_openmw/apps/opencs/model/doc/messages.cpp
|
#include "messages.hpp"
#include <apps/opencs/model/world/universalid.hpp>
CSMDoc::Message::Message()
: mSeverity(Severity_Default)
{
}
CSMDoc::Message::Message(
const CSMWorld::UniversalId& id, const std::string& message, const std::string& hint, Severity severity)
: mId(id)
, mMessage(message)
, mHint(hint)
, mSeverity(severity)
{
}
std::string CSMDoc::Message::toString(Severity severity)
{
switch (severity)
{
case CSMDoc::Message::Severity_Info:
return "Information";
case CSMDoc::Message::Severity_Warning:
return "Warning";
case CSMDoc::Message::Severity_Error:
return "Error";
case CSMDoc::Message::Severity_SeriousError:
return "Serious Error";
case CSMDoc::Message::Severity_Default:
break;
}
return "";
}
CSMDoc::Messages::Messages(Message::Severity default_)
: mDefault(default_)
{
}
void CSMDoc::Messages::add(
const CSMWorld::UniversalId& id, const std::string& message, const std::string& hint, Message::Severity severity)
{
if (severity == Message::Severity_Default)
severity = mDefault;
mMessages.push_back(Message(id, message, hint, severity));
}
CSMDoc::Messages::Iterator CSMDoc::Messages::begin() const
{
return mMessages.begin();
}
CSMDoc::Messages::Iterator CSMDoc::Messages::end() const
{
return mMessages.end();
}
| 1,423
|
C++
|
.cpp
| 50
| 23.82
| 117
| 0.681585
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,998
|
operation.cpp
|
OpenMW_openmw/apps/opencs/model/doc/operation.cpp
|
#include "operation.hpp"
#include <algorithm>
#include <exception>
#include <vector>
#include <QTimer>
#include <components/debug/debuglog.hpp>
#include <apps/opencs/model/doc/messages.hpp>
#include "../world/universalid.hpp"
#include "stage.hpp"
namespace CSMDoc
{
namespace
{
std::string_view operationToString(State value)
{
switch (value)
{
case State_Saving:
return "Saving";
case State_Merging:
return "Merging";
case State_Verifying:
return "Verifying";
case State_Searching:
return "Searching";
case State_Loading:
return "Loading";
default:
break;
}
return "Unknown";
}
}
}
void CSMDoc::Operation::prepareStages()
{
mCurrentStage = mStages.begin();
mCurrentStep = 0;
mCurrentStepTotal = 0;
mTotalSteps = 0;
mError = false;
for (std::vector<std::pair<Stage*, int>>::iterator iter(mStages.begin()); iter != mStages.end(); ++iter)
{
iter->second = iter->first->setup();
mTotalSteps += iter->second;
}
}
CSMDoc::Operation::Operation(State type, bool ordered, bool finalAlways)
: mType(type)
, mStages(std::vector<std::pair<Stage*, int>>())
, mCurrentStage(mStages.begin())
, mCurrentStep(0)
, mCurrentStepTotal(0)
, mTotalSteps(0)
, mOrdered(ordered)
, mFinalAlways(finalAlways)
, mError(false)
, mConnected(false)
, mPrepared(false)
, mDefaultSeverity(Message::Severity_Error)
{
mTimer = new QTimer(this);
}
CSMDoc::Operation::~Operation()
{
for (std::vector<std::pair<Stage*, int>>::iterator iter(mStages.begin()); iter != mStages.end(); ++iter)
delete iter->first;
}
void CSMDoc::Operation::run()
{
mTimer->stop();
if (!mConnected)
{
connect(mTimer, &QTimer::timeout, this, &Operation::executeStage);
mConnected = true;
}
mPrepared = false;
mStart = std::chrono::steady_clock::now();
mTimer->start(0);
}
void CSMDoc::Operation::appendStage(Stage* stage)
{
mStages.emplace_back(stage, 0);
}
void CSMDoc::Operation::setDefaultSeverity(Message::Severity severity)
{
mDefaultSeverity = severity;
}
bool CSMDoc::Operation::hasError() const
{
return mError;
}
void CSMDoc::Operation::abort()
{
if (!mTimer->isActive())
return;
mError = true;
if (mFinalAlways)
{
if (mStages.begin() != mStages.end() && mCurrentStage != --mStages.end())
{
mCurrentStep = 0;
mCurrentStage = --mStages.end();
}
}
else
mCurrentStage = mStages.end();
}
void CSMDoc::Operation::executeStage()
{
if (!mPrepared)
{
prepareStages();
mPrepared = true;
}
Messages messages(mDefaultSeverity);
while (mCurrentStage != mStages.end())
{
if (mCurrentStep >= mCurrentStage->second)
{
mCurrentStep = 0;
++mCurrentStage;
}
else
{
try
{
mCurrentStage->first->perform(mCurrentStep++, messages);
}
catch (const std::exception& e)
{
emit reportMessage(
Message(CSMWorld::UniversalId(), e.what(), "", Message::Severity_SeriousError), mType);
abort();
}
++mCurrentStepTotal;
break;
}
}
emit progress(mCurrentStepTotal, mTotalSteps ? mTotalSteps : 1, mType);
for (Messages::Iterator iter(messages.begin()); iter != messages.end(); ++iter)
emit reportMessage(*iter, mType);
if (mCurrentStage == mStages.end())
{
if (mStart.has_value())
{
const auto duration = std::chrono::steady_clock::now() - *mStart;
Log(Debug::Verbose) << operationToString(mType) << " operation is completed in "
<< std::chrono::duration_cast<std::chrono::duration<double>>(duration).count() << 's';
mStart.reset();
}
operationDone();
}
}
void CSMDoc::Operation::operationDone()
{
mTimer->stop();
emit done(mType, mError);
}
| 4,357
|
C++
|
.cpp
| 159
| 20.100629
| 118
| 0.576536
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,999
|
document.cpp
|
OpenMW_openmw/apps/opencs/model/doc/document.cpp
|
#include "document.hpp"
#include "state.hpp"
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/doc/operationholder.hpp>
#include <apps/opencs/model/doc/runner.hpp>
#include <apps/opencs/model/doc/saving.hpp>
#include <apps/opencs/model/tools/tools.hpp>
#include <apps/opencs/model/world/data.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/debug/debuglog.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/variant.hpp>
#include <components/files/conversion.hpp>
#include <algorithm>
#include <filesystem>
#include <fstream>
#include <memory>
#include <stddef.h>
#include <stdexcept>
#include <utility>
#include <variant>
#include "../world/defaultgmsts.hpp"
#ifndef Q_MOC_RUN
#include <components/files/configurationmanager.hpp>
#endif
namespace CSMWorld
{
class IdCompletionManager;
}
void CSMDoc::Document::addGmsts()
{
for (size_t i = 0; i < CSMWorld::DefaultGmsts::FloatCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Floats[i]);
gmst.mValue.setType(ESM::VT_Float);
gmst.mRecordFlags = 0;
gmst.mValue.setFloat(CSMWorld::DefaultGmsts::FloatsDefaultValues[i]);
getData().getGmsts().add(gmst);
}
for (size_t i = 0; i < CSMWorld::DefaultGmsts::IntCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Ints[i]);
gmst.mValue.setType(ESM::VT_Int);
gmst.mRecordFlags = 0;
gmst.mValue.setInteger(CSMWorld::DefaultGmsts::IntsDefaultValues[i]);
getData().getGmsts().add(gmst);
}
for (size_t i = 0; i < CSMWorld::DefaultGmsts::StringCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::Strings[i]);
gmst.mValue.setType(ESM::VT_String);
gmst.mRecordFlags = 0;
gmst.mValue.setString("");
getData().getGmsts().add(gmst);
}
}
void CSMDoc::Document::addOptionalGmsts()
{
for (size_t i = 0; i < CSMWorld::DefaultGmsts::OptionalFloatCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::OptionalFloats[i]);
gmst.blank();
gmst.mValue.setType(ESM::VT_Float);
addOptionalGmst(gmst);
}
for (size_t i = 0; i < CSMWorld::DefaultGmsts::OptionalIntCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::OptionalInts[i]);
gmst.blank();
gmst.mValue.setType(ESM::VT_Int);
addOptionalGmst(gmst);
}
for (size_t i = 0; i < CSMWorld::DefaultGmsts::OptionalStringCount; ++i)
{
ESM::GameSetting gmst;
gmst.mId = ESM::RefId::stringRefId(CSMWorld::DefaultGmsts::OptionalStrings[i]);
gmst.blank();
gmst.mValue.setType(ESM::VT_String);
gmst.mValue.setString("<no text>");
addOptionalGmst(gmst);
}
}
void CSMDoc::Document::addOptionalGlobals()
{
static constexpr std::string_view globals[] = {
"DaysPassed",
"PCWerewolf",
"PCYear",
};
for (std::size_t i = 0; i < std::size(globals); ++i)
{
ESM::Global global;
global.mId = ESM::RefId::stringRefId(globals[i]);
global.blank();
global.mValue.setType(ESM::VT_Long);
if (i == 0)
global.mValue.setInteger(1); // dayspassed starts counting at 1
addOptionalGlobal(global);
}
}
void CSMDoc::Document::addOptionalMagicEffects()
{
for (int i = ESM::MagicEffect::SummonFabricant; i <= ESM::MagicEffect::SummonCreature05; ++i)
{
ESM::MagicEffect effect;
effect.mIndex = i;
effect.mId = ESM::MagicEffect::indexToRefId(i);
effect.blank();
addOptionalMagicEffect(effect);
}
}
void CSMDoc::Document::addOptionalGmst(const ESM::GameSetting& gmst)
{
if (getData().getGmsts().searchId(gmst.mId) == -1)
{
auto record = std::make_unique<CSMWorld::Record<ESM::GameSetting>>();
record->mBase = gmst;
record->mState = CSMWorld::RecordBase::State_BaseOnly;
getData().getGmsts().appendRecord(std::move(record));
}
}
void CSMDoc::Document::addOptionalGlobal(const ESM::Global& global)
{
if (getData().getGlobals().searchId(global.mId) == -1)
{
auto record = std::make_unique<CSMWorld::Record<ESM::Global>>();
record->mBase = global;
record->mState = CSMWorld::RecordBase::State_BaseOnly;
getData().getGlobals().appendRecord(std::move(record));
}
}
void CSMDoc::Document::addOptionalMagicEffect(const ESM::MagicEffect& magicEffect)
{
if (getData().getMagicEffects().searchId(magicEffect.mId) == -1)
{
auto record = std::make_unique<CSMWorld::Record<ESM::MagicEffect>>();
record->mBase = magicEffect;
record->mState = CSMWorld::RecordBase::State_BaseOnly;
getData().getMagicEffects().appendRecord(std::move(record));
}
}
void CSMDoc::Document::createBase()
{
static constexpr std::string_view globals[] = {
"Day",
"DaysPassed",
"GameHour",
"Month",
"PCRace",
"PCVampire",
"PCWerewolf",
"PCYear",
};
for (std::size_t i = 0; i < std::size(globals); ++i)
{
ESM::Global record;
record.mId = ESM::RefId::stringRefId(globals[i]);
record.mRecordFlags = 0;
record.mValue.setType(i == 2 ? ESM::VT_Float : ESM::VT_Long);
if (i == 0 || i == 1)
record.mValue.setInteger(1);
getData().getGlobals().add(record);
}
addGmsts();
for (int i = 0; i < ESM::Skill::Length; ++i)
{
ESM::Skill record;
record.mId = *ESM::Skill::indexToRefId(i).getIf<ESM::SkillId>();
record.blank();
getData().getSkills().add(record);
}
static constexpr std::string_view voices[] = {
"Intruder",
"Attack",
"Hello",
"Thief",
"Alarm",
"Idle",
"Flee",
"Hit",
};
for (const std::string_view voice : voices)
{
ESM::Dialogue record;
record.mId = ESM::RefId::stringRefId(voice);
record.mStringId = voice;
record.mType = ESM::Dialogue::Voice;
record.blank();
getData().getTopics().add(record);
}
static constexpr std::string_view greetings[] = {
"Greeting 0",
"Greeting 1",
"Greeting 2",
"Greeting 3",
"Greeting 4",
"Greeting 5",
"Greeting 6",
"Greeting 7",
"Greeting 8",
"Greeting 9",
};
for (const std::string_view greeting : greetings)
{
ESM::Dialogue record;
record.mId = ESM::RefId::stringRefId(greeting);
record.mStringId = greeting;
record.mType = ESM::Dialogue::Greeting;
record.blank();
getData().getTopics().add(record);
}
static constexpr std::string_view persuasions[] = {
"Intimidate Success",
"Intimidate Fail",
"Service Refusal",
"Admire Success",
"Taunt Success",
"Bribe Success",
"Info Refusal",
"Admire Fail",
"Taunt Fail",
"Bribe Fail",
};
for (const std::string_view persuasion : persuasions)
{
ESM::Dialogue record;
record.mId = ESM::RefId::stringRefId(persuasion);
record.mStringId = persuasion;
record.mType = ESM::Dialogue::Persuasion;
record.blank();
getData().getTopics().add(record);
}
for (int i = 0; i < ESM::MagicEffect::Length; ++i)
{
ESM::MagicEffect record;
record.mIndex = i;
record.mId = ESM::MagicEffect::indexToRefId(i);
record.blank();
getData().getMagicEffects().add(record);
}
}
CSMDoc::Document::Document(const Files::ConfigurationManager& configuration, std::vector<std::filesystem::path> files,
bool new_, const std::filesystem::path& savePath, const std::filesystem::path& resDir, ToUTF8::FromType encoding,
const Files::PathContainer& dataPaths, const std::vector<std::string>& archives)
: mSavePath(savePath)
, mContentFiles(std::move(files))
, mNew(new_)
, mData(encoding, dataPaths, archives, resDir)
, mTools(*this, encoding)
, mProjectPath((configuration.getUserDataPath() / "projects") / (savePath.filename().u8string() + u8".project"))
, mSavingOperation(*this, mProjectPath, encoding)
, mSaving(&mSavingOperation)
, mResDir(resDir)
, mRunner(mProjectPath)
, mDirty(false)
, mIdCompletionManager(mData)
{
if (mContentFiles.empty())
throw std::runtime_error("Empty content file sequence");
if (mNew || !std::filesystem::exists(mProjectPath))
{
auto filtersPath = configuration.getUserDataPath() / "defaultfilters";
std::ofstream destination(mProjectPath, std::ios::out | std::ios::binary);
if (!destination.is_open())
throw std::runtime_error("Can not create project file: " + Files::pathToUnicodeString(mProjectPath));
destination.exceptions(std::ios::failbit | std::ios::badbit);
if (!std::filesystem::exists(filtersPath))
filtersPath = mResDir / "defaultfilters";
std::ifstream source(filtersPath, std::ios::in | std::ios::binary);
if (!source.is_open())
throw std::runtime_error("Can not read filters file: " + Files::pathToUnicodeString(filtersPath));
source.exceptions(std::ios::failbit | std::ios::badbit);
destination << source.rdbuf();
}
if (mNew)
{
if (mContentFiles.size() == 1)
createBase();
}
addOptionalGmsts();
addOptionalGlobals();
addOptionalMagicEffects();
connect(&mUndoStack, &QUndoStack::cleanChanged, this, &Document::modificationStateChanged);
connect(&mTools, &CSMTools::Tools::progress, this, qOverload<int, int, int>(&Document::progress));
connect(&mTools, &CSMTools::Tools::done, this, &Document::operationDone);
connect(&mTools, &CSMTools::Tools::done, this, &Document::operationDone2);
connect(&mTools, &CSMTools::Tools::mergeDone, this, &Document::mergeDone);
connect(&mSaving, &OperationHolder::progress, this, qOverload<int, int, int>(&Document::progress));
connect(&mSaving, &OperationHolder::done, this, &Document::operationDone2);
connect(&mSaving, &OperationHolder::reportMessage, this, &Document::reportMessage);
connect(&mRunner, &Runner::runStateChanged, this, &Document::runStateChanged);
}
QUndoStack& CSMDoc::Document::getUndoStack()
{
return mUndoStack;
}
int CSMDoc::Document::getState() const
{
int state = 0;
if (!mUndoStack.isClean() || mDirty)
state |= State_Modified;
if (mSaving.isRunning())
state |= State_Locked | State_Saving | State_Operation;
if (mRunner.isRunning())
state |= State_Locked | State_Running;
if (int operations = mTools.getRunningOperations())
state |= State_Locked | State_Operation | operations;
return state;
}
const std::filesystem::path& CSMDoc::Document::getResourceDir() const
{
return mResDir;
}
const std::filesystem::path& CSMDoc::Document::getSavePath() const
{
return mSavePath;
}
const std::filesystem::path& CSMDoc::Document::getProjectPath() const
{
return mProjectPath;
}
const std::vector<std::filesystem::path>& CSMDoc::Document::getContentFiles() const
{
return mContentFiles;
}
bool CSMDoc::Document::isNew() const
{
return mNew;
}
void CSMDoc::Document::save()
{
if (mSaving.isRunning())
throw std::logic_error("Failed to initiate save, because a save operation is already running.");
mSaving.start();
emit stateChanged(getState(), this);
}
CSMWorld::UniversalId CSMDoc::Document::verify(const CSMWorld::UniversalId& reportId)
{
CSMWorld::UniversalId id = mTools.runVerifier(reportId);
emit stateChanged(getState(), this);
return id;
}
CSMWorld::UniversalId CSMDoc::Document::newSearch()
{
return mTools.newSearch();
}
void CSMDoc::Document::runSearch(const CSMWorld::UniversalId& searchId, const CSMTools::Search& search)
{
mTools.runSearch(searchId, search);
emit stateChanged(getState(), this);
}
void CSMDoc::Document::runMerge(std::unique_ptr<CSMDoc::Document> target)
{
mTools.runMerge(std::move(target));
emit stateChanged(getState(), this);
}
void CSMDoc::Document::abortOperation(int type)
{
if (type == State_Saving)
mSaving.abort();
else
mTools.abortOperation(type);
}
void CSMDoc::Document::modificationStateChanged(bool clean)
{
emit stateChanged(getState(), this);
}
void CSMDoc::Document::reportMessage(const CSMDoc::Message& message, int type)
{
/// \todo find a better way to get these messages to the user.
Log(Debug::Info) << message.mMessage;
}
void CSMDoc::Document::operationDone2(int type, bool failed)
{
if (type == CSMDoc::State_Saving && !failed)
mDirty = false;
emit stateChanged(getState(), this);
}
const CSMWorld::Data& CSMDoc::Document::getData() const
{
return mData;
}
CSMWorld::Data& CSMDoc::Document::getData()
{
return mData;
}
CSMTools::ReportModel* CSMDoc::Document::getReport(const CSMWorld::UniversalId& id)
{
return mTools.getReport(id);
}
void CSMDoc::Document::startRunning(const std::string& profile, const std::string& startupInstruction)
{
std::vector<std::filesystem::path> contentFiles;
for (const auto& mContentFile : mContentFiles)
{
contentFiles.emplace_back(mContentFile.filename());
}
mRunner.configure(getData().getDebugProfiles().getRecord(ESM::RefId::stringRefId(profile)).get(), contentFiles,
startupInstruction);
int state = getState();
if (state & State_Modified)
{
// need to save first
mRunner.start(true);
new SaveWatcher(&mRunner, &mSaving); // no, that is not a memory leak. Qt is weird.
if (!(state & State_Saving))
save();
}
else
mRunner.start();
}
void CSMDoc::Document::stopRunning()
{
mRunner.stop();
}
QTextDocument* CSMDoc::Document::getRunLog()
{
return mRunner.getLog();
}
void CSMDoc::Document::runStateChanged()
{
emit stateChanged(getState(), this);
}
void CSMDoc::Document::progress(int current, int max, int type)
{
emit progress(current, max, type, 1, this);
}
CSMWorld::IdCompletionManager& CSMDoc::Document::getIdCompletionManager()
{
return mIdCompletionManager;
}
void CSMDoc::Document::flagAsDirty()
{
mDirty = true;
}
| 14,875
|
C++
|
.cpp
| 445
| 27.934831
| 118
| 0.66097
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,000
|
documentmanager.cpp
|
OpenMW_openmw/apps/opencs/model/doc/documentmanager.cpp
|
#include "documentmanager.hpp"
#include <QWaitCondition>
#include <algorithm>
#include <filesystem>
#include <stdexcept>
#include <apps/opencs/model/doc/loader.hpp>
#ifndef Q_MOC_RUN
#include <components/files/configurationmanager.hpp>
#endif
#include "document.hpp"
CSMDoc::DocumentManager::DocumentManager(const Files::ConfigurationManager& configuration)
: mConfiguration(configuration)
, mEncoding(ToUTF8::WINDOWS_1252)
{
std::filesystem::path projectPath = configuration.getUserDataPath() / "projects";
if (!std::filesystem::is_directory(projectPath))
std::filesystem::create_directories(projectPath);
mLoader.moveToThread(&mLoaderThread);
mLoaderThread.start();
connect(&mLoader, &Loader::documentLoaded, this, &DocumentManager::documentLoaded);
connect(&mLoader, &Loader::documentNotLoaded, this, &DocumentManager::documentNotLoaded);
connect(this, &DocumentManager::loadRequest, &mLoader, &Loader::loadDocument);
connect(&mLoader, &Loader::nextStage, this, &DocumentManager::nextStage);
connect(&mLoader, &Loader::nextRecord, this, &DocumentManager::nextRecord);
connect(this, &DocumentManager::cancelLoading, &mLoader, &Loader::abortLoading);
connect(&mLoader, &Loader::loadMessage, this, &DocumentManager::loadMessage);
}
CSMDoc::DocumentManager::~DocumentManager()
{
mLoaderThread.quit();
mLoader.stop();
mLoader.hasThingsToDo().wakeAll();
mLoaderThread.wait();
for (std::vector<Document*>::iterator iter(mDocuments.begin()); iter != mDocuments.end(); ++iter)
delete *iter;
}
bool CSMDoc::DocumentManager::isEmpty()
{
return mDocuments.empty();
}
void CSMDoc::DocumentManager::addDocument(
const std::vector<std::filesystem::path>& files, const std::filesystem::path& savePath, bool new_)
{
Document* document = makeDocument(files, savePath, new_);
insertDocument(document);
}
CSMDoc::Document* CSMDoc::DocumentManager::makeDocument(
const std::vector<std::filesystem::path>& files, const std::filesystem::path& savePath, bool new_)
{
return new Document(mConfiguration, files, new_, savePath, mResDir, mEncoding, mDataPaths, mArchives);
}
void CSMDoc::DocumentManager::insertDocument(CSMDoc::Document* document)
{
mDocuments.push_back(document);
connect(document, SIGNAL(mergeDone(CSMDoc::Document*)), this, SLOT(insertDocument(CSMDoc::Document*)));
emit loadRequest(document);
mLoader.hasThingsToDo().wakeAll();
}
void CSMDoc::DocumentManager::removeDocument(CSMDoc::Document* document)
{
std::vector<Document*>::iterator iter = std::find(mDocuments.begin(), mDocuments.end(), document);
if (iter == mDocuments.end())
throw std::runtime_error("removing invalid document");
emit documentAboutToBeRemoved(document);
mDocuments.erase(iter);
document->deleteLater();
if (mDocuments.empty())
emit lastDocumentDeleted();
}
void CSMDoc::DocumentManager::setResourceDir(const std::filesystem::path& parResDir)
{
mResDir = std::filesystem::absolute(parResDir);
}
void CSMDoc::DocumentManager::setEncoding(ToUTF8::FromType encoding)
{
mEncoding = encoding;
}
void CSMDoc::DocumentManager::documentLoaded(Document* document)
{
emit documentAdded(document);
emit loadingStopped(document, true, "");
}
void CSMDoc::DocumentManager::documentNotLoaded(Document* document, const std::string& error)
{
emit loadingStopped(document, false, error);
if (error.empty()) // do not remove the document yet, if we have an error
removeDocument(document);
}
void CSMDoc::DocumentManager::setFileData(
const Files::PathContainer& dataPaths, const std::vector<std::string>& archives)
{
mDataPaths = dataPaths;
mArchives = archives;
}
| 3,760
|
C++
|
.cpp
| 94
| 36.43617
| 107
| 0.751443
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,001
|
runner.cpp
|
OpenMW_openmw/apps/opencs/model/doc/runner.cpp
|
#include "runner.hpp"
#include <utility>
#if defined(Q_OS_MAC)
#include <QCoreApplication>
#include <QDir>
#endif
#include <QProcess>
#include <QString>
#include <QStringList>
#include <QTemporaryFile>
#include <QTextStream>
#include <components/files/qtconversion.hpp>
#include "operationholder.hpp"
CSMDoc::Runner::Runner(std::filesystem::path projectPath)
: mRunning(false)
, mStartup(nullptr)
, mProjectPath(std::move(projectPath))
{
connect(&mProcess, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this, &Runner::finished);
connect(&mProcess, &QProcess::readyReadStandardOutput, this, &Runner::readyReadStandardOutput);
mProcess.setProcessChannelMode(QProcess::MergedChannels);
mProfile.blank();
}
CSMDoc::Runner::~Runner()
{
if (mRunning)
{
disconnect(&mProcess, nullptr, this, nullptr);
mProcess.kill();
mProcess.waitForFinished();
}
}
void CSMDoc::Runner::start(bool delayed)
{
if (mStartup)
{
delete mStartup;
mStartup = nullptr;
}
if (!delayed)
{
mLog.clear();
QString path = "openmw";
#ifdef Q_OS_WIN
path.append(QString(".exe"));
#elif defined(Q_OS_MAC)
QDir dir(QCoreApplication::applicationDirPath());
dir.cdUp();
dir.cdUp();
dir.cdUp();
path = dir.absoluteFilePath(path.prepend("OpenMW.app/Contents/MacOS/"));
#else
path.prepend(QString("./"));
#endif
mStartup = new QTemporaryFile(this);
mStartup->open();
{
QTextStream stream(mStartup);
if (!mStartupInstruction.empty())
stream << QString::fromUtf8(mStartupInstruction.c_str()) << '\n';
stream << QString::fromUtf8(mProfile.mScriptText.c_str());
}
mStartup->close();
QStringList arguments;
arguments << "--skip-menu";
if (mProfile.mFlags & ESM::DebugProfile::Flag_BypassNewGame)
arguments << "--new-game=0";
else
arguments << "--new-game=1";
arguments << ("--script-run=" + mStartup->fileName());
arguments << "--data=\"" + Files::pathToQString(mProjectPath.parent_path()) + "\"";
arguments << "--replace=content";
for (const auto& mContentFile : mContentFiles)
{
arguments << "--content=" + Files::pathToQString(mContentFile);
}
arguments << "--content=" + Files::pathToQString(mProjectPath.filename());
mProcess.start(path, arguments);
}
mRunning = true;
emit runStateChanged();
}
void CSMDoc::Runner::stop()
{
delete mStartup;
mStartup = nullptr;
if (mProcess.state() == QProcess::NotRunning)
{
mRunning = false;
emit runStateChanged();
}
else
mProcess.kill();
}
bool CSMDoc::Runner::isRunning() const
{
return mRunning;
}
void CSMDoc::Runner::configure(const ESM::DebugProfile& profile, const std::vector<std::filesystem::path>& contentFiles,
const std::string& startupInstruction)
{
mProfile = profile;
mContentFiles = contentFiles;
mStartupInstruction = startupInstruction;
}
void CSMDoc::Runner::finished(int exitCode, QProcess::ExitStatus exitStatus)
{
mRunning = false;
emit runStateChanged();
}
QTextDocument* CSMDoc::Runner::getLog()
{
return &mLog;
}
void CSMDoc::Runner::readyReadStandardOutput()
{
mLog.setPlainText(mLog.toPlainText() + QString::fromUtf8(mProcess.readAllStandardOutput()));
}
CSMDoc::SaveWatcher::SaveWatcher(Runner* runner, OperationHolder* operation)
: QObject(runner)
, mRunner(runner)
{
connect(operation, &OperationHolder::done, this, &SaveWatcher::saveDone);
}
void CSMDoc::SaveWatcher::saveDone(int type, bool failed)
{
if (failed)
mRunner->stop();
else
mRunner->start();
deleteLater();
}
| 3,876
|
C++
|
.cpp
| 132
| 24.05303
| 120
| 0.659563
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
35,002
|
operationholder.cpp
|
OpenMW_openmw/apps/opencs/model/doc/operationholder.cpp
|
#include "operationholder.hpp"
#include "operation.hpp"
CSMDoc::OperationHolder::OperationHolder(Operation* operation)
: mOperation(nullptr)
, mRunning(false)
{
if (operation)
setOperation(operation);
}
void CSMDoc::OperationHolder::setOperation(Operation* operation)
{
mOperation = operation;
mOperation->moveToThread(&mThread);
connect(mOperation, &Operation::progress, this, &OperationHolder::progress);
connect(mOperation, &Operation::reportMessage, this, &OperationHolder::reportMessage);
connect(mOperation, &Operation::done, this, &OperationHolder::doneSlot);
connect(this, &OperationHolder::abortSignal, mOperation, &Operation::abort);
connect(&mThread, &QThread::started, mOperation, &Operation::run);
}
bool CSMDoc::OperationHolder::isRunning() const
{
return mRunning;
}
void CSMDoc::OperationHolder::start()
{
mRunning = true;
mThread.start();
}
void CSMDoc::OperationHolder::abort()
{
mRunning = false;
emit abortSignal();
}
void CSMDoc::OperationHolder::abortAndWait()
{
if (mRunning)
{
mThread.quit();
mThread.wait();
}
}
void CSMDoc::OperationHolder::doneSlot(int type, bool failed)
{
mRunning = false;
mThread.quit();
emit done(type, failed);
}
| 1,283
|
C++
|
.cpp
| 47
| 23.723404
| 90
| 0.726901
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,003
|
savingstate.cpp
|
OpenMW_openmw/apps/opencs/model/doc/savingstate.cpp
|
#include "savingstate.hpp"
#include <filesystem>
#include <utility>
#include "document.hpp"
#include "operation.hpp"
CSMDoc::SavingState::SavingState(Operation& operation, std::filesystem::path projectPath, ToUTF8::FromType encoding)
: mOperation(operation)
, mEncoder(encoding)
, mProjectPath(std::move(projectPath))
, mProjectFile(false)
{
mWriter.setEncoder(&mEncoder);
}
bool CSMDoc::SavingState::hasError() const
{
return mOperation.hasError();
}
void CSMDoc::SavingState::start(Document& document, bool project)
{
mProjectFile = project;
if (mStream.is_open())
mStream.close();
mStream.clear();
mSubRecords.clear();
if (project)
mPath = mProjectPath;
else
mPath = document.getSavePath();
std::filesystem::path file(mPath.filename().u8string() + u8".tmp");
mTmpPath = mPath.parent_path();
mTmpPath /= file;
}
const std::filesystem::path& CSMDoc::SavingState::getPath() const
{
return mPath;
}
const std::filesystem::path& CSMDoc::SavingState::getTmpPath() const
{
return mTmpPath;
}
std::ofstream& CSMDoc::SavingState::getStream()
{
return mStream;
}
ESM::ESMWriter& CSMDoc::SavingState::getWriter()
{
return mWriter;
}
bool CSMDoc::SavingState::isProjectFile() const
{
return mProjectFile;
}
const std::deque<int>* CSMDoc::SavingState::findSubRecord(const ESM::RefId& refId) const
{
const auto it = mSubRecords.find(refId);
if (it == mSubRecords.end())
return nullptr;
return &it->second;
}
std::deque<int>& CSMDoc::SavingState::getOrInsertSubRecord(const ESM::RefId& refId)
{
return mSubRecords[refId];
}
void CSMDoc::SavingState::clearSubRecords()
{
mSubRecords.clear();
}
| 1,733
|
C++
|
.cpp
| 67
| 22.597015
| 116
| 0.720535
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,004
|
saving.cpp
|
OpenMW_openmw/apps/opencs/model/doc/saving.cpp
|
#include "saving.hpp"
#include <algorithm>
#include <variant>
#include <apps/opencs/model/doc/operation.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/scope.hpp>
#include <components/esm3/debugprofile.hpp>
#include <components/esm3/filter.hpp>
#include <components/esm3/loadbody.hpp>
#include <components/esm3/loadbsgn.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/loadscpt.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/loadsndg.hpp>
#include <components/esm3/loadsoun.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadsscr.hpp>
#include <components/esm3/selectiongroup.hpp>
#include "../world/data.hpp"
#include "../world/idcollection.hpp"
#include "document.hpp"
#include "savingstages.hpp"
#include "state.hpp"
CSMDoc::Saving::Saving(Document& document, const std::filesystem::path& projectPath, ToUTF8::FromType encoding)
: Operation(State_Saving, true, true)
, mDocument(document)
, mState(*this, projectPath, encoding)
{
// save project file
appendStage(new OpenSaveStage(mDocument, mState, true));
appendStage(new WriteHeaderStage(mDocument, mState, true));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Filter>>(
mDocument.getData().getFilters(), mState, CSMWorld::Scope_Project));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::DebugProfile>>(
mDocument.getData().getDebugProfiles(), mState, CSMWorld::Scope_Project));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Script>>(
mDocument.getData().getScripts(), mState, CSMWorld::Scope_Project));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::SelectionGroup>>(
mDocument.getData().getSelectionGroups(), mState, CSMWorld::Scope_Project));
appendStage(new CloseSaveStage(mState));
// save content file
appendStage(new OpenSaveStage(mDocument, mState, false));
appendStage(new WriteHeaderStage(mDocument, mState, false));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::Global>>(mDocument.getData().getGlobals(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::GameSetting>>(mDocument.getData().getGmsts(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Skill>>(mDocument.getData().getSkills(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Class>>(mDocument.getData().getClasses(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::Faction>>(mDocument.getData().getFactions(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Race>>(mDocument.getData().getRaces(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Sound>>(mDocument.getData().getSounds(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::Script>>(mDocument.getData().getScripts(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::Region>>(mDocument.getData().getRegions(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::BirthSign>>(mDocument.getData().getBirthsigns(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Spell>>(mDocument.getData().getSpells(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::Enchantment>>(
mDocument.getData().getEnchantments(), mState));
appendStage(
new WriteCollectionStage<CSMWorld::IdCollection<ESM::BodyPart>>(mDocument.getData().getBodyParts(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::MagicEffect>>(
mDocument.getData().getMagicEffects(), mState));
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::StartScript>>(
mDocument.getData().getStartScripts(), mState));
appendStage(new WriteRefIdCollectionStage(mDocument, mState));
// Can reference creatures so needs to load after them for TESCS compatibility
appendStage(new WriteCollectionStage<CSMWorld::IdCollection<ESM::SoundGenerator>>(
mDocument.getData().getSoundGens(), mState));
appendStage(new CollectionReferencesStage(mDocument, mState));
appendStage(new WriteCellCollectionStage(mDocument, mState));
// Dialogue can reference objects, cells, and journals so must be written after these records for vanilla-compatible
// files
appendStage(new WriteDialogueCollectionStage(mDocument, mState, true));
appendStage(new WriteDialogueCollectionStage(mDocument, mState, false));
appendStage(new WritePathgridCollectionStage(mDocument, mState));
appendStage(new WriteLandTextureCollectionStage(mDocument, mState));
// references Land Textures
appendStage(new WriteLandCollectionStage(mDocument, mState));
// close file and clean up
appendStage(new CloseSaveStage(mState));
appendStage(new FinalSavingStage(mDocument, mState));
}
| 5,414
|
C++
|
.cpp
| 93
| 53.548387
| 120
| 0.772727
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| true
| false
|
35,005
|
savingstages.cpp
|
OpenMW_openmw/apps/opencs/model/doc/savingstages.cpp
|
#include "savingstages.hpp"
#include <QUndoStack>
#include <filesystem>
#include <map>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <apps/opencs/model/doc/savingstate.hpp>
#include <apps/opencs/model/world/cell.hpp>
#include <apps/opencs/model/world/data.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/info.hpp>
#include <apps/opencs/model/world/land.hpp>
#include <apps/opencs/model/world/metadata.hpp>
#include <apps/opencs/model/world/pathgrid.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/ref.hpp>
#include <apps/opencs/model/world/refcollection.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm/esmcommon.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loadinfo.hpp>
#include <components/esm3/loadpgrd.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/strings/lower.hpp>
#include "../world/cellcoordinates.hpp"
#include "document.hpp"
CSMDoc::OpenSaveStage::OpenSaveStage(Document& document, SavingState& state, bool projectFile)
: mDocument(document)
, mState(state)
, mProjectFile(projectFile)
{
}
int CSMDoc::OpenSaveStage::setup()
{
return 1;
}
void CSMDoc::OpenSaveStage::perform(int stage, Messages& messages)
{
mState.start(mDocument, mProjectFile);
mState.getStream().open(mProjectFile ? mState.getPath() : mState.getTmpPath(), std::ios::binary);
if (!mState.getStream().is_open())
throw std::runtime_error("failed to open stream for saving");
}
CSMDoc::WriteHeaderStage::WriteHeaderStage(Document& document, SavingState& state, bool simple)
: mDocument(document)
, mState(state)
, mSimple(simple)
{
}
int CSMDoc::WriteHeaderStage::setup()
{
return 1;
}
void CSMDoc::WriteHeaderStage::perform(int stage, Messages& messages)
{
mState.getWriter().setVersion();
mState.getWriter().clearMaster();
if (mSimple)
{
mState.getWriter().setAuthor("");
mState.getWriter().setDescription("");
mState.getWriter().setRecordCount(0);
// ESM::Header::CurrentFormat is `1` but since new records are not yet used in opencs
// we use the format `0` for compatibility with old versions.
mState.getWriter().setFormatVersion(ESM::DefaultFormatVersion);
}
else
{
mDocument.getData().getMetaData().save(mState.getWriter());
mState.getWriter().setRecordCount(mDocument.getData().count(CSMWorld::RecordBase::State_Modified)
+ mDocument.getData().count(CSMWorld::RecordBase::State_ModifiedOnly)
+ mDocument.getData().count(CSMWorld::RecordBase::State_Deleted));
/// \todo refine dependency list (at least remove redundant dependencies)
std::vector<std::filesystem::path> dependencies = mDocument.getContentFiles();
std::vector<std::filesystem::path>::const_iterator end(--dependencies.end());
for (std::vector<std::filesystem::path>::const_iterator iter(dependencies.begin()); iter != end; ++iter)
{
auto name = Files::pathToUnicodeString(iter->filename());
auto size = std::filesystem::file_size(*iter);
mState.getWriter().addMaster(name, size);
}
}
mState.getWriter().save(mState.getStream());
}
CSMDoc::WriteDialogueCollectionStage::WriteDialogueCollectionStage(Document& document, SavingState& state, bool journal)
: mState(state)
, mTopics(journal ? document.getData().getJournals() : document.getData().getTopics())
, mInfos(journal ? document.getData().getJournalInfos() : document.getData().getTopicInfos())
{
}
int CSMDoc::WriteDialogueCollectionStage::setup()
{
mInfosByTopic = mInfos.getInfosByTopic();
return mTopics.getSize();
}
void CSMDoc::WriteDialogueCollectionStage::perform(int stage, Messages& messages)
{
ESM::ESMWriter& writer = mState.getWriter();
const CSMWorld::Record<ESM::Dialogue>& topic = mTopics.getRecord(stage);
if (topic.mState == CSMWorld::RecordBase::State_Deleted)
{
// if the topic is deleted, we do not need to bother with INFO records.
const ESM::Dialogue& dialogue = topic.get();
writer.startRecord(dialogue.sRecordId);
dialogue.save(writer, true);
writer.endRecord(dialogue.sRecordId);
return;
}
// Test, if we need to save anything associated info records.
bool infoModified = false;
const auto topicInfos = mInfosByTopic.find(topic.get().mId);
if (topicInfos != mInfosByTopic.end())
{
for (const auto& record : topicInfos->second)
{
if (record->isModified() || record->mState == CSMWorld::RecordBase::State_Deleted)
{
infoModified = true;
break;
}
}
}
if (topic.isModified() || infoModified)
{
if (infoModified && topic.mState != CSMWorld::RecordBase::State_Modified
&& topic.mState != CSMWorld::RecordBase::State_ModifiedOnly)
{
mState.getWriter().startRecord(topic.mBase.sRecordId);
topic.mBase.save(mState.getWriter(), topic.mState == CSMWorld::RecordBase::State_Deleted);
mState.getWriter().endRecord(topic.mBase.sRecordId);
}
else
{
mState.getWriter().startRecord(topic.mModified.sRecordId);
topic.mModified.save(mState.getWriter(), topic.mState == CSMWorld::RecordBase::State_Deleted);
mState.getWriter().endRecord(topic.mModified.sRecordId);
}
// write modified selected info records
if (topicInfos != mInfosByTopic.end())
{
const std::vector<const CSMWorld::Record<CSMWorld::Info>*>& infos = topicInfos->second;
for (auto iter = infos.begin(); iter != infos.end(); ++iter)
{
const CSMWorld::Record<CSMWorld::Info>& record = **iter;
if (record.isModified() || record.mState == CSMWorld::RecordBase::State_Deleted)
{
ESM::DialInfo info = record.get();
info.mId = record.get().mOriginalId;
info.mData.mType = topic.get().mType;
if (iter == infos.begin())
info.mPrev = ESM::RefId();
else
info.mPrev = (*std::prev(iter))->get().mOriginalId;
const auto next = std::next(iter);
if (next == infos.end())
info.mNext = ESM::RefId();
else
info.mNext = (*next)->get().mOriginalId;
writer.startRecord(info.sRecordId);
info.save(writer, record.mState == CSMWorld::RecordBase::State_Deleted);
writer.endRecord(info.sRecordId);
}
}
}
}
}
CSMDoc::WriteRefIdCollectionStage::WriteRefIdCollectionStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::WriteRefIdCollectionStage::setup()
{
return mDocument.getData().getReferenceables().getSize();
}
void CSMDoc::WriteRefIdCollectionStage::perform(int stage, Messages& messages)
{
mDocument.getData().getReferenceables().save(stage, mState.getWriter());
}
CSMDoc::CollectionReferencesStage::CollectionReferencesStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::CollectionReferencesStage::setup()
{
mState.clearSubRecords();
int size = mDocument.getData().getReferences().getSize();
int steps = size / 100;
if (size % 100)
++steps;
return steps;
}
void CSMDoc::CollectionReferencesStage::perform(int stage, Messages& messages)
{
int size = mDocument.getData().getReferences().getSize();
for (int i = stage * 100; i < stage * 100 + 100 && i < size; ++i)
{
const CSMWorld::Record<CSMWorld::CellRef>& record = mDocument.getData().getReferences().getRecord(i);
if (record.isModified() || record.mState == CSMWorld::RecordBase::State_Deleted)
{
ESM::RefId cellId = record.get().mOriginalCell.empty() ? record.get().mCell : record.get().mOriginalCell;
std::deque<int>& indices = mState.getOrInsertSubRecord(cellId);
// collect moved references at the end of the container
const bool interior = !cellId.startsWith("#");
std::ostringstream stream;
if (!interior)
{
// recalculate the ref's cell location
std::pair<int, int> index = record.get().getCellIndex();
cellId = ESM::RefId::stringRefId(ESM::RefId::esm3ExteriorCell(index.first, index.second).toString());
}
// An empty mOriginalCell is meant to indicate that it is the same as
// the current cell. It is possible that a moved ref is moved again.
if ((record.get().mOriginalCell.empty() ? record.get().mCell : record.get().mOriginalCell) != cellId
&& !interior && record.mState != CSMWorld::RecordBase::State_ModifiedOnly && !record.get().mNew)
indices.push_back(i);
else
indices.push_front(i);
}
}
}
CSMDoc::WriteCellCollectionStage::WriteCellCollectionStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::WriteCellCollectionStage::setup()
{
return mDocument.getData().getCells().getSize();
}
void CSMDoc::WriteCellCollectionStage::writeReferences(
const std::deque<int>& references, bool interior, unsigned int& newRefNum)
{
ESM::ESMWriter& writer = mState.getWriter();
for (std::deque<int>::const_iterator iter(references.begin()); iter != references.end(); ++iter)
{
const CSMWorld::Record<CSMWorld::CellRef>& ref = mDocument.getData().getReferences().getRecord(*iter);
if (ref.isModified() || ref.mState == CSMWorld::RecordBase::State_Deleted)
{
CSMWorld::CellRef refRecord = ref.get();
// -1 is the current file, saved indices are 1-based
refRecord.mRefNum.mContentFile++;
// recalculate the ref's cell location
std::ostringstream stream;
if (!interior)
{
std::pair<int, int> index = refRecord.getCellIndex();
stream << "#" << index.first << " " << index.second;
}
ESM::RefId streamId = ESM::RefId::stringRefId(stream.str());
if (refRecord.mNew || refRecord.mRefNum.mIndex == 0
|| (!interior && ref.mState == CSMWorld::RecordBase::State_ModifiedOnly && refRecord.mCell != streamId))
{
refRecord.mRefNum.mIndex = newRefNum++;
}
else if ((refRecord.mOriginalCell.empty() ? refRecord.mCell : refRecord.mOriginalCell) != streamId
&& !interior)
{
// An empty mOriginalCell is meant to indicate that it is the same as
// the current cell. It is possible that a moved ref is moved again.
ESM::MovedCellRef moved;
moved.mRefNum = refRecord.mRefNum;
// Need to fill mTarget with the ref's new position.
std::istringstream istream(stream.str().c_str());
char ignore;
istream >> ignore >> moved.mTarget[0] >> moved.mTarget[1];
writer.writeFormId(refRecord.mRefNum, false, "MVRF");
writer.writeHNT("CNDT", moved.mTarget);
}
refRecord.save(writer, false, false, ref.mState == CSMWorld::RecordBase::State_Deleted);
}
}
}
void CSMDoc::WriteCellCollectionStage::perform(int stage, Messages& messages)
{
ESM::ESMWriter& writer = mState.getWriter();
const CSMWorld::Record<CSMWorld::Cell>& cell = mDocument.getData().getCells().getRecord(stage);
const CSMWorld::RefIdCollection& referenceables = mDocument.getData().getReferenceables();
const CSMWorld::RefIdData& refIdData = referenceables.getDataSet();
std::deque<int> tempRefs;
std::deque<int> persistentRefs;
const std::deque<int>* references = mState.findSubRecord(cell.get().mId);
if (cell.isModified() || cell.mState == CSMWorld::RecordBase::State_Deleted || references != nullptr)
{
CSMWorld::Cell cellRecord = cell.get();
const bool interior = !cellRecord.mId.startsWith("#");
// count new references and adjust RefNumCount accordingsly
unsigned int newRefNum = cellRecord.mRefNumCounter;
if (references != nullptr)
{
for (std::deque<int>::const_iterator iter(references->begin()); iter != references->end(); ++iter)
{
const CSMWorld::Record<CSMWorld::CellRef>& ref = mDocument.getData().getReferences().getRecord(*iter);
CSMWorld::CellRef refRecord = ref.get();
CSMWorld::RefIdData::LocalIndex localIndex = refIdData.searchId(refRecord.mRefID);
unsigned int recordFlags = refIdData.getRecordFlags(refRecord.mRefID);
bool isPersistent = ((recordFlags & ESM::FLAG_Persistent) != 0) || refRecord.mTeleport
|| localIndex.second == CSMWorld::UniversalId::Type_Creature
|| localIndex.second == CSMWorld::UniversalId::Type_Npc;
if (isPersistent)
persistentRefs.push_back(*iter);
else
tempRefs.push_back(*iter);
if (refRecord.mNew
|| (!interior && ref.mState == CSMWorld::RecordBase::State_ModifiedOnly &&
/// \todo consider worldspace
ESM::RefId::stringRefId(CSMWorld::CellCoordinates(refRecord.getCellIndex()).getId(""))
!= refRecord.mCell))
++cellRecord.mRefNumCounter;
if (refRecord.mRefNum.mIndex >= newRefNum)
newRefNum = refRecord.mRefNum.mIndex + 1;
}
}
// write cell data
writer.startRecord(cellRecord.sRecordId);
if (interior)
cellRecord.mData.mFlags |= ESM::Cell::Interior;
else
{
cellRecord.mData.mFlags &= ~ESM::Cell::Interior;
std::istringstream stream(cellRecord.mId.getRefIdString().c_str());
char ignore;
stream >> ignore >> cellRecord.mData.mX >> cellRecord.mData.mY;
}
cellRecord.save(writer, cell.mState == CSMWorld::RecordBase::State_Deleted);
// write references
if (references != nullptr)
{
writeReferences(persistentRefs, interior, newRefNum);
cellRecord.saveTempMarker(writer, static_cast<int>(references->size()) - persistentRefs.size());
writeReferences(tempRefs, interior, newRefNum);
}
writer.endRecord(cellRecord.sRecordId);
}
}
CSMDoc::WritePathgridCollectionStage::WritePathgridCollectionStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::WritePathgridCollectionStage::setup()
{
return mDocument.getData().getPathgrids().getSize();
}
void CSMDoc::WritePathgridCollectionStage::perform(int stage, Messages& messages)
{
ESM::ESMWriter& writer = mState.getWriter();
const CSMWorld::Record<CSMWorld::Pathgrid>& pathgrid = mDocument.getData().getPathgrids().getRecord(stage);
if (pathgrid.isModified() || pathgrid.mState == CSMWorld::RecordBase::State_Deleted)
{
CSMWorld::Pathgrid record = pathgrid.get();
if (record.mId.startsWith("#"))
{
std::istringstream stream(record.mId.getRefIdString());
char ignore;
stream >> ignore >> record.mData.mX >> record.mData.mY;
}
else
record.mCell = record.mId;
writer.startRecord(record.sRecordId);
record.save(writer, pathgrid.mState == CSMWorld::RecordBase::State_Deleted);
writer.endRecord(record.sRecordId);
}
}
CSMDoc::WriteLandCollectionStage::WriteLandCollectionStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::WriteLandCollectionStage::setup()
{
return mDocument.getData().getLand().getSize();
}
void CSMDoc::WriteLandCollectionStage::perform(int stage, Messages& messages)
{
ESM::ESMWriter& writer = mState.getWriter();
const CSMWorld::Record<CSMWorld::Land>& land = mDocument.getData().getLand().getRecord(stage);
if (land.isModified() || land.mState == CSMWorld::RecordBase::State_Deleted)
{
CSMWorld::Land record = land.get();
writer.startRecord(record.sRecordId);
record.save(writer, land.mState == CSMWorld::RecordBase::State_Deleted);
writer.endRecord(record.sRecordId);
}
}
CSMDoc::WriteLandTextureCollectionStage::WriteLandTextureCollectionStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::WriteLandTextureCollectionStage::setup()
{
return mDocument.getData().getLandTextures().getSize();
}
void CSMDoc::WriteLandTextureCollectionStage::perform(int stage, Messages& messages)
{
ESM::ESMWriter& writer = mState.getWriter();
const CSMWorld::Record<ESM::LandTexture>& landTexture = mDocument.getData().getLandTextures().getRecord(stage);
if (landTexture.isModified() || landTexture.mState == CSMWorld::RecordBase::State_Deleted)
{
ESM::LandTexture record = landTexture.get();
writer.startRecord(record.sRecordId);
record.save(writer, landTexture.mState == CSMWorld::RecordBase::State_Deleted);
writer.endRecord(record.sRecordId);
}
}
CSMDoc::CloseSaveStage::CloseSaveStage(SavingState& state)
: mState(state)
{
}
int CSMDoc::CloseSaveStage::setup()
{
return 1;
}
void CSMDoc::CloseSaveStage::perform(int stage, Messages& messages)
{
mState.getStream().close();
if (!mState.getStream())
throw std::runtime_error("saving failed");
}
CSMDoc::FinalSavingStage::FinalSavingStage(Document& document, SavingState& state)
: mDocument(document)
, mState(state)
{
}
int CSMDoc::FinalSavingStage::setup()
{
return 1;
}
void CSMDoc::FinalSavingStage::perform(int stage, Messages& messages)
{
if (mState.hasError())
{
mState.getWriter().close();
mState.getStream().close();
if (std::filesystem::exists(mState.getTmpPath()))
std::filesystem::remove(mState.getTmpPath());
}
else if (!mState.isProjectFile())
{
if (std::filesystem::exists(mState.getPath()))
std::filesystem::remove(mState.getPath());
std::filesystem::rename(mState.getTmpPath(), mState.getPath());
mDocument.getUndoStack().setClean();
}
}
| 19,275
|
C++
|
.cpp
| 456
| 34.482456
| 120
| 0.653024
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,006
|
loader.cpp
|
OpenMW_openmw/apps/opencs/model/doc/loader.cpp
|
#include "loader.hpp"
#include <algorithm>
#include <exception>
#include <filesystem>
#include <apps/opencs/model/doc/messages.hpp>
#include <apps/opencs/model/world/data.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/debug/debuglog.hpp>
#include <components/files/conversion.hpp>
#include <QTimer>
#include "../tools/reportmodel.hpp"
#include "document.hpp"
CSMDoc::Loader::Loader()
: mShouldStop(false)
{
mTimer = new QTimer(this);
connect(mTimer, &QTimer::timeout, this, &Loader::load);
mTimer->start();
}
QWaitCondition& CSMDoc::Loader::hasThingsToDo()
{
return mThingsToDo;
}
void CSMDoc::Loader::stop()
{
mShouldStop = true;
}
void CSMDoc::Loader::load()
{
if (mDocuments.empty())
{
mMutex.lock();
mThingsToDo.wait(&mMutex);
mMutex.unlock();
if (mShouldStop)
mTimer->stop();
return;
}
if (!mStart.has_value())
mStart = std::chrono::steady_clock::now();
std::vector<std::pair<Document*, Stage>>::iterator iter = mDocuments.begin();
Document* document = iter->first;
int size = static_cast<int>(document->getContentFiles().size());
int editedIndex = size - 1; // index of the file to be edited/created
if (document->isNew())
--size;
bool done = false;
try
{
if (iter->second.mRecordsLeft)
{
Messages messages(Message::Severity_Error);
const int batchingSize = 50;
for (int i = 0; i < batchingSize; ++i) // do not flood the system with update signals
if (document->getData().continueLoading(messages))
{
iter->second.mRecordsLeft = false;
break;
}
else
++(iter->second.mRecordsLoaded);
CSMWorld::UniversalId log(CSMWorld::UniversalId::Type_LoadErrorLog, 0);
{ // silence a g++ warning
for (CSMDoc::Messages::Iterator messageIter(messages.begin()); messageIter != messages.end();
++messageIter)
{
document->getReport(log)->add(*messageIter);
emit loadMessage(document, messageIter->mMessage);
}
}
emit nextRecord(document, iter->second.mRecordsLoaded);
return;
}
if (iter->second.mFile < size) // start loading the files
{
const std::filesystem::path& path = document->getContentFiles()[iter->second.mFile];
int steps = document->getData().startLoading(path, iter->second.mFile != editedIndex, /*project*/ false);
iter->second.mRecordsLeft = true;
iter->second.mRecordsLoaded = 0;
emit nextStage(document, Files::pathToUnicodeString(path.filename()), steps);
}
else if (iter->second.mFile == size) // start loading the last (project) file
{
int steps = document->getData().startLoading(document->getProjectPath(), /*base*/ false, true);
iter->second.mRecordsLeft = true;
iter->second.mRecordsLoaded = 0;
emit nextStage(document, "Project File", steps);
}
else
{
document->getData().finishLoading();
done = true;
}
++(iter->second.mFile);
}
catch (const std::exception& e)
{
mDocuments.erase(iter);
emit documentNotLoaded(document, e.what());
return;
}
if (done)
{
if (mStart.has_value())
{
const auto duration = std::chrono::steady_clock::now() - *mStart;
Log(Debug::Verbose) << "Loaded content files in "
<< std::chrono::duration_cast<std::chrono::duration<double>>(duration).count() << 's';
mStart.reset();
}
mDocuments.erase(iter);
emit documentLoaded(document);
}
}
void CSMDoc::Loader::loadDocument(CSMDoc::Document* document)
{
mDocuments.emplace_back(document, Stage());
}
void CSMDoc::Loader::abortLoading(CSMDoc::Document* document)
{
for (std::vector<std::pair<Document*, Stage>>::iterator iter = mDocuments.begin(); iter != mDocuments.end(); ++iter)
{
if (iter->first == document)
{
mDocuments.erase(iter);
emit documentNotLoaded(document, "");
break;
}
}
}
| 4,475
|
C++
|
.cpp
| 130
| 25.930769
| 120
| 0.587894
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,007
|
booleannode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/booleannode.cpp
|
#include "booleannode.hpp"
namespace CSMWorld
{
class IdTableBase;
}
CSMFilter::BooleanNode::BooleanNode(bool true_)
: mTrue(true_)
{
}
bool CSMFilter::BooleanNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
return mTrue;
}
std::string CSMFilter::BooleanNode::toString(bool numericColumns) const
{
return mTrue ? "true" : "false";
}
| 403
|
C++
|
.cpp
| 17
| 21.529412
| 119
| 0.746073
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,008
|
narynode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/narynode.cpp
|
#include "narynode.hpp"
#include <algorithm>
#include <sstream>
#include <apps/opencs/model/filter/node.hpp>
CSMFilter::NAryNode::NAryNode(const std::vector<std::shared_ptr<Node>>& nodes, const std::string& name)
: mNodes(nodes)
, mName(name)
{
}
int CSMFilter::NAryNode::getSize() const
{
return static_cast<int>(mNodes.size());
}
const CSMFilter::Node& CSMFilter::NAryNode::operator[](int index) const
{
return *mNodes.at(index);
}
std::vector<int> CSMFilter::NAryNode::getReferencedColumns() const
{
std::vector<int> columns;
for (std::vector<std::shared_ptr<Node>>::const_iterator iter(mNodes.begin()); iter != mNodes.end(); ++iter)
{
std::vector<int> columns2 = (*iter)->getReferencedColumns();
columns.insert(columns.end(), columns2.begin(), columns2.end());
}
return columns;
}
std::string CSMFilter::NAryNode::toString(bool numericColumns) const
{
std::ostringstream stream;
stream << mName << " (";
bool first = true;
int size = getSize();
for (int i = 0; i < size; ++i)
{
if (first)
first = false;
else
stream << ", ";
stream << (*this)[i].toString(numericColumns);
}
stream << ")";
return stream.str();
}
| 1,268
|
C++
|
.cpp
| 44
| 24.363636
| 111
| 0.644868
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,009
|
ornode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/ornode.cpp
|
#include "ornode.hpp"
#include <apps/opencs/model/filter/narynode.hpp>
#include <apps/opencs/model/filter/node.hpp>
namespace CSMWorld
{
class IdTableBase;
}
CSMFilter::OrNode::OrNode(const std::vector<std::shared_ptr<Node>>& nodes)
: NAryNode(nodes, "or")
{
}
bool CSMFilter::OrNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
int size = getSize();
for (int i = 0; i < size; ++i)
if ((*this)[i].test(table, row, columns))
return true;
return false;
}
| 548
|
C++
|
.cpp
| 19
| 25.421053
| 114
| 0.680688
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,010
|
valuenode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/valuenode.cpp
|
#include "valuenode.hpp"
#include <sstream>
#include <stdexcept>
#include <utility>
#include "../world/idtablebase.hpp"
CSMFilter::ValueNode::ValueNode(int columnId, Type lowerType, Type upperType, double lower, double upper)
: mColumnId(columnId)
, mLower(lower)
, mUpper(upper)
, mLowerType(lowerType)
, mUpperType(upperType)
{
}
bool CSMFilter::ValueNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
const std::map<int, int>::const_iterator iter = columns.find(mColumnId);
if (iter == columns.end())
throw std::logic_error("invalid column in value node test");
if (iter->second == -1)
return true;
QModelIndex index = table.index(row, iter->second);
QVariant data = table.data(index);
if (data.type() != QVariant::Double && data.type() != QVariant::Bool && data.type() != QVariant::Int
&& data.type() != QVariant::UInt && data.type() != static_cast<QVariant::Type>(QMetaType::Float))
return false;
double value = data.toDouble();
switch (mLowerType)
{
case Type_Closed:
if (value < mLower)
return false;
break;
case Type_Open:
if (value <= mLower)
return false;
break;
case Type_Infinite:
break;
}
switch (mUpperType)
{
case Type_Closed:
if (value > mUpper)
return false;
break;
case Type_Open:
if (value >= mUpper)
return false;
break;
case Type_Infinite:
break;
}
return true;
}
std::vector<int> CSMFilter::ValueNode::getReferencedColumns() const
{
return std::vector<int>(1, mColumnId);
}
std::string CSMFilter::ValueNode::toString(bool numericColumns) const
{
std::ostringstream stream;
stream << "value (";
if (numericColumns)
stream << mColumnId;
else
stream << "\"" << CSMWorld::Columns::getName(static_cast<CSMWorld::Columns::ColumnId>(mColumnId)) << "\"";
stream << ", ";
if (mLower == mUpper && mLowerType != Type_Infinite && mUpperType != Type_Infinite)
stream << mLower;
else
{
switch (mLowerType)
{
case Type_Closed:
stream << "[" << mLower;
break;
case Type_Open:
stream << "(" << mLower;
break;
case Type_Infinite:
stream << "(";
break;
}
stream << ", ";
switch (mUpperType)
{
case Type_Closed:
stream << mUpper << "]";
break;
case Type_Open:
stream << mUpper << ")";
break;
case Type_Infinite:
stream << ")";
break;
}
}
stream << ")";
return stream.str();
}
| 2,981
|
C++
|
.cpp
| 100
| 21.26
| 117
| 0.542687
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,011
|
parser.cpp
|
OpenMW_openmw/apps/opencs/model/filter/parser.cpp
|
#include "parser.hpp"
#include <algorithm>
#include <cctype>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <components/esm3/filter.hpp>
#include <components/misc/strings/lower.hpp>
#include "../world/columns.hpp"
#include "../world/data.hpp"
#include "andnode.hpp"
#include "booleannode.hpp"
#include "notnode.hpp"
#include "ornode.hpp"
#include "textnode.hpp"
#include "valuenode.hpp"
namespace
{
bool isAlpha(char c)
{
return std::isalpha(static_cast<unsigned char>(c));
}
bool isDigit(char c)
{
return std::isdigit(static_cast<unsigned char>(c));
}
}
namespace CSMFilter
{
struct Token
{
enum Type
{
Type_EOS,
Type_None,
Type_String,
Type_Number,
Type_Open,
Type_Close,
Type_OpenSquare,
Type_CloseSquare,
Type_Comma,
Type_OneShot,
Type_Keyword_True, ///< \attention Keyword enums must be arranged continuously.
Type_Keyword_False,
Type_Keyword_And,
Type_Keyword_Or,
Type_Keyword_Not,
Type_Keyword_Text,
Type_Keyword_Value
};
Type mType;
std::string mString;
double mNumber;
Token(Type type = Type_None);
Token(Type type, const std::string& string);
///< Non-string type that can also be interpreted as a string.
Token(const std::string& string);
Token(double number);
operator bool() const;
bool isString() const;
};
Token::Token(Type type)
: mType(type)
, mNumber(0.0)
{
}
Token::Token(Type type, const std::string& string)
: mType(type)
, mString(string)
, mNumber(0.0)
{
}
Token::Token(const std::string& string)
: mType(Type_String)
, mString(string)
, mNumber(0.0)
{
}
Token::Token(double number)
: mType(Type_Number)
, mNumber(number)
{
}
bool Token::isString() const
{
return mType == Type_String || mType >= Type_Keyword_True;
}
Token::operator bool() const
{
return mType != Type_None;
}
bool operator==(const Token& left, const Token& right)
{
if (left.mType != right.mType)
return false;
switch (left.mType)
{
case Token::Type_String:
return left.mString == right.mString;
case Token::Type_Number:
return left.mNumber == right.mNumber;
default:
return true;
}
}
}
CSMFilter::Token CSMFilter::Parser::getStringToken()
{
std::string string;
int size = static_cast<int>(mInput.size());
for (; mIndex < size; ++mIndex)
{
char c = mInput[mIndex];
if (isAlpha(c) || c == ':' || c == '_' || (!string.empty() && isDigit(c)) || c == '"'
|| (!string.empty() && string[0] == '"'))
string += c;
else
break;
if (c == '"' && string.size() > 1)
{
++mIndex;
break;
}
};
if (!string.empty())
{
if (string[0] == '"' && (string[string.size() - 1] != '"' || string.size() < 2))
{
error();
return Token(Token::Type_None);
}
if (string[0] != '"' && string[string.size() - 1] == '"')
{
error();
return Token(Token::Type_None);
}
if (string[0] == '"')
return string.substr(1, string.size() - 2);
}
return checkKeywords(string);
}
CSMFilter::Token CSMFilter::Parser::getNumberToken()
{
std::string string;
int size = static_cast<int>(mInput.size());
bool hasDecimalPoint = false;
bool hasDigit = false;
for (; mIndex < size; ++mIndex)
{
char c = mInput[mIndex];
if (isDigit(c))
{
string += c;
hasDigit = true;
}
else if (c == '.' && !hasDecimalPoint)
{
string += c;
hasDecimalPoint = true;
}
else if (string.empty() && c == '-')
string += c;
else
break;
}
if (!hasDigit)
{
error();
return Token(Token::Type_None);
}
float value;
std::istringstream stream(string.c_str());
stream >> value;
return value;
}
CSMFilter::Token CSMFilter::Parser::checkKeywords(const Token& token)
{
static const char* sKeywords[] = {
"true",
"false",
"and",
"or",
"not",
"string",
"value",
nullptr,
};
std::string string = Misc::StringUtils::lowerCase(token.mString);
for (int i = 0; sKeywords[i]; ++i)
if (sKeywords[i] == string || (string.size() == 1 && sKeywords[i][0] == string[0]))
return Token(static_cast<Token::Type>(i + Token::Type_Keyword_True), token.mString);
return token;
}
CSMFilter::Token CSMFilter::Parser::getNextToken()
{
int size = static_cast<int>(mInput.size());
char c = 0;
for (; mIndex < size; ++mIndex)
{
c = mInput[mIndex];
if (c != ' ')
break;
}
if (mIndex >= size)
return Token(Token::Type_EOS);
switch (c)
{
case '(':
++mIndex;
return Token(Token::Type_Open);
case ')':
++mIndex;
return Token(Token::Type_Close);
case '[':
++mIndex;
return Token(Token::Type_OpenSquare);
case ']':
++mIndex;
return Token(Token::Type_CloseSquare);
case ',':
++mIndex;
return Token(Token::Type_Comma);
case '!':
++mIndex;
return Token(Token::Type_OneShot);
}
if (c == '"' || c == '_' || isAlpha(c) || c == ':')
return getStringToken();
if (c == '-' || c == '.' || isDigit(c))
return getNumberToken();
error();
return Token(Token::Type_None);
}
std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp(bool allowEmpty, bool ignoreOneShot)
{
if (Token token = getNextToken())
{
if (token == Token(Token::Type_OneShot))
token = getNextToken();
if (token)
switch (token.mType)
{
case Token::Type_Keyword_True:
return std::make_shared<BooleanNode>(true);
case Token::Type_Keyword_False:
return std::make_shared<BooleanNode>(false);
case Token::Type_Keyword_And:
case Token::Type_Keyword_Or:
return parseNAry(token);
case Token::Type_Keyword_Not:
{
std::shared_ptr<CSMFilter::Node> node = parseImp();
if (mError)
return std::shared_ptr<Node>();
return std::make_shared<NotNode>(node);
}
case Token::Type_Keyword_Text:
return parseText();
case Token::Type_Keyword_Value:
return parseValue();
case Token::Type_EOS:
if (!allowEmpty)
error();
return std::shared_ptr<Node>();
default:
error();
}
}
return std::shared_ptr<Node>();
}
std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseNAry(const Token& keyword)
{
std::vector<std::shared_ptr<Node>> nodes;
Token token = getNextToken();
if (token.mType != Token::Type_Open)
{
error();
return std::shared_ptr<Node>();
}
for (;;)
{
std::shared_ptr<Node> node = parseImp();
if (mError)
return std::shared_ptr<Node>();
nodes.push_back(node);
token = getNextToken();
if (!token || (token.mType != Token::Type_Close && token.mType != Token::Type_Comma))
{
error();
return std::shared_ptr<Node>();
}
if (token.mType == Token::Type_Close)
break;
}
switch (keyword.mType)
{
case Token::Type_Keyword_And:
return std::make_shared<AndNode>(nodes);
case Token::Type_Keyword_Or:
return std::make_shared<OrNode>(nodes);
default:
error();
return std::shared_ptr<Node>();
}
}
std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseText()
{
Token token = getNextToken();
if (token.mType != Token::Type_Open)
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (!token)
return std::shared_ptr<Node>();
// parse column ID
int columnId = -1;
if (token.mType == Token::Type_Number)
{
if (static_cast<int>(token.mNumber) == token.mNumber)
columnId = static_cast<int>(token.mNumber);
}
else if (token.isString())
{
columnId = CSMWorld::Columns::getId(token.mString);
}
if (columnId < 0)
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (token.mType != Token::Type_Comma)
{
error();
return std::shared_ptr<Node>();
}
// parse text pattern
token = getNextToken();
if (!token.isString())
{
error();
return std::shared_ptr<Node>();
}
std::string text = token.mString;
token = getNextToken();
if (token.mType != Token::Type_Close)
{
error();
return std::shared_ptr<Node>();
}
auto node = std::make_shared<TextNode>(columnId, text);
if (!node->isValid())
error();
return node;
}
std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseValue()
{
Token token = getNextToken();
if (token.mType != Token::Type_Open)
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (!token)
return std::shared_ptr<Node>();
// parse column ID
int columnId = -1;
if (token.mType == Token::Type_Number)
{
if (static_cast<int>(token.mNumber) == token.mNumber)
columnId = static_cast<int>(token.mNumber);
}
else if (token.isString())
{
columnId = CSMWorld::Columns::getId(token.mString);
}
if (columnId < 0)
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (token.mType != Token::Type_Comma)
{
error();
return std::shared_ptr<Node>();
}
// parse value
double lower = 0;
double upper = 0;
ValueNode::Type lowerType = ValueNode::Type_Open;
ValueNode::Type upperType = ValueNode::Type_Open;
token = getNextToken();
if (token.mType == Token::Type_Number)
{
// single value
lower = upper = token.mNumber;
lowerType = upperType = ValueNode::Type_Closed;
}
else
{
// interval
if (token.mType == Token::Type_OpenSquare)
lowerType = ValueNode::Type_Closed;
else if (token.mType != Token::Type_CloseSquare && token.mType != Token::Type_Open)
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (token.mType == Token::Type_Number)
{
lower = token.mNumber;
token = getNextToken();
if (token.mType != Token::Type_Comma)
{
error();
return std::shared_ptr<Node>();
}
}
else if (token.mType == Token::Type_Comma)
{
lowerType = ValueNode::Type_Infinite;
}
else
{
error();
return std::shared_ptr<Node>();
}
token = getNextToken();
if (token.mType == Token::Type_Number)
{
upper = token.mNumber;
token = getNextToken();
}
else
upperType = ValueNode::Type_Infinite;
if (token.mType == Token::Type_CloseSquare)
{
if (upperType != ValueNode::Type_Infinite)
upperType = ValueNode::Type_Closed;
}
else if (token.mType != Token::Type_OpenSquare && token.mType != Token::Type_Close)
{
error();
return std::shared_ptr<Node>();
}
}
token = getNextToken();
if (token.mType != Token::Type_Close)
{
error();
return std::shared_ptr<Node>();
}
return std::make_shared<ValueNode>(columnId, lowerType, upperType, lower, upper);
}
void CSMFilter::Parser::error()
{
mError = true;
}
CSMFilter::Parser::Parser(const CSMWorld::Data& data)
: mIndex(0)
, mError(false)
, mData(data)
{
}
bool CSMFilter::Parser::parse(const std::string& filter, bool allowPredefined)
{
// reset
mFilter.reset();
mError = false;
mInput = filter;
mIndex = 0;
Token token;
if (allowPredefined)
token = getNextToken();
if (allowPredefined && token == Token(Token::Type_EOS))
{
mFilter.reset();
return true;
}
else if (!allowPredefined || token == Token(Token::Type_OneShot))
{
std::shared_ptr<Node> node = parseImp(true, token != Token(Token::Type_OneShot));
if (mError)
return false;
if (getNextToken() != Token(Token::Type_EOS))
{
error();
return false;
}
if (node)
mFilter = std::move(node);
else
{
// Empty filter string equals to filter "true".
mFilter = std::make_shared<BooleanNode>(true);
}
return true;
}
// We do not use isString() here, because there could be a pre-defined filter with an ID that is
// equal a filter keyword.
else if (token.mType == Token::Type_String)
{
if (getNextToken() != Token(Token::Type_EOS))
{
error();
return false;
}
const int index = mData.getFilters().searchId(ESM::RefId::stringRefId(token.mString));
if (index == -1)
{
error();
return false;
}
const CSMWorld::Record<ESM::Filter>& record = mData.getFilters().getRecord(index);
if (record.isDeleted())
{
error();
return false;
}
return parse(record.get().mFilter, false);
}
else
{
error();
return false;
}
}
std::shared_ptr<CSMFilter::Node> CSMFilter::Parser::getFilter() const
{
if (mError)
throw std::logic_error("No filter available");
return mFilter;
}
| 15,009
|
C++
|
.cpp
| 541
| 19.491682
| 100
| 0.529416
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,012
|
notnode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/notnode.cpp
|
#include "notnode.hpp"
#include <apps/opencs/model/filter/node.hpp>
#include <apps/opencs/model/filter/unarynode.hpp>
namespace CSMWorld
{
class IdTableBase;
}
CSMFilter::NotNode::NotNode(std::shared_ptr<Node> child)
: UnaryNode(std::move(child), "not")
{
}
bool CSMFilter::NotNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
return !getChild().test(table, row, columns);
}
| 440
|
C++
|
.cpp
| 15
| 27.266667
| 115
| 0.745843
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,013
|
textnode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/textnode.cpp
|
#include "textnode.hpp"
#include <memory>
#include <sstream>
#include <stdexcept>
#include <utility>
#include <QRegularExpression>
#include "../world/columns.hpp"
#include "../world/idtablebase.hpp"
CSMFilter::TextNode::TextNode(int columnId, const std::string& text)
: mColumnId(columnId)
, mText(text)
, mRegExp(QRegularExpression::anchoredPattern(QString::fromUtf8(mText.c_str())),
QRegularExpression::CaseInsensitiveOption)
{
}
bool CSMFilter::TextNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
const std::map<int, int>::const_iterator iter = columns.find(mColumnId);
if (iter == columns.end())
throw std::logic_error("invalid column in text node test");
if (iter->second == -1)
return true;
QModelIndex index = table.index(row, iter->second);
QVariant data = table.data(index);
QString string;
if (data.type() == QVariant::String)
{
string = data.toString();
}
else if ((data.type() == QVariant::Int || data.type() == QVariant::UInt)
&& CSMWorld::Columns::hasEnums(static_cast<CSMWorld::Columns::ColumnId>(mColumnId)))
{
int value = data.toInt();
std::vector<std::pair<int, std::string>> enums
= CSMWorld::Columns::getEnums(static_cast<CSMWorld::Columns::ColumnId>(mColumnId));
if (value >= 0 && value < static_cast<int>(enums.size()))
string = QString::fromUtf8(enums[value].second.c_str());
}
else if (data.type() == QVariant::Bool)
{
string = data.toBool() ? "true" : "false";
}
else if (mText.empty() && !data.isValid())
return true;
else
return false;
/// \todo make pattern syntax configurable
QRegularExpressionMatch match = mRegExp.match(string);
return match.hasMatch();
}
std::vector<int> CSMFilter::TextNode::getReferencedColumns() const
{
return std::vector<int>(1, mColumnId);
}
std::string CSMFilter::TextNode::toString(bool numericColumns) const
{
std::ostringstream stream;
stream << "text (";
if (numericColumns)
stream << mColumnId;
else
stream << "\"" << CSMWorld::Columns::getName(static_cast<CSMWorld::Columns::ColumnId>(mColumnId)) << "\"";
stream << ", \"" << mText << "\")";
return stream.str();
}
| 2,350
|
C++
|
.cpp
| 65
| 30.984615
| 116
| 0.654594
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,014
|
andnode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/andnode.cpp
|
#include "andnode.hpp"
#include <apps/opencs/model/filter/narynode.hpp>
#include <apps/opencs/model/filter/node.hpp>
CSMFilter::AndNode::AndNode(const std::vector<std::shared_ptr<Node>>& nodes)
: NAryNode(nodes, "and")
{
}
bool CSMFilter::AndNode::test(const CSMWorld::IdTableBase& table, int row, const std::map<int, int>& columns) const
{
int size = getSize();
for (int i = 0; i < size; ++i)
if (!(*this)[i].test(table, row, columns))
return false;
return true;
}
| 507
|
C++
|
.cpp
| 15
| 30.066667
| 115
| 0.673511
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,015
|
unarynode.cpp
|
OpenMW_openmw/apps/opencs/model/filter/unarynode.cpp
|
#include "unarynode.hpp"
#include <apps/opencs/model/filter/node.hpp>
CSMFilter::UnaryNode::UnaryNode(std::shared_ptr<Node> child, const std::string& name)
: mChild(std::move(child))
, mName(name)
{
}
const CSMFilter::Node& CSMFilter::UnaryNode::getChild() const
{
return *mChild;
}
CSMFilter::Node& CSMFilter::UnaryNode::getChild()
{
return *mChild;
}
std::vector<int> CSMFilter::UnaryNode::getReferencedColumns() const
{
return mChild->getReferencedColumns();
}
std::string CSMFilter::UnaryNode::toString(bool numericColumns) const
{
return mName + " " + mChild->toString(numericColumns);
}
| 623
|
C++
|
.cpp
| 23
| 24.782609
| 85
| 0.745791
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.