mirror of
https://github.com/ciphervance/supercell-wx.git
synced 2025-10-30 21:00:05 +00:00
393 lines
11 KiB
C++
393 lines
11 KiB
C++
#include <scwx/qt/model/layer_model.hpp>
|
|
#include <scwx/qt/manager/placefile_manager.hpp>
|
|
#include <scwx/qt/types/qt_types.hpp>
|
|
#include <scwx/util/logger.hpp>
|
|
|
|
#include <variant>
|
|
|
|
#include <QApplication>
|
|
#include <QCheckBox>
|
|
#include <QFontMetrics>
|
|
#include <QStyle>
|
|
#include <QStyleOption>
|
|
|
|
namespace scwx
|
|
{
|
|
namespace qt
|
|
{
|
|
namespace model
|
|
{
|
|
|
|
static const std::string logPrefix_ = "scwx::qt::model::layer_model";
|
|
static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
|
|
|
|
static constexpr int kFirstColumn = static_cast<int>(LayerModel::Column::Order);
|
|
static constexpr int kLastColumn =
|
|
static_cast<int>(LayerModel::Column::Description);
|
|
static constexpr int kNumColumns = kLastColumn - kFirstColumn + 1;
|
|
|
|
static const std::unordered_map<LayerModel::LayerType, std::string>
|
|
layerTypeNames_ {{LayerModel::LayerType::Map, "Map"},
|
|
{LayerModel::LayerType::Radar, "Radar"},
|
|
{LayerModel::LayerType::Alert, "Alert"},
|
|
{LayerModel::LayerType::Placefile, "Placefile"}};
|
|
|
|
class LayerModelImpl
|
|
{
|
|
public:
|
|
explicit LayerModelImpl() {}
|
|
~LayerModelImpl() = default;
|
|
|
|
std::shared_ptr<manager::PlacefileManager> placefileManager_ {
|
|
manager::PlacefileManager::Instance()};
|
|
|
|
std::vector<std::pair<LayerModel::LayerType, std::variant<std::string>>>
|
|
layers_ {};
|
|
};
|
|
|
|
LayerModel::LayerModel(QObject* parent) :
|
|
QAbstractTableModel(parent), p(std::make_unique<LayerModelImpl>())
|
|
{
|
|
connect(p->placefileManager_.get(),
|
|
&manager::PlacefileManager::PlacefileEnabled,
|
|
this,
|
|
&LayerModel::HandlePlacefileUpdate);
|
|
|
|
connect(p->placefileManager_.get(),
|
|
&manager::PlacefileManager::PlacefileRemoved,
|
|
this,
|
|
&LayerModel::HandlePlacefileRemoved);
|
|
|
|
connect(p->placefileManager_.get(),
|
|
&manager::PlacefileManager::PlacefileRenamed,
|
|
this,
|
|
&LayerModel::HandlePlacefileRenamed);
|
|
|
|
connect(p->placefileManager_.get(),
|
|
&manager::PlacefileManager::PlacefileUpdated,
|
|
this,
|
|
&LayerModel::HandlePlacefileUpdate);
|
|
}
|
|
LayerModel::~LayerModel() = default;
|
|
|
|
int LayerModel::rowCount(const QModelIndex& parent) const
|
|
{
|
|
return parent.isValid() ? 0 : static_cast<int>(p->layers_.size());
|
|
}
|
|
|
|
int LayerModel::columnCount(const QModelIndex& parent) const
|
|
{
|
|
return parent.isValid() ? 0 : kNumColumns;
|
|
}
|
|
|
|
Qt::ItemFlags LayerModel::flags(const QModelIndex& index) const
|
|
{
|
|
Qt::ItemFlags flags = QAbstractTableModel::flags(index);
|
|
|
|
switch (index.column())
|
|
{
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
flags |= Qt::ItemFlag::ItemIsUserCheckable | Qt::ItemFlag::ItemIsEditable;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
QVariant LayerModel::data(const QModelIndex& index, int role) const
|
|
{
|
|
static const QString enabledString = QObject::tr("Enabled");
|
|
static const QString disabledString = QObject::tr("Disabled");
|
|
|
|
if (!index.isValid() || index.row() < 0 ||
|
|
static_cast<std::size_t>(index.row()) >= p->layers_.size())
|
|
{
|
|
return QVariant();
|
|
}
|
|
|
|
const auto& layer = p->layers_.at(index.row());
|
|
bool enabled = true; // TODO
|
|
|
|
switch (index.column())
|
|
{
|
|
case static_cast<int>(Column::Order):
|
|
if (role == Qt::ItemDataRole::DisplayRole)
|
|
{
|
|
return index.row();
|
|
}
|
|
break;
|
|
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
// TODO
|
|
if (role == Qt::ItemDataRole::ToolTipRole)
|
|
{
|
|
return enabled ? enabledString : disabledString;
|
|
}
|
|
else if (role == Qt::ItemDataRole::CheckStateRole)
|
|
{
|
|
return static_cast<int>(enabled ? Qt::CheckState::Checked :
|
|
Qt::CheckState::Unchecked);
|
|
}
|
|
break;
|
|
|
|
case static_cast<int>(Column::Type):
|
|
if (role == Qt::ItemDataRole::DisplayRole ||
|
|
role == Qt::ItemDataRole::ToolTipRole)
|
|
{
|
|
return QString::fromStdString(layerTypeNames_.at(layer.first));
|
|
}
|
|
break;
|
|
|
|
case static_cast<int>(Column::Description):
|
|
if (role == Qt::ItemDataRole::DisplayRole ||
|
|
role == Qt::ItemDataRole::ToolTipRole)
|
|
{
|
|
if (layer.first == LayerType::Placefile)
|
|
{
|
|
std::string placefileName = std::get<std::string>(layer.second);
|
|
std::string description = placefileName;
|
|
std::string title =
|
|
p->placefileManager_->placefile_title(placefileName);
|
|
if (!title.empty())
|
|
{
|
|
description = title + '\n' + description;
|
|
}
|
|
|
|
return QString::fromStdString(description);
|
|
}
|
|
else
|
|
{
|
|
if (std::holds_alternative<std::string>(layer.second))
|
|
{
|
|
return QString::fromStdString(
|
|
std::get<std::string>(layer.second));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant
|
|
LayerModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if (role == Qt::ItemDataRole::DisplayRole)
|
|
{
|
|
if (orientation == Qt::Horizontal)
|
|
{
|
|
switch (section)
|
|
{
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
return tr("1");
|
|
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
return tr("2");
|
|
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
return tr("3");
|
|
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
return tr("4");
|
|
|
|
case static_cast<int>(Column::Type):
|
|
return tr("Type");
|
|
|
|
case static_cast<int>(Column::Description):
|
|
return tr("Description");
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (role == Qt::ItemDataRole::ToolTipRole)
|
|
{
|
|
switch (section)
|
|
{
|
|
case static_cast<int>(Column::Order):
|
|
return tr("Order");
|
|
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
return tr("Enabled on Map 1");
|
|
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
return tr("Enabled on Map 2");
|
|
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
return tr("Enabled on Map 3");
|
|
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
return tr("Enabled on Map 4");
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else if (role == Qt::ItemDataRole::SizeHintRole)
|
|
{
|
|
switch (section)
|
|
{
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
{
|
|
static const QCheckBox checkBox {};
|
|
QStyleOptionButton option {};
|
|
option.initFrom(&checkBox);
|
|
|
|
// Width values from QCheckBox
|
|
return QApplication::style()->sizeFromContents(
|
|
QStyle::ContentsType::CT_CheckBox,
|
|
&option,
|
|
{option.iconSize.width() + 4, 0});
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
bool LayerModel::setData(const QModelIndex& index,
|
|
const QVariant& value,
|
|
int role)
|
|
{
|
|
if (!index.isValid() || index.row() < 0 ||
|
|
static_cast<std::size_t>(index.row()) >= p->layers_.size())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto& layer = p->layers_.at(index.row());
|
|
bool result = false;
|
|
|
|
switch (index.column())
|
|
{
|
|
case static_cast<int>(Column::EnabledMap1):
|
|
case static_cast<int>(Column::EnabledMap2):
|
|
case static_cast<int>(Column::EnabledMap3):
|
|
case static_cast<int>(Column::EnabledMap4):
|
|
if (role == Qt::ItemDataRole::CheckStateRole)
|
|
{
|
|
// TODO
|
|
Q_UNUSED(layer);
|
|
Q_UNUSED(value);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
Q_EMIT dataChanged(index, index);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void LayerModel::HandlePlacefileRemoved(const std::string& name)
|
|
{
|
|
auto it = std::find_if(p->layers_.begin(),
|
|
p->layers_.end(),
|
|
[&name](const auto& layer)
|
|
{
|
|
return layer.first == LayerType::Placefile &&
|
|
std::get<std::string>(layer.second) == name;
|
|
});
|
|
|
|
if (it != p->layers_.end())
|
|
{
|
|
// Placefile exists, delete row
|
|
const int row = std::distance(p->layers_.begin(), it);
|
|
|
|
beginRemoveRows(QModelIndex(), row, row);
|
|
p->layers_.erase(it);
|
|
endRemoveRows();
|
|
}
|
|
}
|
|
|
|
void LayerModel::HandlePlacefileRenamed(const std::string& oldName,
|
|
const std::string& newName)
|
|
{
|
|
auto it =
|
|
std::find_if(p->layers_.begin(),
|
|
p->layers_.end(),
|
|
[&oldName](const auto& layer)
|
|
{
|
|
return layer.first == LayerType::Placefile &&
|
|
std::get<std::string>(layer.second) == oldName;
|
|
});
|
|
|
|
if (it != p->layers_.end())
|
|
{
|
|
// Placefile exists, mark row as updated
|
|
const int row = std::distance(p->layers_.begin(), it);
|
|
QModelIndex topLeft = createIndex(row, kFirstColumn);
|
|
QModelIndex bottomRight = createIndex(row, kLastColumn);
|
|
|
|
// Rename placefile
|
|
it->second = newName;
|
|
|
|
Q_EMIT dataChanged(topLeft, bottomRight);
|
|
}
|
|
else
|
|
{
|
|
// Placefile is new, append row
|
|
const int newIndex = static_cast<int>(p->layers_.size());
|
|
beginInsertRows(QModelIndex(), newIndex, newIndex);
|
|
p->layers_.push_back({LayerType::Placefile, newName});
|
|
endInsertRows();
|
|
}
|
|
}
|
|
|
|
void LayerModel::HandlePlacefileUpdate(const std::string& name)
|
|
{
|
|
auto it = std::find_if(p->layers_.begin(),
|
|
p->layers_.end(),
|
|
[&name](const auto& layer)
|
|
{
|
|
return layer.first == LayerType::Placefile &&
|
|
std::get<std::string>(layer.second) == name;
|
|
});
|
|
|
|
if (it != p->layers_.end())
|
|
{
|
|
// Placefile exists, mark row as updated
|
|
const int row = std::distance(p->layers_.begin(), it);
|
|
QModelIndex topLeft = createIndex(row, kFirstColumn);
|
|
QModelIndex bottomRight = createIndex(row, kLastColumn);
|
|
|
|
Q_EMIT dataChanged(topLeft, bottomRight);
|
|
}
|
|
else
|
|
{
|
|
// Placefile is new, append row
|
|
const int newIndex = static_cast<int>(p->layers_.size());
|
|
beginInsertRows(QModelIndex(), newIndex, newIndex);
|
|
p->layers_.push_back({LayerType::Placefile, name});
|
|
endInsertRows();
|
|
}
|
|
}
|
|
|
|
} // namespace model
|
|
} // namespace qt
|
|
} // namespace scwx
|