| /**************************************************************************** |
| ** |
| ** Copyright (C) 2020 Paolo Angelelli <paolo.angelelli@gmail.com> |
| ** Copyright (C) 2020 The Qt Company Ltd. |
| ** Contact: http://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtLocation module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL3$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see http://www.qt.io/terms-conditions. For further |
| ** information use the contact form at http://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPLv3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or later as published by the Free |
| ** Software Foundation and appearing in the file LICENSE.GPL included in |
| ** the packaging of this file. Please review the following information to |
| ** ensure the GNU General Public License version 2.0 requirements will be |
| ** met: http://www.gnu.org/licenses/gpl-2.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QDECLARATIVERECTANGLEMAPITEM_P_P_H |
| #define QDECLARATIVERECTANGLEMAPITEM_P_P_H |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // We mean it. |
| // |
| |
| #include <QtLocation/private/qlocationglobal_p.h> |
| #include <QtLocation/private/qdeclarativepolygonmapitem_p_p.h> |
| #include <QtLocation/private/qdeclarativerectanglemapitem_p.h> |
| #include <QtPositioning/private/qwebmercator_p.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| class Q_LOCATION_PRIVATE_EXPORT QDeclarativeRectangleMapItemPrivate |
| { |
| public: |
| QDeclarativeRectangleMapItemPrivate(QDeclarativeRectangleMapItem &rect) : m_rect(rect) |
| { |
| |
| } |
| QDeclarativeRectangleMapItemPrivate(QDeclarativeRectangleMapItemPrivate &other) : m_rect(other.m_rect) |
| { |
| } |
| |
| virtual ~QDeclarativeRectangleMapItemPrivate(); |
| virtual void onLinePropertiesChanged() = 0; |
| virtual void markSourceDirtyAndUpdate() = 0; |
| virtual void onMapSet() = 0; |
| virtual void onGeoGeometryChanged() = 0; |
| virtual void onItemGeometryChanged() = 0; |
| virtual void updatePolish() = 0; |
| virtual void afterViewportChanged() = 0; |
| virtual QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) = 0; |
| virtual bool contains(const QPointF &point) const = 0; |
| |
| QDeclarativeRectangleMapItem &m_rect; |
| }; |
| |
| class Q_LOCATION_PRIVATE_EXPORT QDeclarativeRectangleMapItemPrivateCPU: public QDeclarativeRectangleMapItemPrivate |
| { |
| public: |
| QDeclarativeRectangleMapItemPrivateCPU(QDeclarativeRectangleMapItem &rect) : QDeclarativeRectangleMapItemPrivate(rect) |
| { |
| } |
| |
| QDeclarativeRectangleMapItemPrivateCPU(QDeclarativeRectangleMapItemPrivate &other) |
| : QDeclarativeRectangleMapItemPrivate(other) |
| { |
| } |
| |
| ~QDeclarativeRectangleMapItemPrivateCPU() override; |
| |
| void onLinePropertiesChanged() override |
| { |
| // mark dirty just in case we're a width change |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void markSourceDirtyAndUpdate() override |
| { |
| m_geometry.markSourceDirty(); |
| m_borderGeometry.markSourceDirty(); |
| m_rect.polishAndUpdate(); |
| } |
| virtual void onMapSet() override |
| { |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void onGeoGeometryChanged() override |
| { |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void onItemGeometryChanged() override |
| { |
| m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void afterViewportChanged() override |
| { |
| m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void updatePolish() override |
| { |
| if (!m_rect.topLeft().isValid() || !m_rect.bottomRight().isValid()) { |
| m_geometry.clear(); |
| m_borderGeometry.clear(); |
| m_rect.setWidth(0); |
| m_rect.setHeight(0); |
| return; |
| } |
| |
| const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_rect.map()->geoProjection()); |
| |
| QScopedValueRollback<bool> rollback(m_rect.m_updatingGeometry); |
| m_rect.m_updatingGeometry = true; |
| |
| const QList<QGeoCoordinate> perimeter = path(m_rect.m_rectangle); |
| const QList<QDoubleVector2D> pathMercator_ = pathMercator(perimeter); |
| m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| m_geometry.updateSourcePoints(*m_rect.map(), pathMercator_); |
| m_geometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width()); |
| |
| QList<QGeoMapItemGeometry *> geoms; |
| geoms << &m_geometry; |
| m_borderGeometry.clear(); |
| |
| if (m_rect.m_border.color().alpha() != 0 && m_rect.m_border.width() > 0) { |
| QList<QDoubleVector2D> closedPath = pathMercator_; |
| closedPath << closedPath.first(); |
| |
| m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| const QGeoCoordinate &geometryOrigin = m_geometry.origin(); |
| |
| m_borderGeometry.srcPoints_.clear(); |
| m_borderGeometry.srcPointTypes_.clear(); |
| |
| QDoubleVector2D borderLeftBoundWrapped; |
| QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*m_rect.map(), closedPath, borderLeftBoundWrapped); |
| if (clippedPaths.size()) { |
| borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin); |
| m_borderGeometry.pathToScreen(*m_rect.map(), clippedPaths, borderLeftBoundWrapped); |
| m_borderGeometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width()); |
| |
| geoms << &m_borderGeometry; |
| } else { |
| m_borderGeometry.clear(); |
| } |
| } |
| |
| QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms); |
| m_rect.setWidth(combined.width() + 2 * m_rect.m_border.width()); // ToDo: fix this! 2 is incorrect |
| m_rect.setHeight(combined.height() + 2 * m_rect.m_border.width()); |
| |
| m_rect.setPositionOnMap(m_geometry.origin(), m_geometry.firstPointOffset()); |
| } |
| |
| virtual QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override |
| { |
| Q_UNUSED(data); |
| if (!m_node || !oldNode) { |
| m_node = new MapPolygonNode(); |
| if (oldNode) { |
| delete oldNode; |
| oldNode = nullptr; |
| } |
| } else { |
| m_node = static_cast<MapPolygonNode *>(oldNode); |
| } |
| |
| //TODO: update only material |
| if (m_geometry.isScreenDirty() || m_borderGeometry.isScreenDirty() || m_rect.m_dirtyMaterial) { |
| m_node->update(m_rect.m_color, m_rect.m_border.color(), &m_geometry, &m_borderGeometry); |
| m_geometry.setPreserveGeometry(false); |
| m_borderGeometry.setPreserveGeometry(false); |
| m_geometry.markClean(); |
| m_borderGeometry.markClean(); |
| m_rect.m_dirtyMaterial = false; |
| } |
| return m_node; |
| } |
| virtual bool contains(const QPointF &point) const override |
| { |
| return (m_geometry.contains(point) || m_borderGeometry.contains(point)); |
| } |
| |
| static QList<QGeoCoordinate> path(const QGeoRectangle &rect) |
| { |
| QList<QGeoCoordinate> res; |
| res << rect.topLeft(); |
| res << QGeoCoordinate(rect.topLeft().latitude(), rect.bottomRight().longitude()); |
| res << rect.bottomRight(); |
| res << QGeoCoordinate(rect.bottomRight().latitude(), rect.topLeft().longitude()); |
| return res; |
| } |
| |
| static QList<QGeoCoordinate> perimeter(const QGeoRectangle &rect) |
| { |
| QList<QGeoCoordinate> res; |
| res << rect.topLeft(); |
| res << QGeoCoordinate(rect.topLeft().latitude(), rect.bottomRight().longitude()); |
| res << rect.bottomRight(); |
| res << QGeoCoordinate(rect.bottomRight().latitude(), rect.topLeft().longitude()); |
| res << res.first(); |
| return res; |
| } |
| |
| static QList<QDoubleVector2D> pathMercator(const QList<QGeoCoordinate> &p) |
| { |
| QList<QDoubleVector2D> res; |
| for (const auto &c: p) |
| res << QWebMercator::coordToMercator(c); |
| return res; |
| } |
| |
| QGeoMapPolygonGeometry m_geometry; |
| QGeoMapPolylineGeometry m_borderGeometry; |
| MapPolygonNode *m_node = nullptr; |
| }; |
| |
| class Q_LOCATION_PRIVATE_EXPORT QDeclarativeRectangleMapItemPrivateOpenGL: public QDeclarativeRectangleMapItemPrivate |
| { |
| public: |
| QDeclarativeRectangleMapItemPrivateOpenGL(QDeclarativeRectangleMapItem &rect) : QDeclarativeRectangleMapItemPrivate(rect) |
| { |
| } |
| |
| QDeclarativeRectangleMapItemPrivateOpenGL(QDeclarativeRectangleMapItemPrivate &other) |
| : QDeclarativeRectangleMapItemPrivate(other) |
| { |
| } |
| |
| ~QDeclarativeRectangleMapItemPrivateOpenGL() override; |
| |
| void markScreenDirtyAndUpdate() |
| { |
| // preserveGeometry is cleared in updateMapItemPaintNode |
| m_geometry.markScreenDirty(); |
| m_borderGeometry.markScreenDirty(); |
| m_rect.polishAndUpdate(); |
| } |
| void onLinePropertiesChanged() override |
| { |
| m_rect.m_dirtyMaterial = true; |
| afterViewportChanged(); |
| } |
| virtual void markSourceDirtyAndUpdate() override |
| { |
| m_geometry.markSourceDirty(); |
| m_borderGeometry.markSourceDirty(); |
| m_rect.polishAndUpdate(); |
| } |
| void preserveGeometry() |
| { |
| m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft()); |
| } |
| virtual void onMapSet() override |
| { |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void onGeoGeometryChanged() override |
| { |
| preserveGeometry(); |
| markSourceDirtyAndUpdate(); |
| } |
| virtual void onItemGeometryChanged() override |
| { |
| onGeoGeometryChanged(); |
| } |
| virtual void afterViewportChanged() override |
| { |
| preserveGeometry(); |
| markScreenDirtyAndUpdate(); |
| } |
| virtual void updatePolish() override |
| { |
| if (!m_rect.topLeft().isValid() || !m_rect.bottomRight().isValid()) { |
| m_geometry.clear(); |
| m_borderGeometry.clear(); |
| m_rect.setWidth(0); |
| m_rect.setHeight(0); |
| return; |
| } |
| |
| QScopedValueRollback<bool> rollback(m_rect.m_updatingGeometry); |
| m_rect.m_updatingGeometry = true; |
| const qreal lineWidth = m_rect.m_border.width(); |
| const QColor &lineColor = m_rect.m_border.color(); |
| const QColor &fillColor = m_rect.color(); |
| if (fillColor.alpha() != 0) { |
| m_geometry.updateSourcePoints(*m_rect.map(), m_rect.m_rectangle); |
| m_geometry.markScreenDirty(); |
| m_geometry.updateScreenPoints(*m_rect.map(), lineWidth, lineColor); |
| } else { |
| m_geometry.clearBounds(); |
| } |
| |
| QGeoMapItemGeometry * geom = &m_geometry; |
| m_borderGeometry.clearScreen(); |
| if (lineColor.alpha() != 0 && lineWidth > 0) { |
| m_borderGeometry.updateSourcePoints(*m_rect.map(), m_rect.m_rectangle); |
| m_borderGeometry.markScreenDirty(); |
| m_borderGeometry.updateScreenPoints(*m_rect.map(), lineWidth); |
| geom = &m_borderGeometry; |
| } |
| m_rect.setWidth(geom->sourceBoundingBox().width()); |
| m_rect.setHeight(geom->sourceBoundingBox().height()); |
| m_rect.setPosition(1.0 * geom->firstPointOffset() - QPointF(lineWidth * 0.5,lineWidth * 0.5)); |
| } |
| |
| virtual QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override |
| { |
| Q_UNUSED(data); |
| |
| if (!m_rootNode || !oldNode) { |
| m_rootNode = new QDeclarativePolygonMapItemPrivateOpenGL::RootNode(); |
| m_node = new MapPolygonNodeGL(); |
| m_rootNode->appendChildNode(m_node); |
| m_polylinenode = new MapPolylineNodeOpenGLExtruded(); |
| m_rootNode->appendChildNode(m_polylinenode); |
| m_rootNode->markDirty(QSGNode::DirtyNodeAdded); |
| if (oldNode) |
| delete oldNode; |
| } else { |
| m_rootNode = static_cast<QDeclarativePolygonMapItemPrivateOpenGL::RootNode *>(oldNode); |
| } |
| |
| const QGeoMap *map = m_rect.map(); |
| const QMatrix4x4 &combinedMatrix = map->geoProjection().qsgTransform(); |
| const QDoubleVector3D &cameraCenter = map->geoProjection().centerMercator(); |
| |
| if (m_borderGeometry.isScreenDirty()) { |
| /* Do the border update first */ |
| m_polylinenode->update(m_rect.m_border.color(), |
| float(m_rect.m_border.width()), |
| &m_borderGeometry, |
| combinedMatrix, |
| cameraCenter, |
| Qt::SquareCap, |
| true, |
| 30); // No LOD for rectangles |
| m_borderGeometry.setPreserveGeometry(false); |
| m_borderGeometry.markClean(); |
| } else { |
| m_polylinenode->setSubtreeBlocked(true); |
| } |
| if (m_geometry.isScreenDirty()) { |
| m_node->update(m_rect.m_color, |
| &m_geometry, |
| combinedMatrix, |
| cameraCenter); |
| m_geometry.setPreserveGeometry(false); |
| m_geometry.markClean(); |
| } else { |
| m_node->setSubtreeBlocked(true); |
| } |
| |
| m_rootNode->setSubtreeBlocked(false); |
| return m_rootNode; |
| } |
| virtual bool contains(const QPointF &point) const override |
| { |
| const qreal lineWidth = m_rect.m_border.width(); |
| const QColor &lineColor = m_rect.m_border.color(); |
| const QRectF &bounds = (lineColor.alpha() != 0 && lineWidth > 0) ? m_borderGeometry.sourceBoundingBox() : m_geometry.sourceBoundingBox(); |
| if (bounds.contains(point)) { |
| QDeclarativeGeoMap *m = m_rect.quickMap(); |
| if (m) { |
| const QGeoCoordinate crd = m->toCoordinate(m->mapFromItem(&m_rect, point)); |
| return m_rect.m_rectangle.contains(crd) || m_borderGeometry.contains(m_rect.mapToItem(m_rect.quickMap(), point), |
| m_rect.border()->width(), |
| static_cast<const QGeoProjectionWebMercator&>(m_rect.map()->geoProjection())); |
| } else { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| QGeoMapPolygonGeometryOpenGL m_geometry; |
| QGeoMapPolylineGeometryOpenGL m_borderGeometry; |
| QDeclarativePolygonMapItemPrivateOpenGL::RootNode *m_rootNode = nullptr; |
| MapPolygonNodeGL *m_node = nullptr; |
| MapPolylineNodeOpenGLExtruded *m_polylinenode = nullptr; |
| }; |
| |
| QT_END_NAMESPACE |
| |
| #endif // QDECLARATIVERECTANGLEMAPITEM_P_P_H |
| |
