mirror of
https://github.com/OpenMW/openmw.git
synced 2025-02-01 16:15:36 +00:00
20da0892ef
Slowly moving through the open-cs errors Good progress in openCS Very good progress on openCS Getting closer with openCS OpenCS compiles and runs! Didn't have time to test it all though ix openMW everything compiles on windows?? Fix gcc Fix Clang
423 lines
12 KiB
C++
423 lines
12 KiB
C++
#include "idtable.hpp"
|
|
|
|
#include <QModelIndex>
|
|
#include <QVariant>
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <limits>
|
|
#include <map>
|
|
#include <stddef.h>
|
|
#include <stdexcept>
|
|
#include <type_traits>
|
|
|
|
#include <apps/opencs/model/world/columns.hpp>
|
|
#include <apps/opencs/model/world/idtablebase.hpp>
|
|
#include <apps/opencs/model/world/record.hpp>
|
|
#include <apps/opencs/model/world/universalid.hpp>
|
|
|
|
#include <components/esm3/cellid.hpp>
|
|
#include <components/misc/strings/lower.hpp>
|
|
|
|
#include "collectionbase.hpp"
|
|
#include "columnbase.hpp"
|
|
#include "landtexture.hpp"
|
|
|
|
CSMWorld::IdTable::IdTable(CollectionBase* idCollection, unsigned int features)
|
|
: IdTableBase(features)
|
|
, mIdCollection(idCollection)
|
|
{
|
|
}
|
|
|
|
CSMWorld::IdTable::~IdTable() {}
|
|
|
|
int CSMWorld::IdTable::rowCount(const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return 0;
|
|
|
|
return mIdCollection->getSize();
|
|
}
|
|
|
|
int CSMWorld::IdTable::columnCount(const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return 0;
|
|
|
|
return mIdCollection->getColumns();
|
|
}
|
|
|
|
QVariant CSMWorld::IdTable::data(const QModelIndex& index, int role) const
|
|
{
|
|
if (index.row() < 0 || index.column() < 0)
|
|
return QVariant();
|
|
|
|
if (role == ColumnBase::Role_Display)
|
|
return QVariant(mIdCollection->getColumn(index.column()).mDisplayType);
|
|
|
|
if (role == ColumnBase::Role_ColumnId)
|
|
return QVariant(getColumnId(index.column()));
|
|
|
|
if ((role != Qt::DisplayRole && role != Qt::EditRole))
|
|
return QVariant();
|
|
|
|
if (role == Qt::EditRole && !mIdCollection->getColumn(index.column()).isEditable())
|
|
return QVariant();
|
|
|
|
return mIdCollection->getData(index.row(), index.column());
|
|
}
|
|
|
|
QVariant CSMWorld::IdTable::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if (orientation == Qt::Vertical)
|
|
return QVariant();
|
|
|
|
if (orientation != Qt::Horizontal)
|
|
throw std::logic_error("Unknown header orientation specified");
|
|
|
|
if (role == Qt::DisplayRole)
|
|
return tr(mIdCollection->getColumn(section).getTitle().c_str());
|
|
|
|
if (role == ColumnBase::Role_Flags)
|
|
return mIdCollection->getColumn(section).mFlags;
|
|
|
|
if (role == ColumnBase::Role_Display)
|
|
return mIdCollection->getColumn(section).mDisplayType;
|
|
|
|
if (role == ColumnBase::Role_ColumnId)
|
|
return getColumnId(section);
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
bool CSMWorld::IdTable::setData(const QModelIndex& index, const QVariant& value, int role)
|
|
{
|
|
if (mIdCollection->getColumn(index.column()).isEditable() && role == Qt::EditRole)
|
|
{
|
|
mIdCollection->setData(index.row(), index.column(), value);
|
|
|
|
int stateColumn = searchColumnIndex(Columns::ColumnId_Modification);
|
|
if (stateColumn != -1)
|
|
{
|
|
if (index.column() == stateColumn)
|
|
{
|
|
// modifying the state column can modify other values. we need to tell
|
|
// views that the whole row has changed.
|
|
|
|
emit dataChanged(
|
|
this->index(index.row(), 0), this->index(index.row(), columnCount(index.parent()) - 1));
|
|
}
|
|
else
|
|
{
|
|
emit dataChanged(index, index);
|
|
|
|
// Modifying a value can also change the Modified status of a record.
|
|
QModelIndex stateIndex = this->index(index.row(), stateColumn);
|
|
emit dataChanged(stateIndex, stateIndex);
|
|
}
|
|
}
|
|
else
|
|
emit dataChanged(index, index);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Qt::ItemFlags CSMWorld::IdTable::flags(const QModelIndex& index) const
|
|
{
|
|
if (!index.isValid())
|
|
return Qt::ItemFlags();
|
|
|
|
Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
|
|
|
|
if (mIdCollection->getColumn(index.column()).isUserEditable())
|
|
flags |= Qt::ItemIsEditable;
|
|
|
|
int blockedColumn = searchColumnIndex(Columns::ColumnId_Blocked);
|
|
if (blockedColumn != -1 && blockedColumn != index.column())
|
|
{
|
|
bool isBlocked = mIdCollection->getData(index.row(), blockedColumn).toInt();
|
|
if (isBlocked)
|
|
flags = Qt::ItemIsSelectable; // not enabled (to grey out)
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
bool CSMWorld::IdTable::removeRows(int row, int count, const QModelIndex& parent)
|
|
{
|
|
if (parent.isValid())
|
|
return false;
|
|
|
|
beginRemoveRows(parent, row, row + count - 1);
|
|
|
|
mIdCollection->removeRows(row, count);
|
|
|
|
endRemoveRows();
|
|
|
|
return true;
|
|
}
|
|
|
|
QModelIndex CSMWorld::IdTable::index(int row, int column, const QModelIndex& parent) const
|
|
{
|
|
if (parent.isValid())
|
|
return QModelIndex();
|
|
|
|
if (row < 0 || row >= mIdCollection->getSize())
|
|
return QModelIndex();
|
|
|
|
if (column < 0 || column >= mIdCollection->getColumns())
|
|
return QModelIndex();
|
|
|
|
return createIndex(row, column);
|
|
}
|
|
|
|
QModelIndex CSMWorld::IdTable::parent(const QModelIndex& index) const
|
|
{
|
|
return QModelIndex();
|
|
}
|
|
|
|
void CSMWorld::IdTable::addRecord(const std::string& id, UniversalId::Type type)
|
|
{
|
|
ESM::RefId refId = ESM::RefId::stringRefId(id);
|
|
int index = mIdCollection->getAppendIndex(refId, type);
|
|
|
|
beginInsertRows(QModelIndex(), index, index);
|
|
|
|
mIdCollection->appendBlankRecord(refId, type);
|
|
|
|
endInsertRows();
|
|
}
|
|
|
|
void CSMWorld::IdTable::addRecordWithData(
|
|
const std::string& id, const std::map<int, QVariant>& data, UniversalId::Type type)
|
|
{
|
|
ESM::RefId refId = ESM::RefId::stringRefId(id);
|
|
int index = mIdCollection->getAppendIndex(refId, type);
|
|
|
|
beginInsertRows(QModelIndex(), index, index);
|
|
|
|
mIdCollection->appendBlankRecord(refId, type);
|
|
|
|
for (std::map<int, QVariant>::const_iterator iter(data.begin()); iter != data.end(); ++iter)
|
|
{
|
|
mIdCollection->setData(index, iter->first, iter->second);
|
|
}
|
|
|
|
endInsertRows();
|
|
}
|
|
|
|
void CSMWorld::IdTable::cloneRecord(
|
|
const ESM::RefId& origin, const ESM::RefId& destination, CSMWorld::UniversalId::Type type)
|
|
{
|
|
int index = mIdCollection->getAppendIndex(destination, type);
|
|
|
|
beginInsertRows(QModelIndex(), index, index);
|
|
mIdCollection->cloneRecord(origin, destination, type);
|
|
endInsertRows();
|
|
}
|
|
|
|
bool CSMWorld::IdTable::touchRecord(const std::string& id)
|
|
{
|
|
ESM::RefId refId = ESM::RefId::stringRefId(id);
|
|
bool changed = mIdCollection->touchRecord(refId);
|
|
|
|
int row = mIdCollection->getIndex(refId);
|
|
int column = mIdCollection->searchColumnIndex(Columns::ColumnId_RecordType);
|
|
if (changed && column != -1)
|
|
{
|
|
QModelIndex modelIndex = index(row, column);
|
|
emit dataChanged(modelIndex, modelIndex);
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
std::string CSMWorld::IdTable::getId(int row) const
|
|
{
|
|
return mIdCollection->getId(row).getRefIdString();
|
|
}
|
|
|
|
/// This method can return only indexes to the top level table cells
|
|
QModelIndex CSMWorld::IdTable::getModelIndex(const std::string& id, int column) const
|
|
{
|
|
int row = mIdCollection->searchId(id);
|
|
if (row != -1)
|
|
return index(row, column);
|
|
|
|
return QModelIndex();
|
|
}
|
|
|
|
void CSMWorld::IdTable::setRecord(
|
|
const std::string& id, std::unique_ptr<RecordBase> record, CSMWorld::UniversalId::Type type)
|
|
{
|
|
int index = mIdCollection->searchId(id);
|
|
|
|
if (index == -1)
|
|
{
|
|
// For info records, appendRecord may use a different index than the one returned by
|
|
// getAppendIndex (because of prev/next links). This can result in the display not
|
|
// updating correctly after an undo
|
|
//
|
|
// Use an alternative method to get the correct index. For non-Info records the
|
|
// record pointer is ignored and internally calls getAppendIndex.
|
|
int index2 = mIdCollection->getInsertIndex(id, type, record.get());
|
|
|
|
beginInsertRows(QModelIndex(), index2, index2);
|
|
|
|
mIdCollection->appendRecord(std::move(record), type);
|
|
|
|
endInsertRows();
|
|
}
|
|
else
|
|
{
|
|
mIdCollection->replace(index, std::move(record));
|
|
emit dataChanged(
|
|
CSMWorld::IdTable::index(index, 0), CSMWorld::IdTable::index(index, mIdCollection->getColumns() - 1));
|
|
}
|
|
}
|
|
|
|
const CSMWorld::RecordBase& CSMWorld::IdTable::getRecord(const std::string& id) const
|
|
{
|
|
return mIdCollection->getRecord(ESM::RefId::stringRefId(id));
|
|
}
|
|
|
|
int CSMWorld::IdTable::searchColumnIndex(Columns::ColumnId id) const
|
|
{
|
|
return mIdCollection->searchColumnIndex(id);
|
|
}
|
|
|
|
int CSMWorld::IdTable::findColumnIndex(Columns::ColumnId id) const
|
|
{
|
|
return mIdCollection->findColumnIndex(id);
|
|
}
|
|
|
|
void CSMWorld::IdTable::reorderRows(int baseIndex, const std::vector<int>& newOrder)
|
|
{
|
|
if (!newOrder.empty())
|
|
if (mIdCollection->reorderRows(baseIndex, newOrder))
|
|
emit dataChanged(index(baseIndex, 0),
|
|
index(baseIndex + static_cast<int>(newOrder.size()) - 1, mIdCollection->getColumns() - 1));
|
|
}
|
|
|
|
std::pair<CSMWorld::UniversalId, std::string> CSMWorld::IdTable::view(int row) const
|
|
{
|
|
std::string id;
|
|
std::string hint;
|
|
|
|
if (getFeatures() & Feature_ViewCell)
|
|
{
|
|
int cellColumn = mIdCollection->searchColumnIndex(Columns::ColumnId_Cell);
|
|
int idColumn = mIdCollection->searchColumnIndex(Columns::ColumnId_Id);
|
|
|
|
if (cellColumn != -1 && idColumn != -1)
|
|
{
|
|
id = mIdCollection->getData(row, cellColumn).toString().toUtf8().constData();
|
|
hint = "r:" + std::string(mIdCollection->getData(row, idColumn).toString().toUtf8().constData());
|
|
}
|
|
}
|
|
else if (getFeatures() & Feature_ViewId)
|
|
{
|
|
int column = mIdCollection->searchColumnIndex(Columns::ColumnId_Id);
|
|
|
|
if (column != -1)
|
|
{
|
|
id = mIdCollection->getData(row, column).toString().toUtf8().constData();
|
|
hint = "c:" + id;
|
|
}
|
|
}
|
|
|
|
if (id.empty())
|
|
return std::make_pair(UniversalId::Type_None, "");
|
|
|
|
if (id[0] == '#')
|
|
id = ESM::CellId::sDefaultWorldspace;
|
|
|
|
return std::make_pair(UniversalId(UniversalId::Type_Scene, id), hint);
|
|
}
|
|
|
|
/// For top level data/columns
|
|
bool CSMWorld::IdTable::isDeleted(const std::string& id) const
|
|
{
|
|
return getRecord(id).isDeleted();
|
|
}
|
|
|
|
int CSMWorld::IdTable::getColumnId(int column) const
|
|
{
|
|
return mIdCollection->getColumn(column).getId();
|
|
}
|
|
|
|
CSMWorld::CollectionBase* CSMWorld::IdTable::idCollection() const
|
|
{
|
|
return mIdCollection;
|
|
}
|
|
|
|
CSMWorld::LandTextureIdTable::LandTextureIdTable(CollectionBase* idCollection, unsigned int features)
|
|
: IdTable(idCollection, features)
|
|
{
|
|
}
|
|
|
|
CSMWorld::LandTextureIdTable::ImportResults CSMWorld::LandTextureIdTable::importTextures(
|
|
const std::vector<std::string>& ids)
|
|
{
|
|
ImportResults results;
|
|
|
|
// Map existing textures to ids
|
|
std::map<std::string, std::string> reverseLookupMap;
|
|
for (int i = 0; i < idCollection()->getSize(); ++i)
|
|
{
|
|
auto& record = static_cast<const Record<LandTexture>&>(idCollection()->getRecord(i));
|
|
if (record.isModified())
|
|
reverseLookupMap.emplace(Misc::StringUtils::lowerCase(record.get().mTexture), idCollection()->getId(i).getRefIdString());
|
|
}
|
|
|
|
for (const std::string& id : ids)
|
|
{
|
|
int plugin, index;
|
|
|
|
LandTexture::parseUniqueRecordId(id, plugin, index);
|
|
int oldRow = idCollection()->searchId(id);
|
|
|
|
// If it does not exist or it is in the current plugin, it can be skipped.
|
|
if (oldRow < 0 || plugin == 0)
|
|
{
|
|
results.recordMapping.emplace_back(id, id);
|
|
continue;
|
|
}
|
|
|
|
// Look for a pre-existing record
|
|
auto& record = static_cast<const Record<LandTexture>&>(idCollection()->getRecord(oldRow));
|
|
std::string texture = Misc::StringUtils::lowerCase(record.get().mTexture);
|
|
auto searchIt = reverseLookupMap.find(texture);
|
|
if (searchIt != reverseLookupMap.end())
|
|
{
|
|
results.recordMapping.emplace_back(id, searchIt->second);
|
|
continue;
|
|
}
|
|
|
|
// Iterate until an unused index or found, or the index has completely wrapped around.
|
|
int startIndex = index;
|
|
do
|
|
{
|
|
std::string newId = LandTexture::createUniqueRecordId(0, index);
|
|
int newRow = idCollection()->searchId(newId);
|
|
|
|
if (newRow < 0)
|
|
{
|
|
// Id not taken, clone it
|
|
cloneRecord(ESM::RefId::stringRefId(id), ESM::RefId::stringRefId(newId), UniversalId::Type_LandTexture);
|
|
results.createdRecords.push_back(newId);
|
|
results.recordMapping.emplace_back(id, newId);
|
|
reverseLookupMap.emplace(texture, newId);
|
|
break;
|
|
}
|
|
|
|
const size_t MaxIndex = std::numeric_limits<uint16_t>::max() - 1;
|
|
index = (index + 1) % MaxIndex;
|
|
} while (index != startIndex);
|
|
}
|
|
|
|
return results;
|
|
}
|