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

 /*
     SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "mapcsselementstate.h"
 #include "mapcssselector_p.h"
 #include "mapcsscondition_p.h"
 #include "mapcssresult.h"
 #include "mapcssstate_p.h"
 
 #include <QDebug>
 #include <QIODevice>
 
 #include <cmath>
 #include <cstring>
 
 using namespace KOSMIndoorMap;
 
 MapCSSSelector::MapCSSSelector() = default;
 MapCSSSelector::~MapCSSSelector() = default;
 
 MapCSSBasicSelector::MapCSSBasicSelector() = default;
 MapCSSBasicSelector::~MapCSSBasicSelector() = default;
 
 void MapCSSBasicSelector::compile(const OSM::DataSet &dataSet)
 {
     for (const auto &c : conditions) {
         c->compile(dataSet);
     }
 }
 
 bool MapCSSBasicSelector::matches(const MapCSSState &state, MapCSSResult &result, const std::vector<std::unique_ptr<MapCSSDeclaration>> &declarations) const
 {
     // check object type
     switch (m_objectType) {
         case MapCSSObjectType::Node: if (state.element.type() != OSM::Type::Node) return false; break;
         case MapCSSObjectType::Way: if (state.element.type() != OSM::Type::Way) return false; break;
         case MapCSSObjectType::Relation: if (state.element.type() != OSM::Type::Relation) return false; break;
         case MapCSSObjectType::Area: if (state.objectType !=MapCSSObjectType::Area && state.objectType != MapCSSObjectType::LineOrArea) return false; break;
         case MapCSSObjectType::Line: if (state.objectType !=MapCSSObjectType::Line && state.objectType != MapCSSObjectType::LineOrArea) return false; break;
         case MapCSSObjectType::Canvas: return false;
         case MapCSSObjectType::Any: break;
         case MapCSSObjectType::LineOrArea: Q_UNREACHABLE();
     }
 
     // check zoom level
     if (m_zoomLow > 0 && state.zoomLevel < m_zoomLow) {
         return false;
     }
     if (m_zoomHigh > 0 && state.zoomLevel >= m_zoomHigh) {
         return false;
     }
 
     if (!m_class.isNull() && !result[m_layer].hasClass(m_class)) {
         return false;
     }
 
     if (m_elementState && (state.state & m_elementState) == 0) {
         return false;
     }
 
     if (std::all_of(conditions.begin(), conditions.end(), [&state](const auto &cond) { return cond->matches(state); })) {
         result.applyDeclarations(m_layer, declarations);
         return true;
     }
     return false;
 }
 
 bool MapCSSBasicSelector::matchesCanvas(const MapCSSState &state) const
 {
     if (m_objectType != MapCSSObjectType::Canvas) {
         return false;
     }
 
     if (m_zoomLow > 0 && state.zoomLevel < m_zoomLow) {
         return false;
     }
     if (m_zoomHigh > 0 && state.zoomLevel >= m_zoomHigh) {
         return false;
     }
 
     return std::all_of(conditions.begin(), conditions.end(), [&state](const auto &cond) { return cond->matchesCanvas(state); });
 }
 
 LayerSelectorKey MapCSSBasicSelector::layerSelector() const
 {
     return m_layer;
 }
 
 struct {
     const char *name;
     MapCSSObjectType type;
 } static constexpr const object_type_map[] = {
     { "node", MapCSSObjectType::Node },
     { "way", MapCSSObjectType::Way },
     { "relation", MapCSSObjectType::Relation },
     { "area", MapCSSObjectType::Area },
     { "line", MapCSSObjectType::Line },
     { "canvas", MapCSSObjectType::Canvas },
     { "*", MapCSSObjectType::Any },
 };
 
 void MapCSSBasicSelector::write(QIODevice *out) const
 {
     for (const auto &t : object_type_map) {
         if (m_objectType == t.type) {
             out->write(t.name);
             break;
         }
     }
 
     if (!m_class.isNull()) {
         out->write(".");
         out->write(m_class.name());
     }
 
     if (m_zoomLow > 0 || m_zoomHigh > 0) {
         out->write("|z");
         if (m_zoomLow == m_zoomHigh) {
             out->write(QByteArray::number(m_zoomLow));
         } else {
             if (m_zoomLow > 0) {
                 out->write(QByteArray::number(m_zoomLow));
             }
             out->write("-");
             if (m_zoomHigh > 0) {
                 out->write(QByteArray::number(m_zoomHigh));
             }
         }
     }
 
     for (const auto &cond : conditions) {
         cond->write(out);
     }
 
     if (m_elementState & MapCSSElementState::Active) {
         out->write(":active");
     }
     if (m_elementState & MapCSSElementState::Hovered) {
         out->write(":hovered");
     }
 
     if (!m_layer.isNull()) {
         out->write("::");
         out->write(m_layer.name());
     }
 }
 
 void MapCSSBasicSelector::setObjectType(const char *str, std::size_t len)
 {
     for (const auto &t : object_type_map) {
         if (std::strncmp(t.name, str, std::max(std::strlen(t.name), len)) == 0) {
             m_objectType = t.type;
             return;
         }
     }
 }
 
 void MapCSSBasicSelector::setZoomRange(int low, int high)
 {
     m_zoomLow = low;
     m_zoomHigh = high;
 }
 
 void MapCSSBasicSelector::setConditions(MapCSSConditionHolder *conds)
 {
     if (!conds) {
         return;
     }
     conditions = std::move(conds->conditions);
     delete conds;
 }
 
 void MapCSSBasicSelector::setClass(ClassSelectorKey key)
 {
     m_class = key;
 }
 
 void MapCSSBasicSelector::setPseudoClass(const char *str, std::size_t len)
 {
     if (std::strncmp(str, "active", len) == 0) {
         m_elementState |= MapCSSElementState::Active;
     } else if (std::strncmp(str, "hovered", len) == 0) {
         m_elementState |= MapCSSElementState::Hovered;
     } else {
         qWarning() << "Unhandled pseudo class:" << QByteArrayView(str, (qsizetype)len);
     }
 }
 
 void MapCSSBasicSelector::setLayer(LayerSelectorKey key)
 {
     m_layer = key;
 }
 
 
 void MapCSSChainedSelector::compile(const OSM::DataSet &dataSet)
 {
     for (const auto &s : selectors) {
         s->compile(dataSet);
     }
 }
 
 bool MapCSSChainedSelector::matches([[maybe_unused]] const MapCSSState &state, [[maybe_unused]] MapCSSResult &result,
                                     [[maybe_unused]] const std::vector<std::unique_ptr<MapCSSDeclaration>> &declarations) const
 {
     // TODO
     return false;
 }
 
 bool MapCSSChainedSelector::matchesCanvas(const MapCSSState &state) const
 {
     Q_UNUSED(state);
     // canvas cannot be chained
     return false;
 }
 
 LayerSelectorKey MapCSSChainedSelector::layerSelector() const
 {
     return selectors.back()->layerSelector();
 }
 
 void MapCSSChainedSelector::write(QIODevice *out) const
 {
     assert(selectors.size() > 1);
     selectors[0]->write(out);
     for (auto it = std::next(selectors.begin()); it != selectors.end(); ++it) {
         out->write(" ");
         (*it)->write(out);
     }
 }
 
 
 MapCSSUnionSelector::MapCSSUnionSelector() = default;
 MapCSSUnionSelector::~MapCSSUnionSelector() = default;
 
 void MapCSSUnionSelector::compile(const OSM::DataSet &dataSet)
 {
     for (const auto &ls : m_selectors) {
         for (const auto &s : ls.selectors) {
             s->compile(dataSet);
         }
     }
 }
 
 bool MapCSSUnionSelector::matches(const MapCSSState &state, MapCSSResult &result, const std::vector<std::unique_ptr<MapCSSDeclaration>> &declarations) const
 {
     bool ret = false;
     for (const auto &ls : m_selectors) {
         if (std::any_of(ls.selectors.begin(), ls.selectors.end(), [&state, &result, &declarations](const auto &selector) {
             return selector->matches(state, result, declarations);
 
         })) {
             // no short-circuit evaluation, we want the matchCallback to be called once per matching layer!
             ret = true;
         }
     }
     return ret;
 }
 
 bool MapCSSUnionSelector::matchesCanvas(const MapCSSState &state) const
 {
     for (const auto &ls : m_selectors) {
         if (ls.layer.isNull()) {
             return std::any_of(ls.selectors.begin(), ls.selectors.end(), [&state](const auto &selector) { return selector->matchesCanvas(state); });
         }
     }
     return false;
 }
 
 LayerSelectorKey MapCSSUnionSelector::layerSelector() const
 {
     return {};
 }
 
 void MapCSSUnionSelector::write(QIODevice *out) const
 {
     for (std::size_t i = 0; i < m_selectors.size(); ++i) {
         for (std::size_t j = 0; j < m_selectors[i].selectors.size(); ++j) {
             if (i != 0 || j != 0) {
                 out->write(",\n");
             }
             m_selectors[i].selectors[j]->write(out);
         }
     }
 }
 
 void MapCSSUnionSelector::addSelector(std::unique_ptr<MapCSSSelector> &&selector)
 {
     auto it = std::find_if(m_selectors.begin(), m_selectors.end(), [&selector](const auto &ls) {
         return ls.layer == selector->layerSelector();
     });
     if (it != m_selectors.end()) {
         (*it).selectors.push_back(std::move(selector));
     } else {
         SelectorMap ls;
         ls.layer = selector->layerSelector();
         ls.selectors.push_back(std::move(selector));
         m_selectors.push_back(std::move(ls));
     }
 }