From 6909660b73b40681211493a039e72a701d5b4462 Mon Sep 17 00:00:00 2001 From: Paolo Angelelli Date: Fri, 19 Jan 2018 18:52:14 +0100 Subject: Introduce Navigator QML type A new QML type, Navigator, is introduced in Qt.labs.location Its intended purpose is to be a front-end for the functionalities offered by NavigationManagerEngines. Change-Id: Ic93bed0bfaaf32453e759b12a348fa6ef1ae2c93 Reviewed-by: Alex Blasche --- src/imports/locationlabs/locationlabs.cpp | 8 +- src/location/labs/qdeclarativenavigator.cpp | 286 +++++++++++++++++++++++++ src/location/labs/qdeclarativenavigator_p.h | 146 +++++++++++++ src/location/labs/qdeclarativenavigator_p_p.h | 82 +++++++ src/location/maps/qnavigationmanager.cpp | 42 ++++ src/location/maps/qnavigationmanager_p.h | 27 ++- src/location/maps/qnavigationmanagerengine.cpp | 8 +- src/location/maps/qnavigationmanagerengine_p.h | 14 +- 8 files changed, 597 insertions(+), 16 deletions(-) create mode 100644 src/location/labs/qdeclarativenavigator.cpp create mode 100644 src/location/labs/qdeclarativenavigator_p.h create mode 100644 src/location/labs/qdeclarativenavigator_p_p.h diff --git a/src/imports/locationlabs/locationlabs.cpp b/src/imports/locationlabs/locationlabs.cpp index 83deb27e..56924b80 100644 --- a/src/imports/locationlabs/locationlabs.cpp +++ b/src/imports/locationlabs/locationlabs.cpp @@ -40,6 +40,7 @@ #include #include #include +#include #include #include @@ -69,16 +70,17 @@ public: if (QLatin1String(uri) == QLatin1String("Qt.labs.location")) { // @uri QtLocationLabs - int major = 5; - int minor = 11; + int major = 1; + int minor = 0; - // Register the 5.11 types + // Register the 1.0 labs types qmlRegisterType(uri, major, minor, "MapIconObject"); qmlRegisterType(uri, major, minor, "MapObjectView"); qmlRegisterType(uri, major, minor, "MapRouteObject"); qmlRegisterType(uri, major, minor, "MapCircleObject"); qmlRegisterType(uri, major, minor, "MapPolygonObject"); qmlRegisterType(uri, major, minor, "MapPolylineObject"); + qmlRegisterType(uri, major, minor, "Navigator"); // Register the latest Qt version as QML type version qmlRegisterModule(uri, QT_VERSION_MAJOR, QT_VERSION_MINOR); diff --git a/src/location/labs/qdeclarativenavigator.cpp b/src/location/labs/qdeclarativenavigator.cpp new file mode 100644 index 00000000..d0131006 --- /dev/null +++ b/src/location/labs/qdeclarativenavigator.cpp @@ -0,0 +1,286 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtLocation module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL$ +** 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 https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 or (at your option) any later version +** approved by the KDE Free Qt Foundation. The licenses are as published by +** the Free Software Foundation and appearing in the file LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdeclarativenavigator_p.h" +#include "qdeclarativenavigator_p_p.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +/*! + \qmltype Navigator + \instantiates QDeclarativeNavigator + \inqmlmodule Qt.labs.location + \ingroup qml-QtLocation5-maps + + \brief The Navigator type takes control of a \l Map to perform turn-by-turn navigation. + + Its purpose is to include a plugin's turn-by-turn navigation implementation in a QML mapping application + in a seamless manner. + This may include controlling the map position, orientation, tilting and zoom, as well as changing + the map style, elements on the map such as direction information, as well as restricting interaction + with the Map and the items on it. +*/ + + +QDeclarativeNavigator::QDeclarativeNavigator(QObject *parent) + : QParameterizableObject(parent), d_ptr(new QDeclarativeNavigatorPrivate) +{ +} + +QDeclarativeNavigator::~QDeclarativeNavigator() +{ +} + +void QDeclarativeNavigator::classBegin() +{ +} + +void QDeclarativeNavigator::componentComplete() +{ + d_ptr->m_completed = true; + // Children have been completed + d_ptr->m_parameters = quickChildren(); + if (d_ptr->m_plugin && d_ptr->m_plugin->isAttached()) + pluginReady(); +} + +QDeclarativeGeoServiceProvider *QDeclarativeNavigator::plugin() const +{ + return d_ptr->m_plugin; +} + +void QDeclarativeNavigator::setMap(QDeclarativeGeoMap *map) +{ + if (d_ptr->m_map) // set once prop + return; + + d_ptr->m_map = map; + emit mapChanged(); + updateReadyState(); +} + +QDeclarativeGeoMap *QDeclarativeNavigator::map() const +{ + return d_ptr->m_map; +} + +void QDeclarativeNavigator::setRoute(QDeclarativeGeoRoute *route) +{ + if (d_ptr->m_route == route) // This isn't set-once + return; + + const bool isReady = d_ptr->m_navigationManager && d_ptr->m_navigationManager->ready(); + const bool isActive = active(); + if (isReady && isActive) + setActive(false); // Stop current session + + d_ptr->m_route = route; + emit routeChanged(); + updateReadyState(); +} + +QDeclarativeGeoRoute *QDeclarativeNavigator::route() const +{ + return d_ptr->m_route; +} + +void QDeclarativeNavigator::setPositionSource(QDeclarativePositionSource *positionSource) +{ + if (d_ptr->m_positionSource) // set once prop + return; + + d_ptr->m_positionSource = positionSource; + emit positionSourceChanged(); + updateReadyState(); +} + +QDeclarativePositionSource *QDeclarativeNavigator::positionSource() const +{ + return d_ptr->m_positionSource; +} + +QNavigationManager *QDeclarativeNavigator::navigationManager() const +{ + return d_ptr->m_navigationManager; +} + +bool QDeclarativeNavigator::navigatorReady() const +{ + if (d_ptr->m_navigationManager) + return d_ptr->m_navigationManager->ready(); + return d_ptr->m_ready; +} + +QDeclarativeGeoRoute *QDeclarativeNavigator::currentRoute() const +{ + if (!d_ptr->m_ready || !d_ptr->m_navigationManager->active()) + return d_ptr->m_route; + return d_ptr->m_currentRoute; +} + +int QDeclarativeNavigator::currentSegment() const +{ + if (!d_ptr->m_ready || !d_ptr->m_navigationManager->active()) + return 0; + return d_ptr->m_currentSegment; +} + +bool QDeclarativeNavigator::active() const +{ + return d_ptr->m_active; +} + +void QDeclarativeNavigator::setPlugin(QDeclarativeGeoServiceProvider *plugin) +{ + if (d_ptr->m_plugin) + return; // set once property. + + d_ptr->m_plugin = plugin; + emit pluginChanged(); + + if (d_ptr->m_plugin->isAttached()) { + pluginReady(); + } else { + connect(d_ptr->m_plugin, &QDeclarativeGeoServiceProvider::attached, + this, &QDeclarativeNavigator::pluginReady); + } +} + +void QDeclarativeNavigator::setActive(bool active) +{ + if (d_ptr->m_active == active) + return; + + d_ptr->m_active = active; + if (!d_ptr->m_plugin) + return; + + if (active) + start(); + else + stop(); +} + +void QDeclarativeNavigator::start() +{ + if (!d_ptr->m_ready) { + qmlWarning(this) << QStringLiteral("Navigation manager not ready."); + return; + } + + if (d_ptr->m_active) + return; + + d_ptr->m_active = d_ptr->m_navigationManager->start(); +} + +void QDeclarativeNavigator::stop() +{ + if (!ensureEngine()) { // If somebody re-set route to null or something, this may become !d_ptr->m_ready + qmlWarning(this) << QStringLiteral("Navigation manager not ready."); + return; + } + + if (!d_ptr->m_active) + return; + + d_ptr->m_active = d_ptr->m_navigationManager->stop(); +} + +void QDeclarativeNavigator::pluginReady() +{ + if (!d_ptr->m_completed) + return; + + ensureEngine(); + updateReadyState(); + if (d_ptr->m_active) + start(); +} + +bool QDeclarativeNavigator::ensureEngine() +{ + if (d_ptr->m_navigationManager) + return true; + if (!d_ptr->m_completed || !d_ptr->m_plugin->isAttached()) + return false; + + d_ptr->m_navigationManager = d_ptr->m_plugin->sharedGeoServiceProvider()->navigationManager(); + if (d_ptr->m_navigationManager) { + d_ptr->m_navigationManager->setNavigator(d_ptr.data()); + d_ptr->m_navigationManager->setParameters(d_ptr->m_parameters); + connect(d_ptr->m_navigationManager, &QNavigationManager::waypointReached, this, &QDeclarativeNavigator::waypointReached); + connect(d_ptr->m_navigationManager, &QNavigationManager::destinationReached, this, &QDeclarativeNavigator::destinationReached); + connect(d_ptr->m_navigationManager, &QNavigationManager::currentRouteChanged, this, &QDeclarativeNavigator::onCurrentRouteChanged); + connect(d_ptr->m_navigationManager, &QNavigationManager::currentSegmentChanged, this, &QDeclarativeNavigator::onCurrentSegmentChanged); + connect(d_ptr->m_navigationManager, &QNavigationManager::activeChanged, this, [this](bool active){ + d_ptr->m_active = active; + emit activeChanged(active); + }); + emit navigatorReadyChanged(true); + return true; + } + return false; +} + +void QDeclarativeNavigator::updateReadyState() { + const bool oldReady = d_ptr->m_ready; + if (!d_ptr->m_navigationManager) + d_ptr->m_ready = false; + else + d_ptr->m_ready = d_ptr->m_navigationManager->ready(); + + if (oldReady != d_ptr->m_ready) + emit navigatorReadyChanged(d_ptr->m_ready); +} + +void QDeclarativeNavigator::onCurrentRouteChanged(const QGeoRoute &route) +{ + if (d_ptr->m_currentRoute) + d_ptr->m_currentRoute->deleteLater(); + d_ptr->m_currentRoute = new QDeclarativeGeoRoute(route, this); + emit currentRouteChanged(); +} + +void QDeclarativeNavigator::onCurrentSegmentChanged(int segment) +{ + d_ptr->m_currentSegment = segment; + emit currentSegmentChanged(); +} + +QT_END_NAMESPACE diff --git a/src/location/labs/qdeclarativenavigator_p.h b/src/location/labs/qdeclarativenavigator_p.h new file mode 100644 index 00000000..3c9a4653 --- /dev/null +++ b/src/location/labs/qdeclarativenavigator_p.h @@ -0,0 +1,146 @@ +/**************************************************************************** +** +** 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 QDECLARATIVENAVIGATOR_P_H +#define QDECLARATIVENAVIGATOR_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 +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class QDeclarativeGeoServiceProvider; +class QDeclarativeGeoMap; +class QNavigationManager; +class QDeclarativeGeoRoute; +class QDeclarativePositionSource; +class QDeclarativeGeoWaypoint; +class QGeoRoute; +class QGeoRouteSegment; +class QDeclarativeNavigatorPrivate; +class QDeclarativeGeoRouteSegment; + +class Q_LOCATION_PRIVATE_EXPORT QDeclarativeNavigator : public QParameterizableObject, public QQmlParserStatus +{ + Q_OBJECT + Q_PROPERTY(QDeclarativeGeoServiceProvider *plugin READ plugin WRITE setPlugin NOTIFY pluginChanged) + Q_PROPERTY(QDeclarativeGeoMap *map READ map WRITE setMap NOTIFY mapChanged) + Q_PROPERTY(QDeclarativeGeoRoute *route READ route WRITE setRoute NOTIFY routeChanged) + Q_PROPERTY(QDeclarativePositionSource *positionSource READ positionSource WRITE setPositionSource NOTIFY positionSourceChanged) + Q_PROPERTY(bool active READ active WRITE setActive NOTIFY activeChanged) + Q_PROPERTY(bool navigatorReady READ navigatorReady NOTIFY navigatorReadyChanged) + Q_PROPERTY(QDeclarativeGeoRoute *currentRoute READ currentRoute NOTIFY currentRouteChanged) + Q_PROPERTY(int currentSegment READ currentSegment NOTIFY currentSegmentChanged) + Q_INTERFACES(QQmlParserStatus) + +public: + explicit QDeclarativeNavigator(QObject *parent = nullptr); + ~QDeclarativeNavigator(); + + // QQmlParserStatus interface + void classBegin() override; + void componentComplete() override; + + // QDeclarativeNavigator + void start(); + void stop(); + + void setActive(bool active); + bool active() const; + + void setPlugin(QDeclarativeGeoServiceProvider * plugin); + QDeclarativeGeoServiceProvider *plugin() const; + + void setMap(QDeclarativeGeoMap *map); + QDeclarativeGeoMap * map() const; + + void setRoute(QDeclarativeGeoRoute *route); + QDeclarativeGeoRoute *route() const; + + void setPositionSource(QDeclarativePositionSource *positionSource); + QDeclarativePositionSource *positionSource() const; + + QNavigationManager *navigationManager() const; + bool navigatorReady() const; + + QDeclarativeGeoRoute *currentRoute() const; + int currentSegment() const; + +signals: + void navigatorReadyChanged(bool ready); + void activeChanged(bool active); + void waypointReached(const QDeclarativeGeoWaypoint *pos); + void destinationReached(); + + void pluginChanged(); + void mapChanged(); + void routeChanged(); + void positionSourceChanged(); + void currentRouteChanged(); + void currentSegmentChanged(); + +private: + void pluginReady(); + bool ensureEngine(); + void updateReadyState(); + +private slots: + void onCurrentRouteChanged(const QGeoRoute &route); + void onCurrentSegmentChanged(int segment); + +private: + QScopedPointer d_ptr; +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QDeclarativeNavigator) + + +#endif // QDECLARATIVENAVIGATOR_P_H diff --git a/src/location/labs/qdeclarativenavigator_p_p.h b/src/location/labs/qdeclarativenavigator_p_p.h new file mode 100644 index 00000000..291fa3a4 --- /dev/null +++ b/src/location/labs/qdeclarativenavigator_p_p.h @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** 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 QDECLARATIVENAVIGATOR_P_P_H +#define QDECLARATIVENAVIGATOR_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 +#include + +QT_BEGIN_NAMESPACE + +class QDeclarativeGeoServiceProvider; +class QDeclarativeGeoMap; +class QNavigationManager; +class QDeclarativeGeoRoute; +class QDeclarativePositionSource; +class QGeoMapParameter; +class QDeclarativeGeoRouteSegment; + +class Q_LOCATION_PRIVATE_EXPORT QDeclarativeNavigatorPrivate +{ +public: + QNavigationManager *m_navigationManager = nullptr; + QDeclarativeGeoServiceProvider *m_plugin = nullptr; + QDeclarativeGeoMap *m_map = nullptr; + QDeclarativeGeoRoute *m_route = nullptr; + QDeclarativePositionSource *m_positionSource = nullptr; + QDeclarativeGeoRoute *m_currentRoute = nullptr; + QList m_parameters; + int m_currentSegment = 0; + bool m_active = false; + bool m_completed = false; + bool m_ready = false; +}; + +QT_END_NAMESPACE + +#endif // QDECLARATIVENAVIGATOR_P_P_H diff --git a/src/location/maps/qnavigationmanager.cpp b/src/location/maps/qnavigationmanager.cpp index 1e83b2c9..5372e3a5 100644 --- a/src/location/maps/qnavigationmanager.cpp +++ b/src/location/maps/qnavigationmanager.cpp @@ -46,6 +46,8 @@ public: ~QNavigationManagerPrivate(); QNavigationManagerEngine *engine = nullptr; + QDeclarativeNavigatorPrivate *navigator = nullptr; + QList parameters; private: Q_DISABLE_COPY(QNavigationManagerPrivate) @@ -87,6 +89,16 @@ bool QNavigationManager::isInitialized() const return d_ptr->engine->isInitialized(); } +void QNavigationManager::setNavigator(QDeclarativeNavigatorPrivate *navigator) +{ + d_ptr->navigator = navigator; +} + +QDeclarativeNavigatorPrivate *QNavigationManager::declarativeNavigator() const +{ + return d_ptr->navigator; +} + void QNavigationManager::setLocale(const QLocale &locale) { d_ptr->engine->setLocale(locale); @@ -97,6 +109,36 @@ QLocale QNavigationManager::locale() const return d_ptr->engine->locale(); } +void QNavigationManager::setParameters(const QList ¶meters) +{ + d_ptr->parameters = parameters; +} + +QList QNavigationManager::parameters() const +{ + return d_ptr->parameters; +} + +bool QNavigationManager::ready() const +{ + return d_ptr->engine->ready(*d_ptr->navigator, d_ptr->parameters); +} + +bool QNavigationManager::start() +{ + return d_ptr->engine->start(*d_ptr->navigator, d_ptr->parameters); +} + +bool QNavigationManager::stop() +{ + return d_ptr->engine->stop(*d_ptr->navigator); +} + +bool QNavigationManager::active() const +{ + return d_ptr->engine->active(*d_ptr->navigator); +} + QNavigationManager::QNavigationManager(QNavigationManagerEngine *engine, QObject *parent) : QObject(parent), d_ptr(new QNavigationManagerPrivate) { diff --git a/src/location/maps/qnavigationmanager_p.h b/src/location/maps/qnavigationmanager_p.h index e461bcf1..1d8c1722 100644 --- a/src/location/maps/qnavigationmanager_p.h +++ b/src/location/maps/qnavigationmanager_p.h @@ -52,11 +52,17 @@ #include #include #include +#include QT_BEGIN_NAMESPACE class QNavigationManagerEngine; class QNavigationManagerPrivate; +class QDeclarativeNavigatorPrivate; +class QDeclarativeGeoWaypoint; +class QGeoRoute; +class QGeoRouteSegment; + class Q_LOCATION_PRIVATE_EXPORT QNavigationManager : public QObject { Q_OBJECT @@ -66,16 +72,33 @@ public: QString managerName() const; int managerVersion() const; - QNavigationManagerEngine *engine(); - bool isInitialized() const; + + void setNavigator(QDeclarativeNavigatorPrivate *navigator); + QDeclarativeNavigatorPrivate *declarativeNavigator() const; + void setLocale(const QLocale &locale); QLocale locale() const; + void setParameters(const QList ¶meters); + QList parameters() const; + + bool ready() const; + bool start(); + bool stop(); + bool active() const; + Q_SIGNALS: void initialized(); + // These must be emitted by the engine + void activeChanged(bool active); + void waypointReached(const QDeclarativeGeoWaypoint *pos); + void destinationReached(); + void currentRouteChanged(const QGeoRoute &route); + void currentSegmentChanged(int segment); + protected: QNavigationManager(QNavigationManagerEngine *engine, QObject *parent = 0); diff --git a/src/location/maps/qnavigationmanagerengine.cpp b/src/location/maps/qnavigationmanagerengine.cpp index 265237ee..b9191e74 100644 --- a/src/location/maps/qnavigationmanagerengine.cpp +++ b/src/location/maps/qnavigationmanagerengine.cpp @@ -105,14 +105,14 @@ bool QNavigationManagerEngine::isInitialized() const return d_ptr->initialized; } -bool QNavigationManagerEngine::start(const QList &navigationParams, const QMapRouteObject &route) +// Subclasses are supposed to emit activeChanged from here. +bool QNavigationManagerEngine::start(QDeclarativeNavigatorPrivate & /*navigator*/, const QList & /*navigationParams*/) { - Q_UNUSED(navigationParams); - Q_UNUSED(route); + return false; } -bool QNavigationManagerEngine::stop() +bool QNavigationManagerEngine::stop(QDeclarativeNavigatorPrivate & /*navigator*/) // navigator needed to find the right navi session to stop. { return false; } diff --git a/src/location/maps/qnavigationmanagerengine_p.h b/src/location/maps/qnavigationmanagerengine_p.h index 0aa5509e..803050c5 100644 --- a/src/location/maps/qnavigationmanagerengine_p.h +++ b/src/location/maps/qnavigationmanagerengine_p.h @@ -59,6 +59,7 @@ class QGeoMap; class QGeoMapParameter; class QMapRouteObject; class QNavigationManagerEnginePrivate; +class QDeclarativeNavigatorPrivate; class Q_LOCATION_PRIVATE_EXPORT QNavigationManagerEngine : public QObject { @@ -76,17 +77,16 @@ public: virtual QLocale locale() const; virtual void setMeasurementSystem(QLocale::MeasurementSystem system); virtual QLocale::MeasurementSystem measurementSystem() const; - bool isInitialized() const; + virtual bool isInitialized() const; + virtual bool ready(const QDeclarativeNavigatorPrivate &navigator, const QList &navigationParams) = 0; + virtual bool active(const QDeclarativeNavigatorPrivate &navigator) = 0; signals: - void activeChanged(bool active); - void waypointReached(const QGeoCoordinate &pos); - void destinationReached(); void initialized(); public slots: - virtual bool start(const QList &navigationParams, const QMapRouteObject &route); - virtual bool stop(); + virtual bool start(QDeclarativeNavigatorPrivate &navigator, const QList &navigationParams); + virtual bool stop(QDeclarativeNavigatorPrivate &navigator); protected: /*! @@ -94,7 +94,7 @@ protected: call this method after performing implementation-specific initialization within the constructor. */ - void engineInitialized(); + virtual void engineInitialized(); QScopedPointer d_ptr; }; -- cgit v1.2.1