File indexing completed on 2024-11-24 04:15:36

 /*
     SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "floorlevelmodel.h"
 
 #include <KOSMIndoorMap/MapData>
 
 using namespace KOSMIndoorMap;
 
 FloorLevelModel::FloorLevelModel(QObject *parent)
     : QAbstractListModel(parent)
 {
     connect(this, &QAbstractItemModel::modelReset, this, &FloorLevelModel::contentChanged);
 }
 
 FloorLevelModel::~FloorLevelModel() = default;
 
 void FloorLevelModel::setMapData(MapData *data)
 {
     beginResetModel();
     m_level.clear();
     if (data) {
         for (const auto &l : data->levelMap()) {
             if (l.first.isFullLevel()) {
                 m_level.push_back(l.first);
             }
         }
     }
     endResetModel();
 }
 
 int FloorLevelModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
     return m_level.size();
 }
 
 QVariant FloorLevelModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return {};
     }
 
     switch (role) {
         case Qt::DisplayRole:
             return m_level[index.row()].name();
         case MapLevelRole:
             return QVariant::fromValue(m_level[index.row()]);
     }
 
     return {};
 }
 
 int FloorLevelModel::rowForLevel(int level) const
 {
     for (auto it = m_level.begin(); it != m_level.end(); ++it) {
         if ((*it).numericLevel() == level) {
             return std::distance(m_level.begin(), it);
         }
     }
     return -1;
 }
 
 int FloorLevelModel::levelForRow(int row) const
 {
     return m_level[row].numericLevel();
 }
 
 bool FloorLevelModel::hasFloorLevelBelow(int level) const
 {
     if (m_level.empty()) {
         return false;
     }
     return m_level.back().numericLevel() != level;
 }
 
 int FloorLevelModel::floorLevelBelow(int level) const
 {
     for (auto it = m_level.begin(); it != m_level.end(); ++it) {
         if ((*it).numericLevel() == level && std::next(it) != m_level.end()) {
             ++it;
             return (*it).numericLevel();
         }
     }
     return 0;
 }
 
 bool FloorLevelModel::hasFloorLevelAbove(int level) const
 {
     if (m_level.empty()) {
         return false;
     }
 
     return m_level.front().numericLevel() != level;
 }
 
 int FloorLevelModel::floorLevelAbove(int level) const
 {
     for (auto it = std::next(m_level.begin()); it != m_level.end(); ++it) {
         if ((*it).numericLevel() == level) {
             --it;
             return (*it).numericLevel();
         }
     }
     return 0;
 }
 
 bool FloorLevelModel::hasName(int level) const
 {
     for (auto it = m_level.begin(); it != m_level.end(); ++it) {
         if ((*it).numericLevel() == level) {
             return (*it).hasName();
         }
     }
     return false;
 }
 
 QString FloorLevelModel::name(int level) const
 {
     for (auto it = m_level.begin(); it != m_level.end(); ++it) {
         if ((*it).numericLevel() == level) {
             return (*it).name();
         }
     }
     return {};
 }
 
 bool FloorLevelModel::hasFloorLevels() const
 {
     return rowCount() > 1;
 }
 
 #include "moc_floorlevelmodel.cpp"