mirror of https://github.com/OpenMW/openmw.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2415 lines
72 KiB
C++
2415 lines
72 KiB
C++
#ifndef CSM_WOLRD_COLUMNIMP_H
|
|
#define CSM_WOLRD_COLUMNIMP_H
|
|
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
#include <osg/Math>
|
|
|
|
#include <apps/opencs/model/world/cell.hpp>
|
|
#include <components/esm/defs.hpp>
|
|
#include <components/esm3/loadbody.hpp>
|
|
#include <components/esm3/loaddial.hpp>
|
|
#include <components/esm3/loadinfo.hpp>
|
|
#include <components/esm3/loadrace.hpp>
|
|
#include <components/esm3/loadskil.hpp>
|
|
#include <components/esm3/selectiongroup.hpp>
|
|
#include <components/esm3/variant.hpp>
|
|
|
|
#include <optional>
|
|
|
|
#include <QString>
|
|
#include <QVariant>
|
|
#include <QVector>
|
|
|
|
#include "columnbase.hpp"
|
|
#include "columns.hpp"
|
|
#include "info.hpp"
|
|
#include "land.hpp"
|
|
#include "landtexture.hpp"
|
|
#include "record.hpp"
|
|
|
|
namespace CSMWorld
|
|
{
|
|
std::optional<std::uint32_t> getSkillIndex(std::string_view value);
|
|
|
|
std::string getStringId(ESM::RefId value);
|
|
|
|
/// \note Shares ID with VarValueColumn. A table can not have both.
|
|
template <typename ESXRecordT>
|
|
struct FloatValueColumn : public Column<ESXRecordT>
|
|
{
|
|
FloatValueColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Value, ColumnBase::Display_Float)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mValue.getFloat(); }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mValue.setFloat(data.toFloat());
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct StringIdColumn : public Column<ESXRecordT>
|
|
{
|
|
StringIdColumn(bool hidden = false)
|
|
: Column<ESXRecordT>(Columns::ColumnId_Id, ColumnBase::Display_Id,
|
|
hidden ? 0 : ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromStdString(getStringId(record.get().mId));
|
|
}
|
|
|
|
bool isEditable() const override { return false; }
|
|
};
|
|
|
|
template <>
|
|
inline QVariant StringIdColumn<Land>::get(const Record<Land>& record) const
|
|
{
|
|
const Land& land = record.get();
|
|
return QString::fromUtf8(Land::createUniqueRecordId(land.mX, land.mY).c_str());
|
|
}
|
|
|
|
template <>
|
|
inline QVariant StringIdColumn<LandTexture>::get(const Record<LandTexture>& record) const
|
|
{
|
|
const LandTexture& ltex = record.get();
|
|
return QString::fromUtf8(LandTexture::createUniqueRecordId(ltex.mPluginIndex, ltex.mIndex).c_str());
|
|
}
|
|
|
|
template <typename ESXRecordT>
|
|
struct RecordStateColumn : public Column<ESXRecordT>
|
|
{
|
|
RecordStateColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Modification, ColumnBase::Display_RecordState)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
if (record.mState == Record<ESXRecordT>::State_Erased)
|
|
return static_cast<int>(Record<ESXRecordT>::State_Deleted);
|
|
|
|
return static_cast<int>(record.mState);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
record.mState = static_cast<RecordBase::State>(data.toInt());
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FixedRecordTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
int mType;
|
|
|
|
FixedRecordTypeColumn(int type)
|
|
: Column<ESXRecordT>(Columns::ColumnId_RecordType, ColumnBase::Display_Integer, 0)
|
|
, mType(type)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return mType; }
|
|
|
|
bool isEditable() const override { return false; }
|
|
};
|
|
|
|
/// \attention A var type column must be immediately followed by a suitable value column.
|
|
template <typename ESXRecordT>
|
|
struct VarTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
VarTypeColumn(ColumnBase::Display display)
|
|
: Column<ESXRecordT>(Columns::ColumnId_ValueType, display,
|
|
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_Refresh)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mValue.getType());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mValue.setType(static_cast<ESM::VarType>(data.toInt()));
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
/// \note Shares ID with FloatValueColumn. A table can not have both.
|
|
template <typename ESXRecordT>
|
|
struct VarValueColumn : public Column<ESXRecordT>
|
|
{
|
|
VarValueColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Value, ColumnBase::Display_Var,
|
|
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_Refresh)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
switch (record.get().mValue.getType())
|
|
{
|
|
case ESM::VT_String:
|
|
|
|
return QString::fromUtf8(record.get().mValue.getString().c_str());
|
|
|
|
case ESM::VT_Int:
|
|
case ESM::VT_Short:
|
|
case ESM::VT_Long:
|
|
|
|
return record.get().mValue.getInteger();
|
|
|
|
case ESM::VT_Float:
|
|
|
|
return record.get().mValue.getFloat();
|
|
|
|
default:
|
|
return QVariant();
|
|
}
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
switch (record2.mValue.getType())
|
|
{
|
|
case ESM::VT_String:
|
|
|
|
record2.mValue.setString(data.toString().toUtf8().constData());
|
|
break;
|
|
|
|
case ESM::VT_Int:
|
|
case ESM::VT_Short:
|
|
case ESM::VT_Long:
|
|
|
|
record2.mValue.setInteger(data.toInt());
|
|
break;
|
|
|
|
case ESM::VT_Float:
|
|
|
|
record2.mValue.setFloat(data.toFloat());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct DescriptionColumn : public Column<ESXRecordT>
|
|
{
|
|
DescriptionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Description, ColumnBase::Display_LongString)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mDescription.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mDescription = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SpecialisationColumn : public Column<ESXRecordT>
|
|
{
|
|
SpecialisationColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Specialisation, ColumnBase::Display_Specialisation)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mSpecialization; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mSpecialization = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct UseValueColumn : public Column<ESXRecordT>
|
|
{
|
|
int mIndex;
|
|
|
|
UseValueColumn(int index)
|
|
: Column<ESXRecordT>(Columns::ColumnId_UseValue1 + index, ColumnBase::Display_Float)
|
|
, mIndex(index)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mUseValue[mIndex]; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mUseValue[mIndex] = data.toFloat();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct AttributeColumn : public Column<ESXRecordT>
|
|
{
|
|
AttributeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Attribute, ColumnBase::Display_Attribute)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mAttribute; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mAttribute = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct NameColumn : public Column<ESXRecordT>
|
|
{
|
|
NameColumn(ColumnBase::Display display = ColumnBase::Display_String)
|
|
: Column<ESXRecordT>(Columns::ColumnId_Name, display)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mName.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mName = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <>
|
|
struct NameColumn<CSMWorld::Cell> : public Column<CSMWorld::Cell>
|
|
{
|
|
NameColumn(ColumnBase::Display display = ColumnBase::Display_String)
|
|
: Column<CSMWorld::Cell>(Columns::ColumnId_Name, display)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<CSMWorld::Cell>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mName.c_str());
|
|
}
|
|
|
|
void set(Record<CSMWorld::Cell>& record, const QVariant& data) override
|
|
{
|
|
CSMWorld::Cell record2 = record.get();
|
|
|
|
record2.mName = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct AttributesColumn : public Column<ESXRecordT>
|
|
{
|
|
int mIndex;
|
|
|
|
AttributesColumn(int index)
|
|
: Column<ESXRecordT>(Columns::ColumnId_Attribute1 + index, ColumnBase::Display_Attribute)
|
|
, mIndex(index)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mAttribute[mIndex]; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mAttribute[mIndex] = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SkillsColumn : public Column<ESXRecordT>
|
|
{
|
|
int mIndex;
|
|
bool mMajor;
|
|
|
|
SkillsColumn(int index, bool typePrefix = false, bool major = false)
|
|
: Column<ESXRecordT>((typePrefix ? (major ? Columns::ColumnId_MajorSkill1 : Columns::ColumnId_MinorSkill1)
|
|
: Columns::ColumnId_Skill1)
|
|
+ index,
|
|
ColumnBase::Display_Skill)
|
|
, mIndex(index)
|
|
, mMajor(major)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromStdString(
|
|
ESM::Skill::indexToRefId(record.get().mData.getSkill(mIndex, mMajor)).getRefIdString());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
if (const auto index = getSkillIndex(data.toString().toStdString()))
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.getSkill(mIndex, mMajor) = static_cast<int>(*index);
|
|
|
|
record.setModified(record2);
|
|
}
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct PlayableColumn : public Column<ESXRecordT>
|
|
{
|
|
PlayableColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Playable, ColumnBase::Display_Boolean)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mIsPlayable != 0; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mIsPlayable = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct HiddenColumn : public Column<ESXRecordT>
|
|
{
|
|
HiddenColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Hidden, ColumnBase::Display_Boolean)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mIsHidden != 0; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mIsHidden = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FlagColumn : public Column<ESXRecordT>
|
|
{
|
|
int mMask;
|
|
bool mInverted;
|
|
|
|
FlagColumn(int columnId, int mask, int flags = ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue,
|
|
bool inverted = false)
|
|
: Column<ESXRecordT>(columnId, ColumnBase::Display_Boolean, flags)
|
|
, mMask(mask)
|
|
, mInverted(inverted)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
bool flag = (record.get().mData.mFlags & mMask) != 0;
|
|
|
|
if (mInverted)
|
|
flag = !flag;
|
|
|
|
return flag;
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
int flags = record2.mData.mFlags & ~mMask;
|
|
|
|
if ((data.toInt() != 0) != mInverted)
|
|
flags |= mMask;
|
|
|
|
record2.mData.mFlags = flags;
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FlagColumn2 : public Column<ESXRecordT>
|
|
{
|
|
int mMask;
|
|
bool mInverted;
|
|
|
|
FlagColumn2(int columnId, int mask, bool inverted = false)
|
|
: Column<ESXRecordT>(columnId, ColumnBase::Display_Boolean)
|
|
, mMask(mask)
|
|
, mInverted(inverted)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
bool flag = (record.get().mFlags & mMask) != 0;
|
|
|
|
if (mInverted)
|
|
flag = !flag;
|
|
|
|
return flag;
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
int flags = record2.mFlags & ~mMask;
|
|
|
|
if ((data.toInt() != 0) != mInverted)
|
|
flags |= mMask;
|
|
|
|
record2.mFlags = flags;
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct WeightHeightColumn : public Column<ESXRecordT>
|
|
{
|
|
bool mMale;
|
|
bool mWeight;
|
|
|
|
WeightHeightColumn(bool male, bool weight)
|
|
: Column<ESXRecordT>(male ? (weight ? Columns::ColumnId_MaleWeight : Columns::ColumnId_MaleHeight)
|
|
: (weight ? Columns::ColumnId_FemaleWeight : Columns::ColumnId_FemaleHeight),
|
|
ColumnBase::Display_Float)
|
|
, mMale(male)
|
|
, mWeight(weight)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
if (mWeight)
|
|
{
|
|
if (mMale)
|
|
return record.get().mData.mMaleWeight;
|
|
return record.get().mData.mFemaleWeight;
|
|
}
|
|
if (mMale)
|
|
return record.get().mData.mMaleHeight;
|
|
return record.get().mData.mFemaleHeight;
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
if (mWeight)
|
|
{
|
|
if (mMale)
|
|
record2.mData.mMaleWeight = data.toFloat();
|
|
else
|
|
record2.mData.mFemaleWeight = data.toFloat();
|
|
}
|
|
else
|
|
{
|
|
if (mMale)
|
|
record2.mData.mMaleHeight = data.toFloat();
|
|
else
|
|
record2.mData.mFemaleHeight = data.toFloat();
|
|
}
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SoundParamColumn : public Column<ESXRecordT>
|
|
{
|
|
enum Type
|
|
{
|
|
Type_Volume,
|
|
Type_MinRange,
|
|
Type_MaxRange
|
|
};
|
|
|
|
Type mType;
|
|
|
|
SoundParamColumn(Type type)
|
|
: Column<ESXRecordT>(type == Type_Volume
|
|
? Columns::ColumnId_Volume
|
|
: (type == Type_MinRange ? Columns::ColumnId_MinRange : Columns::ColumnId_MaxRange),
|
|
ColumnBase::Display_Integer)
|
|
, mType(type)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
int value = 0;
|
|
|
|
switch (mType)
|
|
{
|
|
case Type_Volume:
|
|
value = record.get().mData.mVolume;
|
|
break;
|
|
case Type_MinRange:
|
|
value = record.get().mData.mMinRange;
|
|
break;
|
|
case Type_MaxRange:
|
|
value = record.get().mData.mMaxRange;
|
|
break;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
int value = data.toInt();
|
|
|
|
if (value < 0)
|
|
value = 0;
|
|
else if (value > 255)
|
|
value = 255;
|
|
|
|
ESXRecordT record2 = record.get();
|
|
|
|
switch (mType)
|
|
{
|
|
case Type_Volume:
|
|
record2.mData.mVolume = static_cast<unsigned char>(value);
|
|
break;
|
|
case Type_MinRange:
|
|
record2.mData.mMinRange = static_cast<unsigned char>(value);
|
|
break;
|
|
case Type_MaxRange:
|
|
record2.mData.mMaxRange = static_cast<unsigned char>(value);
|
|
break;
|
|
}
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SoundFileColumn : public Column<ESXRecordT>
|
|
{
|
|
SoundFileColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_SoundFile, ColumnBase::Display_SoundRes)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mSound.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mSound = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct MapColourColumn : public Column<ESXRecordT>
|
|
{
|
|
MapColourColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_MapColour, ColumnBase::Display_Colour)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mMapColor; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT copy = record.get();
|
|
copy.mMapColor = data.toInt();
|
|
record.setModified(copy);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SleepListColumn : public Column<ESXRecordT>
|
|
{
|
|
SleepListColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_SleepEncounter, ColumnBase::Display_CreatureLevelledList)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mSleepList.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mSleepList = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct TextureColumn : public Column<ESXRecordT>
|
|
{
|
|
TextureColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Texture, ColumnBase::Display_Texture)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mTexture.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mTexture = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SpellTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
SpellTypeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_SpellType, ColumnBase::Display_SpellType)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mType; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mType = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct CostColumn : public Column<ESXRecordT>
|
|
{
|
|
CostColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Cost, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mCost; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mCost = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ScriptColumn : public Column<ESXRecordT>
|
|
{
|
|
enum Type
|
|
{
|
|
Type_File, // regular script record
|
|
Type_Lines, // console context
|
|
Type_Info // dialogue context (not implemented yet)
|
|
};
|
|
|
|
ScriptColumn(Type type)
|
|
: Column<ESXRecordT>(Columns::ColumnId_ScriptText,
|
|
type == Type_File ? ColumnBase::Display_ScriptFile : ColumnBase::Display_ScriptLines,
|
|
type == Type_File ? 0 : ColumnBase::Flag_Dialogue)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mScriptText.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mScriptText = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RegionColumn : public Column<ESXRecordT>
|
|
{
|
|
RegionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Region, ColumnBase::Display_Region)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mRegion.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mRegion = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct CellColumn : public Column<ESXRecordT>
|
|
{
|
|
bool mBlocked;
|
|
|
|
/// \param blocked Do not allow user-modification
|
|
CellColumn(bool blocked = false)
|
|
: Column<ESXRecordT>(Columns::ColumnId_Cell, ColumnBase::Display_Cell)
|
|
, mBlocked(blocked)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mCell.toString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mCell = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return !mBlocked; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct OriginalCellColumn : public Column<ESXRecordT>
|
|
{
|
|
OriginalCellColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_OriginalCell, ColumnBase::Display_Cell)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mOriginalCell.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mOriginalCell = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct IdColumn : public Column<ESXRecordT>
|
|
{
|
|
IdColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_ReferenceableId, ColumnBase::Display_Referenceable)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mRefID.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mRefID = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ScaleColumn : public Column<ESXRecordT>
|
|
{
|
|
ScaleColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Scale, ColumnBase::Display_Float)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mScale; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mScale = data.toFloat();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct OwnerColumn : public Column<ESXRecordT>
|
|
{
|
|
OwnerColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Owner, ColumnBase::Display_Npc)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mOwner.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mOwner = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SoulColumn : public Column<ESXRecordT>
|
|
{
|
|
SoulColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Soul, ColumnBase::Display_Creature)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mSoul.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mSoul = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FactionColumn : public Column<ESXRecordT>
|
|
{
|
|
FactionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Faction, ColumnBase::Display_Faction)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mFaction.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mFaction = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FactionIndexColumn : public Column<ESXRecordT>
|
|
{
|
|
FactionIndexColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_FactionIndex, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mFactionRank; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mFactionRank = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ChargesColumn : public Column<ESXRecordT>
|
|
{
|
|
ChargesColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Charges, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mChargeInt; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mChargeInt = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct EnchantmentChargesColumn : public Column<ESXRecordT>
|
|
{
|
|
EnchantmentChargesColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Enchantment, ColumnBase::Display_Float)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mEnchantmentCharge; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mEnchantmentCharge = data.toFloat();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct StackSizeColumn : public Column<ESXRecordT>
|
|
{
|
|
StackSizeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_StackCount, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mCount; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mCount = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct TeleportColumn : public Column<ESXRecordT>
|
|
{
|
|
TeleportColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Teleport, ColumnBase::Display_Boolean)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mTeleport; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mTeleport = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct TeleportCellColumn : public Column<ESXRecordT>
|
|
{
|
|
TeleportCellColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_TeleportCell, ColumnBase::Display_Cell)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mDestCell.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mDestCell = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct LockLevelColumn : public Column<ESXRecordT>
|
|
{
|
|
LockLevelColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_LockLevel, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mLockLevel; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mLockLevel = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct KeyColumn : public Column<ESXRecordT>
|
|
{
|
|
KeyColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Key, ColumnBase::Display_Miscellaneous)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mKey.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mKey = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct TrapColumn : public Column<ESXRecordT>
|
|
{
|
|
TrapColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Trap, ColumnBase::Display_Spell)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mTrap.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mTrap = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FilterColumn : public Column<ESXRecordT>
|
|
{
|
|
FilterColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Filter, ColumnBase::Display_Filter)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mFilter.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mFilter = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct PosColumn : public Column<ESXRecordT>
|
|
{
|
|
ESM::Position ESXRecordT::*mPosition;
|
|
int mIndex;
|
|
|
|
PosColumn(ESM::Position ESXRecordT::*position, int index, bool door)
|
|
: Column<ESXRecordT>((door ? Columns::ColumnId_DoorPositionXPos : Columns::ColumnId_PositionXPos) + index,
|
|
ColumnBase::Display_Float)
|
|
, mPosition(position)
|
|
, mIndex(index)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
const ESM::Position& position = record.get().*mPosition;
|
|
return position.pos[mIndex];
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
ESM::Position& position = record2.*mPosition;
|
|
|
|
position.pos[mIndex] = data.toFloat();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RotColumn : public Column<ESXRecordT>
|
|
{
|
|
ESM::Position ESXRecordT::*mPosition;
|
|
int mIndex;
|
|
|
|
RotColumn(ESM::Position ESXRecordT::*position, int index, bool door)
|
|
: Column<ESXRecordT>((door ? Columns::ColumnId_DoorPositionXRot : Columns::ColumnId_PositionXRot) + index,
|
|
ColumnBase::Display_Double)
|
|
, mPosition(position)
|
|
, mIndex(index)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
const ESM::Position& position = record.get().*mPosition;
|
|
return osg::RadiansToDegrees(position.rot[mIndex]);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
ESM::Position& position = record2.*mPosition;
|
|
|
|
position.rot[mIndex] = osg::DegreesToRadians(data.toFloat());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct DialogueTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
DialogueTypeColumn(bool hidden = false)
|
|
: Column<ESXRecordT>(Columns::ColumnId_DialogueType, ColumnBase::Display_DialogueType,
|
|
hidden ? 0 : ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return static_cast<int>(record.get().mType); }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mType = static_cast<ESM::Dialogue::Type>(data.toInt());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct QuestStatusTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
QuestStatusTypeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_QuestStatusType, ColumnBase::Display_QuestStatusType)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mQuestStatus);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mQuestStatus = static_cast<Info::QuestStatus>(data.toInt());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct QuestDescriptionColumn : public Column<ESXRecordT>
|
|
{
|
|
QuestDescriptionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_QuestDescription, ColumnBase::Display_LongString)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mResponse.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mResponse = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct QuestIndexColumn : public Column<ESXRecordT>
|
|
{
|
|
QuestIndexColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_QuestIndex, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mDisposition; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mDisposition = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct TopicColumn : public Column<ESXRecordT>
|
|
{
|
|
TopicColumn(bool journal)
|
|
: Column<ESXRecordT>(journal ? Columns::ColumnId_Journal : Columns::ColumnId_Topic,
|
|
journal ? ColumnBase::Display_Journal : ColumnBase::Display_Topic)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mTopicId.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mTopicId = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ActorColumn : public Column<ESXRecordT>
|
|
{
|
|
ActorColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Actor, ColumnBase::Display_Npc)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mActor.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mActor = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RaceColumn : public Column<ESXRecordT>
|
|
{
|
|
RaceColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Race, ColumnBase::Display_Race)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mRace.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mRace = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ClassColumn : public Column<ESXRecordT>
|
|
{
|
|
ClassColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Class, ColumnBase::Display_Class)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mClass.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mClass = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct PcFactionColumn : public Column<ESXRecordT>
|
|
{
|
|
PcFactionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_PcFaction, ColumnBase::Display_Faction)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mPcFaction.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mPcFaction = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ResponseColumn : public Column<ESXRecordT>
|
|
{
|
|
ResponseColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Response, ColumnBase::Display_LongString)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mResponse.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mResponse = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct DispositionColumn : public Column<ESXRecordT>
|
|
{
|
|
DispositionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Disposition, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mDisposition; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mDisposition = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RankColumn : public Column<ESXRecordT>
|
|
{
|
|
RankColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Rank, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mRank);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mRank = static_cast<signed char>(data.toInt());
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct PcRankColumn : public Column<ESXRecordT>
|
|
{
|
|
PcRankColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_PcRank, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mPCrank);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mPCrank = static_cast<signed char>(data.toInt());
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct GenderColumn : public Column<ESXRecordT>
|
|
{
|
|
GenderColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Gender, ColumnBase::Display_Gender)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mGender);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mGender = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct GenderNpcColumn : public Column<ESXRecordT>
|
|
{
|
|
GenderNpcColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Gender, ColumnBase::Display_GenderNpc)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
// Implemented this way to allow additional gender types in the future.
|
|
if ((record.get().mData.mFlags & ESM::BodyPart::BPF_Female) == ESM::BodyPart::BPF_Female)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
// Implemented this way to allow additional gender types in the future.
|
|
if (data.toInt() == 1)
|
|
record2.mData.mFlags = (record2.mData.mFlags & ~ESM::BodyPart::BPF_Female) | ESM::BodyPart::BPF_Female;
|
|
else
|
|
record2.mData.mFlags = record2.mData.mFlags & ~ESM::BodyPart::BPF_Female;
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct EnchantmentTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
EnchantmentTypeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_EnchantmentType, ColumnBase::Display_EnchantmentType)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mType);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mType = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ChargesColumn2 : public Column<ESXRecordT>
|
|
{
|
|
ChargesColumn2()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Charges, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mCharge; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mCharge = data.toInt();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct AutoCalcColumn : public Column<ESXRecordT>
|
|
{
|
|
AutoCalcColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_AutoCalc, ColumnBase::Display_Boolean)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mAutocalc != 0; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mAutocalc = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct ModelColumn : public Column<ESXRecordT>
|
|
{
|
|
ModelColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Model, ColumnBase::Display_Mesh)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mModel.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mModel = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct VampireColumn : public Column<ESXRecordT>
|
|
{
|
|
VampireColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Vampire, ColumnBase::Display_Boolean)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mVampire != 0; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mVampire = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct BodyPartTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
BodyPartTypeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_BodyPartType, ColumnBase::Display_BodyPartType)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mPart);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mPart = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct MeshTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
MeshTypeColumn(int flags = ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue)
|
|
: Column<ESXRecordT>(Columns::ColumnId_MeshType, ColumnBase::Display_MeshType, flags)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mData.mType);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mType = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct OwnerGlobalColumn : public Column<ESXRecordT>
|
|
{
|
|
OwnerGlobalColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_OwnerGlobal, ColumnBase::Display_GlobalVariable)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mGlobalVariable.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mGlobalVariable = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RefNumCounterColumn : public Column<ESXRecordT>
|
|
{
|
|
RefNumCounterColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_RefNumCounter, ColumnBase::Display_Integer, 0)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mRefNumCounter);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mRefNumCounter = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct RefNumColumn : public Column<ESXRecordT>
|
|
{
|
|
RefNumColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_RefNum, ColumnBase::Display_Integer, 0)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return static_cast<int>(record.get().mRefNum.mIndex);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mRefNum.mIndex = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
|
|
bool isUserEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SoundColumn : public Column<ESXRecordT>
|
|
{
|
|
SoundColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Sound, ColumnBase::Display_Sound)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mSound.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mSound = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct CreatureColumn : public Column<ESXRecordT>
|
|
{
|
|
CreatureColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Creature, ColumnBase::Display_Creature)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mCreature.getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mCreature = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SoundGeneratorTypeColumn : public Column<ESXRecordT>
|
|
{
|
|
SoundGeneratorTypeColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_SoundGeneratorType, ColumnBase::Display_SoundGeneratorType)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return static_cast<int>(record.get().mType); }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mType = data.toInt();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct BaseCostColumn : public Column<ESXRecordT>
|
|
{
|
|
BaseCostColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_BaseCost, ColumnBase::Display_Float)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mData.mBaseCost; }
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
record2.mData.mBaseCost = data.toFloat();
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct SchoolColumn : public Column<ESXRecordT>
|
|
{
|
|
SchoolColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_School, ColumnBase::Display_School)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return ESM::MagicSchool::skillRefIdToIndex(record.get().mData.mSchool);
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mData.mSchool = ESM::MagicSchool::indexToSkillRefId(data.toInt());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct EffectTextureColumn : public Column<ESXRecordT>
|
|
{
|
|
EffectTextureColumn(Columns::ColumnId columnId)
|
|
: Column<ESXRecordT>(columnId,
|
|
columnId == Columns::ColumnId_Particle ? ColumnBase::Display_Texture : ColumnBase::Display_Icon)
|
|
{
|
|
assert(this->mColumnId == Columns::ColumnId_Icon || this->mColumnId == Columns::ColumnId_Particle);
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(
|
|
(this->mColumnId == Columns::ColumnId_Icon ? record.get().mIcon : record.get().mParticle).c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
(this->mColumnId == Columns::ColumnId_Icon ? record2.mIcon : record2.mParticle)
|
|
= data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct EffectObjectColumn : public Column<ESXRecordT>
|
|
{
|
|
EffectObjectColumn(Columns::ColumnId columnId)
|
|
: Column<ESXRecordT>(columnId,
|
|
columnId == Columns::ColumnId_BoltObject ? ColumnBase::Display_Weapon : ColumnBase::Display_Static)
|
|
{
|
|
assert(this->mColumnId == Columns::ColumnId_CastingObject || this->mColumnId == Columns::ColumnId_HitObject
|
|
|| this->mColumnId == Columns::ColumnId_AreaObject || this->mColumnId == Columns::ColumnId_BoltObject);
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
const ESM::RefId* string = nullptr;
|
|
|
|
switch (this->mColumnId)
|
|
{
|
|
case Columns::ColumnId_CastingObject:
|
|
string = &record.get().mCasting;
|
|
break;
|
|
case Columns::ColumnId_HitObject:
|
|
string = &record.get().mHit;
|
|
break;
|
|
case Columns::ColumnId_AreaObject:
|
|
string = &record.get().mArea;
|
|
break;
|
|
case Columns::ColumnId_BoltObject:
|
|
string = &record.get().mBolt;
|
|
break;
|
|
}
|
|
|
|
if (!string)
|
|
throw std::logic_error("Unsupported column ID");
|
|
|
|
return QString::fromUtf8(string->getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESM::RefId* id = nullptr;
|
|
|
|
ESXRecordT record2 = record.get();
|
|
|
|
switch (this->mColumnId)
|
|
{
|
|
case Columns::ColumnId_CastingObject:
|
|
id = &record2.mCasting;
|
|
break;
|
|
case Columns::ColumnId_HitObject:
|
|
id = &record2.mHit;
|
|
break;
|
|
case Columns::ColumnId_AreaObject:
|
|
id = &record2.mArea;
|
|
break;
|
|
case Columns::ColumnId_BoltObject:
|
|
id = &record2.mBolt;
|
|
break;
|
|
}
|
|
|
|
if (!id)
|
|
throw std::logic_error("Unsupported column ID");
|
|
|
|
*id = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct EffectSoundColumn : public Column<ESXRecordT>
|
|
{
|
|
EffectSoundColumn(Columns::ColumnId columnId)
|
|
: Column<ESXRecordT>(columnId, ColumnBase::Display_Sound)
|
|
{
|
|
assert(this->mColumnId == Columns::ColumnId_CastingSound || this->mColumnId == Columns::ColumnId_HitSound
|
|
|| this->mColumnId == Columns::ColumnId_AreaSound || this->mColumnId == Columns::ColumnId_BoltSound);
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
const ESM::RefId* id = nullptr;
|
|
|
|
switch (this->mColumnId)
|
|
{
|
|
case Columns::ColumnId_CastingSound:
|
|
id = &record.get().mCastSound;
|
|
break;
|
|
case Columns::ColumnId_HitSound:
|
|
id = &record.get().mHitSound;
|
|
break;
|
|
case Columns::ColumnId_AreaSound:
|
|
id = &record.get().mAreaSound;
|
|
break;
|
|
case Columns::ColumnId_BoltSound:
|
|
id = &record.get().mBoltSound;
|
|
break;
|
|
}
|
|
|
|
if (!id)
|
|
throw std::logic_error("Unsupported column ID");
|
|
|
|
return QString::fromUtf8(id->getRefIdString().c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESM::RefId* id = nullptr;
|
|
|
|
ESXRecordT record2 = record.get();
|
|
|
|
switch (this->mColumnId)
|
|
{
|
|
case Columns::ColumnId_CastingSound:
|
|
id = &record2.mCastSound;
|
|
break;
|
|
case Columns::ColumnId_HitSound:
|
|
id = &record2.mHitSound;
|
|
break;
|
|
case Columns::ColumnId_AreaSound:
|
|
id = &record2.mAreaSound;
|
|
break;
|
|
case Columns::ColumnId_BoltSound:
|
|
id = &record2.mBoltSound;
|
|
break;
|
|
}
|
|
|
|
if (!id)
|
|
throw std::logic_error("Unsupported column ID");
|
|
|
|
*id = ESM::RefId::stringRefId(data.toString().toUtf8().constData());
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FormatColumn : public Column<ESXRecordT>
|
|
{
|
|
FormatColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_FileFormat, ColumnBase::Display_Integer)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override { return record.get().mFormatVersion; }
|
|
|
|
bool isEditable() const override { return false; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct AuthorColumn : public Column<ESXRecordT>
|
|
{
|
|
AuthorColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_Author, ColumnBase::Display_String32)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mAuthor.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mAuthor = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
template <typename ESXRecordT>
|
|
struct FileDescriptionColumn : public Column<ESXRecordT>
|
|
{
|
|
FileDescriptionColumn()
|
|
: Column<ESXRecordT>(Columns::ColumnId_FileDescription, ColumnBase::Display_LongString256)
|
|
{
|
|
}
|
|
|
|
QVariant get(const Record<ESXRecordT>& record) const override
|
|
{
|
|
return QString::fromUtf8(record.get().mDescription.c_str());
|
|
}
|
|
|
|
void set(Record<ESXRecordT>& record, const QVariant& data) override
|
|
{
|
|
ESXRecordT record2 = record.get();
|
|
|
|
record2.mDescription = data.toString().toUtf8().constData();
|
|
|
|
record.setModified(record2);
|
|
}
|
|
|
|
bool isEditable() const override { return true; }
|
|
};
|
|
|
|
struct LandTextureNicknameColumn : public Column<LandTexture>
|
|
{
|
|
LandTextureNicknameColumn();
|
|
|
|
QVariant get(const Record<LandTexture>& record) const override;
|
|
void set(Record<LandTexture>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandTextureIndexColumn : public Column<LandTexture>
|
|
{
|
|
LandTextureIndexColumn();
|
|
|
|
QVariant get(const Record<LandTexture>& record) const override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandPluginIndexColumn : public Column<Land>
|
|
{
|
|
LandPluginIndexColumn();
|
|
|
|
QVariant get(const Record<Land>& record) const override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandTexturePluginIndexColumn : public Column<LandTexture>
|
|
{
|
|
LandTexturePluginIndexColumn();
|
|
|
|
QVariant get(const Record<LandTexture>& record) const override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandNormalsColumn : public Column<Land>
|
|
{
|
|
using DataType = QVector<signed char>;
|
|
|
|
LandNormalsColumn();
|
|
|
|
QVariant get(const Record<Land>& record) const override;
|
|
void set(Record<Land>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandHeightsColumn : public Column<Land>
|
|
{
|
|
using DataType = QVector<float>;
|
|
|
|
LandHeightsColumn();
|
|
|
|
QVariant get(const Record<Land>& record) const override;
|
|
void set(Record<Land>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandColoursColumn : public Column<Land>
|
|
{
|
|
using DataType = QVector<unsigned char>;
|
|
|
|
LandColoursColumn();
|
|
|
|
QVariant get(const Record<Land>& record) const override;
|
|
void set(Record<Land>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct LandTexturesColumn : public Column<Land>
|
|
{
|
|
using DataType = QVector<uint16_t>;
|
|
|
|
LandTexturesColumn();
|
|
|
|
QVariant get(const Record<Land>& record) const override;
|
|
void set(Record<Land>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct BodyPartRaceColumn : public RaceColumn<ESM::BodyPart>
|
|
{
|
|
const MeshTypeColumn<ESM::BodyPart>* mMeshType;
|
|
|
|
BodyPartRaceColumn(const MeshTypeColumn<ESM::BodyPart>* meshType);
|
|
|
|
QVariant get(const Record<ESM::BodyPart>& record) const override;
|
|
void set(Record<ESM::BodyPart>& record, const QVariant& data) override;
|
|
bool isEditable() const override;
|
|
};
|
|
|
|
struct SelectionGroupColumn : public Column<ESM::SelectionGroup>
|
|
{
|
|
SelectionGroupColumn();
|
|
|
|
QVariant get(const Record<ESM::SelectionGroup>& record) const override;
|
|
|
|
void set(Record<ESM::SelectionGroup>& record, const QVariant& data) override;
|
|
|
|
bool isEditable() const override;
|
|
};
|
|
}
|
|
|
|
// This is required to access the type as a QVariant.
|
|
Q_DECLARE_METATYPE(CSMWorld::LandNormalsColumn::DataType)
|
|
Q_DECLARE_METATYPE(CSMWorld::LandHeightsColumn::DataType)
|
|
Q_DECLARE_METATYPE(CSMWorld::LandColoursColumn::DataType)
|
|
Q_DECLARE_METATYPE(CSMWorld::LandTexturesColumn::DataType)
|
|
|
|
#endif
|