File indexing completed on 2024-05-12 04:42:08

 /*
     SPDX-FileCopyrightText: 2023 Volker Krause <vkrause@kde.org>
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "amenitymodel.h"
 #include "localization.h"
 #include "logging.h"
 #include "osmelement.h"
 
 #include <style/mapcssdeclaration_p.h>
 #include <style/mapcssstate_p.h>
 
 #include <KOSMIndoorMap/MapCSSParser>
 #include <KOSMIndoorMap/MapCSSResult>
 
 #include <KLocalizedString>
 
 #include <QDebug>
 #include <QFile>
 #include <QPointF>
 
 #include <limits>
 
 using namespace KOSMIndoorMap;
 
 AmenityModel::AmenityModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_langs(OSM::Languages::fromQLocale(QLocale()))
 {
 }
 
 AmenityModel::~AmenityModel() = default;
 
 MapData AmenityModel::mapData() const
 {
     return m_data;
 }
 
 void AmenityModel::setMapData(const MapData &data)
 {
     if (m_data == data) {
         return;
     }
 
     if (m_style.isEmpty()) {
         MapCSSParser p;
         m_style = p.parse(QStringLiteral(":/org.kde.kosmindoormap/assets/quick/amenity-model.mapcss"));
         if (p.hasError()) {
             qWarning() << p.errorMessage();
             return;
         }
     }
 
     beginResetModel();
     m_entries.clear();
     m_data = data;
     if (!m_data.isEmpty()) {
         m_style.compile(m_data.dataSet());
     }
     endResetModel();
     Q_EMIT mapDataChanged();
 }
 
 int AmenityModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
 
     if (m_entries.empty() && !m_data.isEmpty()) {
         // we assume that this is expensive but almost never will result in an empty result
         // and if it does nevertheless, it's a sparsely populated tile where this is cheap
         const_cast<AmenityModel*>(this)->populateModel();
     }
 
     return (int)m_entries.size();
 }
 
 static QString groupName(AmenityModel::Group group)
 {
     switch (group) {
         case AmenityModel::UndefinedGroup:
             return {};
         case AmenityModel::FoodGroup:
             return i18nc("amenity category", "Food & Drinks");
         case AmenityModel::ShopGroup:
             return i18nc("amenity category", "Shops");
         case AmenityModel::ToiletGroup:
             return i18nc("amenity category", "Toilets");
         case AmenityModel::HealthcareGroup:
             return i18nc("amenity category", "Healthcare");
         case AmenityModel::AmenityGroup:
             return i18nc("amenity category", "Amenities");
         case AmenityModel::AccommodationGroup:
             return i18nc("amenity category", "Accommodations");
     }
     return {};
 }
 
 QString AmenityModel::iconSource(const AmenityModel::Entry &entry)
 {
     QString s = QLatin1String(":/org.kde.kosmindoormap/assets/icons/") + entry.icon + QLatin1String(".svg");
     return QFile::exists(s) ? s : QStringLiteral("map-symbolic");
 }
 
 QVariant AmenityModel::data(const QModelIndex &index, int role) const
 {
     if (!checkIndex(index)) {
         return {};
     }
 
     const auto &entry = m_entries[index.row()];
     switch (role) {
         case Qt::DisplayRole:
             return QString::fromUtf8(entry.element.tagValue(m_langs, "name", "loc_name", "int_name"));
             // TODO see name transliteration in OSM info model
         case TypeNameRole:
         {
             const auto types = entry.element.tagValue(entry.typeKey.constData()).split(';');
             QStringList l;
             for (const auto &type : types) {
                 auto s = Localization::amenityType(type.trimmed().constData(), Localization::ReturnEmptyOnUnknownKey);
                 if (!s.isEmpty()) {
                     l.push_back(std::move(s));
                 }
             }
             return QLocale().createSeparatedList(l);
         }
         case CoordinateRole:
         {
             const auto center = entry.element.center();
             return QPointF(center.lonF(), center.latF());
         }
         case LevelRole:
             return entry.level;
         case ElementRole:
             return QVariant::fromValue(OSMElement(entry.element));
         case GroupRole:
             return entry.group;
         case GroupNameRole:
             return groupName(entry.group);
         case IconSourceRole:
             return iconSource(entry);
         case CuisineRole:
             return Localization::cuisineTypes(entry.element.tagValue("cuisine"), Localization::ReturnEmptyOnUnknownKey);
         case FallbackNameRole:
             return QString::fromUtf8(entry.element.tagValue(m_langs, "brand", "operator", "network"));
         case OpeningHoursRole:
             return QString::fromUtf8(entry.element.tagValue("opening_hours"));
     }
 
     return {};
 }
 
 QHash<int, QByteArray> AmenityModel::roleNames() const
 {
     auto r = QAbstractListModel::roleNames();
     r.insert(NameRole, "name");
     r.insert(TypeNameRole, "typeName");
     r.insert(CoordinateRole, "coordinate");
     r.insert(LevelRole, "level");
     r.insert(ElementRole, "element");
     r.insert(GroupRole, "group");
     r.insert(GroupNameRole, "groupName");
     r.insert(IconSourceRole, "iconSource");
     r.insert(CuisineRole, "cuisine");
     r.insert(FallbackNameRole, "fallbackName");
     r.insert(OpeningHoursRole, "openingHours");
     return r;
 }
 
 struct {
     const char *groupName;
     AmenityModel::Group group;
 } constexpr const group_map[] = {
     { "accommodation", AmenityModel::AccommodationGroup },
     { "amenity", AmenityModel::AmenityGroup },
     { "healthcare", AmenityModel::HealthcareGroup },
     { "food", AmenityModel::FoodGroup },
     { "shop", AmenityModel::ShopGroup },
     { "toilets", AmenityModel::ToiletGroup },
 };
 
 void AmenityModel::populateModel()
 {
     const auto layerKey = m_data.dataSet().tagKey("layer");
 
     MapCSSResult filterResult;
     for (auto it = m_data.levelMap().begin(); it != m_data.levelMap().end(); ++it) {
         for (const auto &e : (*it).second) {
             if (!OSM::contains(m_data.boundingBox(), e.center())) {
                 continue;
             }
 
             MapCSSState filterState;
             filterState.element = e;
             m_style.evaluate(std::move(filterState), filterResult);
 
             const auto &res = filterResult[{}];
             if (auto prop = res.declaration(MapCSSProperty::Opacity); !prop || prop->doubleValue() < 1.0) {
                 continue; // hidden element
             }
 
             const auto group = res.tagValue(layerKey);
             const auto groupIt = std::find_if(std::begin(group_map), std::end(group_map), [&group](const auto &m) { return std::strcmp(m.groupName, group.constData()) == 0; });
             if (groupIt == std::end(group_map)) {
                 continue; // no group assigned
             }
 
             Entry entry;
             entry.element = e;
             entry.group = (*groupIt).group;
 
             QByteArray typeKey;
             if (auto prop = res.declaration(MapCSSProperty::FontFamily); prop) {
                 typeKey = prop->keyValue();
             }
             if (typeKey.isEmpty()) {
                 continue;
             }
 
             const auto types = e.tagValue(typeKey.constData()).split(';');
             for (const auto &type : types) {
                 if (Localization::hasAmenityTypeTranslation(type.trimmed().constData())) {
                     entry.typeKey = std::move(typeKey);
                     break;
                 }
             }
             if (entry.typeKey.isEmpty()) {
                 qCDebug(Log) << "unknown type: " << types << e.url();
                 continue;
             }
 
             if (auto prop = res.declaration(MapCSSProperty::IconImage); prop) {
                 entry.icon = prop->stringValue();
                 if (entry.icon.isEmpty()) {
                     entry.icon = QString::fromUtf8(e.tagValue(prop->keyValue().constData()));
                 }
             }
 
             entry.level = (*it).first.numericLevel(); // TODO we only need one entry, not one per level!
             m_entries.push_back(std::move(entry));
         }
     }
 
     // de-duplicate multi-level entries
     // we could also just iterate over the non-level-split data, but
     // then we need to reparse the level data here...
     std::sort(m_entries.begin(), m_entries.end(), [](const auto &lhs, const auto &rhs) {
         if (lhs.element == rhs.element) {
             return std::abs(lhs.level) < std::abs(rhs.level);
         }
         return lhs.element < rhs.element;
     });
     m_entries.erase(std::unique(m_entries.begin(), m_entries.end(), [](const auto &lhs, const auto &rhs) {
         return lhs.element == rhs.element;
     }), m_entries.end());
 
     // sort by group
     std::sort(m_entries.begin(), m_entries.end(), [](const auto &lhs, const auto &rhs) {
         return lhs.group < rhs.group;
     });
     qCDebug(Log) << m_entries.size() << "amenities found";
 }
 
 #include "moc_amenitymodel.cpp"