diff options
39 files changed, 2183 insertions, 35 deletions
diff --git a/src/location/declarativemaps/qdeclarativecirclemapitem.cpp b/src/location/declarativemaps/qdeclarativecirclemapitem.cpp index 68e61ee5..e8b73ae5 100644 --- a/src/location/declarativemaps/qdeclarativecirclemapitem.cpp +++ b/src/location/declarativemaps/qdeclarativecirclemapitem.cpp @@ -501,7 +501,7 @@ void QDeclarativeCircleMapItem::updatePolish() QList<QDoubleVector2D> circlePath = circlePath_; int pathCount = circlePath.size(); - bool preserve = preserveCircleGeometry(circlePath, circle_.center(), circle_.radius()); + bool preserve = preserveCircleGeometry(circlePath, circle_.center(), circle_.radius(), p); // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft()); // to fix QTBUG-62154 geometry_.setPreserveGeometry(true, leftBound_); // to set the geoLeftBound_ @@ -623,11 +623,11 @@ void QDeclarativeCircleMapItem::geometryChanged(const QRectF &newGeometry, const } bool QDeclarativeCircleMapItem::preserveCircleGeometry (QList<QDoubleVector2D> &path, - const QGeoCoordinate ¢er, qreal distance) + const QGeoCoordinate ¢er, qreal distance, const QGeoProjectionWebMercator &p) { // if circle crosses north/south pole, then don't preserve circular shape, if ( crossEarthPole(center, distance)) { - updateCirclePathForRendering(path, center, distance); + updateCirclePathForRendering(path, center, distance, p); return false; } return true; @@ -653,9 +653,8 @@ bool QDeclarativeCircleMapItem::preserveCircleGeometry (QList<QDoubleVector2D> & */ void QDeclarativeCircleMapItem::updateCirclePathForRendering(QList<QDoubleVector2D> &path, const QGeoCoordinate ¢er, - qreal distance) + qreal distance, const QGeoProjectionWebMercator &p) { - const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map()->geoProjection()); const qreal poleLat = 90; const qreal distanceToNorthPole = center.distanceTo(QGeoCoordinate(poleLat, 0)); const qreal distanceToSouthPole = center.distanceTo(QGeoCoordinate(-poleLat, 0)); diff --git a/src/location/declarativemaps/qdeclarativecirclemapitem_p.h b/src/location/declarativemaps/qdeclarativecirclemapitem_p.h index bb359ee3..2e8c56f8 100644 --- a/src/location/declarativemaps/qdeclarativecirclemapitem_p.h +++ b/src/location/declarativemaps/qdeclarativecirclemapitem_p.h @@ -58,7 +58,7 @@ QT_BEGIN_NAMESPACE -class QGeoMapCircleGeometry : public QGeoMapPolygonGeometry +class Q_LOCATION_PRIVATE_EXPORT QGeoMapCircleGeometry : public QGeoMapPolygonGeometry { public: QGeoMapCircleGeometry(); @@ -99,8 +99,10 @@ public: static bool crossEarthPole(const QGeoCoordinate ¢er, qreal distance); static void calculatePeripheralPoints(QList<QGeoCoordinate> &path, const QGeoCoordinate ¢er, qreal distance, int steps, QGeoCoordinate &leftBound); - bool preserveCircleGeometry(QList<QDoubleVector2D> &path, const QGeoCoordinate ¢er, - qreal distance); + static bool preserveCircleGeometry(QList<QDoubleVector2D> &path, const QGeoCoordinate ¢er, + qreal distance, const QGeoProjectionWebMercator &p); + static void updateCirclePathForRendering(QList<QDoubleVector2D> &path, const QGeoCoordinate ¢er, + qreal distance, const QGeoProjectionWebMercator &p); Q_SIGNALS: void centerChanged(const QGeoCoordinate ¢er); @@ -117,8 +119,6 @@ protected Q_SLOTS: private: void updateCirclePath(); - void updateCirclePathForRendering(QList<QDoubleVector2D> &path, const QGeoCoordinate ¢er, - qreal distance); private: QGeoCircle circle_; diff --git a/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h b/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h index 72bfd856..1e2a91c9 100644 --- a/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h +++ b/src/location/declarativemaps/qdeclarativepolygonmapitem_p.h @@ -60,7 +60,7 @@ QT_BEGIN_NAMESPACE class MapPolygonNode; -class QGeoMapPolygonGeometry : public QGeoMapItemGeometry +class Q_LOCATION_PRIVATE_EXPORT QGeoMapPolygonGeometry : public QGeoMapItemGeometry { public: QGeoMapPolygonGeometry(); @@ -137,7 +137,7 @@ private: ////////////////////////////////////////////////////////////////////// -class MapPolygonNode : public QSGGeometryNode +class Q_LOCATION_PRIVATE_EXPORT MapPolygonNode : public QSGGeometryNode { public: diff --git a/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp b/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp index 3b004dce..632f71d7 100644 --- a/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp +++ b/src/location/declarativemaps/qdeclarativepolylinemapitem.cpp @@ -410,6 +410,12 @@ void QGeoMapPolylineGeometry::updateScreenPoints(const QGeoMap &map, this->translate( -1 * sourceBounds_.topLeft()); } +void QGeoMapPolylineGeometry::clearSource() +{ + srcPoints_.clear(); + srcPointTypes_.clear(); +} + QDeclarativePolylineMapItem::QDeclarativePolylineMapItem(QQuickItem *parent) : QDeclarativeGeoMapItemBase(parent), line_(this), dirtyMaterial_(true), updatingGeometry_(false) { diff --git a/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h b/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h index 03fba636..61439097 100644 --- a/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h +++ b/src/location/declarativemaps/qdeclarativepolylinemapitem_p.h @@ -85,7 +85,7 @@ private: QColor color_; }; -class QGeoMapPolylineGeometry : public QGeoMapItemGeometry +class Q_LOCATION_PRIVATE_EXPORT QGeoMapPolylineGeometry : public QGeoMapItemGeometry { public: QGeoMapPolylineGeometry(); @@ -97,7 +97,8 @@ public: void updateScreenPoints(const QGeoMap &map, qreal strokeWidth); -protected: + void clearSource(); + QList<QList<QDoubleVector2D> > clipPath(const QGeoMap &map, const QList<QDoubleVector2D> &path, QDoubleVector2D &leftBoundWrapped); @@ -177,7 +178,7 @@ private: ////////////////////////////////////////////////////////////////////// -class MapPolylineNode : public QSGGeometryNode +class Q_LOCATION_PRIVATE_EXPORT MapPolylineNode : public QSGGeometryNode { public: diff --git a/src/location/declarativemaps/qgeomapitemgeometry_p.h b/src/location/declarativemaps/qgeomapitemgeometry_p.h index 595107ae..5149a7c0 100644 --- a/src/location/declarativemaps/qgeomapitemgeometry_p.h +++ b/src/location/declarativemaps/qgeomapitemgeometry_p.h @@ -63,7 +63,7 @@ QT_BEGIN_NAMESPACE class QSGGeometry; class QGeoMap; -class QGeoMapItemGeometry +class Q_LOCATION_PRIVATE_EXPORT QGeoMapItemGeometry { public: QGeoMapItemGeometry(); @@ -124,6 +124,9 @@ public: static QRectF translateToCommonOrigin(const QList<QGeoMapItemGeometry *> &geoms); +private: + QGeoMapItemGeometry(const QGeoMapItemGeometry &other); // Or else it may crash on copy + QGeoMapItemGeometry &operator= (const QGeoMapItemGeometry & other); // Or else it may crash on copy protected: bool sourceDirty_; diff --git a/src/location/declarativemaps/qgeomapobject.cpp b/src/location/declarativemaps/qgeomapobject.cpp index 2e81afa9..d1d78b66 100644 --- a/src/location/declarativemaps/qgeomapobject.cpp +++ b/src/location/declarativemaps/qgeomapobject.cpp @@ -185,7 +185,7 @@ void QGeoMapObject::setMap(QGeoMap *map) d_ptr->m_componentCompleted = oldCmponentCompleted; d_ptr->setVisible(oldVisible); } - d_ptr->m_map = map; + d_ptr->setMap(map); const QList<QGeoMapObject *> kids = geoMapObjectChildren(); for (auto kid : kids) @@ -269,4 +269,9 @@ void QGeoMapObjectPrivate::setVisible(bool visible) m_visible = visible; } +void QGeoMapObjectPrivate::setMap(QGeoMap *map) +{ + m_map = map; +} + QT_END_NAMESPACE diff --git a/src/location/declarativemaps/qgeomapobject_p_p.h b/src/location/declarativemaps/qgeomapobject_p_p.h index 000a992d..fa788b00 100644 --- a/src/location/declarativemaps/qgeomapobject_p_p.h +++ b/src/location/declarativemaps/qgeomapobject_p_p.h @@ -72,6 +72,7 @@ public: virtual QGeoMapObject::Type type() const; virtual bool visible() const; virtual void setVisible(bool visible); + virtual void setMap(QGeoMap *map); virtual QGeoMapObjectPrivate *clone() = 0; // to allow proper detaching QGeoMapObject *q = nullptr; diff --git a/src/location/labs/labs.pri b/src/location/labs/labs.pri index de2fd820..2da5e90d 100644 --- a/src/location/labs/labs.pri +++ b/src/location/labs/labs.pri @@ -1,4 +1,4 @@ INCLUDEPATH += labs -PRIVATE_HEADERS += $$files($$PWD/*.h) -SOURCES += $$files($$PWD/*.cpp) +PRIVATE_HEADERS += $$files($$PWD/*.h) $$files($$PWD/qsg/*.h) +SOURCES += $$files($$PWD/*.cpp) $$files($$PWD/qsg/*.cpp) diff --git a/src/location/labs/qgeotiledmaplabs.cpp b/src/location/labs/qgeotiledmaplabs.cpp new file mode 100644 index 00000000..2e4b2c16 --- /dev/null +++ b/src/location/labs/qgeotiledmaplabs.cpp @@ -0,0 +1,295 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qgeotiledmaplabs_p.h" +#include <QtLocation/private/qgeotiledmap_p_p.h> +#include <QtLocation/private/qgeomapobject_p.h> +#include <QtLocation/private/qmappolylineobjectqsg_p_p.h> +#include <QtLocation/private/qmappolygonobjectqsg_p_p.h> +#include <QtLocation/private/qmapcircleobjectqsg_p_p.h> +#include <QtLocation/private/qmaprouteobjectqsg_p_p.h> +#include <QtLocation/private/qmapiconobjectqsg_p_p.h> + +QT_BEGIN_NAMESPACE + +struct MapObject { + MapObject(QPointer<QGeoMapObject> &o, QQSGMapObject *sgo) + : object(o), sgObject(sgo) {} + QPointer<QGeoMapObject> object; + QQSGMapObject *sgObject = nullptr; +}; + +class QGeoTiledMapLabsPrivate : public QGeoTiledMapPrivate +{ + Q_DECLARE_PUBLIC(QGeoTiledMapLabs) +public: + QGeoTiledMapLabsPrivate(QGeoTiledMappingManagerEngine *engine); + virtual ~QGeoTiledMapLabsPrivate(); + + QGeoMapObjectPrivate *createMapObjectImplementation(QGeoMapObject *obj) override; + virtual QList<QGeoMapObject *> mapObjects() const override; + static int findMapObject(QGeoMapObject *o, const QList<MapObject> &list); + void removeMapObject(QGeoMapObject *obj); + + void updateMapObjects(QSGNode *root, QQuickWindow *window); + void updateObjectsGeometry(); + +protected: + void changeViewportSize(const QSize &size) override; + void changeCameraData(const QGeoCameraData &oldCameraData) override; + void changeActiveMapType(const QGeoMapType mapType) override; + + QList<MapObject> m_mapObjects; + QList<MapObject> m_pendingMapObjects; +}; + +QGeoTiledMapLabsPrivate::QGeoTiledMapLabsPrivate(QGeoTiledMappingManagerEngine *engine) + : QGeoTiledMapPrivate(engine) +{ + +} + +QGeoTiledMapLabsPrivate::~QGeoTiledMapLabsPrivate() +{ + +} + +QGeoMapObjectPrivate *QGeoTiledMapLabsPrivate::createMapObjectImplementation(QGeoMapObject *obj) +{ + switch (obj->type()) { + case QGeoMapObject::PolylineType: { + QMapPolylineObjectPrivate &oldImpl = static_cast<QMapPolylineObjectPrivate &>(*obj->implementation()); + QMapPolylineObjectPrivateQSG *pimpl = + new QMapPolylineObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::PolygonType: { + QMapPolygonObjectPrivate &oldImpl = static_cast<QMapPolygonObjectPrivate &>(*obj->implementation()); + QMapPolygonObjectPrivateQSG *pimpl = + new QMapPolygonObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::CircleType: { + QMapCircleObjectPrivate &oldImpl = static_cast<QMapCircleObjectPrivate &>(*obj->implementation()); + QMapCircleObjectPrivateQSG *pimpl = + new QMapCircleObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::RouteType: { + QMapRouteObjectPrivate &oldImpl = static_cast<QMapRouteObjectPrivate &>(*obj->implementation()); + QMapRouteObjectPrivateQSG *pimpl = + new QMapRouteObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::IconType: { + QMapIconObjectPrivate &oldImpl = static_cast<QMapIconObjectPrivate &>(*obj->implementation()); + QMapIconObjectPrivateQSG *pimpl = + new QMapIconObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + default: + qWarning() << "Unsupported object type: " << obj->type(); + break; + } + return nullptr; +} + +QList<QGeoMapObject *> QGeoTiledMapLabsPrivate::mapObjects() const +{ + return QList<QGeoMapObject *>(); +} + +int QGeoTiledMapLabsPrivate::findMapObject(QGeoMapObject *o, const QList<MapObject> &list) +{ + for (int i = 0; i < list.size(); ++i) + { + if (list.at(i).object.data() == o) + return i; + } + return -1; +} + +void QGeoTiledMapLabsPrivate::removeMapObject(QGeoMapObject *obj) +{ + int idx = findMapObject(obj, m_mapObjects); + if (idx >= 0) { + m_mapObjects.removeAt(idx); + } else { + idx = findMapObject(obj, m_pendingMapObjects); + if (idx >= 0) { + m_pendingMapObjects.removeAt(idx); + } else { + // obj not here. + } + } +} + +void QGeoTiledMapLabsPrivate::updateMapObjects(QSGNode *root, QQuickWindow *window) +{ + for (int i = 0; i < m_mapObjects.size(); ++i) { + // already added as node + if (!m_mapObjects.at(i).object) { + qWarning() << "m_mapObjects at "<<i<< " NULLed!!"; + continue; + } + + QQSGMapObject *sgo = m_mapObjects.at(i).sgObject; + QSGNode *oldNode = sgo->node; + sgo->node = sgo->updateMapObjectNode(oldNode, root, window); + } + + QList<int> toRemove; + for (int i = 0; i < m_pendingMapObjects.size(); ++i) { + // already added as node + QQSGMapObject *sgo = m_pendingMapObjects.at(i).sgObject; + QSGNode *oldNode = sgo->node; + sgo->updateGeometry(); // or subtree will be blocked + sgo->node = sgo->updateMapObjectNode(oldNode, root, window); + if (sgo->node) { + m_mapObjects << m_pendingMapObjects.at(i); + toRemove.push_front(i); + } else { + // leave it to be processed + } + } + + for (int i: qAsConst(toRemove)) + m_pendingMapObjects.removeAt(i); +} + +void QGeoTiledMapLabsPrivate::updateObjectsGeometry() +{ + Q_Q(QGeoTiledMapLabs); + for (int i = 0; i < m_mapObjects.size(); ++i) { + // already added as node + if (!m_mapObjects.at(i).object) { + qWarning() << "m_mapObjects at "<<i<< " NULLed!!"; + continue; + } + + QQSGMapObject *sgo = m_mapObjects.at(i).sgObject; + sgo->updateGeometry(); + } + emit q->sgNodeChanged(); +} + +void QGeoTiledMapLabsPrivate::changeViewportSize(const QSize &size) +{ + updateObjectsGeometry(); + QGeoTiledMapPrivate::changeViewportSize(size); +} + +void QGeoTiledMapLabsPrivate::changeCameraData(const QGeoCameraData &oldCameraData) +{ + updateObjectsGeometry(); + QGeoTiledMapPrivate::changeCameraData(oldCameraData); +} + +void QGeoTiledMapLabsPrivate::changeActiveMapType(const QGeoMapType mapType) +{ + updateObjectsGeometry(); + QGeoTiledMapPrivate::changeActiveMapType(mapType); +} + + +/* + QGeoTiledMapLabs +*/ + + + +QGeoTiledMapLabs::QGeoTiledMapLabs(QGeoTiledMappingManagerEngine *engine, QObject *parent) + : QGeoTiledMap(*new QGeoTiledMapLabsPrivate(engine), engine, parent) +{ + +} + +QGeoTiledMapLabs::~QGeoTiledMapLabs() +{ + +} + +bool QGeoTiledMapLabs::createMapObjectImplementation(QGeoMapObject *obj) +{ + Q_D(QGeoTiledMapLabs); + QExplicitlySharedDataPointer<QGeoMapObjectPrivate> pimpl = + QExplicitlySharedDataPointer<QGeoMapObjectPrivate>(d->createMapObjectImplementation(obj)); + if (pimpl.constData()) { + bool res = obj->setImplementation(pimpl); + if (res) + emit sgNodeChanged(); + return res; + } + return false; +} + +QSGNode *QGeoTiledMapLabs::updateSceneGraph(QSGNode *node, QQuickWindow *window) +{ + Q_D(QGeoTiledMapLabs); + QSGNode *root = QGeoTiledMap::updateSceneGraph(node, window); + d->updateMapObjects(root, window); + return root; +} + +void QGeoTiledMapLabs::removeMapObject(QGeoMapObject *obj) +{ + Q_D(QGeoTiledMapLabs); + d->removeMapObject(obj); +} + +QGeoTiledMapLabs::QGeoTiledMapLabs(QGeoTiledMapLabsPrivate &dd, QGeoTiledMappingManagerEngine *engine, QObject *parent) + : QGeoTiledMap(dd, engine, parent) +{ + +} + +QT_END_NAMESPACE + diff --git a/src/location/labs/qgeotiledmaplabs_p.h b/src/location/labs/qgeotiledmaplabs_p.h new file mode 100644 index 00000000..f6499784 --- /dev/null +++ b/src/location/labs/qgeotiledmaplabs_p.h @@ -0,0 +1,90 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QGEOTILEDMAPLABS_P_H +#define QGEOTILEDMAPLABS_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 <QtQml/qqml.h> +#include <QPointer> +#include <QtLocation/private/qgeotiledmap_p.h> +#include <QtQuick/qsgsimplerectnode.h> +#include <QtLocation/private/qqsgmapobject_p.h> + +QT_BEGIN_NAMESPACE + +class QDeclarativeGeoServiceProvider; +class QDeclarativeGeoMap; +class QMapRouteObject; +class QNavigationManager; +class QGeoTiledMapLabsPrivate; +class Q_LOCATION_PRIVATE_EXPORT QGeoTiledMapLabs : public QGeoTiledMap +{ + Q_OBJECT + Q_DECLARE_PRIVATE(QGeoTiledMapLabs) +public: + QGeoTiledMapLabs(QGeoTiledMappingManagerEngine *engine, QObject *parent); + virtual ~QGeoTiledMapLabs(); + + bool createMapObjectImplementation(QGeoMapObject *obj) override; + +protected: + QSGNode *updateSceneGraph(QSGNode *node, QQuickWindow *window) override; + void removeMapObject(QGeoMapObject *obj) override; + + QSGClipNode *m_clip = nullptr; + QSGSimpleRectNode *m_simpleRectNode = nullptr; + + // From QGeoTiledMap + QGeoTiledMapLabs(QGeoTiledMapLabsPrivate &dd, QGeoTiledMappingManagerEngine *engine, QObject *parent); +private: + Q_DISABLE_COPY(QGeoTiledMapLabs) +}; + +QT_END_NAMESPACE + +#endif // QGEOTILEDMAPLABS_P_H diff --git a/src/location/labs/qsg/qmapcircleobjectqsg.cpp b/src/location/labs/qsg/qmapcircleobjectqsg.cpp new file mode 100644 index 00000000..10110eab --- /dev/null +++ b/src/location/labs/qsg/qmapcircleobjectqsg.cpp @@ -0,0 +1,218 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qmapcircleobjectqsg_p_p.h" + +QT_BEGIN_NAMESPACE + +static const int CircleSamples = 128; + +QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(QGeoMapObject *q) + : QMapCircleObjectPrivateDefault(q) +{ + +} + +QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other) + : QMapCircleObjectPrivateDefault(other) +{ + // Data already cloned by the *Default copy constructor, but necessary + // update operations triggered by setters overrides + setCenter(center()); + setRadius(radius()); + setColor(color()); + setBorderColor(borderColor()); + setBorderWidth(borderWidth()); +} + +QMapCircleObjectPrivateQSG::~QMapCircleObjectPrivateQSG() +{ + +} + +void QMapCircleObjectPrivateQSG::updateCirclePath() +{ + const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + QList<QGeoCoordinate> path; + QDeclarativeCircleMapItem::calculatePeripheralPoints(path, center(), radius(), CircleSamples, m_leftBound); + m_circlePath.clear(); + for (const QGeoCoordinate &c : path) + m_circlePath << p.geoToMapProjection(c); +} + +void QMapCircleObjectPrivateQSG::updateGeometry() +{ + if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator + || !qIsFinite(m_radius) || !m_center.isValid()) + return; + + const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + QScopedValueRollback<bool> rollback(m_updatingGeometry); + m_updatingGeometry = true; + + updateCirclePath(); + QList<QDoubleVector2D> circlePath = m_circlePath; + + int pathCount = circlePath.size(); + bool preserve = QDeclarativeCircleMapItem::preserveCircleGeometry(circlePath, center(), radius(), p); + // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft()); + // to fix QTBUG-62154 + m_geometry.markSourceDirty(); + m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_ + m_geometry.setPreserveGeometry(preserve, m_leftBound); + + bool invertedCircle = false; + if (QDeclarativeCircleMapItem::crossEarthPole(center(), radius()) && circlePath.size() == pathCount) { + m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles + invertedCircle = true; + } else { + m_geometry.updateSourcePoints(*m_map, circlePath); + m_geometry.updateScreenPoints(*m_map); + } + + m_borderGeometry.clear(); + + //if (borderColor() != Qt::transparent && borderWidth() > 0) + { + QList<QDoubleVector2D> closedPath = circlePath; + closedPath << closedPath.first(); + + if (invertedCircle) { + closedPath = m_circlePath; + closedPath << closedPath.first(); + std::reverse(closedPath.begin(), closedPath.end()); + } + + m_borderGeometry.markSourceDirty(); + m_borderGeometry.setPreserveGeometry(true, m_leftBound); + m_borderGeometry.setPreserveGeometry(preserve, m_leftBound); + + // Use srcOrigin_ from fill geometry after clipping to ensure that translateToCommonOrigin won't fail. + const QGeoCoordinate &geometryOrigin = m_geometry.origin(); + + m_borderGeometry.clearSource(); + + QDoubleVector2D borderLeftBoundWrapped; + QList<QList<QDoubleVector2D > > clippedPaths = + m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped); + if (clippedPaths.size()) { + borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin); + m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped); + m_borderGeometry.updateScreenPoints(*m_map, borderWidth()); + } else { + m_borderGeometry.clear(); + } + } + + QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF(); + m_geometry.translate(origin - m_geometry.firstPointOffset()); + m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset()); +} + +QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone() +{ + return new QMapCircleObjectPrivateQSG(static_cast<QMapCircleObjectPrivate &>(*this)); +} + +QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/) +{ + MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode); + + bool created = false; + if (!node) { + node = new MapPolygonNode(); + created = true; + } + + //TODO: update only material + if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode || created) { + //QMapPolygonObject *p = static_cast<QMapPolygonObject *>(q); + node->update(color(), borderColor(), &m_geometry, &m_borderGeometry); + m_geometry.setPreserveGeometry(false); + m_borderGeometry.setPreserveGeometry(false); + m_geometry.markClean(); + m_borderGeometry.markClean(); + } + + if (created) + root->appendChildNode(node); + + return node; +} + + +void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate ¢er) +{ + m_center = center; + updateGeometry(); + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapCircleObjectPrivateQSG::setRadius(qreal radius) +{ + m_radius = radius; + updateGeometry(); + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapCircleObjectPrivateQSG::setColor(const QColor &color) +{ + m_fillColor = color; + updateGeometry(); + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color) +{ + m_borderColor = color; + updateGeometry(); + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapCircleObjectPrivateQSG::setBorderWidth(qreal width) +{ + m_borderWidth = width; + updateGeometry(); + if (m_map) + emit m_map->sgNodeChanged(); +} + + +QT_END_NAMESPACE diff --git a/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h b/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h new file mode 100644 index 00000000..17d8568a --- /dev/null +++ b/src/location/labs/qsg/qmapcircleobjectqsg_p_p.h @@ -0,0 +1,98 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QMAPCIRCLEOBJECTQSG_P_H +#define QMAPCIRCLEOBJECTQSG_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/qgeomapobject_p_p.h> +#include <QtLocation/private/qdeclarativecirclemapitem_p.h> +#include <QtLocation/private/qdeclarativepolygonmapitem_p.h> +#include <QtLocation/private/qmapcircleobject_p.h> +#include <QtLocation/private/qmapcircleobject_p_p.h> +#include <QtLocation/private/qqsgmapobject_p.h> +#include <QtCore/qscopedvaluerollback.h> +#include <QGeoCoordinate> +#include <QColor> + +QT_BEGIN_NAMESPACE + +class Q_LOCATION_PRIVATE_EXPORT QMapCircleObjectPrivateQSG : public QMapCircleObjectPrivateDefault, public QQSGMapObject +{ +public: + QMapCircleObjectPrivateQSG(QGeoMapObject *q); + QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other); + ~QMapCircleObjectPrivateQSG() override; + + void updateCirclePath(); + + // QQSGMapObject + void updateGeometry() override; + QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override; + + // QGeoMapCirclePrivate interface + void setCenter(const QGeoCoordinate ¢er) override; + void setRadius(qreal radius) override; + void setColor(const QColor &color) override; + void setBorderColor(const QColor &color) override; + void setBorderWidth(qreal width) override; + + // QGeoMapObjectPrivate + QGeoMapObjectPrivate *clone() override; + +public: + // Data Members + QList<QDoubleVector2D> m_circlePath; + QGeoCoordinate m_leftBound; + QGeoMapCircleGeometry m_geometry; + QGeoMapPolylineGeometry m_borderGeometry; + bool m_updatingGeometry = false; +}; + +QT_END_NAMESPACE + +#endif // QMAPCIRCLEOBJECT_P_P_H diff --git a/src/location/labs/qsg/qmapiconobjectqsg.cpp b/src/location/labs/qsg/qmapiconobjectqsg.cpp new file mode 100644 index 00000000..53d16179 --- /dev/null +++ b/src/location/labs/qsg/qmapiconobjectqsg.cpp @@ -0,0 +1,226 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qmapiconobjectqsg_p_p.h" +#include <QtQuick/qsgimagenode.h> +#include <QtQuick/qsgnode.h> +#include <QtQuick/private/qquickimage_p.h> +#include <QtQuick/qquickimageprovider.h> +#include <QtQuick/qquickwindow.h> +#include <QtQml/qqmlengine.h> +#include <QtQml/qqml.h> +#include <QtNetwork/qnetworkaccessmanager.h> + +QT_BEGIN_NAMESPACE + +class RootNode : public QSGTransformNode +{ +public: + RootNode() : QSGTransformNode() + { } + + bool isSubtreeBlocked() const override + { + return m_blocked; + } + + void setSubtreeBlocked(bool blocked) + { + m_blocked = blocked; + } + + bool m_blocked = false; +}; + +QMapIconObjectPrivateQSG::QMapIconObjectPrivateQSG(QGeoMapObject *q) + : QMapIconObjectPrivateDefault(q) +{ + +} + +QMapIconObjectPrivateQSG::QMapIconObjectPrivateQSG(const QMapIconObjectPrivate &other) + : QMapIconObjectPrivateDefault(other) +{ + setContent(content()); + setCoordinate(coordinate()); +} + +QMapIconObjectPrivateQSG::~QMapIconObjectPrivateQSG() +{ + +} + +void QMapIconObjectPrivateQSG::updateGeometry() +{ + if (!m_map) + return; + + m_geometryDirty = true; + const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + + m_itemPosition = p.coordinateToItemPosition(coordinate()); + if (m_itemPosition.isFinite()) { + m_transformation.setToIdentity(); + m_transformation.translate(QVector3D(m_itemPosition.x(), m_itemPosition.y(), 0)); + } + + // TODO: support and test for zoomLevel +} + +QSGNode *QMapIconObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode * root, QQuickWindow *window) +{ + bool created = false; + RootNode *node = static_cast<RootNode *>(oldNode); + if (!node) { + node = new RootNode(); + m_imageNode = window->createImageNode(); + m_imageNode->setOwnsTexture(true); + node->appendChildNode(m_imageNode); + created = true; + } + + if (m_imageDirty) { + m_imageDirty = false; + m_imageNode->setTexture(window->createTextureFromImage(m_image)); + QRect rect = m_image.rect(); + m_imageNode->setSourceRect(rect); + m_imageNode->setRect(QRectF(QPointF(0,0), m_size)); + } + + if (m_geometryDirty) { + m_geometryDirty = false; + if (!m_itemPosition.isFinite()) { + node->setSubtreeBlocked(true); + } else { + node->setSubtreeBlocked(false); + node->setMatrix(m_transformation); + } + } + + if (created) + root->appendChildNode(node); + + return node; +} + +void QMapIconObjectPrivateQSG::setCoordinate(const QGeoCoordinate &coordinate) +{ + QMapIconObjectPrivateDefault::setCoordinate(coordinate); + updateGeometry(); +} + +template<typename T> +static T *getContent(const QVariant &content) +{ + QObject *obj = qvariant_cast<QObject *>(content); + return qobject_cast<T *>(obj); +} + +static inline QString imageId(const QUrl &url) +{ + return url.toString(QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(1); +} + +void QMapIconObjectPrivateQSG::clearContent() +{ + m_image = QImage(); +} + +void QMapIconObjectPrivateQSG::setContent(const QVariant &content) +{ + // First reset all local containers + clearContent(); + QQmlEngine *engine = qmlEngine(q); + + // Then pull the new content + QMapIconObjectPrivateDefault::setContent(content); + switch (content.type()) { + case QVariant::UserType: { + // TODO: Handle QObject subclasses -- first decide which ones + break; + } + case QVariant::String: + case QVariant::Url: { + // URL, including image/texture providers + // Supporting only image providers for now + const QUrl url = content.toUrl(); + if (!url.isValid()) { + m_image = QImage(content.toString()); + m_imageDirty = true; + updateGeometry(); + } else if (url.scheme().isEmpty() || url.scheme() == QLatin1String("file")) { + m_image = QImage(url.toString(QUrl::RemoveScheme)); + m_imageDirty = true; + updateGeometry(); + } else if (url.scheme() == QLatin1String("image")) { + QQuickImageProvider *provider = static_cast<QQuickImageProvider *>(engine->imageProvider(url.host())); + QSize outSize; + m_image = provider->requestImage(imageId(url), &outSize, QSize()); + if (outSize.isEmpty()) + break; + m_imageDirty = true; + updateGeometry(); + } else { // ToDo: Use QNAM + + } + + break; + } + case QVariant::ByteArray: { + // ToDo: Build the image from bytearray + break; + } + default: + qWarning() << "Unsupported parameter type: " << content.type(); + break; + } + + if (m_map && m_imageDirty) + emit m_map->sgNodeChanged(); +} + +void QMapIconObjectPrivateQSG::setSize(const QSizeF &size) +{ + QMapIconObjectPrivateDefault::setSize(size); + updateGeometry(); +} + +QGeoMapObjectPrivate *QMapIconObjectPrivateQSG::clone() +{ + return new QMapIconObjectPrivateQSG(static_cast<QMapIconObjectPrivate &>(*this)); +} + +QT_END_NAMESPACE diff --git a/src/location/labs/qsg/qmapiconobjectqsg_p_p.h b/src/location/labs/qsg/qmapiconobjectqsg_p_p.h new file mode 100644 index 00000000..a2f7cf40 --- /dev/null +++ b/src/location/labs/qsg/qmapiconobjectqsg_p_p.h @@ -0,0 +1,94 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QMAPICONOBJECTQSG_P_P_H +#define QMAPICONOBJECTQSG_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/qmapiconobject_p.h> +#include <QtLocation/private/qmapiconobject_p_p.h> +#include <QtLocation/private/qqsgmapobject_p.h> +#include <QtCore/qscopedvaluerollback.h> +#include <QtGui/qimage.h> + +QT_BEGIN_NAMESPACE + +class QSGImageNode; +class Q_LOCATION_PRIVATE_EXPORT QMapIconObjectPrivateQSG : public QMapIconObjectPrivateDefault, public QQSGMapObject +{ +public: + QMapIconObjectPrivateQSG(QGeoMapObject *q); + QMapIconObjectPrivateQSG(const QMapIconObjectPrivate &other); + ~QMapIconObjectPrivateQSG() override; + + void clearContent(); + + // QQSGMapObject + void updateGeometry() override; + QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override; + + // QGeoMapIconPrivate interface + void setCoordinate(const QGeoCoordinate &coordinate) override; + void setContent(const QVariant &content) override; + void setSize(const QSizeF &size) override; + + // QGeoMapObjectPrivate + QGeoMapObjectPrivate *clone() override; + +public: + // Data Members + bool m_imageDirty = false; + bool m_geometryDirty = false; + QImage m_image; + QSGImageNode *m_imageNode = nullptr; + QDoubleVector2D m_itemPosition; + QMatrix4x4 m_transformation; +}; + +QT_END_NAMESPACE + +#endif // QMAPICONOBJECTQSG_P_P_H diff --git a/src/location/labs/qsg/qmappolygonobjectqsg.cpp b/src/location/labs/qsg/qmappolygonobjectqsg.cpp new file mode 100644 index 00000000..4000c08f --- /dev/null +++ b/src/location/labs/qsg/qmappolygonobjectqsg.cpp @@ -0,0 +1,212 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qmappolygonobjectqsg_p_p.h" +#include <QtQuick/qsgnode.h> +#include <QtQuick/qsgsimplerectnode.h> + +QT_BEGIN_NAMESPACE + +QMapPolygonObjectPrivateQSG::QMapPolygonObjectPrivateQSG(QGeoMapObject *q) + : QMapPolygonObjectPrivate(q) +{ + +} + +QMapPolygonObjectPrivateQSG::QMapPolygonObjectPrivateQSG(const QMapPolygonObjectPrivate &other) + : QMapPolygonObjectPrivate(other.q) +{ + setPath(other.path()); + setFillColor(other.fillColor()); + setBorderColor(other.borderColor()); + setBorderWidth(other.borderWidth()); +} + +QMapPolygonObjectPrivateQSG::~QMapPolygonObjectPrivateQSG() +{ + +} + +QList<QDoubleVector2D> QMapPolygonObjectPrivateQSG::projectPath() +{ + QList<QDoubleVector2D> geopathProjected_; + if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator) + return geopathProjected_; + + const QGeoProjectionWebMercator &p = + static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + geopathProjected_.reserve(m_geoPath.path().size()); + for (const QGeoCoordinate &c : m_geoPath.path()) + geopathProjected_ << p.geoToMapProjection(c); + return geopathProjected_; +} + +QSGNode *QMapPolygonObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/) +{ + MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode); + + bool created = false; + if (!node) { + node = new MapPolygonNode(); + created = true; + } + + //TODO: update only material + if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode || created) { + node->update(fillColor(), borderColor(), &m_geometry, &m_borderGeometry); + m_geometry.setPreserveGeometry(false); + m_borderGeometry.setPreserveGeometry(false); + m_geometry.markClean(); + m_borderGeometry.markClean(); + } + + if (created) + root->appendChildNode(node); + + return node; +} + +QList<QGeoCoordinate> QMapPolygonObjectPrivateQSG::path() const +{ + return m_geoPath.path(); +} + +QColor QMapPolygonObjectPrivateQSG::fillColor() const +{ + return m_fillColor; +} + +QColor QMapPolygonObjectPrivateQSG::borderColor() const +{ + return m_borderColor; +} + +qreal QMapPolygonObjectPrivateQSG::borderWidth() const +{ + return m_borderWidth; +} + +void QMapPolygonObjectPrivateQSG::setPath(const QList<QGeoCoordinate> &path) +{ + m_geoPath.setPath(path); + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapPolygonObjectPrivateQSG::setFillColor(const QColor &color) +{ + m_fillColor = color; + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapPolygonObjectPrivateQSG::setBorderColor(const QColor &color) +{ + m_borderColor = color; + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapPolygonObjectPrivateQSG::setBorderWidth(qreal width) +{ + m_borderWidth = width; + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +QGeoMapObjectPrivate *QMapPolygonObjectPrivateQSG::clone() +{ + return new QMapPolygonObjectPrivateQSG(static_cast<QMapPolygonObjectPrivate &>(*this)); +} + +void QMapPolygonObjectPrivateQSG::updateGeometry() +{ + if (!m_map || m_geoPath.path().length() == 0 + || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator) + return; + + QScopedValueRollback<bool> rollback(m_updatingGeometry); + m_updatingGeometry = true; + + const QList<QDoubleVector2D> &geopathProjected = projectPath(); + + m_geometry.markSourceDirty(); + m_geometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft()); + m_geometry.updateSourcePoints(*m_map, geopathProjected); + m_geometry.updateScreenPoints(*m_map); + + m_borderGeometry.clear(); + + //if (border_.color() != Qt::transparent && border_.width() > 0) + { + const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + QList<QDoubleVector2D> closedPath = geopathProjected; + closedPath << closedPath.first(); + + m_borderGeometry.markSourceDirty(); + m_borderGeometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft()); + + const QGeoCoordinate &geometryOrigin = m_geometry.origin(); + + m_borderGeometry.clearSource(); + + QDoubleVector2D borderLeftBoundWrapped; + QList<QList<QDoubleVector2D > > clippedPaths = + m_borderGeometry.clipPath(*m_map.data(), closedPath, borderLeftBoundWrapped); + + if (clippedPaths.size()) { + borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin); + m_borderGeometry.pathToScreen(*m_map.data(), clippedPaths, borderLeftBoundWrapped); + m_borderGeometry.updateScreenPoints(*m_map.data(), borderWidth()); + } else { + m_borderGeometry.clear(); + } + } + + QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF(); + m_geometry.translate(origin - m_geometry.firstPointOffset()); + m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset()); +} + +QT_END_NAMESPACE diff --git a/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h b/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h new file mode 100644 index 00000000..bd5efcff --- /dev/null +++ b/src/location/labs/qsg/qmappolygonobjectqsg_p_p.h @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QMAPPOLYGONOBJECTQSG_P_P_H +#define QMAPPOLYGONOBJECTQSG_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/qmappolygonobject_p.h> +#include <QtLocation/private/qmappolygonobject_p_p.h> +#include <QtLocation/private/qqsgmapobject_p.h> +#include <QtLocation/private/qdeclarativepolygonmapitem_p.h> +#include <QtCore/qscopedvaluerollback.h> + +QT_BEGIN_NAMESPACE + +class Q_LOCATION_PRIVATE_EXPORT QMapPolygonObjectPrivateQSG : public QMapPolygonObjectPrivate, public QQSGMapObject +{ +public: + QMapPolygonObjectPrivateQSG(QGeoMapObject *q); + QMapPolygonObjectPrivateQSG(const QMapPolygonObjectPrivate &other); + ~QMapPolygonObjectPrivateQSG() override; + + QList<QDoubleVector2D> projectPath(); + + // QQSGMapObject + void updateGeometry() override; + QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override; + + // QGeoMapPolylinePrivate interface + QList<QGeoCoordinate> path() const override; + QColor fillColor() const override; + QColor borderColor() const override; + qreal borderWidth() const override; + + void setPath(const QList<QGeoCoordinate> &path) override; + void setFillColor(const QColor &color) override; + void setBorderColor(const QColor &color) override; + void setBorderWidth(qreal width) override; + + // QGeoMapObjectPrivate + QGeoMapObjectPrivate *clone() override; + + // Data Members + QGeoMapPolygonGeometry m_geometry; + QGeoMapPolylineGeometry m_borderGeometry; + QGeoPath m_geoPath; + + QColor m_fillColor; + QColor m_borderColor; + qreal m_borderWidth = 0; + bool m_updatingGeometry = false; +}; + +QT_END_NAMESPACE + +#endif // QMAPPOLYGONOBJECTQSG_P_P_H diff --git a/src/location/labs/qsg/qmappolylineobjectqsg.cpp b/src/location/labs/qsg/qmappolylineobjectqsg.cpp new file mode 100644 index 00000000..fe6fbec6 --- /dev/null +++ b/src/location/labs/qsg/qmappolylineobjectqsg.cpp @@ -0,0 +1,160 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qmappolylineobjectqsg_p_p.h" +#include <QtQuick/qsgnode.h> +#include <QtQuick/qsgsimplerectnode.h> + +QT_BEGIN_NAMESPACE + +/* + Note: never use q, since this class is also used inside QMapRouteObjectPrivateQSG! +*/ + +QMapPolylineObjectPrivateQSG::QMapPolylineObjectPrivateQSG(QGeoMapObject *q) + : QMapPolylineObjectPrivate(q) +{ + +} + +QMapPolylineObjectPrivateQSG::QMapPolylineObjectPrivateQSG(const QMapPolylineObjectPrivate &other) + : QMapPolylineObjectPrivate(other.q) +{ + // do the appropriate internal update and trigger map repaint + setPath(other.path()); + setColor(other.color()); + setWidth(other.width()); +} + +QMapPolylineObjectPrivateQSG::~QMapPolylineObjectPrivateQSG() +{ + +} + +QList<QDoubleVector2D> QMapPolylineObjectPrivateQSG::projectPath() +{ + QList<QDoubleVector2D> geopathProjected_; + if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator) + return geopathProjected_; + + const QGeoProjectionWebMercator &p = + static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection()); + geopathProjected_.reserve(m_geoPath.path().size()); + for (const QGeoCoordinate &c : m_geoPath.path()) + geopathProjected_ << p.geoToMapProjection(c); + return geopathProjected_; +} + +void QMapPolylineObjectPrivateQSG::updateGeometry() +{ + if (!m_map || m_geoPath.path().length() == 0 + || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator) + return; + + QScopedValueRollback<bool> rollback(m_updatingGeometry); + m_updatingGeometry = true; + m_geometry.markSourceDirty(); + const QList<QDoubleVector2D> &geopathProjected = projectPath(); + m_geometry.setPreserveGeometry(true, m_geoPath.boundingGeoRectangle().topLeft()); + m_geometry.updateSourcePoints(*m_map.data(), geopathProjected, m_geoPath.boundingGeoRectangle().topLeft()); + m_geometry.updateScreenPoints(*m_map.data(), width()); + + QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF(); + m_geometry.translate(origin - m_geometry.firstPointOffset()); +} + +QSGNode *QMapPolylineObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * /*window*/) +{ + MapPolylineNode *node = static_cast<MapPolylineNode *>(oldNode); + + bool created = false; + if (!node) { + node = new MapPolylineNode(); + created = true; + } + + //TODO: update only material + if (m_geometry.isScreenDirty() || !oldNode || created) { + node->update(color(), &m_geometry); + m_geometry.setPreserveGeometry(false); + m_geometry.markClean(); + } + + if (created) + root->appendChildNode(node); + + return node; +} + +QList<QGeoCoordinate> QMapPolylineObjectPrivateQSG::path() const { return m_geoPath.path(); } + +QColor QMapPolylineObjectPrivateQSG::color() const { return m_color; } + +qreal QMapPolylineObjectPrivateQSG::width() const { return m_width; } + +void QMapPolylineObjectPrivateQSG::setPath(const QList<QGeoCoordinate> &path) +{ + m_geoPath.setPath(path); + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapPolylineObjectPrivateQSG::setColor(const QColor &color) +{ + m_color = color; + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +void QMapPolylineObjectPrivateQSG::setWidth(qreal width) +{ + m_width = width; + updateGeometry(); + + if (m_map) + emit m_map->sgNodeChanged(); +} + +QGeoMapObjectPrivate *QMapPolylineObjectPrivateQSG::clone() +{ + return new QMapPolylineObjectPrivateQSG(static_cast<QMapPolylineObjectPrivate &>(*this)); +} + +QT_END_NAMESPACE diff --git a/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h b/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h new file mode 100644 index 00000000..52b5e89a --- /dev/null +++ b/src/location/labs/qsg/qmappolylineobjectqsg_p_p.h @@ -0,0 +1,96 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QMAPPOLYLINEOBJECTOBJECTSOVERLAY_H +#define QMAPPOLYLINEOBJECTOBJECTSOVERLAY_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/qmappolylineobject_p_p.h> +#include <QtLocation/private/qdeclarativepolylinemapitem_p.h> +#include <QtLocation/private/qmappolylineobject_p.h> +#include <QtLocation/private/qqsgmapobject_p.h> +#include <QtCore/qscopedvaluerollback.h> + +QT_BEGIN_NAMESPACE + +class Q_LOCATION_PRIVATE_EXPORT QMapPolylineObjectPrivateQSG : public QMapPolylineObjectPrivate, public QQSGMapObject +{ +public: + QMapPolylineObjectPrivateQSG(QGeoMapObject *q); + QMapPolylineObjectPrivateQSG(const QMapPolylineObjectPrivate &other); + ~QMapPolylineObjectPrivateQSG() override; + + QList<QDoubleVector2D> projectPath(); + + // QQSGMapObject + void updateGeometry() override; + QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override; + + // QGeoMapPolylinePrivate interface + QList<QGeoCoordinate> path() const override; + QColor color() const override; + qreal width() const override; + + void setPath(const QList<QGeoCoordinate> &path) override; + void setColor(const QColor &color) override; + void setWidth(qreal width) override; + + // QGeoMapObjectPrivate + QGeoMapObjectPrivate *clone() override; + + // Data Members + QGeoMapPolylineGeometry m_geometry; + QGeoPath m_geoPath; + + QColor m_color; + qreal m_width = 0; + bool m_updatingGeometry = false; +}; + +QT_END_NAMESPACE + +#endif // QMAPPOLYLINEOBJECTOBJECTSOVERLAY_H diff --git a/src/location/labs/qsg/qmaprouteobjectqsg.cpp b/src/location/labs/qsg/qmaprouteobjectqsg.cpp new file mode 100644 index 00000000..a8728e08 --- /dev/null +++ b/src/location/labs/qsg/qmaprouteobjectqsg.cpp @@ -0,0 +1,99 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qmaprouteobjectqsg_p_p.h" + +QT_BEGIN_NAMESPACE + +QMapRouteObjectPrivateQSG::QMapRouteObjectPrivateQSG(QGeoMapObject *q) + : QMapRouteObjectPrivate(q) +{ + QScopedPointer<QMapPolylineObjectPrivateQSG> poly(new QMapPolylineObjectPrivateQSG(q)); + m_polyline.swap(poly); + m_polyline->m_componentCompleted = true; +} + +QMapRouteObjectPrivateQSG::QMapRouteObjectPrivateQSG(const QMapRouteObjectPrivate &other) + : QMapRouteObjectPrivate(other) +{ + QScopedPointer<QMapPolylineObjectPrivateQSG> poly(new QMapPolylineObjectPrivateQSG(other.q)); + m_polyline.swap(poly); + m_polyline->m_componentCompleted = true; + setRoute(other.declarativeGeoRoute()); +} + +QMapRouteObjectPrivateQSG::~QMapRouteObjectPrivateQSG() +{ + +} + +void QMapRouteObjectPrivateQSG::updateGeometry() +{ + m_polyline->updateGeometry(); +} + +QSGNode *QMapRouteObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow * window) +{ + return m_polyline->updateMapObjectNode(oldNode, root, window); +} + +void QMapRouteObjectPrivateQSG::setRoute(const QDeclarativeGeoRoute *route) +{ + const QList<QGeoCoordinate> &path = route->route().path(); + m_polyline->setColor(QColor("deepskyblue")); // ToDo: support MapParameters for this + m_polyline->setWidth(4); + m_polyline->setPath(path); // SGNodeChanged emitted by m_polyline +} + +QGeoMapObjectPrivate *QMapRouteObjectPrivateQSG::clone() +{ + return new QMapRouteObjectPrivateQSG(static_cast<QMapRouteObjectPrivate &>(*this)); +} + +void QMapRouteObjectPrivateQSG::setMap(QGeoMap *map) +{ + QGeoMapObjectPrivate::setMap(map); + m_polyline->setMap(map); +} + + +void QMapRouteObjectPrivateQSG::setVisible(bool visible) +{ + m_visible = visible; + m_polyline->setVisible(visible); +} + +QT_END_NAMESPACE diff --git a/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h b/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h new file mode 100644 index 00000000..1c612532 --- /dev/null +++ b/src/location/labs/qsg/qmaprouteobjectqsg_p_p.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QMAPROUTEOBJECTQSG_P_P_H +#define QMAPROUTEOBJECTQSG_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/qmappolylineobjectqsg_p_p.h> +#include <QtLocation/private/qmaprouteobject_p_p.h> +#include <QtLocation/private/qdeclarativegeoroute_p.h> +#include <QtLocation/private/qmaprouteobject_p.h> +#include <QtLocation/private/qqsgmapobject_p.h> +#include <QtCore/qscopedvaluerollback.h> +#include <QtCore/qscopedpointer.h> + +QT_BEGIN_NAMESPACE + +class Q_LOCATION_PRIVATE_EXPORT QMapRouteObjectPrivateQSG : public QMapRouteObjectPrivate, public QQSGMapObject +{ +public: + QMapRouteObjectPrivateQSG(QGeoMapObject *q); + QMapRouteObjectPrivateQSG(const QMapRouteObjectPrivate &other); + ~QMapRouteObjectPrivateQSG() override; + + // QQSGMapObject + void updateGeometry() override; + QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window) override; + + // QMapRouteObjectPrivate interface + void setRoute(const QDeclarativeGeoRoute *route) override; + + // QGeoMapObjectPrivate interface + QGeoMapObjectPrivate *clone() override; + void setMap(QGeoMap *map) override; + void setVisible(bool visible) override; + + // Data Members + QScopedPointer<QMapPolylineObjectPrivateQSG> m_polyline; +}; + +QT_END_NAMESPACE + +#endif // QMAPROUTEOBJECTQSG_P_P_H diff --git a/src/location/labs/qsg/qqsgmapobject.cpp b/src/location/labs/qsg/qqsgmapobject.cpp new file mode 100644 index 00000000..5b4f7dbf --- /dev/null +++ b/src/location/labs/qsg/qqsgmapobject.cpp @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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$ +** +****************************************************************************/ + +#include "qqsgmapobject_p.h" + +QT_BEGIN_NAMESPACE + +QQSGMapObject::QQSGMapObject() +{ + +} + +QQSGMapObject::~QQSGMapObject() +{ + +} + +QSGNode *QQSGMapObject::updateMapObjectNode(QSGNode *oldNode, QSGNode * /*root*/, QQuickWindow * /*window*/) +{ + delete oldNode; + return 0; +} + +void QQSGMapObject::updateGeometry() +{ + +} + +QT_END_NAMESPACE + + diff --git a/src/location/labs/qsg/qqsgmapobject_p.h b/src/location/labs/qsg/qqsgmapobject_p.h new file mode 100644 index 00000000..d3e54a68 --- /dev/null +++ b/src/location/labs/qsg/qqsgmapobject_p.h @@ -0,0 +1,61 @@ +/**************************************************************************** +** +** Copyright (C) 2018 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 QQSGMAPOBJECT_H +#define QQSGMAPOBJECT_H + +#include <QtLocation/private/qlocationglobal_p.h> +#include <QtQuick/QSGOpacityNode> +#include <QtLocation/private/qgeomapobject_p.h> + +QT_BEGIN_NAMESPACE + +class QQuickWindow; +class Q_LOCATION_PRIVATE_EXPORT QQSGMapObject +{ +public: + QQSGMapObject(); + virtual ~QQSGMapObject(); + + virtual QSGNode *updateMapObjectNode(QSGNode *oldNode, QSGNode *root, QQuickWindow *window); + virtual void updateGeometry(); + + QSGNode *node = nullptr; +}; + +QT_END_NAMESPACE + +#endif // QQSGMAPOBJECT_H diff --git a/src/plugins/geoservices/esri/esri.pro b/src/plugins/geoservices/esri/esri.pro index 3642ddaf..3a4da208 100644 --- a/src/plugins/geoservices/esri/esri.pro +++ b/src/plugins/geoservices/esri/esri.pro @@ -2,6 +2,9 @@ TARGET = qtgeoservices_esri QT += location-private positioning-private network +QT_FOR_CONFIG += location-private +qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS + HEADERS += \ geocodereply_esri.h \ geocodingmanagerengine_esri.h \ diff --git a/src/plugins/geoservices/esri/geotiledmap_esri.cpp b/src/plugins/geoservices/esri/geotiledmap_esri.cpp index 9171fc2b..8feb9615 100644 --- a/src/plugins/geoservices/esri/geotiledmap_esri.cpp +++ b/src/plugins/geoservices/esri/geotiledmap_esri.cpp @@ -45,7 +45,7 @@ QT_BEGIN_NAMESPACE GeoTiledMapEsri::GeoTiledMapEsri(GeoTiledMappingManagerEngineEsri *engine, QObject *parent) : - QGeoTiledMap(engine, parent), m_engine(engine), m_mapId(-1) + Map(engine, parent), m_engine(engine), m_mapId(-1) { } diff --git a/src/plugins/geoservices/esri/geotiledmap_esri.h b/src/plugins/geoservices/esri/geotiledmap_esri.h index e8b26152..7a21af9a 100644 --- a/src/plugins/geoservices/esri/geotiledmap_esri.h +++ b/src/plugins/geoservices/esri/geotiledmap_esri.h @@ -41,12 +41,18 @@ #define GEOTILEDMAPESRI_H #include <QtLocation/private/qgeotiledmap_p.h> +#ifdef LOCATIONLABS +#include <QtLocation/private/qgeotiledmaplabs_p.h> +typedef QGeoTiledMapLabs Map; +#else +typedef QGeoTiledMap Map; +#endif QT_BEGIN_NAMESPACE class GeoTiledMappingManagerEngineEsri; -class GeoTiledMapEsri: public QGeoTiledMap +class GeoTiledMapEsri: public Map { Q_OBJECT diff --git a/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro b/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro index 1f45de97..486ed97a 100644 --- a/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro +++ b/src/plugins/geoservices/itemsoverlay/itemsoverlay.pro @@ -2,6 +2,9 @@ TARGET = qtgeoservices_itemsoverlay QT += location-private positioning-private +QT_FOR_CONFIG += location-private +qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS + HEADERS += \ qgeomapitemsoverlay.h \ qgeomappingmanagerengineitemsoverlay.h \ diff --git a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp index 29b84408..99146801 100644 --- a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp +++ b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.cpp @@ -38,6 +38,22 @@ #include "qgeomappingmanagerengineitemsoverlay.h" #include <QtLocation/private/qgeomap_p_p.h> #include <QtQuick/qsgnode.h> +#include <QtQuick/qsgrectanglenode.h> +#include <QtQuick/qquickwindow.h> + +#ifdef LOCATIONLABS +#include <QtLocation/private/qmappolylineobjectqsg_p_p.h> +#include <QtLocation/private/qmappolygonobjectqsg_p_p.h> +#include <QtLocation/private/qmapcircleobjectqsg_p_p.h> +#include <QtLocation/private/qmaprouteobjectqsg_p_p.h> +#include <QtLocation/private/qmapiconobjectqsg_p_p.h> +struct MapObject { + MapObject(QPointer<QGeoMapObject> &o, QQSGMapObject *sgo) + : object(o), sgObject(sgo) {} + QPointer<QGeoMapObject> object; + QQSGMapObject *sgObject = nullptr; +}; +#endif QT_BEGIN_NAMESPACE @@ -46,9 +62,20 @@ class QGeoMapItemsOverlayPrivate : public QGeoMapPrivate Q_DECLARE_PUBLIC(QGeoMapItemsOverlay) public: QGeoMapItemsOverlayPrivate(QGeoMappingManagerEngineItemsOverlay *engine); - virtual ~QGeoMapItemsOverlayPrivate(); +#ifdef LOCATIONLABS + QGeoMapObjectPrivate *createMapObjectImplementation(QGeoMapObject *obj) override; + virtual QList<QGeoMapObject *> mapObjects() const override; + static int findMapObject(QGeoMapObject *o, const QList<MapObject> &list); + void removeMapObject(QGeoMapObject *obj); + void updateMapObjects(QSGNode *root, QQuickWindow *window); + + QList<MapObject> m_mapObjects; + QList<MapObject> m_pendingMapObjects; +#endif + + void updateObjectsGeometry(); protected: void changeViewportSize(const QSize &size) override; void changeCameraData(const QGeoCameraData &oldCameraData) override; @@ -65,10 +92,31 @@ QGeoMapItemsOverlay::~QGeoMapItemsOverlay() { } +QGeoMap::Capabilities QGeoMapItemsOverlay::capabilities() const +{ + return Capabilities(SupportsVisibleRegion + | SupportsSetBearing + | SupportsAnchoringCoordinate); +} + QSGNode *QGeoMapItemsOverlay::updateSceneGraph(QSGNode *node, QQuickWindow *window) { +#ifndef LOCATIONLABS Q_UNUSED(window) return node; +#else + Q_D(QGeoMapItemsOverlay); + + QSGRectangleNode *mapRoot = static_cast<QSGRectangleNode *>(node); + if (!mapRoot) + mapRoot = window->createRectangleNode(); + + mapRoot->setRect(QRect(0, 0, viewportWidth(), viewportHeight())); + mapRoot->setColor(QColor(0,0,0,0)); + + d->updateMapObjects(mapRoot, window); + return mapRoot; +#endif } QGeoMapItemsOverlayPrivate::QGeoMapItemsOverlayPrivate(QGeoMappingManagerEngineItemsOverlay *engine) @@ -80,19 +128,157 @@ QGeoMapItemsOverlayPrivate::~QGeoMapItemsOverlayPrivate() { } -void QGeoMapItemsOverlayPrivate::changeViewportSize(const QSize &size) +#ifdef LOCATIONLABS +QGeoMapObjectPrivate *QGeoMapItemsOverlayPrivate::createMapObjectImplementation(QGeoMapObject *obj) +{ + switch (obj->type()) { + case QGeoMapObject::PolylineType: { + QMapPolylineObjectPrivate &oldImpl = static_cast<QMapPolylineObjectPrivate &>(*obj->implementation()); + QMapPolylineObjectPrivateQSG *pimpl = + new QMapPolylineObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::PolygonType: { + QMapPolygonObjectPrivate &oldImpl = static_cast<QMapPolygonObjectPrivate &>(*obj->implementation()); + QMapPolygonObjectPrivateQSG *pimpl = + new QMapPolygonObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::CircleType: { + QMapCircleObjectPrivate &oldImpl = static_cast<QMapCircleObjectPrivate &>(*obj->implementation()); + QMapCircleObjectPrivateQSG *pimpl = + new QMapCircleObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::RouteType: { + QMapRouteObjectPrivate &oldImpl = static_cast<QMapRouteObjectPrivate &>(*obj->implementation()); + QMapRouteObjectPrivateQSG *pimpl = + new QMapRouteObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + case QGeoMapObject::IconType: { + QMapIconObjectPrivate &oldImpl = static_cast<QMapIconObjectPrivate &>(*obj->implementation()); + QMapIconObjectPrivateQSG *pimpl = + new QMapIconObjectPrivateQSG(oldImpl); + QPointer<QGeoMapObject> p(obj); + MapObject mo(p, pimpl); + m_pendingMapObjects << mo; + return pimpl; + } + default: + qWarning() << "Unsupported object type: " << obj->type(); + break; + } + return nullptr; +} + +QList<QGeoMapObject *> QGeoMapItemsOverlayPrivate::mapObjects() const +{ + return QList<QGeoMapObject *>(); +} + +int QGeoMapItemsOverlayPrivate::findMapObject(QGeoMapObject *o, const QList<MapObject> &list) +{ + for (int i = 0; i < list.size(); ++i) + { + if (list.at(i).object.data() == o) + return i; + } + return -1; +} + +void QGeoMapItemsOverlayPrivate::removeMapObject(QGeoMapObject *obj) +{ + int idx = findMapObject(obj, m_mapObjects); + if (idx >= 0) { + m_mapObjects.removeAt(idx); + } else { + idx = findMapObject(obj, m_pendingMapObjects); + if (idx >= 0) { + m_pendingMapObjects.removeAt(idx); + } else { + // obj not here. + } + } +} + +void QGeoMapItemsOverlayPrivate::updateMapObjects(QSGNode *root, QQuickWindow *window) +{ + for (int i = 0; i < m_mapObjects.size(); ++i) { + // already added as node + if (!m_mapObjects.at(i).object) { + qWarning() << "m_mapObjects at "<<i<< " NULLed!!"; + continue; + } + + QQSGMapObject *sgo = m_mapObjects.at(i).sgObject; + QSGNode *oldNode = sgo->node; + sgo->node = sgo->updateMapObjectNode(oldNode, root, window); + } + + QList<int> toRemove; + for (int i = 0; i < m_pendingMapObjects.size(); ++i) { + // already added as node + QQSGMapObject *sgo = m_pendingMapObjects.at(i).sgObject; + QSGNode *oldNode = sgo->node; + sgo->updateGeometry(); // or subtree will be blocked + sgo->node = sgo->updateMapObjectNode(oldNode, root, window); + if (sgo->node) { + m_mapObjects << m_pendingMapObjects.at(i); + toRemove.push_front(i); + } else { + // leave it to be processed + } + } + + for (int i: qAsConst(toRemove)) + m_pendingMapObjects.removeAt(i); +} +#endif + +void QGeoMapItemsOverlayPrivate::updateObjectsGeometry() +{ +#ifdef LOCATIONLABS + Q_Q(QGeoMapItemsOverlay); + for (int i = 0; i < m_mapObjects.size(); ++i) { + // already added as node + if (!m_mapObjects.at(i).object) { + qWarning() << "m_mapObjects at "<<i<< " NULLed!!"; + continue; + } + + QQSGMapObject *sgo = m_mapObjects.at(i).sgObject; + sgo->updateGeometry(); + } + emit q->sgNodeChanged(); +#endif +} + +void QGeoMapItemsOverlayPrivate::changeViewportSize(const QSize &/*size*/) { - Q_UNUSED(size) + updateObjectsGeometry(); } -void QGeoMapItemsOverlayPrivate::changeCameraData(const QGeoCameraData &oldCameraData) +void QGeoMapItemsOverlayPrivate::changeCameraData(const QGeoCameraData &/*oldCameraData*/) { - Q_UNUSED(oldCameraData) + updateObjectsGeometry(); } -void QGeoMapItemsOverlayPrivate::changeActiveMapType(const QGeoMapType mapType) +void QGeoMapItemsOverlayPrivate::changeActiveMapType(const QGeoMapType /*mapType*/) { - Q_UNUSED(mapType) + updateObjectsGeometry(); } QT_END_NAMESPACE diff --git a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h index 47249240..42a59f06 100644 --- a/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h +++ b/src/plugins/geoservices/itemsoverlay/qgeomapitemsoverlay.h @@ -51,8 +51,10 @@ class QGeoMapItemsOverlay: public QGeoMap Q_DECLARE_PRIVATE(QGeoMapItemsOverlay) public: QGeoMapItemsOverlay(QGeoMappingManagerEngineItemsOverlay *engine, QObject *parent); - virtual ~QGeoMapItemsOverlay(); + + QGeoMap::Capabilities capabilities() const override; + protected: QSGNode *updateSceneGraph(QSGNode *node, QQuickWindow *window) override; diff --git a/src/plugins/geoservices/mapbox/mapbox.pro b/src/plugins/geoservices/mapbox/mapbox.pro index 25a12795..c4e7f671 100644 --- a/src/plugins/geoservices/mapbox/mapbox.pro +++ b/src/plugins/geoservices/mapbox/mapbox.pro @@ -2,6 +2,9 @@ TARGET = qtgeoservices_mapbox QT += location-private positioning-private network +QT_FOR_CONFIG += location-private +qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS + HEADERS += \ qgeoserviceproviderpluginmapbox.h \ qgeotiledmappingmanagerenginemapbox.h \ diff --git a/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp b/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp index 632b2286..f2595d03 100644 --- a/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp +++ b/src/plugins/geoservices/mapbox/qgeotiledmappingmanagerenginemapbox.cpp @@ -41,6 +41,12 @@ #include <QtLocation/private/qgeomaptype_p.h> #include <QtLocation/private/qgeotiledmap_p.h> #include "qgeofiletilecachemapbox.h" +#ifdef LOCATIONLABS +#include <QtLocation/private/qgeotiledmaplabs_p.h> +typedef QGeoTiledMapLabs Map; +#else +typedef QGeoTiledMap Map; +#endif QT_BEGIN_NAMESPACE @@ -246,7 +252,7 @@ QGeoTiledMappingManagerEngineMapbox::~QGeoTiledMappingManagerEngineMapbox() QGeoMap *QGeoTiledMappingManagerEngineMapbox::createMap() { - QGeoTiledMap *map = new QGeoTiledMap(this, 0); + QGeoTiledMap *map = new Map(this, 0); map->setPrefetchStyle(m_prefetchStyle); return map; } diff --git a/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp b/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp index 4835c201..4dae6826 100644 --- a/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp +++ b/src/plugins/geoservices/mapboxgl/qmapboxglstylechange.cpp @@ -97,7 +97,7 @@ QMapbox::Feature featureFromMapCircle(QDeclarativeCircleMapItem *mapItem) for (const QGeoCoordinate &c : qAsConst(path)) pathProjected << p.geoToMapProjection(c); if (QDeclarativeCircleMapItem::crossEarthPole(mapItem->center(), mapItem->radius())) - mapItem->preserveCircleGeometry(pathProjected, mapItem->center(), mapItem->radius()); + mapItem->preserveCircleGeometry(pathProjected, mapItem->center(), mapItem->radius(), p); path.clear(); for (const QDoubleVector2D &c : qAsConst(pathProjected)) path << p.mapProjectionToGeo(c); diff --git a/src/plugins/geoservices/nokia/nokia.pro b/src/plugins/geoservices/nokia/nokia.pro index c6dadd86..86a0665c 100644 --- a/src/plugins/geoservices/nokia/nokia.pro +++ b/src/plugins/geoservices/nokia/nokia.pro @@ -2,6 +2,9 @@ TARGET = qtgeoservices_nokia QT += location-private positioning-private network +QT_FOR_CONFIG += location-private +qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS + HEADERS += \ qgeocodereply_nokia.h \ qgeocodejsonparser.h \ diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp index 90be0ae9..a09899d3 100644 --- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp +++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp @@ -54,7 +54,7 @@ QT_BEGIN_NAMESPACE \a geoMap and makes use of the functionality provided by \a engine. */ QGeoTiledMapNokia::QGeoTiledMapNokia(QGeoTiledMappingManagerEngineNokia *engine, QObject *parent /*= 0*/) : - QGeoTiledMap(engine, parent), + Map(engine, parent), m_logo(":/nokia/logo.png"), // HERE logo image m_engine(engine) {} diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h index 9651cc80..487f6f49 100644 --- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h +++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h @@ -40,12 +40,18 @@ #include "qgeotiledmap_p.h" #include <QtGui/QImage> #include <QtCore/QPointer> +#ifdef LOCATIONLABS +#include <QtLocation/private/qgeotiledmaplabs_p.h> +typedef QGeoTiledMapLabs Map; +#else +typedef QGeoTiledMap Map; +#endif QT_BEGIN_NAMESPACE class QGeoTiledMappingManagerEngineNokia; -class QGeoTiledMapNokia: public QGeoTiledMap +class QGeoTiledMapNokia: public Map { Q_OBJECT public: diff --git a/src/plugins/geoservices/osm/osm.pro b/src/plugins/geoservices/osm/osm.pro index 86a62744..74e27dc9 100644 --- a/src/plugins/geoservices/osm/osm.pro +++ b/src/plugins/geoservices/osm/osm.pro @@ -2,6 +2,9 @@ TARGET = qtgeoservices_osm QT += location-private positioning-private network concurrent +QT_FOR_CONFIG += location-private +qtConfig(location-labs-plugin): DEFINES += LOCATIONLABS + HEADERS += \ qgeoserviceproviderpluginosm.h \ qgeotiledmappingmanagerengineosm.h \ diff --git a/src/plugins/geoservices/osm/qgeotiledmaposm.cpp b/src/plugins/geoservices/osm/qgeotiledmaposm.cpp index 16799dc2..372d1a31 100644 --- a/src/plugins/geoservices/osm/qgeotiledmaposm.cpp +++ b/src/plugins/geoservices/osm/qgeotiledmaposm.cpp @@ -46,7 +46,7 @@ QT_BEGIN_NAMESPACE QGeoTiledMapOsm::QGeoTiledMapOsm(QGeoTiledMappingManagerEngineOsm *engine, QObject *parent) -: QGeoTiledMap(engine, parent), m_mapId(-1), m_engine(engine) +: Map(engine, parent), m_mapId(-1), m_engine(engine) { // Needed because evaluateCopyrights() is only triggered if visible tiles change in the map. // It fails the first time it gets called if providers aren't resolved, and subsequent calls diff --git a/src/plugins/geoservices/osm/qgeotiledmaposm.h b/src/plugins/geoservices/osm/qgeotiledmaposm.h index b2af5d89..cc349793 100644 --- a/src/plugins/geoservices/osm/qgeotiledmaposm.h +++ b/src/plugins/geoservices/osm/qgeotiledmaposm.h @@ -43,11 +43,17 @@ #include "qgeotileproviderosm.h" #include <QtLocation/private/qgeotiledmap_p.h> +#ifdef LOCATIONLABS +#include <QtLocation/private/qgeotiledmaplabs_p.h> +typedef QGeoTiledMapLabs Map; +#else +typedef QGeoTiledMap Map; +#endif QT_BEGIN_NAMESPACE class QGeoTiledMappingManagerEngineOsm; -class QGeoTiledMapOsm: public QGeoTiledMap +class QGeoTiledMapOsm: public Map { Q_OBJECT diff --git a/src/positioning/qdoublevector2d_p.h b/src/positioning/qdoublevector2d_p.h index e944d2f4..92ccfe85 100644 --- a/src/positioning/qdoublevector2d_p.h +++ b/src/positioning/qdoublevector2d_p.h @@ -73,6 +73,7 @@ public: Q_DECL_CONSTEXPR inline double manhattanLength() const; inline bool isNull() const; + inline bool isFinite() const; Q_DECL_CONSTEXPR inline double x() const; Q_DECL_CONSTEXPR inline double y() const; @@ -136,6 +137,11 @@ inline bool QDoubleVector2D::isNull() const return qIsNull(xp) && qIsNull(yp); } +inline bool QDoubleVector2D::isFinite() const +{ + return qIsFinite(xp) && qIsFinite(yp); +} + Q_DECL_CONSTEXPR inline double QDoubleVector2D::x() const { return xp; } Q_DECL_CONSTEXPR inline double QDoubleVector2D::y() const { return yp; } |